/*
 * 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.
 */
XMLPUBFUN int XMLCALL
        xmlReconciliateNs   (xmlDocPtr doc,
                     xmlNodePtr tree);

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

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

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 void  XMLCALL xmlSetDocCompressMode(xmlDocPtr doc, int mode);

#ifndef XMLENGINE_EXCLUDE_UNUSED
XMLPUBFUN int   XMLCALL xmlGetDocCompressMode(xmlDocPtr doc);
XMLPUBFUN int   XMLCALL xmlGetCompressMode(void);
XMLPUBFUN void  XMLCALL xmlSetCompressMode(int mode);
#endif /* ifndef XMLENGINE_EXCLUDE_UNUSED */

#ifdef __cplusplus
}
#endif

#endif /* XML_TREE_H */


