xinclude.c

   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
 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
 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"