![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to tree.h CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [parser3project] / win32 / gnome / gnome-xml / include / libxml|
Return to tree.h CVS log | Up to [parser3project] / win32 / gnome / gnome-xml / include / libxml |
1.1 paf 1: /*
2: * tree.h : describes the structures found in an tree resulting
3: * from an XML parsing.
4: *
5: * See Copyright for the status of this software.
6: *
7: * daniel@veillard.com
8: *
9: */
10:
11: #ifndef __XML_TREE_H__
12: #define __XML_TREE_H__
13:
14: #include <stdio.h>
15: #include <libxml/xmlversion.h>
16:
17: #ifdef __cplusplus
18: extern "C" {
19: #endif
20:
21: /*
22: * Some of the basic types pointer to structures:
23: */
24: /* xmlIO.h */
25: typedef struct _xmlParserInputBuffer xmlParserInputBuffer;
26: typedef xmlParserInputBuffer *xmlParserInputBufferPtr;
27:
28: typedef struct _xmlOutputBuffer xmlOutputBuffer;
29: typedef xmlOutputBuffer *xmlOutputBufferPtr;
30:
31: /* parser.h */
32: typedef struct _xmlParserInput xmlParserInput;
33: typedef xmlParserInput *xmlParserInputPtr;
34:
35: typedef struct _xmlParserCtxt xmlParserCtxt;
36: typedef xmlParserCtxt *xmlParserCtxtPtr;
37:
38: typedef struct _xmlSAXLocator xmlSAXLocator;
39: typedef xmlSAXLocator *xmlSAXLocatorPtr;
40:
41: typedef struct _xmlSAXHandler xmlSAXHandler;
42: typedef xmlSAXHandler *xmlSAXHandlerPtr;
43:
44: /* entities.h */
45: typedef struct _xmlEntity xmlEntity;
46: typedef xmlEntity *xmlEntityPtr;
47:
48: /**
49: * BASE_BUFFER_SIZE:
50: *
51: * default buffer size 4000.
52: */
53: #define BASE_BUFFER_SIZE 4000
54:
55: /**
56: * XML_XML_NAMESPACE:
57: *
58: * This is the namespace for the special xml: prefix predefined in the
59: * XML Namespace specification.
60: */
61: #define XML_XML_NAMESPACE \
62: (const xmlChar *) "http://www.w3.org/XML/1998/namespace"
63:
64: /*
65: * The different element types carried by an XML tree.
66: *
67: * NOTE: This is synchronized with DOM Level1 values
68: * See http://www.w3.org/TR/REC-DOM-Level-1/
69: *
70: * Actually this had diverged a bit, and now XML_DOCUMENT_TYPE_NODE should
71: * be deprecated to use an XML_DTD_NODE.
72: */
73: typedef enum {
74: XML_ELEMENT_NODE= 1,
75: XML_ATTRIBUTE_NODE= 2,
76: XML_TEXT_NODE= 3,
77: XML_CDATA_SECTION_NODE= 4,
78: XML_ENTITY_REF_NODE= 5,
79: XML_ENTITY_NODE= 6,
80: XML_PI_NODE= 7,
81: XML_COMMENT_NODE= 8,
82: XML_DOCUMENT_NODE= 9,
83: XML_DOCUMENT_TYPE_NODE= 10,
84: XML_DOCUMENT_FRAG_NODE= 11,
85: XML_NOTATION_NODE= 12,
86: XML_HTML_DOCUMENT_NODE= 13,
87: XML_DTD_NODE= 14,
88: XML_ELEMENT_DECL= 15,
89: XML_ATTRIBUTE_DECL= 16,
90: XML_ENTITY_DECL= 17,
91: XML_NAMESPACE_DECL= 18,
92: XML_XINCLUDE_START= 19,
93: XML_XINCLUDE_END= 20
94: #ifdef LIBXML_DOCB_ENABLED
95: ,XML_DOCB_DOCUMENT_NODE= 21
96: #endif
97: } xmlElementType;
98:
99: /**
100: * xmlChar:
101: *
102: * This is a basic byte in an UTF-8 encoded string.
103: * It's unsigned allowing to pinpoint case where char * are assigned
104: * to xmlChar * (possibly making serialization back impossible).
105: */
106:
107: typedef unsigned char xmlChar;
108:
109: /**
110: * BAD_CAST:
111: *
112: * Macro to cast a string to an xmlChar * when one know its safe.
113: */
114: #define BAD_CAST (xmlChar *)
115:
116: /**
117: * xmlNotation:
118: *
119: * A DTD Notation definition.
120: */
121:
122: typedef struct _xmlNotation xmlNotation;
123: typedef xmlNotation *xmlNotationPtr;
124: struct _xmlNotation {
125: const xmlChar *name; /* Notation name */
126: const xmlChar *PublicID; /* Public identifier, if any */
127: const xmlChar *SystemID; /* System identifier, if any */
128: };
129:
130: /**
131: * xmlAttributeType:
132: *
133: * A DTD Attribute type definition.
134: */
135:
136: typedef enum {
137: XML_ATTRIBUTE_CDATA = 1,
138: XML_ATTRIBUTE_ID,
139: XML_ATTRIBUTE_IDREF ,
140: XML_ATTRIBUTE_IDREFS,
141: XML_ATTRIBUTE_ENTITY,
142: XML_ATTRIBUTE_ENTITIES,
143: XML_ATTRIBUTE_NMTOKEN,
144: XML_ATTRIBUTE_NMTOKENS,
145: XML_ATTRIBUTE_ENUMERATION,
146: XML_ATTRIBUTE_NOTATION
147: } xmlAttributeType;
148:
149: /**
150: * xmlAttributeDefault:
151: *
152: * A DTD Attribute default definition.
153: */
154:
155: typedef enum {
156: XML_ATTRIBUTE_NONE = 1,
157: XML_ATTRIBUTE_REQUIRED,
158: XML_ATTRIBUTE_IMPLIED,
159: XML_ATTRIBUTE_FIXED
160: } xmlAttributeDefault;
161:
162: /**
163: * xmlEnumeration:
164: *
165: * List structure used when there is an enumeration in DTDs.
166: */
167:
168: typedef struct _xmlEnumeration xmlEnumeration;
169: typedef xmlEnumeration *xmlEnumerationPtr;
170: struct _xmlEnumeration {
171: struct _xmlEnumeration *next; /* next one */
172: const xmlChar *name; /* Enumeration name */
173: };
174:
175: /**
176: * xmlAttribute:
177: *
178: * An Attribute declaration in a DTD.
179: */
180:
181: typedef struct _xmlAttribute xmlAttribute;
182: typedef xmlAttribute *xmlAttributePtr;
183: struct _xmlAttribute {
184: void *_private; /* application data */
185: xmlElementType type; /* XML_ATTRIBUTE_DECL, must be second ! */
186: const xmlChar *name; /* Attribute name */
187: struct _xmlNode *children; /* NULL */
188: struct _xmlNode *last; /* NULL */
189: struct _xmlDtd *parent; /* -> DTD */
190: struct _xmlNode *next; /* next sibling link */
191: struct _xmlNode *prev; /* previous sibling link */
192: struct _xmlDoc *doc; /* the containing document */
193:
194: struct _xmlAttribute *nexth; /* next in hash table */
195: xmlAttributeType atype; /* The attribute type */
196: xmlAttributeDefault def; /* the default */
197: const xmlChar *defaultValue; /* or the default value */
198: xmlEnumerationPtr tree; /* or the enumeration tree if any */
199: const xmlChar *prefix; /* the namespace prefix if any */
200: const xmlChar *elem; /* Element holding the attribute */
201: };
202:
203: /**
204: * xmlElementContentType:
205: *
206: * Possible definitions of element content types.
207: */
208: typedef enum {
209: XML_ELEMENT_CONTENT_PCDATA = 1,
210: XML_ELEMENT_CONTENT_ELEMENT,
211: XML_ELEMENT_CONTENT_SEQ,
212: XML_ELEMENT_CONTENT_OR
213: } xmlElementContentType;
214:
215: /**
216: * xmlElementContentOccur:
217: *
218: * Possible definitions of element content occurrences.
219: */
220: typedef enum {
221: XML_ELEMENT_CONTENT_ONCE = 1,
222: XML_ELEMENT_CONTENT_OPT,
223: XML_ELEMENT_CONTENT_MULT,
224: XML_ELEMENT_CONTENT_PLUS
225: } xmlElementContentOccur;
226:
227: /**
228: * xmlElementContent:
229: *
230: * An XML Element content as stored after parsing an element definition
231: * in a DTD.
232: */
233:
234: typedef struct _xmlElementContent xmlElementContent;
235: typedef xmlElementContent *xmlElementContentPtr;
236: struct _xmlElementContent {
237: xmlElementContentType type; /* PCDATA, ELEMENT, SEQ or OR */
238: xmlElementContentOccur ocur; /* ONCE, OPT, MULT or PLUS */
239: const xmlChar *name; /* Element name */
240: struct _xmlElementContent *c1; /* first child */
241: struct _xmlElementContent *c2; /* second child */
242: struct _xmlElementContent *parent; /* parent */
243: const xmlChar *prefix; /* Namespace prefix */
244: };
245:
246: /**
247: * xmlElementTypeVal:
248: *
249: * The different possibilities for an element content type.
250: */
251:
252: typedef enum {
253: XML_ELEMENT_TYPE_UNDEFINED = 0,
254: XML_ELEMENT_TYPE_EMPTY = 1,
255: XML_ELEMENT_TYPE_ANY,
256: XML_ELEMENT_TYPE_MIXED,
257: XML_ELEMENT_TYPE_ELEMENT
258: } xmlElementTypeVal;
259:
260:
261: #ifdef __cplusplus
262: }
263: #endif
264: #include <libxml/xmlregexp.h>
265: #ifdef __cplusplus
266: extern "C" {
267: #endif
268:
269: /**
270: * xmlElement:
271: *
272: * An XML Element declaration from a DTD.
273: */
274:
275: typedef struct _xmlElement xmlElement;
276: typedef xmlElement *xmlElementPtr;
277: struct _xmlElement {
278: void *_private; /* application data */
279: xmlElementType type; /* XML_ELEMENT_DECL, must be second ! */
280: const xmlChar *name; /* Element name */
281: struct _xmlNode *children; /* NULL */
282: struct _xmlNode *last; /* NULL */
283: struct _xmlDtd *parent; /* -> DTD */
284: struct _xmlNode *next; /* next sibling link */
285: struct _xmlNode *prev; /* previous sibling link */
286: struct _xmlDoc *doc; /* the containing document */
287:
288: xmlElementTypeVal etype; /* The type */
289: xmlElementContentPtr content; /* the allowed element content */
290: xmlAttributePtr attributes; /* List of the declared attributes */
291: const xmlChar *prefix; /* the namespace prefix if any */
292: #ifdef LIBXML_REGEXP_ENABLED
293: xmlRegexpPtr contModel; /* the validating regexp */
294: #else
295: void *contModel;
296: #endif
297: };
298:
299:
300: /**
301: * XML_LOCAL_NAMESPACE:
302: *
303: * A namespace declaration node.
304: */
305: #define XML_LOCAL_NAMESPACE XML_NAMESPACE_DECL
306: typedef xmlElementType xmlNsType;
307:
308: /**
309: * xmlNs:
310: *
311: * An XML namespace.
312: * Note that prefix == NULL is valid, it defines the default namespace
313: * within the subtree (until overridden).
314: *
315: * xmlNsType is unified with xmlElementType.
316: */
317:
318: typedef struct _xmlNs xmlNs;
319: typedef xmlNs *xmlNsPtr;
320: struct _xmlNs {
321: struct _xmlNs *next; /* next Ns link for this node */
322: xmlNsType type; /* global or local */
323: const xmlChar *href; /* URL for the namespace */
324: const xmlChar *prefix; /* prefix for the namespace */
325: void *_private; /* application data */
326: };
327:
328: /**
329: * xmlDtd:
330: *
331: * An XML DTD, as defined by <!DOCTYPE ... There is actually one for
332: * the internal subset and for the external subset.
333: */
334: typedef struct _xmlDtd xmlDtd;
335: typedef xmlDtd *xmlDtdPtr;
336: struct _xmlDtd {
337: void *_private; /* application data */
338: xmlElementType type; /* XML_DTD_NODE, must be second ! */
339: const xmlChar *name; /* Name of the DTD */
340: struct _xmlNode *children; /* the value of the property link */
341: struct _xmlNode *last; /* last child link */
342: struct _xmlDoc *parent; /* child->parent link */
343: struct _xmlNode *next; /* next sibling link */
344: struct _xmlNode *prev; /* previous sibling link */
345: struct _xmlDoc *doc; /* the containing document */
346:
347: /* End of common part */
348: void *notations; /* Hash table for notations if any */
349: void *elements; /* Hash table for elements if any */
350: void *attributes; /* Hash table for attributes if any */
351: void *entities; /* Hash table for entities if any */
352: const xmlChar *ExternalID; /* External identifier for PUBLIC DTD */
353: const xmlChar *SystemID; /* URI for a SYSTEM or PUBLIC DTD */
354: void *pentities; /* Hash table for param entities if any */
355: };
356:
357: /**
358: * xmlAttr:
359: *
360: * An attribute on an XML node.
361: */
362: typedef struct _xmlAttr xmlAttr;
363: typedef xmlAttr *xmlAttrPtr;
364: struct _xmlAttr {
365: void *_private; /* application data */
366: xmlElementType type; /* XML_ATTRIBUTE_NODE, must be second ! */
367: const xmlChar *name; /* the name of the property */
368: struct _xmlNode *children; /* the value of the property */
369: struct _xmlNode *last; /* NULL */
370: struct _xmlNode *parent; /* child->parent link */
371: struct _xmlAttr *next; /* next sibling link */
372: struct _xmlAttr *prev; /* previous sibling link */
373: struct _xmlDoc *doc; /* the containing document */
374: xmlNs *ns; /* pointer to the associated namespace */
375: xmlAttributeType atype; /* the attribute type if validating */
376: };
377:
378: /**
379: * xmlID:
380: *
381: * An XML ID instance.
382: */
383:
384: typedef struct _xmlID xmlID;
385: typedef xmlID *xmlIDPtr;
386: struct _xmlID {
387: struct _xmlID *next; /* next ID */
388: const xmlChar *value; /* The ID name */
389: xmlAttrPtr attr; /* The attribute holding it */
390: const xmlChar *name; /* The attribute if attr is not available */
391: int lineno; /* The line number if attr is not available */
392: };
393:
394: /**
395: * xmlRef:
396: *
397: * An XML IDREF instance.
398: */
399:
400: typedef struct _xmlRef xmlRef;
401: typedef xmlRef *xmlRefPtr;
402: struct _xmlRef {
403: struct _xmlRef *next; /* next Ref */
404: const xmlChar *value; /* The Ref name */
405: xmlAttrPtr attr; /* The attribute holding it */
406: const xmlChar *name; /* The attribute if attr is not available */
407: int lineno; /* The line number if attr is not available */
408: };
409:
410: /**
411: * xmlBufferAllocationScheme:
412: *
413: * A buffer allocation scheme can be defined to either match exactly the
414: * need or double it's allocated size each time it is found too small.
415: */
416:
417: typedef enum {
418: XML_BUFFER_ALLOC_DOUBLEIT,
419: XML_BUFFER_ALLOC_EXACT
420: } xmlBufferAllocationScheme;
421:
422: /**
423: * xmlBuffer:
424: *
425: * A buffer structure.
426: */
427: typedef struct _xmlBuffer xmlBuffer;
428: typedef xmlBuffer *xmlBufferPtr;
429: struct _xmlBuffer {
430: xmlChar *content; /* The buffer content UTF8 */
431: unsigned int use; /* The buffer size used */
432: unsigned int size; /* The buffer size */
433: xmlBufferAllocationScheme alloc; /* The realloc method */
434: };
435:
436: /**
437: * xmlNode:
438: *
439: * A node in an XML tree.
440: */
441: typedef struct _xmlNode xmlNode;
442: typedef xmlNode *xmlNodePtr;
443: struct _xmlNode {
444: void *_private; /* application data */
445: xmlElementType type; /* type number, must be second ! */
446: const xmlChar *name; /* the name of the node, or the entity */
447: struct _xmlNode *children; /* parent->childs link */
448: struct _xmlNode *last; /* last child link */
449: struct _xmlNode *parent; /* child->parent link */
450: struct _xmlNode *next; /* next sibling link */
451: struct _xmlNode *prev; /* previous sibling link */
452: struct _xmlDoc *doc; /* the containing document */
453:
454: /* End of common part */
455: xmlNs *ns; /* pointer to the associated namespace */
456: xmlChar *content; /* the content */
457: struct _xmlAttr *properties;/* properties list */
458: xmlNs *nsDef; /* namespace definitions on this node */
459: };
460:
461: /**
462: * XML_GET_CONTENT:
463: *
464: * Macro to extract the content pointer of a node.
465: */
466: #define XML_GET_CONTENT(n) \
467: ((n)->type == XML_ELEMENT_NODE ? NULL : (n)->content)
468:
469: /**
470: * XML_GET_LINE:
471: *
472: * Macro to extract the line number of an element node.
473: * This will work only if line numbering is activated by
474: * calling xmlLineNumbersDefault(1) before parsing.
475: */
476: #define XML_GET_LINE(n) \
477: ((n)->type == XML_ELEMENT_NODE ? (int) (n)->content : 0)
478:
479: /**
480: * xmlDoc:
481: *
482: * An XML document.
483: */
484: typedef struct _xmlDoc xmlDoc;
485: typedef xmlDoc *xmlDocPtr;
486: struct _xmlDoc {
487: void *_private; /* application data */
488: xmlElementType type; /* XML_DOCUMENT_NODE, must be second ! */
489: char *name; /* name/filename/URI of the document */
490: struct _xmlNode *children; /* the document tree */
491: struct _xmlNode *last; /* last child link */
492: struct _xmlNode *parent; /* child->parent link */
493: struct _xmlNode *next; /* next sibling link */
494: struct _xmlNode *prev; /* previous sibling link */
495: struct _xmlDoc *doc; /* autoreference to itself */
496:
497: /* End of common part */
498: int compression;/* level of zlib compression */
499: int standalone; /* standalone document (no external refs) */
500: struct _xmlDtd *intSubset; /* the document internal subset */
501: struct _xmlDtd *extSubset; /* the document external subset */
502: struct _xmlNs *oldNs; /* Global namespace, the old way */
503: const xmlChar *version; /* the XML version string */
504: const xmlChar *encoding; /* external initial encoding, if any */
505: void *ids; /* Hash table for ID attributes if any */
506: void *refs; /* Hash table for IDREFs attributes if any */
507: const xmlChar *URL; /* The URI for that document */
508: int charset; /* encoding of the in-memory content
509: actually an xmlCharEncoding */
510: };
511:
512: /**
513: * xmlChildrenNode:
514: *
515: * Macro for compatibility naming layer with libxml1.
516: */
517: #ifndef xmlChildrenNode
518: #define xmlChildrenNode children
519: #endif
520:
521: /**
522: * xmlRootNode:
523: *
524: * Macro for compatibility naming layer with libxml1.
525: */
526: #ifndef xmlRootNode
527: #define xmlRootNode children
528: #endif
529:
530: /*
531: * Variables.
532: */
533: #if 0
534: LIBXML_DLL_IMPORT extern int oldXMLWDcompatibility;/* maintain compatibility with old WD */
535: LIBXML_DLL_IMPORT extern int xmlIndentTreeOutput; /* try to indent the tree dumps */
536: LIBXML_DLL_IMPORT extern xmlBufferAllocationScheme xmlBufferAllocScheme; /* alloc scheme to use */
537: LIBXML_DLL_IMPORT extern int xmlSaveNoEmptyTags; /* save empty tags as <empty></empty> */
538: LIBXML_DLL_IMPORT extern int xmlDefaultBufferSize; /* default buffer size */
539: #endif
540:
1.2 ! paf 541: /*
! 542: * Some helper functions
! 543: */
! 544: int xmlValidateNCName (const xmlChar *value,
! 545: int space);
! 546: int xmlValidateQName (const xmlChar *value,
! 547: int space);
! 548: int xmlValidateName (const xmlChar *value,
! 549: int space);
! 550: int xmlValidateNMToken (const xmlChar *value,
! 551: int space);
! 552:
! 553: xmlChar * xmlBuildQName (const xmlChar *ncname,
! 554: const xmlChar *prefix,
! 555: xmlChar *memory,
! 556: int len);
! 557: xmlChar * xmlSplitQName2 (const xmlChar *name,
! 558: xmlChar **prefix);
1.1 paf 559: /*
560: * Handling Buffers.
561: */
562:
563: void xmlSetBufferAllocationScheme(xmlBufferAllocationScheme scheme);
564: xmlBufferAllocationScheme xmlGetBufferAllocationScheme(void);
565:
566: xmlBufferPtr xmlBufferCreate (void);
567: xmlBufferPtr xmlBufferCreateSize (size_t size);
568: int xmlBufferResize (xmlBufferPtr buf,
569: unsigned int size);
570: void xmlBufferFree (xmlBufferPtr buf);
571: int xmlBufferDump (FILE *file,
572: xmlBufferPtr buf);
573: void xmlBufferAdd (xmlBufferPtr buf,
574: const xmlChar *str,
575: int len);
576: void xmlBufferAddHead (xmlBufferPtr buf,
577: const xmlChar *str,
578: int len);
579: void xmlBufferCat (xmlBufferPtr buf,
580: const xmlChar *str);
581: void xmlBufferCCat (xmlBufferPtr buf,
582: const char *str);
583: int xmlBufferShrink (xmlBufferPtr buf,
584: unsigned int len);
585: int xmlBufferGrow (xmlBufferPtr buf,
586: unsigned int len);
587: void xmlBufferEmpty (xmlBufferPtr buf);
588: const xmlChar* xmlBufferContent (const xmlBufferPtr buf);
589: void xmlBufferSetAllocationScheme(xmlBufferPtr buf,
590: xmlBufferAllocationScheme scheme);
591: int xmlBufferLength (const xmlBufferPtr buf);
592:
593: /*
594: * Creating/freeing new structures.
595: */
596: xmlDtdPtr xmlCreateIntSubset (xmlDocPtr doc,
597: const xmlChar *name,
598: const xmlChar *ExternalID,
599: const xmlChar *SystemID);
600: xmlDtdPtr xmlNewDtd (xmlDocPtr doc,
601: const xmlChar *name,
602: const xmlChar *ExternalID,
603: const xmlChar *SystemID);
604: xmlDtdPtr xmlGetIntSubset (xmlDocPtr doc);
605: void xmlFreeDtd (xmlDtdPtr cur);
606: xmlNsPtr xmlNewGlobalNs (xmlDocPtr doc,
607: const xmlChar *href,
608: const xmlChar *prefix);
609: xmlNsPtr xmlNewNs (xmlNodePtr node,
610: const xmlChar *href,
611: const xmlChar *prefix);
612: void xmlFreeNs (xmlNsPtr cur);
613: void xmlFreeNsList (xmlNsPtr cur);
614: xmlDocPtr xmlNewDoc (const xmlChar *version);
615: void xmlFreeDoc (xmlDocPtr cur);
616: xmlAttrPtr xmlNewDocProp (xmlDocPtr doc,
617: const xmlChar *name,
618: const xmlChar *value);
619: xmlAttrPtr xmlNewProp (xmlNodePtr node,
620: const xmlChar *name,
621: const xmlChar *value);
622: xmlAttrPtr xmlNewNsProp (xmlNodePtr node,
623: xmlNsPtr ns,
624: const xmlChar *name,
625: const xmlChar *value);
626: xmlAttrPtr xmlNewNsPropEatName (xmlNodePtr node,
627: xmlNsPtr ns,
628: xmlChar *name,
629: const xmlChar *value);
630: void xmlFreePropList (xmlAttrPtr cur);
631: void xmlFreeProp (xmlAttrPtr cur);
632: xmlAttrPtr xmlCopyProp (xmlNodePtr target,
633: xmlAttrPtr cur);
634: xmlAttrPtr xmlCopyPropList (xmlNodePtr target,
635: xmlAttrPtr cur);
636: xmlDtdPtr xmlCopyDtd (xmlDtdPtr dtd);
637: xmlDocPtr xmlCopyDoc (xmlDocPtr doc,
638: int recursive);
639:
640: /*
641: * Creating new nodes.
642: */
643: xmlNodePtr xmlNewDocNode (xmlDocPtr doc,
644: xmlNsPtr ns,
645: const xmlChar *name,
646: const xmlChar *content);
647: xmlNodePtr xmlNewDocNodeEatName (xmlDocPtr doc,
648: xmlNsPtr ns,
649: xmlChar *name,
650: const xmlChar *content);
651: xmlNodePtr xmlNewDocRawNode (xmlDocPtr doc,
652: xmlNsPtr ns,
653: const xmlChar *name,
654: const xmlChar *content);
655: xmlNodePtr xmlNewNode (xmlNsPtr ns,
656: const xmlChar *name);
657: xmlNodePtr xmlNewNodeEatName (xmlNsPtr ns,
658: xmlChar *name);
659: xmlNodePtr xmlNewChild (xmlNodePtr parent,
660: xmlNsPtr ns,
661: const xmlChar *name,
662: const xmlChar *content);
663: xmlNodePtr xmlNewTextChild (xmlNodePtr parent,
664: xmlNsPtr ns,
665: const xmlChar *name,
666: const xmlChar *content);
667: xmlNodePtr xmlNewDocText (xmlDocPtr doc,
668: const xmlChar *content);
669: xmlNodePtr xmlNewText (const xmlChar *content);
670: xmlNodePtr xmlNewPI (const xmlChar *name,
671: const xmlChar *content);
672: xmlNodePtr xmlNewDocTextLen (xmlDocPtr doc,
673: const xmlChar *content,
674: int len);
675: xmlNodePtr xmlNewTextLen (const xmlChar *content,
676: int len);
677: xmlNodePtr xmlNewDocComment (xmlDocPtr doc,
678: const xmlChar *content);
679: xmlNodePtr xmlNewComment (const xmlChar *content);
680: xmlNodePtr xmlNewCDataBlock (xmlDocPtr doc,
681: const xmlChar *content,
682: int len);
683: xmlNodePtr xmlNewCharRef (xmlDocPtr doc,
684: const xmlChar *name);
685: xmlNodePtr xmlNewReference (xmlDocPtr doc,
686: const xmlChar *name);
687: xmlNodePtr xmlCopyNode (const xmlNodePtr node,
688: int recursive);
689: xmlNodePtr xmlDocCopyNode (const xmlNodePtr node,
690: xmlDocPtr doc,
691: int recursive);
692: xmlNodePtr xmlCopyNodeList (const xmlNodePtr node);
693: xmlNodePtr xmlNewDocFragment (xmlDocPtr doc);
694:
695: /*
696: * Navigating.
697: */
698: long xmlGetLineNo (xmlNodePtr node);
699: xmlChar * xmlGetNodePath (xmlNodePtr node);
700: xmlNodePtr xmlDocGetRootElement (xmlDocPtr doc);
701: xmlNodePtr xmlGetLastChild (xmlNodePtr parent);
702: int xmlNodeIsText (xmlNodePtr node);
703: int xmlIsBlankNode (xmlNodePtr node);
704:
705: /*
706: * Changing the structure.
707: */
708: xmlNodePtr xmlDocSetRootElement (xmlDocPtr doc,
709: xmlNodePtr root);
710: void xmlNodeSetName (xmlNodePtr cur,
711: const xmlChar *name);
712: xmlNodePtr xmlAddChild (xmlNodePtr parent,
713: xmlNodePtr cur);
714: xmlNodePtr xmlAddChildList (xmlNodePtr parent,
715: xmlNodePtr cur);
716: xmlNodePtr xmlReplaceNode (xmlNodePtr old,
717: xmlNodePtr cur);
718: xmlNodePtr xmlAddSibling (xmlNodePtr cur,
719: xmlNodePtr elem);
720: xmlNodePtr xmlAddPrevSibling (xmlNodePtr cur,
721: xmlNodePtr elem);
722: xmlNodePtr xmlAddNextSibling (xmlNodePtr cur,
723: xmlNodePtr elem);
724: void xmlUnlinkNode (xmlNodePtr cur);
725: xmlNodePtr xmlTextMerge (xmlNodePtr first,
726: xmlNodePtr second);
1.2 ! paf 727: int xmlTextConcat (xmlNodePtr node,
1.1 paf 728: const xmlChar *content,
729: int len);
730: void xmlFreeNodeList (xmlNodePtr cur);
731: void xmlFreeNode (xmlNodePtr cur);
732: void xmlSetTreeDoc (xmlNodePtr tree,
733: xmlDocPtr doc);
734: void xmlSetListDoc (xmlNodePtr list,
735: xmlDocPtr doc);
736:
737: /*
738: * Namespaces.
739: */
740: xmlNsPtr xmlSearchNs (xmlDocPtr doc,
741: xmlNodePtr node,
742: const xmlChar *nameSpace);
743: xmlNsPtr xmlSearchNsByHref (xmlDocPtr doc,
744: xmlNodePtr node,
745: const xmlChar *href);
746: xmlNsPtr * xmlGetNsList (xmlDocPtr doc,
747: xmlNodePtr node);
748: void xmlSetNs (xmlNodePtr node,
749: xmlNsPtr ns);
750: xmlNsPtr xmlCopyNamespace (xmlNsPtr cur);
751: xmlNsPtr xmlCopyNamespaceList (xmlNsPtr cur);
752:
753: /*
754: * Changing the content.
755: */
756: xmlAttrPtr xmlSetProp (xmlNodePtr node,
757: const xmlChar *name,
758: const xmlChar *value);
759: xmlChar * xmlGetProp (xmlNodePtr node,
760: const xmlChar *name);
761: xmlChar * xmlGetNoNsProp (xmlNodePtr node,
762: const xmlChar *name);
763: xmlAttrPtr xmlHasProp (xmlNodePtr node,
764: const xmlChar *name);
765: xmlAttrPtr xmlHasNsProp (xmlNodePtr node,
766: const xmlChar *name,
767: const xmlChar *nameSpace);
768: xmlAttrPtr xmlSetNsProp (xmlNodePtr node,
769: xmlNsPtr ns,
770: const xmlChar *name,
771: const xmlChar *value);
772: xmlChar * xmlGetNsProp (xmlNodePtr node,
773: const xmlChar *name,
774: const xmlChar *nameSpace);
775: xmlNodePtr xmlStringGetNodeList (xmlDocPtr doc,
776: const xmlChar *value);
777: xmlNodePtr xmlStringLenGetNodeList (xmlDocPtr doc,
778: const xmlChar *value,
779: int len);
780: xmlChar * xmlNodeListGetString (xmlDocPtr doc,
781: xmlNodePtr list,
782: int inLine);
783: xmlChar * xmlNodeListGetRawString (xmlDocPtr doc,
784: xmlNodePtr list,
785: int inLine);
786: void xmlNodeSetContent (xmlNodePtr cur,
787: const xmlChar *content);
788: void xmlNodeSetContentLen (xmlNodePtr cur,
789: const xmlChar *content,
790: int len);
791: void xmlNodeAddContent (xmlNodePtr cur,
792: const xmlChar *content);
793: void xmlNodeAddContentLen (xmlNodePtr cur,
794: const xmlChar *content,
795: int len);
796: xmlChar * xmlNodeGetContent (xmlNodePtr cur);
797: xmlChar * xmlNodeGetLang (xmlNodePtr cur);
798: void xmlNodeSetLang (xmlNodePtr cur,
799: const xmlChar *lang);
800: int xmlNodeGetSpacePreserve (xmlNodePtr cur);
801: void xmlNodeSetSpacePreserve (xmlNodePtr cur,
802: int val);
803: xmlChar * xmlNodeGetBase (xmlDocPtr doc,
804: xmlNodePtr cur);
805: void xmlNodeSetBase (xmlNodePtr cur,
806: xmlChar *uri);
807:
808: /*
809: * Removing content.
810: */
811: int xmlRemoveProp (xmlAttrPtr cur);
812: int xmlUnsetProp (xmlNodePtr node,
813: const xmlChar *name);
814: int xmlUnsetNsProp (xmlNodePtr node,
815: xmlNsPtr ns,
816: const xmlChar *name);
817:
818: /*
819: * Internal, don't use.
820: */
821: void xmlBufferWriteCHAR (xmlBufferPtr buf,
822: const xmlChar *string);
823: void xmlBufferWriteChar (xmlBufferPtr buf,
824: const char *string);
825: void xmlBufferWriteQuotedString(xmlBufferPtr buf,
826: const xmlChar *string);
827:
828: /*
829: * Namespace handling.
830: */
831: int xmlReconciliateNs (xmlDocPtr doc,
832: xmlNodePtr tree);
833:
834: /*
835: * Saving.
836: */
837: void xmlDocDumpFormatMemory (xmlDocPtr cur,
838: xmlChar **mem,
839: int *size,
840: int format);
841: void xmlDocDumpMemory (xmlDocPtr cur,
842: xmlChar **mem,
843: int *size);
844: void xmlDocDumpMemoryEnc (xmlDocPtr out_doc,
845: xmlChar **doc_txt_ptr,
846: int * doc_txt_len,
847: const char *txt_encoding);
848: void xmlDocDumpFormatMemoryEnc(xmlDocPtr out_doc,
849: xmlChar **doc_txt_ptr,
850: int * doc_txt_len,
851: const char *txt_encoding,
852: int format);
853: int xmlDocFormatDump(FILE *f,
854: xmlDocPtr cur,
855: int format);
856: int xmlDocDump (FILE *f,
857: xmlDocPtr cur);
858: void xmlElemDump (FILE *f,
859: xmlDocPtr doc,
860: xmlNodePtr cur);
861: int xmlSaveFile (const char *filename,
862: xmlDocPtr cur);
863: int xmlSaveFormatFile (const char *filename,
864: xmlDocPtr cur,
865: int format);
866: int xmlNodeDump (xmlBufferPtr buf,
867: xmlDocPtr doc,
868: xmlNodePtr cur,
869: int level,
870: int format);
871:
872: int xmlSaveFileTo (xmlOutputBufferPtr buf,
873: xmlDocPtr cur,
874: const char *encoding);
875: int xmlSaveFormatFileTo (xmlOutputBufferPtr buf,
876: xmlDocPtr cur,
877: const char *encoding,
878: int format);
879: void xmlNodeDumpOutput (xmlOutputBufferPtr buf,
880: xmlDocPtr doc,
881: xmlNodePtr cur,
882: int level,
883: int format,
884: const char *encoding);
885:
886: int xmlSaveFormatFileEnc (const char *filename,
887: xmlDocPtr cur,
888: const char *encoding,
889: int format);
890:
891: int xmlSaveFileEnc (const char *filename,
892: xmlDocPtr cur,
893: const char *encoding);
894:
895: /*
896: * XHTML
897: */
898: int xmlIsXHTML (const xmlChar *systemID,
899: const xmlChar *publicID);
900:
901: /*
902: * Compression.
903: */
904: int xmlGetDocCompressMode (xmlDocPtr doc);
905: void xmlSetDocCompressMode (xmlDocPtr doc,
906: int mode);
907: int xmlGetCompressMode (void);
908: void xmlSetCompressMode (int mode);
909:
910: #ifdef __cplusplus
911: }
912: #endif
913: #ifndef __XML_PARSER_H__
914: #include <libxml/xmlmemory.h>
915: #endif
916:
917: #endif /* __XML_TREE_H__ */
918: