1.1 --- /dev/null Thu Jan 01 00:00:00 1970 +0000
1.2 +++ b/epoc32/include/stdapis/libxml2/libxml2_tree.h Wed Mar 31 12:33:34 2010 +0100
1.3 @@ -0,0 +1,1106 @@
1.4 +/*
1.5 + * Summary: interfaces for tree manipulation
1.6 + * Description: this module describes the structures found in an tree resulting
1.7 + * from an XML or HTML parsing, as well as the API provided for
1.8 + * various processing on that tree
1.9 + *
1.10 + * Copy: See Copyright for the status of this software.
1.11 + *
1.12 + * Author: Daniel Veillard
1.13 + * Portion Copyright © 2009 Nokia Corporation and/or its subsidiary(-ies). All rights reserved.
1.14 + */
1.15 +
1.16 +/** @file
1.17 +@publishedAll
1.18 +@released
1.19 +*/
1.20 +
1.21 +#ifndef XML_TREE_H
1.22 +#define XML_TREE_H
1.23 +
1.24 +#include <stdapis/libxml2/libxml2_xmlstring.h>
1.25 +
1.26 +#include <stdlib.h>
1.27 +#include <stdio.h>
1.28 +
1.29 +#ifdef LIBXML_REGEXP_ENABLED
1.30 +#include "libxml2_xmlregexp.h"
1.31 +#endif
1.32 +
1.33 +#ifdef __cplusplus
1.34 +extern "C" {
1.35 +#endif
1.36 +
1.37 +/*
1.38 + * Some of the basic types pointer to structures:
1.39 + */
1.40 +/* xmlIO.h */
1.41 +typedef struct _xmlParserInputBuffer xmlParserInputBuffer;
1.42 +typedef xmlParserInputBuffer *xmlParserInputBufferPtr;
1.43 +
1.44 +typedef struct _xmlOutputBuffer xmlOutputBuffer;
1.45 +typedef xmlOutputBuffer *xmlOutputBufferPtr;
1.46 +
1.47 +/* parser.h */
1.48 +
1.49 +
1.50 +typedef struct _xmlParserCtxt xmlParserCtxt;
1.51 +typedef xmlParserCtxt *xmlParserCtxtPtr;
1.52 +
1.53 +typedef struct _xmlSAXLocator xmlSAXLocator;
1.54 +typedef xmlSAXLocator *xmlSAXLocatorPtr;
1.55 +
1.56 +typedef struct _xmlSAXHandler xmlSAXHandler;
1.57 +typedef xmlSAXHandler *xmlSAXHandlerPtr;
1.58 +
1.59 +/* entities.h */
1.60 +typedef struct _xmlEntity xmlEntity;
1.61 +typedef xmlEntity *xmlEntityPtr;
1.62 +
1.63 +/**
1.64 + * BASE_BUFFER_SIZE:
1.65 + *
1.66 + * default buffer size 4000.
1.67 + */
1.68 +#define BASE_BUFFER_SIZE 4096
1.69 +
1.70 +
1.71 +// BUT! remember that it is checked in #ifdef's
1.72 +/**
1.73 + * XML_XML_NAMESPACE:
1.74 + *
1.75 + * This is the namespace for the special xml: prefix predefined in the
1.76 + * XML Namespace specification.
1.77 + */
1.78 +#define XML_XML_NAMESPACE \
1.79 + (const xmlChar *) "http://www.w3.org/XML/1998/namespace"
1.80 +
1.81 +/**
1.82 + * XML_XML_ID:
1.83 + *
1.84 + * This is the name for the special xml:id attribute
1.85 + */
1.86 +#define XML_XML_ID (const xmlChar *) "xml:id"
1.87 +
1.88 +/*
1.89 + * The different element types carried by an XML tree.
1.90 + *
1.91 + * NOTE: This is synchronized with DOM Level1 values
1.92 + * See http://www.w3.org/TR/REC-DOM-Level-1/
1.93 + *
1.94 + * Actually this had diverged a bit, and now XML_DOCUMENT_TYPE_NODE should
1.95 + * be deprecated to use an XML_DTD_NODE.
1.96 + */
1.97 +typedef enum {
1.98 + XML_ELEMENT_NODE= 1,
1.99 + XML_ATTRIBUTE_NODE= 2,
1.100 + XML_TEXT_NODE= 3,
1.101 + XML_CDATA_SECTION_NODE= 4,
1.102 + XML_ENTITY_REF_NODE= 5,
1.103 + XML_ENTITY_NODE= 6,
1.104 + XML_PI_NODE= 7,
1.105 + XML_COMMENT_NODE= 8,
1.106 + XML_DOCUMENT_NODE= 9,
1.107 + XML_DOCUMENT_TYPE_NODE= 10,
1.108 + XML_DOCUMENT_FRAG_NODE= 11,
1.109 + XML_NOTATION_NODE= 12,
1.110 + XML_HTML_DOCUMENT_NODE= 13,
1.111 + XML_DTD_NODE= 14,
1.112 + XML_ELEMENT_DECL= 15,
1.113 + XML_ATTRIBUTE_DECL= 16,
1.114 + XML_ENTITY_DECL= 17,
1.115 + XML_NAMESPACE_DECL= 18,
1.116 + XML_XINCLUDE_START= 19,
1.117 + XML_XINCLUDE_END= 20
1.118 +//#ifdef LIBXML_DOCB_ENABLED
1.119 +// ,XML_DOCB_DOCUMENT_NODE= 21 //DocBook support is excluded from XML Engine
1.120 +//#endif
1.121 +} xmlElementType;
1.122 +
1.123 +
1.124 +/**
1.125 + * xmlNotation:
1.126 + *
1.127 + * A DTD Notation definition.
1.128 + */
1.129 +
1.130 +typedef struct _xmlNotation xmlNotation;
1.131 +typedef xmlNotation *xmlNotationPtr;
1.132 +struct _xmlNotation {
1.133 + const xmlChar *name; /* Notation name */
1.134 + const xmlChar *PublicID; /* Public identifier, if any */
1.135 + const xmlChar *SystemID; /* System identifier, if any */
1.136 +};
1.137 +
1.138 +/**
1.139 + * xmlAttributeType:
1.140 + *
1.141 + * A DTD Attribute type definition.
1.142 + */
1.143 +
1.144 +typedef enum {
1.145 + XML_ATTRIBUTE_CDATA = 1,
1.146 + XML_ATTRIBUTE_ID,
1.147 + XML_ATTRIBUTE_IDREF ,
1.148 + XML_ATTRIBUTE_IDREFS,
1.149 + XML_ATTRIBUTE_ENTITY,
1.150 + XML_ATTRIBUTE_ENTITIES,
1.151 + XML_ATTRIBUTE_NMTOKEN,
1.152 + XML_ATTRIBUTE_NMTOKENS,
1.153 + XML_ATTRIBUTE_ENUMERATION,
1.154 + XML_ATTRIBUTE_NOTATION
1.155 +} xmlAttributeType;
1.156 +
1.157 +/**
1.158 + * xmlAttributeDefault:
1.159 + *
1.160 + * A DTD Attribute default definition.
1.161 + */
1.162 +
1.163 +typedef enum {
1.164 + XML_ATTRIBUTE_NONE = 1,
1.165 + XML_ATTRIBUTE_REQUIRED,
1.166 + XML_ATTRIBUTE_IMPLIED,
1.167 + XML_ATTRIBUTE_FIXED
1.168 +} xmlAttributeDefault;
1.169 +
1.170 +/**
1.171 + * xmlEnumeration:
1.172 + *
1.173 + * List structure used when there is an enumeration in DTDs.
1.174 + */
1.175 +
1.176 +typedef struct _xmlEnumeration xmlEnumeration;
1.177 +typedef xmlEnumeration *xmlEnumerationPtr;
1.178 +struct _xmlEnumeration {
1.179 + struct _xmlEnumeration *next; /* next one */
1.180 + const xmlChar *name; /* Enumeration name */
1.181 +};
1.182 +
1.183 +/**
1.184 + * xmlAttribute:
1.185 + *
1.186 + * An Attribute declaration in a DTD.
1.187 + */
1.188 +
1.189 +typedef struct _xmlAttribute xmlAttribute;
1.190 +typedef xmlAttribute *xmlAttributePtr;
1.191 +struct _xmlAttribute {
1.192 + void *_private; /* application data */
1.193 + xmlElementType type; /* XML_ATTRIBUTE_DECL, must be second ! */
1.194 + const xmlChar *name; /* Attribute name */
1.195 + struct _xmlNode *children; /* NULL */
1.196 + struct _xmlNode *last; /* NULL */
1.197 + struct _xmlDtd *parent; /* -> DTD */
1.198 + struct _xmlNode *next; /* next sibling link */
1.199 + struct _xmlNode *prev; /* previous sibling link */
1.200 + struct _xmlDoc *doc; /* the containing document */
1.201 +
1.202 + struct _xmlAttribute *nexth; /* next in hash table */
1.203 + xmlAttributeType atype; /* The attribute type */
1.204 + xmlAttributeDefault def; /* the default */
1.205 + const xmlChar *defaultValue; /* or the default value */
1.206 + xmlEnumerationPtr tree; /* or the enumeration tree if any */
1.207 + const xmlChar *prefix; /* the namespace prefix if any */
1.208 + const xmlChar *elem; /* Element holding the attribute */
1.209 +};
1.210 +
1.211 +/**
1.212 + * xmlElementContentType:
1.213 + *
1.214 + * Possible definitions of element content types.
1.215 + */
1.216 +typedef enum {
1.217 + XML_ELEMENT_CONTENT_PCDATA = 1,
1.218 + XML_ELEMENT_CONTENT_ELEMENT,
1.219 + XML_ELEMENT_CONTENT_SEQ,
1.220 + XML_ELEMENT_CONTENT_OR
1.221 +} xmlElementContentType;
1.222 +
1.223 +/**
1.224 + * xmlElementContentOccur:
1.225 + *
1.226 + * Possible definitions of element content occurrences.
1.227 + */
1.228 +typedef enum {
1.229 + XML_ELEMENT_CONTENT_ONCE = 1,
1.230 + XML_ELEMENT_CONTENT_OPT,
1.231 + XML_ELEMENT_CONTENT_MULT,
1.232 + XML_ELEMENT_CONTENT_PLUS
1.233 +} xmlElementContentOccur;
1.234 +
1.235 +/**
1.236 + * xmlElementContent:
1.237 + *
1.238 + * An XML Element content as stored after parsing an element definition
1.239 + * in a DTD.
1.240 + */
1.241 +
1.242 +typedef struct _xmlElementContent xmlElementContent;
1.243 +typedef xmlElementContent *xmlElementContentPtr;
1.244 +struct _xmlElementContent {
1.245 + xmlElementContentType type; /* PCDATA, ELEMENT, SEQ or OR */
1.246 + xmlElementContentOccur ocur; /* ONCE, OPT, MULT or PLUS */
1.247 + const xmlChar *name; /* Element name */
1.248 + struct _xmlElementContent *c1; /* first child */
1.249 + struct _xmlElementContent *c2; /* second child */
1.250 + struct _xmlElementContent *parent; /* parent */
1.251 + const xmlChar *prefix; /* Namespace prefix */
1.252 +};
1.253 +
1.254 +/**
1.255 + * xmlElementTypeVal:
1.256 + *
1.257 + * The different possibilities for an element content type.
1.258 + */
1.259 +
1.260 +typedef enum {
1.261 + XML_ELEMENT_TYPE_UNDEFINED = 0,
1.262 + XML_ELEMENT_TYPE_EMPTY = 1,
1.263 + XML_ELEMENT_TYPE_ANY,
1.264 + XML_ELEMENT_TYPE_MIXED,
1.265 + XML_ELEMENT_TYPE_ELEMENT
1.266 +} xmlElementTypeVal;
1.267 +
1.268 +
1.269 +//#ifdef __cplusplus
1.270 +//}
1.271 +//#endif
1.272 +//#ifdef __cplusplus
1.273 +//extern "C" {
1.274 +//#endif
1.275 +
1.276 +/**
1.277 + * xmlElement:
1.278 + *
1.279 + * An XML Element declaration from a DTD.
1.280 + */
1.281 +
1.282 +typedef struct _xmlElement xmlElement;
1.283 +typedef xmlElement *xmlElementPtr;
1.284 +struct _xmlElement {
1.285 + void *_private; /* application data */
1.286 + xmlElementType type; /* XML_ELEMENT_DECL, must be second ! */
1.287 + const xmlChar *name; /* Element name */
1.288 + struct _xmlNode *children; /* NULL */
1.289 + struct _xmlNode *last; /* NULL */
1.290 + struct _xmlDtd *parent; /* -> DTD */
1.291 + struct _xmlNode *next; /* next sibling link */
1.292 + struct _xmlNode *prev; /* previous sibling link */
1.293 + struct _xmlDoc *doc; /* the containing document */
1.294 +
1.295 + xmlElementTypeVal etype; /* The type */
1.296 + xmlElementContentPtr content; /* the allowed element content */
1.297 + xmlAttributePtr attributes; /* List of the declared attributes */
1.298 + const xmlChar *prefix; /* the namespace prefix if any */
1.299 +#ifdef LIBXML_REGEXP_ENABLED
1.300 + xmlRegexpPtr contModel; /* the validating regexp */
1.301 +#else
1.302 + void* contModel;
1.303 +#endif
1.304 +};
1.305 +
1.306 +
1.307 +/**
1.308 + * XML_LOCAL_NAMESPACE:
1.309 + *
1.310 + * A namespace declaration node.
1.311 + */
1.312 +#define XML_LOCAL_NAMESPACE XML_NAMESPACE_DECL
1.313 +typedef xmlElementType xmlNsType;
1.314 +
1.315 +/**
1.316 + * xmlNs:
1.317 + *
1.318 + * An XML namespace.
1.319 + * Note that prefix == NULL is valid, it defines the default namespace
1.320 + * within the subtree (until overridden).
1.321 + *
1.322 + * xmlNsType is unified with xmlElementType.
1.323 + */
1.324 +
1.325 +typedef struct _xmlNs xmlNs;
1.326 +typedef xmlNs *xmlNsPtr;
1.327 +struct _xmlNs {
1.328 + struct _xmlNs *next; /* next Ns link for this node */
1.329 + xmlNsType type; /* global or local */
1.330 + const xmlChar *href; /* URL for the namespace */
1.331 + const xmlChar *prefix; /* prefix for the namespace */
1.332 + void *_private; /* application data */
1.333 +};
1.334 +
1.335 +/**
1.336 + * xmlDtd:
1.337 + *
1.338 + * An XML DTD, as defined by <!DOCTYPE ... There is actually one for
1.339 + * the internal subset and for the external subset.
1.340 + */
1.341 +typedef struct _xmlDtd xmlDtd;
1.342 +typedef xmlDtd *xmlDtdPtr;
1.343 +struct _xmlDtd {
1.344 + void *_private; /* application data */
1.345 + xmlElementType type; /* XML_DTD_NODE, must be second ! */
1.346 + const xmlChar *name; /* Name of the DTD */
1.347 + struct _xmlNode *children; /* the value of the property link */
1.348 + struct _xmlNode *last; /* last child link */
1.349 + struct _xmlDoc *parent; /* child->parent link */
1.350 + struct _xmlNode *next; /* next sibling link */
1.351 + struct _xmlNode *prev; /* previous sibling link */
1.352 + struct _xmlDoc *doc; /* the containing document */
1.353 +
1.354 + /* End of common part */
1.355 + void *notations; /* Hash table for notations if any */
1.356 + void *elements; /* Hash table for elements if any */
1.357 + void *attributes; /* Hash table for attributes if any */
1.358 + void *entities; /* Hash table for entities if any */
1.359 + const xmlChar *ExternalID; /* External identifier for PUBLIC DTD */
1.360 + const xmlChar *SystemID; /* URI for a SYSTEM or PUBLIC DTD */
1.361 + void *pentities; /* Hash table for param entities if any */
1.362 +};
1.363 +
1.364 +/**
1.365 + * xmlAttr:
1.366 + *
1.367 + * An attribute on an XML node.
1.368 + */
1.369 +typedef struct _xmlAttr xmlAttr;
1.370 +typedef xmlAttr *xmlAttrPtr;
1.371 +struct _xmlAttr {
1.372 + void *_private; /* application data */
1.373 + xmlElementType type; /* XML_ATTRIBUTE_NODE, must be second ! */
1.374 + const xmlChar *name; /* the name of the property */
1.375 + struct _xmlNode *children; /* the value of the property */
1.376 + struct _xmlNode *last; /* NULL */
1.377 + struct _xmlNode *parent; /* child->parent link */
1.378 + struct _xmlAttr *next; /* next sibling link */
1.379 + struct _xmlAttr *prev; /* previous sibling link */
1.380 + struct _xmlDoc *doc; /* the containing document */
1.381 + /* End of common part */
1.382 + xmlNs *ns; /* pointer to the associated namespace */
1.383 + xmlAttributeType atype; /* the attribute type if validating */
1.384 + void *psvi; /* for type/PSVI informations */
1.385 +};
1.386 +
1.387 +/**
1.388 + * xmlID:
1.389 + *
1.390 + * An XML ID instance.
1.391 + */
1.392 +
1.393 +typedef struct _xmlID xmlID;
1.394 +typedef xmlID* xmlIDPtr;
1.395 +struct _xmlID {
1.396 + xmlIDPtr next; /* next ID */
1.397 + const xmlChar* value; /* The ID name */
1.398 + xmlAttrPtr attr; /* The attribute holding it */
1.399 + const xmlChar* name; /* The attribute if attr is not available */
1.400 + struct _xmlDoc* doc; /* The document holding the ID */
1.401 +#ifdef LIBXML_ENABLE_NODE_LINEINFO
1.402 + int lineno; /* The line number if attr is not available */
1.403 +#endif
1.404 +};
1.405 +
1.406 +/**
1.407 + * xmlRef:
1.408 + *
1.409 + * An XML IDREF instance.
1.410 + */
1.411 +
1.412 +typedef struct _xmlRef xmlRef;
1.413 +typedef xmlRef* xmlRefPtr;
1.414 +struct _xmlRef {
1.415 + xmlRefPtr next; /* next Ref */
1.416 + const xmlChar* value; /* The Ref name */
1.417 + xmlAttrPtr attr; /* The attribute holding it */
1.418 + const xmlChar* name; /* The attribute if attr is not available */
1.419 +#ifdef LIBXML_ENABLE_NODE_LINEINFO
1.420 + int lineno; /* The line number if attr is not available */
1.421 +#endif
1.422 +};
1.423 +
1.424 +/**
1.425 + * xmlBufferAllocationScheme:
1.426 + *
1.427 + * A buffer allocation scheme can be defined to either match exactly the
1.428 + * need or double it's allocated size each time it is found too small.
1.429 + */
1.430 +
1.431 +typedef enum {
1.432 + XML_BUFFER_ALLOC_DOUBLEIT,
1.433 + XML_BUFFER_ALLOC_EXACT,
1.434 + XML_BUFFER_ALLOC_IMMUTABLE
1.435 +} xmlBufferAllocationScheme;
1.436 +
1.437 +/**
1.438 + * xmlBuffer:
1.439 + *
1.440 + * A buffer structure.
1.441 + */
1.442 +typedef struct _xmlBuffer xmlBuffer;
1.443 +typedef xmlBuffer* xmlBufferPtr;
1.444 +struct _xmlBuffer {
1.445 + xmlChar* content; /* The buffer content UTF8 */
1.446 + unsigned int use; /* The buffer size used */
1.447 + unsigned int size; /* The buffer size */
1.448 + xmlBufferAllocationScheme alloc; /* The realloc method */
1.449 +};
1.450 +
1.451 +/**
1.452 + * xmlNode:
1.453 + *
1.454 + * A node in an XML tree.
1.455 + *
1.456 + * Note:
1.457 + * Text nodes are also used to store binary data in the tree.
1.458 + * 'content' field is used to store a pointer to binary data
1.459 + * 'properties' field is used to store int length of the data
1.460 + *
1.461 + */
1.462 +typedef struct _xmlNode xmlNode;
1.463 +typedef xmlNode* xmlNodePtr;
1.464 +struct _xmlNode {
1.465 + void* _private; /* application data */
1.466 + xmlElementType type; /* type number, must be second ! */
1.467 + const xmlChar* name; /* the name of the node, or the entity */
1.468 + xmlNodePtr children; /* parent->childs link */
1.469 + xmlNodePtr last; /* last child link */
1.470 + xmlNodePtr parent; /* child->parent link */
1.471 + xmlNodePtr next; /* next sibling link */
1.472 + xmlNodePtr prev; /* previous sibling link */
1.473 + struct _xmlDoc* doc; /* the containing document */
1.474 + /* End of common part */
1.475 + xmlNs *ns; /* pointer to the associated namespace */
1.476 + xmlChar *content; /* the content */
1.477 + struct _xmlAttr *properties;/* properties list */
1.478 + xmlNs *nsDef; /* namespace definitions on this node */
1.479 + void *psvi; /* for type/PSVI informations */
1.480 + unsigned short extra; /* extra data for XPath/XSLT */
1.481 +#ifdef LIBXML_ENABLE_NODE_LINEINFO
1.482 + unsigned short line; /* line number */
1.483 +#endif
1.484 +};
1.485 +
1.486 +/**
1.487 + * XML_GET_CONTENT:
1.488 + *
1.489 + * Macro to extract the content pointer of a node.
1.490 + */
1.491 +#define XML_GET_CONTENT(n) \
1.492 + ((n)->type == XML_ELEMENT_NODE ? NULL : (n)->content)
1.493 +
1.494 +
1.495 +
1.496 +#ifdef LIBXML_ENABLE_NODE_LINEINFO
1.497 +/**
1.498 + * XML_GET_LINE:
1.499 + *
1.500 + * Macro to extract the line number of an element node.
1.501 + */
1.502 +#define XML_GET_LINE(n) (xmlGetLineNo(n))
1.503 +#endif /* LIBXML_ENABLE_NODE_LINEINFO */
1.504 +
1.505 +/**
1.506 + * xmlDoc:
1.507 + *
1.508 + * An XML document.
1.509 + */
1.510 +typedef struct _xmlDoc xmlDoc;
1.511 +typedef xmlDoc* xmlDocPtr;
1.512 +struct _xmlDoc {
1.513 + void *_private; /* application data */
1.514 + xmlElementType type; /* XML_DOCUMENT_NODE, must be second ! */
1.515 + char *name; /* name/filename/URI of the document */
1.516 + struct _xmlNode *children; /* the document tree */
1.517 + struct _xmlNode *last; /* last child link */
1.518 + struct _xmlNode *parent; /* child->parent link */
1.519 + struct _xmlNode *next; /* next sibling link */
1.520 + struct _xmlNode *prev; /* previous sibling link */
1.521 + struct _xmlDoc *doc; /* autoreference to itself */
1.522 + /* End of common part */
1.523 +
1.524 + /* dummy fields to avoid incorrect use of xmlDoc as xmlNode
1.525 + currently, always NULL; reserved.
1.526 +
1.527 + Added to prevent potential problems of same kind in the future.
1.528 + */
1.529 + void* _reserved1; /* ~ xmlNode.ns */
1.530 + void* _reserved2; /* ~ xmlNode.content */
1.531 + void* _reserved3; /* ~ xmlNode.properties */
1.532 + void* _reserved4; /* ~ xmlNode.nsDef */
1.533 + /* End of 2nd (extra) common part (same as xmlNode) */
1.534 +
1.535 +#ifdef LIBXML_ENABLE_GS_CACHING_IN_DOC
1.536 + void* cachedGs; /* cached value returned by xmlGetGlobalState() */
1.537 +#endif
1.538 + int compression;/* level of zlib compression */
1.539 + int standalone; /* standalone document (no external refs) */
1.540 + struct _xmlDtd *intSubset; /* the document internal subset */
1.541 + struct _xmlDtd *extSubset; /* the document external subset */
1.542 + struct _xmlNs *oldNs; /* Global namespace, the old way */
1.543 + const xmlChar *version; /* the XML version string */
1.544 + const xmlChar *encoding; /* external initial encoding, if any */
1.545 + void *ids; /* Hash table for ID attributes if any */
1.546 + void *refs; /* Hash table for IDREFs attributes if any */
1.547 + const xmlChar *URL; /* The URI for that document */
1.548 + int charset; /* encoding of the in-memory content
1.549 + actually an xmlCharEncoding */
1.550 + struct _xmlDict *dict; /* dict used to allocate names or NULL */
1.551 + void *psvi; /* for type/PSVI informations */
1.552 +//XMLENGINE: NEW CODE
1.553 + /*
1.554 + A container for nodes that were created as nodes of this document but
1.555 + are not linked into the document yet
1.556 + NOTE: this field is used by DOM C++ API only (not in libxml2 functions)
1.557 + */
1.558 + void* ownedNodes;
1.559 + /*
1.560 + * Container for nodes that store external data references
1.561 + */
1.562 + xmlNodePtr* dataNodeList; /* array of data nodes */
1.563 + int dataNodeMax; /* maximum number of data nodes in the array */
1.564 +//
1.565 +};
1.566 +
1.567 +/*
1.568 + * Variables.
1.569 + */
1.570 +
1.571 +/*
1.572 + * Some helper functions
1.573 + */
1.574 +XMLPUBFUN int XMLCALL xmlValidateNCName (const xmlChar* value, int space);
1.575 +XMLPUBFUN int XMLCALL xmlValidateQName (const xmlChar* value, int space);
1.576 +XMLPUBFUN int XMLCALL xmlValidateName (const xmlChar* value, int space);
1.577 +XMLPUBFUN int XMLCALL xmlValidateNMToken(const xmlChar* value, int space);
1.578 +
1.579 +XMLPUBFUN xmlChar* XMLCALL
1.580 + xmlBuildQName (const xmlChar *ncname, const xmlChar *prefix,
1.581 + xmlChar *memory, int len);
1.582 +XMLPUBFUN xmlChar* XMLCALL
1.583 + xmlSplitQName2 (const xmlChar *name, xmlChar **prefix);
1.584 +XMLPUBFUN const xmlChar* XMLCALL
1.585 + xmlSplitQName3 (const xmlChar *name, int *len);
1.586 +
1.587 +/*
1.588 + * Handling Buffers.
1.589 + */
1.590 +
1.591 +XMLPUBFUN void XMLCALL
1.592 + xmlSetBufferAllocationScheme(xmlBufferAllocationScheme scheme);
1.593 +
1.594 +#ifndef XMLENGINE_EXCLUDE_UNUSED
1.595 +XMLPUBFUN xmlBufferAllocationScheme XMLCALL
1.596 + xmlGetBufferAllocationScheme(void);
1.597 +#endif /* ifndef XMLENGINE_EXCLUDE_UNUSED */
1.598 +
1.599 +XMLPUBFUN xmlBufferPtr XMLCALL
1.600 + xmlBufferCreate (void);
1.601 +XMLPUBFUN xmlBufferPtr XMLCALL
1.602 + xmlBufferCreateSize (size_t size);
1.603 +XMLPUBFUN xmlBufferPtr XMLCALL
1.604 + xmlBufferCreateStatic (void *mem, size_t size);
1.605 +XMLPUBFUN int XMLCALL
1.606 + xmlBufferResize (xmlBufferPtr buf, unsigned int size);
1.607 +XMLPUBFUN void XMLCALL
1.608 + xmlBufferFree (xmlBufferPtr buf);
1.609 +
1.610 +#ifndef XMLENGINE_EXCLUDE_FILE_FUNC
1.611 +XMLPUBFUN int XMLCALL
1.612 + xmlBufferDump (FILE *file, xmlBufferPtr buf);
1.613 +#endif
1.614 +
1.615 +XMLPUBFUN void XMLCALL
1.616 + xmlBufferAdd (xmlBufferPtr buf, const xmlChar *str, int len);
1.617 +XMLPUBFUN void XMLCALL
1.618 + xmlBufferAddHead (xmlBufferPtr buf, const xmlChar *str, int len);
1.619 +XMLPUBFUN void XMLCALL
1.620 + xmlBufferCat (xmlBufferPtr buf, const xmlChar *str);
1.621 +XMLPUBFUN void XMLCALL
1.622 + xmlBufferCCat (xmlBufferPtr buf, const char *str);
1.623 +XMLPUBFUN int XMLCALL
1.624 + xmlBufferShrink (xmlBufferPtr buf, unsigned int len);
1.625 +XMLPUBFUN int XMLCALL
1.626 + xmlBufferGrow (xmlBufferPtr buf, unsigned int len);
1.627 +
1.628 +#ifndef XMLENGINE_EXCLUDE_UNUSED
1.629 +XMLPUBFUN void XMLCALL xmlBufferEmpty (xmlBufferPtr buf);
1.630 +XMLPUBFUN void XMLCALL xmlBufferSetAllocationScheme(xmlBufferPtr buf, xmlBufferAllocationScheme scheme);
1.631 +#endif
1.632 +
1.633 +XMLPUBFUN int XMLCALL xmlBufferLength (const xmlBufferPtr buf);
1.634 +
1.635 +// XMLENGINE: BEGIN NEW CODE
1.636 +/**
1.637 + * xmlBufferContent:
1.638 + * @param buf the buffer
1.639 + *
1.640 + * Function to extract the content of a buffer
1.641 + *
1.642 + * Returns the internal content
1.643 + */
1.644 +#define xmlBufferContent(buf) ((buf)? (buf)->content : NULL)
1.645 +// XMLENGINE: END NEW CODE
1.646 +
1.647 +// DONE: OPTIMIZE: replaced by MACRO
1.648 +// XMLPUBFUN const xmlChar* XMLCALL
1.649 +// xmlBufferContent (const xmlBufferPtr buf);
1.650 +
1.651 +/*
1.652 + * Creating/freeing new structures.
1.653 + */
1.654 +
1.655 +XMLPUBFUN xmlDtdPtr XMLCALL
1.656 + xmlCreateIntSubset (xmlDocPtr doc,
1.657 + const xmlChar *name,
1.658 + const xmlChar *ExternalID,
1.659 + const xmlChar *SystemID);
1.660 +XMLPUBFUN xmlDtdPtr XMLCALL
1.661 + xmlNewDtd (xmlDocPtr doc,
1.662 + const xmlChar *name,
1.663 + const xmlChar *ExternalID,
1.664 + const xmlChar *SystemID);
1.665 +XMLPUBFUN xmlDtdPtr XMLCALL
1.666 + xmlGetIntSubset (xmlDocPtr doc);
1.667 +XMLPUBFUN void XMLCALL
1.668 + xmlFreeDtd (xmlDtdPtr cur);
1.669 +XMLPUBFUN xmlNsPtr XMLCALL
1.670 + xmlNewGlobalNs (xmlDocPtr doc,
1.671 + const xmlChar *href,
1.672 + const xmlChar *prefix);
1.673 +XMLPUBFUN xmlNsPtr XMLCALL
1.674 + xmlNewNs (xmlNodePtr node,
1.675 + const xmlChar *href,
1.676 + const xmlChar *prefix);
1.677 +XMLPUBFUN void XMLCALL
1.678 + xmlFreeNs (xmlNsPtr cur);
1.679 +XMLPUBFUN void XMLCALL
1.680 + xmlFreeNsList (xmlNsPtr cur);
1.681 +XMLPUBFUN xmlDocPtr XMLCALL
1.682 + xmlNewDoc (const xmlChar *version);
1.683 +XMLPUBFUN void XMLCALL
1.684 + xmlFreeDoc (xmlDocPtr cur);
1.685 +XMLPUBFUN xmlAttrPtr XMLCALL
1.686 + xmlNewDocProp (xmlDocPtr doc,
1.687 + const xmlChar *name,
1.688 + const xmlChar *value);
1.689 +XMLPUBFUN xmlAttrPtr XMLCALL
1.690 + xmlNewProp (xmlNodePtr node,
1.691 + const xmlChar *name,
1.692 + const xmlChar *value);
1.693 +XMLPUBFUN xmlAttrPtr XMLCALL
1.694 + xmlNewNsProp (xmlNodePtr node,
1.695 + xmlNsPtr ns,
1.696 + const xmlChar *name,
1.697 + const xmlChar *value);
1.698 +XMLPUBFUN xmlAttrPtr XMLCALL
1.699 + xmlNewNsPropEatName (xmlNodePtr node,
1.700 + xmlNsPtr ns,
1.701 + xmlChar *name,
1.702 + const xmlChar *value);
1.703 +XMLPUBFUN void XMLCALL
1.704 + xmlFreePropList (xmlAttrPtr cur);
1.705 +XMLPUBFUN void XMLCALL
1.706 + xmlFreeProp (xmlAttrPtr cur);
1.707 +XMLPUBFUN xmlAttrPtr XMLCALL
1.708 + xmlCopyProp (xmlNodePtr target,
1.709 + xmlAttrPtr cur);
1.710 +XMLPUBFUN xmlAttrPtr XMLCALL
1.711 + xmlCopyPropList (xmlNodePtr target,
1.712 + xmlAttrPtr cur);
1.713 +#ifdef LIBXML_TREE_ENABLED
1.714 +XMLPUBFUN xmlDtdPtr XMLCALL
1.715 + xmlCopyDtd (xmlDtdPtr dtd);
1.716 +XMLPUBFUN xmlDocPtr XMLCALL
1.717 + xmlCopyDoc (xmlDocPtr doc,
1.718 + int recursive);
1.719 +#endif /* LIBXML_TREE_ENABLED */
1.720 +
1.721 +/*
1.722 + * Creating new nodes.
1.723 + */
1.724 +XMLPUBFUN xmlNodePtr XMLCALL
1.725 + xmlNewDocNode (xmlDocPtr doc,
1.726 + xmlNsPtr ns,
1.727 + const xmlChar *name,
1.728 + const xmlChar *content);
1.729 +XMLPUBFUN xmlNodePtr XMLCALL
1.730 + xmlNewDocNodeEatName (xmlDocPtr doc,
1.731 + xmlNsPtr ns,
1.732 + xmlChar *name,
1.733 + const xmlChar *content);
1.734 +XMLPUBFUN xmlNodePtr XMLCALL
1.735 + xmlNewDocRawNode (xmlDocPtr doc,
1.736 + xmlNsPtr ns,
1.737 + const xmlChar *name,
1.738 + const xmlChar *content);
1.739 +XMLPUBFUN xmlNodePtr XMLCALL
1.740 + xmlNewNode (xmlNsPtr ns,
1.741 + const xmlChar *name);
1.742 +XMLPUBFUN xmlNodePtr XMLCALL
1.743 + xmlNewNodeEatName (xmlNsPtr ns,
1.744 + xmlChar *name);
1.745 +XMLPUBFUN xmlNodePtr XMLCALL
1.746 + xmlNewChild (xmlNodePtr parent,
1.747 + xmlNsPtr ns,
1.748 + const xmlChar *name,
1.749 + const xmlChar *content);
1.750 +XMLPUBFUN xmlNodePtr XMLCALL
1.751 + xmlNewTextChild (xmlNodePtr parent,
1.752 + xmlNsPtr ns,
1.753 + const xmlChar *name,
1.754 + const xmlChar *content);
1.755 +XMLPUBFUN xmlNodePtr XMLCALL
1.756 + xmlNewDocText (xmlDocPtr doc,
1.757 + const xmlChar *content);
1.758 +XMLPUBFUN xmlNodePtr XMLCALL
1.759 + xmlNewText (const xmlChar *content);
1.760 +
1.761 +XMLPUBFUN xmlNodePtr XMLCALL
1.762 + xmlNewPI (const xmlChar *name,
1.763 + const xmlChar *content);
1.764 +XMLPUBFUN xmlNodePtr XMLCALL
1.765 + xmlNewDocTextLen (xmlDocPtr doc,
1.766 + const xmlChar *content,
1.767 + int len);
1.768 +XMLPUBFUN xmlNodePtr XMLCALL
1.769 + xmlNewTextLen (const xmlChar *content,
1.770 + int len);
1.771 +XMLPUBFUN xmlNodePtr XMLCALL
1.772 + xmlNewDocComment (xmlDocPtr doc,
1.773 + const xmlChar *content);
1.774 +XMLPUBFUN xmlNodePtr XMLCALL
1.775 + xmlNewComment (const xmlChar *content);
1.776 +XMLPUBFUN xmlNodePtr XMLCALL
1.777 + xmlNewCDataBlock (xmlDocPtr doc,
1.778 + const xmlChar *content,
1.779 + int len);
1.780 +XMLPUBFUN xmlNodePtr XMLCALL
1.781 + xmlNewCharRef (xmlDocPtr doc,
1.782 + const xmlChar *name);
1.783 +XMLPUBFUN xmlNodePtr XMLCALL
1.784 + xmlNewReference (xmlDocPtr doc,
1.785 + const xmlChar *name);
1.786 +XMLPUBFUN xmlNodePtr XMLCALL
1.787 + xmlCopyNode (const xmlNodePtr node,
1.788 + int recursive);
1.789 +XMLPUBFUN xmlNodePtr XMLCALL
1.790 + xmlDocCopyNode (const xmlNodePtr node,
1.791 + xmlDocPtr doc,
1.792 + int recursive);
1.793 +
1.794 +
1.795 +XMLPUBFUN xmlNodePtr XMLCALL xmlCopyNodeList (const xmlNodePtr node);
1.796 +
1.797 +#ifdef LIBXML_TREE_ENABLED
1.798 +XMLPUBFUN xmlNodePtr XMLCALL xmlNewDocFragment (xmlDocPtr doc);
1.799 +#endif /* LIBXML_TREE_ENABLED */
1.800 +
1.801 +/*
1.802 + * Navigating.
1.803 + */
1.804 +#ifdef LIBXML_ENABLE_NODE_LINEINFO
1.805 +XMLPUBFUN long XMLCALL xmlGetLineNo(xmlNodePtr node);
1.806 +#endif
1.807 +
1.808 +#ifdef LIBXML_TREE_ENABLED
1.809 +# ifndef XMLENGINE_EXCLUDE_UNUSED
1.810 + XMLPUBFUN xmlChar * XMLCALL xmlGetNodePath (xmlNodePtr node);
1.811 +# endif /* ifndef XMLENGINE_EXCLUDE_UNUSED */
1.812 +#endif /* LIBXML_TREE_ENABLED */
1.813 +
1.814 +XMLPUBFUN xmlNodePtr XMLCALL xmlDocGetRootElement (xmlDocPtr doc);
1.815 +XMLPUBFUN xmlNodePtr XMLCALL xmlGetLastChild (xmlNodePtr parent);
1.816 +XMLPUBFUN int XMLCALL xmlNodeIsText (xmlNodePtr node);
1.817 +XMLPUBFUN int XMLCALL xmlIsBlankNode (xmlNodePtr node);
1.818 +
1.819 +#ifdef LIBXML_TREE_ENABLED
1.820 +/*
1.821 + * Changing the structure.
1.822 + */
1.823 +XMLPUBFUN xmlNodePtr XMLCALL
1.824 + xmlDocSetRootElement (xmlDocPtr doc, xmlNodePtr root);
1.825 +XMLPUBFUN void XMLCALL
1.826 + xmlNodeSetName (xmlNodePtr cur, const xmlChar *name);
1.827 +XMLPUBFUN xmlNodePtr XMLCALL
1.828 + xmlReplaceNode (xmlNodePtr old, xmlNodePtr cur);
1.829 +XMLPUBFUN xmlNodePtr XMLCALL
1.830 + xmlAddPrevSibling (xmlNodePtr cur, xmlNodePtr elem);
1.831 +#endif /* LIBXML_TREE_ENABLED */
1.832 +
1.833 +XMLPUBFUN xmlNodePtr XMLCALL
1.834 + xmlAddChild (xmlNodePtr parent, xmlNodePtr cur);
1.835 +XMLPUBFUN xmlNodePtr XMLCALL
1.836 + xmlAddChildList (xmlNodePtr parent, xmlNodePtr cur);
1.837 +
1.838 +XMLPUBFUN xmlNodePtr XMLCALL
1.839 + xmlAddSibling (xmlNodePtr cur, xmlNodePtr elem);
1.840 +XMLPUBFUN xmlNodePtr XMLCALL
1.841 + xmlAddNextSibling (xmlNodePtr cur, xmlNodePtr elem);
1.842 +XMLPUBFUN void XMLCALL
1.843 + xmlUnlinkNode (xmlNodePtr cur);
1.844 +XMLPUBFUN xmlNodePtr XMLCALL
1.845 + xmlTextMerge (xmlNodePtr first, xmlNodePtr second);
1.846 +XMLPUBFUN int XMLCALL
1.847 + xmlTextConcat (xmlNodePtr node, const xmlChar *content, int len);
1.848 +
1.849 +XMLPUBFUN void XMLCALL xmlFreeNodeList (xmlNodePtr cur);
1.850 +XMLPUBFUN void XMLCALL xmlFreeNode (xmlNodePtr cur);
1.851 +XMLPUBFUN void XMLCALL xmlSetTreeDoc (xmlNodePtr tree, xmlDocPtr doc);
1.852 +XMLPUBFUN void XMLCALL xmlSetListDoc (xmlNodePtr list, xmlDocPtr doc);
1.853 +/*
1.854 + * Namespaces.
1.855 + */
1.856 +XMLPUBFUN xmlNsPtr XMLCALL
1.857 + xmlSearchNs (xmlDocPtr doc,
1.858 + xmlNodePtr node,
1.859 + const xmlChar *nameSpace);
1.860 +XMLPUBFUN xmlNsPtr XMLCALL
1.861 + xmlSearchNsByHref (xmlDocPtr doc,
1.862 + xmlNodePtr node,
1.863 + const xmlChar *href);
1.864 +
1.865 +XMLPUBFUN void XMLCALL xmlSetNs (xmlNodePtr node, xmlNsPtr ns);
1.866 +XMLPUBFUN xmlNsPtr XMLCALL xmlCopyNamespace (xmlNsPtr cur);
1.867 +XMLPUBFUN xmlNsPtr XMLCALL xmlCopyNamespaceList (xmlNsPtr cur);
1.868 +
1.869 +#ifdef LIBXML_TREE_ENABLED
1.870 +XMLPUBFUN xmlNsPtr* XMLCALL xmlGetNsList (xmlDocPtr doc, xmlNodePtr node);
1.871 +#endif /* LIBXML_TREE_ENABLED */
1.872 +
1.873 +
1.874 +/*
1.875 + * Changing the content.
1.876 + */
1.877 +#ifdef LIBXML_TREE_ENABLED
1.878 +XMLPUBFUN xmlAttrPtr XMLCALL
1.879 + xmlSetProp (xmlNodePtr node,
1.880 + const xmlChar *name,
1.881 + const xmlChar *value);
1.882 +#endif /* LIBXML_TREE_ENABLED */
1.883 +XMLPUBFUN xmlChar * XMLCALL
1.884 + xmlGetNoNsProp (xmlNodePtr node,
1.885 + const xmlChar *name);
1.886 +XMLPUBFUN xmlChar * XMLCALL
1.887 + xmlGetProp (xmlNodePtr node,
1.888 + const xmlChar *name);
1.889 +XMLPUBFUN xmlAttrPtr XMLCALL
1.890 + xmlHasProp (xmlNodePtr node,
1.891 + const xmlChar *name);
1.892 +XMLPUBFUN xmlAttrPtr XMLCALL
1.893 + xmlHasNsProp (xmlNodePtr node,
1.894 + const xmlChar *name,
1.895 + const xmlChar *nameSpace);
1.896 +#ifdef LIBXML_TREE_ENABLED
1.897 +XMLPUBFUN xmlAttrPtr XMLCALL
1.898 + xmlSetNsProp (xmlNodePtr node,
1.899 + xmlNsPtr ns,
1.900 + const xmlChar *name,
1.901 + const xmlChar *value);
1.902 +#endif /* LIBXML_TREE_ENABLED */
1.903 +XMLPUBFUN xmlChar * XMLCALL
1.904 + xmlGetNsProp (xmlNodePtr node,
1.905 + const xmlChar *name,
1.906 + const xmlChar *nameSpace);
1.907 +XMLPUBFUN xmlNodePtr XMLCALL
1.908 + xmlStringGetNodeList (xmlDocPtr doc,
1.909 + const xmlChar *value);
1.910 +XMLPUBFUN xmlNodePtr XMLCALL
1.911 + xmlStringLenGetNodeList (xmlDocPtr doc,
1.912 + const xmlChar *value,
1.913 + int len);
1.914 +XMLPUBFUN xmlChar * XMLCALL
1.915 + xmlNodeListGetString (xmlDocPtr doc,
1.916 + xmlNodePtr list,
1.917 + int inLine);
1.918 +#ifdef LIBXML_TREE_ENABLED
1.919 +XMLPUBFUN xmlChar * XMLCALL
1.920 + xmlNodeListGetRawString (xmlDocPtr doc,
1.921 + xmlNodePtr list,
1.922 + int inLine);
1.923 +#endif /* LIBXML_TREE_ENABLED */
1.924 +XMLPUBFUN void XMLCALL
1.925 + xmlNodeSetContent (xmlNodePtr cur,
1.926 + const xmlChar *content);
1.927 +#ifdef LIBXML_TREE_ENABLED
1.928 +XMLPUBFUN void XMLCALL
1.929 + xmlNodeSetContentLen (xmlNodePtr cur,
1.930 + const xmlChar *content,
1.931 + int len);
1.932 +#endif /* LIBXML_TREE_ENABLED */
1.933 +XMLPUBFUN void XMLCALL
1.934 + xmlNodeAddContent (xmlNodePtr cur,
1.935 + const xmlChar *content);
1.936 +XMLPUBFUN void XMLCALL
1.937 + xmlNodeAddContentLen (xmlNodePtr cur,
1.938 + const xmlChar *content,
1.939 + int len);
1.940 +XMLPUBFUN xmlChar * XMLCALL
1.941 + xmlNodeGetContent (xmlNodePtr cur);
1.942 +XMLPUBFUN int XMLCALL
1.943 + xmlNodeBufGetContent (xmlBufferPtr buffer,
1.944 + xmlNodePtr cur);
1.945 +XMLPUBFUN xmlChar * XMLCALL
1.946 + xmlNodeGetLang (xmlNodePtr cur);
1.947 +XMLPUBFUN int XMLCALL
1.948 + xmlNodeGetSpacePreserve (xmlNodePtr cur);
1.949 +
1.950 +XMLPUBFUN xmlChar * XMLCALL
1.951 + xmlNodeGetBase (xmlDocPtr doc,
1.952 + xmlNodePtr cur);
1.953 +
1.954 +#ifdef LIBXML_TREE_ENABLED
1.955 +XMLPUBFUN void XMLCALL
1.956 + xmlNodeSetLang (xmlNodePtr cur,
1.957 + const xmlChar *lang);
1.958 +XMLPUBFUN void XMLCALL
1.959 + xmlNodeSetSpacePreserve (xmlNodePtr cur,
1.960 + int val);
1.961 +XMLPUBFUN void XMLCALL
1.962 + xmlNodeSetBase (xmlNodePtr cur,
1.963 + const xmlChar *uri);
1.964 +/*
1.965 + * Removing content.
1.966 + */
1.967 +XMLPUBFUN int XMLCALL
1.968 + xmlRemoveProp (xmlAttrPtr cur);
1.969 +XMLPUBFUN int XMLCALL
1.970 + xmlUnsetProp (xmlNodePtr node,
1.971 + const xmlChar *name);
1.972 +XMLPUBFUN int XMLCALL
1.973 + xmlUnsetNsProp (xmlNodePtr node,
1.974 + xmlNsPtr ns,
1.975 + const xmlChar *name);
1.976 +#endif /* LIBXML_TREE_ENABLED */
1.977 +
1.978 +/*
1.979 + * Internal, don't use.
1.980 + */
1.981 +XMLPUBFUN void XMLCALL
1.982 + xmlBufferWriteCHAR (xmlBufferPtr buf,
1.983 + const xmlChar *string);
1.984 +XMLPUBFUN void XMLCALL
1.985 + xmlBufferWriteChar (xmlBufferPtr buf,
1.986 + const char *string);
1.987 +XMLPUBFUN void XMLCALL
1.988 + xmlBufferWriteQuotedString(xmlBufferPtr buf,
1.989 + const xmlChar *string);
1.990 +
1.991 +XMLPUBFUN void xmlAttrSerializeTxtContent(xmlBufferPtr buf,
1.992 + xmlDocPtr doc,
1.993 + xmlAttrPtr attr,
1.994 + const xmlChar *string);
1.995 +
1.996 +/*
1.997 + * Namespace handling.
1.998 + */
1.999 +XMLPUBFUN int XMLCALL
1.1000 + xmlReconciliateNs (xmlDocPtr doc,
1.1001 + xmlNodePtr tree);
1.1002 +
1.1003 +#ifdef LIBXML_OUTPUT_ENABLED
1.1004 +/*
1.1005 + * Saving.
1.1006 + */
1.1007 +XMLPUBFUN void XMLCALL
1.1008 + xmlDocDumpFormatMemory (xmlDocPtr cur,
1.1009 + xmlChar **mem,
1.1010 + int *size,
1.1011 + int format);
1.1012 +XMLPUBFUN void XMLCALL
1.1013 + xmlDocDumpMemory (xmlDocPtr cur,
1.1014 + xmlChar **mem,
1.1015 + int *size);
1.1016 +XMLPUBFUN void XMLCALL
1.1017 + xmlDocDumpMemoryEnc (xmlDocPtr out_doc,
1.1018 + xmlChar **doc_txt_ptr,
1.1019 + int * doc_txt_len,
1.1020 + const char *txt_encoding);
1.1021 +XMLPUBFUN void XMLCALL
1.1022 + xmlDocDumpFormatMemoryEnc(xmlDocPtr out_doc,
1.1023 + xmlChar **doc_txt_ptr,
1.1024 + int * doc_txt_len,
1.1025 + const char *txt_encoding,
1.1026 + int format);
1.1027 +
1.1028 +#ifndef XMLENGINE_EXCLUDE_FILE_FUNC
1.1029 +XMLPUBFUN int XMLCALL
1.1030 + xmlDocFormatDump (FILE *f,
1.1031 + xmlDocPtr cur,
1.1032 + int format);
1.1033 +
1.1034 +XMLPUBFUN int XMLCALL
1.1035 + xmlDocDump (FILE *f,
1.1036 + xmlDocPtr cur);
1.1037 +XMLPUBFUN void XMLCALL
1.1038 + xmlElemDump (FILE *f,
1.1039 + xmlDocPtr doc,
1.1040 + xmlNodePtr cur);
1.1041 +#endif /* XMLENGINE_EXCLUDE_FILE_FUNC */
1.1042 +
1.1043 +XMLPUBFUN int XMLCALL
1.1044 + xmlSaveFile (const char *filename,
1.1045 + xmlDocPtr cur);
1.1046 +XMLPUBFUN int XMLCALL
1.1047 + xmlSaveFormatFile (const char *filename,
1.1048 + xmlDocPtr cur,
1.1049 + int format);
1.1050 +XMLPUBFUN int XMLCALL
1.1051 + xmlNodeDump (xmlBufferPtr buf,
1.1052 + xmlDocPtr doc,
1.1053 + xmlNodePtr cur,
1.1054 + int level,
1.1055 + int format);
1.1056 +
1.1057 +XMLPUBFUN int XMLCALL
1.1058 + xmlSaveFileTo (xmlOutputBufferPtr buf,
1.1059 + xmlDocPtr cur,
1.1060 + const char *encoding);
1.1061 +XMLPUBFUN int XMLCALL
1.1062 + xmlSaveFormatFileTo (xmlOutputBufferPtr buf,
1.1063 + xmlDocPtr cur,
1.1064 + const char *encoding,
1.1065 + int format);
1.1066 +
1.1067 +XMLPUBFUN void XMLCALL
1.1068 + xmlNodeDumpOutput (xmlOutputBufferPtr buf,
1.1069 + xmlDocPtr doc,
1.1070 + xmlNodePtr cur,
1.1071 + int level,
1.1072 + int format,
1.1073 + const char *encoding);
1.1074 +
1.1075 +XMLPUBFUN int XMLCALL
1.1076 + xmlSaveFormatFileEnc (const char *filename,
1.1077 + xmlDocPtr cur,
1.1078 + const char *encoding,
1.1079 + int format);
1.1080 +
1.1081 +XMLPUBFUN int XMLCALL
1.1082 + xmlSaveFileEnc (const char *filename,
1.1083 + xmlDocPtr cur,
1.1084 + const char *encoding);
1.1085 +
1.1086 +#endif /* LIBXML_OUTPUT_ENABLED */
1.1087 +/*
1.1088 + * XHTML
1.1089 + */
1.1090 +XMLPUBFUN int XMLCALL xmlIsXHTML(const xmlChar *systemID, const xmlChar *publicID);
1.1091 +
1.1092 +/*
1.1093 + * Compression.
1.1094 + */
1.1095 +XMLPUBFUN void XMLCALL xmlSetDocCompressMode(xmlDocPtr doc, int mode);
1.1096 +
1.1097 +#ifndef XMLENGINE_EXCLUDE_UNUSED
1.1098 +XMLPUBFUN int XMLCALL xmlGetDocCompressMode(xmlDocPtr doc);
1.1099 +XMLPUBFUN int XMLCALL xmlGetCompressMode(void);
1.1100 +XMLPUBFUN void XMLCALL xmlSetCompressMode(int mode);
1.1101 +#endif /* ifndef XMLENGINE_EXCLUDE_UNUSED */
1.1102 +
1.1103 +#ifdef __cplusplus
1.1104 +}
1.1105 +#endif
1.1106 +
1.1107 +#endif /* XML_TREE_H */
1.1108 +
1.1109 +