/*

 * 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

 * Portion Copyright © 2009 Nokia Corporation and/or its subsidiary(-ies). All rights reserved. 

 */

/** @file

@publishedAll

@released

*/

#ifndef XML_TREE_H

#define XML_TREE_H

#include <stdapis/libxml2/libxml2_xmlstring.h>

#include <stdlib.h>

#include <stdio.h>

#ifdef LIBXML_REGEXP_ENABLED

#include "libxml2_xmlregexp.h"

#endif

#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 _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;

/**

 * BASE_BUFFER_SIZE:

 *

 * default buffer size 4000.

 */

#define BASE_BUFFER_SIZE 4096

//                     BUT! remember that it is checked in #ifdef's

/**

 * XML_XML_NAMESPACE:

 *

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

/**

 * XML_XML_ID:

 *

 * This is the name for the special xml:id attribute

 */

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

/*

 * The different element types carried by an XML tree.

 *

 * NOTE: This is synchronized with DOM Level1 values

 *       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 //DocBook support is excluded from XML Engine

//#endif

} xmlElementType;

/**

 * xmlNotation:

 *

 * A DTD Notation definition.

 */

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

};

/**

 * xmlAttributeType:

 *

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

/**

 * xmlAttributeDefault:

 *

 * A DTD Attribute default definition.

 */

typedef enum {

    XML_ATTRIBUTE_NONE = 1,

    XML_ATTRIBUTE_REQUIRED,

    XML_ATTRIBUTE_IMPLIED,

    XML_ATTRIBUTE_FIXED

} xmlAttributeDefault;

/**

 * xmlEnumeration:

 *

 * List structure used when there is an enumeration in DTDs.

 */

typedef struct _xmlEnumeration xmlEnumeration;

typedef xmlEnumeration *xmlEnumerationPtr;

struct _xmlEnumeration {

    struct _xmlEnumeration    *next;    /* next one */

    const xmlChar            *name; /* Enumeration name */

};

/**

 * xmlAttribute:

 *

 * An Attribute declaration in a DTD.

 */

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

};

/**

 * xmlElementContentType:

 *

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

/**

 * xmlElementContentOccur:

 *

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

/**

 * xmlElementContent:

 *

 * An XML Element content as stored after parsing an element definition

 * in a DTD.

 */

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

};

/**

 * xmlElementTypeVal:

 *

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

//#ifdef __cplusplus

//}

//#endif

//#ifdef __cplusplus

//extern "C" {

//#endif

/**

 * xmlElement:

 *

 * An XML Element declaration from a DTD.

 */

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

};

/**

 * XML_LOCAL_NAMESPACE:

 *

 * A namespace declaration node.

 */

#define XML_LOCAL_NAMESPACE XML_NAMESPACE_DECL

typedef xmlElementType xmlNsType;

/**

 * xmlNs:

 *

 * An XML namespace.

 * Note that prefix == NULL is valid, it defines the default namespace

 * within the subtree (until overridden).

 *

 * xmlNsType is unified with xmlElementType.

 */

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

};

/**

 * xmlDtd:

 *

 * An XML DTD, as defined by <!DOCTYPE ... There is actually one for

 * the internal subset and for the external subset.

 */

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

};

/**

 * xmlAttr:

 *

 * An attribute on an XML node.

 */

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

    /* End of common part */

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

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

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

};

/**

 * xmlID:

 *

 * An XML ID instance.

 */

typedef struct _xmlID xmlID;

typedef xmlID* xmlIDPtr;

struct _xmlID {

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

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

#ifdef LIBXML_ENABLE_NODE_LINEINFO

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

#endif

};

/**

 * xmlRef:

 *

 * An XML IDREF instance.

 */

typedef struct _xmlRef xmlRef;

typedef xmlRef* xmlRefPtr;

struct _xmlRef {

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

#ifdef LIBXML_ENABLE_NODE_LINEINFO

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

#endif

};

/**

 * xmlBufferAllocationScheme:

 *

 * A buffer allocation scheme can be defined to either match exactly the

 * need or double it's allocated size each time it is found too small.

 */

typedef enum {

    XML_BUFFER_ALLOC_DOUBLEIT,

    XML_BUFFER_ALLOC_EXACT,

    XML_BUFFER_ALLOC_IMMUTABLE

} xmlBufferAllocationScheme;

/**

 * xmlBuffer:

 *

 * A buffer structure.

 */

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

};

/**

 * xmlNode:

 *

 * A node in an XML tree. 

 *

 * Note:

 * Text nodes are also used to store binary data in the tree. 

 * 'content' field is used to store a pointer to binary data

 * 'properties' field is used to store int length of the data 

 *

 */

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

    xmlNodePtr      children;  /* parent->childs link */

    xmlNodePtr      last;      /* last child link */

    xmlNodePtr      parent;    /* child->parent link */

    xmlNodePtr      next;      /* next sibling link  */

    xmlNodePtr      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   extra;     /* extra data for XPath/XSLT */

