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