Annotation of embedaddon/libxml2/xinclude.c, revision 1.1.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>