reactos/lib/libxml2/include/libxml/tree.h

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