tree.h

Go to the documentation of this file.
00001 /*
00002  * Summary: interfaces for tree manipulation
00003  * Description: this module describes the structures found in an tree resulting
00004  *              from an XML or HTML parsing, as well as the API provided for
00005  *              various processing on that tree
00006  *
00007  * Copy: See Copyright for the status of this software.
00008  *
00009  * Author: Daniel Veillard
00010  */
00011 
00012 #ifndef __XML_TREE_H__
00013 #define __XML_TREE_H__
00014 
00015 #include <stdio.h>
00016 #include <libxml/xmlversion.h>
00017 #include <libxml/xmlstring.h>
00018 
00019 #ifdef __cplusplus
00020 extern "C" {
00021 #endif
00022 
00023 /*
00024  * Some of the basic types pointer to structures:
00025  */
00026 /* xmlIO.h */
00027 typedef struct _xmlParserInputBuffer xmlParserInputBuffer;
00028 typedef xmlParserInputBuffer *xmlParserInputBufferPtr;
00029 
00030 typedef struct _xmlOutputBuffer xmlOutputBuffer;
00031 typedef xmlOutputBuffer *xmlOutputBufferPtr;
00032 
00033 /* parser.h */
00034 typedef struct _xmlParserInput xmlParserInput;
00035 typedef xmlParserInput *xmlParserInputPtr;
00036 
00037 typedef struct _xmlParserCtxt xmlParserCtxt;
00038 typedef xmlParserCtxt *xmlParserCtxtPtr;
00039 
00040 typedef struct _xmlSAXLocator xmlSAXLocator;
00041 typedef xmlSAXLocator *xmlSAXLocatorPtr;
00042 
00043 typedef struct _xmlSAXHandler xmlSAXHandler;
00044 typedef xmlSAXHandler *xmlSAXHandlerPtr;
00045 
00046 /* entities.h */
00047 typedef struct _xmlEntity xmlEntity;
00048 typedef xmlEntity *xmlEntityPtr;
00049 
00055 #define BASE_BUFFER_SIZE 4096
00056 
00064 /* #define LIBXML_NAMESPACE_DICT */
00065 
00073 typedef enum {
00074     XML_BUFFER_ALLOC_DOUBLEIT,
00075     XML_BUFFER_ALLOC_EXACT,
00076     XML_BUFFER_ALLOC_IMMUTABLE
00077 } xmlBufferAllocationScheme;
00078 
00084 typedef struct _xmlBuffer xmlBuffer;
00085 typedef xmlBuffer *xmlBufferPtr;
00086 struct _xmlBuffer {
00087     xmlChar *content;       /* The buffer content UTF8 */
00088     unsigned int use;       /* The buffer size used */
00089     unsigned int size;      /* The buffer size */
00090     xmlBufferAllocationScheme alloc; /* The realloc method */
00091 };
00092 
00099 #define XML_XML_NAMESPACE \
00100     (const xmlChar *) "http://www.w3.org/XML/1998/namespace"
00101 
00107 #define XML_XML_ID (const xmlChar *) "xml:id"
00108 
00109 /*
00110  * The different element types carried by an XML tree.
00111  *
00112  * NOTE: This is synchronized with DOM Level1 values
00113  *       See http://www.w3.org/TR/REC-DOM-Level-1/
00114  *
00115  * Actually this had diverged a bit, and now XML_DOCUMENT_TYPE_NODE should
00116  * be deprecated to use an XML_DTD_NODE.
00117  */
00118 typedef enum {
00119     XML_ELEMENT_NODE=       1,
00120     XML_ATTRIBUTE_NODE=     2,
00121     XML_TEXT_NODE=      3,
00122     XML_CDATA_SECTION_NODE= 4,
00123     XML_ENTITY_REF_NODE=    5,
00124     XML_ENTITY_NODE=        6,
00125     XML_PI_NODE=        7,
00126     XML_COMMENT_NODE=       8,
00127     XML_DOCUMENT_NODE=      9,
00128     XML_DOCUMENT_TYPE_NODE= 10,
00129     XML_DOCUMENT_FRAG_NODE= 11,
00130     XML_NOTATION_NODE=      12,
00131     XML_HTML_DOCUMENT_NODE= 13,
00132     XML_DTD_NODE=       14,
00133     XML_ELEMENT_DECL=       15,
00134     XML_ATTRIBUTE_DECL=     16,
00135     XML_ENTITY_DECL=        17,
00136     XML_NAMESPACE_DECL=     18,
00137     XML_XINCLUDE_START=     19,
00138     XML_XINCLUDE_END=       20
00139 #ifdef LIBXML_DOCB_ENABLED
00140    ,XML_DOCB_DOCUMENT_NODE= 21
00141 #endif
00142 } xmlElementType;
00143 
00144 
00151 typedef struct _xmlNotation xmlNotation;
00152 typedef xmlNotation *xmlNotationPtr;
00153 struct _xmlNotation {
00154     const xmlChar               *name;          /* Notation name */
00155     const xmlChar               *PublicID;  /* Public identifier, if any */
00156     const xmlChar               *SystemID;  /* System identifier, if any */
00157 };
00158 
00165 typedef enum {
00166     XML_ATTRIBUTE_CDATA = 1,
00167     XML_ATTRIBUTE_ID,
00168     XML_ATTRIBUTE_IDREF ,
00169     XML_ATTRIBUTE_IDREFS,
00170     XML_ATTRIBUTE_ENTITY,
00171     XML_ATTRIBUTE_ENTITIES,
00172     XML_ATTRIBUTE_NMTOKEN,
00173     XML_ATTRIBUTE_NMTOKENS,
00174     XML_ATTRIBUTE_ENUMERATION,
00175     XML_ATTRIBUTE_NOTATION
00176 } xmlAttributeType;
00177 
00184 typedef enum {
00185     XML_ATTRIBUTE_NONE = 1,
00186     XML_ATTRIBUTE_REQUIRED,
00187     XML_ATTRIBUTE_IMPLIED,
00188     XML_ATTRIBUTE_FIXED
00189 } xmlAttributeDefault;
00190 
00197 typedef struct _xmlEnumeration xmlEnumeration;
00198 typedef xmlEnumeration *xmlEnumerationPtr;
00199 struct _xmlEnumeration {
00200     struct _xmlEnumeration    *next;    /* next one */
00201     const xmlChar            *name; /* Enumeration name */
00202 };
00203 
00210 typedef struct _xmlAttribute xmlAttribute;
00211 typedef xmlAttribute *xmlAttributePtr;
00212 struct _xmlAttribute {
00213     void           *_private;           /* application data */
00214     xmlElementType          type;       /* XML_ATTRIBUTE_DECL, must be second ! */
00215     const xmlChar          *name;   /* Attribute name */
00216     struct _xmlNode    *children;   /* NULL */
00217     struct _xmlNode        *last;   /* NULL */
00218     struct _xmlDtd       *parent;   /* -> DTD */
00219     struct _xmlNode        *next;   /* next sibling link  */
00220     struct _xmlNode        *prev;   /* previous sibling link  */
00221     struct _xmlDoc          *doc;       /* the containing document */
00222 
00223     struct _xmlAttribute  *nexth;   /* next in hash table */
00224     xmlAttributeType       atype;   /* The attribute type */
00225     xmlAttributeDefault      def;   /* the default */
00226     const xmlChar  *defaultValue;   /* or the default value */
00227     xmlEnumerationPtr       tree;       /* or the enumeration tree if any */
00228     const xmlChar        *prefix;   /* the namespace prefix if any */
00229     const xmlChar          *elem;   /* Element holding the attribute */
00230 };
00231 
00237 typedef enum {
00238     XML_ELEMENT_CONTENT_PCDATA = 1,
00239     XML_ELEMENT_CONTENT_ELEMENT,
00240     XML_ELEMENT_CONTENT_SEQ,
00241     XML_ELEMENT_CONTENT_OR
00242 } xmlElementContentType;
00243 
00249 typedef enum {
00250     XML_ELEMENT_CONTENT_ONCE = 1,
00251     XML_ELEMENT_CONTENT_OPT,
00252     XML_ELEMENT_CONTENT_MULT,
00253     XML_ELEMENT_CONTENT_PLUS
00254 } xmlElementContentOccur;
00255 
00263 typedef struct _xmlElementContent xmlElementContent;
00264 typedef xmlElementContent *xmlElementContentPtr;
00265 struct _xmlElementContent {
00266     xmlElementContentType     type; /* PCDATA, ELEMENT, SEQ or OR */
00267     xmlElementContentOccur    ocur; /* ONCE, OPT, MULT or PLUS */
00268     const xmlChar             *name;    /* Element name */
00269     struct _xmlElementContent *c1;  /* first child */
00270     struct _xmlElementContent *c2;  /* second child */
00271     struct _xmlElementContent *parent;  /* parent */
00272     const xmlChar             *prefix;  /* Namespace prefix */
00273 };
00274 
00281 typedef enum {
00282     XML_ELEMENT_TYPE_UNDEFINED = 0,
00283     XML_ELEMENT_TYPE_EMPTY = 1,
00284     XML_ELEMENT_TYPE_ANY,
00285     XML_ELEMENT_TYPE_MIXED,
00286     XML_ELEMENT_TYPE_ELEMENT
00287 } xmlElementTypeVal;
00288 
00289 #ifdef __cplusplus
00290 }
00291 #endif
00292 #include <libxml/xmlregexp.h>
00293 #ifdef __cplusplus
00294 extern "C" {
00295 #endif
00296 
00303 typedef struct _xmlElement xmlElement;
00304 typedef xmlElement *xmlElementPtr;
00305 struct _xmlElement {
00306     void           *_private;           /* application data */
00307     xmlElementType          type;       /* XML_ELEMENT_DECL, must be second ! */
00308     const xmlChar          *name;   /* Element name */
00309     struct _xmlNode    *children;   /* NULL */
00310     struct _xmlNode        *last;   /* NULL */
00311     struct _xmlDtd       *parent;   /* -> DTD */
00312     struct _xmlNode        *next;   /* next sibling link  */
00313     struct _xmlNode        *prev;   /* previous sibling link  */
00314     struct _xmlDoc          *doc;       /* the containing document */
00315 
00316     xmlElementTypeVal      etype;   /* The type */
00317     xmlElementContentPtr content;   /* the allowed element content */
00318     xmlAttributePtr   attributes;   /* List of the declared attributes */
00319     const xmlChar        *prefix;   /* the namespace prefix if any */
00320 #ifdef LIBXML_REGEXP_ENABLED
00321     xmlRegexpPtr       contModel;   /* the validating regexp */
00322 #else
00323     void          *contModel;
00324 #endif
00325 };
00326 
00327 
00333 #define XML_LOCAL_NAMESPACE XML_NAMESPACE_DECL
00334 typedef xmlElementType xmlNsType;
00335 
00346 typedef struct _xmlNs xmlNs;
00347 typedef xmlNs *xmlNsPtr;
00348 struct _xmlNs {
00349     struct _xmlNs  *next;   /* next Ns link for this node  */
00350     xmlNsType      type;    /* global or local */
00351     const xmlChar *href;    /* URL for the namespace */
00352     const xmlChar *prefix;  /* prefix for the namespace */
00353     void           *_private;   /* application data */
00354     struct _xmlDoc *context;        /* normally an xmlDoc */
00355 };
00356 
00363 typedef struct _xmlDtd xmlDtd;
00364 typedef xmlDtd *xmlDtdPtr;
00365 struct _xmlDtd {
00366     void           *_private;   /* application data */
00367     xmlElementType  type;       /* XML_DTD_NODE, must be second ! */
00368     const xmlChar *name;    /* Name of the DTD */
00369     struct _xmlNode *children;  /* the value of the property link */
00370     struct _xmlNode *last;  /* last child link */
00371     struct _xmlDoc  *parent;    /* child->parent link */
00372     struct _xmlNode *next;  /* next sibling link  */
00373     struct _xmlNode *prev;  /* previous sibling link  */
00374     struct _xmlDoc  *doc;   /* the containing document */
00375 
00376     /* End of common part */
00377     void          *notations;   /* Hash table for notations if any */
00378     void          *elements;    /* Hash table for elements if any */
00379     void          *attributes;  /* Hash table for attributes if any */
00380     void          *entities;    /* Hash table for entities if any */
00381     const xmlChar *ExternalID;  /* External identifier for PUBLIC DTD */
00382     const xmlChar *SystemID;    /* URI for a SYSTEM or PUBLIC DTD */
00383     void          *pentities;   /* Hash table for param entities if any */
00384 };
00385 
00391 typedef struct _xmlAttr xmlAttr;
00392 typedef xmlAttr *xmlAttrPtr;
00393 struct _xmlAttr {
00394     void           *_private;   /* application data */
00395     xmlElementType   type;      /* XML_ATTRIBUTE_NODE, must be second ! */
00396     const xmlChar   *name;      /* the name of the property */
00397     struct _xmlNode *children;  /* the value of the property */
00398     struct _xmlNode *last;  /* NULL */
00399     struct _xmlNode *parent;    /* child->parent link */
00400     struct _xmlAttr *next;  /* next sibling link  */
00401     struct _xmlAttr *prev;  /* previous sibling link  */
00402     struct _xmlDoc  *doc;   /* the containing document */
00403     xmlNs           *ns;        /* pointer to the associated namespace */
00404     xmlAttributeType atype;     /* the attribute type if validating */
00405     void            *psvi;  /* for type/PSVI informations */
00406 };
00407 
00414 typedef struct _xmlID xmlID;
00415 typedef xmlID *xmlIDPtr;
00416 struct _xmlID {
00417     struct _xmlID    *next; /* next ID */
00418     const xmlChar    *value;    /* The ID name */
00419     xmlAttrPtr        attr; /* The attribute holding it */
00420     const xmlChar    *name; /* The attribute if attr is not available */
00421     int               lineno;   /* The line number if attr is not available */
00422     struct _xmlDoc   *doc;  /* The document holding the ID */
00423 };
00424 
00431 typedef struct _xmlRef xmlRef;
00432 typedef xmlRef *xmlRefPtr;
00433 struct _xmlRef {
00434     struct _xmlRef    *next;    /* next Ref */
00435     const xmlChar     *value;   /* The Ref name */
00436     xmlAttrPtr        attr; /* The attribute holding it */
00437     const xmlChar    *name; /* The attribute if attr is not available */
00438     int               lineno;   /* The line number if attr is not available */
00439 };
00440 
00446 typedef struct _xmlNode xmlNode;
00447 typedef xmlNode *xmlNodePtr;
00448 struct _xmlNode {
00449     void           *_private;   /* application data */
00450     xmlElementType   type;  /* type number, must be second ! */
00451     const xmlChar   *name;      /* the name of the node, or the entity */
00452     struct _xmlNode *children;  /* parent->childs link */
00453     struct _xmlNode *last;  /* last child link */
00454     struct _xmlNode *parent;    /* child->parent link */
00455     struct _xmlNode *next;  /* next sibling link  */
00456     struct _xmlNode *prev;  /* previous sibling link  */
00457     struct _xmlDoc  *doc;   /* the containing document */
00458 
00459     /* End of common part */
00460     xmlNs           *ns;        /* pointer to the associated namespace */
00461     xmlChar         *content;   /* the content */
00462     struct _xmlAttr *properties;/* properties list */
00463     xmlNs           *nsDef;     /* namespace definitions on this node */
00464     void            *psvi;  /* for type/PSVI informations */
00465     unsigned short   line;  /* line number */
00466     unsigned short   extra; /* extra data for XPath/XSLT */
00467 };
00468 
00474 #define XML_GET_CONTENT(n)                  \
00475     ((n)->type == XML_ELEMENT_NODE ? NULL : (n)->content)
00476 
00482 #define XML_GET_LINE(n)                     \
00483     (xmlGetLineNo(n))
00484 
00485 
00491 typedef struct _xmlDoc xmlDoc;
00492 typedef xmlDoc *xmlDocPtr;
00493 struct _xmlDoc {
00494     void           *_private;   /* application data */
00495     xmlElementType  type;       /* XML_DOCUMENT_NODE, must be second ! */
00496     char           *name;   /* name/filename/URI of the document */
00497     struct _xmlNode *children;  /* the document tree */
00498     struct _xmlNode *last;  /* last child link */
00499     struct _xmlNode *parent;    /* child->parent link */
00500     struct _xmlNode *next;  /* next sibling link  */
00501     struct _xmlNode *prev;  /* previous sibling link  */
00502     struct _xmlDoc  *doc;   /* autoreference to itself */
00503 
00504     /* End of common part */
00505     int             compression;/* level of zlib compression */
00506     int             standalone; /* standalone document (no external refs) */
00507     struct _xmlDtd  *intSubset; /* the document internal subset */
00508     struct _xmlDtd  *extSubset; /* the document external subset */
00509     struct _xmlNs   *oldNs; /* Global namespace, the old way */
00510     const xmlChar  *version;    /* the XML version string */
00511     const xmlChar  *encoding;   /* external initial encoding, if any */
00512     void           *ids;        /* Hash table for ID attributes if any */
00513     void           *refs;       /* Hash table for IDREFs attributes if any */
00514     const xmlChar  *URL;    /* The URI for that document */
00515     int             charset;    /* encoding of the in-memory content
00516                    actually an xmlCharEncoding */
00517     struct _xmlDict *dict;      /* dict used to allocate names or NULL */
00518     void           *psvi;   /* for type/PSVI informations */
00519 };
00520 
00521 
00522 typedef struct _xmlDOMWrapCtxt xmlDOMWrapCtxt;
00523 typedef xmlDOMWrapCtxt *xmlDOMWrapCtxtPtr;
00524 
00536 typedef xmlNsPtr (*xmlDOMWrapAcquireNsFunction) (xmlDOMWrapCtxtPtr ctxt,
00537                          xmlNodePtr node,
00538                          const xmlChar *nsName,
00539                          const xmlChar *nsPrefix);
00540 
00546 struct _xmlDOMWrapCtxt {
00547     void * _private;
00548     /*
00549     * The type of this context, just in case we need specialized
00550     * contexts in the future.
00551     */
00552     int type;
00553     /*
00554     * Internal namespace map used for various operations.
00555     */
00556     void * namespaceMap;
00557     /*
00558     * Use this one to acquire an xmlNsPtr intended for node->ns.
00559     * (Note that this is not intended for elem->nsDef).
00560     */
00561     xmlDOMWrapAcquireNsFunction getNsForNodeFunc;
00562 };
00563 
00570 #ifndef xmlChildrenNode
00571 #define xmlChildrenNode children
00572 #endif
00573 
00580 #ifndef xmlRootNode
00581 #define xmlRootNode children
00582 #endif
00583 
00584 /*
00585  * Variables.
00586  */
00587 
00588 /*
00589  * Some helper functions
00590  */
00591 #if defined(LIBXML_TREE_ENABLED) || defined(LIBXML_XPATH_ENABLED) || defined(LIBXML_SCHEMAS_ENABLED) || defined(LIBXML_DEBUG_ENABLED) || defined (LIBXML_HTML_ENABLED) || defined(LIBXML_SAX1_ENABLED) || defined(LIBXML_HTML_ENABLED) || defined(LIBXML_WRITER_ENABLED) || defined(LIBXML_DOCB_ENABLED)
00592 XMLPUBFUN int XMLCALL
00593         xmlValidateNCName   (const xmlChar *value,
00594                      int space);
00595 #endif
00596 
00597 #if defined(LIBXML_TREE_ENABLED) || defined(LIBXML_SCHEMAS_ENABLED)
00598 XMLPUBFUN int XMLCALL       
00599         xmlValidateQName    (const xmlChar *value,
00600                      int space);
00601 XMLPUBFUN int XMLCALL       
00602         xmlValidateName     (const xmlChar *value,
00603                      int space);
00604 XMLPUBFUN int XMLCALL       
00605         xmlValidateNMToken  (const xmlChar *value,
00606                      int space);
00607 #endif
00608 
00609 XMLPUBFUN xmlChar * XMLCALL 
00610         xmlBuildQName       (const xmlChar *ncname,
00611                      const xmlChar *prefix,
00612                      xmlChar *memory,
00613                      int len);
00614 XMLPUBFUN xmlChar * XMLCALL 
00615         xmlSplitQName2      (const xmlChar *name,
00616                      xmlChar **prefix);
00617 XMLPUBFUN const xmlChar * XMLCALL   
00618         xmlSplitQName3      (const xmlChar *name,
00619                      int *len);
00620 
00621 /*
00622  * Handling Buffers.
00623  */
00624 
00625 XMLPUBFUN void XMLCALL      
00626         xmlSetBufferAllocationScheme(xmlBufferAllocationScheme scheme);
00627 XMLPUBFUN xmlBufferAllocationScheme XMLCALL  
00628         xmlGetBufferAllocationScheme(void);
00629 
00630 XMLPUBFUN xmlBufferPtr XMLCALL  
00631         xmlBufferCreate     (void);
00632 XMLPUBFUN xmlBufferPtr XMLCALL  
00633         xmlBufferCreateSize (size_t size);
00634 XMLPUBFUN xmlBufferPtr XMLCALL  
00635         xmlBufferCreateStatic   (void *mem,
00636                      size_t size);
00637 XMLPUBFUN int XMLCALL       
00638         xmlBufferResize     (xmlBufferPtr buf,
00639                      unsigned int size);
00640 XMLPUBFUN void XMLCALL      
00641         xmlBufferFree       (xmlBufferPtr buf);
00642 XMLPUBFUN int XMLCALL       
00643         xmlBufferDump       (FILE *file,
00644                      xmlBufferPtr buf);
00645 XMLPUBFUN int XMLCALL       
00646         xmlBufferAdd        (xmlBufferPtr buf,
00647                      const xmlChar *str,
00648                      int len);
00649 XMLPUBFUN int XMLCALL       
00650         xmlBufferAddHead    (xmlBufferPtr buf,
00651                      const xmlChar *str,
00652                      int len);
00653 XMLPUBFUN int XMLCALL       
00654         xmlBufferCat        (xmlBufferPtr buf,
00655                      const xmlChar *str);
00656 XMLPUBFUN int XMLCALL   
00657         xmlBufferCCat       (xmlBufferPtr buf,
00658                      const char *str);
00659 XMLPUBFUN int XMLCALL       
00660         xmlBufferShrink     (xmlBufferPtr buf,
00661                      unsigned int len);
00662 XMLPUBFUN int XMLCALL       
00663         xmlBufferGrow       (xmlBufferPtr buf,
00664                      unsigned int len);
00665 XMLPUBFUN void XMLCALL      
00666         xmlBufferEmpty      (xmlBufferPtr buf);
00667 XMLPUBFUN const xmlChar* XMLCALL    
00668         xmlBufferContent    (const xmlBufferPtr buf);
00669 XMLPUBFUN void XMLCALL      
00670         xmlBufferSetAllocationScheme(xmlBufferPtr buf,
00671                      xmlBufferAllocationScheme scheme);
00672 XMLPUBFUN int XMLCALL       
00673         xmlBufferLength     (const xmlBufferPtr buf);
00674 
00675 /*
00676  * Creating/freeing new structures.
00677  */
00678 XMLPUBFUN xmlDtdPtr XMLCALL 
00679         xmlCreateIntSubset  (xmlDocPtr doc,
00680                      const xmlChar *name,
00681                      const xmlChar *ExternalID,
00682                      const xmlChar *SystemID);
00683 XMLPUBFUN xmlDtdPtr XMLCALL 
00684         xmlNewDtd       (xmlDocPtr doc,
00685                      const xmlChar *name,
00686                      const xmlChar *ExternalID,
00687                      const xmlChar *SystemID);
00688 XMLPUBFUN xmlDtdPtr XMLCALL 
00689         xmlGetIntSubset     (xmlDocPtr doc);
00690 XMLPUBFUN void XMLCALL      
00691         xmlFreeDtd      (xmlDtdPtr cur);
00692 #ifdef LIBXML_LEGACY_ENABLED
00693 XMLPUBFUN xmlNsPtr XMLCALL  
00694         xmlNewGlobalNs      (xmlDocPtr doc,
00695                      const xmlChar *href,
00696                      const xmlChar *prefix);
00697 #endif /* LIBXML_LEGACY_ENABLED */
00698 XMLPUBFUN xmlNsPtr XMLCALL  
00699         xmlNewNs        (xmlNodePtr node,
00700                      const xmlChar *href,
00701                      const xmlChar *prefix);
00702 XMLPUBFUN void XMLCALL      
00703         xmlFreeNs       (xmlNsPtr cur);
00704 XMLPUBFUN void XMLCALL      
00705         xmlFreeNsList       (xmlNsPtr cur);
00706 XMLPUBFUN xmlDocPtr XMLCALL     
00707         xmlNewDoc       (const xmlChar *version);
00708 XMLPUBFUN void XMLCALL      
00709         xmlFreeDoc      (xmlDocPtr cur);
00710 XMLPUBFUN xmlAttrPtr XMLCALL    
00711         xmlNewDocProp       (xmlDocPtr doc,
00712                      const xmlChar *name,
00713                      const xmlChar *value);
00714 #if defined(LIBXML_TREE_ENABLED) || defined(LIBXML_HTML_ENABLED) || \
00715     defined(LIBXML_SCHEMAS_ENABLED)
00716 XMLPUBFUN xmlAttrPtr XMLCALL    
00717         xmlNewProp      (xmlNodePtr node,
00718                      const xmlChar *name,
00719                      const xmlChar *value);
00720 #endif
00721 XMLPUBFUN xmlAttrPtr XMLCALL    
00722         xmlNewNsProp        (xmlNodePtr node,
00723                      xmlNsPtr ns,
00724                      const xmlChar *name,
00725                      const xmlChar *value);
00726 XMLPUBFUN xmlAttrPtr XMLCALL    
00727         xmlNewNsPropEatName (xmlNodePtr node,
00728                      xmlNsPtr ns,
00729                      xmlChar *name,
00730                      const xmlChar *value);
00731 XMLPUBFUN void XMLCALL      
00732         xmlFreePropList     (xmlAttrPtr cur);
00733 XMLPUBFUN void XMLCALL      
00734         xmlFreeProp     (xmlAttrPtr cur);
00735 XMLPUBFUN xmlAttrPtr XMLCALL    
00736         xmlCopyProp     (xmlNodePtr target,
00737                      xmlAttrPtr cur);
00738 XMLPUBFUN xmlAttrPtr XMLCALL    
00739         xmlCopyPropList     (xmlNodePtr target,
00740                      xmlAttrPtr cur);
00741 #ifdef LIBXML_TREE_ENABLED
00742 XMLPUBFUN xmlDtdPtr XMLCALL 
00743         xmlCopyDtd      (xmlDtdPtr dtd);
00744 #endif /* LIBXML_TREE_ENABLED */
00745 #if defined(LIBXML_TREE_ENABLED) || defined(LIBXML_SCHEMAS_ENABLED)
00746 XMLPUBFUN xmlDocPtr XMLCALL 
00747         xmlCopyDoc      (xmlDocPtr doc,
00748                      int recursive);
00749 #endif /* defined(LIBXML_TREE_ENABLED) || defined(LIBXML_SCHEMAS_ENABLED) */
00750 /*
00751  * Creating new nodes.
00752  */
00753 XMLPUBFUN xmlNodePtr XMLCALL    
00754         xmlNewDocNode       (xmlDocPtr doc,
00755                      xmlNsPtr ns,
00756                      const xmlChar *name,
00757                      const xmlChar *content);
00758 XMLPUBFUN xmlNodePtr XMLCALL    
00759         xmlNewDocNodeEatName    (xmlDocPtr doc,
00760                      xmlNsPtr ns,
00761                      xmlChar *name,
00762                      const xmlChar *content);
00763 XMLPUBFUN xmlNodePtr XMLCALL    
00764         xmlNewNode      (xmlNsPtr ns,
00765                      const xmlChar *name);
00766 XMLPUBFUN xmlNodePtr XMLCALL    
00767         xmlNewNodeEatName   (xmlNsPtr ns,
00768                      xmlChar *name);
00769 #if defined(LIBXML_TREE_ENABLED) || defined(LIBXML_SCHEMAS_ENABLED)
00770 XMLPUBFUN xmlNodePtr XMLCALL    
00771         xmlNewChild     (xmlNodePtr parent,
00772                      xmlNsPtr ns,
00773                      const xmlChar *name,
00774                      const xmlChar *content);
00775 #endif
00776 XMLPUBFUN xmlNodePtr XMLCALL    
00777         xmlNewDocText       (xmlDocPtr doc,
00778                      const xmlChar *content);
00779 XMLPUBFUN xmlNodePtr XMLCALL    
00780         xmlNewText      (const xmlChar *content);
00781 XMLPUBFUN xmlNodePtr XMLCALL    
00782         xmlNewDocPI     (xmlDocPtr doc,
00783                      const xmlChar *name,
00784                      const xmlChar *content);
00785 XMLPUBFUN xmlNodePtr XMLCALL    
00786         xmlNewPI        (const xmlChar *name,
00787                      const xmlChar *content);
00788 XMLPUBFUN xmlNodePtr XMLCALL    
00789         xmlNewDocTextLen    (xmlDocPtr doc,
00790                      const xmlChar *content,
00791                      int len);
00792 XMLPUBFUN xmlNodePtr XMLCALL    
00793         xmlNewTextLen       (const xmlChar *content,
00794                      int len);
00795 XMLPUBFUN xmlNodePtr XMLCALL    
00796         xmlNewDocComment    (xmlDocPtr doc,
00797                      const xmlChar *content);
00798 XMLPUBFUN xmlNodePtr XMLCALL    
00799         xmlNewComment       (const xmlChar *content);
00800 XMLPUBFUN xmlNodePtr XMLCALL    
00801         xmlNewCDataBlock    (xmlDocPtr doc,
00802                      const xmlChar *content,
00803                      int len);
00804 XMLPUBFUN xmlNodePtr XMLCALL    
00805         xmlNewCharRef       (xmlDocPtr doc,
00806                      const xmlChar *name);
00807 XMLPUBFUN xmlNodePtr XMLCALL    
00808         xmlNewReference     (xmlDocPtr doc,
00809                      const xmlChar *name);
00810 XMLPUBFUN xmlNodePtr XMLCALL    
00811         xmlCopyNode     (const xmlNodePtr node,
00812                      int recursive);
00813 XMLPUBFUN xmlNodePtr XMLCALL    
00814         xmlDocCopyNode      (const xmlNodePtr node,
00815                      xmlDocPtr doc,
00816                      int recursive);
00817 XMLPUBFUN xmlNodePtr XMLCALL    
00818         xmlDocCopyNodeList  (xmlDocPtr doc,
00819                      const xmlNodePtr node);
00820 XMLPUBFUN xmlNodePtr XMLCALL    
00821         xmlCopyNodeList     (const xmlNodePtr node);
00822 #ifdef LIBXML_TREE_ENABLED
00823 XMLPUBFUN xmlNodePtr XMLCALL    
00824         xmlNewTextChild     (xmlNodePtr parent,
00825                      xmlNsPtr ns,
00826                      const xmlChar *name,
00827                      const xmlChar *content);
00828 XMLPUBFUN xmlNodePtr XMLCALL    
00829         xmlNewDocRawNode    (xmlDocPtr doc,
00830                      xmlNsPtr ns,
00831                      const xmlChar *name,
00832                      const xmlChar *content);
00833 XMLPUBFUN xmlNodePtr XMLCALL    
00834         xmlNewDocFragment   (xmlDocPtr doc);
00835 #endif /* LIBXML_TREE_ENABLED */
00836 
00837 /*
00838  * Navigating.
00839  */
00840 XMLPUBFUN long XMLCALL      
00841         xmlGetLineNo        (xmlNodePtr node);
00842 #if defined(LIBXML_TREE_ENABLED) || defined(LIBXML_DEBUG_ENABLED)
00843 XMLPUBFUN xmlChar * XMLCALL 
00844         xmlGetNodePath      (xmlNodePtr node);
00845 #endif /* defined(LIBXML_TREE_ENABLED) || defined(LIBXML_DEBUG_ENABLED) */
00846 XMLPUBFUN xmlNodePtr XMLCALL    
00847         xmlDocGetRootElement    (xmlDocPtr doc);
00848 XMLPUBFUN xmlNodePtr XMLCALL    
00849         xmlGetLastChild     (xmlNodePtr parent);
00850 XMLPUBFUN int XMLCALL       
00851         xmlNodeIsText       (xmlNodePtr node);
00852 XMLPUBFUN int XMLCALL       
00853         xmlIsBlankNode      (xmlNodePtr node);
00854 
00855 /*
00856  * Changing the structure.
00857  */
00858 #if defined(LIBXML_TREE_ENABLED) || defined(LIBXML_WRITER_ENABLED)
00859 XMLPUBFUN xmlNodePtr XMLCALL    
00860         xmlDocSetRootElement    (xmlDocPtr doc,
00861                      xmlNodePtr root);
00862 #endif /* defined(LIBXML_TREE_ENABLED) || defined(LIBXML_WRITER_ENABLED) */
00863 #ifdef LIBXML_TREE_ENABLED
00864 XMLPUBFUN void XMLCALL      
00865         xmlNodeSetName      (xmlNodePtr cur,
00866                      const xmlChar *name);
00867 #endif /* LIBXML_TREE_ENABLED */
00868 XMLPUBFUN xmlNodePtr XMLCALL    
00869         xmlAddChild     (xmlNodePtr parent,
00870                      xmlNodePtr cur);
00871 XMLPUBFUN xmlNodePtr XMLCALL    
00872         xmlAddChildList     (xmlNodePtr parent,
00873                      xmlNodePtr cur);
00874 #if defined(LIBXML_TREE_ENABLED) || defined(LIBXML_WRITER_ENABLED)
00875 XMLPUBFUN xmlNodePtr XMLCALL    
00876         xmlReplaceNode      (xmlNodePtr old,
00877                      xmlNodePtr cur);
00878 #endif /* defined(LIBXML_TREE_ENABLED) || defined(LIBXML_WRITER_ENABLED) */
00879 #if defined(LIBXML_TREE_ENABLED) || defined(LIBXML_HTML_ENABLED) || \
00880     defined(LIBXML_SCHEMAS_ENABLED)
00881 XMLPUBFUN xmlNodePtr XMLCALL    
00882         xmlAddPrevSibling   (xmlNodePtr cur,
00883                      xmlNodePtr elem);
00884 #endif /* LIBXML_TREE_ENABLED || LIBXML_HTML_ENABLED || LIBXML_SCHEMAS_ENABLED */
00885 XMLPUBFUN xmlNodePtr XMLCALL    
00886         xmlAddSibling       (xmlNodePtr cur,
00887                      xmlNodePtr elem);
00888 XMLPUBFUN xmlNodePtr XMLCALL    
00889         xmlAddNextSibling   (xmlNodePtr cur,
00890                      xmlNodePtr elem);
00891 XMLPUBFUN void XMLCALL      
00892         xmlUnlinkNode       (xmlNodePtr cur);
00893 XMLPUBFUN xmlNodePtr XMLCALL    
00894         xmlTextMerge        (xmlNodePtr first,
00895                      xmlNodePtr second);
00896 XMLPUBFUN int XMLCALL       
00897         xmlTextConcat       (xmlNodePtr node,
00898                      const xmlChar *content,
00899                      int len);
00900 XMLPUBFUN void XMLCALL      
00901         xmlFreeNodeList     (xmlNodePtr cur);
00902 XMLPUBFUN void XMLCALL      
00903         xmlFreeNode     (xmlNodePtr cur);
00904 XMLPUBFUN void XMLCALL      
00905         xmlSetTreeDoc       (xmlNodePtr tree,
00906                      xmlDocPtr doc);
00907 XMLPUBFUN void XMLCALL      
00908         xmlSetListDoc       (xmlNodePtr list,
00909                      xmlDocPtr doc);
00910 /*
00911  * Namespaces.
00912  */
00913 XMLPUBFUN xmlNsPtr XMLCALL  
00914         xmlSearchNs     (xmlDocPtr doc,
00915                      xmlNodePtr node,
00916                      const xmlChar *nameSpace);
00917 XMLPUBFUN xmlNsPtr XMLCALL  
00918         xmlSearchNsByHref   (xmlDocPtr doc,
00919                      xmlNodePtr node,
00920                      const xmlChar *href);
00921 #if defined(LIBXML_TREE_ENABLED) || defined(LIBXML_XPATH_ENABLED) || defined(LIBXML_SCHEMAS_ENABLED)
00922 XMLPUBFUN xmlNsPtr * XMLCALL    
00923         xmlGetNsList        (xmlDocPtr doc,
00924                      xmlNodePtr node);
00925 #endif /* defined(LIBXML_TREE_ENABLED) || defined(LIBXML_XPATH_ENABLED) */
00926 
00927 XMLPUBFUN void XMLCALL      
00928         xmlSetNs        (xmlNodePtr node,
00929                      xmlNsPtr ns);
00930 XMLPUBFUN xmlNsPtr XMLCALL  
00931         xmlCopyNamespace    (xmlNsPtr cur);
00932 XMLPUBFUN xmlNsPtr XMLCALL  
00933         xmlCopyNamespaceList    (xmlNsPtr cur);
00934 
00935 /*
00936  * Changing the content.
00937  */
00938 #if defined(LIBXML_TREE_ENABLED) || defined(LIBXML_XINCLUDE_ENABLED) || defined(LIBXML_SCHEMAS_ENABLED) || defined(LIBXML_HTML_ENABLED)
00939 XMLPUBFUN xmlAttrPtr XMLCALL    
00940         xmlSetProp      (xmlNodePtr node,
00941                      const xmlChar *name,
00942                      const xmlChar *value);
00943 XMLPUBFUN xmlAttrPtr XMLCALL    
00944         xmlSetNsProp        (xmlNodePtr node,
00945                      xmlNsPtr ns,
00946                      const xmlChar *name,
00947                      const xmlChar *value);
00948 #endif /* defined(LIBXML_TREE_ENABLED) || defined(LIBXML_XINCLUDE_ENABLED) || defined(LIBXML_SCHEMAS_ENABLED) || defined(LIBXML_HTML_ENABLED) */
00949 XMLPUBFUN xmlChar * XMLCALL 
00950         xmlGetNoNsProp      (xmlNodePtr node,
00951                      const xmlChar *name);
00952 XMLPUBFUN xmlChar * XMLCALL 
00953         xmlGetProp      (xmlNodePtr node,
00954                      const xmlChar *name);
00955 XMLPUBFUN xmlAttrPtr XMLCALL    
00956         xmlHasProp      (xmlNodePtr node,
00957                      const xmlChar *name);
00958 XMLPUBFUN xmlAttrPtr XMLCALL    
00959         xmlHasNsProp        (xmlNodePtr node,
00960                      const xmlChar *name,
00961                      const xmlChar *nameSpace);
00962 XMLPUBFUN xmlChar * XMLCALL 
00963         xmlGetNsProp        (xmlNodePtr node,
00964                      const xmlChar *name,
00965                      const xmlChar *nameSpace);
00966 XMLPUBFUN xmlNodePtr XMLCALL    
00967         xmlStringGetNodeList    (xmlDocPtr doc,
00968                      const xmlChar *value);
00969 XMLPUBFUN xmlNodePtr XMLCALL    
00970         xmlStringLenGetNodeList (xmlDocPtr doc,
00971                      const xmlChar *value,
00972                      int len);
00973 XMLPUBFUN xmlChar * XMLCALL 
00974         xmlNodeListGetString    (xmlDocPtr doc,
00975                      xmlNodePtr list,
00976                      int inLine);
00977 #ifdef LIBXML_TREE_ENABLED
00978 XMLPUBFUN xmlChar * XMLCALL 
00979         xmlNodeListGetRawString (xmlDocPtr doc,
00980                      xmlNodePtr list,
00981                      int inLine);
00982 #endif /* LIBXML_TREE_ENABLED */
00983 XMLPUBFUN void XMLCALL      
00984         xmlNodeSetContent   (xmlNodePtr cur,
00985                      const xmlChar *content);
00986 #ifdef LIBXML_TREE_ENABLED
00987 XMLPUBFUN void XMLCALL      
00988         xmlNodeSetContentLen    (xmlNodePtr cur,
00989                      const xmlChar *content,
00990                      int len);
00991 #endif /* LIBXML_TREE_ENABLED */
00992 XMLPUBFUN void XMLCALL      
00993         xmlNodeAddContent   (xmlNodePtr cur,
00994                      const xmlChar *content);
00995 XMLPUBFUN void XMLCALL      
00996         xmlNodeAddContentLen    (xmlNodePtr cur,
00997                      const xmlChar *content,
00998                      int len);
00999 XMLPUBFUN xmlChar * XMLCALL 
01000         xmlNodeGetContent   (xmlNodePtr cur);
01001 XMLPUBFUN int XMLCALL
01002         xmlNodeBufGetContent    (xmlBufferPtr buffer,
01003                      xmlNodePtr cur);
01004 XMLPUBFUN xmlChar * XMLCALL 
01005         xmlNodeGetLang      (xmlNodePtr cur);
01006 XMLPUBFUN int XMLCALL       
01007         xmlNodeGetSpacePreserve (xmlNodePtr cur);
01008 #ifdef LIBXML_TREE_ENABLED
01009 XMLPUBFUN void XMLCALL      
01010         xmlNodeSetLang      (xmlNodePtr cur,
01011                      const xmlChar *lang);
01012 XMLPUBFUN void XMLCALL      
01013         xmlNodeSetSpacePreserve (xmlNodePtr cur,
01014                      int val);
01015 #endif /* LIBXML_TREE_ENABLED */
01016 XMLPUBFUN xmlChar * XMLCALL 
01017         xmlNodeGetBase      (xmlDocPtr doc,
01018                      xmlNodePtr cur);
01019 #if defined(LIBXML_TREE_ENABLED) || defined(LIBXML_XINCLUDE_ENABLED)
01020 XMLPUBFUN void XMLCALL      
01021         xmlNodeSetBase      (xmlNodePtr cur,
01022                      const xmlChar *uri);
01023 #endif
01024 
01025 /*
01026  * Removing content.
01027  */
01028 XMLPUBFUN int XMLCALL       
01029         xmlRemoveProp       (xmlAttrPtr cur);
01030 #if defined(LIBXML_TREE_ENABLED) || defined(LIBXML_SCHEMAS_ENABLED)
01031 XMLPUBFUN int XMLCALL       
01032         xmlUnsetNsProp      (xmlNodePtr node,
01033                      xmlNsPtr ns,
01034                      const xmlChar *name);
01035 XMLPUBFUN int XMLCALL       
01036         xmlUnsetProp        (xmlNodePtr node,
01037                      const xmlChar *name);
01038 #endif /* defined(LIBXML_TREE_ENABLED) || defined(LIBXML_SCHEMAS_ENABLED) */
01039 
01040 /*
01041  * Internal, don't use.
01042  */
01043 XMLPUBFUN void XMLCALL      
01044         xmlBufferWriteCHAR  (xmlBufferPtr buf,
01045                      const xmlChar *string);
01046 XMLPUBFUN void XMLCALL      
01047         xmlBufferWriteChar  (xmlBufferPtr buf,
01048                      const char *string);
01049 XMLPUBFUN void XMLCALL      
01050         xmlBufferWriteQuotedString(xmlBufferPtr buf,
01051                      const xmlChar *string);
01052 
01053 #ifdef LIBXML_OUTPUT_ENABLED
01054 XMLPUBFUN void xmlAttrSerializeTxtContent(xmlBufferPtr buf,
01055                      xmlDocPtr doc,
01056                      xmlAttrPtr attr,
01057                      const xmlChar *string);
01058 #endif /* LIBXML_OUTPUT_ENABLED */
01059 
01060 #ifdef LIBXML_TREE_ENABLED
01061 /*
01062  * Namespace handling.
01063  */
01064 XMLPUBFUN int XMLCALL       
01065         xmlReconciliateNs   (xmlDocPtr doc,
01066                      xmlNodePtr tree);
01067 #endif
01068 
01069 #ifdef LIBXML_OUTPUT_ENABLED
01070 /*
01071  * Saving.
01072  */
01073 XMLPUBFUN void XMLCALL      
01074         xmlDocDumpFormatMemory  (xmlDocPtr cur,
01075                      xmlChar **mem,
01076                      int *size,
01077                      int format);
01078 XMLPUBFUN void XMLCALL      
01079         xmlDocDumpMemory    (xmlDocPtr cur,
01080                      xmlChar **mem,
01081                      int *size);
01082 XMLPUBFUN void XMLCALL      
01083         xmlDocDumpMemoryEnc (xmlDocPtr out_doc,
01084                      xmlChar **doc_txt_ptr,
01085                      int * doc_txt_len,
01086                      const char *txt_encoding);
01087 XMLPUBFUN void XMLCALL      
01088         xmlDocDumpFormatMemoryEnc(xmlDocPtr out_doc,
01089                      xmlChar **doc_txt_ptr,
01090                      int * doc_txt_len,
01091                      const char *txt_encoding,
01092                      int format);
01093 XMLPUBFUN int XMLCALL       
01094         xmlDocFormatDump    (FILE *f,
01095                      xmlDocPtr cur,
01096                      int format);
01097 XMLPUBFUN int XMLCALL   
01098         xmlDocDump      (FILE *f,
01099                      xmlDocPtr cur);
01100 XMLPUBFUN void XMLCALL      
01101         xmlElemDump     (FILE *f,
01102                      xmlDocPtr doc,
01103                      xmlNodePtr cur);
01104 XMLPUBFUN int XMLCALL       
01105         xmlSaveFile     (const char *filename,
01106                      xmlDocPtr cur);
01107 XMLPUBFUN int XMLCALL       
01108         xmlSaveFormatFile   (const char *filename,
01109                      xmlDocPtr cur,
01110                      int format);
01111 XMLPUBFUN int XMLCALL       
01112         xmlNodeDump     (xmlBufferPtr buf,
01113                      xmlDocPtr doc,
01114                      xmlNodePtr cur,
01115                      int level,
01116                      int format);
01117 
01118 XMLPUBFUN int XMLCALL       
01119         xmlSaveFileTo       (xmlOutputBufferPtr buf,
01120                      xmlDocPtr cur,
01121                      const char *encoding);
01122 XMLPUBFUN int XMLCALL             
01123         xmlSaveFormatFileTo     (xmlOutputBufferPtr buf,
01124                      xmlDocPtr cur,
01125                          const char *encoding,
01126                          int format);
01127 XMLPUBFUN void XMLCALL      
01128         xmlNodeDumpOutput   (xmlOutputBufferPtr buf,
01129                      xmlDocPtr doc,
01130                      xmlNodePtr cur,
01131                      int level,
01132                      int format,
01133                      const char *encoding);
01134 
01135 XMLPUBFUN int XMLCALL       
01136         xmlSaveFormatFileEnc    (const char *filename,
01137                      xmlDocPtr cur,
01138                      const char *encoding,
01139                      int format);
01140 
01141 XMLPUBFUN int XMLCALL       
01142         xmlSaveFileEnc      (const char *filename,
01143                      xmlDocPtr cur,
01144                      const char *encoding);
01145 
01146 #endif /* LIBXML_OUTPUT_ENABLED */
01147 /*
01148  * XHTML
01149  */
01150 XMLPUBFUN int XMLCALL       
01151         xmlIsXHTML      (const xmlChar *systemID,
01152                      const xmlChar *publicID);
01153 
01154 /*
01155  * Compression.
01156  */
01157 XMLPUBFUN int XMLCALL       
01158         xmlGetDocCompressMode   (xmlDocPtr doc);
01159 XMLPUBFUN void XMLCALL      
01160         xmlSetDocCompressMode   (xmlDocPtr doc,
01161                      int mode);
01162 XMLPUBFUN int XMLCALL       
01163         xmlGetCompressMode  (void);
01164 XMLPUBFUN void XMLCALL      
01165         xmlSetCompressMode  (int mode);
01166 
01167 /*
01168 * DOM-wrapper helper functions.
01169 */
01170 XMLPUBFUN xmlDOMWrapCtxtPtr XMLCALL
01171         xmlDOMWrapNewCtxt   (void);
01172 XMLPUBFUN void XMLCALL
01173         xmlDOMWrapFreeCtxt  (xmlDOMWrapCtxtPtr ctxt);
01174 XMLPUBFUN int XMLCALL
01175         xmlDOMWrapReconcileNamespaces(xmlDOMWrapCtxtPtr ctxt,
01176                      xmlNodePtr elem,
01177                      int options);
01178 XMLPUBFUN int XMLCALL
01179         xmlDOMWrapAdoptNode     (xmlDOMWrapCtxtPtr ctxt,
01180                      xmlDocPtr sourceDoc,
01181                      xmlNodePtr node,
01182                      xmlDocPtr destDoc,         
01183                      xmlNodePtr destParent,
01184                      int options);
01185 XMLPUBFUN int XMLCALL
01186         xmlDOMWrapRemoveNode    (xmlDOMWrapCtxtPtr ctxt,
01187                      xmlDocPtr doc,
01188                      xmlNodePtr node,
01189                      int options);
01190 XMLPUBFUN int XMLCALL
01191         xmlDOMWrapCloneNode     (xmlDOMWrapCtxtPtr ctxt,
01192                      xmlDocPtr sourceDoc,
01193                      xmlNodePtr node,
01194                      xmlNodePtr *clonedNode,
01195                      xmlDocPtr destDoc,
01196                      xmlNodePtr destParent,
01197                      int deep,
01198                      int options);
01199 
01200 #ifdef __cplusplus
01201 }
01202 #endif
01203 #ifndef __XML_PARSER_H__
01204 #include <libxml/xmlmemory.h>
01205 #endif
01206 
01207 #endif /* __XML_TREE_H__ */
01208
footer
 SourceForge.net Logo