#ifdef LIBXML_ENABLE_NODE_LINEINFO

    unsigned short   line;      /* line number */

#endif

};

/**

 * XML_GET_CONTENT:

 *

 * Macro to extract the content pointer of a node.

 */

#define XML_GET_CONTENT(n)                  \

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

#ifdef LIBXML_ENABLE_NODE_LINEINFO

/**

 * XML_GET_LINE:

 *

 * Macro to extract the line number of an element node.

 */

#define XML_GET_LINE(n)    (xmlGetLineNo(n))

#endif /* LIBXML_ENABLE_NODE_LINEINFO */

/**

 * xmlDoc:

 *

 * An XML document.

 */

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

    /* dummy fields to avoid incorrect use of xmlDoc as xmlNode

       currently, always NULL; reserved.

       Added to prevent potential problems of same kind in the future.

    */

    void*           _reserved1; /* ~ xmlNode.ns            */

    void*           _reserved2; /* ~ xmlNode.content       */

    void*           _reserved3; /* ~ xmlNode.properties    */

    void*           _reserved4; /* ~ xmlNode.nsDef         */

    /* End of 2nd (extra) common part (same as xmlNode) */

#ifdef LIBXML_ENABLE_GS_CACHING_IN_DOC

    void*           cachedGs;   /* cached value returned by xmlGetGlobalState() */

#endif

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

//XMLENGINE: NEW CODE

    /*

    A container for nodes that were created as nodes of this document but

    are not linked into the document yet

    NOTE: this field is used by DOM C++ API only (not in libxml2 functions)

    */

    void*            ownedNodes;

    /* 

     * Container for nodes that store external data references

     */

    xmlNodePtr*		dataNodeList; 	/* array of data nodes */

    int				dataNodeMax;	/* maximum number of data nodes in the array */

//

};

/*

 * Variables.

 */

/*

 * Some helper functions

 */

XMLPUBFUN int XMLCALL xmlValidateNCName (const xmlChar* value, int space);

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

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

#ifndef XMLENGINE_EXCLUDE_UNUSED

XMLPUBFUN xmlBufferAllocationScheme XMLCALL

        xmlGetBufferAllocationScheme(void);

#endif /* ifndef XMLENGINE_EXCLUDE_UNUSED */

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

#ifndef XMLENGINE_EXCLUDE_FILE_FUNC

XMLPUBFUN int XMLCALL

        xmlBufferDump       (FILE *file, xmlBufferPtr buf);

#endif

XMLPUBFUN void XMLCALL

        xmlBufferAdd        (xmlBufferPtr buf, const xmlChar *str, int len);

XMLPUBFUN void XMLCALL

        xmlBufferAddHead    (xmlBufferPtr buf, const xmlChar *str, int len);

XMLPUBFUN void XMLCALL

        xmlBufferCat        (xmlBufferPtr buf, const xmlChar *str);

XMLPUBFUN void 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);

#ifndef XMLENGINE_EXCLUDE_UNUSED

XMLPUBFUN void XMLCALL xmlBufferEmpty   (xmlBufferPtr buf);

XMLPUBFUN void XMLCALL xmlBufferSetAllocationScheme(xmlBufferPtr buf, xmlBufferAllocationScheme scheme);

#endif

XMLPUBFUN int  XMLCALL xmlBufferLength  (const xmlBufferPtr buf);

// XMLENGINE: BEGIN NEW CODE

/**

 * xmlBufferContent:

 * @param buf the buffer

 *

 * Function to extract the content of a buffer

 *

 * Returns the internal content

 */

#define xmlBufferContent(buf) ((buf)? (buf)->content : NULL)

// XMLENGINE: END NEW CODE

// DONE: OPTIMIZE: replaced by MACRO

// XMLPUBFUN const xmlChar* XMLCALL

//      xmlBufferContent    (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);

XMLPUBFUN xmlNsPtr XMLCALL

        xmlNewGlobalNs      (xmlDocPtr doc,

                     const xmlChar *href,

                     const xmlChar *prefix);

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

XMLPUBFUN xmlAttrPtr XMLCALL

        xmlNewProp      (xmlNodePtr node,

                     const xmlChar *name,

                     const xmlChar *value);

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

XMLPUBFUN xmlDocPtr XMLCALL

        xmlCopyDoc      (xmlDocPtr doc,

                     int recursive);

#endif /* LIBXML_TREE_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

        xmlNewDocRawNode    (xmlDocPtr doc,

                     xmlNsPtr ns,

                     const xmlChar *name,

                     const xmlChar *content);

XMLPUBFUN xmlNodePtr XMLCALL

        xmlNewNode      (xmlNsPtr ns,

                     const xmlChar *name);

XMLPUBFUN xmlNodePtr XMLCALL

        xmlNewNodeEatName   (xmlNsPtr ns,

                     xmlChar *name);

XMLPUBFUN xmlNodePtr XMLCALL

        xmlNewChild     (xmlNodePtr parent,

                     xmlNsPtr ns,

                     const xmlChar *name,

                     const xmlChar *content);

