preproc.c File Reference

#include "libxslt.h"
#include <string.h>
#include <libxml/xmlmemory.h>
#include <libxml/parser.h>
#include <libxml/tree.h>
#include <libxml/valid.h>
#include <libxml/hash.h>
#include <libxml/uri.h>
#include <libxml/encoding.h>
#include <libxml/xmlerror.h>
#include "xslt.h"
#include "xsltutils.h"
#include "xsltInternals.h"
#include "transform.h"
#include "templates.h"
#include "variables.h"
#include "numbersInternals.h"
#include "preproc.h"
#include "extra.h"
#include "imports.h"
#include "extensions.h"
#include "pattern.h"

Include dependency graph for preproc.c:

Go to the source code of this file.

Macros
#define	IN_LIBXSLT

Functions
static int	xsltCheckTopLevelElement (xsltStylesheetPtr style, xmlNodePtr inst, int err)
static void	xsltCheckInstructionElement (xsltStylesheetPtr style, xmlNodePtr inst)
static void	xsltCheckParentElement (xsltStylesheetPtr style, xmlNodePtr inst, const xmlChar *allow1, const xmlChar *allow2)
static xsltStylePreCompPtr	xsltNewStylePreComp (xsltStylesheetPtr style, xsltStyleType type)
static void	xsltFreeStylePreComp (xsltStylePreCompPtr comp)
xsltElemPreCompPtr	xsltDocumentComp (xsltStylesheetPtr style, xmlNodePtr inst, xsltTransformFunction function ATTRIBUTE_UNUSED)
static void	xsltSortComp (xsltStylesheetPtr style, xmlNodePtr inst)
static void	xsltCopyComp (xsltStylesheetPtr style, xmlNodePtr inst)
static void	xsltTextComp (xsltStylesheetPtr style, xmlNodePtr inst)
static void	xsltElementComp (xsltStylesheetPtr style, xmlNodePtr inst)
static void	xsltAttributeComp (xsltStylesheetPtr style, xmlNodePtr inst)
static void	xsltCommentComp (xsltStylesheetPtr style, xmlNodePtr inst)
static void	xsltProcessingInstructionComp (xsltStylesheetPtr style, xmlNodePtr inst)
static void	xsltCopyOfComp (xsltStylesheetPtr style, xmlNodePtr inst)
static void	xsltValueOfComp (xsltStylesheetPtr style, xmlNodePtr inst)
static void	xsltGetQNameProperty (xsltStylesheetPtr style, xmlNodePtr inst, const xmlChar *propName, int mandatory, int *hasProp, const xmlChar **nsName, const xmlChar **localName)
static void	xsltWithParamComp (xsltStylesheetPtr style, xmlNodePtr inst)
static void	xsltNumberComp (xsltStylesheetPtr style, xmlNodePtr cur)
static void	xsltApplyImportsComp (xsltStylesheetPtr style, xmlNodePtr inst)
static void	xsltCallTemplateComp (xsltStylesheetPtr style, xmlNodePtr inst)
static void	xsltApplyTemplatesComp (xsltStylesheetPtr style, xmlNodePtr inst)
static void	xsltChooseComp (xsltStylesheetPtr style, xmlNodePtr inst)
static void	xsltIfComp (xsltStylesheetPtr style, xmlNodePtr inst)
static void	xsltWhenComp (xsltStylesheetPtr style, xmlNodePtr inst)
static void	xsltForEachComp (xsltStylesheetPtr style, xmlNodePtr inst)
static void	xsltVariableComp (xsltStylesheetPtr style, xmlNodePtr inst)
static void	xsltParamComp (xsltStylesheetPtr style, xmlNodePtr inst)
void	xsltFreeStylePreComps (xsltStylesheetPtr style)
void	xsltStylePreCompute (xsltStylesheetPtr style, xmlNodePtr inst)

Variables
const xmlChar *	xsltExtMarker = (const xmlChar *) "Extension Element"

Macro Definition Documentation

IN_LIBXSLT

#define IN_LIBXSLT

Definition at line 18 of file preproc.c.

Function Documentation

xsltApplyImportsComp()

static void xsltApplyImportsComp ( xsltStylesheetPtr  style, xmlNodePtr  inst  )

static

xsltApplyImportsComp: @style: an XSLT compiled stylesheet @inst: the xslt apply-imports node

Process the xslt apply-imports node on the source node

Definition at line 1516 of file preproc.c.

                                                               {
#ifdef XSLT_REFACTORED
    xsltStyleItemApplyImportsPtr comp;
#else
    xsltStylePreCompPtr comp;
#endif
 
    if ((style == NULL) || (inst == NULL) || (inst->type != XML_ELEMENT_NODE))
    return;
 
#ifdef XSLT_REFACTORED
    comp = (xsltStyleItemApplyImportsPtr) xsltNewStylePreComp(style, XSLT_FUNC_APPLYIMPORTS);
#else
    comp = xsltNewStylePreComp(style, XSLT_FUNC_APPLYIMPORTS);
#endif
 
    if (comp == NULL)
    return;
    inst->psvi = comp;
    comp->inst = inst;
}

Referenced by xsltStylePreCompute().

xsltApplyTemplatesComp()

static void xsltApplyTemplatesComp ( xsltStylesheetPtr  style, xmlNodePtr  inst  )

static

xsltApplyTemplatesComp: @style: an XSLT compiled stylesheet @inst: the apply-templates node

Process the apply-templates node on the source node

Definition at line 1585 of file preproc.c.

                                                                 {
#ifdef XSLT_REFACTORED
    xsltStyleItemApplyTemplatesPtr comp;
#else
    xsltStylePreCompPtr comp;
#endif
 
    if ((style == NULL) || (inst == NULL) || (inst->type != XML_ELEMENT_NODE))
    return;
 
#ifdef XSLT_REFACTORED
    comp = (xsltStyleItemApplyTemplatesPtr)
    xsltNewStylePreComp(style, XSLT_FUNC_APPLYTEMPLATES);
#else
    comp = xsltNewStylePreComp(style, XSLT_FUNC_APPLYTEMPLATES);
#endif
 
    if (comp == NULL)
    return;
    inst->psvi = comp;
    comp->inst = inst;
 
    /*
     * Attribute "mode".
     */
    xsltGetQNameProperty(style, inst, BAD_CAST "mode",
    0, NULL, &(comp->modeURI), &(comp->mode));
    /*
    * Attribute "select".
    */
    comp->select = xsltGetCNsProp(style, inst, BAD_CAST "select",
    XSLT_NAMESPACE);
    if (comp->select != NULL) {
    comp->comp = xsltXPathCompile(style, comp->select);
    if (comp->comp == NULL) {
        xsltTransformError(NULL, style, inst,
        "XSLT-apply-templates: could not compile select "
        "expression '%s'\n", comp->select);
         style->errors++;
    }
    }
    /* TODO: handle (or skip) the xsl:sort and xsl:with-param */
}

Referenced by xsltStylePreCompute().

xsltAttributeComp()

static void xsltAttributeComp ( xsltStylesheetPtr  style, xmlNodePtr  inst  )

static

xsltAttributeComp: @style: an XSLT compiled stylesheet @inst: the xslt attribute node

Process the xslt attribute node on the source node

Definition at line 983 of file preproc.c.

                                                            {
#ifdef XSLT_REFACTORED
    xsltStyleItemAttributePtr comp;
#else
    xsltStylePreCompPtr comp;
#endif
 
    /*
    * <xsl:attribute
    *   name = { qname }
    *   namespace = { uri-reference }>
    *   <!-- Content: template -->
    * </xsl:attribute>
    */
    if ((style == NULL) || (inst == NULL) || (inst->type != XML_ELEMENT_NODE))
    return;
 
#ifdef XSLT_REFACTORED
    comp = (xsltStyleItemAttributePtr) xsltNewStylePreComp(style,
    XSLT_FUNC_ATTRIBUTE);
#else
    comp = xsltNewStylePreComp(style, XSLT_FUNC_ATTRIBUTE);
#endif
 
    if (comp == NULL)
    return;
    inst->psvi = comp;
    comp->inst = inst;
 
    /*
    * Attribute "name".
    */
    /*
    * TODO: Precompile the AVT. See bug #344894.
    */
    comp->name = xsltEvalStaticAttrValueTemplate(style, inst,
                 (const xmlChar *)"name",
                 NULL, &comp->has_name);
    if (! comp->has_name) {
    xsltTransformError(NULL, style, inst,
        "XSLT-attribute: The attribute 'name' is missing.\n");
    style->errors++;
    return;
    }
    /*
    * Attribute "namespace".
    */
    /*
    * TODO: Precompile the AVT. See bug #344894.
    */
    comp->ns = xsltEvalStaticAttrValueTemplate(style, inst,
    (const xmlChar *)"namespace",
    NULL, &comp->has_ns);
 
    if (comp->name != NULL) {
    if (xmlValidateQName(comp->name, 0)) {
        xsltTransformError(NULL, style, inst,
        "xsl:attribute: The value '%s' of the attribute 'name' is "
        "not a valid QName.\n", comp->name);
        style->errors++;
        } else if (xmlStrEqual(comp->name, BAD_CAST "xmlns")) {
        xsltTransformError(NULL, style, inst,
                "xsl:attribute: The attribute name 'xmlns' is not allowed.\n");
        style->errors++;
    } else {
        const xmlChar *prefix = NULL, *name;
 
        name = xsltSplitQName(style->dict, comp->name, &prefix);
        if (prefix != NULL) {
        if (comp->has_ns == 0) {
            xmlNsPtr ns;
 
            /*
            * SPEC XSLT 1.0:
            *  "If the namespace attribute is not present, then the
            *  QName is expanded into an expanded-name using the
            *  namespace declarations in effect for the xsl:element
            *  element, including any default namespace declaration.
            */
            ns = xmlSearchNs(inst->doc, inst, prefix);
            if (ns != NULL) {
            comp->ns = xmlDictLookup(style->dict, ns->href, -1);
            comp->has_ns = 1;
#ifdef XSLT_REFACTORED
            comp->nsPrefix = prefix;
            comp->name = name;
#else
                        (void)name; /* Suppress unused variable warning. */
#endif
            } else {
            xsltTransformError(NULL, style, inst,
                "xsl:attribute: The prefixed QName '%s' "
                "has no namespace binding in scope in the "
                "stylesheet; this is an error, since the "
                "namespace was not specified by the instruction "
                "itself.\n", comp->name);
            style->errors++;
            }
        }
        }
    }
    }
}

