Annotation of embedaddon/libxml2/include/libxml/tree.h, revision 1.1
1.1 ! misho 1: /*
! 2: * Summary: interfaces for tree manipulation
! 3: * Description: this module describes the structures found in an tree resulting
! 4: * from an XML or HTML parsing, as well as the API provided for
! 5: * various processing on that tree
! 6: *
! 7: * Copy: See Copyright for the status of this software.
! 8: *
! 9: * Author: Daniel Veillard
! 10: */
! 11:
! 12: #ifndef __XML_TREE_H__
! 13: #define __XML_TREE_H__
! 14:
! 15: #include <stdio.h>
! 16: #include <libxml/xmlversion.h>
! 17: #include <libxml/xmlstring.h>
! 18:
! 19: #ifdef __cplusplus
! 20: extern "C" {
! 21: #endif
! 22:
! 23: /*
! 24: * Some of the basic types pointer to structures:
! 25: */
! 26: /* xmlIO.h */
! 27: typedef struct _xmlParserInputBuffer xmlParserInputBuffer;
! 28: typedef xmlParserInputBuffer *xmlParserInputBufferPtr;
! 29:
! 30: typedef struct _xmlOutputBuffer xmlOutputBuffer;
! 31: typedef xmlOutputBuffer *xmlOutputBufferPtr;
! 32:
! 33: /* parser.h */
! 34: typedef struct _xmlParserInput xmlParserInput;
! 35: typedef xmlParserInput *xmlParserInputPtr;
! 36:
! 37: typedef struct _xmlParserCtxt xmlParserCtxt;
! 38: typedef xmlParserCtxt *xmlParserCtxtPtr;
! 39:
! 40: typedef struct _xmlSAXLocator xmlSAXLocator;
! 41: typedef xmlSAXLocator *xmlSAXLocatorPtr;
! 42:
! 43: typedef struct _xmlSAXHandler xmlSAXHandler;
! 44: typedef xmlSAXHandler *xmlSAXHandlerPtr;
! 45:
! 46: /* entities.h */
! 47: typedef struct _xmlEntity xmlEntity;
! 48: typedef xmlEntity *xmlEntityPtr;
! 49:
! 50: /**
! 51: * BASE_BUFFER_SIZE:
! 52: *
! 53: * default buffer size 4000.
! 54: */
! 55: #define BASE_BUFFER_SIZE 4096
! 56:
! 57: /**
! 58: * 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 */
! 65:
! 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: */
! 72:
! 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;
! 79:
! 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: };
! 94:
! 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"
! 103:
! 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"
! 110:
! 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;
! 145:
! 146:
! 147: /**
! 148: * xmlNotation:
! 149: *
! 150: * A DTD Notation definition.
! 151: */
! 152:
! 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: };
! 160:
! 161: /**
! 162: * xmlAttributeType:
! 163: *
! 164: * A DTD Attribute type definition.
! 165: */
! 166:
! 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;
! 179:
! 180: /**
! 181: * xmlAttributeDefault:
! 182: *
! 183: * A DTD Attribute default definition.
! 184: */
! 185:
! 186: typedef enum {
! 187: XML_ATTRIBUTE_NONE = 1,
! 188: XML_ATTRIBUTE_REQUIRED,
! 189: XML_ATTRIBUTE_IMPLIED,
! 190: XML_ATTRIBUTE_FIXED
! 191: } xmlAttributeDefault;
! 192:
! 193: /**
! 194: * xmlEnumeration:
! 195: *
! 196: * List structure used when there is an enumeration in DTDs.
! 197: */
! 198:
! 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: };
! 205:
! 206: /**
! 207: * xmlAttribute:
! 208: *
! 209: * An Attribute declaration in a DTD.
! 210: */
! 211:
! 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 */
! 224:
! 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: };
! 233:
! 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;
! 245:
! 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;
! 257:
! 258: /**
! 259: * xmlElementContent:
! 260: *
! 261: * An XML Element content as stored after parsing an element definition
! 262: * in a DTD.
! 263: */
! 264:
! 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: };
! 276:
! 277: /**
! 278: * xmlElementTypeVal:
! 279: *
! 280: * The different possibilities for an element content type.
! 281: */
! 282:
! 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;
! 290:
! 291: #ifdef __cplusplus
! 292: }
! 293: #endif
! 294: #include <libxml/xmlregexp.h>
! 295: #ifdef __cplusplus
! 296: extern "C" {
! 297: #endif
! 298:
! 299: /**
! 300: * xmlElement:
! 301: *
! 302: * An XML Element declaration from a DTD.
! 303: */
! 304:
! 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 */
! 317:
! 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: };
! 328:
! 329:
! 330: /**
! 331: * XML_LOCAL_NAMESPACE:
! 332: *
! 333: * A namespace declaration node.
! 334: */
! 335: #define XML_LOCAL_NAMESPACE XML_NAMESPACE_DECL
! 336: typedef xmlElementType xmlNsType;
! 337:
! 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: */
! 347:
! 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: };
! 358:
! 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 */
! 377:
! 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: };
! 387:
! 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: };
! 409:
! 410: /**
! 411: * xmlID:
! 412: *
! 413: * An XML ID instance.
! 414: */
! 415:
! 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: };
! 426:
! 427: /**
! 428: * xmlRef:
! 429: *
! 430: * An XML IDREF instance.
! 431: */
! 432:
! 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: };
! 442:
! 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 */
! 460:
! 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: };
! 470:
! 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)
! 478:
! 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))
! 486:
! 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;
! 504:
! 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 */
! 522:
! 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: };
! 548:
! 549:
! 550: typedef struct _xmlDOMWrapCtxt xmlDOMWrapCtxt;
! 551: typedef xmlDOMWrapCtxt *xmlDOMWrapCtxtPtr;
! 552:
! 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);
! 568:
! 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: };
! 591:
! 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
! 601:
! 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
! 611:
! 612: /*
! 613: * Variables.
! 614: */
! 615:
! 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
! 624:
! 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
! 636:
! 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);
! 648:
! 649: /*
! 650: * Handling Buffers.
! 651: */
! 652:
! 653: XMLPUBFUN void XMLCALL
! 654: xmlSetBufferAllocationScheme(xmlBufferAllocationScheme scheme);
! 655: XMLPUBFUN xmlBufferAllocationScheme XMLCALL
! 656: xmlGetBufferAllocationScheme(void);
! 657:
! 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);
! 702:
! 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 */
! 864:
! 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);
! 882:
! 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) */
! 954:
! 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);
! 962:
! 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
! 1052:
! 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) */
! 1067:
! 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);
! 1080:
! 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 */
! 1087:
! 1088: #ifdef LIBXML_TREE_ENABLED
! 1089: /*
! 1090: * Namespace handling.
! 1091: */
! 1092: XMLPUBFUN int XMLCALL
! 1093: xmlReconciliateNs (xmlDocPtr doc,
! 1094: xmlNodePtr tree);
! 1095: #endif
! 1096:
! 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);
! 1145:
! 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);
! 1162:
! 1163: XMLPUBFUN int XMLCALL
! 1164: xmlSaveFormatFileEnc (const char *filename,
! 1165: xmlDocPtr cur,
! 1166: const char *encoding,
! 1167: int format);
! 1168:
! 1169: XMLPUBFUN int XMLCALL
! 1170: xmlSaveFileEnc (const char *filename,
! 1171: xmlDocPtr cur,
! 1172: const char *encoding);
! 1173:
! 1174: #endif /* LIBXML_OUTPUT_ENABLED */
! 1175: /*
! 1176: * XHTML
! 1177: */
! 1178: XMLPUBFUN int XMLCALL
! 1179: xmlIsXHTML (const xmlChar *systemID,
! 1180: const xmlChar *publicID);
! 1181:
! 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);
! 1194:
! 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);
! 1227:
! 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
! 1250:
! 1251: #endif /* __XML_TREE_H__ */
! 1252:
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to tree.h CVS log ![[TXT]](/icons/cvsweb/text.gif){kind=icon}
![[DIR]](/icons/cvsweb/dir.gif){kind=icon}
Up to [ELWIX - Embedded LightWeight unIX -] / embedaddon / libxml2 / include / libxml