开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > Internet/网络编程 > 浏览器 > 查看源码
tree.h.svn-base
资源名称：Client.rar　[点击查看]
上传用户：szjkjd
上传日期：2022-06-27
资源大小：8968k
文件大小：36k
源码类别：

浏览器

开发平台：

Visual C++

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