Referenced by xsltStylePreCompute().

xsltCallTemplateComp()

static void xsltCallTemplateComp ( xsltStylesheetPtr  style, xmlNodePtr  inst  )

static

xsltCallTemplateComp: @style: an XSLT compiled stylesheet @inst: the xslt call-template node

Process the xslt call-template node on the source node

Definition at line 1546 of file preproc.c.

                                                               {
#ifdef XSLT_REFACTORED
    xsltStyleItemCallTemplatePtr comp;
#else
    xsltStylePreCompPtr comp;
#endif
 
    if ((style == NULL) || (inst == NULL) || (inst->type != XML_ELEMENT_NODE))
    return;
 
#ifdef XSLT_REFACTORED
    comp = (xsltStyleItemCallTemplatePtr)
    xsltNewStylePreComp(style, XSLT_FUNC_CALLTEMPLATE);
#else
    comp = xsltNewStylePreComp(style, XSLT_FUNC_CALLTEMPLATE);
#endif
 
    if (comp == NULL)
    return;
    inst->psvi = comp;
    comp->inst = inst;
 
    /*
     * Attribute "name".
     */
    xsltGetQNameProperty(style, inst, BAD_CAST "name",
    1, &(comp->has_name), &(comp->ns), &(comp->name));
    if (comp->ns)
    comp->has_ns = 1;
}

Referenced by xsltStylePreCompute().

xsltCheckInstructionElement()

static void xsltCheckInstructionElement ( xsltStylesheetPtr  style, xmlNodePtr  inst  )

static

xsltCheckInstructionElement: @style: the XSLT stylesheet @inst: the XSLT instruction

Check that the instruction is instanciated as an instruction element.

Definition at line 110 of file preproc.c.

                                                                      {
    xmlNodePtr parent;
    int has_ext;
 
    if ((style == NULL) || (inst == NULL) || (inst->ns == NULL) ||
        (style->literal_result))
        return;
 
    has_ext = (style->extInfos != NULL);
 
    parent = inst->parent;
    if (parent == NULL) {
    xsltTransformError(NULL, style, inst,
        "internal problem: element has no parent\n");
    style->errors++;
    return;
    }
    while ((parent != NULL) && (parent->type != XML_DOCUMENT_NODE)) {
        if (((parent->ns == inst->ns) ||
         ((parent->ns != NULL) &&
          (xmlStrEqual(parent->ns->href, inst->ns->href)))) &&
        ((xmlStrEqual(parent->name, BAD_CAST "template")) ||
         (xmlStrEqual(parent->name, BAD_CAST "param")) ||
         (xmlStrEqual(parent->name, BAD_CAST "attribute")) ||
         (xmlStrEqual(parent->name, BAD_CAST "variable")))) {
        return;
    }
 
    /*
     * if we are within an extension element all bets are off
     * about the semantic there e.g. xsl:param within func:function
     */
    if ((has_ext) && (parent->ns != NULL) &&
        (xmlHashLookup(style->extInfos, parent->ns->href) != NULL))
        return;
 
        parent = parent->parent;
    }
    xsltTransformError(NULL, style, inst,
        "element %s only allowed within a template, variable or param\n",
                   inst->name);
    style->errors++;
}

Referenced by xsltStylePreCompute().

xsltCheckParentElement()

static void xsltCheckParentElement ( xsltStylesheetPtr  style, xmlNodePtr  inst, const xmlChar *  allow1, const xmlChar *  allow2  )

static

xsltCheckParentElement: @style: the XSLT stylesheet @inst: the XSLT instruction @allow1: allowed parent1 @allow2: allowed parent2

Check that the instruction is instanciated as the childre of one of the possible parents.

Definition at line 165 of file preproc.c.

                                                                     {
    xmlNodePtr parent;
 
    if ((style == NULL) || (inst == NULL) || (inst->ns == NULL) ||
        (style->literal_result))
        return;
 
    parent = inst->parent;
    if (parent == NULL) {
    xsltTransformError(NULL, style, inst,
        "internal problem: element has no parent\n");
    style->errors++;
    return;
    }
    if (((parent->ns == inst->ns) ||
     ((parent->ns != NULL) &&
      (xmlStrEqual(parent->ns->href, inst->ns->href)))) &&
    ((xmlStrEqual(parent->name, allow1)) ||
     (xmlStrEqual(parent->name, allow2)))) {
    return;
    }
 
    if (style->extInfos != NULL) {
    while ((parent != NULL) && (parent->type != XML_DOCUMENT_NODE)) {
        /*
         * if we are within an extension element all bets are off
         * about the semantic there e.g. xsl:param within func:function
         */
        if ((parent->ns != NULL) &&
        (xmlHashLookup(style->extInfos, parent->ns->href) != NULL))
        return;
 
        parent = parent->parent;
    }
    }
    xsltTransformError(NULL, style, inst,
               "element %s is not allowed within that context\n",
               inst->name);
    style->errors++;
}

Referenced by xsltStylePreCompute().

xsltCheckTopLevelElement()

static int xsltCheckTopLevelElement ( xsltStylesheetPtr  style, xmlNodePtr  inst, int  err  )

static

xsltCheckTopLevelElement: @style: the XSLT stylesheet @inst: the XSLT instruction @err: raise an error or not

Check that the instruction is instanciated as a top level element.

Returns -1 in case of error, 0 if failed and 1 in case of success

Definition at line 72 of file preproc.c.

                                                                            {
    xmlNodePtr parent;
    if ((style == NULL) || (inst == NULL) || (inst->ns == NULL))
        return(-1);
 
    parent = inst->parent;
    if (parent == NULL) {
        if (err) {
        xsltTransformError(NULL, style, inst,
            "internal problem: element has no parent\n");
        style->errors++;
    }
    return(0);
    }
    if ((parent->ns == NULL) || (parent->type != XML_ELEMENT_NODE) ||
        ((parent->ns != inst->ns) &&
     (!xmlStrEqual(parent->ns->href, inst->ns->href))) ||
    ((!xmlStrEqual(parent->name, BAD_CAST "stylesheet")) &&
     (!xmlStrEqual(parent->name, BAD_CAST "transform")))) {
    if (err) {
        xsltTransformError(NULL, style, inst,
            "element %s only allowed as child of stylesheet\n",
                   inst->name);
        style->errors++;
    }
    return(0);
    }
    return(1);
}

Referenced by xsltStylePreCompute().

xsltChooseComp()

static void xsltChooseComp ( xsltStylesheetPtr  style, xmlNodePtr  inst  )

static

xsltChooseComp: @style: an XSLT compiled stylesheet @inst: the xslt choose node

Process the xslt choose node on the source node

Definition at line 1637 of file preproc.c.

                                                         {
#ifdef XSLT_REFACTORED
    xsltStyleItemChoosePtr comp;
#else
    xsltStylePreCompPtr comp;
#endif
 
    if ((style == NULL) || (inst == NULL) || (inst->type != XML_ELEMENT_NODE))
    return;
 
#ifdef XSLT_REFACTORED
    comp = (xsltStyleItemChoosePtr)
    xsltNewStylePreComp(style, XSLT_FUNC_CHOOSE);
#else
    comp = xsltNewStylePreComp(style, XSLT_FUNC_CHOOSE);
#endif
 
    if (comp == NULL)
    return;
    inst->psvi = comp;
    comp->inst = inst;
}

Referenced by xsltStylePreCompute().

xsltCommentComp()

static void xsltCommentComp ( xsltStylesheetPtr  style, xmlNodePtr  inst  )

static

xsltCommentComp: @style: an XSLT compiled stylesheet @inst: the xslt comment node

Process the xslt comment node on the source node

Definition at line 1095 of file preproc.c.

                                                          {
#ifdef XSLT_REFACTORED
    xsltStyleItemCommentPtr comp;
#else
    xsltStylePreCompPtr comp;
#endif
 
    if ((style == NULL) || (inst == NULL) || (inst->type != XML_ELEMENT_NODE))
    return;
 
#ifdef XSLT_REFACTORED
    comp = (xsltStyleItemCommentPtr) xsltNewStylePreComp(style, XSLT_FUNC_COMMENT);
#else
    comp = xsltNewStylePreComp(style, XSLT_FUNC_COMMENT);
#endif
 
    if (comp == NULL)
    return;
    inst->psvi = comp;
    comp->inst = inst;
}

Referenced by xsltStylePreCompute().

xsltCopyComp()

static void xsltCopyComp ( xsltStylesheetPtr  style, xmlNodePtr  inst  )

static

xsltCopyComp: @style: the XSLT stylesheet @inst: the xslt copy node

Process the xslt copy node on the source node

Definition at line 774 of file preproc.c.

                                                       {
#ifdef XSLT_REFACTORED
    xsltStyleItemCopyPtr comp;
#else
    xsltStylePreCompPtr comp;
#endif
 
    if ((style == NULL) || (inst == NULL) || (inst->type != XML_ELEMENT_NODE))
    return;
#ifdef XSLT_REFACTORED
    comp = (xsltStyleItemCopyPtr) xsltNewStylePreComp(style, XSLT_FUNC_COPY);
#else
    comp = xsltNewStylePreComp(style, XSLT_FUNC_COPY);
#endif
 
    if (comp == NULL)
    return;
    inst->psvi = comp;
    comp->inst = inst;
 
 
    comp->use = xsltGetCNsProp(style, inst, (const xmlChar *)"use-attribute-sets",
                    XSLT_NAMESPACE);
    if (comp->use == NULL)
    comp->has_use = 0;
    else
    comp->has_use = 1;
}

