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