1 /*

     2  * Summary: interfaces for tree manipulation

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

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

     5  *              various processing on that tree

     6  *

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

     8  *

     9  * Author: Daniel Veillard

    10  */

    11 

    12 #ifndef __XML_TREE_H__

    13 #define __XML_TREE_H__

    14 

    15 #include <stdio.h>

    16 #include <libxml/xmlversion.h>

    17 #include <libxml/xmlstring.h>

    18 

    19 #ifdef __cplusplus

    20 extern "C" {

    21 #endif

    22 

    23 /*

    24  * Some of the basic types pointer to structures:

    25  */

    26 /* xmlIO.h */

    27 typedef struct _xmlParserInputBuffer xmlParserInputBuffer;

    28 typedef xmlParserInputBuffer *xmlParserInputBufferPtr;

    29 

    30 typedef struct _xmlOutputBuffer xmlOutputBuffer;

    31 typedef xmlOutputBuffer *xmlOutputBufferPtr;

    32 

    33 /* parser.h */

    34 typedef struct _xmlParserInput xmlParserInput;

    35 typedef xmlParserInput *xmlParserInputPtr;

    36 

    37 typedef struct _xmlParserCtxt xmlParserCtxt;

    38 typedef xmlParserCtxt *xmlParserCtxtPtr;

    39 

    40 typedef struct _xmlSAXLocator xmlSAXLocator;

    41 typedef xmlSAXLocator *xmlSAXLocatorPtr;

    42 

    43 typedef struct _xmlSAXHandler xmlSAXHandler;

    44 typedef xmlSAXHandler *xmlSAXHandlerPtr;

    45 

    46 /* entities.h */

    47 typedef struct _xmlEntity xmlEntity;

    48 typedef xmlEntity *xmlEntityPtr;

    49 

    50 /**

    51  * BASE_BUFFER_SIZE:

    52  *

    53  * default buffer size 4000.

    54  */

    55 #define BASE_BUFFER_SIZE 4096

    56 

    57 /**

    58  * xmlBufferAllocationScheme:

    59  *

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

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

    62  */

    63 

    64 typedef enum {

    65     XML_BUFFER_ALLOC_DOUBLEIT,

    66     XML_BUFFER_ALLOC_EXACT,

    67     XML_BUFFER_ALLOC_IMMUTABLE

    68 } xmlBufferAllocationScheme;

    69 

    70 /**

    71  * xmlBuffer:

    72  *

    73  * A buffer structure.

    74  */

    75 typedef struct _xmlBuffer xmlBuffer;

    76 typedef xmlBuffer *xmlBufferPtr;

    77 struct _xmlBuffer {

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

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

    80     unsigned int size;		/* The buffer size */

    81     xmlBufferAllocationScheme alloc; /* The realloc method */

    82 };

    83 

    84 /**

    85  * XML_XML_NAMESPACE:

    86  *

    87  * This is the namespace for the special xml: prefix predefined in the

    88  * XML Namespace specification.

    89  */

    90 #define XML_XML_NAMESPACE \

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

    92 

    93 /**

    94  * XML_XML_ID:

    95  *

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

    97  */

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

    99 

   100 /*

   101  * The different element types carried by an XML tree.

   102  *

   103  * NOTE: This is synchronized with DOM Level1 values

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

   105  *

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

   107  * be deprecated to use an XML_DTD_NODE.

   108  */

   109 typedef enum {

   110     XML_ELEMENT_NODE=		1,

   111     XML_ATTRIBUTE_NODE=		2,

   112     XML_TEXT_NODE=		3,

   113     XML_CDATA_SECTION_NODE=	4,

   114     XML_ENTITY_REF_NODE=	5,

   115     XML_ENTITY_NODE=		6,

   116     XML_PI_NODE=		7,

   117     XML_COMMENT_NODE=		8,

   118     XML_DOCUMENT_NODE=		9,

   119     XML_DOCUMENT_TYPE_NODE=	10,

   120     XML_DOCUMENT_FRAG_NODE=	11,

   121     XML_NOTATION_NODE=		12,

   122     XML_HTML_DOCUMENT_NODE=	13,

   123     XML_DTD_NODE=		14,

   124     XML_ELEMENT_DECL=		15,

   125     XML_ATTRIBUTE_DECL=		16,

   126     XML_ENTITY_DECL=		17,

   127     XML_NAMESPACE_DECL=		18,

   128     XML_XINCLUDE_START=		19,

   129     XML_XINCLUDE_END=		20

   130 #ifdef LIBXML_DOCB_ENABLED

   131    ,XML_DOCB_DOCUMENT_NODE=	21

   132 #endif

   133 } xmlElementType;

   134 

   135 

   136 /**

   137  * xmlNotation:

   138  *

   139  * A DTD Notation definition.

   140  */

   141 

   142 typedef struct _xmlNotation xmlNotation;

   143 typedef xmlNotation *xmlNotationPtr;

   144 struct _xmlNotation {

   145     const xmlChar               *name;	        /* Notation name */

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

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

   148 };

   149 

   150 /**

   151  * xmlAttributeType:

   152  *

   153  * A DTD Attribute type definition.

   154  */

   155 

   156 typedef enum {

   157     XML_ATTRIBUTE_CDATA = 1,

   158     XML_ATTRIBUTE_ID,

   159     XML_ATTRIBUTE_IDREF	,

   160     XML_ATTRIBUTE_IDREFS,

   161     XML_ATTRIBUTE_ENTITY,

   162     XML_ATTRIBUTE_ENTITIES,

   163     XML_ATTRIBUTE_NMTOKEN,

   164     XML_ATTRIBUTE_NMTOKENS,

   165     XML_ATTRIBUTE_ENUMERATION,

   166     XML_ATTRIBUTE_NOTATION

   167 } xmlAttributeType;

   168 

   169 /**

   170  * xmlAttributeDefault:

   171  *

   172  * A DTD Attribute default definition.

   173  */

   174 

   175 typedef enum {

   176     XML_ATTRIBUTE_NONE = 1,

   177     XML_ATTRIBUTE_REQUIRED,

   178     XML_ATTRIBUTE_IMPLIED,

   179     XML_ATTRIBUTE_FIXED

   180 } xmlAttributeDefault;

   181 

   182 /**

   183  * xmlEnumeration:

   184  *

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

   186  */

   187 

   188 typedef struct _xmlEnumeration xmlEnumeration;

   189 typedef xmlEnumeration *xmlEnumerationPtr;

   190 struct _xmlEnumeration {

   191     struct _xmlEnumeration    *next;	/* next one */

   192     const xmlChar            *name;	/* Enumeration name */

   193 };

   194 

   195 /**

   196  * xmlAttribute:

   197  *

   198  * An Attribute declaration in a DTD.

   199  */

   200 

   201 typedef struct _xmlAttribute xmlAttribute;

   202 typedef xmlAttribute *xmlAttributePtr;

   203 struct _xmlAttribute {

   204     void           *_private;	        /* application data */

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

   206     const xmlChar          *name;	/* Attribute name */

   207     struct _xmlNode    *children;	/* NULL */

   208     struct _xmlNode        *last;	/* NULL */

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

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

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

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

   213 

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

   215     xmlAttributeType       atype;	/* The attribute type */

   216     xmlAttributeDefault      def;	/* the default */

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

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

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

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

   221 };

   222 

   223 /**

   224  * xmlElementContentType:

   225  *

   226  * Possible definitions of element content types.

   227  */

   228 typedef enum {

   229     XML_ELEMENT_CONTENT_PCDATA = 1,

   230     XML_ELEMENT_CONTENT_ELEMENT,

   231     XML_ELEMENT_CONTENT_SEQ,

   232     XML_ELEMENT_CONTENT_OR

   233 } xmlElementContentType;

   234 

   235 /**

   236  * xmlElementContentOccur:

   237  *

   238  * Possible definitions of element content occurrences.

   239  */

   240 typedef enum {

   241     XML_ELEMENT_CONTENT_ONCE = 1,

   242     XML_ELEMENT_CONTENT_OPT,

   243     XML_ELEMENT_CONTENT_MULT,

   244     XML_ELEMENT_CONTENT_PLUS

   245 } xmlElementContentOccur;

   246 

   247 /**

   248  * xmlElementContent:

   249  *

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

   251  * in a DTD.

   252  */

   253 

   254 typedef struct _xmlElementContent xmlElementContent;

   255 typedef xmlElementContent *xmlElementContentPtr;

   256 struct _xmlElementContent {

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

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

   259     const xmlChar             *name;	/* Element name */

   260     struct _xmlElementContent *c1;	/* first child */

   261     struct _xmlElementContent *c2;	/* second child */

   262     struct _xmlElementContent *parent;	/* parent */

   263     const xmlChar             *prefix;	/* Namespace prefix */

   264 };

   265 

   266 /**

   267  * xmlElementTypeVal:

   268  *

   269  * The different possibilities for an element content type.

   270  */

   271 

   272 typedef enum {

   273     XML_ELEMENT_TYPE_UNDEFINED = 0,

   274     XML_ELEMENT_TYPE_EMPTY = 1,

   275     XML_ELEMENT_TYPE_ANY,

   276     XML_ELEMENT_TYPE_MIXED,

   277     XML_ELEMENT_TYPE_ELEMENT

   278 } xmlElementTypeVal;

   279 

   280 #ifdef __cplusplus

   281 }

   282 #endif

   283 #include <libxml/xmlregexp.h>

   284 #ifdef __cplusplus

   285 extern "C" {

   286 #endif

   287 

   288 /**

   289  * xmlElement:

   290  *

   291  * An XML Element declaration from a DTD.

   292  */

   293 

   294 typedef struct _xmlElement xmlElement;

   295 typedef xmlElement *xmlElementPtr;

   296 struct _xmlElement {

   297     void           *_private;	        /* application data */

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

   299     const xmlChar          *name;	/* Element name */

   300     struct _xmlNode    *children;	/* NULL */

   301     struct _xmlNode        *last;	/* NULL */

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

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

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

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

   306 

   307     xmlElementTypeVal      etype;	/* The type */

   308     xmlElementContentPtr content;	/* the allowed element content */

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

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

   311 #ifdef LIBXML_REGEXP_ENABLED

   312     xmlRegexpPtr       contModel;	/* the validating regexp */

   313 #else

   314     void	      *contModel;

   315 #endif

   316 };

   317 

   318 

   319 /**

   320  * XML_LOCAL_NAMESPACE:

   321  *

   322  * A namespace declaration node.

   323  */

   324 #define XML_LOCAL_NAMESPACE XML_NAMESPACE_DECL

   325 typedef xmlElementType xmlNsType;

   326 

   327 /**

   328  * xmlNs:

   329  *

   330  * An XML namespace.

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

   332  * within the subtree (until overridden).

   333  *

   334  * xmlNsType is unified with xmlElementType.

   335  */

   336 

   337 typedef struct _xmlNs xmlNs;

   338 typedef xmlNs *xmlNsPtr;

   339 struct _xmlNs {

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

   341     xmlNsType      type;	/* global or local */

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

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

   344     void           *_private;   /* application data */

   345 };

   346 

   347 /**

   348  * xmlDtd:

   349  *

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

   351  * the internal subset and for the external subset.

   352  */

   353 typedef struct _xmlDtd xmlDtd;

   354 typedef xmlDtd *xmlDtdPtr;

   355 struct _xmlDtd {

   356     void           *_private;	/* application data */

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

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

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

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

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

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

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

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

   365 

   366     /* End of common part */

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

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

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

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

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

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

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

   374 };

   375 

   376 /**

   377  * xmlAttr:

   378  *

   379  * An attribute on an XML node.

   380  */

   381 typedef struct _xmlAttr xmlAttr;

   382 typedef xmlAttr *xmlAttrPtr;

   383 struct _xmlAttr {

   384     void           *_private;	/* application data */

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

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

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

   388     struct _xmlNode *last;	/* NULL */

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

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

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

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

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

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

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

   396 };

   397 

   398 /**

   399  * xmlID:

   400  *

   401  * An XML ID instance.

   402  */

   403 

   404 typedef struct _xmlID xmlID;

   405 typedef xmlID *xmlIDPtr;

   406 struct _xmlID {

   407     struct _xmlID    *next;	/* next ID */

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

   409     xmlAttrPtr        attr;	/* The attribute holding it */

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

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

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

   413 };

   414 

   415 /**

   416  * xmlRef:

   417  *

   418  * An XML IDREF instance.

   419  */

   420 

   421 typedef struct _xmlRef xmlRef;

   422 typedef xmlRef *xmlRefPtr;

   423 struct _xmlRef {

   424     struct _xmlRef    *next;	/* next Ref */

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

   426     xmlAttrPtr        attr;	/* The attribute holding it */

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

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

   429 };

   430 

   431 /**

   432  * xmlNode:

   433  *

   434  * A node in an XML tree.

   435  */

   436 typedef struct _xmlNode xmlNode;

   437 typedef xmlNode *xmlNodePtr;

   438 struct _xmlNode {

   439     void           *_private;	/* application data */

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

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

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

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

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

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

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

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

   448 

   449     /* End of common part */

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

   451     xmlChar         *content;   /* the content */

   452     struct _xmlAttr *properties;/* properties list */

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

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

   455     unsigned short   line;	/* line number */

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

   457 };

   458 

   459 /**

   460  * XML_GET_CONTENT:

   461  *

   462  * Macro to extract the content pointer of a node.

   463  */

   464 #define XML_GET_CONTENT(n)					\

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

   466 

   467 /**

   468  * XML_GET_LINE:

   469  *

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

   471  */

   472 #define XML_GET_LINE(n)						\

   473     (xmlGetLineNo(n))

   474 

   475 

   476 /**

   477  * xmlDoc:

   478  *

   479  * An XML document.

   480  */

   481 typedef struct _xmlDoc xmlDoc;

   482 typedef xmlDoc *xmlDocPtr;

   483 struct _xmlDoc {

   484     void           *_private;	/* application data */

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

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

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

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

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

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

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

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

   493 

   494     /* End of common part */

   495     int             compression;/* level of zlib compression */

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

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

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

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

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

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

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

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

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

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

   506 				   actually an xmlCharEncoding */

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

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

   509 };

   510 

   511 typedef struct _xmlDOMWrapCtxt xmlDOMWrapCtxt;

   512 typedef xmlDOMWrapCtxt *xmlDOMWrapCtxtPtr;

   513 struct _xmlDOMWrapCtxt {

   514     void * _private;

   515 };

   516 

   517 /**

   518  * xmlChildrenNode:

   519  *

   520  * Macro for compatibility naming layer with libxml1. Maps

   521  * to "children."

   522  */

   523 #ifndef xmlChildrenNode

   524 #define xmlChildrenNode children

   525 #endif

   526 

   527 /**

   528  * xmlRootNode:

   529  *

   530  * Macro for compatibility naming layer with libxml1. Maps 

   531  * to "children".

   532  */

   533 #ifndef xmlRootNode

   534 #define xmlRootNode children

   535 #endif

   536 

   537 /*

   538  * Variables.

   539  */

   540 

   541 /*

   542  * Some helper functions

   543  */

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

   545 XMLPUBFUN int XMLCALL

   546 		xmlValidateNCName	(const xmlChar *value,

   547 					 int space);

   548 #endif

   549 

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

   551 XMLPUBFUN int XMLCALL		

   552 		xmlValidateQName	(const xmlChar *value,

   553 					 int space);

   554 XMLPUBFUN int XMLCALL		

   555 		xmlValidateName		(const xmlChar *value,

   556 					 int space);

   557 XMLPUBFUN int XMLCALL		

   558 		xmlValidateNMToken	(const xmlChar *value,

   559 					 int space);

   560 #endif

   561 

   562 XMLPUBFUN xmlChar * XMLCALL	

   563 		xmlBuildQName		(const xmlChar *ncname,

   564 					 const xmlChar *prefix,

   565 					 xmlChar *memory,

   566 					 int len);

   567 XMLPUBFUN xmlChar * XMLCALL	

   568 		xmlSplitQName2		(const xmlChar *name,

   569 					 xmlChar **prefix);

   570 XMLPUBFUN const xmlChar * XMLCALL	

   571 		xmlSplitQName3		(const xmlChar *name,

   572 					 int *len);

   573 

   574 /*

   575  * Handling Buffers.

   576  */

   577 

   578 XMLPUBFUN void XMLCALL		

   579 		xmlSetBufferAllocationScheme(xmlBufferAllocationScheme scheme);

   580 XMLPUBFUN xmlBufferAllocationScheme XMLCALL	 

   581 		xmlGetBufferAllocationScheme(void);

   582 

   583 XMLPUBFUN xmlBufferPtr XMLCALL	

   584 		xmlBufferCreate		(void);

   585 XMLPUBFUN xmlBufferPtr XMLCALL	

   586 		xmlBufferCreateSize	(size_t size);

   587 XMLPUBFUN xmlBufferPtr XMLCALL	

   588 		xmlBufferCreateStatic	(void *mem,

   589 					 size_t size);

   590 XMLPUBFUN int XMLCALL		

   591 		xmlBufferResize		(xmlBufferPtr buf,

   592 					 unsigned int size);

   593 XMLPUBFUN void XMLCALL		

   594 		xmlBufferFree		(xmlBufferPtr buf);

   595 XMLPUBFUN int XMLCALL		

   596 		xmlBufferDump		(FILE *file,

   597 					 xmlBufferPtr buf);

   598 XMLPUBFUN int XMLCALL		

   599 		xmlBufferAdd		(xmlBufferPtr buf,

   600 					 const xmlChar *str,

   601 					 int len);

   602 XMLPUBFUN int XMLCALL		

   603 		xmlBufferAddHead	(xmlBufferPtr buf,

   604 					 const xmlChar *str,

   605 					 int len);

   606 XMLPUBFUN int XMLCALL		

   607 		xmlBufferCat		(xmlBufferPtr buf,

   608 					 const xmlChar *str);

   609 XMLPUBFUN int XMLCALL	

   610 		xmlBufferCCat		(xmlBufferPtr buf,

   611 					 const char *str);

   612 XMLPUBFUN int XMLCALL		

   613 		xmlBufferShrink		(xmlBufferPtr buf,

   614 					 unsigned int len);

   615 XMLPUBFUN int XMLCALL		

   616 		xmlBufferGrow		(xmlBufferPtr buf,

   617 					 unsigned int len);

   618 XMLPUBFUN void XMLCALL		

   619 		xmlBufferEmpty		(xmlBufferPtr buf);

   620 XMLPUBFUN const xmlChar* XMLCALL	

   621 		xmlBufferContent	(const xmlBufferPtr buf);

   622 XMLPUBFUN void XMLCALL		

   623 		xmlBufferSetAllocationScheme(xmlBufferPtr buf,

   624 					 xmlBufferAllocationScheme scheme);

   625 XMLPUBFUN int XMLCALL		

   626 		xmlBufferLength		(const xmlBufferPtr buf);

   627 

   628 /*

   629  * Creating/freeing new structures.

   630  */

   631 XMLPUBFUN xmlDtdPtr XMLCALL	

   632 		xmlCreateIntSubset	(xmlDocPtr doc,

   633 					 const xmlChar *name,

   634 					 const xmlChar *ExternalID,

   635 					 const xmlChar *SystemID);

   636 XMLPUBFUN xmlDtdPtr XMLCALL	

   637 		xmlNewDtd		(xmlDocPtr doc,

   638 					 const xmlChar *name,

   639 					 const xmlChar *ExternalID,

   640 					 const xmlChar *SystemID);

   641 XMLPUBFUN xmlDtdPtr XMLCALL	

   642 		xmlGetIntSubset		(xmlDocPtr doc);

   643 XMLPUBFUN void XMLCALL		

   644 		xmlFreeDtd		(xmlDtdPtr cur);

   645 #ifdef LIBXML_LEGACY_ENABLED

   646 XMLPUBFUN xmlNsPtr XMLCALL	

   647 		xmlNewGlobalNs		(xmlDocPtr doc,

   648 					 const xmlChar *href,

   649 					 const xmlChar *prefix);

   650 #endif /* LIBXML_LEGACY_ENABLED */

   651 XMLPUBFUN xmlNsPtr XMLCALL	

   652 		xmlNewNs		(xmlNodePtr node,

   653 					 const xmlChar *href,

   654 					 const xmlChar *prefix);

   655 XMLPUBFUN void XMLCALL		

   656 		xmlFreeNs		(xmlNsPtr cur);

   657 XMLPUBFUN void XMLCALL		

   658 		xmlFreeNsList		(xmlNsPtr cur);

   659 XMLPUBFUN xmlDocPtr XMLCALL 	

   660 		xmlNewDoc		(const xmlChar *version);

   661 XMLPUBFUN void XMLCALL		

   662 		xmlFreeDoc		(xmlDocPtr cur);

   663 XMLPUBFUN xmlAttrPtr XMLCALL	

   664 		xmlNewDocProp		(xmlDocPtr doc,

   665 					 const xmlChar *name,

   666 					 const xmlChar *value);

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

   668     defined(LIBXML_SCHEMAS_ENABLED)

   669 XMLPUBFUN xmlAttrPtr XMLCALL	

   670 		xmlNewProp		(xmlNodePtr node,

   671 					 const xmlChar *name,

   672 					 const xmlChar *value);

   673 #endif

   674 XMLPUBFUN xmlAttrPtr XMLCALL	

   675 		xmlNewNsProp		(xmlNodePtr node,

   676 					 xmlNsPtr ns,

   677 					 const xmlChar *name,

   678 					 const xmlChar *value);

   679 XMLPUBFUN xmlAttrPtr XMLCALL	

   680 		xmlNewNsPropEatName	(xmlNodePtr node,

   681 					 xmlNsPtr ns,

   682 					 xmlChar *name,

   683 					 const xmlChar *value);

   684 XMLPUBFUN void XMLCALL		

   685 		xmlFreePropList		(xmlAttrPtr cur);

   686 XMLPUBFUN void XMLCALL		

   687 		xmlFreeProp		(xmlAttrPtr cur);

   688 XMLPUBFUN xmlAttrPtr XMLCALL	

   689 		xmlCopyProp		(xmlNodePtr target,

   690 					 xmlAttrPtr cur);

   691 XMLPUBFUN xmlAttrPtr XMLCALL	

   692 		xmlCopyPropList		(xmlNodePtr target,

   693 					 xmlAttrPtr cur);

   694 #ifdef LIBXML_TREE_ENABLED

   695 XMLPUBFUN xmlDtdPtr XMLCALL	

   696 		xmlCopyDtd		(xmlDtdPtr dtd);

   697 #endif /* LIBXML_TREE_ENABLED */

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

   699 XMLPUBFUN xmlDocPtr XMLCALL	

   700 		xmlCopyDoc		(xmlDocPtr doc,

   701 					 int recursive);

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

   703 /*

   704  * Creating new nodes.

   705  */

   706 XMLPUBFUN xmlNodePtr XMLCALL	

   707 		xmlNewDocNode		(xmlDocPtr doc,

   708 					 xmlNsPtr ns,

   709 					 const xmlChar *name,

   710 					 const xmlChar *content);

   711 XMLPUBFUN xmlNodePtr XMLCALL	

   712 		xmlNewDocNodeEatName	(xmlDocPtr doc,

   713 					 xmlNsPtr ns,

   714 					 xmlChar *name,

   715 					 const xmlChar *content);

   716 XMLPUBFUN xmlNodePtr XMLCALL	

   717 		xmlNewNode		(xmlNsPtr ns,

   718 					 const xmlChar *name);

   719 XMLPUBFUN xmlNodePtr XMLCALL	

   720 		xmlNewNodeEatName	(xmlNsPtr ns,

   721 					 xmlChar *name);

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

   723 XMLPUBFUN xmlNodePtr XMLCALL	

   724 		xmlNewChild		(xmlNodePtr parent,

   725 					 xmlNsPtr ns,

   726 					 const xmlChar *name,

   727 					 const xmlChar *content);

   728 #endif

   729 XMLPUBFUN xmlNodePtr XMLCALL	

   730 		xmlNewDocText		(xmlDocPtr doc,

   731 					 const xmlChar *content);

   732 XMLPUBFUN xmlNodePtr XMLCALL	

   733 		xmlNewText		(const xmlChar *content);

   734 XMLPUBFUN xmlNodePtr XMLCALL	

   735 		xmlNewDocPI		(xmlDocPtr doc,

   736 					 const xmlChar *name,

   737 					 const xmlChar *content);

   738 XMLPUBFUN xmlNodePtr XMLCALL	

   739 		xmlNewPI		(const xmlChar *name,

   740 					 const xmlChar *content);

   741 XMLPUBFUN xmlNodePtr XMLCALL	

   742 		xmlNewDocTextLen	(xmlDocPtr doc,

   743 					 const xmlChar *content,

   744 					 int len);

   745 XMLPUBFUN xmlNodePtr XMLCALL	

   746 		xmlNewTextLen		(const xmlChar *content,

   747 					 int len);

   748 XMLPUBFUN xmlNodePtr XMLCALL	

   749 		xmlNewDocComment	(xmlDocPtr doc,

   750 					 const xmlChar *content);

   751 XMLPUBFUN xmlNodePtr XMLCALL	

   752 		xmlNewComment		(const xmlChar *content);

   753 XMLPUBFUN xmlNodePtr XMLCALL	

   754 		xmlNewCDataBlock	(xmlDocPtr doc,

   755 					 const xmlChar *content,

   756 					 int len);

   757 XMLPUBFUN xmlNodePtr XMLCALL	

   758 		xmlNewCharRef		(xmlDocPtr doc,

   759 					 const xmlChar *name);

   760 XMLPUBFUN xmlNodePtr XMLCALL	

   761 		xmlNewReference		(xmlDocPtr doc,

   762 					 const xmlChar *name);

   763 XMLPUBFUN xmlNodePtr XMLCALL	

   764 		xmlCopyNode		(const xmlNodePtr node,

   765 					 int recursive);

   766 XMLPUBFUN xmlNodePtr XMLCALL	

   767 		xmlDocCopyNode		(const xmlNodePtr node,

   768 					 xmlDocPtr doc,

   769 					 int recursive);

   770 XMLPUBFUN xmlNodePtr XMLCALL	

   771 		xmlDocCopyNodeList	(xmlDocPtr doc,

   772 					 const xmlNodePtr node);

   773 XMLPUBFUN xmlNodePtr XMLCALL	

   774 		xmlCopyNodeList		(const xmlNodePtr node);

   775 #ifdef LIBXML_TREE_ENABLED

   776 XMLPUBFUN xmlNodePtr XMLCALL	

   777 		xmlNewTextChild		(xmlNodePtr parent,

   778 					 xmlNsPtr ns,

   779 					 const xmlChar *name,

   780 					 const xmlChar *content);

   781 XMLPUBFUN xmlNodePtr XMLCALL	

   782 		xmlNewDocRawNode	(xmlDocPtr doc,

   783 					 xmlNsPtr ns,

   784 					 const xmlChar *name,

   785 					 const xmlChar *content);

   786 XMLPUBFUN xmlNodePtr XMLCALL	

   787 		xmlNewDocFragment	(xmlDocPtr doc);

   788 #endif /* LIBXML_TREE_ENABLED */

   789 

   790 /*

   791  * Navigating.

   792  */

   793 XMLPUBFUN long XMLCALL		

   794 		xmlGetLineNo		(xmlNodePtr node);

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

   796 XMLPUBFUN xmlChar * XMLCALL	

   797 		xmlGetNodePath		(xmlNodePtr node);

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

   799 XMLPUBFUN xmlNodePtr XMLCALL	

   800 		xmlDocGetRootElement	(xmlDocPtr doc);

   801 XMLPUBFUN xmlNodePtr XMLCALL	

   802 		xmlGetLastChild		(xmlNodePtr parent);

   803 XMLPUBFUN int XMLCALL		

   804 		xmlNodeIsText		(xmlNodePtr node);

   805 XMLPUBFUN int XMLCALL		

   806 		xmlIsBlankNode		(xmlNodePtr node);

   807 

   808 /*

   809  * Changing the structure.

   810  */

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

   812 XMLPUBFUN xmlNodePtr XMLCALL	

   813 		xmlDocSetRootElement	(xmlDocPtr doc,

   814 					 xmlNodePtr root);

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

   816 #ifdef LIBXML_TREE_ENABLED

   817 XMLPUBFUN void XMLCALL		

   818 		xmlNodeSetName		(xmlNodePtr cur,

   819 					 const xmlChar *name);

   820 #endif /* LIBXML_TREE_ENABLED */

   821 XMLPUBFUN xmlNodePtr XMLCALL	

   822 		xmlAddChild		(xmlNodePtr parent,

   823 					 xmlNodePtr cur);

   824 XMLPUBFUN xmlNodePtr XMLCALL	

   825 		xmlAddChildList		(xmlNodePtr parent,

   826 					 xmlNodePtr cur);

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

   828 XMLPUBFUN xmlNodePtr XMLCALL	

   829 		xmlReplaceNode		(xmlNodePtr old,

   830 					 xmlNodePtr cur);

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

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

   833     defined(LIBXML_SCHEMAS_ENABLED)

   834 XMLPUBFUN xmlNodePtr XMLCALL	

   835 		xmlAddPrevSibling	(xmlNodePtr cur,

   836 					 xmlNodePtr elem);

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

   838 XMLPUBFUN xmlNodePtr XMLCALL	

   839 		xmlAddSibling		(xmlNodePtr cur,

   840 					 xmlNodePtr elem);

   841 XMLPUBFUN xmlNodePtr XMLCALL	

   842 		xmlAddNextSibling	(xmlNodePtr cur,

   843 					 xmlNodePtr elem);

   844 XMLPUBFUN void XMLCALL		

   845 		xmlUnlinkNode		(xmlNodePtr cur);

   846 XMLPUBFUN xmlNodePtr XMLCALL	

   847 		xmlTextMerge		(xmlNodePtr first,

   848 					 xmlNodePtr second);

   849 XMLPUBFUN int XMLCALL		

   850 		xmlTextConcat		(xmlNodePtr node,

   851 					 const xmlChar *content,

   852 					 int len);

   853 XMLPUBFUN void XMLCALL		

   854 		xmlFreeNodeList		(xmlNodePtr cur);

   855 XMLPUBFUN void XMLCALL		

   856 		xmlFreeNode		(xmlNodePtr cur);

   857 XMLPUBFUN void XMLCALL		

   858 		xmlSetTreeDoc		(xmlNodePtr tree,

   859 					 xmlDocPtr doc);

   860 XMLPUBFUN void XMLCALL		

   861 		xmlSetListDoc		(xmlNodePtr list,

   862 					 xmlDocPtr doc);

   863 /*

   864  * Namespaces.

   865  */

   866 XMLPUBFUN xmlNsPtr XMLCALL	

   867 		xmlSearchNs		(xmlDocPtr doc,

   868 					 xmlNodePtr node,

   869 					 const xmlChar *nameSpace);

   870 XMLPUBFUN xmlNsPtr XMLCALL	

   871 		xmlSearchNsByHref	(xmlDocPtr doc,

   872 					 xmlNodePtr node,

   873 					 const xmlChar *href);

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

   875 XMLPUBFUN xmlNsPtr * XMLCALL	

   876 		xmlGetNsList		(xmlDocPtr doc,

   877 					 xmlNodePtr node);

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

   879 

   880 XMLPUBFUN void XMLCALL		

   881 		xmlSetNs		(xmlNodePtr node,

   882 					 xmlNsPtr ns);

   883 XMLPUBFUN xmlNsPtr XMLCALL	

   884 		xmlCopyNamespace	(xmlNsPtr cur);

   885 XMLPUBFUN xmlNsPtr XMLCALL	

   886 		xmlCopyNamespaceList	(xmlNsPtr cur);

   887 

   888 /*

   889  * Changing the content.

   890  */

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

   892 XMLPUBFUN xmlAttrPtr XMLCALL	

   893 		xmlSetProp		(xmlNodePtr node,

   894 					 const xmlChar *name,

   895 					 const xmlChar *value);

   896 XMLPUBFUN xmlAttrPtr XMLCALL	

   897 		xmlSetNsProp		(xmlNodePtr node,

   898 					 xmlNsPtr ns,

   899 					 const xmlChar *name,

   900 					 const xmlChar *value);

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

   902 XMLPUBFUN xmlChar * XMLCALL	

   903 		xmlGetNoNsProp		(xmlNodePtr node,

   904 					 const xmlChar *name);

   905 XMLPUBFUN xmlChar * XMLCALL	

   906 		xmlGetProp		(xmlNodePtr node,

   907 					 const xmlChar *name);

   908 XMLPUBFUN xmlAttrPtr XMLCALL	

   909 		xmlHasProp		(xmlNodePtr node,

   910 					 const xmlChar *name);

   911 XMLPUBFUN xmlAttrPtr XMLCALL	

   912 		xmlHasNsProp		(xmlNodePtr node,

   913 					 const xmlChar *name,

   914 					 const xmlChar *nameSpace);

   915 XMLPUBFUN xmlChar * XMLCALL	

   916 		xmlGetNsProp		(xmlNodePtr node,

   917 					 const xmlChar *name,

   918 					 const xmlChar *nameSpace);

   919 XMLPUBFUN xmlNodePtr XMLCALL	

   920 		xmlStringGetNodeList	(xmlDocPtr doc,

   921 					 const xmlChar *value);

   922 XMLPUBFUN xmlNodePtr XMLCALL	

   923 		xmlStringLenGetNodeList	(xmlDocPtr doc,

   924 					 const xmlChar *value,

   925 					 int len);

   926 XMLPUBFUN xmlChar * XMLCALL	

   927 		xmlNodeListGetString	(xmlDocPtr doc,

   928 					 xmlNodePtr list,

   929 					 int inLine);

   930 #ifdef LIBXML_TREE_ENABLED

   931 XMLPUBFUN xmlChar * XMLCALL	

   932 		xmlNodeListGetRawString	(xmlDocPtr doc,

   933 					 xmlNodePtr list,

   934 					 int inLine);

   935 #endif /* LIBXML_TREE_ENABLED */

   936 XMLPUBFUN void XMLCALL		

   937 		xmlNodeSetContent	(xmlNodePtr cur,

   938 					 const xmlChar *content);

   939 #ifdef LIBXML_TREE_ENABLED

   940 XMLPUBFUN void XMLCALL		

   941 		xmlNodeSetContentLen	(xmlNodePtr cur,

   942 					 const xmlChar *content,

   943 					 int len);

   944 #endif /* LIBXML_TREE_ENABLED */

   945 XMLPUBFUN void XMLCALL		

   946 		xmlNodeAddContent	(xmlNodePtr cur,

   947 					 const xmlChar *content);

   948 XMLPUBFUN void XMLCALL		

   949 		xmlNodeAddContentLen	(xmlNodePtr cur,

   950 					 const xmlChar *content,

   951 					 int len);

   952 XMLPUBFUN xmlChar * XMLCALL	

   953 		xmlNodeGetContent	(xmlNodePtr cur);

   954 XMLPUBFUN int XMLCALL

   955 		xmlNodeBufGetContent	(xmlBufferPtr buffer,

   956 					 xmlNodePtr cur);

   957 XMLPUBFUN xmlChar * XMLCALL	

   958 		xmlNodeGetLang		(xmlNodePtr cur);

   959 XMLPUBFUN int XMLCALL		

   960 		xmlNodeGetSpacePreserve	(xmlNodePtr cur);

   961 #ifdef LIBXML_TREE_ENABLED

   962 XMLPUBFUN void XMLCALL		

   963 		xmlNodeSetLang		(xmlNodePtr cur,

   964 					 const xmlChar *lang);

   965 XMLPUBFUN void XMLCALL		

   966 		xmlNodeSetSpacePreserve (xmlNodePtr cur,

   967 					 int val);

   968 #endif /* LIBXML_TREE_ENABLED */

   969 XMLPUBFUN xmlChar * XMLCALL	

   970 		xmlNodeGetBase		(xmlDocPtr doc,

   971 					 xmlNodePtr cur);

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

   973 XMLPUBFUN void XMLCALL		

   974 		xmlNodeSetBase		(xmlNodePtr cur,

   975 					 const xmlChar *uri);

   976 #endif

   977 

   978 /*

   979  * Removing content.

   980  */

   981 #ifdef LIBXML_TREE_ENABLED

   982 XMLPUBFUN int XMLCALL		

   983 		xmlRemoveProp		(xmlAttrPtr cur);

   984 #endif /* LIBXML_TREE_ENABLED */

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

   986 XMLPUBFUN int XMLCALL		

   987 		xmlUnsetNsProp		(xmlNodePtr node,

   988 					 xmlNsPtr ns,

   989 					 const xmlChar *name);

   990 XMLPUBFUN int XMLCALL		

   991 		xmlUnsetProp		(xmlNodePtr node,

   992 					 const xmlChar *name);

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

   994 

   995 /*

   996  * Internal, don't use.

   997  */

   998 XMLPUBFUN void XMLCALL		

   999 		xmlBufferWriteCHAR	(xmlBufferPtr buf,

  1000 					 const xmlChar *string);

  1001 XMLPUBFUN void XMLCALL		

  1002 		xmlBufferWriteChar	(xmlBufferPtr buf,

  1003 					 const char *string);

  1004 XMLPUBFUN void XMLCALL		

  1005 		xmlBufferWriteQuotedString(xmlBufferPtr buf,

  1006 					 const xmlChar *string);

  1007 

  1008 #ifdef LIBXML_OUTPUT_ENABLED

  1009 XMLPUBFUN void xmlAttrSerializeTxtContent(xmlBufferPtr buf,

  1010 					 xmlDocPtr doc,

  1011 					 xmlAttrPtr attr,

  1012 					 const xmlChar *string);

  1013 #endif /* LIBXML_OUTPUT_ENABLED */

  1014 

  1015 #ifdef LIBXML_TREE_ENABLED

  1016 /*

  1017  * Namespace handling.

  1018  */

  1019 XMLPUBFUN int XMLCALL		

  1020 		xmlReconciliateNs	(xmlDocPtr doc,

  1021 					 xmlNodePtr tree);

  1022 #endif

  1023 

  1024 #ifdef LIBXML_OUTPUT_ENABLED

  1025 /*

  1026  * Saving.

  1027  */

  1028 XMLPUBFUN void XMLCALL		

  1029 		xmlDocDumpFormatMemory	(xmlDocPtr cur,

  1030 					 xmlChar **mem,

  1031 					 int *size,

  1032 					 int format);

  1033 XMLPUBFUN void XMLCALL		

  1034 		xmlDocDumpMemory	(xmlDocPtr cur,

  1035 					 xmlChar **mem,

  1036 					 int *size);

  1037 XMLPUBFUN void XMLCALL		

  1038 		xmlDocDumpMemoryEnc	(xmlDocPtr out_doc,

  1039 					 xmlChar **doc_txt_ptr,

  1040 					 int * doc_txt_len,

  1041 					 const char *txt_encoding);

  1042 XMLPUBFUN void XMLCALL		

  1043 		xmlDocDumpFormatMemoryEnc(xmlDocPtr out_doc,

  1044 					 xmlChar **doc_txt_ptr,

  1045 					 int * doc_txt_len,

  1046 					 const char *txt_encoding,

  1047 					 int format);

  1048 XMLPUBFUN int XMLCALL		

  1049 		xmlDocFormatDump	(FILE *f,

  1050 					 xmlDocPtr cur,

  1051 					 int format);

  1052 XMLPUBFUN int XMLCALL	

  1053 		xmlDocDump		(FILE *f,

  1054 					 xmlDocPtr cur);

  1055 XMLPUBFUN void XMLCALL		

  1056 		xmlElemDump		(FILE *f,

  1057 					 xmlDocPtr doc,

  1058 					 xmlNodePtr cur);

  1059 XMLPUBFUN int XMLCALL		

  1060 		xmlSaveFile		(const char *filename,

  1061 					 xmlDocPtr cur);

  1062 XMLPUBFUN int XMLCALL		

  1063 		xmlSaveFormatFile	(const char *filename,

  1064 					 xmlDocPtr cur,

  1065 					 int format);

  1066 XMLPUBFUN int XMLCALL		

  1067 		xmlNodeDump		(xmlBufferPtr buf,

  1068 					 xmlDocPtr doc,

  1069 					 xmlNodePtr cur,

  1070 					 int level,

  1071 					 int format);

  1072 

  1073 XMLPUBFUN int XMLCALL		

  1074 		xmlSaveFileTo		(xmlOutputBufferPtr buf,

  1075 					 xmlDocPtr cur,

  1076 					 const char *encoding);

  1077 XMLPUBFUN int XMLCALL             

  1078 		xmlSaveFormatFileTo     (xmlOutputBufferPtr buf,

  1079 					 xmlDocPtr cur,

  1080 				         const char *encoding,

  1081 				         int format);

  1082 XMLPUBFUN void XMLCALL		

  1083 		xmlNodeDumpOutput	(xmlOutputBufferPtr buf,

  1084 					 xmlDocPtr doc,

  1085 					 xmlNodePtr cur,

  1086 					 int level,

  1087 					 int format,

  1088 					 const char *encoding);

  1089 

  1090 XMLPUBFUN int XMLCALL		

  1091 		xmlSaveFormatFileEnc    (const char *filename,

  1092 					 xmlDocPtr cur,

  1093 					 const char *encoding,

  1094 					 int format);

  1095 

  1096 XMLPUBFUN int XMLCALL		

  1097 		xmlSaveFileEnc		(const char *filename,

  1098 					 xmlDocPtr cur,

  1099 					 const char *encoding);

  1100 

  1101 #endif /* LIBXML_OUTPUT_ENABLED */

  1102 /*

  1103  * XHTML

  1104  */

  1105 XMLPUBFUN int XMLCALL		

  1106 		xmlIsXHTML		(const xmlChar *systemID,

  1107 					 const xmlChar *publicID);

  1108 

  1109 /*

  1110  * Compression.

  1111  */

  1112 XMLPUBFUN int XMLCALL		

  1113 		xmlGetDocCompressMode	(xmlDocPtr doc);

  1114 XMLPUBFUN void XMLCALL		

  1115 		xmlSetDocCompressMode	(xmlDocPtr doc,

  1116 					 int mode);

  1117 XMLPUBFUN int XMLCALL		

  1118 		xmlGetCompressMode	(void);

  1119 XMLPUBFUN void XMLCALL		

  1120 		xmlSetCompressMode	(int mode);

  1121 

  1122 /*

  1123 * DOM-wrapper helper functions.

  1124 */

  1125 XMLPUBFUN xmlDOMWrapCtxtPtr XMLCALL

  1126 		xmlDOMWrapNewCtxt	(void);

  1127 XMLPUBFUN void XMLCALL

  1128 		xmlDOMWrapFreeCtxt	(xmlDOMWrapCtxtPtr ctxt);

  1129 XMLPUBFUN int XMLCALL

  1130 	    xmlDOMWrapReconcileNamespaces(xmlDOMWrapCtxtPtr ctxt,

  1131 					 xmlNodePtr elem,

  1132 					 int options);

  1133 XMLPUBFUN int XMLCALL

  1134 	    xmlDOMWrapAdoptNode		(xmlDOMWrapCtxtPtr ctxt,

  1135 					 xmlDocPtr sourceDoc,