tree.c@ 66250

Last change on this file since 66250 was 65950, checked in by vboxsync, 8 years ago
libxml 2.9.4: fix export
Property svn:eol-style set to `native`
File size: 254.9 KB

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

Note: See TracBrowser for help on using the repository browser.

source: vbox/trunk/src/libs/libxml2-2.9.4/tree.c@ 66250

Download in other formats: