source: trunk/third/libxslt/libxslt/imports.c @ 20733

/*
 * imports.c: Implementation of the XSLT imports
 *
 * Reference:
 *   http://www.w3.org/TR/1999/REC-xslt-19991116
 *
 * See Copyright for the status of this software.
 *
 * daniel@veillard.com
 */

#define IN_LIBXSLT
#include "libxslt.h"

#include <string.h>

#ifdef HAVE_SYS_TYPES_H
#include <sys/types.h>
#endif
#ifdef HAVE_MATH_H
#include <math.h>
#endif
#ifdef HAVE_FLOAT_H
#include <float.h>
#endif
#ifdef HAVE_IEEEFP_H
#include <ieeefp.h>
#endif
#ifdef HAVE_NAN_H
#include <nan.h>
#endif
#ifdef HAVE_CTYPE_H
#include <ctype.h>
#endif

#include <libxml/xmlmemory.h>
#include <libxml/tree.h>
#include <libxml/hash.h>
#include <libxml/xmlerror.h>
#include <libxml/uri.h>
#include "xslt.h"
#include "xsltInternals.h"
#include "xsltutils.h"
#include "imports.h"
#include "documents.h"
#include "security.h"
#include "pattern.h"


/************************************************************************
 *                                                                      *
 *                      Module interfaces                               *
 *                                                                      *
 ************************************************************************/
/**
 * xsltFixImportedCompSteps:
 * @master: the "master" stylesheet
 * @style: the stylesheet being imported by the master
 *
 * normalize the comp steps for the stylesheet being imported
 * by the master, together with any imports within that. 
 *
 */
static void xsltFixImportedCompSteps(xsltStylesheetPtr master, 
                        xsltStylesheetPtr style) {
    xsltStylesheetPtr res;
    xmlHashScan(style->templatesHash,
                    (xmlHashScanner) xsltNormalizeCompSteps, master);
    master->extrasNr += style->extrasNr;
    for (res = style->imports; res != NULL; res = res->next) {
        xsltFixImportedCompSteps(master, res);
    }
}

/**
 * xsltParseStylesheetImport:
 * @style:  the XSLT stylesheet
 * @cur:  the import element
 *
 * parse an XSLT stylesheet import element
 *
 * Returns 0 in case of success -1 in case of failure.
 */

int
xsltParseStylesheetImport(xsltStylesheetPtr style, xmlNodePtr cur) {
    int ret = -1;
    xmlDocPtr import = NULL;
    xmlChar *base = NULL;
    xmlChar *uriRef = NULL;
    xmlChar *URI = NULL;
    xsltStylesheetPtr res;
    xsltSecurityPrefsPtr sec;

    if ((cur == NULL) || (style == NULL))
        return (ret);

    uriRef = xsltGetNsProp(cur, (const xmlChar *)"href", XSLT_NAMESPACE);
    if (uriRef == NULL) {
        xsltTransformError(NULL, style, cur,
            "xsl:import : missing href attribute\n");
        goto error;
    }

    base = xmlNodeGetBase(style->doc, cur);
    URI = xmlBuildURI(uriRef, base);
    if (URI == NULL) {
        xsltTransformError(NULL, style, cur,
            "xsl:import : invalid URI reference %s\n", uriRef);
        goto error;
    }

    res = style;
    while (res != NULL) {
        if (res->doc == NULL)
            break;
        if (xmlStrEqual(res->doc->URL, URI)) {
            xsltTransformError(NULL, style, cur,
               "xsl:import : recursion detected on imported URL %s\n", URI);
            goto error;
        }
        res = res->parent;
    }

    /*
     * Security framework check
     */
    sec = xsltGetDefaultSecurityPrefs();
    if (sec != NULL) {
        int secres;

        secres = xsltCheckRead(sec, NULL, URI);
        if (secres == 0) {
            xsltTransformError(NULL, NULL, NULL,
                 "xsl:import: read rights for %s denied\n",
                             URI);
            goto error;
        }
    }

    import = xsltDocDefaultLoader(URI, style->dict, XSLT_PARSE_OPTIONS,
                                  (void *) style, XSLT_LOAD_STYLESHEET);
    if (import == NULL) {
        xsltTransformError(NULL, style, cur,
            "xsl:import : unable to load %s\n", URI);
        goto error;
    }

    res = xsltParseStylesheetImportedDoc(import, style);
    if (res != NULL) {
        res->next = style->imports;
        style->imports = res;
        if (style->parent == NULL) {
            xsltFixImportedCompSteps(style, res);
        }
        ret = 0;
    } else {
        xmlFreeDoc(import);
        }

error:
    if (uriRef != NULL)
        xmlFree(uriRef);
    if (base != NULL)
        xmlFree(base);
    if (URI != NULL)
        xmlFree(URI);

    return (ret);
}

/**
 * xsltParseStylesheetInclude:
 * @style:  the XSLT stylesheet
 * @cur:  the include node
 *
 * parse an XSLT stylesheet include element
 *
 * Returns 0 in case of success -1 in case of failure
 */

