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