src/third_party/libxml/src/tree.c

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