Referenced by xsltStylePreCompute().

xsltCopyOfComp()

static void xsltCopyOfComp ( xsltStylesheetPtr  style, xmlNodePtr  inst  )

static

xsltCopyOfComp: @style: an XSLT compiled stylesheet @inst: the xslt copy-of node

Process the xslt copy-of node on the source node

Definition at line 1159 of file preproc.c.

                                                         {
#ifdef XSLT_REFACTORED
    xsltStyleItemCopyOfPtr comp;
#else
    xsltStylePreCompPtr comp;
#endif
 
    if ((style == NULL) || (inst == NULL) || (inst->type != XML_ELEMENT_NODE))
    return;
 
#ifdef XSLT_REFACTORED
    comp = (xsltStyleItemCopyOfPtr) xsltNewStylePreComp(style, XSLT_FUNC_COPYOF);
#else
    comp = xsltNewStylePreComp(style, XSLT_FUNC_COPYOF);
#endif
 
    if (comp == NULL)
    return;
    inst->psvi = comp;
    comp->inst = inst;
 
    comp->select = xsltGetCNsProp(style, inst, (const xmlChar *)"select",
                            XSLT_NAMESPACE);
    if (comp->select == NULL) {
    xsltTransformError(NULL, style, inst,
         "xsl:copy-of : select is missing\n");
    if (style != NULL) style->errors++;
    return;
    }
    comp->comp = xsltXPathCompile(style, comp->select);
    if (comp->comp == NULL) {
    xsltTransformError(NULL, style, inst,
         "xsl:copy-of : could not compile select expression '%s'\n",
                     comp->select);
    if (style != NULL) style->errors++;
    }
}

Referenced by xsltStylePreCompute().

xsltDocumentComp()

xsltElemPreCompPtr xsltDocumentComp	(	xsltStylesheetPtr	style,
		xmlNodePtr	inst,
		xsltTransformFunction function	ATTRIBUTE_UNUSED
	)

xsltDocumentComp: @style: the XSLT stylesheet @inst: the instruction in the stylesheet @function: unused

Pre process an XSLT-1.1 document element

Returns a precompiled data structure for the element

Definition at line 528 of file preproc.c.

                                                          {
#ifdef XSLT_REFACTORED
    xsltStyleItemDocumentPtr comp;
#else
    xsltStylePreCompPtr comp;
#endif
    const xmlChar *filename = NULL;
 
    /*
    * As of 2006-03-30, this function is currently defined in Libxslt
    * to be used for:
    * (in libxslt/extra.c)
    * "output" in XSLT_SAXON_NAMESPACE
    * "write" XSLT_XALAN_NAMESPACE
    * "document" XSLT_XT_NAMESPACE
    * "document" XSLT_NAMESPACE (from the abandoned old working
    *                            draft of XSLT 1.1)
    * (in libexslt/common.c)
    * "document" in EXSLT_COMMON_NAMESPACE
    */
#ifdef XSLT_REFACTORED
    comp = (xsltStyleItemDocumentPtr)
    xsltNewStylePreComp(style, XSLT_FUNC_DOCUMENT);
#else
    comp = xsltNewStylePreComp(style, XSLT_FUNC_DOCUMENT);
#endif
 
    if (comp == NULL)
    return (NULL);
    comp->inst = inst;
    comp->ver11 = 0;
 
    if (xmlStrEqual(inst->name, (const xmlChar *) "output")) {
#ifdef WITH_XSLT_DEBUG_EXTRA
    xsltGenericDebug(xsltGenericDebugContext,
        "Found saxon:output extension\n");
#endif
    /*
    * The element "output" is in the namespace XSLT_SAXON_NAMESPACE
    *   (http://icl.com/saxon)
    * The @file is in no namespace; it is an AVT.
    *   (http://www.computerwizards.com/saxon/doc/extensions.html#saxon:output)
    *
    * TODO: Do we need not to check the namespace here?
    */
    filename = xsltEvalStaticAttrValueTemplate(style, inst,
             (const xmlChar *)"file",
             NULL, &comp->has_filename);
    } else if (xmlStrEqual(inst->name, (const xmlChar *) "write")) {
#ifdef WITH_XSLT_DEBUG_EXTRA
    xsltGenericDebug(xsltGenericDebugContext,
        "Found xalan:write extension\n");
#endif
    /* the filename need to be interpreted */
    /*
    * TODO: Is "filename need to be interpreted" meant to be a todo?
    *   Where will be the filename of xalan:write be processed?
    *
    * TODO: Do we need not to check the namespace here?
    *   The extension ns is "http://xml.apache.org/xalan/redirect".
    *   See http://xml.apache.org/xalan-j/extensionslib.html.
    */
    } else if (xmlStrEqual(inst->name, (const xmlChar *) "document")) {
    if (inst->ns != NULL) {
        if (xmlStrEqual(inst->ns->href, XSLT_NAMESPACE)) {
        /*
        * Mark the instruction as being of
        * XSLT version 1.1 (abandoned).
        */
        comp->ver11 = 1;
#ifdef WITH_XSLT_DEBUG_EXTRA
        xsltGenericDebug(xsltGenericDebugContext,
            "Found xslt11:document construct\n");
#endif
        } else {
        if (xmlStrEqual(inst->ns->href,
            (const xmlChar *)"http://exslt.org/common")) {
            /* EXSLT. */
#ifdef WITH_XSLT_DEBUG_EXTRA
            xsltGenericDebug(xsltGenericDebugContext,
            "Found exslt:document extension\n");
#endif
        } else if (xmlStrEqual(inst->ns->href, XSLT_XT_NAMESPACE)) {
            /* James Clark's XT. */
#ifdef WITH_XSLT_DEBUG_EXTRA
            xsltGenericDebug(xsltGenericDebugContext,
            "Found xt:document extension\n");
#endif
        }
        }
    }
    /*
    * The element "document" is used in conjunction with the
    * following namespaces:
    *
    * 1) XSLT_NAMESPACE (http://www.w3.org/1999/XSL/Transform version 1.1)
    *    <!ELEMENT xsl:document %template;>
    *    <!ATTLIST xsl:document
    *       href %avt; #REQUIRED
    *    @href is an AVT
    *    IMPORTANT: xsl:document was in the abandoned XSLT 1.1 draft,
    *    it was removed and isn't available in XSLT 1.1 anymore.
    *    In XSLT 2.0 it was renamed to xsl:result-document.
    *
    *   All other attributes are identical to the attributes
    *   on xsl:output
    *
    * 2) EXSLT_COMMON_NAMESPACE (http://exslt.org/common)
    *    <exsl:document
    *       href = { uri-reference }
    *    TODO: is @href is an AVT?
    *
    * 3) XSLT_XT_NAMESPACE (http://www.jclark.com/xt)
    *     Example: <xt:document method="xml" href="myFile.xml">
    *    TODO: is @href is an AVT?
    *
    * In all cases @href is in no namespace.
    */
    filename = xsltEvalStaticAttrValueTemplate(style, inst,
        (const xmlChar *)"href", NULL, &comp->has_filename);
    }
    if (!comp->has_filename) {
    goto error;
    }
    comp->filename = filename;
 
error:
    return ((xsltElemPreCompPtr) comp);
}

Referenced by xsltRegisterAllExtras(), and xsltStylePreCompute().

xsltElementComp()

static void xsltElementComp ( xsltStylesheetPtr  style, xmlNodePtr  inst  )

static

xsltElementComp: @style: an XSLT compiled stylesheet @inst: the xslt element node

Process the xslt element node on the source node

Definition at line 863 of file preproc.c.

                                                          {
#ifdef XSLT_REFACTORED
    xsltStyleItemElementPtr comp;
#else
    xsltStylePreCompPtr comp;
#endif
 
    /*
    * <xsl:element
    *   name = { qname }
    *   namespace = { uri-reference }
    *   use-attribute-sets = qnames>
    *   <!-- Content: template -->
    * </xsl:element>
    */
    if ((style == NULL) || (inst == NULL) || (inst->type != XML_ELEMENT_NODE))
    return;
 
#ifdef XSLT_REFACTORED
    comp = (xsltStyleItemElementPtr) xsltNewStylePreComp(style, XSLT_FUNC_ELEMENT);
#else
    comp = xsltNewStylePreComp(style, XSLT_FUNC_ELEMENT);
#endif
 
    if (comp == NULL)
    return;
    inst->psvi = comp;
    comp->inst = inst;
 
    /*
    * Attribute "name".
    */
    /*
    * TODO: Precompile the AVT. See bug #344894.
    */
    comp->name = xsltEvalStaticAttrValueTemplate(style, inst,
    (const xmlChar *)"name", NULL, &comp->has_name);
    if (! comp->has_name) {
    xsltTransformError(NULL, style, inst,
        "xsl:element: The attribute 'name' is missing.\n");
    style->errors++;
    goto error;
    }
    /*
    * Attribute "namespace".
    */
    /*
    * TODO: Precompile the AVT. See bug #344894.
    */
    comp->ns = xsltEvalStaticAttrValueTemplate(style, inst,
    (const xmlChar *)"namespace", NULL, &comp->has_ns);
 
    if (comp->name != NULL) {
    if (xmlValidateQName(comp->name, 0)) {
        xsltTransformError(NULL, style, inst,
        "xsl:element: The value '%s' of the attribute 'name' is "
        "not a valid QName.\n", comp->name);
        style->errors++;
    } else {
        const xmlChar *prefix = NULL, *name;
 
        name = xsltSplitQName(style->dict, comp->name, &prefix);
        if (comp->has_ns == 0) {
        xmlNsPtr ns;
 
        /*
        * SPEC XSLT 1.0:
        *  "If the namespace attribute is not present, then the QName is
        *  expanded into an expanded-name using the namespace declarations
        *  in effect for the xsl:element element, including any default
        *  namespace declaration.
        */
        ns = xmlSearchNs(inst->doc, inst, prefix);
        if (ns != NULL) {
            comp->ns = xmlDictLookup(style->dict, ns->href, -1);
            comp->has_ns = 1;
#ifdef XSLT_REFACTORED
            comp->nsPrefix = prefix;
            comp->name = name;
#else
                    (void)name; /* Suppress unused variable warning. */
#endif
        } else if (prefix != NULL) {
            xsltTransformError(NULL, style, inst,
            "xsl:element: The prefixed QName '%s' "
            "has no namespace binding in scope in the "
            "stylesheet; this is an error, since the namespace was "
            "not specified by the instruction itself.\n", comp->name);
            style->errors++;
        }
        }
        if ((prefix != NULL) &&
        (!xmlStrncasecmp(prefix, (xmlChar *)"xml", 3)))
        {
        /*
        * Mark is to be skipped.
        */
        comp->has_name = 0;
        }
    }
    }
    /*
    * Attribute "use-attribute-sets",
    */
    comp->use = xsltEvalStaticAttrValueTemplate(style, inst,
               (const xmlChar *)"use-attribute-sets",
               NULL, &comp->has_use);
 
error:
    return;
}

