Imported Upstream version 0.19.7
[platform/upstream/gettext.git] / gettext-tools / gnulib-lib / libxml / tree.in.h
index 321280e..4a9b3bc 100644 (file)
@@ -13,6 +13,7 @@
 #define __XML_TREE_H__
 
 #include <stdio.h>
+#include <limits.h>
 #include <libxml/xmlversion.h>
 #include <libxml/xmlstring.h>
 
@@ -71,15 +72,19 @@ typedef xmlEntity *xmlEntityPtr;
  */
 
 typedef enum {
-    XML_BUFFER_ALLOC_DOUBLEIT,
-    XML_BUFFER_ALLOC_EXACT,
-    XML_BUFFER_ALLOC_IMMUTABLE
+    XML_BUFFER_ALLOC_DOUBLEIT, /* double each time one need to grow */
+    XML_BUFFER_ALLOC_EXACT,    /* grow only to the minimal size */
+    XML_BUFFER_ALLOC_IMMUTABLE, /* immutable buffer */
+    XML_BUFFER_ALLOC_IO,       /* special allocation scheme used for I/O */
+    XML_BUFFER_ALLOC_HYBRID,   /* exact up to a threshold, and doubleit thereafter */
+    XML_BUFFER_ALLOC_BOUNDED   /* limit the upper size of the buffer */
 } xmlBufferAllocationScheme;
 
 /**
  * xmlBuffer:
  *
- * A buffer structure.
+ * A buffer structure, this old construct is limited to 2GB and
+ * is being deprecated, use API with xmlBuf instead
  */
 typedef struct _xmlBuffer xmlBuffer;
 typedef xmlBuffer *xmlBufferPtr;
@@ -88,9 +93,45 @@ struct _xmlBuffer {
     unsigned int use;          /* The buffer size used */
     unsigned int size;         /* The buffer size */
     xmlBufferAllocationScheme alloc; /* The realloc method */
+    xmlChar *contentIO;                /* in IO mode we may have a different base */
 };
 
 /**
+ * xmlBuf:
+ *
+ * A buffer structure, new one, the actual structure internals are not public
+ */
+
+typedef struct _xmlBuf xmlBuf;
+
+/**
+ * xmlBufPtr:
+ *
+ * A pointer to a buffer structure, the actual structure internals are not
+ * public
+ */
+
+typedef xmlBuf *xmlBufPtr;
+
+/*
+ * A few public routines for xmlBuf. As those are expected to be used
+ * mostly internally the bulk of the routines are internal in buf.h
+ */
+XMLPUBFUN xmlChar* XMLCALL       xmlBufContent (const xmlBuf* buf);
+XMLPUBFUN xmlChar* XMLCALL       xmlBufEnd      (xmlBufPtr buf);
+XMLPUBFUN size_t XMLCALL         xmlBufUse      (const xmlBufPtr buf);
+XMLPUBFUN size_t XMLCALL         xmlBufShrink  (xmlBufPtr buf, size_t len);
+
+/*
+ * LIBXML2_NEW_BUFFER:
+ *
+ * Macro used to express that the API use the new buffers for
+ * xmlParserInputBuffer and xmlOutputBuffer. The change was
+ * introduced in 2.9.0.
+ */
+#define LIBXML2_NEW_BUFFER
+
+/**
  * XML_XML_NAMESPACE:
  *
  * This is the namespace for the special xml: prefix predefined in the
@@ -477,11 +518,28 @@ struct _xmlNode {
 /**
  * XML_GET_LINE:
  *
- * Macro to extract the line number of an element node. 
+ * Macro to extract the line number of an element node.
  */
 #define XML_GET_LINE(n)                                                \
     (xmlGetLineNo(n))
 
+/**
+ * xmlDocProperty
+ *
+ * Set of properties of the document as found by the parser
+ * Some of them are linked to similary named xmlParserOption
+ */
+typedef enum {
+    XML_DOC_WELLFORMED         = 1<<0, /* document is XML well formed */
+    XML_DOC_NSVALID            = 1<<1, /* document is Namespace valid */
+    XML_DOC_OLD10              = 1<<2, /* parsed with old XML-1.0 parser */
+    XML_DOC_DTDVALID           = 1<<3, /* DTD validation was successful */
+    XML_DOC_XINCLUDE           = 1<<4, /* XInclude substitution was done */
+    XML_DOC_USERBUILT          = 1<<5, /* Document was built using the API
+                                           and not by parsing an instance */
+    XML_DOC_INTERNAL           = 1<<6, /* built for internal processing */
+    XML_DOC_HTML               = 1<<7  /* parsed or built HTML document */
+} xmlDocProperties;
 
 /**
  * xmlDoc:
@@ -503,7 +561,12 @@ struct _xmlDoc {
 
     /* End of common part */
     int             compression;/* level of zlib compression */
-    int             standalone; /* standalone document (no external refs) */
+    int             standalone; /* standalone document (no external refs)
+                                    1 if standalone="yes"
+                                    0 if standalone="no"
+                                   -1 if there is no XML declaration
+                                   -2 if there is an XML declaration, but no
+                                       standalone attribute was specified */
     struct _xmlDtd  *intSubset;        /* the document internal subset */
     struct _xmlDtd  *extSubset;        /* the document external subset */
     struct _xmlNs   *oldNs;    /* Global namespace, the old way */
@@ -516,6 +579,10 @@ struct _xmlDoc {
                                   actually an xmlCharEncoding */
     struct _xmlDict *dict;      /* dict used to allocate names or NULL */
     void           *psvi;      /* for type/PSVI informations */
+    int             parseFlags;        /* set of xmlParserOption used to parse the
+                                  document */
+    int             properties;        /* set of xmlDocProperties for this document
+                                  set at the end of parsing */
 };
 
 