XMLPUBFUN xmlNodePtr XMLCALL

        xmlNewTextChild     (xmlNodePtr parent,

                     xmlNsPtr ns,

                     const xmlChar *name,

                     const xmlChar *content);

XMLPUBFUN xmlNodePtr XMLCALL

        xmlNewDocText       (xmlDocPtr doc,

                     const xmlChar *content);

XMLPUBFUN xmlNodePtr XMLCALL

        xmlNewText      (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    xmlCopyNodeList     (const xmlNodePtr node);

#ifdef LIBXML_TREE_ENABLED

XMLPUBFUN xmlNodePtr XMLCALL    xmlNewDocFragment   (xmlDocPtr doc);

#endif /* LIBXML_TREE_ENABLED */

/*

 * Navigating.

 */

#ifdef LIBXML_ENABLE_NODE_LINEINFO

XMLPUBFUN long XMLCALL      xmlGetLineNo(xmlNodePtr node);

#endif

#ifdef LIBXML_TREE_ENABLED

#   ifndef XMLENGINE_EXCLUDE_UNUSED

        XMLPUBFUN xmlChar * XMLCALL xmlGetNodePath      (xmlNodePtr node);

#   endif /* ifndef XMLENGINE_EXCLUDE_UNUSED */

#endif /* LIBXML_TREE_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);

#ifdef LIBXML_TREE_ENABLED

/*

 * Changing the structure.

 */

XMLPUBFUN xmlNodePtr XMLCALL

        xmlDocSetRootElement    (xmlDocPtr doc, xmlNodePtr root);

XMLPUBFUN void XMLCALL

        xmlNodeSetName      (xmlNodePtr cur, const xmlChar *name);

XMLPUBFUN xmlNodePtr XMLCALL

        xmlReplaceNode      (xmlNodePtr old, xmlNodePtr cur);

XMLPUBFUN xmlNodePtr XMLCALL

        xmlAddPrevSibling   (xmlNodePtr cur, xmlNodePtr elem);

#endif /* LIBXML_TREE_ENABLED */

XMLPUBFUN xmlNodePtr XMLCALL

        xmlAddChild     (xmlNodePtr parent, xmlNodePtr cur);

XMLPUBFUN xmlNodePtr XMLCALL

        xmlAddChildList     (xmlNodePtr parent, xmlNodePtr cur);

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

XMLPUBFUN void     XMLCALL xmlSetNs             (xmlNodePtr node, xmlNsPtr ns);

XMLPUBFUN xmlNsPtr XMLCALL xmlCopyNamespace     (xmlNsPtr cur);

XMLPUBFUN xmlNsPtr XMLCALL xmlCopyNamespaceList (xmlNsPtr cur);

#ifdef LIBXML_TREE_ENABLED

XMLPUBFUN xmlNsPtr* XMLCALL xmlGetNsList (xmlDocPtr doc, xmlNodePtr node);

#endif /* LIBXML_TREE_ENABLED */

/*

 * Changing the content.

 */

#ifdef LIBXML_TREE_ENABLED

XMLPUBFUN xmlAttrPtr XMLCALL

        xmlSetProp      (xmlNodePtr node,

                     const xmlChar *name,

                     const xmlChar *value);

#endif /* LIBXML_TREE_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);

#ifdef LIBXML_TREE_ENABLED

XMLPUBFUN xmlAttrPtr XMLCALL

        xmlSetNsProp        (xmlNodePtr node,

                     xmlNsPtr ns,

                     const xmlChar *name,

                     const xmlChar *value);

#endif /* LIBXML_TREE_ENABLED */

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

XMLPUBFUN xmlChar * XMLCALL

        xmlNodeGetBase      (xmlDocPtr doc,

                     xmlNodePtr cur);

#ifdef LIBXML_TREE_ENABLED

XMLPUBFUN void XMLCALL

        xmlNodeSetLang      (xmlNodePtr cur,

                     const xmlChar *lang);

XMLPUBFUN void XMLCALL

        xmlNodeSetSpacePreserve (xmlNodePtr cur,

                     int val);

XMLPUBFUN void XMLCALL

        xmlNodeSetBase      (xmlNodePtr cur,

                     const xmlChar *uri);

/*

 * Removing content.

 */

XMLPUBFUN int XMLCALL

        xmlRemoveProp       (xmlAttrPtr cur);

XMLPUBFUN int XMLCALL

        xmlUnsetProp        (xmlNodePtr node,

                     const xmlChar *name);

XMLPUBFUN int XMLCALL

        xmlUnsetNsProp      (xmlNodePtr node,

                     xmlNsPtr ns,

                     const xmlChar *name);

#endif /* LIBXML_TREE_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);

XMLPUBFUN void xmlAttrSerializeTxtContent(xmlBufferPtr buf,

                     xmlDocPtr doc,

                     xmlAttrPtr attr,

                     const xmlChar *string);

/*

 * Namespace handling.