libxml-rs 0.1.0-alpha.49

/**
 * @file
 *
 * Document tree API for libxml-rs
 */

#ifndef __XML_TREE_H__
#define __XML_TREE_H__

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

#ifdef __cplusplus
extern "C" {
#endif




































































































































/* Forward declarations */
struct _xmlParserInputBuffer;
typedef struct _xmlParserInputBuffer xmlParserInputBuffer;
typedef struct _xmlParserInput xmlParserInput;
typedef struct _xmlParserCtxt xmlParserCtxt;
typedef xmlParserInputBuffer *xmlParserInputBufferPtr;

struct _xmlOutputBuffer;
typedef struct _xmlOutputBuffer xmlOutputBuffer;
typedef xmlOutputBuffer *xmlOutputBufferPtr;

typedef struct _xmlBuffer xmlBuffer;
typedef xmlBuffer *xmlBufferPtr;

/* Phase 14 (DOWNSTREAM-LXML): upstream tree.h defines LIBXML2_NEW_BUFFER to
 * express that the API uses the new xmlBuf-based buffers (introduced in
 * libxml2 2.9.0); consumers (lxml etree_defs.h) key their xmlBuf alias off
 * it. Verbatim from the upstream oracle header. */
#define LIBXML2_NEW_BUFFER

typedef struct _xmlBuf xmlBuf;
typedef xmlBuf *xmlBufPtr;

typedef struct _xmlNode xmlNode;
typedef xmlNode *xmlNodePtr;

typedef struct _xmlDoc xmlDoc;
typedef xmlDoc *xmlDocPtr;

typedef struct _xmlNs xmlNs;
typedef xmlNs *xmlNsPtr;

typedef struct _xmlAttr xmlAttr;
typedef xmlAttr *xmlAttrPtr;

typedef struct _xmlDtd xmlDtd;
typedef xmlDtd *xmlDtdPtr;

typedef struct _xmlEntity xmlEntity;
typedef xmlEntity *xmlEntityPtr;

typedef struct _xmlNotation xmlNotation;
typedef xmlNotation *xmlNotationPtr;

typedef struct _xmlElementContent xmlElementContent;
typedef xmlElementContent *xmlElementContentPtr;

typedef struct _xmlAttribute xmlAttribute;
typedef xmlAttribute *xmlAttributePtr;

/* DTD declaration tables (upstream tree.h) */
typedef struct _xmlHashTable xmlAttributeTable;
typedef xmlAttributeTable *xmlAttributeTablePtr;
typedef struct _xmlHashTable xmlElementTable;
typedef xmlElementTable *xmlElementTablePtr;
typedef struct _xmlHashTable xmlEntitiesTable;
typedef xmlEntitiesTable *xmlEntitiesTablePtr;
typedef struct _xmlHashTable xmlNotationTable;
typedef xmlNotationTable *xmlNotationTablePtr;

typedef struct _xmlEnumeration xmlEnumeration;
typedef xmlEnumeration *xmlEnumerationPtr;

typedef struct _xmlID xmlID;
typedef xmlID *xmlIDPtr;

typedef struct _xmlParserNodeInfo xmlParserNodeInfo;
typedef xmlParserNodeInfo *xmlParserNodeInfoPtr;

struct _xmlParserNodeInfo {
    const struct _xmlNode *node;
    unsigned long begin_pos;
    unsigned long begin_line;
    unsigned long end_pos;
    unsigned long end_line;
};

typedef struct _xmlParserNodeInfoSeq xmlParserNodeInfoSeq;

typedef struct _xmlParserNodeInfoSeq *xmlParserNodeInfoSeqPtr;

struct _xmlParserNodeInfoSeq {
    unsigned long maximum;
    unsigned long length;
    xmlParserNodeInfo *buffer;
};

/* Element types */
typedef enum {
    XML_ELEMENT_NODE = 1,
    XML_ATTRIBUTE_NODE = 2,
    XML_TEXT_NODE = 3,
    XML_CDATA_SECTION_NODE = 4,
    XML_ENTITY_REF_NODE = 5,
    XML_ENTITY_NODE = 6,
    XML_PI_NODE = 7,
    XML_COMMENT_NODE = 8,
    XML_DOCUMENT_NODE = 9,
    XML_DOCUMENT_TYPE_NODE = 10,
    XML_DOCUMENT_FRAG_NODE = 11,
    XML_NOTATION_NODE = 12,
    XML_HTML_DOCUMENT_NODE = 13,
    XML_DTD_NODE = 14,
    XML_ELEMENT_DECL = 15,
    XML_ATTRIBUTE_DECL = 16,
    XML_ENTITY_DECL = 17,
    XML_NAMESPACE_DECL = 18,
    XML_XINCLUDE_START = 19,
    XML_XINCLUDE_END = 20
} xmlElementType;

typedef enum {
    XML_ATTRIBUTE_CDATA = 1,
    XML_ATTRIBUTE_ID = 2,
    XML_ATTRIBUTE_IDREF = 3,
    XML_ATTRIBUTE_IDREFS = 4,
    XML_ATTRIBUTE_ENTITY = 5,
    XML_ATTRIBUTE_ENTITIES = 6,
    XML_ATTRIBUTE_NMTOKEN = 7,
    XML_ATTRIBUTE_NMTOKENS = 8,
    XML_ATTRIBUTE_ENUMERATION = 9,
    XML_ATTRIBUTE_NOTATION = 10
} xmlAttributeType;

typedef enum {
    XML_ATTRIBUTE_NONE = 1,
    XML_ATTRIBUTE_REQUIRED = 2,
    XML_ATTRIBUTE_IMPLIED = 3,
    XML_ATTRIBUTE_FIXED = 4
} xmlAttributeDefault;

typedef enum {
    XML_INTERNAL_GENERAL_ENTITY = 1,
    XML_EXTERNAL_GENERAL_PARSED_ENTITY = 2,
    XML_EXTERNAL_GENERAL_UNPARSED_ENTITY = 3,
    XML_INTERNAL_PARAMETER_ENTITY = 4,
    XML_EXTERNAL_PARAMETER_ENTITY = 5,
    XML_INTERNAL_PREDEFINED_ENTITY = 6
} xmlEntityType;

typedef enum {
    XML_BUFFER_ALLOC_DOUBLEIT,
    XML_BUFFER_ALLOC_EXACT,
    XML_BUFFER_ALLOC_IMMUTABLE,
    XML_BUFFER_ALLOC_IO,
    XML_BUFFER_ALLOC_HYBRID,
    XML_BUFFER_ALLOC_BOUNDED
} xmlBufferAllocationScheme;

/* Document properties */

/* Well-known namespaces */
#define XML_XML_NAMESPACE ((const xmlChar *) "http://www.w3.org/XML/1998/namespace")
#define XML_XMLNS_NAMESPACE ((const xmlChar *) "http://www.w3.org/2000/xmlns/")
#define XML_XMLNS_PREFIX ((const xmlChar *) "xmlns")

/* Limits */
#define XML_MAX_TEXT_LENGTH 1000000000
#define XML_MAX_NAME_LENGTH 50000
#define XML_MAX_DICTIONARY_LIMIT 10000000
#define XML_MAX_LOOKUP_LIMIT 1000000
#define XML_MAX_HUGE_LENGTH 100000000
#define XML_MAX_NAMELEN 50000
#define XML_MAX_ATTRIBUTE_LENGTH 50000

/* Buffer structure */
struct _xmlBuffer {
    xmlChar *content;
    unsigned int use;
    unsigned int size;
    xmlBufferAllocationScheme alloc;
    xmlChar *contentIO;
};

/* Node structure */
struct _xmlNode {
    void *_private;
    int type;
    const xmlChar *name;
    xmlNodePtr children;
    xmlNodePtr last;
    xmlNodePtr parent;
    xmlNodePtr next;
    xmlNodePtr prev;
    xmlDocPtr doc;
    xmlNsPtr ns;
    xmlChar *content;
    xmlAttrPtr properties;
    xmlNsPtr nsDef;
    void *psvi;
    unsigned short line;
    unsigned short extra;
};

/* Attribute structure */
struct _xmlAttr {
    void *_private;
    int type;
    const xmlChar *name;
    xmlNodePtr children;
    xmlNodePtr last;
    xmlNodePtr parent;
    xmlAttrPtr next;
    xmlAttrPtr prev;
    xmlDocPtr doc;
    xmlNsPtr ns;
    int atype;
    void *psvi;
    xmlIDPtr id;
};

/* Namespace structure */
struct _xmlNs {
    xmlNsPtr next;
    int type;
    const xmlChar *href;
    const xmlChar *prefix;
    void *_private;
    struct _xmlDoc *context;
};

/* Document structure */
struct _xmlDoc {
    void *_private;
    int type;
    char *name;
    xmlNodePtr children;
    xmlNodePtr last;
    xmlNodePtr parent;
    xmlNodePtr next;
    xmlNodePtr prev;
    xmlDocPtr doc;
    int compression;
    int standalone;
    xmlDtdPtr intSubset;
    xmlDtdPtr extSubset;
    xmlNsPtr oldNs;
    xmlChar *version;
    xmlChar *encoding;
    void *ids;
    void *refs;
    xmlChar *URL;
    int charset;
    struct _xmlDict *dict;
    void *psvi;
    int parseFlags;
    int properties;
};

/* DTD structure */
struct _xmlDtd {
    void *_private;
    int type;
    const xmlChar *name;
    xmlNodePtr children;
    xmlNodePtr last;
    xmlNodePtr parent;
    xmlNodePtr next;
    xmlNodePtr prev;
    xmlDocPtr doc;
    void *notations;
    void *elements;
    void *attributes;
    void *entities;
    xmlChar *ExternalID;
    xmlChar *SystemID;
    void *pentities;
};

/* Entity structure */
struct _xmlEntity {
    void *_private;
    int type;
    const xmlChar *name;
    xmlNodePtr children;
    xmlNodePtr last;
    xmlNodePtr parent;
    xmlNodePtr next;
    xmlNodePtr prev;
    xmlDocPtr doc;
    xmlChar *orig;
    xmlChar *content;
    int length;
    int etype;
    const xmlChar *ExternalID;
    const xmlChar *SystemID;
    xmlEntityPtr nexte;
    const xmlChar *URI;
    int owner;
    int flags;
    unsigned long expandedSize;
};

/* Notation structure */
struct _xmlNotation {
    const xmlChar *name;
    const xmlChar *PublicID;
    const xmlChar *SystemID;
};

/* Element content structure */
struct _xmlElementContent {
    int type;
    int ocur;
    const xmlChar *name;
    xmlElementContentPtr c1;
    xmlElementContentPtr c2;
    xmlElementContentPtr parent;
    const xmlChar *prefix;
};

/* Enumeration structure */
struct _xmlEnumeration {
    struct _xmlEnumeration *next;
    const xmlChar *name;
};

/* Attribute declaration structure */
struct _xmlAttribute {
    void *_private;
    int type;
    const xmlChar *name;
    xmlNodePtr children;
    xmlNodePtr last;
    xmlNodePtr parent;
    xmlNodePtr next;
    xmlNodePtr prev;
    xmlDocPtr doc;
    xmlAttributePtr nexth;
    int atype;
    int def;
    const xmlChar *defaultValue;
    xmlEnumerationPtr tree;
    const xmlChar *prefix;
    const xmlChar *elem;
};

/* Element declaration types */
typedef enum {
    XML_ELEMENT_TYPE_UNDEFINED = 0,
    XML_ELEMENT_TYPE_EMPTY = 1,
    XML_ELEMENT_TYPE_ANY = 2,
    XML_ELEMENT_TYPE_MIXED = 3,
    XML_ELEMENT_TYPE_ELEMENT = 4
} xmlElementTypeVal;

/* Namespace type */
#define XML_LOCAL_NAMESPACE 0
typedef int xmlNsType;

/* Tree functions */
XMLPUBFUN xmlDocPtr xmlNewDoc(const xmlChar *version);
XMLPUBFUN void xmlFreeDoc(xmlDocPtr doc);
XMLPUBFUN xmlDocPtr xmlCopyDoc(const xmlDocPtr doc, int recursive);
XMLPUBFUN xmlNodePtr xmlNewNode(xmlNsPtr ns, const xmlChar *name);
XMLPUBFUN void xmlFreeNode(xmlNodePtr node);
XMLPUBFUN void xmlFreeNodeList(xmlNodePtr node);
XMLPUBFUN xmlNodePtr xmlCopyNode(const xmlNodePtr node, int extended);
XMLPUBFUN void xmlUnlinkNode(xmlNodePtr node);
XMLPUBFUN xmlNodePtr xmlAddChild(xmlNodePtr parent, xmlNodePtr cur);
XMLPUBFUN xmlNodePtr xmlAddSibling(xmlNodePtr cur, xmlNodePtr sibling);
XMLPUBFUN xmlNodePtr xmlNewChild(xmlNodePtr parent, xmlNsPtr ns,
                                  const xmlChar *name, const xmlChar *content);
XMLPUBFUN xmlNodePtr xmlNewText(const xmlChar *content);
XMLPUBFUN xmlNodePtr xmlNewComment(const xmlChar *content);
XMLPUBFUN xmlNodePtr xmlNewPI(const xmlChar *name, const xmlChar *content);
XMLPUBFUN xmlNodePtr xmlNewCDataBlock(xmlDocPtr doc, const xmlChar *content, int len);
XMLPUBFUN xmlNodePtr xmlDocSetRootElement(xmlDocPtr doc, xmlNodePtr root);
XMLPUBFUN xmlNodePtr xmlDocGetRootElement(const xmlDoc *doc);
XMLPUBFUN long xmlGetLineNo(const xmlNode *node);
XMLPUBFUN xmlNodePtr xmlFirstElementChild(xmlNodePtr parent);
XMLPUBFUN xmlNodePtr xmlLastElementChild(xmlNodePtr parent);
XMLPUBFUN xmlNodePtr xmlNextElementSibling(xmlNodePtr node);
XMLPUBFUN xmlNodePtr xmlPreviousElementSibling(xmlNodePtr node);
XMLPUBFUN int xmlNodeIsText(const xmlNode *node);
XMLPUBFUN int xmlIsBlankNode(const xmlNode *node);
XMLPUBFUN xmlNsPtr xmlNewNs(xmlNodePtr node, const xmlChar *href, const xmlChar *prefix);
XMLPUBFUN void xmlSetNs(xmlNodePtr node, xmlNsPtr ns);
XMLPUBFUN xmlNs **xmlGetNsList(const xmlDoc *doc, const xmlNode *node);
XMLPUBFUN xmlNsPtr xmlSearchNs(xmlDocPtr doc, xmlNodePtr node, const xmlChar *nameSpace);
XMLPUBFUN xmlNsPtr xmlSearchNsByHref(xmlDocPtr doc, xmlNodePtr node, const xmlChar *href);
XMLPUBFUN xmlAttrPtr xmlSetProp(xmlNodePtr node, const xmlChar *name, const xmlChar *value);
XMLPUBFUN xmlChar *xmlGetProp(const xmlNode *node, const xmlChar *name);
XMLPUBFUN xmlChar *xmlNodeGetContent(const xmlNode *cur);
XMLPUBFUN xmlChar *xmlNodeGetBase(const xmlDoc *doc, const xmlNode *cur);
XMLPUBFUN int xmlNodeSetContent(xmlNodePtr cur, const xmlChar *content);
XMLPUBFUN void xmlNodeSetName(xmlNodePtr cur, const xmlChar *name);
XMLPUBFUN int xmlSetTreeDoc(xmlNodePtr tree, xmlDocPtr doc);
XMLPUBFUN int xmlSetListDoc(xmlNodePtr list, xmlDocPtr doc);
XMLPUBFUN xmlAttrPtr xmlHasProp(const xmlNode *node, const xmlChar *name);
XMLPUBFUN xmlNodePtr xmlDocCopyNode(const xmlNodePtr node, xmlDocPtr doc, int extended);
XMLPUBFUN xmlNodePtr xmlCopyNodeList(const xmlNodePtr node);
XMLPUBFUN xmlAttrPtr xmlCopyProp(xmlNodePtr target, const xmlAttrPtr cur);
XMLPUBFUN xmlAttrPtr xmlCopyPropList(xmlNodePtr target, const xmlAttrPtr cur);
XMLPUBFUN xmlChar *xmlGetNsProp(const xmlNode *node, const xmlChar *name, const xmlChar *nameSpace);
XMLPUBFUN xmlAttrPtr xmlSetNsProp(xmlNodePtr node, xmlNsPtr ns,
                                   const xmlChar *name, const xmlChar *value);
XMLPUBFUN int xmlRemoveProp(xmlAttrPtr attr);
XMLPUBFUN xmlDtdPtr xmlGetIntSubset(const xmlDoc *doc);
XMLPUBFUN xmlDtdPtr xmlNewDtd(xmlDocPtr doc, const xmlChar *name,
                               const xmlChar *ExternalID, const xmlChar *SystemID);
XMLPUBFUN xmlEntityPtr xmlNewEntity(xmlDocPtr doc, const xmlChar *name, int type,
                                     const xmlChar *ExternalID, const xmlChar *SystemID,
                                     const xmlChar *content);
XMLPUBFUN xmlEntityPtr xmlGetDocEntity(const xmlDoc *doc, const xmlChar *name);
XMLPUBFUN xmlEntityPtr xmlGetParameterEntity(xmlDoc *doc, const xmlChar *name);
XMLPUBFUN xmlBufferPtr xmlBufferCreate(void);
XMLPUBFUN xmlBufferPtr xmlBufferCreateSize(size_t size);
XMLPUBFUN xmlBufferPtr xmlBufferCreateStatic(void *mem, size_t size);
XMLPUBFUN void xmlBufferFree(xmlBufferPtr buf);
XMLPUBFUN void xmlBufferEmpty(xmlBufferPtr buf);
XMLPUBFUN const xmlChar *xmlBufferContent(const xmlBuffer *buf);
XMLPUBFUN int xmlBufferLength(const xmlBuffer *buf);
XMLPUBFUN int xmlBufferAdd(xmlBufferPtr buf, const xmlChar *str, int len);
XMLPUBFUN int xmlBufferAddHead(xmlBufferPtr buf, const xmlChar *str, int len);
XMLPUBFUN void xmlBufferSetAllocationScheme(xmlBufferPtr buf, xmlBufferAllocationScheme scheme);
XMLPUBFUN int xmlBufferShrink(xmlBufferPtr buf, unsigned int len);
XMLPUBFUN int xmlBufferGrow(xmlBufferPtr buf, unsigned int len);
XMLPUBFUN int xmlBufferReserve(xmlBufferPtr buf, int len);
XMLPUBFUN xmlChar *xmlBufferDetach(xmlBufferPtr buf);
XMLPUBFUN int xmlIsBlankNode(const xmlNode *node);
















































































































































































































/* [11.1-G] begin: extracted verbatim from upstream oracle header */
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.
 */

typedef struct _xmlElement xmlElement;
typedef xmlElement *xmlElementPtr;
/**
 * An XML Element declaration from a DTD.
 *
 * Should be treated as opaque. Accessing members directly
 * is deprecated.
 */

typedef struct _xmlRef xmlRef;
typedef xmlRef *xmlRefPtr;
/*
 * An XML IDREF instance.
 */

typedef enum{
    XML_DOC_WELLFORMED		= 1<<0,
    XML_DOC_NSVALID		= 1<<1,
    XML_DOC_OLD10		= 1<<2,
    XML_DOC_DTDVALID		= 1<<3,
    XML_DOC_XINCLUDE		= 1<<4,
    XML_DOC_USERBUILT		= 1<<5,
    XML_DOC_INTERNAL		= 1<<6,
    XML_DOC_HTML		= 1<<7
} xmlDocProperties;

typedef enum{
    XML_ELEMENT_CONTENT_ONCE = 1,
    XML_ELEMENT_CONTENT_OPT,
    XML_ELEMENT_CONTENT_MULT,
    XML_ELEMENT_CONTENT_PLUS
} xmlElementContentOccur;

typedef enum{
    XML_ELEMENT_CONTENT_PCDATA = 1,
    XML_ELEMENT_CONTENT_ELEMENT,
    XML_ELEMENT_CONTENT_SEQ,
    XML_ELEMENT_CONTENT_OR
} xmlElementContentType;

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

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 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
    /** validating regexp */
    xmlRegexp         *contModel XML_DEPRECATED_MEMBER;
#else
    void	      *contModel XML_DEPRECATED_MEMBER;
#endif
};

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

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

