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