@@ -525,9 +592,9 @@ typedef xmlDOMWrapCtxt *xmlDOMWrapCtxtPtr;
 /**
  * xmlDOMWrapAcquireNsFunction:
  * @ctxt:  a DOM wrapper context
- * @node:  the context node (element or attribute) 
+ * @node:  the context node (element or attribute)
  * @nsName:  the requested namespace name
- * @nsPrefix:  the requested namespace prefix 
+ * @nsPrefix:  the requested namespace prefix
  *
  * A function called to acquire namespaces (xmlNs) from the wrapper.
  *
@@ -574,7 +641,7 @@ struct _xmlDOMWrapCtxt {
 /**
  * xmlRootNode:
  *
- * Macro for compatibility naming layer with libxml1. Maps 
+ * Macro for compatibility naming layer with libxml1. Maps
  * to "children".
  */
 #ifndef xmlRootNode
@@ -588,436 +655,450 @@ struct _xmlDOMWrapCtxt {
 /*
  * Some helper functions
  */
-#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)
+#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) || defined(LIBXML_LEGACY_ENABLED)
 XMLPUBFUN int XMLCALL
                xmlValidateNCName       (const xmlChar *value,
                                         int space);
 #endif
 
 #if defined(LIBXML_TREE_ENABLED) || defined(LIBXML_SCHEMAS_ENABLED)
-XMLPUBFUN int XMLCALL          
+XMLPUBFUN int XMLCALL
                xmlValidateQName        (const xmlChar *value,
                                         int space);
-XMLPUBFUN int XMLCALL          
+XMLPUBFUN int XMLCALL
                xmlValidateName         (const xmlChar *value,
                                         int space);
-XMLPUBFUN int XMLCALL          
+XMLPUBFUN int XMLCALL
                xmlValidateNMToken      (const xmlChar *value,
                                         int space);
 #endif
 
-XMLPUBFUN xmlChar * XMLCALL    
+XMLPUBFUN xmlChar * XMLCALL
                xmlBuildQName           (const xmlChar *ncname,
                                         const xmlChar *prefix,
                                         xmlChar *memory,
                                         int len);
-XMLPUBFUN xmlChar * XMLCALL    
+XMLPUBFUN xmlChar * XMLCALL
                xmlSplitQName2          (const xmlChar *name,
                                         xmlChar **prefix);
-XMLPUBFUN const xmlChar * XMLCALL      
+XMLPUBFUN const xmlChar * XMLCALL
                xmlSplitQName3          (const xmlChar *name,
                                         int *len);
 
 /*
- * Handling Buffers.
+ * Handling Buffers, the old ones see @xmlBuf for the new ones.
  */
 
-XMLPUBFUN void XMLCALL         
+XMLPUBFUN void XMLCALL
                xmlSetBufferAllocationScheme(xmlBufferAllocationScheme scheme);
-XMLPUBFUN xmlBufferAllocationScheme XMLCALL     
+XMLPUBFUN xmlBufferAllocationScheme XMLCALL
                xmlGetBufferAllocationScheme(void);
 
-XMLPUBFUN xmlBufferPtr XMLCALL 
+XMLPUBFUN xmlBufferPtr XMLCALL
                xmlBufferCreate         (void);
-XMLPUBFUN xmlBufferPtr XMLCALL 
+XMLPUBFUN xmlBufferPtr XMLCALL
                xmlBufferCreateSize     (size_t size);
-XMLPUBFUN xmlBufferPtr XMLCALL 
+XMLPUBFUN xmlBufferPtr XMLCALL
                xmlBufferCreateStatic   (void *mem,
                                         size_t size);
-XMLPUBFUN int XMLCALL          
+XMLPUBFUN int XMLCALL
                xmlBufferResize         (xmlBufferPtr buf,
                                         unsigned int size);
-XMLPUBFUN void XMLCALL         
+XMLPUBFUN void XMLCALL
                xmlBufferFree           (xmlBufferPtr buf);
-XMLPUBFUN int XMLCALL          
+XMLPUBFUN int XMLCALL
                xmlBufferDump           (FILE *file,
                                         xmlBufferPtr buf);
-XMLPUBFUN int XMLCALL          
+XMLPUBFUN int XMLCALL
                xmlBufferAdd            (xmlBufferPtr buf,
                                         const xmlChar *str,
                                         int len);
-XMLPUBFUN int XMLCALL          
+XMLPUBFUN int XMLCALL
                xmlBufferAddHead        (xmlBufferPtr buf,
                                         const xmlChar *str,
                                         int len);
-XMLPUBFUN int XMLCALL          
+XMLPUBFUN int XMLCALL
                xmlBufferCat            (xmlBufferPtr buf,
                                         const xmlChar *str);
-XMLPUBFUN int XMLCALL  
+XMLPUBFUN int XMLCALL
                xmlBufferCCat           (xmlBufferPtr buf,
                                         const char *str);
-XMLPUBFUN int XMLCALL          
+XMLPUBFUN int XMLCALL
                xmlBufferShrink         (xmlBufferPtr buf,
                                         unsigned int len);
-XMLPUBFUN int XMLCALL          
+XMLPUBFUN int XMLCALL
                xmlBufferGrow           (xmlBufferPtr buf,
                                         unsigned int len);
-XMLPUBFUN void XMLCALL         
+XMLPUBFUN void XMLCALL
                xmlBufferEmpty          (xmlBufferPtr buf);
-XMLPUBFUN const xmlChar* XMLCALL       
-               xmlBufferContent        (const xmlBufferPtr buf);
-XMLPUBFUN void XMLCALL         
+XMLPUBFUN const xmlChar* XMLCALL
+               xmlBufferContent        (const xmlBuffer *buf);
+XMLPUBFUN xmlChar* XMLCALL
+               xmlBufferDetach         (xmlBufferPtr buf);
+XMLPUBFUN void XMLCALL
                xmlBufferSetAllocationScheme(xmlBufferPtr buf,
                                         xmlBufferAllocationScheme scheme);
-XMLPUBFUN int XMLCALL          
-               xmlBufferLength         (const xmlBufferPtr buf);
+XMLPUBFUN int XMLCALL
+               xmlBufferLength         (const xmlBuffer *buf);
 
 /*
  * Creating/freeing new structures.
  */
-XMLPUBFUN xmlDtdPtr XMLCALL    
+XMLPUBFUN xmlDtdPtr XMLCALL
                xmlCreateIntSubset      (xmlDocPtr doc,
                                         const xmlChar *name,
                                         const xmlChar *ExternalID,
                                         const xmlChar *SystemID);
-XMLPUBFUN xmlDtdPtr XMLCALL    
+XMLPUBFUN xmlDtdPtr XMLCALL
                xmlNewDtd               (xmlDocPtr doc,
                                         const xmlChar *name,
                                         const xmlChar *ExternalID,
                                         const xmlChar *SystemID);
-XMLPUBFUN xmlDtdPtr XMLCALL    
-               xmlGetIntSubset         (xmlDocPtr doc);
-XMLPUBFUN void XMLCALL         
+XMLPUBFUN xmlDtdPtr XMLCALL
+               xmlGetIntSubset         (const xmlDoc *doc);
+XMLPUBFUN void XMLCALL
                xmlFreeDtd              (xmlDtdPtr cur);
 #ifdef LIBXML_LEGACY_ENABLED
-XMLPUBFUN xmlNsPtr XMLCALL     
+XMLPUBFUN xmlNsPtr XMLCALL
                xmlNewGlobalNs          (xmlDocPtr doc,
                                         const xmlChar *href,
                                         const xmlChar *prefix);
 #endif /* LIBXML_LEGACY_ENABLED */
-XMLPUBFUN xmlNsPtr XMLCALL     
+XMLPUBFUN xmlNsPtr XMLCALL
                xmlNewNs                (xmlNodePtr node,
                                         const xmlChar *href,
                                         const xmlChar *prefix);
-XMLPUBFUN void XMLCALL         
+XMLPUBFUN void XMLCALL
                xmlFreeNs               (xmlNsPtr cur);
-XMLPUBFUN void XMLCALL         
+XMLPUBFUN void XMLCALL
                xmlFreeNsList           (xmlNsPtr cur);
-XMLPUBFUN xmlDocPtr XMLCALL    
+XMLPUBFUN xmlDocPtr XMLCALL
                xmlNewDoc               (const xmlChar *version);
-XMLPUBFUN void XMLCALL         
+XMLPUBFUN void XMLCALL
                xmlFreeDoc              (xmlDocPtr cur);
-XMLPUBFUN xmlAttrPtr XMLCALL   
+XMLPUBFUN xmlAttrPtr XMLCALL
                xmlNewDocProp           (xmlDocPtr doc,
                                         const xmlChar *name,
                                         const xmlChar *value);
 #if defined(LIBXML_TREE_ENABLED) || defined(LIBXML_HTML_ENABLED) || \
     defined(LIBXML_SCHEMAS_ENABLED)
-XMLPUBFUN xmlAttrPtr XMLCALL   
+XMLPUBFUN xmlAttrPtr XMLCALL
                xmlNewProp              (xmlNodePtr node,
                                         const xmlChar *name,
                                         const xmlChar *value);
 #endif
-XMLPUBFUN xmlAttrPtr XMLCALL   
+XMLPUBFUN xmlAttrPtr XMLCALL
                xmlNewNsProp            (xmlNodePtr node,
                                         xmlNsPtr ns,
                                         const xmlChar *name,
                                         const xmlChar *value);
-XMLPUBFUN xmlAttrPtr XMLCALL   
+XMLPUBFUN xmlAttrPtr XMLCALL
                xmlNewNsPropEatName     (xmlNodePtr node,
                                         xmlNsPtr ns,
                                         xmlChar *name,
                                         const xmlChar *value);
-XMLPUBFUN void XMLCALL         
+XMLPUBFUN void XMLCALL
                xmlFreePropList         (xmlAttrPtr cur);
-XMLPUBFUN void XMLCALL         
+XMLPUBFUN void XMLCALL
                xmlFreeProp             (xmlAttrPtr cur);
-XMLPUBFUN xmlAttrPtr XMLCALL   
+XMLPUBFUN xmlAttrPtr XMLCALL
                xmlCopyProp             (xmlNodePtr target,
                                         xmlAttrPtr cur);
-XMLPUBFUN xmlAttrPtr XMLCALL   
+XMLPUBFUN xmlAttrPtr XMLCALL
                xmlCopyPropList         (xmlNodePtr target,
                                         xmlAttrPtr cur);
 #ifdef LIBXML_TREE_ENABLED
-XMLPUBFUN xmlDtdPtr XMLCALL    
+XMLPUBFUN xmlDtdPtr XMLCALL
                xmlCopyDtd              (xmlDtdPtr dtd);
 #endif /* LIBXML_TREE_ENABLED */
 #if defined(LIBXML_TREE_ENABLED) || defined(LIBXML_SCHEMAS_ENABLED)
-XMLPUBFUN xmlDocPtr XMLCALL    
+XMLPUBFUN xmlDocPtr XMLCALL
                xmlCopyDoc              (xmlDocPtr doc,
                                         int recursive);
 #endif /* defined(LIBXML_TREE_ENABLED) || defined(LIBXML_SCHEMAS_ENABLED) */
 /*
  * Creating new nodes.
  */
-XMLPUBFUN xmlNodePtr XMLCALL   
+XMLPUBFUN xmlNodePtr XMLCALL
                xmlNewDocNode           (xmlDocPtr doc,
                                         xmlNsPtr ns,
                                         const xmlChar *name,
                                         const xmlChar *content);
-XMLPUBFUN xmlNodePtr XMLCALL   
+XMLPUBFUN xmlNodePtr XMLCALL
                xmlNewDocNodeEatName    (xmlDocPtr doc,
                                         xmlNsPtr ns,
                                         xmlChar *name,
                                         const xmlChar *content);
-XMLPUBFUN xmlNodePtr XMLCALL   
+XMLPUBFUN xmlNodePtr XMLCALL
                xmlNewNode              (xmlNsPtr ns,
                                         const xmlChar *name);
-XMLPUBFUN xmlNodePtr XMLCALL   
+XMLPUBFUN xmlNodePtr XMLCALL
                xmlNewNodeEatName       (xmlNsPtr ns,
                                         xmlChar *name);
 #if defined(LIBXML_TREE_ENABLED) || defined(LIBXML_SCHEMAS_ENABLED)
-XMLPUBFUN xmlNodePtr XMLCALL   
+XMLPUBFUN xmlNodePtr XMLCALL
                xmlNewChild             (xmlNodePtr parent,
                                         xmlNsPtr ns,
                                         const xmlChar *name,
                                         const xmlChar *content);
 #endif
-XMLPUBFUN xmlNodePtr XMLCALL   
-               xmlNewDocText           (xmlDocPtr doc,
+XMLPUBFUN xmlNodePtr XMLCALL
+               xmlNewDocText           (const xmlDoc *doc,
                                         const xmlChar *content);
-XMLPUBFUN xmlNodePtr XMLCALL   
+XMLPUBFUN xmlNodePtr XMLCALL
                xmlNewText              (const xmlChar *content);
-XMLPUBFUN xmlNodePtr XMLCALL   
+XMLPUBFUN xmlNodePtr XMLCALL
                xmlNewDocPI             (xmlDocPtr doc,
                                         const xmlChar *name,
                                         const xmlChar *content);
-XMLPUBFUN xmlNodePtr XMLCALL   
+XMLPUBFUN xmlNodePtr XMLCALL
                xmlNewPI                (const xmlChar *name,
                                         const xmlChar *content);
-XMLPUBFUN xmlNodePtr XMLCALL   
+XMLPUBFUN xmlNodePtr XMLCALL
                xmlNewDocTextLen        (xmlDocPtr doc,
                                         const xmlChar *content,
                                         int len);
-XMLPUBFUN xmlNodePtr XMLCALL   
+XMLPUBFUN xmlNodePtr XMLCALL
                xmlNewTextLen           (const xmlChar *content,
                                         int len);
-XMLPUBFUN xmlNodePtr XMLCALL   
+XMLPUBFUN xmlNodePtr XMLCALL
                xmlNewDocComment        (xmlDocPtr doc,
                                         const xmlChar *content);
-XMLPUBFUN xmlNodePtr XMLCALL   
+XMLPUBFUN xmlNodePtr XMLCALL
                xmlNewComment           (const xmlChar *content);
-XMLPUBFUN xmlNodePtr XMLCALL   
+XMLPUBFUN xmlNodePtr XMLCALL
                xmlNewCDataBlock        (xmlDocPtr doc,
                                         const xmlChar *content,
                                         int len);
-XMLPUBFUN xmlNodePtr XMLCALL   
+XMLPUBFUN xmlNodePtr XMLCALL
                xmlNewCharRef           (xmlDocPtr doc,
                                         const xmlChar *name);
-XMLPUBFUN xmlNodePtr XMLCALL   
-               xmlNewReference         (xmlDocPtr doc,
+XMLPUBFUN xmlNodePtr XMLCALL
+               xmlNewReference         (const xmlDoc *doc,
                                         const xmlChar *name);
-XMLPUBFUN xmlNodePtr XMLCALL   
-               xmlCopyNode             (const xmlNodePtr node,
+XMLPUBFUN xmlNodePtr XMLCALL
+               xmlCopyNode             (xmlNodePtr node,
                                         int recursive);
-XMLPUBFUN xmlNodePtr XMLCALL   
-               xmlDocCopyNode          (const xmlNodePtr node,
+XMLPUBFUN xmlNodePtr XMLCALL
+               xmlDocCopyNode          (xmlNodePtr node,
                                         xmlDocPtr doc,
                                         int recursive);
-XMLPUBFUN xmlNodePtr XMLCALL   
+XMLPUBFUN xmlNodePtr XMLCALL
                xmlDocCopyNodeList      (xmlDocPtr doc,
-                                        const xmlNodePtr node);
-XMLPUBFUN xmlNodePtr XMLCALL   
-               xmlCopyNodeList         (const xmlNodePtr node);
+                                        xmlNodePtr node);
+XMLPUBFUN xmlNodePtr XMLCALL
+               xmlCopyNodeList         (xmlNodePtr node);
 #ifdef LIBXML_TREE_ENABLED
-XMLPUBFUN xmlNodePtr XMLCALL   
+XMLPUBFUN xmlNodePtr XMLCALL
                xmlNewTextChild         (xmlNodePtr parent,
                                         xmlNsPtr ns,
                                         const xmlChar *name,
                                         const xmlChar *content);
-XMLPUBFUN xmlNodePtr XMLCALL   
+XMLPUBFUN xmlNodePtr XMLCALL
                xmlNewDocRawNode        (xmlDocPtr doc,
                                         xmlNsPtr ns,
                                         const xmlChar *name,
                                         const xmlChar *content);
-XMLPUBFUN xmlNodePtr XMLCALL   
+XMLPUBFUN xmlNodePtr XMLCALL
                xmlNewDocFragment       (xmlDocPtr doc);
 #endif /* LIBXML_TREE_ENABLED */
 
 /*
  * Navigating.
  */
-XMLPUBFUN long XMLCALL         
-               xmlGetLineNo            (xmlNodePtr node);
+XMLPUBFUN long XMLCALL
+               xmlGetLineNo            (const xmlNode *node);
 #if defined(LIBXML_TREE_ENABLED) || defined(LIBXML_DEBUG_ENABLED)
-XMLPUBFUN xmlChar * XMLCALL    
-               xmlGetNodePath          (xmlNodePtr node);
+XMLPUBFUN xmlChar * XMLCALL
+               xmlGetNodePath          (const xmlNode *node);
 #endif /* defined(LIBXML_TREE_ENABLED) || defined(LIBXML_DEBUG_ENABLED) */
-XMLPUBFUN xmlNodePtr XMLCALL   
-               xmlDocGetRootElement    (xmlDocPtr doc);
-XMLPUBFUN xmlNodePtr XMLCALL   
-               xmlGetLastChild         (xmlNodePtr parent);
-XMLPUBFUN int XMLCALL          
-               xmlNodeIsText           (xmlNodePtr node);
-XMLPUBFUN int XMLCALL          
-               xmlIsBlankNode          (xmlNodePtr node);
+XMLPUBFUN xmlNodePtr XMLCALL
+               xmlDocGetRootElement    (const xmlDoc *doc);
+XMLPUBFUN xmlNodePtr XMLCALL
+               xmlGetLastChild         (const xmlNode *parent);
+XMLPUBFUN int XMLCALL
+               xmlNodeIsText           (const xmlNode *node);
+XMLPUBFUN int XMLCALL
+               xmlIsBlankNode          (const xmlNode *node);
 
 /*
  * Changing the structure.
  */
 #if defined(LIBXML_TREE_ENABLED) || defined(LIBXML_WRITER_ENABLED)
-XMLPUBFUN xmlNodePtr XMLCALL   
+XMLPUBFUN xmlNodePtr XMLCALL
                xmlDocSetRootElement    (xmlDocPtr doc,
                                         xmlNodePtr root);
 #endif /* defined(LIBXML_TREE_ENABLED) || defined(LIBXML_WRITER_ENABLED) */
 #ifdef LIBXML_TREE_ENABLED
-XMLPUBFUN void XMLCALL         
+XMLPUBFUN void XMLCALL
                xmlNodeSetName          (xmlNodePtr cur,
                                         const xmlChar *name);
 #endif /* LIBXML_TREE_ENABLED */
-XMLPUBFUN xmlNodePtr XMLCALL   
+XMLPUBFUN xmlNodePtr XMLCALL
                xmlAddChild             (xmlNodePtr parent,
                                         xmlNodePtr cur);
-XMLPUBFUN xmlNodePtr XMLCALL   
+XMLPUBFUN xmlNodePtr XMLCALL
                xmlAddChildList         (xmlNodePtr parent,
                                         xmlNodePtr cur);
 #if defined(LIBXML_TREE_ENABLED) || defined(LIBXML_WRITER_ENABLED)
-XMLPUBFUN xmlNodePtr XMLCALL   
+XMLPUBFUN xmlNodePtr XMLCALL
                xmlReplaceNode          (xmlNodePtr old,
                                         xmlNodePtr cur);
 #endif /* defined(LIBXML_TREE_ENABLED) || defined(LIBXML_WRITER_ENABLED) */
 #if defined(LIBXML_TREE_ENABLED) || defined(LIBXML_HTML_ENABLED) || \
-    defined(LIBXML_SCHEMAS_ENABLED)
-XMLPUBFUN xmlNodePtr XMLCALL   
+    defined(LIBXML_SCHEMAS_ENABLED) || defined(LIBXML_XINCLUDE_ENABLED)
+XMLPUBFUN xmlNodePtr XMLCALL
                xmlAddPrevSibling       (xmlNodePtr cur,
                                         xmlNodePtr elem);
 #endif /* LIBXML_TREE_ENABLED || LIBXML_HTML_ENABLED || LIBXML_SCHEMAS_ENABLED */
-XMLPUBFUN xmlNodePtr XMLCALL   
+XMLPUBFUN xmlNodePtr XMLCALL
                xmlAddSibling           (xmlNodePtr cur,
                                         xmlNodePtr elem);
-XMLPUBFUN xmlNodePtr XMLCALL   
+XMLPUBFUN xmlNodePtr XMLCALL
                xmlAddNextSibling       (xmlNodePtr cur,
                                         xmlNodePtr elem);
-XMLPUBFUN void XMLCALL         
+XMLPUBFUN void XMLCALL
                xmlUnlinkNode           (xmlNodePtr cur);
-XMLPUBFUN xmlNodePtr XMLCALL   
+XMLPUBFUN xmlNodePtr XMLCALL
                xmlTextMerge            (xmlNodePtr first,
                                         xmlNodePtr second);
-XMLPUBFUN int XMLCALL          
+XMLPUBFUN int XMLCALL
                xmlTextConcat           (xmlNodePtr node,
                                         const xmlChar *content,
                                         int len);
-XMLPUBFUN void XMLCALL         
+XMLPUBFUN void XMLCALL
                xmlFreeNodeList         (xmlNodePtr cur);
-XMLPUBFUN void XMLCALL         
+XMLPUBFUN void XMLCALL
                xmlFreeNode             (xmlNodePtr cur);
-XMLPUBFUN void XMLCALL         
+XMLPUBFUN void XMLCALL
                xmlSetTreeDoc           (xmlNodePtr tree,
                                         xmlDocPtr doc);
-XMLPUBFUN void XMLCALL         
+XMLPUBFUN void XMLCALL
                xmlSetListDoc           (xmlNodePtr list,
                                         xmlDocPtr doc);
 /*
  * Namespaces.
  */
-XMLPUBFUN xmlNsPtr XMLCALL     
+XMLPUBFUN xmlNsPtr XMLCALL
                xmlSearchNs             (xmlDocPtr doc,
                                         xmlNodePtr node,
                                         const xmlChar *nameSpace);
-XMLPUBFUN xmlNsPtr XMLCALL     
+XMLPUBFUN xmlNsPtr XMLCALL
                xmlSearchNsByHref       (xmlDocPtr doc,
                                         xmlNodePtr node,
                                         const xmlChar *href);
-#if defined(LIBXML_TREE_ENABLED) || defined(LIBXML_XPATH_ENABLED) || defined(LIBXML_SCHEMAS_ENABLED)
-XMLPUBFUN xmlNsPtr * XMLCALL   
-               xmlGetNsList            (xmlDocPtr doc,
-                                        xmlNodePtr node);
+#if defined(LIBXML_TREE_ENABLED) || defined(LIBXML_XPATH_ENABLED) || \
+    defined(LIBXML_SCHEMAS_ENABLED)
+XMLPUBFUN xmlNsPtr * XMLCALL
+               xmlGetNsList            (const xmlDoc *doc,
+                                        const xmlNode *node);
 #endif /* defined(LIBXML_TREE_ENABLED) || defined(LIBXML_XPATH_ENABLED) */
 
-XMLPUBFUN void XMLCALL         
+XMLPUBFUN void XMLCALL
                xmlSetNs                (xmlNodePtr node,
                                         xmlNsPtr ns);
-XMLPUBFUN xmlNsPtr XMLCALL     
+XMLPUBFUN xmlNsPtr XMLCALL
                xmlCopyNamespace        (xmlNsPtr cur);
-XMLPUBFUN xmlNsPtr XMLCALL     
+XMLPUBFUN xmlNsPtr XMLCALL
                xmlCopyNamespaceList    (xmlNsPtr cur);
 
 /*
  * Changing the content.
  */
-#if defined(LIBXML_TREE_ENABLED) || defined(LIBXML_XINCLUDE_ENABLED) || defined(LIBXML_SCHEMAS_ENABLED) || defined(LIBXML_HTML_ENABLED)
-XMLPUBFUN xmlAttrPtr XMLCALL   
+#if defined(LIBXML_TREE_ENABLED) || defined(LIBXML_XINCLUDE_ENABLED) || \
+    defined(LIBXML_SCHEMAS_ENABLED) || defined(LIBXML_HTML_ENABLED)
+XMLPUBFUN xmlAttrPtr XMLCALL
                xmlSetProp              (xmlNodePtr node,
                                         const xmlChar *name,
                                         const xmlChar *value);
-XMLPUBFUN xmlAttrPtr XMLCALL   
+XMLPUBFUN xmlAttrPtr XMLCALL
                xmlSetNsProp            (xmlNodePtr node,
                                         xmlNsPtr ns,
                                         const xmlChar *name,
                                         const xmlChar *value);
-#endif /* defined(LIBXML_TREE_ENABLED) || defined(LIBXML_XINCLUDE_ENABLED) || defined(LIBXML_SCHEMAS_ENABLED) || defined(LIBXML_HTML_ENABLED) */
-XMLPUBFUN xmlChar * XMLCALL    
-               xmlGetNoNsProp          (xmlNodePtr node,
+#endif /* defined(LIBXML_TREE_ENABLED) || defined(LIBXML_XINCLUDE_ENABLED) || \
+         defined(LIBXML_SCHEMAS_ENABLED) || defined(LIBXML_HTML_ENABLED) */
+XMLPUBFUN xmlChar * XMLCALL
+               xmlGetNoNsProp          (const xmlNode *node,
                                         const xmlChar *name);
-XMLPUBFUN xmlChar * XMLCALL    
-               xmlGetProp              (xmlNodePtr node,
+XMLPUBFUN xmlChar * XMLCALL
+               xmlGetProp              (const xmlNode *node,
                                         const xmlChar *name);
-XMLPUBFUN xmlAttrPtr XMLCALL   
-               xmlHasProp              (xmlNodePtr node,
+XMLPUBFUN xmlAttrPtr XMLCALL
+               xmlHasProp              (const xmlNode *node,
                                         const xmlChar *name);
-XMLPUBFUN xmlAttrPtr XMLCALL   
-               xmlHasNsProp            (xmlNodePtr node,
+XMLPUBFUN xmlAttrPtr XMLCALL
+               xmlHasNsProp            (const xmlNode *node,
                                         const xmlChar *name,
                                         const xmlChar *nameSpace);
-XMLPUBFUN xmlChar * XMLCALL    
-               xmlGetNsProp            (xmlNodePtr node,
+XMLPUBFUN xmlChar * XMLCALL
+               xmlGetNsProp            (const xmlNode *node,
                                         const xmlChar *name,
                                         const xmlChar *nameSpace);
-XMLPUBFUN xmlNodePtr XMLCALL   
-               xmlStringGetNodeList    (xmlDocPtr doc,
+XMLPUBFUN xmlNodePtr XMLCALL
+               xmlStringGetNodeList    (const xmlDoc *doc,
                                         const xmlChar *value);
-XMLPUBFUN xmlNodePtr XMLCALL   
-               xmlStringLenGetNodeList (xmlDocPtr doc,
+XMLPUBFUN xmlNodePtr XMLCALL
+               xmlStringLenGetNodeList (const xmlDoc *doc,
                                         const xmlChar *value,
                                         int len);
-XMLPUBFUN xmlChar * XMLCALL    
+XMLPUBFUN xmlChar * XMLCALL
                xmlNodeListGetString    (xmlDocPtr doc,
-                                        xmlNodePtr list,
+                                        const xmlNode *list,
                                         int inLine);
 #ifdef LIBXML_TREE_ENABLED
-XMLPUBFUN xmlChar * XMLCALL    
-               xmlNodeListGetRawString (xmlDocPtr doc,
-                                        xmlNodePtr list,
+XMLPUBFUN xmlChar * XMLCALL
+               xmlNodeListGetRawString (const xmlDoc *doc,
+                                        const xmlNode *list,
                                         int inLine);
 #endif /* LIBXML_TREE_ENABLED */
-XMLPUBFUN void XMLCALL         
+XMLPUBFUN void XMLCALL
                xmlNodeSetContent       (xmlNodePtr cur,
                                         const xmlChar *content);
 #ifdef LIBXML_TREE_ENABLED
-XMLPUBFUN void XMLCALL         
+XMLPUBFUN void XMLCALL
                xmlNodeSetContentLen    (xmlNodePtr cur,
                                         const xmlChar *content,
                                         int len);
 #endif /* LIBXML_TREE_ENABLED */
-XMLPUBFUN void XMLCALL         
+XMLPUBFUN void XMLCALL
                xmlNodeAddContent       (xmlNodePtr cur,
                                         const xmlChar *content);
-XMLPUBFUN void XMLCALL         
+XMLPUBFUN void XMLCALL
                xmlNodeAddContentLen    (xmlNodePtr cur,
                                         const xmlChar *content,
                                         int len);
-XMLPUBFUN xmlChar * XMLCALL    
-               xmlNodeGetContent       (xmlNodePtr cur);
+XMLPUBFUN xmlChar * XMLCALL
+               xmlNodeGetContent       (const xmlNode *cur);
+
 XMLPUBFUN int XMLCALL
                xmlNodeBufGetContent    (xmlBufferPtr buffer,
-                                        xmlNodePtr cur);
-XMLPUBFUN xmlChar * XMLCALL    
-               xmlNodeGetLang          (xmlNodePtr cur);
-XMLPUBFUN int XMLCALL          
-               xmlNodeGetSpacePreserve (xmlNodePtr cur);
+                                        const xmlNode *cur);
+XMLPUBFUN int XMLCALL
+               xmlBufGetNodeContent    (xmlBufPtr buf,
+                                        const xmlNode *cur);
+
+XMLPUBFUN xmlChar * XMLCALL
+               xmlNodeGetLang          (const xmlNode *cur);
+XMLPUBFUN int XMLCALL
+               xmlNodeGetSpacePreserve (const xmlNode *cur);
 #ifdef LIBXML_TREE_ENABLED
-XMLPUBFUN void XMLCALL         
+XMLPUBFUN void XMLCALL
                xmlNodeSetLang          (xmlNodePtr cur,
                                         const xmlChar *lang);
-XMLPUBFUN void XMLCALL         
+XMLPUBFUN void XMLCALL
                xmlNodeSetSpacePreserve (xmlNodePtr cur,
                                         int val);
 #endif /* LIBXML_TREE_ENABLED */
-XMLPUBFUN xmlChar * XMLCALL    
-               xmlNodeGetBase          (xmlDocPtr doc,
-                                        xmlNodePtr cur);
+XMLPUBFUN xmlChar * XMLCALL
+               xmlNodeGetBase          (const xmlDoc *doc,
+                                        const xmlNode *cur);
 #if defined(LIBXML_TREE_ENABLED) || defined(LIBXML_XINCLUDE_ENABLED)
-XMLPUBFUN void XMLCALL         
+XMLPUBFUN void XMLCALL
                xmlNodeSetBase          (xmlNodePtr cur,
                                         const xmlChar *uri);
 #endif
@@ -1025,14 +1106,14 @@ XMLPUBFUN void XMLCALL
 /*
  * Removing content.
  */
-XMLPUBFUN int XMLCALL          
+XMLPUBFUN int XMLCALL
                xmlRemoveProp           (xmlAttrPtr cur);
 #if defined(LIBXML_TREE_ENABLED) || defined(LIBXML_SCHEMAS_ENABLED)
-XMLPUBFUN int XMLCALL          
+XMLPUBFUN int XMLCALL
                xmlUnsetNsProp          (xmlNodePtr node,
                                         xmlNsPtr ns,
                                         const xmlChar *name);
-XMLPUBFUN int XMLCALL          
+XMLPUBFUN int XMLCALL
                xmlUnsetProp            (xmlNodePtr node,
                                         const xmlChar *name);
 #endif /* defined(LIBXML_TREE_ENABLED) || defined(LIBXML_SCHEMAS_ENABLED) */
@@ -1040,13 +1121,13 @@ XMLPUBFUN int XMLCALL
 /*
  * Internal, don't use.
  */
-XMLPUBFUN void XMLCALL         
+XMLPUBFUN void XMLCALL
                xmlBufferWriteCHAR      (xmlBufferPtr buf,
                                         const xmlChar *string);
-XMLPUBFUN void XMLCALL         
+XMLPUBFUN void XMLCALL
                xmlBufferWriteChar      (xmlBufferPtr buf,
                                         const char *string);
-XMLPUBFUN void XMLCALL         
+XMLPUBFUN void XMLCALL
                xmlBufferWriteQuotedString(xmlBufferPtr buf,
                                         const xmlChar *string);
 
@@ -1061,7 +1142,7 @@ XMLPUBFUN void xmlAttrSerializeTxtContent(xmlBufferPtr buf,
 /*
  * Namespace handling.
  */
-XMLPUBFUN int XMLCALL          
+XMLPUBFUN int XMLCALL
                xmlReconciliateNs       (xmlDocPtr doc,
                                         xmlNodePtr tree);
 #endif
@@ -1070,61 +1151,67 @@ XMLPUBFUN int XMLCALL
 /*
  * Saving.
  */
-XMLPUBFUN void XMLCALL         
+XMLPUBFUN void XMLCALL
                xmlDocDumpFormatMemory  (xmlDocPtr cur,
                                         xmlChar **mem,
                                         int *size,
                                         int format);
-XMLPUBFUN void XMLCALL         
+XMLPUBFUN void XMLCALL
                xmlDocDumpMemory        (xmlDocPtr cur,
                                         xmlChar **mem,
                                         int *size);
-XMLPUBFUN void XMLCALL         
+XMLPUBFUN void XMLCALL
                xmlDocDumpMemoryEnc     (xmlDocPtr out_doc,
                                         xmlChar **doc_txt_ptr,
                                         int * doc_txt_len,
                                         const char *txt_encoding);
-XMLPUBFUN void XMLCALL         
+XMLPUBFUN void XMLCALL
                xmlDocDumpFormatMemoryEnc(xmlDocPtr out_doc,
                                         xmlChar **doc_txt_ptr,
                                         int * doc_txt_len,
                                         const char *txt_encoding,
                                         int format);
-XMLPUBFUN int XMLCALL          
+XMLPUBFUN int XMLCALL
                xmlDocFormatDump        (FILE *f,
                                         xmlDocPtr cur,
                                         int format);
-XMLPUBFUN int XMLCALL  
+XMLPUBFUN int XMLCALL
                xmlDocDump              (FILE *f,
                                         xmlDocPtr cur);
-XMLPUBFUN void XMLCALL         
+XMLPUBFUN void XMLCALL
                xmlElemDump             (FILE *f,
                                         xmlDocPtr doc,
                                         xmlNodePtr cur);
-XMLPUBFUN int XMLCALL          
+XMLPUBFUN int XMLCALL
                xmlSaveFile             (const char *filename,
                                         xmlDocPtr cur);
-XMLPUBFUN int XMLCALL          
+XMLPUBFUN int XMLCALL
                xmlSaveFormatFile       (const char *filename,
                                         xmlDocPtr cur,
                                         int format);
-XMLPUBFUN int XMLCALL          
+XMLPUBFUN size_t XMLCALL
+               xmlBufNodeDump          (xmlBufPtr buf,
+                                        xmlDocPtr doc,
+                                        xmlNodePtr cur,
+                                        int level,
+                                        int format);
+XMLPUBFUN int XMLCALL
                xmlNodeDump             (xmlBufferPtr buf,
                                         xmlDocPtr doc,
                                         xmlNodePtr cur,
                                         int level,
                                         int format);
 
-XMLPUBFUN int XMLCALL          
+XMLPUBFUN int XMLCALL
                xmlSaveFileTo           (xmlOutputBufferPtr buf,
                                         xmlDocPtr cur,
                                         const char *encoding);
-XMLPUBFUN int XMLCALL             
+XMLPUBFUN int XMLCALL
                xmlSaveFormatFileTo     (xmlOutputBufferPtr buf,
                                         xmlDocPtr cur,
                                         const char *encoding,
                                         int format);
-XMLPUBFUN void XMLCALL         
+XMLPUBFUN void XMLCALL
                xmlNodeDumpOutput       (xmlOutputBufferPtr buf,
                                         xmlDocPtr doc,
                                         xmlNodePtr cur,
@@ -1132,13 +1219,13 @@ XMLPUBFUN void XMLCALL
                                         int format,
                                         const char *encoding);
 
-XMLPUBFUN int XMLCALL          
+XMLPUBFUN int XMLCALL
                xmlSaveFormatFileEnc    (const char *filename,
                                         xmlDocPtr cur,
                                         const char *encoding,
                                         int format);
 
-XMLPUBFUN int XMLCALL          
+XMLPUBFUN int XMLCALL
                xmlSaveFileEnc          (const char *filename,
                                         xmlDocPtr cur,
                                         const char *encoding);
@@ -1147,21 +1234,21 @@ XMLPUBFUN int XMLCALL
 /*
  * XHTML
  */
-XMLPUBFUN int XMLCALL          
+XMLPUBFUN int XMLCALL
                xmlIsXHTML              (const xmlChar *systemID,
                                         const xmlChar *publicID);
 
 /*
  * Compression.
  */
-XMLPUBFUN int XMLCALL          
-               xmlGetDocCompressMode   (xmlDocPtr doc);
-XMLPUBFUN void XMLCALL         
+XMLPUBFUN int XMLCALL
+               xmlGetDocCompressMode   (const xmlDoc *doc);
+XMLPUBFUN void XMLCALL
                xmlSetDocCompressMode   (xmlDocPtr doc,
                                         int mode);
-XMLPUBFUN int XMLCALL          
+XMLPUBFUN int XMLCALL
                xmlGetCompressMode      (void);
-XMLPUBFUN void XMLCALL         
+XMLPUBFUN void XMLCALL
                xmlSetCompressMode      (int mode);
 
 /*
@@ -1179,7 +1266,7 @@ XMLPUBFUN int XMLCALL
            xmlDOMWrapAdoptNode         (xmlDOMWrapCtxtPtr ctxt,
                                         xmlDocPtr sourceDoc,
                                         xmlNodePtr node,
-                                        xmlDocPtr destDoc,                 
+                                        xmlDocPtr destDoc,
                                         xmlNodePtr destParent,
                                         int options);
 XMLPUBFUN int XMLCALL
@@ -1197,6 +1284,22 @@ XMLPUBFUN int XMLCALL
                                         int deep,
                                         int options);
 
+#ifdef LIBXML_TREE_ENABLED
+/*
+ * 5 interfaces from DOM ElementTraversal, but different in entities
+ * traversal.
+ */
+XMLPUBFUN unsigned long XMLCALL
+            xmlChildElementCount        (xmlNodePtr parent);
+XMLPUBFUN xmlNodePtr XMLCALL
+            xmlNextElementSibling       (xmlNodePtr node);
+XMLPUBFUN xmlNodePtr XMLCALL
+            xmlFirstElementChild        (xmlNodePtr parent);
+XMLPUBFUN xmlNodePtr XMLCALL
+            xmlLastElementChild         (xmlNodePtr parent);
+XMLPUBFUN xmlNodePtr XMLCALL
+            xmlPreviousElementSibling   (xmlNodePtr node);
+#endif
 #ifdef __cplusplus
 }
 #endif