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