Referenced by xsltStylePreCompute().

xsltForEachComp()

static void xsltForEachComp ( xsltStylesheetPtr  style, xmlNodePtr  inst  )

static

xsltForEachComp: @style: an XSLT compiled stylesheet @inst: the xslt for-each node

Process the xslt for-each node on the source node

Definition at line 1760 of file preproc.c.

                                                          {
#ifdef XSLT_REFACTORED
    xsltStyleItemForEachPtr comp;
#else
    xsltStylePreCompPtr comp;
#endif
 
    if ((style == NULL) || (inst == NULL) || (inst->type != XML_ELEMENT_NODE))
    return;
 
#ifdef XSLT_REFACTORED
    comp = (xsltStyleItemForEachPtr)
    xsltNewStylePreComp(style, XSLT_FUNC_FOREACH);
#else
    comp = xsltNewStylePreComp(style, XSLT_FUNC_FOREACH);
#endif
 
    if (comp == NULL)
    return;
    inst->psvi = comp;
    comp->inst = inst;
 
    comp->select = xsltGetCNsProp(style, inst, (const xmlChar *)"select",
                            XSLT_NAMESPACE);
    if (comp->select == NULL) {
    xsltTransformError(NULL, style, inst,
        "xsl:for-each : select is missing\n");
    if (style != NULL) style->errors++;
    } else {
    comp->comp = xsltXPathCompile(style, comp->select);
    if (comp->comp == NULL) {
        xsltTransformError(NULL, style, inst,
     "xsl:for-each : could not compile select expression '%s'\n",
                 comp->select);
        if (style != NULL) style->errors++;
    }
    }
    /* TODO: handle and skip the xsl:sort */
}

Referenced by xsltStylePreCompute().

xsltFreeStylePreComp()

static void xsltFreeStylePreComp ( xsltStylePreCompPtr  comp )

static

xsltFreeStylePreComp: @comp: an XSLT Style precomputed block

Free up the memory allocated by @comp

Definition at line 381 of file preproc.c.

                                               {
    if (comp == NULL)
    return;
#ifdef XSLT_REFACTORED
    /*
    * URGENT TODO: Implement destructors.
    */
    switch (comp->type) {
    case XSLT_FUNC_LITERAL_RESULT_ELEMENT:
        break;
    case XSLT_FUNC_COPY:
            break;
        case XSLT_FUNC_SORT: {
        xsltStyleItemSortPtr item = (xsltStyleItemSortPtr) comp;
        if (item->comp != NULL)
            xmlXPathFreeCompExpr(item->comp);
        }
            break;
        case XSLT_FUNC_TEXT:
            break;
        case XSLT_FUNC_ELEMENT:
            break;
        case XSLT_FUNC_ATTRIBUTE:
            break;
        case XSLT_FUNC_COMMENT:
            break;
        case XSLT_FUNC_PI:
        break;
        case XSLT_FUNC_COPYOF: {
        xsltStyleItemCopyOfPtr item = (xsltStyleItemCopyOfPtr) comp;
        if (item->comp != NULL)
            xmlXPathFreeCompExpr(item->comp);
        }
            break;
        case XSLT_FUNC_VALUEOF: {
        xsltStyleItemValueOfPtr item = (xsltStyleItemValueOfPtr) comp;
        if (item->comp != NULL)
            xmlXPathFreeCompExpr(item->comp);
        }
            break;
        case XSLT_FUNC_NUMBER: {
                xsltStyleItemNumberPtr item = (xsltStyleItemNumberPtr) comp;
                if (item->numdata.countPat != NULL)
                    xsltFreeCompMatchList(item->numdata.countPat);
                if (item->numdata.fromPat != NULL)
                    xsltFreeCompMatchList(item->numdata.fromPat);
            }
            break;
        case XSLT_FUNC_APPLYIMPORTS:
            break;
        case XSLT_FUNC_CALLTEMPLATE:
            break;
        case XSLT_FUNC_APPLYTEMPLATES: {
        xsltStyleItemApplyTemplatesPtr item =
            (xsltStyleItemApplyTemplatesPtr) comp;
        if (item->comp != NULL)
            xmlXPathFreeCompExpr(item->comp);
        }
            break;
        case XSLT_FUNC_CHOOSE:
            break;
        case XSLT_FUNC_IF: {
        xsltStyleItemIfPtr item = (xsltStyleItemIfPtr) comp;
        if (item->comp != NULL)
            xmlXPathFreeCompExpr(item->comp);
        }
            break;
        case XSLT_FUNC_FOREACH: {
        xsltStyleItemForEachPtr item =
            (xsltStyleItemForEachPtr) comp;
        if (item->comp != NULL)
            xmlXPathFreeCompExpr(item->comp);
        }
            break;
        case XSLT_FUNC_DOCUMENT:
            break;
    case XSLT_FUNC_WITHPARAM: {
        xsltStyleItemWithParamPtr item =
            (xsltStyleItemWithParamPtr) comp;
        if (item->comp != NULL)
            xmlXPathFreeCompExpr(item->comp);
        }
        break;
    case XSLT_FUNC_PARAM: {
        xsltStyleItemParamPtr item =
            (xsltStyleItemParamPtr) comp;
        if (item->comp != NULL)
            xmlXPathFreeCompExpr(item->comp);
        }
        break;
    case XSLT_FUNC_VARIABLE: {
        xsltStyleItemVariablePtr item =
            (xsltStyleItemVariablePtr) comp;
        if (item->comp != NULL)
            xmlXPathFreeCompExpr(item->comp);
        }
        break;
    case XSLT_FUNC_WHEN: {
        xsltStyleItemWhenPtr item =
            (xsltStyleItemWhenPtr) comp;
        if (item->comp != NULL)
            xmlXPathFreeCompExpr(item->comp);
        }
        break;
    case XSLT_FUNC_OTHERWISE:
    case XSLT_FUNC_FALLBACK:
    case XSLT_FUNC_MESSAGE:
    case XSLT_FUNC_INCLUDE:
    case XSLT_FUNC_ATTRSET:
 
        break;
    default:
        /* TODO: Raise error. */
        break;
    }
#else
    if (comp->comp != NULL)
    xmlXPathFreeCompExpr(comp->comp);
    if (comp->numdata.countPat != NULL)
        xsltFreeCompMatchList(comp->numdata.countPat);
    if (comp->numdata.fromPat != NULL)
        xsltFreeCompMatchList(comp->numdata.fromPat);
    if (comp->nsList != NULL)
    xmlFree(comp->nsList);
#endif
 
    xmlFree(comp);
}

Referenced by xsltFreeStylePreComps().

xsltFreeStylePreComps()

void xsltFreeStylePreComps

(

xsltStylesheetPtr

style

)

xsltFreeStylePreComps: @style: an XSLT transformation context

Free up the memory allocated by all precomputed blocks

Definition at line 1951 of file preproc.c.

                                               {
    xsltElemPreCompPtr cur, next;
 
    if (style == NULL)
    return;
 
    cur = style->preComps;
    while (cur != NULL) {
    next = cur->next;
    if (cur->type == XSLT_FUNC_EXTENSION)
        cur->free(cur);
    else
        xsltFreeStylePreComp((xsltStylePreCompPtr) cur);
    cur = next;
    }
}

Referenced by xsltFreeStylesheet().

xsltGetQNameProperty()

static void xsltGetQNameProperty ( xsltStylesheetPtr  style, xmlNodePtr  inst, const xmlChar *  propName, int  mandatory, int *  hasProp, const xmlChar **  nsName, const xmlChar **  localName  )

static

Definition at line 1258 of file preproc.c.

{
    const xmlChar *prop;
 
    if (nsName)
    *nsName = NULL;
    if (localName)
    *localName = NULL;
    if (hasProp)
    *hasProp = 0;
 
    prop = xsltGetCNsProp(style, inst, propName, XSLT_NAMESPACE);
    if (prop == NULL) {
    if (mandatory) {
        xsltTransformError(NULL, style, inst,
        "The attribute '%s' is missing.\n", propName);
        style->errors++;
        return;
    }
    } else {
        const xmlChar *URI;
 
    if (xmlValidateQName(prop, 0)) {
        xsltTransformError(NULL, style, inst,
        "The value '%s' of the attribute "
        "'%s' is not a valid QName.\n", prop, propName);
        style->errors++;
        return;
    } else {
        /*
        * @prop will be in the string dict afterwards, @URI not.
        */
        URI = xsltGetQNameURI2(style, inst, &prop);
        if (prop == NULL) {
        style->errors++;
        } else {
        if (localName)
            *localName = prop;
        if (hasProp)
            *hasProp = 1;
        if (URI != NULL) {
            /*
            * Fixes bug #308441: Put the ns-name in the dict
            * in order to pointer compare names during XPath's
            * variable lookup.
            */
            if (nsName)
            *nsName = xmlDictLookup(style->dict, URI, -1);
            /* comp->has_ns = 1; */
        }
        }
    }
    }
    return;
}

