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