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