int
xsltParseStylesheetInclude(xsltStylesheetPtr style, xmlNodePtr cur) {
    int ret = -1;
    xmlDocPtr oldDoc;
    xmlChar *base = NULL;
    xmlChar *uriRef = NULL;
    xmlChar *URI = NULL;
    xsltStylesheetPtr result;
    xsltDocumentPtr include;
    xsltDocumentPtr docptr;

    if ((cur == NULL) || (style == NULL))
        return (ret);

    uriRef = xsltGetNsProp(cur, (const xmlChar *)"href", XSLT_NAMESPACE);
    if (uriRef == NULL) {
        xsltTransformError(NULL, style, cur,
            "xsl:include : missing href attribute\n");
        goto error;
    }

    base = xmlNodeGetBase(style->doc, cur);
    URI = xmlBuildURI(uriRef, base);
    if (URI == NULL) {
        xsltTransformError(NULL, style, cur,
            "xsl:include : invalid URI reference %s\n", uriRef);
        goto error;
    }

    /*
     * in order to detect recursion, we check all previously included
     * stylesheets.
     */
    docptr = style->includes;
    while (docptr != NULL) {
        if (xmlStrEqual(docptr->doc->URL, URI)) {
            xsltTransformError(NULL, style, cur,
                "xsl:include : recursion detected on included URL %s\n", URI);
            goto error;
        }
        docptr = docptr->includes;
    }

    include = xsltLoadStyleDocument(style, URI);
    if (include == NULL) {
        xsltTransformError(NULL, style, cur,
            "xsl:include : unable to load %s\n", URI);
        goto error;
    }

    oldDoc = style->doc;
    style->doc = include->doc;
    /* chain to stylesheet for recursion checking */
    include->includes = style->includes;
    style->includes = include;
    result = xsltParseStylesheetProcess(style, include->doc);
    style->includes = include->includes;
    style->doc = oldDoc;
    if (result == NULL) {
        ret = -1;
        goto error;
    }
    ret = 0;

error:
    if (uriRef != NULL)
        xmlFree(uriRef);
    if (base != NULL)
        xmlFree(base);
    if (URI != NULL)
        xmlFree(URI);

    return (ret);
}

/**
 * xsltNextImport:
 * @cur:  the current XSLT stylesheet
 *
 * Find the next stylesheet in import precedence.
 *
 * Returns the next stylesheet or NULL if it was the last one
 */

xsltStylesheetPtr
xsltNextImport(xsltStylesheetPtr cur) {
    if (cur == NULL)
        return(NULL);
    if (cur->imports != NULL)
        return(cur->imports);
    if (cur->next != NULL)
        return(cur->next) ;
    do {
        cur = cur->parent;
        if (cur == NULL) return(NULL);
        if (cur->next != NULL) return(cur->next);
    } while (cur != NULL);
    return(cur);
}

/**
 * xsltNeedElemSpaceHandling:
 * @ctxt:  an XSLT transformation context
 *
 * Checks whether that stylesheet requires white-space stripping
 *
 * Returns 1 if space should be stripped, 0 if not
 */

int
xsltNeedElemSpaceHandling(xsltTransformContextPtr ctxt) {
    xsltStylesheetPtr style;

    if (ctxt == NULL)
        return(0);
    style = ctxt->style;
    while (style != NULL) {
        if (style->stripSpaces != NULL)
            return(1);
        style = xsltNextImport(style);
    }
    return(0);
}

/**
 * xsltFindElemSpaceHandling:
 * @ctxt:  an XSLT transformation context
 * @node:  an XML node
 *
 * Find strip-space or preserve-space informations for an element
 * respect the import precedence or the wildcards
 *
 * Returns 1 if space should be stripped, 0 if not, and 2 if everything
 *         should be CDTATA wrapped.
 */

int
xsltFindElemSpaceHandling(xsltTransformContextPtr ctxt, xmlNodePtr node) {
    xsltStylesheetPtr style;
    const xmlChar *val;

    if ((ctxt == NULL) || (node == NULL))
        return(0);
    style = ctxt->style;
    while (style != NULL) {
        if (node->ns != NULL) {
            val = (const xmlChar *)
              xmlHashLookup2(style->stripSpaces, node->name, node->ns->href);
        } else {
            val = (const xmlChar *)
                  xmlHashLookup2(style->stripSpaces, node->name, NULL);
        }
        if (val != NULL) {
            if (xmlStrEqual(val, (xmlChar *) "strip"))
                return(1);
            if (xmlStrEqual(val, (xmlChar *) "preserve"))
                return(0);
        } 
        if (style->stripAll == 1)
            return(1);
        if (style->stripAll == -1)
            return(0);

        style = xsltNextImport(style);
    }
    return(0);
}

/**
 * xsltFindTemplate:
 * @ctxt:  an XSLT transformation context
 * @name: the template name
 * @nameURI: the template name URI
 *
 * Finds the named template, apply import precedence rule.
 *
 * Returns the xsltTemplatePtr or NULL if not found
 */
xsltTemplatePtr
xsltFindTemplate(xsltTransformContextPtr ctxt, const xmlChar *name,
                 const xmlChar *nameURI) {
    xsltTemplatePtr cur;
    xsltStylesheetPtr style;

    if ((ctxt == NULL) || (name == NULL))
        return(NULL);
    style = ctxt->style;
    while (style != NULL) {
        cur = style->templates;
        while (cur != NULL) {
            if (xmlStrEqual(name, cur->name)) {
                if (((nameURI == NULL) && (cur->nameURI == NULL)) ||
                    ((nameURI != NULL) && (cur->nameURI != NULL) &&
                     (xmlStrEqual(nameURI, cur->nameURI)))) {
                    return(cur);
                }
            }
            cur = cur->next;
        }

        style = xsltNextImport(style);
    }
    return(NULL);
}