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