1/* 2Copyright (c) 1998, 1999, 2000 Thai Open Source Software Center Ltd 3See the file COPYING for copying permission. 4*/ 5 6#ifndef XmlParse_INCLUDED 7#define XmlParse_INCLUDED 1 8 9#include <stdlib.h> 10 11#ifndef XMLPARSEAPI 12# if defined(__declspec) && !defined(__CYGWIN__) 13# define XMLPARSEAPI __declspec(dllimport) 14# else 15# define XMLPARSEAPI /* nothing */ 16# endif 17#endif /* not defined XMLPARSEAPI */ 18 19#ifdef __cplusplus 20extern "C" { 21#endif 22 23typedef void *XML_Parser; 24 25/* Information is UTF-8 encoded. */ 26typedef char XML_Char; 27typedef char XML_LChar; 28 29enum XML_Content_Type { 30 XML_CTYPE_EMPTY = 1, 31 XML_CTYPE_ANY, 32 XML_CTYPE_MIXED, 33 XML_CTYPE_NAME, 34 XML_CTYPE_CHOICE, 35 XML_CTYPE_SEQ 36}; 37 38enum XML_Content_Quant { 39 XML_CQUANT_NONE, 40 XML_CQUANT_OPT, 41 XML_CQUANT_REP, 42 XML_CQUANT_PLUS 43}; 44 45/* If type == XML_CTYPE_EMPTY or XML_CTYPE_ANY, then quant will be 46 XML_CQUANT_NONE, and the other fields will be zero or NULL. 47 If type == XML_CTYPE_MIXED, then quant will be NONE or REP and 48 numchildren will contain number of elements that may be mixed in 49 and children point to an array of XML_Content cells that will be 50 all of XML_CTYPE_NAME type with no quantification. 51 52 If type == XML_CTYPE_NAME, then the name points to the name, and 53 the numchildren field will be zero and children will be NULL. The 54 quant fields indicates any quantifiers placed on the name. 55 56 CHOICE and SEQ will have name NULL, the number of children in 57 numchildren and children will point, recursively, to an array 58 of XML_Content cells. 59 60 The EMPTY, ANY, and MIXED types will only occur at top level. 61*/ 62 63typedef struct XML_cp XML_Content; 64 65struct XML_cp { 66 enum XML_Content_Type type; 67 enum XML_Content_Quant quant; 68 const XML_Char * name; 69 unsigned int numchildren; 70 XML_Content * children; 71}; 72 73 74/* This is called for an element declaration. See above for 75 description of the model argument. It's the caller's responsibility 76 to free model when finished with it. 77*/ 78 79typedef void (*XML_ElementDeclHandler) (void *userData, 80 const XML_Char *name, 81 XML_Content *model); 82 83void XMLPARSEAPI 84XML_SetElementDeclHandler(XML_Parser parser, 85 XML_ElementDeclHandler eldecl); 86 87/* 88 The Attlist declaration handler is called for *each* attribute. So 89 a single Attlist declaration with multiple attributes declared will 90 generate multiple calls to this handler. The "default" parameter 91 may be NULL in the case of the "#IMPLIED" or "#REQUIRED" keyword. 92 The "isrequired" parameter will be true and the default value will 93 be NULL in the case of "#REQUIRED". If "isrequired" is true and 94 default is non-NULL, then this is a "#FIXED" default. 95 */ 96 97typedef void (*XML_AttlistDeclHandler) (void *userData, 98 const XML_Char *elname, 99 const XML_Char *attname, 100 const XML_Char *att_type, 101 const XML_Char *dflt, 102 int isrequired); 103 104void XMLPARSEAPI 105XML_SetAttlistDeclHandler(XML_Parser parser, 106 XML_AttlistDeclHandler attdecl); 107 108 109 /* The XML declaration handler is called for *both* XML declarations and 110 text declarations. The way to distinguish is that the version parameter 111 will be null for text declarations. The encoding parameter may be null 112 for XML declarations. The standalone parameter will be -1, 0, or 1 113 indicating respectively that there was no standalone parameter in 114 the declaration, that it was given as no, or that it was given as yes. 115 */ 116 117typedef void (*XML_XmlDeclHandler) (void *userData, 118 const XML_Char *version, 119 const XML_Char *encoding, 120 int standalone); 121 122void XMLPARSEAPI 123XML_SetXmlDeclHandler(XML_Parser parser, 124 XML_XmlDeclHandler xmldecl); 125 126 127typedef struct { 128 void *(*malloc_fcn)(size_t size); 129 void *(*realloc_fcn)(void *ptr, size_t size); 130 void (*free_fcn)(void *ptr); 131} XML_Memory_Handling_Suite; 132 133/* Constructs a new parser; encoding is the encoding specified by the 134external protocol or null if there is none specified. */ 135 136XML_Parser XMLPARSEAPI 137XML_ParserCreate(const XML_Char *encoding); 138 139/* Constructs a new parser and namespace processor. Element type 140names and attribute names that belong to a namespace will be expanded; 141unprefixed attribute names are never expanded; unprefixed element type 142names are expanded only if there is a default namespace. The expanded 143name is the concatenation of the namespace URI, the namespace 144separator character, and the local part of the name. If the namespace 145separator is '\0' then the namespace URI and the local part will be 146concatenated without any separator. When a namespace is not declared, 147the name and prefix will be passed through without expansion. */ 148 149XML_Parser XMLPARSEAPI 150XML_ParserCreateNS(const XML_Char *encoding, XML_Char namespaceSeparator); 151 152 153/* Constructs a new parser using the memory management suit referred to 154 by memsuite. If memsuite is NULL, then use the standard library memory 155 suite. If namespaceSeparator is non-NULL it creates a parser with 156 namespace processing as described above. The character pointed at 157 will serve as the namespace separator. 158 159 All further memory operations used for the created parser will come from 160 the given suite. 161*/ 162 163XML_Parser XMLPARSEAPI 164XML_ParserCreate_MM(const XML_Char *encoding, 165 const XML_Memory_Handling_Suite *memsuite, 166 const XML_Char *namespaceSeparator); 167 168/* atts is array of name/value pairs, terminated by 0; 169 names and values are 0 terminated. */ 170 171typedef void (*XML_StartElementHandler)(void *userData, 172 const XML_Char *name, 173 const XML_Char **atts); 174 175typedef void (*XML_EndElementHandler)(void *userData, 176 const XML_Char *name); 177 178 179/* s is not 0 terminated. */ 180typedef void (*XML_CharacterDataHandler)(void *userData, 181 const XML_Char *s, 182 int len); 183 184/* target and data are 0 terminated */ 185typedef void (*XML_ProcessingInstructionHandler)(void *userData, 186 const XML_Char *target, 187 const XML_Char *data); 188 189/* data is 0 terminated */ 190typedef void (*XML_CommentHandler)(void *userData, const XML_Char *data); 191 192typedef void (*XML_StartCdataSectionHandler)(void *userData); 193typedef void (*XML_EndCdataSectionHandler)(void *userData); 194 195/* This is called for any characters in the XML document for 196which there is no applicable handler. This includes both 197characters that are part of markup which is of a kind that is 198not reported (comments, markup declarations), or characters 199that are part of a construct which could be reported but 200for which no handler has been supplied. The characters are passed 201exactly as they were in the XML document except that 202they will be encoded in UTF-8. Line boundaries are not normalized. 203Note that a byte order mark character is not passed to the default handler. 204There are no guarantees about how characters are divided between calls 205to the default handler: for example, a comment might be split between 206multiple calls. */ 207 208typedef void (*XML_DefaultHandler)(void *userData, 209 const XML_Char *s, 210 int len); 211 212/* This is called for the start of the DOCTYPE declaration, before 213 any DTD or internal subset is parsed. */ 214 215typedef void (*XML_StartDoctypeDeclHandler)(void *userData, 216 const XML_Char *doctypeName, 217 const XML_Char *sysid, 218 const XML_Char *pubid, 219 int has_internal_subset 220 ); 221 222/* This is called for the start of the DOCTYPE declaration when the 223closing > is encountered, but after processing any external subset. */ 224typedef void (*XML_EndDoctypeDeclHandler)(void *userData); 225 226/* This is called for entity declarations. The is_parameter_entity 227 argument will be non-zero if the entity is a parameter entity, zero 228 otherwise. 229 230 For internal entities (<!ENTITY foo "bar">), value will 231 be non-null and systemId, publicID, and notationName will be null. 232 The value string is NOT null terminated; the length is provided in 233 the value_length argument. Since it is legal to have zero-length 234 values, do not use this argument to test for internal entities. 235 236 For external entities, value will be null and systemId will be non-null. 237 The publicId argument will be null unless a public identifier was 238 provided. The notationName argument will have a non-null value only 239 for unparsed entity declarations. 240*/ 241 242typedef void (*XML_EntityDeclHandler) (void *userData, 243 const XML_Char *entityName, 244 int is_parameter_entity, 245 const XML_Char *value, 246 int value_length, 247 const XML_Char *base, 248 const XML_Char *systemId, 249 const XML_Char *publicId, 250 const XML_Char *notationName); 251 252void XMLPARSEAPI 253XML_SetEntityDeclHandler(XML_Parser parser, 254 XML_EntityDeclHandler handler); 255 256/* OBSOLETE -- OBSOLETE -- OBSOLETE 257 This handler has been superceded by the EntityDeclHandler above. 258 It is provided here for backward compatibility. 259This is called for a declaration of an unparsed (NDATA) 260entity. The base argument is whatever was set by XML_SetBase. 261The entityName, systemId and notationName arguments will never be null. 262The other arguments may be. */ 263 264typedef void (*XML_UnparsedEntityDeclHandler)(void *userData, 265 const XML_Char *entityName, 266 const XML_Char *base, 267 const XML_Char *systemId, 268 const XML_Char *publicId, 269 const XML_Char *notationName); 270 271/* This is called for a declaration of notation. 272The base argument is whatever was set by XML_SetBase. 273The notationName will never be null. The other arguments can be. */ 274 275typedef void (*XML_NotationDeclHandler)(void *userData, 276 const XML_Char *notationName, 277 const XML_Char *base, 278 const XML_Char *systemId, 279 const XML_Char *publicId); 280 281/* When namespace processing is enabled, these are called once for 282each namespace declaration. The call to the start and end element 283handlers occur between the calls to the start and end namespace 284declaration handlers. For an xmlns attribute, prefix will be null. 285For an xmlns="" attribute, uri will be null. */ 286 287typedef void (*XML_StartNamespaceDeclHandler)(void *userData, 288 const XML_Char *prefix, 289 const XML_Char *uri); 290 291typedef void (*XML_EndNamespaceDeclHandler)(void *userData, 292 const XML_Char *prefix); 293 294/* This is called if the document is not standalone (it has an 295external subset or a reference to a parameter entity, but does not 296have standalone="yes"). If this handler returns 0, then processing 297will not continue, and the parser will return a 298XML_ERROR_NOT_STANDALONE error. */ 299 300typedef int (*XML_NotStandaloneHandler)(void *userData); 301 302/* This is called for a reference to an external parsed general entity. 303The referenced entity is not automatically parsed. 304The application can parse it immediately or later using 305XML_ExternalEntityParserCreate. 306The parser argument is the parser parsing the entity containing the reference; 307it can be passed as the parser argument to XML_ExternalEntityParserCreate. 308The systemId argument is the system identifier as specified in the entity 309declaration; it will not be null. 310The base argument is the system identifier that should be used as the base for 311resolving systemId if systemId was relative; this is set by XML_SetBase; 312it may be null. 313The publicId argument is the public identifier as specified in the entity 314declaration, or null if none was specified; the whitespace in the public 315identifier will have been normalized as required by the XML spec. 316The context argument specifies the parsing context in the format 317expected by the context argument to 318XML_ExternalEntityParserCreate; context is valid only until the handler 319returns, so if the referenced entity is to be parsed later, it must be copied. 320The handler should return 0 if processing should not continue because of 321a fatal error in the handling of the external entity. 322In this case the calling parser will return an 323XML_ERROR_EXTERNAL_ENTITY_HANDLING error. 324Note that unlike other handlers the first argument is the parser, not 325userData. */ 326 327typedef int (*XML_ExternalEntityRefHandler)(XML_Parser parser, 328 const XML_Char *context, 329 const XML_Char *base, 330 const XML_Char *systemId, 331 const XML_Char *publicId); 332 333/* This structure is filled in by the XML_UnknownEncodingHandler 334to provide information to the parser about encodings that are unknown 335to the parser. 336The map[b] member gives information about byte sequences 337whose first byte is b. 338If map[b] is c where c is >= 0, then b by itself encodes the Unicode scalar 339value c. 340If map[b] is -1, then the byte sequence is malformed. 341If map[b] is -n, where n >= 2, then b is the first byte of an n-byte 342sequence that encodes a single Unicode scalar value. 343The data member will be passed as the first argument to the convert function. 344The convert function is used to convert multibyte sequences; 345s will point to a n-byte sequence where map[(unsigned char)*s] == -n. 346The convert function must return the Unicode scalar value 347represented by this byte sequence or -1 if the byte sequence is malformed. 348The convert function may be null if the encoding is a single-byte encoding, 349that is if map[b] >= -1 for all bytes b. 350When the parser is finished with the encoding, then if release is not null, 351it will call release passing it the data member; 352once release has been called, the convert function will not be called again. 353 354Expat places certain restrictions on the encodings that are supported 355using this mechanism. 356 3571. Every ASCII character that can appear in a well-formed XML document, 358other than the characters 359 360 $@\^`{}~ 361 362must be represented by a single byte, and that byte must be the 363same byte that represents that character in ASCII. 364 3652. No character may require more than 4 bytes to encode. 366 3673. All characters encoded must have Unicode scalar values <= 0xFFFF, 368(ie characters that would be encoded by surrogates in UTF-16 369are not allowed). Note that this restriction doesn't apply to 370the built-in support for UTF-8 and UTF-16. 371 3724. No Unicode character may be encoded by more than one distinct sequence 373of bytes. */ 374 375typedef struct { 376 int map[256]; 377 void *data; 378 int (*convert)(void *data, const char *s); 379 void (*release)(void *data); 380} XML_Encoding; 381 382/* This is called for an encoding that is unknown to the parser. 383The encodingHandlerData argument is that which was passed as the 384second argument to XML_SetUnknownEncodingHandler. 385The name argument gives the name of the encoding as specified in 386the encoding declaration. 387If the callback can provide information about the encoding, 388it must fill in the XML_Encoding structure, and return 1. 389Otherwise it must return 0. 390If info does not describe a suitable encoding, 391then the parser will return an XML_UNKNOWN_ENCODING error. */ 392 393typedef int (*XML_UnknownEncodingHandler)(void *encodingHandlerData, 394 const XML_Char *name, 395 XML_Encoding *info); 396 397void XMLPARSEAPI 398XML_SetElementHandler(XML_Parser parser, 399 XML_StartElementHandler start, 400 XML_EndElementHandler end); 401 402void XMLPARSEAPI 403XML_SetStartElementHandler(XML_Parser, XML_StartElementHandler); 404 405void XMLPARSEAPI 406XML_SetEndElementHandler(XML_Parser, XML_EndElementHandler); 407 408void XMLPARSEAPI 409XML_SetCharacterDataHandler(XML_Parser parser, 410 XML_CharacterDataHandler handler); 411 412void XMLPARSEAPI 413XML_SetProcessingInstructionHandler(XML_Parser parser, 414 XML_ProcessingInstructionHandler handler); 415void XMLPARSEAPI 416XML_SetCommentHandler(XML_Parser parser, 417 XML_CommentHandler handler); 418 419void XMLPARSEAPI 420XML_SetCdataSectionHandler(XML_Parser parser, 421 XML_StartCdataSectionHandler start, 422 XML_EndCdataSectionHandler end); 423 424void XMLPARSEAPI 425XML_SetStartCdataSectionHandler(XML_Parser parser, 426 XML_StartCdataSectionHandler start); 427 428void XMLPARSEAPI 429XML_SetEndCdataSectionHandler(XML_Parser parser, 430 XML_EndCdataSectionHandler end); 431 432/* This sets the default handler and also inhibits expansion of 433internal entities. The entity reference will be passed to the default 434handler. */ 435 436void XMLPARSEAPI 437XML_SetDefaultHandler(XML_Parser parser, 438 XML_DefaultHandler handler); 439 440/* This sets the default handler but does not inhibit expansion of 441internal entities. The entity reference will not be passed to the 442default handler. */ 443 444void XMLPARSEAPI 445XML_SetDefaultHandlerExpand(XML_Parser parser, 446 XML_DefaultHandler handler); 447 448void XMLPARSEAPI 449XML_SetDoctypeDeclHandler(XML_Parser parser, 450 XML_StartDoctypeDeclHandler start, 451 XML_EndDoctypeDeclHandler end); 452 453void XMLPARSEAPI 454XML_SetStartDoctypeDeclHandler(XML_Parser parser, 455 XML_StartDoctypeDeclHandler start); 456 457void XMLPARSEAPI 458XML_SetEndDoctypeDeclHandler(XML_Parser parser, 459 XML_EndDoctypeDeclHandler end); 460 461void XMLPARSEAPI 462XML_SetUnparsedEntityDeclHandler(XML_Parser parser, 463 XML_UnparsedEntityDeclHandler handler); 464 465void XMLPARSEAPI 466XML_SetNotationDeclHandler(XML_Parser parser, 467 XML_NotationDeclHandler handler); 468 469void XMLPARSEAPI 470XML_SetNamespaceDeclHandler(XML_Parser parser, 471 XML_StartNamespaceDeclHandler start, 472 XML_EndNamespaceDeclHandler end); 473 474void XMLPARSEAPI 475XML_SetStartNamespaceDeclHandler(XML_Parser parser, 476 XML_StartNamespaceDeclHandler start); 477 478void XMLPARSEAPI 479XML_SetEndNamespaceDeclHandler(XML_Parser parser, 480 XML_EndNamespaceDeclHandler end); 481 482void XMLPARSEAPI 483XML_SetNotStandaloneHandler(XML_Parser parser, 484 XML_NotStandaloneHandler handler); 485 486void XMLPARSEAPI 487XML_SetExternalEntityRefHandler(XML_Parser parser, 488 XML_ExternalEntityRefHandler handler); 489 490/* If a non-null value for arg is specified here, then it will be passed 491as the first argument to the external entity ref handler instead 492of the parser object. */ 493void XMLPARSEAPI 494XML_SetExternalEntityRefHandlerArg(XML_Parser, void *arg); 495 496void XMLPARSEAPI 497XML_SetUnknownEncodingHandler(XML_Parser parser, 498 XML_UnknownEncodingHandler handler, 499 void *encodingHandlerData); 500 501/* This can be called within a handler for a start element, end element, 502processing instruction or character data. It causes the corresponding 503markup to be passed to the default handler. */ 504void XMLPARSEAPI 505XML_DefaultCurrent(XML_Parser parser); 506 507/* If do_nst is non-zero, and namespace processing is in effect, and 508 a name has a prefix (i.e. an explicit namespace qualifier) then 509 that name is returned as a triplet in a single 510 string separated by the separator character specified when the parser 511 was created: URI + sep + local_name + sep + prefix. 512 513 If do_nst is zero, then namespace information is returned in the 514 default manner (URI + sep + local_name) whether or not the names 515 has a prefix. 516*/ 517 518void XMLPARSEAPI 519XML_SetReturnNSTriplet(XML_Parser parser, int do_nst); 520 521/* This value is passed as the userData argument to callbacks. */ 522void XMLPARSEAPI 523XML_SetUserData(XML_Parser parser, void *userData); 524 525/* Returns the last value set by XML_SetUserData or null. */ 526#define XML_GetUserData(parser) (*(void **)(parser)) 527 528/* This is equivalent to supplying an encoding argument 529to XML_ParserCreate. It must not be called after XML_Parse 530or XML_ParseBuffer. */ 531 532int XMLPARSEAPI 533XML_SetEncoding(XML_Parser parser, const XML_Char *encoding); 534 535/* If this function is called, then the parser will be passed 536as the first argument to callbacks instead of userData. 537The userData will still be accessible using XML_GetUserData. */ 538 539void XMLPARSEAPI 540XML_UseParserAsHandlerArg(XML_Parser parser); 541 542/* Sets the base to be used for resolving relative URIs in system 543identifiers in declarations. Resolving relative identifiers is left 544to the application: this value will be passed through as the base 545argument to the XML_ExternalEntityRefHandler, XML_NotationDeclHandler 546and XML_UnparsedEntityDeclHandler. The base argument will be copied. 547Returns zero if out of memory, non-zero otherwise. */ 548 549int XMLPARSEAPI 550XML_SetBase(XML_Parser parser, const XML_Char *base); 551 552const XML_Char XMLPARSEAPI * 553XML_GetBase(XML_Parser parser); 554 555/* Returns the number of the attribute/value pairs passed in last call 556to the XML_StartElementHandler that were specified in the start-tag 557rather than defaulted. Each attribute/value pair counts as 2; thus 558this correspondds to an index into the atts array passed to the 559XML_StartElementHandler. */ 560 561int XMLPARSEAPI 562XML_GetSpecifiedAttributeCount(XML_Parser parser); 563 564/* Returns the index of the ID attribute passed in the last call to 565XML_StartElementHandler, or -1 if there is no ID attribute. Each 566attribute/value pair counts as 2; thus this correspondds to an index 567into the atts array passed to the XML_StartElementHandler. */ 568 569int XMLPARSEAPI 570XML_GetIdAttributeIndex(XML_Parser parser); 571 572/* Parses some input. Returns 0 if a fatal error is detected. 573The last call to XML_Parse must have isFinal true; 574len may be zero for this call (or any other). */ 575int XMLPARSEAPI 576XML_Parse(XML_Parser parser, const char *s, int len, int isFinal); 577 578void XMLPARSEAPI * 579XML_GetBuffer(XML_Parser parser, int len); 580 581int XMLPARSEAPI 582XML_ParseBuffer(XML_Parser parser, int len, int isFinal); 583 584/* Creates an XML_Parser object that can parse an external general 585entity; context is a '\0'-terminated string specifying the parse 586context; encoding is a '\0'-terminated string giving the name of the 587externally specified encoding, or null if there is no externally 588specified encoding. The context string consists of a sequence of 589tokens separated by formfeeds (\f); a token consisting of a name 590specifies that the general entity of the name is open; a token of the 591form prefix=uri specifies the namespace for a particular prefix; a 592token of the form =uri specifies the default namespace. This can be 593called at any point after the first call to an 594ExternalEntityRefHandler so longer as the parser has not yet been 595freed. The new parser is completely independent and may safely be 596used in a separate thread. The handlers and userData are initialized 597from the parser argument. Returns 0 if out of memory. Otherwise 598returns a new XML_Parser object. */ 599XML_Parser XMLPARSEAPI 600XML_ExternalEntityParserCreate(XML_Parser parser, 601 const XML_Char *context, 602 const XML_Char *encoding); 603 604enum XML_ParamEntityParsing { 605 XML_PARAM_ENTITY_PARSING_NEVER, 606 XML_PARAM_ENTITY_PARSING_UNLESS_STANDALONE, 607 XML_PARAM_ENTITY_PARSING_ALWAYS 608}; 609 610/* Controls parsing of parameter entities (including the external DTD 611subset). If parsing of parameter entities is enabled, then references 612to external parameter entities (including the external DTD subset) 613will be passed to the handler set with 614XML_SetExternalEntityRefHandler. The context passed will be 0. 615Unlike external general entities, external parameter entities can only 616be parsed synchronously. If the external parameter entity is to be 617parsed, it must be parsed during the call to the external entity ref 618handler: the complete sequence of XML_ExternalEntityParserCreate, 619XML_Parse/XML_ParseBuffer and XML_ParserFree calls must be made during 620this call. After XML_ExternalEntityParserCreate has been called to 621create the parser for the external parameter entity (context must be 0 622for this call), it is illegal to make any calls on the old parser 623until XML_ParserFree has been called on the newly created parser. If 624the library has been compiled without support for parameter entity 625parsing (ie without XML_DTD being defined), then 626XML_SetParamEntityParsing will return 0 if parsing of parameter 627entities is requested; otherwise it will return non-zero. */ 628 629int XMLPARSEAPI 630XML_SetParamEntityParsing(XML_Parser parser, 631 enum XML_ParamEntityParsing parsing); 632 633enum XML_Error { 634 XML_ERROR_NONE, 635 XML_ERROR_NO_MEMORY, 636 XML_ERROR_SYNTAX, 637 XML_ERROR_NO_ELEMENTS, 638 XML_ERROR_INVALID_TOKEN, 639 XML_ERROR_UNCLOSED_TOKEN, 640 XML_ERROR_PARTIAL_CHAR, 641 XML_ERROR_TAG_MISMATCH, 642 XML_ERROR_DUPLICATE_ATTRIBUTE, 643 XML_ERROR_JUNK_AFTER_DOC_ELEMENT, 644 XML_ERROR_PARAM_ENTITY_REF, 645 XML_ERROR_UNDEFINED_ENTITY, 646 XML_ERROR_RECURSIVE_ENTITY_REF, 647 XML_ERROR_ASYNC_ENTITY, 648 XML_ERROR_BAD_CHAR_REF, 649 XML_ERROR_BINARY_ENTITY_REF, 650 XML_ERROR_ATTRIBUTE_EXTERNAL_ENTITY_REF, 651 XML_ERROR_MISPLACED_XML_PI, 652 XML_ERROR_UNKNOWN_ENCODING, 653 XML_ERROR_INCORRECT_ENCODING, 654 XML_ERROR_UNCLOSED_CDATA_SECTION, 655 XML_ERROR_EXTERNAL_ENTITY_HANDLING, 656 XML_ERROR_NOT_STANDALONE, 657 XML_ERROR_UNEXPECTED_STATE 658}; 659 660/* If XML_Parse or XML_ParseBuffer have returned 0, then XML_GetErrorCode 661returns information about the error. */ 662 663enum XML_Error XMLPARSEAPI 664XML_GetErrorCode(XML_Parser parser); 665 666/* These functions return information about the current parse location. 667They may be called when XML_Parse or XML_ParseBuffer return 0; 668in this case the location is the location of the character at which 669the error was detected. 670They may also be called from any other callback called to report 671some parse event; in this the location is the location of the first 672of the sequence of characters that generated the event. */ 673 674int XMLPARSEAPI XML_GetCurrentLineNumber(XML_Parser parser); 675int XMLPARSEAPI XML_GetCurrentColumnNumber(XML_Parser parser); 676long XMLPARSEAPI XML_GetCurrentByteIndex(XML_Parser parser); 677 678/* Return the number of bytes in the current event. 679Returns 0 if the event is in an internal entity. */ 680 681int XMLPARSEAPI 682XML_GetCurrentByteCount(XML_Parser parser); 683 684/* If XML_CONTEXT_BYTES is defined, returns the input buffer, sets 685 the integer pointed to by offset to the offset within this buffer 686 of the current parse position, and sets the integer pointed to by size 687 to the size of this buffer (the number of input bytes). Otherwise 688 returns a null pointer. Also returns a null pointer if a parse isn't 689 active. 690 691 NOTE: The character pointer returned should not be used outside 692 the handler that makes the call. */ 693 694const char XMLPARSEAPI * 695XML_GetInputContext(XML_Parser parser, 696 int *offset, 697 int *size); 698 699/* For backwards compatibility with previous versions. */ 700#define XML_GetErrorLineNumber XML_GetCurrentLineNumber 701#define XML_GetErrorColumnNumber XML_GetCurrentColumnNumber 702#define XML_GetErrorByteIndex XML_GetCurrentByteIndex 703 704/* Frees memory used by the parser. */ 705void XMLPARSEAPI 706XML_ParserFree(XML_Parser parser); 707 708/* Returns a string describing the error. */ 709const XML_LChar XMLPARSEAPI * 710XML_ErrorString(int code); 711 712/* Return a string containing the version number of this expat */ 713const XML_LChar XMLPARSEAPI * 714XML_ExpatVersion(void); 715 716typedef struct { 717 int major; 718 int minor; 719 int micro; 720} XML_Expat_Version; 721 722/* Return an XML_Expat_Version structure containing numeric version 723 number information for this version of expat */ 724 725XML_Expat_Version XMLPARSEAPI 726XML_ExpatVersionInfo(void); 727 728#ifndef XML_MAJOR_VERSION 729#define XML_MAJOR_VERSION 1 730#endif 731#ifndef XML_MINOR_VERSION 732#define XML_MINOR_VERSION 95 733#endif 734#ifndef XML_MICRO_VERSION 735#define XML_MICRO_VERSION 2 736#endif 737 738#ifdef __cplusplus 739} 740#endif 741 742#endif /* not XmlParse_INCLUDED */ 743