1 /* 2 * Summary: the core parser module 3 * Description: Interfaces, constants and types related to the XML parser 4 * 5 * Copy: See Copyright for the status of this software. 6 * 7 * Author: Daniel Veillard 8 */ 9 10 #ifndef __XML_PARSER_H__ 11 #define __XML_PARSER_H__ 12 13 #include <stdarg.h> 14 15 #include <libxml/xmlversion.h> 16 #include <libxml/tree.h> 17 #include <libxml/dict.h> 18 #include <libxml/hash.h> 19 #include <libxml/valid.h> 20 #include <libxml/entities.h> 21 #include <libxml/xmlerror.h> 22 #include <libxml/xmlstring.h> 23 24 #ifdef __cplusplus 25 extern "C" { 26 #endif 27 28 /** 29 * XML_DEFAULT_VERSION: 30 * 31 * The default version of XML used: 1.0 32 */ 33 #define XML_DEFAULT_VERSION "1.0" 34 35 /** 36 * xmlParserInput: 37 * 38 * An xmlParserInput is an input flow for the XML processor. 39 * Each entity parsed is associated an xmlParserInput (except the 40 * few predefined ones). This is the case both for internal entities 41 * - in which case the flow is already completely in memory - or 42 * external entities - in which case we use the buf structure for 43 * progressive reading and I18N conversions to the internal UTF-8 format. 44 */ 45 46 /** 47 * xmlParserInputDeallocate: 48 * @str: the string to deallocate 49 * 50 * Callback for freeing some parser input allocations. 51 */ 52 typedef void (* xmlParserInputDeallocate)(xmlChar *str); 53 54 struct _xmlParserInput { 55 /* Input buffer */ 56 xmlParserInputBufferPtr buf; /* UTF-8 encoded buffer */ 57 58 const char *filename; /* The file analyzed, if any */ 59 const char *directory; /* the directory/base of the file */ 60 const xmlChar *base; /* Base of the array to parse */ 61 const xmlChar *cur; /* Current char being parsed */ 62 const xmlChar *end; /* end of the array to parse */ 63 int length; /* length if known */ 64 int line; /* Current line */ 65 int col; /* Current column */ 66 /* 67 * NOTE: consumed is only tested for equality in the parser code, 68 * so even if there is an overflow this should not give troubles 69 * for parsing very large instances. 70 */ 71 unsigned long consumed; /* How many xmlChars already consumed */ 72 xmlParserInputDeallocate free; /* function to deallocate the base */ 73 const xmlChar *encoding; /* the encoding string for entity */ 74 const xmlChar *version; /* the version string for entity */ 75 int standalone; /* Was that entity marked standalone */ 76 int id; /* an unique identifier for the entity */ 77 }; 78 79 /** 80 * xmlParserNodeInfo: 81 * 82 * The parser can be asked to collect Node informations, i.e. at what 83 * place in the file they were detected. 84 * NOTE: This is off by default and not very well tested. 85 */ 86 typedef struct _xmlParserNodeInfo xmlParserNodeInfo; 87 typedef xmlParserNodeInfo *xmlParserNodeInfoPtr; 88 89 struct _xmlParserNodeInfo { 90 const struct _xmlNode* node; 91 /* Position & line # that text that created the node begins & ends on */ 92 unsigned long begin_pos; 93 unsigned long begin_line; 94 unsigned long end_pos; 95 unsigned long end_line; 96 }; 97 98 typedef struct _xmlParserNodeInfoSeq xmlParserNodeInfoSeq; 99 typedef xmlParserNodeInfoSeq *xmlParserNodeInfoSeqPtr; 100 struct _xmlParserNodeInfoSeq { 101 unsigned long maximum; 102 unsigned long length; 103 xmlParserNodeInfo* buffer; 104 }; 105 106 /** 107 * xmlParserInputState: 108 * 109 * The parser is now working also as a state based parser. 110 * The recursive one use the state info for entities processing. 111 */ 112 typedef enum { 113 XML_PARSER_EOF = -1, /* nothing is to be parsed */ 114 XML_PARSER_START = 0, /* nothing has been parsed */ 115 XML_PARSER_MISC, /* Misc* before int subset */ 116 XML_PARSER_PI, /* Within a processing instruction */ 117 XML_PARSER_DTD, /* within some DTD content */ 118 XML_PARSER_PROLOG, /* Misc* after internal subset */ 119 XML_PARSER_COMMENT, /* within a comment */ 120 XML_PARSER_START_TAG, /* within a start tag */ 121 XML_PARSER_CONTENT, /* within the content */ 122 XML_PARSER_CDATA_SECTION, /* within a CDATA section */ 123 XML_PARSER_END_TAG, /* within a closing tag */ 124 XML_PARSER_ENTITY_DECL, /* within an entity declaration */ 125 XML_PARSER_ENTITY_VALUE, /* within an entity value in a decl */ 126 XML_PARSER_ATTRIBUTE_VALUE, /* within an attribute value */ 127 XML_PARSER_SYSTEM_LITERAL, /* within a SYSTEM value */ 128 XML_PARSER_EPILOG, /* the Misc* after the last end tag */ 129 XML_PARSER_IGNORE, /* within an IGNORED section */ 130 XML_PARSER_PUBLIC_LITERAL /* within a PUBLIC value */ 131 } xmlParserInputState; 132 133 /** 134 * XML_DETECT_IDS: 135 * 136 * Bit in the loadsubset context field to tell to do ID/REFs lookups. 137 * Use it to initialize xmlLoadExtDtdDefaultValue. 138 */ 139 #define XML_DETECT_IDS 2 140 141 /** 142 * XML_COMPLETE_ATTRS: 143 * 144 * Bit in the loadsubset context field to tell to do complete the 145 * elements attributes lists with the ones defaulted from the DTDs. 146 * Use it to initialize xmlLoadExtDtdDefaultValue. 147 */ 148 #define XML_COMPLETE_ATTRS 4 149 150 /** 151 * XML_SKIP_IDS: 152 * 153 * Bit in the loadsubset context field to tell to not do ID/REFs registration. 154 * Used to initialize xmlLoadExtDtdDefaultValue in some special cases. 155 */ 156 #define XML_SKIP_IDS 8 157 158 /** 159 * xmlParserMode: 160 * 161 * A parser can operate in various modes 162 */ 163 typedef enum { 164 XML_PARSE_UNKNOWN = 0, 165 XML_PARSE_DOM = 1, 166 XML_PARSE_SAX = 2, 167 XML_PARSE_PUSH_DOM = 3, 168 XML_PARSE_PUSH_SAX = 4, 169 XML_PARSE_READER = 5 170 } xmlParserMode; 171 172 /** 173 * xmlParserCtxt: 174 * 175 * The parser context. 176 * NOTE This doesn't completely define the parser state, the (current ?) 177 * design of the parser uses recursive function calls since this allow 178 * and easy mapping from the production rules of the specification 179 * to the actual code. The drawback is that the actual function call 180 * also reflect the parser state. However most of the parsing routines 181 * takes as the only argument the parser context pointer, so migrating 182 * to a state based parser for progressive parsing shouldn't be too hard. 183 */ 184 struct _xmlParserCtxt { 185 struct _xmlSAXHandler *sax; /* The SAX handler */ 186 void *userData; /* For SAX interface only, used by DOM build */ 187 xmlDocPtr myDoc; /* the document being built */ 188 int wellFormed; /* is the document well formed */ 189 int replaceEntities; /* shall we replace entities ? */ 190 const xmlChar *version; /* the XML version string */ 191 const xmlChar *encoding; /* the declared encoding, if any */ 192 int standalone; /* standalone document */ 193 int html; /* an HTML(1)/Docbook(2) document */ 194 195 /* Input stream stack */ 196 xmlParserInputPtr input; /* Current input stream */ 197 int inputNr; /* Number of current input streams */ 198 int inputMax; /* Max number of input streams */ 199 xmlParserInputPtr *inputTab; /* stack of inputs */ 200 201 /* Node analysis stack only used for DOM building */ 202 xmlNodePtr node; /* Current parsed Node */ 203 int nodeNr; /* Depth of the parsing stack */ 204 int nodeMax; /* Max depth of the parsing stack */ 205 xmlNodePtr *nodeTab; /* array of nodes */ 206 207 int record_info; /* Whether node info should be kept */ 208 xmlParserNodeInfoSeq node_seq; /* info about each node parsed */ 209 210 int errNo; /* error code */ 211 212 int hasExternalSubset; /* reference and external subset */ 213 int hasPErefs; /* the internal subset has PE refs */ 214 int external; /* are we parsing an external entity */ 215 216 int valid; /* is the document valid */ 217 int validate; /* shall we try to validate ? */ 218 xmlValidCtxt vctxt; /* The validity context */ 219 220 xmlParserInputState instate; /* current type of input */ 221 int token; /* next char look-ahead */ 222 223 char *directory; /* the data directory */ 224 225 /* Node name stack */ 226 const xmlChar *name; /* Current parsed Node */ 227 int nameNr; /* Depth of the parsing stack */ 228 int nameMax; /* Max depth of the parsing stack */ 229 const xmlChar * *nameTab; /* array of nodes */ 230 231 long nbChars; /* number of xmlChar processed */ 232 long checkIndex; /* used by progressive parsing lookup */ 233 int keepBlanks; /* ugly but ... */ 234 int disableSAX; /* SAX callbacks are disabled */ 235 int inSubset; /* Parsing is in int 1/ext 2 subset */ 236 const xmlChar * intSubName; /* name of subset */ 237 xmlChar * extSubURI; /* URI of external subset */ 238 xmlChar * extSubSystem; /* SYSTEM ID of external subset */ 239 240 /* xml:space values */ 241 int * space; /* Should the parser preserve spaces */ 242 int spaceNr; /* Depth of the parsing stack */ 243 int spaceMax; /* Max depth of the parsing stack */ 244 int * spaceTab; /* array of space infos */ 245 246 int depth; /* to prevent entity substitution loops */ 247 xmlParserInputPtr entity; /* used to check entities boundaries */ 248 int charset; /* encoding of the in-memory content 249 actually an xmlCharEncoding */ 250 int nodelen; /* Those two fields are there to */ 251 int nodemem; /* Speed up large node parsing */ 252 int pedantic; /* signal pedantic warnings */ 253 void *_private; /* For user data, libxml won't touch it */ 254 255 int loadsubset; /* should the external subset be loaded */ 256 int linenumbers; /* set line number in element content */ 257 void *catalogs; /* document's own catalog */ 258 int recovery; /* run in recovery mode */ 259 int progressive; /* is this a progressive parsing */ 260 xmlDictPtr dict; /* dictionnary for the parser */ 261 const xmlChar * *atts; /* array for the attributes callbacks */ 262 int maxatts; /* the size of the array */ 263 int docdict; /* use strings from dict to build tree */ 264 265 /* 266 * pre-interned strings 267 */ 268 const xmlChar *str_xml; 269 const xmlChar *str_xmlns; 270 const xmlChar *str_xml_ns; 271 272 /* 273 * Everything below is used only by the new SAX mode 274 */ 275 int sax2; /* operating in the new SAX mode */ 276 int nsNr; /* the number of inherited namespaces */ 277 int nsMax; /* the size of the arrays */ 278 const xmlChar * *nsTab; /* the array of prefix/namespace name */ 279 int *attallocs; /* which attribute were allocated */ 280 void * *pushTab; /* array of data for push */ 281 xmlHashTablePtr attsDefault; /* defaulted attributes if any */ 282 xmlHashTablePtr attsSpecial; /* non-CDATA attributes if any */ 283 int nsWellFormed; /* is the document XML Nanespace okay */ 284 int options; /* Extra options */ 285 286 /* 287 * Those fields are needed only for treaming parsing so far 288 */ 289 int dictNames; /* Use dictionary names for the tree */ 290 int freeElemsNr; /* number of freed element nodes */ 291 xmlNodePtr freeElems; /* List of freed element nodes */ 292 int freeAttrsNr; /* number of freed attributes nodes */ 293 xmlAttrPtr freeAttrs; /* List of freed attributes nodes */ 294 295 /* 296 * the complete error informations for the last error. 297 */ 298 xmlError lastError; 299 xmlParserMode parseMode; /* the parser mode */ 300 unsigned long nbentities; /* number of entities references */ 301 unsigned long sizeentities; /* size of parsed entities */ 302 }; 303 304 /** 305 * xmlSAXLocator: 306 * 307 * A SAX Locator. 308 */ 309 struct _xmlSAXLocator { 310 const xmlChar *(*getPublicId)(void *ctx); 311 const xmlChar *(*getSystemId)(void *ctx); 312 int (*getLineNumber)(void *ctx); 313 int (*getColumnNumber)(void *ctx); 314 }; 315 316 /** 317 * xmlSAXHandler: 318 * 319 * A SAX handler is bunch of callbacks called by the parser when processing 320 * of the input generate data or structure informations. 321 */ 322 323 /** 324 * resolveEntitySAXFunc: 325 * @ctx: the user data (XML parser context) 326 * @publicId: The public ID of the entity 327 * @systemId: The system ID of the entity 328 * 329 * Callback: 330 * The entity loader, to control the loading of external entities, 331 * the application can either: 332 * - override this resolveEntity() callback in the SAX block 333 * - or better use the xmlSetExternalEntityLoader() function to 334 * set up it's own entity resolution routine 335 * 336 * Returns the xmlParserInputPtr if inlined or NULL for DOM behaviour. 337 */ 338 typedef xmlParserInputPtr (*resolveEntitySAXFunc) (void *ctx, 339 const xmlChar *publicId, 340 const xmlChar *systemId); 341 /** 342 * internalSubsetSAXFunc: 343 * @ctx: the user data (XML parser context) 344 * @name: the root element name 345 * @ExternalID: the external ID 346 * @SystemID: the SYSTEM ID (e.g. filename or URL) 347 * 348 * Callback on internal subset declaration. 349 */ 350 typedef void (*internalSubsetSAXFunc) (void *ctx, 351 const xmlChar *name, 352 const xmlChar *ExternalID, 353 const xmlChar *SystemID); 354 /** 355 * externalSubsetSAXFunc: 356 * @ctx: the user data (XML parser context) 357 * @name: the root element name 358 * @ExternalID: the external ID 359 * @SystemID: the SYSTEM ID (e.g. filename or URL) 360 * 361 * Callback on external subset declaration. 362 */ 363 typedef void (*externalSubsetSAXFunc) (void *ctx, 364 const xmlChar *name, 365 const xmlChar *ExternalID, 366 const xmlChar *SystemID); 367 /** 368 * getEntitySAXFunc: 369 * @ctx: the user data (XML parser context) 370 * @name: The entity name 371 * 372 * Get an entity by name. 373 * 374 * Returns the xmlEntityPtr if found. 375 */ 376 typedef xmlEntityPtr (*getEntitySAXFunc) (void *ctx, 377 const xmlChar *name); 378 /** 379 * getParameterEntitySAXFunc: 380 * @ctx: the user data (XML parser context) 381 * @name: The entity name 382 * 383 * Get a parameter entity by name. 384 * 385 * Returns the xmlEntityPtr if found. 386 */ 387 typedef xmlEntityPtr (*getParameterEntitySAXFunc) (void *ctx, 388 const xmlChar *name); 389 /** 390 * entityDeclSAXFunc: 391 * @ctx: the user data (XML parser context) 392 * @name: the entity name 393 * @type: the entity type 394 * @publicId: The public ID of the entity 395 * @systemId: The system ID of the entity 396 * @content: the entity value (without processing). 397 * 398 * An entity definition has been parsed. 399 */ 400 typedef void (*entityDeclSAXFunc) (void *ctx, 401 const xmlChar *name, 402 int type, 403 const xmlChar *publicId, 404 const xmlChar *systemId, 405 xmlChar *content); 406 /** 407 * notationDeclSAXFunc: 408 * @ctx: the user data (XML parser context) 409 * @name: The name of the notation 410 * @publicId: The public ID of the entity 411 * @systemId: The system ID of the entity 412 * 413 * What to do when a notation declaration has been parsed. 414 */ 415 typedef void (*notationDeclSAXFunc)(void *ctx, 416 const xmlChar *name, 417 const xmlChar *publicId, 418 const xmlChar *systemId); 419 /** 420 * attributeDeclSAXFunc: 421 * @ctx: the user data (XML parser context) 422 * @elem: the name of the element 423 * @fullname: the attribute name 424 * @type: the attribute type 425 * @def: the type of default value 426 * @defaultValue: the attribute default value 427 * @tree: the tree of enumerated value set 428 * 429 * An attribute definition has been parsed. 430 */ 431 typedef void (*attributeDeclSAXFunc)(void *ctx, 432 const xmlChar *elem, 433 const xmlChar *fullname, 434 int type, 435 int def, 436 const xmlChar *defaultValue, 437 xmlEnumerationPtr tree); 438 /** 439 * elementDeclSAXFunc: 440 * @ctx: the user data (XML parser context) 441 * @name: the element name 442 * @type: the element type 443 * @content: the element value tree 444 * 445 * An element definition has been parsed. 446 */ 447 typedef void (*elementDeclSAXFunc)(void *ctx, 448 const xmlChar *name, 449 int type, 450 xmlElementContentPtr content); 451 /** 452 * unparsedEntityDeclSAXFunc: 453 * @ctx: the user data (XML parser context) 454 * @name: The name of the entity 455 * @publicId: The public ID of the entity 456 * @systemId: The system ID of the entity 457 * @notationName: the name of the notation 458 * 459 * What to do when an unparsed entity declaration is parsed. 460 */ 461 typedef void (*unparsedEntityDeclSAXFunc)(void *ctx, 462 const xmlChar *name, 463 const xmlChar *publicId, 464 const xmlChar *systemId, 465 const xmlChar *notationName); 466 /** 467 * setDocumentLocatorSAXFunc: 468 * @ctx: the user data (XML parser context) 469 * @loc: A SAX Locator 470 * 471 * Receive the document locator at startup, actually xmlDefaultSAXLocator. 472 * Everything is available on the context, so this is useless in our case. 473 */ 474 typedef void (*setDocumentLocatorSAXFunc) (void *ctx, 475 xmlSAXLocatorPtr loc); 476 /** 477 * startDocumentSAXFunc: 478 * @ctx: the user data (XML parser context) 479 * 480 * Called when the document start being processed. 481 */ 482 typedef void (*startDocumentSAXFunc) (void *ctx); 483 /** 484 * endDocumentSAXFunc: 485 * @ctx: the user data (XML parser context) 486 * 487 * Called when the document end has been detected. 488 */ 489 typedef void (*endDocumentSAXFunc) (void *ctx); 490 /** 491 * startElementSAXFunc: 492 * @ctx: the user data (XML parser context) 493 * @name: The element name, including namespace prefix 494 * @atts: An array of name/value attributes pairs, NULL terminated 495 * 496 * Called when an opening tag has been processed. 497 */ 498 typedef void (*startElementSAXFunc) (void *ctx, 499 const xmlChar *name, 500 const xmlChar **atts); 501 /** 502 * endElementSAXFunc: 503 * @ctx: the user data (XML parser context) 504 * @name: The element name 505 * 506 * Called when the end of an element has been detected. 507 */ 508 typedef void (*endElementSAXFunc) (void *ctx, 509 const xmlChar *name); 510 /** 511 * attributeSAXFunc: 512 * @ctx: the user data (XML parser context) 513 * @name: The attribute name, including namespace prefix 514 * @value: The attribute value 515 * 516 * Handle an attribute that has been read by the parser. 517 * The default handling is to convert the attribute into an 518 * DOM subtree and past it in a new xmlAttr element added to 519 * the element. 520 */ 521 typedef void (*attributeSAXFunc) (void *ctx, 522 const xmlChar *name, 523 const xmlChar *value); 524 /** 525 * referenceSAXFunc: 526 * @ctx: the user data (XML parser context) 527 * @name: The entity name 528 * 529 * Called when an entity reference is detected. 530 */ 531 typedef void (*referenceSAXFunc) (void *ctx, 532 const xmlChar *name); 533 /** 534 * charactersSAXFunc: 535 * @ctx: the user data (XML parser context) 536 * @ch: a xmlChar string 537 * @len: the number of xmlChar 538 * 539 * Receiving some chars from the parser. 540 */ 541 typedef void (*charactersSAXFunc) (void *ctx, 542 const xmlChar *ch, 543 int len); 544 /** 545 * ignorableWhitespaceSAXFunc: 546 * @ctx: the user data (XML parser context) 547 * @ch: a xmlChar string 548 * @len: the number of xmlChar 549 * 550 * Receiving some ignorable whitespaces from the parser. 551 * UNUSED: by default the DOM building will use characters. 552 */ 553 typedef void (*ignorableWhitespaceSAXFunc) (void *ctx, 554 const xmlChar *ch, 555 int len); 556 /** 557 * processingInstructionSAXFunc: 558 * @ctx: the user data (XML parser context) 559 * @target: the target name 560 * @data: the PI data's 561 * 562 * A processing instruction has been parsed. 563 */ 564 typedef void (*processingInstructionSAXFunc) (void *ctx, 565 const xmlChar *target, 566 const xmlChar *data); 567 /** 568 * commentSAXFunc: 569 * @ctx: the user data (XML parser context) 570 * @value: the comment content 571 * 572 * A comment has been parsed. 573 */ 574 typedef void (*commentSAXFunc) (void *ctx, 575 const xmlChar *value); 576 /** 577 * cdataBlockSAXFunc: 578 * @ctx: the user data (XML parser context) 579 * @value: The pcdata content 580 * @len: the block length 581 * 582 * Called when a pcdata block has been parsed. 583 */ 584 typedef void (*cdataBlockSAXFunc) ( 585 void *ctx, 586 const xmlChar *value, 587 int len); 588 /** 589 * warningSAXFunc: 590 * @ctx: an XML parser context 591 * @msg: the message to display/transmit 592 * @...: extra parameters for the message display 593 * 594 * Display and format a warning messages, callback. 595 */ 596 typedef void (XMLCDECL *warningSAXFunc) (void *ctx, 597 const char *msg, ...) ATTRIBUTE_PRINTF(2,3); 598 /** 599 * errorSAXFunc: 600 * @ctx: an XML parser context 601 * @msg: the message to display/transmit 602 * @...: extra parameters for the message display 603 * 604 * Display and format an error messages, callback. 605 */ 606 typedef void (XMLCDECL *errorSAXFunc) (void *ctx, 607 const char *msg, ...) ATTRIBUTE_PRINTF(2,3); 608 /** 609 * fatalErrorSAXFunc: 610 * @ctx: an XML parser context 611 * @msg: the message to display/transmit 612 * @...: extra parameters for the message display 613 * 614 * Display and format fatal error messages, callback. 615 * Note: so far fatalError() SAX callbacks are not used, error() 616 * get all the callbacks for errors. 617 */ 618 typedef void (XMLCDECL *fatalErrorSAXFunc) (void *ctx, 619 const char *msg, ...) ATTRIBUTE_PRINTF(2,3); 620 /** 621 * isStandaloneSAXFunc: 622 * @ctx: the user data (XML parser context) 623 * 624 * Is this document tagged standalone? 625 * 626 * Returns 1 if true 627 */ 628 typedef int (*isStandaloneSAXFunc) (void *ctx); 629 /** 630 * hasInternalSubsetSAXFunc: 631 * @ctx: the user data (XML parser context) 632 * 633 * Does this document has an internal subset. 634 * 635 * Returns 1 if true 636 */ 637 typedef int (*hasInternalSubsetSAXFunc) (void *ctx); 638 639 /** 640 * hasExternalSubsetSAXFunc: 641 * @ctx: the user data (XML parser context) 642 * 643 * Does this document has an external subset? 644 * 645 * Returns 1 if true 646 */ 647 typedef int (*hasExternalSubsetSAXFunc) (void *ctx); 648 649 /************************************************************************ 650 * * 651 * The SAX version 2 API extensions * 652 * * 653 ************************************************************************/ 654 /** 655 * XML_SAX2_MAGIC: 656 * 657 * Special constant found in SAX2 blocks initialized fields 658 */ 659 #define XML_SAX2_MAGIC 0xDEEDBEAF 660 661 /** 662 * startElementNsSAX2Func: 663 * @ctx: the user data (XML parser context) 664 * @localname: the local name of the element 665 * @prefix: the element namespace prefix if available 666 * @URI: the element namespace name if available 667 * @nb_namespaces: number of namespace definitions on that node 668 * @namespaces: pointer to the array of prefix/URI pairs namespace definitions 669 * @nb_attributes: the number of attributes on that node 670 * @nb_defaulted: the number of defaulted attributes. The defaulted 671 * ones are at the end of the array 672 * @attributes: pointer to the array of (localname/prefix/URI/value/end) 673 * attribute values. 674 * 675 * SAX2 callback when an element start has been detected by the parser. 676 * It provides the namespace informations for the element, as well as 677 * the new namespace declarations on the element. 678 */ 679 680 typedef void (*startElementNsSAX2Func) (void *ctx, 681 const xmlChar *localname, 682 const xmlChar *prefix, 683 const xmlChar *URI, 684 int nb_namespaces, 685 const xmlChar **namespaces, 686 int nb_attributes, 687 int nb_defaulted, 688 const xmlChar **attributes); 689 690 /** 691 * endElementNsSAX2Func: 692 * @ctx: the user data (XML parser context) 693 * @localname: the local name of the element 694 * @prefix: the element namespace prefix if available 695 * @URI: the element namespace name if available 696 * 697 * SAX2 callback when an element end has been detected by the parser. 698 * It provides the namespace informations for the element. 699 */ 700 701 typedef void (*endElementNsSAX2Func) (void *ctx, 702 const xmlChar *localname, 703 const xmlChar *prefix, 704 const xmlChar *URI); 705 706 707 struct _xmlSAXHandler { 708 internalSubsetSAXFunc internalSubset; 709 isStandaloneSAXFunc isStandalone; 710 hasInternalSubsetSAXFunc hasInternalSubset; 711 hasExternalSubsetSAXFunc hasExternalSubset; 712 resolveEntitySAXFunc resolveEntity; 713 getEntitySAXFunc getEntity; 714 entityDeclSAXFunc entityDecl; 715 notationDeclSAXFunc notationDecl; 716 attributeDeclSAXFunc attributeDecl; 717 elementDeclSAXFunc elementDecl; 718 unparsedEntityDeclSAXFunc unparsedEntityDecl; 719 setDocumentLocatorSAXFunc setDocumentLocator; 720 startDocumentSAXFunc startDocument; 721 endDocumentSAXFunc endDocument; 722 startElementSAXFunc startElement; 723 endElementSAXFunc endElement; 724 referenceSAXFunc reference; 725 charactersSAXFunc characters; 726 ignorableWhitespaceSAXFunc ignorableWhitespace; 727 processingInstructionSAXFunc processingInstruction; 728 commentSAXFunc comment; 729 warningSAXFunc warning; 730 errorSAXFunc error; 731 fatalErrorSAXFunc fatalError; /* unused error() get all the errors */ 732 getParameterEntitySAXFunc getParameterEntity; 733 cdataBlockSAXFunc cdataBlock; 734 externalSubsetSAXFunc externalSubset; 735 unsigned int initialized; 736 /* The following fields are extensions available only on version 2 */ 737 void *_private; 738 startElementNsSAX2Func startElementNs; 739 endElementNsSAX2Func endElementNs; 740 xmlStructuredErrorFunc serror; 741 }; 742 743 /* 744 * SAX Version 1 745 */ 746 typedef struct _xmlSAXHandlerV1 xmlSAXHandlerV1; 747 typedef xmlSAXHandlerV1 *xmlSAXHandlerV1Ptr; 748 struct _xmlSAXHandlerV1 { 749 internalSubsetSAXFunc internalSubset; 750 isStandaloneSAXFunc isStandalone; 751 hasInternalSubsetSAXFunc hasInternalSubset; 752 hasExternalSubsetSAXFunc hasExternalSubset; 753 resolveEntitySAXFunc resolveEntity; 754 getEntitySAXFunc getEntity; 755 entityDeclSAXFunc entityDecl; 756 notationDeclSAXFunc notationDecl; 757 attributeDeclSAXFunc attributeDecl; 758 elementDeclSAXFunc elementDecl; 759 unparsedEntityDeclSAXFunc unparsedEntityDecl; 760 setDocumentLocatorSAXFunc setDocumentLocator; 761 startDocumentSAXFunc startDocument; 762 endDocumentSAXFunc endDocument; 763 startElementSAXFunc startElement; 764 endElementSAXFunc endElement; 765 referenceSAXFunc reference; 766 charactersSAXFunc characters; 767 ignorableWhitespaceSAXFunc ignorableWhitespace; 768 processingInstructionSAXFunc processingInstruction; 769 commentSAXFunc comment; 770 warningSAXFunc warning; 771 errorSAXFunc error; 772 fatalErrorSAXFunc fatalError; /* unused error() get all the errors */ 773 getParameterEntitySAXFunc getParameterEntity; 774 cdataBlockSAXFunc cdataBlock; 775 externalSubsetSAXFunc externalSubset; 776 unsigned int initialized; 777 }; 778 779 780 /** 781 * xmlExternalEntityLoader: 782 * @URL: The System ID of the resource requested 783 * @ID: The Public ID of the resource requested 784 * @context: the XML parser context 785 * 786 * External entity loaders types. 787 * 788 * Returns the entity input parser. 789 */ 790 typedef xmlParserInputPtr (*xmlExternalEntityLoader) (const char *URL, 791 const char *ID, 792 xmlParserCtxtPtr context); 793 794 #ifdef __cplusplus 795 } 796 #endif 797 798 #include <libxml/encoding.h> 799 #include <libxml/xmlIO.h> 800 #include <libxml/globals.h> 801 802 #ifdef __cplusplus 803 extern "C" { 804 #endif 805 806 807 /* 808 * Init/Cleanup 809 */ 810 XMLPUBFUN void XMLCALL 811 xmlInitParser (void); 812 XMLPUBFUN void XMLCALL 813 xmlCleanupParser (void); 814 815 /* 816 * Input functions 817 */ 818 XMLPUBFUN int XMLCALL 819 xmlParserInputRead (xmlParserInputPtr in, 820 int len); 821 XMLPUBFUN int XMLCALL 822 xmlParserInputGrow (xmlParserInputPtr in, 823 int len); 824 825 /* 826 * Basic parsing Interfaces 827 */ 828 #ifdef LIBXML_SAX1_ENABLED 829 XMLPUBFUN xmlDocPtr XMLCALL 830 xmlParseDoc (const xmlChar *cur); 831 XMLPUBFUN xmlDocPtr XMLCALL 832 xmlParseFile (const char *filename); 833 XMLPUBFUN xmlDocPtr XMLCALL 834 xmlParseMemory (const char *buffer, 835 int size); 836 #endif /* LIBXML_SAX1_ENABLED */ 837 XMLPUBFUN int XMLCALL 838 xmlSubstituteEntitiesDefault(int val); 839 XMLPUBFUN int XMLCALL 840 xmlKeepBlanksDefault (int val); 841 XMLPUBFUN void XMLCALL 842 xmlStopParser (xmlParserCtxtPtr ctxt); 843 XMLPUBFUN int XMLCALL 844 xmlPedanticParserDefault(int val); 845 XMLPUBFUN int XMLCALL 846 xmlLineNumbersDefault (int val); 847 848 #ifdef LIBXML_SAX1_ENABLED 849 /* 850 * Recovery mode 851 */ 852 XMLPUBFUN xmlDocPtr XMLCALL 853 xmlRecoverDoc (xmlChar *cur); 854 XMLPUBFUN xmlDocPtr XMLCALL 855 xmlRecoverMemory (const char *buffer, 856 int size); 857 XMLPUBFUN xmlDocPtr XMLCALL 858 xmlRecoverFile (const char *filename); 859 #endif /* LIBXML_SAX1_ENABLED */ 860 861 /* 862 * Less common routines and SAX interfaces 863 */ 864 XMLPUBFUN int XMLCALL 865 xmlParseDocument (xmlParserCtxtPtr ctxt); 866 XMLPUBFUN int XMLCALL 867 xmlParseExtParsedEnt (xmlParserCtxtPtr ctxt); 868 #ifdef LIBXML_SAX1_ENABLED 869 XMLPUBFUN int XMLCALL 870 xmlSAXUserParseFile (xmlSAXHandlerPtr sax, 871 void *user_data, 872 const char *filename); 873 XMLPUBFUN int XMLCALL 874 xmlSAXUserParseMemory (xmlSAXHandlerPtr sax, 875 void *user_data, 876 const char *buffer, 877 int size); 878 XMLPUBFUN xmlDocPtr XMLCALL 879 xmlSAXParseDoc (xmlSAXHandlerPtr sax, 880 const xmlChar *cur, 881 int recovery); 882 XMLPUBFUN xmlDocPtr XMLCALL 883 xmlSAXParseMemory (xmlSAXHandlerPtr sax, 884 const char *buffer, 885 int size, 886 int recovery); 887 XMLPUBFUN xmlDocPtr XMLCALL 888 xmlSAXParseMemoryWithData (xmlSAXHandlerPtr sax, 889 const char *buffer, 890 int size, 891 int recovery, 892 void *data); 893 XMLPUBFUN xmlDocPtr XMLCALL 894 xmlSAXParseFile (xmlSAXHandlerPtr sax, 895 const char *filename, 896 int recovery); 897 XMLPUBFUN xmlDocPtr XMLCALL 898 xmlSAXParseFileWithData (xmlSAXHandlerPtr sax, 899 const char *filename, 900 int recovery, 901 void *data); 902 XMLPUBFUN xmlDocPtr XMLCALL 903 xmlSAXParseEntity (xmlSAXHandlerPtr sax, 904 const char *filename); 905 XMLPUBFUN xmlDocPtr XMLCALL 906 xmlParseEntity (const char *filename); 907 #endif /* LIBXML_SAX1_ENABLED */ 908 909 #ifdef LIBXML_VALID_ENABLED 910 XMLPUBFUN xmlDtdPtr XMLCALL 911 xmlSAXParseDTD (xmlSAXHandlerPtr sax, 912 const xmlChar *ExternalID, 913 const xmlChar *SystemID); 914 XMLPUBFUN xmlDtdPtr XMLCALL 915 xmlParseDTD (const xmlChar *ExternalID, 916 const xmlChar *SystemID); 917 XMLPUBFUN xmlDtdPtr XMLCALL 918 xmlIOParseDTD (xmlSAXHandlerPtr sax, 919 xmlParserInputBufferPtr input, 920 xmlCharEncoding enc); 921 #endif /* LIBXML_VALID_ENABLE */ 922 #ifdef LIBXML_SAX1_ENABLED 923 XMLPUBFUN int XMLCALL 924 xmlParseBalancedChunkMemory(xmlDocPtr doc, 925 xmlSAXHandlerPtr sax, 926 void *user_data, 927 int depth, 928 const xmlChar *string, 929 xmlNodePtr *lst); 930 #endif /* LIBXML_SAX1_ENABLED */ 931 XMLPUBFUN xmlParserErrors XMLCALL 932 xmlParseInNodeContext (xmlNodePtr node, 933 const char *data, 934 int datalen, 935 int options, 936 xmlNodePtr *lst); 937 #ifdef LIBXML_SAX1_ENABLED 938 XMLPUBFUN int XMLCALL 939 xmlParseBalancedChunkMemoryRecover(xmlDocPtr doc, 940 xmlSAXHandlerPtr sax, 941 void *user_data, 942 int depth, 943 const xmlChar *string, 944 xmlNodePtr *lst, 945 int recover); 946 XMLPUBFUN int XMLCALL 947 xmlParseExternalEntity (xmlDocPtr doc, 948 xmlSAXHandlerPtr sax, 949 void *user_data, 950 int depth, 951 const xmlChar *URL, 952 const xmlChar *ID, 953 xmlNodePtr *lst); 954 #endif /* LIBXML_SAX1_ENABLED */ 955 XMLPUBFUN int XMLCALL 956 xmlParseCtxtExternalEntity(xmlParserCtxtPtr ctx, 957 const xmlChar *URL, 958 const xmlChar *ID, 959 xmlNodePtr *lst); 960 961 /* 962 * Parser contexts handling. 963 */ 964 XMLPUBFUN xmlParserCtxtPtr XMLCALL 965 xmlNewParserCtxt (void); 966 XMLPUBFUN int XMLCALL 967 xmlInitParserCtxt (xmlParserCtxtPtr ctxt); 968 XMLPUBFUN void XMLCALL 969 xmlClearParserCtxt (xmlParserCtxtPtr ctxt); 970 XMLPUBFUN void XMLCALL 971 xmlFreeParserCtxt (xmlParserCtxtPtr ctxt); 972 #ifdef LIBXML_SAX1_ENABLED 973 XMLPUBFUN void XMLCALL 974 xmlSetupParserForBuffer (xmlParserCtxtPtr ctxt, 975 const xmlChar* buffer, 976 const char *filename); 977 #endif /* LIBXML_SAX1_ENABLED */ 978 XMLPUBFUN xmlParserCtxtPtr XMLCALL 979 xmlCreateDocParserCtxt (const xmlChar *cur); 980 981 #ifdef LIBXML_LEGACY_ENABLED 982 /* 983 * Reading/setting optional parsing features. 984 */ 985 XMLPUBFUN int XMLCALL 986 xmlGetFeaturesList (int *len, 987 const char **result); 988 XMLPUBFUN int XMLCALL 989 xmlGetFeature (xmlParserCtxtPtr ctxt, 990 const char *name, 991 void *result); 992 XMLPUBFUN int XMLCALL 993 xmlSetFeature (xmlParserCtxtPtr ctxt, 994 const char *name, 995 void *value); 996 #endif /* LIBXML_LEGACY_ENABLED */ 997 998 #ifdef LIBXML_PUSH_ENABLED 999 /* 1000 * Interfaces for the Push mode. 1001 */ 1002 XMLPUBFUN xmlParserCtxtPtr XMLCALL 1003 xmlCreatePushParserCtxt(xmlSAXHandlerPtr sax, 1004 void *user_data, 1005 const char *chunk, 1006 int size, 1007 const char *filename); 1008 XMLPUBFUN int XMLCALL 1009 xmlParseChunk (xmlParserCtxtPtr ctxt, 1010 const char *chunk, 1011 int size, 1012 int terminate); 1013 #endif /* LIBXML_PUSH_ENABLED */ 1014 1015 /* 1016 * Special I/O mode. 1017 */ 1018 1019 XMLPUBFUN xmlParserCtxtPtr XMLCALL 1020 xmlCreateIOParserCtxt (xmlSAXHandlerPtr sax, 1021 void *user_data, 1022 xmlInputReadCallback ioread, 1023 xmlInputCloseCallback ioclose, 1024 void *ioctx, 1025 xmlCharEncoding enc); 1026 1027 XMLPUBFUN xmlParserInputPtr XMLCALL 1028 xmlNewIOInputStream (xmlParserCtxtPtr ctxt, 1029 xmlParserInputBufferPtr input, 1030 xmlCharEncoding enc); 1031 1032 /* 1033 * Node infos. 1034 */ 1035 XMLPUBFUN const xmlParserNodeInfo* XMLCALL 1036 xmlParserFindNodeInfo (const xmlParserCtxtPtr ctxt, 1037 const xmlNodePtr node); 1038 XMLPUBFUN void XMLCALL 1039 xmlInitNodeInfoSeq (xmlParserNodeInfoSeqPtr seq); 1040 XMLPUBFUN void XMLCALL 1041 xmlClearNodeInfoSeq (xmlParserNodeInfoSeqPtr seq); 1042 XMLPUBFUN unsigned long XMLCALL 1043 xmlParserFindNodeInfoIndex(const xmlParserNodeInfoSeqPtr seq, 1044 const xmlNodePtr node); 1045 XMLPUBFUN void XMLCALL 1046 xmlParserAddNodeInfo (xmlParserCtxtPtr ctxt, 1047 const xmlParserNodeInfoPtr info); 1048 1049 /* 1050 * External entities handling actually implemented in xmlIO. 1051 */ 1052 1053 XMLPUBFUN void XMLCALL 1054 xmlSetExternalEntityLoader(xmlExternalEntityLoader f); 1055 XMLPUBFUN xmlExternalEntityLoader XMLCALL 1056 xmlGetExternalEntityLoader(void); 1057 XMLPUBFUN xmlParserInputPtr XMLCALL 1058 xmlLoadExternalEntity (const char *URL, 1059 const char *ID, 1060 xmlParserCtxtPtr ctxt); 1061 1062 /* 1063 * Index lookup, actually implemented in the encoding module 1064 */ 1065 XMLPUBFUN long XMLCALL 1066 xmlByteConsumed (xmlParserCtxtPtr ctxt); 1067 1068 /* 1069 * New set of simpler/more flexible APIs 1070 */ 1071 /** 1072 * xmlParserOption: 1073 * 1074 * This is the set of XML parser options that can be passed down 1075 * to the xmlReadDoc() and similar calls. 1076 */ 1077 typedef enum { 1078 XML_PARSE_RECOVER = 1<<0, /* recover on errors */ 1079 XML_PARSE_NOENT = 1<<1, /* substitute entities */ 1080 XML_PARSE_DTDLOAD = 1<<2, /* load the external subset */ 1081 XML_PARSE_DTDATTR = 1<<3, /* default DTD attributes */ 1082 XML_PARSE_DTDVALID = 1<<4, /* validate with the DTD */ 1083 XML_PARSE_NOERROR = 1<<5, /* suppress error reports */ 1084 XML_PARSE_NOWARNING = 1<<6, /* suppress warning reports */ 1085 XML_PARSE_PEDANTIC = 1<<7, /* pedantic error reporting */ 1086 XML_PARSE_NOBLANKS = 1<<8, /* remove blank nodes */ 1087 XML_PARSE_SAX1 = 1<<9, /* use the SAX1 interface internally */ 1088 XML_PARSE_XINCLUDE = 1<<10,/* Implement XInclude substitition */ 1089 XML_PARSE_NONET = 1<<11,/* Forbid network access */ 1090 XML_PARSE_NODICT = 1<<12,/* Do not reuse the context dictionnary */ 1091 XML_PARSE_NSCLEAN = 1<<13,/* remove redundant namespaces declarations */ 1092 XML_PARSE_NOCDATA = 1<<14,/* merge CDATA as text nodes */ 1093 XML_PARSE_NOXINCNODE= 1<<15,/* do not generate XINCLUDE START/END nodes */ 1094 XML_PARSE_COMPACT = 1<<16,/* compact small text nodes; no modification of 1095 the tree allowed afterwards (will possibly 1096 crash if you try to modify the tree) */ 1097 XML_PARSE_OLD10 = 1<<17,/* parse using XML-1.0 before update 5 */ 1098 XML_PARSE_NOBASEFIX = 1<<18,/* do not fixup XINCLUDE xml:base uris */ 1099 XML_PARSE_HUGE = 1<<19, /* relax any hardcoded limit from the parser */ 1100 XML_PARSE_OLDSAX = 1<<20 /* parse using SAX2 interface from before 2.7.0 */ 1101 } xmlParserOption; 1102 1103 XMLPUBFUN void XMLCALL 1104 xmlCtxtReset (xmlParserCtxtPtr ctxt); 1105 XMLPUBFUN int XMLCALL 1106 xmlCtxtResetPush (xmlParserCtxtPtr ctxt, 1107 const char *chunk, 1108 int size, 1109 const char *filename, 1110 const char *encoding); 1111 XMLPUBFUN int XMLCALL 1112 xmlCtxtUseOptions (xmlParserCtxtPtr ctxt, 1113 int options); 1114 XMLPUBFUN xmlDocPtr XMLCALL 1115 xmlReadDoc (const xmlChar *cur, 1116 const char *URL, 1117 const char *encoding, 1118 int options); 1119 XMLPUBFUN xmlDocPtr XMLCALL 1120 xmlReadFile (const char *URL, 1121 const char *encoding, 1122 int options); 1123 XMLPUBFUN xmlDocPtr XMLCALL 1124 xmlReadMemory (const char *buffer, 1125 int size, 1126 const char *URL, 1127 const char *encoding, 1128 int options); 1129 XMLPUBFUN xmlDocPtr XMLCALL 1130 xmlReadFd (int fd, 1131 const char *URL, 1132 const char *encoding, 1133 int options); 1134 XMLPUBFUN xmlDocPtr XMLCALL 1135 xmlReadIO (xmlInputReadCallback ioread, 1136 xmlInputCloseCallback ioclose, 1137 void *ioctx, 1138 const char *URL, 1139 const char *encoding, 1140 int options); 1141 XMLPUBFUN xmlDocPtr XMLCALL 1142 xmlCtxtReadDoc (xmlParserCtxtPtr ctxt, 1143 const xmlChar *cur, 1144 const char *URL, 1145 const char *encoding, 1146 int options); 1147 XMLPUBFUN xmlDocPtr XMLCALL 1148 xmlCtxtReadFile (xmlParserCtxtPtr ctxt, 1149 const char *filename, 1150 const char *encoding, 1151 int options); 1152 XMLPUBFUN xmlDocPtr XMLCALL 1153 xmlCtxtReadMemory (xmlParserCtxtPtr ctxt, 1154 const char *buffer, 1155 int size, 1156 const char *URL, 1157 const char *encoding, 1158 int options); 1159 XMLPUBFUN xmlDocPtr XMLCALL 1160 xmlCtxtReadFd (xmlParserCtxtPtr ctxt, 1161 int fd, 1162 const char *URL, 1163 const char *encoding, 1164 int options); 1165 XMLPUBFUN xmlDocPtr XMLCALL 1166 xmlCtxtReadIO (xmlParserCtxtPtr ctxt, 1167 xmlInputReadCallback ioread, 1168 xmlInputCloseCallback ioclose, 1169 void *ioctx, 1170 const char *URL, 1171 const char *encoding, 1172 int options); 1173 1174 /* 1175 * Library wide options 1176 */ 1177 /** 1178 * xmlFeature: 1179 * 1180 * Used to examine the existance of features that can be enabled 1181 * or disabled at compile-time. 1182 * They used to be called XML_FEATURE_xxx but this clashed with Expat 1183 */ 1184 typedef enum { 1185 XML_WITH_THREAD = 1, 1186 XML_WITH_TREE = 2, 1187 XML_WITH_OUTPUT = 3, 1188 XML_WITH_PUSH = 4, 1189 XML_WITH_READER = 5, 1190 XML_WITH_PATTERN = 6, 1191 XML_WITH_WRITER = 7, 1192 XML_WITH_SAX1 = 8, 1193 XML_WITH_FTP = 9, 1194 XML_WITH_HTTP = 10, 1195 XML_WITH_VALID = 11, 1196 XML_WITH_HTML = 12, 1197 XML_WITH_LEGACY = 13, 1198 XML_WITH_C14N = 14, 1199 XML_WITH_CATALOG = 15, 1200 XML_WITH_XPATH = 16, 1201 XML_WITH_XPTR = 17, 1202 XML_WITH_XINCLUDE = 18, 1203 XML_WITH_ICONV = 19, 1204 XML_WITH_ISO8859X = 20, 1205 XML_WITH_UNICODE = 21, 1206 XML_WITH_REGEXP = 22, 1207 XML_WITH_AUTOMATA = 23, 1208 XML_WITH_EXPR = 24, 1209 XML_WITH_SCHEMAS = 25, 1210 XML_WITH_SCHEMATRON = 26, 1211 XML_WITH_MODULES = 27, 1212 XML_WITH_DEBUG = 28, 1213 XML_WITH_DEBUG_MEM = 29, 1214 XML_WITH_DEBUG_RUN = 30, 1215 XML_WITH_ZLIB = 31, 1216 XML_WITH_NONE = 99999 /* just to be sure of allocation size */ 1217 } xmlFeature; 1218 1219 XMLPUBFUN int XMLCALL 1220 xmlHasFeature (xmlFeature feature); 1221 1222 #ifdef __cplusplus 1223 } 1224 #endif 1225 #endif /* __XML_PARSER_H__ */ 1226 1227