/* [11.1-G] end: extracted definitions */

/* [11.1-L] begin: node-registration callback declarations extracted verbatim
 * from the oracle libxml2 2.15.3 tree.h (exported by the candidate DSO). */
typedef void (*xmlRegisterNodeFunc) (xmlNode *node);
typedef void (*xmlDeregisterNodeFunc) (xmlNode *node);
XMLPUBFUN xmlRegisterNodeFunc
	    xmlRegisterNodeDefault	(xmlRegisterNodeFunc func);
XMLPUBFUN xmlDeregisterNodeFunc
	    xmlDeregisterNodeDefault	(xmlDeregisterNodeFunc func);
/* [11.1-L] end: extracted declarations */

/* [11.1-S] begin: oracle-extracted declarations
 * Extracted verbatim from the upstream headers (11.1-S header-surface
 * audit: every function the oracle headers declare must be declared by the
 * drop-in headers — the source-compatibility contract. Signatures are the upstream ABI contract.
 */
XMLPUBFUN xmlNode * xmlAddChildList (xmlNode *parent, xmlNode *cur);
XMLPUBFUN xmlNode * xmlAddNextSibling (xmlNode *cur, xmlNode *elem);
XMLPUBFUN xmlNode * xmlAddPrevSibling (xmlNode *cur, xmlNode *elem);
XMLPUBFUN void xmlAttrSerializeTxtContent(xmlBuffer *buf, xmlDoc *doc, xmlAttr *attr, const xmlChar *string);
XMLPUBFUN xmlChar* xmlBufContent (const xmlBuf* buf);
XMLPUBFUN xmlChar* xmlBufEnd (xmlBuf *buf);
XMLPUBFUN int xmlBufGetNodeContent (xmlBuf *buf, const xmlNode *cur);
XMLPUBFUN size_t xmlBufNodeDump (xmlBuf *buf, xmlDoc *doc, xmlNode *cur, int level, int format);
XMLPUBFUN size_t xmlBufShrink (xmlBuf *buf, size_t len);
XMLPUBFUN size_t xmlBufUse (xmlBuf *buf);
XMLPUBFUN int xmlBufferCCat (xmlBuffer *buf, const char *str);
XMLPUBFUN int xmlBufferCat (xmlBuffer *buf, const xmlChar *str);
XMLPUBFUN int xmlBufferDump (FILE *file, xmlBuffer *buf);
XMLPUBFUN int xmlBufferResize (xmlBuffer *buf, unsigned int size);
XMLPUBFUN void xmlBufferWriteCHAR (xmlBuffer *buf, const xmlChar *string);
XMLPUBFUN void xmlBufferWriteChar (xmlBuffer *buf, const char *string);
XMLPUBFUN void xmlBufferWriteQuotedString(xmlBuffer *buf, const xmlChar *string);
XMLPUBFUN xmlChar * xmlBuildQName (const xmlChar *ncname, const xmlChar *prefix, xmlChar *memory, int len);
XMLPUBFUN unsigned long xmlChildElementCount (xmlNode *parent);
XMLPUBFUN xmlDtd * xmlCopyDtd (xmlDtd *dtd);
XMLPUBFUN xmlNs * xmlCopyNamespace (xmlNs *cur);
XMLPUBFUN xmlNs * xmlCopyNamespaceList (xmlNs *cur);
XMLPUBFUN xmlDtd * xmlCreateIntSubset (xmlDoc *doc, const xmlChar *name, const xmlChar *publicId, const xmlChar *systemId);
XMLPUBFUN int xmlDOMWrapAdoptNode (xmlDOMWrapCtxt *ctxt, xmlDoc *sourceDoc, xmlNode *node, xmlDoc *destDoc, xmlNode *destParent, int options);
XMLPUBFUN int xmlDOMWrapCloneNode (xmlDOMWrapCtxt *ctxt, xmlDoc *sourceDoc, xmlNode *node, xmlNode **clonedNode, xmlDoc *destDoc, xmlNode *destParent, int deep, int options);
XMLPUBFUN void xmlDOMWrapFreeCtxt (xmlDOMWrapCtxt *ctxt);
XMLPUBFUN xmlDOMWrapCtxt * xmlDOMWrapNewCtxt (void);
XMLPUBFUN int xmlDOMWrapReconcileNamespaces(xmlDOMWrapCtxt *ctxt, xmlNode *elem, int options);
XMLPUBFUN int xmlDOMWrapRemoveNode (xmlDOMWrapCtxt *ctxt, xmlDoc *doc, xmlNode *node, int options);
XMLPUBFUN xmlNode * xmlDocCopyNodeList (xmlDoc *doc, xmlNode *node);
XMLPUBFUN int xmlDocDump (FILE *f, xmlDoc *cur);
XMLPUBFUN void xmlDocDumpFormatMemory (xmlDoc *cur, xmlChar **mem, int *size, int format);
XMLPUBFUN void xmlDocDumpFormatMemoryEnc(xmlDoc *out_doc, xmlChar **doc_txt_ptr, int * doc_txt_len, const char *txt_encoding, 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 int xmlDocFormatDump (FILE *f, xmlDoc *cur, int format);
XMLPUBFUN void xmlElemDump (FILE *f, xmlDoc *doc, xmlNode *cur);
XMLPUBFUN void xmlFreeDtd (xmlDtd *cur);
XMLPUBFUN void xmlFreeNs (xmlNs *cur);
XMLPUBFUN void xmlFreeNsList (xmlNs *cur);
XMLPUBFUN void xmlFreeProp (xmlAttr *cur);
XMLPUBFUN void xmlFreePropList (xmlAttr *cur);
XMLPUBFUN xmlBufferAllocationScheme xmlGetBufferAllocationScheme(void);
XMLPUBFUN int xmlGetCompressMode (void);
XMLPUBFUN int xmlGetDocCompressMode (const xmlDoc *doc);
XMLPUBFUN xmlNode * xmlGetLastChild (const xmlNode *parent);
XMLPUBFUN xmlChar * xmlGetNoNsProp (const xmlNode *node, const xmlChar *name);
XMLPUBFUN xmlChar * xmlGetNodePath (const xmlNode *node);
XMLPUBFUN int xmlGetNsListSafe (const xmlDoc *doc, const xmlNode *node, xmlNs ***out);
XMLPUBFUN xmlAttr * xmlHasNsProp (const xmlNode *node, const xmlChar *name, const xmlChar *nameSpace);
XMLPUBFUN int xmlIsXHTML (const xmlChar *systemID, const xmlChar *publicID);
XMLPUBFUN xmlNode * xmlNewCharRef (xmlDoc *doc, const xmlChar *name);
XMLPUBFUN xmlNode * xmlNewDocComment (xmlDoc *doc, const xmlChar *content);
XMLPUBFUN xmlNode * xmlNewDocFragment (xmlDoc *doc);
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 * xmlNewDocPI (xmlDoc *doc, const xmlChar *name, const xmlChar *content);
XMLPUBFUN xmlAttr * xmlNewDocProp (xmlDoc *doc, const xmlChar *name, const xmlChar *value);
XMLPUBFUN xmlNode * xmlNewDocRawNode (xmlDoc *doc, xmlNs *ns, const xmlChar *name, const xmlChar *content);
XMLPUBFUN xmlNode * xmlNewDocText (const xmlDoc *doc, const xmlChar *content);
XMLPUBFUN xmlNode * xmlNewDocTextLen (xmlDoc *doc, const xmlChar *content, int len);
XMLPUBFUN xmlNode * xmlNewNodeEatName (xmlNs *ns, xmlChar *name);
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 xmlAttr * xmlNewProp (xmlNode *node, const xmlChar *name, const xmlChar *value);
XMLPUBFUN xmlNode * xmlNewReference (const xmlDoc *doc, const xmlChar *name);
XMLPUBFUN xmlNode * xmlNewTextChild (xmlNode *parent, xmlNs *ns, const xmlChar *name, const xmlChar *content);
XMLPUBFUN xmlNode * xmlNewTextLen (const xmlChar *content, int len);
XMLPUBFUN int xmlNodeAddContent (xmlNode *cur, const xmlChar *content);
XMLPUBFUN int xmlNodeAddContentLen (xmlNode *cur, const xmlChar *content, int len);
XMLPUBFUN int xmlNodeBufGetContent (xmlBuffer *buffer, const xmlNode *cur);
XMLPUBFUN int xmlNodeDump (xmlBuffer *buf, xmlDoc *doc, xmlNode *cur, int level, int format);
XMLPUBFUN void xmlNodeDumpOutput (xmlOutputBuffer *buf, xmlDoc *doc, xmlNode *cur, int level, int format, const char *encoding);
XMLPUBFUN int xmlNodeGetAttrValue (const xmlNode *node, const xmlChar *name, const xmlChar *nsUri, xmlChar **out);
XMLPUBFUN int xmlNodeGetBaseSafe (const xmlDoc *doc, const xmlNode *cur, xmlChar **baseOut);
XMLPUBFUN xmlChar * xmlNodeGetLang (const xmlNode *cur);
XMLPUBFUN int xmlNodeGetSpacePreserve (const xmlNode *cur);
XMLPUBFUN xmlChar * xmlNodeListGetRawString (const xmlDoc *doc, const xmlNode *list, int inLine);
XMLPUBFUN xmlChar * xmlNodeListGetString (xmlDoc *doc, const xmlNode *list, int inLine);
XMLPUBFUN int xmlNodeSetBase (xmlNode *cur, const xmlChar *uri);
XMLPUBFUN int xmlNodeSetContentLen (xmlNode *cur, const xmlChar *content, int len);
XMLPUBFUN int xmlNodeSetLang (xmlNode *cur, const xmlChar *lang);
XMLPUBFUN int xmlNodeSetSpacePreserve (xmlNode *cur, int val);
XMLPUBFUN int xmlReconciliateNs (xmlDoc *doc, xmlNode *tree);
XMLPUBFUN xmlNode * xmlReplaceNode (xmlNode *old, xmlNode *cur);
XMLPUBFUN int xmlSaveFile (const char *filename, xmlDoc *cur);
XMLPUBFUN int xmlSaveFileEnc (const char *filename, xmlDoc *cur, const char *encoding);
/* Legacy save family: upstream tree.h declares these alongside the
 * xmlsave.h xmlSaveTo* family (tree2.c includes only tree.h and calls
 * xmlSaveFormatFileEnc). Declared here verbatim so tree.h-only consumers
 * compile unchanged (Phase-12 EXTERNAL-CONSUMERS court). */
XMLPUBFUN int xmlSaveFormatFile (const char *filename, xmlDoc *cur, 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 int xmlSaveFormatFileEnc (const char *filename, xmlDoc *cur, const char *encoding, int format);
XMLPUBFUN void xmlSetBufferAllocationScheme(xmlBufferAllocationScheme scheme);
XMLPUBFUN void xmlSetCompressMode (int mode);
XMLPUBFUN void xmlSetDocCompressMode (xmlDoc *doc, int mode);
XMLPUBFUN xmlChar * xmlSplitQName2 (const xmlChar *name, xmlChar **prefix);
XMLPUBFUN const xmlChar * xmlSplitQName3 (const xmlChar *name, int *len);
XMLPUBFUN xmlNode * xmlStringGetNodeList (const xmlDoc *doc, const xmlChar *value);
XMLPUBFUN xmlNode * xmlStringLenGetNodeList (const xmlDoc *doc, const xmlChar *value, int len);
XMLPUBFUN int xmlTextConcat (xmlNode *node, const xmlChar *content, int len);
XMLPUBFUN xmlNode * xmlTextMerge (xmlNode *first, xmlNode *second);
XMLPUBFUN xmlDeregisterNodeFunc xmlThrDefDeregisterNodeDefault(xmlDeregisterNodeFunc func);
XMLPUBFUN xmlRegisterNodeFunc xmlThrDefRegisterNodeDefault(xmlRegisterNodeFunc func);
XMLPUBFUN int xmlUnsetNsProp (xmlNode *node, xmlNs *ns, const xmlChar *name);
XMLPUBFUN int xmlUnsetProp (xmlNode *node, const xmlChar *name);
XMLPUBFUN int xmlValidateNCName (const xmlChar *value, int space);
XMLPUBFUN int xmlValidateNMToken (const xmlChar *value, int space);
XMLPUBFUN int xmlValidateName (const xmlChar *value, int space);
XMLPUBFUN int xmlValidateQName (const xmlChar *value, int space);
/* [11.1-S] end: oracle-extracted declarations */

/* [13.1] begin: thread-local node-hook accessors + macro aliases
 *
 * Phase 13 (HOSTILE-THREADS): upstream 2.15 keeps the node
 * register/deregister hooks per-thread (globals.c xmlGetThreadLocalStorage);
 * the oracle headers alias the names to `(*__xmlXxx())` accessor functions
 * and the oracle DSO exports only the accessors. The candidate implements
 * the same contract (src/xml/globals/tls.rs). Guarded by
 * XML_GLOBALS_NO_REDEFINITION exactly like upstream tree.h.
 */
XMLPUBFUN xmlRegisterNodeFunc *__xmlRegisterNodeDefaultValue(void);
XMLPUBFUN xmlDeregisterNodeFunc *__xmlDeregisterNodeDefaultValue(void);

#ifndef XML_GLOBALS_NO_REDEFINITION
  #define xmlRegisterNodeDefaultValue \
    (*__xmlRegisterNodeDefaultValue())
  #define xmlDeregisterNodeDefaultValue \
    (*__xmlDeregisterNodeDefaultValue())
#endif /* XML_GLOBALS_NO_REDEFINITION */
/* [13.1] end: thread-local node-hook accessors + macro aliases */

#ifdef __cplusplus
}
#endif

#endif /* __XML_TREE_H__ */