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