tree.h revision 5821806d5e7f356e8fa4b058a389a808ea183019 
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
20extern "C" {
21#endif
22
23/*
24 * Some of the basic types pointer to structures:
25 */
26/* xmlIO.h */
27typedef struct _xmlParserInputBuffer xmlParserInputBuffer;
28typedef xmlParserInputBuffer *xmlParserInputBufferPtr;
29
30typedef struct _xmlOutputBuffer xmlOutputBuffer;
31typedef xmlOutputBuffer *xmlOutputBufferPtr;
32
33/* parser.h */
34typedef struct _xmlParserInput xmlParserInput;
35typedef xmlParserInput *xmlParserInputPtr;
36
37typedef struct _xmlParserCtxt xmlParserCtxt;
38typedef xmlParserCtxt *xmlParserCtxtPtr;
39
40typedef struct _xmlSAXLocator xmlSAXLocator;
41typedef xmlSAXLocator *xmlSAXLocatorPtr;
42
43typedef struct _xmlSAXHandler xmlSAXHandler;
44typedef xmlSAXHandler *xmlSAXHandlerPtr;
45
46/* entities.h */
47typedef struct _xmlEntity xmlEntity;
48typedef xmlEntity *xmlEntityPtr;
49
50/**
51 * BASE_BUFFER_SIZE:
52 *
53 * default buffer size 4000.
54 */
55#define BASE_BUFFER_SIZE 4096
56
57/**
58 * LIBXML_NAMESPACE_DICT:
59 *
60 * Defines experimental behaviour:
61 * 1) xmlNs gets an additional field @context (a xmlDoc)
62 * 2) when creating a tree, xmlNs->href is stored in the dict of xmlDoc.
63 */
64/* #define LIBXML_NAMESPACE_DICT */
65
66/**
67 * xmlBufferAllocationScheme:
68 *
69 * A buffer allocation scheme can be defined to either match exactly the
70 * need or double it's allocated size each time it is found too small.
71 */
72
73typedef enum {
74    XML_BUFFER_ALLOC_DOUBLEIT,	/* double each time one need to grow */
75    XML_BUFFER_ALLOC_EXACT,	/* grow only to the minimal size */
76    XML_BUFFER_ALLOC_IMMUTABLE, /* immutable buffer */
77    XML_BUFFER_ALLOC_IO		/* special allocation scheme used for I/O */
78} xmlBufferAllocationScheme;
79
80/**
81 * xmlBuffer:
82 *
83 * A buffer structure.
84 */
85typedef struct _xmlBuffer xmlBuffer;
86typedef xmlBuffer *xmlBufferPtr;
87struct _xmlBuffer {
88    xmlChar *content;		/* The buffer content UTF8 */
89    unsigned int use;		/* The buffer size used */
90    unsigned int size;		/* The buffer size */
91    xmlBufferAllocationScheme alloc; /* The realloc method */
92    xmlChar *contentIO;		/* in IO mode we may have a different base */
93};
94
95/**
96 * XML_XML_NAMESPACE:
97 *
98 * This is the namespace for the special xml: prefix predefined in the
99 * XML Namespace specification.
100 */
101#define XML_XML_NAMESPACE \
102    (const xmlChar *) "http://www.w3.org/XML/1998/namespace"
103
104/**
105 * XML_XML_ID:
106 *
107 * This is the name for the special xml:id attribute
108 */
109#define XML_XML_ID (const xmlChar *) "xml:id"
110
111/*
112 * The different element types carried by an XML tree.
113 *
114 * NOTE: This is synchronized with DOM Level1 values
115 *       See http://www.w3.org/TR/REC-DOM-Level-1/
116 *
117 * Actually this had diverged a bit, and now XML_DOCUMENT_TYPE_NODE should
118 * be deprecated to use an XML_DTD_NODE.
119 */
120typedef enum {
121    XML_ELEMENT_NODE=		1,
122    XML_ATTRIBUTE_NODE=		2,
123    XML_TEXT_NODE=		3,
124    XML_CDATA_SECTION_NODE=	4,
125    XML_ENTITY_REF_NODE=	5,
126    XML_ENTITY_NODE=		6,
127    XML_PI_NODE=		7,
128    XML_COMMENT_NODE=		8,
129    XML_DOCUMENT_NODE=		9,
130    XML_DOCUMENT_TYPE_NODE=	10,
131    XML_DOCUMENT_FRAG_NODE=	11,
132    XML_NOTATION_NODE=		12,
133    XML_HTML_DOCUMENT_NODE=	13,
134    XML_DTD_NODE=		14,
135    XML_ELEMENT_DECL=		15,
136    XML_ATTRIBUTE_DECL=		16,
137    XML_ENTITY_DECL=		17,
138    XML_NAMESPACE_DECL=		18,
139    XML_XINCLUDE_START=		19,
140    XML_XINCLUDE_END=		20
141#ifdef LIBXML_DOCB_ENABLED
142   ,XML_DOCB_DOCUMENT_NODE=	21
143#endif
144} xmlElementType;
145
146
147/**
148 * xmlNotation:
149 *
150 * A DTD Notation definition.
151 */
152
153typedef struct _xmlNotation xmlNotation;
154typedef xmlNotation *xmlNotationPtr;
155struct _xmlNotation {
156    const xmlChar               *name;	        /* Notation name */
157    const xmlChar               *PublicID;	/* Public identifier, if any */
158    const xmlChar               *SystemID;	/* System identifier, if any */
159};
160
161/**
162 * xmlAttributeType:
163 *
164 * A DTD Attribute type definition.
165 */
166
167typedef enum {
168    XML_ATTRIBUTE_CDATA = 1,
169    XML_ATTRIBUTE_ID,
170    XML_ATTRIBUTE_IDREF	,
171    XML_ATTRIBUTE_IDREFS,
172    XML_ATTRIBUTE_ENTITY,
173    XML_ATTRIBUTE_ENTITIES,
174    XML_ATTRIBUTE_NMTOKEN,
175    XML_ATTRIBUTE_NMTOKENS,
176    XML_ATTRIBUTE_ENUMERATION,
177    XML_ATTRIBUTE_NOTATION
178} xmlAttributeType;
179
180/**
181 * xmlAttributeDefault:
182 *
183 * A DTD Attribute default definition.
184 */
185
186typedef enum {
187    XML_ATTRIBUTE_NONE = 1,
188    XML_ATTRIBUTE_REQUIRED,
189    XML_ATTRIBUTE_IMPLIED,
190    XML_ATTRIBUTE_FIXED
191} xmlAttributeDefault;
192
193/**
194 * xmlEnumeration:
195 *
196 * List structure used when there is an enumeration in DTDs.
197 */
198
199typedef struct _xmlEnumeration xmlEnumeration;
200typedef xmlEnumeration *xmlEnumerationPtr;
201struct _xmlEnumeration {
202    struct _xmlEnumeration    *next;	/* next one */
203    const xmlChar            *name;	/* Enumeration name */
204};
205
206/**
207 * xmlAttribute:
208 *
209 * An Attribute declaration in a DTD.
210 */
211
212typedef struct _xmlAttribute xmlAttribute;
213typedef xmlAttribute *xmlAttributePtr;
214struct _xmlAttribute {
215    void           *_private;	        /* application data */
216    xmlElementType          type;       /* XML_ATTRIBUTE_DECL, must be second ! */
217    const xmlChar          *name;	/* Attribute name */
218    struct _xmlNode    *children;	/* NULL */
219    struct _xmlNode        *last;	/* NULL */
220    struct _xmlDtd       *parent;	/* -> DTD */
221    struct _xmlNode        *next;	/* next sibling link  */
222    struct _xmlNode        *prev;	/* previous sibling link  */
223    struct _xmlDoc          *doc;       /* the containing document */
224
225    struct _xmlAttribute  *nexth;	/* next in hash table */
226    xmlAttributeType       atype;	/* The attribute type */
227    xmlAttributeDefault      def;	/* the default */
228    const xmlChar  *defaultValue;	/* or the default value */
229    xmlEnumerationPtr       tree;       /* or the enumeration tree if any */
230    const xmlChar        *prefix;	/* the namespace prefix if any */
231    const xmlChar          *elem;	/* Element holding the attribute */
232};
233
234/**
235 * xmlElementContentType:
236 *
237 * Possible definitions of element content types.
238 */
239typedef enum {
240    XML_ELEMENT_CONTENT_PCDATA = 1,
241    XML_ELEMENT_CONTENT_ELEMENT,
242    XML_ELEMENT_CONTENT_SEQ,
243    XML_ELEMENT_CONTENT_OR
244} xmlElementContentType;
245
246/**
247 * xmlElementContentOccur:
248 *
249 * Possible definitions of element content occurrences.
250 */
251typedef enum {
252    XML_ELEMENT_CONTENT_ONCE = 1,
253    XML_ELEMENT_CONTENT_OPT,
254    XML_ELEMENT_CONTENT_MULT,
255    XML_ELEMENT_CONTENT_PLUS
256} xmlElementContentOccur;
257
258/**
259 * xmlElementContent:
260 *
261 * An XML Element content as stored after parsing an element definition
262 * in a DTD.
263 */
264
265typedef struct _xmlElementContent xmlElementContent;
266typedef xmlElementContent *xmlElementContentPtr;
267struct _xmlElementContent {
268    xmlElementContentType     type;	/* PCDATA, ELEMENT, SEQ or OR */
269    xmlElementContentOccur    ocur;	/* ONCE, OPT, MULT or PLUS */
270    const xmlChar             *name;	/* Element name */
271    struct _xmlElementContent *c1;	/* first child */
272    struct _xmlElementContent *c2;	/* second child */
273    struct _xmlElementContent *parent;	/* parent */
274    const xmlChar             *prefix;	/* Namespace prefix */
275};
276
277/**
278 * xmlElementTypeVal:
279 *
280 * The different possibilities for an element content type.
281 */
282
283typedef enum {
284    XML_ELEMENT_TYPE_UNDEFINED = 0,
285    XML_ELEMENT_TYPE_EMPTY = 1,
286    XML_ELEMENT_TYPE_ANY,
287    XML_ELEMENT_TYPE_MIXED,
288    XML_ELEMENT_TYPE_ELEMENT
289} xmlElementTypeVal;
290
291#ifdef __cplusplus
292}
293#endif
294#include <libxml/xmlregexp.h>
295#ifdef __cplusplus
296extern "C" {
297#endif
298
299/**
300 * xmlElement:
301 *
302 * An XML Element declaration from a DTD.
303 */
304
305typedef struct _xmlElement xmlElement;
306typedef xmlElement *xmlElementPtr;
307struct _xmlElement {
308    void           *_private;	        /* application data */
309    xmlElementType          type;       /* XML_ELEMENT_DECL, must be second ! */
310    const xmlChar          *name;	/* Element name */
311    struct _xmlNode    *children;	/* NULL */
312    struct _xmlNode        *last;	/* NULL */
313    struct _xmlDtd       *parent;	/* -> DTD */
314    struct _xmlNode        *next;	/* next sibling link  */
315    struct _xmlNode        *prev;	/* previous sibling link  */
316    struct _xmlDoc          *doc;       /* the containing document */
317
318    xmlElementTypeVal      etype;	/* The type */
319    xmlElementContentPtr content;	/* the allowed element content */
320    xmlAttributePtr   attributes;	/* List of the declared attributes */
321    const xmlChar        *prefix;	/* the namespace prefix if any */
322#ifdef LIBXML_REGEXP_ENABLED
323    xmlRegexpPtr       contModel;	/* the validating regexp */
324#else
325    void	      *contModel;
326#endif
327};
328
329
330/**
331 * XML_LOCAL_NAMESPACE:
332 *
333 * A namespace declaration node.
334 */
335#define XML_LOCAL_NAMESPACE XML_NAMESPACE_DECL
336typedef xmlElementType xmlNsType;
337
338/**
339 * xmlNs:
340 *
341 * An XML namespace.
342 * Note that prefix == NULL is valid, it defines the default namespace
343 * within the subtree (until overridden).
344 *
345 * xmlNsType is unified with xmlElementType.
346 */
347
348typedef struct _xmlNs xmlNs;
349typedef xmlNs *xmlNsPtr;
350struct _xmlNs {
351    struct _xmlNs  *next;	/* next Ns link for this node  */
352    xmlNsType      type;	/* global or local */
353    const xmlChar *href;	/* URL for the namespace */
354    const char* dummy_children; /* lines up with node->children */
355    const xmlChar *prefix;	/* prefix for the namespace */
356    void           *_private;   /* application data */
357    struct _xmlDoc *context;		/* normally an xmlDoc */
358};
359
360/**
361 * xmlDtd:
362 *
363 * An XML DTD, as defined by <!DOCTYPE ... There is actually one for
364 * the internal subset and for the external subset.
365 */
366typedef struct _xmlDtd xmlDtd;
367typedef xmlDtd *xmlDtdPtr;
368struct _xmlDtd {
369    void           *_private;	/* application data */
370    xmlElementType  type;       /* XML_DTD_NODE, must be second ! */
371    const xmlChar *name;	/* Name of the DTD */
372    struct _xmlNode *children;	/* the value of the property link */
373    struct _xmlNode *last;	/* last child link */
374    struct _xmlDoc  *parent;	/* child->parent link */
375    struct _xmlNode *next;	/* next sibling link  */
376    struct _xmlNode *prev;	/* previous sibling link  */
377    struct _xmlDoc  *doc;	/* the containing document */
378
379    /* End of common part */
380    void          *notations;   /* Hash table for notations if any */
381    void          *elements;    /* Hash table for elements if any */
382    void          *attributes;  /* Hash table for attributes if any */
383    void          *entities;    /* Hash table for entities if any */
384    const xmlChar *ExternalID;	/* External identifier for PUBLIC DTD */
385    const xmlChar *SystemID;	/* URI for a SYSTEM or PUBLIC DTD */
386    void          *pentities;   /* Hash table for param entities if any */
387};
388
389/**
390 * xmlAttr:
391 *
392 * An attribute on an XML node.
393 */
394typedef struct _xmlAttr xmlAttr;
395typedef xmlAttr *xmlAttrPtr;
396struct _xmlAttr {
397    void           *_private;	/* application data */
398    xmlElementType   type;      /* XML_ATTRIBUTE_NODE, must be second ! */
399    const xmlChar   *name;      /* the name of the property */
400    struct _xmlNode *children;	/* the value of the property */
401    struct _xmlNode *last;	/* NULL */
402    struct _xmlNode *parent;	/* child->parent link */
403    struct _xmlAttr *next;	/* next sibling link  */
404    struct _xmlAttr *prev;	/* previous sibling link  */
405    struct _xmlDoc  *doc;	/* the containing document */
406    xmlNs           *ns;        /* pointer to the associated namespace */
407    xmlAttributeType atype;     /* the attribute type if validating */
408    void            *psvi;	/* for type/PSVI informations */
409};
410
411/**
412 * xmlID:
413 *
414 * An XML ID instance.
415 */
416
417typedef struct _xmlID xmlID;
418typedef xmlID *xmlIDPtr;
419struct _xmlID {
420    struct _xmlID    *next;	/* next ID */
421    const xmlChar    *value;	/* The ID name */
422    xmlAttrPtr        attr;	/* The attribute holding it */
423    const xmlChar    *name;	/* The attribute if attr is not available */
424    int               lineno;	/* The line number if attr is not available */
425    struct _xmlDoc   *doc;	/* The document holding the ID */
426};
427
428/**
429 * xmlRef:
430 *
431 * An XML IDREF instance.
432 */
433
434typedef struct _xmlRef xmlRef;
435typedef xmlRef *xmlRefPtr;
436struct _xmlRef {
437    struct _xmlRef    *next;	/* next Ref */
438    const xmlChar     *value;	/* The Ref name */
439    xmlAttrPtr        attr;	/* The attribute holding it */
440    const xmlChar    *name;	/* The attribute if attr is not available */
441    int               lineno;	/* The line number if attr is not available */
442};
443
444/**
445 * xmlNode:
446 *
447 * A node in an XML tree.
448 */
449typedef struct _xmlNode xmlNode;
450typedef xmlNode *xmlNodePtr;
451struct _xmlNode {
452    void           *_private;	/* application data */
453    xmlElementType   type;	/* type number, must be second ! */
454    const xmlChar   *name;      /* the name of the node, or the entity */
455    struct _xmlNode *children;	/* parent->childs link */
456    struct _xmlNode *last;	/* last child link */
457    struct _xmlNode *parent;	/* child->parent link */
458    struct _xmlNode *next;	/* next sibling link  */
459    struct _xmlNode *prev;	/* previous sibling link  */
460    struct _xmlDoc  *doc;	/* the containing document */
461
462    /* End of common part */
463    xmlNs           *ns;        /* pointer to the associated namespace */
464    xmlChar         *content;   /* the content */
465    struct _xmlAttr *properties;/* properties list */
466    xmlNs           *nsDef;     /* namespace definitions on this node */
467    void            *psvi;	/* for type/PSVI informations */
468    unsigned short   line;	/* line number */
469    unsigned short   extra;	/* extra data for XPath/XSLT */
470};
471
472/**
473 * XML_GET_CONTENT:
474 *
475 * Macro to extract the content pointer of a node.
476 */
477#define XML_GET_CONTENT(n)					\
478    ((n)->type == XML_ELEMENT_NODE ? NULL : (n)->content)
479
480/**
481 * XML_GET_LINE:
482 *
483 * Macro to extract the line number of an element node.
484 */
485#define XML_GET_LINE(n)						\
486    (xmlGetLineNo(n))
487
488/**
489 * xmlDocProperty
490 *
491 * Set of properties of the document as found by the parser
492 * Some of them are linked to similary named xmlParserOption
493 */
494typedef enum {
495    XML_DOC_WELLFORMED		= 1<<0, /* document is XML well formed */
496    XML_DOC_NSVALID		= 1<<1, /* document is Namespace valid */
497    XML_DOC_OLD10		= 1<<2, /* parsed with old XML-1.0 parser */
498    XML_DOC_DTDVALID		= 1<<3, /* DTD validation was successful */
499    XML_DOC_XINCLUDE		= 1<<4, /* XInclude substitution was done */
500    XML_DOC_USERBUILT		= 1<<5, /* Document was built using the API
501                                           and not by parsing an instance */
502    XML_DOC_INTERNAL		= 1<<6, /* built for internal processing */
503    XML_DOC_HTML		= 1<<7  /* parsed or built HTML document */
504} xmlDocProperties;
505
506/**
507 * xmlDoc:
508 *
509 * An XML document.
510 */
511typedef struct _xmlDoc xmlDoc;
512typedef xmlDoc *xmlDocPtr;
513struct _xmlDoc {
514    void           *_private;	/* application data */
515    xmlElementType  type;       /* XML_DOCUMENT_NODE, must be second ! */
516    char           *name;	/* name/filename/URI of the document */
517    struct _xmlNode *children;	/* the document tree */
518    struct _xmlNode *last;	/* last child link */
519    struct _xmlNode *parent;	/* child->parent link */
520    struct _xmlNode *next;	/* next sibling link  */
521    struct _xmlNode *prev;	/* previous sibling link  */
522    struct _xmlDoc  *doc;	/* autoreference to itself */
523
524    /* End of common part */
525    int             compression;/* level of zlib compression */
526    int             standalone; /* standalone document (no external refs)
527				     1 if standalone="yes"
528				     0 if standalone="no"
529				    -1 if there is no XML declaration
530				    -2 if there is an XML declaration, but no
531					standalone attribute was specified */
532    struct _xmlDtd  *intSubset;	/* the document internal subset */
533    struct _xmlDtd  *extSubset;	/* the document external subset */
534    struct _xmlNs   *oldNs;	/* Global namespace, the old way */
535    const xmlChar  *version;	/* the XML version string */
536    const xmlChar  *encoding;   /* external initial encoding, if any */
537    void           *ids;        /* Hash table for ID attributes if any */
538    void           *refs;       /* Hash table for IDREFs attributes if any */
539    const xmlChar  *URL;	/* The URI for that document */
540    int             charset;    /* encoding of the in-memory content
541				   actually an xmlCharEncoding */
542    struct _xmlDict *dict;      /* dict used to allocate names or NULL */
543    void           *psvi;	/* for type/PSVI informations */
544    int             parseFlags;	/* set of xmlParserOption used to parse the
545				   document */
546    int             properties;	/* set of xmlDocProperties for this document
547				   set at the end of parsing */
548};
549
550
551typedef struct _xmlDOMWrapCtxt xmlDOMWrapCtxt;
552typedef xmlDOMWrapCtxt *xmlDOMWrapCtxtPtr;
553
554/**
555 * xmlDOMWrapAcquireNsFunction:
556 * @ctxt:  a DOM wrapper context
557 * @node:  the context node (element or attribute)
558 * @nsName:  the requested namespace name
559 * @nsPrefix:  the requested namespace prefix
560 *
561 * A function called to acquire namespaces (xmlNs) from the wrapper.
562 *
563 * Returns an xmlNsPtr or NULL in case of an error.
564 */
565typedef xmlNsPtr (*xmlDOMWrapAcquireNsFunction) (xmlDOMWrapCtxtPtr ctxt,
566						 xmlNodePtr node,
567						 const xmlChar *nsName,
568						 const xmlChar *nsPrefix);
569
570/**
571 * xmlDOMWrapCtxt:
572 *
573 * Context for DOM wrapper-operations.
574 */
575struct _xmlDOMWrapCtxt {
576    void * _private;
577    /*
578    * The type of this context, just in case we need specialized
579    * contexts in the future.
580    */
581    int type;
582    /*
583    * Internal namespace map used for various operations.
584    */
585    void * namespaceMap;
586    /*
587    * Use this one to acquire an xmlNsPtr intended for node->ns.
588    * (Note that this is not intended for elem->nsDef).
589    */
590    xmlDOMWrapAcquireNsFunction getNsForNodeFunc;
591};
592
593/**
594 * xmlChildrenNode:
595 *
596 * Macro for compatibility naming layer with libxml1. Maps
597 * to "children."
598 */
599#ifndef xmlChildrenNode
600#define xmlChildrenNode children
601#endif
602
603/**
604 * xmlRootNode:
605 *
606 * Macro for compatibility naming layer with libxml1. Maps
607 * to "children".
608 */
609#ifndef xmlRootNode
610#define xmlRootNode children
611#endif
612
613/*
614 * Variables.
615 */
616
617/*
618 * Some helper functions
619 */
620#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)
621XMLPUBFUN int XMLCALL
622		xmlValidateNCName	(const xmlChar *value,
623					 int space);
624#endif
625
626#if defined(LIBXML_TREE_ENABLED) || defined(LIBXML_SCHEMAS_ENABLED)
627XMLPUBFUN int XMLCALL
628		xmlValidateQName	(const xmlChar *value,
629					 int space);
630XMLPUBFUN int XMLCALL
631		xmlValidateName		(const xmlChar *value,
632					 int space);
633XMLPUBFUN int XMLCALL
634		xmlValidateNMToken	(const xmlChar *value,
635					 int space);
636#endif
637
638XMLPUBFUN xmlChar * XMLCALL
639		xmlBuildQName		(const xmlChar *ncname,
640					 const xmlChar *prefix,
641					 xmlChar *memory,
642					 int len);
643XMLPUBFUN xmlChar * XMLCALL
644		xmlSplitQName2		(const xmlChar *name,
645					 xmlChar **prefix);
646XMLPUBFUN const xmlChar * XMLCALL
647		xmlSplitQName3		(const xmlChar *name,
648					 int *len);
649
650/*
651 * Handling Buffers.
652 */
653
654XMLPUBFUN void XMLCALL
655		xmlSetBufferAllocationScheme(xmlBufferAllocationScheme scheme);
656XMLPUBFUN xmlBufferAllocationScheme XMLCALL
657		xmlGetBufferAllocationScheme(void);
658
659XMLPUBFUN xmlBufferPtr XMLCALL
660		xmlBufferCreate		(void);
661XMLPUBFUN xmlBufferPtr XMLCALL
662		xmlBufferCreateSize	(size_t size);
663XMLPUBFUN xmlBufferPtr XMLCALL
664		xmlBufferCreateStatic	(void *mem,
665					 size_t size);
666XMLPUBFUN int XMLCALL
667		xmlBufferResize		(xmlBufferPtr buf,
668					 unsigned int size);
669XMLPUBFUN void XMLCALL
670		xmlBufferFree		(xmlBufferPtr buf);
671XMLPUBFUN int XMLCALL
672		xmlBufferDump		(FILE *file,
673					 xmlBufferPtr buf);
674XMLPUBFUN int XMLCALL
675		xmlBufferAdd		(xmlBufferPtr buf,
676					 const xmlChar *str,
677					 int len);
678XMLPUBFUN int XMLCALL
679		xmlBufferAddHead	(xmlBufferPtr buf,
680					 const xmlChar *str,
681					 int len);
682XMLPUBFUN int XMLCALL
683		xmlBufferCat		(xmlBufferPtr buf,
684					 const xmlChar *str);
685XMLPUBFUN int XMLCALL
686		xmlBufferCCat		(xmlBufferPtr buf,
687					 const char *str);
688XMLPUBFUN int XMLCALL
689		xmlBufferShrink		(xmlBufferPtr buf,
690					 unsigned int len);
691XMLPUBFUN int XMLCALL
692		xmlBufferGrow		(xmlBufferPtr buf,
693					 unsigned int len);
694XMLPUBFUN void XMLCALL
695		xmlBufferEmpty		(xmlBufferPtr buf);
696XMLPUBFUN const xmlChar* XMLCALL
697		xmlBufferContent	(const xmlBufferPtr buf);
698XMLPUBFUN void XMLCALL
699		xmlBufferSetAllocationScheme(xmlBufferPtr buf,
700					 xmlBufferAllocationScheme scheme);
701XMLPUBFUN int XMLCALL
702		xmlBufferLength		(const xmlBufferPtr buf);
703
704/*
705 * Creating/freeing new structures.
706 */
707XMLPUBFUN xmlDtdPtr XMLCALL
708		xmlCreateIntSubset	(xmlDocPtr doc,
709					 const xmlChar *name,
710					 const xmlChar *ExternalID,
711					 const xmlChar *SystemID);
712XMLPUBFUN xmlDtdPtr XMLCALL
713		xmlNewDtd		(xmlDocPtr doc,
714					 const xmlChar *name,
715					 const xmlChar *ExternalID,
716					 const xmlChar *SystemID);
717XMLPUBFUN xmlDtdPtr XMLCALL
718		xmlGetIntSubset		(xmlDocPtr doc);
719XMLPUBFUN void XMLCALL
720		xmlFreeDtd		(xmlDtdPtr cur);
721#ifdef LIBXML_LEGACY_ENABLED
722XMLPUBFUN xmlNsPtr XMLCALL
723		xmlNewGlobalNs		(xmlDocPtr doc,
724					 const xmlChar *href,
725					 const xmlChar *prefix);
726#endif /* LIBXML_LEGACY_ENABLED */
727XMLPUBFUN xmlNsPtr XMLCALL
728		xmlNewNs		(xmlNodePtr node,
729					 const xmlChar *href,
730					 const xmlChar *prefix);
731XMLPUBFUN void XMLCALL
732		xmlFreeNs		(xmlNsPtr cur);
733XMLPUBFUN void XMLCALL
734		xmlFreeNsList		(xmlNsPtr cur);
735XMLPUBFUN xmlDocPtr XMLCALL
736		xmlNewDoc		(const xmlChar *version);
737XMLPUBFUN void XMLCALL
738		xmlFreeDoc		(xmlDocPtr cur);
739XMLPUBFUN xmlAttrPtr XMLCALL
740		xmlNewDocProp		(xmlDocPtr doc,
741					 const xmlChar *name,
742					 const xmlChar *value);
743#if defined(LIBXML_TREE_ENABLED) || defined(LIBXML_HTML_ENABLED) || \
744    defined(LIBXML_SCHEMAS_ENABLED)
745XMLPUBFUN xmlAttrPtr XMLCALL
746		xmlNewProp		(xmlNodePtr node,
747					 const xmlChar *name,
748					 const xmlChar *value);
749#endif
750XMLPUBFUN xmlAttrPtr XMLCALL
751		xmlNewNsProp		(xmlNodePtr node,
752					 xmlNsPtr ns,
753					 const xmlChar *name,
754					 const xmlChar *value);
755XMLPUBFUN xmlAttrPtr XMLCALL
756		xmlNewNsPropEatName	(xmlNodePtr node,
757					 xmlNsPtr ns,
758					 xmlChar *name,
759					 const xmlChar *value);
760XMLPUBFUN void XMLCALL
761		xmlFreePropList		(xmlAttrPtr cur);
762XMLPUBFUN void XMLCALL
763		xmlFreeProp		(xmlAttrPtr cur);
764XMLPUBFUN xmlAttrPtr XMLCALL
765		xmlCopyProp		(xmlNodePtr target,
766					 xmlAttrPtr cur);
767XMLPUBFUN xmlAttrPtr XMLCALL
768		xmlCopyPropList		(xmlNodePtr target,
769					 xmlAttrPtr cur);
770#ifdef LIBXML_TREE_ENABLED
771XMLPUBFUN xmlDtdPtr XMLCALL
772		xmlCopyDtd		(xmlDtdPtr dtd);
773#endif /* LIBXML_TREE_ENABLED */
774#if defined(LIBXML_TREE_ENABLED) || defined(LIBXML_SCHEMAS_ENABLED)
775XMLPUBFUN xmlDocPtr XMLCALL
776		xmlCopyDoc		(xmlDocPtr doc,
777					 int recursive);
778#endif /* defined(LIBXML_TREE_ENABLED) || defined(LIBXML_SCHEMAS_ENABLED) */
779/*
780 * Creating new nodes.
781 */
782XMLPUBFUN xmlNodePtr XMLCALL
783		xmlNewDocNode		(xmlDocPtr doc,
784					 xmlNsPtr ns,
785					 const xmlChar *name,
786					 const xmlChar *content);
787XMLPUBFUN xmlNodePtr XMLCALL
788		xmlNewDocNodeEatName	(xmlDocPtr doc,
789					 xmlNsPtr ns,
790					 xmlChar *name,
791					 const xmlChar *content);
792XMLPUBFUN xmlNodePtr XMLCALL
793		xmlNewNode		(xmlNsPtr ns,
794					 const xmlChar *name);
795XMLPUBFUN xmlNodePtr XMLCALL
796		xmlNewNodeEatName	(xmlNsPtr ns,
797					 xmlChar *name);
798#if defined(LIBXML_TREE_ENABLED) || defined(LIBXML_SCHEMAS_ENABLED)
799XMLPUBFUN xmlNodePtr XMLCALL
800		xmlNewChild		(xmlNodePtr parent,
801					 xmlNsPtr ns,
802					 const xmlChar *name,
803					 const xmlChar *content);
804#endif
805XMLPUBFUN xmlNodePtr XMLCALL
806		xmlNewDocText		(xmlDocPtr doc,
807					 const xmlChar *content);
808XMLPUBFUN xmlNodePtr XMLCALL
809		xmlNewText		(const xmlChar *content);
810XMLPUBFUN xmlNodePtr XMLCALL
811		xmlNewDocPI		(xmlDocPtr doc,
812					 const xmlChar *name,
813					 const xmlChar *content);
814XMLPUBFUN xmlNodePtr XMLCALL
815		xmlNewPI		(const xmlChar *name,
816					 const xmlChar *content);
817XMLPUBFUN xmlNodePtr XMLCALL
818		xmlNewDocTextLen	(xmlDocPtr doc,
819					 const xmlChar *content,
820					 int len);
821XMLPUBFUN xmlNodePtr XMLCALL
822		xmlNewTextLen		(const xmlChar *content,
823					 int len);
824XMLPUBFUN xmlNodePtr XMLCALL
825		xmlNewDocComment	(xmlDocPtr doc,
826					 const xmlChar *content);
827XMLPUBFUN xmlNodePtr XMLCALL
828		xmlNewComment		(const xmlChar *content);
829XMLPUBFUN xmlNodePtr XMLCALL
830		xmlNewCDataBlock	(xmlDocPtr doc,
831					 const xmlChar *content,
832					 int len);
833XMLPUBFUN xmlNodePtr XMLCALL
834		xmlNewCharRef		(xmlDocPtr doc,
835					 const xmlChar *name);
836XMLPUBFUN xmlNodePtr XMLCALL
837		xmlNewReference		(xmlDocPtr doc,
838					 const xmlChar *name);
839XMLPUBFUN xmlNodePtr XMLCALL
840		xmlCopyNode		(const xmlNodePtr node,
841					 int recursive);
842XMLPUBFUN xmlNodePtr XMLCALL
843		xmlDocCopyNode		(const xmlNodePtr node,
844					 xmlDocPtr doc,
845					 int recursive);
846XMLPUBFUN xmlNodePtr XMLCALL
847		xmlDocCopyNodeList	(xmlDocPtr doc,
848					 const xmlNodePtr node);
849XMLPUBFUN xmlNodePtr XMLCALL
850		xmlCopyNodeList		(const xmlNodePtr node);
851#ifdef LIBXML_TREE_ENABLED
852XMLPUBFUN xmlNodePtr XMLCALL
853		xmlNewTextChild		(xmlNodePtr parent,
854					 xmlNsPtr ns,
855					 const xmlChar *name,
856					 const xmlChar *content);
857XMLPUBFUN xmlNodePtr XMLCALL
858		xmlNewDocRawNode	(xmlDocPtr doc,
859					 xmlNsPtr ns,
860					 const xmlChar *name,
861					 const xmlChar *content);
862XMLPUBFUN xmlNodePtr XMLCALL
863		xmlNewDocFragment	(xmlDocPtr doc);
864#endif /* LIBXML_TREE_ENABLED */
865
866/*
867 * Navigating.
868 */
869XMLPUBFUN long XMLCALL
870		xmlGetLineNo		(xmlNodePtr node);
871#if defined(LIBXML_TREE_ENABLED) || defined(LIBXML_DEBUG_ENABLED)
872XMLPUBFUN xmlChar * XMLCALL
873		xmlGetNodePath		(xmlNodePtr node);
874#endif /* defined(LIBXML_TREE_ENABLED) || defined(LIBXML_DEBUG_ENABLED) */
875XMLPUBFUN xmlNodePtr XMLCALL
876		xmlDocGetRootElement	(xmlDocPtr doc);
877XMLPUBFUN xmlNodePtr XMLCALL
878		xmlGetLastChild		(xmlNodePtr parent);
879XMLPUBFUN int XMLCALL
880		xmlNodeIsText		(xmlNodePtr node);
881XMLPUBFUN int XMLCALL
882		xmlIsBlankNode		(xmlNodePtr node);
883
884/*
885 * Changing the structure.
886 */
887#if defined(LIBXML_TREE_ENABLED) || defined(LIBXML_WRITER_ENABLED)
888XMLPUBFUN xmlNodePtr XMLCALL
889		xmlDocSetRootElement	(xmlDocPtr doc,
890					 xmlNodePtr root);
891#endif /* defined(LIBXML_TREE_ENABLED) || defined(LIBXML_WRITER_ENABLED) */
892#ifdef LIBXML_TREE_ENABLED
893XMLPUBFUN void XMLCALL
894		xmlNodeSetName		(xmlNodePtr cur,
895					 const xmlChar *name);
896#endif /* LIBXML_TREE_ENABLED */
897XMLPUBFUN xmlNodePtr XMLCALL
898		xmlAddChild		(xmlNodePtr parent,
899					 xmlNodePtr cur);
900XMLPUBFUN xmlNodePtr XMLCALL
901		xmlAddChildList		(xmlNodePtr parent,
902					 xmlNodePtr cur);
903#if defined(LIBXML_TREE_ENABLED) || defined(LIBXML_WRITER_ENABLED)
904XMLPUBFUN xmlNodePtr XMLCALL
905		xmlReplaceNode		(xmlNodePtr old,
906					 xmlNodePtr cur);
907#endif /* defined(LIBXML_TREE_ENABLED) || defined(LIBXML_WRITER_ENABLED) */
908#if defined(LIBXML_TREE_ENABLED) || defined(LIBXML_HTML_ENABLED) || \
909    defined(LIBXML_SCHEMAS_ENABLED)
910XMLPUBFUN xmlNodePtr XMLCALL
911		xmlAddPrevSibling	(xmlNodePtr cur,
912					 xmlNodePtr elem);
913#endif /* LIBXML_TREE_ENABLED || LIBXML_HTML_ENABLED || LIBXML_SCHEMAS_ENABLED */
914XMLPUBFUN xmlNodePtr XMLCALL
915		xmlAddSibling		(xmlNodePtr cur,
916					 xmlNodePtr elem);
917XMLPUBFUN xmlNodePtr XMLCALL
918		xmlAddNextSibling	(xmlNodePtr cur,
919					 xmlNodePtr elem);
920XMLPUBFUN void XMLCALL
921		xmlUnlinkNode		(xmlNodePtr cur);
922XMLPUBFUN xmlNodePtr XMLCALL
923		xmlTextMerge		(xmlNodePtr first,
924					 xmlNodePtr second);
925XMLPUBFUN int XMLCALL
926		xmlTextConcat		(xmlNodePtr node,
927					 const xmlChar *content,
928					 int len);
929XMLPUBFUN void XMLCALL
930		xmlFreeNodeList		(xmlNodePtr cur);
931XMLPUBFUN void XMLCALL
932		xmlFreeNode		(xmlNodePtr cur);
933XMLPUBFUN void XMLCALL
934		xmlSetTreeDoc		(xmlNodePtr tree,
935					 xmlDocPtr doc);
936XMLPUBFUN void XMLCALL
937		xmlSetListDoc		(xmlNodePtr list,
938					 xmlDocPtr doc);
939/*
940 * Namespaces.
941 */
942XMLPUBFUN xmlNsPtr XMLCALL
943		xmlSearchNs		(xmlDocPtr doc,
944					 xmlNodePtr node,
945					 const xmlChar *nameSpace);
946XMLPUBFUN xmlNsPtr XMLCALL
947		xmlSearchNsByHref	(xmlDocPtr doc,
948					 xmlNodePtr node,
949					 const xmlChar *href);
950#if defined(LIBXML_TREE_ENABLED) || defined(LIBXML_XPATH_ENABLED) || defined(LIBXML_SCHEMAS_ENABLED)
951XMLPUBFUN xmlNsPtr * XMLCALL
952		xmlGetNsList		(xmlDocPtr doc,
953					 xmlNodePtr node);
954#endif /* defined(LIBXML_TREE_ENABLED) || defined(LIBXML_XPATH_ENABLED) */
955
956XMLPUBFUN void XMLCALL
957		xmlSetNs		(xmlNodePtr node,
958					 xmlNsPtr ns);
959XMLPUBFUN xmlNsPtr XMLCALL
960		xmlCopyNamespace	(xmlNsPtr cur);
961XMLPUBFUN xmlNsPtr XMLCALL
962		xmlCopyNamespaceList	(xmlNsPtr cur);
963
964/*
965 * Changing the content.
966 */
967#if defined(LIBXML_TREE_ENABLED) || defined(LIBXML_XINCLUDE_ENABLED) || defined(LIBXML_SCHEMAS_ENABLED) || defined(LIBXML_HTML_ENABLED)
968XMLPUBFUN xmlAttrPtr XMLCALL
969		xmlSetProp		(xmlNodePtr node,
970					 const xmlChar *name,
971					 const xmlChar *value);
972XMLPUBFUN xmlAttrPtr XMLCALL
973		xmlSetNsProp		(xmlNodePtr node,
974					 xmlNsPtr ns,
975					 const xmlChar *name,
976					 const xmlChar *value);
977#endif /* defined(LIBXML_TREE_ENABLED) || defined(LIBXML_XINCLUDE_ENABLED) || defined(LIBXML_SCHEMAS_ENABLED) || defined(LIBXML_HTML_ENABLED) */
978XMLPUBFUN xmlChar * XMLCALL
979		xmlGetNoNsProp		(xmlNodePtr node,
980					 const xmlChar *name);
981XMLPUBFUN xmlChar * XMLCALL
982		xmlGetProp		(xmlNodePtr node,
983					 const xmlChar *name);
984XMLPUBFUN xmlAttrPtr XMLCALL
985		xmlHasProp		(xmlNodePtr node,
986					 const xmlChar *name);
987XMLPUBFUN xmlAttrPtr XMLCALL
988		xmlHasNsProp		(xmlNodePtr node,
989					 const xmlChar *name,
990					 const xmlChar *nameSpace);
991XMLPUBFUN xmlChar * XMLCALL
992		xmlGetNsProp		(xmlNodePtr node,
993					 const xmlChar *name,
994					 const xmlChar *nameSpace);
995XMLPUBFUN xmlNodePtr XMLCALL
996		xmlStringGetNodeList	(xmlDocPtr doc,
997					 const xmlChar *value);
998XMLPUBFUN xmlNodePtr XMLCALL
999		xmlStringLenGetNodeList	(xmlDocPtr doc,
1000					 const xmlChar *value,
1001					 int len);
1002XMLPUBFUN xmlChar * XMLCALL
1003		xmlNodeListGetString	(xmlDocPtr doc,
1004					 xmlNodePtr list,
1005					 int inLine);
1006#ifdef LIBXML_TREE_ENABLED
1007XMLPUBFUN xmlChar * XMLCALL
1008		xmlNodeListGetRawString	(xmlDocPtr doc,
1009					 xmlNodePtr list,
1010					 int inLine);
1011#endif /* LIBXML_TREE_ENABLED */
1012XMLPUBFUN void XMLCALL
1013		xmlNodeSetContent	(xmlNodePtr cur,
1014					 const xmlChar *content);
1015#ifdef LIBXML_TREE_ENABLED
1016XMLPUBFUN void XMLCALL
1017		xmlNodeSetContentLen	(xmlNodePtr cur,
1018					 const xmlChar *content,
1019					 int len);
1020#endif /* LIBXML_TREE_ENABLED */
1021XMLPUBFUN void XMLCALL
1022		xmlNodeAddContent	(xmlNodePtr cur,
1023					 const xmlChar *content);
1024XMLPUBFUN void XMLCALL
1025		xmlNodeAddContentLen	(xmlNodePtr cur,
1026					 const xmlChar *content,
1027					 int len);
1028XMLPUBFUN xmlChar * XMLCALL
1029		xmlNodeGetContent	(xmlNodePtr cur);
1030XMLPUBFUN int XMLCALL
1031		xmlNodeBufGetContent	(xmlBufferPtr buffer,
1032					 xmlNodePtr cur);
1033XMLPUBFUN xmlChar * XMLCALL
1034		xmlNodeGetLang		(xmlNodePtr cur);
1035XMLPUBFUN int XMLCALL
1036		xmlNodeGetSpacePreserve	(xmlNodePtr cur);
1037#ifdef LIBXML_TREE_ENABLED
1038XMLPUBFUN void XMLCALL
1039		xmlNodeSetLang		(xmlNodePtr cur,
1040					 const xmlChar *lang);
1041XMLPUBFUN void XMLCALL
1042		xmlNodeSetSpacePreserve (xmlNodePtr cur,
1043					 int val);
1044#endif /* LIBXML_TREE_ENABLED */
1045XMLPUBFUN xmlChar * XMLCALL
1046		xmlNodeGetBase		(xmlDocPtr doc,
1047					 xmlNodePtr cur);
1048#if defined(LIBXML_TREE_ENABLED) || defined(LIBXML_XINCLUDE_ENABLED)
1049XMLPUBFUN void XMLCALL
1050		xmlNodeSetBase		(xmlNodePtr cur,
1051					 const xmlChar *uri);
1052#endif
1053
1054/*
1055 * Removing content.
1056 */
1057XMLPUBFUN int XMLCALL
1058		xmlRemoveProp		(xmlAttrPtr cur);
1059#if defined(LIBXML_TREE_ENABLED) || defined(LIBXML_SCHEMAS_ENABLED)
1060XMLPUBFUN int XMLCALL
1061		xmlUnsetNsProp		(xmlNodePtr node,
1062					 xmlNsPtr ns,
1063					 const xmlChar *name);
1064XMLPUBFUN int XMLCALL
1065		xmlUnsetProp		(xmlNodePtr node,
1066					 const xmlChar *name);
1067#endif /* defined(LIBXML_TREE_ENABLED) || defined(LIBXML_SCHEMAS_ENABLED) */
1068
1069/*
1070 * Internal, don't use.
1071 */
1072XMLPUBFUN void XMLCALL
1073		xmlBufferWriteCHAR	(xmlBufferPtr buf,
1074					 const xmlChar *string);
1075XMLPUBFUN void XMLCALL
1076		xmlBufferWriteChar	(xmlBufferPtr buf,
1077					 const char *string);
1078XMLPUBFUN void XMLCALL
1079		xmlBufferWriteQuotedString(xmlBufferPtr buf,
1080					 const xmlChar *string);
1081
1082#ifdef LIBXML_OUTPUT_ENABLED
1083XMLPUBFUN void xmlAttrSerializeTxtContent(xmlBufferPtr buf,
1084					 xmlDocPtr doc,
1085					 xmlAttrPtr attr,
1086					 const xmlChar *string);
1087#endif /* LIBXML_OUTPUT_ENABLED */
1088
1089#ifdef LIBXML_TREE_ENABLED
1090/*
1091 * Namespace handling.
1092 */
1093XMLPUBFUN int XMLCALL
1094		xmlReconciliateNs	(xmlDocPtr doc,
1095					 xmlNodePtr tree);
1096#endif
1097
1098#ifdef LIBXML_OUTPUT_ENABLED
1099/*
1100 * Saving.
1101 */
1102XMLPUBFUN void XMLCALL
1103		xmlDocDumpFormatMemory	(xmlDocPtr cur,
1104					 xmlChar **mem,
1105					 int *size,
1106					 int format);
1107XMLPUBFUN void XMLCALL
1108		xmlDocDumpMemory	(xmlDocPtr cur,
1109					 xmlChar **mem,
1110					 int *size);
1111XMLPUBFUN void XMLCALL
1112		xmlDocDumpMemoryEnc	(xmlDocPtr out_doc,
1113					 xmlChar **doc_txt_ptr,
1114					 int * doc_txt_len,
1115					 const char *txt_encoding);
1116XMLPUBFUN void XMLCALL
1117		xmlDocDumpFormatMemoryEnc(xmlDocPtr out_doc,
1118					 xmlChar **doc_txt_ptr,
1119					 int * doc_txt_len,
1120					 const char *txt_encoding,
1121					 int format);
1122XMLPUBFUN int XMLCALL
1123		xmlDocFormatDump	(FILE *f,
1124					 xmlDocPtr cur,
1125					 int format);
1126XMLPUBFUN int XMLCALL
1127		xmlDocDump		(FILE *f,
1128					 xmlDocPtr cur);
1129XMLPUBFUN void XMLCALL
1130		xmlElemDump		(FILE *f,
1131					 xmlDocPtr doc,
1132					 xmlNodePtr cur);
1133XMLPUBFUN int XMLCALL
1134		xmlSaveFile		(const char *filename,
1135					 xmlDocPtr cur);
1136XMLPUBFUN int XMLCALL
1137		xmlSaveFormatFile	(const char *filename,
1138					 xmlDocPtr cur,
1139					 int format);
1140XMLPUBFUN int XMLCALL
1141		xmlNodeDump		(xmlBufferPtr buf,
1142					 xmlDocPtr doc,
1143					 xmlNodePtr cur,
1144					 int level,
1145					 int format);
1146
1147XMLPUBFUN int XMLCALL
1148		xmlSaveFileTo		(xmlOutputBufferPtr buf,
1149					 xmlDocPtr cur,
1150					 const char *encoding);
1151XMLPUBFUN int XMLCALL
1152		xmlSaveFormatFileTo     (xmlOutputBufferPtr buf,
1153					 xmlDocPtr cur,
1154				         const char *encoding,
1155				         int format);
1156XMLPUBFUN void XMLCALL
1157		xmlNodeDumpOutput	(xmlOutputBufferPtr buf,
1158					 xmlDocPtr doc,
1159					 xmlNodePtr cur,
1160					 int level,
1161					 int format,
1162					 const char *encoding);
1163
1164XMLPUBFUN int XMLCALL
1165		xmlSaveFormatFileEnc    (const char *filename,
1166					 xmlDocPtr cur,
1167					 const char *encoding,
1168					 int format);
1169
1170XMLPUBFUN int XMLCALL
1171		xmlSaveFileEnc		(const char *filename,
1172					 xmlDocPtr cur,
1173					 const char *encoding);
1174
1175#endif /* LIBXML_OUTPUT_ENABLED */
1176/*
1177 * XHTML
1178 */
1179XMLPUBFUN int XMLCALL
1180		xmlIsXHTML		(const xmlChar *systemID,
1181					 const xmlChar *publicID);
1182
1183/*
1184 * Compression.
1185 */
1186XMLPUBFUN int XMLCALL
1187		xmlGetDocCompressMode	(xmlDocPtr doc);
1188XMLPUBFUN void XMLCALL
1189		xmlSetDocCompressMode	(xmlDocPtr doc,
1190					 int mode);
1191XMLPUBFUN int XMLCALL
1192		xmlGetCompressMode	(void);
1193XMLPUBFUN void XMLCALL
1194		xmlSetCompressMode	(int mode);
1195
1196/*
1197* DOM-wrapper helper functions.
1198*/
1199XMLPUBFUN xmlDOMWrapCtxtPtr XMLCALL
1200		xmlDOMWrapNewCtxt	(void);
1201XMLPUBFUN void XMLCALL
1202		xmlDOMWrapFreeCtxt	(xmlDOMWrapCtxtPtr ctxt);
1203XMLPUBFUN int XMLCALL
1204	    xmlDOMWrapReconcileNamespaces(xmlDOMWrapCtxtPtr ctxt,
1205					 xmlNodePtr elem,
1206					 int options);
1207XMLPUBFUN int XMLCALL
1208	    xmlDOMWrapAdoptNode		(xmlDOMWrapCtxtPtr ctxt,
1209					 xmlDocPtr sourceDoc,
1210					 xmlNodePtr node,
1211					 xmlDocPtr destDoc,
1212					 xmlNodePtr destParent,
1213					 int options);
1214XMLPUBFUN int XMLCALL
1215	    xmlDOMWrapRemoveNode	(xmlDOMWrapCtxtPtr ctxt,
1216					 xmlDocPtr doc,
1217					 xmlNodePtr node,
1218					 int options);
1219XMLPUBFUN int XMLCALL
1220	    xmlDOMWrapCloneNode		(xmlDOMWrapCtxtPtr ctxt,
1221					 xmlDocPtr sourceDoc,
1222					 xmlNodePtr node,
1223					 xmlNodePtr *clonedNode,
1224					 xmlDocPtr destDoc,
1225					 xmlNodePtr destParent,
1226					 int deep,
1227					 int options);
1228
1229#ifdef LIBXML_TREE_ENABLED
1230/*
1231 * 5 interfaces from DOM ElementTraversal, but different in entities
1232 * traversal.
1233 */
1234XMLPUBFUN unsigned long XMLCALL
1235            xmlChildElementCount        (xmlNodePtr parent);
1236XMLPUBFUN xmlNodePtr XMLCALL
1237            xmlNextElementSibling       (xmlNodePtr node);
1238XMLPUBFUN xmlNodePtr XMLCALL
1239            xmlFirstElementChild        (xmlNodePtr parent);
1240XMLPUBFUN xmlNodePtr XMLCALL
1241            xmlLastElementChild         (xmlNodePtr parent);
1242XMLPUBFUN xmlNodePtr XMLCALL
1243            xmlPreviousElementSibling   (xmlNodePtr node);
1244#endif
1245#ifdef __cplusplus
1246}
1247#endif
1248#ifndef __XML_PARSER_H__
1249#include <libxml/xmlmemory.h>
1250#endif
1251
1252#endif /* __XML_TREE_H__ */
1253
1254