Referenced by xsltApplyTemplatesComp(), xsltCallTemplateComp(), xsltParamComp(), xsltVariableComp(), and xsltWithParamComp().

xsltIfComp()

static void xsltIfComp ( xsltStylesheetPtr  style, xmlNodePtr  inst  )

static

xsltIfComp: @style: an XSLT compiled stylesheet @inst: the xslt if node

Process the xslt if node on the source node

Definition at line 1668 of file preproc.c.

                                                     {
#ifdef XSLT_REFACTORED
    xsltStyleItemIfPtr comp;
#else
    xsltStylePreCompPtr comp;
#endif
 
    if ((style == NULL) || (inst == NULL) || (inst->type != XML_ELEMENT_NODE))
    return;
 
#ifdef XSLT_REFACTORED
    comp = (xsltStyleItemIfPtr)
    xsltNewStylePreComp(style, XSLT_FUNC_IF);
#else
    comp = xsltNewStylePreComp(style, XSLT_FUNC_IF);
#endif
 
    if (comp == NULL)
    return;
    inst->psvi = comp;
    comp->inst = inst;
 
    comp->test = xsltGetCNsProp(style, inst, (const xmlChar *)"test", XSLT_NAMESPACE);
    if (comp->test == NULL) {
    xsltTransformError(NULL, style, inst,
         "xsl:if : test is not defined\n");
    if (style != NULL) style->errors++;
    return;
    }
    comp->comp = xsltXPathCompile(style, comp->test);
    if (comp->comp == NULL) {
    xsltTransformError(NULL, style, inst,
         "xsl:if : could not compile test expression '%s'\n",
                     comp->test);
    if (style != NULL) style->errors++;
    }
}

Referenced by xsltStylePreCompute().

xsltNewStylePreComp()

static xsltStylePreCompPtr xsltNewStylePreComp ( xsltStylesheetPtr  style, xsltStyleType  type  )

static

xsltNewStylePreComp: @style: the XSLT stylesheet @type: the construct type

Create a new XSLT Style precomputed block

Returns the newly allocated specialized structure or NULL in case of error

Definition at line 225 of file preproc.c.

                                                                 {
    xsltStylePreCompPtr cur;
#ifdef XSLT_REFACTORED
    size_t size;
#endif
 
    if (style == NULL)
        return(NULL);
 
#ifdef XSLT_REFACTORED
    /*
    * URGENT TODO: Use specialized factory functions in order
    *   to avoid this ugliness.
    */
    switch (type) {
        case XSLT_FUNC_COPY:
            size = sizeof(xsltStyleItemCopy); break;
        case XSLT_FUNC_SORT:
            size = sizeof(xsltStyleItemSort); break;
        case XSLT_FUNC_TEXT:
            size = sizeof(xsltStyleItemText); break;
        case XSLT_FUNC_ELEMENT:
            size = sizeof(xsltStyleItemElement); break;
        case XSLT_FUNC_ATTRIBUTE:
            size = sizeof(xsltStyleItemAttribute); break;
        case XSLT_FUNC_COMMENT:
            size = sizeof(xsltStyleItemComment); break;
        case XSLT_FUNC_PI:
            size = sizeof(xsltStyleItemPI); break;
        case XSLT_FUNC_COPYOF:
            size = sizeof(xsltStyleItemCopyOf); break;
        case XSLT_FUNC_VALUEOF:
            size = sizeof(xsltStyleItemValueOf); break;;
        case XSLT_FUNC_NUMBER:
            size = sizeof(xsltStyleItemNumber); break;
        case XSLT_FUNC_APPLYIMPORTS:
            size = sizeof(xsltStyleItemApplyImports); break;
        case XSLT_FUNC_CALLTEMPLATE:
            size = sizeof(xsltStyleItemCallTemplate); break;
        case XSLT_FUNC_APPLYTEMPLATES:
            size = sizeof(xsltStyleItemApplyTemplates); break;
        case XSLT_FUNC_CHOOSE:
            size = sizeof(xsltStyleItemChoose); break;
        case XSLT_FUNC_IF:
            size = sizeof(xsltStyleItemIf); break;
        case XSLT_FUNC_FOREACH:
            size = sizeof(xsltStyleItemForEach); break;
        case XSLT_FUNC_DOCUMENT:
            size = sizeof(xsltStyleItemDocument); break;
    case XSLT_FUNC_WITHPARAM:
        size = sizeof(xsltStyleItemWithParam); break;
    case XSLT_FUNC_PARAM:
        size = sizeof(xsltStyleItemParam); break;
    case XSLT_FUNC_VARIABLE:
        size = sizeof(xsltStyleItemVariable); break;
    case XSLT_FUNC_WHEN:
        size = sizeof(xsltStyleItemWhen); break;
    case XSLT_FUNC_OTHERWISE:
        size = sizeof(xsltStyleItemOtherwise); break;
    default:
        xsltTransformError(NULL, style, NULL,
            "xsltNewStylePreComp : invalid type %d\n", type);
        style->errors++;
        return(NULL);
    }
    /*
    * Create the structure.
    */
    cur = (xsltStylePreCompPtr) xmlMalloc(size);
    if (cur == NULL) {
    xsltTransformError(NULL, style, NULL,
        "xsltNewStylePreComp : malloc failed\n");
    style->errors++;
    return(NULL);
    }
    memset(cur, 0, size);
 
#else /* XSLT_REFACTORED */
    /*
    * Old behaviour.
    */
    cur = (xsltStylePreCompPtr) xmlMalloc(sizeof(xsltStylePreComp));
    if (cur == NULL) {
    xsltTransformError(NULL, style, NULL,
        "xsltNewStylePreComp : malloc failed\n");
    style->errors++;
    return(NULL);
    }
    memset(cur, 0, sizeof(xsltStylePreComp));
#endif /* XSLT_REFACTORED */
 
    /*
    * URGENT TODO: Better to move this to spezialized factory functions.
    */
    cur->type = type;
    switch (cur->type) {
        case XSLT_FUNC_COPY:
            cur->func = xsltCopy;break;
        case XSLT_FUNC_SORT:
            cur->func = xsltSort;break;
        case XSLT_FUNC_TEXT:
            cur->func = xsltText;break;
        case XSLT_FUNC_ELEMENT:
            cur->func = xsltElement;break;
        case XSLT_FUNC_ATTRIBUTE:
            cur->func = xsltAttribute;break;
        case XSLT_FUNC_COMMENT:
            cur->func = xsltComment;break;
        case XSLT_FUNC_PI:
            cur->func = xsltProcessingInstruction;
        break;
        case XSLT_FUNC_COPYOF:
            cur->func = xsltCopyOf;break;
        case XSLT_FUNC_VALUEOF:
            cur->func = xsltValueOf;break;
        case XSLT_FUNC_NUMBER:
            cur->func = xsltNumber;break;
        case XSLT_FUNC_APPLYIMPORTS:
            cur->func = xsltApplyImports;break;
        case XSLT_FUNC_CALLTEMPLATE:
            cur->func = xsltCallTemplate;break;
        case XSLT_FUNC_APPLYTEMPLATES:
            cur->func = xsltApplyTemplates;break;
        case XSLT_FUNC_CHOOSE:
            cur->func = xsltChoose;break;
        case XSLT_FUNC_IF:
            cur->func = xsltIf;break;
        case XSLT_FUNC_FOREACH:
            cur->func = xsltForEach;break;
        case XSLT_FUNC_DOCUMENT:
            cur->func = xsltDocumentElem;break;
    case XSLT_FUNC_WITHPARAM:
    case XSLT_FUNC_PARAM:
    case XSLT_FUNC_VARIABLE:
    case XSLT_FUNC_WHEN:
        break;
    default:
    if (cur->func == NULL) {
        xsltTransformError(NULL, style, NULL,
            "xsltNewStylePreComp : no function for type %d\n", type);
        style->errors++;
    }
    }
    cur->next = style->preComps;
    style->preComps = (xsltElemPreCompPtr) cur;
 
    return(cur);
}

Referenced by xsltApplyImportsComp(), xsltApplyTemplatesComp(), xsltAttributeComp(), xsltCallTemplateComp(), xsltChooseComp(), xsltCommentComp(), xsltCopyComp(), xsltCopyOfComp(), xsltDocumentComp(), xsltElementComp(), xsltForEachComp(), xsltIfComp(), xsltNumberComp(), xsltParamComp(), xsltProcessingInstructionComp(), xsltSortComp(), xsltTextComp(), xsltValueOfComp(), xsltVariableComp(), xsltWhenComp(), and xsltWithParamComp().

xsltNumberComp()

static void xsltNumberComp ( xsltStylesheetPtr  style, xmlNodePtr  cur  )

static

xsltNumberComp: @style: an XSLT compiled stylesheet @cur: the xslt number node

Process the xslt number node on the source node

