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 char* dummy_children; /* lines up with node->children */ 355 const xmlChar *prefix; /* prefix for the namespace */ 356 void *_private; /* application data */ 357 struct _xmlDoc *context; /* normally an xmlDoc */ 358 }; 359 360 /** 361 * xmlDtd: 362 * 363 * An XML DTD, as defined by <!DOCTYPE ... There is actually one for 364 * the internal subset and for the external subset. 365 */ 366 typedef struct _xmlDtd xmlDtd; 367 typedef xmlDtd *xmlDtdPtr; 368 struct _xmlDtd { 369 void *_private; /* application data */ 370 xmlElementType type; /* XML_DTD_NODE, must be second ! */ 371 const xmlChar *name; /* Name of the DTD */ 372 struct _xmlNode *children; /* the value of the property link */ 373 struct _xmlNode *last; /* last child link */ 374 struct _xmlDoc *parent; /* child->parent link */ 375 struct _xmlNode *next; /* next sibling link */ 376 struct _xmlNode *prev; /* previous sibling link */ 377 struct _xmlDoc *doc; /* the containing document */ 378 379 /* End of common part */ 380 void *notations; /* Hash table for notations if any */ 381 void *elements; /* Hash table for elements if any */ 382 void *attributes; /* Hash table for attributes if any */ 383 void *entities; /* Hash table for entities if any */ 384 const xmlChar *ExternalID; /* External identifier for PUBLIC DTD */ 385 const xmlChar *SystemID; /* URI for a SYSTEM or PUBLIC DTD */ 386 void *pentities; /* Hash table for param entities if any */ 387 }; 388 389 /** 390 * xmlAttr: 391 * 392 * An attribute on an XML node. 393 */ 394 typedef struct _xmlAttr xmlAttr; 395 typedef xmlAttr *xmlAttrPtr; 396 struct _xmlAttr { 397 void *_private; /* application data */ 398 xmlElementType type; /* XML_ATTRIBUTE_NODE, must be second ! */ 399 const xmlChar *name; /* the name of the property */ 400 struct _xmlNode *children; /* the value of the property */ 401 struct _xmlNode *last; /* NULL */ 402 struct _xmlNode *parent; /* child->parent link */ 403 struct _xmlAttr *next; /* next sibling link */ 404 struct _xmlAttr *prev; /* previous sibling link */ 405 struct _xmlDoc *doc; /* the containing document */ 406 xmlNs *ns; /* pointer to the associated namespace */ 407 xmlAttributeType atype; /* the attribute type if validating */ 408 void *psvi; /* for type/PSVI informations */ 409 }; 410 411 /** 412 * xmlID: 413 * 414 * An XML ID instance. 415 */ 416 417 typedef struct _xmlID xmlID; 418 typedef xmlID *xmlIDPtr; 419 struct _xmlID { 420 struct _xmlID *next; /* next ID */ 421 const xmlChar *value; /* The ID name */ 422 xmlAttrPtr attr; /* The attribute holding it */ 423 const xmlChar *name; /* The attribute if attr is not available */ 424 int lineno; /* The line number if attr is not available */ 425 struct _xmlDoc *doc; /* The document holding the ID */ 426 }; 427 428 /** 429 * xmlRef: 430 * 431 * An XML IDREF instance. 432 */ 433 434 typedef struct _xmlRef xmlRef; 435 typedef xmlRef *xmlRefPtr; 436 struct _xmlRef { 437 struct _xmlRef *next; /* next Ref */ 438 const xmlChar *value; /* The Ref name */ 439 xmlAttrPtr attr; /* The attribute holding it */ 440 const xmlChar *name; /* The attribute if attr is not available */ 441 int lineno; /* The line number if attr is not available */ 442 }; 443 444 /** 445 * xmlNode: 446 * 447 * A node in an XML tree. 448 */ 449 typedef struct _xmlNode xmlNode; 450 typedef xmlNode *xmlNodePtr; 451 struct _xmlNode { 452 void *_private; /* application data */ 453 xmlElementType type; /* type number, must be second ! */ 454 const xmlChar *name; /* the name of the node, or the entity */ 455 struct _xmlNode *children; /* parent->childs link */ 456 struct _xmlNode *last; /* last child link */ 457 struct _xmlNode *parent; /* child->parent link */ 458 struct _xmlNode *next; /* next sibling link */ 459 struct _xmlNode *prev; /* previous sibling link */ 460 struct _xmlDoc *doc; /* the containing document */ 461 462 /* End of common part */ 463 xmlNs *ns; /* pointer to the associated namespace */ 464 xmlChar *content; /* the content */ 465 struct _xmlAttr *properties;/* properties list */ 466 xmlNs *nsDef; /* namespace definitions on this node */ 467 void *psvi; /* for type/PSVI informations */ 468 unsigned short line; /* line number */ 469 unsigned short extra; /* extra data for XPath/XSLT */ 470 }; 471 472 /** 473 * XML_GET_CONTENT: 474 * 475 * Macro to extract the content pointer of a node. 476 */ 477 #define XML_GET_CONTENT(n) \ 478 ((n)->type == XML_ELEMENT_NODE ? NULL : (n)->content) 479 480 /** 481 * XML_GET_LINE: 482 * 483 * Macro to extract the line number of an element node. 484 */ 485 #define XML_GET_LINE(n) \ 486 (xmlGetLineNo(n)) 487 488 /** 489 * xmlDocProperty 490 * 491 * Set of properties of the document as found by the parser 492 * Some of them are linked to similary named xmlParserOption 493 */ 494 typedef enum { 495 XML_DOC_WELLFORMED = 1<<0, /* document is XML well formed */ 496 XML_DOC_NSVALID = 1<<1, /* document is Namespace valid */ 497 XML_DOC_OLD10 = 1<<2, /* parsed with old XML-1.0 parser */ 498 XML_DOC_DTDVALID = 1<<3, /* DTD validation was successful */ 499 XML_DOC_XINCLUDE = 1<<4, /* XInclude substitution was done */ 500 XML_DOC_USERBUILT = 1<<5, /* Document was built using the API 501 and not by parsing an instance */ 502 XML_DOC_INTERNAL = 1<<6, /* built for internal processing */ 503 XML_DOC_HTML = 1<<7 /* parsed or built HTML document */ 504 } xmlDocProperties; 505 506 /** 507 * xmlDoc: 508 * 509 * An XML document. 510 */ 511 typedef struct _xmlDoc xmlDoc; 512 typedef xmlDoc *xmlDocPtr; 513 struct _xmlDoc { 514 void *_private; /* application data */ 515 xmlElementType type; /* XML_DOCUMENT_NODE, must be second ! */ 516 char *name; /* name/filename/URI of the document */ 517 struct _xmlNode *children; /* the document tree */ 518 struct _xmlNode *last; /* last child link */ 519 struct _xmlNode *parent; /* child->parent link */ 520 struct _xmlNode *next; /* next sibling link */ 521 struct _xmlNode *prev; /* previous sibling link */ 522 struct _xmlDoc *doc; /* autoreference to itself */ 523 524 /* End of common part */ 525 int compression;/* level of zlib compression */ 526 int standalone; /* standalone document (no external refs) 527 1 if standalone="yes" 528 0 if standalone="no" 529 -1 if there is no XML declaration 530 -2 if there is an XML declaration, but no 531 standalone attribute was specified */ 532 struct _xmlDtd *intSubset; /* the document internal subset */ 533 struct _xmlDtd *extSubset; /* the document external subset */ 534 struct _xmlNs *oldNs; /* Global namespace, the old way */ 535 const xmlChar *version; /* the XML version string */ 536 const xmlChar *encoding; /* external initial encoding, if any */ 537 void *ids; /* Hash table for ID attributes if any */ 538 void *refs; /* Hash table for IDREFs attributes if any */ 539 const xmlChar *URL; /* The URI for that document */ 540 int charset; /* encoding of the in-memory content 541 actually an xmlCharEncoding */ 542 struct _xmlDict *dict; /* dict used to allocate names or NULL */ 543 void *psvi; /* for type/PSVI informations */ 544 int parseFlags; /* set of xmlParserOption used to parse the 545 document */ 546 int properties; /* set of xmlDocProperties for this document 547 set at the end of parsing */ 548 }; 549 550 551 typedef struct _xmlDOMWrapCtxt xmlDOMWrapCtxt; 552 typedef xmlDOMWrapCtxt *xmlDOMWrapCtxtPtr; 553 554 /** 555 * xmlDOMWrapAcquireNsFunction: 556 * @ctxt: a DOM wrapper context 557 * @node: the context node (element or attribute) 558 * @nsName: the requested namespace name 559 * @nsPrefix: the requested namespace prefix 560 * 561 * A function called to acquire namespaces (xmlNs) from the wrapper. 562 * 563 * Returns an xmlNsPtr or NULL in case of an error. 564 */ 565 typedef xmlNsPtr (*xmlDOMWrapAcquireNsFunction) (xmlDOMWrapCtxtPtr ctxt, 566 xmlNodePtr node, 567 const xmlChar *nsName, 568 const xmlChar *nsPrefix); 569 570 /** 571 * xmlDOMWrapCtxt: 572 * 573 * Context for DOM wrapper-operations. 574 */ 575 struct _xmlDOMWrapCtxt { 576 void * _private; 577 /* 578 * The type of this context, just in case we need specialized 579 * contexts in the future. 580 */ 581 int type; 582 /* 583 * Internal namespace map used for various operations. 584 */ 585 void * namespaceMap; 586 /* 587 * Use this one to acquire an xmlNsPtr intended for node->ns. 588 * (Note that this is not intended for elem->nsDef). 589 */ 590 xmlDOMWrapAcquireNsFunction getNsForNodeFunc; 591 }; 592 593 /** 594 * xmlChildrenNode: 595 * 596 * Macro for compatibility naming layer with libxml1. Maps 597 * to "children." 598 */ 599 #ifndef xmlChildrenNode 600 #define xmlChildrenNode children 601 #endif 602 603 /** 604 * xmlRootNode: 605 * 606 * Macro for compatibility naming layer with libxml1. Maps 607 * to "children". 608 */ 609 #ifndef xmlRootNode 610 #define xmlRootNode children 611 #endif 612 613 /* 614 * Variables. 615 */ 616 617 /* 618 * Some helper functions 619 */ 620 #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) 621 XMLPUBFUN int XMLCALL 622 xmlValidateNCName (const xmlChar *value, 623 int space); 624 #endif 625 626 #if defined(LIBXML_TREE_ENABLED) || defined(LIBXML_SCHEMAS_ENABLED) 627 XMLPUBFUN int XMLCALL 628 xmlValidateQName (const xmlChar *value, 629 int space); 630 XMLPUBFUN int XMLCALL 631 xmlValidateName (const xmlChar *value, 632 int space); 633 XMLPUBFUN int XMLCALL 634 xmlValidateNMToken (const xmlChar *value, 635 int space); 636 #endif 637 638 XMLPUBFUN xmlChar * XMLCALL 639 xmlBuildQName (const xmlChar *ncname, 640 const xmlChar *prefix, 641 xmlChar *memory, 642 int len); 643 XMLPUBFUN xmlChar * XMLCALL 644 xmlSplitQName2 (const xmlChar *name, 645 xmlChar **prefix); 646 XMLPUBFUN const xmlChar * XMLCALL 647 xmlSplitQName3 (const xmlChar *name, 648 int *len); 649 650 /* 651 * Handling Buffers. 652 */ 653 654 XMLPUBFUN void XMLCALL 655 xmlSetBufferAllocationScheme(xmlBufferAllocationScheme scheme); 656 XMLPUBFUN xmlBufferAllocationScheme XMLCALL 657 xmlGetBufferAllocationScheme(void); 658 659 XMLPUBFUN xmlBufferPtr XMLCALL 660 xmlBufferCreate (void); 661 XMLPUBFUN xmlBufferPtr XMLCALL 662 xmlBufferCreateSize (size_t size); 663 XMLPUBFUN xmlBufferPtr XMLCALL 664 xmlBufferCreateStatic (void *mem, 665 size_t size); 666 XMLPUBFUN int XMLCALL 667 xmlBufferResize (xmlBufferPtr buf, 668 unsigned int size); 669 XMLPUBFUN void XMLCALL 670 xmlBufferFree (xmlBufferPtr buf); 671 XMLPUBFUN int XMLCALL 672 xmlBufferDump (FILE *file, 673 xmlBufferPtr buf); 674 XMLPUBFUN int XMLCALL 675 xmlBufferAdd (xmlBufferPtr buf, 676 const xmlChar *str, 677 int len); 678 XMLPUBFUN int XMLCALL 679 xmlBufferAddHead (xmlBufferPtr buf, 680 const xmlChar *str, 681 int len); 682 XMLPUBFUN int XMLCALL 683 xmlBufferCat (xmlBufferPtr buf, 684 const xmlChar *str); 685 XMLPUBFUN int XMLCALL 686 xmlBufferCCat (xmlBufferPtr buf, 687 const char *str); 688 XMLPUBFUN int XMLCALL 689 xmlBufferShrink (xmlBufferPtr buf, 690 unsigned int len); 691 XMLPUBFUN int XMLCALL 692 xmlBufferGrow (xmlBufferPtr buf, 693 unsigned int len); 694 XMLPUBFUN void XMLCALL 695 xmlBufferEmpty (xmlBufferPtr buf); 696 XMLPUBFUN const xmlChar* XMLCALL 697 xmlBufferContent (const xmlBufferPtr buf); 698 XMLPUBFUN void XMLCALL 699 xmlBufferSetAllocationScheme(xmlBufferPtr buf, 700 xmlBufferAllocationScheme scheme); 701 XMLPUBFUN int XMLCALL 702 xmlBufferLength (const xmlBufferPtr buf); 703 704 /* 705 * Creating/freeing new structures. 706 */ 707 XMLPUBFUN xmlDtdPtr XMLCALL 708 xmlCreateIntSubset (xmlDocPtr doc, 709 const xmlChar *name, 710 const xmlChar *ExternalID, 711 const xmlChar *SystemID); 712 XMLPUBFUN xmlDtdPtr XMLCALL 713 xmlNewDtd (xmlDocPtr doc, 714 const xmlChar *name, 715 const xmlChar *ExternalID, 716 const xmlChar *SystemID); 717 XMLPUBFUN xmlDtdPtr XMLCALL 718 xmlGetIntSubset (xmlDocPtr doc); 719 XMLPUBFUN void XMLCALL 720 xmlFreeDtd (xmlDtdPtr cur); 721 #ifdef LIBXML_LEGACY_ENABLED 722 XMLPUBFUN xmlNsPtr XMLCALL 723 xmlNewGlobalNs (xmlDocPtr doc, 724 const xmlChar *href, 725 const xmlChar *prefix); 726 #endif /* LIBXML_LEGACY_ENABLED */ 727 XMLPUBFUN xmlNsPtr XMLCALL 728 xmlNewNs (xmlNodePtr node, 729 const xmlChar *href, 730 const xmlChar *prefix); 731 XMLPUBFUN void XMLCALL 732 xmlFreeNs (xmlNsPtr cur); 733 XMLPUBFUN void XMLCALL 734 xmlFreeNsList (xmlNsPtr cur); 735 XMLPUBFUN xmlDocPtr XMLCALL 736 xmlNewDoc (const xmlChar *version); 737 XMLPUBFUN void XMLCALL 738 xmlFreeDoc (xmlDocPtr cur); 739 XMLPUBFUN xmlAttrPtr XMLCALL 740 xmlNewDocProp (xmlDocPtr doc, 741 const xmlChar *name, 742 const xmlChar *value); 743 #if defined(LIBXML_TREE_ENABLED) || defined(LIBXML_HTML_ENABLED) || \ 744 defined(LIBXML_SCHEMAS_ENABLED) 745 XMLPUBFUN xmlAttrPtr XMLCALL 746 xmlNewProp (xmlNodePtr node, 747 const xmlChar *name, 748 const xmlChar *value); 749 #endif 750 XMLPUBFUN xmlAttrPtr XMLCALL 751 xmlNewNsProp (xmlNodePtr node, 752 xmlNsPtr ns, 753 const xmlChar *name, 754 const xmlChar *value); 755 XMLPUBFUN xmlAttrPtr XMLCALL 756 xmlNewNsPropEatName (xmlNodePtr node, 757 xmlNsPtr ns, 758 xmlChar *name, 759 const xmlChar *value); 760 XMLPUBFUN void XMLCALL 761 xmlFreePropList (xmlAttrPtr cur); 762 XMLPUBFUN void XMLCALL 763 xmlFreeProp (xmlAttrPtr cur); 764 XMLPUBFUN xmlAttrPtr XMLCALL 765 xmlCopyProp (xmlNodePtr target, 766 xmlAttrPtr cur); 767 XMLPUBFUN xmlAttrPtr XMLCALL 768 xmlCopyPropList (xmlNodePtr target, 769 xmlAttrPtr cur); 770 #ifdef LIBXML_TREE_ENABLED 771 XMLPUBFUN xmlDtdPtr XMLCALL 772 xmlCopyDtd (xmlDtdPtr dtd); 773 #endif /* LIBXML_TREE_ENABLED */ 774 #if defined(LIBXML_TREE_ENABLED) || defined(LIBXML_SCHEMAS_ENABLED) 775 XMLPUBFUN xmlDocPtr XMLCALL 776 xmlCopyDoc (xmlDocPtr doc, 777 int recursive); 778 #endif /* defined(LIBXML_TREE_ENABLED) || defined(LIBXML_SCHEMAS_ENABLED) */ 779 /* 780 * Creating new nodes. 781 */ 782 XMLPUBFUN xmlNodePtr XMLCALL 783 xmlNewDocNode (xmlDocPtr doc, 784 xmlNsPtr ns, 785 const xmlChar *name, 786 const xmlChar *content); 787 XMLPUBFUN xmlNodePtr XMLCALL 788 xmlNewDocNodeEatName (xmlDocPtr doc, 789 xmlNsPtr ns, 790 xmlChar *name, 791 const xmlChar *content); 792 XMLPUBFUN xmlNodePtr XMLCALL 793 xmlNewNode (xmlNsPtr ns, 794 const xmlChar *name); 795 XMLPUBFUN xmlNodePtr XMLCALL 796 xmlNewNodeEatName (xmlNsPtr ns, 797 xmlChar *name); 798 #if defined(LIBXML_TREE_ENABLED) || defined(LIBXML_SCHEMAS_ENABLED) 799 XMLPUBFUN xmlNodePtr XMLCALL 800 xmlNewChild (xmlNodePtr parent, 801 xmlNsPtr ns, 802 const xmlChar *name, 803 const xmlChar *content); 804 #endif 805 XMLPUBFUN xmlNodePtr XMLCALL 806 xmlNewDocText (xmlDocPtr doc, 807 const xmlChar *content); 808 XMLPUBFUN xmlNodePtr XMLCALL 809 xmlNewText (const xmlChar *content); 810 XMLPUBFUN xmlNodePtr XMLCALL 811 xmlNewDocPI (xmlDocPtr doc, 812 const xmlChar *name, 813 const xmlChar *content); 814 XMLPUBFUN xmlNodePtr XMLCALL 815 xmlNewPI (const xmlChar *name, 816 const xmlChar *content); 817 XMLPUBFUN xmlNodePtr XMLCALL 818 xmlNewDocTextLen (xmlDocPtr doc, 819 const xmlChar *content, 820 int len); 821 XMLPUBFUN xmlNodePtr XMLCALL 822 xmlNewTextLen (const xmlChar *content, 823 int len); 824 XMLPUBFUN xmlNodePtr XMLCALL 825 xmlNewDocComment (xmlDocPtr doc, 826 const xmlChar *content); 827 XMLPUBFUN xmlNodePtr XMLCALL 828 xmlNewComment (const xmlChar *content); 829 XMLPUBFUN xmlNodePtr XMLCALL 830 xmlNewCDataBlock (xmlDocPtr doc, 831 const xmlChar *content, 832 int len); 833 XMLPUBFUN xmlNodePtr XMLCALL 834 xmlNewCharRef (xmlDocPtr doc, 835 const xmlChar *name); 836 XMLPUBFUN xmlNodePtr XMLCALL 837 xmlNewReference (xmlDocPtr doc, 838 const xmlChar *name); 839 XMLPUBFUN xmlNodePtr XMLCALL 840 xmlCopyNode (const xmlNodePtr node, 841 int recursive); 842 XMLPUBFUN xmlNodePtr XMLCALL 843 xmlDocCopyNode (const xmlNodePtr node, 844 xmlDocPtr doc, 845 int recursive); 846 XMLPUBFUN xmlNodePtr XMLCALL 847 xmlDocCopyNodeList (xmlDocPtr doc, 848 const xmlNodePtr node); 849 XMLPUBFUN xmlNodePtr XMLCALL 850 xmlCopyNodeList (const xmlNodePtr node); 851 #ifdef LIBXML_TREE_ENABLED 852 XMLPUBFUN xmlNodePtr XMLCALL 853 xmlNewTextChild (xmlNodePtr parent, 854 xmlNsPtr ns, 855 const xmlChar *name, 856 const xmlChar *content); 857 XMLPUBFUN xmlNodePtr XMLCALL 858 xmlNewDocRawNode (xmlDocPtr doc, 859 xmlNsPtr ns, 860 const xmlChar *name, 861 const xmlChar *content); 862 XMLPUBFUN xmlNodePtr XMLCALL 863 xmlNewDocFragment (xmlDocPtr doc); 864 #endif /* LIBXML_TREE_ENABLED */ 865 866 /* 867 * Navigating. 868 */ 869 XMLPUBFUN long XMLCALL 870 xmlGetLineNo (xmlNodePtr node); 871 #if defined(LIBXML_TREE_ENABLED) || defined(LIBXML_DEBUG_ENABLED) 872 XMLPUBFUN xmlChar * XMLCALL 873 xmlGetNodePath (xmlNodePtr node); 874 #endif /* defined(LIBXML_TREE_ENABLED) || defined(LIBXML_DEBUG_ENABLED) */ 875 XMLPUBFUN xmlNodePtr XMLCALL 876 xmlDocGetRootElement (xmlDocPtr doc); 877 XMLPUBFUN xmlNodePtr XMLCALL 878 xmlGetLastChild (xmlNodePtr parent); 879 XMLPUBFUN int XMLCALL 880 xmlNodeIsText (xmlNodePtr node); 881 XMLPUBFUN int XMLCALL 882 xmlIsBlankNode (xmlNodePtr node); 883 884 /* 885 * Changing the structure. 886 */ 887 #if defined(LIBXML_TREE_ENABLED) || defined(LIBXML_WRITER_ENABLED) 888 XMLPUBFUN xmlNodePtr XMLCALL 889 xmlDocSetRootElement (xmlDocPtr doc, 890 xmlNodePtr root); 891 #endif /* defined(LIBXML_TREE_ENABLED) || defined(LIBXML_WRITER_ENABLED) */ 892 #ifdef LIBXML_TREE_ENABLED 893 XMLPUBFUN void XMLCALL 894 xmlNodeSetName (xmlNodePtr cur, 895 const xmlChar *name); 896 #endif /* LIBXML_TREE_ENABLED */ 897 XMLPUBFUN xmlNodePtr XMLCALL 898 xmlAddChild (xmlNodePtr parent, 899 xmlNodePtr cur); 900 XMLPUBFUN xmlNodePtr XMLCALL 901 xmlAddChildList (xmlNodePtr parent, 902 xmlNodePtr cur); 903 #if defined(LIBXML_TREE_ENABLED) || defined(LIBXML_WRITER_ENABLED) 904 XMLPUBFUN xmlNodePtr XMLCALL 905 xmlReplaceNode (xmlNodePtr old, 906 xmlNodePtr cur); 907 #endif /* defined(LIBXML_TREE_ENABLED) || defined(LIBXML_WRITER_ENABLED) */ 908 #if defined(LIBXML_TREE_ENABLED) || defined(LIBXML_HTML_ENABLED) || \ 909 defined(LIBXML_SCHEMAS_ENABLED) 910 XMLPUBFUN xmlNodePtr XMLCALL 911 xmlAddPrevSibling (xmlNodePtr cur, 912 xmlNodePtr elem); 913 #endif /* LIBXML_TREE_ENABLED || LIBXML_HTML_ENABLED || LIBXML_SCHEMAS_ENABLED */ 914 XMLPUBFUN xmlNodePtr XMLCALL 915 xmlAddSibling (xmlNodePtr cur, 916 xmlNodePtr elem); 917 XMLPUBFUN xmlNodePtr XMLCALL 918 xmlAddNextSibling (xmlNodePtr cur, 919 xmlNodePtr elem); 920 XMLPUBFUN void XMLCALL 921 xmlUnlinkNode (xmlNodePtr cur); 922 XMLPUBFUN xmlNodePtr XMLCALL 923 xmlTextMerge (xmlNodePtr first, 924 xmlNodePtr second); 925 XMLPUBFUN int XMLCALL 926 xmlTextConcat (xmlNodePtr node, 927 const xmlChar *content, 928 int len); 929 XMLPUBFUN void XMLCALL 930 xmlFreeNodeList (xmlNodePtr cur); 931 XMLPUBFUN void XMLCALL 932 xmlFreeNode (xmlNodePtr cur); 933 XMLPUBFUN void XMLCALL 934 xmlSetTreeDoc (xmlNodePtr tree, 935 xmlDocPtr doc); 936 XMLPUBFUN void XMLCALL 937 xmlSetListDoc (xmlNodePtr list, 938 xmlDocPtr doc); 939 /* 940 * Namespaces. 941 */ 942 XMLPUBFUN xmlNsPtr XMLCALL 943 xmlSearchNs (xmlDocPtr doc, 944 xmlNodePtr node, 945 const xmlChar *nameSpace); 946 XMLPUBFUN xmlNsPtr XMLCALL 947 xmlSearchNsByHref (xmlDocPtr doc, 948 xmlNodePtr node, 949 const xmlChar *href); 950 #if defined(LIBXML_TREE_ENABLED) || defined(LIBXML_XPATH_ENABLED) || defined(LIBXML_SCHEMAS_ENABLED) 951 XMLPUBFUN xmlNsPtr * XMLCALL 952 xmlGetNsList (xmlDocPtr doc, 953 xmlNodePtr node); 954 #endif /* defined(LIBXML_TREE_ENABLED) || defined(LIBXML_XPATH_ENABLED) */ 955 956 XMLPUBFUN void XMLCALL 957 xmlSetNs (xmlNodePtr node, 958 xmlNsPtr ns); 959 XMLPUBFUN xmlNsPtr XMLCALL 960 xmlCopyNamespace (xmlNsPtr cur); 961 XMLPUBFUN xmlNsPtr XMLCALL 962 xmlCopyNamespaceList (xmlNsPtr cur); 963 964 /* 965 * Changing the content. 966 */ 967 #if defined(LIBXML_TREE_ENABLED) || defined(LIBXML_XINCLUDE_ENABLED) || defined(LIBXML_SCHEMAS_ENABLED) || defined(LIBXML_HTML_ENABLED) 968 XMLPUBFUN xmlAttrPtr XMLCALL 969 xmlSetProp (xmlNodePtr node, 970 const xmlChar *name, 971 const xmlChar *value); 972 XMLPUBFUN xmlAttrPtr XMLCALL 973 xmlSetNsProp (xmlNodePtr node, 974 xmlNsPtr ns, 975 const xmlChar *name, 976 const xmlChar *value); 977 #endif /* defined(LIBXML_TREE_ENABLED) || defined(LIBXML_XINCLUDE_ENABLED) || defined(LIBXML_SCHEMAS_ENABLED) || defined(LIBXML_HTML_ENABLED) */ 978 XMLPUBFUN xmlChar * XMLCALL 979 xmlGetNoNsProp (xmlNodePtr node, 980 const xmlChar *name); 981 XMLPUBFUN xmlChar * XMLCALL 982 xmlGetProp (xmlNodePtr node, 983 const xmlChar *name); 984 XMLPUBFUN xmlAttrPtr XMLCALL 985 xmlHasProp (xmlNodePtr node, 986 const xmlChar *name); 987 XMLPUBFUN xmlAttrPtr XMLCALL 988 xmlHasNsProp (xmlNodePtr node, 989 const xmlChar *name, 990 const xmlChar *nameSpace); 991 XMLPUBFUN xmlChar * XMLCALL 992 xmlGetNsProp (xmlNodePtr node, 993 const xmlChar *name, 994 const xmlChar *nameSpace); 995 XMLPUBFUN xmlNodePtr XMLCALL 996 xmlStringGetNodeList (xmlDocPtr doc, 997 const xmlChar *value); 998 XMLPUBFUN xmlNodePtr XMLCALL 999 xmlStringLenGetNodeList (xmlDocPtr doc, 1000 const xmlChar *value, 1001 int len); 1002 XMLPUBFUN xmlChar * XMLCALL 1003 xmlNodeListGetString (xmlDocPtr doc, 1004 xmlNodePtr list, 1005 int inLine); 1006 #ifdef LIBXML_TREE_ENABLED 1007 XMLPUBFUN xmlChar * XMLCALL 1008 xmlNodeListGetRawString (xmlDocPtr doc, 1009 xmlNodePtr list, 1010 int inLine); 1011 #endif /* LIBXML_TREE_ENABLED */ 1012 XMLPUBFUN void XMLCALL 1013 xmlNodeSetContent (xmlNodePtr cur, 1014 const xmlChar *content); 1015 #ifdef LIBXML_TREE_ENABLED 1016 XMLPUBFUN void XMLCALL 1017 xmlNodeSetContentLen (xmlNodePtr cur, 1018 const xmlChar *content, 1019 int len); 1020 #endif /* LIBXML_TREE_ENABLED */ 1021 XMLPUBFUN void XMLCALL 1022 xmlNodeAddContent (xmlNodePtr cur, 1023 const xmlChar *content); 1024 XMLPUBFUN void XMLCALL 1025 xmlNodeAddContentLen (xmlNodePtr cur, 1026 const xmlChar *content, 1027 int len); 1028 XMLPUBFUN xmlChar * XMLCALL 1029 xmlNodeGetContent (xmlNodePtr cur); 1030 XMLPUBFUN int XMLCALL 1031 xmlNodeBufGetContent (xmlBufferPtr buffer, 1032 xmlNodePtr cur); 1033 XMLPUBFUN xmlChar * XMLCALL 1034 xmlNodeGetLang (xmlNodePtr cur); 1035 XMLPUBFUN int XMLCALL 1036 xmlNodeGetSpacePreserve (xmlNodePtr cur); 1037 #ifdef LIBXML_TREE_ENABLED 1038 XMLPUBFUN void XMLCALL 1039 xmlNodeSetLang (xmlNodePtr cur, 1040 const xmlChar *lang); 1041 XMLPUBFUN void XMLCALL 1042 xmlNodeSetSpacePreserve (xmlNodePtr cur, 1043 int val); 1044 #endif /* LIBXML_TREE_ENABLED */ 1045 XMLPUBFUN xmlChar * XMLCALL 1046 xmlNodeGetBase (xmlDocPtr doc, 1047 xmlNodePtr cur); 1048 #if defined(LIBXML_TREE_ENABLED) || defined(LIBXML_XINCLUDE_ENABLED) 1049 XMLPUBFUN void XMLCALL 1050 xmlNodeSetBase (xmlNodePtr cur, 1051 const xmlChar *uri); 1052 #endif 1053 1054 /* 1055 * Removing content. 1056 */ 1057 XMLPUBFUN int XMLCALL 1058 xmlRemoveProp (xmlAttrPtr cur); 1059 #if defined(LIBXML_TREE_ENABLED) || defined(LIBXML_SCHEMAS_ENABLED) 1060 XMLPUBFUN int XMLCALL 1061 xmlUnsetNsProp (xmlNodePtr node, 1062 xmlNsPtr ns, 1063 const xmlChar *name); 1064 XMLPUBFUN int XMLCALL 1065 xmlUnsetProp (xmlNodePtr node, 1066 const xmlChar *name); 1067 #endif /* defined(LIBXML_TREE_ENABLED) || defined(LIBXML_SCHEMAS_ENABLED) */ 1068 1069 /* 1070 * Internal, don't use. 1071 */ 1072 XMLPUBFUN void XMLCALL 1073 xmlBufferWriteCHAR (xmlBufferPtr buf, 1074 const xmlChar *string); 1075 XMLPUBFUN void XMLCALL 1076 xmlBufferWriteChar (xmlBufferPtr buf, 1077 const char *string); 1078 XMLPUBFUN void XMLCALL 1079 xmlBufferWriteQuotedString(xmlBufferPtr buf, 1080 const xmlChar *string); 1081 1082 #ifdef LIBXML_OUTPUT_ENABLED 1083 XMLPUBFUN void xmlAttrSerializeTxtContent(xmlBufferPtr buf, 1084 xmlDocPtr doc, 1085 xmlAttrPtr attr, 1086 const xmlChar *string); 1087 #endif /* LIBXML_OUTPUT_ENABLED */ 1088 1089 #ifdef LIBXML_TREE_ENABLED 1090 /* 1091 * Namespace handling. 1092 */ 1093 XMLPUBFUN int XMLCALL 1094 xmlReconciliateNs (xmlDocPtr doc, 1095 xmlNodePtr tree); 1096 #endif 1097 1098 #ifdef LIBXML_OUTPUT_ENABLED 1099 /* 1100 * Saving. 1101 */ 1102 XMLPUBFUN void XMLCALL 1103 xmlDocDumpFormatMemory (xmlDocPtr cur, 1104 xmlChar **mem, 1105 int *size, 1106 int format); 1107 XMLPUBFUN void XMLCALL 1108 xmlDocDumpMemory (xmlDocPtr cur, 1109 xmlChar **mem, 1110 int *size); 1111 XMLPUBFUN void XMLCALL 1112 xmlDocDumpMemoryEnc (xmlDocPtr out_doc, 1113 xmlChar **doc_txt_ptr, 1114 int * doc_txt_len, 1115 const char *txt_encoding); 1116 XMLPUBFUN void XMLCALL 1117 xmlDocDumpFormatMemoryEnc(xmlDocPtr out_doc, 1118 xmlChar **doc_txt_ptr, 1119 int * doc_txt_len, 1120 const char *txt_encoding, 1121 int format); 1122 XMLPUBFUN int XMLCALL 1123 xmlDocFormatDump (FILE *f, 1124 xmlDocPtr cur, 1125 int format); 1126 XMLPUBFUN int XMLCALL 1127 xmlDocDump (FILE *f, 1128 xmlDocPtr cur); 1129 XMLPUBFUN void XMLCALL 1130 xmlElemDump (FILE *f, 1131 xmlDocPtr doc, 1132 xmlNodePtr cur); 1133 XMLPUBFUN int XMLCALL 1134 xmlSaveFile (const char *filename, 1135 xmlDocPtr cur); 1136 XMLPUBFUN int XMLCALL 1137 xmlSaveFormatFile (const char *filename, 1138 xmlDocPtr cur, 1139 int format); 1140 XMLPUBFUN int XMLCALL 1141 xmlNodeDump (xmlBufferPtr buf, 1142 xmlDocPtr doc, 1143 xmlNodePtr cur, 1144 int level, 1145 int format); 1146 1147 XMLPUBFUN int XMLCALL 1148 xmlSaveFileTo (xmlOutputBufferPtr buf, 1149 xmlDocPtr cur, 1150 const char *encoding); 1151 XMLPUBFUN int XMLCALL 1152 xmlSaveFormatFileTo (xmlOutputBufferPtr buf, 1153 xmlDocPtr cur, 1154 const char *encoding, 1155 int format); 1156 XMLPUBFUN void XMLCALL 1157 xmlNodeDumpOutput (xmlOutputBufferPtr buf, 1158 xmlDocPtr doc, 1159 xmlNodePtr cur, 1160 int level, 1161 int format, 1162 const char *encoding); 1163 1164 XMLPUBFUN int XMLCALL 1165 xmlSaveFormatFileEnc (const char *filename, 1166 xmlDocPtr cur, 1167 const char *encoding, 1168 int format); 1169 1170 XMLPUBFUN int XMLCALL 1171 xmlSaveFileEnc (const char *filename, 1172 xmlDocPtr cur, 1173 const char *encoding); 1174 1175 #endif /* LIBXML_OUTPUT_ENABLED */ 1176 /* 1177 * XHTML 1178 */ 1179 XMLPUBFUN int XMLCALL 1180 xmlIsXHTML (const xmlChar *systemID, 1181 const xmlChar *publicID); 1182 1183 /* 1184 * Compression. 1185 */ 1186 XMLPUBFUN int XMLCALL 1187 xmlGetDocCompressMode (xmlDocPtr doc); 1188 XMLPUBFUN void XMLCALL 1189 xmlSetDocCompressMode (xmlDocPtr doc, 1190 int mode); 1191 XMLPUBFUN int XMLCALL 1192 xmlGetCompressMode (void); 1193 XMLPUBFUN void XMLCALL 1194 xmlSetCompressMode (int mode); 1195 1196 /* 1197 * DOM-wrapper helper functions. 1198 */ 1199 XMLPUBFUN xmlDOMWrapCtxtPtr XMLCALL 1200 xmlDOMWrapNewCtxt (void); 1201 XMLPUBFUN void XMLCALL 1202 xmlDOMWrapFreeCtxt (xmlDOMWrapCtxtPtr ctxt); 1203 XMLPUBFUN int XMLCALL 1204 xmlDOMWrapReconcileNamespaces(xmlDOMWrapCtxtPtr ctxt, 1205 xmlNodePtr elem, 1206 int options); 1207 XMLPUBFUN int XMLCALL 1208 xmlDOMWrapAdoptNode (xmlDOMWrapCtxtPtr ctxt, 1209 xmlDocPtr sourceDoc, 1210 xmlNodePtr node, 1211 xmlDocPtr destDoc, 1212 xmlNodePtr destParent, 1213 int options); 1214 XMLPUBFUN int XMLCALL 1215 xmlDOMWrapRemoveNode (xmlDOMWrapCtxtPtr ctxt, 1216 xmlDocPtr doc, 1217 xmlNodePtr node, 1218 int options); 1219 XMLPUBFUN int XMLCALL 1220 xmlDOMWrapCloneNode (xmlDOMWrapCtxtPtr ctxt, 1221 xmlDocPtr sourceDoc, 1222 xmlNodePtr node, 1223 xmlNodePtr *clonedNode, 1224 xmlDocPtr destDoc, 1225 xmlNodePtr destParent, 1226 int deep, 1227 int options); 1228 1229 #ifdef LIBXML_TREE_ENABLED 1230 /* 1231 * 5 interfaces from DOM ElementTraversal, but different in entities 1232 * traversal. 1233 */ 1234 XMLPUBFUN unsigned long XMLCALL 1235 xmlChildElementCount (xmlNodePtr parent); 1236 XMLPUBFUN xmlNodePtr XMLCALL 1237 xmlNextElementSibling (xmlNodePtr node); 1238 XMLPUBFUN xmlNodePtr XMLCALL 1239 xmlFirstElementChild (xmlNodePtr parent); 1240 XMLPUBFUN xmlNodePtr XMLCALL 1241 xmlLastElementChild (xmlNodePtr parent); 1242 XMLPUBFUN xmlNodePtr XMLCALL 1243 xmlPreviousElementSibling (xmlNodePtr node); 1244 #endif 1245 #ifdef __cplusplus 1246 } 1247 #endif 1248 #ifndef __XML_PARSER_H__ 1249 #include <libxml/xmlmemory.h> 1250 #endif 1251 1252 #endif /* __XML_TREE_H__ */ 1253 1254