File: //opt/cpanel/ea-libxml2/include/libxml2/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 */