tree.c@ 53367

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

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

source: vbox/trunk/src/libs/libxml2-2.6.31/tree.c@ 53367

Download in other formats: