include/libxml/tree.h

/**
 * @file
 *
 * @brief Document tree API
 *
 * Data structures and functions to build, modify, query and
 * serialize XML and HTML document trees. Also contains the
 * buffer API.
 *
 * @copyright See Copyright for the status of this software.
 *
 * @author Daniel Veillard
 */

#ifndef XML_TREE_INTERNALS

/*
 * Emulate circular dependency for backward compatibility
 */
#include <libxml/parser.h>

#else /* XML_TREE_INTERNALS */

#ifndef __XML_TREE_H__
/** @cond ignore */
#define __XML_TREE_H__
/** @endcond */

#include <stdio.h>
#include <limits.h>
#include <libxml/xmlversion.h>
#include <libxml/xmlstring.h>
#include <libxml/xmlmemory.h>
#include <libxml/xmlregexp.h>

#ifdef __cplusplus
extern "C" {
#endif

/*
 * 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;

/**
 * Removed, buffers always use XML_BUFFER_ALLOC_IO now.
 */
typedef enum {
    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, deprecated */
    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;

/** Buffer type */
typedef struct _xmlBuffer xmlBuffer;
typedef xmlBuffer *xmlBufferPtr;
/**
 * A buffer structure, this old construct is limited to 2GB and
 * is being deprecated, use API with xmlBuf instead.
 */
struct _xmlBuffer {
    /**
     * @deprecated Use #xmlBufferContent
     *
     * The buffer content UTF8
     */
    xmlChar *content XML_DEPRECATED_MEMBER;
    /**
     * @deprecated Use #xmlBufferLength
     *
     * The buffer size used
     */
    unsigned int use XML_DEPRECATED_MEMBER;
    /* The buffer size */
    unsigned int size XML_DEPRECATED_MEMBER;
    /* The realloc method */
    xmlBufferAllocationScheme alloc XML_DEPRECATED_MEMBER;
    /* in IO mode we may have a different base */
    xmlChar *contentIO XML_DEPRECATED_MEMBER;
};

/** Buffer with 64-bit support */
typedef struct _xmlBuf xmlBuf;
typedef xmlBuf *xmlBufPtr;

/**
 * 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

/**
 * This is the namespace for the special xml: prefix predefined in the
 * XML Namespace specification.
 */
#define XML_XML_NAMESPACE \
    (const xmlChar *) "http://www.w3.org/XML/1998/namespace"

/**
 * 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 Level 1 values.
 *       See http://www.w3.org/TR/REC-DOM-Level-1/
 *
 * 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,
    /** 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,
    /** unused */
    XML_DOCUMENT_TYPE_NODE=	10,
    /**
     * A document fragment.
     *
     * Objects of this type are an xmlNode.
     */
    XML_DOCUMENT_FRAG_NODE=	11,
    /** 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;

/** @cond IGNORE */
/* For backward compatibility */
#define XML_DOCB_DOCUMENT_NODE 21
/** @endcond */

/** Notation declaration */
typedef struct _xmlNotation xmlNotation;
typedef xmlNotation *xmlNotationPtr;
/**
 * A DTD Notation definition.
 *
 * Should be treated as opaque. Accessing members directly
 * is deprecated.
 */
struct _xmlNotation {
    /** Notation name */
    const xmlChar               *name;
    /** Public identifier, if any */
    const xmlChar               *PublicID;
    /** System identifier, if any */
    const xmlChar               *SystemID;
};

/**
 * A DTD Attribute type definition.
 */
typedef enum {
    XML_ATTRIBUTE_CDATA = 1,
    XML_ATTRIBUTE_ID,
    XML_ATTRIBUTE_IDREF	,
    XML_ATTRIBUTE_IDREFS,
    XML_ATTRIBUTE_ENTITY,
    XML_ATTRIBUTE_ENTITIES,
    XML_ATTRIBUTE_NMTOKEN,
    XML_ATTRIBUTE_NMTOKENS,
    XML_ATTRIBUTE_ENUMERATION,
    XML_ATTRIBUTE_NOTATION
} xmlAttributeType;

/**
 * A DTD Attribute default definition.
 */
typedef enum {
    XML_ATTRIBUTE_NONE = 1,
    XML_ATTRIBUTE_REQUIRED,
    XML_ATTRIBUTE_IMPLIED,
    XML_ATTRIBUTE_FIXED
} xmlAttributeDefault;

/** Enumeration in a DTD */
typedef struct _xmlEnumeration xmlEnumeration;
typedef xmlEnumeration *xmlEnumerationPtr;
/**
 * List structure used when there is an enumeration in DTDs.
 *
 * Should be treated as opaque. Accessing members directly
 * is deprecated.
 */
struct _xmlEnumeration {
    /** next enumeration */
    struct _xmlEnumeration    *next XML_DEPRECATED_MEMBER;
    /** value */
    const xmlChar            *name XML_DEPRECATED_MEMBER;
};

/** Attribute declaration */
typedef struct _xmlAttribute xmlAttribute;
typedef xmlAttribute *xmlAttributePtr;
/**
 * An Attribute declaration in a DTD.
 *
 * Should be treated as opaque. Accessing members directly
 * is deprecated.
 */
struct _xmlAttribute {
    /** 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;
    /** attribute type */
    xmlAttributeType       atype;
    /** attribute default */
    xmlAttributeDefault      def;
    /** 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;
};

/**
 * Possible definitions of element content types.
 */
typedef enum {
    XML_ELEMENT_CONTENT_PCDATA = 1,
    XML_ELEMENT_CONTENT_ELEMENT,
    XML_ELEMENT_CONTENT_SEQ,
    XML_ELEMENT_CONTENT_OR
} xmlElementContentType;

/**
 * Possible definitions of element content occurrences.
 */
typedef enum {
    XML_ELEMENT_CONTENT_ONCE = 1,
    XML_ELEMENT_CONTENT_OPT,
    XML_ELEMENT_CONTENT_MULT,
    XML_ELEMENT_CONTENT_PLUS
} xmlElementContentOccur;

/** Element content in element declarations */
typedef struct _xmlElementContent xmlElementContent;
typedef xmlElementContent *xmlElementContentPtr;
/**
 * An XML Element content as stored after parsing an element definition
 * in a DTD.
 *
 * Should be treated as opaque. Accessing members directly
 * is deprecated.
 */
struct _xmlElementContent {
    /** 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;
};

/**
 * The different possibilities for an element content type.
 */
typedef enum {
    XML_ELEMENT_TYPE_UNDEFINED = 0,
    XML_ELEMENT_TYPE_EMPTY = 1,
    XML_ELEMENT_TYPE_ANY,
    XML_ELEMENT_TYPE_MIXED,
    XML_ELEMENT_TYPE_ELEMENT
} xmlElementTypeVal;

/** Element declaration */
typedef struct _xmlElement xmlElement;
typedef xmlElement *xmlElementPtr;
/**
 * An XML Element declaration from a DTD.
 *
 * Should be treated as opaque. Accessing members directly
 * is deprecated.
 */
struct _xmlElement {
    /** 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;
    /** allowed element content */
    xmlElementContent *content;
    /** list of declared attributes */
    xmlAttribute     *attributes;
    /** namespace prefix if any */
    const xmlChar        *prefix;
#ifdef LIBXML_REGEXP_ENABLED
    /** validating regexp */
    xmlRegexp         *contModel XML_DEPRECATED_MEMBER;
#else
    void	      *contModel XML_DEPRECATED_MEMBER;
#endif
};


/**
 * A namespace declaration node.
 */
#define XML_LOCAL_NAMESPACE XML_NAMESPACE_DECL
typedef xmlElementType xmlNsType;

/** Namespace declaration */
typedef struct _xmlNs xmlNs;
typedef xmlNs *xmlNsPtr;
/**
 * 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.
 */
struct _xmlNs {
    /** 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;
/**
 * 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.
 */
struct _xmlDtd {
    /** 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 */

    /** hash table for notations if any */
    void          *notations;
    /** hash table for elements if any */
    void          *elements;
    /** hash table for attributes if any */
    void          *attributes;
    /** hash table for entities if any */
    void          *entities;
    /** public identifier */
    xmlChar *ExternalID;
    /** system identifier */
    xmlChar *SystemID;
    /** hash table for parameter entities if any */
    void          *pentities;
};

/** Attribute of an element */
typedef struct _xmlAttr xmlAttr;
typedef xmlAttr *xmlAttrPtr;
/**
 * 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;
/**
 * An XML ID 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 {
    /* 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;
/**
 * 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`
 *
 * xmlNode and xmlAttr also share the `ns` member.
 */
struct _xmlNode {
    /** 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 */

    /** 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;
};

/**
 * Set of properties of the document as found by the parser.
 * Some of them are linked to similarly named xmlParserOption.
 */
typedef enum {
    /** 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;

/** XML or HTML document */
typedef struct _xmlDoc xmlDoc;
typedef xmlDoc *xmlDocPtr;
/**
 * An XML or HTML document.
 */
struct _xmlDoc {
    /** 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 */

    /** 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;
    /** 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;

/**
 * A function called to acquire namespaces (xmlNs) from the wrapper.
 *
 * @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 xmlNs *(*xmlDOMWrapAcquireNsFunction) (xmlDOMWrapCtxt *ctxt,
						 xmlNode *node,
						 const xmlChar *nsName,
						 const xmlChar *nsPrefix);

/**
 * Context for DOM wrapper-operations.
 */
struct _xmlDOMWrapCtxt {
    void * _private;
    /*
    * The type of this context, just in case we need specialized
    * contexts in the future.
    */
    int type;
    /*
    * Internal namespace map used for various operations.
    */
    void * namespaceMap;
    /*
    * Use this one to acquire an xmlNs intended for node->ns.
    * (Note that this is not intended for elem->nsDef).
    */
    xmlDOMWrapAcquireNsFunction getNsForNodeFunc;
};

/**
 * Signature for the registration callback of a created node
 *
 * @param node  the current node
 */
typedef void (*xmlRegisterNodeFunc) (xmlNode *node);

/**
 * Signature for the deregistration callback of a discarded node
 *
 * @param node  the current node
 */
typedef void (*xmlDeregisterNodeFunc) (xmlNode *node);

/**
 * Macro for compatibility naming layer with libxml1. Maps
 * to "children."
 */
#ifndef xmlChildrenNode
#define xmlChildrenNode children
#endif

/**
 * Macro for compatibility naming layer with libxml1. Maps
 * to "children".
 */
#ifndef xmlRootNode
#define xmlRootNode children
#endif

/*
 * Variables.
 */

/** @cond ignore */

XML_DEPRECATED
XMLPUBFUN xmlRegisterNodeFunc *__xmlRegisterNodeDefaultValue(void);
XML_DEPRECATED
XMLPUBFUN xmlDeregisterNodeFunc *__xmlDeregisterNodeDefaultValue(void);

#ifndef XML_GLOBALS_NO_REDEFINITION
  #define xmlRegisterNodeDefaultValue \
    (*__xmlRegisterNodeDefaultValue())
  #define xmlDeregisterNodeDefaultValue \
    (*__xmlDeregisterNodeDefaultValue())
#endif

/** @endcond */

/*
 * Some helper functions
 */
XMLPUBFUN int
		xmlValidateNCName	(const xmlChar *value,
					 int space);

XMLPUBFUN int
		xmlValidateQName	(const xmlChar *value,
					 int space);
XMLPUBFUN int
		xmlValidateName		(const xmlChar *value,
					 int space);
XMLPUBFUN int
		xmlValidateNMToken	(const xmlChar *value,
					 int space);

XMLPUBFUN xmlChar *
		xmlBuildQName		(const xmlChar *ncname,
					 const xmlChar *prefix,
					 xmlChar *memory,
					 int len);
XMLPUBFUN xmlChar *
		xmlSplitQName2		(const xmlChar *name,
					 xmlChar **prefix);
XMLPUBFUN const xmlChar *
		xmlSplitQName3		(const xmlChar *name,
					 int *len);

/*
 * Creating/freeing new structures.
 */
XMLPUBFUN xmlDtd *
		xmlCreateIntSubset	(xmlDoc *doc,
					 const xmlChar *name,
					 const xmlChar *publicId,
					 const xmlChar *systemId);
XMLPUBFUN xmlDtd *
		xmlNewDtd		(xmlDoc *doc,
					 const xmlChar *name,
					 const xmlChar *publicId,
					 const xmlChar *systemId);
XMLPUBFUN xmlDtd *
		xmlGetIntSubset		(const xmlDoc *doc);
XMLPUBFUN void
		xmlFreeDtd		(xmlDtd *cur);
XMLPUBFUN xmlNs *
		xmlNewNs		(xmlNode *node,
					 const xmlChar *href,
					 const xmlChar *prefix);
XMLPUBFUN void
		xmlFreeNs		(xmlNs *cur);
XMLPUBFUN void
		xmlFreeNsList		(xmlNs *cur);
XMLPUBFUN xmlDoc *
		xmlNewDoc		(const xmlChar *version);
XMLPUBFUN void
		xmlFreeDoc		(xmlDoc *cur);
XMLPUBFUN xmlAttr *
		xmlNewDocProp		(xmlDoc *doc,
					 const xmlChar *name,
					 const xmlChar *value);
XMLPUBFUN xmlAttr *
		xmlNewProp		(xmlNode *node,
					 const xmlChar *name,
					 const xmlChar *value);
XMLPUBFUN xmlAttr *
		xmlNewNsProp		(xmlNode *node,
					 xmlNs *ns,
					 const xmlChar *name,
					 const xmlChar *value);
XMLPUBFUN xmlAttr *
		xmlNewNsPropEatName	(xmlNode *node,
					 xmlNs *ns,
					 xmlChar *name,
					 const xmlChar *value);
XMLPUBFUN void
		xmlFreePropList		(xmlAttr *cur);
XMLPUBFUN void
		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 xmlNode *
		xmlNewDocNode		(xmlDoc *doc,
					 xmlNs *ns,
					 const xmlChar *name,
					 const xmlChar *content);
XMLPUBFUN xmlNode *
		xmlNewDocNodeEatName	(xmlDoc *doc,
					 xmlNs *ns,
					 xmlChar *name,
					 const xmlChar *content);
XMLPUBFUN xmlNode *
		xmlNewNode		(xmlNs *ns,
					 const xmlChar *name);
XMLPUBFUN xmlNode *
		xmlNewNodeEatName	(xmlNs *ns,
					 xmlChar *name);
XMLPUBFUN xmlNode *
		xmlNewChild		(xmlNode *parent,
					 xmlNs *ns,
					 const xmlChar *name,
					 const xmlChar *content);
XMLPUBFUN xmlNode *
		xmlNewDocText		(const xmlDoc *doc,
					 const xmlChar *content);
XMLPUBFUN xmlNode *
		xmlNewText		(const xmlChar *content);
XMLPUBFUN xmlNode *
		xmlNewDocPI		(xmlDoc *doc,
					 const xmlChar *name,
					 const xmlChar *content);
XMLPUBFUN xmlNode *
		xmlNewPI		(const xmlChar *name,
					 const xmlChar *content);
XMLPUBFUN xmlNode *
		xmlNewDocTextLen	(xmlDoc *doc,
					 const xmlChar *content,
					 int len);
XMLPUBFUN xmlNode *
		xmlNewTextLen		(const xmlChar *content,
					 int len);
XMLPUBFUN xmlNode *
		xmlNewDocComment	(xmlDoc *doc,
					 const xmlChar *content);
XMLPUBFUN xmlNode *
		xmlNewComment		(const xmlChar *content);
XMLPUBFUN xmlNode *
		xmlNewCDataBlock	(xmlDoc *doc,
					 const xmlChar *content,
					 int len);
XMLPUBFUN xmlNode *
		xmlNewCharRef		(xmlDoc *doc,
					 const xmlChar *name);
XMLPUBFUN xmlNode *
		xmlNewReference		(const xmlDoc *doc,
					 const xmlChar *name);
XMLPUBFUN xmlNode *
		xmlCopyNode		(xmlNode *node,
					 int recursive);
XMLPUBFUN xmlNode *
		xmlDocCopyNode		(xmlNode *node,
					 xmlDoc *doc,
					 int recursive);
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 xmlNode *
		xmlNewDocRawNode	(xmlDoc *doc,
					 xmlNs *ns,
					 const xmlChar *name,
					 const xmlChar *content);
XMLPUBFUN xmlNode *
		xmlNewDocFragment	(xmlDoc *doc);

/*
 * Navigating.
 */
XMLPUBFUN long
		xmlGetLineNo		(const xmlNode *node);
XMLPUBFUN xmlChar *
		xmlGetNodePath		(const xmlNode *node);
XMLPUBFUN xmlNode *
		xmlDocGetRootElement	(const xmlDoc *doc);
XMLPUBFUN xmlNode *
		xmlGetLastChild		(const xmlNode *parent);
XMLPUBFUN int
		xmlNodeIsText		(const xmlNode *node);
XMLPUBFUN int
		xmlIsBlankNode		(const xmlNode *node);

/*
 * Changing the structure.
 */
XMLPUBFUN xmlNode *
		xmlDocSetRootElement	(xmlDoc *doc,
					 xmlNode *root);
XMLPUBFUN void
		xmlNodeSetName		(xmlNode *cur,
					 const xmlChar *name);
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		(xmlNode *cur);
XMLPUBFUN xmlNode *
		xmlTextMerge		(xmlNode *first,
					 xmlNode *second);
XMLPUBFUN int
		xmlTextConcat		(xmlNode *node,
					 const xmlChar *content,
					 int len);
XMLPUBFUN void
		xmlFreeNodeList		(xmlNode *cur);
XMLPUBFUN void
		xmlFreeNode		(xmlNode *cur);
XMLPUBFUN int
		xmlSetTreeDoc		(xmlNode *tree,
					 xmlDoc *doc);
XMLPUBFUN int
		xmlSetListDoc		(xmlNode *list,
					 xmlDoc *doc);
/*
 * Namespaces.
 */
XMLPUBFUN xmlNs *
		xmlSearchNs		(xmlDoc *doc,
					 xmlNode *node,
					 const xmlChar *nameSpace);
XMLPUBFUN xmlNs *
		xmlSearchNsByHref	(xmlDoc *doc,
					 xmlNode *node,
					 const xmlChar *href);
XMLPUBFUN int
		xmlGetNsListSafe	(const xmlDoc *doc,
					 const xmlNode *node,
					 xmlNs ***out);
XMLPUBFUN xmlNs **
		xmlGetNsList		(const xmlDoc *doc,
					 const xmlNode *node);

XMLPUBFUN void
		xmlSetNs		(xmlNode *node,
					 xmlNs *ns);
XMLPUBFUN xmlNs *
		xmlCopyNamespace	(xmlNs *cur);
XMLPUBFUN xmlNs *
		xmlCopyNamespaceList	(xmlNs *cur);

/*
 * Changing the content.
 */
XMLPUBFUN xmlAttr *
		xmlSetProp		(xmlNode *node,
					 const xmlChar *name,
					 const xmlChar *value);
XMLPUBFUN xmlAttr *
		xmlSetNsProp		(xmlNode *node,
					 xmlNs *ns,
					 const xmlChar *name,
					 const xmlChar *value);
XMLPUBFUN int
		xmlNodeGetAttrValue	(const xmlNode *node,
					 const xmlChar *name,
					 const xmlChar *nsUri,
					 xmlChar **out);
XMLPUBFUN xmlChar *
		xmlGetNoNsProp		(const xmlNode *node,
					 const xmlChar *name);
XMLPUBFUN xmlChar *
		xmlGetProp		(const xmlNode *node,
					 const xmlChar *name);
XMLPUBFUN xmlAttr *
		xmlHasProp		(const xmlNode *node,
					 const xmlChar *name);
XMLPUBFUN xmlAttr *
		xmlHasNsProp		(const xmlNode *node,
					 const xmlChar *name,
					 const xmlChar *nameSpace);
XMLPUBFUN xmlChar *
		xmlGetNsProp		(const xmlNode *node,
					 const xmlChar *name,
					 const xmlChar *nameSpace);
XMLPUBFUN xmlNode *
		xmlStringGetNodeList	(const xmlDoc *doc,
					 const xmlChar *value);
XMLPUBFUN xmlNode *
		xmlStringLenGetNodeList	(const xmlDoc *doc,
					 const xmlChar *value,
					 int len);
XMLPUBFUN xmlChar *
		xmlNodeListGetString	(xmlDoc *doc,
					 const xmlNode *list,
					 int inLine);
XMLPUBFUN xmlChar *
		xmlNodeListGetRawString	(const xmlDoc *doc,
					 const xmlNode *list,
					 int inLine);
XMLPUBFUN int
		xmlNodeSetContent	(xmlNode *cur,
					 const xmlChar *content);
XMLPUBFUN int
		xmlNodeSetContentLen	(xmlNode *cur,
					 const xmlChar *content,
					 int len);
XMLPUBFUN int
		xmlNodeAddContent	(xmlNode *cur,
					 const xmlChar *content);
XMLPUBFUN int
		xmlNodeAddContentLen	(xmlNode *cur,
					 const xmlChar *content,
					 int len);
XMLPUBFUN xmlChar *
		xmlNodeGetContent	(const xmlNode *cur);

XMLPUBFUN int
		xmlNodeBufGetContent	(xmlBuffer *buffer,
					 const xmlNode *cur);
XMLPUBFUN int
		xmlBufGetNodeContent	(xmlBuf *buf,
					 const xmlNode *cur);

XMLPUBFUN xmlChar *
		xmlNodeGetLang		(const xmlNode *cur);
XMLPUBFUN int
		xmlNodeGetSpacePreserve	(const xmlNode *cur);
XMLPUBFUN int
		xmlNodeSetLang		(xmlNode *cur,
					 const xmlChar *lang);
XMLPUBFUN int
		xmlNodeSetSpacePreserve (xmlNode *cur,
					 int val);
XMLPUBFUN int
		xmlNodeGetBaseSafe	(const xmlDoc *doc,
					 const xmlNode *cur,
					 xmlChar **baseOut);
XMLPUBFUN xmlChar *
		xmlNodeGetBase		(const xmlDoc *doc,
					 const xmlNode *cur);
XMLPUBFUN int
		xmlNodeSetBase		(xmlNode *cur,
					 const xmlChar *uri);

/*
 * Removing content.
 */
XMLPUBFUN int
		xmlRemoveProp		(xmlAttr *cur);
XMLPUBFUN int
		xmlUnsetNsProp		(xmlNode *node,
					 xmlNs *ns,
					 const xmlChar *name);
XMLPUBFUN int
		xmlUnsetProp		(xmlNode *node,
					 const xmlChar *name);

#ifdef LIBXML_OUTPUT_ENABLED
XMLPUBFUN void xmlAttrSerializeTxtContent(xmlBuffer *buf,
					 xmlDoc *doc,
					 xmlAttr *attr,
					 const xmlChar *string);
#endif /* LIBXML_OUTPUT_ENABLED */

/*
 * Namespace handling.
 */
XMLPUBFUN int
		xmlReconciliateNs	(xmlDoc *doc,
					 xmlNode *tree);

#ifdef LIBXML_OUTPUT_ENABLED
/*
 * Saving.
 */
XMLPUBFUN void
		xmlDocDumpFormatMemory	(xmlDoc *cur,
					 xmlChar **mem,
					 int *size,
					 int format);
XMLPUBFUN void
		xmlDocDumpMemory	(xmlDoc *cur,
					 xmlChar **mem,
					 int *size);
XMLPUBFUN void
		xmlDocDumpMemoryEnc	(xmlDoc *out_doc,
					 xmlChar **doc_txt_ptr,
					 int * doc_txt_len,
					 const char *txt_encoding);
XMLPUBFUN void
		xmlDocDumpFormatMemoryEnc(xmlDoc *out_doc,
					 xmlChar **doc_txt_ptr,
					 int * doc_txt_len,
					 const char *txt_encoding,
					 int format);
XMLPUBFUN int
		xmlDocFormatDump	(FILE *f,
					 xmlDoc *cur,
					 int format);
XMLPUBFUN int
		xmlDocDump		(FILE *f,
					 xmlDoc *cur);
XMLPUBFUN void
		xmlElemDump		(FILE *f,
					 xmlDoc *doc,
					 xmlNode *cur);
XMLPUBFUN int
		xmlSaveFile		(const char *filename,
					 xmlDoc *cur);
XMLPUBFUN int
		xmlSaveFormatFile	(const char *filename,
					 xmlDoc *cur,
					 int format);
XMLPUBFUN size_t
		xmlBufNodeDump		(xmlBuf *buf,
					 xmlDoc *doc,
					 xmlNode *cur,
					 int level,
					 int format);
XMLPUBFUN int
		xmlNodeDump		(xmlBuffer *buf,
					 xmlDoc *doc,
					 xmlNode *cur,
					 int level,
					 int format);

XMLPUBFUN int
		xmlSaveFileTo		(xmlOutputBuffer *buf,
					 xmlDoc *cur,
					 const char *encoding);
XMLPUBFUN int
		xmlSaveFormatFileTo     (xmlOutputBuffer *buf,
					 xmlDoc *cur,
				         const char *encoding,
				         int format);
XMLPUBFUN void
		xmlNodeDumpOutput	(xmlOutputBuffer *buf,
					 xmlDoc *doc,
					 xmlNode *cur,
					 int level,
					 int format,
					 const char *encoding);

XMLPUBFUN int
		xmlSaveFormatFileEnc    (const char *filename,
					 xmlDoc *cur,
					 const char *encoding,
					 int format);

XMLPUBFUN int
		xmlSaveFileEnc		(const char *filename,
					 xmlDoc *cur,
					 const char *encoding);

#endif /* LIBXML_OUTPUT_ENABLED */
/*
 * XHTML
 */
XMLPUBFUN int
		xmlIsXHTML		(const xmlChar *systemID,
					 const xmlChar *publicID);

/*
 * Compression.
 */
XMLPUBFUN int
		xmlGetDocCompressMode	(const xmlDoc *doc);
XMLPUBFUN void
		xmlSetDocCompressMode	(xmlDoc *doc,
					 int mode);
XML_DEPRECATED
XMLPUBFUN int
		xmlGetCompressMode	(void);
XML_DEPRECATED
XMLPUBFUN void
		xmlSetCompressMode	(int mode);

/*
* DOM-wrapper helper functions.
*/
XMLPUBFUN xmlDOMWrapCtxt *
		xmlDOMWrapNewCtxt	(void);
XMLPUBFUN void
		xmlDOMWrapFreeCtxt	(xmlDOMWrapCtxt *ctxt);
XMLPUBFUN int
	    xmlDOMWrapReconcileNamespaces(xmlDOMWrapCtxt *ctxt,
					 xmlNode *elem,
					 int options);
XMLPUBFUN int
	    xmlDOMWrapAdoptNode		(xmlDOMWrapCtxt *ctxt,
					 xmlDoc *sourceDoc,
					 xmlNode *node,
					 xmlDoc *destDoc,
					 xmlNode *destParent,
					 int options);
XMLPUBFUN int
	    xmlDOMWrapRemoveNode	(xmlDOMWrapCtxt *ctxt,
					 xmlDoc *doc,
					 xmlNode *node,
					 int options);
XMLPUBFUN int
	    xmlDOMWrapCloneNode		(xmlDOMWrapCtxt *ctxt,
					 xmlDoc *sourceDoc,
					 xmlNode *node,
					 xmlNode **clonedNode,
					 xmlDoc *destDoc,
					 xmlNode *destParent,
					 int deep,
					 int options);

/*
 * 5 interfaces from DOM ElementTraversal, but different in entities
 * traversal.
 */
XMLPUBFUN unsigned long
            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
	    xmlRegisterNodeDefault	(xmlRegisterNodeFunc func);
XML_DEPRECATED
XMLPUBFUN xmlDeregisterNodeFunc
	    xmlDeregisterNodeDefault	(xmlDeregisterNodeFunc func);
XML_DEPRECATED
XMLPUBFUN xmlRegisterNodeFunc
            xmlThrDefRegisterNodeDefault(xmlRegisterNodeFunc func);
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

#endif /* __XML_TREE_H__ */

#endif /* XML_TREE_INTERNALS */