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