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