@img/sharp-libvips-dev 1.2.2 → 1.2.3

package/include/libxml2/libxml/tree.h

@@ -1,12 +1,15 @@
-/*
- * Summary: interfaces for tree manipulation
- * Description: this module describes the structures found in an tree resulting
- *              from an XML or HTML parsing, as well as the API provided for
- *              various processing on that tree
+/**
+ * @file
+ *
+ * @brief Document tree API
  *
- * Copy: See Copyright for the status of this software.
+ * Data structures and functions to build, modify, query and
+ * serialize XML and HTML document trees. Also contains the
+ * buffer API.
  *
- * Author: Daniel Veillard
+ * @copyright See Copyright for the status of this software.
+ *
+ * @author Daniel Veillard
  */
 
 #ifndef XML_TREE_INTERNALS
@@ -19,7 +22,9 @@
 #else /* XML_TREE_INTERNALS */
 
 #ifndef __XML_TREE_H__
+/** @cond ignore */
 #define __XML_TREE_H__
+/** @endcond */
 
 #include <stdio.h>
 #include <limits.h>
@@ -35,52 +40,56 @@ extern "C" {
 /*
  * Backward compatibility
  */
+/** @cond ignore */
 #define xmlBufferAllocScheme XML_BUFFER_ALLOC_EXACT
 #define xmlDefaultBufferSize 4096
+#define XML_GET_CONTENT(n) \
+    ((n)->type == XML_ELEMENT_NODE ? NULL : (n)->content)
+#define XML_GET_LINE(n)	xmlGetLineNo(n)
+/** @endcond */
 
 /*
  * Some of the basic types pointer to structures:
  */
 /* xmlIO.h */
+/**
+ * Parser input buffer
+ *
+ * This struct and all related functions should ultimately
+ * be removed from the public interface.
+ */
 typedef struct _xmlParserInputBuffer xmlParserInputBuffer;
 typedef xmlParserInputBuffer *xmlParserInputBufferPtr;
 
+/** Output buffer */
 typedef struct _xmlOutputBuffer xmlOutputBuffer;
 typedef xmlOutputBuffer *xmlOutputBufferPtr;
 
 /* parser.h */
+/** Parser input */
 typedef struct _xmlParserInput xmlParserInput;
 typedef xmlParserInput *xmlParserInputPtr;
 
+/** Parser context */
 typedef struct _xmlParserCtxt xmlParserCtxt;
 typedef xmlParserCtxt *xmlParserCtxtPtr;
 
+/** SAX locator */
 typedef struct _xmlSAXLocator xmlSAXLocator;
 typedef xmlSAXLocator *xmlSAXLocatorPtr;
 
+/** SAX handler */
 typedef struct _xmlSAXHandler xmlSAXHandler;
 typedef xmlSAXHandler *xmlSAXHandlerPtr;
 
 /* entities.h */
+/** Entity declaration */
 typedef struct _xmlEntity xmlEntity;
 typedef xmlEntity *xmlEntityPtr;
 
 /**
- * LIBXML_NAMESPACE_DICT:
- *
- * Defines experimental behaviour:
- * 1) xmlNs gets an additional field @context (a xmlDoc)
- * 2) when creating a tree, xmlNs->href is stored in the dict of xmlDoc.
+ * Removed, buffers always use XML_BUFFER_ALLOC_IO now.
  */
-/* #define LIBXML_NAMESPACE_DICT */
-
-/**
- * xmlBufferAllocationScheme:
- *
- * A buffer allocation scheme can be defined to either match exactly the
- * need or double it's allocated size each time it is found too small.
- */
-
 typedef enum {
     XML_BUFFER_ALLOC_DOUBLEIT,	/* double each time one need to grow */
     XML_BUFFER_ALLOC_EXACT,	/* grow only to the minimal size */
@@ -90,18 +99,25 @@ typedef enum {
     XML_BUFFER_ALLOC_BOUNDED	/* limit the upper size of the buffer */
 } xmlBufferAllocationScheme;
 
+/** Buffer type */
+typedef struct _xmlBuffer xmlBuffer;
+typedef xmlBuffer *xmlBufferPtr;
 /**
- * xmlBuffer:
- *
  * A buffer structure, this old construct is limited to 2GB and
- * is being deprecated, use API with xmlBuf instead
+ * is being deprecated, use API with xmlBuf instead.
  */
-typedef struct _xmlBuffer xmlBuffer;
-typedef xmlBuffer *xmlBufferPtr;
 struct _xmlBuffer {
-    /* The buffer content UTF8 */
+    /**
+     * @deprecated Use #xmlBufferContent
+     *
+     * The buffer content UTF8
+     */
     xmlChar *content XML_DEPRECATED_MEMBER;
-    /* The buffer size used */
+    /**
+     * @deprecated Use #xmlBufferLength
+     *
+     * The buffer size used
+     */
     unsigned int use XML_DEPRECATED_MEMBER;
     /* The buffer size */
     unsigned int size XML_DEPRECATED_MEMBER;
@@ -111,35 +127,11 @@ struct _xmlBuffer {
     xmlChar *contentIO XML_DEPRECATED_MEMBER;
 };
 
-/**
- * xmlBuf:
- *
- * A buffer structure, new one, the actual structure internals are not public
- */
-
+/** Buffer with 64-bit support */
 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*       xmlBufContent	(const xmlBuf* buf);
-XMLPUBFUN xmlChar*       xmlBufEnd      (xmlBufPtr buf);
-XMLPUBFUN size_t         xmlBufUse      (const xmlBufPtr buf);
-XMLPUBFUN size_t         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.
@@ -147,8 +139,6 @@ XMLPUBFUN size_t         xmlBufShrink	(xmlBufPtr buf, size_t len);
 #define LIBXML2_NEW_BUFFER
 
 /**
- * XML_XML_NAMESPACE:
- *
  * This is the namespace for the special xml: prefix predefined in the
  * XML Namespace specification.
  */
@@ -156,70 +146,166 @@ XMLPUBFUN size_t         xmlBufShrink	(xmlBufPtr buf, size_t len);
     (const xmlChar *) "http://www.w3.org/XML/1998/namespace"
 
 /**
- * XML_XML_ID:
- *
  * This is the name for the special xml:id attribute
  */
 #define XML_XML_ID (const xmlChar *) "xml:id"
 
-/*
+/**
  * The different element types carried by an XML tree.
  *
- * NOTE: This is synchronized with DOM Level1 values
+ * NOTE: This is synchronized with DOM Level 1 values.
  *       See http://www.w3.org/TR/REC-DOM-Level-1/
  *
- * Actually this had diverged a bit, and now XML_DOCUMENT_TYPE_NODE should
- * be deprecated to use an XML_DTD_NODE.
+ * Actually this had diverged a bit, and XML_DTD_NODE is used instead
+ * of XML_DOCUMENT_TYPE_NODE.
  */
 typedef enum {
+    /**
+     * An element.
+     *
+     * Objects of this type are an xmlNode.
+     */
     XML_ELEMENT_NODE=		1,
+    /**
+     * An attribute.
+     *
+     * Objects of this type are an xmlAttr.
+     */
     XML_ATTRIBUTE_NODE=		2,
+    /**
+     * A text node.
+     *
+     * Objects of this type are an xmlNode.
+     */
     XML_TEXT_NODE=		3,
+    /**
+     * A CDATA section.
+     *
+     * Objects of this type are an xmlNode.
+     */
     XML_CDATA_SECTION_NODE=	4,
+    /**
+     * An entity reference.
+     *
+     * Objects of this type are an xmlNode. The `children` member
+     * points to the entity declaration if available.
+     */
     XML_ENTITY_REF_NODE=	5,
-    XML_ENTITY_NODE=		6,  /* unused */
+    /** unused */
+    XML_ENTITY_NODE=		6,
+    /**
+     * A processing instruction.
+     *
+     * Objects of this type are an xmlNode.
+     */
     XML_PI_NODE=		7,
+    /**
+     * A comment.
+     *
+     * Objects of this type are an xmlNode.
+     */
     XML_COMMENT_NODE=		8,
+    /**
+     * A document.
+     *
+     * Objects of this type are an xmlDoc.
+     */
     XML_DOCUMENT_NODE=		9,
-    XML_DOCUMENT_TYPE_NODE=	10, /* unused */
+    /** unused */
+    XML_DOCUMENT_TYPE_NODE=	10,
+    /**
+     * A document fragment.
+     *
+     * Objects of this type are an xmlNode.
+     */
     XML_DOCUMENT_FRAG_NODE=	11,
-    XML_NOTATION_NODE=		12, /* unused */
+    /** A notation, unused */
+    XML_NOTATION_NODE=		12,
+    /**
+     * An HTML document.
+     *
+     * Objects of this type are an xmlDoc.
+     */
     XML_HTML_DOCUMENT_NODE=	13,
+    /**
+     * A document type definition.
+     *
+     * Objects of this type are an xmlDtd.
+     */
     XML_DTD_NODE=		14,
+    /**
+     * An element declaration.
+     *
+     * Objects of this type are an xmlElement.
+     */
     XML_ELEMENT_DECL=		15,
+    /**
+     * An attribute declaration.
+     *
+     * Objects of this type are an xmlAttribute.
+     */
     XML_ATTRIBUTE_DECL=		16,
+    /**
+     * An entity declaration.
+     *
+     * Objects of this type are an xmlEntity.
+     */
     XML_ENTITY_DECL=		17,
+    /**
+     * An XPath namespace node.
+     *
+     * Can only be returned by the XPath engine. Objects of this
+     * type are an xmlNs which has a completely different layout
+     * than xmlNode. The `next` member contains a pointer to the
+     * xmlNode element to which the namespace applies.
+     *
+     * Nodes of this type must be handled with extreme care to
+     * avoid type confusion bugs.
+     */
     XML_NAMESPACE_DECL=		18,
+    /**
+     * An XInclude start marker.
+     *
+     * Objects of this type are an xmlNode. Inserted as preceding
+     * sibling of XIncluded content.
+     */
     XML_XINCLUDE_START=		19,
+    /**
+     * An XInclude end marker.
+     *
+     * Objects of this type are an xmlNode. Inserted as following
+     * sibling of XIncluded content.
+     */
     XML_XINCLUDE_END=		20
     /* XML_DOCB_DOCUMENT_NODE=	21 */ /* removed */
 } xmlElementType;
 
-/** DOC_DISABLE */
+/** @cond IGNORE */
 /* For backward compatibility */
 #define XML_DOCB_DOCUMENT_NODE 21
-/** DOC_ENABLE */
+/** @endcond */
 
+/** Notation declaration */
+typedef struct _xmlNotation xmlNotation;
+typedef xmlNotation *xmlNotationPtr;
 /**
- * xmlNotation:
- *
  * A DTD Notation definition.
+ *
+ * Should be treated as opaque. Accessing members directly
+ * is deprecated.
  */
-
-typedef struct _xmlNotation xmlNotation;
-typedef xmlNotation *xmlNotationPtr;
 struct _xmlNotation {
-    const xmlChar               *name;	        /* Notation name */
-    const xmlChar               *PublicID;	/* Public identifier, if any */
-    const xmlChar               *SystemID;	/* System identifier, if any */
+    /** Notation name */
+    const xmlChar               *name XML_DEPRECATED_MEMBER;
+    /** Public identifier, if any */
+    const xmlChar               *PublicID XML_DEPRECATED_MEMBER;
+    /** System identifier, if any */
+    const xmlChar               *SystemID XML_DEPRECATED_MEMBER;
 };
 
 /**
- * xmlAttributeType:
- *
  * A DTD Attribute type definition.
  */
-
 typedef enum {
     XML_ATTRIBUTE_CDATA = 1,
     XML_ATTRIBUTE_ID,
@@ -234,11 +320,8 @@ typedef enum {
 } xmlAttributeType;
 
 /**
- * xmlAttributeDefault:
- *
  * A DTD Attribute default definition.
  */
-
 typedef enum {
     XML_ATTRIBUTE_NONE = 1,
     XML_ATTRIBUTE_REQUIRED,
@@ -246,50 +329,68 @@ typedef enum {
     XML_ATTRIBUTE_FIXED
 } xmlAttributeDefault;
 
+/** Enumeration in a DTD */
+typedef struct _xmlEnumeration xmlEnumeration;
+typedef xmlEnumeration *xmlEnumerationPtr;
 /**
- * xmlEnumeration:
- *
  * List structure used when there is an enumeration in DTDs.
+ *
+ * Should be treated as opaque. Accessing members directly
+ * is deprecated.
  */
-
-typedef struct _xmlEnumeration xmlEnumeration;
-typedef xmlEnumeration *xmlEnumerationPtr;
 struct _xmlEnumeration {
-    struct _xmlEnumeration    *next;	/* next one */
-    const xmlChar            *name;	/* Enumeration name */
+    /** next enumeration */
+    struct _xmlEnumeration    *next XML_DEPRECATED_MEMBER;
+    /** value */
+    const xmlChar            *name XML_DEPRECATED_MEMBER;
 };
 
+/** Attribute declaration */
+typedef struct _xmlAttribute xmlAttribute;
+typedef xmlAttribute *xmlAttributePtr;
 /**
- * xmlAttribute:
- *
  * An Attribute declaration in a DTD.
+ *
+ * Should be treated as opaque. Accessing members directly
+ * is deprecated.
  */
-
-typedef struct _xmlAttribute xmlAttribute;
-typedef xmlAttribute *xmlAttributePtr;
 struct _xmlAttribute {
-    void           *_private;	        /* application data */
-    xmlElementType          type;       /* XML_ATTRIBUTE_DECL, must be second ! */
-    const xmlChar          *name;	/* Attribute name */
-    struct _xmlNode    *children;	/* NULL */
-    struct _xmlNode        *last;	/* NULL */
-    struct _xmlDtd       *parent;	/* -> DTD */
-    struct _xmlNode        *next;	/* next sibling link  */
-    struct _xmlNode        *prev;	/* previous sibling link  */
-    struct _xmlDoc          *doc;       /* the containing document */
-
-    struct _xmlAttribute  *nexth;	/* next in hash table */
-    xmlAttributeType       atype;	/* The attribute type */
-    xmlAttributeDefault      def;	/* the default */
-    const xmlChar  *defaultValue;	/* or the default value */
-    xmlEnumerationPtr       tree;       /* or the enumeration tree if any */
-    const xmlChar        *prefix;	/* the namespace prefix if any */
-    const xmlChar          *elem;	/* Element holding the attribute */
+    /** application data */
+    void           *_private;
+    /** XML_ATTRIBUTE_DECL */
+    xmlElementType          type;
+    /** attribute name */
+    const xmlChar          *name;
+    /** NULL */
+    struct _xmlNode    *children;
+    /** NULL */
+    struct _xmlNode        *last;
+    /** DTD */
+    struct _xmlDtd       *parent;
+    /** next sibling */
+    struct _xmlNode        *next;
+    /** previous sibling */
+    struct _xmlNode        *prev;
+    /** containing document */
+    struct _xmlDoc          *doc;
+
+    /** next in hash table */
+    struct _xmlAttribute  *nexth XML_DEPRECATED_MEMBER;
+    /** attribute type */
+    xmlAttributeType       atype XML_DEPRECATED_MEMBER;
+    /** attribute default */
+    xmlAttributeDefault      def XML_DEPRECATED_MEMBER;
+    /** default value */
+    xmlChar *defaultValue;
+    /** enumeration tree if any */
+    xmlEnumeration         *tree XML_DEPRECATED_MEMBER;
+    /** namespace prefix if any */
+    const xmlChar        *prefix;
+    /** element name */
+    const xmlChar          *elem XML_DEPRECATED_MEMBER;
 };
 
 /**
- * xmlElementContentType:
- *
  * Possible definitions of element content types.
  */
 typedef enum {
@@ -300,8 +401,6 @@ typedef enum {
 } xmlElementContentType;
 
 /**
- * xmlElementContentOccur:
- *
  * Possible definitions of element content occurrences.
  */
 typedef enum {
@@ -311,31 +410,36 @@ typedef enum {
     XML_ELEMENT_CONTENT_PLUS
 } xmlElementContentOccur;
 
+/** Element content in element declarations */
+typedef struct _xmlElementContent xmlElementContent;
+typedef xmlElementContent *xmlElementContentPtr;
 /**
- * xmlElementContent:
- *
  * An XML Element content as stored after parsing an element definition
  * in a DTD.
+ *
+ * Should be treated as opaque. Accessing members directly
+ * is deprecated.
  */
-
-typedef struct _xmlElementContent xmlElementContent;
-typedef xmlElementContent *xmlElementContentPtr;
 struct _xmlElementContent {
-    xmlElementContentType     type;	/* PCDATA, ELEMENT, SEQ or OR */
-    xmlElementContentOccur    ocur;	/* ONCE, OPT, MULT or PLUS */
-    const xmlChar             *name;	/* Element name */
-    struct _xmlElementContent *c1;	/* first child */
-    struct _xmlElementContent *c2;	/* second child */
-    struct _xmlElementContent *parent;	/* parent */
-    const xmlChar             *prefix;	/* Namespace prefix */
+    /** PCDATA, ELEMENT, SEQ or OR */
+    xmlElementContentType     type XML_DEPRECATED_MEMBER;
+    /** ONCE, OPT, MULT or PLUS */
+    xmlElementContentOccur    ocur XML_DEPRECATED_MEMBER;
+    /** element name */
+    const xmlChar             *name XML_DEPRECATED_MEMBER;
+    /** first child */
+    struct _xmlElementContent *c1 XML_DEPRECATED_MEMBER;
+    /** second child */
+    struct _xmlElementContent *c2 XML_DEPRECATED_MEMBER;
+    /** parent */
+    struct _xmlElementContent *parent XML_DEPRECATED_MEMBER;
+    /** namespace prefix */
+    const xmlChar             *prefix XML_DEPRECATED_MEMBER;
 };
 
 /**
- * xmlElementTypeVal:
- *
  * The different possibilities for an element content type.
  */
-
 typedef enum {
     XML_ELEMENT_TYPE_UNDEFINED = 0,
     XML_ELEMENT_TYPE_EMPTY = 1,
@@ -344,279 +448,424 @@ typedef enum {
     XML_ELEMENT_TYPE_ELEMENT
 } xmlElementTypeVal;
 
+/** Element declaration */
+typedef struct _xmlElement xmlElement;
+typedef xmlElement *xmlElementPtr;
 /**
- * xmlElement:
- *
  * An XML Element declaration from a DTD.
+ *
+ * Should be treated as opaque. Accessing members directly
+ * is deprecated.
  */
-
-typedef struct _xmlElement xmlElement;
-typedef xmlElement *xmlElementPtr;
 struct _xmlElement {
-    void           *_private;	        /* application data */
-    xmlElementType          type;       /* XML_ELEMENT_DECL, must be second ! */
-    const xmlChar          *name;	/* Element name */
-    struct _xmlNode    *children;	/* NULL */
-    struct _xmlNode        *last;	/* NULL */
-    struct _xmlDtd       *parent;	/* -> DTD */
-    struct _xmlNode        *next;	/* next sibling link  */
-    struct _xmlNode        *prev;	/* previous sibling link  */
-    struct _xmlDoc          *doc;       /* the containing document */
-
-    xmlElementTypeVal      etype;	/* The type */
-    xmlElementContentPtr content;	/* the allowed element content */
-    xmlAttributePtr   attributes;	/* List of the declared attributes */
-    const xmlChar        *prefix;	/* the namespace prefix if any */
+    /** application data */
+    void           *_private;
+    /** XML_ELEMENT_DECL */
+    xmlElementType          type;
+    /** element name */
+    const xmlChar          *name;
+    /** NULL */
+    struct _xmlNode    *children;
+    /** NULL */
+    struct _xmlNode        *last;
+    /** -> DTD */
+    struct _xmlDtd       *parent;
+    /** next sibling */
+    struct _xmlNode        *next;
+    /** previous sibling */
+    struct _xmlNode        *prev;
+    /** containing document */
+    struct _xmlDoc          *doc;
+
+    /** element type */
+    xmlElementTypeVal      etype XML_DEPRECATED_MEMBER;
+    /** allowed element content */
+    xmlElementContent *content XML_DEPRECATED_MEMBER;
+    /** list of declared attributes */
+    xmlAttribute     *attributes XML_DEPRECATED_MEMBER;
+    /** namespace prefix if any */
+    const xmlChar        *prefix XML_DEPRECATED_MEMBER;
 #ifdef LIBXML_REGEXP_ENABLED
-    xmlRegexpPtr       contModel;	/* the validating regexp */
+    /** validating regexp */
+    xmlRegexp         *contModel XML_DEPRECATED_MEMBER;
 #else
-    void	      *contModel;
+    void	      *contModel XML_DEPRECATED_MEMBER;
 #endif
 };
 
 
 /**
- * XML_LOCAL_NAMESPACE:
- *
  * A namespace declaration node.
  */
 #define XML_LOCAL_NAMESPACE XML_NAMESPACE_DECL
 typedef xmlElementType xmlNsType;
 
+/** Namespace declaration */
+typedef struct _xmlNs xmlNs;
+typedef xmlNs *xmlNsPtr;
 /**
- * xmlNs:
- *
  * An XML namespace.
  * Note that prefix == NULL is valid, it defines the default namespace
  * within the subtree (until overridden).
  *
  * xmlNsType is unified with xmlElementType.
+ *
+ * Note that the XPath engine returns XPath namespace nodes as
+ * xmlNs cast to xmlNode. This is a terrible design decision that
+ * can easily cause type confusion errors. In this case, the `next`
+ * member points to the xmlNode element to which the namespace
+ * node belongs.
  */
-
-typedef struct _xmlNs xmlNs;
-typedef xmlNs *xmlNsPtr;
 struct _xmlNs {
-    struct _xmlNs  *next;	/* next Ns link for this node  */
-    xmlNsType      type;	/* global or local */
-    const xmlChar *href;	/* URL for the namespace */
-    const xmlChar *prefix;	/* prefix for the namespace */
-    void           *_private;   /* application data */
-    struct _xmlDoc *context;		/* normally an xmlDoc */
+    /** next namespace */
+    struct _xmlNs  *next;
+    /** XML_NAMESPACE_DECL */
+    xmlNsType      type;
+    /** namespace URI */
+    const xmlChar *href;
+    /** namespace prefix */
+    const xmlChar *prefix;
+    /** application data */
+    void           *_private;
+    /** normally an xmlDoc */
+    struct _xmlDoc *context XML_DEPRECATED_MEMBER;
 };
 
+/** Document type definition (DTD) */
+typedef struct _xmlDtd xmlDtd;
+typedef xmlDtd *xmlDtdPtr;
 /**
- * xmlDtd:
- *
  * An XML DTD, as defined by <!DOCTYPE ... There is actually one for
  * the internal subset and for the external subset.
+ *
+ * Should be treated as opaque. Accessing members directly
+ * is deprecated.
  */
-typedef struct _xmlDtd xmlDtd;
-typedef xmlDtd *xmlDtdPtr;
 struct _xmlDtd {
-    void           *_private;	/* application data */
-    xmlElementType  type;       /* XML_DTD_NODE, must be second ! */
-    const xmlChar *name;	/* Name of the DTD */
-    struct _xmlNode *children;	/* the value of the property link */
-    struct _xmlNode *last;	/* last child link */
-    struct _xmlDoc  *parent;	/* child->parent link */
-    struct _xmlNode *next;	/* next sibling link  */
-    struct _xmlNode *prev;	/* previous sibling link  */
-    struct _xmlDoc  *doc;	/* the containing document */
+    /** application data */
+    void           *_private;
+    /** XML_DTD_NODE */
+    xmlElementType  type;
+    /** name of the DTD */
+    const xmlChar *name;
+    /** first child */
+    struct _xmlNode *children;
+    /** last child */
+    struct _xmlNode *last;
+    /** parent node */
+    struct _xmlDoc  *parent;
+    /** next sibling */
+    struct _xmlNode *next;
+    /** previous sibling */
+    struct _xmlNode *prev;
+    /** containing document */
+    struct _xmlDoc  *doc;
 
     /* End of common part */
-    void          *notations;   /* Hash table for notations if any */
-    void          *elements;    /* Hash table for elements if any */
-    void          *attributes;  /* Hash table for attributes if any */
-    void          *entities;    /* Hash table for entities if any */
-    const xmlChar *ExternalID;	/* External identifier for PUBLIC DTD */
-    const xmlChar *SystemID;	/* URI for a SYSTEM or PUBLIC DTD */
-    void          *pentities;   /* Hash table for param entities if any */
+
+    /** hash table for notations if any */
+    void          *notations XML_DEPRECATED_MEMBER;
+    /** hash table for elements if any */
+    void          *elements XML_DEPRECATED_MEMBER;
+    /** hash table for attributes if any */
+    void          *attributes XML_DEPRECATED_MEMBER;
+    /** hash table for entities if any */
+    void          *entities XML_DEPRECATED_MEMBER;
+    /** public identifier */
+    xmlChar *ExternalID XML_DEPRECATED_MEMBER;
+    /** system identifier */
+    xmlChar *SystemID XML_DEPRECATED_MEMBER;
+    /** hash table for parameter entities if any */
+    void          *pentities XML_DEPRECATED_MEMBER;
 };
 
-/**
- * xmlAttr:
- *
- * An attribute on an XML node.
- */
+/** Attribute of an element */
 typedef struct _xmlAttr xmlAttr;
 typedef xmlAttr *xmlAttrPtr;
-struct _xmlAttr {
-    void           *_private;	/* application data */
-    xmlElementType   type;      /* XML_ATTRIBUTE_NODE, must be second ! */
-    const xmlChar   *name;      /* the name of the property */
-    struct _xmlNode *children;	/* the value of the property */
-    struct _xmlNode *last;	/* NULL */
-    struct _xmlNode *parent;	/* child->parent link */
-    struct _xmlAttr *next;	/* next sibling link  */
-    struct _xmlAttr *prev;	/* previous sibling link  */
-    struct _xmlDoc  *doc;	/* the containing document */
-    xmlNs           *ns;        /* pointer to the associated namespace */
-    xmlAttributeType atype;     /* the attribute type if validating */
-    void            *psvi;	/* for type/PSVI information */
-    struct _xmlID   *id;        /* the ID struct */
-};
-
 /**
- * xmlID:
- *
- * An XML ID instance.
+ * An attribute of element.
  */
+struct _xmlAttr {
+    /** application data */
+    void           *_private;
+    /** XML_ATTRIBUTE_NODE */
+    xmlElementType   type;
+    /** local name */
+    const xmlChar   *name;
+    /** first child */
+    struct _xmlNode *children;
+    /** last child */
+    struct _xmlNode *last;
+    /** parent node */
+    struct _xmlNode *parent;
+    /** next sibling */
+    struct _xmlAttr *next;
+    /** previous sibling */
+    struct _xmlAttr *prev;
+    /** containing document */
+    struct _xmlDoc  *doc;
+    /** namespace if any */
+    xmlNs           *ns;
+    /** attribute type if validating */
+    xmlAttributeType atype;
+    /** for type/PSVI information */
+    void            *psvi;
+    /** ID struct if any */
+    struct _xmlID   *id XML_DEPRECATED_MEMBER;
+};
 
+/** Extra data for ID attributes */
 typedef struct _xmlID xmlID;
 typedef xmlID *xmlIDPtr;
-struct _xmlID {
-    struct _xmlID    *next;	/* next ID */
-    const xmlChar    *value;	/* The ID name */
-    xmlAttrPtr        attr;	/* The attribute holding it */
-    const xmlChar    *name;	/* The attribute if attr is not available */
-    int               lineno;	/* The line number if attr is not available */
-    struct _xmlDoc   *doc;	/* The document holding the ID */
-};
-
 /**
- * xmlRef:
+ * An XML ID instance.
  *
- * An XML IDREF instance.
+ * Should be treated as opaque. Accessing members directly
+ * is deprecated.
  */
+struct _xmlID {
+    /* next ID */
+    struct _xmlID    *next XML_DEPRECATED_MEMBER;
+    /* The ID name */
+    xmlChar *value XML_DEPRECATED_MEMBER;
+    /* The attribute holding it */
+    xmlAttr          *attr XML_DEPRECATED_MEMBER;
+    /* The attribute if attr is not available */
+    const xmlChar    *name XML_DEPRECATED_MEMBER;
+    /* The line number if attr is not available */
+    int               lineno XML_DEPRECATED_MEMBER;
+    /* The document holding the ID */
+    struct _xmlDoc   *doc XML_DEPRECATED_MEMBER;
+};
 
+/** @cond ignore */
 typedef struct _xmlRef xmlRef;
 typedef xmlRef *xmlRefPtr;
+/*
+ * An XML IDREF instance.
+ */
 struct _xmlRef {
-    struct _xmlRef    *next;	/* next Ref */
-    const xmlChar     *value;	/* The Ref name */
-    xmlAttrPtr        attr;	/* The attribute holding it */
-    const xmlChar    *name;	/* The attribute if attr is not available */
-    int               lineno;	/* The line number if attr is not available */
+    /* next Ref */
+    struct _xmlRef    *next XML_DEPRECATED_MEMBER;
+    /* The Ref name */
+    const xmlChar     *value XML_DEPRECATED_MEMBER;
+    /* The attribute holding it */
+    xmlAttr          *attr XML_DEPRECATED_MEMBER;
+    /* The attribute if attr is not available */
+    const xmlChar    *name XML_DEPRECATED_MEMBER;
+    /* The line number if attr is not available */
+    int               lineno XML_DEPRECATED_MEMBER;
 };
+/** @endcond */
 
+/** Generic node type in an XML or HTML tree */
+typedef struct _xmlNode xmlNode;
+typedef xmlNode *xmlNodePtr;
 /**
- * xmlNode:
+ * Generic node type in an XML or HTML tree.
+ *
+ * This is used for
+ *
+ * - XML_ELEMENT_NODE
+ * - XML_TEXT_NODE
+ * - XML_CDATA_SECTION_NODE
+ * - XML_ENTITY_REF_NODE
+ * - XML_PI_NODE
+ * - XML_COMMENT_NODE
+ * - XML_DOCUMENT_FRAG_NODE
+ * - XML_XINCLUDE_START_NODE
+ * - XML_XINCLUDE_END_NODE
+ *
+ * Other node types have a different struct layout than xmlNode,
+ * see xmlElementType. Except for XML_NAMESPACE_DECL all nodes
+ * share the following members at the same offset:
+ *
+ * - `_private`
+ * - `type` (also for XML_NAMESPACE_DECL)
+ * - `name`
+ * - `children`
+ * - `last`
+ * - `parent`
+ * - `next`
+ * - `prev`
+ * - `doc`
  *
- * A node in an XML tree.
+ * xmlNode and xmlAttr also share the `ns` member.
  */
-typedef struct _xmlNode xmlNode;
-typedef xmlNode *xmlNodePtr;
 struct _xmlNode {
-    void           *_private;	/* application data */
-    xmlElementType   type;	/* type number, must be second ! */
-    const xmlChar   *name;      /* the name of the node, or the entity */
-    struct _xmlNode *children;	/* parent->childs link */
-    struct _xmlNode *last;	/* last child link */
-    struct _xmlNode *parent;	/* child->parent link */
-    struct _xmlNode *next;	/* next sibling link  */
-    struct _xmlNode *prev;	/* previous sibling link  */
-    struct _xmlDoc  *doc;	/* the containing document */
+    /** Application data. Often used by language bindings. */
+    void           *_private;
+    /** Type enum, an xmlElementType value */
+    xmlElementType   type;
+    /**
+     * Name of the node.
+     *
+     * - Local name of elements or attributes. As a corner case,
+     *   this can also contain Names which are invalid QNames in
+     *   non-namespace-wellformed documents.
+     * - Name of entity references
+     * - Target of processing instructions
+     * - Fixed string for text and comments
+     * - Unused otherwise
+     */
+    const xmlChar   *name;
+    /** First child. Entity declaration of entity references. */
+    struct _xmlNode *children;
+    /** Last child */
+    struct _xmlNode *last;
+    /** Parent node. NULL for documents or unlinked root nodes. */
+    struct _xmlNode *parent;
+    /** Next sibling */
+    struct _xmlNode *next;
+    /** Previous sibling */
+    struct _xmlNode *prev;
+    /**
+     * Associated document.
+     *
+     * Used to access DTDs, entities, ID tables, dictionary or
+     * other document properties. All children of a node share the
+     * same document.
+     */
+    struct _xmlDoc  *doc;
 
     /* End of common part */
-    xmlNs           *ns;        /* pointer to the associated namespace */
-    xmlChar         *content;   /* the content */
-    struct _xmlAttr *properties;/* properties list */
-    xmlNs           *nsDef;     /* namespace definitions on this node */
-    void            *psvi;	/* for type/PSVI information */
-    unsigned short   line;	/* line number */
-    unsigned short   extra;	/* extra data for XPath/XSLT */
-};
-
-/**
- * XML_GET_CONTENT:
- *
- * Macro to extract the content pointer of a node.
- */
-#define XML_GET_CONTENT(n)					\
-    ((n)->type == XML_ELEMENT_NODE ? NULL : (n)->content)
 
-/**
- * XML_GET_LINE:
- *
- * Macro to extract the line number of an element node.
- */
-#define XML_GET_LINE(n)						\
-    (xmlGetLineNo(n))
+    /** Namespace of element if any */
+    xmlNs           *ns;
+    /**
+     * Content of text, comment, PI nodes.
+     *
+     * Sort index for elements after calling #xmlXPathOrderDocElems.
+     * Content of internal entities for entity references.
+     */
+    xmlChar         *content;
+    /**
+     * First attribute of element.
+     *
+     * Also used to store small strings with XML_PARSE_COMPACT.
+     */
+    struct _xmlAttr *properties;
+    /** First namespace definition of element */
+    xmlNs           *nsDef;
+    /** For type/PSVI information */
+    void            *psvi;
+    /** Line number */
+    unsigned short   line;
+    /** Extra data for XPath/XSLT */
+    unsigned short   extra;
+};
 
 /**
- * xmlDocProperty
- *
- * Set of properties of the document as found by the parser
- * Some of them are linked to similarly named xmlParserOption
+ * Set of properties of the document as found by the parser.
+ * Some of them are linked to similarly 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 */
+    /** document is XML well formed */
+    XML_DOC_WELLFORMED		= 1<<0,
+    /** document is Namespace valid */
+    XML_DOC_NSVALID		= 1<<1,
+    /** parsed with old XML-1.0 parser */
+    XML_DOC_OLD10		= 1<<2,
+    /** DTD validation was successful */
+    XML_DOC_DTDVALID		= 1<<3,
+    /** XInclude substitution was done */
+    XML_DOC_XINCLUDE		= 1<<4,
+    /** Document was built using the API and not by parsing an instance */
+    XML_DOC_USERBUILT		= 1<<5,
+    /** built for internal processing */
+    XML_DOC_INTERNAL		= 1<<6,
+    /** parsed or built HTML document */
+    XML_DOC_HTML		= 1<<7
 } xmlDocProperties;
 
-/**
- * xmlDoc:
- *
- * An XML document.
- */
+/** XML or HTML document */
 typedef struct _xmlDoc xmlDoc;
 typedef xmlDoc *xmlDocPtr;
+/**
+ * An XML or HTML document.
+ */
 struct _xmlDoc {
-    void           *_private;	/* application data */
-    xmlElementType  type;       /* XML_DOCUMENT_NODE, must be second ! */
-    char           *name;	/* name/filename/URI of the document */
-    struct _xmlNode *children;	/* the document tree */
-    struct _xmlNode *last;	/* last child link */
-    struct _xmlNode *parent;	/* child->parent link */
-    struct _xmlNode *next;	/* next sibling link  */
-    struct _xmlNode *prev;	/* previous sibling link  */
-    struct _xmlDoc  *doc;	/* autoreference to itself */
+    /** application data */
+    void           *_private;
+    /** XML_DOCUMENT_NODE or XML_HTML_DOCUMENT_NODE */
+    xmlElementType  type;
+    /** NULL */
+    char           *name;
+    /** first child */
+    struct _xmlNode *children;
+    /** last child */
+    struct _xmlNode *last;
+    /** parent node */
+    struct _xmlNode *parent;
+    /** next sibling */
+    struct _xmlNode *next;
+    /** previous sibling */
+    struct _xmlNode *prev;
+    /** reference to itself */
+    struct _xmlDoc  *doc;
 
     /* End of common part */
-    int             compression;/* level of zlib compression */
-    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 */
-    const xmlChar  *version;	/* the XML version string */
-    const xmlChar  *encoding;   /* actual encoding, if any */
-    void           *ids;        /* Hash table for ID attributes if any */
-    void           *refs;       /* Hash table for IDREFs attributes if any */
-    const xmlChar  *URL;	/* The URI for that document */
-    int             charset;    /* unused */
-    struct _xmlDict *dict;      /* dict used to allocate names or NULL */
-    void           *psvi;	/* for type/PSVI information */
-    int             parseFlags;	/* set of xmlParserOption used to parse the
-				   document */
-    int             properties;	/* set of xmlDocProperties for this document
-				   set at the end of parsing */
+
+    /** level of zlib compression */
+    int             compression;
+    /**
+     * 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
+     */
+    int             standalone;
+    /** internal subset */
+    struct _xmlDtd  *intSubset;
+    /** external subset */
+    struct _xmlDtd  *extSubset;
+    /** used to hold the XML namespace if needed */
+    struct _xmlNs   *oldNs XML_DEPRECATED_MEMBER;
+    /** version string from XML declaration */
+    xmlChar  *version;
+    /** actual encoding if any */
+    xmlChar  *encoding;
+    /** hash table for ID attributes if any */
+    void           *ids;
+    /** hash table for IDREFs attributes if any */
+    void           *refs XML_DEPRECATED_MEMBER;
+    /** URI of the document */
+    xmlChar  *URL;
+    /** unused */
+    int             charset;
+    /** dict used to allocate names if any */
+    struct _xmlDict *dict;
+    /** for type/PSVI information */
+    void           *psvi;
+    /** xmlParserOption enum used to parse the document */
+    int             parseFlags;
+    /** xmlDocProperties of the document */
+    int             properties;
 };
 
 
+/** Context for DOM wrapper operations */
 typedef struct _xmlDOMWrapCtxt xmlDOMWrapCtxt;
 typedef xmlDOMWrapCtxt *xmlDOMWrapCtxtPtr;
 
 /**
- * xmlDOMWrapAcquireNsFunction:
- * @ctxt:  a DOM wrapper context
- * @node:  the context node (element or attribute)
- * @nsName:  the requested namespace name
- * @nsPrefix:  the requested namespace prefix
- *
  * A function called to acquire namespaces (xmlNs) from the wrapper.
  *
- * Returns an xmlNsPtr or NULL in case of an error.
+ * @param ctxt  a DOM wrapper context
+ * @param node  the context node (element or attribute)
+ * @param nsName  the requested namespace name
+ * @param nsPrefix  the requested namespace prefix
+ * @returns an xmlNs or NULL in case of an error.
  */
-typedef xmlNsPtr (*xmlDOMWrapAcquireNsFunction) (xmlDOMWrapCtxtPtr ctxt,
-						 xmlNodePtr node,
+typedef xmlNs *(*xmlDOMWrapAcquireNsFunction) (xmlDOMWrapCtxt *ctxt,
+						 xmlNode *node,
 						 const xmlChar *nsName,
 						 const xmlChar *nsPrefix);
 
 /**
- * xmlDOMWrapCtxt:
- *
  * Context for DOM wrapper-operations.
  */
 struct _xmlDOMWrapCtxt {
@@ -631,31 +880,27 @@ struct _xmlDOMWrapCtxt {
     */
     void * namespaceMap;
     /*
-    * Use this one to acquire an xmlNsPtr intended for node->ns.
+    * Use this one to acquire an xmlNs intended for node->ns.
     * (Note that this is not intended for elem->nsDef).
     */
     xmlDOMWrapAcquireNsFunction getNsForNodeFunc;
 };
 
 /**
- * xmlRegisterNodeFunc:
- * @node: the current node
- *
  * Signature for the registration callback of a created node
+ *
+ * @param node  the current node
  */
-typedef void (*xmlRegisterNodeFunc) (xmlNodePtr node);
+typedef void (*xmlRegisterNodeFunc) (xmlNode *node);
 
 /**
- * xmlDeregisterNodeFunc:
- * @node: the current node
- *
  * Signature for the deregistration callback of a discarded node
+ *
+ * @param node  the current node
  */
-typedef void (*xmlDeregisterNodeFunc) (xmlNodePtr node);
+typedef void (*xmlDeregisterNodeFunc) (xmlNode *node);
 
 /**
- * xmlChildrenNode:
- *
  * Macro for compatibility naming layer with libxml1. Maps
  * to "children."
  */
@@ -664,8 +909,6 @@ typedef void (*xmlDeregisterNodeFunc) (xmlNodePtr node);
 #endif
 
 /**
- * xmlRootNode:
- *
  * Macro for compatibility naming layer with libxml1. Maps
  * to "children".
  */
@@ -677,7 +920,8 @@ typedef void (*xmlDeregisterNodeFunc) (xmlNodePtr node);
  * Variables.
  */
 
-/** DOC_DISABLE */
+/** @cond ignore */
+
 XML_DEPRECATED
 XMLPUBFUN xmlRegisterNodeFunc *__xmlRegisterNodeDefaultValue(void);
 XML_DEPRECATED
@@ -689,7 +933,8 @@ XMLPUBFUN xmlDeregisterNodeFunc *__xmlDeregisterNodeDefaultValue(void);
   #define xmlDeregisterNodeDefaultValue \
     (*__xmlDeregisterNodeDefaultValue())
 #endif
-/** DOC_ENABLE */
+
+/** @endcond */
 
 /*
  * Some helper functions
@@ -720,211 +965,150 @@ XMLPUBFUN const xmlChar *
 		xmlSplitQName3		(const xmlChar *name,
 					 int *len);
 
-/*
- * Handling Buffers, the old ones see @xmlBuf for the new ones.
- */
-
-XML_DEPRECATED
-XMLPUBFUN void
-		xmlSetBufferAllocationScheme(xmlBufferAllocationScheme scheme);
-XML_DEPRECATED
-XMLPUBFUN xmlBufferAllocationScheme
-		xmlGetBufferAllocationScheme(void);
-
-XMLPUBFUN xmlBufferPtr
-		xmlBufferCreate		(void);
-XMLPUBFUN xmlBufferPtr
-		xmlBufferCreateSize	(size_t size);
-XMLPUBFUN xmlBufferPtr
-		xmlBufferCreateStatic	(void *mem,
-					 size_t size);
-XML_DEPRECATED
-XMLPUBFUN int
-		xmlBufferResize		(xmlBufferPtr buf,
-					 unsigned int size);
-XMLPUBFUN void
-		xmlBufferFree		(xmlBufferPtr buf);
-XMLPUBFUN int
-		xmlBufferDump		(FILE *file,
-					 xmlBufferPtr buf);
-XMLPUBFUN int
-		xmlBufferAdd		(xmlBufferPtr buf,
-					 const xmlChar *str,
-					 int len);
-XMLPUBFUN int
-		xmlBufferAddHead	(xmlBufferPtr buf,
-					 const xmlChar *str,
-					 int len);
-XMLPUBFUN int
-		xmlBufferCat		(xmlBufferPtr buf,
-					 const xmlChar *str);
-XMLPUBFUN int
-		xmlBufferCCat		(xmlBufferPtr buf,
-					 const char *str);
-XML_DEPRECATED
-XMLPUBFUN int
-		xmlBufferShrink		(xmlBufferPtr buf,
-					 unsigned int len);
-XML_DEPRECATED
-XMLPUBFUN int
-		xmlBufferGrow		(xmlBufferPtr buf,
-					 unsigned int len);
-XMLPUBFUN void
-		xmlBufferEmpty		(xmlBufferPtr buf);
-XMLPUBFUN const xmlChar*
-		xmlBufferContent	(const xmlBuffer *buf);
-XMLPUBFUN xmlChar*
-		xmlBufferDetach         (xmlBufferPtr buf);
-XMLPUBFUN void
-		xmlBufferSetAllocationScheme(xmlBufferPtr buf,
-					 xmlBufferAllocationScheme scheme);
-XMLPUBFUN int
-		xmlBufferLength		(const xmlBuffer *buf);
-
 /*
  * Creating/freeing new structures.
  */
-XMLPUBFUN xmlDtdPtr
-		xmlCreateIntSubset	(xmlDocPtr doc,
+XMLPUBFUN xmlDtd *
+		xmlCreateIntSubset	(xmlDoc *doc,
 					 const xmlChar *name,
-					 const xmlChar *ExternalID,
-					 const xmlChar *SystemID);
-XMLPUBFUN xmlDtdPtr
-		xmlNewDtd		(xmlDocPtr doc,
+					 const xmlChar *publicId,
+					 const xmlChar *systemId);
+XMLPUBFUN xmlDtd *
+		xmlNewDtd		(xmlDoc *doc,
 					 const xmlChar *name,
-					 const xmlChar *ExternalID,
-					 const xmlChar *SystemID);
-XMLPUBFUN xmlDtdPtr
+					 const xmlChar *publicId,
+					 const xmlChar *systemId);
+XMLPUBFUN xmlDtd *
 		xmlGetIntSubset		(const xmlDoc *doc);
 XMLPUBFUN void
-		xmlFreeDtd		(xmlDtdPtr cur);
-XMLPUBFUN xmlNsPtr
-		xmlNewNs		(xmlNodePtr node,
+		xmlFreeDtd		(xmlDtd *cur);
+XMLPUBFUN xmlNs *
+		xmlNewNs		(xmlNode *node,
 					 const xmlChar *href,
 					 const xmlChar *prefix);
 XMLPUBFUN void
-		xmlFreeNs		(xmlNsPtr cur);
+		xmlFreeNs		(xmlNs *cur);
 XMLPUBFUN void
-		xmlFreeNsList		(xmlNsPtr cur);
-XMLPUBFUN xmlDocPtr
+		xmlFreeNsList		(xmlNs *cur);
+XMLPUBFUN xmlDoc *
 		xmlNewDoc		(const xmlChar *version);
 XMLPUBFUN void
-		xmlFreeDoc		(xmlDocPtr cur);
-XMLPUBFUN xmlAttrPtr
-		xmlNewDocProp		(xmlDocPtr doc,
+		xmlFreeDoc		(xmlDoc *cur);
+XMLPUBFUN xmlAttr *
+		xmlNewDocProp		(xmlDoc *doc,
 					 const xmlChar *name,
 					 const xmlChar *value);
-XMLPUBFUN xmlAttrPtr
-		xmlNewProp		(xmlNodePtr node,
+XMLPUBFUN xmlAttr *
+		xmlNewProp		(xmlNode *node,
 					 const xmlChar *name,
 					 const xmlChar *value);
-XMLPUBFUN xmlAttrPtr
-		xmlNewNsProp		(xmlNodePtr node,
-					 xmlNsPtr ns,
+XMLPUBFUN xmlAttr *
+		xmlNewNsProp		(xmlNode *node,
+					 xmlNs *ns,
 					 const xmlChar *name,
 					 const xmlChar *value);
-XMLPUBFUN xmlAttrPtr
-		xmlNewNsPropEatName	(xmlNodePtr node,
-					 xmlNsPtr ns,
+XMLPUBFUN xmlAttr *
+		xmlNewNsPropEatName	(xmlNode *node,
+					 xmlNs *ns,
 					 xmlChar *name,
 					 const xmlChar *value);
 XMLPUBFUN void
-		xmlFreePropList		(xmlAttrPtr cur);
+		xmlFreePropList		(xmlAttr *cur);
 XMLPUBFUN void
-		xmlFreeProp		(xmlAttrPtr cur);
-XMLPUBFUN xmlAttrPtr
-		xmlCopyProp		(xmlNodePtr target,
-					 xmlAttrPtr cur);
-XMLPUBFUN xmlAttrPtr
-		xmlCopyPropList		(xmlNodePtr target,
-					 xmlAttrPtr cur);
-XMLPUBFUN xmlDtdPtr
-		xmlCopyDtd		(xmlDtdPtr dtd);
-XMLPUBFUN xmlDocPtr
-		xmlCopyDoc		(xmlDocPtr doc,
+		xmlFreeProp		(xmlAttr *cur);
+XMLPUBFUN xmlAttr *
+		xmlCopyProp		(xmlNode *target,
+					 xmlAttr *cur);
+XMLPUBFUN xmlAttr *
+		xmlCopyPropList		(xmlNode *target,
+					 xmlAttr *cur);
+XMLPUBFUN xmlDtd *
+		xmlCopyDtd		(xmlDtd *dtd);
+XMLPUBFUN xmlDoc *
+		xmlCopyDoc		(xmlDoc *doc,
 					 int recursive);
 /*
  * Creating new nodes.
  */
-XMLPUBFUN xmlNodePtr
-		xmlNewDocNode		(xmlDocPtr doc,
-					 xmlNsPtr ns,
+XMLPUBFUN xmlNode *
+		xmlNewDocNode		(xmlDoc *doc,
+					 xmlNs *ns,
 					 const xmlChar *name,
 					 const xmlChar *content);
-XMLPUBFUN xmlNodePtr
-		xmlNewDocNodeEatName	(xmlDocPtr doc,
-					 xmlNsPtr ns,
+XMLPUBFUN xmlNode *
+		xmlNewDocNodeEatName	(xmlDoc *doc,
+					 xmlNs *ns,
 					 xmlChar *name,
 					 const xmlChar *content);
-XMLPUBFUN xmlNodePtr
-		xmlNewNode		(xmlNsPtr ns,
+XMLPUBFUN xmlNode *
+		xmlNewNode		(xmlNs *ns,
 					 const xmlChar *name);
-XMLPUBFUN xmlNodePtr
-		xmlNewNodeEatName	(xmlNsPtr ns,
+XMLPUBFUN xmlNode *
+		xmlNewNodeEatName	(xmlNs *ns,
 					 xmlChar *name);
-XMLPUBFUN xmlNodePtr
-		xmlNewChild		(xmlNodePtr parent,
-					 xmlNsPtr ns,
+XMLPUBFUN xmlNode *
+		xmlNewChild		(xmlNode *parent,
+					 xmlNs *ns,
 					 const xmlChar *name,
 					 const xmlChar *content);
-XMLPUBFUN xmlNodePtr
+XMLPUBFUN xmlNode *
 		xmlNewDocText		(const xmlDoc *doc,
 					 const xmlChar *content);
-XMLPUBFUN xmlNodePtr
+XMLPUBFUN xmlNode *
 		xmlNewText		(const xmlChar *content);
-XMLPUBFUN xmlNodePtr
-		xmlNewDocPI		(xmlDocPtr doc,
+XMLPUBFUN xmlNode *
+		xmlNewDocPI		(xmlDoc *doc,
 					 const xmlChar *name,
 					 const xmlChar *content);
-XMLPUBFUN xmlNodePtr
+XMLPUBFUN xmlNode *
 		xmlNewPI		(const xmlChar *name,
 					 const xmlChar *content);
-XMLPUBFUN xmlNodePtr
-		xmlNewDocTextLen	(xmlDocPtr doc,
+XMLPUBFUN xmlNode *
+		xmlNewDocTextLen	(xmlDoc *doc,
 					 const xmlChar *content,
 					 int len);
-XMLPUBFUN xmlNodePtr
+XMLPUBFUN xmlNode *
 		xmlNewTextLen		(const xmlChar *content,
 					 int len);
-XMLPUBFUN xmlNodePtr
-		xmlNewDocComment	(xmlDocPtr doc,
+XMLPUBFUN xmlNode *
+		xmlNewDocComment	(xmlDoc *doc,
 					 const xmlChar *content);
-XMLPUBFUN xmlNodePtr
+XMLPUBFUN xmlNode *
 		xmlNewComment		(const xmlChar *content);
-XMLPUBFUN xmlNodePtr
-		xmlNewCDataBlock	(xmlDocPtr doc,
+XMLPUBFUN xmlNode *
+		xmlNewCDataBlock	(xmlDoc *doc,
 					 const xmlChar *content,
 					 int len);
-XMLPUBFUN xmlNodePtr
-		xmlNewCharRef		(xmlDocPtr doc,
+XMLPUBFUN xmlNode *
+		xmlNewCharRef		(xmlDoc *doc,
 					 const xmlChar *name);
-XMLPUBFUN xmlNodePtr
+XMLPUBFUN xmlNode *
 		xmlNewReference		(const xmlDoc *doc,
 					 const xmlChar *name);
-XMLPUBFUN xmlNodePtr
-		xmlCopyNode		(xmlNodePtr node,
+XMLPUBFUN xmlNode *
+		xmlCopyNode		(xmlNode *node,
 					 int recursive);
-XMLPUBFUN xmlNodePtr
-		xmlDocCopyNode		(xmlNodePtr node,
-					 xmlDocPtr doc,
+XMLPUBFUN xmlNode *
+		xmlDocCopyNode		(xmlNode *node,
+					 xmlDoc *doc,
 					 int recursive);
-XMLPUBFUN xmlNodePtr
-		xmlDocCopyNodeList	(xmlDocPtr doc,
-					 xmlNodePtr node);
-XMLPUBFUN xmlNodePtr
-		xmlCopyNodeList		(xmlNodePtr node);
-XMLPUBFUN xmlNodePtr
-		xmlNewTextChild		(xmlNodePtr parent,
-					 xmlNsPtr ns,
+XMLPUBFUN xmlNode *
+		xmlDocCopyNodeList	(xmlDoc *doc,
+					 xmlNode *node);
+XMLPUBFUN xmlNode *
+		xmlCopyNodeList		(xmlNode *node);
+XMLPUBFUN xmlNode *
+		xmlNewTextChild		(xmlNode *parent,
+					 xmlNs *ns,
 					 const xmlChar *name,
 					 const xmlChar *content);
-XMLPUBFUN xmlNodePtr
-		xmlNewDocRawNode	(xmlDocPtr doc,
-					 xmlNsPtr ns,
+XMLPUBFUN xmlNode *
+		xmlNewDocRawNode	(xmlDoc *doc,
+					 xmlNs *ns,
 					 const xmlChar *name,
 					 const xmlChar *content);
-XMLPUBFUN xmlNodePtr
-		xmlNewDocFragment	(xmlDocPtr doc);
+XMLPUBFUN xmlNode *
+		xmlNewDocFragment	(xmlDoc *doc);
 
 /*
  * Navigating.
@@ -933,9 +1117,9 @@ XMLPUBFUN long
 		xmlGetLineNo		(const xmlNode *node);
 XMLPUBFUN xmlChar *
 		xmlGetNodePath		(const xmlNode *node);
-XMLPUBFUN xmlNodePtr
+XMLPUBFUN xmlNode *
 		xmlDocGetRootElement	(const xmlDoc *doc);
-XMLPUBFUN xmlNodePtr
+XMLPUBFUN xmlNode *
 		xmlGetLastChild		(const xmlNode *parent);
 XMLPUBFUN int
 		xmlNodeIsText		(const xmlNode *node);
@@ -945,86 +1129,86 @@ XMLPUBFUN int
 /*
  * Changing the structure.
  */
-XMLPUBFUN xmlNodePtr
-		xmlDocSetRootElement	(xmlDocPtr doc,
-					 xmlNodePtr root);
+XMLPUBFUN xmlNode *
+		xmlDocSetRootElement	(xmlDoc *doc,
+					 xmlNode *root);
 XMLPUBFUN void
-		xmlNodeSetName		(xmlNodePtr cur,
+		xmlNodeSetName		(xmlNode *cur,
 					 const xmlChar *name);
-XMLPUBFUN xmlNodePtr
-		xmlAddChild		(xmlNodePtr parent,
-					 xmlNodePtr cur);
-XMLPUBFUN xmlNodePtr
-		xmlAddChildList		(xmlNodePtr parent,
-					 xmlNodePtr cur);
-XMLPUBFUN xmlNodePtr
-		xmlReplaceNode		(xmlNodePtr old,
-					 xmlNodePtr cur);
-XMLPUBFUN xmlNodePtr
-		xmlAddPrevSibling	(xmlNodePtr cur,
-					 xmlNodePtr elem);
-XMLPUBFUN xmlNodePtr
-		xmlAddSibling		(xmlNodePtr cur,
-					 xmlNodePtr elem);
-XMLPUBFUN xmlNodePtr
-		xmlAddNextSibling	(xmlNodePtr cur,
-					 xmlNodePtr elem);
+XMLPUBFUN xmlNode *
+		xmlAddChild		(xmlNode *parent,
+					 xmlNode *cur);
+XMLPUBFUN xmlNode *
+		xmlAddChildList		(xmlNode *parent,
+					 xmlNode *cur);
+XMLPUBFUN xmlNode *
+		xmlReplaceNode		(xmlNode *old,
+					 xmlNode *cur);
+XMLPUBFUN xmlNode *
+		xmlAddPrevSibling	(xmlNode *cur,
+					 xmlNode *elem);
+XMLPUBFUN xmlNode *
+		xmlAddSibling		(xmlNode *cur,
+					 xmlNode *elem);
+XMLPUBFUN xmlNode *
+		xmlAddNextSibling	(xmlNode *cur,
+					 xmlNode *elem);
 XMLPUBFUN void
-		xmlUnlinkNode		(xmlNodePtr cur);
-XMLPUBFUN xmlNodePtr
-		xmlTextMerge		(xmlNodePtr first,
-					 xmlNodePtr second);
+		xmlUnlinkNode		(xmlNode *cur);
+XMLPUBFUN xmlNode *
+		xmlTextMerge		(xmlNode *first,
+					 xmlNode *second);
 XMLPUBFUN int
-		xmlTextConcat		(xmlNodePtr node,
+		xmlTextConcat		(xmlNode *node,
 					 const xmlChar *content,
 					 int len);
 XMLPUBFUN void
-		xmlFreeNodeList		(xmlNodePtr cur);
+		xmlFreeNodeList		(xmlNode *cur);
 XMLPUBFUN void
-		xmlFreeNode		(xmlNodePtr cur);
+		xmlFreeNode		(xmlNode *cur);
 XMLPUBFUN int
-		xmlSetTreeDoc		(xmlNodePtr tree,
-					 xmlDocPtr doc);
+		xmlSetTreeDoc		(xmlNode *tree,
+					 xmlDoc *doc);
 XMLPUBFUN int
-		xmlSetListDoc		(xmlNodePtr list,
-					 xmlDocPtr doc);
+		xmlSetListDoc		(xmlNode *list,
+					 xmlDoc *doc);
 /*
  * Namespaces.
  */
-XMLPUBFUN xmlNsPtr
-		xmlSearchNs		(xmlDocPtr doc,
-					 xmlNodePtr node,
+XMLPUBFUN xmlNs *
+		xmlSearchNs		(xmlDoc *doc,
+					 xmlNode *node,
 					 const xmlChar *nameSpace);
-XMLPUBFUN xmlNsPtr
-		xmlSearchNsByHref	(xmlDocPtr doc,
-					 xmlNodePtr node,
+XMLPUBFUN xmlNs *
+		xmlSearchNsByHref	(xmlDoc *doc,
+					 xmlNode *node,
 					 const xmlChar *href);
 XMLPUBFUN int
 		xmlGetNsListSafe	(const xmlDoc *doc,
 					 const xmlNode *node,
-					 xmlNsPtr **out);
-XMLPUBFUN xmlNsPtr *
+					 xmlNs ***out);
+XMLPUBFUN xmlNs **
 		xmlGetNsList		(const xmlDoc *doc,
 					 const xmlNode *node);
 
 XMLPUBFUN void
-		xmlSetNs		(xmlNodePtr node,
-					 xmlNsPtr ns);
-XMLPUBFUN xmlNsPtr
-		xmlCopyNamespace	(xmlNsPtr cur);
-XMLPUBFUN xmlNsPtr
-		xmlCopyNamespaceList	(xmlNsPtr cur);
+		xmlSetNs		(xmlNode *node,
+					 xmlNs *ns);
+XMLPUBFUN xmlNs *
+		xmlCopyNamespace	(xmlNs *cur);
+XMLPUBFUN xmlNs *
+		xmlCopyNamespaceList	(xmlNs *cur);
 
 /*
  * Changing the content.
  */
-XMLPUBFUN xmlAttrPtr
-		xmlSetProp		(xmlNodePtr node,
+XMLPUBFUN xmlAttr *
+		xmlSetProp		(xmlNode *node,
 					 const xmlChar *name,
 					 const xmlChar *value);
-XMLPUBFUN xmlAttrPtr
-		xmlSetNsProp		(xmlNodePtr node,
-					 xmlNsPtr ns,
+XMLPUBFUN xmlAttr *
+		xmlSetNsProp		(xmlNode *node,
+					 xmlNs *ns,
 					 const xmlChar *name,
 					 const xmlChar *value);
 XMLPUBFUN int
@@ -1038,10 +1222,10 @@ XMLPUBFUN xmlChar *
 XMLPUBFUN xmlChar *
 		xmlGetProp		(const xmlNode *node,
 					 const xmlChar *name);
-XMLPUBFUN xmlAttrPtr
+XMLPUBFUN xmlAttr *
 		xmlHasProp		(const xmlNode *node,
 					 const xmlChar *name);
-XMLPUBFUN xmlAttrPtr
+XMLPUBFUN xmlAttr *
 		xmlHasNsProp		(const xmlNode *node,
 					 const xmlChar *name,
 					 const xmlChar *nameSpace);
@@ -1049,15 +1233,15 @@ XMLPUBFUN xmlChar *
 		xmlGetNsProp		(const xmlNode *node,
 					 const xmlChar *name,
 					 const xmlChar *nameSpace);
-XMLPUBFUN xmlNodePtr
+XMLPUBFUN xmlNode *
 		xmlStringGetNodeList	(const xmlDoc *doc,
 					 const xmlChar *value);
-XMLPUBFUN xmlNodePtr
+XMLPUBFUN xmlNode *
 		xmlStringLenGetNodeList	(const xmlDoc *doc,
 					 const xmlChar *value,
 					 int len);
 XMLPUBFUN xmlChar *
-		xmlNodeListGetString	(xmlDocPtr doc,
+		xmlNodeListGetString	(xmlDoc *doc,
 					 const xmlNode *list,
 					 int inLine);
 XMLPUBFUN xmlChar *
@@ -1065,27 +1249,27 @@ XMLPUBFUN xmlChar *
 					 const xmlNode *list,
 					 int inLine);
 XMLPUBFUN int
-		xmlNodeSetContent	(xmlNodePtr cur,
+		xmlNodeSetContent	(xmlNode *cur,
 					 const xmlChar *content);
 XMLPUBFUN int
-		xmlNodeSetContentLen	(xmlNodePtr cur,
+		xmlNodeSetContentLen	(xmlNode *cur,
 					 const xmlChar *content,
 					 int len);
 XMLPUBFUN int
-		xmlNodeAddContent	(xmlNodePtr cur,
+		xmlNodeAddContent	(xmlNode *cur,
 					 const xmlChar *content);
 XMLPUBFUN int
-		xmlNodeAddContentLen	(xmlNodePtr cur,
+		xmlNodeAddContentLen	(xmlNode *cur,
 					 const xmlChar *content,
 					 int len);
 XMLPUBFUN xmlChar *
 		xmlNodeGetContent	(const xmlNode *cur);
 
 XMLPUBFUN int
-		xmlNodeBufGetContent	(xmlBufferPtr buffer,
+		xmlNodeBufGetContent	(xmlBuffer *buffer,
 					 const xmlNode *cur);
 XMLPUBFUN int
-		xmlBufGetNodeContent	(xmlBufPtr buf,
+		xmlBufGetNodeContent	(xmlBuf *buf,
 					 const xmlNode *cur);
 
 XMLPUBFUN xmlChar *
@@ -1093,10 +1277,10 @@ XMLPUBFUN xmlChar *
 XMLPUBFUN int
 		xmlNodeGetSpacePreserve	(const xmlNode *cur);
 XMLPUBFUN int
-		xmlNodeSetLang		(xmlNodePtr cur,
+		xmlNodeSetLang		(xmlNode *cur,
 					 const xmlChar *lang);
 XMLPUBFUN int
-		xmlNodeSetSpacePreserve (xmlNodePtr cur,
+		xmlNodeSetSpacePreserve (xmlNode *cur,
 					 int val);
 XMLPUBFUN int
 		xmlNodeGetBaseSafe	(const xmlDoc *doc,
@@ -1106,39 +1290,26 @@ XMLPUBFUN xmlChar *
 		xmlNodeGetBase		(const xmlDoc *doc,
 					 const xmlNode *cur);
 XMLPUBFUN int
-		xmlNodeSetBase		(xmlNodePtr cur,
+		xmlNodeSetBase		(xmlNode *cur,
 					 const xmlChar *uri);
 
 /*
  * Removing content.
  */
 XMLPUBFUN int
-		xmlRemoveProp		(xmlAttrPtr cur);
+		xmlRemoveProp		(xmlAttr *cur);
 XMLPUBFUN int
-		xmlUnsetNsProp		(xmlNodePtr node,
-					 xmlNsPtr ns,
+		xmlUnsetNsProp		(xmlNode *node,
+					 xmlNs *ns,
 					 const xmlChar *name);
 XMLPUBFUN int
-		xmlUnsetProp		(xmlNodePtr node,
+		xmlUnsetProp		(xmlNode *node,
 					 const xmlChar *name);
 
-/*
- * Internal, don't use.
- */
-XMLPUBFUN void
-		xmlBufferWriteCHAR	(xmlBufferPtr buf,
-					 const xmlChar *string);
-XMLPUBFUN void
-		xmlBufferWriteChar	(xmlBufferPtr buf,
-					 const char *string);
-XMLPUBFUN void
-		xmlBufferWriteQuotedString(xmlBufferPtr buf,
-					 const xmlChar *string);
-
 #ifdef LIBXML_OUTPUT_ENABLED
-XMLPUBFUN void xmlAttrSerializeTxtContent(xmlBufferPtr buf,
-					 xmlDocPtr doc,
-					 xmlAttrPtr attr,
+XMLPUBFUN void xmlAttrSerializeTxtContent(xmlBuffer *buf,
+					 xmlDoc *doc,
+					 xmlAttr *attr,
 					 const xmlChar *string);
 #endif /* LIBXML_OUTPUT_ENABLED */
 
@@ -1146,90 +1317,90 @@ XMLPUBFUN void xmlAttrSerializeTxtContent(xmlBufferPtr buf,
  * Namespace handling.
  */
 XMLPUBFUN int
-		xmlReconciliateNs	(xmlDocPtr doc,
-					 xmlNodePtr tree);
+		xmlReconciliateNs	(xmlDoc *doc,
+					 xmlNode *tree);
 
 #ifdef LIBXML_OUTPUT_ENABLED
 /*
  * Saving.
  */
 XMLPUBFUN void
-		xmlDocDumpFormatMemory	(xmlDocPtr cur,
+		xmlDocDumpFormatMemory	(xmlDoc *cur,
 					 xmlChar **mem,
 					 int *size,
 					 int format);
 XMLPUBFUN void
-		xmlDocDumpMemory	(xmlDocPtr cur,
+		xmlDocDumpMemory	(xmlDoc *cur,
 					 xmlChar **mem,
 					 int *size);
 XMLPUBFUN void
-		xmlDocDumpMemoryEnc	(xmlDocPtr out_doc,
+		xmlDocDumpMemoryEnc	(xmlDoc *out_doc,
 					 xmlChar **doc_txt_ptr,
 					 int * doc_txt_len,
 					 const char *txt_encoding);
 XMLPUBFUN void
-		xmlDocDumpFormatMemoryEnc(xmlDocPtr out_doc,
+		xmlDocDumpFormatMemoryEnc(xmlDoc *out_doc,
 					 xmlChar **doc_txt_ptr,
 					 int * doc_txt_len,
 					 const char *txt_encoding,
 					 int format);
 XMLPUBFUN int
 		xmlDocFormatDump	(FILE *f,
-					 xmlDocPtr cur,
+					 xmlDoc *cur,
 					 int format);
 XMLPUBFUN int
 		xmlDocDump		(FILE *f,
-					 xmlDocPtr cur);
+					 xmlDoc *cur);
 XMLPUBFUN void
 		xmlElemDump		(FILE *f,
-					 xmlDocPtr doc,
-					 xmlNodePtr cur);
+					 xmlDoc *doc,
+					 xmlNode *cur);
 XMLPUBFUN int
 		xmlSaveFile		(const char *filename,
-					 xmlDocPtr cur);
+					 xmlDoc *cur);
 XMLPUBFUN int
 		xmlSaveFormatFile	(const char *filename,
-					 xmlDocPtr cur,
+					 xmlDoc *cur,
 					 int format);
 XMLPUBFUN size_t
-		xmlBufNodeDump		(xmlBufPtr buf,
-					 xmlDocPtr doc,
-					 xmlNodePtr cur,
+		xmlBufNodeDump		(xmlBuf *buf,
+					 xmlDoc *doc,
+					 xmlNode *cur,
 					 int level,
 					 int format);
 XMLPUBFUN int
-		xmlNodeDump		(xmlBufferPtr buf,
-					 xmlDocPtr doc,
-					 xmlNodePtr cur,
+		xmlNodeDump		(xmlBuffer *buf,
+					 xmlDoc *doc,
+					 xmlNode *cur,
 					 int level,
 					 int format);
 
 XMLPUBFUN int
-		xmlSaveFileTo		(xmlOutputBufferPtr buf,
-					 xmlDocPtr cur,
+		xmlSaveFileTo		(xmlOutputBuffer *buf,
+					 xmlDoc *cur,
 					 const char *encoding);
 XMLPUBFUN int
-		xmlSaveFormatFileTo     (xmlOutputBufferPtr buf,
-					 xmlDocPtr cur,
+		xmlSaveFormatFileTo     (xmlOutputBuffer *buf,
+					 xmlDoc *cur,
 				         const char *encoding,
 				         int format);
 XMLPUBFUN void
-		xmlNodeDumpOutput	(xmlOutputBufferPtr buf,
-					 xmlDocPtr doc,
-					 xmlNodePtr cur,
+		xmlNodeDumpOutput	(xmlOutputBuffer *buf,
+					 xmlDoc *doc,
+					 xmlNode *cur,
 					 int level,
 					 int format,
 					 const char *encoding);
 
 XMLPUBFUN int
 		xmlSaveFormatFileEnc    (const char *filename,
-					 xmlDocPtr cur,
+					 xmlDoc *cur,
 					 const char *encoding,
 					 int format);
 
 XMLPUBFUN int
 		xmlSaveFileEnc		(const char *filename,
-					 xmlDocPtr cur,
+					 xmlDoc *cur,
 					 const char *encoding);
 
 #endif /* LIBXML_OUTPUT_ENABLED */
@@ -1246,7 +1417,7 @@ XMLPUBFUN int
 XMLPUBFUN int
 		xmlGetDocCompressMode	(const xmlDoc *doc);
 XMLPUBFUN void
-		xmlSetDocCompressMode	(xmlDocPtr doc,
+		xmlSetDocCompressMode	(xmlDoc *doc,
 					 int mode);
 XML_DEPRECATED
 XMLPUBFUN int
@@ -1258,33 +1429,33 @@ XMLPUBFUN void
 /*
 * DOM-wrapper helper functions.
 */
-XMLPUBFUN xmlDOMWrapCtxtPtr
+XMLPUBFUN xmlDOMWrapCtxt *
 		xmlDOMWrapNewCtxt	(void);
 XMLPUBFUN void
-		xmlDOMWrapFreeCtxt	(xmlDOMWrapCtxtPtr ctxt);
+		xmlDOMWrapFreeCtxt	(xmlDOMWrapCtxt *ctxt);
 XMLPUBFUN int
-	    xmlDOMWrapReconcileNamespaces(xmlDOMWrapCtxtPtr ctxt,
-					 xmlNodePtr elem,
+	    xmlDOMWrapReconcileNamespaces(xmlDOMWrapCtxt *ctxt,
+					 xmlNode *elem,
 					 int options);
 XMLPUBFUN int
-	    xmlDOMWrapAdoptNode		(xmlDOMWrapCtxtPtr ctxt,
-					 xmlDocPtr sourceDoc,
-					 xmlNodePtr node,
-					 xmlDocPtr destDoc,
-					 xmlNodePtr destParent,
+	    xmlDOMWrapAdoptNode		(xmlDOMWrapCtxt *ctxt,
+					 xmlDoc *sourceDoc,
+					 xmlNode *node,
+					 xmlDoc *destDoc,
+					 xmlNode *destParent,
 					 int options);
 XMLPUBFUN int
-	    xmlDOMWrapRemoveNode	(xmlDOMWrapCtxtPtr ctxt,
-					 xmlDocPtr doc,
-					 xmlNodePtr node,
+	    xmlDOMWrapRemoveNode	(xmlDOMWrapCtxt *ctxt,
+					 xmlDoc *doc,
+					 xmlNode *node,
 					 int options);
 XMLPUBFUN int
-	    xmlDOMWrapCloneNode		(xmlDOMWrapCtxtPtr ctxt,
-					 xmlDocPtr sourceDoc,
-					 xmlNodePtr node,
-					 xmlNodePtr *clonedNode,
-					 xmlDocPtr destDoc,
-					 xmlNodePtr destParent,
+	    xmlDOMWrapCloneNode		(xmlDOMWrapCtxt *ctxt,
+					 xmlDoc *sourceDoc,
+					 xmlNode *node,
+					 xmlNode **clonedNode,
+					 xmlDoc *destDoc,
+					 xmlNode *destParent,
 					 int deep,
 					 int options);
 
@@ -1293,15 +1464,15 @@ XMLPUBFUN int
  * traversal.
  */
 XMLPUBFUN unsigned long
-            xmlChildElementCount        (xmlNodePtr parent);
-XMLPUBFUN xmlNodePtr
-            xmlNextElementSibling       (xmlNodePtr node);
-XMLPUBFUN xmlNodePtr
-            xmlFirstElementChild        (xmlNodePtr parent);
-XMLPUBFUN xmlNodePtr
-            xmlLastElementChild         (xmlNodePtr parent);
-XMLPUBFUN xmlNodePtr
-            xmlPreviousElementSibling   (xmlNodePtr node);
+            xmlChildElementCount        (xmlNode *parent);
+XMLPUBFUN xmlNode *
+            xmlNextElementSibling       (xmlNode *node);
+XMLPUBFUN xmlNode *
+            xmlFirstElementChild        (xmlNode *parent);
+XMLPUBFUN xmlNode *
+            xmlLastElementChild         (xmlNode *parent);
+XMLPUBFUN xmlNode *
+            xmlPreviousElementSibling   (xmlNode *node);
 
 XML_DEPRECATED
 XMLPUBFUN xmlRegisterNodeFunc
@@ -1316,6 +1487,85 @@ XML_DEPRECATED
 XMLPUBFUN xmlDeregisterNodeFunc
             xmlThrDefDeregisterNodeDefault(xmlDeregisterNodeFunc func);
 
+/*
+ * Handling Buffers, the old ones see `xmlBuf` for the new ones.
+ */
+
+XML_DEPRECATED
+XMLPUBFUN void
+		xmlSetBufferAllocationScheme(xmlBufferAllocationScheme scheme);
+XML_DEPRECATED
+XMLPUBFUN xmlBufferAllocationScheme
+		xmlGetBufferAllocationScheme(void);
+
+XMLPUBFUN xmlBuffer *
+		xmlBufferCreate		(void);
+XMLPUBFUN xmlBuffer *
+		xmlBufferCreateSize	(size_t size);
+XMLPUBFUN xmlBuffer *
+		xmlBufferCreateStatic	(void *mem,
+					 size_t size);
+XML_DEPRECATED
+XMLPUBFUN int
+		xmlBufferResize		(xmlBuffer *buf,
+					 unsigned int size);
+XMLPUBFUN void
+		xmlBufferFree		(xmlBuffer *buf);
+XMLPUBFUN int
+		xmlBufferDump		(FILE *file,
+					 xmlBuffer *buf);
+XMLPUBFUN int
+		xmlBufferAdd		(xmlBuffer *buf,
+					 const xmlChar *str,
+					 int len);
+XMLPUBFUN int
+		xmlBufferAddHead	(xmlBuffer *buf,
+					 const xmlChar *str,
+					 int len);
+XMLPUBFUN int
+		xmlBufferCat		(xmlBuffer *buf,
+					 const xmlChar *str);
+XMLPUBFUN int
+		xmlBufferCCat		(xmlBuffer *buf,
+					 const char *str);
+XML_DEPRECATED
+XMLPUBFUN int
+		xmlBufferShrink		(xmlBuffer *buf,
+					 unsigned int len);
+XML_DEPRECATED
+XMLPUBFUN int
+		xmlBufferGrow		(xmlBuffer *buf,
+					 unsigned int len);
+XMLPUBFUN void
+		xmlBufferEmpty		(xmlBuffer *buf);
+XMLPUBFUN const xmlChar*
+		xmlBufferContent	(const xmlBuffer *buf);
+XMLPUBFUN xmlChar*
+		xmlBufferDetach         (xmlBuffer *buf);
+XMLPUBFUN void
+		xmlBufferSetAllocationScheme(xmlBuffer *buf,
+					 xmlBufferAllocationScheme scheme);
+XMLPUBFUN int
+		xmlBufferLength		(const xmlBuffer *buf);
+XMLPUBFUN void
+		xmlBufferWriteCHAR	(xmlBuffer *buf,
+					 const xmlChar *string);
+XMLPUBFUN void
+		xmlBufferWriteChar	(xmlBuffer *buf,
+					 const char *string);
+XMLPUBFUN void
+		xmlBufferWriteQuotedString(xmlBuffer *buf,
+					 const xmlChar *string);
+
+/*
+ * 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*       xmlBufContent	(const xmlBuf* buf);
+XMLPUBFUN xmlChar*       xmlBufEnd      (xmlBuf *buf);
+XMLPUBFUN size_t         xmlBufUse      (xmlBuf *buf);
+XMLPUBFUN size_t         xmlBufShrink	(xmlBuf *buf, size_t len);
+
 #ifdef __cplusplus
 }
 #endif