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
21extern "C" {
22#endif
23
24/*
25 * Some of the basic types pointer to structures:
26 */
27/* xmlIO.h */
28typedef struct _xmlParserInputBuffer xmlParserInputBuffer;
29typedef xmlParserInputBuffer *xmlParserInputBufferPtr;
30
31typedef struct _xmlOutputBuffer xmlOutputBuffer;
32typedef xmlOutputBuffer *xmlOutputBufferPtr;
33
34/* parser.h */
35typedef struct _xmlParserInput xmlParserInput;
36typedef xmlParserInput *xmlParserInputPtr;
37
38typedef struct _xmlParserCtxt xmlParserCtxt;
39typedef xmlParserCtxt *xmlParserCtxtPtr;
40
41typedef struct _xmlSAXLocator xmlSAXLocator;
42typedef xmlSAXLocator *xmlSAXLocatorPtr;
43
44typedef struct _xmlSAXHandler xmlSAXHandler;
45typedef xmlSAXHandler *xmlSAXHandlerPtr;
46
47/* entities.h */
48typedef struct _xmlEntity xmlEntity;
49typedef 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
74typedef 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 */
89typedef struct _xmlBuffer xmlBuffer;
90typedef xmlBuffer *xmlBufferPtr;
91struct _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
105typedef 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
114typedef 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 */
120XMLPUBFUN xmlChar* XMLCALL xmlBufContent (const xmlBuf* buf);
121XMLPUBFUN xmlChar* XMLCALL xmlBufEnd (xmlBufPtr buf);
122XMLPUBFUN size_t XMLCALL xmlBufUse (const xmlBufPtr buf);
123XMLPUBFUN 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 */
159typedef 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
192typedef struct _xmlNotation xmlNotation;
193typedef xmlNotation *xmlNotationPtr;
194struct _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
206typedef 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
225typedef 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
238typedef struct _xmlEnumeration xmlEnumeration;
239typedef xmlEnumeration *xmlEnumerationPtr;
240struct _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
251typedef struct _xmlAttribute xmlAttribute;
252typedef xmlAttribute *xmlAttributePtr;
253struct _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 */
278typedef 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 */
290typedef 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
304typedef struct _xmlElementContent xmlElementContent;
305typedef xmlElementContent *xmlElementContentPtr;
306struct _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
322typedef 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
335extern "C" {
336#endif
337
338/**
339 * xmlElement:
340 *
341 * An XML Element declaration from a DTD.
342 */
343
344typedef struct _xmlElement xmlElement;
345typedef xmlElement *xmlElementPtr;
346struct _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
375typedef 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
387typedef struct _xmlNs xmlNs;
388typedef xmlNs *xmlNsPtr;
389struct _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 */
404typedef struct _xmlDtd xmlDtd;
405typedef xmlDtd *xmlDtdPtr;
406struct _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 */
432typedef struct _xmlAttr xmlAttr;
433typedef xmlAttr *xmlAttrPtr;
434struct _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 information */
447};
448
449/**
450 * xmlID:
451 *
452 * An XML ID instance.
453 */
454
455typedef struct _xmlID xmlID;
456typedef xmlID *xmlIDPtr;
457struct _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
472typedef struct _xmlRef xmlRef;
473typedef xmlRef *xmlRefPtr;
474struct _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 */
487typedef struct _xmlNode xmlNode;
488typedef xmlNode *xmlNodePtr;
489struct _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 information */
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 similarly named xmlParserOption
531 */
532typedef 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 */
549typedef struct _xmlDoc xmlDoc;
550typedef xmlDoc *xmlDocPtr;
551struct _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; /* Internal flag for charset handling,
579 actually an xmlCharEncoding */
580 struct _xmlDict *dict; /* dict used to allocate names or NULL */
581 void *psvi; /* for type/PSVI information */
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
589typedef struct _xmlDOMWrapCtxt xmlDOMWrapCtxt;
590typedef 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 */
603typedef 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 */
613struct _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)
663XMLPUBFUN int XMLCALL
664 xmlValidateNCName (const xmlChar *value,
665 int space);
666#endif
667
668#if defined(LIBXML_TREE_ENABLED) || defined(LIBXML_SCHEMAS_ENABLED)
669XMLPUBFUN int XMLCALL
670 xmlValidateQName (const xmlChar *value,
671 int space);
672XMLPUBFUN int XMLCALL
673 xmlValidateName (const xmlChar *value,
674 int space);
675XMLPUBFUN int XMLCALL
676 xmlValidateNMToken (const xmlChar *value,
677 int space);
678#endif
679
680XMLPUBFUN xmlChar * XMLCALL
681 xmlBuildQName (const xmlChar *ncname,
682 const xmlChar *prefix,
683 xmlChar *memory,
684 int len);
685XMLPUBFUN xmlChar * XMLCALL
686 xmlSplitQName2 (const xmlChar *name,
687 xmlChar **prefix);
688XMLPUBFUN 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
696XMLPUBFUN void XMLCALL
697 xmlSetBufferAllocationScheme(xmlBufferAllocationScheme scheme);
698XMLPUBFUN xmlBufferAllocationScheme XMLCALL
699 xmlGetBufferAllocationScheme(void);
700
701XMLPUBFUN xmlBufferPtr XMLCALL
702 xmlBufferCreate (void);
703XMLPUBFUN xmlBufferPtr XMLCALL
704 xmlBufferCreateSize (size_t size);
705XMLPUBFUN xmlBufferPtr XMLCALL
706 xmlBufferCreateStatic (void *mem,
707 size_t size);
708XMLPUBFUN int XMLCALL
709 xmlBufferResize (xmlBufferPtr buf,
710 unsigned int size);
711XMLPUBFUN void XMLCALL
712 xmlBufferFree (xmlBufferPtr buf);
713XMLPUBFUN int XMLCALL
714 xmlBufferDump (FILE *file,
715 xmlBufferPtr buf);
716XMLPUBFUN int XMLCALL
717 xmlBufferAdd (xmlBufferPtr buf,
718 const xmlChar *str,
719 int len);
720XMLPUBFUN int XMLCALL
721 xmlBufferAddHead (xmlBufferPtr buf,
722 const xmlChar *str,
723 int len);
724XMLPUBFUN int XMLCALL
725 xmlBufferCat (xmlBufferPtr buf,
726 const xmlChar *str);
727XMLPUBFUN int XMLCALL
728 xmlBufferCCat (xmlBufferPtr buf,
729 const char *str);
730XMLPUBFUN int XMLCALL
731 xmlBufferShrink (xmlBufferPtr buf,
732 unsigned int len);
733XMLPUBFUN int XMLCALL
734 xmlBufferGrow (xmlBufferPtr buf,
735 unsigned int len);
736XMLPUBFUN void XMLCALL
737 xmlBufferEmpty (xmlBufferPtr buf);
738XMLPUBFUN const xmlChar* XMLCALL
739 xmlBufferContent (const xmlBuffer *buf);
740XMLPUBFUN xmlChar* XMLCALL
741 xmlBufferDetach (xmlBufferPtr buf);
742XMLPUBFUN void XMLCALL
743 xmlBufferSetAllocationScheme(xmlBufferPtr buf,
744 xmlBufferAllocationScheme scheme);
745XMLPUBFUN int XMLCALL
746 xmlBufferLength (const xmlBuffer *buf);
747
748/*
749 * Creating/freeing new structures.
750 */
751XMLPUBFUN xmlDtdPtr XMLCALL
752 xmlCreateIntSubset (xmlDocPtr doc,
753 const xmlChar *name,
754 const xmlChar *ExternalID,
755 const xmlChar *SystemID);
756XMLPUBFUN xmlDtdPtr XMLCALL
757 xmlNewDtd (xmlDocPtr doc,
758 const xmlChar *name,
759 const xmlChar *ExternalID,
760 const xmlChar *SystemID);
761XMLPUBFUN xmlDtdPtr XMLCALL
762 xmlGetIntSubset (const xmlDoc *doc);
763XMLPUBFUN void XMLCALL
764 xmlFreeDtd (xmlDtdPtr cur);
765#ifdef LIBXML_LEGACY_ENABLED
766XMLPUBFUN xmlNsPtr XMLCALL
767 xmlNewGlobalNs (xmlDocPtr doc,
768 const xmlChar *href,
769 const xmlChar *prefix);
770#endif /* LIBXML_LEGACY_ENABLED */
771XMLPUBFUN xmlNsPtr XMLCALL
772 xmlNewNs (xmlNodePtr node,
773 const xmlChar *href,
774 const xmlChar *prefix);
775XMLPUBFUN void XMLCALL
776 xmlFreeNs (xmlNsPtr cur);
777XMLPUBFUN void XMLCALL
778 xmlFreeNsList (xmlNsPtr cur);
779XMLPUBFUN xmlDocPtr XMLCALL
780 xmlNewDoc (const xmlChar *version);
781XMLPUBFUN void XMLCALL
782 xmlFreeDoc (xmlDocPtr cur);
783XMLPUBFUN 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)
789XMLPUBFUN xmlAttrPtr XMLCALL
790 xmlNewProp (xmlNodePtr node,
791 const xmlChar *name,
792 const xmlChar *value);
793#endif
794XMLPUBFUN xmlAttrPtr XMLCALL
795 xmlNewNsProp (xmlNodePtr node,
796 xmlNsPtr ns,
797 const xmlChar *name,
798 const xmlChar *value);
799XMLPUBFUN xmlAttrPtr XMLCALL
800 xmlNewNsPropEatName (xmlNodePtr node,
801 xmlNsPtr ns,
802 xmlChar *name,
803 const xmlChar *value);
804XMLPUBFUN void XMLCALL
805 xmlFreePropList (xmlAttrPtr cur);
806XMLPUBFUN void XMLCALL
807 xmlFreeProp (xmlAttrPtr cur);
808XMLPUBFUN xmlAttrPtr XMLCALL
809 xmlCopyProp (xmlNodePtr target,
810 xmlAttrPtr cur);
811XMLPUBFUN xmlAttrPtr XMLCALL
812 xmlCopyPropList (xmlNodePtr target,
813 xmlAttrPtr cur);
814#ifdef LIBXML_TREE_ENABLED
815XMLPUBFUN xmlDtdPtr XMLCALL
816 xmlCopyDtd (xmlDtdPtr dtd);
817#endif /* LIBXML_TREE_ENABLED */
818#if defined(LIBXML_TREE_ENABLED) || defined(LIBXML_SCHEMAS_ENABLED)
819XMLPUBFUN 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 */
826XMLPUBFUN xmlNodePtr XMLCALL
827 xmlNewDocNode (xmlDocPtr doc,
828 xmlNsPtr ns,
829 const xmlChar *name,
830 const xmlChar *content);
831XMLPUBFUN xmlNodePtr XMLCALL
832 xmlNewDocNodeEatName (xmlDocPtr doc,
833 xmlNsPtr ns,
834 xmlChar *name,
835 const xmlChar *content);
836XMLPUBFUN xmlNodePtr XMLCALL
837 xmlNewNode (xmlNsPtr ns,
838 const xmlChar *name);
839XMLPUBFUN xmlNodePtr XMLCALL
840 xmlNewNodeEatName (xmlNsPtr ns,
841 xmlChar *name);
842#if defined(LIBXML_TREE_ENABLED) || defined(LIBXML_SCHEMAS_ENABLED)
843XMLPUBFUN xmlNodePtr XMLCALL
844 xmlNewChild (xmlNodePtr parent,
845 xmlNsPtr ns,
846 const xmlChar *name,
847 const xmlChar *content);
848#endif
849XMLPUBFUN xmlNodePtr XMLCALL
850 xmlNewDocText (const xmlDoc *doc,
851 const xmlChar *content);
852XMLPUBFUN xmlNodePtr XMLCALL
853 xmlNewText (const xmlChar *content);
854XMLPUBFUN xmlNodePtr XMLCALL
855 xmlNewDocPI (xmlDocPtr doc,
856 const xmlChar *name,
857 const xmlChar *content);
858XMLPUBFUN xmlNodePtr XMLCALL
859 xmlNewPI (const xmlChar *name,
860 const xmlChar *content);
861XMLPUBFUN xmlNodePtr XMLCALL
862 xmlNewDocTextLen (xmlDocPtr doc,
863 const xmlChar *content,
864 int len);
865XMLPUBFUN xmlNodePtr XMLCALL
866 xmlNewTextLen (const xmlChar *content,
867 int len);
868XMLPUBFUN xmlNodePtr XMLCALL
869 xmlNewDocComment (xmlDocPtr doc,
870 const xmlChar *content);
871XMLPUBFUN xmlNodePtr XMLCALL
872 xmlNewComment (const xmlChar *content);
873XMLPUBFUN xmlNodePtr XMLCALL
874 xmlNewCDataBlock (xmlDocPtr doc,
875 const xmlChar *content,
876 int len);
877XMLPUBFUN xmlNodePtr XMLCALL
878 xmlNewCharRef (xmlDocPtr doc,
879 const xmlChar *name);
880XMLPUBFUN xmlNodePtr XMLCALL
881 xmlNewReference (const xmlDoc *doc,
882 const xmlChar *name);
883XMLPUBFUN xmlNodePtr XMLCALL
884 xmlCopyNode (xmlNodePtr node,
885 int recursive);
886XMLPUBFUN xmlNodePtr XMLCALL
887 xmlDocCopyNode (xmlNodePtr node,
888 xmlDocPtr doc,
889 int recursive);
890XMLPUBFUN xmlNodePtr XMLCALL
891 xmlDocCopyNodeList (xmlDocPtr doc,
892 xmlNodePtr node);
893XMLPUBFUN xmlNodePtr XMLCALL
894 xmlCopyNodeList (xmlNodePtr node);
895#ifdef LIBXML_TREE_ENABLED
896XMLPUBFUN xmlNodePtr XMLCALL
897 xmlNewTextChild (xmlNodePtr parent,
898 xmlNsPtr ns,
899 const xmlChar *name,
900 const xmlChar *content);
901XMLPUBFUN xmlNodePtr XMLCALL
902 xmlNewDocRawNode (xmlDocPtr doc,
903 xmlNsPtr ns,
904 const xmlChar *name,
905 const xmlChar *content);
906XMLPUBFUN xmlNodePtr XMLCALL
907 xmlNewDocFragment (xmlDocPtr doc);
908#endif /* LIBXML_TREE_ENABLED */
909
910/*
911 * Navigating.
912 */
913XMLPUBFUN long XMLCALL
914 xmlGetLineNo (const xmlNode *node);
915#if defined(LIBXML_TREE_ENABLED) || defined(LIBXML_DEBUG_ENABLED)
916XMLPUBFUN xmlChar * XMLCALL
917 xmlGetNodePath (const xmlNode *node);
918#endif /* defined(LIBXML_TREE_ENABLED) || defined(LIBXML_DEBUG_ENABLED) */
919XMLPUBFUN xmlNodePtr XMLCALL
920 xmlDocGetRootElement (const xmlDoc *doc);
921XMLPUBFUN xmlNodePtr XMLCALL
922 xmlGetLastChild (const xmlNode *parent);
923XMLPUBFUN int XMLCALL
924 xmlNodeIsText (const xmlNode *node);
925XMLPUBFUN int XMLCALL
926 xmlIsBlankNode (const xmlNode *node);
927
928/*
929 * Changing the structure.
930 */
931#if defined(LIBXML_TREE_ENABLED) || defined(LIBXML_WRITER_ENABLED)
932XMLPUBFUN xmlNodePtr XMLCALL
933 xmlDocSetRootElement (xmlDocPtr doc,
934 xmlNodePtr root);
935#endif /* defined(LIBXML_TREE_ENABLED) || defined(LIBXML_WRITER_ENABLED) */
936#ifdef LIBXML_TREE_ENABLED
937XMLPUBFUN void XMLCALL
938 xmlNodeSetName (xmlNodePtr cur,
939 const xmlChar *name);
940#endif /* LIBXML_TREE_ENABLED */
941XMLPUBFUN xmlNodePtr XMLCALL
942 xmlAddChild (xmlNodePtr parent,
943 xmlNodePtr cur);
944XMLPUBFUN xmlNodePtr XMLCALL
945 xmlAddChildList (xmlNodePtr parent,
946 xmlNodePtr cur);
947#if defined(LIBXML_TREE_ENABLED) || defined(LIBXML_WRITER_ENABLED)
948XMLPUBFUN 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)
954XMLPUBFUN xmlNodePtr XMLCALL
955 xmlAddPrevSibling (xmlNodePtr cur,
956 xmlNodePtr elem);
957#endif /* LIBXML_TREE_ENABLED || LIBXML_HTML_ENABLED || LIBXML_SCHEMAS_ENABLED */
958XMLPUBFUN xmlNodePtr XMLCALL
959 xmlAddSibling (xmlNodePtr cur,
960 xmlNodePtr elem);
961XMLPUBFUN xmlNodePtr XMLCALL
962 xmlAddNextSibling (xmlNodePtr cur,
963 xmlNodePtr elem);
964XMLPUBFUN void XMLCALL
965 xmlUnlinkNode (xmlNodePtr cur);
966XMLPUBFUN xmlNodePtr XMLCALL
967 xmlTextMerge (xmlNodePtr first,
968 xmlNodePtr second);
969XMLPUBFUN int XMLCALL
970 xmlTextConcat (xmlNodePtr node,
971 const xmlChar *content,
972 int len);
973XMLPUBFUN void XMLCALL
974 xmlFreeNodeList (xmlNodePtr cur);
975XMLPUBFUN void XMLCALL
976 xmlFreeNode (xmlNodePtr cur);
977XMLPUBFUN void XMLCALL
978 xmlSetTreeDoc (xmlNodePtr tree,
979 xmlDocPtr doc);
980XMLPUBFUN void XMLCALL
981 xmlSetListDoc (xmlNodePtr list,
982 xmlDocPtr doc);
983/*
984 * Namespaces.
985 */
986XMLPUBFUN xmlNsPtr XMLCALL
987 xmlSearchNs (xmlDocPtr doc,
988 xmlNodePtr node,
989 const xmlChar *nameSpace);
990XMLPUBFUN 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)
996XMLPUBFUN xmlNsPtr * XMLCALL
997 xmlGetNsList (const xmlDoc *doc,
998 const xmlNode *node);
999#endif /* defined(LIBXML_TREE_ENABLED) || defined(LIBXML_XPATH_ENABLED) */
1000
1001XMLPUBFUN void XMLCALL
1002 xmlSetNs (xmlNodePtr node,
1003 xmlNsPtr ns);
1004XMLPUBFUN xmlNsPtr XMLCALL
1005 xmlCopyNamespace (xmlNsPtr cur);
1006XMLPUBFUN 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)
1014XMLPUBFUN xmlAttrPtr XMLCALL
1015 xmlSetProp (xmlNodePtr node,
1016 const xmlChar *name,
1017 const xmlChar *value);
1018XMLPUBFUN 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) */
1025XMLPUBFUN xmlChar * XMLCALL
1026 xmlGetNoNsProp (const xmlNode *node,
1027 const xmlChar *name);
1028XMLPUBFUN xmlChar * XMLCALL
1029 xmlGetProp (const xmlNode *node,
1030 const xmlChar *name);
1031XMLPUBFUN xmlAttrPtr XMLCALL
1032 xmlHasProp (const xmlNode *node,
1033 const xmlChar *name);
1034XMLPUBFUN xmlAttrPtr XMLCALL
1035 xmlHasNsProp (const xmlNode *node,
1036 const xmlChar *name,
1037 const xmlChar *nameSpace);
1038XMLPUBFUN xmlChar * XMLCALL
1039 xmlGetNsProp (const xmlNode *node,
1040 const xmlChar *name,
1041 const xmlChar *nameSpace);
1042XMLPUBFUN xmlNodePtr XMLCALL
1043 xmlStringGetNodeList (const xmlDoc *doc,
1044 const xmlChar *value);
1045XMLPUBFUN xmlNodePtr XMLCALL
1046 xmlStringLenGetNodeList (const xmlDoc *doc,
1047 const xmlChar *value,
1048 int len);
1049XMLPUBFUN xmlChar * XMLCALL
1050 xmlNodeListGetString (xmlDocPtr doc,
1051 const xmlNode *list,
1052 int inLine);
1053#ifdef LIBXML_TREE_ENABLED
1054XMLPUBFUN xmlChar * XMLCALL
1055 xmlNodeListGetRawString (const xmlDoc *doc,
1056 const xmlNode *list,
1057 int inLine);
1058#endif /* LIBXML_TREE_ENABLED */
1059XMLPUBFUN void XMLCALL
1060 xmlNodeSetContent (xmlNodePtr cur,
1061 const xmlChar *content);
1062#ifdef LIBXML_TREE_ENABLED
1063XMLPUBFUN void XMLCALL
1064 xmlNodeSetContentLen (xmlNodePtr cur,
1065 const xmlChar *content,
1066 int len);
1067#endif /* LIBXML_TREE_ENABLED */
1068XMLPUBFUN void XMLCALL
1069 xmlNodeAddContent (xmlNodePtr cur,
1070 const xmlChar *content);
1071XMLPUBFUN void XMLCALL
1072 xmlNodeAddContentLen (xmlNodePtr cur,
1073 const xmlChar *content,
1074 int len);
1075XMLPUBFUN xmlChar * XMLCALL
1076 xmlNodeGetContent (const xmlNode *cur);
1077
1078XMLPUBFUN int XMLCALL
1079 xmlNodeBufGetContent (xmlBufferPtr buffer,
1080 const xmlNode *cur);
1081XMLPUBFUN int XMLCALL
1082 xmlBufGetNodeContent (xmlBufPtr buf,
1083 const xmlNode *cur);
1084
1085XMLPUBFUN xmlChar * XMLCALL
1086 xmlNodeGetLang (const xmlNode *cur);
1087XMLPUBFUN int XMLCALL
1088 xmlNodeGetSpacePreserve (const xmlNode *cur);
1089#ifdef LIBXML_TREE_ENABLED
1090XMLPUBFUN void XMLCALL
1091 xmlNodeSetLang (xmlNodePtr cur,
1092 const xmlChar *lang);
1093XMLPUBFUN void XMLCALL
1094 xmlNodeSetSpacePreserve (xmlNodePtr cur,
1095 int val);
1096#endif /* LIBXML_TREE_ENABLED */
1097XMLPUBFUN xmlChar * XMLCALL
1098 xmlNodeGetBase (const xmlDoc *doc,
1099 const xmlNode *cur);
1100#if defined(LIBXML_TREE_ENABLED) || defined(LIBXML_XINCLUDE_ENABLED)
1101XMLPUBFUN void XMLCALL
1102 xmlNodeSetBase (xmlNodePtr cur,
1103 const xmlChar *uri);
1104#endif
1105
1106/*
1107 * Removing content.
1108 */
1109XMLPUBFUN int XMLCALL
1110 xmlRemoveProp (xmlAttrPtr cur);
1111#if defined(LIBXML_TREE_ENABLED) || defined(LIBXML_SCHEMAS_ENABLED)
1112XMLPUBFUN int XMLCALL
1113 xmlUnsetNsProp (xmlNodePtr node,
1114 xmlNsPtr ns,
1115 const xmlChar *name);
1116XMLPUBFUN 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 */
1124XMLPUBFUN void XMLCALL
1125 xmlBufferWriteCHAR (xmlBufferPtr buf,
1126 const xmlChar *string);
1127XMLPUBFUN void XMLCALL
1128 xmlBufferWriteChar (xmlBufferPtr buf,
1129 const char *string);
1130XMLPUBFUN void XMLCALL
1131 xmlBufferWriteQuotedString(xmlBufferPtr buf,
1132 const xmlChar *string);
1133
1134#ifdef LIBXML_OUTPUT_ENABLED
1135XMLPUBFUN 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 */
1145XMLPUBFUN int XMLCALL
1146 xmlReconciliateNs (xmlDocPtr doc,
1147 xmlNodePtr tree);
1148#endif
1149
1150#ifdef LIBXML_OUTPUT_ENABLED
1151/*
1152 * Saving.
1153 */
1154XMLPUBFUN void XMLCALL
1155 xmlDocDumpFormatMemory (xmlDocPtr cur,
1156 xmlChar **mem,
1157 int *size,
1158 int format);
1159XMLPUBFUN void XMLCALL
1160 xmlDocDumpMemory (xmlDocPtr cur,
1161 xmlChar **mem,
1162 int *size);
1163XMLPUBFUN void XMLCALL
1164 xmlDocDumpMemoryEnc (xmlDocPtr out_doc,
1165 xmlChar **doc_txt_ptr,
1166 int * doc_txt_len,
1167 const char *txt_encoding);
1168XMLPUBFUN 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);
1174XMLPUBFUN int XMLCALL
1175 xmlDocFormatDump (FILE *f,
1176 xmlDocPtr cur,
1177 int format);
1178XMLPUBFUN int XMLCALL
1179 xmlDocDump (FILE *f,
1180 xmlDocPtr cur);
1181XMLPUBFUN void XMLCALL
1182 xmlElemDump (FILE *f,
1183 xmlDocPtr doc,
1184 xmlNodePtr cur);
1185XMLPUBFUN int XMLCALL
1186 xmlSaveFile (const char *filename,
1187 xmlDocPtr cur);
1188XMLPUBFUN int XMLCALL
1189 xmlSaveFormatFile (const char *filename,
1190 xmlDocPtr cur,
1191 int format);
1192XMLPUBFUN size_t XMLCALL
1193 xmlBufNodeDump (xmlBufPtr buf,
1194 xmlDocPtr doc,
1195 xmlNodePtr cur,
1196 int level,
1197 int format);
1198XMLPUBFUN int XMLCALL
1199 xmlNodeDump (xmlBufferPtr buf,
1200 xmlDocPtr doc,
1201 xmlNodePtr cur,
1202 int level,
1203 int format);
1204
1205XMLPUBFUN int XMLCALL
1206 xmlSaveFileTo (xmlOutputBufferPtr buf,
1207 xmlDocPtr cur,
1208 const char *encoding);
1209XMLPUBFUN int XMLCALL
1210 xmlSaveFormatFileTo (xmlOutputBufferPtr buf,
1211 xmlDocPtr cur,
1212 const char *encoding,
1213 int format);
1214XMLPUBFUN void XMLCALL
1215 xmlNodeDumpOutput (xmlOutputBufferPtr buf,
1216 xmlDocPtr doc,
1217 xmlNodePtr cur,
1218 int level,
1219 int format,
1220 const char *encoding);
1221
1222XMLPUBFUN int XMLCALL
1223 xmlSaveFormatFileEnc (const char *filename,
1224 xmlDocPtr cur,
1225 const char *encoding,
1226 int format);
1227
1228XMLPUBFUN int XMLCALL
1229 xmlSaveFileEnc (const char *filename,
1230 xmlDocPtr cur,
1231 const char *encoding);
1232
1233#endif /* LIBXML_OUTPUT_ENABLED */
1234/*
1235 * XHTML
1236 */
1237XMLPUBFUN int XMLCALL
1238 xmlIsXHTML (const xmlChar *systemID,
1239 const xmlChar *publicID);
1240
1241/*
1242 * Compression.
1243 */
1244XMLPUBFUN int XMLCALL
1245 xmlGetDocCompressMode (const xmlDoc *doc);
1246XMLPUBFUN void XMLCALL
1247 xmlSetDocCompressMode (xmlDocPtr doc,
1248 int mode);
1249XMLPUBFUN int XMLCALL
1250 xmlGetCompressMode (void);
1251XMLPUBFUN void XMLCALL
1252 xmlSetCompressMode (int mode);
1253
1254/*
1255* DOM-wrapper helper functions.
1256*/
1257XMLPUBFUN xmlDOMWrapCtxtPtr XMLCALL
1258 xmlDOMWrapNewCtxt (void);
1259XMLPUBFUN void XMLCALL
1260 xmlDOMWrapFreeCtxt (xmlDOMWrapCtxtPtr ctxt);
1261XMLPUBFUN int XMLCALL
1262 xmlDOMWrapReconcileNamespaces(xmlDOMWrapCtxtPtr ctxt,
1263 xmlNodePtr elem,
1264 int options);
1265XMLPUBFUN int XMLCALL
1266 xmlDOMWrapAdoptNode (xmlDOMWrapCtxtPtr ctxt,
1267 xmlDocPtr sourceDoc,
1268 xmlNodePtr node,
1269 xmlDocPtr destDoc,
1270 xmlNodePtr destParent,
1271 int options);
1272XMLPUBFUN int XMLCALL
1273 xmlDOMWrapRemoveNode (xmlDOMWrapCtxtPtr ctxt,
1274 xmlDocPtr doc,
1275 xmlNodePtr node,
1276 int options);
1277XMLPUBFUN 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 */
1292XMLPUBFUN unsigned long XMLCALL
1293 xmlChildElementCount (xmlNodePtr parent);
1294XMLPUBFUN xmlNodePtr XMLCALL
1295 xmlNextElementSibling (xmlNodePtr node);
1296XMLPUBFUN xmlNodePtr XMLCALL
1297 xmlFirstElementChild (xmlNodePtr parent);
1298XMLPUBFUN xmlNodePtr XMLCALL
1299 xmlLastElementChild (xmlNodePtr parent);
1300XMLPUBFUN 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

Provided by KDAB

Privacy Policy

source code of include/libxml2/libxml/tree.h