tree.h

/*

 * Summary: interfaces for tree manipulation

 * Description: this module describes the structures found in an tree resulting

 *              from an XML or HTML parsing, as well as the API provided for

 *              various processing on that tree

 *

 * Copy: See Copyright for the status of this software.

 *

 * Author: Daniel Veillard

 */



#ifndef __XML_TREE_H__

#define __XML_TREE_H__



#include <stdio.h>

#include <libxml/xmlversion.h>

#include <libxml/xmlstring.h>



#ifdef __cplusplus

extern "C" {

#endif



/*

 * Some of the basic types pointer to structures:

 */

/* xmlIO.h */

typedef struct _xmlParserInputBuffer xmlParserInputBuffer;

typedef xmlParserInputBuffer *xmlParserInputBufferPtr;



typedef struct _xmlOutputBuffer xmlOutputBuffer;

typedef xmlOutputBuffer *xmlOutputBufferPtr;



/* parser.h */

typedef struct _xmlParserInput xmlParserInput;

typedef xmlParserInput *xmlParserInputPtr;



typedef struct _xmlParserCtxt xmlParserCtxt;

typedef xmlParserCtxt *xmlParserCtxtPtr;



typedef struct _xmlSAXLocator xmlSAXLocator;

typedef xmlSAXLocator *xmlSAXLocatorPtr;



typedef struct _xmlSAXHandler xmlSAXHandler;

typedef xmlSAXHandler *xmlSAXHandlerPtr;



/* entities.h */

typedef struct _xmlEntity xmlEntity;

typedef xmlEntity *xmlEntityPtr;



#define BASE_BUFFER_SIZE 4096



#define XML_XML_NAMESPACE \

    (const xmlChar *) "http://www.w3.org/XML/1998/namespace"



#define XML_XML_ID (const xmlChar *) "xml:id"



/*

 * The different element types carried by an XML tree.

 *

 * NOTE: This is synchronized with DOM Level1 values

 *       See http://www.w3.org/TR/REC-DOM-Level-1/

 *

 * Actually this had diverged a bit, and now XML_DOCUMENT_TYPE_NODE should

 * be deprecated to use an XML_DTD_NODE.

 */

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

#ifdef LIBXML_DOCB_ENABLED

   ,XML_DOCB_DOCUMENT_NODE=     21

#endif

} xmlElementType;





typedef struct _xmlNotation xmlNotation;

typedef xmlNotation *xmlNotationPtr;

struct _xmlNotation {

    const xmlChar               *name;          /* Notation name */

    const xmlChar               *PublicID;      /* Public identifier, if any */

    const xmlChar               *SystemID;      /* System identifier, if any */

};



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;



typedef enum {

    XML_ATTRIBUTE_NONE = 1,

    XML_ATTRIBUTE_REQUIRED,

    XML_ATTRIBUTE_IMPLIED,

    XML_ATTRIBUTE_FIXED

} xmlAttributeDefault;



typedef struct _xmlEnumeration xmlEnumeration;

typedef xmlEnumeration *xmlEnumerationPtr;

struct _xmlEnumeration {

    struct _xmlEnumeration    *next;    /* next one */

    const xmlChar            *name;     /* Enumeration name */

};



typedef struct _xmlAttribute xmlAttribute;

typedef xmlAttribute *xmlAttributePtr;

struct _xmlAttribute {

    void           *_private;           /* application data */

    xmlElementType          type;       /* XML_ATTRIBUTE_DECL, must be second ! */

    const xmlChar          *name;       /* Attribute name */

    struct _xmlNode    *children;       /* NULL */

    struct _xmlNode        *last;       /* NULL */

    struct _xmlDtd       *parent;       /* -> DTD */

    struct _xmlNode        *next;       /* next sibling link  */

    struct _xmlNode        *prev;       /* previous sibling link  */

    struct _xmlDoc          *doc;       /* the containing document */



    struct _xmlAttribute  *nexth;       /* next in hash table */

    xmlAttributeType       atype;       /* The attribute type */

    xmlAttributeDefault      def;       /* the default */

    const xmlChar  *defaultValue;       /* or the default value */

    xmlEnumerationPtr       tree;       /* or the enumeration tree if any */

    const xmlChar        *prefix;       /* the namespace prefix if any */

    const xmlChar          *elem;       /* Element holding the attribute */

};



typedef enum {

    XML_ELEMENT_CONTENT_PCDATA = 1,

    XML_ELEMENT_CONTENT_ELEMENT,

    XML_ELEMENT_CONTENT_SEQ,

    XML_ELEMENT_CONTENT_OR

} xmlElementContentType;



typedef enum {

    XML_ELEMENT_CONTENT_ONCE = 1,

    XML_ELEMENT_CONTENT_OPT,

    XML_ELEMENT_CONTENT_MULT,

    XML_ELEMENT_CONTENT_PLUS

} xmlElementContentOccur;



typedef struct _xmlElementContent xmlElementContent;

typedef xmlElementContent *xmlElementContentPtr;

struct _xmlElementContent {

    xmlElementContentType     type;     /* PCDATA, ELEMENT, SEQ or OR */

