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