libxml2/include/libxml/tree.h

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