|
Packit |
423ecb |
/*
|
|
Packit |
423ecb |
* xinclude.c : Code to implement XInclude processing
|
|
Packit |
423ecb |
*
|
|
Packit |
423ecb |
* World Wide Web Consortium W3C Last Call Working Draft 10 November 2003
|
|
Packit |
423ecb |
* http://www.w3.org/TR/2003/WD-xinclude-20031110
|
|
Packit |
423ecb |
*
|
|
Packit |
423ecb |
* See Copyright for the status of this software.
|
|
Packit |
423ecb |
*
|
|
Packit |
423ecb |
* daniel@veillard.com
|
|
Packit |
423ecb |
*/
|
|
Packit |
423ecb |
|
|
Packit |
423ecb |
#define IN_LIBXML
|
|
Packit |
423ecb |
#include "libxml.h"
|
|
Packit |
423ecb |
|
|
Packit |
423ecb |
#include <string.h>
|
|
Packit |
423ecb |
#include <libxml/xmlmemory.h>
|
|
Packit |
423ecb |
#include <libxml/tree.h>
|
|
Packit |
423ecb |
#include <libxml/parser.h>
|
|
Packit |
423ecb |
#include <libxml/uri.h>
|
|
Packit |
423ecb |
#include <libxml/xpath.h>
|
|
Packit |
423ecb |
#include <libxml/xpointer.h>
|
|
Packit |
423ecb |
#include <libxml/parserInternals.h>
|
|
Packit |
423ecb |
#include <libxml/xmlerror.h>
|
|
Packit |
423ecb |
#include <libxml/encoding.h>
|
|
Packit |
423ecb |
#include <libxml/globals.h>
|
|
Packit |
423ecb |
|
|
Packit |
423ecb |
#ifdef LIBXML_XINCLUDE_ENABLED
|
|
Packit |
423ecb |
#include <libxml/xinclude.h>
|
|
Packit |
423ecb |
|
|
Packit |
423ecb |
#include "buf.h"
|
|
Packit |
423ecb |
|
|
Packit |
423ecb |
#define XINCLUDE_MAX_DEPTH 40
|
|
Packit |
423ecb |
|
|
Packit |
423ecb |
/* #define DEBUG_XINCLUDE */
|
|
Packit |
423ecb |
#ifdef DEBUG_XINCLUDE
|
|
Packit |
423ecb |
#ifdef LIBXML_DEBUG_ENABLED
|
|
Packit |
423ecb |
#include <libxml/debugXML.h>
|
|
Packit |
423ecb |
#endif
|
|
Packit |
423ecb |
#endif
|
|
Packit |
423ecb |
|
|
Packit |
423ecb |
/************************************************************************
|
|
Packit |
423ecb |
* *
|
|
Packit |
423ecb |
* XInclude context handling *
|
|
Packit |
423ecb |
* *
|
|
Packit |
423ecb |
************************************************************************/
|
|
Packit |
423ecb |
|
|
Packit |
423ecb |
/*
|
|
Packit |
423ecb |
* An XInclude context
|
|
Packit |
423ecb |
*/
|
|
Packit |
423ecb |
typedef xmlChar *xmlURL;
|
|
Packit |
423ecb |
|
|
Packit |
423ecb |
typedef struct _xmlXIncludeRef xmlXIncludeRef;
|
|
Packit |
423ecb |
typedef xmlXIncludeRef *xmlXIncludeRefPtr;
|
|
Packit |
423ecb |
struct _xmlXIncludeRef {
|
|
Packit |
423ecb |
xmlChar *URI; /* the fully resolved resource URL */
|
|
Packit |
423ecb |
xmlChar *fragment; /* the fragment in the URI */
|
|
Packit |
423ecb |
xmlDocPtr doc; /* the parsed document */
|
|
Packit |
423ecb |
xmlNodePtr ref; /* the node making the reference in the source */
|
|
Packit |
423ecb |
xmlNodePtr inc; /* the included copy */
|
|
Packit |
423ecb |
int xml; /* xml or txt */
|
|
Packit |
423ecb |
int count; /* how many refs use that specific doc */
|
|
Packit |
423ecb |
xmlXPathObjectPtr xptr; /* the xpointer if needed */
|
|
Packit |
423ecb |
int emptyFb; /* flag to show fallback empty */
|
|
Packit |
423ecb |
};
|
|
Packit |
423ecb |
|
|
Packit |
423ecb |
struct _xmlXIncludeCtxt {
|
|
Packit |
423ecb |
xmlDocPtr doc; /* the source document */
|
|
Packit |
423ecb |
int incBase; /* the first include for this document */
|
|
Packit |
423ecb |
int incNr; /* number of includes */
|
|
Packit |
423ecb |
int incMax; /* size of includes tab */
|
|
Packit |
423ecb |
xmlXIncludeRefPtr *incTab; /* array of included references */
|
|
Packit |
423ecb |
|
|
Packit |
423ecb |
int txtNr; /* number of unparsed documents */
|
|
Packit |
423ecb |
int txtMax; /* size of unparsed documents tab */
|
|
Packit |
423ecb |
xmlNodePtr *txtTab; /* array of unparsed text nodes */
|
|
Packit |
423ecb |
xmlURL *txturlTab; /* array of unparsed text URLs */
|
|
Packit |
423ecb |
|
|
Packit |
423ecb |
xmlChar * url; /* the current URL processed */
|
|
Packit |
423ecb |
int urlNr; /* number of URLs stacked */
|
|
Packit |
423ecb |
int urlMax; /* size of URL stack */
|
|
Packit |
423ecb |
xmlChar * *urlTab; /* URL stack */
|
|
Packit |
423ecb |
|
|
Packit |
423ecb |
int nbErrors; /* the number of errors detected */
|
|
Packit |
423ecb |
int legacy; /* using XINCLUDE_OLD_NS */
|
|
Packit |
423ecb |
int parseFlags; /* the flags used for parsing XML documents */
|
|
Packit |
423ecb |
xmlChar * base; /* the current xml:base */
|
|
Packit |
423ecb |
|
|
Packit |
423ecb |
void *_private; /* application data */
|
|
Packit |
423ecb |
};
|
|
Packit |
423ecb |
|
|
Packit |
423ecb |
static int
|
|
Packit |
423ecb |
xmlXIncludeDoProcess(xmlXIncludeCtxtPtr ctxt, xmlDocPtr doc, xmlNodePtr tree);
|
|
Packit |
423ecb |
|
|
Packit |
423ecb |
|
|
Packit |
423ecb |
/************************************************************************
|
|
Packit |
423ecb |
* *
|
|
Packit |
423ecb |
* XInclude error handler *
|
|
Packit |
423ecb |
* *
|
|
Packit |
423ecb |
************************************************************************/
|
|
Packit |
423ecb |
|
|
Packit |
423ecb |
/**
|
|
Packit |
423ecb |
* xmlXIncludeErrMemory:
|
|
Packit |
423ecb |
* @extra: extra information
|
|
Packit |
423ecb |
*
|
|
Packit |
423ecb |
* Handle an out of memory condition
|
|
Packit |
423ecb |
*/
|
|
Packit |
423ecb |
static void
|
|
Packit |
423ecb |
xmlXIncludeErrMemory(xmlXIncludeCtxtPtr ctxt, xmlNodePtr node,
|
|
Packit |
423ecb |
const char *extra)
|
|
Packit |
423ecb |
{
|
|
Packit |
423ecb |
if (ctxt != NULL)
|
|
Packit |
423ecb |
ctxt->nbErrors++;
|
|
Packit |
423ecb |
__xmlRaiseError(NULL, NULL, NULL, ctxt, node, XML_FROM_XINCLUDE,
|
|
Packit |
423ecb |
XML_ERR_NO_MEMORY, XML_ERR_ERROR, NULL, 0,
|
|
Packit |
423ecb |
extra, NULL, NULL, 0, 0,
|
|
Packit |
423ecb |
"Memory allocation failed : %s\n", extra);
|
|
Packit |
423ecb |
}
|
|
Packit |
423ecb |
|
|
Packit |
423ecb |
/**
|
|
Packit |
423ecb |
* xmlXIncludeErr:
|
|
Packit |
423ecb |
* @ctxt: the XInclude context
|
|
Packit |
423ecb |
* @node: the context node
|
|
Packit |
423ecb |
* @msg: the error message
|
|
Packit |
423ecb |
* @extra: extra information
|
|
Packit |
423ecb |
*
|
|
Packit |
423ecb |
* Handle an XInclude error
|
|
Packit |
423ecb |
*/
|
|
Packit |
423ecb |
static void LIBXML_ATTR_FORMAT(4,0)
|
|
Packit |
423ecb |
xmlXIncludeErr(xmlXIncludeCtxtPtr ctxt, xmlNodePtr node, int error,
|
|
Packit |
423ecb |
const char *msg, const xmlChar *extra)
|
|
Packit |
423ecb |
{
|
|
Packit |
423ecb |
if (ctxt != NULL)
|
|
Packit |
423ecb |
ctxt->nbErrors++;
|
|
Packit |
423ecb |
__xmlRaiseError(NULL, NULL, NULL, ctxt, node, XML_FROM_XINCLUDE,
|
|
Packit |
423ecb |
error, XML_ERR_ERROR, NULL, 0,
|
|
Packit |
423ecb |
(const char *) extra, NULL, NULL, 0, 0,
|
|
Packit |
423ecb |
msg, (const char *) extra);
|
|
Packit |
423ecb |
}
|
|
Packit |
423ecb |
|
|
Packit |
423ecb |
#if 0
|
|
Packit |
423ecb |
/**
|
|
Packit |
423ecb |
* xmlXIncludeWarn:
|
|
Packit |
423ecb |
* @ctxt: the XInclude context
|
|
Packit |
423ecb |
* @node: the context node
|
|
Packit |
423ecb |
* @msg: the error message
|
|
Packit |
423ecb |
* @extra: extra information
|
|
Packit |
423ecb |
*
|
|
Packit |
423ecb |
* Emit an XInclude warning.
|
|
Packit |
423ecb |
*/
|
|
Packit |
423ecb |
static void LIBXML_ATTR_FORMAT(4,0)
|
|
Packit |
423ecb |
xmlXIncludeWarn(xmlXIncludeCtxtPtr ctxt, xmlNodePtr node, int error,
|
|
Packit |
423ecb |
const char *msg, const xmlChar *extra)
|
|
Packit |
423ecb |
{
|
|
Packit |
423ecb |
__xmlRaiseError(NULL, NULL, NULL, ctxt, node, XML_FROM_XINCLUDE,
|
|
Packit |
423ecb |
error, XML_ERR_WARNING, NULL, 0,
|
|
Packit |
423ecb |
(const char *) extra, NULL, NULL, 0, 0,
|
|
Packit |
423ecb |
msg, (const char *) extra);
|
|
Packit |
423ecb |
}
|
|
Packit |
423ecb |
#endif
|
|
Packit |
423ecb |
|
|
Packit |
423ecb |
/**
|
|
Packit |
423ecb |
* xmlXIncludeGetProp:
|
|
Packit |
423ecb |
* @ctxt: the XInclude context
|
|
Packit |
423ecb |
* @cur: the node
|
|
Packit |
423ecb |
* @name: the attribute name
|
|
Packit |
423ecb |
*
|
|
Packit |
423ecb |
* Get an XInclude attribute
|
|
Packit |
423ecb |
*
|
|
Packit |
423ecb |
* Returns the value (to be freed) or NULL if not found
|
|
Packit |
423ecb |
*/
|
|
Packit |
423ecb |
static xmlChar *
|
|
Packit |
423ecb |
xmlXIncludeGetProp(xmlXIncludeCtxtPtr ctxt, xmlNodePtr cur,
|
|
Packit |
423ecb |
const xmlChar *name) {
|
|
Packit |
423ecb |
xmlChar *ret;
|
|
Packit |
423ecb |
|
|
Packit |
423ecb |
ret = xmlGetNsProp(cur, XINCLUDE_NS, name);
|
|
Packit |
423ecb |
if (ret != NULL)
|
|
Packit |
423ecb |
return(ret);
|
|
Packit |
423ecb |
if (ctxt->legacy != 0) {
|
|
Packit |
423ecb |
ret = xmlGetNsProp(cur, XINCLUDE_OLD_NS, name);
|
|
Packit |
423ecb |
if (ret != NULL)
|
|
Packit |
423ecb |
return(ret);
|
|
Packit |
423ecb |
}
|
|
Packit |
423ecb |
ret = xmlGetProp(cur, name);
|
|
Packit |
423ecb |
return(ret);
|
|
Packit |
423ecb |
}
|
|
Packit |
423ecb |
/**
|
|
Packit |
423ecb |
* xmlXIncludeFreeRef:
|
|
Packit |
423ecb |
* @ref: the XInclude reference
|
|
Packit |
423ecb |
*
|
|
Packit |
423ecb |
* Free an XInclude reference
|
|
Packit |
423ecb |
*/
|
|
Packit |
423ecb |
static void
|
|
Packit |
423ecb |
xmlXIncludeFreeRef(xmlXIncludeRefPtr ref) {
|
|
Packit |
423ecb |
if (ref == NULL)
|
|
Packit |
423ecb |
return;
|
|
Packit |
423ecb |
#ifdef DEBUG_XINCLUDE
|
|
Packit |
423ecb |
xmlGenericError(xmlGenericErrorContext, "Freeing ref\n");
|
|
Packit |
423ecb |
#endif
|
|
Packit |
423ecb |
if (ref->doc != NULL) {
|
|
Packit |
423ecb |
#ifdef DEBUG_XINCLUDE
|
|
Packit |
423ecb |
xmlGenericError(xmlGenericErrorContext, "Freeing doc %s\n", ref->URI);
|
|
Packit |
423ecb |
#endif
|
|
Packit |
423ecb |
xmlFreeDoc(ref->doc);
|
|
Packit |
423ecb |
}
|
|
Packit |
423ecb |
if (ref->URI != NULL)
|
|
Packit |
423ecb |
xmlFree(ref->URI);
|
|
Packit |
423ecb |
if (ref->fragment != NULL)
|
|
Packit |
423ecb |
xmlFree(ref->fragment);
|
|
Packit |
423ecb |
if (ref->xptr != NULL)
|
|
Packit |
423ecb |
xmlXPathFreeObject(ref->xptr);
|
|
Packit |
423ecb |
xmlFree(ref);
|
|
Packit |
423ecb |
}
|
|
Packit |
423ecb |
|
|
Packit |
423ecb |
/**
|
|
Packit |
423ecb |
* xmlXIncludeNewRef:
|
|
Packit |
423ecb |
* @ctxt: the XInclude context
|
|
Packit |
423ecb |
* @URI: the resource URI
|
|
Packit |
423ecb |
*
|
|
Packit |
423ecb |
* Creates a new reference within an XInclude context
|
|
Packit |
423ecb |
*
|
|
Packit |
423ecb |
* Returns the new set
|
|
Packit |
423ecb |
*/
|
|
Packit |
423ecb |
static xmlXIncludeRefPtr
|
|
Packit |
423ecb |
xmlXIncludeNewRef(xmlXIncludeCtxtPtr ctxt, const xmlChar *URI,
|
|
Packit |
423ecb |
xmlNodePtr ref) {
|
|
Packit |
423ecb |
xmlXIncludeRefPtr ret;
|
|
Packit |
423ecb |
|
|
Packit |
423ecb |
#ifdef DEBUG_XINCLUDE
|
|
Packit |
423ecb |
xmlGenericError(xmlGenericErrorContext, "New ref %s\n", URI);
|
|
Packit |
423ecb |
#endif
|
|
Packit |
423ecb |
ret = (xmlXIncludeRefPtr) xmlMalloc(sizeof(xmlXIncludeRef));
|
|
Packit |
423ecb |
if (ret == NULL) {
|
|
Packit |
423ecb |
xmlXIncludeErrMemory(ctxt, ref, "growing XInclude context");
|
|
Packit |
423ecb |
return(NULL);
|
|
Packit |
423ecb |
}
|
|
Packit |
423ecb |
memset(ret, 0, sizeof(xmlXIncludeRef));
|
|
Packit |
423ecb |
if (URI == NULL)
|
|
Packit |
423ecb |
ret->URI = NULL;
|
|
Packit |
423ecb |
else
|
|
Packit |
423ecb |
ret->URI = xmlStrdup(URI);
|
|
Packit |
423ecb |
ret->fragment = NULL;
|
|
Packit |
423ecb |
ret->ref = ref;
|
|
Packit |
423ecb |
ret->doc = NULL;
|
|
Packit |
423ecb |
ret->count = 0;
|
|
Packit |
423ecb |
ret->xml = 0;
|
|
Packit |
423ecb |
ret->inc = NULL;
|
|
Packit |
423ecb |
if (ctxt->incMax == 0) {
|
|
Packit |
423ecb |
ctxt->incMax = 4;
|
|
Packit |
423ecb |
ctxt->incTab = (xmlXIncludeRefPtr *) xmlMalloc(ctxt->incMax *
|
|
Packit |
423ecb |
sizeof(ctxt->incTab[0]));
|
|
Packit |
423ecb |
if (ctxt->incTab == NULL) {
|
|
Packit |
423ecb |
xmlXIncludeErrMemory(ctxt, ref, "growing XInclude context");
|
|
Packit |
423ecb |
xmlXIncludeFreeRef(ret);
|
|
Packit |
423ecb |
return(NULL);
|
|
Packit |
423ecb |
}
|
|
Packit |
423ecb |
}
|
|
Packit |
423ecb |
if (ctxt->incNr >= ctxt->incMax) {
|
|
Packit |
423ecb |
ctxt->incMax *= 2;
|
|
Packit |
423ecb |
ctxt->incTab = (xmlXIncludeRefPtr *) xmlRealloc(ctxt->incTab,
|
|
Packit |
423ecb |
ctxt->incMax * sizeof(ctxt->incTab[0]));
|
|
Packit |
423ecb |
if (ctxt->incTab == NULL) {
|
|
Packit |
423ecb |
xmlXIncludeErrMemory(ctxt, ref, "growing XInclude context");
|
|
Packit |
423ecb |
xmlXIncludeFreeRef(ret);
|
|
Packit |
423ecb |
return(NULL);
|
|
Packit |
423ecb |
}
|
|
Packit |
423ecb |
}
|
|
Packit |
423ecb |
ctxt->incTab[ctxt->incNr++] = ret;
|
|
Packit |
423ecb |
return(ret);
|
|
Packit |
423ecb |
}
|
|
Packit |
423ecb |
|
|
Packit |
423ecb |
/**
|
|
Packit |
423ecb |
* xmlXIncludeNewContext:
|
|
Packit |
423ecb |
* @doc: an XML Document
|
|
Packit |
423ecb |
*
|
|
Packit |
423ecb |
* Creates a new XInclude context
|
|
Packit |
423ecb |
*
|
|
Packit |
423ecb |
* Returns the new set
|
|
Packit |
423ecb |
*/
|
|
Packit |
423ecb |
xmlXIncludeCtxtPtr
|
|
Packit |
423ecb |
xmlXIncludeNewContext(xmlDocPtr doc) {
|
|
Packit |
423ecb |
xmlXIncludeCtxtPtr ret;
|
|
Packit |
423ecb |
|
|
Packit |
423ecb |
#ifdef DEBUG_XINCLUDE
|
|
Packit |
423ecb |
xmlGenericError(xmlGenericErrorContext, "New context\n");
|
|
Packit |
423ecb |
#endif
|
|
Packit |
423ecb |
if (doc == NULL)
|
|
Packit |
423ecb |
return(NULL);
|
|
Packit |
423ecb |
ret = (xmlXIncludeCtxtPtr) xmlMalloc(sizeof(xmlXIncludeCtxt));
|
|
Packit |
423ecb |
if (ret == NULL) {
|
|
Packit |
423ecb |
xmlXIncludeErrMemory(NULL, (xmlNodePtr) doc,
|
|
Packit |
423ecb |
"creating XInclude context");
|
|
Packit |
423ecb |
return(NULL);
|
|
Packit |
423ecb |
}
|
|
Packit |
423ecb |
memset(ret, 0, sizeof(xmlXIncludeCtxt));
|
|
Packit |
423ecb |
ret->doc = doc;
|
|
Packit |
423ecb |
ret->incNr = 0;
|
|
Packit |
423ecb |
ret->incBase = 0;
|
|
Packit |
423ecb |
ret->incMax = 0;
|
|
Packit |
423ecb |
ret->incTab = NULL;
|
|
Packit |
423ecb |
ret->nbErrors = 0;
|
|
Packit |
423ecb |
return(ret);
|
|
Packit |
423ecb |
}
|
|
Packit |
423ecb |
|
|
Packit |
423ecb |
/**
|
|
Packit |
423ecb |
* xmlXIncludeURLPush:
|
|
Packit |
423ecb |
* @ctxt: the parser context
|
|
Packit |
423ecb |
* @value: the url
|
|
Packit |
423ecb |
*
|
|
Packit |
423ecb |
* Pushes a new url on top of the url stack
|
|
Packit |
423ecb |
*
|
|
Packit |
423ecb |
* Returns -1 in case of error, the index in the stack otherwise
|
|
Packit |
423ecb |
*/
|
|
Packit |
423ecb |
static int
|
|
Packit |
423ecb |
xmlXIncludeURLPush(xmlXIncludeCtxtPtr ctxt,
|
|
Packit |
423ecb |
const xmlChar *value)
|
|
Packit |
423ecb |
{
|
|
Packit |
423ecb |
if (ctxt->urlNr > XINCLUDE_MAX_DEPTH) {
|
|
Packit |
423ecb |
xmlXIncludeErr(ctxt, NULL, XML_XINCLUDE_RECURSION,
|
|
Packit |
423ecb |
"detected a recursion in %s\n", value);
|
|
Packit |
423ecb |
return(-1);
|
|
Packit |
423ecb |
}
|
|
Packit |
423ecb |
if (ctxt->urlTab == NULL) {
|
|
Packit |
423ecb |
ctxt->urlMax = 4;
|
|
Packit |
423ecb |
ctxt->urlNr = 0;
|
|
Packit |
423ecb |
ctxt->urlTab = (xmlChar * *) xmlMalloc(
|
|
Packit |
423ecb |
ctxt->urlMax * sizeof(ctxt->urlTab[0]));
|
|
Packit |
423ecb |
if (ctxt->urlTab == NULL) {
|
|
Packit |
423ecb |
xmlXIncludeErrMemory(ctxt, NULL, "adding URL");
|
|
Packit |
423ecb |
return (-1);
|
|
Packit |
423ecb |
}
|
|
Packit |
423ecb |
}
|
|
Packit |
423ecb |
if (ctxt->urlNr >= ctxt->urlMax) {
|
|
Packit |
423ecb |
ctxt->urlMax *= 2;
|
|
Packit |
423ecb |
ctxt->urlTab =
|
|
Packit |
423ecb |
(xmlChar * *) xmlRealloc(ctxt->urlTab,
|
|
Packit |
423ecb |
ctxt->urlMax *
|
|
Packit |
423ecb |
sizeof(ctxt->urlTab[0]));
|
|
Packit |
423ecb |
if (ctxt->urlTab == NULL) {
|
|
Packit |
423ecb |
xmlXIncludeErrMemory(ctxt, NULL, "adding URL");
|
|
Packit |
423ecb |
return (-1);
|
|
Packit |
423ecb |
}
|
|
Packit |
423ecb |
}
|
|
Packit |
423ecb |
ctxt->url = ctxt->urlTab[ctxt->urlNr] = xmlStrdup(value);
|
|
Packit |
423ecb |
return (ctxt->urlNr++);
|
|
Packit |
423ecb |
}
|
|
Packit |
423ecb |
|
|
Packit |
423ecb |
/**
|
|
Packit |
423ecb |
* xmlXIncludeURLPop:
|
|
Packit |
423ecb |
* @ctxt: the parser context
|
|
Packit |
423ecb |
*
|
|
Packit |
423ecb |
* Pops the top URL from the URL stack
|
|
Packit |
423ecb |
*/
|
|
Packit |
423ecb |
static void
|
|
Packit |
423ecb |
xmlXIncludeURLPop(xmlXIncludeCtxtPtr ctxt)
|
|
Packit |
423ecb |
{
|
|
Packit |
423ecb |
xmlChar * ret;
|
|
Packit |
423ecb |
|
|
Packit |
423ecb |
if (ctxt->urlNr <= 0)
|
|
Packit |
423ecb |
return;
|
|
Packit |
423ecb |
ctxt->urlNr--;
|
|
Packit |
423ecb |
if (ctxt->urlNr > 0)
|
|
Packit |
423ecb |
ctxt->url = ctxt->urlTab[ctxt->urlNr - 1];
|
|
Packit |
423ecb |
else
|
|
Packit |
423ecb |
ctxt->url = NULL;
|
|
Packit |
423ecb |
ret = ctxt->urlTab[ctxt->urlNr];
|
|
Packit |
423ecb |
ctxt->urlTab[ctxt->urlNr] = NULL;
|
|
Packit |
423ecb |
if (ret != NULL)
|
|
Packit |
423ecb |
xmlFree(ret);
|
|
Packit |
423ecb |
}
|
|
Packit |
423ecb |
|
|
Packit |
423ecb |
/**
|
|
Packit |
423ecb |
* xmlXIncludeFreeContext:
|
|
Packit |
423ecb |
* @ctxt: the XInclude context
|
|
Packit |
423ecb |
*
|
|
Packit |
423ecb |
* Free an XInclude context
|
|
Packit |
423ecb |
*/
|
|
Packit |
423ecb |
void
|
|
Packit |
423ecb |
xmlXIncludeFreeContext(xmlXIncludeCtxtPtr ctxt) {
|
|
Packit |
423ecb |
int i;
|
|
Packit |
423ecb |
|
|
Packit |
423ecb |
#ifdef DEBUG_XINCLUDE
|
|
Packit |
423ecb |
xmlGenericError(xmlGenericErrorContext, "Freeing context\n");
|
|
Packit |
423ecb |
#endif
|
|
Packit |
423ecb |
if (ctxt == NULL)
|
|
Packit |
423ecb |
return;
|
|
Packit |
423ecb |
while (ctxt->urlNr > 0)
|
|
Packit |
423ecb |
xmlXIncludeURLPop(ctxt);
|
|
Packit |
423ecb |
if (ctxt->urlTab != NULL)
|
|
Packit |
423ecb |
xmlFree(ctxt->urlTab);
|
|
Packit |
423ecb |
for (i = 0;i < ctxt->incNr;i++) {
|
|
Packit |
423ecb |
if (ctxt->incTab[i] != NULL)
|
|
Packit |
423ecb |
xmlXIncludeFreeRef(ctxt->incTab[i]);
|
|
Packit |
423ecb |
}
|
|
Packit |
423ecb |
if (ctxt->txturlTab != NULL) {
|
|
Packit |
423ecb |
for (i = 0;i < ctxt->txtNr;i++) {
|
|
Packit |
423ecb |
if (ctxt->txturlTab[i] != NULL)
|
|
Packit |
423ecb |
xmlFree(ctxt->txturlTab[i]);
|
|
Packit |
423ecb |
}
|
|
Packit |
423ecb |
}
|
|
Packit |
423ecb |
if (ctxt->incTab != NULL)
|
|
Packit |
423ecb |
xmlFree(ctxt->incTab);
|
|
Packit |
423ecb |
if (ctxt->txtTab != NULL)
|
|
Packit |
423ecb |
xmlFree(ctxt->txtTab);
|
|
Packit |
423ecb |
if (ctxt->txturlTab != NULL)
|
|
Packit |
423ecb |
xmlFree(ctxt->txturlTab);
|
|
Packit |
423ecb |
if (ctxt->base != NULL) {
|
|
Packit |
423ecb |
xmlFree(ctxt->base);
|
|
Packit |
423ecb |
}
|
|
Packit |
423ecb |
xmlFree(ctxt);
|
|
Packit |
423ecb |
}
|
|
Packit |
423ecb |
|
|
Packit |
423ecb |
/**
|
|
Packit |
423ecb |
* xmlXIncludeParseFile:
|
|
Packit |
423ecb |
* @ctxt: the XInclude context
|
|
Packit |
423ecb |
* @URL: the URL or file path
|
|
Packit |
423ecb |
*
|
|
Packit |
423ecb |
* parse a document for XInclude
|
|
Packit |
423ecb |
*/
|
|
Packit |
423ecb |
static xmlDocPtr
|
|
Packit |
423ecb |
xmlXIncludeParseFile(xmlXIncludeCtxtPtr ctxt, const char *URL) {
|
|
Packit |
423ecb |
xmlDocPtr ret;
|
|
Packit |
423ecb |
xmlParserCtxtPtr pctxt;
|
|
Packit |
423ecb |
xmlParserInputPtr inputStream;
|
|
Packit |
423ecb |
|
|
Packit |
423ecb |
xmlInitParser();
|
|
Packit |
423ecb |
|
|
Packit |
423ecb |
pctxt = xmlNewParserCtxt();
|
|
Packit |
423ecb |
if (pctxt == NULL) {
|
|
Packit |
423ecb |
xmlXIncludeErrMemory(ctxt, NULL, "cannot allocate parser context");
|
|
Packit |
423ecb |
return(NULL);
|
|
Packit |
423ecb |
}
|
|
Packit |
423ecb |
|
|
Packit |
423ecb |
/*
|
|
Packit |
423ecb |
* pass in the application data to the parser context.
|
|
Packit |
423ecb |
*/
|
|
Packit |
423ecb |
pctxt->_private = ctxt->_private;
|
|
Packit |
423ecb |
|
|
Packit |
423ecb |
/*
|
|
Packit |
423ecb |
* try to ensure that new documents included are actually
|
|
Packit |
423ecb |
* built with the same dictionary as the including document.
|
|
Packit |
423ecb |
*/
|
|
Packit |
423ecb |
if ((ctxt->doc != NULL) && (ctxt->doc->dict != NULL)) {
|
|
Packit |
423ecb |
if (pctxt->dict != NULL)
|
|
Packit |
423ecb |
xmlDictFree(pctxt->dict);
|
|
Packit |
423ecb |
pctxt->dict = ctxt->doc->dict;
|
|
Packit |
423ecb |
xmlDictReference(pctxt->dict);
|
|
Packit |
423ecb |
}
|
|
Packit |
423ecb |
|
|
Packit |
423ecb |
xmlCtxtUseOptions(pctxt, ctxt->parseFlags | XML_PARSE_DTDLOAD);
|
|
Packit |
423ecb |
|
|
Packit |
423ecb |
inputStream = xmlLoadExternalEntity(URL, NULL, pctxt);
|
|
Packit |
423ecb |
if (inputStream == NULL) {
|
|
Packit |
423ecb |
xmlFreeParserCtxt(pctxt);
|
|
Packit |
423ecb |
return(NULL);
|
|
Packit |
423ecb |
}
|
|
Packit |
423ecb |
|
|
Packit |
423ecb |
inputPush(pctxt, inputStream);
|
|
Packit |
423ecb |
|
|
Packit |
423ecb |
if (pctxt->directory == NULL)
|
|
Packit |
423ecb |
pctxt->directory = xmlParserGetDirectory(URL);
|
|
Packit |
423ecb |
|
|
Packit |
423ecb |
pctxt->loadsubset |= XML_DETECT_IDS;
|
|
Packit |
423ecb |
|
|
Packit |
423ecb |
xmlParseDocument(pctxt);
|
|
Packit |
423ecb |
|
|
Packit |
423ecb |
if (pctxt->wellFormed) {
|
|
Packit |
423ecb |
ret = pctxt->myDoc;
|
|
Packit |
423ecb |
}
|
|
Packit |
423ecb |
else {
|
|
Packit |
423ecb |
ret = NULL;
|
|
Packit |
423ecb |
if (pctxt->myDoc != NULL)
|
|
Packit |
423ecb |
xmlFreeDoc(pctxt->myDoc);
|
|
Packit |
423ecb |
pctxt->myDoc = NULL;
|
|
Packit |
423ecb |
}
|
|
Packit |
423ecb |
xmlFreeParserCtxt(pctxt);
|
|
Packit |
423ecb |
|
|
Packit |
423ecb |
return(ret);
|
|
Packit |
423ecb |
}
|
|
Packit |
423ecb |
|
|
Packit |
423ecb |
/**
|
|
Packit |
423ecb |
* xmlXIncludeAddNode:
|
|
Packit |
423ecb |
* @ctxt: the XInclude context
|
|
Packit |
423ecb |
* @cur: the new node
|
|
Packit |
423ecb |
*
|
|
Packit |
423ecb |
* Add a new node to process to an XInclude context
|
|
Packit |
423ecb |
*/
|
|
Packit |
423ecb |
static int
|
|
Packit |
423ecb |
xmlXIncludeAddNode(xmlXIncludeCtxtPtr ctxt, xmlNodePtr cur) {
|
|
Packit |
423ecb |
xmlXIncludeRefPtr ref;
|
|
Packit |
423ecb |
xmlURIPtr uri;
|
|
Packit |
423ecb |
xmlChar *URL;
|
|
Packit |
423ecb |
xmlChar *fragment = NULL;
|
|
Packit |
423ecb |
xmlChar *href;
|
|
Packit |
423ecb |
xmlChar *parse;
|
|
Packit |
423ecb |
xmlChar *base;
|
|
Packit |
423ecb |
xmlChar *URI;
|
|
Packit |
423ecb |
int xml = 1, i; /* default Issue 64 */
|
|
Packit |
423ecb |
int local = 0;
|
|
Packit |
423ecb |
|
|
Packit |
423ecb |
|
|
Packit |
423ecb |
if (ctxt == NULL)
|
|
Packit |
423ecb |
return(-1);
|
|
Packit |
423ecb |
if (cur == NULL)
|
|
Packit |
423ecb |
return(-1);
|
|
Packit |
423ecb |
|
|
Packit |
423ecb |
#ifdef DEBUG_XINCLUDE
|
|
Packit |
423ecb |
xmlGenericError(xmlGenericErrorContext, "Add node\n");
|
|
Packit |
423ecb |
#endif
|
|
Packit |
423ecb |
/*
|
|
Packit |
423ecb |
* read the attributes
|
|
Packit |
423ecb |
*/
|
|
Packit |
423ecb |
href = xmlXIncludeGetProp(ctxt, cur, XINCLUDE_HREF);
|
|
Packit |
423ecb |
if (href == NULL) {
|
|
Packit |
423ecb |
href = xmlStrdup(BAD_CAST ""); /* @@@@ href is now optional */
|
|
Packit |
423ecb |
if (href == NULL)
|
|
Packit |
423ecb |
return(-1);
|
|
Packit |
423ecb |
}
|
|
Packit |
423ecb |
if ((href[0] == '#') || (href[0] == 0))
|
|
Packit |
423ecb |
local = 1;
|
|
Packit |
423ecb |
parse = xmlXIncludeGetProp(ctxt, cur, XINCLUDE_PARSE);
|
|
Packit |
423ecb |
if (parse != NULL) {
|
|
Packit |
423ecb |
if (xmlStrEqual(parse, XINCLUDE_PARSE_XML))
|
|
Packit |
423ecb |
xml = 1;
|
|
Packit |
423ecb |
else if (xmlStrEqual(parse, XINCLUDE_PARSE_TEXT))
|
|
Packit |
423ecb |
xml = 0;
|
|
Packit |
423ecb |
else {
|
|
Packit |
423ecb |
xmlXIncludeErr(ctxt, cur, XML_XINCLUDE_PARSE_VALUE,
|
|
Packit |
423ecb |
"invalid value %s for 'parse'\n", parse);
|
|
Packit |
423ecb |
if (href != NULL)
|
|
Packit |
423ecb |
xmlFree(href);
|
|
Packit |
423ecb |
if (parse != NULL)
|
|
Packit |
423ecb |
xmlFree(parse);
|
|
Packit |
423ecb |
return(-1);
|
|
Packit |
423ecb |
}
|
|
Packit |
423ecb |
}
|
|
Packit |
423ecb |
|
|
Packit |
423ecb |
/*
|
|
Packit |
423ecb |
* compute the URI
|
|
Packit |
423ecb |
*/
|
|
Packit |
423ecb |
base = xmlNodeGetBase(ctxt->doc, cur);
|
|
Packit |
423ecb |
if (base == NULL) {
|
|
Packit |
423ecb |
URI = xmlBuildURI(href, ctxt->doc->URL);
|
|
Packit |
423ecb |
} else {
|
|
Packit |
423ecb |
URI = xmlBuildURI(href, base);
|
|
Packit |
423ecb |
}
|
|
Packit |
423ecb |
if (URI == NULL) {
|
|
Packit |
423ecb |
xmlChar *escbase;
|
|
Packit |
423ecb |
xmlChar *eschref;
|
|
Packit |
423ecb |
/*
|
|
Packit |
423ecb |
* Some escaping may be needed
|
|
Packit |
423ecb |
*/
|
|
Packit |
423ecb |
escbase = xmlURIEscape(base);
|
|
Packit |
423ecb |
eschref = xmlURIEscape(href);
|
|
Packit |
423ecb |
URI = xmlBuildURI(eschref, escbase);
|
|
Packit |
423ecb |
if (escbase != NULL)
|
|
Packit |
423ecb |
xmlFree(escbase);
|
|
Packit |
423ecb |
if (eschref != NULL)
|
|
Packit |
423ecb |
xmlFree(eschref);
|
|
Packit |
423ecb |
}
|
|
Packit |
423ecb |
if (parse != NULL)
|
|
Packit |
423ecb |
xmlFree(parse);
|
|
Packit |
423ecb |
if (href != NULL)
|
|
Packit |
423ecb |
xmlFree(href);
|
|
Packit |
423ecb |
if (base != NULL)
|
|
Packit |
423ecb |
xmlFree(base);
|
|
Packit |
423ecb |
if (URI == NULL) {
|
|
Packit |
423ecb |
xmlXIncludeErr(ctxt, cur, XML_XINCLUDE_HREF_URI,
|
|
Packit |
423ecb |
"failed build URL\n", NULL);
|
|
Packit |
423ecb |
return(-1);
|
|
Packit |
423ecb |
}
|
|
Packit |
423ecb |
fragment = xmlXIncludeGetProp(ctxt, cur, XINCLUDE_PARSE_XPOINTER);
|
|
Packit |
423ecb |
|
|
Packit |
423ecb |
/*
|
|
Packit |
423ecb |
* Check the URL and remove any fragment identifier
|
|
Packit |
423ecb |
*/
|
|
Packit |
423ecb |
uri = xmlParseURI((const char *)URI);
|
|
Packit |
423ecb |
if (uri == NULL) {
|
|
Packit |
423ecb |
xmlXIncludeErr(ctxt, cur, XML_XINCLUDE_HREF_URI,
|
|
Packit |
423ecb |
"invalid value URI %s\n", URI);
|
|
Packit |
423ecb |
if (fragment != NULL)
|
|
Packit |
423ecb |
xmlFree(fragment);
|
|
Packit |
423ecb |
xmlFree(URI);
|
|
Packit |
423ecb |
return(-1);
|
|
Packit |
423ecb |
}
|
|
Packit |
423ecb |
|
|
Packit |
423ecb |
if (uri->fragment != NULL) {
|
|
Packit |
423ecb |
if (ctxt->legacy != 0) {
|
|
Packit |
423ecb |
if (fragment == NULL) {
|
|
Packit |
423ecb |
fragment = (xmlChar *) uri->fragment;
|
|
Packit |
423ecb |
} else {
|
|
Packit |
423ecb |
xmlFree(uri->fragment);
|
|
Packit |
423ecb |
}
|
|
Packit |
423ecb |
} else {
|
|
Packit |
423ecb |
xmlXIncludeErr(ctxt, cur, XML_XINCLUDE_FRAGMENT_ID,
|
|
Packit |
423ecb |
"Invalid fragment identifier in URI %s use the xpointer attribute\n",
|
|
Packit |
423ecb |
URI);
|
|
Packit |
423ecb |
if (fragment != NULL)
|
|
Packit |
423ecb |
xmlFree(fragment);
|
|
Packit |
423ecb |
xmlFreeURI(uri);
|
|
Packit |
423ecb |
xmlFree(URI);
|
|
Packit |
423ecb |
return(-1);
|
|
Packit |
423ecb |
}
|
|
Packit |
423ecb |
uri->fragment = NULL;
|
|
Packit |
423ecb |
}
|
|
Packit |
423ecb |
URL = xmlSaveUri(uri);
|
|
Packit |
423ecb |
xmlFreeURI(uri);
|
|
Packit |
423ecb |
xmlFree(URI);
|
|
Packit |
423ecb |
if (URL == NULL) {
|
|
Packit |
423ecb |
xmlXIncludeErr(ctxt, cur, XML_XINCLUDE_HREF_URI,
|
|
Packit |
423ecb |
"invalid value URI %s\n", URI);
|
|
Packit |
423ecb |
if (fragment != NULL)
|
|
Packit |
423ecb |
xmlFree(fragment);
|
|
Packit |
423ecb |
return(-1);
|
|
Packit |
423ecb |
}
|
|
Packit |
423ecb |
|
|
Packit |
423ecb |
/*
|
|
Packit |
423ecb |
* If local and xml then we need a fragment
|
|
Packit |
423ecb |
*/
|
|
Packit |
423ecb |
if ((local == 1) && (xml == 1) &&
|
|
Packit |
423ecb |
((fragment == NULL) || (fragment[0] == 0))) {
|
|
Packit |
423ecb |
xmlXIncludeErr(ctxt, cur, XML_XINCLUDE_RECURSION,
|
|
Packit |
423ecb |
"detected a local recursion with no xpointer in %s\n",
|
|
Packit |
423ecb |
URL);
|
|
Packit |
423ecb |
if (fragment != NULL)
|
|
Packit |
423ecb |
xmlFree(fragment);
|
|
Packit |
423ecb |
return(-1);
|
|
Packit |
423ecb |
}
|
|
Packit |
423ecb |
|
|
Packit |
423ecb |
/*
|
|
Packit |
423ecb |
* Check the URL against the stack for recursions
|
|
Packit |
423ecb |
*/
|
|
Packit |
423ecb |
if ((!local) && (xml == 1)) {
|
|
Packit |
423ecb |
for (i = 0;i < ctxt->urlNr;i++) {
|
|
Packit |
423ecb |
if (xmlStrEqual(URL, ctxt->urlTab[i])) {
|
|
Packit |
423ecb |
xmlXIncludeErr(ctxt, cur, XML_XINCLUDE_RECURSION,
|
|
Packit |
423ecb |
"detected a recursion in %s\n", URL);
|
|
Packit |
423ecb |
return(-1);
|
|
Packit |
423ecb |
}
|
|
Packit |
423ecb |
}
|
|
Packit |
423ecb |
}
|
|
Packit |
423ecb |
|
|
Packit |
423ecb |
ref = xmlXIncludeNewRef(ctxt, URL, cur);
|
|
Packit |
423ecb |
if (ref == NULL) {
|
|
Packit |
423ecb |
return(-1);
|
|
Packit |
423ecb |
}
|
|
Packit |
423ecb |
ref->fragment = fragment;
|
|
Packit |
423ecb |
ref->doc = NULL;
|
|
Packit |
423ecb |
ref->xml = xml;
|
|
Packit |
423ecb |
ref->count = 1;
|
|
Packit |
423ecb |
xmlFree(URL);
|
|
Packit |
423ecb |
return(0);
|
|
Packit |
423ecb |
}
|
|
Packit |
423ecb |
|
|
Packit |
423ecb |
/**
|
|
Packit |
423ecb |
* xmlXIncludeRecurseDoc:
|
|
Packit |
423ecb |
* @ctxt: the XInclude context
|
|
Packit |
423ecb |
* @doc: the new document
|
|
Packit |
423ecb |
* @url: the associated URL
|
|
Packit |
423ecb |
*
|
|
Packit |
423ecb |
* The XInclude recursive nature is handled at this point.
|
|
Packit |
423ecb |
*/
|
|
Packit |
423ecb |
static void
|
|
Packit |
423ecb |
xmlXIncludeRecurseDoc(xmlXIncludeCtxtPtr ctxt, xmlDocPtr doc,
|
|
Packit |
423ecb |
const xmlURL url ATTRIBUTE_UNUSED) {
|
|
Packit |
423ecb |
xmlXIncludeCtxtPtr newctxt;
|
|
Packit |
423ecb |
int i;
|
|
Packit |
423ecb |
|
|
Packit |
423ecb |
/*
|
|
Packit |
423ecb |
* Avoid recursion in already substitued resources
|
|
Packit |
423ecb |
for (i = 0;i < ctxt->urlNr;i++) {
|
|
Packit |
423ecb |
if (xmlStrEqual(doc->URL, ctxt->urlTab[i]))
|
|
Packit |
423ecb |
return;
|
|
Packit |
423ecb |
}
|
|
Packit |
423ecb |
*/
|
|
Packit |
423ecb |
|
|
Packit |
423ecb |
#ifdef DEBUG_XINCLUDE
|
|
Packit |
423ecb |
xmlGenericError(xmlGenericErrorContext, "Recursing in doc %s\n", doc->URL);
|
|
Packit |
423ecb |
#endif
|
|
Packit |
423ecb |
/*
|
|
Packit |
423ecb |
* Handle recursion here.
|
|
Packit |
423ecb |
*/
|
|
Packit |
423ecb |
|
|
Packit |
423ecb |
newctxt = xmlXIncludeNewContext(doc);
|
|
Packit |
423ecb |
if (newctxt != NULL) {
|
|
Packit |
423ecb |
/*
|
|
Packit |
423ecb |
* Copy the private user data
|
|
Packit |
423ecb |
*/
|
|
Packit |
423ecb |
newctxt->_private = ctxt->_private;
|
|
Packit |
423ecb |
/*
|
|
Packit |
423ecb |
* Copy the existing document set
|
|
Packit |
423ecb |
*/
|
|
Packit |
423ecb |
newctxt->incMax = ctxt->incMax;
|
|
Packit |
423ecb |
newctxt->incNr = ctxt->incNr;
|
|
Packit |
423ecb |
newctxt->incTab = (xmlXIncludeRefPtr *) xmlMalloc(newctxt->incMax *
|
|
Packit |
423ecb |
sizeof(newctxt->incTab[0]));
|
|
Packit |
423ecb |
if (newctxt->incTab == NULL) {
|
|
Packit |
423ecb |
xmlXIncludeErrMemory(ctxt, (xmlNodePtr) doc, "processing doc");
|
|
Packit |
423ecb |
xmlFree(newctxt);
|
|
Packit |
423ecb |
return;
|
|
Packit |
423ecb |
}
|
|
Packit |
423ecb |
/*
|
|
Packit |
423ecb |
* copy the urlTab
|
|
Packit |
423ecb |
*/
|
|
Packit |
423ecb |
newctxt->urlMax = ctxt->urlMax;
|
|
Packit |
423ecb |
newctxt->urlNr = ctxt->urlNr;
|
|
Packit |
423ecb |
newctxt->urlTab = ctxt->urlTab;
|
|
Packit |
423ecb |
|
|
Packit |
423ecb |
/*
|
|
Packit |
423ecb |
* Inherit the existing base
|
|
Packit |
423ecb |
*/
|
|
Packit |
423ecb |
newctxt->base = xmlStrdup(ctxt->base);
|
|
Packit |
423ecb |
|
|
Packit |
423ecb |
/*
|
|
Packit |
423ecb |
* Inherit the documents already in use by other includes
|
|
Packit |
423ecb |
*/
|
|
Packit |
423ecb |
newctxt->incBase = ctxt->incNr;
|
|
Packit |
423ecb |
for (i = 0;i < ctxt->incNr;i++) {
|
|
Packit |
423ecb |
newctxt->incTab[i] = ctxt->incTab[i];
|
|
Packit |
423ecb |
newctxt->incTab[i]->count++; /* prevent the recursion from
|
|
Packit |
423ecb |
freeing it */
|
|
Packit |
423ecb |
}
|
|
Packit |
423ecb |
/*
|
|
Packit |
423ecb |
* The new context should also inherit the Parse Flags
|
|
Packit |
423ecb |
* (bug 132597)
|
|
Packit |
423ecb |
*/
|
|
Packit |
423ecb |
newctxt->parseFlags = ctxt->parseFlags;
|
|
Packit |
423ecb |
xmlXIncludeDoProcess(newctxt, doc, xmlDocGetRootElement(doc));
|
|
Packit |
423ecb |
for (i = 0;i < ctxt->incNr;i++) {
|
|
Packit |
423ecb |
newctxt->incTab[i]->count--;
|
|
Packit |
423ecb |
newctxt->incTab[i] = NULL;
|
|
Packit |
423ecb |
}
|
|
Packit |
423ecb |
|
|
Packit |
423ecb |
/* urlTab may have been reallocated */
|
|
Packit |
423ecb |
ctxt->urlTab = newctxt->urlTab;
|
|
Packit |
423ecb |
ctxt->urlMax = newctxt->urlMax;
|
|
Packit |
423ecb |
|
|
Packit |
423ecb |
newctxt->urlMax = 0;
|
|
Packit |
423ecb |
newctxt->urlNr = 0;
|
|
Packit |
423ecb |
newctxt->urlTab = NULL;
|
|
Packit |
423ecb |
|
|
Packit |
423ecb |
xmlXIncludeFreeContext(newctxt);
|
|
Packit |
423ecb |
}
|
|
Packit |
423ecb |
#ifdef DEBUG_XINCLUDE
|
|
Packit |
423ecb |
xmlGenericError(xmlGenericErrorContext, "Done recursing in doc %s\n", url);
|
|
Packit |
423ecb |
#endif
|
|
Packit |
423ecb |
}
|
|
Packit |
423ecb |
|
|
Packit |
423ecb |
/**
|
|
Packit |
423ecb |
* xmlXIncludeAddTxt:
|
|
Packit |
423ecb |
* @ctxt: the XInclude context
|
|
Packit |
423ecb |
* @txt: the new text node
|
|
Packit |
423ecb |
* @url: the associated URL
|
|
Packit |
423ecb |
*
|
|
Packit |
423ecb |
* Add a new txtument to the list
|
|
Packit |
423ecb |
*/
|
|
Packit |
423ecb |
static void
|
|
Packit |
423ecb |
xmlXIncludeAddTxt(xmlXIncludeCtxtPtr ctxt, xmlNodePtr txt, const xmlURL url) {
|
|
Packit |
423ecb |
#ifdef DEBUG_XINCLUDE
|
|
Packit |
423ecb |
xmlGenericError(xmlGenericErrorContext, "Adding text %s\n", url);
|
|
Packit |
423ecb |
#endif
|
|
Packit |
423ecb |
if (ctxt->txtMax == 0) {
|
|
Packit |
423ecb |
ctxt->txtMax = 4;
|
|
Packit |
423ecb |
ctxt->txtTab = (xmlNodePtr *) xmlMalloc(ctxt->txtMax *
|
|
Packit |
423ecb |
sizeof(ctxt->txtTab[0]));
|
|
Packit |
423ecb |
if (ctxt->txtTab == NULL) {
|
|
Packit |
423ecb |
xmlXIncludeErrMemory(ctxt, NULL, "processing text");
|
|
Packit |
423ecb |
return;
|
|
Packit |
423ecb |
}
|
|
Packit |
423ecb |
ctxt->txturlTab = (xmlURL *) xmlMalloc(ctxt->txtMax *
|
|
Packit |
423ecb |
sizeof(ctxt->txturlTab[0]));
|
|
Packit |
423ecb |
if (ctxt->txturlTab == NULL) {
|
|
Packit |
423ecb |
xmlXIncludeErrMemory(ctxt, NULL, "processing text");
|
|
Packit |
423ecb |
return;
|
|
Packit |
423ecb |
}
|
|
Packit |
423ecb |
}
|
|
Packit |
423ecb |
if (ctxt->txtNr >= ctxt->txtMax) {
|
|
Packit |
423ecb |
ctxt->txtMax *= 2;
|
|
Packit |
423ecb |
ctxt->txtTab = (xmlNodePtr *) xmlRealloc(ctxt->txtTab,
|
|
Packit |
423ecb |
ctxt->txtMax * sizeof(ctxt->txtTab[0]));
|
|
Packit |
423ecb |
if (ctxt->txtTab == NULL) {
|
|
Packit |
423ecb |
xmlXIncludeErrMemory(ctxt, NULL, "processing text");
|
|
Packit |
423ecb |
return;
|
|
Packit |
423ecb |
}
|
|
Packit |
423ecb |
ctxt->txturlTab = (xmlURL *) xmlRealloc(ctxt->txturlTab,
|
|
Packit |
423ecb |
ctxt->txtMax * sizeof(ctxt->txturlTab[0]));
|
|
Packit |
423ecb |
if (ctxt->txturlTab == NULL) {
|
|
Packit |
423ecb |
xmlXIncludeErrMemory(ctxt, NULL, "processing text");
|
|
Packit |
423ecb |
return;
|
|
Packit |
423ecb |
}
|
|
Packit |
423ecb |
}
|
|
Packit |
423ecb |
ctxt->txtTab[ctxt->txtNr] = txt;
|
|
Packit |
423ecb |
ctxt->txturlTab[ctxt->txtNr] = xmlStrdup(url);
|
|
Packit |
423ecb |
ctxt->txtNr++;
|
|
Packit |
423ecb |
}
|
|
Packit |
423ecb |
|
|
Packit |
423ecb |
/************************************************************************
|
|
Packit |
423ecb |
* *
|
|
Packit |
423ecb |
* Node copy with specific semantic *
|
|
Packit |
423ecb |
* *
|
|
Packit |
423ecb |
************************************************************************/
|
|
Packit |
423ecb |
|
|
Packit |
423ecb |
static xmlNodePtr
|
|
Packit |
423ecb |
xmlXIncludeCopyNodeList(xmlXIncludeCtxtPtr ctxt, xmlDocPtr target,
|
|
Packit |
423ecb |
xmlDocPtr source, xmlNodePtr elem);
|
|
Packit |
423ecb |
|
|
Packit |
423ecb |
/**
|
|
Packit |
423ecb |
* xmlXIncludeCopyNode:
|
|
Packit |
423ecb |
* @ctxt: the XInclude context
|
|
Packit |
423ecb |
* @target: the document target
|
|
Packit |
423ecb |
* @source: the document source
|
|
Packit |
423ecb |
* @elem: the element
|
|
Packit |
423ecb |
*
|
|
Packit |
423ecb |
* Make a copy of the node while preserving the XInclude semantic
|
|
Packit |
423ecb |
* of the Infoset copy
|
|
Packit |
423ecb |
*/
|
|
Packit |
423ecb |
static xmlNodePtr
|
|
Packit |
423ecb |
xmlXIncludeCopyNode(xmlXIncludeCtxtPtr ctxt, xmlDocPtr target,
|
|
Packit |
423ecb |
xmlDocPtr source, xmlNodePtr elem) {
|
|
Packit |
423ecb |
xmlNodePtr result = NULL;
|
|
Packit |
423ecb |
|
|
Packit |
423ecb |
if ((ctxt == NULL) || (target == NULL) || (source == NULL) ||
|
|
Packit |
423ecb |
(elem == NULL))
|
|
Packit |
423ecb |
return(NULL);
|
|
Packit |
423ecb |
if (elem->type == XML_DTD_NODE)
|
|
Packit |
423ecb |
return(NULL);
|
|
Packit |
423ecb |
if (elem->type == XML_DOCUMENT_NODE)
|
|
Packit |
423ecb |
result = xmlXIncludeCopyNodeList(ctxt, target, source, elem->children);
|
|
Packit |
423ecb |
else
|
|
Packit |
423ecb |
result = xmlDocCopyNode(elem, target, 1);
|
|
Packit |
423ecb |
return(result);
|
|
Packit |
423ecb |
}
|
|
Packit |
423ecb |
|
|
Packit |
423ecb |
/**
|
|
Packit |
423ecb |
* xmlXIncludeCopyNodeList:
|
|
Packit |
423ecb |
* @ctxt: the XInclude context
|
|
Packit |
423ecb |
* @target: the document target
|
|
Packit |
423ecb |
* @source: the document source
|
|
Packit |
423ecb |
* @elem: the element list
|
|
Packit |
423ecb |
*
|
|
Packit |
423ecb |
* Make a copy of the node list while preserving the XInclude semantic
|
|
Packit |
423ecb |
* of the Infoset copy
|
|
Packit |
423ecb |
*/
|
|
Packit |
423ecb |
static xmlNodePtr
|
|
Packit |
423ecb |
xmlXIncludeCopyNodeList(xmlXIncludeCtxtPtr ctxt, xmlDocPtr target,
|
|
Packit |
423ecb |
xmlDocPtr source, xmlNodePtr elem) {
|
|
Packit |
423ecb |
xmlNodePtr cur, res, result = NULL, last = NULL;
|
|
Packit |
423ecb |
|
|
Packit |
423ecb |
if ((ctxt == NULL) || (target == NULL) || (source == NULL) ||
|
|
Packit |
423ecb |
(elem == NULL))
|
|
Packit |
423ecb |
return(NULL);
|
|
Packit |
423ecb |
cur = elem;
|
|
Packit |
423ecb |
while (cur != NULL) {
|
|
Packit |
423ecb |
res = xmlXIncludeCopyNode(ctxt, target, source, cur);
|
|
Packit |
423ecb |
if (res != NULL) {
|
|
Packit |
423ecb |
if (result == NULL) {
|
|
Packit |
423ecb |
result = last = res;
|
|
Packit |
423ecb |
} else {
|
|
Packit |
423ecb |
last->next = res;
|
|
Packit |
423ecb |
res->prev = last;
|
|
Packit |
423ecb |
last = res;
|
|
Packit |
423ecb |
}
|
|
Packit |
423ecb |
}
|
|
Packit |
423ecb |
cur = cur->next;
|
|
Packit |
423ecb |
}
|
|
Packit |
423ecb |
return(result);
|
|
Packit |
423ecb |
}
|
|
Packit |
423ecb |
|
|
Packit |
423ecb |
/**
|
|
Packit |
423ecb |
* xmlXIncludeGetNthChild:
|
|
Packit |
423ecb |
* @cur: the node
|
|
Packit |
423ecb |
* @no: the child number
|
|
Packit |
423ecb |
*
|
|
Packit |
423ecb |
* Returns the @n'th element child of @cur or NULL
|
|
Packit |
423ecb |
*/
|
|
Packit |
423ecb |
static xmlNodePtr
|
|
Packit |
423ecb |
xmlXIncludeGetNthChild(xmlNodePtr cur, int no) {
|
|
Packit |
423ecb |
int i;
|
|
Packit |
423ecb |
if ((cur == NULL) || (cur->type == XML_NAMESPACE_DECL))
|
|
Packit |
423ecb |
return(NULL);
|
|
Packit |
423ecb |
cur = cur->children;
|
|
Packit |
423ecb |
for (i = 0;i <= no;cur = cur->next) {
|
|
Packit |
423ecb |
if (cur == NULL)
|
|
Packit |
423ecb |
return(cur);
|
|
Packit |
423ecb |
if ((cur->type == XML_ELEMENT_NODE) ||
|
|
Packit |
423ecb |
(cur->type == XML_DOCUMENT_NODE) ||
|
|
Packit |
423ecb |
(cur->type == XML_HTML_DOCUMENT_NODE)) {
|
|
Packit |
423ecb |
i++;
|
|
Packit |
423ecb |
if (i == no)
|
|
Packit |
423ecb |
break;
|
|
Packit |
423ecb |
}
|
|
Packit |
423ecb |
}
|
|
Packit |
423ecb |
return(cur);
|
|
Packit |
423ecb |
}
|
|
Packit |
423ecb |
|
|
Packit |
423ecb |
xmlNodePtr xmlXPtrAdvanceNode(xmlNodePtr cur, int *level); /* in xpointer.c */
|
|
Packit |
423ecb |
/**
|
|
Packit |
423ecb |
* xmlXIncludeCopyRange:
|
|
Packit |
423ecb |
* @ctxt: the XInclude context
|
|
Packit |
423ecb |
* @target: the document target
|
|
Packit |
423ecb |
* @source: the document source
|
|
Packit |
423ecb |
* @obj: the XPointer result from the evaluation.
|
|
Packit |
423ecb |
*
|
|
Packit |
423ecb |
* Build a node list tree copy of the XPointer result.
|
|
Packit |
423ecb |
*
|
|
Packit |
423ecb |
* Returns an xmlNodePtr list or NULL.
|
|
Packit |
423ecb |
* The caller has to free the node tree.
|
|
Packit |
423ecb |
*/
|
|
Packit |
423ecb |
static xmlNodePtr
|
|
Packit |
423ecb |
xmlXIncludeCopyRange(xmlXIncludeCtxtPtr ctxt, xmlDocPtr target,
|
|
Packit |
423ecb |
xmlDocPtr source, xmlXPathObjectPtr range) {
|
|
Packit |
423ecb |
/* pointers to generated nodes */
|
|
Packit |
423ecb |
xmlNodePtr list = NULL, last = NULL, listParent = NULL;
|
|
Packit |
423ecb |
xmlNodePtr tmp, tmp2;
|
|
Packit |
423ecb |
/* pointers to traversal nodes */
|
|
Packit |
423ecb |
xmlNodePtr start, cur, end;
|
|
Packit |
423ecb |
int index1, index2;
|
|
Packit |
423ecb |
int level = 0, lastLevel = 0, endLevel = 0, endFlag = 0;
|
|
Packit |
423ecb |
|
|
Packit |
423ecb |
if ((ctxt == NULL) || (target == NULL) || (source == NULL) ||
|
|
Packit |
423ecb |
(range == NULL))
|
|
Packit |
423ecb |
return(NULL);
|
|
Packit |
423ecb |
if (range->type != XPATH_RANGE)
|
|
Packit |
423ecb |
return(NULL);
|
|
Packit |
423ecb |
start = (xmlNodePtr) range->user;
|
|
Packit |
423ecb |
|
|
Packit |
423ecb |
if ((start == NULL) || (start->type == XML_NAMESPACE_DECL))
|
|
Packit |
423ecb |
return(NULL);
|
|
Packit |
423ecb |
end = range->user2;
|
|
Packit |
423ecb |
if (end == NULL)
|
|
Packit |
423ecb |
return(xmlDocCopyNode(start, target, 1));
|
|
Packit |
423ecb |
if (end->type == XML_NAMESPACE_DECL)
|
|
Packit |
423ecb |
return(NULL);
|
|
Packit |
423ecb |
|
|
Packit |
423ecb |
cur = start;
|
|
Packit |
423ecb |
index1 = range->index;
|
|
Packit |
423ecb |
index2 = range->index2;
|
|
Packit |
423ecb |
/*
|
|
Packit |
423ecb |
* level is depth of the current node under consideration
|
|
Packit |
423ecb |
* list is the pointer to the root of the output tree
|
|
Packit |
423ecb |
* listParent is a pointer to the parent of output tree (within
|
|
Packit |
423ecb |
the included file) in case we need to add another level
|
|
Packit |
423ecb |
* last is a pointer to the last node added to the output tree
|
|
Packit |
423ecb |
* lastLevel is the depth of last (relative to the root)
|
|
Packit |
423ecb |
*/
|
|
Packit |
423ecb |
while (cur != NULL) {
|
|
Packit |
423ecb |
/*
|
|
Packit |
423ecb |
* Check if our output tree needs a parent
|
|
Packit |
423ecb |
*/
|
|
Packit |
423ecb |
if (level < 0) {
|
|
Packit |
423ecb |
while (level < 0) {
|
|
Packit |
423ecb |
/* copy must include namespaces and properties */
|
|
Packit |
423ecb |
tmp2 = xmlDocCopyNode(listParent, target, 2);
|
|
Packit |
423ecb |
xmlAddChild(tmp2, list);
|
|
Packit |
423ecb |
list = tmp2;
|
|
Packit |
423ecb |
listParent = listParent->parent;
|
|
Packit |
423ecb |
level++;
|
|
Packit |
423ecb |
}
|
|
Packit |
423ecb |
last = list;
|
|
Packit |
423ecb |
lastLevel = 0;
|
|
Packit |
423ecb |
}
|
|
Packit |
423ecb |
/*
|
|
Packit |
423ecb |
* Check whether we need to change our insertion point
|
|
Packit |
423ecb |
*/
|
|
Packit |
423ecb |
while (level < lastLevel) {
|
|
Packit |
423ecb |
last = last->parent;
|
|
Packit |
423ecb |
lastLevel --;
|
|
Packit |
423ecb |
}
|
|
Packit |
423ecb |
if (cur == end) { /* Are we at the end of the range? */
|
|
Packit |
423ecb |
if (cur->type == XML_TEXT_NODE) {
|
|
Packit |
423ecb |
const xmlChar *content = cur->content;
|
|
Packit |
423ecb |
int len;
|
|
Packit |
423ecb |
|
|
Packit |
423ecb |
if (content == NULL) {
|
|
Packit |
423ecb |
tmp = xmlNewTextLen(NULL, 0);
|
|
Packit |
423ecb |
} else {
|
|
Packit |
423ecb |
len = index2;
|
|
Packit |
423ecb |
if ((cur == start) && (index1 > 1)) {
|
|
Packit |
423ecb |
content += (index1 - 1);
|
|
Packit |
423ecb |
len -= (index1 - 1);
|
|
Packit |
423ecb |
} else {
|
|
Packit |
423ecb |
len = index2;
|
|
Packit |
423ecb |
}
|
|
Packit |
423ecb |
tmp = xmlNewTextLen(content, len);
|
|
Packit |
423ecb |
}
|
|
Packit |
423ecb |
/* single sub text node selection */
|
|
Packit |
423ecb |
if (list == NULL)
|
|
Packit |
423ecb |
return(tmp);
|
|
Packit |
423ecb |
/* prune and return full set */
|
|
Packit |
423ecb |
if (level == lastLevel)
|
|
Packit |
423ecb |
xmlAddNextSibling(last, tmp);
|
|
Packit |
423ecb |
else
|
|
Packit |
423ecb |
xmlAddChild(last, tmp);
|
|
Packit |
423ecb |
return(list);
|
|
Packit |
423ecb |
} else { /* ending node not a text node */
|
|
Packit |
423ecb |
endLevel = level; /* remember the level of the end node */
|
|
Packit |
423ecb |
endFlag = 1;
|
|
Packit |
423ecb |
/* last node - need to take care of properties + namespaces */
|
|
Packit |
423ecb |
tmp = xmlDocCopyNode(cur, target, 2);
|
|
Packit |
423ecb |
if (list == NULL) {
|
|
Packit |
423ecb |
list = tmp;
|
|
Packit |
423ecb |
listParent = cur->parent;
|
|
Packit |
423ecb |
} else {
|
|
Packit |
423ecb |
if (level == lastLevel)
|
|
Packit |
423ecb |
xmlAddNextSibling(last, tmp);
|
|
Packit |
423ecb |
else {
|
|
Packit |
423ecb |
xmlAddChild(last, tmp);
|
|
Packit |
423ecb |
lastLevel = level;
|
|
Packit |
423ecb |
}
|
|
Packit |
423ecb |
}
|
|
Packit |
423ecb |
last = tmp;
|
|
Packit |
423ecb |
|
|
Packit |
423ecb |
if (index2 > 1) {
|
|
Packit |
423ecb |
end = xmlXIncludeGetNthChild(cur, index2 - 1);
|
|
Packit |
423ecb |
index2 = 0;
|
|
Packit |
423ecb |
}
|
|
Packit |
423ecb |
if ((cur == start) && (index1 > 1)) {
|
|
Packit |
423ecb |
cur = xmlXIncludeGetNthChild(cur, index1 - 1);
|
|
Packit |
423ecb |
index1 = 0;
|
|
Packit |
423ecb |
} else {
|
|
Packit |
423ecb |
cur = cur->children;
|
|
Packit |
423ecb |
}
|
|
Packit |
423ecb |
level++; /* increment level to show change */
|
|
Packit |
423ecb |
/*
|
|
Packit |
423ecb |
* Now gather the remaining nodes from cur to end
|
|
Packit |
423ecb |
*/
|
|
Packit |
423ecb |
continue; /* while */
|
|
Packit |
423ecb |
}
|
|
Packit |
423ecb |
} else if (cur == start) { /* Not at the end, are we at start? */
|
|
Packit |
423ecb |
if ((cur->type == XML_TEXT_NODE) ||
|
|
Packit |
423ecb |
(cur->type == XML_CDATA_SECTION_NODE)) {
|
|
Packit |
423ecb |
const xmlChar *content = cur->content;
|
|
Packit |
423ecb |
|
|
Packit |
423ecb |
if (content == NULL) {
|
|
Packit |
423ecb |
tmp = xmlNewTextLen(NULL, 0);
|
|
Packit |
423ecb |
} else {
|
|
Packit |
423ecb |
if (index1 > 1) {
|
|
Packit |
423ecb |
content += (index1 - 1);
|
|
Packit |
423ecb |
index1 = 0;
|
|
Packit |
423ecb |
}
|
|
Packit |
423ecb |
tmp = xmlNewText(content);
|
|
Packit |
423ecb |
}
|
|
Packit |
423ecb |
last = list = tmp;
|
|
Packit |
423ecb |
listParent = cur->parent;
|
|
Packit |
423ecb |
} else { /* Not text node */
|
|
Packit |
423ecb |
/*
|
|
Packit |
423ecb |
* start of the range - need to take care of
|
|
Packit |
423ecb |
* properties and namespaces
|
|
Packit |
423ecb |
*/
|
|
Packit |
423ecb |
tmp = xmlDocCopyNode(cur, target, 2);
|
|
Packit |
423ecb |
list = last = tmp;
|
|
Packit |
423ecb |
listParent = cur->parent;
|
|
Packit |
423ecb |
if (index1 > 1) { /* Do we need to position? */
|
|
Packit |
423ecb |
cur = xmlXIncludeGetNthChild(cur, index1 - 1);
|
|
Packit |
423ecb |
level = lastLevel = 1;
|
|
Packit |
423ecb |
index1 = 0;
|
|
Packit |
423ecb |
/*
|
|
Packit |
423ecb |
* Now gather the remaining nodes from cur to end
|
|
Packit |
423ecb |
*/
|
|
Packit |
423ecb |
continue; /* while */
|
|
Packit |
423ecb |
}
|
|
Packit |
423ecb |
}
|
|
Packit |
423ecb |
} else {
|
|
Packit |
423ecb |
tmp = NULL;
|
|
Packit |
423ecb |
switch (cur->type) {
|
|
Packit |
423ecb |
case XML_DTD_NODE:
|
|
Packit |
423ecb |
case XML_ELEMENT_DECL:
|
|
Packit |
423ecb |
case XML_ATTRIBUTE_DECL:
|
|
Packit |
423ecb |
case XML_ENTITY_NODE:
|
|
Packit |
423ecb |
/* Do not copy DTD informations */
|
|
Packit |
423ecb |
break;
|
|
Packit |
423ecb |
case XML_ENTITY_DECL:
|
|
Packit |
423ecb |
/* handle crossing entities -> stack needed */
|
|
Packit |
423ecb |
break;
|
|
Packit |
423ecb |
case XML_XINCLUDE_START:
|
|
Packit |
423ecb |
case XML_XINCLUDE_END:
|
|
Packit |
423ecb |
/* don't consider it part of the tree content */
|
|
Packit |
423ecb |
break;
|
|
Packit |
423ecb |
case XML_ATTRIBUTE_NODE:
|
|
Packit |
423ecb |
/* Humm, should not happen ! */
|
|
Packit |
423ecb |
break;
|
|
Packit |
423ecb |
default:
|
|
Packit |
423ecb |
/*
|
|
Packit |
423ecb |
* Middle of the range - need to take care of
|
|
Packit |
423ecb |
* properties and namespaces
|
|
Packit |
423ecb |
*/
|
|
Packit |
423ecb |
tmp = xmlDocCopyNode(cur, target, 2);
|
|
Packit |
423ecb |
break;
|
|
Packit |
423ecb |
}
|
|
Packit |
423ecb |
if (tmp != NULL) {
|
|
Packit |
423ecb |
if (level == lastLevel)
|
|
Packit |
423ecb |
xmlAddNextSibling(last, tmp);
|
|
Packit |
423ecb |
else {
|
|
Packit |
423ecb |
xmlAddChild(last, tmp);
|
|
Packit |
423ecb |
lastLevel = level;
|
|
Packit |
423ecb |
}
|
|
Packit |
423ecb |
last = tmp;
|
|
Packit |
423ecb |
}
|
|
Packit |
423ecb |
}
|
|
Packit |
423ecb |
/*
|
|
Packit |
423ecb |
* Skip to next node in document order
|
|
Packit |
423ecb |
*/
|
|
Packit |
423ecb |
cur = xmlXPtrAdvanceNode(cur, &level);
|
|
Packit |
423ecb |
if (endFlag && (level >= endLevel))
|
|
Packit |
423ecb |
break;
|
|
Packit |
423ecb |
}
|
|
Packit |
423ecb |
return(list);
|
|
Packit |
423ecb |
}
|
|
Packit |
423ecb |
|
|
Packit |
423ecb |
/**
|
|
Packit |
423ecb |
* xmlXIncludeBuildNodeList:
|
|
Packit |
423ecb |
* @ctxt: the XInclude context
|
|
Packit |
423ecb |
* @target: the document target
|
|
Packit |
423ecb |
* @source: the document source
|
|
Packit |
423ecb |
* @obj: the XPointer result from the evaluation.
|
|
Packit |
423ecb |
*
|
|
Packit |
423ecb |
* Build a node list tree copy of the XPointer result.
|
|
Packit |
423ecb |
* This will drop Attributes and Namespace declarations.
|
|
Packit |
423ecb |
*
|
|
Packit |
423ecb |
* Returns an xmlNodePtr list or NULL.
|
|
Packit |
423ecb |
* the caller has to free the node tree.
|
|
Packit |
423ecb |
*/
|
|
Packit |
423ecb |
static xmlNodePtr
|
|
Packit |
423ecb |
xmlXIncludeCopyXPointer(xmlXIncludeCtxtPtr ctxt, xmlDocPtr target,
|
|
Packit |
423ecb |
xmlDocPtr source, xmlXPathObjectPtr obj) {
|
|
Packit |
423ecb |
xmlNodePtr list = NULL, last = NULL;
|
|
Packit |
423ecb |
int i;
|
|
Packit |
423ecb |
|
|
Packit |
423ecb |
if (source == NULL)
|
|
Packit |
423ecb |
source = ctxt->doc;
|
|
Packit |
423ecb |
if ((ctxt == NULL) || (target == NULL) || (source == NULL) ||
|
|
Packit |
423ecb |
(obj == NULL))
|
|
Packit |
423ecb |
return(NULL);
|
|
Packit |
423ecb |
switch (obj->type) {
|
|
Packit |
423ecb |
case XPATH_NODESET: {
|
|
Packit |
423ecb |
xmlNodeSetPtr set = obj->nodesetval;
|
|
Packit |
423ecb |
if (set == NULL)
|
|
Packit |
423ecb |
return(NULL);
|
|
Packit |
423ecb |
for (i = 0;i < set->nodeNr;i++) {
|
|
Packit |
423ecb |
if (set->nodeTab[i] == NULL)
|
|
Packit |
423ecb |
continue;
|
|
Packit |
423ecb |
switch (set->nodeTab[i]->type) {
|
|
Packit |
423ecb |
case XML_TEXT_NODE:
|
|
Packit |
423ecb |
case XML_CDATA_SECTION_NODE:
|
|
Packit |
423ecb |
case XML_ELEMENT_NODE:
|
|
Packit |
423ecb |
case XML_ENTITY_REF_NODE:
|
|
Packit |
423ecb |
case XML_ENTITY_NODE:
|
|
Packit |
423ecb |
case XML_PI_NODE:
|
|
Packit |
423ecb |
case XML_COMMENT_NODE:
|
|
Packit |
423ecb |
case XML_DOCUMENT_NODE:
|
|
Packit |
423ecb |
case XML_HTML_DOCUMENT_NODE:
|
|
Packit |
423ecb |
#ifdef LIBXML_DOCB_ENABLED
|
|
Packit |
423ecb |
case XML_DOCB_DOCUMENT_NODE:
|
|
Packit |
423ecb |
#endif
|
|
Packit |
423ecb |
case XML_XINCLUDE_END:
|
|
Packit |
423ecb |
break;
|
|
Packit |
423ecb |
case XML_XINCLUDE_START: {
|
|
Packit |
423ecb |
xmlNodePtr tmp, cur = set->nodeTab[i];
|
|
Packit |
423ecb |
|
|
Packit |
423ecb |
cur = cur->next;
|
|
Packit |
423ecb |
while (cur != NULL) {
|
|
Packit |
423ecb |
switch(cur->type) {
|
|
Packit |
423ecb |
case XML_TEXT_NODE:
|
|
Packit |
423ecb |
case XML_CDATA_SECTION_NODE:
|
|
Packit |
423ecb |
case XML_ELEMENT_NODE:
|
|
Packit |
423ecb |
case XML_ENTITY_REF_NODE:
|
|
Packit |
423ecb |
case XML_ENTITY_NODE:
|
|
Packit |
423ecb |
case XML_PI_NODE:
|
|
Packit |
423ecb |
case XML_COMMENT_NODE:
|
|
Packit |
423ecb |
tmp = xmlXIncludeCopyNode(ctxt, target,
|
|
Packit |
423ecb |
source, cur);
|
|
Packit |
423ecb |
if (last == NULL) {
|
|
Packit |
423ecb |
list = last = tmp;
|
|
Packit |
423ecb |
} else {
|
|
Packit |
423ecb |
xmlAddNextSibling(last, tmp);
|
|
Packit |
423ecb |
last = tmp;
|
|
Packit |
423ecb |
}
|
|
Packit |
423ecb |
cur = cur->next;
|
|
Packit |
423ecb |
continue;
|
|
Packit |
423ecb |
default:
|
|
Packit |
423ecb |
break;
|
|
Packit |
423ecb |
}
|
|
Packit |
423ecb |
break;
|
|
Packit |
423ecb |
}
|
|
Packit |
423ecb |
continue;
|
|
Packit |
423ecb |
}
|
|
Packit |
423ecb |
case XML_ATTRIBUTE_NODE:
|
|
Packit |
423ecb |
case XML_NAMESPACE_DECL:
|
|
Packit |
423ecb |
case XML_DOCUMENT_TYPE_NODE:
|
|
Packit |
423ecb |
case XML_DOCUMENT_FRAG_NODE:
|
|
Packit |
423ecb |
case XML_NOTATION_NODE:
|
|
Packit |
423ecb |
case XML_DTD_NODE:
|
|
Packit |
423ecb |
case XML_ELEMENT_DECL:
|
|
Packit |
423ecb |
case XML_ATTRIBUTE_DECL:
|
|
Packit |
423ecb |
case XML_ENTITY_DECL:
|
|
Packit |
423ecb |
continue; /* for */
|
|
Packit |
423ecb |
}
|
|
Packit |
423ecb |
if (last == NULL)
|
|
Packit |
423ecb |
list = last = xmlXIncludeCopyNode(ctxt, target, source,
|
|
Packit |
423ecb |
set->nodeTab[i]);
|
|
Packit |
423ecb |
else {
|
|
Packit |
423ecb |
xmlAddNextSibling(last,
|
|
Packit |
423ecb |
xmlXIncludeCopyNode(ctxt, target, source,
|
|
Packit |
423ecb |
set->nodeTab[i]));
|
|
Packit |
423ecb |
if (last->next != NULL)
|
|
Packit |
423ecb |
last = last->next;
|
|
Packit |
423ecb |
}
|
|
Packit |
423ecb |
}
|
|
Packit |
423ecb |
break;
|
|
Packit |
423ecb |
}
|
|
Packit |
423ecb |
#ifdef LIBXML_XPTR_ENABLED
|
|
Packit |
423ecb |
case XPATH_LOCATIONSET: {
|
|
Packit |
423ecb |
xmlLocationSetPtr set = (xmlLocationSetPtr) obj->user;
|
|
Packit |
423ecb |
if (set == NULL)
|
|
Packit |
423ecb |
return(NULL);
|
|
Packit |
423ecb |
for (i = 0;i < set->locNr;i++) {
|
|
Packit |
423ecb |
if (last == NULL)
|
|
Packit |
423ecb |
list = last = xmlXIncludeCopyXPointer(ctxt, target, source,
|
|
Packit |
423ecb |
set->locTab[i]);
|
|
Packit |
423ecb |
else
|
|
Packit |
423ecb |
xmlAddNextSibling(last,
|
|
Packit |
423ecb |
xmlXIncludeCopyXPointer(ctxt, target, source,
|
|
Packit |
423ecb |
set->locTab[i]));
|
|
Packit |
423ecb |
if (last != NULL) {
|
|
Packit |
423ecb |
while (last->next != NULL)
|
|
Packit |
423ecb |
last = last->next;
|
|
Packit |
423ecb |
}
|
|
Packit |
423ecb |
}
|
|
Packit |
423ecb |
break;
|
|
Packit |
423ecb |
}
|
|
Packit |
423ecb |
case XPATH_RANGE:
|
|
Packit |
423ecb |
return(xmlXIncludeCopyRange(ctxt, target, source, obj));
|
|
Packit |
423ecb |
#endif
|
|
Packit |
423ecb |
case XPATH_POINT:
|
|
Packit |
423ecb |
/* points are ignored in XInclude */
|
|
Packit |
423ecb |
break;
|
|
Packit |
423ecb |
default:
|
|
Packit |
423ecb |
break;
|
|
Packit |
423ecb |
}
|
|
Packit |
423ecb |
return(list);
|
|
Packit |
423ecb |
}
|
|
Packit |
423ecb |
/************************************************************************
|
|
Packit |
423ecb |
* *
|
|
Packit |
423ecb |
* XInclude I/O handling *
|
|
Packit |
423ecb |
* *
|
|
Packit |
423ecb |
************************************************************************/
|
|
Packit |
423ecb |
|
|
Packit |
423ecb |
typedef struct _xmlXIncludeMergeData xmlXIncludeMergeData;
|
|
Packit |
423ecb |
typedef xmlXIncludeMergeData *xmlXIncludeMergeDataPtr;
|
|
Packit |
423ecb |
struct _xmlXIncludeMergeData {
|
|
Packit |
423ecb |
xmlDocPtr doc;
|
|
Packit |
423ecb |
xmlXIncludeCtxtPtr ctxt;
|
|
Packit |
423ecb |
};
|
|
Packit |
423ecb |
|
|
Packit |
423ecb |
/**
|
|
Packit |
423ecb |
* xmlXIncludeMergeOneEntity:
|
|
Packit |
423ecb |
* @ent: the entity
|
|
Packit |
423ecb |
* @doc: the including doc
|
|
Packit |
423ecb |
* @nr: the entity name
|
|
Packit |
423ecb |
*
|
|
Packit |
423ecb |
* Inplements the merge of one entity
|
|
Packit |
423ecb |
*/
|
|
Packit |
423ecb |
static void
|
|
Packit |
423ecb |
xmlXIncludeMergeEntity(xmlEntityPtr ent, xmlXIncludeMergeDataPtr data,
|
|
Packit |
423ecb |
xmlChar *name ATTRIBUTE_UNUSED) {
|
|
Packit |
423ecb |
xmlEntityPtr ret, prev;
|
|
Packit |
423ecb |
xmlDocPtr doc;
|
|
Packit |
423ecb |
xmlXIncludeCtxtPtr ctxt;
|
|
Packit |
423ecb |
|
|
Packit |
423ecb |
if ((ent == NULL) || (data == NULL))
|
|
Packit |
423ecb |
return;
|
|
Packit |
423ecb |
ctxt = data->ctxt;
|
|
Packit |
423ecb |
doc = data->doc;
|
|
Packit |
423ecb |
if ((ctxt == NULL) || (doc == NULL))
|
|
Packit |
423ecb |
return;
|
|
Packit |
423ecb |
switch (ent->etype) {
|
|
Packit |
423ecb |
case XML_INTERNAL_PARAMETER_ENTITY:
|
|
Packit |
423ecb |
case XML_EXTERNAL_PARAMETER_ENTITY:
|
|
Packit |
423ecb |
case XML_INTERNAL_PREDEFINED_ENTITY:
|
|
Packit |
423ecb |
return;
|
|
Packit |
423ecb |
case XML_INTERNAL_GENERAL_ENTITY:
|
|
Packit |
423ecb |
case XML_EXTERNAL_GENERAL_PARSED_ENTITY:
|
|
Packit |
423ecb |
case XML_EXTERNAL_GENERAL_UNPARSED_ENTITY:
|
|
Packit |
423ecb |
break;
|
|
Packit |
423ecb |
}
|
|
Packit |
423ecb |
ret = xmlAddDocEntity(doc, ent->name, ent->etype, ent->ExternalID,
|
|
Packit |
423ecb |
ent->SystemID, ent->content);
|
|
Packit |
423ecb |
if (ret != NULL) {
|
|
Packit |
423ecb |
if (ent->URI != NULL)
|
|
Packit |
423ecb |
ret->URI = xmlStrdup(ent->URI);
|
|
Packit |
423ecb |
} else {
|
|
Packit |
423ecb |
prev = xmlGetDocEntity(doc, ent->name);
|
|
Packit |
423ecb |
if (prev != NULL) {
|
|
Packit |
423ecb |
if (ent->etype != prev->etype)
|
|
Packit |
423ecb |
goto error;
|
|
Packit |
423ecb |
|
|
Packit |
423ecb |
if ((ent->SystemID != NULL) && (prev->SystemID != NULL)) {
|
|
Packit |
423ecb |
if (!xmlStrEqual(ent->SystemID, prev->SystemID))
|
|
Packit |
423ecb |
goto error;
|
|
Packit |
423ecb |
} else if ((ent->ExternalID != NULL) &&
|
|
Packit |
423ecb |
(prev->ExternalID != NULL)) {
|
|
Packit |
423ecb |
if (!xmlStrEqual(ent->ExternalID, prev->ExternalID))
|
|
Packit |
423ecb |
goto error;
|
|
Packit |
423ecb |
} else if ((ent->content != NULL) && (prev->content != NULL)) {
|
|
Packit |
423ecb |
if (!xmlStrEqual(ent->content, prev->content))
|
|
Packit |
423ecb |
goto error;
|
|
Packit |
423ecb |
} else {
|
|
Packit |
423ecb |
goto error;
|
|
Packit |
423ecb |
}
|
|
Packit |
423ecb |
|
|
Packit |
423ecb |
}
|
|
Packit |
423ecb |
}
|
|
Packit |
423ecb |
return;
|
|
Packit |
423ecb |
error:
|
|
Packit |
423ecb |
switch (ent->etype) {
|
|
Packit |
423ecb |
case XML_INTERNAL_PARAMETER_ENTITY:
|
|
Packit |
423ecb |
case XML_EXTERNAL_PARAMETER_ENTITY:
|
|
Packit |
423ecb |
case XML_INTERNAL_PREDEFINED_ENTITY:
|
|
Packit |
423ecb |
case XML_INTERNAL_GENERAL_ENTITY:
|
|
Packit |
423ecb |
case XML_EXTERNAL_GENERAL_PARSED_ENTITY:
|
|
Packit |
423ecb |
return;
|
|
Packit |
423ecb |
case XML_EXTERNAL_GENERAL_UNPARSED_ENTITY:
|
|
Packit |
423ecb |
break;
|
|
Packit |
423ecb |
}
|
|
Packit |
423ecb |
xmlXIncludeErr(ctxt, (xmlNodePtr) ent, XML_XINCLUDE_ENTITY_DEF_MISMATCH,
|
|
Packit |
423ecb |
"mismatch in redefinition of entity %s\n",
|
|
Packit |
423ecb |
ent->name);
|
|
Packit |
423ecb |
}
|
|
Packit |
423ecb |
|
|
Packit |
423ecb |
/**
|
|
Packit |
423ecb |
* xmlXIncludeMergeEntities:
|
|
Packit |
423ecb |
* @ctxt: an XInclude context
|
|
Packit |
423ecb |
* @doc: the including doc
|
|
Packit |
423ecb |
* @from: the included doc
|
|
Packit |
423ecb |
*
|
|
Packit |
423ecb |
* Inplements the entity merge
|
|
Packit |
423ecb |
*
|
|
Packit |
423ecb |
* Returns 0 if merge succeeded, -1 if some processing failed
|
|
Packit |
423ecb |
*/
|
|
Packit |
423ecb |
static int
|
|
Packit |
423ecb |
xmlXIncludeMergeEntities(xmlXIncludeCtxtPtr ctxt, xmlDocPtr doc,
|
|
Packit |
423ecb |
xmlDocPtr from) {
|
|
Packit |
423ecb |
xmlNodePtr cur;
|
|
Packit |
423ecb |
xmlDtdPtr target, source;
|
|
Packit |
423ecb |
|
|
Packit |
423ecb |
if (ctxt == NULL)
|
|
Packit |
423ecb |
return(-1);
|
|
Packit |
423ecb |
|
|
Packit |
423ecb |
if ((from == NULL) || (from->intSubset == NULL))
|
|
Packit |
423ecb |
return(0);
|
|
Packit |
423ecb |
|
|
Packit |
423ecb |
target = doc->intSubset;
|
|
Packit |
423ecb |
if (target == NULL) {
|
|
Packit |
423ecb |
cur = xmlDocGetRootElement(doc);
|
|
Packit |
423ecb |
if (cur == NULL)
|
|
Packit |
423ecb |
return(-1);
|
|
Packit |
423ecb |
target = xmlCreateIntSubset(doc, cur->name, NULL, NULL);
|
|
Packit |
423ecb |
if (target == NULL)
|
|
Packit |
423ecb |
return(-1);
|
|
Packit |
423ecb |
}
|
|
Packit |
423ecb |
|
|
Packit |
423ecb |
source = from->intSubset;
|
|
Packit |
423ecb |
if ((source != NULL) && (source->entities != NULL)) {
|
|
Packit |
423ecb |
xmlXIncludeMergeData data;
|
|
Packit |
423ecb |
|
|
Packit |
423ecb |
data.ctxt = ctxt;
|
|
Packit |
423ecb |
data.doc = doc;
|
|
Packit |
423ecb |
|
|
Packit |
423ecb |
xmlHashScan((xmlHashTablePtr) source->entities,
|
|
Packit |
423ecb |
(xmlHashScanner) xmlXIncludeMergeEntity, &data);
|
|
Packit |
423ecb |
}
|
|
Packit |
423ecb |
source = from->extSubset;
|
|
Packit |
423ecb |
if ((source != NULL) && (source->entities != NULL)) {
|
|
Packit |
423ecb |
xmlXIncludeMergeData data;
|
|
Packit |
423ecb |
|
|
Packit |
423ecb |
data.ctxt = ctxt;
|
|
Packit |
423ecb |
data.doc = doc;
|
|
Packit |
423ecb |
|
|
Packit |
423ecb |
/*
|
|
Packit |
423ecb |
* don't duplicate existing stuff when external subsets are the same
|
|
Packit |
423ecb |
*/
|
|
Packit |
423ecb |
if ((!xmlStrEqual(target->ExternalID, source->ExternalID)) &&
|
|
Packit |
423ecb |
(!xmlStrEqual(target->SystemID, source->SystemID))) {
|
|
Packit |
423ecb |
xmlHashScan((xmlHashTablePtr) source->entities,
|
|
Packit |
423ecb |
(xmlHashScanner) xmlXIncludeMergeEntity, &data);
|
|
Packit |
423ecb |
}
|
|
Packit |
423ecb |
}
|
|
Packit |
423ecb |
return(0);
|
|
Packit |
423ecb |
}
|
|
Packit |
423ecb |
|
|
Packit |
423ecb |
/**
|
|
Packit |
423ecb |
* xmlXIncludeLoadDoc:
|
|
Packit |
423ecb |
* @ctxt: the XInclude context
|
|
Packit |
423ecb |
* @url: the associated URL
|
|
Packit |
423ecb |
* @nr: the xinclude node number
|
|
Packit |
423ecb |
*
|
|
Packit |
423ecb |
* Load the document, and store the result in the XInclude context
|
|
Packit |
423ecb |
*
|
|
Packit |
423ecb |
* Returns 0 in case of success, -1 in case of failure
|
|
Packit |
423ecb |
*/
|
|
Packit |
423ecb |
static int
|
|
Packit |
423ecb |
xmlXIncludeLoadDoc(xmlXIncludeCtxtPtr ctxt, const xmlChar *url, int nr) {
|
|
Packit |
423ecb |
xmlDocPtr doc;
|
|
Packit |
423ecb |
xmlURIPtr uri;
|
|
Packit |
423ecb |
xmlChar *URL;
|
|
Packit |
423ecb |
xmlChar *fragment = NULL;
|
|
Packit |
423ecb |
int i = 0;
|
|
Packit |
423ecb |
#ifdef LIBXML_XPTR_ENABLED
|
|
Packit |
423ecb |
int saveFlags;
|
|
Packit |
423ecb |
#endif
|
|
Packit |
423ecb |
|
|
Packit |
423ecb |
#ifdef DEBUG_XINCLUDE
|
|
Packit |
423ecb |
xmlGenericError(xmlGenericErrorContext, "Loading doc %s:%d\n", url, nr);
|
|
Packit |
423ecb |
#endif
|
|
Packit |
423ecb |
/*
|
|
Packit |
423ecb |
* Check the URL and remove any fragment identifier
|
|
Packit |
423ecb |
*/
|
|
Packit |
423ecb |
uri = xmlParseURI((const char *)url);
|
|
Packit |
423ecb |
if (uri == NULL) {
|
|
Packit |
423ecb |
xmlXIncludeErr(ctxt, ctxt->incTab[nr]->ref,
|
|
Packit |
423ecb |
XML_XINCLUDE_HREF_URI,
|
|
Packit |
423ecb |
"invalid value URI %s\n", url);
|
|
Packit |
423ecb |
return(-1);
|
|
Packit |
423ecb |
}
|
|
Packit |
423ecb |
if (uri->fragment != NULL) {
|
|
Packit |
423ecb |
fragment = (xmlChar *) uri->fragment;
|
|
Packit |
423ecb |
uri->fragment = NULL;
|
|
Packit |
423ecb |
}
|
|
Packit |
423ecb |
if ((ctxt->incTab != NULL) && (ctxt->incTab[nr] != NULL) &&
|
|
Packit |
423ecb |
(ctxt->incTab[nr]->fragment != NULL)) {
|
|
Packit |
423ecb |
if (fragment != NULL) xmlFree(fragment);
|
|
Packit |
423ecb |
fragment = xmlStrdup(ctxt->incTab[nr]->fragment);
|
|
Packit |
423ecb |
}
|
|
Packit |
423ecb |
URL = xmlSaveUri(uri);
|
|
Packit |
423ecb |
xmlFreeURI(uri);
|
|
Packit |
423ecb |
if (URL == NULL) {
|
|
Packit |
423ecb |
if (ctxt->incTab != NULL)
|
|
Packit |
423ecb |
xmlXIncludeErr(ctxt, ctxt->incTab[nr]->ref,
|
|
Packit |
423ecb |
XML_XINCLUDE_HREF_URI,
|
|
Packit |
423ecb |
"invalid value URI %s\n", url);
|
|
Packit |
423ecb |
else
|
|
Packit |
423ecb |
xmlXIncludeErr(ctxt, NULL,
|
|
Packit |
423ecb |
XML_XINCLUDE_HREF_URI,
|
|
Packit |
423ecb |
"invalid value URI %s\n", url);
|
|
Packit |
423ecb |
if (fragment != NULL)
|
|
Packit |
423ecb |
xmlFree(fragment);
|
|
Packit |
423ecb |
return(-1);
|
|
Packit |
423ecb |
}
|
|
Packit |
423ecb |
|
|
Packit |
423ecb |
/*
|
|
Packit |
423ecb |
* Handling of references to the local document are done
|
|
Packit |
423ecb |
* directly through ctxt->doc.
|
|
Packit |
423ecb |
*/
|
|
Packit |
423ecb |
if ((URL[0] == 0) || (URL[0] == '#') ||
|
|
Packit |
423ecb |
((ctxt->doc != NULL) && (xmlStrEqual(URL, ctxt->doc->URL)))) {
|
|
Packit |
423ecb |
doc = NULL;
|
|
Packit |
423ecb |
goto loaded;
|
|
Packit |
423ecb |
}
|
|
Packit |
423ecb |
|
|
Packit |
423ecb |
/*
|
|
Packit |
423ecb |
* Prevent reloading twice the document.
|
|
Packit |
423ecb |
*/
|
|
Packit |
423ecb |
for (i = 0; i < ctxt->incNr; i++) {
|
|
Packit |
423ecb |
if ((xmlStrEqual(URL, ctxt->incTab[i]->URI)) &&
|
|
Packit |
423ecb |
(ctxt->incTab[i]->doc != NULL)) {
|
|
Packit |
423ecb |
doc = ctxt->incTab[i]->doc;
|
|
Packit |
423ecb |
#ifdef DEBUG_XINCLUDE
|
|
Packit |
423ecb |
printf("Already loaded %s\n", URL);
|
|
Packit |
423ecb |
#endif
|
|
Packit |
423ecb |
goto loaded;
|
|
Packit |
423ecb |
}
|
|
Packit |
423ecb |
}
|
|
Packit |
423ecb |
|
|
Packit |
423ecb |
/*
|
|
Packit |
423ecb |
* Load it.
|
|
Packit |
423ecb |
*/
|
|
Packit |
423ecb |
#ifdef DEBUG_XINCLUDE
|
|
Packit |
423ecb |
printf("loading %s\n", URL);
|
|
Packit |
423ecb |
#endif
|
|
Packit |
423ecb |
#ifdef LIBXML_XPTR_ENABLED
|
|
Packit |
423ecb |
/*
|
|
Packit |
423ecb |
* If this is an XPointer evaluation, we want to assure that
|
|
Packit |
423ecb |
* all entities have been resolved prior to processing the
|
|
Packit |
423ecb |
* referenced document
|
|
Packit |
423ecb |
*/
|
|
Packit |
423ecb |
saveFlags = ctxt->parseFlags;
|
|
Packit |
423ecb |
if (fragment != NULL) { /* if this is an XPointer eval */
|
|
Packit |
423ecb |
ctxt->parseFlags |= XML_PARSE_NOENT;
|
|
Packit |
423ecb |
}
|
|
Packit |
423ecb |
#endif
|
|
Packit |
423ecb |
|
|
Packit |
423ecb |
doc = xmlXIncludeParseFile(ctxt, (const char *)URL);
|
|
Packit |
423ecb |
#ifdef LIBXML_XPTR_ENABLED
|
|
Packit |
423ecb |
ctxt->parseFlags = saveFlags;
|
|
Packit |
423ecb |
#endif
|
|
Packit |
423ecb |
if (doc == NULL) {
|
|
Packit |
423ecb |
xmlFree(URL);
|
|
Packit |
423ecb |
if (fragment != NULL)
|
|
Packit |
423ecb |
xmlFree(fragment);
|
|
Packit |
423ecb |
return(-1);
|
|
Packit |
423ecb |
}
|
|
Packit |
423ecb |
ctxt->incTab[nr]->doc = doc;
|
|
Packit |
423ecb |
/*
|
|
Packit |
423ecb |
* It's possible that the requested URL has been mapped to a
|
|
Packit |
423ecb |
* completely different location (e.g. through a catalog entry).
|
|
Packit |
423ecb |
* To check for this, we compare the URL with that of the doc
|
|
Packit |
423ecb |
* and change it if they disagree (bug 146988).
|
|
Packit |
423ecb |
*/
|
|
Packit |
423ecb |
if (!xmlStrEqual(URL, doc->URL)) {
|
|
Packit |
423ecb |
xmlFree(URL);
|
|
Packit |
423ecb |
URL = xmlStrdup(doc->URL);
|
|
Packit |
423ecb |
}
|
|
Packit |
423ecb |
for (i = nr + 1; i < ctxt->incNr; i++) {
|
|
Packit |
423ecb |
if (xmlStrEqual(URL, ctxt->incTab[i]->URI)) {
|
|
Packit |
423ecb |
ctxt->incTab[nr]->count++;
|
|
Packit |
423ecb |
#ifdef DEBUG_XINCLUDE
|
|
Packit |
423ecb |
printf("Increasing %s count since reused\n", URL);
|
|
Packit |
423ecb |
#endif
|
|
Packit |
423ecb |
break;
|
|
Packit |
423ecb |
}
|
|
Packit |
423ecb |
}
|
|
Packit |
423ecb |
|
|
Packit |
423ecb |
/*
|
|
Packit |
423ecb |
* Make sure we have all entities fixed up
|
|
Packit |
423ecb |
*/
|
|
Packit |
423ecb |
xmlXIncludeMergeEntities(ctxt, ctxt->doc, doc);
|
|
Packit |
423ecb |
|
|
Packit |
423ecb |
/*
|
|
Packit |
423ecb |
* We don't need the DTD anymore, free up space
|
|
Packit |
423ecb |
if (doc->intSubset != NULL) {
|
|
Packit |
423ecb |
xmlUnlinkNode((xmlNodePtr) doc->intSubset);
|
|
Packit |
423ecb |
xmlFreeNode((xmlNodePtr) doc->intSubset);
|
|
Packit |
423ecb |
doc->intSubset = NULL;
|
|
Packit |
423ecb |
}
|
|
Packit |
423ecb |
if (doc->extSubset != NULL) {
|
|
Packit |
423ecb |
xmlUnlinkNode((xmlNodePtr) doc->extSubset);
|
|
Packit |
423ecb |
xmlFreeNode((xmlNodePtr) doc->extSubset);
|
|
Packit |
423ecb |
doc->extSubset = NULL;
|
|
Packit |
423ecb |
}
|
|
Packit |
423ecb |
*/
|
|
Packit |
423ecb |
xmlXIncludeRecurseDoc(ctxt, doc, URL);
|
|
Packit |
423ecb |
|
|
Packit |
423ecb |
loaded:
|
|
Packit |
423ecb |
if (fragment == NULL) {
|
|
Packit |
423ecb |
/*
|
|
Packit |
423ecb |
* Add the top children list as the replacement copy.
|
|
Packit |
423ecb |
*/
|
|
Packit |
423ecb |
if (doc == NULL)
|
|
Packit |
423ecb |
{
|
|
Packit |
423ecb |
/* Hopefully a DTD declaration won't be copied from
|
|
Packit |
423ecb |
* the same document */
|
|
Packit |
423ecb |
ctxt->incTab[nr]->inc = xmlCopyNodeList(ctxt->doc->children);
|
|
Packit |
423ecb |
} else {
|
|
Packit |
423ecb |
ctxt->incTab[nr]->inc = xmlXIncludeCopyNodeList(ctxt, ctxt->doc,
|
|
Packit |
423ecb |
doc, doc->children);
|
|
Packit |
423ecb |
}
|
|
Packit |
423ecb |
}
|
|
Packit |
423ecb |
#ifdef LIBXML_XPTR_ENABLED
|
|
Packit |
423ecb |
else {
|
|
Packit |
423ecb |
/*
|
|
Packit |
423ecb |
* Computes the XPointer expression and make a copy used
|
|
Packit |
423ecb |
* as the replacement copy.
|
|
Packit |
423ecb |
*/
|
|
Packit |
423ecb |
xmlXPathObjectPtr xptr;
|
|
Packit |
423ecb |
xmlXPathContextPtr xptrctxt;
|
|
Packit |
423ecb |
xmlNodeSetPtr set;
|
|
Packit |
423ecb |
|
|
Packit |
423ecb |
if (doc == NULL) {
|
|
Packit |
423ecb |
xptrctxt = xmlXPtrNewContext(ctxt->doc, ctxt->incTab[nr]->ref,
|
|
Packit |
423ecb |
NULL);
|
|
Packit |
423ecb |
} else {
|
|
Packit |
423ecb |
xptrctxt = xmlXPtrNewContext(doc, NULL, NULL);
|
|
Packit |
423ecb |
}
|
|
Packit |
423ecb |
if (xptrctxt == NULL) {
|
|
Packit |
423ecb |
xmlXIncludeErr(ctxt, ctxt->incTab[nr]->ref,
|
|
Packit |
423ecb |
XML_XINCLUDE_XPTR_FAILED,
|
|
Packit |
423ecb |
"could not create XPointer context\n", NULL);
|
|
Packit |
423ecb |
xmlFree(URL);
|
|
Packit |
423ecb |
xmlFree(fragment);
|
|
Packit |
423ecb |
return(-1);
|
|
Packit |
423ecb |
}
|
|
Packit |
423ecb |
xptr = xmlXPtrEval(fragment, xptrctxt);
|
|
Packit |
423ecb |
if (xptr == NULL) {
|
|
Packit |
423ecb |
xmlXIncludeErr(ctxt, ctxt->incTab[nr]->ref,
|
|
Packit |
423ecb |
XML_XINCLUDE_XPTR_FAILED,
|
|
Packit |
423ecb |
"XPointer evaluation failed: #%s\n",
|
|
Packit |
423ecb |
fragment);
|
|
Packit |
423ecb |
xmlXPathFreeContext(xptrctxt);
|
|
Packit |
423ecb |
xmlFree(URL);
|
|
Packit |
423ecb |
xmlFree(fragment);
|
|
Packit |
423ecb |
return(-1);
|
|
Packit |
423ecb |
}
|
|
Packit |
423ecb |
switch (xptr->type) {
|
|
Packit |
423ecb |
case XPATH_UNDEFINED:
|
|
Packit |
423ecb |
case XPATH_BOOLEAN:
|
|
Packit |
423ecb |
case XPATH_NUMBER:
|
|
Packit |
423ecb |
case XPATH_STRING:
|
|
Packit |
423ecb |
case XPATH_POINT:
|
|
Packit |
423ecb |
case XPATH_USERS:
|
|
Packit |
423ecb |
case XPATH_XSLT_TREE:
|
|
Packit |
423ecb |
xmlXIncludeErr(ctxt, ctxt->incTab[nr]->ref,
|
|
Packit |
423ecb |
XML_XINCLUDE_XPTR_RESULT,
|
|
Packit |
423ecb |
"XPointer is not a range: #%s\n",
|
|
Packit |
423ecb |
fragment);
|
|
Packit |
423ecb |
xmlXPathFreeContext(xptrctxt);
|
|
Packit |
423ecb |
xmlFree(URL);
|
|
Packit |
423ecb |
xmlFree(fragment);
|
|
Packit |
423ecb |
return(-1);
|
|
Packit |
423ecb |
case XPATH_NODESET:
|
|
Packit |
423ecb |
if ((xptr->nodesetval == NULL) ||
|
|
Packit |
423ecb |
(xptr->nodesetval->nodeNr <= 0)) {
|
|
Packit |
423ecb |
xmlXPathFreeContext(xptrctxt);
|
|
Packit |
423ecb |
xmlFree(URL);
|
|
Packit |
423ecb |
xmlFree(fragment);
|
|
Packit |
423ecb |
return(-1);
|
|
Packit |
423ecb |
}
|
|
Packit |
423ecb |
|
|
Packit |
423ecb |
case XPATH_RANGE:
|
|
Packit |
423ecb |
case XPATH_LOCATIONSET:
|
|
Packit |
423ecb |
break;
|
|
Packit |
423ecb |
}
|
|
Packit |
423ecb |
set = xptr->nodesetval;
|
|
Packit |
423ecb |
if (set != NULL) {
|
|
Packit |
423ecb |
for (i = 0;i < set->nodeNr;i++) {
|
|
Packit |
423ecb |
if (set->nodeTab[i] == NULL)
|
|
Packit |
423ecb |
continue;
|
|
Packit |
423ecb |
switch (set->nodeTab[i]->type) {
|
|
Packit |
423ecb |
case XML_ELEMENT_NODE:
|
|
Packit |
423ecb |
case XML_TEXT_NODE:
|
|
Packit |
423ecb |
case XML_CDATA_SECTION_NODE:
|
|
Packit |
423ecb |
case XML_ENTITY_REF_NODE:
|
|
Packit |
423ecb |
case XML_ENTITY_NODE:
|
|
Packit |
423ecb |
case XML_PI_NODE:
|
|
Packit |
423ecb |
case XML_COMMENT_NODE:
|
|
Packit |
423ecb |
case XML_DOCUMENT_NODE:
|
|
Packit |
423ecb |
case XML_HTML_DOCUMENT_NODE:
|
|
Packit |
423ecb |
#ifdef LIBXML_DOCB_ENABLED
|
|
Packit |
423ecb |
case XML_DOCB_DOCUMENT_NODE:
|
|
Packit |
423ecb |
#endif
|
|
Packit |
423ecb |
continue;
|
|
Packit |
423ecb |
|
|
Packit |
423ecb |
case XML_ATTRIBUTE_NODE:
|
|
Packit |
423ecb |
xmlXIncludeErr(ctxt, ctxt->incTab[nr]->ref,
|
|
Packit |
423ecb |
XML_XINCLUDE_XPTR_RESULT,
|
|
Packit |
423ecb |
"XPointer selects an attribute: #%s\n",
|
|
Packit |
423ecb |
fragment);
|
|
Packit |
423ecb |
set->nodeTab[i] = NULL;
|
|
Packit |
423ecb |
continue;
|
|
Packit |
423ecb |
case XML_NAMESPACE_DECL:
|
|
Packit |
423ecb |
xmlXIncludeErr(ctxt, ctxt->incTab[nr]->ref,
|
|
Packit |
423ecb |
XML_XINCLUDE_XPTR_RESULT,
|
|
Packit |
423ecb |
"XPointer selects a namespace: #%s\n",
|
|
Packit |
423ecb |
fragment);
|
|
Packit |
423ecb |
set->nodeTab[i] = NULL;
|
|
Packit |
423ecb |
continue;
|
|
Packit |
423ecb |
case XML_DOCUMENT_TYPE_NODE:
|
|
Packit |
423ecb |
case XML_DOCUMENT_FRAG_NODE:
|
|
Packit |
423ecb |
case XML_NOTATION_NODE:
|
|
Packit |
423ecb |
case XML_DTD_NODE:
|
|
Packit |
423ecb |
case XML_ELEMENT_DECL:
|
|
Packit |
423ecb |
case XML_ATTRIBUTE_DECL:
|
|
Packit |
423ecb |
case XML_ENTITY_DECL:
|
|
Packit |
423ecb |
case XML_XINCLUDE_START:
|
|
Packit |
423ecb |
case XML_XINCLUDE_END:
|
|
Packit |
423ecb |
xmlXIncludeErr(ctxt, ctxt->incTab[nr]->ref,
|
|
Packit |
423ecb |
XML_XINCLUDE_XPTR_RESULT,
|
|
Packit |
423ecb |
"XPointer selects unexpected nodes: #%s\n",
|
|
Packit |
423ecb |
fragment);
|
|
Packit |
423ecb |
set->nodeTab[i] = NULL;
|
|
Packit |
423ecb |
set->nodeTab[i] = NULL;
|
|
Packit |
423ecb |
continue; /* for */
|
|
Packit |
423ecb |
}
|
|
Packit |
423ecb |
}
|
|
Packit |
423ecb |
}
|
|
Packit |
423ecb |
if (doc == NULL) {
|
|
Packit |
423ecb |
ctxt->incTab[nr]->xptr = xptr;
|
|
Packit |
423ecb |
ctxt->incTab[nr]->inc = NULL;
|
|
Packit |
423ecb |
} else {
|
|
Packit |
423ecb |
ctxt->incTab[nr]->inc =
|
|
Packit |
423ecb |
xmlXIncludeCopyXPointer(ctxt, ctxt->doc, doc, xptr);
|
|
Packit |
423ecb |
xmlXPathFreeObject(xptr);
|
|
Packit |
423ecb |
}
|
|
Packit |
423ecb |
xmlXPathFreeContext(xptrctxt);
|
|
Packit |
423ecb |
xmlFree(fragment);
|
|
Packit |
423ecb |
}
|
|
Packit |
423ecb |
#endif
|
|
Packit |
423ecb |
|
|
Packit |
423ecb |
/*
|
|
Packit |
423ecb |
* Do the xml:base fixup if needed
|
|
Packit |
423ecb |
*/
|
|
Packit |
423ecb |
if ((doc != NULL) && (URL != NULL) &&
|
|
Packit |
423ecb |
(!(ctxt->parseFlags & XML_PARSE_NOBASEFIX)) &&
|
|
Packit |
423ecb |
(!(doc->parseFlags & XML_PARSE_NOBASEFIX))) {
|
|
Packit |
423ecb |
xmlNodePtr node;
|
|
Packit |
423ecb |
xmlChar *base;
|
|
Packit |
423ecb |
xmlChar *curBase;
|
|
Packit |
423ecb |
|
|
Packit |
423ecb |
/*
|
|
Packit |
423ecb |
* The base is only adjusted if "necessary", i.e. if the xinclude node
|
|
Packit |
423ecb |
* has a base specified, or the URL is relative
|
|
Packit |
423ecb |
*/
|
|
Packit |
423ecb |
base = xmlGetNsProp(ctxt->incTab[nr]->ref, BAD_CAST "base",
|
|
Packit |
423ecb |
XML_XML_NAMESPACE);
|
|
Packit |
423ecb |
if (base == NULL) {
|
|
Packit |
423ecb |
/*
|
|
Packit |
423ecb |
* No xml:base on the xinclude node, so we check whether the
|
|
Packit |
423ecb |
* URI base is different than (relative to) the context base
|
|
Packit |
423ecb |
*/
|
|
Packit |
423ecb |
curBase = xmlBuildRelativeURI(URL, ctxt->base);
|
|
Packit |
423ecb |
if (curBase == NULL) { /* Error return */
|
|
Packit |
423ecb |
xmlXIncludeErr(ctxt, ctxt->incTab[nr]->ref,
|
|
Packit |
423ecb |
XML_XINCLUDE_HREF_URI,
|
|
Packit |
423ecb |
"trying to build relative URI from %s\n", URL);
|
|
Packit |
423ecb |
} else {
|
|
Packit |
423ecb |
/* If the URI doesn't contain a slash, it's not relative */
|
|
Packit |
423ecb |
if (!xmlStrchr(curBase, (xmlChar) '/'))
|
|
Packit |
423ecb |
xmlFree(curBase);
|
|
Packit |
423ecb |
else
|
|
Packit |
423ecb |
base = curBase;
|
|
Packit |
423ecb |
}
|
|
Packit |
423ecb |
}
|
|
Packit |
423ecb |
if (base != NULL) { /* Adjustment may be needed */
|
|
Packit |
423ecb |
node = ctxt->incTab[nr]->inc;
|
|
Packit |
423ecb |
while (node != NULL) {
|
|
Packit |
423ecb |
/* Only work on element nodes */
|
|
Packit |
423ecb |
if (node->type == XML_ELEMENT_NODE) {
|
|
Packit |
423ecb |
curBase = xmlNodeGetBase(node->doc, node);
|
|
Packit |
423ecb |
/* If no current base, set it */
|
|
Packit |
423ecb |
if (curBase == NULL) {
|
|
Packit |
423ecb |
xmlNodeSetBase(node, base);
|
|
Packit |
423ecb |
} else {
|
|
Packit |
423ecb |
/*
|
|
Packit |
423ecb |
* If the current base is the same as the
|
|
Packit |
423ecb |
* URL of the document, then reset it to be
|
|
Packit |
423ecb |
* the specified xml:base or the relative URI
|
|
Packit |
423ecb |
*/
|
|
Packit |
423ecb |
if (xmlStrEqual(curBase, node->doc->URL)) {
|
|
Packit |
423ecb |
xmlNodeSetBase(node, base);
|
|
Packit |
423ecb |
} else {
|
|
Packit |
423ecb |
/*
|
|
Packit |
423ecb |
* If the element already has an xml:base
|
|
Packit |
423ecb |
* set, then relativise it if necessary
|
|
Packit |
423ecb |
*/
|
|
Packit |
423ecb |
xmlChar *xmlBase;
|
|
Packit |
423ecb |
xmlBase = xmlGetNsProp(node,
|
|
Packit |
423ecb |
BAD_CAST "base",
|
|
Packit |
423ecb |
XML_XML_NAMESPACE);
|
|
Packit |
423ecb |
if (xmlBase != NULL) {
|
|
Packit |
423ecb |
xmlChar *relBase;
|
|
Packit |
423ecb |
relBase = xmlBuildURI(xmlBase, base);
|
|
Packit |
423ecb |
if (relBase == NULL) { /* error */
|
|
Packit |
423ecb |
xmlXIncludeErr(ctxt,
|
|
Packit |
423ecb |
ctxt->incTab[nr]->ref,
|
|
Packit |
423ecb |
XML_XINCLUDE_HREF_URI,
|
|
Packit |
423ecb |
"trying to rebuild base from %s\n",
|
|
Packit |
423ecb |
xmlBase);
|
|
Packit |
423ecb |
} else {
|
|
Packit |
423ecb |
xmlNodeSetBase(node, relBase);
|
|
Packit |
423ecb |
xmlFree(relBase);
|
|
Packit |
423ecb |
}
|
|
Packit |
423ecb |
xmlFree(xmlBase);
|
|
Packit |
423ecb |
}
|
|
Packit |
423ecb |
}
|
|
Packit |
423ecb |
xmlFree(curBase);
|
|
Packit |
423ecb |
}
|
|
Packit |
423ecb |
}
|
|
Packit |
423ecb |
node = node->next;
|
|
Packit |
423ecb |
}
|
|
Packit |
423ecb |
xmlFree(base);
|
|
Packit |
423ecb |
}
|
|
Packit |
423ecb |
}
|
|
Packit |
423ecb |
if ((nr < ctxt->incNr) && (ctxt->incTab[nr]->doc != NULL) &&
|
|
Packit |
423ecb |
(ctxt->incTab[nr]->count <= 1)) {
|
|
Packit |
423ecb |
#ifdef DEBUG_XINCLUDE
|
|
Packit |
423ecb |
printf("freeing %s\n", ctxt->incTab[nr]->doc->URL);
|
|
Packit |
423ecb |
#endif
|
|
Packit |
423ecb |
xmlFreeDoc(ctxt->incTab[nr]->doc);
|
|
Packit |
423ecb |
ctxt->incTab[nr]->doc = NULL;
|
|
Packit |
423ecb |
}
|
|
Packit |
423ecb |
xmlFree(URL);
|
|
Packit |
423ecb |
return(0);
|
|
Packit |
423ecb |
}
|
|
Packit |
423ecb |
|
|
Packit |
423ecb |
/**
|
|
Packit |
423ecb |
* xmlXIncludeLoadTxt:
|
|
Packit |
423ecb |
* @ctxt: the XInclude context
|
|
Packit |
423ecb |
* @url: the associated URL
|
|
Packit |
423ecb |
* @nr: the xinclude node number
|
|
Packit |
423ecb |
*
|
|
Packit |
423ecb |
* Load the content, and store the result in the XInclude context
|
|
Packit |
423ecb |
*
|
|
Packit |
423ecb |
* Returns 0 in case of success, -1 in case of failure
|
|
Packit |
423ecb |
*/
|
|
Packit |
423ecb |
static int
|
|
Packit |
423ecb |
xmlXIncludeLoadTxt(xmlXIncludeCtxtPtr ctxt, const xmlChar *url, int nr) {
|
|
Packit |
423ecb |
xmlParserInputBufferPtr buf;
|
|
Packit |
423ecb |
xmlNodePtr node;
|
|
Packit |
423ecb |
xmlURIPtr uri;
|
|
Packit |
423ecb |
xmlChar *URL;
|
|
Packit |
423ecb |
int i;
|
|
Packit |
423ecb |
xmlChar *encoding = NULL;
|
|
Packit |
423ecb |
xmlCharEncoding enc = (xmlCharEncoding) 0;
|
|
Packit |
423ecb |
xmlParserCtxtPtr pctxt;
|
|
Packit |
423ecb |
xmlParserInputPtr inputStream;
|
|
Packit |
423ecb |
int xinclude_multibyte_fallback_used = 0;
|
|
Packit |
423ecb |
|
|
Packit |
423ecb |
/*
|
|
Packit |
423ecb |
* Check the URL and remove any fragment identifier
|
|
Packit |
423ecb |
*/
|
|
Packit |
423ecb |
uri = xmlParseURI((const char *)url);
|
|
Packit |
423ecb |
if (uri == NULL) {
|
|
Packit |
423ecb |
xmlXIncludeErr(ctxt, ctxt->incTab[nr]->ref, XML_XINCLUDE_HREF_URI,
|
|
Packit |
423ecb |
"invalid value URI %s\n", url);
|
|
Packit |
423ecb |
return(-1);
|
|
Packit |
423ecb |
}
|
|
Packit |
423ecb |
if (uri->fragment != NULL) {
|
|
Packit |
423ecb |
xmlXIncludeErr(ctxt, ctxt->incTab[nr]->ref, XML_XINCLUDE_TEXT_FRAGMENT,
|
|
Packit |
423ecb |
"fragment identifier forbidden for text: %s\n",
|
|
Packit |
423ecb |
(const xmlChar *) uri->fragment);
|
|
Packit |
423ecb |
xmlFreeURI(uri);
|
|
Packit |
423ecb |
return(-1);
|
|
Packit |
423ecb |
}
|
|
Packit |
423ecb |
URL = xmlSaveUri(uri);
|
|
Packit |
423ecb |
xmlFreeURI(uri);
|
|
Packit |
423ecb |
if (URL == NULL) {
|
|
Packit |
423ecb |
xmlXIncludeErr(ctxt, ctxt->incTab[nr]->ref, XML_XINCLUDE_HREF_URI,
|
|
Packit |
423ecb |
"invalid value URI %s\n", url);
|
|
Packit |
423ecb |
return(-1);
|
|
Packit |
423ecb |
}
|
|
Packit |
423ecb |
|
|
Packit |
423ecb |
/*
|
|
Packit |
423ecb |
* Handling of references to the local document are done
|
|
Packit |
423ecb |
* directly through ctxt->doc.
|
|
Packit |
423ecb |
*/
|
|
Packit |
423ecb |
if (URL[0] == 0) {
|
|
Packit |
423ecb |
xmlXIncludeErr(ctxt, ctxt->incTab[nr]->ref,
|
|
Packit |
423ecb |
XML_XINCLUDE_TEXT_DOCUMENT,
|
|
Packit |
423ecb |
"text serialization of document not available\n", NULL);
|
|
Packit |
423ecb |
xmlFree(URL);
|
|
Packit |
423ecb |
return(-1);
|
|
Packit |
423ecb |
}
|
|
Packit |
423ecb |
|
|
Packit |
423ecb |
/*
|
|
Packit |
423ecb |
* Prevent reloading twice the document.
|
|
Packit |
423ecb |
*/
|
|
Packit |
423ecb |
for (i = 0; i < ctxt->txtNr; i++) {
|
|
Packit |
423ecb |
if (xmlStrEqual(URL, ctxt->txturlTab[i])) {
|
|
Packit |
423ecb |
node = xmlCopyNode(ctxt->txtTab[i], 1);
|
|
Packit |
423ecb |
goto loaded;
|
|
Packit |
423ecb |
}
|
|
Packit |
423ecb |
}
|
|
Packit |
423ecb |
/*
|
|
Packit |
423ecb |
* Try to get the encoding if available
|
|
Packit |
423ecb |
*/
|
|
Packit |
423ecb |
if ((ctxt->incTab[nr] != NULL) && (ctxt->incTab[nr]->ref != NULL)) {
|
|
Packit |
423ecb |
encoding = xmlGetProp(ctxt->incTab[nr]->ref, XINCLUDE_PARSE_ENCODING);
|
|
Packit |
423ecb |
}
|
|
Packit |
423ecb |
if (encoding != NULL) {
|
|
Packit |
423ecb |
/*
|
|
Packit |
423ecb |
* TODO: we should not have to remap to the xmlCharEncoding
|
|
Packit |
423ecb |
* predefined set, a better interface than
|
|
Packit |
423ecb |
* xmlParserInputBufferCreateFilename should allow any
|
|
Packit |
423ecb |
* encoding supported by iconv
|
|
Packit |
423ecb |
*/
|
|
Packit |
423ecb |
enc = xmlParseCharEncoding((const char *) encoding);
|
|
Packit |
423ecb |
if (enc == XML_CHAR_ENCODING_ERROR) {
|
|
Packit |
423ecb |
xmlXIncludeErr(ctxt, ctxt->incTab[nr]->ref,
|
|
Packit |
423ecb |
XML_XINCLUDE_UNKNOWN_ENCODING,
|
|
Packit |
423ecb |
"encoding %s not supported\n", encoding);
|
|
Packit |
423ecb |
xmlFree(encoding);
|
|
Packit |
423ecb |
xmlFree(URL);
|
|
Packit |
423ecb |
return(-1);
|
|
Packit |
423ecb |
}
|
|
Packit |
423ecb |
xmlFree(encoding);
|
|
Packit |
423ecb |
}
|
|
Packit |
423ecb |
|
|
Packit |
423ecb |
/*
|
|
Packit |
423ecb |
* Load it.
|
|
Packit |
423ecb |
*/
|
|
Packit |
423ecb |
pctxt = xmlNewParserCtxt();
|
|
Packit |
423ecb |
inputStream = xmlLoadExternalEntity((const char*)URL, NULL, pctxt);
|
|
Packit |
423ecb |
if(inputStream == NULL) {
|
|
Packit |
423ecb |
xmlFreeParserCtxt(pctxt);
|
|
Packit |
423ecb |
xmlFree(URL);
|
|
Packit |
423ecb |
return(-1);
|
|
Packit |
423ecb |
}
|
|
Packit |
423ecb |
buf = inputStream->buf;
|
|
Packit |
423ecb |
if (buf == NULL) {
|
|
Packit |
423ecb |
xmlFreeInputStream (inputStream);
|
|
Packit |
423ecb |
xmlFreeParserCtxt(pctxt);
|
|
Packit |
423ecb |
xmlFree(URL);
|
|
Packit |
423ecb |
return(-1);
|
|
Packit |
423ecb |
}
|
|
Packit |
423ecb |
if (buf->encoder)
|
|
Packit |
423ecb |
xmlCharEncCloseFunc(buf->encoder);
|
|
Packit |
423ecb |
buf->encoder = xmlGetCharEncodingHandler(enc);
|
|
Packit |
423ecb |
node = xmlNewText(NULL);
|
|
Packit |
423ecb |
|
|
Packit |
423ecb |
/*
|
|
Packit |
423ecb |
* Scan all chars from the resource and add the to the node
|
|
Packit |
423ecb |
*/
|
|
Packit |
423ecb |
xinclude_multibyte_fallback:
|
|
Packit |
423ecb |
while (xmlParserInputBufferRead(buf, 128) > 0) {
|
|
Packit |
423ecb |
int len;
|
|
Packit |
423ecb |
const xmlChar *content;
|
|
Packit |
423ecb |
|
|
Packit |
423ecb |
content = xmlBufContent(buf->buffer);
|
|
Packit |
423ecb |
len = xmlBufLength(buf->buffer);
|
|
Packit |
423ecb |
for (i = 0;i < len;) {
|
|
Packit |
423ecb |
int cur;
|
|
Packit |
423ecb |
int l;
|
|
Packit |
423ecb |
|
|
Packit |
423ecb |
cur = xmlStringCurrentChar(NULL, &content[i], &l);
|
|
Packit |
423ecb |
if (!IS_CHAR(cur)) {
|
|
Packit |
423ecb |
/* Handle splitted multibyte char at buffer boundary */
|
|
Packit |
423ecb |
if (((len - i) < 4) && (!xinclude_multibyte_fallback_used)) {
|
|
Packit |
423ecb |
xinclude_multibyte_fallback_used = 1;
|
|
Packit |
423ecb |
xmlBufShrink(buf->buffer, i);
|
|
Packit |
423ecb |
goto xinclude_multibyte_fallback;
|
|
Packit |
423ecb |
} else {
|
|
Packit |
423ecb |
xmlXIncludeErr(ctxt, ctxt->incTab[nr]->ref,
|
|
Packit |
423ecb |
XML_XINCLUDE_INVALID_CHAR,
|
|
Packit |
423ecb |
"%s contains invalid char\n", URL);
|
|
Packit |
423ecb |
xmlFreeParserInputBuffer(buf);
|
|
Packit |
423ecb |
xmlFree(URL);
|
|
Packit |
423ecb |
return(-1);
|
|
Packit |
423ecb |
}
|
|
Packit |
423ecb |
} else {
|
|
Packit |
423ecb |
xinclude_multibyte_fallback_used = 0;
|
|
Packit |
423ecb |
xmlNodeAddContentLen(node, &content[i], l);
|
|
Packit |
423ecb |
}
|
|
Packit |
423ecb |
i += l;
|
|
Packit |
423ecb |
}
|
|
Packit |
423ecb |
xmlBufShrink(buf->buffer, len);
|
|
Packit |
423ecb |
}
|
|
Packit |
423ecb |
xmlFreeParserCtxt(pctxt);
|
|
Packit |
423ecb |
xmlXIncludeAddTxt(ctxt, node, URL);
|
|
Packit |
423ecb |
xmlFreeInputStream(inputStream);
|
|
Packit |
423ecb |
|
|
Packit |
423ecb |
loaded:
|
|
Packit |
423ecb |
/*
|
|
Packit |
423ecb |
* Add the element as the replacement copy.
|
|
Packit |
423ecb |
*/
|
|
Packit |
423ecb |
ctxt->incTab[nr]->inc = node;
|
|
Packit |
423ecb |
xmlFree(URL);
|
|
Packit |
423ecb |
return(0);
|
|
Packit |
423ecb |
}
|
|
Packit |
423ecb |
|
|
Packit |
423ecb |
/**
|
|
Packit |
423ecb |
* xmlXIncludeLoadFallback:
|
|
Packit |
423ecb |
* @ctxt: the XInclude context
|
|
Packit |
423ecb |
* @fallback: the fallback node
|
|
Packit |
423ecb |
* @nr: the xinclude node number
|
|
Packit |
423ecb |
*
|
|
Packit |
423ecb |
* Load the content of the fallback node, and store the result
|
|
Packit |
423ecb |
* in the XInclude context
|
|
Packit |
423ecb |
*
|
|
Packit |
423ecb |
* Returns 0 in case of success, -1 in case of failure
|
|
Packit |
423ecb |
*/
|
|
Packit |
423ecb |
static int
|
|
Packit |
423ecb |
xmlXIncludeLoadFallback(xmlXIncludeCtxtPtr ctxt, xmlNodePtr fallback, int nr) {
|
|
Packit |
423ecb |
xmlXIncludeCtxtPtr newctxt;
|
|
Packit |
423ecb |
int ret = 0;
|
|
Packit |
423ecb |
|
|
Packit |
423ecb |
if ((fallback == NULL) || (fallback->type == XML_NAMESPACE_DECL) ||
|
|
Packit |
423ecb |
(ctxt == NULL))
|
|
Packit |
423ecb |
return(-1);
|
|
Packit |
423ecb |
if (fallback->children != NULL) {
|
|
Packit |
423ecb |
/*
|
|
Packit |
423ecb |
* It's possible that the fallback also has 'includes'
|
|
Packit |
423ecb |
* (Bug 129969), so we re-process the fallback just in case
|
|
Packit |
423ecb |
*/
|
|
Packit |
423ecb |
newctxt = xmlXIncludeNewContext(ctxt->doc);
|
|
Packit |
423ecb |
if (newctxt == NULL)
|
|
Packit |
423ecb |
return (-1);
|
|
Packit |
423ecb |
newctxt->_private = ctxt->_private;
|
|
Packit |
423ecb |
newctxt->base = xmlStrdup(ctxt->base); /* Inherit the base from the existing context */
|
|
Packit |
423ecb |
xmlXIncludeSetFlags(newctxt, ctxt->parseFlags);
|
|
Packit |
423ecb |
ret = xmlXIncludeDoProcess(newctxt, ctxt->doc, fallback->children);
|
|
Packit |
423ecb |
if (ctxt->nbErrors > 0)
|
|
Packit |
423ecb |
ret = -1;
|
|
Packit |
423ecb |
else if (ret > 0)
|
|
Packit |
423ecb |
ret = 0; /* xmlXIncludeDoProcess can return +ve number */
|
|
Packit |
423ecb |
xmlXIncludeFreeContext(newctxt);
|
|
Packit |
423ecb |
|
|
Packit |
423ecb |
ctxt->incTab[nr]->inc = xmlDocCopyNodeList(ctxt->doc,
|
|
Packit |
423ecb |
fallback->children);
|
|
Packit |
423ecb |
} else {
|
|
Packit |
423ecb |
ctxt->incTab[nr]->inc = NULL;
|
|
Packit |
423ecb |
ctxt->incTab[nr]->emptyFb = 1; /* flag empty callback */
|
|
Packit |
423ecb |
}
|
|
Packit |
423ecb |
return(ret);
|
|
Packit |
423ecb |
}
|
|
Packit |
423ecb |
|
|
Packit |
423ecb |
/************************************************************************
|
|
Packit |
423ecb |
* *
|
|
Packit |
423ecb |
* XInclude Processing *
|
|
Packit |
423ecb |
* *
|
|
Packit |
423ecb |
************************************************************************/
|
|
Packit |
423ecb |
|
|
Packit |
423ecb |
/**
|
|
Packit |
423ecb |
* xmlXIncludePreProcessNode:
|
|
Packit |
423ecb |
* @ctxt: an XInclude context
|
|
Packit |
423ecb |
* @node: an XInclude node
|
|
Packit |
423ecb |
*
|
|
Packit |
423ecb |
* Implement the XInclude preprocessing, currently just adding the element
|
|
Packit |
423ecb |
* for further processing.
|
|
Packit |
423ecb |
*
|
|
Packit |
423ecb |
* Returns the result list or NULL in case of error
|
|
Packit |
423ecb |
*/
|
|
Packit |
423ecb |
static xmlNodePtr
|
|
Packit |
423ecb |
xmlXIncludePreProcessNode(xmlXIncludeCtxtPtr ctxt, xmlNodePtr node) {
|
|
Packit |
423ecb |
xmlXIncludeAddNode(ctxt, node);
|
|
Packit |
423ecb |
return(NULL);
|
|
Packit |
423ecb |
}
|
|
Packit |
423ecb |
|
|
Packit |
423ecb |
/**
|
|
Packit |
423ecb |
* xmlXIncludeLoadNode:
|
|
Packit |
423ecb |
* @ctxt: an XInclude context
|
|
Packit |
423ecb |
* @nr: the node number
|
|
Packit |
423ecb |
*
|
|
Packit |
423ecb |
* Find and load the infoset replacement for the given node.
|
|
Packit |
423ecb |
*
|
|
Packit |
423ecb |
* Returns 0 if substitution succeeded, -1 if some processing failed
|
|
Packit |
423ecb |
*/
|
|
Packit |
423ecb |
static int
|
|
Packit |
423ecb |
xmlXIncludeLoadNode(xmlXIncludeCtxtPtr ctxt, int nr) {
|
|
Packit |
423ecb |
xmlNodePtr cur;
|
|
Packit |
423ecb |
xmlChar *href;
|
|
Packit |
423ecb |
xmlChar *parse;
|
|
Packit |
423ecb |
xmlChar *base;
|
|
Packit |
423ecb |
xmlChar *oldBase;
|
|
Packit |
423ecb |
xmlChar *URI;
|
|
Packit |
423ecb |
int xml = 1; /* default Issue 64 */
|
|
Packit |
423ecb |
int ret;
|
|
Packit |
423ecb |
|
|
Packit |
423ecb |
if (ctxt == NULL)
|
|
Packit |
423ecb |
return(-1);
|
|
Packit |
423ecb |
if ((nr < 0) || (nr >= ctxt->incNr))
|
|
Packit |
423ecb |
return(-1);
|
|
Packit |
423ecb |
cur = ctxt->incTab[nr]->ref;
|
|
Packit |
423ecb |
if (cur == NULL)
|
|
Packit |
423ecb |
return(-1);
|
|
Packit |
423ecb |
|
|
Packit |
423ecb |
/*
|
|
Packit |
423ecb |
* read the attributes
|
|
Packit |
423ecb |
*/
|
|
Packit |
423ecb |
href = xmlXIncludeGetProp(ctxt, cur, XINCLUDE_HREF);
|
|
Packit |
423ecb |
if (href == NULL) {
|
|
Packit |
423ecb |
href = xmlStrdup(BAD_CAST ""); /* @@@@ href is now optional */
|
|
Packit |
423ecb |
if (href == NULL)
|
|
Packit |
423ecb |
return(-1);
|
|
Packit |
423ecb |
}
|
|
Packit |
423ecb |
parse = xmlXIncludeGetProp(ctxt, cur, XINCLUDE_PARSE);
|
|
Packit |
423ecb |
if (parse != NULL) {
|
|
Packit |
423ecb |
if (xmlStrEqual(parse, XINCLUDE_PARSE_XML))
|
|
Packit |
423ecb |
xml = 1;
|
|
Packit |
423ecb |
else if (xmlStrEqual(parse, XINCLUDE_PARSE_TEXT))
|
|
Packit |
423ecb |
xml = 0;
|
|
Packit |
423ecb |
else {
|
|
Packit |
423ecb |
xmlXIncludeErr(ctxt, ctxt->incTab[nr]->ref,
|
|
Packit |
423ecb |
XML_XINCLUDE_PARSE_VALUE,
|
|
Packit |
423ecb |
"invalid value %s for 'parse'\n", parse);
|
|
Packit |
423ecb |
if (href != NULL)
|
|
Packit |
423ecb |
xmlFree(href);
|
|
Packit |
423ecb |
if (parse != NULL)
|
|
Packit |
423ecb |
xmlFree(parse);
|
|
Packit |
423ecb |
return(-1);
|
|
Packit |
423ecb |
}
|
|
Packit |
423ecb |
}
|
|
Packit |
423ecb |
|
|
Packit |
423ecb |
/*
|
|
Packit |
423ecb |
* compute the URI
|
|
Packit |
423ecb |
*/
|
|
Packit |
423ecb |
base = xmlNodeGetBase(ctxt->doc, cur);
|
|
Packit |
423ecb |
if (base == NULL) {
|
|
Packit |
423ecb |
URI = xmlBuildURI(href, ctxt->doc->URL);
|
|
Packit |
423ecb |
} else {
|
|
Packit |
423ecb |
URI = xmlBuildURI(href, base);
|
|
Packit |
423ecb |
}
|
|
Packit |
423ecb |
if (URI == NULL) {
|
|
Packit |
423ecb |
xmlChar *escbase;
|
|
Packit |
423ecb |
xmlChar *eschref;
|
|
Packit |
423ecb |
/*
|
|
Packit |
423ecb |
* Some escaping may be needed
|
|
Packit |
423ecb |
*/
|
|
Packit |
423ecb |
escbase = xmlURIEscape(base);
|
|
Packit |
423ecb |
eschref = xmlURIEscape(href);
|
|
Packit |
423ecb |
URI = xmlBuildURI(eschref, escbase);
|
|
Packit |
423ecb |
if (escbase != NULL)
|
|
Packit |
423ecb |
xmlFree(escbase);
|
|
Packit |
423ecb |
if (eschref != NULL)
|
|
Packit |
423ecb |
xmlFree(eschref);
|
|
Packit |
423ecb |
}
|
|
Packit |
423ecb |
if (URI == NULL) {
|
|
Packit |
423ecb |
xmlXIncludeErr(ctxt, ctxt->incTab[nr]->ref,
|
|
Packit |
423ecb |
XML_XINCLUDE_HREF_URI, "failed build URL\n", NULL);
|
|
Packit |
423ecb |
if (parse != NULL)
|
|
Packit |
423ecb |
xmlFree(parse);
|
|
Packit |
423ecb |
if (href != NULL)
|
|
Packit |
423ecb |
xmlFree(href);
|
|
Packit |
423ecb |
if (base != NULL)
|
|
Packit |
423ecb |
xmlFree(base);
|
|
Packit |
423ecb |
return(-1);
|
|
Packit |
423ecb |
}
|
|
Packit |
423ecb |
#ifdef DEBUG_XINCLUDE
|
|
Packit |
423ecb |
xmlGenericError(xmlGenericErrorContext, "parse: %s\n",
|
|
Packit |
423ecb |
xml ? "xml": "text");
|
|
Packit |
423ecb |
xmlGenericError(xmlGenericErrorContext, "URI: %s\n", URI);
|
|
Packit |
423ecb |
#endif
|
|
Packit |
423ecb |
|
|
Packit |
423ecb |
/*
|
|
Packit |
423ecb |
* Save the base for this include (saving the current one)
|
|
Packit |
423ecb |
*/
|
|
Packit |
423ecb |
oldBase = ctxt->base;
|
|
Packit |
423ecb |
ctxt->base = base;
|
|
Packit |
423ecb |
|
|
Packit |
423ecb |
if (xml) {
|
|
Packit |
423ecb |
ret = xmlXIncludeLoadDoc(ctxt, URI, nr);
|
|
Packit |
423ecb |
/* xmlXIncludeGetFragment(ctxt, cur, URI); */
|
|
Packit |
423ecb |
} else {
|
|
Packit |
423ecb |
ret = xmlXIncludeLoadTxt(ctxt, URI, nr);
|
|
Packit |
423ecb |
}
|
|
Packit |
423ecb |
|
|
Packit |
423ecb |
/*
|
|
Packit |
423ecb |
* Restore the original base before checking for fallback
|
|
Packit |
423ecb |
*/
|
|
Packit |
423ecb |
ctxt->base = oldBase;
|
|
Packit |
423ecb |
|
|
Packit |
423ecb |
if (ret < 0) {
|
|
Packit |
423ecb |
xmlNodePtr children;
|
|
Packit |
423ecb |
|
|
Packit |
423ecb |
/*
|
|
Packit |
423ecb |
* Time to try a fallback if availble
|
|
Packit |
423ecb |
*/
|
|
Packit |
423ecb |
#ifdef DEBUG_XINCLUDE
|
|
Packit |
423ecb |
xmlGenericError(xmlGenericErrorContext, "error looking for fallback\n");
|
|
Packit |
423ecb |
#endif
|
|
Packit |
423ecb |
children = cur->children;
|
|
Packit |
423ecb |
while (children != NULL) {
|
|
Packit |
423ecb |
if ((children->type == XML_ELEMENT_NODE) &&
|
|
Packit |
423ecb |
(children->ns != NULL) &&
|
|
Packit |
423ecb |
(xmlStrEqual(children->name, XINCLUDE_FALLBACK)) &&
|
|
Packit |
423ecb |
((xmlStrEqual(children->ns->href, XINCLUDE_NS)) ||
|
|
Packit |
423ecb |
(xmlStrEqual(children->ns->href, XINCLUDE_OLD_NS)))) {
|
|
Packit |
423ecb |
ret = xmlXIncludeLoadFallback(ctxt, children, nr);
|
|
Packit |
423ecb |
if (ret == 0)
|
|
Packit |
423ecb |
break;
|
|
Packit |
423ecb |
}
|
|
Packit |
423ecb |
children = children->next;
|
|
Packit |
423ecb |
}
|
|
Packit |
423ecb |
}
|
|
Packit |
423ecb |
if (ret < 0) {
|
|
Packit |
423ecb |
xmlXIncludeErr(ctxt, ctxt->incTab[nr]->ref,
|
|
Packit |
423ecb |
XML_XINCLUDE_NO_FALLBACK,
|
|
Packit |
423ecb |
"could not load %s, and no fallback was found\n",
|
|
Packit |
423ecb |
URI);
|
|
Packit |
423ecb |
}
|
|
Packit |
423ecb |
|
|
Packit |
423ecb |
/*
|
|
Packit |
423ecb |
* Cleanup
|
|
Packit |
423ecb |
*/
|
|
Packit |
423ecb |
if (URI != NULL)
|
|
Packit |
423ecb |
xmlFree(URI);
|
|
Packit |
423ecb |
if (parse != NULL)
|
|
Packit |
423ecb |
xmlFree(parse);
|
|
Packit |
423ecb |
if (href != NULL)
|
|
Packit |
423ecb |
xmlFree(href);
|
|
Packit |
423ecb |
if (base != NULL)
|
|
Packit |
423ecb |
xmlFree(base);
|
|
Packit |
423ecb |
return(0);
|
|
Packit |
423ecb |
}
|
|
Packit |
423ecb |
|
|
Packit |
423ecb |
/**
|
|
Packit |
423ecb |
* xmlXIncludeIncludeNode:
|
|
Packit |
423ecb |
* @ctxt: an XInclude context
|
|
Packit |
423ecb |
* @nr: the node number
|
|
Packit |
423ecb |
*
|
|
Packit |
423ecb |
* Inplement the infoset replacement for the given node
|
|
Packit |
423ecb |
*
|
|
Packit |
423ecb |
* Returns 0 if substitution succeeded, -1 if some processing failed
|
|
Packit |
423ecb |
*/
|
|
Packit |
423ecb |
static int
|
|
Packit |
423ecb |
xmlXIncludeIncludeNode(xmlXIncludeCtxtPtr ctxt, int nr) {
|
|
Packit |
423ecb |
xmlNodePtr cur, end, list, tmp;
|
|
Packit |
423ecb |
|
|
Packit |
423ecb |
if (ctxt == NULL)
|
|
Packit |
423ecb |
return(-1);
|
|
Packit |
423ecb |
if ((nr < 0) || (nr >= ctxt->incNr))
|
|
Packit |
423ecb |
return(-1);
|
|
Packit |
423ecb |
cur = ctxt->incTab[nr]->ref;
|
|
Packit |
423ecb |
if ((cur == NULL) || (cur->type == XML_NAMESPACE_DECL))
|
|
Packit |
423ecb |
return(-1);
|
|
Packit |
423ecb |
|
|
Packit |
423ecb |
/*
|
|
Packit |
423ecb |
* If we stored an XPointer a late computation may be needed
|
|
Packit |
423ecb |
*/
|
|
Packit |
423ecb |
if ((ctxt->incTab[nr]->inc == NULL) &&
|
|
Packit |
423ecb |
(ctxt->incTab[nr]->xptr != NULL)) {
|
|
Packit |
423ecb |
ctxt->incTab[nr]->inc =
|
|
Packit |
423ecb |
xmlXIncludeCopyXPointer(ctxt, ctxt->doc, ctxt->doc,
|
|
Packit |
423ecb |
ctxt->incTab[nr]->xptr);
|
|
Packit |
423ecb |
xmlXPathFreeObject(ctxt->incTab[nr]->xptr);
|
|
Packit |
423ecb |
ctxt->incTab[nr]->xptr = NULL;
|
|
Packit |
423ecb |
}
|
|
Packit |
423ecb |
list = ctxt->incTab[nr]->inc;
|
|
Packit |
423ecb |
ctxt->incTab[nr]->inc = NULL;
|
|
Packit |
423ecb |
|
|
Packit |
423ecb |
/*
|
|
Packit |
423ecb |
* Check against the risk of generating a multi-rooted document
|
|
Packit |
423ecb |
*/
|
|
Packit |
423ecb |
if ((cur->parent != NULL) &&
|
|
Packit |
423ecb |
(cur->parent->type != XML_ELEMENT_NODE)) {
|
|
Packit |
423ecb |
int nb_elem = 0;
|
|
Packit |
423ecb |
|
|
Packit |
423ecb |
tmp = list;
|
|
Packit |
423ecb |
while (tmp != NULL) {
|
|
Packit |
423ecb |
if (tmp->type == XML_ELEMENT_NODE)
|
|
Packit |
423ecb |
nb_elem++;
|
|
Packit |
423ecb |
tmp = tmp->next;
|
|
Packit |
423ecb |
}
|
|
Packit |
423ecb |
if (nb_elem > 1) {
|
|
Packit |
423ecb |
xmlXIncludeErr(ctxt, ctxt->incTab[nr]->ref,
|
|
Packit |
423ecb |
XML_XINCLUDE_MULTIPLE_ROOT,
|
|
Packit |
423ecb |
"XInclude error: would result in multiple root nodes\n",
|
|
Packit |
423ecb |
NULL);
|
|
Packit |
423ecb |
return(-1);
|
|
Packit |
423ecb |
}
|
|
Packit |
423ecb |
}
|
|
Packit |
423ecb |
|
|
Packit |
423ecb |
if (ctxt->parseFlags & XML_PARSE_NOXINCNODE) {
|
|
Packit |
423ecb |
/*
|
|
Packit |
423ecb |
* Add the list of nodes
|
|
Packit |
423ecb |
*/
|
|
Packit |
423ecb |
while (list != NULL) {
|
|
Packit |
423ecb |
end = list;
|
|
Packit |
423ecb |
list = list->next;
|
|
Packit |
423ecb |
|
|
Packit |
423ecb |
xmlAddPrevSibling(cur, end);
|
|
Packit |
423ecb |
}
|
|
Packit |
423ecb |
xmlUnlinkNode(cur);
|
|
Packit |
423ecb |
xmlFreeNode(cur);
|
|
Packit |
423ecb |
} else {
|
|
Packit |
423ecb |
/*
|
|
Packit |
423ecb |
* Change the current node as an XInclude start one, and add an
|
|
Packit |
423ecb |
* XInclude end one
|
|
Packit |
423ecb |
*/
|
|
Packit |
423ecb |
cur->type = XML_XINCLUDE_START;
|
|
Packit |
423ecb |
end = xmlNewDocNode(cur->doc, cur->ns, cur->name, NULL);
|
|
Packit |
423ecb |
if (end == NULL) {
|
|
Packit |
423ecb |
xmlXIncludeErr(ctxt, ctxt->incTab[nr]->ref,
|
|
Packit |
423ecb |
XML_XINCLUDE_BUILD_FAILED,
|
|
Packit |
423ecb |
"failed to build node\n", NULL);
|
|
Packit |
423ecb |
return(-1);
|
|
Packit |
423ecb |
}
|
|
Packit |
423ecb |
end->type = XML_XINCLUDE_END;
|
|
Packit |
423ecb |
xmlAddNextSibling(cur, end);
|
|
Packit |
423ecb |
|
|
Packit |
423ecb |
/*
|
|
Packit |
423ecb |
* Add the list of nodes
|
|
Packit |
423ecb |
*/
|
|
Packit |
423ecb |
while (list != NULL) {
|
|
Packit |
423ecb |
cur = list;
|
|
Packit |
423ecb |
list = list->next;
|
|
Packit |
423ecb |
|
|
Packit |
423ecb |
xmlAddPrevSibling(end, cur);
|
|
Packit |
423ecb |
}
|
|
Packit |
423ecb |
}
|
|
Packit |
423ecb |
|
|
Packit |
423ecb |
|
|
Packit |
423ecb |
return(0);
|
|
Packit |
423ecb |
}
|
|
Packit |
423ecb |
|
|
Packit |
423ecb |
/**
|
|
Packit |
423ecb |
* xmlXIncludeTestNode:
|
|
Packit |
423ecb |
* @ctxt: the XInclude processing context
|
|
Packit |
423ecb |
* @node: an XInclude node
|
|
Packit |
423ecb |
*
|
|
Packit |
423ecb |
* test if the node is an XInclude node
|
|
Packit |
423ecb |
*
|
|
Packit |
423ecb |
* Returns 1 true, 0 otherwise
|
|
Packit |
423ecb |
*/
|
|
Packit |
423ecb |
static int
|
|
Packit |
423ecb |
xmlXIncludeTestNode(xmlXIncludeCtxtPtr ctxt, xmlNodePtr node) {
|
|
Packit |
423ecb |
if (node == NULL)
|
|
Packit |
423ecb |
return(0);
|
|
Packit |
423ecb |
if (node->type != XML_ELEMENT_NODE)
|
|
Packit |
423ecb |
return(0);
|
|
Packit |
423ecb |
if (node->ns == NULL)
|
|
Packit |
423ecb |
return(0);
|
|
Packit |
423ecb |
if ((xmlStrEqual(node->ns->href, XINCLUDE_NS)) ||
|
|
Packit |
423ecb |
(xmlStrEqual(node->ns->href, XINCLUDE_OLD_NS))) {
|
|
Packit |
423ecb |
if (xmlStrEqual(node->ns->href, XINCLUDE_OLD_NS)) {
|
|
Packit |
423ecb |
if (ctxt->legacy == 0) {
|
|
Packit |
423ecb |
#if 0 /* wait for the XML Core Working Group to get something stable ! */
|
|
Packit |
423ecb |
xmlXIncludeWarn(ctxt, node, XML_XINCLUDE_DEPRECATED_NS,
|
|
Packit |
423ecb |
"Deprecated XInclude namespace found, use %s",
|
|
Packit |
423ecb |
XINCLUDE_NS);
|
|
Packit |
423ecb |
#endif
|
|
Packit |
423ecb |
ctxt->legacy = 1;
|
|
Packit |
423ecb |
}
|
|
Packit |
423ecb |
}
|
|
Packit |
423ecb |
if (xmlStrEqual(node->name, XINCLUDE_NODE)) {
|
|
Packit |
423ecb |
xmlNodePtr child = node->children;
|
|
Packit |
423ecb |
int nb_fallback = 0;
|
|
Packit |
423ecb |
|
|
Packit |
423ecb |
while (child != NULL) {
|
|
Packit |
423ecb |
if ((child->type == XML_ELEMENT_NODE) &&
|
|
Packit |
423ecb |
(child->ns != NULL) &&
|
|
Packit |
423ecb |
((xmlStrEqual(child->ns->href, XINCLUDE_NS)) ||
|
|
Packit |
423ecb |
(xmlStrEqual(child->ns->href, XINCLUDE_OLD_NS)))) {
|
|
Packit |
423ecb |
if (xmlStrEqual(child->name, XINCLUDE_NODE)) {
|
|
Packit |
423ecb |
xmlXIncludeErr(ctxt, node,
|
|
Packit |
423ecb |
XML_XINCLUDE_INCLUDE_IN_INCLUDE,
|
|
Packit |
423ecb |
"%s has an 'include' child\n",
|
|
Packit |
423ecb |
XINCLUDE_NODE);
|
|
Packit |
423ecb |
return(0);
|
|
Packit |
423ecb |
}
|
|
Packit |
423ecb |
if (xmlStrEqual(child->name, XINCLUDE_FALLBACK)) {
|
|
Packit |
423ecb |
nb_fallback++;
|
|
Packit |
423ecb |
}
|
|
Packit |
423ecb |
}
|
|
Packit |
423ecb |
child = child->next;
|
|
Packit |
423ecb |
}
|
|
Packit |
423ecb |
if (nb_fallback > 1) {
|
|
Packit |
423ecb |
xmlXIncludeErr(ctxt, node, XML_XINCLUDE_FALLBACKS_IN_INCLUDE,
|
|
Packit |
423ecb |
"%s has multiple fallback children\n",
|
|
Packit |
423ecb |
XINCLUDE_NODE);
|
|
Packit |
423ecb |
return(0);
|
|
Packit |
423ecb |
}
|
|
Packit |
423ecb |
return(1);
|
|
Packit |
423ecb |
}
|
|
Packit |
423ecb |
if (xmlStrEqual(node->name, XINCLUDE_FALLBACK)) {
|
|
Packit |
423ecb |
if ((node->parent == NULL) ||
|
|
Packit |
423ecb |
(node->parent->type != XML_ELEMENT_NODE) ||
|
|
Packit |
423ecb |
(node->parent->ns == NULL) ||
|
|
Packit |
423ecb |
((!xmlStrEqual(node->parent->ns->href, XINCLUDE_NS)) &&
|
|
Packit |
423ecb |
(!xmlStrEqual(node->parent->ns->href, XINCLUDE_OLD_NS))) ||
|
|
Packit |
423ecb |
(!xmlStrEqual(node->parent->name, XINCLUDE_NODE))) {
|
|
Packit |
423ecb |
xmlXIncludeErr(ctxt, node,
|
|
Packit |
423ecb |
XML_XINCLUDE_FALLBACK_NOT_IN_INCLUDE,
|
|
Packit |
423ecb |
"%s is not the child of an 'include'\n",
|
|
Packit |
423ecb |
XINCLUDE_FALLBACK);
|
|
Packit |
423ecb |
}
|
|
Packit |
423ecb |
}
|
|
Packit |
423ecb |
}
|
|
Packit |
423ecb |
return(0);
|
|
Packit |
423ecb |
}
|
|
Packit |
423ecb |
|
|
Packit |
423ecb |
/**
|
|
Packit |
423ecb |
* xmlXIncludeDoProcess:
|
|
Packit |
423ecb |
* @ctxt: the XInclude processing context
|
|
Packit |
423ecb |
* @doc: an XML document
|
|
Packit |
423ecb |
* @tree: the top of the tree to process
|
|
Packit |
423ecb |
*
|
|
Packit |
423ecb |
* Implement the XInclude substitution on the XML document @doc
|
|
Packit |
423ecb |
*
|
|
Packit |
423ecb |
* Returns 0 if no substitution were done, -1 if some processing failed
|
|
Packit |
423ecb |
* or the number of substitutions done.
|
|
Packit |
423ecb |
*/
|
|
Packit |
423ecb |
static int
|
|
Packit |
423ecb |
xmlXIncludeDoProcess(xmlXIncludeCtxtPtr ctxt, xmlDocPtr doc, xmlNodePtr tree) {
|
|
Packit |
423ecb |
xmlNodePtr cur;
|
|
Packit |
423ecb |
int ret = 0;
|
|
Packit |
423ecb |
int i, start;
|
|
Packit |
423ecb |
|
|
Packit |
423ecb |
if ((doc == NULL) || (tree == NULL) || (tree->type == XML_NAMESPACE_DECL))
|
|
Packit |
423ecb |
return(-1);
|
|
Packit |
423ecb |
if (ctxt == NULL)
|
|
Packit |
423ecb |
return(-1);
|
|
Packit |
423ecb |
|
|
Packit |
423ecb |
if (doc->URL != NULL) {
|
|
Packit |
423ecb |
ret = xmlXIncludeURLPush(ctxt, doc->URL);
|
|
Packit |
423ecb |
if (ret < 0)
|
|
Packit |
423ecb |
return(-1);
|
|
Packit |
423ecb |
}
|
|
Packit |
423ecb |
start = ctxt->incNr;
|
|
Packit |
423ecb |
|
|
Packit |
423ecb |
/*
|
|
Packit |
423ecb |
* First phase: lookup the elements in the document
|
|
Packit |
423ecb |
*/
|
|
Packit |
423ecb |
cur = tree;
|
|
Packit |
423ecb |
if (xmlXIncludeTestNode(ctxt, cur) == 1)
|
|
Packit |
423ecb |
xmlXIncludePreProcessNode(ctxt, cur);
|
|
Packit |
423ecb |
while ((cur != NULL) && (cur != tree->parent)) {
|
|
Packit |
423ecb |
/* TODO: need to work on entities -> stack */
|
|
Packit |
423ecb |
if ((cur->children != NULL) &&
|
|
Packit |
423ecb |
(cur->children->type != XML_ENTITY_DECL) &&
|
|
Packit |
423ecb |
(cur->children->type != XML_XINCLUDE_START) &&
|
|
Packit |
423ecb |
(cur->children->type != XML_XINCLUDE_END)) {
|
|
Packit |
423ecb |
cur = cur->children;
|
|
Packit |
423ecb |
if (xmlXIncludeTestNode(ctxt, cur))
|
|
Packit |
423ecb |
xmlXIncludePreProcessNode(ctxt, cur);
|
|
Packit |
423ecb |
} else if (cur->next != NULL) {
|
|
Packit |
423ecb |
cur = cur->next;
|
|
Packit |
423ecb |
if (xmlXIncludeTestNode(ctxt, cur))
|
|
Packit |
423ecb |
xmlXIncludePreProcessNode(ctxt, cur);
|
|
Packit |
423ecb |
} else {
|
|
Packit |
423ecb |
if (cur == tree)
|
|
Packit |
423ecb |
break;
|
|
Packit |
423ecb |
do {
|
|
Packit |
423ecb |
cur = cur->parent;
|
|
Packit |
423ecb |
if ((cur == NULL) || (cur == tree->parent))
|
|
Packit |
423ecb |
break; /* do */
|
|
Packit |
423ecb |
if (cur->next != NULL) {
|
|
Packit |
423ecb |
cur = cur->next;
|
|
Packit |
423ecb |
if (xmlXIncludeTestNode(ctxt, cur))
|
|
Packit |
423ecb |
xmlXIncludePreProcessNode(ctxt, cur);
|
|
Packit |
423ecb |
break; /* do */
|
|
Packit |
423ecb |
}
|
|
Packit |
423ecb |
} while (cur != NULL);
|
|
Packit |
423ecb |
}
|
|
Packit |
423ecb |
}
|
|
Packit |
423ecb |
|
|
Packit |
423ecb |
/*
|
|
Packit |
423ecb |
* Second Phase : collect the infosets fragments
|
|
Packit |
423ecb |
*/
|
|
Packit |
423ecb |
for (i = start;i < ctxt->incNr; i++) {
|
|
Packit |
423ecb |
xmlXIncludeLoadNode(ctxt, i);
|
|
Packit |
423ecb |
ret++;
|
|
Packit |
423ecb |
}
|
|
Packit |
423ecb |
|
|
Packit |
423ecb |
/*
|
|
Packit |
423ecb |
* Third phase: extend the original document infoset.
|
|
Packit |
423ecb |
*
|
|
Packit |
423ecb |
* Originally we bypassed the inclusion if there were any errors
|
|
Packit |
423ecb |
* encountered on any of the XIncludes. A bug was raised (bug
|
|
Packit |
423ecb |
* 132588) requesting that we output the XIncludes without error,
|
|
Packit |
423ecb |
* so the check for inc!=NULL || xptr!=NULL was put in. This may
|
|
Packit |
423ecb |
* give some other problems in the future, but for now it seems to
|
|
Packit |
423ecb |
* work ok.
|
|
Packit |
423ecb |
*
|
|
Packit |
423ecb |
*/
|
|
Packit |
423ecb |
for (i = ctxt->incBase;i < ctxt->incNr; i++) {
|
|
Packit |
423ecb |
if ((ctxt->incTab[i]->inc != NULL) ||
|
|
Packit |
423ecb |
(ctxt->incTab[i]->xptr != NULL) ||
|
|
Packit |
423ecb |
(ctxt->incTab[i]->emptyFb != 0)) /* (empty fallback) */
|
|
Packit |
423ecb |
xmlXIncludeIncludeNode(ctxt, i);
|
|
Packit |
423ecb |
}
|
|
Packit |
423ecb |
|
|
Packit |
423ecb |
if (doc->URL != NULL)
|
|
Packit |
423ecb |
xmlXIncludeURLPop(ctxt);
|
|
Packit |
423ecb |
return(ret);
|
|
Packit |
423ecb |
}
|
|
Packit |
423ecb |
|
|
Packit |
423ecb |
/**
|
|
Packit |
423ecb |
* xmlXIncludeSetFlags:
|
|
Packit |
423ecb |
* @ctxt: an XInclude processing context
|
|
Packit |
423ecb |
* @flags: a set of xmlParserOption used for parsing XML includes
|
|
Packit |
423ecb |
*
|
|
Packit |
423ecb |
* Set the flags used for further processing of XML resources.
|
|
Packit |
423ecb |
*
|
|
Packit |
423ecb |
* Returns 0 in case of success and -1 in case of error.
|
|
Packit |
423ecb |
*/
|
|
Packit |
423ecb |
int
|
|
Packit |
423ecb |
xmlXIncludeSetFlags(xmlXIncludeCtxtPtr ctxt, int flags) {
|
|
Packit |
423ecb |
if (ctxt == NULL)
|
|
Packit |
423ecb |
return(-1);
|
|
Packit |
423ecb |
ctxt->parseFlags = flags;
|
|
Packit |
423ecb |
return(0);
|
|
Packit |
423ecb |
}
|
|
Packit |
423ecb |
|
|
Packit |
423ecb |
/**
|
|
Packit |
423ecb |
* xmlXIncludeProcessTreeFlagsData:
|
|
Packit |
423ecb |
* @tree: an XML node
|
|
Packit |
423ecb |
* @flags: a set of xmlParserOption used for parsing XML includes
|
|
Packit |
423ecb |
* @data: application data that will be passed to the parser context
|
|
Packit |
423ecb |
* in the _private field of the parser context(s)
|
|
Packit |
423ecb |
*
|
|
Packit |
423ecb |
* Implement the XInclude substitution on the XML node @tree
|
|
Packit |
423ecb |
*
|
|
Packit |
423ecb |
* Returns 0 if no substitution were done, -1 if some processing failed
|
|
Packit |
423ecb |
* or the number of substitutions done.
|
|
Packit |
423ecb |
*/
|
|
Packit |
423ecb |
|
|
Packit |
423ecb |
int
|
|
Packit |
423ecb |
xmlXIncludeProcessTreeFlagsData(xmlNodePtr tree, int flags, void *data) {
|
|
Packit |
423ecb |
xmlXIncludeCtxtPtr ctxt;
|
|
Packit |
423ecb |
int ret = 0;
|
|
Packit |
423ecb |
|
|
Packit |
423ecb |
if ((tree == NULL) || (tree->type == XML_NAMESPACE_DECL) ||
|
|
Packit |
423ecb |
(tree->doc == NULL))
|
|
Packit |
423ecb |
return(-1);
|
|
Packit |
423ecb |
|
|
Packit |
423ecb |
ctxt = xmlXIncludeNewContext(tree->doc);
|
|
Packit |
423ecb |
if (ctxt == NULL)
|
|
Packit |
423ecb |
return(-1);
|
|
Packit |
423ecb |
ctxt->_private = data;
|
|
Packit |
423ecb |
ctxt->base = xmlStrdup((xmlChar *)tree->doc->URL);
|
|
Packit |
423ecb |
xmlXIncludeSetFlags(ctxt, flags);
|
|
Packit |
423ecb |
ret = xmlXIncludeDoProcess(ctxt, tree->doc, tree);
|
|
Packit |
423ecb |
if ((ret >= 0) && (ctxt->nbErrors > 0))
|
|
Packit |
423ecb |
ret = -1;
|
|
Packit |
423ecb |
|
|
Packit |
423ecb |
xmlXIncludeFreeContext(ctxt);
|
|
Packit |
423ecb |
return(ret);
|
|
Packit |
423ecb |
}
|
|
Packit |
423ecb |
|
|
Packit |
423ecb |
/**
|
|
Packit |
423ecb |
* xmlXIncludeProcessFlagsData:
|
|
Packit |
423ecb |
* @doc: an XML document
|
|
Packit |
423ecb |
* @flags: a set of xmlParserOption used for parsing XML includes
|
|
Packit |
423ecb |
* @data: application data that will be passed to the parser context
|
|
Packit |
423ecb |
* in the _private field of the parser context(s)
|
|
Packit |
423ecb |
*
|
|
Packit |
423ecb |
* Implement the XInclude substitution on the XML document @doc
|
|
Packit |
423ecb |
*
|
|
Packit |
423ecb |
* Returns 0 if no substitution were done, -1 if some processing failed
|
|
Packit |
423ecb |
* or the number of substitutions done.
|
|
Packit |
423ecb |
*/
|
|
Packit |
423ecb |
int
|
|
Packit |
423ecb |
xmlXIncludeProcessFlagsData(xmlDocPtr doc, int flags, void *data) {
|
|
Packit |
423ecb |
xmlNodePtr tree;
|
|
Packit |
423ecb |
|
|
Packit |
423ecb |
if (doc == NULL)
|
|
Packit |
423ecb |
return(-1);
|
|
Packit |
423ecb |
tree = xmlDocGetRootElement(doc);
|
|
Packit |
423ecb |
if (tree == NULL)
|
|
Packit |
423ecb |
return(-1);
|
|
Packit |
423ecb |
return(xmlXIncludeProcessTreeFlagsData(tree, flags, data));
|
|
Packit |
423ecb |
}
|
|
Packit |
423ecb |
|
|
Packit |
423ecb |
/**
|
|
Packit |
423ecb |
* xmlXIncludeProcessFlags:
|
|
Packit |
423ecb |
* @doc: an XML document
|
|
Packit |
423ecb |
* @flags: a set of xmlParserOption used for parsing XML includes
|
|
Packit |
423ecb |
*
|
|
Packit |
423ecb |
* Implement the XInclude substitution on the XML document @doc
|
|
Packit |
423ecb |
*
|
|
Packit |
423ecb |
* Returns 0 if no substitution were done, -1 if some processing failed
|
|
Packit |
423ecb |
* or the number of substitutions done.
|
|
Packit |
423ecb |
*/
|
|
Packit |
423ecb |
int
|
|
Packit |
423ecb |
xmlXIncludeProcessFlags(xmlDocPtr doc, int flags) {
|
|
Packit |
423ecb |
return xmlXIncludeProcessFlagsData(doc, flags, NULL);
|
|
Packit |
423ecb |
}
|
|
Packit |
423ecb |
|
|
Packit |
423ecb |
/**
|
|
Packit |
423ecb |
* xmlXIncludeProcess:
|
|
Packit |
423ecb |
* @doc: an XML document
|
|
Packit |
423ecb |
*
|
|
Packit |
423ecb |
* Implement the XInclude substitution on the XML document @doc
|
|
Packit |
423ecb |
*
|
|
Packit |
423ecb |
* Returns 0 if no substitution were done, -1 if some processing failed
|
|
Packit |
423ecb |
* or the number of substitutions done.
|
|
Packit |
423ecb |
*/
|
|
Packit |
423ecb |
int
|
|
Packit |
423ecb |
xmlXIncludeProcess(xmlDocPtr doc) {
|
|
Packit |
423ecb |
return(xmlXIncludeProcessFlags(doc, 0));
|
|
Packit |
423ecb |
}
|
|
Packit |
423ecb |
|
|
Packit |
423ecb |
/**
|
|
Packit |
423ecb |
* xmlXIncludeProcessTreeFlags:
|
|
Packit |
423ecb |
* @tree: a node in an XML document
|
|
Packit |
423ecb |
* @flags: a set of xmlParserOption used for parsing XML includes
|
|
Packit |
423ecb |
*
|
|
Packit |
423ecb |
* Implement the XInclude substitution for the given subtree
|
|
Packit |
423ecb |
*
|
|
Packit |
423ecb |
* Returns 0 if no substitution were done, -1 if some processing failed
|
|
Packit |
423ecb |
* or the number of substitutions done.
|
|
Packit |
423ecb |
*/
|
|
Packit |
423ecb |
int
|
|
Packit |
423ecb |
xmlXIncludeProcessTreeFlags(xmlNodePtr tree, int flags) {
|
|
Packit |
423ecb |
xmlXIncludeCtxtPtr ctxt;
|
|
Packit |
423ecb |
int ret = 0;
|
|
Packit |
423ecb |
|
|
Packit |
423ecb |
if ((tree == NULL) || (tree->type == XML_NAMESPACE_DECL) ||
|
|
Packit |
423ecb |
(tree->doc == NULL))
|
|
Packit |
423ecb |
return(-1);
|
|
Packit |
423ecb |
ctxt = xmlXIncludeNewContext(tree->doc);
|
|
Packit |
423ecb |
if (ctxt == NULL)
|
|
Packit |
423ecb |
return(-1);
|
|
Packit |
423ecb |
ctxt->base = xmlNodeGetBase(tree->doc, tree);
|
|
Packit |
423ecb |
xmlXIncludeSetFlags(ctxt, flags);
|
|
Packit |
423ecb |
ret = xmlXIncludeDoProcess(ctxt, tree->doc, tree);
|
|
Packit |
423ecb |
if ((ret >= 0) && (ctxt->nbErrors > 0))
|
|
Packit |
423ecb |
ret = -1;
|
|
Packit |
423ecb |
|
|
Packit |
423ecb |
xmlXIncludeFreeContext(ctxt);
|
|
Packit |
423ecb |
return(ret);
|
|
Packit |
423ecb |
}
|
|
Packit |
423ecb |
|
|
Packit |
423ecb |
/**
|
|
Packit |
423ecb |
* xmlXIncludeProcessTree:
|
|
Packit |
423ecb |
* @tree: a node in an XML document
|
|
Packit |
423ecb |
*
|
|
Packit |
423ecb |
* Implement the XInclude substitution for the given subtree
|
|
Packit |
423ecb |
*
|
|
Packit |
423ecb |
* Returns 0 if no substitution were done, -1 if some processing failed
|
|
Packit |
423ecb |
* or the number of substitutions done.
|
|
Packit |
423ecb |
*/
|
|
Packit |
423ecb |
int
|
|
Packit |
423ecb |
xmlXIncludeProcessTree(xmlNodePtr tree) {
|
|
Packit |
423ecb |
return(xmlXIncludeProcessTreeFlags(tree, 0));
|
|
Packit |
423ecb |
}
|
|
Packit |
423ecb |
|
|
Packit |
423ecb |
/**
|
|
Packit |
423ecb |
* xmlXIncludeProcessNode:
|
|
Packit |
423ecb |
* @ctxt: an existing XInclude context
|
|
Packit |
423ecb |
* @node: a node in an XML document
|
|
Packit |
423ecb |
*
|
|
Packit |
423ecb |
* Implement the XInclude substitution for the given subtree reusing
|
|
Packit |
423ecb |
* the informations and data coming from the given context.
|
|
Packit |
423ecb |
*
|
|
Packit |
423ecb |
* Returns 0 if no substitution were done, -1 if some processing failed
|
|
Packit |
423ecb |
* or the number of substitutions done.
|
|
Packit |
423ecb |
*/
|
|
Packit |
423ecb |
int
|
|
Packit |
423ecb |
xmlXIncludeProcessNode(xmlXIncludeCtxtPtr ctxt, xmlNodePtr node) {
|
|
Packit |
423ecb |
int ret = 0;
|
|
Packit |
423ecb |
|
|
Packit |
423ecb |
if ((node == NULL) || (node->type == XML_NAMESPACE_DECL) ||
|
|
Packit |
423ecb |
(node->doc == NULL) || (ctxt == NULL))
|
|
Packit |
423ecb |
return(-1);
|
|
Packit |
423ecb |
ret = xmlXIncludeDoProcess(ctxt, node->doc, node);
|
|
Packit |
423ecb |
if ((ret >= 0) && (ctxt->nbErrors > 0))
|
|
Packit |
423ecb |
ret = -1;
|
|
Packit |
423ecb |
return(ret);
|
|
Packit |
423ecb |
}
|
|
Packit |
423ecb |
|
|
Packit |
423ecb |
#else /* !LIBXML_XINCLUDE_ENABLED */
|
|
Packit |
423ecb |
#endif
|
|
Packit |
423ecb |
#define bottom_xinclude
|
|
Packit |
423ecb |
#include "elfgcchack.h"
|