1/* 2 * Summary: interfaces for tree manipulation 3 * Description: this module describes the structures found in an tree resulting 4 * from an XML or HTML parsing, as well as the API provided for 5 * various processing on that tree 6 * 7 * Copy: See Copyright for the status of this software. 8 * 9 * Author: Daniel Veillard 10 */ 11 12#ifndef __XML_TREE_H__ 13#define __XML_TREE_H__ 14 15#include <stdio.h> 16#include <libxml/xmlversion.h> 17#include <libxml/xmlstring.h> 18 19#ifdef __cplusplus 20extern "C" { 21#endif 22 23/* 24 * Some of the basic types pointer to structures: 25 */ 26/* xmlIO.h */ 27typedef struct _xmlParserInputBuffer xmlParserInputBuffer; 28typedef xmlParserInputBuffer *xmlParserInputBufferPtr; 29 30typedef struct _xmlOutputBuffer xmlOutputBuffer; 31typedef xmlOutputBuffer *xmlOutputBufferPtr; 32 33/* parser.h */ 34typedef struct _xmlParserInput xmlParserInput; 35typedef xmlParserInput *xmlParserInputPtr; 36 37typedef struct _xmlParserCtxt xmlParserCtxt; 38typedef xmlParserCtxt *xmlParserCtxtPtr; 39 40typedef struct _xmlSAXLocator xmlSAXLocator; 41typedef xmlSAXLocator *xmlSAXLocatorPtr; 42 43typedef struct _xmlSAXHandler xmlSAXHandler; 44typedef xmlSAXHandler *xmlSAXHandlerPtr; 45 46/* entities.h */ 47typedef struct _xmlEntity xmlEntity; 48typedef xmlEntity *xmlEntityPtr; 49 50/** 51 * BASE_BUFFER_SIZE: 52 * 53 * default buffer size 4000. 54 */ 55#define BASE_BUFFER_SIZE 4096 56 57/** 58 * 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 73typedef 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 */ 85typedef struct _xmlBuffer xmlBuffer; 86typedef xmlBuffer *xmlBufferPtr; 87struct _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 */ 120typedef 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 153typedef struct _xmlNotation xmlNotation; 154typedef xmlNotation *xmlNotationPtr; 155struct _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 167typedef 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 186typedef 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 199typedef struct _xmlEnumeration xmlEnumeration; 200typedef xmlEnumeration *xmlEnumerationPtr; 201struct _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 212typedef struct _xmlAttribute xmlAttribute; 213typedef xmlAttribute *xmlAttributePtr; 214struct _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 */ 239typedef 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 */ 251typedef 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 265typedef struct _xmlElementContent xmlElementContent; 266typedef xmlElementContent *xmlElementContentPtr; 267struct _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 283typedef 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 296extern "C" { 297#endif 298 299/** 300 * xmlElement: 301 * 302 * An XML Element declaration from a DTD. 303 */ 304 305typedef struct _xmlElement xmlElement; 306typedef xmlElement *xmlElementPtr; 307struct _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 336typedef 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 348typedef struct _xmlNs xmlNs; 349typedef xmlNs *xmlNsPtr; 350struct _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 */ 366typedef struct _xmlDtd xmlDtd; 367typedef xmlDtd *xmlDtdPtr; 368struct _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 */ 394typedef struct _xmlAttr xmlAttr; 395typedef xmlAttr *xmlAttrPtr; 396struct _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 417typedef struct _xmlID xmlID; 418typedef xmlID *xmlIDPtr; 419struct _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 434typedef struct _xmlRef xmlRef; 435typedef xmlRef *xmlRefPtr; 436struct _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 */ 449typedef struct _xmlNode xmlNode; 450typedef xmlNode *xmlNodePtr; 451struct _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 */ 494typedef 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 */ 511typedef struct _xmlDoc xmlDoc; 512typedef xmlDoc *xmlDocPtr; 513struct _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 551typedef struct _xmlDOMWrapCtxt xmlDOMWrapCtxt; 552typedef 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 */ 565typedef 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 */ 575struct _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) 621XMLPUBFUN int XMLCALL 622 xmlValidateNCName (const xmlChar *value, 623 int space); 624#endif 625 626#if defined(LIBXML_TREE_ENABLED) || defined(LIBXML_SCHEMAS_ENABLED) 627XMLPUBFUN int XMLCALL 628 xmlValidateQName (const xmlChar *value, 629 int space); 630XMLPUBFUN int XMLCALL 631 xmlValidateName (const xmlChar *value, 632 int space); 633XMLPUBFUN int XMLCALL 634 xmlValidateNMToken (const xmlChar *value, 635 int space); 636#endif 637 638XMLPUBFUN xmlChar * XMLCALL 639 xmlBuildQName (const xmlChar *ncname, 640 const xmlChar *prefix, 641 xmlChar *memory, 642 int len); 643XMLPUBFUN xmlChar * XMLCALL 644 xmlSplitQName2 (const xmlChar *name, 645 xmlChar **prefix); 646XMLPUBFUN const xmlChar * XMLCALL 647 xmlSplitQName3 (const xmlChar *name, 648 int *len); 649 650/* 651 * Handling Buffers. 652 */ 653 654XMLPUBFUN void XMLCALL 655 xmlSetBufferAllocationScheme(xmlBufferAllocationScheme scheme); 656XMLPUBFUN xmlBufferAllocationScheme XMLCALL 657 xmlGetBufferAllocationScheme(void); 658 659XMLPUBFUN xmlBufferPtr XMLCALL 660 xmlBufferCreate (void); 661XMLPUBFUN xmlBufferPtr XMLCALL 662 xmlBufferCreateSize (size_t size); 663XMLPUBFUN xmlBufferPtr XMLCALL 664 xmlBufferCreateStatic (void *mem, 665 size_t size); 666XMLPUBFUN int XMLCALL 667 xmlBufferResize (xmlBufferPtr buf, 668 unsigned int size); 669XMLPUBFUN void XMLCALL 670 xmlBufferFree (xmlBufferPtr buf); 671XMLPUBFUN int XMLCALL 672 xmlBufferDump (FILE *file, 673 xmlBufferPtr buf); 674XMLPUBFUN int XMLCALL 675 xmlBufferAdd (xmlBufferPtr buf, 676 const xmlChar *str, 677 int len); 678XMLPUBFUN int XMLCALL 679 xmlBufferAddHead (xmlBufferPtr buf, 680 const xmlChar *str, 681 int len); 682XMLPUBFUN int XMLCALL 683 xmlBufferCat (xmlBufferPtr buf, 684 const xmlChar *str); 685XMLPUBFUN int XMLCALL 686 xmlBufferCCat (xmlBufferPtr buf, 687 const char *str); 688XMLPUBFUN int XMLCALL 689 xmlBufferShrink (xmlBufferPtr buf, 690 unsigned int len); 691XMLPUBFUN int XMLCALL 692 xmlBufferGrow (xmlBufferPtr buf, 693 unsigned int len); 694XMLPUBFUN void XMLCALL 695 xmlBufferEmpty (xmlBufferPtr buf); 696XMLPUBFUN const xmlChar* XMLCALL 697 xmlBufferContent (const xmlBufferPtr buf); 698XMLPUBFUN void XMLCALL 699 xmlBufferSetAllocationScheme(xmlBufferPtr buf, 700 xmlBufferAllocationScheme scheme); 701XMLPUBFUN int XMLCALL 702 xmlBufferLength (const xmlBufferPtr buf); 703 704/* 705 * Creating/freeing new structures. 706 */ 707XMLPUBFUN xmlDtdPtr XMLCALL 708 xmlCreateIntSubset (xmlDocPtr doc, 709 const xmlChar *name, 710 const xmlChar *ExternalID, 711 const xmlChar *SystemID); 712XMLPUBFUN xmlDtdPtr XMLCALL 713 xmlNewDtd (xmlDocPtr doc, 714 const xmlChar *name, 715 const xmlChar *ExternalID, 716 const xmlChar *SystemID); 717XMLPUBFUN xmlDtdPtr XMLCALL 718 xmlGetIntSubset (xmlDocPtr doc); 719XMLPUBFUN void XMLCALL 720 xmlFreeDtd (xmlDtdPtr cur); 721#ifdef LIBXML_LEGACY_ENABLED 722XMLPUBFUN xmlNsPtr XMLCALL 723 xmlNewGlobalNs (xmlDocPtr doc, 724 const xmlChar *href, 725 const xmlChar *prefix); 726#endif /* LIBXML_LEGACY_ENABLED */ 727XMLPUBFUN xmlNsPtr XMLCALL 728 xmlNewNs (xmlNodePtr node, 729 const xmlChar *href, 730 const xmlChar *prefix); 731XMLPUBFUN void XMLCALL 732 xmlFreeNs (xmlNsPtr cur); 733XMLPUBFUN void XMLCALL 734 xmlFreeNsList (xmlNsPtr cur); 735XMLPUBFUN xmlDocPtr XMLCALL 736 xmlNewDoc (const xmlChar *version); 737XMLPUBFUN void XMLCALL 738 xmlFreeDoc (xmlDocPtr cur); 739XMLPUBFUN 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) 745XMLPUBFUN xmlAttrPtr XMLCALL 746 xmlNewProp (xmlNodePtr node, 747 const xmlChar *name, 748 const xmlChar *value); 749#endif 750XMLPUBFUN xmlAttrPtr XMLCALL 751 xmlNewNsProp (xmlNodePtr node, 752 xmlNsPtr ns, 753 const xmlChar *name, 754 const xmlChar *value); 755XMLPUBFUN xmlAttrPtr XMLCALL 756 xmlNewNsPropEatName (xmlNodePtr node, 757 xmlNsPtr ns, 758 xmlChar *name, 759 const xmlChar *value); 760XMLPUBFUN void XMLCALL 761 xmlFreePropList (xmlAttrPtr cur); 762XMLPUBFUN void XMLCALL 763 xmlFreeProp (xmlAttrPtr cur); 764XMLPUBFUN xmlAttrPtr XMLCALL 765 xmlCopyProp (xmlNodePtr target, 766 xmlAttrPtr cur); 767XMLPUBFUN xmlAttrPtr XMLCALL 768 xmlCopyPropList (xmlNodePtr target, 769 xmlAttrPtr cur); 770#ifdef LIBXML_TREE_ENABLED 771XMLPUBFUN xmlDtdPtr XMLCALL 772 xmlCopyDtd (xmlDtdPtr dtd); 773#endif /* LIBXML_TREE_ENABLED */ 774#if defined(LIBXML_TREE_ENABLED) || defined(LIBXML_SCHEMAS_ENABLED) 775XMLPUBFUN 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 */ 782XMLPUBFUN xmlNodePtr XMLCALL 783 xmlNewDocNode (xmlDocPtr doc, 784 xmlNsPtr ns, 785 const xmlChar *name, 786 const xmlChar *content); 787XMLPUBFUN xmlNodePtr XMLCALL 788 xmlNewDocNodeEatName (xmlDocPtr doc, 789 xmlNsPtr ns, 790 xmlChar *name, 791 const xmlChar *content); 792XMLPUBFUN xmlNodePtr XMLCALL 793 xmlNewNode (xmlNsPtr ns, 794 const xmlChar *name); 795XMLPUBFUN xmlNodePtr XMLCALL 796 xmlNewNodeEatName (xmlNsPtr ns, 797 xmlChar *name); 798#if defined(LIBXML_TREE_ENABLED) || defined(LIBXML_SCHEMAS_ENABLED) 799XMLPUBFUN xmlNodePtr XMLCALL 800 xmlNewChild (xmlNodePtr parent, 801 xmlNsPtr ns, 802 const xmlChar *name, 803 const xmlChar *content); 804#endif 805XMLPUBFUN xmlNodePtr XMLCALL 806 xmlNewDocText (xmlDocPtr doc, 807 const xmlChar *content); 808XMLPUBFUN xmlNodePtr XMLCALL 809 xmlNewText (const xmlChar *content); 810XMLPUBFUN xmlNodePtr XMLCALL 811 xmlNewDocPI (xmlDocPtr doc, 812 const xmlChar *name, 813 const xmlChar *content); 814XMLPUBFUN xmlNodePtr XMLCALL 815 xmlNewPI (const xmlChar *name, 816 const xmlChar *content); 817XMLPUBFUN xmlNodePtr XMLCALL 818 xmlNewDocTextLen (xmlDocPtr doc, 819 const xmlChar *content, 820 int len); 821XMLPUBFUN xmlNodePtr XMLCALL 822 xmlNewTextLen (const xmlChar *content, 823 int len); 824XMLPUBFUN xmlNodePtr XMLCALL 825 xmlNewDocComment (xmlDocPtr doc, 826 const xmlChar *content); 827XMLPUBFUN xmlNodePtr XMLCALL 828 xmlNewComment (const xmlChar *content); 829XMLPUBFUN xmlNodePtr XMLCALL 830 xmlNewCDataBlock (xmlDocPtr doc, 831 const xmlChar *content, 832 int len); 833XMLPUBFUN xmlNodePtr XMLCALL 834 xmlNewCharRef (xmlDocPtr doc, 835 const xmlChar *name); 836XMLPUBFUN xmlNodePtr XMLCALL 837 xmlNewReference (xmlDocPtr doc, 838 const xmlChar *name); 839XMLPUBFUN xmlNodePtr XMLCALL 840 xmlCopyNode (const xmlNodePtr node, 841 int recursive); 842XMLPUBFUN xmlNodePtr XMLCALL 843 xmlDocCopyNode (const xmlNodePtr node, 844 xmlDocPtr doc, 845 int recursive); 846XMLPUBFUN xmlNodePtr XMLCALL 847 xmlDocCopyNodeList (xmlDocPtr doc, 848 const xmlNodePtr node); 849XMLPUBFUN xmlNodePtr XMLCALL 850 xmlCopyNodeList (const xmlNodePtr node); 851#ifdef LIBXML_TREE_ENABLED 852XMLPUBFUN xmlNodePtr XMLCALL 853 xmlNewTextChild (xmlNodePtr parent, 854 xmlNsPtr ns, 855 const xmlChar *name, 856 const xmlChar *content); 857XMLPUBFUN xmlNodePtr XMLCALL 858 xmlNewDocRawNode (xmlDocPtr doc, 859 xmlNsPtr ns, 860 const xmlChar *name, 861 const xmlChar *content); 862XMLPUBFUN xmlNodePtr XMLCALL 863 xmlNewDocFragment (xmlDocPtr doc); 864#endif /* LIBXML_TREE_ENABLED */ 865 866/* 867 * Navigating. 868 */ 869XMLPUBFUN long XMLCALL 870 xmlGetLineNo (xmlNodePtr node); 871#if defined(LIBXML_TREE_ENABLED) || defined(LIBXML_DEBUG_ENABLED) 872XMLPUBFUN xmlChar * XMLCALL 873 xmlGetNodePath (xmlNodePtr node); 874#endif /* defined(LIBXML_TREE_ENABLED) || defined(LIBXML_DEBUG_ENABLED) */ 875XMLPUBFUN xmlNodePtr XMLCALL 876 xmlDocGetRootElement (xmlDocPtr doc); 877XMLPUBFUN xmlNodePtr XMLCALL 878 xmlGetLastChild (xmlNodePtr parent); 879XMLPUBFUN int XMLCALL 880 xmlNodeIsText (xmlNodePtr node); 881XMLPUBFUN int XMLCALL 882 xmlIsBlankNode (xmlNodePtr node); 883 884/* 885 * Changing the structure. 886 */ 887#if defined(LIBXML_TREE_ENABLED) || defined(LIBXML_WRITER_ENABLED) 888XMLPUBFUN xmlNodePtr XMLCALL 889 xmlDocSetRootElement (xmlDocPtr doc, 890 xmlNodePtr root); 891#endif /* defined(LIBXML_TREE_ENABLED) || defined(LIBXML_WRITER_ENABLED) */ 892#ifdef LIBXML_TREE_ENABLED 893XMLPUBFUN void XMLCALL 894 xmlNodeSetName (xmlNodePtr cur, 895 const xmlChar *name); 896#endif /* LIBXML_TREE_ENABLED */ 897XMLPUBFUN xmlNodePtr XMLCALL 898 xmlAddChild (xmlNodePtr parent, 899 xmlNodePtr cur); 900XMLPUBFUN xmlNodePtr XMLCALL 901 xmlAddChildList (xmlNodePtr parent, 902 xmlNodePtr cur); 903#if defined(LIBXML_TREE_ENABLED) || defined(LIBXML_WRITER_ENABLED) 904XMLPUBFUN 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) 910XMLPUBFUN xmlNodePtr XMLCALL 911 xmlAddPrevSibling (xmlNodePtr cur, 912 xmlNodePtr elem); 913#endif /* LIBXML_TREE_ENABLED || LIBXML_HTML_ENABLED || LIBXML_SCHEMAS_ENABLED */ 914XMLPUBFUN xmlNodePtr XMLCALL 915 xmlAddSibling (xmlNodePtr cur, 916 xmlNodePtr elem); 917XMLPUBFUN xmlNodePtr XMLCALL 918 xmlAddNextSibling (xmlNodePtr cur, 919 xmlNodePtr elem); 920XMLPUBFUN void XMLCALL 921 xmlUnlinkNode (xmlNodePtr cur); 922XMLPUBFUN xmlNodePtr XMLCALL 923 xmlTextMerge (xmlNodePtr first, 924 xmlNodePtr second); 925XMLPUBFUN int XMLCALL 926 xmlTextConcat (xmlNodePtr node, 927 const xmlChar *content, 928 int len); 929XMLPUBFUN void XMLCALL 930 xmlFreeNodeList (xmlNodePtr cur); 931XMLPUBFUN void XMLCALL 932 xmlFreeNode (xmlNodePtr cur); 933XMLPUBFUN void XMLCALL 934 xmlSetTreeDoc (xmlNodePtr tree, 935 xmlDocPtr doc); 936XMLPUBFUN void XMLCALL 937 xmlSetListDoc (xmlNodePtr list, 938 xmlDocPtr doc); 939/* 940 * Namespaces. 941 */ 942XMLPUBFUN xmlNsPtr XMLCALL 943 xmlSearchNs (xmlDocPtr doc, 944 xmlNodePtr node, 945 const xmlChar *nameSpace); 946XMLPUBFUN 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) 951XMLPUBFUN xmlNsPtr * XMLCALL 952 xmlGetNsList (xmlDocPtr doc, 953 xmlNodePtr node); 954#endif /* defined(LIBXML_TREE_ENABLED) || defined(LIBXML_XPATH_ENABLED) */ 955 956XMLPUBFUN void XMLCALL 957 xmlSetNs (xmlNodePtr node, 958 xmlNsPtr ns); 959XMLPUBFUN xmlNsPtr XMLCALL 960 xmlCopyNamespace (xmlNsPtr cur); 961XMLPUBFUN 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) 968XMLPUBFUN xmlAttrPtr XMLCALL 969 xmlSetProp (xmlNodePtr node, 970 const xmlChar *name, 971 const xmlChar *value); 972XMLPUBFUN 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) */ 978XMLPUBFUN xmlChar * XMLCALL 979 xmlGetNoNsProp (xmlNodePtr node, 980 const xmlChar *name); 981XMLPUBFUN xmlChar * XMLCALL 982 xmlGetProp (xmlNodePtr node, 983 const xmlChar *name); 984XMLPUBFUN xmlAttrPtr XMLCALL 985 xmlHasProp (xmlNodePtr node, 986 const xmlChar *name); 987XMLPUBFUN xmlAttrPtr XMLCALL 988 xmlHasNsProp (xmlNodePtr node, 989 const xmlChar *name, 990 const xmlChar *nameSpace); 991XMLPUBFUN xmlChar * XMLCALL 992 xmlGetNsProp (xmlNodePtr node, 993 const xmlChar *name, 994 const xmlChar *nameSpace); 995XMLPUBFUN xmlNodePtr XMLCALL 996 xmlStringGetNodeList (xmlDocPtr doc, 997 const xmlChar *value); 998XMLPUBFUN xmlNodePtr XMLCALL 999 xmlStringLenGetNodeList (xmlDocPtr doc, 1000 const xmlChar *value, 1001 int len); 1002XMLPUBFUN xmlChar * XMLCALL 1003 xmlNodeListGetString (xmlDocPtr doc, 1004 xmlNodePtr list, 1005 int inLine); 1006#ifdef LIBXML_TREE_ENABLED 1007XMLPUBFUN xmlChar * XMLCALL 1008 xmlNodeListGetRawString (xmlDocPtr doc, 1009 xmlNodePtr list, 1010 int inLine); 1011#endif /* LIBXML_TREE_ENABLED */ 1012XMLPUBFUN void XMLCALL 1013 xmlNodeSetContent (xmlNodePtr cur, 1014 const xmlChar *content); 1015#ifdef LIBXML_TREE_ENABLED 1016XMLPUBFUN void XMLCALL 1017 xmlNodeSetContentLen (xmlNodePtr cur, 1018 const xmlChar *content, 1019 int len); 1020#endif /* LIBXML_TREE_ENABLED */ 1021XMLPUBFUN void XMLCALL 1022 xmlNodeAddContent (xmlNodePtr cur, 1023 const xmlChar *content); 1024XMLPUBFUN void XMLCALL 1025 xmlNodeAddContentLen (xmlNodePtr cur, 1026 const xmlChar *content, 1027 int len); 1028XMLPUBFUN xmlChar * XMLCALL 1029 xmlNodeGetContent (xmlNodePtr cur); 1030XMLPUBFUN int XMLCALL 1031 xmlNodeBufGetContent (xmlBufferPtr buffer, 1032 xmlNodePtr cur); 1033XMLPUBFUN xmlChar * XMLCALL 1034 xmlNodeGetLang (xmlNodePtr cur); 1035XMLPUBFUN int XMLCALL 1036 xmlNodeGetSpacePreserve (xmlNodePtr cur); 1037#ifdef LIBXML_TREE_ENABLED 1038XMLPUBFUN void XMLCALL 1039 xmlNodeSetLang (xmlNodePtr cur, 1040 const xmlChar *lang); 1041XMLPUBFUN void XMLCALL 1042 xmlNodeSetSpacePreserve (xmlNodePtr cur, 1043 int val); 1044#endif /* LIBXML_TREE_ENABLED */ 1045XMLPUBFUN xmlChar * XMLCALL 1046 xmlNodeGetBase (xmlDocPtr doc, 1047 xmlNodePtr cur); 1048#if defined(LIBXML_TREE_ENABLED) || defined(LIBXML_XINCLUDE_ENABLED) 1049XMLPUBFUN void XMLCALL 1050 xmlNodeSetBase (xmlNodePtr cur, 1051 const xmlChar *uri); 1052#endif 1053 1054/* 1055 * Removing content. 1056 */ 1057XMLPUBFUN int XMLCALL 1058 xmlRemoveProp (xmlAttrPtr cur); 1059#if defined(LIBXML_TREE_ENABLED) || defined(LIBXML_SCHEMAS_ENABLED) 1060XMLPUBFUN int XMLCALL 1061 xmlUnsetNsProp (xmlNodePtr node, 1062 xmlNsPtr ns, 1063 const xmlChar *name); 1064XMLPUBFUN 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 */ 1072XMLPUBFUN void XMLCALL 1073 xmlBufferWriteCHAR (xmlBufferPtr buf, 1074 const xmlChar *string); 1075XMLPUBFUN void XMLCALL 1076 xmlBufferWriteChar (xmlBufferPtr buf, 1077 const char *string); 1078XMLPUBFUN void XMLCALL 1079 xmlBufferWriteQuotedString(xmlBufferPtr buf, 1080 const xmlChar *string); 1081 1082#ifdef LIBXML_OUTPUT_ENABLED 1083XMLPUBFUN 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 */ 1093XMLPUBFUN int XMLCALL 1094 xmlReconciliateNs (xmlDocPtr doc, 1095 xmlNodePtr tree); 1096#endif 1097 1098#ifdef LIBXML_OUTPUT_ENABLED 1099/* 1100 * Saving. 1101 */ 1102XMLPUBFUN void XMLCALL 1103 xmlDocDumpFormatMemory (xmlDocPtr cur, 1104 xmlChar **mem, 1105 int *size, 1106 int format); 1107XMLPUBFUN void XMLCALL 1108 xmlDocDumpMemory (xmlDocPtr cur, 1109 xmlChar **mem, 1110 int *size); 1111XMLPUBFUN void XMLCALL 1112 xmlDocDumpMemoryEnc (xmlDocPtr out_doc, 1113 xmlChar **doc_txt_ptr, 1114 int * doc_txt_len, 1115 const char *txt_encoding); 1116XMLPUBFUN 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); 1122XMLPUBFUN int XMLCALL 1123 xmlDocFormatDump (FILE *f, 1124 xmlDocPtr cur, 1125 int format); 1126XMLPUBFUN int XMLCALL 1127 xmlDocDump (FILE *f, 1128 xmlDocPtr cur); 1129XMLPUBFUN void XMLCALL 1130 xmlElemDump (FILE *f, 1131 xmlDocPtr doc, 1132 xmlNodePtr cur); 1133XMLPUBFUN int XMLCALL 1134 xmlSaveFile (const char *filename, 1135 xmlDocPtr cur); 1136XMLPUBFUN int XMLCALL 1137 xmlSaveFormatFile (const char *filename, 1138 xmlDocPtr cur, 1139 int format); 1140XMLPUBFUN int XMLCALL 1141 xmlNodeDump (xmlBufferPtr buf, 1142 xmlDocPtr doc, 1143 xmlNodePtr cur, 1144 int level, 1145 int format); 1146 1147XMLPUBFUN int XMLCALL 1148 xmlSaveFileTo (xmlOutputBufferPtr buf, 1149 xmlDocPtr cur, 1150 const char *encoding); 1151XMLPUBFUN int XMLCALL 1152 xmlSaveFormatFileTo (xmlOutputBufferPtr buf, 1153 xmlDocPtr cur, 1154 const char *encoding, 1155 int format); 1156XMLPUBFUN void XMLCALL 1157 xmlNodeDumpOutput (xmlOutputBufferPtr buf, 1158 xmlDocPtr doc, 1159 xmlNodePtr cur, 1160 int level, 1161 int format, 1162 const char *encoding); 1163 1164XMLPUBFUN int XMLCALL 1165 xmlSaveFormatFileEnc (const char *filename, 1166 xmlDocPtr cur, 1167 const char *encoding, 1168 int format); 1169 1170XMLPUBFUN int XMLCALL 1171 xmlSaveFileEnc (const char *filename, 1172 xmlDocPtr cur, 1173 const char *encoding); 1174 1175#endif /* LIBXML_OUTPUT_ENABLED */ 1176/* 1177 * XHTML 1178 */ 1179XMLPUBFUN int XMLCALL 1180 xmlIsXHTML (const xmlChar *systemID, 1181 const xmlChar *publicID); 1182 1183/* 1184 * Compression. 1185 */ 1186XMLPUBFUN int XMLCALL 1187 xmlGetDocCompressMode (xmlDocPtr doc); 1188XMLPUBFUN void XMLCALL 1189 xmlSetDocCompressMode (xmlDocPtr doc, 1190 int mode); 1191XMLPUBFUN int XMLCALL 1192 xmlGetCompressMode (void); 1193XMLPUBFUN void XMLCALL 1194 xmlSetCompressMode (int mode); 1195 1196/* 1197* DOM-wrapper helper functions. 1198*/ 1199XMLPUBFUN xmlDOMWrapCtxtPtr XMLCALL 1200 xmlDOMWrapNewCtxt (void); 1201XMLPUBFUN void XMLCALL 1202 xmlDOMWrapFreeCtxt (xmlDOMWrapCtxtPtr ctxt); 1203XMLPUBFUN int XMLCALL 1204 xmlDOMWrapReconcileNamespaces(xmlDOMWrapCtxtPtr ctxt, 1205 xmlNodePtr elem, 1206 int options); 1207XMLPUBFUN int XMLCALL 1208 xmlDOMWrapAdoptNode (xmlDOMWrapCtxtPtr ctxt, 1209 xmlDocPtr sourceDoc, 1210 xmlNodePtr node, 1211 xmlDocPtr destDoc, 1212 xmlNodePtr destParent, 1213 int options); 1214XMLPUBFUN int XMLCALL 1215 xmlDOMWrapRemoveNode (xmlDOMWrapCtxtPtr ctxt, 1216 xmlDocPtr doc, 1217 xmlNodePtr node, 1218 int options); 1219XMLPUBFUN 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 */ 1234XMLPUBFUN unsigned long XMLCALL 1235 xmlChildElementCount (xmlNodePtr parent); 1236XMLPUBFUN xmlNodePtr XMLCALL 1237 xmlNextElementSibling (xmlNodePtr node); 1238XMLPUBFUN xmlNodePtr XMLCALL 1239 xmlFirstElementChild (xmlNodePtr parent); 1240XMLPUBFUN xmlNodePtr XMLCALL 1241 xmlLastElementChild (xmlNodePtr parent); 1242XMLPUBFUN 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