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