← Back to branch summary

~armagetronad-dev/armagetronad/0.2.9-winlibs-work

« back to all changes in this revision

Viewing changes to libxml2/include/libxml/tree.h

  • Committer: luke-jr
  • Date: 2006-05-29 01:55:42 UTC
  • Revision ID: svn-v3-list-QlpoOTFBWSZTWZvbKhsAAAdRgAAQABK6798QIABURMgAAaeoNT1TxT1DQbKaeobXKiyAmlWT7Y5MkdJOtXDtB7w7DOGFBHiOBxaUIu7HQyyQSvxdyRThQkJvbKhs:7d95bf1e-0414-0410-9756-b78462a59f44:armagetronad%2Fbranches%2F0.2.8%2Fwinlibs:4612
Unify tags/branches of modules released together

Show diffs side-by-side

added added

removed removed

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