Definition at line 1390 of file preproc.c.

                                                        {
#ifdef XSLT_REFACTORED
    xsltStyleItemNumberPtr comp;
#else
    xsltStylePreCompPtr comp;
#endif
    const xmlChar *prop;
 
    if ((style == NULL) || (cur == NULL) || (cur->type != XML_ELEMENT_NODE))
    return;
 
#ifdef XSLT_REFACTORED
    comp = (xsltStyleItemNumberPtr) xsltNewStylePreComp(style, XSLT_FUNC_NUMBER);
#else
    comp = xsltNewStylePreComp(style, XSLT_FUNC_NUMBER);
#endif
 
    if (comp == NULL)
    return;
    cur->psvi = comp;
 
    comp->numdata.doc = cur->doc;
    comp->numdata.node = cur;
    comp->numdata.value = xsltGetCNsProp(style, cur, (const xmlChar *)"value",
                                    XSLT_NAMESPACE);
 
    prop = xsltEvalStaticAttrValueTemplate(style, cur,
             (const xmlChar *)"format",
             XSLT_NAMESPACE, &comp->numdata.has_format);
    if (comp->numdata.has_format == 0) {
    comp->numdata.format = xmlDictLookup(style->dict, BAD_CAST "" , 0);
    } else {
    comp->numdata.format = prop;
    }
 
    comp->numdata.count = xsltGetCNsProp(style, cur, (const xmlChar *)"count",
                                         XSLT_NAMESPACE);
    comp->numdata.from = xsltGetCNsProp(style, cur, (const xmlChar *)"from",
                                        XSLT_NAMESPACE);
 
    prop = xsltGetCNsProp(style, cur, (const xmlChar *)"count", XSLT_NAMESPACE);
    if (prop != NULL) {
    comp->numdata.countPat = xsltCompilePattern(prop, cur->doc, cur, style,
                                                    NULL);
    }
 
    prop = xsltGetCNsProp(style, cur, (const xmlChar *)"from", XSLT_NAMESPACE);
    if (prop != NULL) {
    comp->numdata.fromPat = xsltCompilePattern(prop, cur->doc, cur, style,
                                                   NULL);
    }
 
    prop = xsltGetCNsProp(style, cur, (const xmlChar *)"level", XSLT_NAMESPACE);
    if (prop != NULL) {
    if (xmlStrEqual(prop, BAD_CAST("single")) ||
        xmlStrEqual(prop, BAD_CAST("multiple")) ||
        xmlStrEqual(prop, BAD_CAST("any"))) {
        comp->numdata.level = prop;
    } else {
        xsltTransformError(NULL, style, cur,
             "xsl:number : invalid value %s for level\n", prop);
        if (style != NULL) style->warnings++;
    }
    }
 
    prop = xsltGetCNsProp(style, cur, (const xmlChar *)"lang", XSLT_NAMESPACE);
    if (prop != NULL) {
        xsltTransformError(NULL, style, cur,
         "xsl:number : lang attribute not implemented\n");
    XSLT_TODO; /* xsl:number lang attribute */
    }
 
    prop = xsltGetCNsProp(style, cur, (const xmlChar *)"letter-value", XSLT_NAMESPACE);
    if (prop != NULL) {
    if (xmlStrEqual(prop, BAD_CAST("alphabetic"))) {
        xsltTransformError(NULL, style, cur,
         "xsl:number : letter-value 'alphabetic' not implemented\n");
        if (style != NULL) style->warnings++;
        XSLT_TODO; /* xsl:number letter-value attribute alphabetic */
    } else if (xmlStrEqual(prop, BAD_CAST("traditional"))) {
        xsltTransformError(NULL, style, cur,
         "xsl:number : letter-value 'traditional' not implemented\n");
        if (style != NULL) style->warnings++;
        XSLT_TODO; /* xsl:number letter-value attribute traditional */
    } else {
        xsltTransformError(NULL, style, cur,
             "xsl:number : invalid value %s for letter-value\n", prop);
        if (style != NULL) style->warnings++;
    }
    }
 
    prop = xsltGetCNsProp(style, cur, (const xmlChar *)"grouping-separator",
                    XSLT_NAMESPACE);
    if (prop != NULL) {
        comp->numdata.groupingCharacterLen = xmlStrlen(prop);
    comp->numdata.groupingCharacter =
        xsltGetUTF8Char(prop, &(comp->numdata.groupingCharacterLen));
        if (comp->numdata.groupingCharacter < 0)
            comp->numdata.groupingCharacter = 0;
    }
 
    prop = xsltGetCNsProp(style, cur, (const xmlChar *)"grouping-size", XSLT_NAMESPACE);
    if (prop != NULL) {
    sscanf((char *)prop, "%d", &comp->numdata.digitsPerGroup);
    } else {
    comp->numdata.groupingCharacter = 0;
    }
 
    /* Set default values */
    if (comp->numdata.value == NULL) {
    if (comp->numdata.level == NULL) {
        comp->numdata.level = xmlDictLookup(style->dict,
                                            BAD_CAST"single", 6);
    }
    }
 
}

Referenced by xsltStylePreCompute().

xsltParamComp()

static void xsltParamComp ( xsltStylesheetPtr  style, xmlNodePtr  inst  )

static

xsltParamComp: @style: an XSLT compiled stylesheet @inst: the xslt param node

Process the xslt param node on the source node

Definition at line 1887 of file preproc.c.

                                                        {
#ifdef XSLT_REFACTORED
    xsltStyleItemParamPtr comp;
#else
    xsltStylePreCompPtr comp;
#endif
 
    if ((style == NULL) || (inst == NULL) || (inst->type != XML_ELEMENT_NODE))
    return;
 
#ifdef XSLT_REFACTORED
    comp = (xsltStyleItemParamPtr)
    xsltNewStylePreComp(style, XSLT_FUNC_PARAM);
#else
    comp = xsltNewStylePreComp(style, XSLT_FUNC_PARAM);
#endif
 
    if (comp == NULL)
    return;
    inst->psvi = comp;
    comp->inst = inst;
 
    /*
     * Attribute "name".
     */
    xsltGetQNameProperty(style, inst, BAD_CAST "name",
    1, &(comp->has_name), &(comp->ns), &(comp->name));
    if (comp->ns)
    comp->has_ns = 1;
    /*
    * Attribute "select".
    */
    comp->select = xsltGetCNsProp(style, inst, (const xmlChar *)"select",
                            XSLT_NAMESPACE);
    if (comp->select != NULL) {
    comp->comp = xsltXPathCompile(style, comp->select);
    if (comp->comp == NULL) {
        xsltTransformError(NULL, style, inst,
        "XSLT-param: could not compile select expression '%s'.\n",
        comp->select);
        style->errors++;
    }
    if (inst->children != NULL) {
        xsltTransformError(NULL, style, inst,
        "XSLT-param: The content should be empty since the "
        "attribute 'select' is present.\n");
        style->warnings++;
    }
    }
}

Referenced by xsltStylePreCompute().

xsltProcessingInstructionComp()

static void xsltProcessingInstructionComp ( xsltStylesheetPtr  style, xmlNodePtr  inst  )

static

xsltProcessingInstructionComp: @style: an XSLT compiled stylesheet @inst: the xslt processing-instruction node

Process the xslt processing-instruction node on the source node

Definition at line 1125 of file preproc.c.

                                                                        {
#ifdef XSLT_REFACTORED
    xsltStyleItemPIPtr comp;
#else
    xsltStylePreCompPtr comp;
#endif
 
    if ((style == NULL) || (inst == NULL) || (inst->type != XML_ELEMENT_NODE))
    return;
 
#ifdef XSLT_REFACTORED
    comp = (xsltStyleItemPIPtr) xsltNewStylePreComp(style, XSLT_FUNC_PI);
#else
    comp = xsltNewStylePreComp(style, XSLT_FUNC_PI);
#endif
 
    if (comp == NULL)
    return;
    inst->psvi = comp;
    comp->inst = inst;
 
    comp->name = xsltEvalStaticAttrValueTemplate(style, inst,
                 (const xmlChar *)"name",
                 XSLT_NAMESPACE, &comp->has_name);
}

Referenced by xsltStylePreCompute().

xsltSortComp()

static void xsltSortComp ( xsltStylesheetPtr  style, xmlNodePtr  inst  )

static

xsltSortComp: @style: the XSLT stylesheet @inst: the xslt sort node

Process the xslt sort node on the source node

Definition at line 673 of file preproc.c.

                                                       {
#ifdef XSLT_REFACTORED
    xsltStyleItemSortPtr comp;
#else
    xsltStylePreCompPtr comp;
#endif
    if ((style == NULL) || (inst == NULL) || (inst->type != XML_ELEMENT_NODE))
    return;
 
#ifdef XSLT_REFACTORED
    comp = (xsltStyleItemSortPtr) xsltNewStylePreComp(style, XSLT_FUNC_SORT);
#else
    comp = xsltNewStylePreComp(style, XSLT_FUNC_SORT);
#endif
 
    if (comp == NULL)
    return;
    inst->psvi = comp;
    comp->inst = inst;
 
    comp->stype = xsltEvalStaticAttrValueTemplate(style, inst,
             (const xmlChar *)"data-type",
             NULL, &comp->has_stype);
    if (comp->stype != NULL) {
    if (xmlStrEqual(comp->stype, (const xmlChar *) "text"))
        comp->number = 0;
    else if (xmlStrEqual(comp->stype, (const xmlChar *) "number"))
        comp->number = 1;
    else {
        xsltTransformError(NULL, style, inst,
         "xsltSortComp: no support for data-type = %s\n", comp->stype);
        comp->number = 0; /* use default */
        if (style != NULL) style->warnings++;
    }
    }
    comp->order = xsltEvalStaticAttrValueTemplate(style, inst,
                  (const xmlChar *)"order",
                  NULL, &comp->has_order);
    if (comp->order != NULL) {
    if (xmlStrEqual(comp->order, (const xmlChar *) "ascending"))
        comp->descending = 0;
    else if (xmlStrEqual(comp->order, (const xmlChar *) "descending"))
        comp->descending = 1;
    else {
        xsltTransformError(NULL, style, inst,
         "xsltSortComp: invalid value %s for order\n", comp->order);
        comp->descending = 0; /* use default */
        if (style != NULL) style->warnings++;
    }
    }
    comp->case_order = xsltEvalStaticAttrValueTemplate(style, inst,
                  (const xmlChar *)"case-order",
                  NULL, &comp->has_use);
    if (comp->case_order != NULL) {
    if (xmlStrEqual(comp->case_order, (const xmlChar *) "upper-first"))
        comp->lower_first = 0;
    else if (xmlStrEqual(comp->case_order, (const xmlChar *) "lower-first"))
        comp->lower_first = 1;
    else {
        xsltTransformError(NULL, style, inst,
         "xsltSortComp: invalid value %s for order\n", comp->order);
        comp->lower_first = 0; /* use default */
        if (style != NULL) style->warnings++;
    }
    }
 
    comp->lang = xsltEvalStaticAttrValueTemplate(style, inst,
                 (const xmlChar *)"lang",
                 NULL, &comp->has_lang);
 
    comp->select = xsltGetCNsProp(style, inst,(const xmlChar *)"select", XSLT_NAMESPACE);
    if (comp->select == NULL) {
    /*
     * The default value of the select attribute is ., which will
     * cause the string-value of the current node to be used as
     * the sort key.
     */
    comp->select = xmlDictLookup(style->dict, BAD_CAST ".", 1);
    }
    comp->comp = xsltXPathCompile(style, comp->select);
    if (comp->comp == NULL) {
    xsltTransformError(NULL, style, inst,
         "xsltSortComp: could not compile select expression '%s'\n",
                     comp->select);
    if (style != NULL) style->errors++;
    }
    if (inst->children != NULL) {
    xsltTransformError(NULL, style, inst,
    "xsl:sort : is not empty\n");
    if (style != NULL) style->errors++;
    }
}

