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