1/* 2 * Summary: interfaces for tree manipulation 3 * Description: this module describes the structures found in an tree resulting 4 * from an XML or HTML parsing, as well as the API provided for 5 * various processing on that tree 6 * 7 * Copy: See Copyright for the status of this software. 8 * 9 * Author: Daniel Veillard 10 */ 11 12#ifndef __XML_TREE_H__ 13#define __XML_TREE_H__ 14 15#include <stdio.h> 16#include <libxml/xmlversion.h> 17#include <libxml/xmlstring.h> 18 19#ifdef __cplusplus 20extern "C" { 21#endif 22 23/* 24 * Some of the basic types pointer to structures: 25 */ 26/* xmlIO.h */ 27typedef struct _xmlParserInputBuffer xmlParserInputBuffer; 28typedef xmlParserInputBuffer *xmlParserInputBufferPtr; 29 30typedef struct _xmlOutputBuffer xmlOutputBuffer; 31typedef xmlOutputBuffer *xmlOutputBufferPtr; 32 33/* parser.h */ 34typedef struct _xmlParserInput xmlParserInput; 35typedef xmlParserInput *xmlParserInputPtr; 36 37typedef struct _xmlParserCtxt xmlParserCtxt; 38typedef xmlParserCtxt *xmlParserCtxtPtr; 39 40typedef struct _xmlSAXLocator xmlSAXLocator; 41typedef xmlSAXLocator *xmlSAXLocatorPtr; 42 43typedef struct _xmlSAXHandler xmlSAXHandler; 44typedef xmlSAXHandler *xmlSAXHandlerPtr; 45 46/* entities.h */ 47typedef struct _xmlEntity xmlEntity; 48typedef xmlEntity *xmlEntityPtr; 49 50/** 51 * BASE_BUFFER_SIZE: 52 * 53 * default buffer size 4000. 54 */ 55#define BASE_BUFFER_SIZE 4096 56 57/** 58 * xmlBufferAllocationScheme: 59 * 60 * A buffer allocation scheme can be defined to either match exactly the 61 * need or double it's allocated size each time it is found too small. 62 */ 63 64typedef enum { 65 XML_BUFFER_ALLOC_DOUBLEIT, 66 XML_BUFFER_ALLOC_EXACT, 67 XML_BUFFER_ALLOC_IMMUTABLE 68} xmlBufferAllocationScheme; 69 70/** 71 * xmlBuffer: 72 * 73 * A buffer structure. 74 */ 75typedef struct _xmlBuffer xmlBuffer; 76typedef xmlBuffer *xmlBufferPtr; 77struct _xmlBuffer { 78 xmlChar *content; /* The buffer content UTF8 */ 79 unsigned int use; /* The buffer size used */ 80 unsigned int size; /* The buffer size */ 81 xmlBufferAllocationScheme alloc; /* The realloc method */ 82}; 83 84/** 85 * XML_XML_NAMESPACE: 86 * 87 * This is the namespace for the special xml: prefix predefined in the 88 * XML Namespace specification. 89 */ 90#define XML_XML_NAMESPACE \ 91 (const xmlChar *) "http://www.w3.org/XML/1998/namespace" 92 93/** 94 * XML_XML_ID: 95 * 96 * This is the name for the special xml:id attribute 97 */ 98#define XML_XML_ID (const xmlChar *) "xml:id" 99 100/* 101 * The different element types carried by an XML tree. 102 * 103 * NOTE: This is synchronized with DOM Level1 values 104 * See http://www.w3.org/TR/REC-DOM-Level-1/ 105 * 106 * Actually this had diverged a bit, and now XML_DOCUMENT_TYPE_NODE should 107 * be deprecated to use an XML_DTD_NODE. 108 */ 109typedef enum { 110 XML_ELEMENT_NODE= 1, 111 XML_ATTRIBUTE_NODE= 2, 112 XML_TEXT_NODE= 3, 113 XML_CDATA_SECTION_NODE= 4, 114 XML_ENTITY_REF_NODE= 5, 115 XML_ENTITY_NODE= 6, 116 XML_PI_NODE= 7, 117 XML_COMMENT_NODE= 8, 118 XML_DOCUMENT_NODE= 9, 119 XML_DOCUMENT_TYPE_NODE= 10, 120 XML_DOCUMENT_FRAG_NODE= 11, 121 XML_NOTATION_NODE= 12, 122 XML_HTML_DOCUMENT_NODE= 13, 123 XML_DTD_NODE= 14, 124 XML_ELEMENT_DECL= 15, 125 XML_ATTRIBUTE_DECL= 16, 126 XML_ENTITY_DECL= 17, 127 XML_NAMESPACE_DECL= 18, 128 XML_XINCLUDE_START= 19, 129 XML_XINCLUDE_END= 20 130#ifdef LIBXML_DOCB_ENABLED 131 ,XML_DOCB_DOCUMENT_NODE= 21 132#endif 133} xmlElementType; 134 135 136/** 137 * xmlNotation: 138 * 139 * A DTD Notation definition. 140 */ 141 142typedef struct _xmlNotation xmlNotation; 143typedef xmlNotation *xmlNotationPtr; 144struct _xmlNotation { 145 const xmlChar *name; /* Notation name */ 146 const xmlChar *PublicID; /* Public identifier, if any */ 147 const xmlChar *SystemID; /* System identifier, if any */ 148}; 149 150/** 151 * xmlAttributeType: 152 * 153 * A DTD Attribute type definition. 154 */ 155 156typedef enum { 157 XML_ATTRIBUTE_CDATA = 1, 158 XML_ATTRIBUTE_ID, 159 XML_ATTRIBUTE_IDREF , 160 XML_ATTRIBUTE_IDREFS, 161 XML_ATTRIBUTE_ENTITY, 162 XML_ATTRIBUTE_ENTITIES, 163 XML_ATTRIBUTE_NMTOKEN, 164 XML_ATTRIBUTE_NMTOKENS, 165 XML_ATTRIBUTE_ENUMERATION, 166 XML_ATTRIBUTE_NOTATION 167} xmlAttributeType; 168 169/** 170 * xmlAttributeDefault: 171 * 172 * A DTD Attribute default definition. 173 */ 174 175typedef enum { 176 XML_ATTRIBUTE_NONE = 1, 177 XML_ATTRIBUTE_REQUIRED, 178 XML_ATTRIBUTE_IMPLIED, 179 XML_ATTRIBUTE_FIXED 180} xmlAttributeDefault; 181 182/** 183 * xmlEnumeration: 184 * 185 * List structure used when there is an enumeration in DTDs. 186 */ 187 188typedef struct _xmlEnumeration xmlEnumeration; 189typedef xmlEnumeration *xmlEnumerationPtr; 190struct _xmlEnumeration { 191 struct _xmlEnumeration *next; /* next one */ 192 const xmlChar *name; /* Enumeration name */ 193}; 194 195/** 196 * xmlAttribute: 197 * 198 * An Attribute declaration in a DTD. 199 */ 200 201typedef struct _xmlAttribute xmlAttribute; 202typedef xmlAttribute *xmlAttributePtr; 203struct _xmlAttribute { 204 void *_private; /* application data */ 205 xmlElementType type; /* XML_ATTRIBUTE_DECL, must be second ! */ 206 const xmlChar *name; /* Attribute name */ 207 struct _xmlNode *children; /* NULL */ 208 struct _xmlNode *last; /* NULL */ 209 struct _xmlDtd *parent; /* -> DTD */ 210 struct _xmlNode *next; /* next sibling link */ 211 struct _xmlNode *prev; /* previous sibling link */ 212 struct _xmlDoc *doc; /* the containing document */ 213 214 struct _xmlAttribute *nexth; /* next in hash table */ 215 xmlAttributeType atype; /* The attribute type */ 216 xmlAttributeDefault def; /* the default */ 217 const xmlChar *defaultValue; /* or the default value */ 218 xmlEnumerationPtr tree; /* or the enumeration tree if any */ 219 const xmlChar *prefix; /* the namespace prefix if any */ 220 const xmlChar *elem; /* Element holding the attribute */ 221}; 222 223/** 224 * xmlElementContentType: 225 * 226 * Possible definitions of element content types. 227 */ 228typedef enum { 229 XML_ELEMENT_CONTENT_PCDATA = 1, 230 XML_ELEMENT_CONTENT_ELEMENT, 231 XML_ELEMENT_CONTENT_SEQ, 232 XML_ELEMENT_CONTENT_OR 233} xmlElementContentType; 234 235/** 236 * xmlElementContentOccur: 237 * 238 * Possible definitions of element content occurrences. 239 */ 240typedef enum { 241 XML_ELEMENT_CONTENT_ONCE = 1, 242 XML_ELEMENT_CONTENT_OPT, 243 XML_ELEMENT_CONTENT_MULT, 244 XML_ELEMENT_CONTENT_PLUS 245} xmlElementContentOccur; 246 247/** 248 * xmlElementContent: 249 * 250 * An XML Element content as stored after parsing an element definition 251 * in a DTD. 252 */ 253 254typedef struct _xmlElementContent xmlElementContent; 255typedef xmlElementContent *xmlElementContentPtr; 256struct _xmlElementContent { 257 xmlElementContentType type; /* PCDATA, ELEMENT, SEQ or OR */ 258 xmlElementContentOccur ocur; /* ONCE, OPT, MULT or PLUS */ 259 const xmlChar *name; /* Element name */ 260 struct _xmlElementContent *c1; /* first child */ 261 struct _xmlElementContent *c2; /* second child */ 262 struct _xmlElementContent *parent; /* parent */ 263 const xmlChar *prefix; /* Namespace prefix */ 264}; 265 266/** 267 * xmlElementTypeVal: 268 * 269 * The different possibilities for an element content type. 270 */ 271 272typedef enum { 273 XML_ELEMENT_TYPE_UNDEFINED = 0, 274 XML_ELEMENT_TYPE_EMPTY = 1, 275 XML_ELEMENT_TYPE_ANY, 276 XML_ELEMENT_TYPE_MIXED, 277 XML_ELEMENT_TYPE_ELEMENT 278} xmlElementTypeVal; 279 280#ifdef __cplusplus 281} 282#endif 283#include <libxml/xmlregexp.h> 284#ifdef __cplusplus 285extern "C" { 286#endif 287 288/** 289 * xmlElement: 290 * 291 * An XML Element declaration from a DTD. 292 */ 293 294typedef struct _xmlElement xmlElement; 295typedef xmlElement *xmlElementPtr; 296struct _xmlElement { 297 void *_private; /* application data */ 298 xmlElementType type; /* XML_ELEMENT_DECL, must be second ! */ 299 const xmlChar *name; /* Element name */ 300 struct _xmlNode *children; /* NULL */ 301 struct _xmlNode *last; /* NULL */ 302 struct _xmlDtd *parent; /* -> DTD */ 303 struct _xmlNode *next; /* next sibling link */ 304 struct _xmlNode *prev; /* previous sibling link */ 305 struct _xmlDoc *doc; /* the containing document */ 306 307 xmlElementTypeVal etype; /* The type */ 308 xmlElementContentPtr content; /* the allowed element content */ 309 xmlAttributePtr attributes; /* List of the declared attributes */ 310 const xmlChar *prefix; /* the namespace prefix if any */ 311#ifdef LIBXML_REGEXP_ENABLED 312 xmlRegexpPtr contModel; /* the validating regexp */ 313#else 314 void *contModel; 315#endif 316}; 317 318 319/** 320 * XML_LOCAL_NAMESPACE: 321 * 322 * A namespace declaration node. 323 */ 324#define XML_LOCAL_NAMESPACE XML_NAMESPACE_DECL 325typedef xmlElementType xmlNsType; 326 327/** 328 * xmlNs: 329 * 330 * An XML namespace. 331 * Note that prefix == NULL is valid, it defines the default namespace 332 * within the subtree (until overridden). 333 * 334 * xmlNsType is unified with xmlElementType. 335 */ 336 337typedef struct _xmlNs xmlNs; 338typedef xmlNs *xmlNsPtr; 339struct _xmlNs { 340 struct _xmlNs *next; /* next Ns link for this node */ 341 xmlNsType type; /* global or local */ 342 const xmlChar *href; /* URL for the namespace */ 343 const xmlChar *prefix; /* prefix for the namespace */ 344 void *_private; /* application data */ 345}; 346 347/** 348 * xmlDtd: 349 * 350 * An XML DTD, as defined by <!DOCTYPE ... There is actually one for 351 * the internal subset and for the external subset. 352 */ 353typedef struct _xmlDtd xmlDtd; 354typedef xmlDtd *xmlDtdPtr; 355struct _xmlDtd { 356 void *_private; /* application data */ 357 xmlElementType type; /* XML_DTD_NODE, must be second ! */ 358 const xmlChar *name; /* Name of the DTD */ 359 struct _xmlNode *children; /* the value of the property link */ 360 struct _xmlNode *last; /* last child link */ 361 struct _xmlDoc *parent; /* child->parent link */ 362 struct _xmlNode *next; /* next sibling link */ 363 struct _xmlNode *prev; /* previous sibling link */ 364 struct _xmlDoc *doc; /* the containing document */ 365 366 /* End of common part */ 367 void *notations; /* Hash table for notations if any */ 368 void *elements; /* Hash table for elements if any */ 369 void *attributes; /* Hash table for attributes if any */ 370 void *entities; /* Hash table for entities if any */ 371 const xmlChar *ExternalID; /* External identifier for PUBLIC DTD */ 372 const xmlChar *SystemID; /* URI for a SYSTEM or PUBLIC DTD */ 373 void *pentities; /* Hash table for param entities if any */ 374}; 375 376/** 377 * xmlAttr: 378 * 379 * An attribute on an XML node. 380 */ 381typedef struct _xmlAttr xmlAttr; 382typedef xmlAttr *xmlAttrPtr; 383struct _xmlAttr { 384 void *_private; /* application data */ 385 xmlElementType type; /* XML_ATTRIBUTE_NODE, must be second ! */ 386 const xmlChar *name; /* the name of the property */ 387 struct _xmlNode *children; /* the value of the property */ 388 struct _xmlNode *last; /* NULL */ 389 struct _xmlNode *parent; /* child->parent link */ 390 struct _xmlAttr *next; /* next sibling link */ 391 struct _xmlAttr *prev; /* previous sibling link */ 392 struct _xmlDoc *doc; /* the containing document */ 393 xmlNs *ns; /* pointer to the associated namespace */ 394 xmlAttributeType atype; /* the attribute type if validating */ 395 void *psvi; /* for type/PSVI informations */ 396}; 397 398/** 399 * xmlID: 400 * 401 * An XML ID instance. 402 */ 403 404typedef struct _xmlID xmlID; 405typedef xmlID *xmlIDPtr; 406struct _xmlID { 407 struct _xmlID *next; /* next ID */ 408 const xmlChar *value; /* The ID name */ 409 xmlAttrPtr attr; /* The attribute holding it */ 410 const xmlChar *name; /* The attribute if attr is not available */ 411 int lineno; /* The line number if attr is not available */ 412 struct _xmlDoc *doc; /* The document holding the ID */ 413}; 414 415/** 416 * xmlRef: 417 * 418 * An XML IDREF instance. 419 */ 420 421typedef struct _xmlRef xmlRef; 422typedef xmlRef *xmlRefPtr; 423struct _xmlRef { 424 struct _xmlRef *next; /* next Ref */ 425 const xmlChar *value; /* The Ref name */ 426 xmlAttrPtr attr; /* The attribute holding it */ 427 const xmlChar *name; /* The attribute if attr is not available */ 428 int lineno; /* The line number if attr is not available */ 429}; 430 431/** 432 * xmlNode: 433 * 434 * A node in an XML tree. 435 */ 436typedef struct _xmlNode xmlNode; 437typedef xmlNode *xmlNodePtr; 438struct _xmlNode { 439 void *_private; /* application data */ 440 xmlElementType type; /* type number, must be second ! */ 441 const xmlChar *name; /* the name of the node, or the entity */ 442 struct _xmlNode *children; /* parent->childs link */ 443 struct _xmlNode *last; /* last child link */ 444 struct _xmlNode *parent; /* child->parent link */ 445 struct _xmlNode *next; /* next sibling link */ 446 struct _xmlNode *prev; /* previous sibling link */ 447 struct _xmlDoc *doc; /* the containing document */ 448 449 /* End of common part */ 450 xmlNs *ns; /* pointer to the associated namespace */ 451 xmlChar *content; /* the content */ 452 struct _xmlAttr *properties;/* properties list */ 453 xmlNs *nsDef; /* namespace definitions on this node */ 454 void *psvi; /* for type/PSVI informations */ 455 unsigned short line; /* line number */ 456 unsigned short extra; /* extra data for XPath/XSLT */ 457}; 458 459/** 460 * XML_GET_CONTENT: 461 * 462 * Macro to extract the content pointer of a node. 463 */ 464#define XML_GET_CONTENT(n) \ 465 ((n)->type == XML_ELEMENT_NODE ? NULL : (n)->content) 466 467/** 468 * XML_GET_LINE: 469 * 470 * Macro to extract the line number of an element node. 471 */ 472#define XML_GET_LINE(n) \ 473 (xmlGetLineNo(n)) 474 475 476/** 477 * xmlDoc: 478 * 479 * An XML document. 480 */ 481typedef struct _xmlDoc xmlDoc; 482typedef xmlDoc *xmlDocPtr; 483struct _xmlDoc { 484 void *_private; /* application data */ 485 xmlElementType type; /* XML_DOCUMENT_NODE, must be second ! */ 486 char *name; /* name/filename/URI of the document */ 487 struct _xmlNode *children; /* the document tree */ 488 struct _xmlNode *last; /* last child link */ 489 struct _xmlNode *parent; /* child->parent link */ 490 struct _xmlNode *next; /* next sibling link */ 491 struct _xmlNode *prev; /* previous sibling link */ 492 struct _xmlDoc *doc; /* autoreference to itself */ 493 494 /* End of common part */ 495 int compression;/* level of zlib compression */ 496 int standalone; /* standalone document (no external refs) */ 497 struct _xmlDtd *intSubset; /* the document internal subset */ 498 struct _xmlDtd *extSubset; /* the document external subset */ 499 struct _xmlNs *oldNs; /* Global namespace, the old way */ 500 const xmlChar *version; /* the XML version string */ 501 const xmlChar *encoding; /* external initial encoding, if any */ 502 void *ids; /* Hash table for ID attributes if any */ 503 void *refs; /* Hash table for IDREFs attributes if any */ 504 const xmlChar *URL; /* The URI for that document */ 505 int charset; /* encoding of the in-memory content 506 actually an xmlCharEncoding */ 507 struct _xmlDict *dict; /* dict used to allocate names or NULL */ 508 void *psvi; /* for type/PSVI informations */ 509}; 510 511typedef struct _xmlDOMWrapCtxt xmlDOMWrapCtxt; 512typedef xmlDOMWrapCtxt *xmlDOMWrapCtxtPtr; 513struct _xmlDOMWrapCtxt { 514 void * _private; 515}; 516 517/** 518 * xmlChildrenNode: 519 * 520 * Macro for compatibility naming layer with libxml1. Maps 521 * to "children." 522 */ 523#ifndef xmlChildrenNode 524#define xmlChildrenNode children 525#endif 526 527/** 528 * xmlRootNode: 529 * 530 * Macro for compatibility naming layer with libxml1. Maps 531 * to "children". 532 */ 533#ifndef xmlRootNode 534#define xmlRootNode children 535#endif 536 537/* 538 * Variables. 539 */ 540 541/* 542 * Some helper functions 543 */ 544#if defined(LIBXML_TREE_ENABLED) || defined(LIBXML_XPATH_ENABLED) || defined(LIBXML_SCHEMAS_ENABLED) || defined(LIBXML_DEBUG_ENABLED) || defined (LIBXML_HTML_ENABLED) 545XMLPUBFUN int XMLCALL 546 xmlValidateNCName (const xmlChar *value, 547 int space); 548#endif 549 550#if defined(LIBXML_TREE_ENABLED) || defined(LIBXML_SCHEMAS_ENABLED) 551XMLPUBFUN int XMLCALL 552 xmlValidateQName (const xmlChar *value, 553 int space); 554XMLPUBFUN int XMLCALL 555 xmlValidateName (const xmlChar *value, 556 int space); 557XMLPUBFUN int XMLCALL 558 xmlValidateNMToken (const xmlChar *value, 559 int space); 560#endif 561 562XMLPUBFUN xmlChar * XMLCALL 563 xmlBuildQName (const xmlChar *ncname, 564 const xmlChar *prefix, 565 xmlChar *memory, 566 int len); 567XMLPUBFUN xmlChar * XMLCALL 568 xmlSplitQName2 (const xmlChar *name, 569 xmlChar **prefix); 570XMLPUBFUN const xmlChar * XMLCALL 571 xmlSplitQName3 (const xmlChar *name, 572 int *len); 573 574/* 575 * Handling Buffers. 576 */ 577 578XMLPUBFUN void XMLCALL 579 xmlSetBufferAllocationScheme(xmlBufferAllocationScheme scheme); 580XMLPUBFUN xmlBufferAllocationScheme XMLCALL 581 xmlGetBufferAllocationScheme(void); 582 583XMLPUBFUN xmlBufferPtr XMLCALL 584 xmlBufferCreate (void); 585XMLPUBFUN xmlBufferPtr XMLCALL 586 xmlBufferCreateSize (size_t size); 587XMLPUBFUN xmlBufferPtr XMLCALL 588 xmlBufferCreateStatic (void *mem, 589 size_t size); 590XMLPUBFUN int XMLCALL 591 xmlBufferResize (xmlBufferPtr buf, 592 unsigned int size); 593XMLPUBFUN void XMLCALL 594 xmlBufferFree (xmlBufferPtr buf); 595XMLPUBFUN int XMLCALL 596 xmlBufferDump (FILE *file, 597 xmlBufferPtr buf); 598XMLPUBFUN int XMLCALL 599 xmlBufferAdd (xmlBufferPtr buf, 600 const xmlChar *str, 601 int len); 602XMLPUBFUN int XMLCALL 603 xmlBufferAddHead (xmlBufferPtr buf, 604 const xmlChar *str, 605 int len); 606XMLPUBFUN int XMLCALL 607 xmlBufferCat (xmlBufferPtr buf, 608 const xmlChar *str); 609XMLPUBFUN int XMLCALL 610 xmlBufferCCat (xmlBufferPtr buf, 611 const char *str); 612XMLPUBFUN int XMLCALL 613 xmlBufferShrink (xmlBufferPtr buf, 614 unsigned int len); 615XMLPUBFUN int XMLCALL 616 xmlBufferGrow (xmlBufferPtr buf, 617 unsigned int len); 618XMLPUBFUN void XMLCALL 619 xmlBufferEmpty (xmlBufferPtr buf); 620XMLPUBFUN const xmlChar* XMLCALL 621 xmlBufferContent (const xmlBufferPtr buf); 622XMLPUBFUN void XMLCALL 623 xmlBufferSetAllocationScheme(xmlBufferPtr buf, 624 xmlBufferAllocationScheme scheme); 625XMLPUBFUN int XMLCALL 626 xmlBufferLength (const xmlBufferPtr buf); 627 628/* 629 * Creating/freeing new structures. 630 */ 631XMLPUBFUN xmlDtdPtr XMLCALL 632 xmlCreateIntSubset (xmlDocPtr doc, 633 const xmlChar *name, 634 const xmlChar *ExternalID, 635 const xmlChar *SystemID); 636XMLPUBFUN xmlDtdPtr XMLCALL 637 xmlNewDtd (xmlDocPtr doc, 638 const xmlChar *name, 639 const xmlChar *ExternalID, 640 const xmlChar *SystemID); 641XMLPUBFUN xmlDtdPtr XMLCALL 642 xmlGetIntSubset (xmlDocPtr doc); 643XMLPUBFUN void XMLCALL 644 xmlFreeDtd (xmlDtdPtr cur); 645#ifdef LIBXML_LEGACY_ENABLED 646XMLPUBFUN xmlNsPtr XMLCALL 647 xmlNewGlobalNs (xmlDocPtr doc, 648 const xmlChar *href, 649 const xmlChar *prefix); 650#endif /* LIBXML_LEGACY_ENABLED */ 651XMLPUBFUN xmlNsPtr XMLCALL 652 xmlNewNs (xmlNodePtr node, 653 const xmlChar *href, 654 const xmlChar *prefix); 655XMLPUBFUN void XMLCALL 656 xmlFreeNs (xmlNsPtr cur); 657XMLPUBFUN void XMLCALL 658 xmlFreeNsList (xmlNsPtr cur); 659XMLPUBFUN xmlDocPtr XMLCALL 660 xmlNewDoc (const xmlChar *version); 661XMLPUBFUN void XMLCALL 662 xmlFreeDoc (xmlDocPtr cur); 663XMLPUBFUN xmlAttrPtr XMLCALL 664 xmlNewDocProp (xmlDocPtr doc, 665 const xmlChar *name, 666 const xmlChar *value); 667#if defined(LIBXML_TREE_ENABLED) || defined(LIBXML_HTML_ENABLED) || \ 668 defined(LIBXML_SCHEMAS_ENABLED) 669XMLPUBFUN xmlAttrPtr XMLCALL 670 xmlNewProp (xmlNodePtr node, 671 const xmlChar *name, 672 const xmlChar *value); 673#endif 674XMLPUBFUN xmlAttrPtr XMLCALL 675 xmlNewNsProp (xmlNodePtr node, 676 xmlNsPtr ns, 677 const xmlChar *name, 678 const xmlChar *value); 679XMLPUBFUN xmlAttrPtr XMLCALL 680 xmlNewNsPropEatName (xmlNodePtr node, 681 xmlNsPtr ns, 682 xmlChar *name, 683 const xmlChar *value); 684XMLPUBFUN void XMLCALL 685 xmlFreePropList (xmlAttrPtr cur); 686XMLPUBFUN void XMLCALL 687 xmlFreeProp (xmlAttrPtr cur); 688XMLPUBFUN xmlAttrPtr XMLCALL 689 xmlCopyProp (xmlNodePtr target, 690 xmlAttrPtr cur); 691XMLPUBFUN xmlAttrPtr XMLCALL 692 xmlCopyPropList (xmlNodePtr target, 693 xmlAttrPtr cur); 694#ifdef LIBXML_TREE_ENABLED 695XMLPUBFUN xmlDtdPtr XMLCALL 696 xmlCopyDtd (xmlDtdPtr dtd); 697#endif /* LIBXML_TREE_ENABLED */ 698#if defined(LIBXML_TREE_ENABLED) || defined(LIBXML_SCHEMAS_ENABLED) 699XMLPUBFUN xmlDocPtr XMLCALL 700 xmlCopyDoc (xmlDocPtr doc, 701 int recursive); 702#endif /* defined(LIBXML_TREE_ENABLED) || defined(LIBXML_SCHEMAS_ENABLED) */ 703/* 704 * Creating new nodes. 705 */ 706XMLPUBFUN xmlNodePtr XMLCALL 707 xmlNewDocNode (xmlDocPtr doc, 708 xmlNsPtr ns, 709 const xmlChar *name, 710 const xmlChar *content); 711XMLPUBFUN xmlNodePtr XMLCALL 712 xmlNewDocNodeEatName (xmlDocPtr doc, 713 xmlNsPtr ns, 714 xmlChar *name, 715 const xmlChar *content); 716XMLPUBFUN xmlNodePtr XMLCALL 717 xmlNewNode (xmlNsPtr ns, 718 const xmlChar *name); 719XMLPUBFUN xmlNodePtr XMLCALL 720 xmlNewNodeEatName (xmlNsPtr ns, 721 xmlChar *name); 722#if defined(LIBXML_TREE_ENABLED) || defined(LIBXML_SCHEMAS_ENABLED) 723XMLPUBFUN xmlNodePtr XMLCALL 724 xmlNewChild (xmlNodePtr parent, 725 xmlNsPtr ns, 726 const xmlChar *name, 727 const xmlChar *content); 728#endif 729XMLPUBFUN xmlNodePtr XMLCALL 730 xmlNewDocText (xmlDocPtr doc, 731 const xmlChar *content); 732XMLPUBFUN xmlNodePtr XMLCALL 733 xmlNewText (const xmlChar *content); 734XMLPUBFUN xmlNodePtr XMLCALL 735 xmlNewDocPI (xmlDocPtr doc, 736 const xmlChar *name, 737 const xmlChar *content); 738XMLPUBFUN xmlNodePtr XMLCALL 739 xmlNewPI (const xmlChar *name, 740 const xmlChar *content); 741XMLPUBFUN xmlNodePtr XMLCALL 742 xmlNewDocTextLen (xmlDocPtr doc, 743 const xmlChar *content, 744 int len); 745XMLPUBFUN xmlNodePtr XMLCALL 746 xmlNewTextLen (const xmlChar *content, 747 int len); 748XMLPUBFUN xmlNodePtr XMLCALL 749 xmlNewDocComment (xmlDocPtr doc, 750 const xmlChar *content); 751XMLPUBFUN xmlNodePtr XMLCALL 752 xmlNewComment (const xmlChar *content); 753XMLPUBFUN xmlNodePtr XMLCALL 754 xmlNewCDataBlock (xmlDocPtr doc, 755 const xmlChar *content, 756 int len); 757XMLPUBFUN xmlNodePtr XMLCALL 758 xmlNewCharRef (xmlDocPtr doc, 759 const xmlChar *name); 760XMLPUBFUN xmlNodePtr XMLCALL 761 xmlNewReference (xmlDocPtr doc, 762 const xmlChar *name); 763XMLPUBFUN xmlNodePtr XMLCALL 764 xmlCopyNode (const xmlNodePtr node, 765 int recursive); 766XMLPUBFUN xmlNodePtr XMLCALL 767 xmlDocCopyNode (const xmlNodePtr node, 768 xmlDocPtr doc, 769 int recursive); 770XMLPUBFUN xmlNodePtr XMLCALL 771 xmlDocCopyNodeList (xmlDocPtr doc, 772 const xmlNodePtr node); 773XMLPUBFUN xmlNodePtr XMLCALL 774 xmlCopyNodeList (const xmlNodePtr node); 775#ifdef LIBXML_TREE_ENABLED 776XMLPUBFUN xmlNodePtr XMLCALL 777 xmlNewTextChild (xmlNodePtr parent, 778 xmlNsPtr ns, 779 const xmlChar *name, 780 const xmlChar *content); 781XMLPUBFUN xmlNodePtr XMLCALL 782 xmlNewDocRawNode (xmlDocPtr doc, 783 xmlNsPtr ns, 784 const xmlChar *name, 785 const xmlChar *content); 786XMLPUBFUN xmlNodePtr XMLCALL 787 xmlNewDocFragment (xmlDocPtr doc); 788#endif /* LIBXML_TREE_ENABLED */ 789 790/* 791 * Navigating. 792 */ 793XMLPUBFUN long XMLCALL 794 xmlGetLineNo (xmlNodePtr node); 795#if defined(LIBXML_TREE_ENABLED) || defined(LIBXML_DEBUG_ENABLED) 796XMLPUBFUN xmlChar * XMLCALL 797 xmlGetNodePath (xmlNodePtr node); 798#endif /* defined(LIBXML_TREE_ENABLED) || defined(LIBXML_DEBUG_ENABLED) */ 799XMLPUBFUN xmlNodePtr XMLCALL 800 xmlDocGetRootElement (xmlDocPtr doc); 801XMLPUBFUN xmlNodePtr XMLCALL 802 xmlGetLastChild (xmlNodePtr parent); 803XMLPUBFUN int XMLCALL 804 xmlNodeIsText (xmlNodePtr node); 805XMLPUBFUN int XMLCALL 806 xmlIsBlankNode (xmlNodePtr node); 807 808/* 809 * Changing the structure. 810 */ 811#if defined(LIBXML_TREE_ENABLED) || defined(LIBXML_WRITER_ENABLED) 812XMLPUBFUN xmlNodePtr XMLCALL 813 xmlDocSetRootElement (xmlDocPtr doc, 814 xmlNodePtr root); 815#endif /* defined(LIBXML_TREE_ENABLED) || defined(LIBXML_WRITER_ENABLED) */ 816#ifdef LIBXML_TREE_ENABLED 817XMLPUBFUN void XMLCALL 818 xmlNodeSetName (xmlNodePtr cur, 819 const xmlChar *name); 820#endif /* LIBXML_TREE_ENABLED */ 821XMLPUBFUN xmlNodePtr XMLCALL 822 xmlAddChild (xmlNodePtr parent, 823 xmlNodePtr cur); 824XMLPUBFUN xmlNodePtr XMLCALL 825 xmlAddChildList (xmlNodePtr parent, 826 xmlNodePtr cur); 827#if defined(LIBXML_TREE_ENABLED) || defined(LIBXML_WRITER_ENABLED) 828XMLPUBFUN xmlNodePtr XMLCALL 829 xmlReplaceNode (xmlNodePtr old, 830 xmlNodePtr cur); 831#endif /* defined(LIBXML_TREE_ENABLED) || defined(LIBXML_WRITER_ENABLED) */ 832#if defined(LIBXML_TREE_ENABLED) || defined(LIBXML_HTML_ENABLED) || \ 833 defined(LIBXML_SCHEMAS_ENABLED) 834XMLPUBFUN xmlNodePtr XMLCALL 835 xmlAddPrevSibling (xmlNodePtr cur, 836 xmlNodePtr elem); 837#endif /* LIBXML_TREE_ENABLED || LIBXML_HTML_ENABLED || LIBXML_SCHEMAS_ENABLED */ 838XMLPUBFUN xmlNodePtr XMLCALL 839 xmlAddSibling (xmlNodePtr cur, 840 xmlNodePtr elem); 841XMLPUBFUN xmlNodePtr XMLCALL 842 xmlAddNextSibling (xmlNodePtr cur, 843 xmlNodePtr elem); 844XMLPUBFUN void XMLCALL 845 xmlUnlinkNode (xmlNodePtr cur); 846XMLPUBFUN xmlNodePtr XMLCALL 847 xmlTextMerge (xmlNodePtr first, 848 xmlNodePtr second); 849XMLPUBFUN int XMLCALL 850 xmlTextConcat (xmlNodePtr node, 851 const xmlChar *content, 852 int len); 853XMLPUBFUN void XMLCALL 854 xmlFreeNodeList (xmlNodePtr cur); 855XMLPUBFUN void XMLCALL 856 xmlFreeNode (xmlNodePtr cur); 857XMLPUBFUN void XMLCALL 858 xmlSetTreeDoc (xmlNodePtr tree, 859 xmlDocPtr doc); 860XMLPUBFUN void XMLCALL 861 xmlSetListDoc (xmlNodePtr list, 862 xmlDocPtr doc); 863/* 864 * Namespaces. 865 */ 866XMLPUBFUN xmlNsPtr XMLCALL 867 xmlSearchNs (xmlDocPtr doc, 868 xmlNodePtr node, 869 const xmlChar *nameSpace); 870XMLPUBFUN xmlNsPtr XMLCALL 871 xmlSearchNsByHref (xmlDocPtr doc, 872 xmlNodePtr node, 873 const xmlChar *href); 874#if defined(LIBXML_TREE_ENABLED) || defined(LIBXML_XPATH_ENABLED) 875XMLPUBFUN xmlNsPtr * XMLCALL 876 xmlGetNsList (xmlDocPtr doc, 877 xmlNodePtr node); 878#endif /* defined(LIBXML_TREE_ENABLED) || defined(LIBXML_XPATH_ENABLED) */ 879 880XMLPUBFUN void XMLCALL 881 xmlSetNs (xmlNodePtr node, 882 xmlNsPtr ns); 883XMLPUBFUN xmlNsPtr XMLCALL 884 xmlCopyNamespace (xmlNsPtr cur); 885XMLPUBFUN xmlNsPtr XMLCALL 886 xmlCopyNamespaceList (xmlNsPtr cur); 887 888/* 889 * Changing the content. 890 */ 891#if defined(LIBXML_TREE_ENABLED) || defined(LIBXML_XINCLUDE_ENABLED) || defined(LIBXML_SCHEMAS_ENABLED) || defined(LIBXML_HTML_ENABLED) 892XMLPUBFUN xmlAttrPtr XMLCALL 893 xmlSetProp (xmlNodePtr node, 894 const xmlChar *name, 895 const xmlChar *value); 896XMLPUBFUN xmlAttrPtr XMLCALL 897 xmlSetNsProp (xmlNodePtr node, 898 xmlNsPtr ns, 899 const xmlChar *name, 900 const xmlChar *value); 901#endif /* defined(LIBXML_TREE_ENABLED) || defined(LIBXML_XINCLUDE_ENABLED) || defined(LIBXML_SCHEMAS_ENABLED) || defined(LIBXML_HTML_ENABLED) */ 902XMLPUBFUN xmlChar * XMLCALL 903 xmlGetNoNsProp (xmlNodePtr node, 904 const xmlChar *name); 905XMLPUBFUN xmlChar * XMLCALL 906 xmlGetProp (xmlNodePtr node, 907 const xmlChar *name); 908XMLPUBFUN xmlAttrPtr XMLCALL 909 xmlHasProp (xmlNodePtr node, 910 const xmlChar *name); 911XMLPUBFUN xmlAttrPtr XMLCALL 912 xmlHasNsProp (xmlNodePtr node, 913 const xmlChar *name, 914 const xmlChar *nameSpace); 915XMLPUBFUN xmlChar * XMLCALL 916 xmlGetNsProp (xmlNodePtr node, 917 const xmlChar *name, 918 const xmlChar *nameSpace); 919XMLPUBFUN xmlNodePtr XMLCALL 920 xmlStringGetNodeList (xmlDocPtr doc, 921 const xmlChar *value); 922XMLPUBFUN xmlNodePtr XMLCALL 923 xmlStringLenGetNodeList (xmlDocPtr doc, 924 const xmlChar *value, 925 int len); 926XMLPUBFUN xmlChar * XMLCALL 927 xmlNodeListGetString (xmlDocPtr doc, 928 xmlNodePtr list, 929 int inLine); 930#ifdef LIBXML_TREE_ENABLED 931XMLPUBFUN xmlChar * XMLCALL 932 xmlNodeListGetRawString (xmlDocPtr doc, 933 xmlNodePtr list, 934 int inLine); 935#endif /* LIBXML_TREE_ENABLED */ 936XMLPUBFUN void XMLCALL 937 xmlNodeSetContent (xmlNodePtr cur, 938 const xmlChar *content); 939#ifdef LIBXML_TREE_ENABLED 940XMLPUBFUN void XMLCALL 941 xmlNodeSetContentLen (xmlNodePtr cur, 942 const xmlChar *content, 943 int len); 944#endif /* LIBXML_TREE_ENABLED */ 945XMLPUBFUN void XMLCALL 946 xmlNodeAddContent (xmlNodePtr cur, 947 const xmlChar *content); 948XMLPUBFUN void XMLCALL 949 xmlNodeAddContentLen (xmlNodePtr cur, 950 const xmlChar *content, 951 int len); 952XMLPUBFUN xmlChar * XMLCALL 953 xmlNodeGetContent (xmlNodePtr cur); 954XMLPUBFUN int XMLCALL 955 xmlNodeBufGetContent (xmlBufferPtr buffer, 956 xmlNodePtr cur); 957XMLPUBFUN xmlChar * XMLCALL 958 xmlNodeGetLang (xmlNodePtr cur); 959XMLPUBFUN int XMLCALL 960 xmlNodeGetSpacePreserve (xmlNodePtr cur); 961#ifdef LIBXML_TREE_ENABLED 962XMLPUBFUN void XMLCALL 963 xmlNodeSetLang (xmlNodePtr cur, 964 const xmlChar *lang); 965XMLPUBFUN void XMLCALL 966 xmlNodeSetSpacePreserve (xmlNodePtr cur, 967 int val); 968#endif /* LIBXML_TREE_ENABLED */ 969XMLPUBFUN xmlChar * XMLCALL 970 xmlNodeGetBase (xmlDocPtr doc, 971 xmlNodePtr cur); 972#if defined(LIBXML_TREE_ENABLED) || defined(LIBXML_XINCLUDE_ENABLED) 973XMLPUBFUN void XMLCALL 974 xmlNodeSetBase (xmlNodePtr cur, 975 const xmlChar *uri); 976#endif 977 978/* 979 * Removing content. 980 */ 981XMLPUBFUN int XMLCALL 982 xmlRemoveProp (xmlAttrPtr cur); 983#if defined(LIBXML_TREE_ENABLED) || defined(LIBXML_SCHEMAS_ENABLED) 984XMLPUBFUN int XMLCALL 985 xmlUnsetNsProp (xmlNodePtr node, 986 xmlNsPtr ns, 987 const xmlChar *name); 988XMLPUBFUN int XMLCALL 989 xmlUnsetProp (xmlNodePtr node, 990 const xmlChar *name); 991#endif /* defined(LIBXML_TREE_ENABLED) || defined(LIBXML_SCHEMAS_ENABLED) */ 992 993/* 994 * Internal, don't use. 995 */ 996XMLPUBFUN void XMLCALL 997 xmlBufferWriteCHAR (xmlBufferPtr buf, 998 const xmlChar *string); 999XMLPUBFUN void XMLCALL 1000 xmlBufferWriteChar (xmlBufferPtr buf, 1001 const char *string); 1002XMLPUBFUN void XMLCALL 1003 xmlBufferWriteQuotedString(xmlBufferPtr buf, 1004 const xmlChar *string); 1005 1006#ifdef LIBXML_OUTPUT_ENABLED 1007XMLPUBFUN void xmlAttrSerializeTxtContent(xmlBufferPtr buf, 1008 xmlDocPtr doc, 1009 xmlAttrPtr attr, 1010 const xmlChar *string); 1011#endif /* LIBXML_OUTPUT_ENABLED */ 1012 1013#ifdef LIBXML_TREE_ENABLED 1014/* 1015 * Namespace handling. 1016 */ 1017XMLPUBFUN int XMLCALL 1018 xmlReconciliateNs (xmlDocPtr doc, 1019 xmlNodePtr tree); 1020#endif 1021 1022#ifdef LIBXML_OUTPUT_ENABLED 1023/* 1024 * Saving. 1025 */ 1026XMLPUBFUN void XMLCALL 1027 xmlDocDumpFormatMemory (xmlDocPtr cur, 1028 xmlChar **mem, 1029 int *size, 1030 int format); 1031XMLPUBFUN void XMLCALL 1032 xmlDocDumpMemory (xmlDocPtr cur, 1033 xmlChar **mem, 1034 int *size); 1035XMLPUBFUN void XMLCALL 1036 xmlDocDumpMemoryEnc (xmlDocPtr out_doc, 1037 xmlChar **doc_txt_ptr, 1038 int * doc_txt_len, 1039 const char *txt_encoding); 1040XMLPUBFUN void XMLCALL 1041 xmlDocDumpFormatMemoryEnc(xmlDocPtr out_doc, 1042 xmlChar **doc_txt_ptr, 1043 int * doc_txt_len, 1044 const char *txt_encoding, 1045 int format); 1046XMLPUBFUN int XMLCALL 1047 xmlDocFormatDump (FILE *f, 1048 xmlDocPtr cur, 1049 int format); 1050XMLPUBFUN int XMLCALL 1051 xmlDocDump (FILE *f, 1052 xmlDocPtr cur); 1053XMLPUBFUN void XMLCALL 1054 xmlElemDump (FILE *f, 1055 xmlDocPtr doc, 1056 xmlNodePtr cur); 1057XMLPUBFUN int XMLCALL 1058 xmlSaveFile (const char *filename, 1059 xmlDocPtr cur); 1060XMLPUBFUN int XMLCALL 1061 xmlSaveFormatFile (const char *filename, 1062 xmlDocPtr cur, 1063 int format); 1064XMLPUBFUN int XMLCALL 1065 xmlNodeDump (xmlBufferPtr buf, 1066 xmlDocPtr doc, 1067 xmlNodePtr cur, 1068 int level, 1069 int format); 1070 1071XMLPUBFUN int XMLCALL 1072 xmlSaveFileTo (xmlOutputBufferPtr buf, 1073 xmlDocPtr cur, 1074 const char *encoding); 1075XMLPUBFUN int XMLCALL 1076 xmlSaveFormatFileTo (xmlOutputBufferPtr buf, 1077 xmlDocPtr cur, 1078 const char *encoding, 1079 int format); 1080XMLPUBFUN void XMLCALL 1081 xmlNodeDumpOutput (xmlOutputBufferPtr buf, 1082 xmlDocPtr doc, 1083 xmlNodePtr cur, 1084 int level, 1085 int format, 1086 const char *encoding); 1087 1088XMLPUBFUN int XMLCALL 1089 xmlSaveFormatFileEnc (const char *filename, 1090 xmlDocPtr cur, 1091 const char *encoding, 1092 int format); 1093 1094XMLPUBFUN int XMLCALL 1095 xmlSaveFileEnc (const char *filename, 1096 xmlDocPtr cur, 1097 const char *encoding); 1098 1099#endif /* LIBXML_OUTPUT_ENABLED */ 1100/* 1101 * XHTML 1102 */ 1103XMLPUBFUN int XMLCALL 1104 xmlIsXHTML (const xmlChar *systemID, 1105 const xmlChar *publicID); 1106 1107/* 1108 * Compression. 1109 */ 1110XMLPUBFUN int XMLCALL 1111 xmlGetDocCompressMode (xmlDocPtr doc); 1112XMLPUBFUN void XMLCALL 1113 xmlSetDocCompressMode (xmlDocPtr doc, 1114 int mode); 1115XMLPUBFUN int XMLCALL 1116 xmlGetCompressMode (void); 1117XMLPUBFUN void XMLCALL 1118 xmlSetCompressMode (int mode); 1119 1120/* 1121* DOM-wrapper helper functions. 1122*/ 1123XMLPUBFUN xmlDOMWrapCtxtPtr XMLCALL 1124 xmlDOMWrapNewCtxt (void); 1125XMLPUBFUN void XMLCALL 1126 xmlDOMWrapFreeCtxt (xmlDOMWrapCtxtPtr ctxt); 1127XMLPUBFUN int XMLCALL 1128 xmlDOMWrapReconcileNamespaces(xmlDOMWrapCtxtPtr ctxt, 1129 xmlNodePtr elem, 1130 int options); 1131XMLPUBFUN int XMLCALL 1132 xmlDOMWrapAdoptNode (xmlDOMWrapCtxtPtr ctxt, 1133 xmlDocPtr sourceDoc, 1134 xmlNodePtr node, 1135 xmlDocPtr destDoc, 1136 xmlNodePtr destParent, 1137 int options); 1138XMLPUBFUN int XMLCALL 1139 xmlDOMWrapRemoveNode (xmlDOMWrapCtxtPtr ctxt, 1140 xmlDocPtr doc, 1141 xmlNodePtr node, 1142 int options); 1143XMLPUBFUN int XMLCALL 1144 xmlDOMWrapCloneNode (xmlDOMWrapCtxtPtr ctxt, 1145 xmlDocPtr sourceDoc, 1146 xmlNodePtr node, 1147 xmlNodePtr *clonedNode, 1148 xmlDocPtr destDoc, 1149 xmlNodePtr destParent, 1150 int deep, 1151 int options); 1152 1153#ifdef __cplusplus 1154} 1155#endif 1156#ifndef __XML_PARSER_H__ 1157#include <libxml/xmlmemory.h> 1158#endif 1159 1160#endif /* __XML_TREE_H__ */ 1161 1162