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