    xmlElementContentOccur    ocur;     /* ONCE, OPT, MULT or PLUS */

    const xmlChar             *name;    /* Element name */

    struct _xmlElementContent *c1;      /* first child */

    struct _xmlElementContent *c2;      /* second child */

    struct _xmlElementContent *parent;  /* parent */

    const xmlChar             *prefix;  /* Namespace prefix */

};



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;





#ifdef __cplusplus

}

#endif

#include <libxml/xmlregexp.h>

#ifdef __cplusplus

extern "C" {

#endif



typedef struct _xmlElement xmlElement;

typedef xmlElement *xmlElementPtr;

struct _xmlElement {

    void           *_private;           /* application data */

    xmlElementType          type;       /* XML_ELEMENT_DECL, must be second ! */

    const xmlChar          *name;       /* Element name */

    struct _xmlNode    *children;       /* NULL */

    struct _xmlNode        *last;       /* NULL */

    struct _xmlDtd       *parent;       /* -> DTD */

    struct _xmlNode        *next;       /* next sibling link  */

    struct _xmlNode        *prev;       /* previous sibling link  */

    struct _xmlDoc          *doc;       /* the containing document */



    xmlElementTypeVal      etype;       /* The type */

    xmlElementContentPtr content;       /* the allowed element content */

    xmlAttributePtr   attributes;       /* List of the declared attributes */

    const xmlChar        *prefix;       /* the namespace prefix if any */

#ifdef LIBXML_REGEXP_ENABLED

    xmlRegexpPtr       contModel;       /* the validating regexp */

#else

    void              *contModel;

#endif

};





#define XML_LOCAL_NAMESPACE XML_NAMESPACE_DECL

typedef xmlElementType xmlNsType;



typedef struct _xmlNs xmlNs;

typedef xmlNs *xmlNsPtr;

struct _xmlNs {

    struct _xmlNs  *next;       /* next Ns link for this node  */

    xmlNsType      type;        /* global or local */

    const xmlChar *href;        /* URL for the namespace */

    const xmlChar *prefix;      /* prefix for the namespace */

    void           *_private;   /* application data */

};



typedef struct _xmlDtd xmlDtd;

typedef xmlDtd *xmlDtdPtr;

struct _xmlDtd {

    void           *_private;   /* application data */

    xmlElementType  type;       /* XML_DTD_NODE, must be second ! */

    const xmlChar *name;        /* Name of the DTD */

    struct _xmlNode *children;  /* the value of the property link */

    struct _xmlNode *last;      /* last child link */

    struct _xmlDoc  *parent;    /* child->parent link */

    struct _xmlNode *next;      /* next sibling link  */

    struct _xmlNode *prev;      /* previous sibling link  */

    struct _xmlDoc  *doc;       /* the containing document */



    /* End of common part */

    void          *notations;   /* Hash table for notations if any */

    void          *elements;    /* Hash table for elements if any */

    void          *attributes;  /* Hash table for attributes if any */

    void          *entities;    /* Hash table for entities if any */

    const xmlChar *ExternalID;  /* External identifier for PUBLIC DTD */

    const xmlChar *SystemID;    /* URI for a SYSTEM or PUBLIC DTD */

    void          *pentities;   /* Hash table for param entities if any */

};



typedef struct _xmlAttr xmlAttr;

typedef xmlAttr *xmlAttrPtr;

struct _xmlAttr {

    void           *_private;   /* application data */

    xmlElementType   type;      /* XML_ATTRIBUTE_NODE, must be second ! */

    const xmlChar   *name;      /* the name of the property */

    struct _xmlNode *children;  /* the value of the property */

    struct _xmlNode *last;      /* NULL */

    struct _xmlNode *parent;    /* child->parent link */

    struct _xmlAttr *next;      /* next sibling link  */

    struct _xmlAttr *prev;      /* previous sibling link  */

    struct _xmlDoc  *doc;       /* the containing document */

    xmlNs           *ns;        /* pointer to the associated namespace */

    xmlAttributeType atype;     /* the attribute type if validating */

    void            *psvi;      /* for type/PSVI informations */

};



typedef struct _xmlID xmlID;

typedef xmlID *xmlIDPtr;

struct _xmlID {

    struct _xmlID    *next;     /* next ID */

    const xmlChar    *value;    /* The ID name */

    xmlAttrPtr        attr;     /* The attribute holding it */

    const xmlChar    *name;     /* The attribute if attr is not available */

    int               lineno;   /* The line number if attr is not available */

    struct _xmlDoc   *doc;      /* The document holding the ID */

};



typedef struct _xmlRef xmlRef;

typedef xmlRef *xmlRefPtr;

struct _xmlRef {

    struct _xmlRef    *next;    /* next Ref */

    const xmlChar     *value;   /* The Ref name */

    xmlAttrPtr        attr;     /* The attribute holding it */

    const xmlChar    *name;     /* The attribute if attr is not available */

    int               lineno;   /* The line number if attr is not available */

};



typedef enum {

    XML_BUFFER_ALLOC_DOUBLEIT,

    XML_BUFFER_ALLOC_EXACT,

    XML_BUFFER_ALLOC_IMMUTABLE

} xmlBufferAllocationScheme;



typedef struct _xmlBuffer xmlBuffer;

typedef xmlBuffer *xmlBufferPtr;

struct _xmlBuffer {

    xmlChar *content;           /* The buffer content UTF8 */

    unsigned int use;           /* The buffer size used */

    unsigned int size;          /* The buffer size */

    xmlBufferAllocationScheme alloc; /* The realloc method */

};



typedef struct _xmlNode xmlNode;

typedef xmlNode *xmlNodePtr;

struct _xmlNode {

    void           *_private;   /* application data */

    xmlElementType   type;      /* type number, must be second ! */

    const xmlChar   *name;      /* the name of the node, or the entity */

    struct _xmlNode *children;  /* parent->childs link */

    struct _xmlNode *last;      /* last child link */

    struct _xmlNode *parent;    /* child->parent link */

    struct _xmlNode *next;      /* next sibling link  */

    struct _xmlNode *prev;      /* previous sibling link  */

    struct _xmlDoc  *doc;       /* the containing document */



    /* End of common part */

    xmlNs           *ns;        /* pointer to the associated namespace */

    xmlChar         *content;   /* the content */

    struct _xmlAttr *properties;/* properties list */

    xmlNs           *nsDef;     /* namespace definitions on this node */

    void            *psvi;      /* for type/PSVI informations */

    unsigned short   line;      /* line number */

    unsigned short   extra;     /* extra data for XPath/XSLT */

};



#define XML_GET_CONTENT(n)                                      \

    ((n)->type == XML_ELEMENT_NODE ? NULL : (n)->content)



#define XML_GET_LINE(n)                                         \

    (xmlGetLineNo(n))





typedef struct _xmlDoc xmlDoc;

typedef xmlDoc *xmlDocPtr;

struct _xmlDoc {

    void           *_private;   /* application data */

    xmlElementType  type;       /* XML_DOCUMENT_NODE, must be second ! */

    char           *name;       /* name/filename/URI of the document */

    struct _xmlNode *children;  /* the document tree */

    struct _xmlNode *last;      /* last child link */

    struct _xmlNode *parent;    /* child->parent link */

    struct _xmlNode *next;      /* next sibling link  */

    struct _xmlNode *prev;      /* previous sibling link  */

    struct _xmlDoc  *doc;       /* autoreference to itself */



    /* End of common part */

    int             compression;/* level of zlib compression */

    int             standalone; /* standalone document (no external refs) */

    struct _xmlDtd  *intSubset; /* the document internal subset */

    struct _xmlDtd  *extSubset; /* the document external subset */

    struct _xmlNs   *oldNs;     /* Global namespace, the old way */

    const xmlChar  *version;    /* the XML version string */

    const xmlChar  *encoding;   /* external initial encoding, if any */

    void           *ids;        /* Hash table for ID attributes if any */

    void           *refs;       /* Hash table for IDREFs attributes if any */

    const xmlChar  *URL;        /* The URI for that document */

    int             charset;    /* encoding of the in-memory content

                                   actually an xmlCharEncoding */

    struct _xmlDict *dict;      /* dict used to allocate names or NULL */

    void           *psvi;       /* for type/PSVI informations */

};



#ifndef xmlChildrenNode

#define xmlChildrenNode children

#endif



#ifndef xmlRootNode

#define xmlRootNode children

#endif



/*

 * Variables.

 */



/*

 * Some helper functions

 */

#if defined(LIBXML_TREE_ENABLED) || defined(LIBXML_XPATH_ENABLED) || defined(LIBXML_SCHEMAS_ENABLED) || defined(LIBXML_DEBUG_ENABLED)

XMLPUBFUN int XMLCALL

                xmlValidateNCName       (const xmlChar *value,

                                         int space);

#endif



#if defined(LIBXML_TREE_ENABLED) || defined(LIBXML_SCHEMAS_ENABLED)

XMLPUBFUN int XMLCALL           

                xmlValidateQName        (const xmlChar *value,

                                         int space);

XMLPUBFUN int XMLCALL           

                xmlValidateName         (const xmlChar *value,

                                         int space);

XMLPUBFUN int XMLCALL           

                xmlValidateNMToken      (const xmlChar *value,

                                         int space);

#endif



XMLPUBFUN xmlChar * XMLCALL     

                xmlBuildQName           (const xmlChar *ncname,

                                         const xmlChar *prefix,

                                         xmlChar *memory,

                                         int len);

XMLPUBFUN xmlChar * XMLCALL     

                xmlSplitQName2          (const xmlChar *name,

                                         xmlChar **prefix);

XMLPUBFUN const xmlChar * XMLCALL       

                xmlSplitQName3          (const xmlChar *name,

                                         int *len);



/*

 * Handling Buffers.

 */



XMLPUBFUN void XMLCALL          

                xmlSetBufferAllocationScheme(xmlBufferAllocationScheme scheme);

XMLPUBFUN xmlBufferAllocationScheme XMLCALL      

                xmlGetBufferAllocationScheme(void);



XMLPUBFUN xmlBufferPtr XMLCALL  

                xmlBufferCreate         (void);

XMLPUBFUN xmlBufferPtr XMLCALL  

                xmlBufferCreateSize     (size_t size);

XMLPUBFUN xmlBufferPtr XMLCALL  

                xmlBufferCreateStatic   (void *mem,

                                         size_t size);

XMLPUBFUN int XMLCALL           

                xmlBufferResize         (xmlBufferPtr buf,

                                         unsigned int size);

XMLPUBFUN void XMLCALL          

                xmlBufferFree           (xmlBufferPtr buf);

XMLPUBFUN int XMLCALL           

                xmlBufferDump           (FILE *file,

                                         xmlBufferPtr buf);

XMLPUBFUN int XMLCALL           

                xmlBufferAdd            (xmlBufferPtr buf,

                                         const xmlChar *str,

                                         int len);

XMLPUBFUN int XMLCALL           

                xmlBufferAddHead        (xmlBufferPtr buf,

                                         const xmlChar *str,

                                         int len);

XMLPUBFUN int XMLCALL           

                xmlBufferCat            (xmlBufferPtr buf,

                                         const xmlChar *str);

XMLPUBFUN int XMLCALL   

                xmlBufferCCat           (xmlBufferPtr buf,

                                         const char *str);

XMLPUBFUN int XMLCALL           

                xmlBufferShrink         (xmlBufferPtr buf,

                                         unsigned int len);

XMLPUBFUN int XMLCALL           

                xmlBufferGrow           (xmlBufferPtr buf,

                                         unsigned int len);

XMLPUBFUN void XMLCALL          

                xmlBufferEmpty          (xmlBufferPtr buf);

XMLPUBFUN const xmlChar* XMLCALL        

                xmlBufferContent        (const xmlBufferPtr buf);

XMLPUBFUN void XMLCALL          

                xmlBufferSetAllocationScheme(xmlBufferPtr buf,

                                         xmlBufferAllocationScheme scheme);

XMLPUBFUN int XMLCALL           

                xmlBufferLength         (const xmlBufferPtr buf);



/*

 * Creating/freeing new structures.

 */

XMLPUBFUN xmlDtdPtr XMLCALL     

                xmlCreateIntSubset      (xmlDocPtr doc,

                                         const xmlChar *name,

                                         const xmlChar *ExternalID,

                                         const xmlChar *SystemID);

XMLPUBFUN xmlDtdPtr XMLCALL     

                xmlNewDtd               (xmlDocPtr doc,

                                         const xmlChar *name,

                                         const xmlChar *ExternalID,

                                         const xmlChar *SystemID);

XMLPUBFUN xmlDtdPtr XMLCALL     

                xmlGetIntSubset         (xmlDocPtr doc);

XMLPUBFUN void XMLCALL          

                xmlFreeDtd              (xmlDtdPtr cur);

#ifdef LIBXML_LEGACY_ENABLED

XMLPUBFUN xmlNsPtr XMLCALL      

                xmlNewGlobalNs          (xmlDocPtr doc,

                                         const xmlChar *href,

                                         const xmlChar *prefix);

#endif /* LIBXML_LEGACY_ENABLED */

XMLPUBFUN xmlNsPtr XMLCALL      

                xmlNewNs                (xmlNodePtr node,

                                         const xmlChar *href,

                                         const xmlChar *prefix);

XMLPUBFUN void XMLCALL          

                xmlFreeNs               (xmlNsPtr cur);

XMLPUBFUN void XMLCALL          

                xmlFreeNsList           (xmlNsPtr cur);

XMLPUBFUN xmlDocPtr XMLCALL     

                xmlNewDoc               (const xmlChar *version);

XMLPUBFUN void XMLCALL          

                xmlFreeDoc              (xmlDocPtr cur);

XMLPUBFUN xmlAttrPtr XMLCALL    

                xmlNewDocProp           (xmlDocPtr doc,

                                         const xmlChar *name,

                                         const xmlChar *value);

#if defined(LIBXML_TREE_ENABLED) || defined(LIBXML_HTML_ENABLED) || \

    defined(LIBXML_SCHEMAS_ENABLED)

XMLPUBFUN xmlAttrPtr XMLCALL    

                xmlNewProp              (xmlNodePtr node,

                                         const xmlChar *name,

                                         const xmlChar *value);

#endif

XMLPUBFUN xmlAttrPtr XMLCALL    

                xmlNewNsProp            (xmlNodePtr node,

                                         xmlNsPtr ns,

                                         const xmlChar *name,

                                         const xmlChar *value);

XMLPUBFUN xmlAttrPtr XMLCALL    

                xmlNewNsPropEatName     (xmlNodePtr node,

                                         xmlNsPtr ns,

                                         xmlChar *name,

                                         const xmlChar *value);

XMLPUBFUN void XMLCALL          

                xmlFreePropList         (xmlAttrPtr cur);

XMLPUBFUN void XMLCALL          

                xmlFreeProp             (xmlAttrPtr cur);

XMLPUBFUN xmlAttrPtr XMLCALL    

                xmlCopyProp             (xmlNodePtr target,

                                         xmlAttrPtr cur);

XMLPUBFUN xmlAttrPtr XMLCALL    

                xmlCopyPropList         (xmlNodePtr target,

                                         xmlAttrPtr cur);

#ifdef LIBXML_TREE_ENABLED

XMLPUBFUN xmlDtdPtr XMLCALL     

                xmlCopyDtd              (xmlDtdPtr dtd);

#endif /* LIBXML_TREE_ENABLED */

#if defined(LIBXML_TREE_ENABLED) || defined(LIBXML_SCHEMAS_ENABLED)

XMLPUBFUN xmlDocPtr XMLCALL     

                xmlCopyDoc              (xmlDocPtr doc,

                                         int recursive);

#endif /* defined(LIBXML_TREE_ENABLED) || defined(LIBXML_SCHEMAS_ENABLED) */

/*

 * Creating new nodes.

 */

XMLPUBFUN xmlNodePtr XMLCALL    

                xmlNewDocNode           (xmlDocPtr doc,

                                         xmlNsPtr ns,

                                         const xmlChar *name,

                                         const xmlChar *content);

XMLPUBFUN xmlNodePtr XMLCALL    

                xmlNewDocNodeEatName    (xmlDocPtr doc,

                                         xmlNsPtr ns,

                                         xmlChar *name,

                                         const xmlChar *content);

XMLPUBFUN xmlNodePtr XMLCALL    

                xmlNewNode              (xmlNsPtr ns,

                                         const xmlChar *name);

XMLPUBFUN xmlNodePtr XMLCALL    

                xmlNewNodeEatName       (xmlNsPtr ns,

                                         xmlChar *name);

#if defined(LIBXML_TREE_ENABLED) || defined(LIBXML_SCHEMAS_ENABLED)

XMLPUBFUN xmlNodePtr XMLCALL    

                xmlNewChild             (xmlNodePtr parent,

                                         xmlNsPtr ns,

                                         const xmlChar *name,

                                         const xmlChar *content);

#endif

XMLPUBFUN xmlNodePtr XMLCALL    

                xmlNewDocText           (xmlDocPtr doc,

                                         const xmlChar *content);

XMLPUBFUN xmlNodePtr XMLCALL    

                xmlNewText              (const xmlChar *content);

XMLPUBFUN xmlNodePtr XMLCALL    

                xmlNewDocPI             (xmlDocPtr doc,

                                         const xmlChar *name,

                                         const xmlChar *content);

XMLPUBFUN xmlNodePtr XMLCALL    

                xmlNewPI                (const xmlChar *name,

                                         const xmlChar *content);

XMLPUBFUN xmlNodePtr XMLCALL    

                xmlNewDocTextLen        (xmlDocPtr doc,

                                         const xmlChar *content,

                                         int len);

XMLPUBFUN xmlNodePtr XMLCALL    

                xmlNewTextLen           (const xmlChar *content,

                                         int len);

XMLPUBFUN xmlNodePtr XMLCALL    

                xmlNewDocComment        (xmlDocPtr doc,

                                         const xmlChar *content);

XMLPUBFUN xmlNodePtr XMLCALL    

                xmlNewComment           (const xmlChar *content);

XMLPUBFUN xmlNodePtr XMLCALL    

                xmlNewCDataBlock        (xmlDocPtr doc,

                                         const xmlChar *content,

                                         int len);

XMLPUBFUN xmlNodePtr XMLCALL    

                xmlNewCharRef           (xmlDocPtr doc,

                                         const xmlChar *name);

XMLPUBFUN xmlNodePtr XMLCALL    

                xmlNewReference         (xmlDocPtr doc,

                                         const xmlChar *name);

XMLPUBFUN xmlNodePtr XMLCALL    

                xmlCopyNode             (const xmlNodePtr node,

                                         int recursive);

XMLPUBFUN xmlNodePtr XMLCALL    

                xmlDocCopyNode          (const xmlNodePtr node,

                                         xmlDocPtr doc,

                                         int recursive);

XMLPUBFUN xmlNodePtr XMLCALL    

                xmlDocCopyNodeList      (xmlDocPtr doc,

                                         const xmlNodePtr node);

XMLPUBFUN xmlNodePtr XMLCALL    

                xmlCopyNodeList         (const xmlNodePtr node);

#ifdef LIBXML_TREE_ENABLED

XMLPUBFUN xmlNodePtr XMLCALL    

                xmlNewTextChild         (xmlNodePtr parent,

                                         xmlNsPtr ns,

                                         const xmlChar *name,

                                         const xmlChar *content);

XMLPUBFUN xmlNodePtr XMLCALL    

                xmlNewDocRawNode        (xmlDocPtr doc,

                                         xmlNsPtr ns,

                                         const xmlChar *name,

                                         const xmlChar *content);

XMLPUBFUN xmlNodePtr XMLCALL    

                xmlNewDocFragment       (xmlDocPtr doc);

#endif /* LIBXML_TREE_ENABLED */



/*

 * Navigating.

 */

XMLPUBFUN long XMLCALL          

                xmlGetLineNo            (xmlNodePtr node);

#if defined(LIBXML_TREE_ENABLED) || defined(LIBXML_DEBUG_ENABLED)

XMLPUBFUN xmlChar * XMLCALL     

                xmlGetNodePath          (xmlNodePtr node);

#endif /* defined(LIBXML_TREE_ENABLED) || defined(LIBXML_DEBUG_ENABLED) */

XMLPUBFUN xmlNodePtr XMLCALL    

                xmlDocGetRootElement    (xmlDocPtr doc);

XMLPUBFUN xmlNodePtr XMLCALL    

                xmlGetLastChild         (xmlNodePtr parent);

XMLPUBFUN int XMLCALL           

                xmlNodeIsText           (xmlNodePtr node);

XMLPUBFUN int XMLCALL           

                xmlIsBlankNode          (xmlNodePtr node);



/*

 * Changing the structure.

 */

#if defined(LIBXML_TREE_ENABLED) || defined(LIBXML_WRITER_ENABLED)

XMLPUBFUN xmlNodePtr XMLCALL    

                xmlDocSetRootElement    (xmlDocPtr doc,

                                         xmlNodePtr root);

#endif /* defined(LIBXML_TREE_ENABLED) || defined(LIBXML_WRITER_ENABLED) */

#ifdef LIBXML_TREE_ENABLED

XMLPUBFUN void XMLCALL          

                xmlNodeSetName          (xmlNodePtr cur,

                                         const xmlChar *name);

#endif /* LIBXML_TREE_ENABLED */

XMLPUBFUN xmlNodePtr XMLCALL    

                xmlAddChild             (xmlNodePtr parent,

                                         xmlNodePtr cur);

XMLPUBFUN xmlNodePtr XMLCALL    

                xmlAddChildList         (xmlNodePtr parent,

                                         xmlNodePtr cur);

#if defined(LIBXML_TREE_ENABLED) || defined(LIBXML_WRITER_ENABLED)

XMLPUBFUN xmlNodePtr XMLCALL    

                xmlReplaceNode          (xmlNodePtr old,

                                         xmlNodePtr cur);

#endif /* defined(LIBXML_TREE_ENABLED) || defined(LIBXML_WRITER_ENABLED) */

#if defined(LIBXML_TREE_ENABLED) || defined(LIBXML_HTML_ENABLED) || \

    defined(LIBXML_SCHEMAS_ENABLED)

XMLPUBFUN xmlNodePtr XMLCALL    

                xmlAddPrevSibling       (xmlNodePtr cur,

                                         xmlNodePtr elem);

#endif /* LIBXML_TREE_ENABLED || LIBXML_HTML_ENABLED || LIBXML_SCHEMAS_ENABLED */

XMLPUBFUN xmlNodePtr XMLCALL    

                xmlAddSibling           (xmlNodePtr cur,

                                         xmlNodePtr elem);

XMLPUBFUN xmlNodePtr XMLCALL    

                xmlAddNextSibling       (xmlNodePtr cur,

                                         xmlNodePtr elem);

XMLPUBFUN void XMLCALL          

                xmlUnlinkNode           (xmlNodePtr cur);

XMLPUBFUN xmlNodePtr XMLCALL    

                xmlTextMerge            (xmlNodePtr first,

                                         xmlNodePtr second);

XMLPUBFUN int XMLCALL           

                xmlTextConcat           (xmlNodePtr node,

                                         const xmlChar *content,

                                         int len);

XMLPUBFUN void XMLCALL          

                xmlFreeNodeList         (xmlNodePtr cur);

XMLPUBFUN void XMLCALL          

                xmlFreeNode             (xmlNodePtr cur);

XMLPUBFUN void XMLCALL          

                xmlSetTreeDoc           (xmlNodePtr tree,

                                         xmlDocPtr doc);

XMLPUBFUN void XMLCALL          

                xmlSetListDoc           (xmlNodePtr list,

                                         xmlDocPtr doc);

/*

 * Namespaces.

 */

XMLPUBFUN xmlNsPtr XMLCALL      

                xmlSearchNs             (xmlDocPtr doc,

                                         xmlNodePtr node,

                                         const xmlChar *nameSpace);

XMLPUBFUN xmlNsPtr XMLCALL      

                xmlSearchNsByHref       (xmlDocPtr doc,

                                         xmlNodePtr node,

                                         const xmlChar *href);

#if defined(LIBXML_TREE_ENABLED) || defined(LIBXML_XPATH_ENABLED)

XMLPUBFUN xmlNsPtr * XMLCALL    

                xmlGetNsList            (xmlDocPtr doc,

                                         xmlNodePtr node);

#endif /* defined(LIBXML_TREE_ENABLED) || defined(LIBXML_XPATH_ENABLED) */



XMLPUBFUN void XMLCALL          

                xmlSetNs                (xmlNodePtr node,

                                         xmlNsPtr ns);

XMLPUBFUN xmlNsPtr XMLCALL      

                xmlCopyNamespace        (xmlNsPtr cur);

XMLPUBFUN xmlNsPtr XMLCALL      

                xmlCopyNamespaceList    (xmlNsPtr cur);



/*

 * Changing the content.

 */

#if defined(LIBXML_TREE_ENABLED) || defined(LIBXML_XINCLUDE_ENABLED) || defined(LIBXML_SCHEMAS_ENABLED) || defined(LIBXML_HTML_ENABLED)

XMLPUBFUN xmlAttrPtr XMLCALL    

                xmlSetProp              (xmlNodePtr node,

                                         const xmlChar *name,

                                         const xmlChar *value);

XMLPUBFUN xmlAttrPtr XMLCALL    

                xmlSetNsProp            (xmlNodePtr node,

                                         xmlNsPtr ns,

                                         const xmlChar *name,

                                         const xmlChar *value);

#endif /* defined(LIBXML_TREE_ENABLED) || defined(LIBXML_XINCLUDE_ENABLED) || defined(LIBXML_SCHEMAS_ENABLED) || defined(LIBXML_HTML_ENABLED) */

XMLPUBFUN xmlChar * XMLCALL     

                xmlGetNoNsProp          (xmlNodePtr node,

                                         const xmlChar *name);

XMLPUBFUN xmlChar * XMLCALL     

                xmlGetProp              (xmlNodePtr node,

                                         const xmlChar *name);

XMLPUBFUN xmlAttrPtr XMLCALL    

                xmlHasProp              (xmlNodePtr node,

                                         const xmlChar *name);

XMLPUBFUN xmlAttrPtr XMLCALL    

                xmlHasNsProp            (xmlNodePtr node,

                                         const xmlChar *name,

                                         const xmlChar *nameSpace);

XMLPUBFUN xmlChar * XMLCALL     

                xmlGetNsProp            (xmlNodePtr node,

                                         const xmlChar *name,

                                         const xmlChar *nameSpace);

XMLPUBFUN xmlNodePtr XMLCALL    

                xmlStringGetNodeList    (xmlDocPtr doc,

                                         const xmlChar *value);

XMLPUBFUN xmlNodePtr XMLCALL    

                xmlStringLenGetNodeList (xmlDocPtr doc,

                                         const xmlChar *value,

                                         int len);

XMLPUBFUN xmlChar * XMLCALL     

                xmlNodeListGetString    (xmlDocPtr doc,

                                         xmlNodePtr list,

                                         int inLine);

#ifdef LIBXML_TREE_ENABLED

XMLPUBFUN xmlChar * XMLCALL     

                xmlNodeListGetRawString (xmlDocPtr doc,

                                         xmlNodePtr list,

                                         int inLine);

#endif /* LIBXML_TREE_ENABLED */

XMLPUBFUN void XMLCALL          

                xmlNodeSetContent       (xmlNodePtr cur,

                                         const xmlChar *content);

#ifdef LIBXML_TREE_ENABLED

XMLPUBFUN void XMLCALL          

                xmlNodeSetContentLen    (xmlNodePtr cur,

                                         const xmlChar *content,

                                         int len);

#endif /* LIBXML_TREE_ENABLED */

XMLPUBFUN void XMLCALL          

                xmlNodeAddContent       (xmlNodePtr cur,

                                         const xmlChar *content);

XMLPUBFUN void XMLCALL          

                xmlNodeAddContentLen    (xmlNodePtr cur,

                                         const xmlChar *content,

                                         int len);

XMLPUBFUN xmlChar * XMLCALL     

                xmlNodeGetContent       (xmlNodePtr cur);

XMLPUBFUN int XMLCALL

                xmlNodeBufGetContent    (xmlBufferPtr buffer,

                                         xmlNodePtr cur);

XMLPUBFUN xmlChar * XMLCALL     

                xmlNodeGetLang          (xmlNodePtr cur);

XMLPUBFUN int XMLCALL           

                xmlNodeGetSpacePreserve (xmlNodePtr cur);

#ifdef LIBXML_TREE_ENABLED

XMLPUBFUN void XMLCALL          

                xmlNodeSetLang          (xmlNodePtr cur,

                                         const xmlChar *lang);

XMLPUBFUN void XMLCALL          

                xmlNodeSetSpacePreserve (xmlNodePtr cur,

                                         int val);

#endif /* LIBXML_TREE_ENABLED */

XMLPUBFUN xmlChar * XMLCALL     

                xmlNodeGetBase          (xmlDocPtr doc,

                                         xmlNodePtr cur);

#if defined(LIBXML_TREE_ENABLED) || defined(LIBXML_XINCLUDE_ENABLED)

XMLPUBFUN void XMLCALL          

                xmlNodeSetBase          (xmlNodePtr cur,

                                         const xmlChar *uri);

#endif



/*

 * Removing content.

 */

#ifdef LIBXML_TREE_ENABLED

XMLPUBFUN int XMLCALL           

                xmlRemoveProp           (xmlAttrPtr cur);

#endif /* LIBXML_TREE_ENABLED */

#if defined(LIBXML_TREE_ENABLED) || defined(LIBXML_SCHEMAS_ENABLED)

XMLPUBFUN int XMLCALL           

                xmlUnsetNsProp          (xmlNodePtr node,

                                         xmlNsPtr ns,

                                         const xmlChar *name);

XMLPUBFUN int XMLCALL           

                xmlUnsetProp            (xmlNodePtr node,

                                         const xmlChar *name);

#endif /* defined(LIBXML_TREE_ENABLED) || defined(LIBXML_SCHEMAS_ENABLED) */



/*

 * Internal, don't use.

 */

XMLPUBFUN void XMLCALL          

                xmlBufferWriteCHAR      (xmlBufferPtr buf,

                                         const xmlChar *string);

XMLPUBFUN void XMLCALL          

                xmlBufferWriteChar      (xmlBufferPtr buf,

                                         const char *string);

XMLPUBFUN void XMLCALL          

                xmlBufferWriteQuotedString(xmlBufferPtr buf,

                                         const xmlChar *string);



#ifdef LIBXML_OUTPUT_ENABLED

XMLPUBFUN void xmlAttrSerializeTxtContent(xmlBufferPtr buf,

                                         xmlDocPtr doc,

                                         xmlAttrPtr attr,

                                         const xmlChar *string);

#endif /* LIBXML_OUTPUT_ENABLED */



#ifdef LIBXML_TREE_ENABLED

/*

 * Namespace handling.

 */

XMLPUBFUN int XMLCALL           

                xmlReconciliateNs       (xmlDocPtr doc,

                                         xmlNodePtr tree);

#endif



#ifdef LIBXML_OUTPUT_ENABLED

/*

 * Saving.

 */

XMLPUBFUN void XMLCALL          

                xmlDocDumpFormatMemory  (xmlDocPtr cur,

                                         xmlChar **mem,

                                         int *size,

                                         int format);

XMLPUBFUN void XMLCALL          

                xmlDocDumpMemory        (xmlDocPtr cur,

                                         xmlChar **mem,

                                         int *size);

XMLPUBFUN void XMLCALL          

                xmlDocDumpMemoryEnc     (xmlDocPtr out_doc,

                                         xmlChar **doc_txt_ptr,

                                         int * doc_txt_len,

                                         const char *txt_encoding);

XMLPUBFUN void XMLCALL          

                xmlDocDumpFormatMemoryEnc(xmlDocPtr out_doc,

                                         xmlChar **doc_txt_ptr,

                                         int * doc_txt_len,

                                         const char *txt_encoding,

                                         int format);

XMLPUBFUN int XMLCALL           

                xmlDocFormatDump        (FILE *f,

                                         xmlDocPtr cur,

                                         int format);

XMLPUBFUN int XMLCALL   

                xmlDocDump              (FILE *f,

                                         xmlDocPtr cur);

XMLPUBFUN void XMLCALL          

                xmlElemDump             (FILE *f,

                                         xmlDocPtr doc,

                                         xmlNodePtr cur);

XMLPUBFUN int XMLCALL           

                xmlSaveFile             (const char *filename,

                                         xmlDocPtr cur);

XMLPUBFUN int XMLCALL           

                xmlSaveFormatFile       (const char *filename,

                                         xmlDocPtr cur,

                                         int format);

XMLPUBFUN int XMLCALL           

                xmlNodeDump             (xmlBufferPtr buf,

                                         xmlDocPtr doc,

                                         xmlNodePtr cur,

                                         int level,

                                         int format);



XMLPUBFUN int XMLCALL           

                xmlSaveFileTo           (xmlOutputBufferPtr buf,

                                         xmlDocPtr cur,

                                         const char *encoding);

XMLPUBFUN int XMLCALL             

                xmlSaveFormatFileTo     (xmlOutputBufferPtr buf,

                                         xmlDocPtr cur,

                                         const char *encoding,

                                         int format);

XMLPUBFUN void XMLCALL          

                xmlNodeDumpOutput       (xmlOutputBufferPtr buf,

                                         xmlDocPtr doc,

                                         xmlNodePtr cur,

                                         int level,

                                         int format,

                                         const char *encoding);



XMLPUBFUN int XMLCALL           

                xmlSaveFormatFileEnc    (const char *filename,

                                         xmlDocPtr cur,

                                         const char *encoding,

                                         int format);



XMLPUBFUN int XMLCALL           

                xmlSaveFileEnc          (const char *filename,

                                         xmlDocPtr cur,

                                         const char *encoding);



#endif /* LIBXML_OUTPUT_ENABLED */

/*

 * XHTML

 */

XMLPUBFUN int XMLCALL           

                xmlIsXHTML              (const xmlChar *systemID,

                                         const xmlChar *publicID);



/*

 * Compression.

 */

XMLPUBFUN int XMLCALL           

                xmlGetDocCompressMode   (xmlDocPtr doc);

XMLPUBFUN void XMLCALL          

                xmlSetDocCompressMode   (xmlDocPtr doc,

                                         int mode);

XMLPUBFUN int XMLCALL           

                xmlGetCompressMode      (void);

XMLPUBFUN void XMLCALL          

                xmlSetCompressMode      (int mode);



#ifdef __cplusplus

}

#endif

#ifndef __XML_PARSER_H__

#include <libxml/xmlmemory.h>

#endif



#endif /* __XML_TREE_H__ */

---