Referenced by xsltStylePreCompute().

xsltStylePreCompute()

void xsltStylePreCompute	(	xsltStylesheetPtr	style,
		xmlNodePtr	inst
	)

xsltStylePreCompute: @style: the XSLT stylesheet @inst: the instruction in the stylesheet

Precompute an XSLT stylesheet element

Definition at line 2191 of file preproc.c.

                                                              {
    /*
    * URGENT TODO: Normally inst->psvi Should never be reserved here,
    *   BUT: since if we include the same stylesheet from
    *   multiple imports, then the stylesheet will be parsed
    *   again. We simply must not try to compute the stylesheet again.
    * TODO: Get to the point where we don't need to query the
    *   namespace- and local-name of the node, but can evaluate this
    *   using cctxt->style->inode->category;
    */
    if ((inst == NULL) || (inst->type != XML_ELEMENT_NODE) ||
        (inst->psvi != NULL))
    return;
 
    if (IS_XSLT_ELEM(inst)) {
    xsltStylePreCompPtr cur;
 
    if (IS_XSLT_NAME(inst, "apply-templates")) {
        xsltCheckInstructionElement(style, inst);
        xsltApplyTemplatesComp(style, inst);
    } else if (IS_XSLT_NAME(inst, "with-param")) {
        xsltCheckParentElement(style, inst, BAD_CAST "apply-templates",
                               BAD_CAST "call-template");
        xsltWithParamComp(style, inst);
    } else if (IS_XSLT_NAME(inst, "value-of")) {
        xsltCheckInstructionElement(style, inst);
        xsltValueOfComp(style, inst);
    } else if (IS_XSLT_NAME(inst, "copy")) {
        xsltCheckInstructionElement(style, inst);
        xsltCopyComp(style, inst);
    } else if (IS_XSLT_NAME(inst, "copy-of")) {
        xsltCheckInstructionElement(style, inst);
        xsltCopyOfComp(style, inst);
    } else if (IS_XSLT_NAME(inst, "if")) {
        xsltCheckInstructionElement(style, inst);
        xsltIfComp(style, inst);
    } else if (IS_XSLT_NAME(inst, "when")) {
        xsltCheckParentElement(style, inst, BAD_CAST "choose", NULL);
        xsltWhenComp(style, inst);
    } else if (IS_XSLT_NAME(inst, "choose")) {
        xsltCheckInstructionElement(style, inst);
        xsltChooseComp(style, inst);
    } else if (IS_XSLT_NAME(inst, "for-each")) {
        xsltCheckInstructionElement(style, inst);
        xsltForEachComp(style, inst);
    } else if (IS_XSLT_NAME(inst, "apply-imports")) {
        xsltCheckInstructionElement(style, inst);
        xsltApplyImportsComp(style, inst);
    } else if (IS_XSLT_NAME(inst, "attribute")) {
        xmlNodePtr parent = inst->parent;
 
        if ((parent == NULL) ||
            (parent->type != XML_ELEMENT_NODE) || (parent->ns == NULL) ||
        ((parent->ns != inst->ns) &&
         (!xmlStrEqual(parent->ns->href, inst->ns->href))) ||
        (!xmlStrEqual(parent->name, BAD_CAST "attribute-set"))) {
        xsltCheckInstructionElement(style, inst);
        }
        xsltAttributeComp(style, inst);
    } else if (IS_XSLT_NAME(inst, "element")) {
        xsltCheckInstructionElement(style, inst);
        xsltElementComp(style, inst);
    } else if (IS_XSLT_NAME(inst, "text")) {
        xsltCheckInstructionElement(style, inst);
        xsltTextComp(style, inst);
    } else if (IS_XSLT_NAME(inst, "sort")) {
        xsltCheckParentElement(style, inst, BAD_CAST "apply-templates",
                               BAD_CAST "for-each");
        xsltSortComp(style, inst);
    } else if (IS_XSLT_NAME(inst, "comment")) {
        xsltCheckInstructionElement(style, inst);
        xsltCommentComp(style, inst);
    } else if (IS_XSLT_NAME(inst, "number")) {
        xsltCheckInstructionElement(style, inst);
        xsltNumberComp(style, inst);
    } else if (IS_XSLT_NAME(inst, "processing-instruction")) {
        xsltCheckInstructionElement(style, inst);
        xsltProcessingInstructionComp(style, inst);
    } else if (IS_XSLT_NAME(inst, "call-template")) {
        xsltCheckInstructionElement(style, inst);
        xsltCallTemplateComp(style, inst);
    } else if (IS_XSLT_NAME(inst, "param")) {
        if (xsltCheckTopLevelElement(style, inst, 0) == 0)
            xsltCheckInstructionElement(style, inst);
        xsltParamComp(style, inst);
    } else if (IS_XSLT_NAME(inst, "variable")) {
        if (xsltCheckTopLevelElement(style, inst, 0) == 0)
            xsltCheckInstructionElement(style, inst);
        xsltVariableComp(style, inst);
    } else if (IS_XSLT_NAME(inst, "otherwise")) {
        xsltCheckParentElement(style, inst, BAD_CAST "choose", NULL);
        xsltCheckInstructionElement(style, inst);
        return;
    } else if (IS_XSLT_NAME(inst, "template")) {
        xsltCheckTopLevelElement(style, inst, 1);
        return;
    } else if (IS_XSLT_NAME(inst, "output")) {
        xsltCheckTopLevelElement(style, inst, 1);
        return;
    } else if (IS_XSLT_NAME(inst, "preserve-space")) {
        xsltCheckTopLevelElement(style, inst, 1);
        return;
    } else if (IS_XSLT_NAME(inst, "strip-space")) {
        xsltCheckTopLevelElement(style, inst, 1);
        return;
    } else if ((IS_XSLT_NAME(inst, "stylesheet")) ||
               (IS_XSLT_NAME(inst, "transform"))) {
        xmlNodePtr parent = inst->parent;
 
        if ((parent == NULL) || (parent->type != XML_DOCUMENT_NODE)) {
        xsltTransformError(NULL, style, inst,
            "element %s only allowed only as root element\n",
                   inst->name);
        style->errors++;
        }
        return;
    } else if (IS_XSLT_NAME(inst, "key")) {
        xsltCheckTopLevelElement(style, inst, 1);
        return;
    } else if (IS_XSLT_NAME(inst, "message")) {
        xsltCheckInstructionElement(style, inst);
        return;
    } else if (IS_XSLT_NAME(inst, "attribute-set")) {
        xsltCheckTopLevelElement(style, inst, 1);
        return;
    } else if (IS_XSLT_NAME(inst, "namespace-alias")) {
        xsltCheckTopLevelElement(style, inst, 1);
        return;
    } else if (IS_XSLT_NAME(inst, "include")) {
        xsltCheckTopLevelElement(style, inst, 1);
        return;
    } else if (IS_XSLT_NAME(inst, "import")) {
        xsltCheckTopLevelElement(style, inst, 1);
        return;
    } else if (IS_XSLT_NAME(inst, "decimal-format")) {
        xsltCheckTopLevelElement(style, inst, 1);
        return;
    } else if (IS_XSLT_NAME(inst, "fallback")) {
        xsltCheckInstructionElement(style, inst);
        return;
    } else if (IS_XSLT_NAME(inst, "document")) {
        xsltCheckInstructionElement(style, inst);
        inst->psvi = (void *) xsltDocumentComp(style, inst,
                xsltDocumentElem);
    } else if ((style == NULL) || (style->forwards_compatible == 0)) {
        xsltTransformError(NULL, style, inst,
         "xsltStylePreCompute: unknown xsl:%s\n", inst->name);
        if (style != NULL) style->warnings++;
    }
 
    cur = (xsltStylePreCompPtr) inst->psvi;
    /*
    * A ns-list is build for every XSLT item in the
    * node-tree. This is needed for XPath expressions.
    */
    if (cur != NULL) {
        int i = 0;
 
        cur->nsList = xmlGetNsList(inst->doc, inst);
            if (cur->nsList != NULL) {
        while (cur->nsList[i] != NULL)
            i++;
        }
        cur->nsNr = i;
    }
    } else {
    inst->psvi =
        (void *) xsltPreComputeExtModuleElement(style, inst);
 
    /*
     * Unknown element, maybe registered at the context
     * level. Mark it for later recognition.
     */
    if (inst->psvi == NULL)
        inst->psvi = (void *) xsltExtMarker;
    }
}

Referenced by xsltParseGlobalParam(), xsltParseGlobalVariable(), xsltParseStylesheetAttributeSet(), and xsltParseTemplateContent().

xsltTextComp()

static void xsltTextComp ( xsltStylesheetPtr  style, xmlNodePtr  inst  )

static

xsltTextComp: @style: an XSLT compiled stylesheet @inst: the xslt text node

TODO: This function is obsolete, since xsl:text won't be compiled, but removed from the tree.

Process the xslt text node on the source node

