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