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