Mercurial > repos > shellac > guppy_basecaller

comparison env/lib/python3.7/site-packages/lxml/includes/libxml/tree.h @ 0:26e78fe6e8c4 draft

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