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