imports.h File Reference

#include <libxml/tree.h>
#include "xsltexports.h"
#include "xsltInternals.h"

Include dependency graph for imports.h:

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Macros
#define	XSLT_GET_IMPORT_PTR(res, style, name)
#define	XSLT_GET_IMPORT_INT(res, style, name)

Functions
XSLTPUBFUN int XSLTCALL	xsltParseStylesheetImport (xsltStylesheetPtr style, xmlNodePtr cur)
XSLTPUBFUN int XSLTCALL	xsltParseStylesheetInclude (xsltStylesheetPtr style, xmlNodePtr cur)
XSLTPUBFUN xsltStylesheetPtr XSLTCALL	xsltNextImport (xsltStylesheetPtr style)
XSLTPUBFUN int XSLTCALL	xsltNeedElemSpaceHandling (xsltTransformContextPtr ctxt)
XSLTPUBFUN int XSLTCALL	xsltFindElemSpaceHandling (xsltTransformContextPtr ctxt, xmlNodePtr node)
XSLTPUBFUN xsltTemplatePtr XSLTCALL	xsltFindTemplate (xsltTransformContextPtr ctxt, const xmlChar *name, const xmlChar *nameURI)

Macro Definition Documentation

XSLT_GET_IMPORT_INT

#define XSLT_GET_IMPORT_INT	(		res,
			style,
			name
	)

Value:

{           \
    xsltStylesheetPtr st = style;               \
    res = -1;                           \
    while (st != NULL) {                    \
    if (st->name != -1) { res = st->name; break; }  \
    st = xsltNextImport(st);                \
    }}

XSLT_GET_IMPORT_INT:

A macro to import intergers from the stylesheet cascading order.

Definition at line 40 of file imports.h.

XSLT_GET_IMPORT_PTR

#define XSLT_GET_IMPORT_PTR	(		res,
			style,
			name
	)

Value:

{           \
    xsltStylesheetPtr st = style;               \
    res = NULL;                         \
    while (st != NULL) {                    \
    if (st->name != NULL) { res = st->name; break; }    \
    st = xsltNextImport(st);                \
    }}

XSLT_GET_IMPORT_PTR:

A macro to import pointers from the stylesheet cascading order.

Definition at line 27 of file imports.h.

Function Documentation

xsltFindElemSpaceHandling()

XSLTPUBFUN int XSLTCALL xsltFindElemSpaceHandling	(	xsltTransformContextPtr	ctxt,
		xmlNodePtr	node
	)

xsltFindElemSpaceHandling: @ctxt: an XSLT transformation context @node: an XML node

Find strip-space or preserve-space information 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.

Definition at line 303 of file imports.c.

                                                                         {
    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);
            if (val == NULL) {
                val = (const xmlChar *)
                    xmlHashLookup2(style->stripSpaces, BAD_CAST "*",
                                   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);
}

Referenced by xsltApplyStripSpaces().

xsltFindTemplate()

XSLTPUBFUN xsltTemplatePtr XSLTCALL xsltFindTemplate	(	xsltTransformContextPtr	ctxt,
		const xmlChar *	name,
		const xmlChar *	nameURI
	)

Definition at line 357 of file imports.c.

                                     {
    xsltTemplatePtr cur;
    xsltStylesheetPtr style;

    if ((ctxt == NULL) || (name == NULL))
    return(NULL);
    style = ctxt->style;
    while (style != NULL) {
        if (style->namedTemplates != NULL) {
            cur = (xsltTemplatePtr)
                xmlHashLookup2(style->namedTemplates, name, nameURI);
            if (cur != NULL)
                return(cur);
        }

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

Referenced by xsltCallTemplate().

xsltNeedElemSpaceHandling()

XSLTPUBFUN int XSLTCALL xsltNeedElemSpaceHandling

(

xsltTransformContextPtr

ctxt

)

xsltNeedElemSpaceHandling: @ctxt: an XSLT transformation context

Checks whether that stylesheet requires white-space stripping

Returns 1 if space should be stripped, 0 if not

Definition at line 276 of file imports.c.

                                                        {
    xsltStylesheetPtr style;

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

Referenced by xsltApplyStylesheetInternal(), and xsltLoadDocument().

xsltNextImport()

XSLTPUBFUN xsltStylesheetPtr XSLTCALL xsltNextImport

(

xsltStylesheetPtr

cur

)

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

Definition at line 251 of file imports.c.

                                      {
    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) break;
    if (cur->next != NULL) return(cur->next);
    } while (cur != NULL);
    return(cur);
}

Referenced by xsltApplySequenceConstructor(), xsltCountKeys(), xsltDecimalFormatGetByName(), xsltDecimalFormatGetByQName(), xsltEvalGlobalVariables(), xsltFindElemSpaceHandling(), xsltFindTemplate(), xsltGetNamespace(), xsltGetTemplate(), xsltInitAllDocKeys(), xsltInitCtxtExts(), xsltInitCtxtKeys(), xsltInitDocKeyTable(), xsltNeedElemSpaceHandling(), xsltProcessUserParamInternal(), xsltResolveAttrSet(), xsltResolveStylesheetAttributeSet(), xsltResolveUseAttrSets(), and xsltStyleGetExtData().

xsltParseStylesheetImport()

XSLTPUBFUN int XSLTCALL xsltParseStylesheetImport	(	xsltStylesheetPtr	style,
		xmlNodePtr	cur
	)

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.

Definition at line 49 of file imports.c.

                                                                   {
    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 = xmlGetNsProp(cur, (const xmlChar *)"href", NULL);
    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) {
            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);
}

Referenced by xsltParseStylesheetTop().

xsltParseStylesheetInclude()

XSLTPUBFUN int XSLTCALL xsltParseStylesheetInclude	(	xsltStylesheetPtr	style,
		xmlNodePtr	cur
	)

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

Definition at line 147 of file imports.c.

                                                                    {
    int ret = -1;
    xmlDocPtr oldDoc;
    xmlChar *base = NULL;
    xmlChar *uriRef = NULL;
    xmlChar *URI = NULL;
    xsltStylesheetPtr result;
    xsltDocumentPtr include;
    xsltDocumentPtr docptr;
    int oldNopreproc;

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

    uriRef = xmlGetNsProp(cur, (const xmlChar *)"href", NULL);
    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;
    }
#ifdef XSLT_REFACTORED
    if (IS_XSLT_ELEM_FAST(cur) && (cur->psvi != NULL)) {
    ((xsltStyleItemIncludePtr) cur->psvi)->include = include;
    } else {
    xsltTransformError(NULL, style, cur,
        "Internal error: (xsltParseStylesheetInclude) "
        "The xsl:include element was not compiled.\n", URI);
    style->errors++;
    }
#endif
    oldDoc = style->doc;
    style->doc = include->doc;
    /* chain to stylesheet for recursion checking */
    include->includes = style->includes;
    style->includes = include;
    oldNopreproc = style->nopreproc;
    style->nopreproc = include->preproc;
    /*
    * TODO: This will change some values of the
    *  including stylesheet with every included module
    *  (e.g. excluded-result-prefixes)
    *  We need to strictly seperate such stylesheet-owned values.
    */
    result = xsltParseStylesheetProcess(style, include->doc);
    style->nopreproc = oldNopreproc;
    include->preproc = 1;
    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);
}

Referenced by xsltParseStylesheetTop().