Definition at line 817 of file preproc.c.

                                                       {
#ifdef XSLT_REFACTORED
    xsltStyleItemTextPtr comp;
#else
    xsltStylePreCompPtr comp;
#endif
    const xmlChar *prop;
 
    if ((style == NULL) || (inst == NULL) || (inst->type != XML_ELEMENT_NODE))
    return;
 
#ifdef XSLT_REFACTORED
    comp = (xsltStyleItemTextPtr) xsltNewStylePreComp(style, XSLT_FUNC_TEXT);
#else
    comp = xsltNewStylePreComp(style, XSLT_FUNC_TEXT);
#endif
    if (comp == NULL)
    return;
    inst->psvi = comp;
    comp->inst = inst;
    comp->noescape = 0;
 
    prop = xsltGetCNsProp(style, inst,
        (const xmlChar *)"disable-output-escaping",
            XSLT_NAMESPACE);
    if (prop != NULL) {
    if (xmlStrEqual(prop, (const xmlChar *)"yes")) {
        comp->noescape = 1;
    } else if (!xmlStrEqual(prop,
        (const xmlChar *)"no")){
        xsltTransformError(NULL, style, inst,
        "xsl:text: disable-output-escaping allows only yes or no\n");
        if (style != NULL) style->warnings++;
    }
    }
}

Referenced by xsltStylePreCompute().

xsltValueOfComp()

static void xsltValueOfComp ( xsltStylesheetPtr  style, xmlNodePtr  inst  )

static

xsltValueOfComp: @style: an XSLT compiled stylesheet @inst: the xslt value-of node

Process the xslt value-of node on the source node

Definition at line 1205 of file preproc.c.

                                                          {
#ifdef XSLT_REFACTORED
    xsltStyleItemValueOfPtr comp;
#else
    xsltStylePreCompPtr comp;
#endif
    const xmlChar *prop;
 
    if ((style == NULL) || (inst == NULL) || (inst->type != XML_ELEMENT_NODE))
    return;
 
#ifdef XSLT_REFACTORED
    comp = (xsltStyleItemValueOfPtr) xsltNewStylePreComp(style, XSLT_FUNC_VALUEOF);
#else
    comp = xsltNewStylePreComp(style, XSLT_FUNC_VALUEOF);
#endif
 
    if (comp == NULL)
    return;
    inst->psvi = comp;
    comp->inst = inst;
 
    prop = xsltGetCNsProp(style, inst,
        (const xmlChar *)"disable-output-escaping",
            XSLT_NAMESPACE);
    if (prop != NULL) {
    if (xmlStrEqual(prop, (const xmlChar *)"yes")) {
        comp->noescape = 1;
    } else if (!xmlStrEqual(prop,
                (const xmlChar *)"no")){
        xsltTransformError(NULL, style, inst,
"xsl:value-of : disable-output-escaping allows only yes or no\n");
        if (style != NULL) style->warnings++;
    }
    }
    comp->select = xsltGetCNsProp(style, inst, (const xmlChar *)"select",
                            XSLT_NAMESPACE);
    if (comp->select == NULL) {
    xsltTransformError(NULL, style, inst,
         "xsl:value-of : select is missing\n");
    if (style != NULL) style->errors++;
    return;
    }
    comp->comp = xsltXPathCompile(style, comp->select);
    if (comp->comp == NULL) {
    xsltTransformError(NULL, style, inst,
         "xsl:value-of : could not compile select expression '%s'\n",
                     comp->select);
    if (style != NULL) style->errors++;
    }
}

Referenced by xsltStylePreCompute().

xsltVariableComp()

static void xsltVariableComp ( xsltStylesheetPtr  style, xmlNodePtr  inst  )

static

xsltVariableComp: @style: an XSLT compiled stylesheet @inst: the xslt variable node

Process the xslt variable node on the source node

Definition at line 1808 of file preproc.c.

                                                           {
#ifdef XSLT_REFACTORED
    xsltStyleItemVariablePtr comp;
#else
    xsltStylePreCompPtr comp;
#endif
 
    if ((style == NULL) || (inst == NULL) || (inst->type != XML_ELEMENT_NODE))
    return;
 
#ifdef XSLT_REFACTORED
    comp = (xsltStyleItemVariablePtr)
    xsltNewStylePreComp(style, XSLT_FUNC_VARIABLE);
#else
    comp = xsltNewStylePreComp(style, XSLT_FUNC_VARIABLE);
#endif
 
    if (comp == NULL)
    return;
 
    inst->psvi = comp;
    comp->inst = inst;
    /*
     * The full template resolution can be done statically
     */
 
    /*
    * Attribute "name".
    */
    xsltGetQNameProperty(style, inst, BAD_CAST "name",
    1, &(comp->has_name), &(comp->ns), &(comp->name));
    if (comp->ns)
    comp->has_ns = 1;
    /*
    * Attribute "select".
    */
    comp->select = xsltGetCNsProp(style, inst, (const xmlChar *)"select",
                            XSLT_NAMESPACE);
    if (comp->select != NULL) {
#ifndef XSLT_REFACTORED
        xmlNodePtr cur;
#endif
    comp->comp = xsltXPathCompile(style, comp->select);
    if (comp->comp == NULL) {
        xsltTransformError(NULL, style, inst,
        "XSLT-variable: Failed to compile the XPath expression '%s'.\n",
        comp->select);
        style->errors++;
    }
#ifdef XSLT_REFACTORED
    if (inst->children != NULL) {
        xsltTransformError(NULL, style, inst,
        "XSLT-variable: There must be no child nodes, since the "
        "attribute 'select' was specified.\n");
        style->errors++;
    }
#else
        for (cur = inst->children; cur != NULL; cur = cur->next) {
            if (cur->type != XML_COMMENT_NODE &&
                (cur->type != XML_TEXT_NODE || !xsltIsBlank(cur->content)))
            {
                xsltTransformError(NULL, style, inst,
                    "XSLT-variable: There must be no child nodes, since the "
                    "attribute 'select' was specified.\n");
                style->errors++;
            }
        }
#endif
    }
}

Referenced by xsltStylePreCompute().

xsltWhenComp()

static void xsltWhenComp ( xsltStylesheetPtr  style, xmlNodePtr  inst  )

static

xsltWhenComp: @style: an XSLT compiled stylesheet @inst: the xslt if node

Process the xslt if node on the source node

Definition at line 1714 of file preproc.c.

                                                       {
#ifdef XSLT_REFACTORED
    xsltStyleItemWhenPtr comp;
#else
    xsltStylePreCompPtr comp;
#endif
 
    if ((style == NULL) || (inst == NULL) || (inst->type != XML_ELEMENT_NODE))
    return;
 
#ifdef XSLT_REFACTORED
    comp = (xsltStyleItemWhenPtr)
    xsltNewStylePreComp(style, XSLT_FUNC_WHEN);
#else
    comp = xsltNewStylePreComp(style, XSLT_FUNC_WHEN);
#endif
 
    if (comp == NULL)
    return;
    inst->psvi = comp;
    comp->inst = inst;
 
    comp->test = xsltGetCNsProp(style, inst, (const xmlChar *)"test", XSLT_NAMESPACE);
    if (comp->test == NULL) {
    xsltTransformError(NULL, style, inst,
         "xsl:when : test is not defined\n");
    if (style != NULL) style->errors++;
    return;
    }
    comp->comp = xsltXPathCompile(style, comp->test);
    if (comp->comp == NULL) {
    xsltTransformError(NULL, style, inst,
         "xsl:when : could not compile test expression '%s'\n",
                     comp->test);
    if (style != NULL) style->errors++;
    }
}

Referenced by xsltStylePreCompute().

xsltWithParamComp()

static void xsltWithParamComp ( xsltStylesheetPtr  style, xmlNodePtr  inst  )

static

xsltWithParamComp: @style: an XSLT compiled stylesheet @inst: the xslt with-param node

Process the xslt with-param node on the source node Allowed parents: xsl:call-template, xsl:apply-templates. <xsl:with-param name = qname select = expression>

</xsl:with-param>

Definition at line 1332 of file preproc.c.

                                                            {
#ifdef XSLT_REFACTORED
    xsltStyleItemWithParamPtr comp;
#else
    xsltStylePreCompPtr comp;
#endif
 
    if ((style == NULL) || (inst == NULL) || (inst->type != XML_ELEMENT_NODE))
    return;
 
#ifdef XSLT_REFACTORED
    comp = (xsltStyleItemWithParamPtr) xsltNewStylePreComp(style, XSLT_FUNC_WITHPARAM);
#else
    comp = xsltNewStylePreComp(style, XSLT_FUNC_WITHPARAM);
#endif
 
    if (comp == NULL)
    return;
    inst->psvi = comp;
    comp->inst = inst;
 
    /*
    * Attribute "name".
    */
    xsltGetQNameProperty(style, inst, BAD_CAST "name",
    1, &(comp->has_name), &(comp->ns), &(comp->name));
    if (comp->ns)
    comp->has_ns = 1;
    /*
    * Attribute "select".
    */
    comp->select = xsltGetCNsProp(style, inst, (const xmlChar *)"select",
                            XSLT_NAMESPACE);
    if (comp->select != NULL) {
    comp->comp = xsltXPathCompile(style, comp->select);
    if (comp->comp == NULL) {
        xsltTransformError(NULL, style, inst,
         "XSLT-with-param: Failed to compile select "
         "expression '%s'\n", comp->select);
        style->errors++;
    }
    if (inst->children != NULL) {
        xsltTransformError(NULL, style, inst,
        "XSLT-with-param: The content should be empty since "
        "the attribute select is present.\n");
        style->warnings++;
    }
    }
}

Referenced by xsltStylePreCompute().

Variable Documentation

xsltExtMarker

const xmlChar* xsltExtMarker = (const xmlChar *) "Extension Element"

Definition at line 48 of file preproc.c.

Referenced by xsltApplySequenceConstructor(), and xsltStylePreCompute().