xinclude.c@ 93145

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

Line
1	/*
2	* xinclude.c : Code to implement XInclude processing
3	*
4	* World Wide Web Consortium W3C Last Call Working Draft 10 November 2003
5	* http://www.w3.org/TR/2003/WD-xinclude-20031110
6	*
7	* See Copyright for the status of this software.
8	*
9	* daniel@veillard.com
10	*/
11
12	#define IN_LIBXML
13	#include "libxml.h"
14
15	#include <string.h>
16	#include <libxml/xmlmemory.h>
17	#include <libxml/tree.h>
18	#include <libxml/parser.h>
19	#include <libxml/uri.h>
20	#include <libxml/xpath.h>
21	#include <libxml/xpointer.h>
22	#include <libxml/parserInternals.h>
23	#include <libxml/xmlerror.h>
24	#include <libxml/encoding.h>
25	#include <libxml/globals.h>
26
27	#ifdef LIBXML_XINCLUDE_ENABLED
28	#include <libxml/xinclude.h>
29
30	#include "buf.h"
31
32	#define XINCLUDE_MAX_DEPTH 40
33
34	/* #define DEBUG_XINCLUDE */
35	#ifdef DEBUG_XINCLUDE
36	#ifdef LIBXML_DEBUG_ENABLED
37	#include <libxml/debugXML.h>
38	#endif
39	#endif
40
41	/************************************************************************
42	* *
43	* XInclude context handling *
44	* *
45	************************************************************************/
46
47	/*
48	* An XInclude context
49	*/
50	typedef xmlChar *xmlURL;
51
52	typedef struct _xmlXIncludeRef xmlXIncludeRef;
53	typedef xmlXIncludeRef *xmlXIncludeRefPtr;
54	struct _xmlXIncludeRef {
55	xmlChar URI; / the fully resolved resource URL */
56	xmlChar fragment; / the fragment in the URI */
57	xmlDocPtr doc; /* the parsed document */
58	xmlNodePtr ref; /* the node making the reference in the source */
59	xmlNodePtr inc; /* the included copy */
60	int xml; /* xml or txt */
61	int count; /* how many refs use that specific doc */
62	xmlXPathObjectPtr xptr; /* the xpointer if needed */
63	int emptyFb; /* flag to show fallback empty */
64	};
65
66	struct _xmlXIncludeCtxt {
67	xmlDocPtr doc; /* the source document */
68	int incBase; /* the first include for this document */
69	int incNr; /* number of includes */
70	int incMax; /* size of includes tab */
71	xmlXIncludeRefPtr incTab; / array of included references */
72
73	int txtNr; /* number of unparsed documents */
74	int txtMax; /* size of unparsed documents tab */
75	xmlNodePtr txtTab; / array of unparsed text nodes */
76	xmlURL txturlTab; / array of unparsed text URLs */
77
78	xmlChar * url; /* the current URL processed */
79	int urlNr; /* number of URLs stacked */
80	int urlMax; /* size of URL stack */
81	xmlChar * urlTab; / URL stack */
82
83	int nbErrors; /* the number of errors detected */
84	int legacy; /* using XINCLUDE_OLD_NS */
85	int parseFlags; /* the flags used for parsing XML documents */
86	xmlChar * base; /* the current xml:base */
87
88	void _private; / application data */
89	};
90
91	static int
92	xmlXIncludeDoProcess(xmlXIncludeCtxtPtr ctxt, xmlDocPtr doc, xmlNodePtr tree);
93
94
95	/************************************************************************
96	* *
97	* XInclude error handler *
98	* *
99	************************************************************************/
100
101	/**
102	* xmlXIncludeErrMemory:
103	* @extra: extra information
104	*
105	* Handle an out of memory condition
106	*/
107	static void
108	xmlXIncludeErrMemory(xmlXIncludeCtxtPtr ctxt, xmlNodePtr node,
109	const char *extra)
110	{
111	if (ctxt != NULL)
112	ctxt->nbErrors++;
113	__xmlRaiseError(NULL, NULL, NULL, ctxt, node, XML_FROM_XINCLUDE,
114	XML_ERR_NO_MEMORY, XML_ERR_ERROR, NULL, 0,
115	extra, NULL, NULL, 0, 0,
116	"Memory allocation failed : %s\n", extra);
117	}
118
119	/**
120	* xmlXIncludeErr:
121	* @ctxt: the XInclude context
122	* @node: the context node
123	* @msg: the error message
124	* @extra: extra information
125	*
126	* Handle an XInclude error
127	*/
128	static void LIBXML_ATTR_FORMAT(4,0)
129	xmlXIncludeErr(xmlXIncludeCtxtPtr ctxt, xmlNodePtr node, int error,
130	const char msg, const xmlChar extra)
131	{
132	if (ctxt != NULL)
133	ctxt->nbErrors++;
134	__xmlRaiseError(NULL, NULL, NULL, ctxt, node, XML_FROM_XINCLUDE,
135	error, XML_ERR_ERROR, NULL, 0,
136	(const char *) extra, NULL, NULL, 0, 0,
137	msg, (const char *) extra);
138	}
139
140	#if 0
141	/**
142	* xmlXIncludeWarn:
143	* @ctxt: the XInclude context
144	* @node: the context node
145	* @msg: the error message
146	* @extra: extra information
147	*
148	* Emit an XInclude warning.
149	*/
150	static void LIBXML_ATTR_FORMAT(4,0)
151	xmlXIncludeWarn(xmlXIncludeCtxtPtr ctxt, xmlNodePtr node, int error,
152	const char msg, const xmlChar extra)
153	{
154	__xmlRaiseError(NULL, NULL, NULL, ctxt, node, XML_FROM_XINCLUDE,
155	error, XML_ERR_WARNING, NULL, 0,
156	(const char *) extra, NULL, NULL, 0, 0,
157	msg, (const char *) extra);
158	}
159	#endif
160
161	/**
162	* xmlXIncludeGetProp:
163	* @ctxt: the XInclude context
164	* @cur: the node
165	* @name: the attribute name
166	*
167	* Get an XInclude attribute
168	*
169	* Returns the value (to be freed) or NULL if not found
170	*/
171	static xmlChar *
172	xmlXIncludeGetProp(xmlXIncludeCtxtPtr ctxt, xmlNodePtr cur,
173	const xmlChar *name) {
174	xmlChar *ret;
175
176	ret = xmlGetNsProp(cur, XINCLUDE_NS, name);
177	if (ret != NULL)
178	return(ret);
179	if (ctxt->legacy != 0) {
180	ret = xmlGetNsProp(cur, XINCLUDE_OLD_NS, name);
181	if (ret != NULL)
182	return(ret);
183	}
184	ret = xmlGetProp(cur, name);
185	return(ret);
186	}
187	/**
188	* xmlXIncludeFreeRef:
189	* @ref: the XInclude reference
190	*
191	* Free an XInclude reference
192	*/
193	static void
194	xmlXIncludeFreeRef(xmlXIncludeRefPtr ref) {
195	if (ref == NULL)
196	return;
197	#ifdef DEBUG_XINCLUDE
198	xmlGenericError(xmlGenericErrorContext, "Freeing ref\n");
199	#endif
200	if (ref->doc != NULL) {
201	#ifdef DEBUG_XINCLUDE
202	xmlGenericError(xmlGenericErrorContext, "Freeing doc %s\n", ref->URI);
203	#endif
204	xmlFreeDoc(ref->doc);
205	}
206	if (ref->URI != NULL)
207	xmlFree(ref->URI);
208	if (ref->fragment != NULL)
209	xmlFree(ref->fragment);
210	if (ref->xptr != NULL)
211	xmlXPathFreeObject(ref->xptr);
212	xmlFree(ref);
213	}
214
215	/**
216	* xmlXIncludeNewRef:
217	* @ctxt: the XInclude context
218	* @URI: the resource URI
219	*
220	* Creates a new reference within an XInclude context
221	*
222	* Returns the new set
223	*/
224	static xmlXIncludeRefPtr
225	xmlXIncludeNewRef(xmlXIncludeCtxtPtr ctxt, const xmlChar *URI,
226	xmlNodePtr ref) {
227	xmlXIncludeRefPtr ret;
228
229	#ifdef DEBUG_XINCLUDE
230	xmlGenericError(xmlGenericErrorContext, "New ref %s\n", URI);
231	#endif
232	ret = (xmlXIncludeRefPtr) xmlMalloc(sizeof(xmlXIncludeRef));
233	if (ret == NULL) {
234	xmlXIncludeErrMemory(ctxt, ref, "growing XInclude context");
235	return(NULL);
236	}
237	memset(ret, 0, sizeof(xmlXIncludeRef));
238	if (URI == NULL)
239	ret->URI = NULL;
240	else
241	ret->URI = xmlStrdup(URI);
242	ret->fragment = NULL;
243	ret->ref = ref;
244	ret->doc = NULL;
245	ret->count = 0;
246	ret->xml = 0;
247	ret->inc = NULL;
248	if (ctxt->incMax == 0) {
249	ctxt->incMax = 4;
250	ctxt->incTab = (xmlXIncludeRefPtr ) xmlMalloc(ctxt->incMax
251	sizeof(ctxt->incTab[0]));
252	if (ctxt->incTab == NULL) {
253	xmlXIncludeErrMemory(ctxt, ref, "growing XInclude context");
254	xmlXIncludeFreeRef(ret);
255	return(NULL);
256	}
257	}
258	if (ctxt->incNr >= ctxt->incMax) {
259	ctxt->incMax *= 2;
260	ctxt->incTab = (xmlXIncludeRefPtr *) xmlRealloc(ctxt->incTab,
261	ctxt->incMax * sizeof(ctxt->incTab[0]));
262	if (ctxt->incTab == NULL) {
263	xmlXIncludeErrMemory(ctxt, ref, "growing XInclude context");
264	xmlXIncludeFreeRef(ret);
265	return(NULL);
266	}
267	}
268	ctxt->incTab[ctxt->incNr++] = ret;
269	return(ret);
270	}
271
272	/**
273	* xmlXIncludeNewContext:
274	* @doc: an XML Document
275	*
276	* Creates a new XInclude context
277	*
278	* Returns the new set
279	*/
280	xmlXIncludeCtxtPtr
281	xmlXIncludeNewContext(xmlDocPtr doc) {
282	xmlXIncludeCtxtPtr ret;
283
284	#ifdef DEBUG_XINCLUDE
285	xmlGenericError(xmlGenericErrorContext, "New context\n");
286	#endif
287	if (doc == NULL)
288	return(NULL);
289	ret = (xmlXIncludeCtxtPtr) xmlMalloc(sizeof(xmlXIncludeCtxt));
290	if (ret == NULL) {
291	xmlXIncludeErrMemory(NULL, (xmlNodePtr) doc,
292	"creating XInclude context");
293	return(NULL);
294	}
295	memset(ret, 0, sizeof(xmlXIncludeCtxt));
296	ret->doc = doc;
297	ret->incNr = 0;
298	ret->incBase = 0;
299	ret->incMax = 0;
300	ret->incTab = NULL;
301	ret->nbErrors = 0;
302	return(ret);
303	}
304
305	/**
306	* xmlXIncludeURLPush:
307	* @ctxt: the parser context
308	* @value: the url
309	*
310	* Pushes a new url on top of the url stack
311	*
312	* Returns -1 in case of error, the index in the stack otherwise
313	*/
314	static int
315	xmlXIncludeURLPush(xmlXIncludeCtxtPtr ctxt,
316	const xmlChar *value)
317	{
318	if (ctxt->urlNr > XINCLUDE_MAX_DEPTH) {
319	xmlXIncludeErr(ctxt, NULL, XML_XINCLUDE_RECURSION,
320	"detected a recursion in %s\n", value);
321	return(-1);
322	}
323	if (ctxt->urlTab == NULL) {
324	ctxt->urlMax = 4;
325	ctxt->urlNr = 0;
326	ctxt->urlTab = (xmlChar * *) xmlMalloc(
327	ctxt->urlMax * sizeof(ctxt->urlTab[0]));
328	if (ctxt->urlTab == NULL) {
329	xmlXIncludeErrMemory(ctxt, NULL, "adding URL");
330	return (-1);
331	}
332	}
333	if (ctxt->urlNr >= ctxt->urlMax) {
334	ctxt->urlMax *= 2;
335	ctxt->urlTab =
336	(xmlChar * *) xmlRealloc(ctxt->urlTab,
337	ctxt->urlMax *
338	sizeof(ctxt->urlTab[0]));
339	if (ctxt->urlTab == NULL) {
340	xmlXIncludeErrMemory(ctxt, NULL, "adding URL");
341	return (-1);
342	}
343	}
344	ctxt->url = ctxt->urlTab[ctxt->urlNr] = xmlStrdup(value);
345	return (ctxt->urlNr++);
346	}
347
348	/**
349	* xmlXIncludeURLPop:
350	* @ctxt: the parser context
351	*
352	* Pops the top URL from the URL stack
353	*/
354	static void
355	xmlXIncludeURLPop(xmlXIncludeCtxtPtr ctxt)
356	{
357	xmlChar * ret;
358
359	if (ctxt->urlNr <= 0)
360	return;
361	ctxt->urlNr--;
362	if (ctxt->urlNr > 0)
363	ctxt->url = ctxt->urlTab[ctxt->urlNr - 1];
364	else
365	ctxt->url = NULL;
366	ret = ctxt->urlTab[ctxt->urlNr];
367	ctxt->urlTab[ctxt->urlNr] = NULL;
368	if (ret != NULL)
369	xmlFree(ret);
370	}
371
372	/**
373	* xmlXIncludeFreeContext:
374	* @ctxt: the XInclude context
375	*
376	* Free an XInclude context
377	*/
378	void
379	xmlXIncludeFreeContext(xmlXIncludeCtxtPtr ctxt) {
380	int i;
381
382	#ifdef DEBUG_XINCLUDE
383	xmlGenericError(xmlGenericErrorContext, "Freeing context\n");
384	#endif
385	if (ctxt == NULL)
386	return;
387	while (ctxt->urlNr > 0)
388	xmlXIncludeURLPop(ctxt);
389	if (ctxt->urlTab != NULL)
390	xmlFree(ctxt->urlTab);
391	for (i = 0;i < ctxt->incNr;i++) {
392	if (ctxt->incTab[i] != NULL)
393	xmlXIncludeFreeRef(ctxt->incTab[i]);
394	}
395	if (ctxt->txturlTab != NULL) {
396	for (i = 0;i < ctxt->txtNr;i++) {
397	if (ctxt->txturlTab[i] != NULL)
398	xmlFree(ctxt->txturlTab[i]);
399	}
400	}
401	if (ctxt->incTab != NULL)
402	xmlFree(ctxt->incTab);
403	if (ctxt->txtTab != NULL)
404	xmlFree(ctxt->txtTab);
405	if (ctxt->txturlTab != NULL)
406	xmlFree(ctxt->txturlTab);
407	if (ctxt->base != NULL) {
408	xmlFree(ctxt->base);
409	}
410	xmlFree(ctxt);
411	}
412
413	/**
414	* xmlXIncludeParseFile:
415	* @ctxt: the XInclude context
416	* @URL: the URL or file path
417	*
418	* parse a document for XInclude
419	*/
420	static xmlDocPtr
421	xmlXIncludeParseFile(xmlXIncludeCtxtPtr ctxt, const char *URL) {
422	xmlDocPtr ret;
423	xmlParserCtxtPtr pctxt;
424	xmlParserInputPtr inputStream;
425
426	xmlInitParser();
427
428	pctxt = xmlNewParserCtxt();
429	if (pctxt == NULL) {
430	xmlXIncludeErrMemory(ctxt, NULL, "cannot allocate parser context");
431	return(NULL);
432	}
433
434	/*
435	* pass in the application data to the parser context.
436	*/
437	pctxt->_private = ctxt->_private;
438
439	/*
440	* try to ensure that new documents included are actually
441	* built with the same dictionary as the including document.
442	*/
443	if ((ctxt->doc != NULL) && (ctxt->doc->dict != NULL)) {
444	if (pctxt->dict != NULL)
445	xmlDictFree(pctxt->dict);
446	pctxt->dict = ctxt->doc->dict;
447	xmlDictReference(pctxt->dict);
448	}
449
450	xmlCtxtUseOptions(pctxt, ctxt->parseFlags \| XML_PARSE_DTDLOAD);
451
452	inputStream = xmlLoadExternalEntity(URL, NULL, pctxt);
453	if (inputStream == NULL) {
454	xmlFreeParserCtxt(pctxt);
455	return(NULL);
456	}
457
458	inputPush(pctxt, inputStream);
459
460	if (pctxt->directory == NULL)
461	pctxt->directory = xmlParserGetDirectory(URL);
462
463	pctxt->loadsubset \|= XML_DETECT_IDS;
464
465	xmlParseDocument(pctxt);
466
467	if (pctxt->wellFormed) {
468	ret = pctxt->myDoc;
469	}
470	else {
471	ret = NULL;
472	if (pctxt->myDoc != NULL)
473	xmlFreeDoc(pctxt->myDoc);
474	pctxt->myDoc = NULL;
475	}
476	xmlFreeParserCtxt(pctxt);
477
478	return(ret);
479	}
480
481	/**
482	* xmlXIncludeAddNode:
483	* @ctxt: the XInclude context
484	* @cur: the new node
485	*
486	* Add a new node to process to an XInclude context
487	*/
488	static int
489	xmlXIncludeAddNode(xmlXIncludeCtxtPtr ctxt, xmlNodePtr cur) {
490	xmlXIncludeRefPtr ref;
491	xmlURIPtr uri;
492	xmlChar *URL;
493	xmlChar *fragment = NULL;
494	xmlChar *href;
495	xmlChar *parse;
496	xmlChar *base;
497	xmlChar *URI;
498	int xml = 1, i; /* default Issue 64 */
499	int local = 0;
500
501
502	if (ctxt == NULL)
503	return(-1);
504	if (cur == NULL)
505	return(-1);
506
507	#ifdef DEBUG_XINCLUDE
508	xmlGenericError(xmlGenericErrorContext, "Add node\n");
509	#endif
510	/*
511	* read the attributes
512	*/
513	href = xmlXIncludeGetProp(ctxt, cur, XINCLUDE_HREF);
514	if (href == NULL) {
515	href = xmlStrdup(BAD_CAST ""); /* @@@@ href is now optional */
516	if (href == NULL)
517	return(-1);
518	}
519	if ((href[0] == '#') \|\| (href[0] == 0))
520	local = 1;
521	parse = xmlXIncludeGetProp(ctxt, cur, XINCLUDE_PARSE);
522	if (parse != NULL) {
523	if (xmlStrEqual(parse, XINCLUDE_PARSE_XML))
524	xml = 1;
525	else if (xmlStrEqual(parse, XINCLUDE_PARSE_TEXT))
526	xml = 0;
527	else {
528	xmlXIncludeErr(ctxt, cur, XML_XINCLUDE_PARSE_VALUE,
529	"invalid value %s for 'parse'\n", parse);
530	if (href != NULL)
531	xmlFree(href);
532	if (parse != NULL)
533	xmlFree(parse);
534	return(-1);
535	}
536	}
537
538	/*
539	* compute the URI
540	*/
541	base = xmlNodeGetBase(ctxt->doc, cur);
542	if (base == NULL) {
543	URI = xmlBuildURI(href, ctxt->doc->URL);
544	} else {
545	URI = xmlBuildURI(href, base);
546	}
547	if (URI == NULL) {
548	xmlChar *escbase;
549	xmlChar *eschref;
550	/*
551	* Some escaping may be needed
552	*/
553	escbase = xmlURIEscape(base);
554	eschref = xmlURIEscape(href);
555	URI = xmlBuildURI(eschref, escbase);
556	if (escbase != NULL)
557	xmlFree(escbase);
558	if (eschref != NULL)
559	xmlFree(eschref);
560	}
561	if (parse != NULL)
562	xmlFree(parse);
563	if (href != NULL)
564	xmlFree(href);
565	if (base != NULL)
566	xmlFree(base);
567	if (URI == NULL) {
568	xmlXIncludeErr(ctxt, cur, XML_XINCLUDE_HREF_URI,
569	"failed build URL\n", NULL);
570	return(-1);
571	}
572	fragment = xmlXIncludeGetProp(ctxt, cur, XINCLUDE_PARSE_XPOINTER);
573
574	/*
575	* Check the URL and remove any fragment identifier
576	*/
577	uri = xmlParseURI((const char *)URI);
578	if (uri == NULL) {
579	xmlXIncludeErr(ctxt, cur, XML_XINCLUDE_HREF_URI,
580	"invalid value URI %s\n", URI);
581	if (fragment != NULL)
582	xmlFree(fragment);
583	xmlFree(URI);
584	return(-1);
585	}
586
587	if (uri->fragment != NULL) {
588	if (ctxt->legacy != 0) {
589	if (fragment == NULL) {
590	fragment = (xmlChar *) uri->fragment;
591	} else {
592	xmlFree(uri->fragment);
593	}
594	} else {
595	xmlXIncludeErr(ctxt, cur, XML_XINCLUDE_FRAGMENT_ID,
596	"Invalid fragment identifier in URI %s use the xpointer attribute\n",
597	URI);
598	if (fragment != NULL)
599	xmlFree(fragment);
600	xmlFreeURI(uri);
601	xmlFree(URI);
602	return(-1);
603	}
604	uri->fragment = NULL;
605	}
606	URL = xmlSaveUri(uri);
607	xmlFreeURI(uri);
608	xmlFree(URI);
609	if (URL == NULL) {
610	xmlXIncludeErr(ctxt, cur, XML_XINCLUDE_HREF_URI,
611	"invalid value URI %s\n", URI);
612	if (fragment != NULL)
613	xmlFree(fragment);
614	return(-1);
615	}
616
617	/*
618	* If local and xml then we need a fragment
619	*/
620	if ((local == 1) && (xml == 1) &&
621	((fragment == NULL) \|\| (fragment[0] == 0))) {
622	xmlXIncludeErr(ctxt, cur, XML_XINCLUDE_RECURSION,
623	"detected a local recursion with no xpointer in %s\n",
624	URL);
625	if (fragment != NULL)
626	xmlFree(fragment);
627	return(-1);
628	}
629
630	/*
631	* Check the URL against the stack for recursions
632	*/
633	if ((!local) && (xml == 1)) {
634	for (i = 0;i < ctxt->urlNr;i++) {
635	if (xmlStrEqual(URL, ctxt->urlTab[i])) {
636	xmlXIncludeErr(ctxt, cur, XML_XINCLUDE_RECURSION,
637	"detected a recursion in %s\n", URL);
638	return(-1);
639	}
640	}
641	}
642
643	ref = xmlXIncludeNewRef(ctxt, URL, cur);
644	if (ref == NULL) {
645	return(-1);
646	}
647	ref->fragment = fragment;
648	ref->doc = NULL;
649	ref->xml = xml;
650	ref->count = 1;
651	xmlFree(URL);
652	return(0);
653	}
654
655	/**
656	* xmlXIncludeRecurseDoc:
657	* @ctxt: the XInclude context
658	* @doc: the new document
659	* @url: the associated URL
660	*
661	* The XInclude recursive nature is handled at this point.
662	*/
663	static void
664	xmlXIncludeRecurseDoc(xmlXIncludeCtxtPtr ctxt, xmlDocPtr doc,
665	const xmlURL url ATTRIBUTE_UNUSED) {
666	xmlXIncludeCtxtPtr newctxt;
667	int i;
668
669	/*
670	* Avoid recursion in already substitued resources
671	for (i = 0;i < ctxt->urlNr;i++) {
672	if (xmlStrEqual(doc->URL, ctxt->urlTab[i]))
673	return;
674	}
675	*/
676
677	#ifdef DEBUG_XINCLUDE
678	xmlGenericError(xmlGenericErrorContext, "Recursing in doc %s\n", doc->URL);
679	#endif
680	/*
681	* Handle recursion here.
682	*/
683
684	newctxt = xmlXIncludeNewContext(doc);
685	if (newctxt != NULL) {
686	/*
687	* Copy the private user data
688	*/
689	newctxt->_private = ctxt->_private;
690	/*
691	* Copy the existing document set
692	*/
693	newctxt->incMax = ctxt->incMax;
694	newctxt->incNr = ctxt->incNr;
695	newctxt->incTab = (xmlXIncludeRefPtr ) xmlMalloc(newctxt->incMax
696	sizeof(newctxt->incTab[0]));
697	if (newctxt->incTab == NULL) {
698	xmlXIncludeErrMemory(ctxt, (xmlNodePtr) doc, "processing doc");
699	xmlFree(newctxt);
700	return;
701	}
702	/*
703	* copy the urlTab
704	*/
705	newctxt->urlMax = ctxt->urlMax;
706	newctxt->urlNr = ctxt->urlNr;
707	newctxt->urlTab = ctxt->urlTab;
708
709	/*
710	* Inherit the existing base
711	*/
712	newctxt->base = xmlStrdup(ctxt->base);
713
714	/*
715	* Inherit the documents already in use by other includes
716	*/
717	newctxt->incBase = ctxt->incNr;
718	for (i = 0;i < ctxt->incNr;i++) {
719	newctxt->incTab[i] = ctxt->incTab[i];
720	newctxt->incTab[i]->count++; /* prevent the recursion from
721	freeing it */
722	}
723	/*
724	* The new context should also inherit the Parse Flags
725	* (bug 132597)
726	*/
727	newctxt->parseFlags = ctxt->parseFlags;
728	xmlXIncludeDoProcess(newctxt, doc, xmlDocGetRootElement(doc));
729	for (i = 0;i < ctxt->incNr;i++) {
730	newctxt->incTab[i]->count--;
731	newctxt->incTab[i] = NULL;
732	}
733
734	/* urlTab may have been reallocated */
735	ctxt->urlTab = newctxt->urlTab;
736	ctxt->urlMax = newctxt->urlMax;
737
738	newctxt->urlMax = 0;
739	newctxt->urlNr = 0;
740	newctxt->urlTab = NULL;
741
742	xmlXIncludeFreeContext(newctxt);
743	}
744	#ifdef DEBUG_XINCLUDE
745	xmlGenericError(xmlGenericErrorContext, "Done recursing in doc %s\n", url);
746	#endif
747	}
748
749	/**
750	* xmlXIncludeAddTxt:
751	* @ctxt: the XInclude context
752	* @txt: the new text node
753	* @url: the associated URL
754	*
755	* Add a new txtument to the list
756	*/
757	static void
758	xmlXIncludeAddTxt(xmlXIncludeCtxtPtr ctxt, xmlNodePtr txt, const xmlURL url) {
759	#ifdef DEBUG_XINCLUDE
760	xmlGenericError(xmlGenericErrorContext, "Adding text %s\n", url);
761	#endif
762	if (ctxt->txtMax == 0) {
763	ctxt->txtMax = 4;
764	ctxt->txtTab = (xmlNodePtr ) xmlMalloc(ctxt->txtMax
765	sizeof(ctxt->txtTab[0]));
766	if (ctxt->txtTab == NULL) {
767	xmlXIncludeErrMemory(ctxt, NULL, "processing text");
768	return;
769	}
770	ctxt->txturlTab = (xmlURL ) xmlMalloc(ctxt->txtMax
771	sizeof(ctxt->txturlTab[0]));
772	if (ctxt->txturlTab == NULL) {
773	xmlXIncludeErrMemory(ctxt, NULL, "processing text");
774	return;
775	}
776	}
777	if (ctxt->txtNr >= ctxt->txtMax) {
778	ctxt->txtMax *= 2;
779	ctxt->txtTab = (xmlNodePtr *) xmlRealloc(ctxt->txtTab,
780	ctxt->txtMax * sizeof(ctxt->txtTab[0]));
781	if (ctxt->txtTab == NULL) {
782	xmlXIncludeErrMemory(ctxt, NULL, "processing text");
783	return;
784	}
785	ctxt->txturlTab = (xmlURL *) xmlRealloc(ctxt->txturlTab,
786	ctxt->txtMax * sizeof(ctxt->txturlTab[0]));
787	if (ctxt->txturlTab == NULL) {
788	xmlXIncludeErrMemory(ctxt, NULL, "processing text");
789	return;
790	}
791	}
792	ctxt->txtTab[ctxt->txtNr] = txt;
793	ctxt->txturlTab[ctxt->txtNr] = xmlStrdup(url);
794	ctxt->txtNr++;
795	}
796
797	/************************************************************************
798	* *
799	* Node copy with specific semantic *
800	* *
801	************************************************************************/
802
803	static xmlNodePtr
804	xmlXIncludeCopyNodeList(xmlXIncludeCtxtPtr ctxt, xmlDocPtr target,
805	xmlDocPtr source, xmlNodePtr elem);
806
807	/**
808	* xmlXIncludeCopyNode:
809	* @ctxt: the XInclude context
810	* @target: the document target
811	* @source: the document source
812	* @elem: the element
813	*
814	* Make a copy of the node while preserving the XInclude semantic
815	* of the Infoset copy
816	*/
817	static xmlNodePtr
818	xmlXIncludeCopyNode(xmlXIncludeCtxtPtr ctxt, xmlDocPtr target,
819	xmlDocPtr source, xmlNodePtr elem) {
820	xmlNodePtr result = NULL;
821
822	if ((ctxt == NULL) \|\| (target == NULL) \|\| (source == NULL) \|\|
823	(elem == NULL))
824	return(NULL);
825	if (elem->type == XML_DTD_NODE)
826	return(NULL);
827	if (elem->type == XML_DOCUMENT_NODE)
828	result = xmlXIncludeCopyNodeList(ctxt, target, source, elem->children);
829	else
830	result = xmlDocCopyNode(elem, target, 1);
831	return(result);
832	}
833
834	/**
835	* xmlXIncludeCopyNodeList:
836	* @ctxt: the XInclude context
837	* @target: the document target
838	* @source: the document source
839	* @elem: the element list
840	*
841	* Make a copy of the node list while preserving the XInclude semantic
842	* of the Infoset copy
843	*/
844	static xmlNodePtr
845	xmlXIncludeCopyNodeList(xmlXIncludeCtxtPtr ctxt, xmlDocPtr target,
846	xmlDocPtr source, xmlNodePtr elem) {
847	xmlNodePtr cur, res, result = NULL, last = NULL;
848
849	if ((ctxt == NULL) \|\| (target == NULL) \|\| (source == NULL) \|\|
850	(elem == NULL))
851	return(NULL);
852	cur = elem;
853	while (cur != NULL) {
854	res = xmlXIncludeCopyNode(ctxt, target, source, cur);
855	if (res != NULL) {
856	if (result == NULL) {
857	result = last = res;
858	} else {
859	last->next = res;
860	res->prev = last;
861	last = res;
862	}
863	}
864	cur = cur->next;
865	}
866	return(result);
867	}
868
869	/**
870	* xmlXIncludeGetNthChild:
871	* @cur: the node
872	* @no: the child number
873	*
874	* Returns the @n'th element child of @cur or NULL
875	*/
876	static xmlNodePtr
877	xmlXIncludeGetNthChild(xmlNodePtr cur, int no) {
878	int i;
879	if ((cur == NULL) \|\| (cur->type == XML_NAMESPACE_DECL))
880	return(NULL);
881	cur = cur->children;
882	for (i = 0;i <= no;cur = cur->next) {
883	if (cur == NULL)
884	return(cur);
885	if ((cur->type == XML_ELEMENT_NODE) \|\|
886	(cur->type == XML_DOCUMENT_NODE) \|\|
887	(cur->type == XML_HTML_DOCUMENT_NODE)) {
888	i++;
889	if (i == no)
890	break;
891	}
892	}
893	return(cur);
894	}
895
896	xmlNodePtr xmlXPtrAdvanceNode(xmlNodePtr cur, int level); / in xpointer.c */
897	/**
898	* xmlXIncludeCopyRange:
899	* @ctxt: the XInclude context
900	* @target: the document target
901	* @source: the document source
902	* @obj: the XPointer result from the evaluation.
903	*
904	* Build a node list tree copy of the XPointer result.
905	*
906	* Returns an xmlNodePtr list or NULL.
907	* The caller has to free the node tree.
908	*/
909	static xmlNodePtr
910	xmlXIncludeCopyRange(xmlXIncludeCtxtPtr ctxt, xmlDocPtr target,
911	xmlDocPtr source, xmlXPathObjectPtr range) {
912	/* pointers to generated nodes */
913	xmlNodePtr list = NULL, last = NULL, listParent = NULL;
914	xmlNodePtr tmp, tmp2;
915	/* pointers to traversal nodes */
916	xmlNodePtr start, cur, end;
917	int index1, index2;
918	int level = 0, lastLevel = 0, endLevel = 0, endFlag = 0;
919
920	if ((ctxt == NULL) \|\| (target == NULL) \|\| (source == NULL) \|\|
921	(range == NULL))
922	return(NULL);
923	if (range->type != XPATH_RANGE)
924	return(NULL);
925	start = (xmlNodePtr) range->user;
926
927	if ((start == NULL) \|\| (start->type == XML_NAMESPACE_DECL))
928	return(NULL);
929	end = range->user2;
930	if (end == NULL)
931	return(xmlDocCopyNode(start, target, 1));
932	if (end->type == XML_NAMESPACE_DECL)
933	return(NULL);
934
935	cur = start;
936	index1 = range->index;
937	index2 = range->index2;
938	/*
939	* level is depth of the current node under consideration
940	* list is the pointer to the root of the output tree
941	* listParent is a pointer to the parent of output tree (within
942	the included file) in case we need to add another level
943	* last is a pointer to the last node added to the output tree
944	* lastLevel is the depth of last (relative to the root)
945	*/
946	while (cur != NULL) {
947	/*
948	* Check if our output tree needs a parent
949	*/
950	if (level < 0) {
951	while (level < 0) {
952	/* copy must include namespaces and properties */
953	tmp2 = xmlDocCopyNode(listParent, target, 2);
954	xmlAddChild(tmp2, list);
955	list = tmp2;
956	listParent = listParent->parent;
957	level++;
958	}
959	last = list;
960	lastLevel = 0;
961	}
962	/*
963	* Check whether we need to change our insertion point
964	*/
965	while (level < lastLevel) {
966	last = last->parent;
967	lastLevel --;
968	}
969	if (cur == end) { /* Are we at the end of the range? */
970	if (cur->type == XML_TEXT_NODE) {
971	const xmlChar *content = cur->content;
972	int len;
973
974	if (content == NULL) {
975	tmp = xmlNewTextLen(NULL, 0);
976	} else {
977	len = index2;
978	if ((cur == start) && (index1 > 1)) {
979	content += (index1 - 1);
980	len -= (index1 - 1);
981	} else {
982	len = index2;
983	}
984	tmp = xmlNewTextLen(content, len);
985	}
986	/* single sub text node selection */
987	if (list == NULL)
988	return(tmp);
989	/* prune and return full set */
990	if (level == lastLevel)
991	xmlAddNextSibling(last, tmp);
992	else
993	xmlAddChild(last, tmp);
994	return(list);
995	} else { /* ending node not a text node */
996	endLevel = level; /* remember the level of the end node */
997	endFlag = 1;
998	/* last node - need to take care of properties + namespaces */
999	tmp = xmlDocCopyNode(cur, target, 2);
1000	if (list == NULL) {
1001	list = tmp;
1002	listParent = cur->parent;
1003	} else {
1004	if (level == lastLevel)
1005	xmlAddNextSibling(last, tmp);
1006	else {
1007	xmlAddChild(last, tmp);
1008	lastLevel = level;
1009	}
1010	}
1011	last = tmp;
1012
1013	if (index2 > 1) {
1014	end = xmlXIncludeGetNthChild(cur, index2 - 1);
1015	index2 = 0;
1016	}
1017	if ((cur == start) && (index1 > 1)) {
1018	cur = xmlXIncludeGetNthChild(cur, index1 - 1);
1019	index1 = 0;
1020	} else {
1021	cur = cur->children;
1022	}
1023	level++; /* increment level to show change */
1024	/*
1025	* Now gather the remaining nodes from cur to end
1026	*/
1027	continue; /* while */
1028	}
1029	} else if (cur == start) { /* Not at the end, are we at start? */
1030	if ((cur->type == XML_TEXT_NODE) \|\|
1031	(cur->type == XML_CDATA_SECTION_NODE)) {
1032	const xmlChar *content = cur->content;
1033
1034	if (content == NULL) {
1035	tmp = xmlNewTextLen(NULL, 0);
1036	} else {
1037	if (index1 > 1) {
1038	content += (index1 - 1);
1039	index1 = 0;
1040	}
1041	tmp = xmlNewText(content);
1042	}
1043	last = list = tmp;
1044	listParent = cur->parent;
1045	} else { /* Not text node */
1046	/*
1047	* start of the range - need to take care of
1048	* properties and namespaces
1049	*/
1050	tmp = xmlDocCopyNode(cur, target, 2);
1051	list = last = tmp;
1052	listParent = cur->parent;
1053	if (index1 > 1) { /* Do we need to position? */
1054	cur = xmlXIncludeGetNthChild(cur, index1 - 1);
1055	level = lastLevel = 1;
1056	index1 = 0;
1057	/*
1058	* Now gather the remaining nodes from cur to end
1059	*/
1060	continue; /* while */
1061	}
1062	}
1063	} else {
1064	tmp = NULL;
1065	switch (cur->type) {
1066	case XML_DTD_NODE:
1067	case XML_ELEMENT_DECL:
1068	case XML_ATTRIBUTE_DECL:
1069	case XML_ENTITY_NODE:
1070	/* Do not copy DTD informations */
1071	break;
1072	case XML_ENTITY_DECL:
1073	/* handle crossing entities -> stack needed */
1074	break;
1075	case XML_XINCLUDE_START:
1076	case XML_XINCLUDE_END:
1077	/* don't consider it part of the tree content */
1078	break;
1079	case XML_ATTRIBUTE_NODE:
1080	/* Humm, should not happen ! */
1081	break;
1082	default:
1083	/*
1084	* Middle of the range - need to take care of
1085	* properties and namespaces
1086	*/
1087	tmp = xmlDocCopyNode(cur, target, 2);
1088	break;
1089	}
1090	if (tmp != NULL) {
1091	if (level == lastLevel)
1092	xmlAddNextSibling(last, tmp);
1093	else {
1094	xmlAddChild(last, tmp);
1095	lastLevel = level;
1096	}
1097	last = tmp;
1098	}
1099	}
1100	/*
1101	* Skip to next node in document order
1102	*/
1103	cur = xmlXPtrAdvanceNode(cur, &level);
1104	if (endFlag && (level >= endLevel))
1105	break;
1106	}
1107	return(list);
1108	}
1109
1110	/**
1111	* xmlXIncludeBuildNodeList:
1112	* @ctxt: the XInclude context
1113	* @target: the document target
1114	* @source: the document source
1115	* @obj: the XPointer result from the evaluation.
1116	*
1117	* Build a node list tree copy of the XPointer result.
1118	* This will drop Attributes and Namespace declarations.
1119	*
1120	* Returns an xmlNodePtr list or NULL.
1121	* the caller has to free the node tree.
1122	*/
1123	static xmlNodePtr
1124	xmlXIncludeCopyXPointer(xmlXIncludeCtxtPtr ctxt, xmlDocPtr target,
1125	xmlDocPtr source, xmlXPathObjectPtr obj) {
1126	xmlNodePtr list = NULL, last = NULL;
1127	int i;
1128
1129	if (source == NULL)
1130	source = ctxt->doc;
1131	if ((ctxt == NULL) \|\| (target == NULL) \|\| (source == NULL) \|\|
1132	(obj == NULL))
1133	return(NULL);
1134	switch (obj->type) {
1135	case XPATH_NODESET: {
1136	xmlNodeSetPtr set = obj->nodesetval;
1137	if (set == NULL)
1138	return(NULL);
1139	for (i = 0;i < set->nodeNr;i++) {
1140	if (set->nodeTab[i] == NULL)
1141	continue;
1142	switch (set->nodeTab[i]->type) {
1143	case XML_TEXT_NODE:
1144	case XML_CDATA_SECTION_NODE:
1145	case XML_ELEMENT_NODE:
1146	case XML_ENTITY_REF_NODE:
1147	case XML_ENTITY_NODE:
1148	case XML_PI_NODE:
1149	case XML_COMMENT_NODE:
1150	case XML_DOCUMENT_NODE:
1151	case XML_HTML_DOCUMENT_NODE:
1152	#ifdef LIBXML_DOCB_ENABLED
1153	case XML_DOCB_DOCUMENT_NODE:
1154	#endif
1155	case XML_XINCLUDE_END:
1156	break;
1157	case XML_XINCLUDE_START: {
1158	xmlNodePtr tmp, cur = set->nodeTab[i];
1159
1160	cur = cur->next;
1161	while (cur != NULL) {
1162	switch(cur->type) {
1163	case XML_TEXT_NODE:
1164	case XML_CDATA_SECTION_NODE:
1165	case XML_ELEMENT_NODE:
1166	case XML_ENTITY_REF_NODE:
1167	case XML_ENTITY_NODE:
1168	case XML_PI_NODE:
1169	case XML_COMMENT_NODE:
1170	tmp = xmlXIncludeCopyNode(ctxt, target,
1171	source, cur);
1172	if (last == NULL) {
1173	list = last = tmp;
1174	} else {
1175	xmlAddNextSibling(last, tmp);
1176	last = tmp;
1177	}
1178	cur = cur->next;
1179	continue;
1180	default:
1181	break;
1182	}
1183	break;
1184	}
1185	continue;
1186	}
1187	case XML_ATTRIBUTE_NODE:
1188	case XML_NAMESPACE_DECL:
1189	case XML_DOCUMENT_TYPE_NODE:
1190	case XML_DOCUMENT_FRAG_NODE:
1191	case XML_NOTATION_NODE:
1192	case XML_DTD_NODE:
1193	case XML_ELEMENT_DECL:
1194	case XML_ATTRIBUTE_DECL:
1195	case XML_ENTITY_DECL:
1196	continue; /* for */
1197	}
1198	if (last == NULL)
1199	list = last = xmlXIncludeCopyNode(ctxt, target, source,
1200	set->nodeTab[i]);
1201	else {
1202	xmlAddNextSibling(last,
1203	xmlXIncludeCopyNode(ctxt, target, source,
1204	set->nodeTab[i]));
1205	if (last->next != NULL)
1206	last = last->next;
1207	}
1208	}
1209	break;
1210	}
1211	#ifdef LIBXML_XPTR_ENABLED
1212	case XPATH_LOCATIONSET: {
1213	xmlLocationSetPtr set = (xmlLocationSetPtr) obj->user;
1214	if (set == NULL)
1215	return(NULL);
1216	for (i = 0;i < set->locNr;i++) {
1217	if (last == NULL)
1218	list = last = xmlXIncludeCopyXPointer(ctxt, target, source,
1219	set->locTab[i]);
1220	else
1221	xmlAddNextSibling(last,
1222	xmlXIncludeCopyXPointer(ctxt, target, source,
1223	set->locTab[i]));
1224	if (last != NULL) {
1225	while (last->next != NULL)
1226	last = last->next;
1227	}
1228	}
1229	break;
1230	}
1231	case XPATH_RANGE:
1232	return(xmlXIncludeCopyRange(ctxt, target, source, obj));
1233	#endif
1234	case XPATH_POINT:
1235	/* points are ignored in XInclude */
1236	break;
1237	default:
1238	break;
1239	}
1240	return(list);
1241	}
1242	/************************************************************************
1243	* *
1244	* XInclude I/O handling *
1245	* *
1246	************************************************************************/
1247
1248	typedef struct _xmlXIncludeMergeData xmlXIncludeMergeData;
1249	typedef xmlXIncludeMergeData *xmlXIncludeMergeDataPtr;
1250	struct _xmlXIncludeMergeData {
1251	xmlDocPtr doc;
1252	xmlXIncludeCtxtPtr ctxt;
1253	};
1254
1255	/**
1256	* xmlXIncludeMergeOneEntity:
1257	* @ent: the entity
1258	* @doc: the including doc
1259	* @nr: the entity name
1260	*
1261	* Inplements the merge of one entity
1262	*/
1263	static void
1264	xmlXIncludeMergeEntity(xmlEntityPtr ent, xmlXIncludeMergeDataPtr data,
1265	xmlChar *name ATTRIBUTE_UNUSED) {
1266	xmlEntityPtr ret, prev;
1267	xmlDocPtr doc;
1268	xmlXIncludeCtxtPtr ctxt;
1269
1270	if ((ent == NULL) \|\| (data == NULL))
1271	return;
1272	ctxt = data->ctxt;
1273	doc = data->doc;
1274	if ((ctxt == NULL) \|\| (doc == NULL))
1275	return;
1276	switch (ent->etype) {
1277	case XML_INTERNAL_PARAMETER_ENTITY:
1278	case XML_EXTERNAL_PARAMETER_ENTITY:
1279	case XML_INTERNAL_PREDEFINED_ENTITY:
1280	return;
1281	case XML_INTERNAL_GENERAL_ENTITY:
1282	case XML_EXTERNAL_GENERAL_PARSED_ENTITY:
1283	case XML_EXTERNAL_GENERAL_UNPARSED_ENTITY:
1284	break;
1285	}
1286	ret = xmlAddDocEntity(doc, ent->name, ent->etype, ent->ExternalID,
1287	ent->SystemID, ent->content);
1288	if (ret != NULL) {
1289	if (ent->URI != NULL)
1290	ret->URI = xmlStrdup(ent->URI);
1291	} else {
1292	prev = xmlGetDocEntity(doc, ent->name);
1293	if (prev != NULL) {
1294	if (ent->etype != prev->etype)
1295	goto error;
1296
1297	if ((ent->SystemID != NULL) && (prev->SystemID != NULL)) {
1298	if (!xmlStrEqual(ent->SystemID, prev->SystemID))
1299	goto error;
1300	} else if ((ent->ExternalID != NULL) &&
1301	(prev->ExternalID != NULL)) {
1302	if (!xmlStrEqual(ent->ExternalID, prev->ExternalID))
1303	goto error;
1304	} else if ((ent->content != NULL) && (prev->content != NULL)) {
1305	if (!xmlStrEqual(ent->content, prev->content))
1306	goto error;
1307	} else {
1308	goto error;
1309	}
1310
1311	}
1312	}
1313	return;
1314	error:
1315	switch (ent->etype) {
1316	case XML_INTERNAL_PARAMETER_ENTITY:
1317	case XML_EXTERNAL_PARAMETER_ENTITY:
1318	case XML_INTERNAL_PREDEFINED_ENTITY:
1319	case XML_INTERNAL_GENERAL_ENTITY:
1320	case XML_EXTERNAL_GENERAL_PARSED_ENTITY:
1321	return;
1322	case XML_EXTERNAL_GENERAL_UNPARSED_ENTITY:
1323	break;
1324	}
1325	xmlXIncludeErr(ctxt, (xmlNodePtr) ent, XML_XINCLUDE_ENTITY_DEF_MISMATCH,
1326	"mismatch in redefinition of entity %s\n",
1327	ent->name);
1328	}
1329
1330	/**
1331	* xmlXIncludeMergeEntities:
1332	* @ctxt: an XInclude context
1333	* @doc: the including doc
1334	* @from: the included doc
1335	*
1336	* Inplements the entity merge
1337	*
1338	* Returns 0 if merge succeeded, -1 if some processing failed
1339	*/
1340	static int
1341	xmlXIncludeMergeEntities(xmlXIncludeCtxtPtr ctxt, xmlDocPtr doc,
1342	xmlDocPtr from) {
1343	xmlNodePtr cur;
1344	xmlDtdPtr target, source;
1345
1346	if (ctxt == NULL)
1347	return(-1);
1348
1349	if ((from == NULL) \|\| (from->intSubset == NULL))
1350	return(0);
1351
1352	target = doc->intSubset;
1353	if (target == NULL) {
1354	cur = xmlDocGetRootElement(doc);
1355	if (cur == NULL)
1356	return(-1);
1357	target = xmlCreateIntSubset(doc, cur->name, NULL, NULL);
1358	if (target == NULL)
1359	return(-1);
1360	}
1361
1362	source = from->intSubset;
1363	if ((source != NULL) && (source->entities != NULL)) {
1364	xmlXIncludeMergeData data;
1365
1366	data.ctxt = ctxt;
1367	data.doc = doc;
1368
1369	xmlHashScan((xmlHashTablePtr) source->entities,
1370	(xmlHashScanner) xmlXIncludeMergeEntity, &data);
1371	}
1372	source = from->extSubset;
1373	if ((source != NULL) && (source->entities != NULL)) {
1374	xmlXIncludeMergeData data;
1375
1376	data.ctxt = ctxt;
1377	data.doc = doc;
1378
1379	/*
1380	* don't duplicate existing stuff when external subsets are the same
1381	*/
1382	if ((!xmlStrEqual(target->ExternalID, source->ExternalID)) &&
1383	(!xmlStrEqual(target->SystemID, source->SystemID))) {
1384	xmlHashScan((xmlHashTablePtr) source->entities,
1385	(xmlHashScanner) xmlXIncludeMergeEntity, &data);
1386	}
1387	}
1388	return(0);
1389	}
1390
1391	/**
1392	* xmlXIncludeLoadDoc:
1393	* @ctxt: the XInclude context
1394	* @url: the associated URL
1395	* @nr: the xinclude node number
1396	*
1397	* Load the document, and store the result in the XInclude context
1398	*
1399	* Returns 0 in case of success, -1 in case of failure
1400	*/
1401	static int
1402	xmlXIncludeLoadDoc(xmlXIncludeCtxtPtr ctxt, const xmlChar *url, int nr) {
1403	xmlDocPtr doc;
1404	xmlURIPtr uri;
1405	xmlChar *URL;
1406	xmlChar *fragment = NULL;
1407	int i = 0;
1408	#ifdef LIBXML_XPTR_ENABLED
1409	int saveFlags;
1410	#endif
1411
1412	#ifdef DEBUG_XINCLUDE
1413	xmlGenericError(xmlGenericErrorContext, "Loading doc %s:%d\n", url, nr);
1414	#endif
1415	/*
1416	* Check the URL and remove any fragment identifier
1417	*/
1418	uri = xmlParseURI((const char *)url);
1419	if (uri == NULL) {
1420	xmlXIncludeErr(ctxt, ctxt->incTab[nr]->ref,
1421	XML_XINCLUDE_HREF_URI,
1422	"invalid value URI %s\n", url);
1423	return(-1);
1424	}
1425	if (uri->fragment != NULL) {
1426	fragment = (xmlChar *) uri->fragment;
1427	uri->fragment = NULL;
1428	}
1429	if ((ctxt->incTab != NULL) && (ctxt->incTab[nr] != NULL) &&
1430	(ctxt->incTab[nr]->fragment != NULL)) {
1431	if (fragment != NULL) xmlFree(fragment);
1432	fragment = xmlStrdup(ctxt->incTab[nr]->fragment);
1433	}
1434	URL = xmlSaveUri(uri);
1435	xmlFreeURI(uri);
1436	if (URL == NULL) {
1437	if (ctxt->incTab != NULL)
1438	xmlXIncludeErr(ctxt, ctxt->incTab[nr]->ref,
1439	XML_XINCLUDE_HREF_URI,
1440	"invalid value URI %s\n", url);
1441	else
1442	xmlXIncludeErr(ctxt, NULL,
1443	XML_XINCLUDE_HREF_URI,
1444	"invalid value URI %s\n", url);
1445	if (fragment != NULL)
1446	xmlFree(fragment);
1447	return(-1);
1448	}
1449
1450	/*
1451	* Handling of references to the local document are done
1452	* directly through ctxt->doc.
1453	*/
1454	if ((URL[0] == 0) \|\| (URL[0] == '#') \|\|
1455	((ctxt->doc != NULL) && (xmlStrEqual(URL, ctxt->doc->URL)))) {
1456	doc = NULL;
1457	goto loaded;
1458	}
1459
1460	/*
1461	* Prevent reloading twice the document.
1462	*/
1463	for (i = 0; i < ctxt->incNr; i++) {
1464	if ((xmlStrEqual(URL, ctxt->incTab[i]->URI)) &&
1465	(ctxt->incTab[i]->doc != NULL)) {
1466	doc = ctxt->incTab[i]->doc;
1467	#ifdef DEBUG_XINCLUDE
1468	printf("Already loaded %s\n", URL);
1469	#endif
1470	goto loaded;
1471	}
1472	}
1473
1474	/*
1475	* Load it.
1476	*/
1477	#ifdef DEBUG_XINCLUDE
1478	printf("loading %s\n", URL);
1479	#endif
1480	#ifdef LIBXML_XPTR_ENABLED
1481	/*
1482	* If this is an XPointer evaluation, we want to assure that
1483	* all entities have been resolved prior to processing the
1484	* referenced document
1485	*/
1486	saveFlags = ctxt->parseFlags;
1487	if (fragment != NULL) { /* if this is an XPointer eval */
1488	ctxt->parseFlags \|= XML_PARSE_NOENT;
1489	}
1490	#endif
1491
1492	doc = xmlXIncludeParseFile(ctxt, (const char *)URL);
1493	#ifdef LIBXML_XPTR_ENABLED
1494	ctxt->parseFlags = saveFlags;
1495	#endif
1496	if (doc == NULL) {
1497	xmlFree(URL);
1498	if (fragment != NULL)
1499	xmlFree(fragment);
1500	return(-1);
1501	}
1502	ctxt->incTab[nr]->doc = doc;
1503	/*
1504	* It's possible that the requested URL has been mapped to a
1505	* completely different location (e.g. through a catalog entry).
1506	* To check for this, we compare the URL with that of the doc
1507	* and change it if they disagree (bug 146988).
1508	*/
1509	if (!xmlStrEqual(URL, doc->URL)) {
1510	xmlFree(URL);
1511	URL = xmlStrdup(doc->URL);
1512	}
1513	for (i = nr + 1; i < ctxt->incNr; i++) {
1514	if (xmlStrEqual(URL, ctxt->incTab[i]->URI)) {
1515	ctxt->incTab[nr]->count++;
1516	#ifdef DEBUG_XINCLUDE
1517	printf("Increasing %s count since reused\n", URL);
1518	#endif
1519	break;
1520	}
1521	}
1522
1523	/*
1524	* Make sure we have all entities fixed up
1525	*/
1526	xmlXIncludeMergeEntities(ctxt, ctxt->doc, doc);
1527
1528	/*
1529	* We don't need the DTD anymore, free up space
1530	if (doc->intSubset != NULL) {
1531	xmlUnlinkNode((xmlNodePtr) doc->intSubset);
1532	xmlFreeNode((xmlNodePtr) doc->intSubset);
1533	doc->intSubset = NULL;
1534	}
1535	if (doc->extSubset != NULL) {
1536	xmlUnlinkNode((xmlNodePtr) doc->extSubset);
1537	xmlFreeNode((xmlNodePtr) doc->extSubset);
1538	doc->extSubset = NULL;
1539	}
1540	*/
1541	xmlXIncludeRecurseDoc(ctxt, doc, URL);
1542
1543	loaded:
1544	if (fragment == NULL) {
1545	/*
1546	* Add the top children list as the replacement copy.
1547	*/
1548	if (doc == NULL)
1549	{
1550	/* Hopefully a DTD declaration won't be copied from
1551	* the same document */
1552	ctxt->incTab[nr]->inc = xmlCopyNodeList(ctxt->doc->children);
1553	} else {
1554	ctxt->incTab[nr]->inc = xmlXIncludeCopyNodeList(ctxt, ctxt->doc,
1555	doc, doc->children);
1556	}
1557	}
1558	#ifdef LIBXML_XPTR_ENABLED
1559	else {
1560	/*
1561	* Computes the XPointer expression and make a copy used
1562	* as the replacement copy.
1563	*/
1564	xmlXPathObjectPtr xptr;
1565	xmlXPathContextPtr xptrctxt;
1566	xmlNodeSetPtr set;
1567
1568	if (doc == NULL) {
1569	xptrctxt = xmlXPtrNewContext(ctxt->doc, ctxt->incTab[nr]->ref,
1570	NULL);
1571	} else {
1572	xptrctxt = xmlXPtrNewContext(doc, NULL, NULL);
1573	}
1574	if (xptrctxt == NULL) {
1575	xmlXIncludeErr(ctxt, ctxt->incTab[nr]->ref,
1576	XML_XINCLUDE_XPTR_FAILED,
1577	"could not create XPointer context\n", NULL);
1578	xmlFree(URL);
1579	xmlFree(fragment);
1580	return(-1);
1581	}
1582	xptr = xmlXPtrEval(fragment, xptrctxt);
1583	if (xptr == NULL) {
1584	xmlXIncludeErr(ctxt, ctxt->incTab[nr]->ref,
1585	XML_XINCLUDE_XPTR_FAILED,
1586	"XPointer evaluation failed: #%s\n",
1587	fragment);
1588	xmlXPathFreeContext(xptrctxt);
1589	xmlFree(URL);
1590	xmlFree(fragment);
1591	return(-1);
1592	}
1593	switch (xptr->type) {
1594	case XPATH_UNDEFINED:
1595	case XPATH_BOOLEAN:
1596	case XPATH_NUMBER:
1597	case XPATH_STRING:
1598	case XPATH_POINT:
1599	case XPATH_USERS:
1600	case XPATH_XSLT_TREE:
1601	xmlXIncludeErr(ctxt, ctxt->incTab[nr]->ref,
1602	XML_XINCLUDE_XPTR_RESULT,
1603	"XPointer is not a range: #%s\n",
1604	fragment);
1605	xmlXPathFreeContext(xptrctxt);
1606	xmlFree(URL);
1607	xmlFree(fragment);
1608	return(-1);
1609	case XPATH_NODESET:
1610	if ((xptr->nodesetval == NULL) \|\|
1611	(xptr->nodesetval->nodeNr <= 0)) {
1612	xmlXPathFreeContext(xptrctxt);
1613	xmlFree(URL);
1614	xmlFree(fragment);
1615	return(-1);
1616	}
1617
1618	case XPATH_RANGE:
1619	case XPATH_LOCATIONSET:
1620	break;
1621	}
1622	set = xptr->nodesetval;
1623	if (set != NULL) {
1624	for (i = 0;i < set->nodeNr;i++) {
1625	if (set->nodeTab[i] == NULL)
1626	continue;
1627	switch (set->nodeTab[i]->type) {
1628	case XML_ELEMENT_NODE:
1629	case XML_TEXT_NODE:
1630	case XML_CDATA_SECTION_NODE:
1631	case XML_ENTITY_REF_NODE:
1632	case XML_ENTITY_NODE:
1633	case XML_PI_NODE:
1634	case XML_COMMENT_NODE:
1635	case XML_DOCUMENT_NODE:
1636	case XML_HTML_DOCUMENT_NODE:
1637	#ifdef LIBXML_DOCB_ENABLED
1638	case XML_DOCB_DOCUMENT_NODE:
1639	#endif
1640	continue;
1641
1642	case XML_ATTRIBUTE_NODE:
1643	xmlXIncludeErr(ctxt, ctxt->incTab[nr]->ref,
1644	XML_XINCLUDE_XPTR_RESULT,
1645	"XPointer selects an attribute: #%s\n",
1646	fragment);
1647	set->nodeTab[i] = NULL;
1648	continue;
1649	case XML_NAMESPACE_DECL:
1650	xmlXIncludeErr(ctxt, ctxt->incTab[nr]->ref,
1651	XML_XINCLUDE_XPTR_RESULT,
1652	"XPointer selects a namespace: #%s\n",
1653	fragment);
1654	set->nodeTab[i] = NULL;
1655	continue;
1656	case XML_DOCUMENT_TYPE_NODE:
1657	case XML_DOCUMENT_FRAG_NODE:
1658	case XML_NOTATION_NODE:
1659	case XML_DTD_NODE:
1660	case XML_ELEMENT_DECL:
1661	case XML_ATTRIBUTE_DECL:
1662	case XML_ENTITY_DECL:
1663	case XML_XINCLUDE_START:
1664	case XML_XINCLUDE_END:
1665	xmlXIncludeErr(ctxt, ctxt->incTab[nr]->ref,
1666	XML_XINCLUDE_XPTR_RESULT,
1667	"XPointer selects unexpected nodes: #%s\n",
1668	fragment);
1669	set->nodeTab[i] = NULL;
1670	set->nodeTab[i] = NULL;
1671	continue; /* for */
1672	}
1673	}
1674	}
1675	if (doc == NULL) {
1676	ctxt->incTab[nr]->xptr = xptr;
1677	ctxt->incTab[nr]->inc = NULL;
1678	} else {
1679	ctxt->incTab[nr]->inc =
1680	xmlXIncludeCopyXPointer(ctxt, ctxt->doc, doc, xptr);
1681	xmlXPathFreeObject(xptr);
1682	}
1683	xmlXPathFreeContext(xptrctxt);
1684	xmlFree(fragment);
1685	}
1686	#endif
1687
1688	/*
1689	* Do the xml:base fixup if needed
1690	*/
1691	if ((doc != NULL) && (URL != NULL) &&
1692	(!(ctxt->parseFlags & XML_PARSE_NOBASEFIX)) &&
1693	(!(doc->parseFlags & XML_PARSE_NOBASEFIX))) {
1694	xmlNodePtr node;
1695	xmlChar *base;
1696	xmlChar *curBase;
1697
1698	/*
1699	* The base is only adjusted if "necessary", i.e. if the xinclude node
1700	* has a base specified, or the URL is relative
1701	*/
1702	base = xmlGetNsProp(ctxt->incTab[nr]->ref, BAD_CAST "base",
1703	XML_XML_NAMESPACE);
1704	if (base == NULL) {
1705	/*
1706	* No xml:base on the xinclude node, so we check whether the
1707	* URI base is different than (relative to) the context base
1708	*/
1709	curBase = xmlBuildRelativeURI(URL, ctxt->base);
1710	if (curBase == NULL) { /* Error return */
1711	xmlXIncludeErr(ctxt, ctxt->incTab[nr]->ref,
1712	XML_XINCLUDE_HREF_URI,
1713	"trying to build relative URI from %s\n", URL);
1714	} else {
1715	/* If the URI doesn't contain a slash, it's not relative */
1716	if (!xmlStrchr(curBase, (xmlChar) '/'))
1717	xmlFree(curBase);
1718	else
1719	base = curBase;
1720	}
1721	}
1722	if (base != NULL) { /* Adjustment may be needed */
1723	node = ctxt->incTab[nr]->inc;
1724	while (node != NULL) {
1725	/* Only work on element nodes */
1726	if (node->type == XML_ELEMENT_NODE) {
1727	curBase = xmlNodeGetBase(node->doc, node);
1728	/* If no current base, set it */
1729	if (curBase == NULL) {
1730	xmlNodeSetBase(node, base);
1731	} else {
1732	/*
1733	* If the current base is the same as the
1734	* URL of the document, then reset it to be
1735	* the specified xml:base or the relative URI
1736	*/
1737	if (xmlStrEqual(curBase, node->doc->URL)) {
1738	xmlNodeSetBase(node, base);
1739	} else {
1740	/*
1741	* If the element already has an xml:base
1742	* set, then relativise it if necessary
1743	*/
1744	xmlChar *xmlBase;
1745	xmlBase = xmlGetNsProp(node,
1746	BAD_CAST "base",
1747	XML_XML_NAMESPACE);
1748	if (xmlBase != NULL) {
1749	xmlChar *relBase;
1750	relBase = xmlBuildURI(xmlBase, base);
1751	if (relBase == NULL) { /* error */
1752	xmlXIncludeErr(ctxt,
1753	ctxt->incTab[nr]->ref,
1754	XML_XINCLUDE_HREF_URI,
1755	"trying to rebuild base from %s\n",
1756	xmlBase);
1757	} else {
1758	xmlNodeSetBase(node, relBase);
1759	xmlFree(relBase);
1760	}
1761	xmlFree(xmlBase);
1762	}
1763	}
1764	xmlFree(curBase);
1765	}
1766	}
1767	node = node->next;
1768	}
1769	xmlFree(base);
1770	}
1771	}
1772	if ((nr < ctxt->incNr) && (ctxt->incTab[nr]->doc != NULL) &&
1773	(ctxt->incTab[nr]->count <= 1)) {
1774	#ifdef DEBUG_XINCLUDE
1775	printf("freeing %s\n", ctxt->incTab[nr]->doc->URL);
1776	#endif
1777	xmlFreeDoc(ctxt->incTab[nr]->doc);
1778	ctxt->incTab[nr]->doc = NULL;
1779	}
1780	xmlFree(URL);
1781	return(0);
1782	}
1783
1784	/**
1785	* xmlXIncludeLoadTxt:
1786	* @ctxt: the XInclude context
1787	* @url: the associated URL
1788	* @nr: the xinclude node number
1789	*
1790	* Load the content, and store the result in the XInclude context
1791	*
1792	* Returns 0 in case of success, -1 in case of failure
1793	*/
1794	static int
1795	xmlXIncludeLoadTxt(xmlXIncludeCtxtPtr ctxt, const xmlChar *url, int nr) {
1796	xmlParserInputBufferPtr buf;
1797	xmlNodePtr node;
1798	xmlURIPtr uri;
1799	xmlChar *URL;
1800	int i;
1801	xmlChar *encoding = NULL;
1802	xmlCharEncoding enc = (xmlCharEncoding) 0;
1803	xmlParserCtxtPtr pctxt;
1804	xmlParserInputPtr inputStream;
1805	int xinclude_multibyte_fallback_used = 0;
1806
1807	/*
1808	* Check the URL and remove any fragment identifier
1809	*/
1810	uri = xmlParseURI((const char *)url);
1811	if (uri == NULL) {
1812	xmlXIncludeErr(ctxt, ctxt->incTab[nr]->ref, XML_XINCLUDE_HREF_URI,
1813	"invalid value URI %s\n", url);
1814	return(-1);
1815	}
1816	if (uri->fragment != NULL) {
1817	xmlXIncludeErr(ctxt, ctxt->incTab[nr]->ref, XML_XINCLUDE_TEXT_FRAGMENT,
1818	"fragment identifier forbidden for text: %s\n",
1819	(const xmlChar *) uri->fragment);
1820	xmlFreeURI(uri);
1821	return(-1);
1822	}
1823	URL = xmlSaveUri(uri);
1824	xmlFreeURI(uri);
1825	if (URL == NULL) {
1826	xmlXIncludeErr(ctxt, ctxt->incTab[nr]->ref, XML_XINCLUDE_HREF_URI,
1827	"invalid value URI %s\n", url);
1828	return(-1);
1829	}
1830
1831	/*
1832	* Handling of references to the local document are done
1833	* directly through ctxt->doc.
1834	*/
1835	if (URL[0] == 0) {
1836	xmlXIncludeErr(ctxt, ctxt->incTab[nr]->ref,
1837	XML_XINCLUDE_TEXT_DOCUMENT,
1838	"text serialization of document not available\n", NULL);
1839	xmlFree(URL);
1840	return(-1);
1841	}
1842
1843	/*
1844	* Prevent reloading twice the document.
1845	*/
1846	for (i = 0; i < ctxt->txtNr; i++) {
1847	if (xmlStrEqual(URL, ctxt->txturlTab[i])) {
1848	node = xmlCopyNode(ctxt->txtTab[i], 1);
1849	goto loaded;
1850	}
1851	}
1852	/*
1853	* Try to get the encoding if available
1854	*/
1855	if ((ctxt->incTab[nr] != NULL) && (ctxt->incTab[nr]->ref != NULL)) {
1856	encoding = xmlGetProp(ctxt->incTab[nr]->ref, XINCLUDE_PARSE_ENCODING);
1857	}
1858	if (encoding != NULL) {
1859	/*
1860	* TODO: we should not have to remap to the xmlCharEncoding
1861	* predefined set, a better interface than
1862	* xmlParserInputBufferCreateFilename should allow any
1863	* encoding supported by iconv
1864	*/
1865	enc = xmlParseCharEncoding((const char *) encoding);
1866	if (enc == XML_CHAR_ENCODING_ERROR) {
1867	xmlXIncludeErr(ctxt, ctxt->incTab[nr]->ref,
1868	XML_XINCLUDE_UNKNOWN_ENCODING,
1869	"encoding %s not supported\n", encoding);
1870	xmlFree(encoding);
1871	xmlFree(URL);
1872	return(-1);
1873	}
1874	xmlFree(encoding);
1875	}
1876
1877	/*
1878	* Load it.
1879	*/
1880	pctxt = xmlNewParserCtxt();
1881	inputStream = xmlLoadExternalEntity((const char*)URL, NULL, pctxt);
1882	if(inputStream == NULL) {
1883	xmlFreeParserCtxt(pctxt);
1884	xmlFree(URL);
1885	return(-1);
1886	}
1887	buf = inputStream->buf;
1888	if (buf == NULL) {
1889	xmlFreeInputStream (inputStream);
1890	xmlFreeParserCtxt(pctxt);
1891	xmlFree(URL);
1892	return(-1);
1893	}
1894	if (buf->encoder)
1895	xmlCharEncCloseFunc(buf->encoder);
1896	buf->encoder = xmlGetCharEncodingHandler(enc);
1897	node = xmlNewText(NULL);
1898
1899	/*
1900	* Scan all chars from the resource and add the to the node
1901	*/
1902	xinclude_multibyte_fallback:
1903	while (xmlParserInputBufferRead(buf, 128) > 0) {
1904	int len;
1905	const xmlChar *content;
1906
1907	content = xmlBufContent(buf->buffer);
1908	len = xmlBufLength(buf->buffer);
1909	for (i = 0;i < len;) {
1910	int cur;
1911	int l;
1912
1913	cur = xmlStringCurrentChar(NULL, &content[i], &l);
1914	if (!IS_CHAR(cur)) {
1915	/* Handle splitted multibyte char at buffer boundary */
1916	if (((len - i) < 4) && (!xinclude_multibyte_fallback_used)) {
1917	xinclude_multibyte_fallback_used = 1;
1918	xmlBufShrink(buf->buffer, i);
1919	goto xinclude_multibyte_fallback;
1920	} else {
1921	xmlXIncludeErr(ctxt, ctxt->incTab[nr]->ref,
1922	XML_XINCLUDE_INVALID_CHAR,
1923	"%s contains invalid char\n", URL);
1924	xmlFreeParserInputBuffer(buf);
1925	xmlFree(URL);
1926	return(-1);
1927	}
1928	} else {
1929	xinclude_multibyte_fallback_used = 0;
1930	xmlNodeAddContentLen(node, &content[i], l);
1931	}
1932	i += l;
1933	}
1934	xmlBufShrink(buf->buffer, len);
1935	}
1936	xmlFreeParserCtxt(pctxt);
1937	xmlXIncludeAddTxt(ctxt, node, URL);
1938	xmlFreeInputStream(inputStream);
1939
1940	loaded:
1941	/*
1942	* Add the element as the replacement copy.
1943	*/
1944	ctxt->incTab[nr]->inc = node;
1945	xmlFree(URL);
1946	return(0);
1947	}
1948
1949	/**
1950	* xmlXIncludeLoadFallback:
1951	* @ctxt: the XInclude context
1952	* @fallback: the fallback node
1953	* @nr: the xinclude node number
1954	*
1955	* Load the content of the fallback node, and store the result
1956	* in the XInclude context
1957	*
1958	* Returns 0 in case of success, -1 in case of failure
1959	*/
1960	static int
1961	xmlXIncludeLoadFallback(xmlXIncludeCtxtPtr ctxt, xmlNodePtr fallback, int nr) {
1962	xmlXIncludeCtxtPtr newctxt;
1963	int ret = 0;
1964
1965	if ((fallback == NULL) \|\| (fallback->type == XML_NAMESPACE_DECL) \|\|
1966	(ctxt == NULL))
1967	return(-1);
1968	if (fallback->children != NULL) {
1969	/*
1970	* It's possible that the fallback also has 'includes'
1971	* (Bug 129969), so we re-process the fallback just in case
1972	*/
1973	newctxt = xmlXIncludeNewContext(ctxt->doc);
1974	if (newctxt == NULL)
1975	return (-1);
1976	newctxt->_private = ctxt->_private;
1977	newctxt->base = xmlStrdup(ctxt->base); /* Inherit the base from the existing context */
1978	xmlXIncludeSetFlags(newctxt, ctxt->parseFlags);
1979	ret = xmlXIncludeDoProcess(newctxt, ctxt->doc, fallback->children);
1980	if (ctxt->nbErrors > 0)
1981	ret = -1;
1982	else if (ret > 0)
1983	ret = 0; /* xmlXIncludeDoProcess can return +ve number */
1984	xmlXIncludeFreeContext(newctxt);
1985
1986	ctxt->incTab[nr]->inc = xmlDocCopyNodeList(ctxt->doc,
1987	fallback->children);
1988	} else {
1989	ctxt->incTab[nr]->inc = NULL;
1990	ctxt->incTab[nr]->emptyFb = 1; /* flag empty callback */
1991	}
1992	return(ret);
1993	}
1994
1995	/************************************************************************
1996	* *
1997	* XInclude Processing *
1998	* *
1999	************************************************************************/
2000
2001	/**
2002	* xmlXIncludePreProcessNode:
2003	* @ctxt: an XInclude context
2004	* @node: an XInclude node
2005	*
2006	* Implement the XInclude preprocessing, currently just adding the element
2007	* for further processing.
2008	*
2009	* Returns the result list or NULL in case of error
2010	*/
2011	static xmlNodePtr
2012	xmlXIncludePreProcessNode(xmlXIncludeCtxtPtr ctxt, xmlNodePtr node) {
2013	xmlXIncludeAddNode(ctxt, node);
2014	return(NULL);
2015	}
2016
2017	/**
2018	* xmlXIncludeLoadNode:
2019	* @ctxt: an XInclude context
2020	* @nr: the node number
2021	*
2022	* Find and load the infoset replacement for the given node.
2023	*
2024	* Returns 0 if substitution succeeded, -1 if some processing failed
2025	*/
2026	static int
2027	xmlXIncludeLoadNode(xmlXIncludeCtxtPtr ctxt, int nr) {
2028	xmlNodePtr cur;
2029	xmlChar *href;
2030	xmlChar *parse;
2031	xmlChar *base;
2032	xmlChar *oldBase;
2033	xmlChar *URI;
2034	int xml = 1; /* default Issue 64 */
2035	int ret;
2036
2037	if (ctxt == NULL)
2038	return(-1);
2039	if ((nr < 0) \|\| (nr >= ctxt->incNr))
2040	return(-1);
2041	cur = ctxt->incTab[nr]->ref;
2042	if (cur == NULL)
2043	return(-1);
2044
2045	/*
2046	* read the attributes
2047	*/
2048	href = xmlXIncludeGetProp(ctxt, cur, XINCLUDE_HREF);
2049	if (href == NULL) {
2050	href = xmlStrdup(BAD_CAST ""); /* @@@@ href is now optional */
2051	if (href == NULL)
2052	return(-1);
2053	}
2054	parse = xmlXIncludeGetProp(ctxt, cur, XINCLUDE_PARSE);
2055	if (parse != NULL) {
2056	if (xmlStrEqual(parse, XINCLUDE_PARSE_XML))
2057	xml = 1;
2058	else if (xmlStrEqual(parse, XINCLUDE_PARSE_TEXT))
2059	xml = 0;
2060	else {
2061	xmlXIncludeErr(ctxt, ctxt->incTab[nr]->ref,
2062	XML_XINCLUDE_PARSE_VALUE,
2063	"invalid value %s for 'parse'\n", parse);
2064	if (href != NULL)
2065	xmlFree(href);
2066	if (parse != NULL)
2067	xmlFree(parse);
2068	return(-1);
2069	}
2070	}
2071
2072	/*
2073	* compute the URI
2074	*/
2075	base = xmlNodeGetBase(ctxt->doc, cur);
2076	if (base == NULL) {
2077	URI = xmlBuildURI(href, ctxt->doc->URL);
2078	} else {
2079	URI = xmlBuildURI(href, base);
2080	}
2081	if (URI == NULL) {
2082	xmlChar *escbase;
2083	xmlChar *eschref;
2084	/*
2085	* Some escaping may be needed
2086	*/
2087	escbase = xmlURIEscape(base);
2088	eschref = xmlURIEscape(href);
2089	URI = xmlBuildURI(eschref, escbase);
2090	if (escbase != NULL)
2091	xmlFree(escbase);
2092	if (eschref != NULL)
2093	xmlFree(eschref);
2094	}
2095	if (URI == NULL) {
2096	xmlXIncludeErr(ctxt, ctxt->incTab[nr]->ref,
2097	XML_XINCLUDE_HREF_URI, "failed build URL\n", NULL);
2098	if (parse != NULL)
2099	xmlFree(parse);
2100	if (href != NULL)
2101	xmlFree(href);
2102	if (base != NULL)
2103	xmlFree(base);
2104	return(-1);
2105	}
2106	#ifdef DEBUG_XINCLUDE
2107	xmlGenericError(xmlGenericErrorContext, "parse: %s\n",
2108	xml ? "xml": "text");
2109	xmlGenericError(xmlGenericErrorContext, "URI: %s\n", URI);
2110	#endif
2111
2112	/*
2113	* Save the base for this include (saving the current one)
2114	*/
2115	oldBase = ctxt->base;
2116	ctxt->base = base;
2117
2118	if (xml) {
2119	ret = xmlXIncludeLoadDoc(ctxt, URI, nr);
2120	/* xmlXIncludeGetFragment(ctxt, cur, URI); */
2121	} else {
2122	ret = xmlXIncludeLoadTxt(ctxt, URI, nr);
2123	}
2124
2125	/*
2126	* Restore the original base before checking for fallback
2127	*/
2128	ctxt->base = oldBase;
2129
2130	if (ret < 0) {
2131	xmlNodePtr children;
2132
2133	/*
2134	* Time to try a fallback if availble
2135	*/
2136	#ifdef DEBUG_XINCLUDE
2137	xmlGenericError(xmlGenericErrorContext, "error looking for fallback\n");
2138	#endif
2139	children = cur->children;
2140	while (children != NULL) {
2141	if ((children->type == XML_ELEMENT_NODE) &&
2142	(children->ns != NULL) &&
2143	(xmlStrEqual(children->name, XINCLUDE_FALLBACK)) &&
2144	((xmlStrEqual(children->ns->href, XINCLUDE_NS)) \|\|
2145	(xmlStrEqual(children->ns->href, XINCLUDE_OLD_NS)))) {
2146	ret = xmlXIncludeLoadFallback(ctxt, children, nr);
2147	if (ret == 0)
2148	break;
2149	}
2150	children = children->next;
2151	}
2152	}
2153	if (ret < 0) {
2154	xmlXIncludeErr(ctxt, ctxt->incTab[nr]->ref,
2155	XML_XINCLUDE_NO_FALLBACK,
2156	"could not load %s, and no fallback was found\n",
2157	URI);
2158	}
2159
2160	/*
2161	* Cleanup
2162	*/
2163	if (URI != NULL)
2164	xmlFree(URI);
2165	if (parse != NULL)
2166	xmlFree(parse);
2167	if (href != NULL)
2168	xmlFree(href);
2169	if (base != NULL)
2170	xmlFree(base);
2171	return(0);
2172	}
2173
2174	/**
2175	* xmlXIncludeIncludeNode:
2176	* @ctxt: an XInclude context
2177	* @nr: the node number
2178	*
2179	* Inplement the infoset replacement for the given node
2180	*
2181	* Returns 0 if substitution succeeded, -1 if some processing failed
2182	*/
2183	static int
2184	xmlXIncludeIncludeNode(xmlXIncludeCtxtPtr ctxt, int nr) {
2185	xmlNodePtr cur, end, list, tmp;
2186
2187	if (ctxt == NULL)
2188	return(-1);
2189	if ((nr < 0) \|\| (nr >= ctxt->incNr))
2190	return(-1);
2191	cur = ctxt->incTab[nr]->ref;
2192	if ((cur == NULL) \|\| (cur->type == XML_NAMESPACE_DECL))
2193	return(-1);
2194
2195	/*
2196	* If we stored an XPointer a late computation may be needed
2197	*/
2198	if ((ctxt->incTab[nr]->inc == NULL) &&
2199	(ctxt->incTab[nr]->xptr != NULL)) {
2200	ctxt->incTab[nr]->inc =
2201	xmlXIncludeCopyXPointer(ctxt, ctxt->doc, ctxt->doc,
2202	ctxt->incTab[nr]->xptr);
2203	xmlXPathFreeObject(ctxt->incTab[nr]->xptr);
2204	ctxt->incTab[nr]->xptr = NULL;
2205	}
2206	list = ctxt->incTab[nr]->inc;
2207	ctxt->incTab[nr]->inc = NULL;
2208
2209	/*
2210	* Check against the risk of generating a multi-rooted document
2211	*/
2212	if ((cur->parent != NULL) &&
2213	(cur->parent->type != XML_ELEMENT_NODE)) {
2214	int nb_elem = 0;
2215
2216	tmp = list;
2217	while (tmp != NULL) {
2218	if (tmp->type == XML_ELEMENT_NODE)
2219	nb_elem++;
2220	tmp = tmp->next;
2221	}
2222	if (nb_elem > 1) {
2223	xmlXIncludeErr(ctxt, ctxt->incTab[nr]->ref,
2224	XML_XINCLUDE_MULTIPLE_ROOT,
2225	"XInclude error: would result in multiple root nodes\n",
2226	NULL);
2227	return(-1);
2228	}
2229	}
2230
2231	if (ctxt->parseFlags & XML_PARSE_NOXINCNODE) {
2232	/*
2233	* Add the list of nodes
2234	*/
2235	while (list != NULL) {
2236	end = list;
2237	list = list->next;
2238
2239	xmlAddPrevSibling(cur, end);
2240	}
2241	xmlUnlinkNode(cur);
2242	xmlFreeNode(cur);
2243	} else {
2244	/*
2245	* Change the current node as an XInclude start one, and add an
2246	* XInclude end one
2247	*/
2248	cur->type = XML_XINCLUDE_START;
2249	end = xmlNewDocNode(cur->doc, cur->ns, cur->name, NULL);
2250	if (end == NULL) {
2251	xmlXIncludeErr(ctxt, ctxt->incTab[nr]->ref,
2252	XML_XINCLUDE_BUILD_FAILED,
2253	"failed to build node\n", NULL);
2254	return(-1);
2255	}
2256	end->type = XML_XINCLUDE_END;
2257	xmlAddNextSibling(cur, end);
2258
2259	/*
2260	* Add the list of nodes
2261	*/
2262	while (list != NULL) {
2263	cur = list;
2264	list = list->next;
2265
2266	xmlAddPrevSibling(end, cur);
2267	}
2268	}
2269
2270
2271	return(0);
2272	}
2273
2274	/**
2275	* xmlXIncludeTestNode:
2276	* @ctxt: the XInclude processing context
2277	* @node: an XInclude node
2278	*
2279	* test if the node is an XInclude node
2280	*
2281	* Returns 1 true, 0 otherwise
2282	*/
2283	static int
2284	xmlXIncludeTestNode(xmlXIncludeCtxtPtr ctxt, xmlNodePtr node) {
2285	if (node == NULL)
2286	return(0);
2287	if (node->type != XML_ELEMENT_NODE)
2288	return(0);
2289	if (node->ns == NULL)
2290	return(0);
2291	if ((xmlStrEqual(node->ns->href, XINCLUDE_NS)) \|\|
2292	(xmlStrEqual(node->ns->href, XINCLUDE_OLD_NS))) {
2293	if (xmlStrEqual(node->ns->href, XINCLUDE_OLD_NS)) {
2294	if (ctxt->legacy == 0) {
2295	#if 0 /* wait for the XML Core Working Group to get something stable ! */
2296	xmlXIncludeWarn(ctxt, node, XML_XINCLUDE_DEPRECATED_NS,
2297	"Deprecated XInclude namespace found, use %s",
2298	XINCLUDE_NS);
2299	#endif
2300	ctxt->legacy = 1;
2301	}
2302	}
2303	if (xmlStrEqual(node->name, XINCLUDE_NODE)) {
2304	xmlNodePtr child = node->children;
2305	int nb_fallback = 0;
2306
2307	while (child != NULL) {
2308	if ((child->type == XML_ELEMENT_NODE) &&
2309	(child->ns != NULL) &&
2310	((xmlStrEqual(child->ns->href, XINCLUDE_NS)) \|\|
2311	(xmlStrEqual(child->ns->href, XINCLUDE_OLD_NS)))) {
2312	if (xmlStrEqual(child->name, XINCLUDE_NODE)) {
2313	xmlXIncludeErr(ctxt, node,
2314	XML_XINCLUDE_INCLUDE_IN_INCLUDE,
2315	"%s has an 'include' child\n",
2316	XINCLUDE_NODE);
2317	return(0);
2318	}
2319	if (xmlStrEqual(child->name, XINCLUDE_FALLBACK)) {
2320	nb_fallback++;
2321	}
2322	}
2323	child = child->next;
2324	}
2325	if (nb_fallback > 1) {
2326	xmlXIncludeErr(ctxt, node, XML_XINCLUDE_FALLBACKS_IN_INCLUDE,
2327	"%s has multiple fallback children\n",
2328	XINCLUDE_NODE);
2329	return(0);
2330	}
2331	return(1);
2332	}
2333	if (xmlStrEqual(node->name, XINCLUDE_FALLBACK)) {
2334	if ((node->parent == NULL) \|\|
2335	(node->parent->type != XML_ELEMENT_NODE) \|\|
2336	(node->parent->ns == NULL) \|\|
2337	((!xmlStrEqual(node->parent->ns->href, XINCLUDE_NS)) &&
2338	(!xmlStrEqual(node->parent->ns->href, XINCLUDE_OLD_NS))) \|\|
2339	(!xmlStrEqual(node->parent->name, XINCLUDE_NODE))) {
2340	xmlXIncludeErr(ctxt, node,
2341	XML_XINCLUDE_FALLBACK_NOT_IN_INCLUDE,
2342	"%s is not the child of an 'include'\n",
2343	XINCLUDE_FALLBACK);
2344	}
2345	}
2346	}
2347	return(0);
2348	}
2349
2350	/**
2351	* xmlXIncludeDoProcess:
2352	* @ctxt: the XInclude processing context
2353	* @doc: an XML document
2354	* @tree: the top of the tree to process
2355	*
2356	* Implement the XInclude substitution on the XML document @doc
2357	*
2358	* Returns 0 if no substitution were done, -1 if some processing failed
2359	* or the number of substitutions done.
2360	*/
2361	static int
2362	xmlXIncludeDoProcess(xmlXIncludeCtxtPtr ctxt, xmlDocPtr doc, xmlNodePtr tree) {
2363	xmlNodePtr cur;
2364	int ret = 0;
2365	int i, start;
2366
2367	if ((doc == NULL) \|\| (tree == NULL) \|\| (tree->type == XML_NAMESPACE_DECL))
2368	return(-1);
2369	if (ctxt == NULL)
2370	return(-1);
2371
2372	if (doc->URL != NULL) {
2373	ret = xmlXIncludeURLPush(ctxt, doc->URL);
2374	if (ret < 0)
2375	return(-1);
2376	}
2377	start = ctxt->incNr;
2378
2379	/*
2380	* First phase: lookup the elements in the document
2381	*/
2382	cur = tree;
2383	if (xmlXIncludeTestNode(ctxt, cur) == 1)
2384	xmlXIncludePreProcessNode(ctxt, cur);
2385	while ((cur != NULL) && (cur != tree->parent)) {
2386	/* TODO: need to work on entities -> stack */
2387	if ((cur->children != NULL) &&
2388	(cur->children->type != XML_ENTITY_DECL) &&
2389	(cur->children->type != XML_XINCLUDE_START) &&
2390	(cur->children->type != XML_XINCLUDE_END)) {
2391	cur = cur->children;
2392	if (xmlXIncludeTestNode(ctxt, cur))
2393	xmlXIncludePreProcessNode(ctxt, cur);
2394	} else if (cur->next != NULL) {
2395	cur = cur->next;
2396	if (xmlXIncludeTestNode(ctxt, cur))
2397	xmlXIncludePreProcessNode(ctxt, cur);
2398	} else {
2399	if (cur == tree)
2400	break;
2401	do {
2402	cur = cur->parent;
2403	if ((cur == NULL) \|\| (cur == tree->parent))
2404	break; /* do */
2405	if (cur->next != NULL) {
2406	cur = cur->next;
2407	if (xmlXIncludeTestNode(ctxt, cur))
2408	xmlXIncludePreProcessNode(ctxt, cur);
2409	break; /* do */
2410	}
2411	} while (cur != NULL);
2412	}
2413	}
2414
2415	/*
2416	* Second Phase : collect the infosets fragments
2417	*/
2418	for (i = start;i < ctxt->incNr; i++) {
2419	xmlXIncludeLoadNode(ctxt, i);
2420	ret++;
2421	}
2422
2423	/*
2424	* Third phase: extend the original document infoset.
2425	*
2426	* Originally we bypassed the inclusion if there were any errors
2427	* encountered on any of the XIncludes. A bug was raised (bug
2428	* 132588) requesting that we output the XIncludes without error,
2429	* so the check for inc!=NULL \|\| xptr!=NULL was put in. This may
2430	* give some other problems in the future, but for now it seems to
2431	* work ok.
2432	*
2433	*/
2434	for (i = ctxt->incBase;i < ctxt->incNr; i++) {
2435	if ((ctxt->incTab[i]->inc != NULL) \|\|
2436	(ctxt->incTab[i]->xptr != NULL) \|\|
2437	(ctxt->incTab[i]->emptyFb != 0)) /* (empty fallback) */
2438	xmlXIncludeIncludeNode(ctxt, i);
2439	}
2440
2441	if (doc->URL != NULL)
2442	xmlXIncludeURLPop(ctxt);
2443	return(ret);
2444	}
2445
2446	/**
2447	* xmlXIncludeSetFlags:
2448	* @ctxt: an XInclude processing context
2449	* @flags: a set of xmlParserOption used for parsing XML includes
2450	*
2451	* Set the flags used for further processing of XML resources.
2452	*
2453	* Returns 0 in case of success and -1 in case of error.
2454	*/
2455	int
2456	xmlXIncludeSetFlags(xmlXIncludeCtxtPtr ctxt, int flags) {
2457	if (ctxt == NULL)
2458	return(-1);
2459	ctxt->parseFlags = flags;
2460	return(0);
2461	}
2462
2463	/**
2464	* xmlXIncludeProcessTreeFlagsData:
2465	* @tree: an XML node
2466	* @flags: a set of xmlParserOption used for parsing XML includes
2467	* @data: application data that will be passed to the parser context
2468	* in the _private field of the parser context(s)
2469	*
2470	* Implement the XInclude substitution on the XML node @tree
2471	*
2472	* Returns 0 if no substitution were done, -1 if some processing failed
2473	* or the number of substitutions done.
2474	*/
2475
2476	int
2477	xmlXIncludeProcessTreeFlagsData(xmlNodePtr tree, int flags, void *data) {
2478	xmlXIncludeCtxtPtr ctxt;
2479	int ret = 0;
2480
2481	if ((tree == NULL) \|\| (tree->type == XML_NAMESPACE_DECL) \|\|
2482	(tree->doc == NULL))
2483	return(-1);
2484
2485	ctxt = xmlXIncludeNewContext(tree->doc);
2486	if (ctxt == NULL)
2487	return(-1);
2488	ctxt->_private = data;
2489	ctxt->base = xmlStrdup((xmlChar *)tree->doc->URL);
2490	xmlXIncludeSetFlags(ctxt, flags);
2491	ret = xmlXIncludeDoProcess(ctxt, tree->doc, tree);
2492	if ((ret >= 0) && (ctxt->nbErrors > 0))
2493	ret = -1;
2494
2495	xmlXIncludeFreeContext(ctxt);
2496	return(ret);
2497	}
2498
2499	/**
2500	* xmlXIncludeProcessFlagsData:
2501	* @doc: an XML document
2502	* @flags: a set of xmlParserOption used for parsing XML includes
2503	* @data: application data that will be passed to the parser context
2504	* in the _private field of the parser context(s)
2505	*
2506	* Implement the XInclude substitution on the XML document @doc
2507	*
2508	* Returns 0 if no substitution were done, -1 if some processing failed
2509	* or the number of substitutions done.
2510	*/
2511	int
2512	xmlXIncludeProcessFlagsData(xmlDocPtr doc, int flags, void *data) {
2513	xmlNodePtr tree;
2514
2515	if (doc == NULL)
2516	return(-1);
2517	tree = xmlDocGetRootElement(doc);
2518	if (tree == NULL)
2519	return(-1);
2520	return(xmlXIncludeProcessTreeFlagsData(tree, flags, data));
2521	}
2522
2523	/**
2524	* xmlXIncludeProcessFlags:
2525	* @doc: an XML document
2526	* @flags: a set of xmlParserOption used for parsing XML includes
2527	*
2528	* Implement the XInclude substitution on the XML document @doc
2529	*
2530	* Returns 0 if no substitution were done, -1 if some processing failed
2531	* or the number of substitutions done.
2532	*/
2533	int
2534	xmlXIncludeProcessFlags(xmlDocPtr doc, int flags) {
2535	return xmlXIncludeProcessFlagsData(doc, flags, NULL);
2536	}
2537
2538	/**
2539	* xmlXIncludeProcess:
2540	* @doc: an XML document
2541	*
2542	* Implement the XInclude substitution on the XML document @doc
2543	*
2544	* Returns 0 if no substitution were done, -1 if some processing failed
2545	* or the number of substitutions done.
2546	*/
2547	int
2548	xmlXIncludeProcess(xmlDocPtr doc) {
2549	return(xmlXIncludeProcessFlags(doc, 0));
2550	}
2551
2552	/**
2553	* xmlXIncludeProcessTreeFlags:
2554	* @tree: a node in an XML document
2555	* @flags: a set of xmlParserOption used for parsing XML includes
2556	*
2557	* Implement the XInclude substitution for the given subtree
2558	*
2559	* Returns 0 if no substitution were done, -1 if some processing failed
2560	* or the number of substitutions done.
2561	*/
2562	int
2563	xmlXIncludeProcessTreeFlags(xmlNodePtr tree, int flags) {
2564	xmlXIncludeCtxtPtr ctxt;
2565	int ret = 0;
2566
2567	if ((tree == NULL) \|\| (tree->type == XML_NAMESPACE_DECL) \|\|
2568	(tree->doc == NULL))
2569	return(-1);
2570	ctxt = xmlXIncludeNewContext(tree->doc);
2571	if (ctxt == NULL)
2572	return(-1);
2573	ctxt->base = xmlNodeGetBase(tree->doc, tree);
2574	xmlXIncludeSetFlags(ctxt, flags);
2575	ret = xmlXIncludeDoProcess(ctxt, tree->doc, tree);
2576	if ((ret >= 0) && (ctxt->nbErrors > 0))
2577	ret = -1;
2578
2579	xmlXIncludeFreeContext(ctxt);
2580	return(ret);
2581	}
2582
2583	/**
2584	* xmlXIncludeProcessTree:
2585	* @tree: a node in an XML document
2586	*
2587	* Implement the XInclude substitution for the given subtree
2588	*
2589	* Returns 0 if no substitution were done, -1 if some processing failed
2590	* or the number of substitutions done.
2591	*/
2592	int
2593	xmlXIncludeProcessTree(xmlNodePtr tree) {
2594	return(xmlXIncludeProcessTreeFlags(tree, 0));
2595	}
2596
2597	/**
2598	* xmlXIncludeProcessNode:
2599	* @ctxt: an existing XInclude context
2600	* @node: a node in an XML document
2601	*
2602	* Implement the XInclude substitution for the given subtree reusing
2603	* the informations and data coming from the given context.
2604	*
2605	* Returns 0 if no substitution were done, -1 if some processing failed
2606	* or the number of substitutions done.
2607	*/
2608	int
2609	xmlXIncludeProcessNode(xmlXIncludeCtxtPtr ctxt, xmlNodePtr node) {
2610	int ret = 0;
2611
2612	if ((node == NULL) \|\| (node->type == XML_NAMESPACE_DECL) \|\|
2613	(node->doc == NULL) \|\| (ctxt == NULL))
2614	return(-1);
2615	ret = xmlXIncludeDoProcess(ctxt, node->doc, node);
2616	if ((ret >= 0) && (ctxt->nbErrors > 0))
2617	ret = -1;
2618	return(ret);
2619	}
2620
2621	#else /* !LIBXML_XINCLUDE_ENABLED */
2622	#endif
2623	#define bottom_xinclude
2624	#include "elfgcchack.h"

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

source: vbox/trunk/src/libs/libxml2-2.9.4/xinclude.c@ 93145

Download in other formats: