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