1 /* 2 * tree.c : implementation of access function for an XML tree. 3 * 4 * References: 5 * XHTML 1.0 W3C REC: http://www.w3.org/TR/2002/REC-xhtml1-20020801/ 6 * 7 * See Copyright for the status of this software. 8 * 9 * daniel (at) veillard.com 10 * 11 */ 12 13 /* To avoid EBCDIC trouble when parsing on zOS */ 14 #if defined(__MVS__) 15 #pragma convert("ISO8859-1") 16 #endif 17 18 #define IN_LIBXML 19 #include "libxml.h" 20 21 #include <string.h> /* for memset() only ! */ 22 #include <stddef.h> 23 #include <limits.h> 24 #ifdef HAVE_CTYPE_H 25 #include <ctype.h> 26 #endif 27 #ifdef HAVE_STDLIB_H 28 #include <stdlib.h> 29 #endif 30 #ifdef LIBXML_ZLIB_ENABLED 31 #include <zlib.h> 32 #endif 33 34 #include <libxml/xmlmemory.h> 35 #include <libxml/tree.h> 36 #include <libxml/parser.h> 37 #include <libxml/uri.h> 38 #include <libxml/entities.h> 39 #include <libxml/valid.h> 40 #include <libxml/xmlerror.h> 41 #include <libxml/parserInternals.h> 42 #include <libxml/globals.h> 43 #ifdef LIBXML_HTML_ENABLED 44 #include <libxml/HTMLtree.h> 45 #endif 46 #ifdef LIBXML_DEBUG_ENABLED 47 #include <libxml/debugXML.h> 48 #endif 49 50 #include "buf.h" 51 #include "save.h" 52 53 int __xmlRegisterCallbacks = 0; 54 55 /************************************************************************ 56 * * 57 * Forward declarations * 58 * * 59 ************************************************************************/ 60 61 static xmlNsPtr 62 xmlNewReconciliedNs(xmlDocPtr doc, xmlNodePtr tree, xmlNsPtr ns); 63 64 static xmlChar* xmlGetPropNodeValueInternal(const xmlAttr *prop); 65 66 /************************************************************************ 67 * * 68 * Tree memory error handler * 69 * * 70 ************************************************************************/ 71 /** 72 * xmlTreeErrMemory: 73 * @extra: extra informations 74 * 75 * Handle an out of memory condition 76 */ 77 static void 78 xmlTreeErrMemory(const char *extra) 79 { 80 __xmlSimpleError(XML_FROM_TREE, XML_ERR_NO_MEMORY, NULL, NULL, extra); 81 } 82 83 /** 84 * xmlTreeErr: 85 * @code: the error number 86 * @extra: extra informations 87 * 88 * Handle an out of memory condition 89 */ 90 static void 91 xmlTreeErr(int code, xmlNodePtr node, const char *extra) 92 { 93 const char *msg = NULL; 94 95 switch(code) { 96 case XML_TREE_INVALID_HEX: 97 msg = "invalid hexadecimal character value\n"; 98 break; 99 case XML_TREE_INVALID_DEC: 100 msg = "invalid decimal character value\n"; 101 break; 102 case XML_TREE_UNTERMINATED_ENTITY: 103 msg = "unterminated entity reference %15s\n"; 104 break; 105 case XML_TREE_NOT_UTF8: 106 msg = "string is not in UTF-8\n"; 107 break; 108 default: 109 msg = "unexpected error number\n"; 110 } 111 __xmlSimpleError(XML_FROM_TREE, code, node, msg, extra); 112 } 113 114 /************************************************************************ 115 * * 116 * A few static variables and macros * 117 * * 118 ************************************************************************/ 119 /* #undef xmlStringText */ 120 const xmlChar xmlStringText[] = { 't', 'e', 'x', 't', 0 }; 121 /* #undef xmlStringTextNoenc */ 122 const xmlChar xmlStringTextNoenc[] = 123 { 't', 'e', 'x', 't', 'n', 'o', 'e', 'n', 'c', 0 }; 124 /* #undef xmlStringComment */ 125 const xmlChar xmlStringComment[] = { 'c', 'o', 'm', 'm', 'e', 'n', 't', 0 }; 126 127 static int xmlCompressMode = 0; 128 static int xmlCheckDTD = 1; 129 130 #define UPDATE_LAST_CHILD_AND_PARENT(n) if ((n) != NULL) { \ 131 xmlNodePtr ulccur = (n)->children; \ 132 if (ulccur == NULL) { \ 133 (n)->last = NULL; \ 134 } else { \ 135 while (ulccur->next != NULL) { \ 136 ulccur->parent = (n); \ 137 ulccur = ulccur->next; \ 138 } \ 139 ulccur->parent = (n); \ 140 (n)->last = ulccur; \ 141 }} 142 143 #define IS_STR_XML(str) ((str != NULL) && (str[0] == 'x') && \ 144 (str[1] == 'm') && (str[2] == 'l') && (str[3] == 0)) 145 146 /* #define DEBUG_BUFFER */ 147 /* #define DEBUG_TREE */ 148 149 /************************************************************************ 150 * * 151 * Functions to move to entities.c once the * 152 * API freeze is smoothen and they can be made public. * 153 * * 154 ************************************************************************/ 155 #include <libxml/hash.h> 156 157 #ifdef LIBXML_TREE_ENABLED 158 /** 159 * xmlGetEntityFromDtd: 160 * @dtd: A pointer to the DTD to search 161 * @name: The entity name 162 * 163 * Do an entity lookup in the DTD entity hash table and 164 * return the corresponding entity, if found. 165 * 166 * Returns A pointer to the entity structure or NULL if not found. 167 */ 168 static xmlEntityPtr 169 xmlGetEntityFromDtd(const xmlDtd *dtd, const xmlChar *name) { 170 xmlEntitiesTablePtr table; 171 172 if((dtd != NULL) && (dtd->entities != NULL)) { 173 table = (xmlEntitiesTablePtr) dtd->entities; 174 return((xmlEntityPtr) xmlHashLookup(table, name)); 175 /* return(xmlGetEntityFromTable(table, name)); */ 176 } 177 return(NULL); 178 } 179 /** 180 * xmlGetParameterEntityFromDtd: 181 * @dtd: A pointer to the DTD to search 182 * @name: The entity name 183 * 184 * Do an entity lookup in the DTD pararmeter entity hash table and 185 * return the corresponding entity, if found. 186 * 187 * Returns A pointer to the entity structure or NULL if not found. 188 */ 189 static xmlEntityPtr 190 xmlGetParameterEntityFromDtd(const xmlDtd *dtd, const xmlChar *name) { 191 xmlEntitiesTablePtr table; 192 193 if ((dtd != NULL) && (dtd->pentities != NULL)) { 194 table = (xmlEntitiesTablePtr) dtd->pentities; 195 return((xmlEntityPtr) xmlHashLookup(table, name)); 196 /* return(xmlGetEntityFromTable(table, name)); */ 197 } 198 return(NULL); 199 } 200 #endif /* LIBXML_TREE_ENABLED */ 201 202 /************************************************************************ 203 * * 204 * QName handling helper * 205 * * 206 ************************************************************************/ 207 208 /** 209 * xmlBuildQName: 210 * @ncname: the Name 211 * @prefix: the prefix 212 * @memory: preallocated memory 213 * @len: preallocated memory length 214 * 215 * Builds the QName @prefix:@ncname in @memory if there is enough space 216 * and prefix is not NULL nor empty, otherwise allocate a new string. 217 * If prefix is NULL or empty it returns ncname. 218 * 219 * Returns the new string which must be freed by the caller if different from 220 * @memory and @ncname or NULL in case of error 221 */ 222 xmlChar * 223 xmlBuildQName(const xmlChar *ncname, const xmlChar *prefix, 224 xmlChar *memory, int len) { 225 int lenn, lenp; 226 xmlChar *ret; 227 228 if (ncname == NULL) return(NULL); 229 if (prefix == NULL) return((xmlChar *) ncname); 230 231 lenn = strlen((char *) ncname); 232 lenp = strlen((char *) prefix); 233 234 if ((memory == NULL) || (len < lenn + lenp + 2)) { 235 ret = (xmlChar *) xmlMallocAtomic(lenn + lenp + 2); 236 if (ret == NULL) { 237 xmlTreeErrMemory("building QName"); 238 return(NULL); 239 } 240 } else { 241 ret = memory; 242 } 243 memcpy(&ret[0], prefix, lenp); 244 ret[lenp] = ':'; 245 memcpy(&ret[lenp + 1], ncname, lenn); 246 ret[lenn + lenp + 1] = 0; 247 return(ret); 248 } 249 250 /** 251 * xmlSplitQName2: 252 * @name: the full QName 253 * @prefix: a xmlChar ** 254 * 255 * parse an XML qualified name string 256 * 257 * [NS 5] QName ::= (Prefix ':')? LocalPart 258 * 259 * [NS 6] Prefix ::= NCName 260 * 261 * [NS 7] LocalPart ::= NCName 262 * 263 * Returns NULL if the name doesn't have a prefix. Otherwise, returns the 264 * local part, and prefix is updated to get the Prefix. Both the return value 265 * and the prefix must be freed by the caller. 266 */ 267 xmlChar * 268 xmlSplitQName2(const xmlChar *name, xmlChar **prefix) { 269 int len = 0; 270 xmlChar *ret = NULL; 271 272 if (prefix == NULL) return(NULL); 273 *prefix = NULL; 274 if (name == NULL) return(NULL); 275 276 #ifndef XML_XML_NAMESPACE 277 /* xml: prefix is not really a namespace */ 278 if ((name[0] == 'x') && (name[1] == 'm') && 279 (name[2] == 'l') && (name[3] == ':')) 280 return(NULL); 281 #endif 282 283 /* nasty but valid */ 284 if (name[0] == ':') 285 return(NULL); 286 287 /* 288 * we are not trying to validate but just to cut, and yes it will 289 * work even if this is as set of UTF-8 encoded chars 290 */ 291 while ((name[len] != 0) && (name[len] != ':')) 292 len++; 293 294 if (name[len] == 0) 295 return(NULL); 296 297 *prefix = xmlStrndup(name, len); 298 if (*prefix == NULL) { 299 xmlTreeErrMemory("QName split"); 300 return(NULL); 301 } 302 ret = xmlStrdup(&name[len + 1]); 303 if (ret == NULL) { 304 xmlTreeErrMemory("QName split"); 305 if (*prefix != NULL) { 306 xmlFree(*prefix); 307 *prefix = NULL; 308 } 309 return(NULL); 310 } 311 312 return(ret); 313 } 314 315 /** 316 * xmlSplitQName3: 317 * @name: the full QName 318 * @len: an int * 319 * 320 * parse an XML qualified name string,i 321 * 322 * returns NULL if it is not a Qualified Name, otherwise, update len 323 * with the length in byte of the prefix and return a pointer 324 * to the start of the name without the prefix 325 */ 326 327 const xmlChar * 328 xmlSplitQName3(const xmlChar *name, int *len) { 329 int l = 0; 330 331 if (name == NULL) return(NULL); 332 if (len == NULL) return(NULL); 333 334 /* nasty but valid */ 335 if (name[0] == ':') 336 return(NULL); 337 338 /* 339 * we are not trying to validate but just to cut, and yes it will 340 * work even if this is as set of UTF-8 encoded chars 341 */ 342 while ((name[l] != 0) && (name[l] != ':')) 343 l++; 344 345 if (name[l] == 0) 346 return(NULL); 347 348 *len = l; 349 350 return(&name[l+1]); 351 } 352 353 /************************************************************************ 354 * * 355 * Check Name, NCName and QName strings * 356 * * 357 ************************************************************************/ 358 359 #define CUR_SCHAR(s, l) xmlStringCurrentChar(NULL, s, &l) 360 361 #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) || defined(LIBXML_LEGACY_ENABLED) 362 /** 363 * xmlValidateNCName: 364 * @value: the value to check 365 * @space: allow spaces in front and end of the string 366 * 367 * Check that a value conforms to the lexical space of NCName 368 * 369 * Returns 0 if this validates, a positive error code number otherwise 370 * and -1 in case of internal or API error. 371 */ 372 int 373 xmlValidateNCName(const xmlChar *value, int space) { 374 const xmlChar *cur = value; 375 int c,l; 376 377 if (value == NULL) 378 return(-1); 379 380 /* 381 * First quick algorithm for ASCII range 382 */ 383 if (space) 384 while (IS_BLANK_CH(*cur)) cur++; 385 if (((*cur >= 'a') && (*cur <= 'z')) || ((*cur >= 'A') && (*cur <= 'Z')) || 386 (*cur == '_')) 387 cur++; 388 else 389 goto try_complex; 390 while (((*cur >= 'a') && (*cur <= 'z')) || 391 ((*cur >= 'A') && (*cur <= 'Z')) || 392 ((*cur >= '0') && (*cur <= '9')) || 393 (*cur == '_') || (*cur == '-') || (*cur == '.')) 394 cur++; 395 if (space) 396 while (IS_BLANK_CH(*cur)) cur++; 397 if (*cur == 0) 398 return(0); 399 400 try_complex: 401 /* 402 * Second check for chars outside the ASCII range 403 */ 404 cur = value; 405 c = CUR_SCHAR(cur, l); 406 if (space) { 407 while (IS_BLANK(c)) { 408 cur += l; 409 c = CUR_SCHAR(cur, l); 410 } 411 } 412 if ((!IS_LETTER(c)) && (c != '_')) 413 return(1); 414 cur += l; 415 c = CUR_SCHAR(cur, l); 416 while (IS_LETTER(c) || IS_DIGIT(c) || (c == '.') || 417 (c == '-') || (c == '_') || IS_COMBINING(c) || 418 IS_EXTENDER(c)) { 419 cur += l; 420 c = CUR_SCHAR(cur, l); 421 } 422 if (space) { 423 while (IS_BLANK(c)) { 424 cur += l; 425 c = CUR_SCHAR(cur, l); 426 } 427 } 428 if (c != 0) 429 return(1); 430 431 return(0); 432 } 433 #endif 434 435 #if defined(LIBXML_TREE_ENABLED) || defined(LIBXML_SCHEMAS_ENABLED) 436 /** 437 * xmlValidateQName: 438 * @value: the value to check 439 * @space: allow spaces in front and end of the string 440 * 441 * Check that a value conforms to the lexical space of QName 442 * 443 * Returns 0 if this validates, a positive error code number otherwise 444 * and -1 in case of internal or API error. 445 */ 446 int 447 xmlValidateQName(const xmlChar *value, int space) { 448 const xmlChar *cur = value; 449 int c,l; 450 451 if (value == NULL) 452 return(-1); 453 /* 454 * First quick algorithm for ASCII range 455 */ 456 if (space) 457 while (IS_BLANK_CH(*cur)) cur++; 458 if (((*cur >= 'a') && (*cur <= 'z')) || ((*cur >= 'A') && (*cur <= 'Z')) || 459 (*cur == '_')) 460 cur++; 461 else 462 goto try_complex; 463 while (((*cur >= 'a') && (*cur <= 'z')) || 464 ((*cur >= 'A') && (*cur <= 'Z')) || 465 ((*cur >= '0') && (*cur <= '9')) || 466 (*cur == '_') || (*cur == '-') || (*cur == '.')) 467 cur++; 468 if (*cur == ':') { 469 cur++; 470 if (((*cur >= 'a') && (*cur <= 'z')) || 471 ((*cur >= 'A') && (*cur <= 'Z')) || 472 (*cur == '_')) 473 cur++; 474 else 475 goto try_complex; 476 while (((*cur >= 'a') && (*cur <= 'z')) || 477 ((*cur >= 'A') && (*cur <= 'Z')) || 478 ((*cur >= '0') && (*cur <= '9')) || 479 (*cur == '_') || (*cur == '-') || (*cur == '.')) 480 cur++; 481 } 482 if (space) 483 while (IS_BLANK_CH(*cur)) cur++; 484 if (*cur == 0) 485 return(0); 486 487 try_complex: 488 /* 489 * Second check for chars outside the ASCII range 490 */ 491 cur = value; 492 c = CUR_SCHAR(cur, l); 493 if (space) { 494 while (IS_BLANK(c)) { 495 cur += l; 496 c = CUR_SCHAR(cur, l); 497 } 498 } 499 if ((!IS_LETTER(c)) && (c != '_')) 500 return(1); 501 cur += l; 502 c = CUR_SCHAR(cur, l); 503 while (IS_LETTER(c) || IS_DIGIT(c) || (c == '.') || 504 (c == '-') || (c == '_') || IS_COMBINING(c) || 505 IS_EXTENDER(c)) { 506 cur += l; 507 c = CUR_SCHAR(cur, l); 508 } 509 if (c == ':') { 510 cur += l; 511 c = CUR_SCHAR(cur, l); 512 if ((!IS_LETTER(c)) && (c != '_')) 513 return(1); 514 cur += l; 515 c = CUR_SCHAR(cur, l); 516 while (IS_LETTER(c) || IS_DIGIT(c) || (c == '.') || 517 (c == '-') || (c == '_') || IS_COMBINING(c) || 518 IS_EXTENDER(c)) { 519 cur += l; 520 c = CUR_SCHAR(cur, l); 521 } 522 } 523 if (space) { 524 while (IS_BLANK(c)) { 525 cur += l; 526 c = CUR_SCHAR(cur, l); 527 } 528 } 529 if (c != 0) 530 return(1); 531 return(0); 532 } 533 534 /** 535 * xmlValidateName: 536 * @value: the value to check 537 * @space: allow spaces in front and end of the string 538 * 539 * Check that a value conforms to the lexical space of Name 540 * 541 * Returns 0 if this validates, a positive error code number otherwise 542 * and -1 in case of internal or API error. 543 */ 544 int 545 xmlValidateName(const xmlChar *value, int space) { 546 const xmlChar *cur = value; 547 int c,l; 548 549 if (value == NULL) 550 return(-1); 551 /* 552 * First quick algorithm for ASCII range 553 */ 554 if (space) 555 while (IS_BLANK_CH(*cur)) cur++; 556 if (((*cur >= 'a') && (*cur <= 'z')) || ((*cur >= 'A') && (*cur <= 'Z')) || 557 (*cur == '_') || (*cur == ':')) 558 cur++; 559 else 560 goto try_complex; 561 while (((*cur >= 'a') && (*cur <= 'z')) || 562 ((*cur >= 'A') && (*cur <= 'Z')) || 563 ((*cur >= '0') && (*cur <= '9')) || 564 (*cur == '_') || (*cur == '-') || (*cur == '.') || (*cur == ':')) 565 cur++; 566 if (space) 567 while (IS_BLANK_CH(*cur)) cur++; 568 if (*cur == 0) 569 return(0); 570 571 try_complex: 572 /* 573 * Second check for chars outside the ASCII range 574 */ 575 cur = value; 576 c = CUR_SCHAR(cur, l); 577 if (space) { 578 while (IS_BLANK(c)) { 579 cur += l; 580 c = CUR_SCHAR(cur, l); 581 } 582 } 583 if ((!IS_LETTER(c)) && (c != '_') && (c != ':')) 584 return(1); 585 cur += l; 586 c = CUR_SCHAR(cur, l); 587 while (IS_LETTER(c) || IS_DIGIT(c) || (c == '.') || (c == ':') || 588 (c == '-') || (c == '_') || IS_COMBINING(c) || IS_EXTENDER(c)) { 589 cur += l; 590 c = CUR_SCHAR(cur, l); 591 } 592 if (space) { 593 while (IS_BLANK(c)) { 594 cur += l; 595 c = CUR_SCHAR(cur, l); 596 } 597 } 598 if (c != 0) 599 return(1); 600 return(0); 601 } 602 603 /** 604 * xmlValidateNMToken: 605 * @value: the value to check 606 * @space: allow spaces in front and end of the string 607 * 608 * Check that a value conforms to the lexical space of NMToken 609 * 610 * Returns 0 if this validates, a positive error code number otherwise 611 * and -1 in case of internal or API error. 612 */ 613 int 614 xmlValidateNMToken(const xmlChar *value, int space) { 615 const xmlChar *cur = value; 616 int c,l; 617 618 if (value == NULL) 619 return(-1); 620 /* 621 * First quick algorithm for ASCII range 622 */ 623 if (space) 624 while (IS_BLANK_CH(*cur)) cur++; 625 if (((*cur >= 'a') && (*cur <= 'z')) || 626 ((*cur >= 'A') && (*cur <= 'Z')) || 627 ((*cur >= '0') && (*cur <= '9')) || 628 (*cur == '_') || (*cur == '-') || (*cur == '.') || (*cur == ':')) 629 cur++; 630 else 631 goto try_complex; 632 while (((*cur >= 'a') && (*cur <= 'z')) || 633 ((*cur >= 'A') && (*cur <= 'Z')) || 634 ((*cur >= '0') && (*cur <= '9')) || 635 (*cur == '_') || (*cur == '-') || (*cur == '.') || (*cur == ':')) 636 cur++; 637 if (space) 638 while (IS_BLANK_CH(*cur)) cur++; 639 if (*cur == 0) 640 return(0); 641 642 try_complex: 643 /* 644 * Second check for chars outside the ASCII range 645 */ 646 cur = value; 647 c = CUR_SCHAR(cur, l); 648 if (space) { 649 while (IS_BLANK(c)) { 650 cur += l; 651 c = CUR_SCHAR(cur, l); 652 } 653 } 654 if (!(IS_LETTER(c) || IS_DIGIT(c) || (c == '.') || (c == ':') || 655 (c == '-') || (c == '_') || IS_COMBINING(c) || IS_EXTENDER(c))) 656 return(1); 657 cur += l; 658 c = CUR_SCHAR(cur, l); 659 while (IS_LETTER(c) || IS_DIGIT(c) || (c == '.') || (c == ':') || 660 (c == '-') || (c == '_') || IS_COMBINING(c) || IS_EXTENDER(c)) { 661 cur += l; 662 c = CUR_SCHAR(cur, l); 663 } 664 if (space) { 665 while (IS_BLANK(c)) { 666 cur += l; 667 c = CUR_SCHAR(cur, l); 668 } 669 } 670 if (c != 0) 671 return(1); 672 return(0); 673 } 674 #endif /* LIBXML_TREE_ENABLED */ 675 676 /************************************************************************ 677 * * 678 * Allocation and deallocation of basic structures * 679 * * 680 ************************************************************************/ 681 682 /** 683 * xmlSetBufferAllocationScheme: 684 * @scheme: allocation method to use 685 * 686 * Set the buffer allocation method. Types are 687 * XML_BUFFER_ALLOC_EXACT - use exact sizes, keeps memory usage down 688 * XML_BUFFER_ALLOC_DOUBLEIT - double buffer when extra needed, 689 * improves performance 690 */ 691 void 692 xmlSetBufferAllocationScheme(xmlBufferAllocationScheme scheme) { 693 if ((scheme == XML_BUFFER_ALLOC_EXACT) || 694 (scheme == XML_BUFFER_ALLOC_DOUBLEIT) || 695 (scheme == XML_BUFFER_ALLOC_HYBRID)) 696 xmlBufferAllocScheme = scheme; 697 } 698 699 /** 700 * xmlGetBufferAllocationScheme: 701 * 702 * Types are 703 * XML_BUFFER_ALLOC_EXACT - use exact sizes, keeps memory usage down 704 * XML_BUFFER_ALLOC_DOUBLEIT - double buffer when extra needed, 705 * improves performance 706 * XML_BUFFER_ALLOC_HYBRID - use exact sizes on small strings to keep memory usage tight 707 * in normal usage, and doubleit on large strings to avoid 708 * pathological performance. 709 * 710 * Returns the current allocation scheme 711 */ 712 xmlBufferAllocationScheme 713 xmlGetBufferAllocationScheme(void) { 714 return(xmlBufferAllocScheme); 715 } 716 717 /** 718 * xmlNewNs: 719 * @node: the element carrying the namespace 720 * @href: the URI associated 721 * @prefix: the prefix for the namespace 722 * 723 * Creation of a new Namespace. This function will refuse to create 724 * a namespace with a similar prefix than an existing one present on this 725 * node. 726 * Note that for a default namespace, @prefix should be NULL. 727 * 728 * We use href==NULL in the case of an element creation where the namespace 729 * was not defined. 730 * 731 * Returns a new namespace pointer or NULL 732 */ 733 xmlNsPtr 734 xmlNewNs(xmlNodePtr node, const xmlChar *href, const xmlChar *prefix) { 735 xmlNsPtr cur; 736 737 if ((node != NULL) && (node->type != XML_ELEMENT_NODE)) 738 return(NULL); 739 740 if ((prefix != NULL) && (xmlStrEqual(prefix, BAD_CAST "xml"))) { 741 /* xml namespace is predefined, no need to add it */ 742 if (xmlStrEqual(href, XML_XML_NAMESPACE)) 743 return(NULL); 744 745 /* 746 * Problem, this is an attempt to bind xml prefix to a wrong 747 * namespace, which breaks 748 * Namespace constraint: Reserved Prefixes and Namespace Names 749 * from XML namespace. But documents authors may not care in 750 * their context so let's proceed. 751 */ 752 } 753 754 /* 755 * Allocate a new Namespace and fill the fields. 756 */ 757 cur = (xmlNsPtr) xmlMalloc(sizeof(xmlNs)); 758 if (cur == NULL) { 759 xmlTreeErrMemory("building namespace"); 760 return(NULL); 761 } 762 memset(cur, 0, sizeof(xmlNs)); 763 cur->type = XML_LOCAL_NAMESPACE; 764 765 if (href != NULL) 766 cur->href = xmlStrdup(href); 767 if (prefix != NULL) 768 cur->prefix = xmlStrdup(prefix); 769 770 /* 771 * Add it at the end to preserve parsing order ... 772 * and checks for existing use of the prefix 773 */ 774 if (node != NULL) { 775 if (node->nsDef == NULL) { 776 node->nsDef = cur; 777 } else { 778 xmlNsPtr prev = node->nsDef; 779 780 if (((prev->prefix == NULL) && (cur->prefix == NULL)) || 781 (xmlStrEqual(prev->prefix, cur->prefix))) { 782 xmlFreeNs(cur); 783 return(NULL); 784 } 785 while (prev->next != NULL) { 786 prev = prev->next; 787 if (((prev->prefix == NULL) && (cur->prefix == NULL)) || 788 (xmlStrEqual(prev->prefix, cur->prefix))) { 789 xmlFreeNs(cur); 790 return(NULL); 791 } 792 } 793 prev->next = cur; 794 } 795 } 796 return(cur); 797 } 798 799 /** 800 * xmlSetNs: 801 * @node: a node in the document 802 * @ns: a namespace pointer 803 * 804 * Associate a namespace to a node, a posteriori. 805 */ 806 void 807 xmlSetNs(xmlNodePtr node, xmlNsPtr ns) { 808 if (node == NULL) { 809 #ifdef DEBUG_TREE 810 xmlGenericError(xmlGenericErrorContext, 811 "xmlSetNs: node == NULL\n"); 812 #endif 813 return; 814 } 815 if ((node->type == XML_ELEMENT_NODE) || 816 (node->type == XML_ATTRIBUTE_NODE)) 817 node->ns = ns; 818 } 819 820 /** 821 * xmlFreeNs: 822 * @cur: the namespace pointer 823 * 824 * Free up the structures associated to a namespace 825 */ 826 void 827 xmlFreeNs(xmlNsPtr cur) { 828 if (cur == NULL) { 829 #ifdef DEBUG_TREE 830 xmlGenericError(xmlGenericErrorContext, 831 "xmlFreeNs : ns == NULL\n"); 832 #endif 833 return; 834 } 835 if (cur->href != NULL) xmlFree((char *) cur->href); 836 if (cur->prefix != NULL) xmlFree((char *) cur->prefix); 837 xmlFree(cur); 838 } 839 840 /** 841 * xmlFreeNsList: 842 * @cur: the first namespace pointer 843 * 844 * Free up all the structures associated to the chained namespaces. 845 */ 846 void 847 xmlFreeNsList(xmlNsPtr cur) { 848 xmlNsPtr next; 849 if (cur == NULL) { 850 #ifdef DEBUG_TREE 851 xmlGenericError(xmlGenericErrorContext, 852 "xmlFreeNsList : ns == NULL\n"); 853 #endif 854 return; 855 } 856 while (cur != NULL) { 857 next = cur->next; 858 xmlFreeNs(cur); 859 cur = next; 860 } 861 } 862 863 /** 864 * xmlNewDtd: 865 * @doc: the document pointer 866 * @name: the DTD name 867 * @ExternalID: the external ID 868 * @SystemID: the system ID 869 * 870 * Creation of a new DTD for the external subset. To create an 871 * internal subset, use xmlCreateIntSubset(). 872 * 873 * Returns a pointer to the new DTD structure 874 */ 875 xmlDtdPtr 876 xmlNewDtd(xmlDocPtr doc, const xmlChar *name, 877 const xmlChar *ExternalID, const xmlChar *SystemID) { 878 xmlDtdPtr cur; 879 880 if ((doc != NULL) && (doc->extSubset != NULL)) { 881 #ifdef DEBUG_TREE 882 xmlGenericError(xmlGenericErrorContext, 883 "xmlNewDtd(%s): document %s already have a DTD %s\n", 884 /* !!! */ (char *) name, doc->name, 885 /* !!! */ (char *)doc->extSubset->name); 886 #endif 887 return(NULL); 888 } 889 890 /* 891 * Allocate a new DTD and fill the fields. 892 */ 893 cur = (xmlDtdPtr) xmlMalloc(sizeof(xmlDtd)); 894 if (cur == NULL) { 895 xmlTreeErrMemory("building DTD"); 896 return(NULL); 897 } 898 memset(cur, 0 , sizeof(xmlDtd)); 899 cur->type = XML_DTD_NODE; 900 901 if (name != NULL) 902 cur->name = xmlStrdup(name); 903 if (ExternalID != NULL) 904 cur->ExternalID = xmlStrdup(ExternalID); 905 if (SystemID != NULL) 906 cur->SystemID = xmlStrdup(SystemID); 907 if (doc != NULL) 908 doc->extSubset = cur; 909 cur->doc = doc; 910 911 if ((__xmlRegisterCallbacks) && (xmlRegisterNodeDefaultValue)) 912 xmlRegisterNodeDefaultValue((xmlNodePtr)cur); 913 return(cur); 914 } 915 916 /** 917 * xmlGetIntSubset: 918 * @doc: the document pointer 919 * 920 * Get the internal subset of a document 921 * Returns a pointer to the DTD structure or NULL if not found 922 */ 923 924 xmlDtdPtr 925 xmlGetIntSubset(const xmlDoc *doc) { 926 xmlNodePtr cur; 927 928 if (doc == NULL) 929 return(NULL); 930 cur = doc->children; 931 while (cur != NULL) { 932 if (cur->type == XML_DTD_NODE) 933 return((xmlDtdPtr) cur); 934 cur = cur->next; 935 } 936 return((xmlDtdPtr) doc->intSubset); 937 } 938 939 /** 940 * xmlCreateIntSubset: 941 * @doc: the document pointer 942 * @name: the DTD name 943 * @ExternalID: the external (PUBLIC) ID 944 * @SystemID: the system ID 945 * 946 * Create the internal subset of a document 947 * Returns a pointer to the new DTD structure 948 */ 949 xmlDtdPtr 950 xmlCreateIntSubset(xmlDocPtr doc, const xmlChar *name, 951 const xmlChar *ExternalID, const xmlChar *SystemID) { 952 xmlDtdPtr cur; 953 954 if ((doc != NULL) && (xmlGetIntSubset(doc) != NULL)) { 955 #ifdef DEBUG_TREE 956 xmlGenericError(xmlGenericErrorContext, 957 958 "xmlCreateIntSubset(): document %s already have an internal subset\n", 959 doc->name); 960 #endif 961 return(NULL); 962 } 963 964 /* 965 * Allocate a new DTD and fill the fields. 966 */ 967 cur = (xmlDtdPtr) xmlMalloc(sizeof(xmlDtd)); 968 if (cur == NULL) { 969 xmlTreeErrMemory("building internal subset"); 970 return(NULL); 971 } 972 memset(cur, 0, sizeof(xmlDtd)); 973 cur->type = XML_DTD_NODE; 974 975 if (name != NULL) { 976 cur->name = xmlStrdup(name); 977 if (cur->name == NULL) { 978 xmlTreeErrMemory("building internal subset"); 979 xmlFree(cur); 980 return(NULL); 981 } 982 } 983 if (ExternalID != NULL) { 984 cur->ExternalID = xmlStrdup(ExternalID); 985 if (cur->ExternalID == NULL) { 986 xmlTreeErrMemory("building internal subset"); 987 if (cur->name != NULL) 988 xmlFree((char *)cur->name); 989 xmlFree(cur); 990 return(NULL); 991 } 992 } 993 if (SystemID != NULL) { 994 cur->SystemID = xmlStrdup(SystemID); 995 if (cur->SystemID == NULL) { 996 xmlTreeErrMemory("building internal subset"); 997 if (cur->name != NULL) 998 xmlFree((char *)cur->name); 999 if (cur->ExternalID != NULL) 1000 xmlFree((char *)cur->ExternalID); 1001 xmlFree(cur); 1002 return(NULL); 1003 } 1004 } 1005 if (doc != NULL) { 1006 doc->intSubset = cur; 1007 cur->parent = doc; 1008 cur->doc = doc; 1009 if (doc->children == NULL) { 1010 doc->children = (xmlNodePtr) cur; 1011 doc->last = (xmlNodePtr) cur; 1012 } else { 1013 if (doc->type == XML_HTML_DOCUMENT_NODE) { 1014 xmlNodePtr prev; 1015 1016 prev = doc->children; 1017 prev->prev = (xmlNodePtr) cur; 1018 cur->next = prev; 1019 doc->children = (xmlNodePtr) cur; 1020 } else { 1021 xmlNodePtr next; 1022 1023 next = doc->children; 1024 while ((next != NULL) && (next->type != XML_ELEMENT_NODE)) 1025 next = next->next; 1026 if (next == NULL) { 1027 cur->prev = doc->last; 1028 cur->prev->next = (xmlNodePtr) cur; 1029 cur->next = NULL; 1030 doc->last = (xmlNodePtr) cur; 1031 } else { 1032 cur->next = next; 1033 cur->prev = next->prev; 1034 if (cur->prev == NULL) 1035 doc->children = (xmlNodePtr) cur; 1036 else 1037 cur->prev->next = (xmlNodePtr) cur; 1038 next->prev = (xmlNodePtr) cur; 1039 } 1040 } 1041 } 1042 } 1043 1044 if ((__xmlRegisterCallbacks) && (xmlRegisterNodeDefaultValue)) 1045 xmlRegisterNodeDefaultValue((xmlNodePtr)cur); 1046 return(cur); 1047 } 1048 1049 /** 1050 * DICT_FREE: 1051 * @str: a string 1052 * 1053 * Free a string if it is not owned by the "dict" dictionary in the 1054 * current scope 1055 */ 1056 #define DICT_FREE(str) \ 1057 if ((str) && ((!dict) || \ 1058 (xmlDictOwns(dict, (const xmlChar *)(str)) == 0))) \ 1059 xmlFree((char *)(str)); 1060 1061 1062 /** 1063 * DICT_COPY: 1064 * @str: a string 1065 * 1066 * Copy a string using a "dict" dictionary in the current scope, 1067 * if availabe. 1068 */ 1069 #define DICT_COPY(str, cpy) \ 1070 if (str) { \ 1071 if (dict) { \ 1072 if (xmlDictOwns(dict, (const xmlChar *)(str))) \ 1073 cpy = (xmlChar *) (str); \ 1074 else \ 1075 cpy = (xmlChar *) xmlDictLookup((dict), (const xmlChar *)(str), -1); \ 1076 } else \ 1077 cpy = xmlStrdup((const xmlChar *)(str)); } 1078 1079 /** 1080 * DICT_CONST_COPY: 1081 * @str: a string 1082 * 1083 * Copy a string using a "dict" dictionary in the current scope, 1084 * if availabe. 1085 */ 1086 #define DICT_CONST_COPY(str, cpy) \ 1087 if (str) { \ 1088 if (dict) { \ 1089 if (xmlDictOwns(dict, (const xmlChar *)(str))) \ 1090 cpy = (const xmlChar *) (str); \ 1091 else \ 1092 cpy = xmlDictLookup((dict), (const xmlChar *)(str), -1); \ 1093 } else \ 1094 cpy = (const xmlChar *) xmlStrdup((const xmlChar *)(str)); } 1095 1096 1097 /** 1098 * xmlFreeDtd: 1099 * @cur: the DTD structure to free up 1100 * 1101 * Free a DTD structure. 1102 */ 1103 void 1104 xmlFreeDtd(xmlDtdPtr cur) { 1105 xmlDictPtr dict = NULL; 1106 1107 if (cur == NULL) { 1108 return; 1109 } 1110 if (cur->doc != NULL) dict = cur->doc->dict; 1111 1112 if ((__xmlRegisterCallbacks) && (xmlDeregisterNodeDefaultValue)) 1113 xmlDeregisterNodeDefaultValue((xmlNodePtr)cur); 1114 1115 if (cur->children != NULL) { 1116 xmlNodePtr next, c = cur->children; 1117 1118 /* 1119 * Cleanup all nodes which are not part of the specific lists 1120 * of notations, elements, attributes and entities. 1121 */ 1122 while (c != NULL) { 1123 next = c->next; 1124 if ((c->type != XML_NOTATION_NODE) && 1125 (c->type != XML_ELEMENT_DECL) && 1126 (c->type != XML_ATTRIBUTE_DECL) && 1127 (c->type != XML_ENTITY_DECL)) { 1128 xmlUnlinkNode(c); 1129 xmlFreeNode(c); 1130 } 1131 c = next; 1132 } 1133 } 1134 DICT_FREE(cur->name) 1135 DICT_FREE(cur->SystemID) 1136 DICT_FREE(cur->ExternalID) 1137 /* TODO !!! */ 1138 if (cur->notations != NULL) 1139 xmlFreeNotationTable((xmlNotationTablePtr) cur->notations); 1140 1141 if (cur->elements != NULL) 1142 xmlFreeElementTable((xmlElementTablePtr) cur->elements); 1143 if (cur->attributes != NULL) 1144 xmlFreeAttributeTable((xmlAttributeTablePtr) cur->attributes); 1145 if (cur->entities != NULL) 1146 xmlFreeEntitiesTable((xmlEntitiesTablePtr) cur->entities); 1147 if (cur->pentities != NULL) 1148 xmlFreeEntitiesTable((xmlEntitiesTablePtr) cur->pentities); 1149 1150 xmlFree(cur); 1151 } 1152 1153 /** 1154 * xmlNewDoc: 1155 * @version: xmlChar string giving the version of XML "1.0" 1156 * 1157 * Creates a new XML document 1158 * 1159 * Returns a new document 1160 */ 1161 xmlDocPtr 1162 xmlNewDoc(const xmlChar *version) { 1163 xmlDocPtr cur; 1164 1165 if (version == NULL) 1166 version = (const xmlChar *) "1.0"; 1167 1168 /* 1169 * Allocate a new document and fill the fields. 1170 */ 1171 cur = (xmlDocPtr) xmlMalloc(sizeof(xmlDoc)); 1172 if (cur == NULL) { 1173 xmlTreeErrMemory("building doc"); 1174 return(NULL); 1175 } 1176 memset(cur, 0, sizeof(xmlDoc)); 1177 cur->type = XML_DOCUMENT_NODE; 1178 1179 cur->version = xmlStrdup(version); 1180 if (cur->version == NULL) { 1181 xmlTreeErrMemory("building doc"); 1182 xmlFree(cur); 1183 return(NULL); 1184 } 1185 cur->standalone = -1; 1186 cur->compression = -1; /* not initialized */ 1187 cur->doc = cur; 1188 cur->parseFlags = 0; 1189 cur->properties = XML_DOC_USERBUILT; 1190 /* 1191 * The in memory encoding is always UTF8 1192 * This field will never change and would 1193 * be obsolete if not for binary compatibility. 1194 */ 1195 cur->charset = XML_CHAR_ENCODING_UTF8; 1196 1197 if ((__xmlRegisterCallbacks) && (xmlRegisterNodeDefaultValue)) 1198 xmlRegisterNodeDefaultValue((xmlNodePtr)cur); 1199 return(cur); 1200 } 1201 1202 /** 1203 * xmlFreeDoc: 1204 * @cur: pointer to the document 1205 * 1206 * Free up all the structures used by a document, tree included. 1207 */ 1208 void 1209 xmlFreeDoc(xmlDocPtr cur) { 1210 xmlDtdPtr extSubset, intSubset; 1211 xmlDictPtr dict = NULL; 1212 1213 if (cur == NULL) { 1214 #ifdef DEBUG_TREE 1215 xmlGenericError(xmlGenericErrorContext, 1216 "xmlFreeDoc : document == NULL\n"); 1217 #endif 1218 return; 1219 } 1220 #ifdef LIBXML_DEBUG_RUNTIME 1221 #ifdef LIBXML_DEBUG_ENABLED 1222 xmlDebugCheckDocument(stderr, cur); 1223 #endif 1224 #endif 1225 1226 if (cur != NULL) dict = cur->dict; 1227 1228 if ((__xmlRegisterCallbacks) && (xmlDeregisterNodeDefaultValue)) 1229 xmlDeregisterNodeDefaultValue((xmlNodePtr)cur); 1230 1231 /* 1232 * Do this before freeing the children list to avoid ID lookups 1233 */ 1234 if (cur->ids != NULL) xmlFreeIDTable((xmlIDTablePtr) cur->ids); 1235 cur->ids = NULL; 1236 if (cur->refs != NULL) xmlFreeRefTable((xmlRefTablePtr) cur->refs); 1237 cur->refs = NULL; 1238 extSubset = cur->extSubset; 1239 intSubset = cur->intSubset; 1240 if (intSubset == extSubset) 1241 extSubset = NULL; 1242 if (extSubset != NULL) { 1243 xmlUnlinkNode((xmlNodePtr) cur->extSubset); 1244 cur->extSubset = NULL; 1245 xmlFreeDtd(extSubset); 1246 } 1247 if (intSubset != NULL) { 1248 xmlUnlinkNode((xmlNodePtr) cur->intSubset); 1249 cur->intSubset = NULL; 1250 xmlFreeDtd(intSubset); 1251 } 1252 1253 if (cur->children != NULL) xmlFreeNodeList(cur->children); 1254 if (cur->oldNs != NULL) xmlFreeNsList(cur->oldNs); 1255 1256 DICT_FREE(cur->version) 1257 DICT_FREE(cur->name) 1258 DICT_FREE(cur->encoding) 1259 DICT_FREE(cur->URL) 1260 xmlFree(cur); 1261 if (dict) xmlDictFree(dict); 1262 } 1263 1264 /** 1265 * xmlStringLenGetNodeList: 1266 * @doc: the document 1267 * @value: the value of the text 1268 * @len: the length of the string value 1269 * 1270 * Parse the value string and build the node list associated. Should 1271 * produce a flat tree with only TEXTs and ENTITY_REFs. 1272 * Returns a pointer to the first child 1273 */ 1274 xmlNodePtr 1275 xmlStringLenGetNodeList(const xmlDoc *doc, const xmlChar *value, int len) { 1276 xmlNodePtr ret = NULL, last = NULL; 1277 xmlNodePtr node; 1278 xmlChar *val; 1279 const xmlChar *cur = value, *end = cur + len; 1280 const xmlChar *q; 1281 xmlEntityPtr ent; 1282 xmlBufPtr buf; 1283 1284 if (value == NULL) return(NULL); 1285 1286 buf = xmlBufCreateSize(0); 1287 if (buf == NULL) return(NULL); 1288 xmlBufSetAllocationScheme(buf, XML_BUFFER_ALLOC_HYBRID); 1289 1290 q = cur; 1291 while ((cur < end) && (*cur != 0)) { 1292 if (cur[0] == '&') { 1293 int charval = 0; 1294 xmlChar tmp; 1295 1296 /* 1297 * Save the current text. 1298 */ 1299 if (cur != q) { 1300 if (xmlBufAdd(buf, q, cur - q)) 1301 goto out; 1302 } 1303 q = cur; 1304 if ((cur + 2 < end) && (cur[1] == '#') && (cur[2] == 'x')) { 1305 cur += 3; 1306 if (cur < end) 1307 tmp = *cur; 1308 else 1309 tmp = 0; 1310 while (tmp != ';') { /* Non input consuming loop */ 1311 if ((tmp >= '0') && (tmp <= '9')) 1312 charval = charval * 16 + (tmp - '0'); 1313 else if ((tmp >= 'a') && (tmp <= 'f')) 1314 charval = charval * 16 + (tmp - 'a') + 10; 1315 else if ((tmp >= 'A') && (tmp <= 'F')) 1316 charval = charval * 16 + (tmp - 'A') + 10; 1317 else { 1318 xmlTreeErr(XML_TREE_INVALID_HEX, (xmlNodePtr) doc, 1319 NULL); 1320 charval = 0; 1321 break; 1322 } 1323 cur++; 1324 if (cur < end) 1325 tmp = *cur; 1326 else 1327 tmp = 0; 1328 } 1329 if (tmp == ';') 1330 cur++; 1331 q = cur; 1332 } else if ((cur + 1 < end) && (cur[1] == '#')) { 1333 cur += 2; 1334 if (cur < end) 1335 tmp = *cur; 1336 else 1337 tmp = 0; 1338 while (tmp != ';') { /* Non input consuming loops */ 1339 if ((tmp >= '0') && (tmp <= '9')) 1340 charval = charval * 10 + (tmp - '0'); 1341 else { 1342 xmlTreeErr(XML_TREE_INVALID_DEC, (xmlNodePtr) doc, 1343 NULL); 1344 charval = 0; 1345 break; 1346 } 1347 cur++; 1348 if (cur < end) 1349 tmp = *cur; 1350 else 1351 tmp = 0; 1352 } 1353 if (tmp == ';') 1354 cur++; 1355 q = cur; 1356 } else { 1357 /* 1358 * Read the entity string 1359 */ 1360 cur++; 1361 q = cur; 1362 while ((cur < end) && (*cur != 0) && (*cur != ';')) cur++; 1363 if ((cur >= end) || (*cur == 0)) { 1364 xmlTreeErr(XML_TREE_UNTERMINATED_ENTITY, (xmlNodePtr) doc, 1365 (const char *) q); 1366 goto out; 1367 } 1368 if (cur != q) { 1369 /* 1370 * Predefined entities don't generate nodes 1371 */ 1372 val = xmlStrndup(q, cur - q); 1373 ent = xmlGetDocEntity(doc, val); 1374 if ((ent != NULL) && 1375 (ent->etype == XML_INTERNAL_PREDEFINED_ENTITY)) { 1376 1377 if (xmlBufCat(buf, ent->content)) 1378 goto out; 1379 1380 } else { 1381 /* 1382 * Flush buffer so far 1383 */ 1384 if (!xmlBufIsEmpty(buf)) { 1385 node = xmlNewDocText(doc, NULL); 1386 if (node == NULL) { 1387 if (val != NULL) xmlFree(val); 1388 goto out; 1389 } 1390 node->content = xmlBufDetach(buf); 1391 1392 if (last == NULL) { 1393 last = ret = node; 1394 } else { 1395 last = xmlAddNextSibling(last, node); 1396 } 1397 } 1398 1399 /* 1400 * Create a new REFERENCE_REF node 1401 */ 1402 node = xmlNewReference(doc, val); 1403 if (node == NULL) { 1404 if (val != NULL) xmlFree(val); 1405 goto out; 1406 } 1407 else if ((ent != NULL) && (ent->children == NULL)) { 1408 xmlNodePtr temp; 1409 1410 /* Set to non-NULL value to avoid recursion. */ 1411 ent->children = (xmlNodePtr) -1; 1412 ent->children = xmlStringGetNodeList(doc, 1413 (const xmlChar*)node->content); 1414 ent->owner = 1; 1415 temp = ent->children; 1416 while (temp) { 1417 temp->parent = (xmlNodePtr)ent; 1418 ent->last = temp; 1419 temp = temp->next; 1420 } 1421 } 1422 if (last == NULL) { 1423 last = ret = node; 1424 } else { 1425 last = xmlAddNextSibling(last, node); 1426 } 1427 } 1428 xmlFree(val); 1429 } 1430 cur++; 1431 q = cur; 1432 } 1433 if (charval != 0) { 1434 xmlChar buffer[10]; 1435 int l; 1436 1437 l = xmlCopyCharMultiByte(buffer, charval); 1438 buffer[l] = 0; 1439 1440 if (xmlBufCat(buf, buffer)) 1441 goto out; 1442 charval = 0; 1443 } 1444 } else 1445 cur++; 1446 } 1447 1448 if (cur != q) { 1449 /* 1450 * Handle the last piece of text. 1451 */ 1452 if (xmlBufAdd(buf, q, cur - q)) 1453 goto out; 1454 } 1455 1456 if (!xmlBufIsEmpty(buf)) { 1457 node = xmlNewDocText(doc, NULL); 1458 if (node == NULL) goto out; 1459 node->content = xmlBufDetach(buf); 1460 1461 if (last == NULL) { 1462 ret = node; 1463 } else { 1464 xmlAddNextSibling(last, node); 1465 } 1466 } else if (ret == NULL) { 1467 ret = xmlNewDocText(doc, BAD_CAST ""); 1468 } 1469 1470 out: 1471 xmlBufFree(buf); 1472 return(ret); 1473 } 1474 1475 /** 1476 * xmlStringGetNodeList: 1477 * @doc: the document 1478 * @value: the value of the attribute 1479 * 1480 * Parse the value string and build the node list associated. Should 1481 * produce a flat tree with only TEXTs and ENTITY_REFs. 1482 * Returns a pointer to the first child 1483 */ 1484 xmlNodePtr 1485 xmlStringGetNodeList(const xmlDoc *doc, const xmlChar *value) { 1486 xmlNodePtr ret = NULL, last = NULL; 1487 xmlNodePtr node; 1488 xmlChar *val; 1489 const xmlChar *cur = value; 1490 const xmlChar *q; 1491 xmlEntityPtr ent; 1492 xmlBufPtr buf; 1493 1494 if (value == NULL) return(NULL); 1495 1496 buf = xmlBufCreateSize(0); 1497 if (buf == NULL) return(NULL); 1498 xmlBufSetAllocationScheme(buf, XML_BUFFER_ALLOC_HYBRID); 1499 1500 q = cur; 1501 while (*cur != 0) { 1502 if (cur[0] == '&') { 1503 int charval = 0; 1504 xmlChar tmp; 1505 1506 /* 1507 * Save the current text. 1508 */ 1509 if (cur != q) { 1510 if (xmlBufAdd(buf, q, cur - q)) 1511 goto out; 1512 } 1513 q = cur; 1514 if ((cur[1] == '#') && (cur[2] == 'x')) { 1515 cur += 3; 1516 tmp = *cur; 1517 while (tmp != ';') { /* Non input consuming loop */ 1518 if ((tmp >= '0') && (tmp <= '9')) 1519 charval = charval * 16 + (tmp - '0'); 1520 else if ((tmp >= 'a') && (tmp <= 'f')) 1521 charval = charval * 16 + (tmp - 'a') + 10; 1522 else if ((tmp >= 'A') && (tmp <= 'F')) 1523 charval = charval * 16 + (tmp - 'A') + 10; 1524 else { 1525 xmlTreeErr(XML_TREE_INVALID_HEX, (xmlNodePtr) doc, 1526 NULL); 1527 charval = 0; 1528 break; 1529 } 1530 cur++; 1531 tmp = *cur; 1532 } 1533 if (tmp == ';') 1534 cur++; 1535 q = cur; 1536 } else if (cur[1] == '#') { 1537 cur += 2; 1538 tmp = *cur; 1539 while (tmp != ';') { /* Non input consuming loops */ 1540 if ((tmp >= '0') && (tmp <= '9')) 1541 charval = charval * 10 + (tmp - '0'); 1542 else { 1543 xmlTreeErr(XML_TREE_INVALID_DEC, (xmlNodePtr) doc, 1544 NULL); 1545 charval = 0; 1546 break; 1547 } 1548 cur++; 1549 tmp = *cur; 1550 } 1551 if (tmp == ';') 1552 cur++; 1553 q = cur; 1554 } else { 1555 /* 1556 * Read the entity string 1557 */ 1558 cur++; 1559 q = cur; 1560 while ((*cur != 0) && (*cur != ';')) cur++; 1561 if (*cur == 0) { 1562 xmlTreeErr(XML_TREE_UNTERMINATED_ENTITY, 1563 (xmlNodePtr) doc, (const char *) q); 1564 goto out; 1565 } 1566 if (cur != q) { 1567 /* 1568 * Predefined entities don't generate nodes 1569 */ 1570 val = xmlStrndup(q, cur - q); 1571 ent = xmlGetDocEntity(doc, val); 1572 if ((ent != NULL) && 1573 (ent->etype == XML_INTERNAL_PREDEFINED_ENTITY)) { 1574 1575 if (xmlBufCat(buf, ent->content)) 1576 goto out; 1577 1578 } else { 1579 /* 1580 * Flush buffer so far 1581 */ 1582 if (!xmlBufIsEmpty(buf)) { 1583 node = xmlNewDocText(doc, NULL); 1584 node->content = xmlBufDetach(buf); 1585 1586 if (last == NULL) { 1587 last = ret = node; 1588 } else { 1589 last = xmlAddNextSibling(last, node); 1590 } 1591 } 1592 1593 /* 1594 * Create a new REFERENCE_REF node 1595 */ 1596 node = xmlNewReference(doc, val); 1597 if (node == NULL) { 1598 if (val != NULL) xmlFree(val); 1599 goto out; 1600 } 1601 else if ((ent != NULL) && (ent->children == NULL)) { 1602 xmlNodePtr temp; 1603 1604 /* Set to non-NULL value to avoid recursion. */ 1605 ent->children = (xmlNodePtr) -1; 1606 ent->children = xmlStringGetNodeList(doc, 1607 (const xmlChar*)node->content); 1608 ent->owner = 1; 1609 temp = ent->children; 1610 while (temp) { 1611 temp->parent = (xmlNodePtr)ent; 1612 ent->last = temp; 1613 temp = temp->next; 1614 } 1615 } 1616 if (last == NULL) { 1617 last = ret = node; 1618 } else { 1619 last = xmlAddNextSibling(last, node); 1620 } 1621 } 1622 xmlFree(val); 1623 } 1624 cur++; 1625 q = cur; 1626 } 1627 if (charval != 0) { 1628 xmlChar buffer[10]; 1629 int len; 1630 1631 len = xmlCopyCharMultiByte(buffer, charval); 1632 buffer[len] = 0; 1633 1634 if (xmlBufCat(buf, buffer)) 1635 goto out; 1636 charval = 0; 1637 } 1638 } else 1639 cur++; 1640 } 1641 if ((cur != q) || (ret == NULL)) { 1642 /* 1643 * Handle the last piece of text. 1644 */ 1645 xmlBufAdd(buf, q, cur - q); 1646 } 1647 1648 if (!xmlBufIsEmpty(buf)) { 1649 node = xmlNewDocText(doc, NULL); 1650 node->content = xmlBufDetach(buf); 1651 1652 if (last == NULL) { 1653 ret = node; 1654 } else { 1655 xmlAddNextSibling(last, node); 1656 } 1657 } 1658 1659 out: 1660 xmlBufFree(buf); 1661 return(ret); 1662 } 1663 1664 /** 1665 * xmlNodeListGetString: 1666 * @doc: the document 1667 * @list: a Node list 1668 * @inLine: should we replace entity contents or show their external form 1669 * 1670 * Build the string equivalent to the text contained in the Node list 1671 * made of TEXTs and ENTITY_REFs 1672 * 1673 * Returns a pointer to the string copy, the caller must free it with xmlFree(). 1674 */ 1675 xmlChar * 1676 xmlNodeListGetString(xmlDocPtr doc, const xmlNode *list, int inLine) 1677 { 1678 const xmlNode *node = list; 1679 xmlChar *ret = NULL; 1680 xmlEntityPtr ent; 1681 int attr; 1682 1683 if (list == NULL) 1684 return (NULL); 1685 if ((list->parent != NULL) && (list->parent->type == XML_ATTRIBUTE_NODE)) 1686 attr = 1; 1687 else 1688 attr = 0; 1689 1690 while (node != NULL) { 1691 if ((node->type == XML_TEXT_NODE) || 1692 (node->type == XML_CDATA_SECTION_NODE)) { 1693 if (inLine) { 1694 ret = xmlStrcat(ret, node->content); 1695 } else { 1696 xmlChar *buffer; 1697 1698 if (attr) 1699 buffer = xmlEncodeAttributeEntities(doc, node->content); 1700 else 1701 buffer = xmlEncodeEntitiesReentrant(doc, node->content); 1702 if (buffer != NULL) { 1703 ret = xmlStrcat(ret, buffer); 1704 xmlFree(buffer); 1705 } 1706 } 1707 } else if (node->type == XML_ENTITY_REF_NODE) { 1708 if (inLine) { 1709 ent = xmlGetDocEntity(doc, node->name); 1710 if (ent != NULL) { 1711 xmlChar *buffer; 1712 1713 /* an entity content can be any "well balanced chunk", 1714 * i.e. the result of the content [43] production: 1715 * http://www.w3.org/TR/REC-xml#NT-content. 1716 * So it can contain text, CDATA section or nested 1717 * entity reference nodes (among others). 1718 * -> we recursive call xmlNodeListGetString() 1719 * which handles these types */ 1720 buffer = xmlNodeListGetString(doc, ent->children, 1); 1721 if (buffer != NULL) { 1722 ret = xmlStrcat(ret, buffer); 1723 xmlFree(buffer); 1724 } 1725 } else { 1726 ret = xmlStrcat(ret, node->content); 1727 } 1728 } else { 1729 xmlChar buf[2]; 1730 1731 buf[0] = '&'; 1732 buf[1] = 0; 1733 ret = xmlStrncat(ret, buf, 1); 1734 ret = xmlStrcat(ret, node->name); 1735 buf[0] = ';'; 1736 buf[1] = 0; 1737 ret = xmlStrncat(ret, buf, 1); 1738 } 1739 } 1740 #if 0 1741 else { 1742 xmlGenericError(xmlGenericErrorContext, 1743 "xmlGetNodeListString : invalid node type %d\n", 1744 node->type); 1745 } 1746 #endif 1747 node = node->next; 1748 } 1749 return (ret); 1750 } 1751 1752 #ifdef LIBXML_TREE_ENABLED 1753 /** 1754 * xmlNodeListGetRawString: 1755 * @doc: the document 1756 * @list: a Node list 1757 * @inLine: should we replace entity contents or show their external form 1758 * 1759 * Builds the string equivalent to the text contained in the Node list 1760 * made of TEXTs and ENTITY_REFs, contrary to xmlNodeListGetString() 1761 * this function doesn't do any character encoding handling. 1762 * 1763 * Returns a pointer to the string copy, the caller must free it with xmlFree(). 1764 */ 1765 xmlChar * 1766 xmlNodeListGetRawString(const xmlDoc *doc, const xmlNode *list, int inLine) 1767 { 1768 const xmlNode *node = list; 1769 xmlChar *ret = NULL; 1770 xmlEntityPtr ent; 1771 1772 if (list == NULL) 1773 return (NULL); 1774 1775 while (node != NULL) { 1776 if ((node->type == XML_TEXT_NODE) || 1777 (node->type == XML_CDATA_SECTION_NODE)) { 1778 if (inLine) { 1779 ret = xmlStrcat(ret, node->content); 1780 } else { 1781 xmlChar *buffer; 1782 1783 buffer = xmlEncodeSpecialChars(doc, node->content); 1784 if (buffer != NULL) { 1785 ret = xmlStrcat(ret, buffer); 1786 xmlFree(buffer); 1787 } 1788 } 1789 } else if (node->type == XML_ENTITY_REF_NODE) { 1790 if (inLine) { 1791 ent = xmlGetDocEntity(doc, node->name); 1792 if (ent != NULL) { 1793 xmlChar *buffer; 1794 1795 /* an entity content can be any "well balanced chunk", 1796 * i.e. the result of the content [43] production: 1797 * http://www.w3.org/TR/REC-xml#NT-content. 1798 * So it can contain text, CDATA section or nested 1799 * entity reference nodes (among others). 1800 * -> we recursive call xmlNodeListGetRawString() 1801 * which handles these types */ 1802 buffer = 1803 xmlNodeListGetRawString(doc, ent->children, 1); 1804 if (buffer != NULL) { 1805 ret = xmlStrcat(ret, buffer); 1806 xmlFree(buffer); 1807 } 1808 } else { 1809 ret = xmlStrcat(ret, node->content); 1810 } 1811 } else { 1812 xmlChar buf[2]; 1813 1814 buf[0] = '&'; 1815 buf[1] = 0; 1816 ret = xmlStrncat(ret, buf, 1); 1817 ret = xmlStrcat(ret, node->name); 1818 buf[0] = ';'; 1819 buf[1] = 0; 1820 ret = xmlStrncat(ret, buf, 1); 1821 } 1822 } 1823 #if 0 1824 else { 1825 xmlGenericError(xmlGenericErrorContext, 1826 "xmlGetNodeListString : invalid node type %d\n", 1827 node->type); 1828 } 1829 #endif 1830 node = node->next; 1831 } 1832 return (ret); 1833 } 1834 #endif /* LIBXML_TREE_ENABLED */ 1835 1836 static xmlAttrPtr 1837 xmlNewPropInternal(xmlNodePtr node, xmlNsPtr ns, 1838 const xmlChar * name, const xmlChar * value, 1839 int eatname) 1840 { 1841 xmlAttrPtr cur; 1842 xmlDocPtr doc = NULL; 1843 1844 if ((node != NULL) && (node->type != XML_ELEMENT_NODE)) { 1845 if ((eatname == 1) && 1846 ((node->doc == NULL) || 1847 (!(xmlDictOwns(node->doc->dict, name))))) 1848 xmlFree((xmlChar *) name); 1849 return (NULL); 1850 } 1851 1852 /* 1853 * Allocate a new property and fill the fields. 1854 */ 1855 cur = (xmlAttrPtr) xmlMalloc(sizeof(xmlAttr)); 1856 if (cur == NULL) { 1857 if ((eatname == 1) && 1858 ((node == NULL) || (node->doc == NULL) || 1859 (!(xmlDictOwns(node->doc->dict, name))))) 1860 xmlFree((xmlChar *) name); 1861 xmlTreeErrMemory("building attribute"); 1862 return (NULL); 1863 } 1864 memset(cur, 0, sizeof(xmlAttr)); 1865 cur->type = XML_ATTRIBUTE_NODE; 1866 1867 cur->parent = node; 1868 if (node != NULL) { 1869 doc = node->doc; 1870 cur->doc = doc; 1871 } 1872 cur->ns = ns; 1873 1874 if (eatname == 0) { 1875 if ((doc != NULL) && (doc->dict != NULL)) 1876 cur->name = (xmlChar *) xmlDictLookup(doc->dict, name, -1); 1877 else 1878 cur->name = xmlStrdup(name); 1879 } else 1880 cur->name = name; 1881 1882 if (value != NULL) { 1883 xmlNodePtr tmp; 1884 1885 if(!xmlCheckUTF8(value)) { 1886 xmlTreeErr(XML_TREE_NOT_UTF8, (xmlNodePtr) doc, 1887 NULL); 1888 if (doc != NULL) 1889 doc->encoding = xmlStrdup(BAD_CAST "ISO-8859-1"); 1890 } 1891 cur->children = xmlNewDocText(doc, value); 1892 cur->last = NULL; 1893 tmp = cur->children; 1894 while (tmp != NULL) { 1895 tmp->parent = (xmlNodePtr) cur; 1896 if (tmp->next == NULL) 1897 cur->last = tmp; 1898 tmp = tmp->next; 1899 } 1900 } 1901 1902 /* 1903 * Add it at the end to preserve parsing order ... 1904 */ 1905 if (node != NULL) { 1906 if (node->properties == NULL) { 1907 node->properties = cur; 1908 } else { 1909 xmlAttrPtr prev = node->properties; 1910 1911 while (prev->next != NULL) 1912 prev = prev->next; 1913 prev->next = cur; 1914 cur->prev = prev; 1915 } 1916 } 1917 1918 if ((value != NULL) && (node != NULL) && 1919 (xmlIsID(node->doc, node, cur) == 1)) 1920 xmlAddID(NULL, node->doc, value, cur); 1921 1922 if ((__xmlRegisterCallbacks) && (xmlRegisterNodeDefaultValue)) 1923 xmlRegisterNodeDefaultValue((xmlNodePtr) cur); 1924 return (cur); 1925 } 1926 1927 #if defined(LIBXML_TREE_ENABLED) || defined(LIBXML_HTML_ENABLED) || \ 1928 defined(LIBXML_SCHEMAS_ENABLED) 1929 /** 1930 * xmlNewProp: 1931 * @node: the holding node 1932 * @name: the name of the attribute 1933 * @value: the value of the attribute 1934 * 1935 * Create a new property carried by a node. 1936 * Returns a pointer to the attribute 1937 */ 1938 xmlAttrPtr 1939 xmlNewProp(xmlNodePtr node, const xmlChar *name, const xmlChar *value) { 1940 1941 if (name == NULL) { 1942 #ifdef DEBUG_TREE 1943 xmlGenericError(xmlGenericErrorContext, 1944 "xmlNewProp : name == NULL\n"); 1945 #endif 1946 return(NULL); 1947 } 1948 1949 return xmlNewPropInternal(node, NULL, name, value, 0); 1950 } 1951 #endif /* LIBXML_TREE_ENABLED */ 1952 1953 /** 1954 * xmlNewNsProp: 1955 * @node: the holding node 1956 * @ns: the namespace 1957 * @name: the name of the attribute 1958 * @value: the value of the attribute 1959 * 1960 * Create a new property tagged with a namespace and carried by a node. 1961 * Returns a pointer to the attribute 1962 */ 1963 xmlAttrPtr 1964 xmlNewNsProp(xmlNodePtr node, xmlNsPtr ns, const xmlChar *name, 1965 const xmlChar *value) { 1966 1967 if (name == NULL) { 1968 #ifdef DEBUG_TREE 1969 xmlGenericError(xmlGenericErrorContext, 1970 "xmlNewNsProp : name == NULL\n"); 1971 #endif 1972 return(NULL); 1973 } 1974 1975 return xmlNewPropInternal(node, ns, name, value, 0); 1976 } 1977 1978 /** 1979 * xmlNewNsPropEatName: 1980 * @node: the holding node 1981 * @ns: the namespace 1982 * @name: the name of the attribute 1983 * @value: the value of the attribute 1984 * 1985 * Create a new property tagged with a namespace and carried by a node. 1986 * Returns a pointer to the attribute 1987 */ 1988 xmlAttrPtr 1989 xmlNewNsPropEatName(xmlNodePtr node, xmlNsPtr ns, xmlChar *name, 1990 const xmlChar *value) { 1991 1992 if (name == NULL) { 1993 #ifdef DEBUG_TREE 1994 xmlGenericError(xmlGenericErrorContext, 1995 "xmlNewNsPropEatName : name == NULL\n"); 1996 #endif 1997 return(NULL); 1998 } 1999 2000 return xmlNewPropInternal(node, ns, name, value, 1); 2001 } 2002 2003 /** 2004 * xmlNewDocProp: 2005 * @doc: the document 2006 * @name: the name of the attribute 2007 * @value: the value of the attribute 2008 * 2009 * Create a new property carried by a document. 2010 * Returns a pointer to the attribute 2011 */ 2012 xmlAttrPtr 2013 xmlNewDocProp(xmlDocPtr doc, const xmlChar *name, const xmlChar *value) { 2014 xmlAttrPtr cur; 2015 2016 if (name == NULL) { 2017 #ifdef DEBUG_TREE 2018 xmlGenericError(xmlGenericErrorContext, 2019 "xmlNewDocProp : name == NULL\n"); 2020 #endif 2021 return(NULL); 2022 } 2023 2024 /* 2025 * Allocate a new property and fill the fields. 2026 */ 2027 cur = (xmlAttrPtr) xmlMalloc(sizeof(xmlAttr)); 2028 if (cur == NULL) { 2029 xmlTreeErrMemory("building attribute"); 2030 return(NULL); 2031 } 2032 memset(cur, 0, sizeof(xmlAttr)); 2033 cur->type = XML_ATTRIBUTE_NODE; 2034 2035 if ((doc != NULL) && (doc->dict != NULL)) 2036 cur->name = xmlDictLookup(doc->dict, name, -1); 2037 else 2038 cur->name = xmlStrdup(name); 2039 cur->doc = doc; 2040 if (value != NULL) { 2041 xmlNodePtr tmp; 2042 2043 cur->children = xmlStringGetNodeList(doc, value); 2044 cur->last = NULL; 2045 2046 tmp = cur->children; 2047 while (tmp != NULL) { 2048 tmp->parent = (xmlNodePtr) cur; 2049 if (tmp->next == NULL) 2050 cur->last = tmp; 2051 tmp = tmp->next; 2052 } 2053 } 2054 2055 if ((__xmlRegisterCallbacks) && (xmlRegisterNodeDefaultValue)) 2056 xmlRegisterNodeDefaultValue((xmlNodePtr)cur); 2057 return(cur); 2058 } 2059 2060 /** 2061 * xmlFreePropList: 2062 * @cur: the first property in the list 2063 * 2064 * Free a property and all its siblings, all the children are freed too. 2065 */ 2066 void 2067 xmlFreePropList(xmlAttrPtr cur) { 2068 xmlAttrPtr next; 2069 if (cur == NULL) return; 2070 while (cur != NULL) { 2071 next = cur->next; 2072 xmlFreeProp(cur); 2073 cur = next; 2074 } 2075 } 2076 2077 /** 2078 * xmlFreeProp: 2079 * @cur: an attribute 2080 * 2081 * Free one attribute, all the content is freed too 2082 */ 2083 void 2084 xmlFreeProp(xmlAttrPtr cur) { 2085 xmlDictPtr dict = NULL; 2086 if (cur == NULL) return; 2087 2088 if (cur->doc != NULL) dict = cur->doc->dict; 2089 2090 if ((__xmlRegisterCallbacks) && (xmlDeregisterNodeDefaultValue)) 2091 xmlDeregisterNodeDefaultValue((xmlNodePtr)cur); 2092 2093 /* Check for ID removal -> leading to invalid references ! */ 2094 if ((cur->doc != NULL) && (cur->atype == XML_ATTRIBUTE_ID)) { 2095 xmlRemoveID(cur->doc, cur); 2096 } 2097 if (cur->children != NULL) xmlFreeNodeList(cur->children); 2098 DICT_FREE(cur->name) 2099 xmlFree(cur); 2100 } 2101 2102 /** 2103 * xmlRemoveProp: 2104 * @cur: an attribute 2105 * 2106 * Unlink and free one attribute, all the content is freed too 2107 * Note this doesn't work for namespace definition attributes 2108 * 2109 * Returns 0 if success and -1 in case of error. 2110 */ 2111 int 2112 xmlRemoveProp(xmlAttrPtr cur) { 2113 xmlAttrPtr tmp; 2114 if (cur == NULL) { 2115 #ifdef DEBUG_TREE 2116 xmlGenericError(xmlGenericErrorContext, 2117 "xmlRemoveProp : cur == NULL\n"); 2118 #endif 2119 return(-1); 2120 } 2121 if (cur->parent == NULL) { 2122 #ifdef DEBUG_TREE 2123 xmlGenericError(xmlGenericErrorContext, 2124 "xmlRemoveProp : cur->parent == NULL\n"); 2125 #endif 2126 return(-1); 2127 } 2128 tmp = cur->parent->properties; 2129 if (tmp == cur) { 2130 cur->parent->properties = cur->next; 2131 if (cur->next != NULL) 2132 cur->next->prev = NULL; 2133 xmlFreeProp(cur); 2134 return(0); 2135 } 2136 while (tmp != NULL) { 2137 if (tmp->next == cur) { 2138 tmp->next = cur->next; 2139 if (tmp->next != NULL) 2140 tmp->next->prev = tmp; 2141 xmlFreeProp(cur); 2142 return(0); 2143 } 2144 tmp = tmp->next; 2145 } 2146 #ifdef DEBUG_TREE 2147 xmlGenericError(xmlGenericErrorContext, 2148 "xmlRemoveProp : attribute not owned by its node\n"); 2149 #endif 2150 return(-1); 2151 } 2152 2153 /** 2154 * xmlNewDocPI: 2155 * @doc: the target document 2156 * @name: the processing instruction name 2157 * @content: the PI content 2158 * 2159 * Creation of a processing instruction element. 2160 * Returns a pointer to the new node object. 2161 */ 2162 xmlNodePtr 2163 xmlNewDocPI(xmlDocPtr doc, const xmlChar *name, const xmlChar *content) { 2164 xmlNodePtr cur; 2165 2166 if (name == NULL) { 2167 #ifdef DEBUG_TREE 2168 xmlGenericError(xmlGenericErrorContext, 2169 "xmlNewPI : name == NULL\n"); 2170 #endif 2171 return(NULL); 2172 } 2173 2174 /* 2175 * Allocate a new node and fill the fields. 2176 */ 2177 cur = (xmlNodePtr) xmlMalloc(sizeof(xmlNode)); 2178 if (cur == NULL) { 2179 xmlTreeErrMemory("building PI"); 2180 return(NULL); 2181 } 2182 memset(cur, 0, sizeof(xmlNode)); 2183 cur->type = XML_PI_NODE; 2184 2185 if ((doc != NULL) && (doc->dict != NULL)) 2186 cur->name = xmlDictLookup(doc->dict, name, -1); 2187 else 2188 cur->name = xmlStrdup(name); 2189 if (content != NULL) { 2190 cur->content = xmlStrdup(content); 2191 } 2192 cur->doc = doc; 2193 2194 if ((__xmlRegisterCallbacks) && (xmlRegisterNodeDefaultValue)) 2195 xmlRegisterNodeDefaultValue((xmlNodePtr)cur); 2196 return(cur); 2197 } 2198 2199 /** 2200 * xmlNewPI: 2201 * @name: the processing instruction name 2202 * @content: the PI content 2203 * 2204 * Creation of a processing instruction element. 2205 * Use xmlDocNewPI preferably to get string interning 2206 * 2207 * Returns a pointer to the new node object. 2208 */ 2209 xmlNodePtr 2210 xmlNewPI(const xmlChar *name, const xmlChar *content) { 2211 return(xmlNewDocPI(NULL, name, content)); 2212 } 2213 2214 /** 2215 * xmlNewNode: 2216 * @ns: namespace if any 2217 * @name: the node name 2218 * 2219 * Creation of a new node element. @ns is optional (NULL). 2220 * 2221 * Returns a pointer to the new node object. Uses xmlStrdup() to make 2222 * copy of @name. 2223 */ 2224 xmlNodePtr 2225 xmlNewNode(xmlNsPtr ns, const xmlChar *name) { 2226 xmlNodePtr cur; 2227 2228 if (name == NULL) { 2229 #ifdef DEBUG_TREE 2230 xmlGenericError(xmlGenericErrorContext, 2231 "xmlNewNode : name == NULL\n"); 2232 #endif 2233 return(NULL); 2234 } 2235 2236 /* 2237 * Allocate a new node and fill the fields. 2238 */ 2239 cur = (xmlNodePtr) xmlMalloc(sizeof(xmlNode)); 2240 if (cur == NULL) { 2241 xmlTreeErrMemory("building node"); 2242 return(NULL); 2243 } 2244 memset(cur, 0, sizeof(xmlNode)); 2245 cur->type = XML_ELEMENT_NODE; 2246 2247 cur->name = xmlStrdup(name); 2248 cur->ns = ns; 2249 2250 if ((__xmlRegisterCallbacks) && (xmlRegisterNodeDefaultValue)) 2251 xmlRegisterNodeDefaultValue(cur); 2252 return(cur); 2253 } 2254 2255 /** 2256 * xmlNewNodeEatName: 2257 * @ns: namespace if any 2258 * @name: the node name 2259 * 2260 * Creation of a new node element. @ns is optional (NULL). 2261 * 2262 * Returns a pointer to the new node object, with pointer @name as 2263 * new node's name. Use xmlNewNode() if a copy of @name string is 2264 * is needed as new node's name. 2265 */ 2266 xmlNodePtr 2267 xmlNewNodeEatName(xmlNsPtr ns, xmlChar *name) { 2268 xmlNodePtr cur; 2269 2270 if (name == NULL) { 2271 #ifdef DEBUG_TREE 2272 xmlGenericError(xmlGenericErrorContext, 2273 "xmlNewNode : name == NULL\n"); 2274 #endif 2275 return(NULL); 2276 } 2277 2278 /* 2279 * Allocate a new node and fill the fields. 2280 */ 2281 cur = (xmlNodePtr) xmlMalloc(sizeof(xmlNode)); 2282 if (cur == NULL) { 2283 xmlTreeErrMemory("building node"); 2284 /* we can't check here that name comes from the doc dictionary */ 2285 return(NULL); 2286 } 2287 memset(cur, 0, sizeof(xmlNode)); 2288 cur->type = XML_ELEMENT_NODE; 2289 2290 cur->name = name; 2291 cur->ns = ns; 2292 2293 if ((__xmlRegisterCallbacks) && (xmlRegisterNodeDefaultValue)) 2294 xmlRegisterNodeDefaultValue((xmlNodePtr)cur); 2295 return(cur); 2296 } 2297 2298 /** 2299 * xmlNewDocNode: 2300 * @doc: the document 2301 * @ns: namespace if any 2302 * @name: the node name 2303 * @content: the XML text content if any 2304 * 2305 * Creation of a new node element within a document. @ns and @content 2306 * are optional (NULL). 2307 * NOTE: @content is supposed to be a piece of XML CDATA, so it allow entities 2308 * references, but XML special chars need to be escaped first by using 2309 * xmlEncodeEntitiesReentrant(). Use xmlNewDocRawNode() if you don't 2310 * need entities support. 2311 * 2312 * Returns a pointer to the new node object. 2313 */ 2314 xmlNodePtr 2315 xmlNewDocNode(xmlDocPtr doc, xmlNsPtr ns, 2316 const xmlChar *name, const xmlChar *content) { 2317 xmlNodePtr cur; 2318 2319 if ((doc != NULL) && (doc->dict != NULL)) 2320 cur = xmlNewNodeEatName(ns, (xmlChar *) 2321 xmlDictLookup(doc->dict, name, -1)); 2322 else 2323 cur = xmlNewNode(ns, name); 2324 if (cur != NULL) { 2325 cur->doc = doc; 2326 if (content != NULL) { 2327 cur->children = xmlStringGetNodeList(doc, content); 2328 UPDATE_LAST_CHILD_AND_PARENT(cur) 2329 } 2330 } 2331 2332 return(cur); 2333 } 2334 2335 /** 2336 * xmlNewDocNodeEatName: 2337 * @doc: the document 2338 * @ns: namespace if any 2339 * @name: the node name 2340 * @content: the XML text content if any 2341 * 2342 * Creation of a new node element within a document. @ns and @content 2343 * are optional (NULL). 2344 * NOTE: @content is supposed to be a piece of XML CDATA, so it allow entities 2345 * references, but XML special chars need to be escaped first by using 2346 * xmlEncodeEntitiesReentrant(). Use xmlNewDocRawNode() if you don't 2347 * need entities support. 2348 * 2349 * Returns a pointer to the new node object. 2350 */ 2351 xmlNodePtr 2352 xmlNewDocNodeEatName(xmlDocPtr doc, xmlNsPtr ns, 2353 xmlChar *name, const xmlChar *content) { 2354 xmlNodePtr cur; 2355 2356 cur = xmlNewNodeEatName(ns, name); 2357 if (cur != NULL) { 2358 cur->doc = doc; 2359 if (content != NULL) { 2360 cur->children = xmlStringGetNodeList(doc, content); 2361 UPDATE_LAST_CHILD_AND_PARENT(cur) 2362 } 2363 } else { 2364 /* if name don't come from the doc dictionary free it here */ 2365 if ((name != NULL) && (doc != NULL) && 2366 (!(xmlDictOwns(doc->dict, name)))) 2367 xmlFree(name); 2368 } 2369 return(cur); 2370 } 2371 2372 #ifdef LIBXML_TREE_ENABLED 2373 /** 2374 * xmlNewDocRawNode: 2375 * @doc: the document 2376 * @ns: namespace if any 2377 * @name: the node name 2378 * @content: the text content if any 2379 * 2380 * Creation of a new node element within a document. @ns and @content 2381 * are optional (NULL). 2382 * 2383 * Returns a pointer to the new node object. 2384 */ 2385 xmlNodePtr 2386 xmlNewDocRawNode(xmlDocPtr doc, xmlNsPtr ns, 2387 const xmlChar *name, const xmlChar *content) { 2388 xmlNodePtr cur; 2389 2390 cur = xmlNewDocNode(doc, ns, name, NULL); 2391 if (cur != NULL) { 2392 cur->doc = doc; 2393 if (content != NULL) { 2394 cur->children = xmlNewDocText(doc, content); 2395 UPDATE_LAST_CHILD_AND_PARENT(cur) 2396 } 2397 } 2398 return(cur); 2399 } 2400 2401 /** 2402 * xmlNewDocFragment: 2403 * @doc: the document owning the fragment 2404 * 2405 * Creation of a new Fragment node. 2406 * Returns a pointer to the new node object. 2407 */ 2408 xmlNodePtr 2409 xmlNewDocFragment(xmlDocPtr doc) { 2410 xmlNodePtr cur; 2411 2412 /* 2413 * Allocate a new DocumentFragment node and fill the fields. 2414 */ 2415 cur = (xmlNodePtr) xmlMalloc(sizeof(xmlNode)); 2416 if (cur == NULL) { 2417 xmlTreeErrMemory("building fragment"); 2418 return(NULL); 2419 } 2420 memset(cur, 0, sizeof(xmlNode)); 2421 cur->type = XML_DOCUMENT_FRAG_NODE; 2422 2423 cur->doc = doc; 2424 2425 if ((__xmlRegisterCallbacks) && (xmlRegisterNodeDefaultValue)) 2426 xmlRegisterNodeDefaultValue(cur); 2427 return(cur); 2428 } 2429 #endif /* LIBXML_TREE_ENABLED */ 2430 2431 /** 2432 * xmlNewText: 2433 * @content: the text content 2434 * 2435 * Creation of a new text node. 2436 * Returns a pointer to the new node object. 2437 */ 2438 xmlNodePtr 2439 xmlNewText(const xmlChar *content) { 2440 xmlNodePtr cur; 2441 2442 /* 2443 * Allocate a new node and fill the fields. 2444 */ 2445 cur = (xmlNodePtr) xmlMalloc(sizeof(xmlNode)); 2446 if (cur == NULL) { 2447 xmlTreeErrMemory("building text"); 2448 return(NULL); 2449 } 2450 memset(cur, 0, sizeof(xmlNode)); 2451 cur->type = XML_TEXT_NODE; 2452 2453 cur->name = xmlStringText; 2454 if (content != NULL) { 2455 cur->content = xmlStrdup(content); 2456 } 2457 2458 if ((__xmlRegisterCallbacks) && (xmlRegisterNodeDefaultValue)) 2459 xmlRegisterNodeDefaultValue(cur); 2460 return(cur); 2461 } 2462 2463 #ifdef LIBXML_TREE_ENABLED 2464 /** 2465 * xmlNewTextChild: 2466 * @parent: the parent node 2467 * @ns: a namespace if any 2468 * @name: the name of the child 2469 * @content: the text content of the child if any. 2470 * 2471 * Creation of a new child element, added at the end of @parent children list. 2472 * @ns and @content parameters are optional (NULL). If @ns is NULL, the newly 2473 * created element inherits the namespace of @parent. If @content is non NULL, 2474 * a child TEXT node will be created containing the string @content. 2475 * NOTE: Use xmlNewChild() if @content will contain entities that need to be 2476 * preserved. Use this function, xmlNewTextChild(), if you need to ensure that 2477 * reserved XML chars that might appear in @content, such as the ampersand, 2478 * greater-than or less-than signs, are automatically replaced by their XML 2479 * escaped entity representations. 2480 * 2481 * Returns a pointer to the new node object. 2482 */ 2483 xmlNodePtr 2484 xmlNewTextChild(xmlNodePtr parent, xmlNsPtr ns, 2485 const xmlChar *name, const xmlChar *content) { 2486 xmlNodePtr cur, prev; 2487 2488 if (parent == NULL) { 2489 #ifdef DEBUG_TREE 2490 xmlGenericError(xmlGenericErrorContext, 2491 "xmlNewTextChild : parent == NULL\n"); 2492 #endif 2493 return(NULL); 2494 } 2495 2496 if (name == NULL) { 2497 #ifdef DEBUG_TREE 2498 xmlGenericError(xmlGenericErrorContext, 2499 "xmlNewTextChild : name == NULL\n"); 2500 #endif 2501 return(NULL); 2502 } 2503 2504 /* 2505 * Allocate a new node 2506 */ 2507 if (parent->type == XML_ELEMENT_NODE) { 2508 if (ns == NULL) 2509 cur = xmlNewDocRawNode(parent->doc, parent->ns, name, content); 2510 else 2511 cur = xmlNewDocRawNode(parent->doc, ns, name, content); 2512 } else if ((parent->type == XML_DOCUMENT_NODE) || 2513 (parent->type == XML_HTML_DOCUMENT_NODE)) { 2514 if (ns == NULL) 2515 cur = xmlNewDocRawNode((xmlDocPtr) parent, NULL, name, content); 2516 else 2517 cur = xmlNewDocRawNode((xmlDocPtr) parent, ns, name, content); 2518 } else if (parent->type == XML_DOCUMENT_FRAG_NODE) { 2519 cur = xmlNewDocRawNode( parent->doc, ns, name, content); 2520 } else { 2521 return(NULL); 2522 } 2523 if (cur == NULL) return(NULL); 2524 2525 /* 2526 * add the new element at the end of the children list. 2527 */ 2528 cur->type = XML_ELEMENT_NODE; 2529 cur->parent = parent; 2530 cur->doc = parent->doc; 2531 if (parent->children == NULL) { 2532 parent->children = cur; 2533 parent->last = cur; 2534 } else { 2535 prev = parent->last; 2536 prev->next = cur; 2537 cur->prev = prev; 2538 parent->last = cur; 2539 } 2540 2541 return(cur); 2542 } 2543 #endif /* LIBXML_TREE_ENABLED */ 2544 2545 /** 2546 * xmlNewCharRef: 2547 * @doc: the document 2548 * @name: the char ref string, starting with # or "&# ... ;" 2549 * 2550 * Creation of a new character reference node. 2551 * Returns a pointer to the new node object. 2552 */ 2553 xmlNodePtr 2554 xmlNewCharRef(xmlDocPtr doc, const xmlChar *name) { 2555 xmlNodePtr cur; 2556 2557 if (name == NULL) 2558 return(NULL); 2559 2560 /* 2561 * Allocate a new node and fill the fields. 2562 */ 2563 cur = (xmlNodePtr) xmlMalloc(sizeof(xmlNode)); 2564 if (cur == NULL) { 2565 xmlTreeErrMemory("building character reference"); 2566 return(NULL); 2567 } 2568 memset(cur, 0, sizeof(xmlNode)); 2569 cur->type = XML_ENTITY_REF_NODE; 2570 2571 cur->doc = doc; 2572 if (name[0] == '&') { 2573 int len; 2574 name++; 2575 len = xmlStrlen(name); 2576 if (name[len - 1] == ';') 2577 cur->name = xmlStrndup(name, len - 1); 2578 else 2579 cur->name = xmlStrndup(name, len); 2580 } else 2581 cur->name = xmlStrdup(name); 2582 2583 if ((__xmlRegisterCallbacks) && (xmlRegisterNodeDefaultValue)) 2584 xmlRegisterNodeDefaultValue(cur); 2585 return(cur); 2586 } 2587 2588 /** 2589 * xmlNewReference: 2590 * @doc: the document 2591 * @name: the reference name, or the reference string with & and ; 2592 * 2593 * Creation of a new reference node. 2594 * Returns a pointer to the new node object. 2595 */ 2596 xmlNodePtr 2597 xmlNewReference(const xmlDoc *doc, const xmlChar *name) { 2598 xmlNodePtr cur; 2599 xmlEntityPtr ent; 2600 2601 if (name == NULL) 2602 return(NULL); 2603 2604 /* 2605 * Allocate a new node and fill the fields. 2606 */ 2607 cur = (xmlNodePtr) xmlMalloc(sizeof(xmlNode)); 2608 if (cur == NULL) { 2609 xmlTreeErrMemory("building reference"); 2610 return(NULL); 2611 } 2612 memset(cur, 0, sizeof(xmlNode)); 2613 cur->type = XML_ENTITY_REF_NODE; 2614 2615 cur->doc = (xmlDoc *)doc; 2616 if (name[0] == '&') { 2617 int len; 2618 name++; 2619 len = xmlStrlen(name); 2620 if (name[len - 1] == ';') 2621 cur->name = xmlStrndup(name, len - 1); 2622 else 2623 cur->name = xmlStrndup(name, len); 2624 } else 2625 cur->name = xmlStrdup(name); 2626 2627 ent = xmlGetDocEntity(doc, cur->name); 2628 if (ent != NULL) { 2629 cur->content = ent->content; 2630 /* 2631 * The parent pointer in entity is a DTD pointer and thus is NOT 2632 * updated. Not sure if this is 100% correct. 2633 * -George 2634 */ 2635 cur->children = (xmlNodePtr) ent; 2636 cur->last = (xmlNodePtr) ent; 2637 } 2638 2639 if ((__xmlRegisterCallbacks) && (xmlRegisterNodeDefaultValue)) 2640 xmlRegisterNodeDefaultValue(cur); 2641 return(cur); 2642 } 2643 2644 /** 2645 * xmlNewDocText: 2646 * @doc: the document 2647 * @content: the text content 2648 * 2649 * Creation of a new text node within a document. 2650 * Returns a pointer to the new node object. 2651 */ 2652 xmlNodePtr 2653 xmlNewDocText(const xmlDoc *doc, const xmlChar *content) { 2654 xmlNodePtr cur; 2655 2656 cur = xmlNewText(content); 2657 if (cur != NULL) cur->doc = (xmlDoc *)doc; 2658 return(cur); 2659 } 2660 2661 /** 2662 * xmlNewTextLen: 2663 * @content: the text content 2664 * @len: the text len. 2665 * 2666 * Creation of a new text node with an extra parameter for the content's length 2667 * Returns a pointer to the new node object. 2668 */ 2669 xmlNodePtr 2670 xmlNewTextLen(const xmlChar *content, int len) { 2671 xmlNodePtr cur; 2672 2673 /* 2674 * Allocate a new node and fill the fields. 2675 */ 2676 cur = (xmlNodePtr) xmlMalloc(sizeof(xmlNode)); 2677 if (cur == NULL) { 2678 xmlTreeErrMemory("building text"); 2679 return(NULL); 2680 } 2681 memset(cur, 0, sizeof(xmlNode)); 2682 cur->type = XML_TEXT_NODE; 2683 2684 cur->name = xmlStringText; 2685 if (content != NULL) { 2686 cur->content = xmlStrndup(content, len); 2687 } 2688 2689 if ((__xmlRegisterCallbacks) && (xmlRegisterNodeDefaultValue)) 2690 xmlRegisterNodeDefaultValue(cur); 2691 return(cur); 2692 } 2693 2694 /** 2695 * xmlNewDocTextLen: 2696 * @doc: the document 2697 * @content: the text content 2698 * @len: the text len. 2699 * 2700 * Creation of a new text node with an extra content length parameter. The 2701 * text node pertain to a given document. 2702 * Returns a pointer to the new node object. 2703 */ 2704 xmlNodePtr 2705 xmlNewDocTextLen(xmlDocPtr doc, const xmlChar *content, int len) { 2706 xmlNodePtr cur; 2707 2708 cur = xmlNewTextLen(content, len); 2709 if (cur != NULL) cur->doc = doc; 2710 return(cur); 2711 } 2712 2713 /** 2714 * xmlNewComment: 2715 * @content: the comment content 2716 * 2717 * Creation of a new node containing a comment. 2718 * Returns a pointer to the new node object. 2719 */ 2720 xmlNodePtr 2721 xmlNewComment(const xmlChar *content) { 2722 xmlNodePtr cur; 2723 2724 /* 2725 * Allocate a new node and fill the fields. 2726 */ 2727 cur = (xmlNodePtr) xmlMalloc(sizeof(xmlNode)); 2728 if (cur == NULL) { 2729 xmlTreeErrMemory("building comment"); 2730 return(NULL); 2731 } 2732 memset(cur, 0, sizeof(xmlNode)); 2733 cur->type = XML_COMMENT_NODE; 2734 2735 cur->name = xmlStringComment; 2736 if (content != NULL) { 2737 cur->content = xmlStrdup(content); 2738 } 2739 2740 if ((__xmlRegisterCallbacks) && (xmlRegisterNodeDefaultValue)) 2741 xmlRegisterNodeDefaultValue(cur); 2742 return(cur); 2743 } 2744 2745 /** 2746 * xmlNewCDataBlock: 2747 * @doc: the document 2748 * @content: the CDATA block content content 2749 * @len: the length of the block 2750 * 2751 * Creation of a new node containing a CDATA block. 2752 * Returns a pointer to the new node object. 2753 */ 2754 xmlNodePtr 2755 xmlNewCDataBlock(xmlDocPtr doc, const xmlChar *content, int len) { 2756 xmlNodePtr cur; 2757 2758 /* 2759 * Allocate a new node and fill the fields. 2760 */ 2761 cur = (xmlNodePtr) xmlMalloc(sizeof(xmlNode)); 2762 if (cur == NULL) { 2763 xmlTreeErrMemory("building CDATA"); 2764 return(NULL); 2765 } 2766 memset(cur, 0, sizeof(xmlNode)); 2767 cur->type = XML_CDATA_SECTION_NODE; 2768 cur->doc = doc; 2769 2770 if (content != NULL) { 2771 cur->content = xmlStrndup(content, len); 2772 } 2773 2774 if ((__xmlRegisterCallbacks) && (xmlRegisterNodeDefaultValue)) 2775 xmlRegisterNodeDefaultValue(cur); 2776 return(cur); 2777 } 2778 2779 /** 2780 * xmlNewDocComment: 2781 * @doc: the document 2782 * @content: the comment content 2783 * 2784 * Creation of a new node containing a comment within a document. 2785 * Returns a pointer to the new node object. 2786 */ 2787 xmlNodePtr 2788 xmlNewDocComment(xmlDocPtr doc, const xmlChar *content) { 2789 xmlNodePtr cur; 2790 2791 cur = xmlNewComment(content); 2792 if (cur != NULL) cur->doc = doc; 2793 return(cur); 2794 } 2795 2796 /** 2797 * xmlSetTreeDoc: 2798 * @tree: the top element 2799 * @doc: the document 2800 * 2801 * update all nodes under the tree to point to the right document 2802 */ 2803 void 2804 xmlSetTreeDoc(xmlNodePtr tree, xmlDocPtr doc) { 2805 xmlAttrPtr prop; 2806 2807 if ((tree == NULL) || (tree->type == XML_NAMESPACE_DECL)) 2808 return; 2809 if (tree->doc != doc) { 2810 if(tree->type == XML_ELEMENT_NODE) { 2811 prop = tree->properties; 2812 while (prop != NULL) { 2813 if (prop->atype == XML_ATTRIBUTE_ID) { 2814 xmlRemoveID(tree->doc, prop); 2815 } 2816 2817 prop->doc = doc; 2818 xmlSetListDoc(prop->children, doc); 2819 2820 /* 2821 * TODO: ID attributes should be also added to the new 2822 * document, but this breaks things like xmlReplaceNode. 2823 * The underlying problem is that xmlRemoveID is only called 2824 * if a node is destroyed, not if it's unlinked. 2825 */ 2826 #if 0 2827 if (xmlIsID(doc, tree, prop)) { 2828 xmlChar *idVal = xmlNodeListGetString(doc, prop->children, 2829 1); 2830 xmlAddID(NULL, doc, idVal, prop); 2831 } 2832 #endif 2833 2834 prop = prop->next; 2835 } 2836 } 2837 if (tree->children != NULL) 2838 xmlSetListDoc(tree->children, doc); 2839 tree->doc = doc; 2840 } 2841 } 2842 2843 /** 2844 * xmlSetListDoc: 2845 * @list: the first element 2846 * @doc: the document 2847 * 2848 * update all nodes in the list to point to the right document 2849 */ 2850 void 2851 xmlSetListDoc(xmlNodePtr list, xmlDocPtr doc) { 2852 xmlNodePtr cur; 2853 2854 if ((list == NULL) || (list->type == XML_NAMESPACE_DECL)) 2855 return; 2856 cur = list; 2857 while (cur != NULL) { 2858 if (cur->doc != doc) 2859 xmlSetTreeDoc(cur, doc); 2860 cur = cur->next; 2861 } 2862 } 2863 2864 #if defined(LIBXML_TREE_ENABLED) || defined(LIBXML_SCHEMAS_ENABLED) 2865 /** 2866 * xmlNewChild: 2867 * @parent: the parent node 2868 * @ns: a namespace if any 2869 * @name: the name of the child 2870 * @content: the XML content of the child if any. 2871 * 2872 * Creation of a new child element, added at the end of @parent children list. 2873 * @ns and @content parameters are optional (NULL). If @ns is NULL, the newly 2874 * created element inherits the namespace of @parent. If @content is non NULL, 2875 * a child list containing the TEXTs and ENTITY_REFs node will be created. 2876 * NOTE: @content is supposed to be a piece of XML CDATA, so it allows entity 2877 * references. XML special chars must be escaped first by using 2878 * xmlEncodeEntitiesReentrant(), or xmlNewTextChild() should be used. 2879 * 2880 * Returns a pointer to the new node object. 2881 */ 2882 xmlNodePtr 2883 xmlNewChild(xmlNodePtr parent, xmlNsPtr ns, 2884 const xmlChar *name, const xmlChar *content) { 2885 xmlNodePtr cur, prev; 2886 2887 if (parent == NULL) { 2888 #ifdef DEBUG_TREE 2889 xmlGenericError(xmlGenericErrorContext, 2890 "xmlNewChild : parent == NULL\n"); 2891 #endif 2892 return(NULL); 2893 } 2894 2895 if (name == NULL) { 2896 #ifdef DEBUG_TREE 2897 xmlGenericError(xmlGenericErrorContext, 2898 "xmlNewChild : name == NULL\n"); 2899 #endif 2900 return(NULL); 2901 } 2902 2903 /* 2904 * Allocate a new node 2905 */ 2906 if (parent->type == XML_ELEMENT_NODE) { 2907 if (ns == NULL) 2908 cur = xmlNewDocNode(parent->doc, parent->ns, name, content); 2909 else 2910 cur = xmlNewDocNode(parent->doc, ns, name, content); 2911 } else if ((parent->type == XML_DOCUMENT_NODE) || 2912 (parent->type == XML_HTML_DOCUMENT_NODE)) { 2913 if (ns == NULL) 2914 cur = xmlNewDocNode((xmlDocPtr) parent, NULL, name, content); 2915 else 2916 cur = xmlNewDocNode((xmlDocPtr) parent, ns, name, content); 2917 } else if (parent->type == XML_DOCUMENT_FRAG_NODE) { 2918 cur = xmlNewDocNode( parent->doc, ns, name, content); 2919 } else { 2920 return(NULL); 2921 } 2922 if (cur == NULL) return(NULL); 2923 2924 /* 2925 * add the new element at the end of the children list. 2926 */ 2927 cur->type = XML_ELEMENT_NODE; 2928 cur->parent = parent; 2929 cur->doc = parent->doc; 2930 if (parent->children == NULL) { 2931 parent->children = cur; 2932 parent->last = cur; 2933 } else { 2934 prev = parent->last; 2935 prev->next = cur; 2936 cur->prev = prev; 2937 parent->last = cur; 2938 } 2939 2940 return(cur); 2941 } 2942 #endif /* LIBXML_TREE_ENABLED */ 2943 2944 /** 2945 * xmlAddPropSibling: 2946 * @prev: the attribute to which @prop is added after 2947 * @cur: the base attribute passed to calling function 2948 * @prop: the new attribute 2949 * 2950 * Add a new attribute after @prev using @cur as base attribute. 2951 * When inserting before @cur, @prev is passed as @cur->prev. 2952 * When inserting after @cur, @prev is passed as @cur. 2953 * If an existing attribute is found it is detroyed prior to adding @prop. 2954 * 2955 * Returns the attribute being inserted or NULL in case of error. 2956 */ 2957 static xmlNodePtr 2958 xmlAddPropSibling(xmlNodePtr prev, xmlNodePtr cur, xmlNodePtr prop) { 2959 xmlAttrPtr attr; 2960 2961 if ((cur == NULL) || (cur->type != XML_ATTRIBUTE_NODE) || 2962 (prop == NULL) || (prop->type != XML_ATTRIBUTE_NODE) || 2963 ((prev != NULL) && (prev->type != XML_ATTRIBUTE_NODE))) 2964 return(NULL); 2965 2966 /* check if an attribute with the same name exists */ 2967 if (prop->ns == NULL) 2968 attr = xmlHasNsProp(cur->parent, prop->name, NULL); 2969 else 2970 attr = xmlHasNsProp(cur->parent, prop->name, prop->ns->href); 2971 2972 if (prop->doc != cur->doc) { 2973 xmlSetTreeDoc(prop, cur->doc); 2974 } 2975 prop->parent = cur->parent; 2976 prop->prev = prev; 2977 if (prev != NULL) { 2978 prop->next = prev->next; 2979 prev->next = prop; 2980 if (prop->next) 2981 prop->next->prev = prop; 2982 } else { 2983 prop->next = cur; 2984 cur->prev = prop; 2985 } 2986 if (prop->prev == NULL && prop->parent != NULL) 2987 prop->parent->properties = (xmlAttrPtr) prop; 2988 if ((attr != NULL) && (attr->type != XML_ATTRIBUTE_DECL)) { 2989 /* different instance, destroy it (attributes must be unique) */ 2990 xmlRemoveProp((xmlAttrPtr) attr); 2991 } 2992 return prop; 2993 } 2994 2995 /** 2996 * xmlAddNextSibling: 2997 * @cur: the child node 2998 * @elem: the new node 2999 * 3000 * Add a new node @elem as the next sibling of @cur 3001 * If the new node was already inserted in a document it is 3002 * first unlinked from its existing context. 3003 * As a result of text merging @elem may be freed. 3004 * If the new node is ATTRIBUTE, it is added into properties instead of children. 3005 * If there is an attribute with equal name, it is first destroyed. 3006 * 3007 * Returns the new node or NULL in case of error. 3008 */ 3009 xmlNodePtr 3010 xmlAddNextSibling(xmlNodePtr cur, xmlNodePtr elem) { 3011 if ((cur == NULL) || (cur->type == XML_NAMESPACE_DECL)) { 3012 #ifdef DEBUG_TREE 3013 xmlGenericError(xmlGenericErrorContext, 3014 "xmlAddNextSibling : cur == NULL\n"); 3015 #endif 3016 return(NULL); 3017 } 3018 if ((elem == NULL) || (elem->type == XML_NAMESPACE_DECL)) { 3019 #ifdef DEBUG_TREE 3020 xmlGenericError(xmlGenericErrorContext, 3021 "xmlAddNextSibling : elem == NULL\n"); 3022 #endif 3023 return(NULL); 3024 } 3025 3026 if (cur == elem) { 3027 #ifdef DEBUG_TREE 3028 xmlGenericError(xmlGenericErrorContext, 3029 "xmlAddNextSibling : cur == elem\n"); 3030 #endif 3031 return(NULL); 3032 } 3033 3034 xmlUnlinkNode(elem); 3035 3036 if (elem->type == XML_TEXT_NODE) { 3037 if (cur->type == XML_TEXT_NODE) { 3038 xmlNodeAddContent(cur, elem->content); 3039 xmlFreeNode(elem); 3040 return(cur); 3041 } 3042 if ((cur->next != NULL) && (cur->next->type == XML_TEXT_NODE) && 3043 (cur->name == cur->next->name)) { 3044 xmlChar *tmp; 3045 3046 tmp = xmlStrdup(elem->content); 3047 tmp = xmlStrcat(tmp, cur->next->content); 3048 xmlNodeSetContent(cur->next, tmp); 3049 xmlFree(tmp); 3050 xmlFreeNode(elem); 3051 return(cur->next); 3052 } 3053 } else if (elem->type == XML_ATTRIBUTE_NODE) { 3054 return xmlAddPropSibling(cur, cur, elem); 3055 } 3056 3057 if (elem->doc != cur->doc) { 3058 xmlSetTreeDoc(elem, cur->doc); 3059 } 3060 elem->parent = cur->parent; 3061 elem->prev = cur; 3062 elem->next = cur->next; 3063 cur->next = elem; 3064 if (elem->next != NULL) 3065 elem->next->prev = elem; 3066 if ((elem->parent != NULL) && (elem->parent->last == cur)) 3067 elem->parent->last = elem; 3068 return(elem); 3069 } 3070 3071 #if defined(LIBXML_TREE_ENABLED) || defined(LIBXML_HTML_ENABLED) || \ 3072 defined(LIBXML_SCHEMAS_ENABLED) || defined(LIBXML_XINCLUDE_ENABLED) 3073 /** 3074 * xmlAddPrevSibling: 3075 * @cur: the child node 3076 * @elem: the new node 3077 * 3078 * Add a new node @elem as the previous sibling of @cur 3079 * merging adjacent TEXT nodes (@elem may be freed) 3080 * If the new node was already inserted in a document it is 3081 * first unlinked from its existing context. 3082 * If the new node is ATTRIBUTE, it is added into properties instead of children. 3083 * If there is an attribute with equal name, it is first destroyed. 3084 * 3085 * Returns the new node or NULL in case of error. 3086 */ 3087 xmlNodePtr 3088 xmlAddPrevSibling(xmlNodePtr cur, xmlNodePtr elem) { 3089 if ((cur == NULL) || (cur->type == XML_NAMESPACE_DECL)) { 3090 #ifdef DEBUG_TREE 3091 xmlGenericError(xmlGenericErrorContext, 3092 "xmlAddPrevSibling : cur == NULL\n"); 3093 #endif 3094 return(NULL); 3095 } 3096 if ((elem == NULL) || (elem->type == XML_NAMESPACE_DECL)) { 3097 #ifdef DEBUG_TREE 3098 xmlGenericError(xmlGenericErrorContext, 3099 "xmlAddPrevSibling : elem == NULL\n"); 3100 #endif 3101 return(NULL); 3102 } 3103 3104 if (cur == elem) { 3105 #ifdef DEBUG_TREE 3106 xmlGenericError(xmlGenericErrorContext, 3107 "xmlAddPrevSibling : cur == elem\n"); 3108 #endif 3109 return(NULL); 3110 } 3111 3112 xmlUnlinkNode(elem); 3113 3114 if (elem->type == XML_TEXT_NODE) { 3115 if (cur->type == XML_TEXT_NODE) { 3116 xmlChar *tmp; 3117 3118 tmp = xmlStrdup(elem->content); 3119 tmp = xmlStrcat(tmp, cur->content); 3120 xmlNodeSetContent(cur, tmp); 3121 xmlFree(tmp); 3122 xmlFreeNode(elem); 3123 return(cur); 3124 } 3125 if ((cur->prev != NULL) && (cur->prev->type == XML_TEXT_NODE) && 3126 (cur->name == cur->prev->name)) { 3127 xmlNodeAddContent(cur->prev, elem->content); 3128 xmlFreeNode(elem); 3129 return(cur->prev); 3130 } 3131 } else if (elem->type == XML_ATTRIBUTE_NODE) { 3132 return xmlAddPropSibling(cur->prev, cur, elem); 3133 } 3134 3135 if (elem->doc != cur->doc) { 3136 xmlSetTreeDoc(elem, cur->doc); 3137 } 3138 elem->parent = cur->parent; 3139 elem->next = cur; 3140 elem->prev = cur->prev; 3141 cur->prev = elem; 3142 if (elem->prev != NULL) 3143 elem->prev->next = elem; 3144 if ((elem->parent != NULL) && (elem->parent->children == cur)) { 3145 elem->parent->children = elem; 3146 } 3147 return(elem); 3148 } 3149 #endif /* LIBXML_TREE_ENABLED */ 3150 3151 /** 3152 * xmlAddSibling: 3153 * @cur: the child node 3154 * @elem: the new node 3155 * 3156 * Add a new element @elem to the list of siblings of @cur 3157 * merging adjacent TEXT nodes (@elem may be freed) 3158 * If the new element was already inserted in a document it is 3159 * first unlinked from its existing context. 3160 * 3161 * Returns the new element or NULL in case of error. 3162 */ 3163 xmlNodePtr 3164 xmlAddSibling(xmlNodePtr cur, xmlNodePtr elem) { 3165 xmlNodePtr parent; 3166 3167 if ((cur == NULL) || (cur->type == XML_NAMESPACE_DECL)) { 3168 #ifdef DEBUG_TREE 3169 xmlGenericError(xmlGenericErrorContext, 3170 "xmlAddSibling : cur == NULL\n"); 3171 #endif 3172 return(NULL); 3173 } 3174 3175 if ((elem == NULL) || (elem->type == XML_NAMESPACE_DECL)) { 3176 #ifdef DEBUG_TREE 3177 xmlGenericError(xmlGenericErrorContext, 3178 "xmlAddSibling : elem == NULL\n"); 3179 #endif 3180 return(NULL); 3181 } 3182 3183 if (cur == elem) { 3184 #ifdef DEBUG_TREE 3185 xmlGenericError(xmlGenericErrorContext, 3186 "xmlAddSibling : cur == elem\n"); 3187 #endif 3188 return(NULL); 3189 } 3190 3191 /* 3192 * Constant time is we can rely on the ->parent->last to find 3193 * the last sibling. 3194 */ 3195 if ((cur->type != XML_ATTRIBUTE_NODE) && (cur->parent != NULL) && 3196 (cur->parent->children != NULL) && 3197 (cur->parent->last != NULL) && 3198 (cur->parent->last->next == NULL)) { 3199 cur = cur->parent->last; 3200 } else { 3201 while (cur->next != NULL) cur = cur->next; 3202 } 3203 3204 xmlUnlinkNode(elem); 3205 3206 if ((cur->type == XML_TEXT_NODE) && (elem->type == XML_TEXT_NODE) && 3207 (cur->name == elem->name)) { 3208 xmlNodeAddContent(cur, elem->content); 3209 xmlFreeNode(elem); 3210 return(cur); 3211 } else if (elem->type == XML_ATTRIBUTE_NODE) { 3212 return xmlAddPropSibling(cur, cur, elem); 3213 } 3214 3215 if (elem->doc != cur->doc) { 3216 xmlSetTreeDoc(elem, cur->doc); 3217 } 3218 parent = cur->parent; 3219 elem->prev = cur; 3220 elem->next = NULL; 3221 elem->parent = parent; 3222 cur->next = elem; 3223 if (parent != NULL) 3224 parent->last = elem; 3225 3226 return(elem); 3227 } 3228 3229 /** 3230 * xmlAddChildList: 3231 * @parent: the parent node 3232 * @cur: the first node in the list 3233 * 3234 * Add a list of node at the end of the child list of the parent 3235 * merging adjacent TEXT nodes (@cur may be freed) 3236 * 3237 * Returns the last child or NULL in case of error. 3238 */ 3239 xmlNodePtr 3240 xmlAddChildList(xmlNodePtr parent, xmlNodePtr cur) { 3241 xmlNodePtr prev; 3242 3243 if ((parent == NULL) || (parent->type == XML_NAMESPACE_DECL)) { 3244 #ifdef DEBUG_TREE 3245 xmlGenericError(xmlGenericErrorContext, 3246 "xmlAddChildList : parent == NULL\n"); 3247 #endif 3248 return(NULL); 3249 } 3250 3251 if ((cur == NULL) || (cur->type == XML_NAMESPACE_DECL)) { 3252 #ifdef DEBUG_TREE 3253 xmlGenericError(xmlGenericErrorContext, 3254 "xmlAddChildList : child == NULL\n"); 3255 #endif 3256 return(NULL); 3257 } 3258 3259 if ((cur->doc != NULL) && (parent->doc != NULL) && 3260 (cur->doc != parent->doc)) { 3261 #ifdef DEBUG_TREE 3262 xmlGenericError(xmlGenericErrorContext, 3263 "Elements moved to a different document\n"); 3264 #endif 3265 } 3266 3267 /* 3268 * add the first element at the end of the children list. 3269 */ 3270 3271 if (parent->children == NULL) { 3272 parent->children = cur; 3273 } else { 3274 /* 3275 * If cur and parent->last both are TEXT nodes, then merge them. 3276 */ 3277 if ((cur->type == XML_TEXT_NODE) && 3278 (parent->last->type == XML_TEXT_NODE) && 3279 (cur->name == parent->last->name)) { 3280 xmlNodeAddContent(parent->last, cur->content); 3281 /* 3282 * if it's the only child, nothing more to be done. 3283 */ 3284 if (cur->next == NULL) { 3285 xmlFreeNode(cur); 3286 return(parent->last); 3287 } 3288 prev = cur; 3289 cur = cur->next; 3290 xmlFreeNode(prev); 3291 } 3292 prev = parent->last; 3293 prev->next = cur; 3294 cur->prev = prev; 3295 } 3296 while (cur->next != NULL) { 3297 cur->parent = parent; 3298 if (cur->doc != parent->doc) { 3299 xmlSetTreeDoc(cur, parent->doc); 3300 } 3301 cur = cur->next; 3302 } 3303 cur->parent = parent; 3304 /* the parent may not be linked to a doc ! */ 3305 if (cur->doc != parent->doc) { 3306 xmlSetTreeDoc(cur, parent->doc); 3307 } 3308 parent->last = cur; 3309 3310 return(cur); 3311 } 3312 3313 /** 3314 * xmlAddChild: 3315 * @parent: the parent node 3316 * @cur: the child node 3317 * 3318 * Add a new node to @parent, at the end of the child (or property) list 3319 * merging adjacent TEXT nodes (in which case @cur is freed) 3320 * If the new node is ATTRIBUTE, it is added into properties instead of children. 3321 * If there is an attribute with equal name, it is first destroyed. 3322 * 3323 * Returns the child or NULL in case of error. 3324 */ 3325 xmlNodePtr 3326 xmlAddChild(xmlNodePtr parent, xmlNodePtr cur) { 3327 xmlNodePtr prev; 3328 3329 if ((parent == NULL) || (parent->type == XML_NAMESPACE_DECL)) { 3330 #ifdef DEBUG_TREE 3331 xmlGenericError(xmlGenericErrorContext, 3332 "xmlAddChild : parent == NULL\n"); 3333 #endif 3334 return(NULL); 3335 } 3336 3337 if ((cur == NULL) || (cur->type == XML_NAMESPACE_DECL)) { 3338 #ifdef DEBUG_TREE 3339 xmlGenericError(xmlGenericErrorContext, 3340 "xmlAddChild : child == NULL\n"); 3341 #endif 3342 return(NULL); 3343 } 3344 3345 if (parent == cur) { 3346 #ifdef DEBUG_TREE 3347 xmlGenericError(xmlGenericErrorContext, 3348 "xmlAddChild : parent == cur\n"); 3349 #endif 3350 return(NULL); 3351 } 3352 /* 3353 * If cur is a TEXT node, merge its content with adjacent TEXT nodes 3354 * cur is then freed. 3355 */ 3356 if (cur->type == XML_TEXT_NODE) { 3357 if ((parent->type == XML_TEXT_NODE) && 3358 (parent->content != NULL) && 3359 (parent->name == cur->name)) { 3360 xmlNodeAddContent(parent, cur->content); 3361 xmlFreeNode(cur); 3362 return(parent); 3363 } 3364 if ((parent->last != NULL) && (parent->last->type == XML_TEXT_NODE) && 3365 (parent->last->name == cur->name) && 3366 (parent->last != cur)) { 3367 xmlNodeAddContent(parent->last, cur->content); 3368 xmlFreeNode(cur); 3369 return(parent->last); 3370 } 3371 } 3372 3373 /* 3374 * add the new element at the end of the children list. 3375 */ 3376 prev = cur->parent; 3377 cur->parent = parent; 3378 if (cur->doc != parent->doc) { 3379 xmlSetTreeDoc(cur, parent->doc); 3380 } 3381 /* this check prevents a loop on tree-traversions if a developer 3382 * tries to add a node to its parent multiple times 3383 */ 3384 if (prev == parent) 3385 return(cur); 3386 3387 /* 3388 * Coalescing 3389 */ 3390 if ((parent->type == XML_TEXT_NODE) && 3391 (parent->content != NULL) && 3392 (parent != cur)) { 3393 xmlNodeAddContent(parent, cur->content); 3394 xmlFreeNode(cur); 3395 return(parent); 3396 } 3397 if (cur->type == XML_ATTRIBUTE_NODE) { 3398 if (parent->type != XML_ELEMENT_NODE) 3399 return(NULL); 3400 if (parent->properties != NULL) { 3401 /* check if an attribute with the same name exists */ 3402 xmlAttrPtr lastattr; 3403 3404 if (cur->ns == NULL) 3405 lastattr = xmlHasNsProp(parent, cur->name, NULL); 3406 else 3407 lastattr = xmlHasNsProp(parent, cur->name, cur->ns->href); 3408 if ((lastattr != NULL) && (lastattr != (xmlAttrPtr) cur) && (lastattr->type != XML_ATTRIBUTE_DECL)) { 3409 /* different instance, destroy it (attributes must be unique) */ 3410 xmlUnlinkNode((xmlNodePtr) lastattr); 3411 xmlFreeProp(lastattr); 3412 } 3413 if (lastattr == (xmlAttrPtr) cur) 3414 return(cur); 3415 3416 } 3417 if (parent->properties == NULL) { 3418 parent->properties = (xmlAttrPtr) cur; 3419 } else { 3420 /* find the end */ 3421 xmlAttrPtr lastattr = parent->properties; 3422 while (lastattr->next != NULL) { 3423 lastattr = lastattr->next; 3424 } 3425 lastattr->next = (xmlAttrPtr) cur; 3426 ((xmlAttrPtr) cur)->prev = lastattr; 3427 } 3428 } else { 3429 if (parent->children == NULL) { 3430 parent->children = cur; 3431 parent->last = cur; 3432 } else { 3433 prev = parent->last; 3434 prev->next = cur; 3435 cur->prev = prev; 3436 parent->last = cur; 3437 } 3438 } 3439 return(cur); 3440 } 3441 3442 /** 3443 * xmlGetLastChild: 3444 * @parent: the parent node 3445 * 3446 * Search the last child of a node. 3447 * Returns the last child or NULL if none. 3448 */ 3449 xmlNodePtr 3450 xmlGetLastChild(const xmlNode *parent) { 3451 if ((parent == NULL) || (parent->type == XML_NAMESPACE_DECL)) { 3452 #ifdef DEBUG_TREE 3453 xmlGenericError(xmlGenericErrorContext, 3454 "xmlGetLastChild : parent == NULL\n"); 3455 #endif 3456 return(NULL); 3457 } 3458 return(parent->last); 3459 } 3460 3461 #ifdef LIBXML_TREE_ENABLED 3462 /* 3463 * 5 interfaces from DOM ElementTraversal 3464 */ 3465 3466 /** 3467 * xmlChildElementCount: 3468 * @parent: the parent node 3469 * 3470 * Finds the current number of child nodes of that element which are 3471 * element nodes. 3472 * Note the handling of entities references is different than in 3473 * the W3C DOM element traversal spec since we don't have back reference 3474 * from entities content to entities references. 3475 * 3476 * Returns the count of element child or 0 if not available 3477 */ 3478 unsigned long 3479 xmlChildElementCount(xmlNodePtr parent) { 3480 unsigned long ret = 0; 3481 xmlNodePtr cur = NULL; 3482 3483 if (parent == NULL) 3484 return(0); 3485 switch (parent->type) { 3486 case XML_ELEMENT_NODE: 3487 case XML_ENTITY_NODE: 3488 case XML_DOCUMENT_NODE: 3489 case XML_DOCUMENT_FRAG_NODE: 3490 case XML_HTML_DOCUMENT_NODE: 3491 cur = parent->children; 3492 break; 3493 default: 3494 return(0); 3495 } 3496 while (cur != NULL) { 3497 if (cur->type == XML_ELEMENT_NODE) 3498 ret++; 3499 cur = cur->next; 3500 } 3501 return(ret); 3502 } 3503 3504 /** 3505 * xmlFirstElementChild: 3506 * @parent: the parent node 3507 * 3508 * Finds the first child node of that element which is a Element node 3509 * Note the handling of entities references is different than in 3510 * the W3C DOM element traversal spec since we don't have back reference 3511 * from entities content to entities references. 3512 * 3513 * Returns the first element child or NULL if not available 3514 */ 3515 xmlNodePtr 3516 xmlFirstElementChild(xmlNodePtr parent) { 3517 xmlNodePtr cur = NULL; 3518 3519 if (parent == NULL) 3520 return(NULL); 3521 switch (parent->type) { 3522 case XML_ELEMENT_NODE: 3523 case XML_ENTITY_NODE: 3524 case XML_DOCUMENT_NODE: 3525 case XML_DOCUMENT_FRAG_NODE: 3526 case XML_HTML_DOCUMENT_NODE: 3527 cur = parent->children; 3528 break; 3529 default: 3530 return(NULL); 3531 } 3532 while (cur != NULL) { 3533 if (cur->type == XML_ELEMENT_NODE) 3534 return(cur); 3535 cur = cur->next; 3536 } 3537 return(NULL); 3538 } 3539 3540 /** 3541 * xmlLastElementChild: 3542 * @parent: the parent node 3543 * 3544 * Finds the last child node of that element which is a Element node 3545 * Note the handling of entities references is different than in 3546 * the W3C DOM element traversal spec since we don't have back reference 3547 * from entities content to entities references. 3548 * 3549 * Returns the last element child or NULL if not available 3550 */ 3551 xmlNodePtr 3552 xmlLastElementChild(xmlNodePtr parent) { 3553 xmlNodePtr cur = NULL; 3554 3555 if (parent == NULL) 3556 return(NULL); 3557 switch (parent->type) { 3558 case XML_ELEMENT_NODE: 3559 case XML_ENTITY_NODE: 3560 case XML_DOCUMENT_NODE: 3561 case XML_DOCUMENT_FRAG_NODE: 3562 case XML_HTML_DOCUMENT_NODE: 3563 cur = parent->last; 3564 break; 3565 default: 3566 return(NULL); 3567 } 3568 while (cur != NULL) { 3569 if (cur->type == XML_ELEMENT_NODE) 3570 return(cur); 3571 cur = cur->prev; 3572 } 3573 return(NULL); 3574 } 3575 3576 /** 3577 * xmlPreviousElementSibling: 3578 * @node: the current node 3579 * 3580 * Finds the first closest previous sibling of the node which is an 3581 * element node. 3582 * Note the handling of entities references is different than in 3583 * the W3C DOM element traversal spec since we don't have back reference 3584 * from entities content to entities references. 3585 * 3586 * Returns the previous element sibling or NULL if not available 3587 */ 3588 xmlNodePtr 3589 xmlPreviousElementSibling(xmlNodePtr node) { 3590 if (node == NULL) 3591 return(NULL); 3592 switch (node->type) { 3593 case XML_ELEMENT_NODE: 3594 case XML_TEXT_NODE: 3595 case XML_CDATA_SECTION_NODE: 3596 case XML_ENTITY_REF_NODE: 3597 case XML_ENTITY_NODE: 3598 case XML_PI_NODE: 3599 case XML_COMMENT_NODE: 3600 case XML_XINCLUDE_START: 3601 case XML_XINCLUDE_END: 3602 node = node->prev; 3603 break; 3604 default: 3605 return(NULL); 3606 } 3607 while (node != NULL) { 3608 if (node->type == XML_ELEMENT_NODE) 3609 return(node); 3610 node = node->prev; 3611 } 3612 return(NULL); 3613 } 3614 3615 /** 3616 * xmlNextElementSibling: 3617 * @node: the current node 3618 * 3619 * Finds the first closest next sibling of the node which is an 3620 * element node. 3621 * Note the handling of entities references is different than in 3622 * the W3C DOM element traversal spec since we don't have back reference 3623 * from entities content to entities references. 3624 * 3625 * Returns the next element sibling or NULL if not available 3626 */ 3627 xmlNodePtr 3628 xmlNextElementSibling(xmlNodePtr node) { 3629 if (node == NULL) 3630 return(NULL); 3631 switch (node->type) { 3632 case XML_ELEMENT_NODE: 3633 case XML_TEXT_NODE: 3634 case XML_CDATA_SECTION_NODE: 3635 case XML_ENTITY_REF_NODE: 3636 case XML_ENTITY_NODE: 3637 case XML_PI_NODE: 3638 case XML_COMMENT_NODE: 3639 case XML_DTD_NODE: 3640 case XML_XINCLUDE_START: 3641 case XML_XINCLUDE_END: 3642 node = node->next; 3643 break; 3644 default: 3645 return(NULL); 3646 } 3647 while (node != NULL) { 3648 if (node->type == XML_ELEMENT_NODE) 3649 return(node); 3650 node = node->next; 3651 } 3652 return(NULL); 3653 } 3654 3655 #endif /* LIBXML_TREE_ENABLED */ 3656 3657 /** 3658 * xmlFreeNodeList: 3659 * @cur: the first node in the list 3660 * 3661 * Free a node and all its siblings, this is a recursive behaviour, all 3662 * the children are freed too. 3663 */ 3664 void 3665 xmlFreeNodeList(xmlNodePtr cur) { 3666 xmlNodePtr next; 3667 xmlDictPtr dict = NULL; 3668 3669 if (cur == NULL) return; 3670 if (cur->type == XML_NAMESPACE_DECL) { 3671 xmlFreeNsList((xmlNsPtr) cur); 3672 return; 3673 } 3674 if ((cur->type == XML_DOCUMENT_NODE) || 3675 #ifdef LIBXML_DOCB_ENABLED 3676 (cur->type == XML_DOCB_DOCUMENT_NODE) || 3677 #endif 3678 (cur->type == XML_HTML_DOCUMENT_NODE)) { 3679 xmlFreeDoc((xmlDocPtr) cur); 3680 return; 3681 } 3682 if (cur->doc != NULL) dict = cur->doc->dict; 3683 while (cur != NULL) { 3684 next = cur->next; 3685 if (cur->type != XML_DTD_NODE) { 3686 3687 if ((__xmlRegisterCallbacks) && (xmlDeregisterNodeDefaultValue)) 3688 xmlDeregisterNodeDefaultValue(cur); 3689 3690 if ((cur->children != NULL) && 3691 (cur->type != XML_ENTITY_REF_NODE)) 3692 xmlFreeNodeList(cur->children); 3693 if (((cur->type == XML_ELEMENT_NODE) || 3694 (cur->type == XML_XINCLUDE_START) || 3695 (cur->type == XML_XINCLUDE_END)) && 3696 (cur->properties != NULL)) 3697 xmlFreePropList(cur->properties); 3698 if ((cur->type != XML_ELEMENT_NODE) && 3699 (cur->type != XML_XINCLUDE_START) && 3700 (cur->type != XML_XINCLUDE_END) && 3701 (cur->type != XML_ENTITY_REF_NODE) && 3702 (cur->content != (xmlChar *) &(cur->properties))) { 3703 DICT_FREE(cur->content) 3704 } 3705 if (((cur->type == XML_ELEMENT_NODE) || 3706 (cur->type == XML_XINCLUDE_START) || 3707 (cur->type == XML_XINCLUDE_END)) && 3708 (cur->nsDef != NULL)) 3709 xmlFreeNsList(cur->nsDef); 3710 3711 /* 3712 * When a node is a text node or a comment, it uses a global static 3713 * variable for the name of the node. 3714 * Otherwise the node name might come from the document's 3715 * dictionary 3716 */ 3717 if ((cur->name != NULL) && 3718 (cur->type != XML_TEXT_NODE) && 3719 (cur->type != XML_COMMENT_NODE)) 3720 DICT_FREE(cur->name) 3721 xmlFree(cur); 3722 } 3723 cur = next; 3724 } 3725 } 3726 3727 /** 3728 * xmlFreeNode: 3729 * @cur: the node 3730 * 3731 * Free a node, this is a recursive behaviour, all the children are freed too. 3732 * This doesn't unlink the child from the list, use xmlUnlinkNode() first. 3733 */ 3734 void 3735 xmlFreeNode(xmlNodePtr cur) { 3736 xmlDictPtr dict = NULL; 3737 3738 if (cur == NULL) return; 3739 3740 /* use xmlFreeDtd for DTD nodes */ 3741 if (cur->type == XML_DTD_NODE) { 3742 xmlFreeDtd((xmlDtdPtr) cur); 3743 return; 3744 } 3745 if (cur->type == XML_NAMESPACE_DECL) { 3746 xmlFreeNs((xmlNsPtr) cur); 3747 return; 3748 } 3749 if (cur->type == XML_ATTRIBUTE_NODE) { 3750 xmlFreeProp((xmlAttrPtr) cur); 3751 return; 3752 } 3753 3754 if ((__xmlRegisterCallbacks) && (xmlDeregisterNodeDefaultValue)) 3755 xmlDeregisterNodeDefaultValue(cur); 3756 3757 if (cur->doc != NULL) dict = cur->doc->dict; 3758 3759 if (cur->type == XML_ENTITY_DECL) { 3760 xmlEntityPtr ent = (xmlEntityPtr) cur; 3761 DICT_FREE(ent->SystemID); 3762 DICT_FREE(ent->ExternalID); 3763 } 3764 if ((cur->children != NULL) && 3765 (cur->type != XML_ENTITY_REF_NODE)) 3766 xmlFreeNodeList(cur->children); 3767 if (((cur->type == XML_ELEMENT_NODE) || 3768 (cur->type == XML_XINCLUDE_START) || 3769 (cur->type == XML_XINCLUDE_END)) && 3770 (cur->properties != NULL)) 3771 xmlFreePropList(cur->properties); 3772 if ((cur->type != XML_ELEMENT_NODE) && 3773 (cur->content != NULL) && 3774 (cur->type != XML_ENTITY_REF_NODE) && 3775 (cur->type != XML_XINCLUDE_END) && 3776 (cur->type != XML_XINCLUDE_START) && 3777 (cur->content != (xmlChar *) &(cur->properties))) { 3778 DICT_FREE(cur->content) 3779 } 3780 3781 /* 3782 * When a node is a text node or a comment, it uses a global static 3783 * variable for the name of the node. 3784 * Otherwise the node name might come from the document's dictionary 3785 */ 3786 if ((cur->name != NULL) && 3787 (cur->type != XML_TEXT_NODE) && 3788 (cur->type != XML_COMMENT_NODE)) 3789 DICT_FREE(cur->name) 3790 3791 if (((cur->type == XML_ELEMENT_NODE) || 3792 (cur->type == XML_XINCLUDE_START) || 3793 (cur->type == XML_XINCLUDE_END)) && 3794 (cur->nsDef != NULL)) 3795 xmlFreeNsList(cur->nsDef); 3796 xmlFree(cur); 3797 } 3798 3799 /** 3800 * xmlUnlinkNode: 3801 * @cur: the node 3802 * 3803 * Unlink a node from it's current context, the node is not freed 3804 * If one need to free the node, use xmlFreeNode() routine after the 3805 * unlink to discard it. 3806 * Note that namespace nodes can't be unlinked as they do not have 3807 * pointer to their parent. 3808 */ 3809 void 3810 xmlUnlinkNode(xmlNodePtr cur) { 3811 if (cur == NULL) { 3812 #ifdef DEBUG_TREE 3813 xmlGenericError(xmlGenericErrorContext, 3814 "xmlUnlinkNode : node == NULL\n"); 3815 #endif 3816 return; 3817 } 3818 if (cur->type == XML_NAMESPACE_DECL) 3819 return; 3820 if (cur->type == XML_DTD_NODE) { 3821 xmlDocPtr doc; 3822 doc = cur->doc; 3823 if (doc != NULL) { 3824 if (doc->intSubset == (xmlDtdPtr) cur) 3825 doc->intSubset = NULL; 3826 if (doc->extSubset == (xmlDtdPtr) cur) 3827 doc->extSubset = NULL; 3828 } 3829 } 3830 if (cur->type == XML_ENTITY_DECL) { 3831 xmlDocPtr doc; 3832 doc = cur->doc; 3833 if (doc != NULL) { 3834 if (doc->intSubset != NULL) { 3835 if (xmlHashLookup(doc->intSubset->entities, cur->name) == cur) 3836 xmlHashRemoveEntry(doc->intSubset->entities, cur->name, 3837 NULL); 3838 if (xmlHashLookup(doc->intSubset->pentities, cur->name) == cur) 3839 xmlHashRemoveEntry(doc->intSubset->pentities, cur->name, 3840 NULL); 3841 } 3842 if (doc->extSubset != NULL) { 3843 if (xmlHashLookup(doc->extSubset->entities, cur->name) == cur) 3844 xmlHashRemoveEntry(doc->extSubset->entities, cur->name, 3845 NULL); 3846 if (xmlHashLookup(doc->extSubset->pentities, cur->name) == cur) 3847 xmlHashRemoveEntry(doc->extSubset->pentities, cur->name, 3848 NULL); 3849 } 3850 } 3851 } 3852 if (cur->parent != NULL) { 3853 xmlNodePtr parent; 3854 parent = cur->parent; 3855 if (cur->type == XML_ATTRIBUTE_NODE) { 3856 if (parent->properties == (xmlAttrPtr) cur) 3857 parent->properties = ((xmlAttrPtr) cur)->next; 3858 } else { 3859 if (parent->children == cur) 3860 parent->children = cur->next; 3861 if (parent->last == cur) 3862 parent->last = cur->prev; 3863 } 3864 cur->parent = NULL; 3865 } 3866 if (cur->next != NULL) 3867 cur->next->prev = cur->prev; 3868 if (cur->prev != NULL) 3869 cur->prev->next = cur->next; 3870 cur->next = cur->prev = NULL; 3871 } 3872 3873 #if defined(LIBXML_TREE_ENABLED) || defined(LIBXML_WRITER_ENABLED) 3874 /** 3875 * xmlReplaceNode: 3876 * @old: the old node 3877 * @cur: the node 3878 * 3879 * Unlink the old node from its current context, prune the new one 3880 * at the same place. If @cur was already inserted in a document it is 3881 * first unlinked from its existing context. 3882 * 3883 * Returns the @old node 3884 */ 3885 xmlNodePtr 3886 xmlReplaceNode(xmlNodePtr old, xmlNodePtr cur) { 3887 if (old == cur) return(NULL); 3888 if ((old == NULL) || (old->type == XML_NAMESPACE_DECL) || 3889 (old->parent == NULL)) { 3890 #ifdef DEBUG_TREE 3891 xmlGenericError(xmlGenericErrorContext, 3892 "xmlReplaceNode : old == NULL or without parent\n"); 3893 #endif 3894 return(NULL); 3895 } 3896 if ((cur == NULL) || (cur->type == XML_NAMESPACE_DECL)) { 3897 xmlUnlinkNode(old); 3898 return(old); 3899 } 3900 if (cur == old) { 3901 return(old); 3902 } 3903 if ((old->type==XML_ATTRIBUTE_NODE) && (cur->type!=XML_ATTRIBUTE_NODE)) { 3904 #ifdef DEBUG_TREE 3905 xmlGenericError(xmlGenericErrorContext, 3906 "xmlReplaceNode : Trying to replace attribute node with other node type\n"); 3907 #endif 3908 return(old); 3909 } 3910 if ((cur->type==XML_ATTRIBUTE_NODE) && (old->type!=XML_ATTRIBUTE_NODE)) { 3911 #ifdef DEBUG_TREE 3912 xmlGenericError(xmlGenericErrorContext, 3913 "xmlReplaceNode : Trying to replace a non-attribute node with attribute node\n"); 3914 #endif 3915 return(old); 3916 } 3917 xmlUnlinkNode(cur); 3918 xmlSetTreeDoc(cur, old->doc); 3919 cur->parent = old->parent; 3920 cur->next = old->next; 3921 if (cur->next != NULL) 3922 cur->next->prev = cur; 3923 cur->prev = old->prev; 3924 if (cur->prev != NULL) 3925 cur->prev->next = cur; 3926 if (cur->parent != NULL) { 3927 if (cur->type == XML_ATTRIBUTE_NODE) { 3928 if (cur->parent->properties == (xmlAttrPtr)old) 3929 cur->parent->properties = ((xmlAttrPtr) cur); 3930 } else { 3931 if (cur->parent->children == old) 3932 cur->parent->children = cur; 3933 if (cur->parent->last == old) 3934 cur->parent->last = cur; 3935 } 3936 } 3937 old->next = old->prev = NULL; 3938 old->parent = NULL; 3939 return(old); 3940 } 3941 #endif /* LIBXML_TREE_ENABLED */ 3942 3943 /************************************************************************ 3944 * * 3945 * Copy operations * 3946 * * 3947 ************************************************************************/ 3948 3949 /** 3950 * xmlCopyNamespace: 3951 * @cur: the namespace 3952 * 3953 * Do a copy of the namespace. 3954 * 3955 * Returns: a new #xmlNsPtr, or NULL in case of error. 3956 */ 3957 xmlNsPtr 3958 xmlCopyNamespace(xmlNsPtr cur) { 3959 xmlNsPtr ret; 3960 3961 if (cur == NULL) return(NULL); 3962 switch (cur->type) { 3963 case XML_LOCAL_NAMESPACE: 3964 ret = xmlNewNs(NULL, cur->href, cur->prefix); 3965 break; 3966 default: 3967 #ifdef DEBUG_TREE 3968 xmlGenericError(xmlGenericErrorContext, 3969 "xmlCopyNamespace: invalid type %d\n", cur->type); 3970 #endif 3971 return(NULL); 3972 } 3973 return(ret); 3974 } 3975 3976 /** 3977 * xmlCopyNamespaceList: 3978 * @cur: the first namespace 3979 * 3980 * Do a copy of an namespace list. 3981 * 3982 * Returns: a new #xmlNsPtr, or NULL in case of error. 3983 */ 3984 xmlNsPtr 3985 xmlCopyNamespaceList(xmlNsPtr cur) { 3986 xmlNsPtr ret = NULL; 3987 xmlNsPtr p = NULL,q; 3988 3989 while (cur != NULL) { 3990 q = xmlCopyNamespace(cur); 3991 if (p == NULL) { 3992 ret = p = q; 3993 } else { 3994 p->next = q; 3995 p = q; 3996 } 3997 cur = cur->next; 3998 } 3999 return(ret); 4000 } 4001 4002 static xmlNodePtr 4003 xmlStaticCopyNodeList(xmlNodePtr node, xmlDocPtr doc, xmlNodePtr parent); 4004 4005 static xmlAttrPtr 4006 xmlCopyPropInternal(xmlDocPtr doc, xmlNodePtr target, xmlAttrPtr cur) { 4007 xmlAttrPtr ret; 4008 4009 if (cur == NULL) return(NULL); 4010 if ((target != NULL) && (target->type != XML_ELEMENT_NODE)) 4011 return(NULL); 4012 if (target != NULL) 4013 ret = xmlNewDocProp(target->doc, cur->name, NULL); 4014 else if (doc != NULL) 4015 ret = xmlNewDocProp(doc, cur->name, NULL); 4016 else if (cur->parent != NULL) 4017 ret = xmlNewDocProp(cur->parent->doc, cur->name, NULL); 4018 else if (cur->children != NULL) 4019 ret = xmlNewDocProp(cur->children->doc, cur->name, NULL); 4020 else 4021 ret = xmlNewDocProp(NULL, cur->name, NULL); 4022 if (ret == NULL) return(NULL); 4023 ret->parent = target; 4024 4025 if ((cur->ns != NULL) && (target != NULL)) { 4026 xmlNsPtr ns; 4027 4028 ns = xmlSearchNs(target->doc, target, cur->ns->prefix); 4029 if (ns == NULL) { 4030 /* 4031 * Humm, we are copying an element whose namespace is defined 4032 * out of the new tree scope. Search it in the original tree 4033 * and add it at the top of the new tree 4034 */ 4035 ns = xmlSearchNs(cur->doc, cur->parent, cur->ns->prefix); 4036 if (ns != NULL) { 4037 xmlNodePtr root = target; 4038 xmlNodePtr pred = NULL; 4039 4040 while (root->parent != NULL) { 4041 pred = root; 4042 root = root->parent; 4043 } 4044 if (root == (xmlNodePtr) target->doc) { 4045 /* correct possibly cycling above the document elt */ 4046 root = pred; 4047 } 4048 ret->ns = xmlNewNs(root, ns->href, ns->prefix); 4049 } 4050 } else { 4051 /* 4052 * we have to find something appropriate here since 4053 * we cant be sure, that the namespce we found is identified 4054 * by the prefix 4055 */ 4056 if (xmlStrEqual(ns->href, cur->ns->href)) { 4057 /* this is the nice case */ 4058 ret->ns = ns; 4059 } else { 4060 /* 4061 * we are in trouble: we need a new reconcilied namespace. 4062 * This is expensive 4063 */ 4064 ret->ns = xmlNewReconciliedNs(target->doc, target, cur->ns); 4065 } 4066 } 4067 4068 } else 4069 ret->ns = NULL; 4070 4071 if (cur->children != NULL) { 4072 xmlNodePtr tmp; 4073 4074 ret->children = xmlStaticCopyNodeList(cur->children, ret->doc, (xmlNodePtr) ret); 4075 ret->last = NULL; 4076 tmp = ret->children; 4077 while (tmp != NULL) { 4078 /* tmp->parent = (xmlNodePtr)ret; */ 4079 if (tmp->next == NULL) 4080 ret->last = tmp; 4081 tmp = tmp->next; 4082 } 4083 } 4084 /* 4085 * Try to handle IDs 4086 */ 4087 if ((target!= NULL) && (cur!= NULL) && 4088 (target->doc != NULL) && (cur->doc != NULL) && 4089 (cur->doc->ids != NULL) && (cur->parent != NULL)) { 4090 if (xmlIsID(cur->doc, cur->parent, cur)) { 4091 xmlChar *id; 4092 4093 id = xmlNodeListGetString(cur->doc, cur->children, 1); 4094 if (id != NULL) { 4095 xmlAddID(NULL, target->doc, id, ret); 4096 xmlFree(id); 4097 } 4098 } 4099 } 4100 return(ret); 4101 } 4102 4103 /** 4104 * xmlCopyProp: 4105 * @target: the element where the attribute will be grafted 4106 * @cur: the attribute 4107 * 4108 * Do a copy of the attribute. 4109 * 4110 * Returns: a new #xmlAttrPtr, or NULL in case of error. 4111 */ 4112 xmlAttrPtr 4113 xmlCopyProp(xmlNodePtr target, xmlAttrPtr cur) { 4114 return xmlCopyPropInternal(NULL, target, cur); 4115 } 4116 4117 /** 4118 * xmlCopyPropList: 4119 * @target: the element where the attributes will be grafted 4120 * @cur: the first attribute 4121 * 4122 * Do a copy of an attribute list. 4123 * 4124 * Returns: a new #xmlAttrPtr, or NULL in case of error. 4125 */ 4126 xmlAttrPtr 4127 xmlCopyPropList(xmlNodePtr target, xmlAttrPtr cur) { 4128 xmlAttrPtr ret = NULL; 4129 xmlAttrPtr p = NULL,q; 4130 4131 if ((target != NULL) && (target->type != XML_ELEMENT_NODE)) 4132 return(NULL); 4133 while (cur != NULL) { 4134 q = xmlCopyProp(target, cur); 4135 if (q == NULL) 4136 return(NULL); 4137 if (p == NULL) { 4138 ret = p = q; 4139 } else { 4140 p->next = q; 4141 q->prev = p; 4142 p = q; 4143 } 4144 cur = cur->next; 4145 } 4146 return(ret); 4147 } 4148 4149 /* 4150 * NOTE about the CopyNode operations ! 4151 * 4152 * They are split into external and internal parts for one 4153 * tricky reason: namespaces. Doing a direct copy of a node 4154 * say RPM:Copyright without changing the namespace pointer to 4155 * something else can produce stale links. One way to do it is 4156 * to keep a reference counter but this doesn't work as soon 4157 * as one move the element or the subtree out of the scope of 4158 * the existing namespace. The actual solution seems to add 4159 * a copy of the namespace at the top of the copied tree if 4160 * not available in the subtree. 4161 * Hence two functions, the public front-end call the inner ones 4162 * The argument "recursive" normally indicates a recursive copy 4163 * of the node with values 0 (no) and 1 (yes). For XInclude, 4164 * however, we allow a value of 2 to indicate copy properties and 4165 * namespace info, but don't recurse on children. 4166 */ 4167 4168 static xmlNodePtr 4169 xmlStaticCopyNode(xmlNodePtr node, xmlDocPtr doc, xmlNodePtr parent, 4170 int extended) { 4171 xmlNodePtr ret; 4172 4173 if (node == NULL) return(NULL); 4174 switch (node->type) { 4175 case XML_TEXT_NODE: 4176 case XML_CDATA_SECTION_NODE: 4177 case XML_ELEMENT_NODE: 4178 case XML_DOCUMENT_FRAG_NODE: 4179 case XML_ENTITY_REF_NODE: 4180 case XML_ENTITY_NODE: 4181 case XML_PI_NODE: 4182 case XML_COMMENT_NODE: 4183 case XML_XINCLUDE_START: 4184 case XML_XINCLUDE_END: 4185 break; 4186 case XML_ATTRIBUTE_NODE: 4187 return((xmlNodePtr) xmlCopyPropInternal(doc, parent, (xmlAttrPtr) node)); 4188 case XML_NAMESPACE_DECL: 4189 return((xmlNodePtr) xmlCopyNamespaceList((xmlNsPtr) node)); 4190 4191 case XML_DOCUMENT_NODE: 4192 case XML_HTML_DOCUMENT_NODE: 4193 #ifdef LIBXML_DOCB_ENABLED 4194 case XML_DOCB_DOCUMENT_NODE: 4195 #endif 4196 #ifdef LIBXML_TREE_ENABLED 4197 return((xmlNodePtr) xmlCopyDoc((xmlDocPtr) node, extended)); 4198 #endif /* LIBXML_TREE_ENABLED */ 4199 case XML_DOCUMENT_TYPE_NODE: 4200 case XML_NOTATION_NODE: 4201 case XML_DTD_NODE: 4202 case XML_ELEMENT_DECL: 4203 case XML_ATTRIBUTE_DECL: 4204 case XML_ENTITY_DECL: 4205 return(NULL); 4206 } 4207 4208 /* 4209 * Allocate a new node and fill the fields. 4210 */ 4211 ret = (xmlNodePtr) xmlMalloc(sizeof(xmlNode)); 4212 if (ret == NULL) { 4213 xmlTreeErrMemory("copying node"); 4214 return(NULL); 4215 } 4216 memset(ret, 0, sizeof(xmlNode)); 4217 ret->type = node->type; 4218 4219 ret->doc = doc; 4220 ret->parent = parent; 4221 if (node->name == xmlStringText) 4222 ret->name = xmlStringText; 4223 else if (node->name == xmlStringTextNoenc) 4224 ret->name = xmlStringTextNoenc; 4225 else if (node->name == xmlStringComment) 4226 ret->name = xmlStringComment; 4227 else if (node->name != NULL) { 4228 if ((doc != NULL) && (doc->dict != NULL)) 4229 ret->name = xmlDictLookup(doc->dict, node->name, -1); 4230 else 4231 ret->name = xmlStrdup(node->name); 4232 } 4233 if ((node->type != XML_ELEMENT_NODE) && 4234 (node->content != NULL) && 4235 (node->type != XML_ENTITY_REF_NODE) && 4236 (node->type != XML_XINCLUDE_END) && 4237 (node->type != XML_XINCLUDE_START)) { 4238 ret->content = xmlStrdup(node->content); 4239 }else{ 4240 if (node->type == XML_ELEMENT_NODE) 4241 ret->line = node->line; 4242 } 4243 if (parent != NULL) { 4244 xmlNodePtr tmp; 4245 4246 /* 4247 * this is a tricky part for the node register thing: 4248 * in case ret does get coalesced in xmlAddChild 4249 * the deregister-node callback is called; so we register ret now already 4250 */ 4251 if ((__xmlRegisterCallbacks) && (xmlRegisterNodeDefaultValue)) 4252 xmlRegisterNodeDefaultValue((xmlNodePtr)ret); 4253 4254 tmp = xmlAddChild(parent, ret); 4255 /* node could have coalesced */ 4256 if (tmp != ret) 4257 return(tmp); 4258 } 4259 4260 if (!extended) 4261 goto out; 4262 if (((node->type == XML_ELEMENT_NODE) || 4263 (node->type == XML_XINCLUDE_START)) && (node->nsDef != NULL)) 4264 ret->nsDef = xmlCopyNamespaceList(node->nsDef); 4265 4266 if (node->ns != NULL) { 4267 xmlNsPtr ns; 4268 4269 ns = xmlSearchNs(doc, ret, node->ns->prefix); 4270 if (ns == NULL) { 4271 /* 4272 * Humm, we are copying an element whose namespace is defined 4273 * out of the new tree scope. Search it in the original tree 4274 * and add it at the top of the new tree 4275 */ 4276 ns = xmlSearchNs(node->doc, node, node->ns->prefix); 4277 if (ns != NULL) { 4278 xmlNodePtr root = ret; 4279 4280 while (root->parent != NULL) root = root->parent; 4281 ret->ns = xmlNewNs(root, ns->href, ns->prefix); 4282 } else { 4283 ret->ns = xmlNewReconciliedNs(doc, ret, node->ns); 4284 } 4285 } else { 4286 /* 4287 * reference the existing namespace definition in our own tree. 4288 */ 4289 ret->ns = ns; 4290 } 4291 } 4292 if (((node->type == XML_ELEMENT_NODE) || 4293 (node->type == XML_XINCLUDE_START)) && (node->properties != NULL)) 4294 ret->properties = xmlCopyPropList(ret, node->properties); 4295 if (node->type == XML_ENTITY_REF_NODE) { 4296 if ((doc == NULL) || (node->doc != doc)) { 4297 /* 4298 * The copied node will go into a separate document, so 4299 * to avoid dangling references to the ENTITY_DECL node 4300 * we cannot keep the reference. Try to find it in the 4301 * target document. 4302 */ 4303 ret->children = (xmlNodePtr) xmlGetDocEntity(doc, ret->name); 4304 } else { 4305 ret->children = node->children; 4306 } 4307 ret->last = ret->children; 4308 } else if ((node->children != NULL) && (extended != 2)) { 4309 ret->children = xmlStaticCopyNodeList(node->children, doc, ret); 4310 UPDATE_LAST_CHILD_AND_PARENT(ret) 4311 } 4312 4313 out: 4314 /* if parent != NULL we already registered the node above */ 4315 if ((parent == NULL) && 4316 ((__xmlRegisterCallbacks) && (xmlRegisterNodeDefaultValue))) 4317 xmlRegisterNodeDefaultValue((xmlNodePtr)ret); 4318 return(ret); 4319 } 4320 4321 static xmlNodePtr 4322 xmlStaticCopyNodeList(xmlNodePtr node, xmlDocPtr doc, xmlNodePtr parent) { 4323 xmlNodePtr ret = NULL; 4324 xmlNodePtr p = NULL,q; 4325 4326 while (node != NULL) { 4327 #ifdef LIBXML_TREE_ENABLED 4328 if (node->type == XML_DTD_NODE ) { 4329 if (doc == NULL) { 4330 node = node->next; 4331 continue; 4332 } 4333 if (doc->intSubset == NULL) { 4334 q = (xmlNodePtr) xmlCopyDtd( (xmlDtdPtr) node ); 4335 if (q == NULL) return(NULL); 4336 q->doc = doc; 4337 q->parent = parent; 4338 doc->intSubset = (xmlDtdPtr) q; 4339 xmlAddChild(parent, q); 4340 } else { 4341 q = (xmlNodePtr) doc->intSubset; 4342 xmlAddChild(parent, q); 4343 } 4344 } else 4345 #endif /* LIBXML_TREE_ENABLED */ 4346 q = xmlStaticCopyNode(node, doc, parent, 1); 4347 if (q == NULL) return(NULL); 4348 if (ret == NULL) { 4349 q->prev = NULL; 4350 ret = p = q; 4351 } else if (p != q) { 4352 /* the test is required if xmlStaticCopyNode coalesced 2 text nodes */ 4353 p->next = q; 4354 q->prev = p; 4355 p = q; 4356 } 4357 node = node->next; 4358 } 4359 return(ret); 4360 } 4361 4362 /** 4363 * xmlCopyNode: 4364 * @node: the node 4365 * @extended: if 1 do a recursive copy (properties, namespaces and children 4366 * when applicable) 4367 * if 2 copy properties and namespaces (when applicable) 4368 * 4369 * Do a copy of the node. 4370 * 4371 * Returns: a new #xmlNodePtr, or NULL in case of error. 4372 */ 4373 xmlNodePtr 4374 xmlCopyNode(xmlNodePtr node, int extended) { 4375 xmlNodePtr ret; 4376 4377 ret = xmlStaticCopyNode(node, NULL, NULL, extended); 4378 return(ret); 4379 } 4380 4381 /** 4382 * xmlDocCopyNode: 4383 * @node: the node 4384 * @doc: the document 4385 * @extended: if 1 do a recursive copy (properties, namespaces and children 4386 * when applicable) 4387 * if 2 copy properties and namespaces (when applicable) 4388 * 4389 * Do a copy of the node to a given document. 4390 * 4391 * Returns: a new #xmlNodePtr, or NULL in case of error. 4392 */ 4393 xmlNodePtr 4394 xmlDocCopyNode(xmlNodePtr node, xmlDocPtr doc, int extended) { 4395 xmlNodePtr ret; 4396 4397 ret = xmlStaticCopyNode(node, doc, NULL, extended); 4398 return(ret); 4399 } 4400 4401 /** 4402 * xmlDocCopyNodeList: 4403 * @doc: the target document 4404 * @node: the first node in the list. 4405 * 4406 * Do a recursive copy of the node list. 4407 * 4408 * Returns: a new #xmlNodePtr, or NULL in case of error. 4409 */ 4410 xmlNodePtr xmlDocCopyNodeList(xmlDocPtr doc, xmlNodePtr node) { 4411 xmlNodePtr ret = xmlStaticCopyNodeList(node, doc, NULL); 4412 return(ret); 4413 } 4414 4415 /** 4416 * xmlCopyNodeList: 4417 * @node: the first node in the list. 4418 * 4419 * Do a recursive copy of the node list. 4420 * Use xmlDocCopyNodeList() if possible to ensure string interning. 4421 * 4422 * Returns: a new #xmlNodePtr, or NULL in case of error. 4423 */ 4424 xmlNodePtr xmlCopyNodeList(xmlNodePtr node) { 4425 xmlNodePtr ret = xmlStaticCopyNodeList(node, NULL, NULL); 4426 return(ret); 4427 } 4428 4429 #if defined(LIBXML_TREE_ENABLED) 4430 /** 4431 * xmlCopyDtd: 4432 * @dtd: the dtd 4433 * 4434 * Do a copy of the dtd. 4435 * 4436 * Returns: a new #xmlDtdPtr, or NULL in case of error. 4437 */ 4438 xmlDtdPtr 4439 xmlCopyDtd(xmlDtdPtr dtd) { 4440 xmlDtdPtr ret; 4441 xmlNodePtr cur, p = NULL, q; 4442 4443 if (dtd == NULL) return(NULL); 4444 ret = xmlNewDtd(NULL, dtd->name, dtd->ExternalID, dtd->SystemID); 4445 if (ret == NULL) return(NULL); 4446 if (dtd->entities != NULL) 4447 ret->entities = (void *) xmlCopyEntitiesTable( 4448 (xmlEntitiesTablePtr) dtd->entities); 4449 if (dtd->notations != NULL) 4450 ret->notations = (void *) xmlCopyNotationTable( 4451 (xmlNotationTablePtr) dtd->notations); 4452 if (dtd->elements != NULL) 4453 ret->elements = (void *) xmlCopyElementTable( 4454 (xmlElementTablePtr) dtd->elements); 4455 if (dtd->attributes != NULL) 4456 ret->attributes = (void *) xmlCopyAttributeTable( 4457 (xmlAttributeTablePtr) dtd->attributes); 4458 if (dtd->pentities != NULL) 4459 ret->pentities = (void *) xmlCopyEntitiesTable( 4460 (xmlEntitiesTablePtr) dtd->pentities); 4461 4462 cur = dtd->children; 4463 while (cur != NULL) { 4464 q = NULL; 4465 4466 if (cur->type == XML_ENTITY_DECL) { 4467 xmlEntityPtr tmp = (xmlEntityPtr) cur; 4468 switch (tmp->etype) { 4469 case XML_INTERNAL_GENERAL_ENTITY: 4470 case XML_EXTERNAL_GENERAL_PARSED_ENTITY: 4471 case XML_EXTERNAL_GENERAL_UNPARSED_ENTITY: 4472 q = (xmlNodePtr) xmlGetEntityFromDtd(ret, tmp->name); 4473 break; 4474 case XML_INTERNAL_PARAMETER_ENTITY: 4475 case XML_EXTERNAL_PARAMETER_ENTITY: 4476 q = (xmlNodePtr) 4477 xmlGetParameterEntityFromDtd(ret, tmp->name); 4478 break; 4479 case XML_INTERNAL_PREDEFINED_ENTITY: 4480 break; 4481 } 4482 } else if (cur->type == XML_ELEMENT_DECL) { 4483 xmlElementPtr tmp = (xmlElementPtr) cur; 4484 q = (xmlNodePtr) 4485 xmlGetDtdQElementDesc(ret, tmp->name, tmp->prefix); 4486 } else if (cur->type == XML_ATTRIBUTE_DECL) { 4487 xmlAttributePtr tmp = (xmlAttributePtr) cur; 4488 q = (xmlNodePtr) 4489 xmlGetDtdQAttrDesc(ret, tmp->elem, tmp->name, tmp->prefix); 4490 } else if (cur->type == XML_COMMENT_NODE) { 4491 q = xmlCopyNode(cur, 0); 4492 } 4493 4494 if (q == NULL) { 4495 cur = cur->next; 4496 continue; 4497 } 4498 4499 if (p == NULL) 4500 ret->children = q; 4501 else 4502 p->next = q; 4503 4504 q->prev = p; 4505 q->parent = (xmlNodePtr) ret; 4506 q->next = NULL; 4507 ret->last = q; 4508 p = q; 4509 cur = cur->next; 4510 } 4511 4512 return(ret); 4513 } 4514 #endif 4515 4516 #if defined(LIBXML_TREE_ENABLED) || defined(LIBXML_SCHEMAS_ENABLED) 4517 /** 4518 * xmlCopyDoc: 4519 * @doc: the document 4520 * @recursive: if not zero do a recursive copy. 4521 * 4522 * Do a copy of the document info. If recursive, the content tree will 4523 * be copied too as well as DTD, namespaces and entities. 4524 * 4525 * Returns: a new #xmlDocPtr, or NULL in case of error. 4526 */ 4527 xmlDocPtr 4528 xmlCopyDoc(xmlDocPtr doc, int recursive) { 4529 xmlDocPtr ret; 4530 4531 if (doc == NULL) return(NULL); 4532 ret = xmlNewDoc(doc->version); 4533 if (ret == NULL) return(NULL); 4534 if (doc->name != NULL) 4535 ret->name = xmlMemStrdup(doc->name); 4536 if (doc->encoding != NULL) 4537 ret->encoding = xmlStrdup(doc->encoding); 4538 if (doc->URL != NULL) 4539 ret->URL = xmlStrdup(doc->URL); 4540 ret->charset = doc->charset; 4541 ret->compression = doc->compression; 4542 ret->standalone = doc->standalone; 4543 if (!recursive) return(ret); 4544 4545 ret->last = NULL; 4546 ret->children = NULL; 4547 #ifdef LIBXML_TREE_ENABLED 4548 if (doc->intSubset != NULL) { 4549 ret->intSubset = xmlCopyDtd(doc->intSubset); 4550 if (ret->intSubset == NULL) { 4551 xmlFreeDoc(ret); 4552 return(NULL); 4553 } 4554 xmlSetTreeDoc((xmlNodePtr)ret->intSubset, ret); 4555 ret->intSubset->parent = ret; 4556 } 4557 #endif 4558 if (doc->oldNs != NULL) 4559 ret->oldNs = xmlCopyNamespaceList(doc->oldNs); 4560 if (doc->children != NULL) { 4561 xmlNodePtr tmp; 4562 4563 ret->children = xmlStaticCopyNodeList(doc->children, ret, 4564 (xmlNodePtr)ret); 4565 ret->last = NULL; 4566 tmp = ret->children; 4567 while (tmp != NULL) { 4568 if (tmp->next == NULL) 4569 ret->last = tmp; 4570 tmp = tmp->next; 4571 } 4572 } 4573 return(ret); 4574 } 4575 #endif /* LIBXML_TREE_ENABLED */ 4576 4577 /************************************************************************ 4578 * * 4579 * Content access functions * 4580 * * 4581 ************************************************************************/ 4582 4583 /** 4584 * xmlGetLineNoInternal: 4585 * @node: valid node 4586 * @depth: used to limit any risk of recursion 4587 * 4588 * Get line number of @node. 4589 * Try to override the limitation of lines being store in 16 bits ints 4590 * 4591 * Returns the line number if successful, -1 otherwise 4592 */ 4593 static long 4594 xmlGetLineNoInternal(const xmlNode *node, int depth) 4595 { 4596 long result = -1; 4597 4598 if (depth >= 5) 4599 return(-1); 4600 4601 if (!node) 4602 return result; 4603 if ((node->type == XML_ELEMENT_NODE) || 4604 (node->type == XML_TEXT_NODE) || 4605 (node->type == XML_COMMENT_NODE) || 4606 (node->type == XML_PI_NODE)) { 4607 if (node->line == 65535) { 4608 if ((node->type == XML_TEXT_NODE) && (node->psvi != NULL)) 4609 result = (long) (ptrdiff_t) node->psvi; 4610 else if ((node->type == XML_ELEMENT_NODE) && 4611 (node->children != NULL)) 4612 result = xmlGetLineNoInternal(node->children, depth + 1); 4613 else if (node->next != NULL) 4614 result = xmlGetLineNoInternal(node->next, depth + 1); 4615 else if (node->prev != NULL) 4616 result = xmlGetLineNoInternal(node->prev, depth + 1); 4617 } 4618 if ((result == -1) || (result == 65535)) 4619 result = (long) node->line; 4620 } else if ((node->prev != NULL) && 4621 ((node->prev->type == XML_ELEMENT_NODE) || 4622 (node->prev->type == XML_TEXT_NODE) || 4623 (node->prev->type == XML_COMMENT_NODE) || 4624 (node->prev->type == XML_PI_NODE))) 4625 result = xmlGetLineNoInternal(node->prev, depth + 1); 4626 else if ((node->parent != NULL) && 4627 (node->parent->type == XML_ELEMENT_NODE)) 4628 result = xmlGetLineNoInternal(node->parent, depth + 1); 4629 4630 return result; 4631 } 4632 4633 /** 4634 * xmlGetLineNo: 4635 * @node: valid node 4636 * 4637 * Get line number of @node. 4638 * Try to override the limitation of lines being store in 16 bits ints 4639 * if XML_PARSE_BIG_LINES parser option was used 4640 * 4641 * Returns the line number if successful, -1 otherwise 4642 */ 4643 long 4644 xmlGetLineNo(const xmlNode *node) 4645 { 4646 return(xmlGetLineNoInternal(node, 0)); 4647 } 4648 4649 #if defined(LIBXML_TREE_ENABLED) || defined(LIBXML_DEBUG_ENABLED) 4650 /** 4651 * xmlGetNodePath: 4652 * @node: a node 4653 * 4654 * Build a structure based Path for the given node 4655 * 4656 * Returns the new path or NULL in case of error. The caller must free 4657 * the returned string 4658 */ 4659 xmlChar * 4660 xmlGetNodePath(const xmlNode *node) 4661 { 4662 const xmlNode *cur, *tmp, *next; 4663 xmlChar *buffer = NULL, *temp; 4664 size_t buf_len; 4665 xmlChar *buf; 4666 const char *sep; 4667 const char *name; 4668 char nametemp[100]; 4669 int occur = 0, generic; 4670 4671 if ((node == NULL) || (node->type == XML_NAMESPACE_DECL)) 4672 return (NULL); 4673 4674 buf_len = 500; 4675 buffer = (xmlChar *) xmlMallocAtomic(buf_len * sizeof(xmlChar)); 4676 if (buffer == NULL) { 4677 xmlTreeErrMemory("getting node path"); 4678 return (NULL); 4679 } 4680 buf = (xmlChar *) xmlMallocAtomic(buf_len * sizeof(xmlChar)); 4681 if (buf == NULL) { 4682 xmlTreeErrMemory("getting node path"); 4683 xmlFree(buffer); 4684 return (NULL); 4685 } 4686 4687 buffer[0] = 0; 4688 cur = node; 4689 do { 4690 name = ""; 4691 sep = "?"; 4692 occur = 0; 4693 if ((cur->type == XML_DOCUMENT_NODE) || 4694 (cur->type == XML_HTML_DOCUMENT_NODE)) { 4695 if (buffer[0] == '/') 4696 break; 4697 sep = "/"; 4698 next = NULL; 4699 } else if (cur->type == XML_ELEMENT_NODE) { 4700 generic = 0; 4701 sep = "/"; 4702 name = (const char *) cur->name; 4703 if (cur->ns) { 4704 if (cur->ns->prefix != NULL) { 4705 snprintf(nametemp, sizeof(nametemp) - 1, "%s:%s", 4706 (char *)cur->ns->prefix, (char *)cur->name); 4707 nametemp[sizeof(nametemp) - 1] = 0; 4708 name = nametemp; 4709 } else { 4710 /* 4711 * We cannot express named elements in the default 4712 * namespace, so use "*". 4713 */ 4714 generic = 1; 4715 name = "*"; 4716 } 4717 } 4718 next = cur->parent; 4719 4720 /* 4721 * Thumbler index computation 4722 * TODO: the ocurence test seems bogus for namespaced names 4723 */ 4724 tmp = cur->prev; 4725 while (tmp != NULL) { 4726 if ((tmp->type == XML_ELEMENT_NODE) && 4727 (generic || 4728 (xmlStrEqual(cur->name, tmp->name) && 4729 ((tmp->ns == cur->ns) || 4730 ((tmp->ns != NULL) && (cur->ns != NULL) && 4731 (xmlStrEqual(cur->ns->prefix, tmp->ns->prefix))))))) 4732 occur++; 4733 tmp = tmp->prev; 4734 } 4735 if (occur == 0) { 4736 tmp = cur->next; 4737 while (tmp != NULL && occur == 0) { 4738 if ((tmp->type == XML_ELEMENT_NODE) && 4739 (generic || 4740 (xmlStrEqual(cur->name, tmp->name) && 4741 ((tmp->ns == cur->ns) || 4742 ((tmp->ns != NULL) && (cur->ns != NULL) && 4743 (xmlStrEqual(cur->ns->prefix, tmp->ns->prefix))))))) 4744 occur++; 4745 tmp = tmp->next; 4746 } 4747 if (occur != 0) 4748 occur = 1; 4749 } else 4750 occur++; 4751 } else if (cur->type == XML_COMMENT_NODE) { 4752 sep = "/"; 4753 name = "comment()"; 4754 next = cur->parent; 4755 4756 /* 4757 * Thumbler index computation 4758 */ 4759 tmp = cur->prev; 4760 while (tmp != NULL) { 4761 if (tmp->type == XML_COMMENT_NODE) 4762 occur++; 4763 tmp = tmp->prev; 4764 } 4765 if (occur == 0) { 4766 tmp = cur->next; 4767 while (tmp != NULL && occur == 0) { 4768 if (tmp->type == XML_COMMENT_NODE) 4769 occur++; 4770 tmp = tmp->next; 4771 } 4772 if (occur != 0) 4773 occur = 1; 4774 } else 4775 occur++; 4776 } else if ((cur->type == XML_TEXT_NODE) || 4777 (cur->type == XML_CDATA_SECTION_NODE)) { 4778 sep = "/"; 4779 name = "text()"; 4780 next = cur->parent; 4781 4782 /* 4783 * Thumbler index computation 4784 */ 4785 tmp = cur->prev; 4786 while (tmp != NULL) { 4787 if ((tmp->type == XML_TEXT_NODE) || 4788 (tmp->type == XML_CDATA_SECTION_NODE)) 4789 occur++; 4790 tmp = tmp->prev; 4791 } 4792 /* 4793 * Evaluate if this is the only text- or CDATA-section-node; 4794 * if yes, then we'll get "text()", otherwise "text()[1]". 4795 */ 4796 if (occur == 0) { 4797 tmp = cur->next; 4798 while (tmp != NULL) { 4799 if ((tmp->type == XML_TEXT_NODE) || 4800 (tmp->type == XML_CDATA_SECTION_NODE)) 4801 { 4802 occur = 1; 4803 break; 4804 } 4805 tmp = tmp->next; 4806 } 4807 } else 4808 occur++; 4809 } else if (cur->type == XML_PI_NODE) { 4810 sep = "/"; 4811 snprintf(nametemp, sizeof(nametemp) - 1, 4812 "processing-instruction('%s')", (char *)cur->name); 4813 nametemp[sizeof(nametemp) - 1] = 0; 4814 name = nametemp; 4815 4816 next = cur->parent; 4817 4818 /* 4819 * Thumbler index computation 4820 */ 4821 tmp = cur->prev; 4822 while (tmp != NULL) { 4823 if ((tmp->type == XML_PI_NODE) && 4824 (xmlStrEqual(cur->name, tmp->name))) 4825 occur++; 4826 tmp = tmp->prev; 4827 } 4828 if (occur == 0) { 4829 tmp = cur->next; 4830 while (tmp != NULL && occur == 0) { 4831 if ((tmp->type == XML_PI_NODE) && 4832 (xmlStrEqual(cur->name, tmp->name))) 4833 occur++; 4834 tmp = tmp->next; 4835 } 4836 if (occur != 0) 4837 occur = 1; 4838 } else 4839 occur++; 4840 4841 } else if (cur->type == XML_ATTRIBUTE_NODE) { 4842 sep = "/@"; 4843 name = (const char *) (((xmlAttrPtr) cur)->name); 4844 if (cur->ns) { 4845 if (cur->ns->prefix != NULL) 4846 snprintf(nametemp, sizeof(nametemp) - 1, "%s:%s", 4847 (char *)cur->ns->prefix, (char *)cur->name); 4848 else 4849 snprintf(nametemp, sizeof(nametemp) - 1, "%s", 4850 (char *)cur->name); 4851 nametemp[sizeof(nametemp) - 1] = 0; 4852 name = nametemp; 4853 } 4854 next = ((xmlAttrPtr) cur)->parent; 4855 } else { 4856 next = cur->parent; 4857 } 4858 4859 /* 4860 * Make sure there is enough room 4861 */ 4862 if (xmlStrlen(buffer) + sizeof(nametemp) + 20 > buf_len) { 4863 buf_len = 4864 2 * buf_len + xmlStrlen(buffer) + sizeof(nametemp) + 20; 4865 temp = (xmlChar *) xmlRealloc(buffer, buf_len); 4866 if (temp == NULL) { 4867 xmlTreeErrMemory("getting node path"); 4868 xmlFree(buf); 4869 xmlFree(buffer); 4870 return (NULL); 4871 } 4872 buffer = temp; 4873 temp = (xmlChar *) xmlRealloc(buf, buf_len); 4874 if (temp == NULL) { 4875 xmlTreeErrMemory("getting node path"); 4876 xmlFree(buf); 4877 xmlFree(buffer); 4878 return (NULL); 4879 } 4880 buf = temp; 4881 } 4882 if (occur == 0) 4883 snprintf((char *) buf, buf_len, "%s%s%s", 4884 sep, name, (char *) buffer); 4885 else 4886 snprintf((char *) buf, buf_len, "%s%s[%d]%s", 4887 sep, name, occur, (char *) buffer); 4888 snprintf((char *) buffer, buf_len, "%s", (char *)buf); 4889 cur = next; 4890 } while (cur != NULL); 4891 xmlFree(buf); 4892 return (buffer); 4893 } 4894 #endif /* LIBXML_TREE_ENABLED */ 4895 4896 /** 4897 * xmlDocGetRootElement: 4898 * @doc: the document 4899 * 4900 * Get the root element of the document (doc->children is a list 4901 * containing possibly comments, PIs, etc ...). 4902 * 4903 * Returns the #xmlNodePtr for the root or NULL 4904 */ 4905 xmlNodePtr 4906 xmlDocGetRootElement(const xmlDoc *doc) { 4907 xmlNodePtr ret; 4908 4909 if (doc == NULL) return(NULL); 4910 ret = doc->children; 4911 while (ret != NULL) { 4912 if (ret->type == XML_ELEMENT_NODE) 4913 return(ret); 4914 ret = ret->next; 4915 } 4916 return(ret); 4917 } 4918 4919 #if defined(LIBXML_TREE_ENABLED) || defined(LIBXML_WRITER_ENABLED) 4920 /** 4921 * xmlDocSetRootElement: 4922 * @doc: the document 4923 * @root: the new document root element, if root is NULL no action is taken, 4924 * to remove a node from a document use xmlUnlinkNode(root) instead. 4925 * 4926 * Set the root element of the document (doc->children is a list 4927 * containing possibly comments, PIs, etc ...). 4928 * 4929 * Returns the old root element if any was found, NULL if root was NULL 4930 */ 4931 xmlNodePtr 4932 xmlDocSetRootElement(xmlDocPtr doc, xmlNodePtr root) { 4933 xmlNodePtr old = NULL; 4934 4935 if (doc == NULL) return(NULL); 4936 if ((root == NULL) || (root->type == XML_NAMESPACE_DECL)) 4937 return(NULL); 4938 xmlUnlinkNode(root); 4939 xmlSetTreeDoc(root, doc); 4940 root->parent = (xmlNodePtr) doc; 4941 old = doc->children; 4942 while (old != NULL) { 4943 if (old->type == XML_ELEMENT_NODE) 4944 break; 4945 old = old->next; 4946 } 4947 if (old == NULL) { 4948 if (doc->children == NULL) { 4949 doc->children = root; 4950 doc->last = root; 4951 } else { 4952 xmlAddSibling(doc->children, root); 4953 } 4954 } else { 4955 xmlReplaceNode(old, root); 4956 } 4957 return(old); 4958 } 4959 #endif 4960 4961 #if defined(LIBXML_TREE_ENABLED) 4962 /** 4963 * xmlNodeSetLang: 4964 * @cur: the node being changed 4965 * @lang: the language description 4966 * 4967 * Set the language of a node, i.e. the values of the xml:lang 4968 * attribute. 4969 */ 4970 void 4971 xmlNodeSetLang(xmlNodePtr cur, const xmlChar *lang) { 4972 xmlNsPtr ns; 4973 4974 if (cur == NULL) return; 4975 switch(cur->type) { 4976 case XML_TEXT_NODE: 4977 case XML_CDATA_SECTION_NODE: 4978 case XML_COMMENT_NODE: 4979 case XML_DOCUMENT_NODE: 4980 case XML_DOCUMENT_TYPE_NODE: 4981 case XML_DOCUMENT_FRAG_NODE: 4982 case XML_NOTATION_NODE: 4983 case XML_HTML_DOCUMENT_NODE: 4984 case XML_DTD_NODE: 4985 case XML_ELEMENT_DECL: 4986 case XML_ATTRIBUTE_DECL: 4987 case XML_ENTITY_DECL: 4988 case XML_PI_NODE: 4989 case XML_ENTITY_REF_NODE: 4990 case XML_ENTITY_NODE: 4991 case XML_NAMESPACE_DECL: 4992 #ifdef LIBXML_DOCB_ENABLED 4993 case XML_DOCB_DOCUMENT_NODE: 4994 #endif 4995 case XML_XINCLUDE_START: 4996 case XML_XINCLUDE_END: 4997 return; 4998 case XML_ELEMENT_NODE: 4999 case XML_ATTRIBUTE_NODE: 5000 break; 5001 } 5002 ns = xmlSearchNsByHref(cur->doc, cur, XML_XML_NAMESPACE); 5003 if (ns == NULL) 5004 return; 5005 xmlSetNsProp(cur, ns, BAD_CAST "lang", lang); 5006 } 5007 #endif /* LIBXML_TREE_ENABLED */ 5008 5009 /** 5010 * xmlNodeGetLang: 5011 * @cur: the node being checked 5012 * 5013 * Searches the language of a node, i.e. the values of the xml:lang 5014 * attribute or the one carried by the nearest ancestor. 5015 * 5016 * Returns a pointer to the lang value, or NULL if not found 5017 * It's up to the caller to free the memory with xmlFree(). 5018 */ 5019 xmlChar * 5020 xmlNodeGetLang(const xmlNode *cur) { 5021 xmlChar *lang; 5022 5023 if ((cur == NULL) || (cur->type == XML_NAMESPACE_DECL)) 5024 return(NULL); 5025 while (cur != NULL) { 5026 lang = xmlGetNsProp(cur, BAD_CAST "lang", XML_XML_NAMESPACE); 5027 if (lang != NULL) 5028 return(lang); 5029 cur = cur->parent; 5030 } 5031 return(NULL); 5032 } 5033 5034 5035 #ifdef LIBXML_TREE_ENABLED 5036 /** 5037 * xmlNodeSetSpacePreserve: 5038 * @cur: the node being changed 5039 * @val: the xml:space value ("0": default, 1: "preserve") 5040 * 5041 * Set (or reset) the space preserving behaviour of a node, i.e. the 5042 * value of the xml:space attribute. 5043 */ 5044 void 5045 xmlNodeSetSpacePreserve(xmlNodePtr cur, int val) { 5046 xmlNsPtr ns; 5047 5048 if (cur == NULL) return; 5049 switch(cur->type) { 5050 case XML_TEXT_NODE: 5051 case XML_CDATA_SECTION_NODE: 5052 case XML_COMMENT_NODE: 5053 case XML_DOCUMENT_NODE: 5054 case XML_DOCUMENT_TYPE_NODE: 5055 case XML_DOCUMENT_FRAG_NODE: 5056 case XML_NOTATION_NODE: 5057 case XML_HTML_DOCUMENT_NODE: 5058 case XML_DTD_NODE: 5059 case XML_ELEMENT_DECL: 5060 case XML_ATTRIBUTE_DECL: 5061 case XML_ENTITY_DECL: 5062 case XML_PI_NODE: 5063 case XML_ENTITY_REF_NODE: 5064 case XML_ENTITY_NODE: 5065 case XML_NAMESPACE_DECL: 5066 case XML_XINCLUDE_START: 5067 case XML_XINCLUDE_END: 5068 #ifdef LIBXML_DOCB_ENABLED 5069 case XML_DOCB_DOCUMENT_NODE: 5070 #endif 5071 return; 5072 case XML_ELEMENT_NODE: 5073 case XML_ATTRIBUTE_NODE: 5074 break; 5075 } 5076 ns = xmlSearchNsByHref(cur->doc, cur, XML_XML_NAMESPACE); 5077 if (ns == NULL) 5078 return; 5079 switch (val) { 5080 case 0: 5081 xmlSetNsProp(cur, ns, BAD_CAST "space", BAD_CAST "default"); 5082 break; 5083 case 1: 5084 xmlSetNsProp(cur, ns, BAD_CAST "space", BAD_CAST "preserve"); 5085 break; 5086 } 5087 } 5088 #endif /* LIBXML_TREE_ENABLED */ 5089 5090 /** 5091 * xmlNodeGetSpacePreserve: 5092 * @cur: the node being checked 5093 * 5094 * Searches the space preserving behaviour of a node, i.e. the values 5095 * of the xml:space attribute or the one carried by the nearest 5096 * ancestor. 5097 * 5098 * Returns -1 if xml:space is not inherited, 0 if "default", 1 if "preserve" 5099 */ 5100 int 5101 xmlNodeGetSpacePreserve(const xmlNode *cur) { 5102 xmlChar *space; 5103 5104 if ((cur == NULL) || (cur->type != XML_ELEMENT_NODE)) 5105 return(-1); 5106 while (cur != NULL) { 5107 space = xmlGetNsProp(cur, BAD_CAST "space", XML_XML_NAMESPACE); 5108 if (space != NULL) { 5109 if (xmlStrEqual(space, BAD_CAST "preserve")) { 5110 xmlFree(space); 5111 return(1); 5112 } 5113 if (xmlStrEqual(space, BAD_CAST "default")) { 5114 xmlFree(space); 5115 return(0); 5116 } 5117 xmlFree(space); 5118 } 5119 cur = cur->parent; 5120 } 5121 return(-1); 5122 } 5123 5124 #ifdef LIBXML_TREE_ENABLED 5125 /** 5126 * xmlNodeSetName: 5127 * @cur: the node being changed 5128 * @name: the new tag name 5129 * 5130 * Set (or reset) the name of a node. 5131 */ 5132 void 5133 xmlNodeSetName(xmlNodePtr cur, const xmlChar *name) { 5134 xmlDocPtr doc; 5135 xmlDictPtr dict; 5136 const xmlChar *freeme = NULL; 5137 5138 if (cur == NULL) return; 5139 if (name == NULL) return; 5140 switch(cur->type) { 5141 case XML_TEXT_NODE: 5142 case XML_CDATA_SECTION_NODE: 5143 case XML_COMMENT_NODE: 5144 case XML_DOCUMENT_TYPE_NODE: 5145 case XML_DOCUMENT_FRAG_NODE: 5146 case XML_NOTATION_NODE: 5147 case XML_HTML_DOCUMENT_NODE: 5148 case XML_NAMESPACE_DECL: 5149 case XML_XINCLUDE_START: 5150 case XML_XINCLUDE_END: 5151 #ifdef LIBXML_DOCB_ENABLED 5152 case XML_DOCB_DOCUMENT_NODE: 5153 #endif 5154 return; 5155 case XML_ELEMENT_NODE: 5156 case XML_ATTRIBUTE_NODE: 5157 case XML_PI_NODE: 5158 case XML_ENTITY_REF_NODE: 5159 case XML_ENTITY_NODE: 5160 case XML_DTD_NODE: 5161 case XML_DOCUMENT_NODE: 5162 case XML_ELEMENT_DECL: 5163 case XML_ATTRIBUTE_DECL: 5164 case XML_ENTITY_DECL: 5165 break; 5166 } 5167 doc = cur->doc; 5168 if (doc != NULL) 5169 dict = doc->dict; 5170 else 5171 dict = NULL; 5172 if (dict != NULL) { 5173 if ((cur->name != NULL) && (!xmlDictOwns(dict, cur->name))) 5174 freeme = cur->name; 5175 cur->name = xmlDictLookup(dict, name, -1); 5176 } else { 5177 if (cur->name != NULL) 5178 freeme = cur->name; 5179 cur->name = xmlStrdup(name); 5180 } 5181 5182 if (freeme) 5183 xmlFree((xmlChar *) freeme); 5184 } 5185 #endif 5186 5187 #if defined(LIBXML_TREE_ENABLED) || defined(LIBXML_XINCLUDE_ENABLED) 5188 /** 5189 * xmlNodeSetBase: 5190 * @cur: the node being changed 5191 * @uri: the new base URI 5192 * 5193 * Set (or reset) the base URI of a node, i.e. the value of the 5194 * xml:base attribute. 5195 */ 5196 void 5197 xmlNodeSetBase(xmlNodePtr cur, const xmlChar* uri) { 5198 xmlNsPtr ns; 5199 xmlChar* fixed; 5200 5201 if (cur == NULL) return; 5202 switch(cur->type) { 5203 case XML_TEXT_NODE: 5204 case XML_CDATA_SECTION_NODE: 5205 case XML_COMMENT_NODE: 5206 case XML_DOCUMENT_TYPE_NODE: 5207 case XML_DOCUMENT_FRAG_NODE: 5208 case XML_NOTATION_NODE: 5209 case XML_DTD_NODE: 5210 case XML_ELEMENT_DECL: 5211 case XML_ATTRIBUTE_DECL: 5212 case XML_ENTITY_DECL: 5213 case XML_PI_NODE: 5214 case XML_ENTITY_REF_NODE: 5215 case XML_ENTITY_NODE: 5216 case XML_NAMESPACE_DECL: 5217 case XML_XINCLUDE_START: 5218 case XML_XINCLUDE_END: 5219 return; 5220 case XML_ELEMENT_NODE: 5221 case XML_ATTRIBUTE_NODE: 5222 break; 5223 case XML_DOCUMENT_NODE: 5224 #ifdef LIBXML_DOCB_ENABLED 5225 case XML_DOCB_DOCUMENT_NODE: 5226 #endif 5227 case XML_HTML_DOCUMENT_NODE: { 5228 xmlDocPtr doc = (xmlDocPtr) cur; 5229 5230 if (doc->URL != NULL) 5231 xmlFree((xmlChar *) doc->URL); 5232 if (uri == NULL) 5233 doc->URL = NULL; 5234 else 5235 doc->URL = xmlPathToURI(uri); 5236 return; 5237 } 5238 } 5239 5240 ns = xmlSearchNsByHref(cur->doc, cur, XML_XML_NAMESPACE); 5241 if (ns == NULL) 5242 return; 5243 fixed = xmlPathToURI(uri); 5244 if (fixed != NULL) { 5245 xmlSetNsProp(cur, ns, BAD_CAST "base", fixed); 5246 xmlFree(fixed); 5247 } else { 5248 xmlSetNsProp(cur, ns, BAD_CAST "base", uri); 5249 } 5250 } 5251 #endif /* LIBXML_TREE_ENABLED */ 5252 5253 /** 5254 * xmlNodeGetBase: 5255 * @doc: the document the node pertains to 5256 * @cur: the node being checked 5257 * 5258 * Searches for the BASE URL. The code should work on both XML 5259 * and HTML document even if base mechanisms are completely different. 5260 * It returns the base as defined in RFC 2396 sections 5261 * 5.1.1. Base URI within Document Content 5262 * and 5263 * 5.1.2. Base URI from the Encapsulating Entity 5264 * However it does not return the document base (5.1.3), use 5265 * doc->URL in this case 5266 * 5267 * Returns a pointer to the base URL, or NULL if not found 5268 * It's up to the caller to free the memory with xmlFree(). 5269 */ 5270 xmlChar * 5271 xmlNodeGetBase(const xmlDoc *doc, const xmlNode *cur) { 5272 xmlChar *oldbase = NULL; 5273 xmlChar *base, *newbase; 5274 5275 if ((cur == NULL) && (doc == NULL)) 5276 return(NULL); 5277 if ((cur != NULL) && (cur->type == XML_NAMESPACE_DECL)) 5278 return(NULL); 5279 if (doc == NULL) doc = cur->doc; 5280 if ((doc != NULL) && (doc->type == XML_HTML_DOCUMENT_NODE)) { 5281 cur = doc->children; 5282 while ((cur != NULL) && (cur->name != NULL)) { 5283 if (cur->type != XML_ELEMENT_NODE) { 5284 cur = cur->next; 5285 continue; 5286 } 5287 if (!xmlStrcasecmp(cur->name, BAD_CAST "html")) { 5288 cur = cur->children; 5289 continue; 5290 } 5291 if (!xmlStrcasecmp(cur->name, BAD_CAST "head")) { 5292 cur = cur->children; 5293 continue; 5294 } 5295 if (!xmlStrcasecmp(cur->name, BAD_CAST "base")) { 5296 return(xmlGetProp(cur, BAD_CAST "href")); 5297 } 5298 cur = cur->next; 5299 } 5300 return(NULL); 5301 } 5302 while (cur != NULL) { 5303 if (cur->type == XML_ENTITY_DECL) { 5304 xmlEntityPtr ent = (xmlEntityPtr) cur; 5305 return(xmlStrdup(ent->URI)); 5306 } 5307 if (cur->type == XML_ELEMENT_NODE) { 5308 base = xmlGetNsProp(cur, BAD_CAST "base", XML_XML_NAMESPACE); 5309 if (base != NULL) { 5310 if (oldbase != NULL) { 5311 newbase = xmlBuildURI(oldbase, base); 5312 if (newbase != NULL) { 5313 xmlFree(oldbase); 5314 xmlFree(base); 5315 oldbase = newbase; 5316 } else { 5317 xmlFree(oldbase); 5318 xmlFree(base); 5319 return(NULL); 5320 } 5321 } else { 5322 oldbase = base; 5323 } 5324 if ((!xmlStrncmp(oldbase, BAD_CAST "http://", 7)) || 5325 (!xmlStrncmp(oldbase, BAD_CAST "ftp://", 6)) || 5326 (!xmlStrncmp(oldbase, BAD_CAST "urn:", 4))) 5327 return(oldbase); 5328 } 5329 } 5330 cur = cur->parent; 5331 } 5332 if ((doc != NULL) && (doc->URL != NULL)) { 5333 if (oldbase == NULL) 5334 return(xmlStrdup(doc->URL)); 5335 newbase = xmlBuildURI(oldbase, doc->URL); 5336 xmlFree(oldbase); 5337 return(newbase); 5338 } 5339 return(oldbase); 5340 } 5341 5342 /** 5343 * xmlNodeBufGetContent: 5344 * @buffer: a buffer 5345 * @cur: the node being read 5346 * 5347 * Read the value of a node @cur, this can be either the text carried 5348 * directly by this node if it's a TEXT node or the aggregate string 5349 * of the values carried by this node child's (TEXT and ENTITY_REF). 5350 * Entity references are substituted. 5351 * Fills up the buffer @buffer with this value 5352 * 5353 * Returns 0 in case of success and -1 in case of error. 5354 */ 5355 int 5356 xmlNodeBufGetContent(xmlBufferPtr buffer, const xmlNode *cur) 5357 { 5358 xmlBufPtr buf; 5359 int ret; 5360 5361 if ((cur == NULL) || (buffer == NULL)) return(-1); 5362 buf = xmlBufFromBuffer(buffer); 5363 ret = xmlBufGetNodeContent(buf, cur); 5364 buffer = xmlBufBackToBuffer(buf); 5365 if ((ret < 0) || (buffer == NULL)) 5366 return(-1); 5367 return(0); 5368 } 5369 5370 /** 5371 * xmlBufGetNodeContent: 5372 * @buf: a buffer xmlBufPtr 5373 * @cur: the node being read 5374 * 5375 * Read the value of a node @cur, this can be either the text carried 5376 * directly by this node if it's a TEXT node or the aggregate string 5377 * of the values carried by this node child's (TEXT and ENTITY_REF). 5378 * Entity references are substituted. 5379 * Fills up the buffer @buf with this value 5380 * 5381 * Returns 0 in case of success and -1 in case of error. 5382 */ 5383 int 5384 xmlBufGetNodeContent(xmlBufPtr buf, const xmlNode *cur) 5385 { 5386 if ((cur == NULL) || (buf == NULL)) return(-1); 5387 switch (cur->type) { 5388 case XML_CDATA_SECTION_NODE: 5389 case XML_TEXT_NODE: 5390 xmlBufCat(buf, cur->content); 5391 break; 5392 case XML_DOCUMENT_FRAG_NODE: 5393 case XML_ELEMENT_NODE:{ 5394 const xmlNode *tmp = cur; 5395 5396 while (tmp != NULL) { 5397 switch (tmp->type) { 5398 case XML_CDATA_SECTION_NODE: 5399 case XML_TEXT_NODE: 5400 if (tmp->content != NULL) 5401 xmlBufCat(buf, tmp->content); 5402 break; 5403 case XML_ENTITY_REF_NODE: 5404 xmlBufGetNodeContent(buf, tmp); 5405 break; 5406 default: 5407 break; 5408 } 5409 /* 5410 * Skip to next node 5411 */ 5412 if (tmp->children != NULL) { 5413 if (tmp->children->type != XML_ENTITY_DECL) { 5414 tmp = tmp->children; 5415 continue; 5416 } 5417 } 5418 if (tmp == cur) 5419 break; 5420 5421 if (tmp->next != NULL) { 5422 tmp = tmp->next; 5423 continue; 5424 } 5425 5426 do { 5427 tmp = tmp->parent; 5428 if (tmp == NULL) 5429 break; 5430 if (tmp == cur) { 5431 tmp = NULL; 5432 break; 5433 } 5434 if (tmp->next != NULL) { 5435 tmp = tmp->next; 5436 break; 5437 } 5438 } while (tmp != NULL); 5439 } 5440 break; 5441 } 5442 case XML_ATTRIBUTE_NODE:{ 5443 xmlAttrPtr attr = (xmlAttrPtr) cur; 5444 xmlNodePtr tmp = attr->children; 5445 5446 while (tmp != NULL) { 5447 if (tmp->type == XML_TEXT_NODE) 5448 xmlBufCat(buf, tmp->content); 5449 else 5450 xmlBufGetNodeContent(buf, tmp); 5451 tmp = tmp->next; 5452 } 5453 break; 5454 } 5455 case XML_COMMENT_NODE: 5456 case XML_PI_NODE: 5457 xmlBufCat(buf, cur->content); 5458 break; 5459 case XML_ENTITY_REF_NODE:{ 5460 xmlEntityPtr ent; 5461 xmlNodePtr tmp; 5462 5463 /* lookup entity declaration */ 5464 ent = xmlGetDocEntity(cur->doc, cur->name); 5465 if (ent == NULL) 5466 return(-1); 5467 5468 /* an entity content can be any "well balanced chunk", 5469 * i.e. the result of the content [43] production: 5470 * http://www.w3.org/TR/REC-xml#NT-content 5471 * -> we iterate through child nodes and recursive call 5472 * xmlNodeGetContent() which handles all possible node types */ 5473 tmp = ent->children; 5474 while (tmp) { 5475 xmlBufGetNodeContent(buf, tmp); 5476 tmp = tmp->next; 5477 } 5478 break; 5479 } 5480 case XML_ENTITY_NODE: 5481 case XML_DOCUMENT_TYPE_NODE: 5482 case XML_NOTATION_NODE: 5483 case XML_DTD_NODE: 5484 case XML_XINCLUDE_START: 5485 case XML_XINCLUDE_END: 5486 break; 5487 case XML_DOCUMENT_NODE: 5488 #ifdef LIBXML_DOCB_ENABLED 5489 case XML_DOCB_DOCUMENT_NODE: 5490 #endif 5491 case XML_HTML_DOCUMENT_NODE: 5492 cur = cur->children; 5493 while (cur!= NULL) { 5494 if ((cur->type == XML_ELEMENT_NODE) || 5495 (cur->type == XML_TEXT_NODE) || 5496 (cur->type == XML_CDATA_SECTION_NODE)) { 5497 xmlBufGetNodeContent(buf, cur); 5498 } 5499 cur = cur->next; 5500 } 5501 break; 5502 case XML_NAMESPACE_DECL: 5503 xmlBufCat(buf, ((xmlNsPtr) cur)->href); 5504 break; 5505 case XML_ELEMENT_DECL: 5506 case XML_ATTRIBUTE_DECL: 5507 case XML_ENTITY_DECL: 5508 break; 5509 } 5510 return(0); 5511 } 5512 5513 /** 5514 * xmlNodeGetContent: 5515 * @cur: the node being read 5516 * 5517 * Read the value of a node, this can be either the text carried 5518 * directly by this node if it's a TEXT node or the aggregate string 5519 * of the values carried by this node child's (TEXT and ENTITY_REF). 5520 * Entity references are substituted. 5521 * Returns a new #xmlChar * or NULL if no content is available. 5522 * It's up to the caller to free the memory with xmlFree(). 5523 */ 5524 xmlChar * 5525 xmlNodeGetContent(const xmlNode *cur) 5526 { 5527 if (cur == NULL) 5528 return (NULL); 5529 switch (cur->type) { 5530 case XML_DOCUMENT_FRAG_NODE: 5531 case XML_ELEMENT_NODE:{ 5532 xmlBufPtr buf; 5533 xmlChar *ret; 5534 5535 buf = xmlBufCreateSize(64); 5536 if (buf == NULL) 5537 return (NULL); 5538 xmlBufGetNodeContent(buf, cur); 5539 ret = xmlBufDetach(buf); 5540 xmlBufFree(buf); 5541 return (ret); 5542 } 5543 case XML_ATTRIBUTE_NODE: 5544 return(xmlGetPropNodeValueInternal((xmlAttrPtr) cur)); 5545 case XML_COMMENT_NODE: 5546 case XML_PI_NODE: 5547 if (cur->content != NULL) 5548 return (xmlStrdup(cur->content)); 5549 return (NULL); 5550 case XML_ENTITY_REF_NODE:{ 5551 xmlEntityPtr ent; 5552 xmlBufPtr buf; 5553 xmlChar *ret; 5554 5555 /* lookup entity declaration */ 5556 ent = xmlGetDocEntity(cur->doc, cur->name); 5557 if (ent == NULL) 5558 return (NULL); 5559 5560 buf = xmlBufCreate(); 5561 if (buf == NULL) 5562 return (NULL); 5563 5564 xmlBufGetNodeContent(buf, cur); 5565 5566 ret = xmlBufDetach(buf); 5567 xmlBufFree(buf); 5568 return (ret); 5569 } 5570 case XML_ENTITY_NODE: 5571 case XML_DOCUMENT_TYPE_NODE: 5572 case XML_NOTATION_NODE: 5573 case XML_DTD_NODE: 5574 case XML_XINCLUDE_START: 5575 case XML_XINCLUDE_END: 5576 return (NULL); 5577 case XML_DOCUMENT_NODE: 5578 #ifdef LIBXML_DOCB_ENABLED 5579 case XML_DOCB_DOCUMENT_NODE: 5580 #endif 5581 case XML_HTML_DOCUMENT_NODE: { 5582 xmlBufPtr buf; 5583 xmlChar *ret; 5584 5585 buf = xmlBufCreate(); 5586 if (buf == NULL) 5587 return (NULL); 5588 5589 xmlBufGetNodeContent(buf, (xmlNodePtr) cur); 5590 5591 ret = xmlBufDetach(buf); 5592 xmlBufFree(buf); 5593 return (ret); 5594 } 5595 case XML_NAMESPACE_DECL: { 5596 xmlChar *tmp; 5597 5598 tmp = xmlStrdup(((xmlNsPtr) cur)->href); 5599 return (tmp); 5600 } 5601 case XML_ELEMENT_DECL: 5602 /* TODO !!! */ 5603 return (NULL); 5604 case XML_ATTRIBUTE_DECL: 5605 /* TODO !!! */ 5606 return (NULL); 5607 case XML_ENTITY_DECL: 5608 /* TODO !!! */ 5609 return (NULL); 5610 case XML_CDATA_SECTION_NODE: 5611 case XML_TEXT_NODE: 5612 if (cur->content != NULL) 5613 return (xmlStrdup(cur->content)); 5614 return (NULL); 5615 } 5616 return (NULL); 5617 } 5618 5619 /** 5620 * xmlNodeSetContent: 5621 * @cur: the node being modified 5622 * @content: the new value of the content 5623 * 5624 * Replace the content of a node. 5625 * NOTE: @content is supposed to be a piece of XML CDATA, so it allows entity 5626 * references, but XML special chars need to be escaped first by using 5627 * xmlEncodeEntitiesReentrant() resp. xmlEncodeSpecialChars(). 5628 */ 5629 void 5630 xmlNodeSetContent(xmlNodePtr cur, const xmlChar *content) { 5631 if (cur == NULL) { 5632 #ifdef DEBUG_TREE 5633 xmlGenericError(xmlGenericErrorContext, 5634 "xmlNodeSetContent : node == NULL\n"); 5635 #endif 5636 return; 5637 } 5638 switch (cur->type) { 5639 case XML_DOCUMENT_FRAG_NODE: 5640 case XML_ELEMENT_NODE: 5641 case XML_ATTRIBUTE_NODE: 5642 if (cur->children != NULL) xmlFreeNodeList(cur->children); 5643 cur->children = xmlStringGetNodeList(cur->doc, content); 5644 UPDATE_LAST_CHILD_AND_PARENT(cur) 5645 break; 5646 case XML_TEXT_NODE: 5647 case XML_CDATA_SECTION_NODE: 5648 case XML_ENTITY_REF_NODE: 5649 case XML_ENTITY_NODE: 5650 case XML_PI_NODE: 5651 case XML_COMMENT_NODE: 5652 if ((cur->content != NULL) && 5653 (cur->content != (xmlChar *) &(cur->properties))) { 5654 if (!((cur->doc != NULL) && (cur->doc->dict != NULL) && 5655 (xmlDictOwns(cur->doc->dict, cur->content)))) 5656 xmlFree(cur->content); 5657 } 5658 if (cur->children != NULL) xmlFreeNodeList(cur->children); 5659 cur->last = cur->children = NULL; 5660 if (content != NULL) { 5661 cur->content = xmlStrdup(content); 5662 } else 5663 cur->content = NULL; 5664 cur->properties = NULL; 5665 cur->nsDef = NULL; 5666 break; 5667 case XML_DOCUMENT_NODE: 5668 case XML_HTML_DOCUMENT_NODE: 5669 case XML_DOCUMENT_TYPE_NODE: 5670 case XML_XINCLUDE_START: 5671 case XML_XINCLUDE_END: 5672 #ifdef LIBXML_DOCB_ENABLED 5673 case XML_DOCB_DOCUMENT_NODE: 5674 #endif 5675 break; 5676 case XML_NOTATION_NODE: 5677 break; 5678 case XML_DTD_NODE: 5679 break; 5680 case XML_NAMESPACE_DECL: 5681 break; 5682 case XML_ELEMENT_DECL: 5683 /* TODO !!! */ 5684 break; 5685 case XML_ATTRIBUTE_DECL: 5686 /* TODO !!! */ 5687 break; 5688 case XML_ENTITY_DECL: 5689 /* TODO !!! */ 5690 break; 5691 } 5692 } 5693 5694 #ifdef LIBXML_TREE_ENABLED 5695 /** 5696 * xmlNodeSetContentLen: 5697 * @cur: the node being modified 5698 * @content: the new value of the content 5699 * @len: the size of @content 5700 * 5701 * Replace the content of a node. 5702 * NOTE: @content is supposed to be a piece of XML CDATA, so it allows entity 5703 * references, but XML special chars need to be escaped first by using 5704 * xmlEncodeEntitiesReentrant() resp. xmlEncodeSpecialChars(). 5705 */ 5706 void 5707 xmlNodeSetContentLen(xmlNodePtr cur, const xmlChar *content, int len) { 5708 if (cur == NULL) { 5709 #ifdef DEBUG_TREE 5710 xmlGenericError(xmlGenericErrorContext, 5711 "xmlNodeSetContentLen : node == NULL\n"); 5712 #endif 5713 return; 5714 } 5715 switch (cur->type) { 5716 case XML_DOCUMENT_FRAG_NODE: 5717 case XML_ELEMENT_NODE: 5718 case XML_ATTRIBUTE_NODE: 5719 if (cur->children != NULL) xmlFreeNodeList(cur->children); 5720 cur->children = xmlStringLenGetNodeList(cur->doc, content, len); 5721 UPDATE_LAST_CHILD_AND_PARENT(cur) 5722 break; 5723 case XML_TEXT_NODE: 5724 case XML_CDATA_SECTION_NODE: 5725 case XML_ENTITY_REF_NODE: 5726 case XML_ENTITY_NODE: 5727 case XML_PI_NODE: 5728 case XML_COMMENT_NODE: 5729 case XML_NOTATION_NODE: 5730 if ((cur->content != NULL) && 5731 (cur->content != (xmlChar *) &(cur->properties))) { 5732 if (!((cur->doc != NULL) && (cur->doc->dict != NULL) && 5733 (xmlDictOwns(cur->doc->dict, cur->content)))) 5734 xmlFree(cur->content); 5735 } 5736 if (cur->children != NULL) xmlFreeNodeList(cur->children); 5737 cur->children = cur->last = NULL; 5738 if (content != NULL) { 5739 cur->content = xmlStrndup(content, len); 5740 } else 5741 cur->content = NULL; 5742 cur->properties = NULL; 5743 cur->nsDef = NULL; 5744 break; 5745 case XML_DOCUMENT_NODE: 5746 case XML_DTD_NODE: 5747 case XML_HTML_DOCUMENT_NODE: 5748 case XML_DOCUMENT_TYPE_NODE: 5749 case XML_NAMESPACE_DECL: 5750 case XML_XINCLUDE_START: 5751 case XML_XINCLUDE_END: 5752 #ifdef LIBXML_DOCB_ENABLED 5753 case XML_DOCB_DOCUMENT_NODE: 5754 #endif 5755 break; 5756 case XML_ELEMENT_DECL: 5757 /* TODO !!! */ 5758 break; 5759 case XML_ATTRIBUTE_DECL: 5760 /* TODO !!! */ 5761 break; 5762 case XML_ENTITY_DECL: 5763 /* TODO !!! */ 5764 break; 5765 } 5766 } 5767 #endif /* LIBXML_TREE_ENABLED */ 5768 5769 /** 5770 * xmlNodeAddContentLen: 5771 * @cur: the node being modified 5772 * @content: extra content 5773 * @len: the size of @content 5774 * 5775 * Append the extra substring to the node content. 5776 * NOTE: In contrast to xmlNodeSetContentLen(), @content is supposed to be 5777 * raw text, so unescaped XML special chars are allowed, entity 5778 * references are not supported. 5779 */ 5780 void 5781 xmlNodeAddContentLen(xmlNodePtr cur, const xmlChar *content, int len) { 5782 if (cur == NULL) { 5783 #ifdef DEBUG_TREE 5784 xmlGenericError(xmlGenericErrorContext, 5785 "xmlNodeAddContentLen : node == NULL\n"); 5786 #endif 5787 return; 5788 } 5789 if (len <= 0) return; 5790 switch (cur->type) { 5791 case XML_DOCUMENT_FRAG_NODE: 5792 case XML_ELEMENT_NODE: { 5793 xmlNodePtr last, newNode, tmp; 5794 5795 last = cur->last; 5796 newNode = xmlNewTextLen(content, len); 5797 if (newNode != NULL) { 5798 tmp = xmlAddChild(cur, newNode); 5799 if (tmp != newNode) 5800 return; 5801 if ((last != NULL) && (last->next == newNode)) { 5802 xmlTextMerge(last, newNode); 5803 } 5804 } 5805 break; 5806 } 5807 case XML_ATTRIBUTE_NODE: 5808 break; 5809 case XML_TEXT_NODE: 5810 case XML_CDATA_SECTION_NODE: 5811 case XML_ENTITY_REF_NODE: 5812 case XML_ENTITY_NODE: 5813 case XML_PI_NODE: 5814 case XML_COMMENT_NODE: 5815 case XML_NOTATION_NODE: 5816 if (content != NULL) { 5817 if ((cur->content == (xmlChar *) &(cur->properties)) || 5818 ((cur->doc != NULL) && (cur->doc->dict != NULL) && 5819 xmlDictOwns(cur->doc->dict, cur->content))) { 5820 cur->content = xmlStrncatNew(cur->content, content, len); 5821 cur->properties = NULL; 5822 cur->nsDef = NULL; 5823 break; 5824 } 5825 cur->content = xmlStrncat(cur->content, content, len); 5826 } 5827 case XML_DOCUMENT_NODE: 5828 case XML_DTD_NODE: 5829 case XML_HTML_DOCUMENT_NODE: 5830 case XML_DOCUMENT_TYPE_NODE: 5831 case XML_NAMESPACE_DECL: 5832 case XML_XINCLUDE_START: 5833 case XML_XINCLUDE_END: 5834 #ifdef LIBXML_DOCB_ENABLED 5835 case XML_DOCB_DOCUMENT_NODE: 5836 #endif 5837 break; 5838 case XML_ELEMENT_DECL: 5839 case XML_ATTRIBUTE_DECL: 5840 case XML_ENTITY_DECL: 5841 break; 5842 } 5843 } 5844 5845 /** 5846 * xmlNodeAddContent: 5847 * @cur: the node being modified 5848 * @content: extra content 5849 * 5850 * Append the extra substring to the node content. 5851 * NOTE: In contrast to xmlNodeSetContent(), @content is supposed to be 5852 * raw text, so unescaped XML special chars are allowed, entity 5853 * references are not supported. 5854 */ 5855 void 5856 xmlNodeAddContent(xmlNodePtr cur, const xmlChar *content) { 5857 int len; 5858 5859 if (cur == NULL) { 5860 #ifdef DEBUG_TREE 5861 xmlGenericError(xmlGenericErrorContext, 5862 "xmlNodeAddContent : node == NULL\n"); 5863 #endif 5864 return; 5865 } 5866 if (content == NULL) return; 5867 len = xmlStrlen(content); 5868 xmlNodeAddContentLen(cur, content, len); 5869 } 5870 5871 /** 5872 * xmlTextMerge: 5873 * @first: the first text node 5874 * @second: the second text node being merged 5875 * 5876 * Merge two text nodes into one 5877 * Returns the first text node augmented 5878 */ 5879 xmlNodePtr 5880 xmlTextMerge(xmlNodePtr first, xmlNodePtr second) { 5881 if (first == NULL) return(second); 5882 if (second == NULL) return(first); 5883 if (first->type != XML_TEXT_NODE) return(first); 5884 if (second->type != XML_TEXT_NODE) return(first); 5885 if (second->name != first->name) 5886 return(first); 5887 xmlNodeAddContent(first, second->content); 5888 xmlUnlinkNode(second); 5889 xmlFreeNode(second); 5890 return(first); 5891 } 5892 5893 #if defined(LIBXML_TREE_ENABLED) || defined(LIBXML_XPATH_ENABLED) || defined(LIBXML_SCHEMAS_ENABLED) 5894 /** 5895 * xmlGetNsList: 5896 * @doc: the document 5897 * @node: the current node 5898 * 5899 * Search all the namespace applying to a given element. 5900 * Returns an NULL terminated array of all the #xmlNsPtr found 5901 * that need to be freed by the caller or NULL if no 5902 * namespace if defined 5903 */ 5904 xmlNsPtr * 5905 xmlGetNsList(const xmlDoc *doc ATTRIBUTE_UNUSED, const xmlNode *node) 5906 { 5907 xmlNsPtr cur; 5908 xmlNsPtr *ret = NULL; 5909 int nbns = 0; 5910 int maxns = 10; 5911 int i; 5912 5913 if ((node == NULL) || (node->type == XML_NAMESPACE_DECL)) 5914 return(NULL); 5915 5916 while (node != NULL) { 5917 if (node->type == XML_ELEMENT_NODE) { 5918 cur = node->nsDef; 5919 while (cur != NULL) { 5920 if (ret == NULL) { 5921 ret = 5922 (xmlNsPtr *) xmlMalloc((maxns + 1) * 5923 sizeof(xmlNsPtr)); 5924 if (ret == NULL) { 5925 xmlTreeErrMemory("getting namespace list"); 5926 return (NULL); 5927 } 5928 ret[nbns] = NULL; 5929 } 5930 for (i = 0; i < nbns; i++) { 5931 if ((cur->prefix == ret[i]->prefix) || 5932 (xmlStrEqual(cur->prefix, ret[i]->prefix))) 5933 break; 5934 } 5935 if (i >= nbns) { 5936 if (nbns >= maxns) { 5937 maxns *= 2; 5938 ret = (xmlNsPtr *) xmlRealloc(ret, 5939 (maxns + 5940 1) * 5941 sizeof(xmlNsPtr)); 5942 if (ret == NULL) { 5943 xmlTreeErrMemory("getting namespace list"); 5944 return (NULL); 5945 } 5946 } 5947 ret[nbns++] = cur; 5948 ret[nbns] = NULL; 5949 } 5950 5951 cur = cur->next; 5952 } 5953 } 5954 node = node->parent; 5955 } 5956 return (ret); 5957 } 5958 #endif /* LIBXML_TREE_ENABLED */ 5959 5960 /* 5961 * xmlTreeEnsureXMLDecl: 5962 * @doc: the doc 5963 * 5964 * Ensures that there is an XML namespace declaration on the doc. 5965 * 5966 * Returns the XML ns-struct or NULL on API and internal errors. 5967 */ 5968 static xmlNsPtr 5969 xmlTreeEnsureXMLDecl(xmlDocPtr doc) 5970 { 5971 if (doc == NULL) 5972 return (NULL); 5973 if (doc->oldNs != NULL) 5974 return (doc->oldNs); 5975 { 5976 xmlNsPtr ns; 5977 ns = (xmlNsPtr) xmlMalloc(sizeof(xmlNs)); 5978 if (ns == NULL) { 5979 xmlTreeErrMemory( 5980 "allocating the XML namespace"); 5981 return (NULL); 5982 } 5983 memset(ns, 0, sizeof(xmlNs)); 5984 ns->type = XML_LOCAL_NAMESPACE; 5985 ns->href = xmlStrdup(XML_XML_NAMESPACE); 5986 ns->prefix = xmlStrdup((const xmlChar *)"xml"); 5987 doc->oldNs = ns; 5988 return (ns); 5989 } 5990 } 5991 5992 /** 5993 * xmlSearchNs: 5994 * @doc: the document 5995 * @node: the current node 5996 * @nameSpace: the namespace prefix 5997 * 5998 * Search a Ns registered under a given name space for a document. 5999 * recurse on the parents until it finds the defined namespace 6000 * or return NULL otherwise. 6001 * @nameSpace can be NULL, this is a search for the default namespace. 6002 * We don't allow to cross entities boundaries. If you don't declare 6003 * the namespace within those you will be in troubles !!! A warning 6004 * is generated to cover this case. 6005 * 6006 * Returns the namespace pointer or NULL. 6007 */ 6008 xmlNsPtr 6009 xmlSearchNs(xmlDocPtr doc, xmlNodePtr node, const xmlChar *nameSpace) { 6010 6011 xmlNsPtr cur; 6012 const xmlNode *orig = node; 6013 6014 if ((node == NULL) || (node->type == XML_NAMESPACE_DECL)) return(NULL); 6015 if ((nameSpace != NULL) && 6016 (xmlStrEqual(nameSpace, (const xmlChar *)"xml"))) { 6017 if ((doc == NULL) && (node->type == XML_ELEMENT_NODE)) { 6018 /* 6019 * The XML-1.0 namespace is normally held on the root 6020 * element. In this case exceptionally create it on the 6021 * node element. 6022 */ 6023 cur = (xmlNsPtr) xmlMalloc(sizeof(xmlNs)); 6024 if (cur == NULL) { 6025 xmlTreeErrMemory("searching namespace"); 6026 return(NULL); 6027 } 6028 memset(cur, 0, sizeof(xmlNs)); 6029 cur->type = XML_LOCAL_NAMESPACE; 6030 cur->href = xmlStrdup(XML_XML_NAMESPACE); 6031 cur->prefix = xmlStrdup((const xmlChar *)"xml"); 6032 cur->next = node->nsDef; 6033 node->nsDef = cur; 6034 return(cur); 6035 } 6036 if (doc == NULL) { 6037 doc = node->doc; 6038 if (doc == NULL) 6039 return(NULL); 6040 } 6041 /* 6042 * Return the XML namespace declaration held by the doc. 6043 */ 6044 if (doc->oldNs == NULL) 6045 return(xmlTreeEnsureXMLDecl(doc)); 6046 else 6047 return(doc->oldNs); 6048 } 6049 while (node != NULL) { 6050 if ((node->type == XML_ENTITY_REF_NODE) || 6051 (node->type == XML_ENTITY_NODE) || 6052 (node->type == XML_ENTITY_DECL)) 6053 return(NULL); 6054 if (node->type == XML_ELEMENT_NODE) { 6055 cur = node->nsDef; 6056 while (cur != NULL) { 6057 if ((cur->prefix == NULL) && (nameSpace == NULL) && 6058 (cur->href != NULL)) 6059 return(cur); 6060 if ((cur->prefix != NULL) && (nameSpace != NULL) && 6061 (cur->href != NULL) && 6062 (xmlStrEqual(cur->prefix, nameSpace))) 6063 return(cur); 6064 cur = cur->next; 6065 } 6066 if (orig != node) { 6067 cur = node->ns; 6068 if (cur != NULL) { 6069 if ((cur->prefix == NULL) && (nameSpace == NULL) && 6070 (cur->href != NULL)) 6071 return(cur); 6072 if ((cur->prefix != NULL) && (nameSpace != NULL) && 6073 (cur->href != NULL) && 6074 (xmlStrEqual(cur->prefix, nameSpace))) 6075 return(cur); 6076 } 6077 } 6078 } 6079 node = node->parent; 6080 } 6081 return(NULL); 6082 } 6083 6084 /** 6085 * xmlNsInScope: 6086 * @doc: the document 6087 * @node: the current node 6088 * @ancestor: the ancestor carrying the namespace 6089 * @prefix: the namespace prefix 6090 * 6091 * Verify that the given namespace held on @ancestor is still in scope 6092 * on node. 6093 * 6094 * Returns 1 if true, 0 if false and -1 in case of error. 6095 */ 6096 static int 6097 xmlNsInScope(xmlDocPtr doc ATTRIBUTE_UNUSED, xmlNodePtr node, 6098 xmlNodePtr ancestor, const xmlChar * prefix) 6099 { 6100 xmlNsPtr tst; 6101 6102 while ((node != NULL) && (node != ancestor)) { 6103 if ((node->type == XML_ENTITY_REF_NODE) || 6104 (node->type == XML_ENTITY_NODE) || 6105 (node->type == XML_ENTITY_DECL)) 6106 return (-1); 6107 if (node->type == XML_ELEMENT_NODE) { 6108 tst = node->nsDef; 6109 while (tst != NULL) { 6110 if ((tst->prefix == NULL) 6111 && (prefix == NULL)) 6112 return (0); 6113 if ((tst->prefix != NULL) 6114 && (prefix != NULL) 6115 && (xmlStrEqual(tst->prefix, prefix))) 6116 return (0); 6117 tst = tst->next; 6118 } 6119 } 6120 node = node->parent; 6121 } 6122 if (node != ancestor) 6123 return (-1); 6124 return (1); 6125 } 6126 6127 /** 6128 * xmlSearchNsByHref: 6129 * @doc: the document 6130 * @node: the current node 6131 * @href: the namespace value 6132 * 6133 * Search a Ns aliasing a given URI. Recurse on the parents until it finds 6134 * the defined namespace or return NULL otherwise. 6135 * Returns the namespace pointer or NULL. 6136 */ 6137 xmlNsPtr 6138 xmlSearchNsByHref(xmlDocPtr doc, xmlNodePtr node, const xmlChar * href) 6139 { 6140 xmlNsPtr cur; 6141 xmlNodePtr orig = node; 6142 int is_attr; 6143 6144 if ((node == NULL) || (node->type == XML_NAMESPACE_DECL) || (href == NULL)) 6145 return (NULL); 6146 if (xmlStrEqual(href, XML_XML_NAMESPACE)) { 6147 /* 6148 * Only the document can hold the XML spec namespace. 6149 */ 6150 if ((doc == NULL) && (node->type == XML_ELEMENT_NODE)) { 6151 /* 6152 * The XML-1.0 namespace is normally held on the root 6153 * element. In this case exceptionally create it on the 6154 * node element. 6155 */ 6156 cur = (xmlNsPtr) xmlMalloc(sizeof(xmlNs)); 6157 if (cur == NULL) { 6158 xmlTreeErrMemory("searching namespace"); 6159 return (NULL); 6160 } 6161 memset(cur, 0, sizeof(xmlNs)); 6162 cur->type = XML_LOCAL_NAMESPACE; 6163 cur->href = xmlStrdup(XML_XML_NAMESPACE); 6164 cur->prefix = xmlStrdup((const xmlChar *) "xml"); 6165 cur->next = node->nsDef; 6166 node->nsDef = cur; 6167 return (cur); 6168 } 6169 if (doc == NULL) { 6170 doc = node->doc; 6171 if (doc == NULL) 6172 return(NULL); 6173 } 6174 /* 6175 * Return the XML namespace declaration held by the doc. 6176 */ 6177 if (doc->oldNs == NULL) 6178 return(xmlTreeEnsureXMLDecl(doc)); 6179 else 6180 return(doc->oldNs); 6181 } 6182 is_attr = (node->type == XML_ATTRIBUTE_NODE); 6183 while (node != NULL) { 6184 if ((node->type == XML_ENTITY_REF_NODE) || 6185 (node->type == XML_ENTITY_NODE) || 6186 (node->type == XML_ENTITY_DECL)) 6187 return (NULL); 6188 if (node->type == XML_ELEMENT_NODE) { 6189 cur = node->nsDef; 6190 while (cur != NULL) { 6191 if ((cur->href != NULL) && (href != NULL) && 6192 (xmlStrEqual(cur->href, href))) { 6193 if (((!is_attr) || (cur->prefix != NULL)) && 6194 (xmlNsInScope(doc, orig, node, cur->prefix) == 1)) 6195 return (cur); 6196 } 6197 cur = cur->next; 6198 } 6199 if (orig != node) { 6200 cur = node->ns; 6201 if (cur != NULL) { 6202 if ((cur->href != NULL) && (href != NULL) && 6203 (xmlStrEqual(cur->href, href))) { 6204 if (((!is_attr) || (cur->prefix != NULL)) && 6205 (xmlNsInScope(doc, orig, node, cur->prefix) == 1)) 6206 return (cur); 6207 } 6208 } 6209 } 6210 } 6211 node = node->parent; 6212 } 6213 return (NULL); 6214 } 6215 6216 /** 6217 * xmlNewReconciliedNs: 6218 * @doc: the document 6219 * @tree: a node expected to hold the new namespace 6220 * @ns: the original namespace 6221 * 6222 * This function tries to locate a namespace definition in a tree 6223 * ancestors, or create a new namespace definition node similar to 6224 * @ns trying to reuse the same prefix. However if the given prefix is 6225 * null (default namespace) or reused within the subtree defined by 6226 * @tree or on one of its ancestors then a new prefix is generated. 6227 * Returns the (new) namespace definition or NULL in case of error 6228 */ 6229 static xmlNsPtr 6230 xmlNewReconciliedNs(xmlDocPtr doc, xmlNodePtr tree, xmlNsPtr ns) { 6231 xmlNsPtr def; 6232 xmlChar prefix[50]; 6233 int counter = 1; 6234 6235 if ((tree == NULL) || (tree->type != XML_ELEMENT_NODE)) { 6236 #ifdef DEBUG_TREE 6237 xmlGenericError(xmlGenericErrorContext, 6238 "xmlNewReconciliedNs : tree == NULL\n"); 6239 #endif 6240 return(NULL); 6241 } 6242 if ((ns == NULL) || (ns->type != XML_NAMESPACE_DECL)) { 6243 #ifdef DEBUG_TREE 6244 xmlGenericError(xmlGenericErrorContext, 6245 "xmlNewReconciliedNs : ns == NULL\n"); 6246 #endif 6247 return(NULL); 6248 } 6249 /* 6250 * Search an existing namespace definition inherited. 6251 */ 6252 def = xmlSearchNsByHref(doc, tree, ns->href); 6253 if (def != NULL) 6254 return(def); 6255 6256 /* 6257 * Find a close prefix which is not already in use. 6258 * Let's strip namespace prefixes longer than 20 chars ! 6259 */ 6260 if (ns->prefix == NULL) 6261 snprintf((char *) prefix, sizeof(prefix), "default"); 6262 else 6263 snprintf((char *) prefix, sizeof(prefix), "%.20s", (char *)ns->prefix); 6264 6265 def = xmlSearchNs(doc, tree, prefix); 6266 while (def != NULL) { 6267 if (counter > 1000) return(NULL); 6268 if (ns->prefix == NULL) 6269 snprintf((char *) prefix, sizeof(prefix), "default%d", counter++); 6270 else 6271 snprintf((char *) prefix, sizeof(prefix), "%.20s%d", 6272 (char *)ns->prefix, counter++); 6273 def = xmlSearchNs(doc, tree, prefix); 6274 } 6275 6276 /* 6277 * OK, now we are ready to create a new one. 6278 */ 6279 def = xmlNewNs(tree, ns->href, prefix); 6280 return(def); 6281 } 6282 6283 #ifdef LIBXML_TREE_ENABLED 6284 /** 6285 * xmlReconciliateNs: 6286 * @doc: the document 6287 * @tree: a node defining the subtree to reconciliate 6288 * 6289 * This function checks that all the namespaces declared within the given 6290 * tree are properly declared. This is needed for example after Copy or Cut 6291 * and then paste operations. The subtree may still hold pointers to 6292 * namespace declarations outside the subtree or invalid/masked. As much 6293 * as possible the function try to reuse the existing namespaces found in 6294 * the new environment. If not possible the new namespaces are redeclared 6295 * on @tree at the top of the given subtree. 6296 * Returns the number of namespace declarations created or -1 in case of error. 6297 */ 6298 int 6299 xmlReconciliateNs(xmlDocPtr doc, xmlNodePtr tree) { 6300 xmlNsPtr *oldNs = NULL; 6301 xmlNsPtr *newNs = NULL; 6302 int sizeCache = 0; 6303 int nbCache = 0; 6304 6305 xmlNsPtr n; 6306 xmlNodePtr node = tree; 6307 xmlAttrPtr attr; 6308 int ret = 0, i; 6309 6310 if ((node == NULL) || (node->type != XML_ELEMENT_NODE)) return(-1); 6311 if ((doc == NULL) || (doc->type != XML_DOCUMENT_NODE)) return(-1); 6312 if (node->doc != doc) return(-1); 6313 while (node != NULL) { 6314 /* 6315 * Reconciliate the node namespace 6316 */ 6317 if (node->ns != NULL) { 6318 /* 6319 * initialize the cache if needed 6320 */ 6321 if (sizeCache == 0) { 6322 sizeCache = 10; 6323 oldNs = (xmlNsPtr *) xmlMalloc(sizeCache * 6324 sizeof(xmlNsPtr)); 6325 if (oldNs == NULL) { 6326 xmlTreeErrMemory("fixing namespaces"); 6327 return(-1); 6328 } 6329 newNs = (xmlNsPtr *) xmlMalloc(sizeCache * 6330 sizeof(xmlNsPtr)); 6331 if (newNs == NULL) { 6332 xmlTreeErrMemory("fixing namespaces"); 6333 xmlFree(oldNs); 6334 return(-1); 6335 } 6336 } 6337 for (i = 0;i < nbCache;i++) { 6338 if (oldNs[i] == node->ns) { 6339 node->ns = newNs[i]; 6340 break; 6341 } 6342 } 6343 if (i == nbCache) { 6344 /* 6345 * OK we need to recreate a new namespace definition 6346 */ 6347 n = xmlNewReconciliedNs(doc, tree, node->ns); 6348 if (n != NULL) { /* :-( what if else ??? */ 6349 /* 6350 * check if we need to grow the cache buffers. 6351 */ 6352 if (sizeCache <= nbCache) { 6353 sizeCache *= 2; 6354 oldNs = (xmlNsPtr *) xmlRealloc(oldNs, sizeCache * 6355 sizeof(xmlNsPtr)); 6356 if (oldNs == NULL) { 6357 xmlTreeErrMemory("fixing namespaces"); 6358 xmlFree(newNs); 6359 return(-1); 6360 } 6361 newNs = (xmlNsPtr *) xmlRealloc(newNs, sizeCache * 6362 sizeof(xmlNsPtr)); 6363 if (newNs == NULL) { 6364 xmlTreeErrMemory("fixing namespaces"); 6365 xmlFree(oldNs); 6366 return(-1); 6367 } 6368 } 6369 newNs[nbCache] = n; 6370 oldNs[nbCache++] = node->ns; 6371 node->ns = n; 6372 } 6373 } 6374 } 6375 /* 6376 * now check for namespace hold by attributes on the node. 6377 */ 6378 if (node->type == XML_ELEMENT_NODE) { 6379 attr = node->properties; 6380 while (attr != NULL) { 6381 if (attr->ns != NULL) { 6382 /* 6383 * initialize the cache if needed 6384 */ 6385 if (sizeCache == 0) { 6386 sizeCache = 10; 6387 oldNs = (xmlNsPtr *) xmlMalloc(sizeCache * 6388 sizeof(xmlNsPtr)); 6389 if (oldNs == NULL) { 6390 xmlTreeErrMemory("fixing namespaces"); 6391 return(-1); 6392 } 6393 newNs = (xmlNsPtr *) xmlMalloc(sizeCache * 6394 sizeof(xmlNsPtr)); 6395 if (newNs == NULL) { 6396 xmlTreeErrMemory("fixing namespaces"); 6397 xmlFree(oldNs); 6398 return(-1); 6399 } 6400 } 6401 for (i = 0;i < nbCache;i++) { 6402 if (oldNs[i] == attr->ns) { 6403 attr->ns = newNs[i]; 6404 break; 6405 } 6406 } 6407 if (i == nbCache) { 6408 /* 6409 * OK we need to recreate a new namespace definition 6410 */ 6411 n = xmlNewReconciliedNs(doc, tree, attr->ns); 6412 if (n != NULL) { /* :-( what if else ??? */ 6413 /* 6414 * check if we need to grow the cache buffers. 6415 */ 6416 if (sizeCache <= nbCache) { 6417 sizeCache *= 2; 6418 oldNs = (xmlNsPtr *) xmlRealloc(oldNs, 6419 sizeCache * sizeof(xmlNsPtr)); 6420 if (oldNs == NULL) { 6421 xmlTreeErrMemory("fixing namespaces"); 6422 xmlFree(newNs); 6423 return(-1); 6424 } 6425 newNs = (xmlNsPtr *) xmlRealloc(newNs, 6426 sizeCache * sizeof(xmlNsPtr)); 6427 if (newNs == NULL) { 6428 xmlTreeErrMemory("fixing namespaces"); 6429 xmlFree(oldNs); 6430 return(-1); 6431 } 6432 } 6433 newNs[nbCache] = n; 6434 oldNs[nbCache++] = attr->ns; 6435 attr->ns = n; 6436 } 6437 } 6438 } 6439 attr = attr->next; 6440 } 6441 } 6442 6443 /* 6444 * Browse the full subtree, deep first 6445 */ 6446 if ((node->children != NULL) && (node->type != XML_ENTITY_REF_NODE)) { 6447 /* deep first */ 6448 node = node->children; 6449 } else if ((node != tree) && (node->next != NULL)) { 6450 /* then siblings */ 6451 node = node->next; 6452 } else if (node != tree) { 6453 /* go up to parents->next if needed */ 6454 while (node != tree) { 6455 if (node->parent != NULL) 6456 node = node->parent; 6457 if ((node != tree) && (node->next != NULL)) { 6458 node = node->next; 6459 break; 6460 } 6461 if (node->parent == NULL) { 6462 node = NULL; 6463 break; 6464 } 6465 } 6466 /* exit condition */ 6467 if (node == tree) 6468 node = NULL; 6469 } else 6470 break; 6471 } 6472 if (oldNs != NULL) 6473 xmlFree(oldNs); 6474 if (newNs != NULL) 6475 xmlFree(newNs); 6476 return(ret); 6477 } 6478 #endif /* LIBXML_TREE_ENABLED */ 6479 6480 static xmlAttrPtr 6481 xmlGetPropNodeInternal(const xmlNode *node, const xmlChar *name, 6482 const xmlChar *nsName, int useDTD) 6483 { 6484 xmlAttrPtr prop; 6485 6486 if ((node == NULL) || (node->type != XML_ELEMENT_NODE) || (name == NULL)) 6487 return(NULL); 6488 6489 if (node->properties != NULL) { 6490 prop = node->properties; 6491 if (nsName == NULL) { 6492 /* 6493 * We want the attr to be in no namespace. 6494 */ 6495 do { 6496 if ((prop->ns == NULL) && xmlStrEqual(prop->name, name)) { 6497 return(prop); 6498 } 6499 prop = prop->next; 6500 } while (prop != NULL); 6501 } else { 6502 /* 6503 * We want the attr to be in the specified namespace. 6504 */ 6505 do { 6506 if ((prop->ns != NULL) && xmlStrEqual(prop->name, name) && 6507 ((prop->ns->href == nsName) || 6508 xmlStrEqual(prop->ns->href, nsName))) 6509 { 6510 return(prop); 6511 } 6512 prop = prop->next; 6513 } while (prop != NULL); 6514 } 6515 } 6516 6517 #ifdef LIBXML_TREE_ENABLED 6518 if (! useDTD) 6519 return(NULL); 6520 /* 6521 * Check if there is a default/fixed attribute declaration in 6522 * the internal or external subset. 6523 */ 6524 if ((node->doc != NULL) && (node->doc->intSubset != NULL)) { 6525 xmlDocPtr doc = node->doc; 6526 xmlAttributePtr attrDecl = NULL; 6527 xmlChar *elemQName, *tmpstr = NULL; 6528 6529 /* 6530 * We need the QName of the element for the DTD-lookup. 6531 */ 6532 if ((node->ns != NULL) && (node->ns->prefix != NULL)) { 6533 tmpstr = xmlStrdup(node->ns->prefix); 6534 tmpstr = xmlStrcat(tmpstr, BAD_CAST ":"); 6535 tmpstr = xmlStrcat(tmpstr, node->name); 6536 if (tmpstr == NULL) 6537 return(NULL); 6538 elemQName = tmpstr; 6539 } else 6540 elemQName = (xmlChar *) node->name; 6541 if (nsName == NULL) { 6542 /* 6543 * The common and nice case: Attr in no namespace. 6544 */ 6545 attrDecl = xmlGetDtdQAttrDesc(doc->intSubset, 6546 elemQName, name, NULL); 6547 if ((attrDecl == NULL) && (doc->extSubset != NULL)) { 6548 attrDecl = xmlGetDtdQAttrDesc(doc->extSubset, 6549 elemQName, name, NULL); 6550 } 6551 } else { 6552 xmlNsPtr *nsList, *cur; 6553 6554 /* 6555 * The ugly case: Search using the prefixes of in-scope 6556 * ns-decls corresponding to @nsName. 6557 */ 6558 nsList = xmlGetNsList(node->doc, node); 6559 if (nsList == NULL) { 6560 if (tmpstr != NULL) 6561 xmlFree(tmpstr); 6562 return(NULL); 6563 } 6564 cur = nsList; 6565 while (*cur != NULL) { 6566 if (xmlStrEqual((*cur)->href, nsName)) { 6567 attrDecl = xmlGetDtdQAttrDesc(doc->intSubset, elemQName, 6568 name, (*cur)->prefix); 6569 if (attrDecl) 6570 break; 6571 if (doc->extSubset != NULL) { 6572 attrDecl = xmlGetDtdQAttrDesc(doc->extSubset, elemQName, 6573 name, (*cur)->prefix); 6574 if (attrDecl) 6575 break; 6576 } 6577 } 6578 cur++; 6579 } 6580 xmlFree(nsList); 6581 } 6582 if (tmpstr != NULL) 6583 xmlFree(tmpstr); 6584 /* 6585 * Only default/fixed attrs are relevant. 6586 */ 6587 if ((attrDecl != NULL) && (attrDecl->defaultValue != NULL)) 6588 return((xmlAttrPtr) attrDecl); 6589 } 6590 #endif /* LIBXML_TREE_ENABLED */ 6591 return(NULL); 6592 } 6593 6594 static xmlChar* 6595 xmlGetPropNodeValueInternal(const xmlAttr *prop) 6596 { 6597 if (prop == NULL) 6598 return(NULL); 6599 if (prop->type == XML_ATTRIBUTE_NODE) { 6600 /* 6601 * Note that we return at least the empty string. 6602 * TODO: Do we really always want that? 6603 */ 6604 if (prop->children != NULL) { 6605 if ((prop->children->next == NULL) && 6606 ((prop->children->type == XML_TEXT_NODE) || 6607 (prop->children->type == XML_CDATA_SECTION_NODE))) 6608 { 6609 /* 6610 * Optimization for the common case: only 1 text node. 6611 */ 6612 return(xmlStrdup(prop->children->content)); 6613 } else { 6614 xmlChar *ret; 6615 6616 ret = xmlNodeListGetString(prop->doc, prop->children, 1); 6617 if (ret != NULL) 6618 return(ret); 6619 } 6620 } 6621 return(xmlStrdup((xmlChar *)"")); 6622 } else if (prop->type == XML_ATTRIBUTE_DECL) { 6623 return(xmlStrdup(((xmlAttributePtr)prop)->defaultValue)); 6624 } 6625 return(NULL); 6626 } 6627 6628 /** 6629 * xmlHasProp: 6630 * @node: the node 6631 * @name: the attribute name 6632 * 6633 * Search an attribute associated to a node 6634 * This function also looks in DTD attribute declaration for #FIXED or 6635 * default declaration values unless DTD use has been turned off. 6636 * 6637 * Returns the attribute or the attribute declaration or NULL if 6638 * neither was found. 6639 */ 6640 xmlAttrPtr 6641 xmlHasProp(const xmlNode *node, const xmlChar *name) { 6642 xmlAttrPtr prop; 6643 xmlDocPtr doc; 6644 6645 if ((node == NULL) || (node->type != XML_ELEMENT_NODE) || (name == NULL)) 6646 return(NULL); 6647 /* 6648 * Check on the properties attached to the node 6649 */ 6650 prop = node->properties; 6651 while (prop != NULL) { 6652 if (xmlStrEqual(prop->name, name)) { 6653 return(prop); 6654 } 6655 prop = prop->next; 6656 } 6657 if (!xmlCheckDTD) return(NULL); 6658 6659 /* 6660 * Check if there is a default declaration in the internal 6661 * or external subsets 6662 */ 6663 doc = node->doc; 6664 if (doc != NULL) { 6665 xmlAttributePtr attrDecl; 6666 if (doc->intSubset != NULL) { 6667 attrDecl = xmlGetDtdAttrDesc(doc->intSubset, node->name, name); 6668 if ((attrDecl == NULL) && (doc->extSubset != NULL)) 6669 attrDecl = xmlGetDtdAttrDesc(doc->extSubset, node->name, name); 6670 if ((attrDecl != NULL) && (attrDecl->defaultValue != NULL)) 6671 /* return attribute declaration only if a default value is given 6672 (that includes #FIXED declarations) */ 6673 return((xmlAttrPtr) attrDecl); 6674 } 6675 } 6676 return(NULL); 6677 } 6678 6679 /** 6680 * xmlHasNsProp: 6681 * @node: the node 6682 * @name: the attribute name 6683 * @nameSpace: the URI of the namespace 6684 * 6685 * Search for an attribute associated to a node 6686 * This attribute has to be anchored in the namespace specified. 6687 * This does the entity substitution. 6688 * This function looks in DTD attribute declaration for #FIXED or 6689 * default declaration values unless DTD use has been turned off. 6690 * Note that a namespace of NULL indicates to use the default namespace. 6691 * 6692 * Returns the attribute or the attribute declaration or NULL 6693 * if neither was found. 6694 */ 6695 xmlAttrPtr 6696 xmlHasNsProp(const xmlNode *node, const xmlChar *name, const xmlChar *nameSpace) { 6697 6698 return(xmlGetPropNodeInternal(node, name, nameSpace, xmlCheckDTD)); 6699 } 6700 6701 /** 6702 * xmlGetProp: 6703 * @node: the node 6704 * @name: the attribute name 6705 * 6706 * Search and get the value of an attribute associated to a node 6707 * This does the entity substitution. 6708 * This function looks in DTD attribute declaration for #FIXED or 6709 * default declaration values unless DTD use has been turned off. 6710 * NOTE: this function acts independently of namespaces associated 6711 * to the attribute. Use xmlGetNsProp() or xmlGetNoNsProp() 6712 * for namespace aware processing. 6713 * 6714 * Returns the attribute value or NULL if not found. 6715 * It's up to the caller to free the memory with xmlFree(). 6716 */ 6717 xmlChar * 6718 xmlGetProp(const xmlNode *node, const xmlChar *name) { 6719 xmlAttrPtr prop; 6720 6721 prop = xmlHasProp(node, name); 6722 if (prop == NULL) 6723 return(NULL); 6724 return(xmlGetPropNodeValueInternal(prop)); 6725 } 6726 6727 /** 6728 * xmlGetNoNsProp: 6729 * @node: the node 6730 * @name: the attribute name 6731 * 6732 * Search and get the value of an attribute associated to a node 6733 * This does the entity substitution. 6734 * This function looks in DTD attribute declaration for #FIXED or 6735 * default declaration values unless DTD use has been turned off. 6736 * This function is similar to xmlGetProp except it will accept only 6737 * an attribute in no namespace. 6738 * 6739 * Returns the attribute value or NULL if not found. 6740 * It's up to the caller to free the memory with xmlFree(). 6741 */ 6742 xmlChar * 6743 xmlGetNoNsProp(const xmlNode *node, const xmlChar *name) { 6744 xmlAttrPtr prop; 6745 6746 prop = xmlGetPropNodeInternal(node, name, NULL, xmlCheckDTD); 6747 if (prop == NULL) 6748 return(NULL); 6749 return(xmlGetPropNodeValueInternal(prop)); 6750 } 6751 6752 /** 6753 * xmlGetNsProp: 6754 * @node: the node 6755 * @name: the attribute name 6756 * @nameSpace: the URI of the namespace 6757 * 6758 * Search and get the value of an attribute associated to a node 6759 * This attribute has to be anchored in the namespace specified. 6760 * This does the entity substitution. 6761 * This function looks in DTD attribute declaration for #FIXED or 6762 * default declaration values unless DTD use has been turned off. 6763 * 6764 * Returns the attribute value or NULL if not found. 6765 * It's up to the caller to free the memory with xmlFree(). 6766 */ 6767 xmlChar * 6768 xmlGetNsProp(const xmlNode *node, const xmlChar *name, const xmlChar *nameSpace) { 6769 xmlAttrPtr prop; 6770 6771 prop = xmlGetPropNodeInternal(node, name, nameSpace, xmlCheckDTD); 6772 if (prop == NULL) 6773 return(NULL); 6774 return(xmlGetPropNodeValueInternal(prop)); 6775 } 6776 6777 #if defined(LIBXML_TREE_ENABLED) || defined(LIBXML_SCHEMAS_ENABLED) 6778 /** 6779 * xmlUnsetProp: 6780 * @node: the node 6781 * @name: the attribute name 6782 * 6783 * Remove an attribute carried by a node. 6784 * This handles only attributes in no namespace. 6785 * Returns 0 if successful, -1 if not found 6786 */ 6787 int 6788 xmlUnsetProp(xmlNodePtr node, const xmlChar *name) { 6789 xmlAttrPtr prop; 6790 6791 prop = xmlGetPropNodeInternal(node, name, NULL, 0); 6792 if (prop == NULL) 6793 return(-1); 6794 xmlUnlinkNode((xmlNodePtr) prop); 6795 xmlFreeProp(prop); 6796 return(0); 6797 } 6798 6799 /** 6800 * xmlUnsetNsProp: 6801 * @node: the node 6802 * @ns: the namespace definition 6803 * @name: the attribute name 6804 * 6805 * Remove an attribute carried by a node. 6806 * Returns 0 if successful, -1 if not found 6807 */ 6808 int 6809 xmlUnsetNsProp(xmlNodePtr node, xmlNsPtr ns, const xmlChar *name) { 6810 xmlAttrPtr prop; 6811 6812 prop = xmlGetPropNodeInternal(node, name, (ns != NULL) ? ns->href : NULL, 0); 6813 if (prop == NULL) 6814 return(-1); 6815 xmlUnlinkNode((xmlNodePtr) prop); 6816 xmlFreeProp(prop); 6817 return(0); 6818 } 6819 #endif 6820 6821 #if defined(LIBXML_TREE_ENABLED) || defined(LIBXML_XINCLUDE_ENABLED) || defined(LIBXML_SCHEMAS_ENABLED) || defined(LIBXML_HTML_ENABLED) 6822 /** 6823 * xmlSetProp: 6824 * @node: the node 6825 * @name: the attribute name (a QName) 6826 * @value: the attribute value 6827 * 6828 * Set (or reset) an attribute carried by a node. 6829 * If @name has a prefix, then the corresponding 6830 * namespace-binding will be used, if in scope; it is an 6831 * error it there's no such ns-binding for the prefix in 6832 * scope. 6833 * Returns the attribute pointer. 6834 * 6835 */ 6836 xmlAttrPtr 6837 xmlSetProp(xmlNodePtr node, const xmlChar *name, const xmlChar *value) { 6838 int len; 6839 const xmlChar *nqname; 6840 6841 if ((node == NULL) || (name == NULL) || (node->type != XML_ELEMENT_NODE)) 6842 return(NULL); 6843 6844 /* 6845 * handle QNames 6846 */ 6847 nqname = xmlSplitQName3(name, &len); 6848 if (nqname != NULL) { 6849 xmlNsPtr ns; 6850 xmlChar *prefix = xmlStrndup(name, len); 6851 ns = xmlSearchNs(node->doc, node, prefix); 6852 if (prefix != NULL) 6853 xmlFree(prefix); 6854 if (ns != NULL) 6855 return(xmlSetNsProp(node, ns, nqname, value)); 6856 } 6857 return(xmlSetNsProp(node, NULL, name, value)); 6858 } 6859 6860 /** 6861 * xmlSetNsProp: 6862 * @node: the node 6863 * @ns: the namespace definition 6864 * @name: the attribute name 6865 * @value: the attribute value 6866 * 6867 * Set (or reset) an attribute carried by a node. 6868 * The ns structure must be in scope, this is not checked 6869 * 6870 * Returns the attribute pointer. 6871 */ 6872 xmlAttrPtr 6873 xmlSetNsProp(xmlNodePtr node, xmlNsPtr ns, const xmlChar *name, 6874 const xmlChar *value) 6875 { 6876 xmlAttrPtr prop; 6877 6878 if (ns && (ns->href == NULL)) 6879 return(NULL); 6880 prop = xmlGetPropNodeInternal(node, name, (ns != NULL) ? ns->href : NULL, 0); 6881 if (prop != NULL) { 6882 /* 6883 * Modify the attribute's value. 6884 */ 6885 if (prop->atype == XML_ATTRIBUTE_ID) { 6886 xmlRemoveID(node->doc, prop); 6887 prop->atype = XML_ATTRIBUTE_ID; 6888 } 6889 if (prop->children != NULL) 6890 xmlFreeNodeList(prop->children); 6891 prop->children = NULL; 6892 prop->last = NULL; 6893 prop->ns = ns; 6894 if (value != NULL) { 6895 xmlNodePtr tmp; 6896 6897 if(!xmlCheckUTF8(value)) { 6898 xmlTreeErr(XML_TREE_NOT_UTF8, (xmlNodePtr) node->doc, 6899 NULL); 6900 if (node->doc != NULL) 6901 node->doc->encoding = xmlStrdup(BAD_CAST "ISO-8859-1"); 6902 } 6903 prop->children = xmlNewDocText(node->doc, value); 6904 prop->last = NULL; 6905 tmp = prop->children; 6906 while (tmp != NULL) { 6907 tmp->parent = (xmlNodePtr) prop; 6908 if (tmp->next == NULL) 6909 prop->last = tmp; 6910 tmp = tmp->next; 6911 } 6912 } 6913 if (prop->atype == XML_ATTRIBUTE_ID) 6914 xmlAddID(NULL, node->doc, value, prop); 6915 return(prop); 6916 } 6917 /* 6918 * No equal attr found; create a new one. 6919 */ 6920 return(xmlNewPropInternal(node, ns, name, value, 0)); 6921 } 6922 6923 #endif /* LIBXML_TREE_ENABLED */ 6924 6925 /** 6926 * xmlNodeIsText: 6927 * @node: the node 6928 * 6929 * Is this node a Text node ? 6930 * Returns 1 yes, 0 no 6931 */ 6932 int 6933 xmlNodeIsText(const xmlNode *node) { 6934 if (node == NULL) return(0); 6935 6936 if (node->type == XML_TEXT_NODE) return(1); 6937 return(0); 6938 } 6939 6940 /** 6941 * xmlIsBlankNode: 6942 * @node: the node 6943 * 6944 * Checks whether this node is an empty or whitespace only 6945 * (and possibly ignorable) text-node. 6946 * 6947 * Returns 1 yes, 0 no 6948 */ 6949 int 6950 xmlIsBlankNode(const xmlNode *node) { 6951 const xmlChar *cur; 6952 if (node == NULL) return(0); 6953 6954 if ((node->type != XML_TEXT_NODE) && 6955 (node->type != XML_CDATA_SECTION_NODE)) 6956 return(0); 6957 if (node->content == NULL) return(1); 6958 cur = node->content; 6959 while (*cur != 0) { 6960 if (!IS_BLANK_CH(*cur)) return(0); 6961 cur++; 6962 } 6963 6964 return(1); 6965 } 6966 6967 /** 6968 * xmlTextConcat: 6969 * @node: the node 6970 * @content: the content 6971 * @len: @content length 6972 * 6973 * Concat the given string at the end of the existing node content 6974 * 6975 * Returns -1 in case of error, 0 otherwise 6976 */ 6977 6978 int 6979 xmlTextConcat(xmlNodePtr node, const xmlChar *content, int len) { 6980 if (node == NULL) return(-1); 6981 6982 if ((node->type != XML_TEXT_NODE) && 6983 (node->type != XML_CDATA_SECTION_NODE) && 6984 (node->type != XML_COMMENT_NODE) && 6985 (node->type != XML_PI_NODE)) { 6986 #ifdef DEBUG_TREE 6987 xmlGenericError(xmlGenericErrorContext, 6988 "xmlTextConcat: node is not text nor CDATA\n"); 6989 #endif 6990 return(-1); 6991 } 6992 /* need to check if content is currently in the dictionary */ 6993 if ((node->content == (xmlChar *) &(node->properties)) || 6994 ((node->doc != NULL) && (node->doc->dict != NULL) && 6995 xmlDictOwns(node->doc->dict, node->content))) { 6996 node->content = xmlStrncatNew(node->content, content, len); 6997 } else { 6998 node->content = xmlStrncat(node->content, content, len); 6999 } 7000 node->properties = NULL; 7001 if (node->content == NULL) 7002 return(-1); 7003 return(0); 7004 } 7005 7006 /************************************************************************ 7007 * * 7008 * Output : to a FILE or in memory * 7009 * * 7010 ************************************************************************/ 7011 7012 /** 7013 * xmlBufferCreate: 7014 * 7015 * routine to create an XML buffer. 7016 * returns the new structure. 7017 */ 7018 xmlBufferPtr 7019 xmlBufferCreate(void) { 7020 xmlBufferPtr ret; 7021 7022 ret = (xmlBufferPtr) xmlMalloc(sizeof(xmlBuffer)); 7023 if (ret == NULL) { 7024 xmlTreeErrMemory("creating buffer"); 7025 return(NULL); 7026 } 7027 ret->use = 0; 7028 ret->size = xmlDefaultBufferSize; 7029 ret->alloc = xmlBufferAllocScheme; 7030 ret->content = (xmlChar *) xmlMallocAtomic(ret->size * sizeof(xmlChar)); 7031 if (ret->content == NULL) { 7032 xmlTreeErrMemory("creating buffer"); 7033 xmlFree(ret); 7034 return(NULL); 7035 } 7036 ret->content[0] = 0; 7037 ret->contentIO = NULL; 7038 return(ret); 7039 } 7040 7041 /** 7042 * xmlBufferCreateSize: 7043 * @size: initial size of buffer 7044 * 7045 * routine to create an XML buffer. 7046 * returns the new structure. 7047 */ 7048 xmlBufferPtr 7049 xmlBufferCreateSize(size_t size) { 7050 xmlBufferPtr ret; 7051 7052 ret = (xmlBufferPtr) xmlMalloc(sizeof(xmlBuffer)); 7053 if (ret == NULL) { 7054 xmlTreeErrMemory("creating buffer"); 7055 return(NULL); 7056 } 7057 ret->use = 0; 7058 ret->alloc = xmlBufferAllocScheme; 7059 ret->size = (size ? size+2 : 0); /* +1 for ending null */ 7060 if (ret->size){ 7061 ret->content = (xmlChar *) xmlMallocAtomic(ret->size * sizeof(xmlChar)); 7062 if (ret->content == NULL) { 7063 xmlTreeErrMemory("creating buffer"); 7064 xmlFree(ret); 7065 return(NULL); 7066 } 7067 ret->content[0] = 0; 7068 } else 7069 ret->content = NULL; 7070 ret->contentIO = NULL; 7071 return(ret); 7072 } 7073 7074 /** 7075 * xmlBufferDetach: 7076 * @buf: the buffer 7077 * 7078 * Remove the string contained in a buffer and gie it back to the 7079 * caller. The buffer is reset to an empty content. 7080 * This doesn't work with immutable buffers as they can't be reset. 7081 * 7082 * Returns the previous string contained by the buffer. 7083 */ 7084 xmlChar * 7085 xmlBufferDetach(xmlBufferPtr buf) { 7086 xmlChar *ret; 7087 7088 if (buf == NULL) 7089 return(NULL); 7090 if (buf->alloc == XML_BUFFER_ALLOC_IMMUTABLE) 7091 return(NULL); 7092 7093 ret = buf->content; 7094 buf->content = NULL; 7095 buf->size = 0; 7096 buf->use = 0; 7097 7098 return ret; 7099 } 7100 7101 7102 /** 7103 * xmlBufferCreateStatic: 7104 * @mem: the memory area 7105 * @size: the size in byte 7106 * 7107 * routine to create an XML buffer from an immutable memory area. 7108 * The area won't be modified nor copied, and is expected to be 7109 * present until the end of the buffer lifetime. 7110 * 7111 * returns the new structure. 7112 */ 7113 xmlBufferPtr 7114 xmlBufferCreateStatic(void *mem, size_t size) { 7115 xmlBufferPtr ret; 7116 7117 if ((mem == NULL) || (size == 0)) 7118 return(NULL); 7119 7120 ret = (xmlBufferPtr) xmlMalloc(sizeof(xmlBuffer)); 7121 if (ret == NULL) { 7122 xmlTreeErrMemory("creating buffer"); 7123 return(NULL); 7124 } 7125 ret->use = size; 7126 ret->size = size; 7127 ret->alloc = XML_BUFFER_ALLOC_IMMUTABLE; 7128 ret->content = (xmlChar *) mem; 7129 return(ret); 7130 } 7131 7132 /** 7133 * xmlBufferSetAllocationScheme: 7134 * @buf: the buffer to tune 7135 * @scheme: allocation scheme to use 7136 * 7137 * Sets the allocation scheme for this buffer 7138 */ 7139 void 7140 xmlBufferSetAllocationScheme(xmlBufferPtr buf, 7141 xmlBufferAllocationScheme scheme) { 7142 if (buf == NULL) { 7143 #ifdef DEBUG_BUFFER 7144 xmlGenericError(xmlGenericErrorContext, 7145 "xmlBufferSetAllocationScheme: buf == NULL\n"); 7146 #endif 7147 return; 7148 } 7149 if ((buf->alloc == XML_BUFFER_ALLOC_IMMUTABLE) || 7150 (buf->alloc == XML_BUFFER_ALLOC_IO)) return; 7151 if ((scheme == XML_BUFFER_ALLOC_DOUBLEIT) || 7152 (scheme == XML_BUFFER_ALLOC_EXACT) || 7153 (scheme == XML_BUFFER_ALLOC_HYBRID) || 7154 (scheme == XML_BUFFER_ALLOC_IMMUTABLE)) 7155 buf->alloc = scheme; 7156 } 7157 7158 /** 7159 * xmlBufferFree: 7160 * @buf: the buffer to free 7161 * 7162 * Frees an XML buffer. It frees both the content and the structure which 7163 * encapsulate it. 7164 */ 7165 void 7166 xmlBufferFree(xmlBufferPtr buf) { 7167 if (buf == NULL) { 7168 #ifdef DEBUG_BUFFER 7169 xmlGenericError(xmlGenericErrorContext, 7170 "xmlBufferFree: buf == NULL\n"); 7171 #endif 7172 return; 7173 } 7174 7175 if ((buf->alloc == XML_BUFFER_ALLOC_IO) && 7176 (buf->contentIO != NULL)) { 7177 xmlFree(buf->contentIO); 7178 } else if ((buf->content != NULL) && 7179 (buf->alloc != XML_BUFFER_ALLOC_IMMUTABLE)) { 7180 xmlFree(buf->content); 7181 } 7182 xmlFree(buf); 7183 } 7184 7185 /** 7186 * xmlBufferEmpty: 7187 * @buf: the buffer 7188 * 7189 * empty a buffer. 7190 */ 7191 void 7192 xmlBufferEmpty(xmlBufferPtr buf) { 7193 if (buf == NULL) return; 7194 if (buf->content == NULL) return; 7195 buf->use = 0; 7196 if (buf->alloc == XML_BUFFER_ALLOC_IMMUTABLE) { 7197 buf->content = BAD_CAST ""; 7198 } else if ((buf->alloc == XML_BUFFER_ALLOC_IO) && 7199 (buf->contentIO != NULL)) { 7200 size_t start_buf = buf->content - buf->contentIO; 7201 7202 buf->size += start_buf; 7203 buf->content = buf->contentIO; 7204 buf->content[0] = 0; 7205 } else { 7206 buf->content[0] = 0; 7207 } 7208 } 7209 7210 /** 7211 * xmlBufferShrink: 7212 * @buf: the buffer to dump 7213 * @len: the number of xmlChar to remove 7214 * 7215 * Remove the beginning of an XML buffer. 7216 * 7217 * Returns the number of #xmlChar removed, or -1 in case of failure. 7218 */ 7219 int 7220 xmlBufferShrink(xmlBufferPtr buf, unsigned int len) { 7221 if (buf == NULL) return(-1); 7222 if (len == 0) return(0); 7223 if (len > buf->use) return(-1); 7224 7225 buf->use -= len; 7226 if ((buf->alloc == XML_BUFFER_ALLOC_IMMUTABLE) || 7227 ((buf->alloc == XML_BUFFER_ALLOC_IO) && (buf->contentIO != NULL))) { 7228 /* 7229 * we just move the content pointer, but also make sure 7230 * the perceived buffer size has shrinked accordingly 7231 */ 7232 buf->content += len; 7233 buf->size -= len; 7234 7235 /* 7236 * sometimes though it maybe be better to really shrink 7237 * on IO buffers 7238 */ 7239 if ((buf->alloc == XML_BUFFER_ALLOC_IO) && (buf->contentIO != NULL)) { 7240 size_t start_buf = buf->content - buf->contentIO; 7241 if (start_buf >= buf->size) { 7242 memmove(buf->contentIO, &buf->content[0], buf->use); 7243 buf->content = buf->contentIO; 7244 buf->content[buf->use] = 0; 7245 buf->size += start_buf; 7246 } 7247 } 7248 } else { 7249 memmove(buf->content, &buf->content[len], buf->use); 7250 buf->content[buf->use] = 0; 7251 } 7252 return(len); 7253 } 7254 7255 /** 7256 * xmlBufferGrow: 7257 * @buf: the buffer 7258 * @len: the minimum free size to allocate 7259 * 7260 * Grow the available space of an XML buffer. 7261 * 7262 * Returns the new available space or -1 in case of error 7263 */ 7264 int 7265 xmlBufferGrow(xmlBufferPtr buf, unsigned int len) { 7266 int size; 7267 xmlChar *newbuf; 7268 7269 if (buf == NULL) return(-1); 7270 7271 if (buf->alloc == XML_BUFFER_ALLOC_IMMUTABLE) return(0); 7272 if (len + buf->use < buf->size) return(0); 7273 7274 /* 7275 * Windows has a BIG problem on realloc timing, so we try to double 7276 * the buffer size (if that's enough) (bug 146697) 7277 * Apparently BSD too, and it's probably best for linux too 7278 * On an embedded system this may be something to change 7279 */ 7280 #if 1 7281 if (buf->size > len) 7282 size = buf->size * 2; 7283 else 7284 size = buf->use + len + 100; 7285 #else 7286 size = buf->use + len + 100; 7287 #endif 7288 7289 if ((buf->alloc == XML_BUFFER_ALLOC_IO) && (buf->contentIO != NULL)) { 7290 size_t start_buf = buf->content - buf->contentIO; 7291 7292 newbuf = (xmlChar *) xmlRealloc(buf->contentIO, start_buf + size); 7293 if (newbuf == NULL) { 7294 xmlTreeErrMemory("growing buffer"); 7295 return(-1); 7296 } 7297 buf->contentIO = newbuf; 7298 buf->content = newbuf + start_buf; 7299 } else { 7300 newbuf = (xmlChar *) xmlRealloc(buf->content, size); 7301 if (newbuf == NULL) { 7302 xmlTreeErrMemory("growing buffer"); 7303 return(-1); 7304 } 7305 buf->content = newbuf; 7306 } 7307 buf->size = size; 7308 return(buf->size - buf->use); 7309 } 7310 7311 /** 7312 * xmlBufferDump: 7313 * @file: the file output 7314 * @buf: the buffer to dump 7315 * 7316 * Dumps an XML buffer to a FILE *. 7317 * Returns the number of #xmlChar written 7318 */ 7319 int 7320 xmlBufferDump(FILE *file, xmlBufferPtr buf) { 7321 int ret; 7322 7323 if (buf == NULL) { 7324 #ifdef DEBUG_BUFFER 7325 xmlGenericError(xmlGenericErrorContext, 7326 "xmlBufferDump: buf == NULL\n"); 7327 #endif 7328 return(0); 7329 } 7330 if (buf->content == NULL) { 7331 #ifdef DEBUG_BUFFER 7332 xmlGenericError(xmlGenericErrorContext, 7333 "xmlBufferDump: buf->content == NULL\n"); 7334 #endif 7335 return(0); 7336 } 7337 if (file == NULL) 7338 file = stdout; 7339 ret = fwrite(buf->content, sizeof(xmlChar), buf->use, file); 7340 return(ret); 7341 } 7342 7343 /** 7344 * xmlBufferContent: 7345 * @buf: the buffer 7346 * 7347 * Function to extract the content of a buffer 7348 * 7349 * Returns the internal content 7350 */ 7351 7352 const xmlChar * 7353 xmlBufferContent(const xmlBuffer *buf) 7354 { 7355 if(!buf) 7356 return NULL; 7357 7358 return buf->content; 7359 } 7360 7361 /** 7362 * xmlBufferLength: 7363 * @buf: the buffer 7364 * 7365 * Function to get the length of a buffer 7366 * 7367 * Returns the length of data in the internal content 7368 */ 7369 7370 int 7371 xmlBufferLength(const xmlBuffer *buf) 7372 { 7373 if(!buf) 7374 return 0; 7375 7376 return buf->use; 7377 } 7378 7379 /** 7380 * xmlBufferResize: 7381 * @buf: the buffer to resize 7382 * @size: the desired size 7383 * 7384 * Resize a buffer to accommodate minimum size of @size. 7385 * 7386 * Returns 0 in case of problems, 1 otherwise 7387 */ 7388 int 7389 xmlBufferResize(xmlBufferPtr buf, unsigned int size) 7390 { 7391 unsigned int newSize; 7392 xmlChar* rebuf = NULL; 7393 size_t start_buf; 7394 7395 if (buf == NULL) 7396 return(0); 7397 7398 if (buf->alloc == XML_BUFFER_ALLOC_IMMUTABLE) return(0); 7399 7400 /* Don't resize if we don't have to */ 7401 if (size < buf->size) 7402 return 1; 7403 7404 /* figure out new size */ 7405 switch (buf->alloc){ 7406 case XML_BUFFER_ALLOC_IO: 7407 case XML_BUFFER_ALLOC_DOUBLEIT: 7408 /*take care of empty case*/ 7409 newSize = (buf->size ? buf->size*2 : size + 10); 7410 while (size > newSize) { 7411 if (newSize > UINT_MAX / 2) { 7412 xmlTreeErrMemory("growing buffer"); 7413 return 0; 7414 } 7415 newSize *= 2; 7416 } 7417 break; 7418 case XML_BUFFER_ALLOC_EXACT: 7419 newSize = size+10; 7420 break; 7421 case XML_BUFFER_ALLOC_HYBRID: 7422 if (buf->use < BASE_BUFFER_SIZE) 7423 newSize = size; 7424 else { 7425 newSize = buf->size * 2; 7426 while (size > newSize) { 7427 if (newSize > UINT_MAX / 2) { 7428 xmlTreeErrMemory("growing buffer"); 7429 return 0; 7430 } 7431 newSize *= 2; 7432 } 7433 } 7434 break; 7435 7436 default: 7437 newSize = size+10; 7438 break; 7439 } 7440 7441 if ((buf->alloc == XML_BUFFER_ALLOC_IO) && (buf->contentIO != NULL)) { 7442 start_buf = buf->content - buf->contentIO; 7443 7444 if (start_buf > newSize) { 7445 /* move data back to start */ 7446 memmove(buf->contentIO, buf->content, buf->use); 7447 buf->content = buf->contentIO; 7448 buf->content[buf->use] = 0; 7449 buf->size += start_buf; 7450 } else { 7451 rebuf = (xmlChar *) xmlRealloc(buf->contentIO, start_buf + newSize); 7452 if (rebuf == NULL) { 7453 xmlTreeErrMemory("growing buffer"); 7454 return 0; 7455 } 7456 buf->contentIO = rebuf; 7457 buf->content = rebuf + start_buf; 7458 } 7459 } else { 7460 if (buf->content == NULL) { 7461 rebuf = (xmlChar *) xmlMallocAtomic(newSize); 7462 } else if (buf->size - buf->use < 100) { 7463 rebuf = (xmlChar *) xmlRealloc(buf->content, newSize); 7464 } else { 7465 /* 7466 * if we are reallocating a buffer far from being full, it's 7467 * better to make a new allocation and copy only the used range 7468 * and free the old one. 7469 */ 7470 rebuf = (xmlChar *) xmlMallocAtomic(newSize); 7471 if (rebuf != NULL) { 7472 memcpy(rebuf, buf->content, buf->use); 7473 xmlFree(buf->content); 7474 rebuf[buf->use] = 0; 7475 } 7476 } 7477 if (rebuf == NULL) { 7478 xmlTreeErrMemory("growing buffer"); 7479 return 0; 7480 } 7481 buf->content = rebuf; 7482 } 7483 buf->size = newSize; 7484 7485 return 1; 7486 } 7487 7488 /** 7489 * xmlBufferAdd: 7490 * @buf: the buffer to dump 7491 * @str: the #xmlChar string 7492 * @len: the number of #xmlChar to add 7493 * 7494 * Add a string range to an XML buffer. if len == -1, the length of 7495 * str is recomputed. 7496 * 7497 * Returns 0 successful, a positive error code number otherwise 7498 * and -1 in case of internal or API error. 7499 */ 7500 int 7501 xmlBufferAdd(xmlBufferPtr buf, const xmlChar *str, int len) { 7502 unsigned int needSize; 7503 7504 if ((str == NULL) || (buf == NULL)) { 7505 return -1; 7506 } 7507 if (buf->alloc == XML_BUFFER_ALLOC_IMMUTABLE) return -1; 7508 if (len < -1) { 7509 #ifdef DEBUG_BUFFER 7510 xmlGenericError(xmlGenericErrorContext, 7511 "xmlBufferAdd: len < 0\n"); 7512 #endif 7513 return -1; 7514 } 7515 if (len == 0) return 0; 7516 7517 if (len < 0) 7518 len = xmlStrlen(str); 7519 7520 if (len < 0) return -1; 7521 if (len == 0) return 0; 7522 7523 needSize = buf->use + len + 2; 7524 if (needSize > buf->size){ 7525 if (!xmlBufferResize(buf, needSize)){ 7526 xmlTreeErrMemory("growing buffer"); 7527 return XML_ERR_NO_MEMORY; 7528 } 7529 } 7530 7531 memmove(&buf->content[buf->use], str, len*sizeof(xmlChar)); 7532 buf->use += len; 7533 buf->content[buf->use] = 0; 7534 return 0; 7535 } 7536 7537 /** 7538 * xmlBufferAddHead: 7539 * @buf: the buffer 7540 * @str: the #xmlChar string 7541 * @len: the number of #xmlChar to add 7542 * 7543 * Add a string range to the beginning of an XML buffer. 7544 * if len == -1, the length of @str is recomputed. 7545 * 7546 * Returns 0 successful, a positive error code number otherwise 7547 * and -1 in case of internal or API error. 7548 */ 7549 int 7550 xmlBufferAddHead(xmlBufferPtr buf, const xmlChar *str, int len) { 7551 unsigned int needSize; 7552 7553 if (buf == NULL) 7554 return(-1); 7555 if (buf->alloc == XML_BUFFER_ALLOC_IMMUTABLE) return -1; 7556 if (str == NULL) { 7557 #ifdef DEBUG_BUFFER 7558 xmlGenericError(xmlGenericErrorContext, 7559 "xmlBufferAddHead: str == NULL\n"); 7560 #endif 7561 return -1; 7562 } 7563 if (len < -1) { 7564 #ifdef DEBUG_BUFFER 7565 xmlGenericError(xmlGenericErrorContext, 7566 "xmlBufferAddHead: len < 0\n"); 7567 #endif 7568 return -1; 7569 } 7570 if (len == 0) return 0; 7571 7572 if (len < 0) 7573 len = xmlStrlen(str); 7574 7575 if (len <= 0) return -1; 7576 7577 if ((buf->alloc == XML_BUFFER_ALLOC_IO) && (buf->contentIO != NULL)) { 7578 size_t start_buf = buf->content - buf->contentIO; 7579 7580 if (start_buf > (unsigned int) len) { 7581 /* 7582 * We can add it in the space previously shrinked 7583 */ 7584 buf->content -= len; 7585 memmove(&buf->content[0], str, len); 7586 buf->use += len; 7587 buf->size += len; 7588 return(0); 7589 } 7590 } 7591 needSize = buf->use + len + 2; 7592 if (needSize > buf->size){ 7593 if (!xmlBufferResize(buf, needSize)){ 7594 xmlTreeErrMemory("growing buffer"); 7595 return XML_ERR_NO_MEMORY; 7596 } 7597 } 7598 7599 memmove(&buf->content[len], &buf->content[0], buf->use); 7600 memmove(&buf->content[0], str, len); 7601 buf->use += len; 7602 buf->content[buf->use] = 0; 7603 return 0; 7604 } 7605 7606 /** 7607 * xmlBufferCat: 7608 * @buf: the buffer to add to 7609 * @str: the #xmlChar string 7610 * 7611 * Append a zero terminated string to an XML buffer. 7612 * 7613 * Returns 0 successful, a positive error code number otherwise 7614 * and -1 in case of internal or API error. 7615 */ 7616 int 7617 xmlBufferCat(xmlBufferPtr buf, const xmlChar *str) { 7618 if (buf == NULL) 7619 return(-1); 7620 if (buf->alloc == XML_BUFFER_ALLOC_IMMUTABLE) return -1; 7621 if (str == NULL) return -1; 7622 return xmlBufferAdd(buf, str, -1); 7623 } 7624 7625 /** 7626 * xmlBufferCCat: 7627 * @buf: the buffer to dump 7628 * @str: the C char string 7629 * 7630 * Append a zero terminated C string to an XML buffer. 7631 * 7632 * Returns 0 successful, a positive error code number otherwise 7633 * and -1 in case of internal or API error. 7634 */ 7635 int 7636 xmlBufferCCat(xmlBufferPtr buf, const char *str) { 7637 const char *cur; 7638 7639 if (buf == NULL) 7640 return(-1); 7641 if (buf->alloc == XML_BUFFER_ALLOC_IMMUTABLE) return -1; 7642 if (str == NULL) { 7643 #ifdef DEBUG_BUFFER 7644 xmlGenericError(xmlGenericErrorContext, 7645 "xmlBufferCCat: str == NULL\n"); 7646 #endif 7647 return -1; 7648 } 7649 for (cur = str;*cur != 0;cur++) { 7650 if (buf->use + 10 >= buf->size) { 7651 if (!xmlBufferResize(buf, buf->use+10)){ 7652 xmlTreeErrMemory("growing buffer"); 7653 return XML_ERR_NO_MEMORY; 7654 } 7655 } 7656 buf->content[buf->use++] = *cur; 7657 } 7658 buf->content[buf->use] = 0; 7659 return 0; 7660 } 7661 7662 /** 7663 * xmlBufferWriteCHAR: 7664 * @buf: the XML buffer 7665 * @string: the string to add 7666 * 7667 * routine which manages and grows an output buffer. This one adds 7668 * xmlChars at the end of the buffer. 7669 */ 7670 void 7671 xmlBufferWriteCHAR(xmlBufferPtr buf, const xmlChar *string) { 7672 if (buf == NULL) 7673 return; 7674 if (buf->alloc == XML_BUFFER_ALLOC_IMMUTABLE) return; 7675 xmlBufferCat(buf, string); 7676 } 7677 7678 /** 7679 * xmlBufferWriteChar: 7680 * @buf: the XML buffer output 7681 * @string: the string to add 7682 * 7683 * routine which manage and grows an output buffer. This one add 7684 * C chars at the end of the array. 7685 */ 7686 void 7687 xmlBufferWriteChar(xmlBufferPtr buf, const char *string) { 7688 if (buf == NULL) 7689 return; 7690 if (buf->alloc == XML_BUFFER_ALLOC_IMMUTABLE) return; 7691 xmlBufferCCat(buf, string); 7692 } 7693 7694 7695 /** 7696 * xmlBufferWriteQuotedString: 7697 * @buf: the XML buffer output 7698 * @string: the string to add 7699 * 7700 * routine which manage and grows an output buffer. This one writes 7701 * a quoted or double quoted #xmlChar string, checking first if it holds 7702 * quote or double-quotes internally 7703 */ 7704 void 7705 xmlBufferWriteQuotedString(xmlBufferPtr buf, const xmlChar *string) { 7706 const xmlChar *cur, *base; 7707 if (buf == NULL) 7708 return; 7709 if (buf->alloc == XML_BUFFER_ALLOC_IMMUTABLE) return; 7710 if (xmlStrchr(string, '\"')) { 7711 if (xmlStrchr(string, '\'')) { 7712 #ifdef DEBUG_BUFFER 7713 xmlGenericError(xmlGenericErrorContext, 7714 "xmlBufferWriteQuotedString: string contains quote and double-quotes !\n"); 7715 #endif 7716 xmlBufferCCat(buf, "\""); 7717 base = cur = string; 7718 while(*cur != 0){ 7719 if(*cur == '"'){ 7720 if (base != cur) 7721 xmlBufferAdd(buf, base, cur - base); 7722 xmlBufferAdd(buf, BAD_CAST """, 6); 7723 cur++; 7724 base = cur; 7725 } 7726 else { 7727 cur++; 7728 } 7729 } 7730 if (base != cur) 7731 xmlBufferAdd(buf, base, cur - base); 7732 xmlBufferCCat(buf, "\""); 7733 } 7734 else{ 7735 xmlBufferCCat(buf, "\'"); 7736 xmlBufferCat(buf, string); 7737 xmlBufferCCat(buf, "\'"); 7738 } 7739 } else { 7740 xmlBufferCCat(buf, "\""); 7741 xmlBufferCat(buf, string); 7742 xmlBufferCCat(buf, "\""); 7743 } 7744 } 7745 7746 7747 /** 7748 * xmlGetDocCompressMode: 7749 * @doc: the document 7750 * 7751 * get the compression ratio for a document, ZLIB based 7752 * Returns 0 (uncompressed) to 9 (max compression) 7753 */ 7754 int 7755 xmlGetDocCompressMode (const xmlDoc *doc) { 7756 if (doc == NULL) return(-1); 7757 return(doc->compression); 7758 } 7759 7760 /** 7761 * xmlSetDocCompressMode: 7762 * @doc: the document 7763 * @mode: the compression ratio 7764 * 7765 * set the compression ratio for a document, ZLIB based 7766 * Correct values: 0 (uncompressed) to 9 (max compression) 7767 */ 7768 void 7769 xmlSetDocCompressMode (xmlDocPtr doc, int mode) { 7770 if (doc == NULL) return; 7771 if (mode < 0) doc->compression = 0; 7772 else if (mode > 9) doc->compression = 9; 7773 else doc->compression = mode; 7774 } 7775 7776 /** 7777 * xmlGetCompressMode: 7778 * 7779 * get the default compression mode used, ZLIB based. 7780 * Returns 0 (uncompressed) to 9 (max compression) 7781 */ 7782 int 7783 xmlGetCompressMode(void) 7784 { 7785 return (xmlCompressMode); 7786 } 7787 7788 /** 7789 * xmlSetCompressMode: 7790 * @mode: the compression ratio 7791 * 7792 * set the default compression mode used, ZLIB based 7793 * Correct values: 0 (uncompressed) to 9 (max compression) 7794 */ 7795 void 7796 xmlSetCompressMode(int mode) { 7797 if (mode < 0) xmlCompressMode = 0; 7798 else if (mode > 9) xmlCompressMode = 9; 7799 else xmlCompressMode = mode; 7800 } 7801 7802 #define XML_TREE_NSMAP_PARENT -1 7803 #define XML_TREE_NSMAP_XML -2 7804 #define XML_TREE_NSMAP_DOC -3 7805 #define XML_TREE_NSMAP_CUSTOM -4 7806 7807 typedef struct xmlNsMapItem *xmlNsMapItemPtr; 7808 struct xmlNsMapItem { 7809 xmlNsMapItemPtr next; 7810 xmlNsMapItemPtr prev; 7811 xmlNsPtr oldNs; /* old ns decl reference */ 7812 xmlNsPtr newNs; /* new ns decl reference */ 7813 int shadowDepth; /* Shadowed at this depth */ 7814 /* 7815 * depth: 7816 * >= 0 == @node's ns-decls 7817 * -1 == @parent's ns-decls 7818 * -2 == the doc->oldNs XML ns-decl 7819 * -3 == the doc->oldNs storage ns-decls 7820 * -4 == ns-decls provided via custom ns-handling 7821 */ 7822 int depth; 7823 }; 7824 7825 typedef struct xmlNsMap *xmlNsMapPtr; 7826 struct xmlNsMap { 7827 xmlNsMapItemPtr first; 7828 xmlNsMapItemPtr last; 7829 xmlNsMapItemPtr pool; 7830 }; 7831 7832 #define XML_NSMAP_NOTEMPTY(m) (((m) != NULL) && ((m)->first != NULL)) 7833 #define XML_NSMAP_FOREACH(m, i) for (i = (m)->first; i != NULL; i = (i)->next) 7834 #define XML_NSMAP_POP(m, i) \ 7835 i = (m)->last; \ 7836 (m)->last = (i)->prev; \ 7837 if ((m)->last == NULL) \ 7838 (m)->first = NULL; \ 7839 else \ 7840 (m)->last->next = NULL; \ 7841 (i)->next = (m)->pool; \ 7842 (m)->pool = i; 7843 7844 /* 7845 * xmlDOMWrapNsMapFree: 7846 * @map: the ns-map 7847 * 7848 * Frees the ns-map 7849 */ 7850 static void 7851 xmlDOMWrapNsMapFree(xmlNsMapPtr nsmap) 7852 { 7853 xmlNsMapItemPtr cur, tmp; 7854 7855 if (nsmap == NULL) 7856 return; 7857 cur = nsmap->pool; 7858 while (cur != NULL) { 7859 tmp = cur; 7860 cur = cur->next; 7861 xmlFree(tmp); 7862 } 7863 cur = nsmap->first; 7864 while (cur != NULL) { 7865 tmp = cur; 7866 cur = cur->next; 7867 xmlFree(tmp); 7868 } 7869 xmlFree(nsmap); 7870 } 7871 7872 /* 7873 * xmlDOMWrapNsMapAddItem: 7874 * @map: the ns-map 7875 * @oldNs: the old ns-struct 7876 * @newNs: the new ns-struct 7877 * @depth: depth and ns-kind information 7878 * 7879 * Adds an ns-mapping item. 7880 */ 7881 static xmlNsMapItemPtr 7882 xmlDOMWrapNsMapAddItem(xmlNsMapPtr *nsmap, int position, 7883 xmlNsPtr oldNs, xmlNsPtr newNs, int depth) 7884 { 7885 xmlNsMapItemPtr ret; 7886 xmlNsMapPtr map; 7887 7888 if (nsmap == NULL) 7889 return(NULL); 7890 if ((position != -1) && (position != 0)) 7891 return(NULL); 7892 map = *nsmap; 7893 7894 if (map == NULL) { 7895 /* 7896 * Create the ns-map. 7897 */ 7898 map = (xmlNsMapPtr) xmlMalloc(sizeof(struct xmlNsMap)); 7899 if (map == NULL) { 7900 xmlTreeErrMemory("allocating namespace map"); 7901 return (NULL); 7902 } 7903 memset(map, 0, sizeof(struct xmlNsMap)); 7904 *nsmap = map; 7905 } 7906 7907 if (map->pool != NULL) { 7908 /* 7909 * Reuse an item from the pool. 7910 */ 7911 ret = map->pool; 7912 map->pool = ret->next; 7913 memset(ret, 0, sizeof(struct xmlNsMapItem)); 7914 } else { 7915 /* 7916 * Create a new item. 7917 */ 7918 ret = (xmlNsMapItemPtr) xmlMalloc(sizeof(struct xmlNsMapItem)); 7919 if (ret == NULL) { 7920 xmlTreeErrMemory("allocating namespace map item"); 7921 return (NULL); 7922 } 7923 memset(ret, 0, sizeof(struct xmlNsMapItem)); 7924 } 7925 7926 if (map->first == NULL) { 7927 /* 7928 * First ever. 7929 */ 7930 map->first = ret; 7931 map->last = ret; 7932 } else if (position == -1) { 7933 /* 7934 * Append. 7935 */ 7936 ret->prev = map->last; 7937 map->last->next = ret; 7938 map->last = ret; 7939 } else if (position == 0) { 7940 /* 7941 * Set on first position. 7942 */ 7943 map->first->prev = ret; 7944 ret->next = map->first; 7945 map->first = ret; 7946 } 7947 7948 ret->oldNs = oldNs; 7949 ret->newNs = newNs; 7950 ret->shadowDepth = -1; 7951 ret->depth = depth; 7952 return (ret); 7953 } 7954 7955 /* 7956 * xmlDOMWrapStoreNs: 7957 * @doc: the doc 7958 * @nsName: the namespace name 7959 * @prefix: the prefix 7960 * 7961 * Creates or reuses an xmlNs struct on doc->oldNs with 7962 * the given prefix and namespace name. 7963 * 7964 * Returns the aquired ns struct or NULL in case of an API 7965 * or internal error. 7966 */ 7967 static xmlNsPtr 7968 xmlDOMWrapStoreNs(xmlDocPtr doc, 7969 const xmlChar *nsName, 7970 const xmlChar *prefix) 7971 { 7972 xmlNsPtr ns; 7973 7974 if (doc == NULL) 7975 return (NULL); 7976 ns = xmlTreeEnsureXMLDecl(doc); 7977 if (ns == NULL) 7978 return (NULL); 7979 if (ns->next != NULL) { 7980 /* Reuse. */ 7981 ns = ns->next; 7982 while (ns != NULL) { 7983 if (((ns->prefix == prefix) || 7984 xmlStrEqual(ns->prefix, prefix)) && 7985 xmlStrEqual(ns->href, nsName)) { 7986 return (ns); 7987 } 7988 if (ns->next == NULL) 7989 break; 7990 ns = ns->next; 7991 } 7992 } 7993 /* Create. */ 7994 if (ns != NULL) { 7995 ns->next = xmlNewNs(NULL, nsName, prefix); 7996 return (ns->next); 7997 } 7998 return(NULL); 7999 } 8000 8001 /* 8002 * xmlDOMWrapNewCtxt: 8003 * 8004 * Allocates and initializes a new DOM-wrapper context. 8005 * 8006 * Returns the xmlDOMWrapCtxtPtr or NULL in case of an internal error. 8007 */ 8008 xmlDOMWrapCtxtPtr 8009 xmlDOMWrapNewCtxt(void) 8010 { 8011 xmlDOMWrapCtxtPtr ret; 8012 8013 ret = xmlMalloc(sizeof(xmlDOMWrapCtxt)); 8014 if (ret == NULL) { 8015 xmlTreeErrMemory("allocating DOM-wrapper context"); 8016 return (NULL); 8017 } 8018 memset(ret, 0, sizeof(xmlDOMWrapCtxt)); 8019 return (ret); 8020 } 8021 8022 /* 8023 * xmlDOMWrapFreeCtxt: 8024 * @ctxt: the DOM-wrapper context 8025 * 8026 * Frees the DOM-wrapper context. 8027 */ 8028 void 8029 xmlDOMWrapFreeCtxt(xmlDOMWrapCtxtPtr ctxt) 8030 { 8031 if (ctxt == NULL) 8032 return; 8033 if (ctxt->namespaceMap != NULL) 8034 xmlDOMWrapNsMapFree((xmlNsMapPtr) ctxt->namespaceMap); 8035 /* 8036 * TODO: Store the namespace map in the context. 8037 */ 8038 xmlFree(ctxt); 8039 } 8040 8041 /* 8042 * xmlTreeLookupNsListByPrefix: 8043 * @nsList: a list of ns-structs 8044 * @prefix: the searched prefix 8045 * 8046 * Searches for a ns-decl with the given prefix in @nsList. 8047 * 8048 * Returns the ns-decl if found, NULL if not found and on 8049 * API errors. 8050 */ 8051 static xmlNsPtr 8052 xmlTreeNSListLookupByPrefix(xmlNsPtr nsList, const xmlChar *prefix) 8053 { 8054 if (nsList == NULL) 8055 return (NULL); 8056 { 8057 xmlNsPtr ns; 8058 ns = nsList; 8059 do { 8060 if ((prefix == ns->prefix) || 8061 xmlStrEqual(prefix, ns->prefix)) { 8062 return (ns); 8063 } 8064 ns = ns->next; 8065 } while (ns != NULL); 8066 } 8067 return (NULL); 8068 } 8069 8070 /* 8071 * 8072 * xmlDOMWrapNSNormGatherInScopeNs: 8073 * @map: the namespace map 8074 * @node: the node to start with 8075 * 8076 * Puts in-scope namespaces into the ns-map. 8077 * 8078 * Returns 0 on success, -1 on API or internal errors. 8079 */ 8080 static int 8081 xmlDOMWrapNSNormGatherInScopeNs(xmlNsMapPtr *map, 8082 xmlNodePtr node) 8083 { 8084 xmlNodePtr cur; 8085 xmlNsPtr ns; 8086 xmlNsMapItemPtr mi; 8087 int shadowed; 8088 8089 if ((map == NULL) || (*map != NULL)) 8090 return (-1); 8091 if ((node == NULL) || (node->type == XML_NAMESPACE_DECL)) 8092 return (-1); 8093 /* 8094 * Get in-scope ns-decls of @parent. 8095 */ 8096 cur = node; 8097 while ((cur != NULL) && (cur != (xmlNodePtr) cur->doc)) { 8098 if (cur->type == XML_ELEMENT_NODE) { 8099 if (cur->nsDef != NULL) { 8100 ns = cur->nsDef; 8101 do { 8102 shadowed = 0; 8103 if (XML_NSMAP_NOTEMPTY(*map)) { 8104 /* 8105 * Skip shadowed prefixes. 8106 */ 8107 XML_NSMAP_FOREACH(*map, mi) { 8108 if ((ns->prefix == mi->newNs->prefix) || 8109 xmlStrEqual(ns->prefix, mi->newNs->prefix)) { 8110 shadowed = 1; 8111 break; 8112 } 8113 } 8114 } 8115 /* 8116 * Insert mapping. 8117 */ 8118 mi = xmlDOMWrapNsMapAddItem(map, 0, NULL, 8119 ns, XML_TREE_NSMAP_PARENT); 8120 if (mi == NULL) 8121 return (-1); 8122 if (shadowed) 8123 mi->shadowDepth = 0; 8124 ns = ns->next; 8125 } while (ns != NULL); 8126 } 8127 } 8128 cur = cur->parent; 8129 } 8130 return (0); 8131 } 8132 8133 /* 8134 * XML_TREE_ADOPT_STR: If we have a dest-dict, put @str in the dict; 8135 * otherwise copy it, when it was in the source-dict. 8136 */ 8137 #define XML_TREE_ADOPT_STR(str) \ 8138 if (adoptStr && (str != NULL)) { \ 8139 if (destDoc->dict) { \ 8140 const xmlChar *old = str; \ 8141 str = xmlDictLookup(destDoc->dict, str, -1); \ 8142 if ((sourceDoc == NULL) || (sourceDoc->dict == NULL) || \ 8143 (!xmlDictOwns(sourceDoc->dict, old))) \ 8144 xmlFree((char *)old); \ 8145 } else if ((sourceDoc) && (sourceDoc->dict) && \ 8146 xmlDictOwns(sourceDoc->dict, str)) { \ 8147 str = BAD_CAST xmlStrdup(str); \ 8148 } \ 8149 } 8150 8151 /* 8152 * XML_TREE_ADOPT_STR_2: If @str was in the source-dict, then 8153 * put it in dest-dict or copy it. 8154 */ 8155 #define XML_TREE_ADOPT_STR_2(str) \ 8156 if (adoptStr && (str != NULL) && (sourceDoc != NULL) && \ 8157 (sourceDoc->dict != NULL) && \ 8158 xmlDictOwns(sourceDoc->dict, cur->content)) { \ 8159 if (destDoc->dict) \ 8160 cur->content = (xmlChar *) \ 8161 xmlDictLookup(destDoc->dict, cur->content, -1); \ 8162 else \ 8163 cur->content = xmlStrdup(BAD_CAST cur->content); \ 8164 } 8165 8166 /* 8167 * xmlDOMWrapNSNormAddNsMapItem2: 8168 * 8169 * For internal use. Adds a ns-decl mapping. 8170 * 8171 * Returns 0 on success, -1 on internal errors. 8172 */ 8173 static int 8174 xmlDOMWrapNSNormAddNsMapItem2(xmlNsPtr **list, int *size, int *number, 8175 xmlNsPtr oldNs, xmlNsPtr newNs) 8176 { 8177 if (*list == NULL) { 8178 *list = (xmlNsPtr *) xmlMalloc(6 * sizeof(xmlNsPtr)); 8179 if (*list == NULL) { 8180 xmlTreeErrMemory("alloc ns map item"); 8181 return(-1); 8182 } 8183 *size = 3; 8184 *number = 0; 8185 } else if ((*number) >= (*size)) { 8186 *size *= 2; 8187 *list = (xmlNsPtr *) xmlRealloc(*list, 8188 (*size) * 2 * sizeof(xmlNsPtr)); 8189 if (*list == NULL) { 8190 xmlTreeErrMemory("realloc ns map item"); 8191 return(-1); 8192 } 8193 } 8194 (*list)[2 * (*number)] = oldNs; 8195 (*list)[2 * (*number) +1] = newNs; 8196 (*number)++; 8197 return (0); 8198 } 8199 8200 /* 8201 * xmlDOMWrapRemoveNode: 8202 * @ctxt: a DOM wrapper context 8203 * @doc: the doc 8204 * @node: the node to be removed. 8205 * @options: set of options, unused at the moment 8206 * 8207 * Unlinks the given node from its owner. 8208 * This will substitute ns-references to node->nsDef for 8209 * ns-references to doc->oldNs, thus ensuring the removed 8210 * branch to be autark wrt ns-references. 8211 * 8212 * NOTE: This function was not intensively tested. 8213 * 8214 * Returns 0 on success, 1 if the node is not supported, 8215 * -1 on API and internal errors. 8216 */ 8217 int 8218 xmlDOMWrapRemoveNode(xmlDOMWrapCtxtPtr ctxt, xmlDocPtr doc, 8219 xmlNodePtr node, int options ATTRIBUTE_UNUSED) 8220 { 8221 xmlNsPtr *list = NULL; 8222 int sizeList, nbList, i, j; 8223 xmlNsPtr ns; 8224 8225 if ((node == NULL) || (doc == NULL) || (node->doc != doc)) 8226 return (-1); 8227 8228 /* TODO: 0 or -1 ? */ 8229 if (node->parent == NULL) 8230 return (0); 8231 8232 switch (node->type) { 8233 case XML_TEXT_NODE: 8234 case XML_CDATA_SECTION_NODE: 8235 case XML_ENTITY_REF_NODE: 8236 case XML_PI_NODE: 8237 case XML_COMMENT_NODE: 8238 xmlUnlinkNode(node); 8239 return (0); 8240 case XML_ELEMENT_NODE: 8241 case XML_ATTRIBUTE_NODE: 8242 break; 8243 default: 8244 return (1); 8245 } 8246 xmlUnlinkNode(node); 8247 /* 8248 * Save out-of-scope ns-references in doc->oldNs. 8249 */ 8250 do { 8251 switch (node->type) { 8252 case XML_ELEMENT_NODE: 8253 if ((ctxt == NULL) && (node->nsDef != NULL)) { 8254 ns = node->nsDef; 8255 do { 8256 if (xmlDOMWrapNSNormAddNsMapItem2(&list, &sizeList, 8257 &nbList, ns, ns) == -1) 8258 goto internal_error; 8259 ns = ns->next; 8260 } while (ns != NULL); 8261 } 8262 /* Falls through. */ 8263 case XML_ATTRIBUTE_NODE: 8264 if (node->ns != NULL) { 8265 /* 8266 * Find a mapping. 8267 */ 8268 if (list != NULL) { 8269 for (i = 0, j = 0; i < nbList; i++, j += 2) { 8270 if (node->ns == list[j]) { 8271 node->ns = list[++j]; 8272 goto next_node; 8273 } 8274 } 8275 } 8276 ns = NULL; 8277 if (ctxt != NULL) { 8278 /* 8279 * User defined. 8280 */ 8281 } else { 8282 /* 8283 * Add to doc's oldNs. 8284 */ 8285 ns = xmlDOMWrapStoreNs(doc, node->ns->href, 8286 node->ns->prefix); 8287 if (ns == NULL) 8288 goto internal_error; 8289 } 8290 if (ns != NULL) { 8291 /* 8292 * Add mapping. 8293 */ 8294 if (xmlDOMWrapNSNormAddNsMapItem2(&list, &sizeList, 8295 &nbList, node->ns, ns) == -1) 8296 goto internal_error; 8297 } 8298 node->ns = ns; 8299 } 8300 if ((node->type == XML_ELEMENT_NODE) && 8301 (node->properties != NULL)) { 8302 node = (xmlNodePtr) node->properties; 8303 continue; 8304 } 8305 break; 8306 default: 8307 goto next_sibling; 8308 } 8309 next_node: 8310 if ((node->type == XML_ELEMENT_NODE) && 8311 (node->children != NULL)) { 8312 node = node->children; 8313 continue; 8314 } 8315 next_sibling: 8316 if (node == NULL) 8317 break; 8318 if (node->next != NULL) 8319 node = node->next; 8320 else { 8321 node = node->parent; 8322 goto next_sibling; 8323 } 8324 } while (node != NULL); 8325 8326 if (list != NULL) 8327 xmlFree(list); 8328 return (0); 8329 8330 internal_error: 8331 if (list != NULL) 8332 xmlFree(list); 8333 return (-1); 8334 } 8335 8336 /* 8337 * xmlSearchNsByNamespaceStrict: 8338 * @doc: the document 8339 * @node: the start node 8340 * @nsName: the searched namespace name 8341 * @retNs: the resulting ns-decl 8342 * @prefixed: if the found ns-decl must have a prefix (for attributes) 8343 * 8344 * Dynamically searches for a ns-declaration which matches 8345 * the given @nsName in the ancestor-or-self axis of @node. 8346 * 8347 * Returns 1 if a ns-decl was found, 0 if not and -1 on API 8348 * and internal errors. 8349 */ 8350 static int 8351 xmlSearchNsByNamespaceStrict(xmlDocPtr doc, xmlNodePtr node, 8352 const xmlChar* nsName, 8353 xmlNsPtr *retNs, int prefixed) 8354 { 8355 xmlNodePtr cur, prev = NULL, out = NULL; 8356 xmlNsPtr ns, prevns; 8357 8358 if ((doc == NULL) || (nsName == NULL) || (retNs == NULL)) 8359 return (-1); 8360 if ((node == NULL) || (node->type == XML_NAMESPACE_DECL)) 8361 return(-1); 8362 8363 *retNs = NULL; 8364 if (xmlStrEqual(nsName, XML_XML_NAMESPACE)) { 8365 *retNs = xmlTreeEnsureXMLDecl(doc); 8366 if (*retNs == NULL) 8367 return (-1); 8368 return (1); 8369 } 8370 cur = node; 8371 do { 8372 if (cur->type == XML_ELEMENT_NODE) { 8373 if (cur->nsDef != NULL) { 8374 for (ns = cur->nsDef; ns != NULL; ns = ns->next) { 8375 if (prefixed && (ns->prefix == NULL)) 8376 continue; 8377 if (prev != NULL) { 8378 /* 8379 * Check the last level of ns-decls for a 8380 * shadowing prefix. 8381 */ 8382 prevns = prev->nsDef; 8383 do { 8384 if ((prevns->prefix == ns->prefix) || 8385 ((prevns->prefix != NULL) && 8386 (ns->prefix != NULL) && 8387 xmlStrEqual(prevns->prefix, ns->prefix))) { 8388 /* 8389 * Shadowed. 8390 */ 8391 break; 8392 } 8393 prevns = prevns->next; 8394 } while (prevns != NULL); 8395 if (prevns != NULL) 8396 continue; 8397 } 8398 /* 8399 * Ns-name comparison. 8400 */ 8401 if ((nsName == ns->href) || 8402 xmlStrEqual(nsName, ns->href)) { 8403 /* 8404 * At this point the prefix can only be shadowed, 8405 * if we are the the (at least) 3rd level of 8406 * ns-decls. 8407 */ 8408 if (out) { 8409 int ret; 8410 8411 ret = xmlNsInScope(doc, node, prev, ns->prefix); 8412 if (ret < 0) 8413 return (-1); 8414 /* 8415 * TODO: Should we try to find a matching ns-name 8416 * only once? This here keeps on searching. 8417 * I think we should try further since, there might 8418 * be an other matching ns-decl with an unshadowed 8419 * prefix. 8420 */ 8421 if (! ret) 8422 continue; 8423 } 8424 *retNs = ns; 8425 return (1); 8426 } 8427 } 8428 out = prev; 8429 prev = cur; 8430 } 8431 } else if ((cur->type == XML_ENTITY_NODE) || 8432 (cur->type == XML_ENTITY_DECL)) 8433 return (0); 8434 cur = cur->parent; 8435 } while ((cur != NULL) && (cur->doc != (xmlDocPtr) cur)); 8436 return (0); 8437 } 8438 8439 /* 8440 * xmlSearchNsByPrefixStrict: 8441 * @doc: the document 8442 * @node: the start node 8443 * @prefix: the searched namespace prefix 8444 * @retNs: the resulting ns-decl 8445 * 8446 * Dynamically searches for a ns-declaration which matches 8447 * the given @nsName in the ancestor-or-self axis of @node. 8448 * 8449 * Returns 1 if a ns-decl was found, 0 if not and -1 on API 8450 * and internal errors. 8451 */ 8452 static int 8453 xmlSearchNsByPrefixStrict(xmlDocPtr doc, xmlNodePtr node, 8454 const xmlChar* prefix, 8455 xmlNsPtr *retNs) 8456 { 8457 xmlNodePtr cur; 8458 xmlNsPtr ns; 8459 8460 if ((doc == NULL) || (node == NULL) || (node->type == XML_NAMESPACE_DECL)) 8461 return(-1); 8462 8463 if (retNs) 8464 *retNs = NULL; 8465 if (IS_STR_XML(prefix)) { 8466 if (retNs) { 8467 *retNs = xmlTreeEnsureXMLDecl(doc); 8468 if (*retNs == NULL) 8469 return (-1); 8470 } 8471 return (1); 8472 } 8473 cur = node; 8474 do { 8475 if (cur->type == XML_ELEMENT_NODE) { 8476 if (cur->nsDef != NULL) { 8477 ns = cur->nsDef; 8478 do { 8479 if ((prefix == ns->prefix) || 8480 xmlStrEqual(prefix, ns->prefix)) 8481 { 8482 /* 8483 * Disabled namespaces, e.g. xmlns:abc="". 8484 */ 8485 if (ns->href == NULL) 8486 return(0); 8487 if (retNs) 8488 *retNs = ns; 8489 return (1); 8490 } 8491 ns = ns->next; 8492 } while (ns != NULL); 8493 } 8494 } else if ((cur->type == XML_ENTITY_NODE) || 8495 (cur->type == XML_ENTITY_DECL)) 8496 return (0); 8497 cur = cur->parent; 8498 } while ((cur != NULL) && (cur->doc != (xmlDocPtr) cur)); 8499 return (0); 8500 } 8501 8502 /* 8503 * xmlDOMWrapNSNormDeclareNsForced: 8504 * @doc: the doc 8505 * @elem: the element-node to declare on 8506 * @nsName: the namespace-name of the ns-decl 8507 * @prefix: the preferred prefix of the ns-decl 8508 * @checkShadow: ensure that the new ns-decl doesn't shadow ancestor ns-decls 8509 * 8510 * Declares a new namespace on @elem. It tries to use the 8511 * given @prefix; if a ns-decl with the given prefix is already existent 8512 * on @elem, it will generate an other prefix. 8513 * 8514 * Returns 1 if a ns-decl was found, 0 if not and -1 on API 8515 * and internal errors. 8516 */ 8517 static xmlNsPtr 8518 xmlDOMWrapNSNormDeclareNsForced(xmlDocPtr doc, 8519 xmlNodePtr elem, 8520 const xmlChar *nsName, 8521 const xmlChar *prefix, 8522 int checkShadow) 8523 { 8524 8525 xmlNsPtr ret; 8526 char buf[50]; 8527 const xmlChar *pref; 8528 int counter = 0; 8529 8530 if ((doc == NULL) || (elem == NULL) || (elem->type != XML_ELEMENT_NODE)) 8531 return(NULL); 8532 /* 8533 * Create a ns-decl on @anchor. 8534 */ 8535 pref = prefix; 8536 while (1) { 8537 /* 8538 * Lookup whether the prefix is unused in elem's ns-decls. 8539 */ 8540 if ((elem->nsDef != NULL) && 8541 (xmlTreeNSListLookupByPrefix(elem->nsDef, pref) != NULL)) 8542 goto ns_next_prefix; 8543 if (checkShadow && elem->parent && 8544 ((xmlNodePtr) elem->parent->doc != elem->parent)) { 8545 /* 8546 * Does it shadow ancestor ns-decls? 8547 */ 8548 if (xmlSearchNsByPrefixStrict(doc, elem->parent, pref, NULL) == 1) 8549 goto ns_next_prefix; 8550 } 8551 ret = xmlNewNs(NULL, nsName, pref); 8552 if (ret == NULL) 8553 return (NULL); 8554 if (elem->nsDef == NULL) 8555 elem->nsDef = ret; 8556 else { 8557 xmlNsPtr ns2 = elem->nsDef; 8558 while (ns2->next != NULL) 8559 ns2 = ns2->next; 8560 ns2->next = ret; 8561 } 8562 return (ret); 8563 ns_next_prefix: 8564 counter++; 8565 if (counter > 1000) 8566 return (NULL); 8567 if (prefix == NULL) { 8568 snprintf((char *) buf, sizeof(buf), 8569 "ns_%d", counter); 8570 } else 8571 snprintf((char *) buf, sizeof(buf), 8572 "%.30s_%d", (char *)prefix, counter); 8573 pref = BAD_CAST buf; 8574 } 8575 } 8576 8577 /* 8578 * xmlDOMWrapNSNormAquireNormalizedNs: 8579 * @doc: the doc 8580 * @elem: the element-node to declare namespaces on 8581 * @ns: the ns-struct to use for the search 8582 * @retNs: the found/created ns-struct 8583 * @nsMap: the ns-map 8584 * @depth: the current tree depth 8585 * @ancestorsOnly: search in ancestor ns-decls only 8586 * @prefixed: if the searched ns-decl must have a prefix (for attributes) 8587 * 8588 * Searches for a matching ns-name in the ns-decls of @nsMap, if not 8589 * found it will either declare it on @elem, or store it in doc->oldNs. 8590 * If a new ns-decl needs to be declared on @elem, it tries to use the 8591 * @ns->prefix for it, if this prefix is already in use on @elem, it will 8592 * change the prefix or the new ns-decl. 8593 * 8594 * Returns 0 if succeeded, -1 otherwise and on API/internal errors. 8595 */ 8596 static int 8597 xmlDOMWrapNSNormAquireNormalizedNs(xmlDocPtr doc, 8598 xmlNodePtr elem, 8599 xmlNsPtr ns, 8600 xmlNsPtr *retNs, 8601 xmlNsMapPtr *nsMap, 8602 8603 int depth, 8604 int ancestorsOnly, 8605 int prefixed) 8606 { 8607 xmlNsMapItemPtr mi; 8608 8609 if ((doc == NULL) || (ns == NULL) || (retNs == NULL) || 8610 (nsMap == NULL)) 8611 return (-1); 8612 8613 *retNs = NULL; 8614 /* 8615 * Handle XML namespace. 8616 */ 8617 if (IS_STR_XML(ns->prefix)) { 8618 /* 8619 * Insert XML namespace mapping. 8620 */ 8621 *retNs = xmlTreeEnsureXMLDecl(doc); 8622 if (*retNs == NULL) 8623 return (-1); 8624 return (0); 8625 } 8626 /* 8627 * If the search should be done in ancestors only and no 8628 * @elem (the first ancestor) was specified, then skip the search. 8629 */ 8630 if ((XML_NSMAP_NOTEMPTY(*nsMap)) && 8631 (! (ancestorsOnly && (elem == NULL)))) 8632 { 8633 /* 8634 * Try to find an equal ns-name in in-scope ns-decls. 8635 */ 8636 XML_NSMAP_FOREACH(*nsMap, mi) { 8637 if ((mi->depth >= XML_TREE_NSMAP_PARENT) && 8638 /* 8639 * ancestorsOnly: This should be turned on to gain speed, 8640 * if one knows that the branch itself was already 8641 * ns-wellformed and no stale references existed. 8642 * I.e. it searches in the ancestor axis only. 8643 */ 8644 ((! ancestorsOnly) || (mi->depth == XML_TREE_NSMAP_PARENT)) && 8645 /* Skip shadowed prefixes. */ 8646 (mi->shadowDepth == -1) && 8647 /* Skip xmlns="" or xmlns:foo="". */ 8648 ((mi->newNs->href != NULL) && 8649 (mi->newNs->href[0] != 0)) && 8650 /* Ensure a prefix if wanted. */ 8651 ((! prefixed) || (mi->newNs->prefix != NULL)) && 8652 /* Equal ns name */ 8653 ((mi->newNs->href == ns->href) || 8654 xmlStrEqual(mi->newNs->href, ns->href))) { 8655 /* Set the mapping. */ 8656 mi->oldNs = ns; 8657 *retNs = mi->newNs; 8658 return (0); 8659 } 8660 } 8661 } 8662 /* 8663 * No luck, the namespace is out of scope or shadowed. 8664 */ 8665 if (elem == NULL) { 8666 xmlNsPtr tmpns; 8667 8668 /* 8669 * Store ns-decls in "oldNs" of the document-node. 8670 */ 8671 tmpns = xmlDOMWrapStoreNs(doc, ns->href, ns->prefix); 8672 if (tmpns == NULL) 8673 return (-1); 8674 /* 8675 * Insert mapping. 8676 */ 8677 if (xmlDOMWrapNsMapAddItem(nsMap, -1, ns, 8678 tmpns, XML_TREE_NSMAP_DOC) == NULL) { 8679 xmlFreeNs(tmpns); 8680 return (-1); 8681 } 8682 *retNs = tmpns; 8683 } else { 8684 xmlNsPtr tmpns; 8685 8686 tmpns = xmlDOMWrapNSNormDeclareNsForced(doc, elem, ns->href, 8687 ns->prefix, 0); 8688 if (tmpns == NULL) 8689 return (-1); 8690 8691 if (*nsMap != NULL) { 8692 /* 8693 * Does it shadow ancestor ns-decls? 8694 */ 8695 XML_NSMAP_FOREACH(*nsMap, mi) { 8696 if ((mi->depth < depth) && 8697 (mi->shadowDepth == -1) && 8698 ((ns->prefix == mi->newNs->prefix) || 8699 xmlStrEqual(ns->prefix, mi->newNs->prefix))) { 8700 /* 8701 * Shadows. 8702 */ 8703 mi->shadowDepth = depth; 8704 break; 8705 } 8706 } 8707 } 8708 if (xmlDOMWrapNsMapAddItem(nsMap, -1, ns, tmpns, depth) == NULL) { 8709 xmlFreeNs(tmpns); 8710 return (-1); 8711 } 8712 *retNs = tmpns; 8713 } 8714 return (0); 8715 } 8716 8717 typedef enum { 8718 XML_DOM_RECONNS_REMOVEREDUND = 1<<0 8719 } xmlDOMReconcileNSOptions; 8720 8721 /* 8722 * xmlDOMWrapReconcileNamespaces: 8723 * @ctxt: DOM wrapper context, unused at the moment 8724 * @elem: the element-node 8725 * @options: option flags 8726 * 8727 * Ensures that ns-references point to ns-decls hold on element-nodes. 8728 * Ensures that the tree is namespace wellformed by creating additional 8729 * ns-decls where needed. Note that, since prefixes of already existent 8730 * ns-decls can be shadowed by this process, it could break QNames in 8731 * attribute values or element content. 8732 * 8733 * NOTE: This function was not intensively tested. 8734 * 8735 * Returns 0 if succeeded, -1 otherwise and on API/internal errors. 8736 */ 8737 8738 int 8739 xmlDOMWrapReconcileNamespaces(xmlDOMWrapCtxtPtr ctxt ATTRIBUTE_UNUSED, 8740 xmlNodePtr elem, 8741 int options) 8742 { 8743 int depth = -1, adoptns = 0, parnsdone = 0; 8744 xmlNsPtr ns, prevns; 8745 xmlDocPtr doc; 8746 xmlNodePtr cur, curElem = NULL; 8747 xmlNsMapPtr nsMap = NULL; 8748 xmlNsMapItemPtr /* topmi = NULL, */ mi; 8749 /* @ancestorsOnly should be set by an option flag. */ 8750 int ancestorsOnly = 0; 8751 int optRemoveRedundantNS = 8752 ((xmlDOMReconcileNSOptions) options & XML_DOM_RECONNS_REMOVEREDUND) ? 1 : 0; 8753 xmlNsPtr *listRedund = NULL; 8754 int sizeRedund = 0, nbRedund = 0, ret, i, j; 8755 8756 if ((elem == NULL) || (elem->doc == NULL) || 8757 (elem->type != XML_ELEMENT_NODE)) 8758 return (-1); 8759 8760 doc = elem->doc; 8761 cur = elem; 8762 do { 8763 switch (cur->type) { 8764 case XML_ELEMENT_NODE: 8765 adoptns = 1; 8766 curElem = cur; 8767 depth++; 8768 /* 8769 * Namespace declarations. 8770 */ 8771 if (cur->nsDef != NULL) { 8772 prevns = NULL; 8773 ns = cur->nsDef; 8774 while (ns != NULL) { 8775 if (! parnsdone) { 8776 if ((elem->parent) && 8777 ((xmlNodePtr) elem->parent->doc != elem->parent)) { 8778 /* 8779 * Gather ancestor in-scope ns-decls. 8780 */ 8781 if (xmlDOMWrapNSNormGatherInScopeNs(&nsMap, 8782 elem->parent) == -1) 8783 goto internal_error; 8784 } 8785 parnsdone = 1; 8786 } 8787 8788 /* 8789 * Lookup the ns ancestor-axis for equal ns-decls in scope. 8790 */ 8791 if (optRemoveRedundantNS && XML_NSMAP_NOTEMPTY(nsMap)) { 8792 XML_NSMAP_FOREACH(nsMap, mi) { 8793 if ((mi->depth >= XML_TREE_NSMAP_PARENT) && 8794 (mi->shadowDepth == -1) && 8795 ((ns->prefix == mi->newNs->prefix) || 8796 xmlStrEqual(ns->prefix, mi->newNs->prefix)) && 8797 ((ns->href == mi->newNs->href) || 8798 xmlStrEqual(ns->href, mi->newNs->href))) 8799 { 8800 /* 8801 * A redundant ns-decl was found. 8802 * Add it to the list of redundant ns-decls. 8803 */ 8804 if (xmlDOMWrapNSNormAddNsMapItem2(&listRedund, 8805 &sizeRedund, &nbRedund, ns, mi->newNs) == -1) 8806 goto internal_error; 8807 /* 8808 * Remove the ns-decl from the element-node. 8809 */ 8810 if (prevns) 8811 prevns->next = ns->next; 8812 else 8813 cur->nsDef = ns->next; 8814 goto next_ns_decl; 8815 } 8816 } 8817 } 8818 8819 /* 8820 * Skip ns-references handling if the referenced 8821 * ns-decl is declared on the same element. 8822 */ 8823 if ((cur->ns != NULL) && adoptns && (cur->ns == ns)) 8824 adoptns = 0; 8825 /* 8826 * Does it shadow any ns-decl? 8827 */ 8828 if (XML_NSMAP_NOTEMPTY(nsMap)) { 8829 XML_NSMAP_FOREACH(nsMap, mi) { 8830 if ((mi->depth >= XML_TREE_NSMAP_PARENT) && 8831 (mi->shadowDepth == -1) && 8832 ((ns->prefix == mi->newNs->prefix) || 8833 xmlStrEqual(ns->prefix, mi->newNs->prefix))) { 8834 8835 mi->shadowDepth = depth; 8836 } 8837 } 8838 } 8839 /* 8840 * Push mapping. 8841 */ 8842 if (xmlDOMWrapNsMapAddItem(&nsMap, -1, ns, ns, 8843 depth) == NULL) 8844 goto internal_error; 8845 8846 prevns = ns; 8847 next_ns_decl: 8848 ns = ns->next; 8849 } 8850 } 8851 if (! adoptns) 8852 goto ns_end; 8853 /* Falls through. */ 8854 case XML_ATTRIBUTE_NODE: 8855 /* No ns, no fun. */ 8856 if (cur->ns == NULL) 8857 goto ns_end; 8858 8859 if (! parnsdone) { 8860 if ((elem->parent) && 8861 ((xmlNodePtr) elem->parent->doc != elem->parent)) { 8862 if (xmlDOMWrapNSNormGatherInScopeNs(&nsMap, 8863 elem->parent) == -1) 8864 goto internal_error; 8865 } 8866 parnsdone = 1; 8867 } 8868 /* 8869 * Adjust the reference if this was a redundant ns-decl. 8870 */ 8871 if (listRedund) { 8872 for (i = 0, j = 0; i < nbRedund; i++, j += 2) { 8873 if (cur->ns == listRedund[j]) { 8874 cur->ns = listRedund[++j]; 8875 break; 8876 } 8877 } 8878 } 8879 /* 8880 * Adopt ns-references. 8881 */ 8882 if (XML_NSMAP_NOTEMPTY(nsMap)) { 8883 /* 8884 * Search for a mapping. 8885 */ 8886 XML_NSMAP_FOREACH(nsMap, mi) { 8887 if ((mi->shadowDepth == -1) && 8888 (cur->ns == mi->oldNs)) { 8889 8890 cur->ns = mi->newNs; 8891 goto ns_end; 8892 } 8893 } 8894 } 8895 /* 8896 * Aquire a normalized ns-decl and add it to the map. 8897 */ 8898 if (xmlDOMWrapNSNormAquireNormalizedNs(doc, curElem, 8899 cur->ns, &ns, 8900 &nsMap, depth, 8901 ancestorsOnly, 8902 (cur->type == XML_ATTRIBUTE_NODE) ? 1 : 0) == -1) 8903 goto internal_error; 8904 cur->ns = ns; 8905 8906 ns_end: 8907 if ((cur->type == XML_ELEMENT_NODE) && 8908 (cur->properties != NULL)) { 8909 /* 8910 * Process attributes. 8911 */ 8912 cur = (xmlNodePtr) cur->properties; 8913 continue; 8914 } 8915 break; 8916 default: 8917 goto next_sibling; 8918 } 8919 into_content: 8920 if ((cur->type == XML_ELEMENT_NODE) && 8921 (cur->children != NULL)) { 8922 /* 8923 * Process content of element-nodes only. 8924 */ 8925 cur = cur->children; 8926 continue; 8927 } 8928 next_sibling: 8929 if (cur == elem) 8930 break; 8931 if (cur->type == XML_ELEMENT_NODE) { 8932 if (XML_NSMAP_NOTEMPTY(nsMap)) { 8933 /* 8934 * Pop mappings. 8935 */ 8936 while ((nsMap->last != NULL) && 8937 (nsMap->last->depth >= depth)) 8938 { 8939 XML_NSMAP_POP(nsMap, mi) 8940 } 8941 /* 8942 * Unshadow. 8943 */ 8944 XML_NSMAP_FOREACH(nsMap, mi) { 8945 if (mi->shadowDepth >= depth) 8946 mi->shadowDepth = -1; 8947 } 8948 } 8949 depth--; 8950 } 8951 if (cur->next != NULL) 8952 cur = cur->next; 8953 else { 8954 if (cur->type == XML_ATTRIBUTE_NODE) { 8955 cur = cur->parent; 8956 goto into_content; 8957 } 8958 cur = cur->parent; 8959 goto next_sibling; 8960 } 8961 } while (cur != NULL); 8962 8963 ret = 0; 8964 goto exit; 8965 internal_error: 8966 ret = -1; 8967 exit: 8968 if (listRedund) { 8969 for (i = 0, j = 0; i < nbRedund; i++, j += 2) { 8970 xmlFreeNs(listRedund[j]); 8971 } 8972 xmlFree(listRedund); 8973 } 8974 if (nsMap != NULL) 8975 xmlDOMWrapNsMapFree(nsMap); 8976 return (ret); 8977 } 8978 8979 /* 8980 * xmlDOMWrapAdoptBranch: 8981 * @ctxt: the optional context for custom processing 8982 * @sourceDoc: the optional sourceDoc 8983 * @node: the element-node to start with 8984 * @destDoc: the destination doc for adoption 8985 * @destParent: the optional new parent of @node in @destDoc 8986 * @options: option flags 8987 * 8988 * Ensures that ns-references point to @destDoc: either to 8989 * elements->nsDef entries if @destParent is given, or to 8990 * @destDoc->oldNs otherwise. 8991 * If @destParent is given, it ensures that the tree is namespace 8992 * wellformed by creating additional ns-decls where needed. 8993 * Note that, since prefixes of already existent ns-decls can be 8994 * shadowed by this process, it could break QNames in attribute 8995 * values or element content. 8996 * 8997 * NOTE: This function was not intensively tested. 8998 * 8999 * Returns 0 if succeeded, -1 otherwise and on API/internal errors. 9000 */ 9001 static int 9002 xmlDOMWrapAdoptBranch(xmlDOMWrapCtxtPtr ctxt, 9003 xmlDocPtr sourceDoc, 9004 xmlNodePtr node, 9005 xmlDocPtr destDoc, 9006 xmlNodePtr destParent, 9007 int options ATTRIBUTE_UNUSED) 9008 { 9009 int ret = 0; 9010 xmlNodePtr cur, curElem = NULL; 9011 xmlNsMapPtr nsMap = NULL; 9012 xmlNsMapItemPtr mi; 9013 xmlNsPtr ns = NULL; 9014 int depth = -1, adoptStr = 1; 9015 /* gather @parent's ns-decls. */ 9016 int parnsdone; 9017 /* @ancestorsOnly should be set per option. */ 9018 int ancestorsOnly = 0; 9019 9020 /* 9021 * Optimize string adoption for equal or none dicts. 9022 */ 9023 if ((sourceDoc != NULL) && 9024 (sourceDoc->dict == destDoc->dict)) 9025 adoptStr = 0; 9026 else 9027 adoptStr = 1; 9028 9029 /* 9030 * Get the ns-map from the context if available. 9031 */ 9032 if (ctxt) 9033 nsMap = (xmlNsMapPtr) ctxt->namespaceMap; 9034 /* 9035 * Disable search for ns-decls in the parent-axis of the 9036 * desination element, if: 9037 * 1) there's no destination parent 9038 * 2) custom ns-reference handling is used 9039 */ 9040 if ((destParent == NULL) || 9041 (ctxt && ctxt->getNsForNodeFunc)) 9042 { 9043 parnsdone = 1; 9044 } else 9045 parnsdone = 0; 9046 9047 cur = node; 9048 if ((cur != NULL) && (cur->type == XML_NAMESPACE_DECL)) 9049 goto internal_error; 9050 9051 while (cur != NULL) { 9052 /* 9053 * Paranoid source-doc sanity check. 9054 */ 9055 if (cur->doc != sourceDoc) { 9056 /* 9057 * We'll assume XIncluded nodes if the doc differs. 9058 * TODO: Do we need to reconciliate XIncluded nodes? 9059 * This here skips XIncluded nodes and tries to handle 9060 * broken sequences. 9061 */ 9062 if (cur->next == NULL) 9063 goto leave_node; 9064 do { 9065 cur = cur->next; 9066 if ((cur->type == XML_XINCLUDE_END) || 9067 (cur->doc == node->doc)) 9068 break; 9069 } while (cur->next != NULL); 9070 9071 if (cur->doc != node->doc) 9072 goto leave_node; 9073 } 9074 cur->doc = destDoc; 9075 switch (cur->type) { 9076 case XML_XINCLUDE_START: 9077 case XML_XINCLUDE_END: 9078 /* 9079 * TODO 9080 */ 9081 return (-1); 9082 case XML_ELEMENT_NODE: 9083 curElem = cur; 9084 depth++; 9085 /* 9086 * Namespace declarations. 9087 * - ns->href and ns->prefix are never in the dict, so 9088 * we need not move the values over to the destination dict. 9089 * - Note that for custom handling of ns-references, 9090 * the ns-decls need not be stored in the ns-map, 9091 * since they won't be referenced by node->ns. 9092 */ 9093 if ((cur->nsDef) && 9094 ((ctxt == NULL) || (ctxt->getNsForNodeFunc == NULL))) 9095 { 9096 if (! parnsdone) { 9097 /* 9098 * Gather @parent's in-scope ns-decls. 9099 */ 9100 if (xmlDOMWrapNSNormGatherInScopeNs(&nsMap, 9101 destParent) == -1) 9102 goto internal_error; 9103 parnsdone = 1; 9104 } 9105 for (ns = cur->nsDef; ns != NULL; ns = ns->next) { 9106 /* 9107 * NOTE: ns->prefix and ns->href are never in the dict. 9108 * XML_TREE_ADOPT_STR(ns->prefix) 9109 * XML_TREE_ADOPT_STR(ns->href) 9110 */ 9111 /* 9112 * Does it shadow any ns-decl? 9113 */ 9114 if (XML_NSMAP_NOTEMPTY(nsMap)) { 9115 XML_NSMAP_FOREACH(nsMap, mi) { 9116 if ((mi->depth >= XML_TREE_NSMAP_PARENT) && 9117 (mi->shadowDepth == -1) && 9118 ((ns->prefix == mi->newNs->prefix) || 9119 xmlStrEqual(ns->prefix, 9120 mi->newNs->prefix))) { 9121 9122 mi->shadowDepth = depth; 9123 } 9124 } 9125 } 9126 /* 9127 * Push mapping. 9128 */ 9129 if (xmlDOMWrapNsMapAddItem(&nsMap, -1, 9130 ns, ns, depth) == NULL) 9131 goto internal_error; 9132 } 9133 } 9134 /* Falls through. */ 9135 case XML_ATTRIBUTE_NODE: 9136 /* No namespace, no fun. */ 9137 if (cur->ns == NULL) 9138 goto ns_end; 9139 9140 if (! parnsdone) { 9141 if (xmlDOMWrapNSNormGatherInScopeNs(&nsMap, 9142 destParent) == -1) 9143 goto internal_error; 9144 parnsdone = 1; 9145 } 9146 /* 9147 * Adopt ns-references. 9148 */ 9149 if (XML_NSMAP_NOTEMPTY(nsMap)) { 9150 /* 9151 * Search for a mapping. 9152 */ 9153 XML_NSMAP_FOREACH(nsMap, mi) { 9154 if ((mi->shadowDepth == -1) && 9155 (cur->ns == mi->oldNs)) { 9156 9157 cur->ns = mi->newNs; 9158 goto ns_end; 9159 } 9160 } 9161 } 9162 /* 9163 * No matching namespace in scope. We need a new one. 9164 */ 9165 if ((ctxt) && (ctxt->getNsForNodeFunc)) { 9166 /* 9167 * User-defined behaviour. 9168 */ 9169 ns = ctxt->getNsForNodeFunc(ctxt, cur, 9170 cur->ns->href, cur->ns->prefix); 9171 /* 9172 * Insert mapping if ns is available; it's the users fault 9173 * if not. 9174 */ 9175 if (xmlDOMWrapNsMapAddItem(&nsMap, -1, 9176 cur->ns, ns, XML_TREE_NSMAP_CUSTOM) == NULL) 9177 goto internal_error; 9178 cur->ns = ns; 9179 } else { 9180 /* 9181 * Aquire a normalized ns-decl and add it to the map. 9182 */ 9183 if (xmlDOMWrapNSNormAquireNormalizedNs(destDoc, 9184 /* ns-decls on curElem or on destDoc->oldNs */ 9185 destParent ? curElem : NULL, 9186 cur->ns, &ns, 9187 &nsMap, depth, 9188 ancestorsOnly, 9189 /* ns-decls must be prefixed for attributes. */ 9190 (cur->type == XML_ATTRIBUTE_NODE) ? 1 : 0) == -1) 9191 goto internal_error; 9192 cur->ns = ns; 9193 } 9194 ns_end: 9195 /* 9196 * Further node properties. 9197 * TODO: Is this all? 9198 */ 9199 XML_TREE_ADOPT_STR(cur->name) 9200 if (cur->type == XML_ELEMENT_NODE) { 9201 cur->psvi = NULL; 9202 cur->line = 0; 9203 cur->extra = 0; 9204 /* 9205 * Walk attributes. 9206 */ 9207 if (cur->properties != NULL) { 9208 /* 9209 * Process first attribute node. 9210 */ 9211 cur = (xmlNodePtr) cur->properties; 9212 continue; 9213 } 9214 } else { 9215 /* 9216 * Attributes. 9217 */ 9218 if ((sourceDoc != NULL) && 9219 (((xmlAttrPtr) cur)->atype == XML_ATTRIBUTE_ID)) 9220 { 9221 xmlRemoveID(sourceDoc, (xmlAttrPtr) cur); 9222 } 9223 ((xmlAttrPtr) cur)->atype = 0; 9224 ((xmlAttrPtr) cur)->psvi = NULL; 9225 } 9226 break; 9227 case XML_TEXT_NODE: 9228 case XML_CDATA_SECTION_NODE: 9229 /* 9230 * This puts the content in the dest dict, only if 9231 * it was previously in the source dict. 9232 */ 9233 XML_TREE_ADOPT_STR_2(cur->content) 9234 goto leave_node; 9235 case XML_ENTITY_REF_NODE: 9236 /* 9237 * Remove reference to the entitity-node. 9238 */ 9239 cur->content = NULL; 9240 cur->children = NULL; 9241 cur->last = NULL; 9242 if ((destDoc->intSubset) || (destDoc->extSubset)) { 9243 xmlEntityPtr ent; 9244 /* 9245 * Assign new entity-node if available. 9246 */ 9247 ent = xmlGetDocEntity(destDoc, cur->name); 9248 if (ent != NULL) { 9249 cur->content = ent->content; 9250 cur->children = (xmlNodePtr) ent; 9251 cur->last = (xmlNodePtr) ent; 9252 } 9253 } 9254 goto leave_node; 9255 case XML_PI_NODE: 9256 XML_TREE_ADOPT_STR(cur->name) 9257 XML_TREE_ADOPT_STR_2(cur->content) 9258 break; 9259 case XML_COMMENT_NODE: 9260 break; 9261 default: 9262 goto internal_error; 9263 } 9264 /* 9265 * Walk the tree. 9266 */ 9267 if (cur->children != NULL) { 9268 cur = cur->children; 9269 continue; 9270 } 9271 9272 leave_node: 9273 if (cur == node) 9274 break; 9275 if ((cur->type == XML_ELEMENT_NODE) || 9276 (cur->type == XML_XINCLUDE_START) || 9277 (cur->type == XML_XINCLUDE_END)) 9278 { 9279 /* 9280 * TODO: Do we expect nsDefs on XML_XINCLUDE_START? 9281 */ 9282 if (XML_NSMAP_NOTEMPTY(nsMap)) { 9283 /* 9284 * Pop mappings. 9285 */ 9286 while ((nsMap->last != NULL) && 9287 (nsMap->last->depth >= depth)) 9288 { 9289 XML_NSMAP_POP(nsMap, mi) 9290 } 9291 /* 9292 * Unshadow. 9293 */ 9294 XML_NSMAP_FOREACH(nsMap, mi) { 9295 if (mi->shadowDepth >= depth) 9296 mi->shadowDepth = -1; 9297 } 9298 } 9299 depth--; 9300 } 9301 if (cur->next != NULL) 9302 cur = cur->next; 9303 else if ((cur->type == XML_ATTRIBUTE_NODE) && 9304 (cur->parent->children != NULL)) 9305 { 9306 cur = cur->parent->children; 9307 } else { 9308 cur = cur->parent; 9309 goto leave_node; 9310 } 9311 } 9312 9313 goto exit; 9314 9315 internal_error: 9316 ret = -1; 9317 9318 exit: 9319 /* 9320 * Cleanup. 9321 */ 9322 if (nsMap != NULL) { 9323 if ((ctxt) && (ctxt->namespaceMap == nsMap)) { 9324 /* 9325 * Just cleanup the map but don't free. 9326 */ 9327 if (nsMap->first) { 9328 if (nsMap->pool) 9329 nsMap->last->next = nsMap->pool; 9330 nsMap->pool = nsMap->first; 9331 nsMap->first = NULL; 9332 } 9333 } else 9334 xmlDOMWrapNsMapFree(nsMap); 9335 } 9336 return(ret); 9337 } 9338 9339 /* 9340 * xmlDOMWrapCloneNode: 9341 * @ctxt: the optional context for custom processing 9342 * @sourceDoc: the optional sourceDoc 9343 * @node: the node to start with 9344 * @resNode: the clone of the given @node 9345 * @destDoc: the destination doc 9346 * @destParent: the optional new parent of @node in @destDoc 9347 * @deep: descend into child if set 9348 * @options: option flags 9349 * 9350 * References of out-of scope ns-decls are remapped to point to @destDoc: 9351 * 1) If @destParent is given, then nsDef entries on element-nodes are used 9352 * 2) If *no* @destParent is given, then @destDoc->oldNs entries are used. 9353 * This is the case when you don't know already where the cloned branch 9354 * will be added to. 9355 * 9356 * If @destParent is given, it ensures that the tree is namespace 9357 * wellformed by creating additional ns-decls where needed. 9358 * Note that, since prefixes of already existent ns-decls can be 9359 * shadowed by this process, it could break QNames in attribute 9360 * values or element content. 9361 * TODO: 9362 * 1) What to do with XInclude? Currently this returns an error for XInclude. 9363 * 9364 * Returns 0 if the operation succeeded, 9365 * 1 if a node of unsupported (or not yet supported) type was given, 9366 * -1 on API/internal errors. 9367 */ 9368 9369 int 9370 xmlDOMWrapCloneNode(xmlDOMWrapCtxtPtr ctxt, 9371 xmlDocPtr sourceDoc, 9372 xmlNodePtr node, 9373 xmlNodePtr *resNode, 9374 xmlDocPtr destDoc, 9375 xmlNodePtr destParent, 9376 int deep, 9377 int options ATTRIBUTE_UNUSED) 9378 { 9379 int ret = 0; 9380 xmlNodePtr cur, curElem = NULL; 9381 xmlNsMapPtr nsMap = NULL; 9382 xmlNsMapItemPtr mi; 9383 xmlNsPtr ns; 9384 int depth = -1; 9385 /* int adoptStr = 1; */ 9386 /* gather @parent's ns-decls. */ 9387 int parnsdone = 0; 9388 /* 9389 * @ancestorsOnly: 9390 * TODO: @ancestorsOnly should be set per option. 9391 * 9392 */ 9393 int ancestorsOnly = 0; 9394 xmlNodePtr resultClone = NULL, clone = NULL, parentClone = NULL, prevClone = NULL; 9395 xmlNsPtr cloneNs = NULL, *cloneNsDefSlot = NULL; 9396 xmlDictPtr dict; /* The destination dict */ 9397 9398 if ((node == NULL) || (resNode == NULL) || (destDoc == NULL)) 9399 return(-1); 9400 /* 9401 * TODO: Initially we support only element-nodes. 9402 */ 9403 if (node->type != XML_ELEMENT_NODE) 9404 return(1); 9405 /* 9406 * Check node->doc sanity. 9407 */ 9408 if ((node->doc != NULL) && (sourceDoc != NULL) && 9409 (node->doc != sourceDoc)) { 9410 /* 9411 * Might be an XIncluded node. 9412 */ 9413 return (-1); 9414 } 9415 if (sourceDoc == NULL) 9416 sourceDoc = node->doc; 9417 if (sourceDoc == NULL) 9418 return (-1); 9419 9420 dict = destDoc->dict; 9421 /* 9422 * Reuse the namespace map of the context. 9423 */ 9424 if (ctxt) 9425 nsMap = (xmlNsMapPtr) ctxt->namespaceMap; 9426 9427 *resNode = NULL; 9428 9429 cur = node; 9430 if ((cur != NULL) && (cur->type == XML_NAMESPACE_DECL)) 9431 return(-1); 9432 9433 while (cur != NULL) { 9434 if (cur->doc != sourceDoc) { 9435 /* 9436 * We'll assume XIncluded nodes if the doc differs. 9437 * TODO: Do we need to reconciliate XIncluded nodes? 9438 * TODO: This here returns -1 in this case. 9439 */ 9440 goto internal_error; 9441 } 9442 /* 9443 * Create a new node. 9444 */ 9445 switch (cur->type) { 9446 case XML_XINCLUDE_START: 9447 case XML_XINCLUDE_END: 9448 /* 9449 * TODO: What to do with XInclude? 9450 */ 9451 goto internal_error; 9452 break; 9453 case XML_ELEMENT_NODE: 9454 case XML_TEXT_NODE: 9455 case XML_CDATA_SECTION_NODE: 9456 case XML_COMMENT_NODE: 9457 case XML_PI_NODE: 9458 case XML_DOCUMENT_FRAG_NODE: 9459 case XML_ENTITY_REF_NODE: 9460 case XML_ENTITY_NODE: 9461 /* 9462 * Nodes of xmlNode structure. 9463 */ 9464 clone = (xmlNodePtr) xmlMalloc(sizeof(xmlNode)); 9465 if (clone == NULL) { 9466 xmlTreeErrMemory("xmlDOMWrapCloneNode(): allocating a node"); 9467 goto internal_error; 9468 } 9469 memset(clone, 0, sizeof(xmlNode)); 9470 /* 9471 * Set hierachical links. 9472 */ 9473 if (resultClone != NULL) { 9474 clone->parent = parentClone; 9475 if (prevClone) { 9476 prevClone->next = clone; 9477 clone->prev = prevClone; 9478 } else 9479 parentClone->children = clone; 9480 } else 9481 resultClone = clone; 9482 9483 break; 9484 case XML_ATTRIBUTE_NODE: 9485 /* 9486 * Attributes (xmlAttr). 9487 */ 9488 clone = (xmlNodePtr) xmlMalloc(sizeof(xmlAttr)); 9489 if (clone == NULL) { 9490 xmlTreeErrMemory("xmlDOMWrapCloneNode(): allocating an attr-node"); 9491 goto internal_error; 9492 } 9493 memset(clone, 0, sizeof(xmlAttr)); 9494 /* 9495 * Set hierachical links. 9496 * TODO: Change this to add to the end of attributes. 9497 */ 9498 if (resultClone != NULL) { 9499 clone->parent = parentClone; 9500 if (prevClone) { 9501 prevClone->next = clone; 9502 clone->prev = prevClone; 9503 } else 9504 parentClone->properties = (xmlAttrPtr) clone; 9505 } else 9506 resultClone = clone; 9507 break; 9508 default: 9509 /* 9510 * TODO QUESTION: Any other nodes expected? 9511 */ 9512 goto internal_error; 9513 } 9514 9515 clone->type = cur->type; 9516 clone->doc = destDoc; 9517 9518 /* 9519 * Clone the name of the node if any. 9520 */ 9521 if (cur->name == xmlStringText) 9522 clone->name = xmlStringText; 9523 else if (cur->name == xmlStringTextNoenc) 9524 /* 9525 * NOTE: Although xmlStringTextNoenc is never assigned to a node 9526 * in tree.c, it might be set in Libxslt via 9527 * "xsl:disable-output-escaping". 9528 */ 9529 clone->name = xmlStringTextNoenc; 9530 else if (cur->name == xmlStringComment) 9531 clone->name = xmlStringComment; 9532 else if (cur->name != NULL) { 9533 DICT_CONST_COPY(cur->name, clone->name); 9534 } 9535 9536 switch (cur->type) { 9537 case XML_XINCLUDE_START: 9538 case XML_XINCLUDE_END: 9539 /* 9540 * TODO 9541 */ 9542 return (-1); 9543 case XML_ELEMENT_NODE: 9544 curElem = cur; 9545 depth++; 9546 /* 9547 * Namespace declarations. 9548 */ 9549 if (cur->nsDef != NULL) { 9550 if (! parnsdone) { 9551 if (destParent && (ctxt == NULL)) { 9552 /* 9553 * Gather @parent's in-scope ns-decls. 9554 */ 9555 if (xmlDOMWrapNSNormGatherInScopeNs(&nsMap, 9556 destParent) == -1) 9557 goto internal_error; 9558 } 9559 parnsdone = 1; 9560 } 9561 /* 9562 * Clone namespace declarations. 9563 */ 9564 cloneNsDefSlot = &(clone->nsDef); 9565 for (ns = cur->nsDef; ns != NULL; ns = ns->next) { 9566 /* 9567 * Create a new xmlNs. 9568 */ 9569 cloneNs = (xmlNsPtr) xmlMalloc(sizeof(xmlNs)); 9570 if (cloneNs == NULL) { 9571 xmlTreeErrMemory("xmlDOMWrapCloneNode(): " 9572 "allocating namespace"); 9573 return(-1); 9574 } 9575 memset(cloneNs, 0, sizeof(xmlNs)); 9576 cloneNs->type = XML_LOCAL_NAMESPACE; 9577 9578 if (ns->href != NULL) 9579 cloneNs->href = xmlStrdup(ns->href); 9580 if (ns->prefix != NULL) 9581 cloneNs->prefix = xmlStrdup(ns->prefix); 9582 9583 *cloneNsDefSlot = cloneNs; 9584 cloneNsDefSlot = &(cloneNs->next); 9585 9586 /* 9587 * Note that for custom handling of ns-references, 9588 * the ns-decls need not be stored in the ns-map, 9589 * since they won't be referenced by node->ns. 9590 */ 9591 if ((ctxt == NULL) || 9592 (ctxt->getNsForNodeFunc == NULL)) 9593 { 9594 /* 9595 * Does it shadow any ns-decl? 9596 */ 9597 if (XML_NSMAP_NOTEMPTY(nsMap)) { 9598 XML_NSMAP_FOREACH(nsMap, mi) { 9599 if ((mi->depth >= XML_TREE_NSMAP_PARENT) && 9600 (mi->shadowDepth == -1) && 9601 ((ns->prefix == mi->newNs->prefix) || 9602 xmlStrEqual(ns->prefix, 9603 mi->newNs->prefix))) { 9604 /* 9605 * Mark as shadowed at the current 9606 * depth. 9607 */ 9608 mi->shadowDepth = depth; 9609 } 9610 } 9611 } 9612 /* 9613 * Push mapping. 9614 */ 9615 if (xmlDOMWrapNsMapAddItem(&nsMap, -1, 9616 ns, cloneNs, depth) == NULL) 9617 goto internal_error; 9618 } 9619 } 9620 } 9621 /* cur->ns will be processed further down. */ 9622 break; 9623 case XML_ATTRIBUTE_NODE: 9624 /* IDs will be processed further down. */ 9625 /* cur->ns will be processed further down. */ 9626 break; 9627 case XML_TEXT_NODE: 9628 case XML_CDATA_SECTION_NODE: 9629 /* 9630 * Note that this will also cover the values of attributes. 9631 */ 9632 DICT_COPY(cur->content, clone->content); 9633 goto leave_node; 9634 case XML_ENTITY_NODE: 9635 /* TODO: What to do here? */ 9636 goto leave_node; 9637 case XML_ENTITY_REF_NODE: 9638 if (sourceDoc != destDoc) { 9639 if ((destDoc->intSubset) || (destDoc->extSubset)) { 9640 xmlEntityPtr ent; 9641 /* 9642 * Different doc: Assign new entity-node if available. 9643 */ 9644 ent = xmlGetDocEntity(destDoc, cur->name); 9645 if (ent != NULL) { 9646 clone->content = ent->content; 9647 clone->children = (xmlNodePtr) ent; 9648 clone->last = (xmlNodePtr) ent; 9649 } 9650 } 9651 } else { 9652 /* 9653 * Same doc: Use the current node's entity declaration 9654 * and value. 9655 */ 9656 clone->content = cur->content; 9657 clone->children = cur->children; 9658 clone->last = cur->last; 9659 } 9660 goto leave_node; 9661 case XML_PI_NODE: 9662 DICT_COPY(cur->content, clone->content); 9663 goto leave_node; 9664 case XML_COMMENT_NODE: 9665 DICT_COPY(cur->content, clone->content); 9666 goto leave_node; 9667 default: 9668 goto internal_error; 9669 } 9670 9671 if (cur->ns == NULL) 9672 goto end_ns_reference; 9673 9674 /* handle_ns_reference: */ 9675 /* 9676 ** The following will take care of references to ns-decls ******** 9677 ** and is intended only for element- and attribute-nodes. 9678 ** 9679 */ 9680 if (! parnsdone) { 9681 if (destParent && (ctxt == NULL)) { 9682 if (xmlDOMWrapNSNormGatherInScopeNs(&nsMap, destParent) == -1) 9683 goto internal_error; 9684 } 9685 parnsdone = 1; 9686 } 9687 /* 9688 * Adopt ns-references. 9689 */ 9690 if (XML_NSMAP_NOTEMPTY(nsMap)) { 9691 /* 9692 * Search for a mapping. 9693 */ 9694 XML_NSMAP_FOREACH(nsMap, mi) { 9695 if ((mi->shadowDepth == -1) && 9696 (cur->ns == mi->oldNs)) { 9697 /* 9698 * This is the nice case: a mapping was found. 9699 */ 9700 clone->ns = mi->newNs; 9701 goto end_ns_reference; 9702 } 9703 } 9704 } 9705 /* 9706 * No matching namespace in scope. We need a new one. 9707 */ 9708 if ((ctxt != NULL) && (ctxt->getNsForNodeFunc != NULL)) { 9709 /* 9710 * User-defined behaviour. 9711 */ 9712 ns = ctxt->getNsForNodeFunc(ctxt, cur, 9713 cur->ns->href, cur->ns->prefix); 9714 /* 9715 * Add user's mapping. 9716 */ 9717 if (xmlDOMWrapNsMapAddItem(&nsMap, -1, 9718 cur->ns, ns, XML_TREE_NSMAP_CUSTOM) == NULL) 9719 goto internal_error; 9720 clone->ns = ns; 9721 } else { 9722 /* 9723 * Aquire a normalized ns-decl and add it to the map. 9724 */ 9725 if (xmlDOMWrapNSNormAquireNormalizedNs(destDoc, 9726 /* ns-decls on curElem or on destDoc->oldNs */ 9727 destParent ? curElem : NULL, 9728 cur->ns, &ns, 9729 &nsMap, depth, 9730 /* if we need to search only in the ancestor-axis */ 9731 ancestorsOnly, 9732 /* ns-decls must be prefixed for attributes. */ 9733 (cur->type == XML_ATTRIBUTE_NODE) ? 1 : 0) == -1) 9734 goto internal_error; 9735 clone->ns = ns; 9736 } 9737 9738 end_ns_reference: 9739 9740 /* 9741 * Some post-processing. 9742 * 9743 * Handle ID attributes. 9744 */ 9745 if ((clone->type == XML_ATTRIBUTE_NODE) && 9746 (clone->parent != NULL)) 9747 { 9748 if (xmlIsID(destDoc, clone->parent, (xmlAttrPtr) clone)) { 9749 9750 xmlChar *idVal; 9751 9752 idVal = xmlNodeListGetString(cur->doc, cur->children, 1); 9753 if (idVal != NULL) { 9754 if (xmlAddID(NULL, destDoc, idVal, (xmlAttrPtr) cur) == NULL) { 9755 /* TODO: error message. */ 9756 xmlFree(idVal); 9757 goto internal_error; 9758 } 9759 xmlFree(idVal); 9760 } 9761 } 9762 } 9763 /* 9764 ** 9765 ** The following will traverse the tree ************************** 9766 ** 9767 * 9768 * Walk the element's attributes before descending into child-nodes. 9769 */ 9770 if ((cur->type == XML_ELEMENT_NODE) && (cur->properties != NULL)) { 9771 prevClone = NULL; 9772 parentClone = clone; 9773 cur = (xmlNodePtr) cur->properties; 9774 continue; 9775 } 9776 into_content: 9777 /* 9778 * Descend into child-nodes. 9779 */ 9780 if (cur->children != NULL) { 9781 if (deep || (cur->type == XML_ATTRIBUTE_NODE)) { 9782 prevClone = NULL; 9783 parentClone = clone; 9784 cur = cur->children; 9785 continue; 9786 } 9787 } 9788 9789 leave_node: 9790 /* 9791 * At this point we are done with the node, its content 9792 * and an element-nodes's attribute-nodes. 9793 */ 9794 if (cur == node) 9795 break; 9796 if ((cur->type == XML_ELEMENT_NODE) || 9797 (cur->type == XML_XINCLUDE_START) || 9798 (cur->type == XML_XINCLUDE_END)) { 9799 /* 9800 * TODO: Do we expect nsDefs on XML_XINCLUDE_START? 9801 */ 9802 if (XML_NSMAP_NOTEMPTY(nsMap)) { 9803 /* 9804 * Pop mappings. 9805 */ 9806 while ((nsMap->last != NULL) && 9807 (nsMap->last->depth >= depth)) 9808 { 9809 XML_NSMAP_POP(nsMap, mi) 9810 } 9811 /* 9812 * Unshadow. 9813 */ 9814 XML_NSMAP_FOREACH(nsMap, mi) { 9815 if (mi->shadowDepth >= depth) 9816 mi->shadowDepth = -1; 9817 } 9818 } 9819 depth--; 9820 } 9821 if (cur->next != NULL) { 9822 prevClone = clone; 9823 cur = cur->next; 9824 } else if (cur->type != XML_ATTRIBUTE_NODE) { 9825 /* 9826 * Set clone->last. 9827 */ 9828 if (clone->parent != NULL) 9829 clone->parent->last = clone; 9830 clone = clone->parent; 9831 if (clone != NULL) 9832 parentClone = clone->parent; 9833 /* 9834 * Process parent --> next; 9835 */ 9836 cur = cur->parent; 9837 goto leave_node; 9838 } else { 9839 /* This is for attributes only. */ 9840 clone = clone->parent; 9841 parentClone = clone->parent; 9842 /* 9843 * Process parent-element --> children. 9844 */ 9845 cur = cur->parent; 9846 goto into_content; 9847 } 9848 } 9849 goto exit; 9850 9851 internal_error: 9852 ret = -1; 9853 9854 exit: 9855 /* 9856 * Cleanup. 9857 */ 9858 if (nsMap != NULL) { 9859 if ((ctxt) && (ctxt->namespaceMap == nsMap)) { 9860 /* 9861 * Just cleanup the map but don't free. 9862 */ 9863 if (nsMap->first) { 9864 if (nsMap->pool) 9865 nsMap->last->next = nsMap->pool; 9866 nsMap->pool = nsMap->first; 9867 nsMap->first = NULL; 9868 } 9869 } else 9870 xmlDOMWrapNsMapFree(nsMap); 9871 } 9872 /* 9873 * TODO: Should we try a cleanup of the cloned node in case of a 9874 * fatal error? 9875 */ 9876 *resNode = resultClone; 9877 return (ret); 9878 } 9879 9880 /* 9881 * xmlDOMWrapAdoptAttr: 9882 * @ctxt: the optional context for custom processing 9883 * @sourceDoc: the optional source document of attr 9884 * @attr: the attribute-node to be adopted 9885 * @destDoc: the destination doc for adoption 9886 * @destParent: the optional new parent of @attr in @destDoc 9887 * @options: option flags 9888 * 9889 * @attr is adopted by @destDoc. 9890 * Ensures that ns-references point to @destDoc: either to 9891 * elements->nsDef entries if @destParent is given, or to 9892 * @destDoc->oldNs otherwise. 9893 * 9894 * Returns 0 if succeeded, -1 otherwise and on API/internal errors. 9895 */ 9896 static int 9897 xmlDOMWrapAdoptAttr(xmlDOMWrapCtxtPtr ctxt, 9898 xmlDocPtr sourceDoc, 9899 xmlAttrPtr attr, 9900 xmlDocPtr destDoc, 9901 xmlNodePtr destParent, 9902 int options ATTRIBUTE_UNUSED) 9903 { 9904 xmlNodePtr cur; 9905 int adoptStr = 1; 9906 9907 if ((attr == NULL) || (destDoc == NULL)) 9908 return (-1); 9909 9910 attr->doc = destDoc; 9911 if (attr->ns != NULL) { 9912 xmlNsPtr ns = NULL; 9913 9914 if (ctxt != NULL) { 9915 /* TODO: User defined. */ 9916 } 9917 /* XML Namespace. */ 9918 if (IS_STR_XML(attr->ns->prefix)) { 9919 ns = xmlTreeEnsureXMLDecl(destDoc); 9920 } else if (destParent == NULL) { 9921 /* 9922 * Store in @destDoc->oldNs. 9923 */ 9924 ns = xmlDOMWrapStoreNs(destDoc, attr->ns->href, attr->ns->prefix); 9925 } else { 9926 /* 9927 * Declare on @destParent. 9928 */ 9929 if (xmlSearchNsByNamespaceStrict(destDoc, destParent, attr->ns->href, 9930 &ns, 1) == -1) 9931 goto internal_error; 9932 if (ns == NULL) { 9933 ns = xmlDOMWrapNSNormDeclareNsForced(destDoc, destParent, 9934 attr->ns->href, attr->ns->prefix, 1); 9935 } 9936 } 9937 if (ns == NULL) 9938 goto internal_error; 9939 attr->ns = ns; 9940 } 9941 9942 XML_TREE_ADOPT_STR(attr->name); 9943 attr->atype = 0; 9944 attr->psvi = NULL; 9945 /* 9946 * Walk content. 9947 */ 9948 if (attr->children == NULL) 9949 return (0); 9950 cur = attr->children; 9951 if ((cur != NULL) && (cur->type == XML_NAMESPACE_DECL)) 9952 goto internal_error; 9953 while (cur != NULL) { 9954 cur->doc = destDoc; 9955 switch (cur->type) { 9956 case XML_TEXT_NODE: 9957 case XML_CDATA_SECTION_NODE: 9958 XML_TREE_ADOPT_STR_2(cur->content) 9959 break; 9960 case XML_ENTITY_REF_NODE: 9961 /* 9962 * Remove reference to the entitity-node. 9963 */ 9964 cur->content = NULL; 9965 cur->children = NULL; 9966 cur->last = NULL; 9967 if ((destDoc->intSubset) || (destDoc->extSubset)) { 9968 xmlEntityPtr ent; 9969 /* 9970 * Assign new entity-node if available. 9971 */ 9972 ent = xmlGetDocEntity(destDoc, cur->name); 9973 if (ent != NULL) { 9974 cur->content = ent->content; 9975 cur->children = (xmlNodePtr) ent; 9976 cur->last = (xmlNodePtr) ent; 9977 } 9978 } 9979 break; 9980 default: 9981 break; 9982 } 9983 if (cur->children != NULL) { 9984 cur = cur->children; 9985 continue; 9986 } 9987 next_sibling: 9988 if (cur == (xmlNodePtr) attr) 9989 break; 9990 if (cur->next != NULL) 9991 cur = cur->next; 9992 else { 9993 cur = cur->parent; 9994 goto next_sibling; 9995 } 9996 } 9997 return (0); 9998 internal_error: 9999 return (-1); 10000 } 10001 10002 /* 10003 * xmlDOMWrapAdoptNode: 10004 * @ctxt: the optional context for custom processing 10005 * @sourceDoc: the optional sourceDoc 10006 * @node: the node to start with 10007 * @destDoc: the destination doc 10008 * @destParent: the optional new parent of @node in @destDoc 10009 * @options: option flags 10010 * 10011 * References of out-of scope ns-decls are remapped to point to @destDoc: 10012 * 1) If @destParent is given, then nsDef entries on element-nodes are used 10013 * 2) If *no* @destParent is given, then @destDoc->oldNs entries are used 10014 * This is the case when you have an unlinked node and just want to move it 10015 * to the context of 10016 * 10017 * If @destParent is given, it ensures that the tree is namespace 10018 * wellformed by creating additional ns-decls where needed. 10019 * Note that, since prefixes of already existent ns-decls can be 10020 * shadowed by this process, it could break QNames in attribute 10021 * values or element content. 10022 * NOTE: This function was not intensively tested. 10023 * 10024 * Returns 0 if the operation succeeded, 10025 * 1 if a node of unsupported type was given, 10026 * 2 if a node of not yet supported type was given and 10027 * -1 on API/internal errors. 10028 */ 10029 int 10030 xmlDOMWrapAdoptNode(xmlDOMWrapCtxtPtr ctxt, 10031 xmlDocPtr sourceDoc, 10032 xmlNodePtr node, 10033 xmlDocPtr destDoc, 10034 xmlNodePtr destParent, 10035 int options) 10036 { 10037 if ((node == NULL) || (node->type == XML_NAMESPACE_DECL) || 10038 (destDoc == NULL) || 10039 ((destParent != NULL) && (destParent->doc != destDoc))) 10040 return(-1); 10041 /* 10042 * Check node->doc sanity. 10043 */ 10044 if ((node->doc != NULL) && (sourceDoc != NULL) && 10045 (node->doc != sourceDoc)) { 10046 /* 10047 * Might be an XIncluded node. 10048 */ 10049 return (-1); 10050 } 10051 if (sourceDoc == NULL) 10052 sourceDoc = node->doc; 10053 if (sourceDoc == destDoc) 10054 return (-1); 10055 switch (node->type) { 10056 case XML_ELEMENT_NODE: 10057 case XML_ATTRIBUTE_NODE: 10058 case XML_TEXT_NODE: 10059 case XML_CDATA_SECTION_NODE: 10060 case XML_ENTITY_REF_NODE: 10061 case XML_PI_NODE: 10062 case XML_COMMENT_NODE: 10063 break; 10064 case XML_DOCUMENT_FRAG_NODE: 10065 /* TODO: Support document-fragment-nodes. */ 10066 return (2); 10067 default: 10068 return (1); 10069 } 10070 /* 10071 * Unlink only if @node was not already added to @destParent. 10072 */ 10073 if ((node->parent != NULL) && (destParent != node->parent)) 10074 xmlUnlinkNode(node); 10075 10076 if (node->type == XML_ELEMENT_NODE) { 10077 return (xmlDOMWrapAdoptBranch(ctxt, sourceDoc, node, 10078 destDoc, destParent, options)); 10079 } else if (node->type == XML_ATTRIBUTE_NODE) { 10080 return (xmlDOMWrapAdoptAttr(ctxt, sourceDoc, 10081 (xmlAttrPtr) node, destDoc, destParent, options)); 10082 } else { 10083 xmlNodePtr cur = node; 10084 int adoptStr = 1; 10085 10086 cur->doc = destDoc; 10087 /* 10088 * Optimize string adoption. 10089 */ 10090 if ((sourceDoc != NULL) && 10091 (sourceDoc->dict == destDoc->dict)) 10092 adoptStr = 0; 10093 switch (node->type) { 10094 case XML_TEXT_NODE: 10095 case XML_CDATA_SECTION_NODE: 10096 XML_TREE_ADOPT_STR_2(node->content) 10097 break; 10098 case XML_ENTITY_REF_NODE: 10099 /* 10100 * Remove reference to the entitity-node. 10101 */ 10102 node->content = NULL; 10103 node->children = NULL; 10104 node->last = NULL; 10105 if ((destDoc->intSubset) || (destDoc->extSubset)) { 10106 xmlEntityPtr ent; 10107 /* 10108 * Assign new entity-node if available. 10109 */ 10110 ent = xmlGetDocEntity(destDoc, node->name); 10111 if (ent != NULL) { 10112 node->content = ent->content; 10113 node->children = (xmlNodePtr) ent; 10114 node->last = (xmlNodePtr) ent; 10115 } 10116 } 10117 XML_TREE_ADOPT_STR(node->name) 10118 break; 10119 case XML_PI_NODE: { 10120 XML_TREE_ADOPT_STR(node->name) 10121 XML_TREE_ADOPT_STR_2(node->content) 10122 break; 10123 } 10124 default: 10125 break; 10126 } 10127 } 10128 return (0); 10129 } 10130 10131 #define bottom_tree 10132 #include "elfgcchack.h" 10133
