variables.h File Reference

#include <libxml/xpath.h>
#include <libxml/xpathInternals.h>
#include "xsltexports.h"
#include "xsltInternals.h"
#include "functions.h"

Include dependency graph for variables.h:

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

Go to the source code of this file.

Macros
#define	XSLT_REGISTER_VARIABLE_LOOKUP(ctxt)
#define	XSLT_RVT_LOCAL   1
#define	XSLT_RVT_FUNC_RESULT   2
#define	XSLT_RVT_GLOBAL   3

Functions
XSLTPUBFUN int XSLTCALL	xsltEvalGlobalVariables (xsltTransformContextPtr ctxt)
XSLTPUBFUN int XSLTCALL	xsltEvalUserParams (xsltTransformContextPtr ctxt, const char **params)
XSLTPUBFUN int XSLTCALL	xsltQuoteUserParams (xsltTransformContextPtr ctxt, const char **params)
XSLTPUBFUN int XSLTCALL	xsltEvalOneUserParam (xsltTransformContextPtr ctxt, const xmlChar *name, const xmlChar *value)
XSLTPUBFUN int XSLTCALL	xsltQuoteOneUserParam (xsltTransformContextPtr ctxt, const xmlChar *name, const xmlChar *value)
XSLTPUBFUN void XSLTCALL	xsltParseGlobalVariable (xsltStylesheetPtr style, xmlNodePtr cur)
XSLTPUBFUN void XSLTCALL	xsltParseGlobalParam (xsltStylesheetPtr style, xmlNodePtr cur)
XSLTPUBFUN void XSLTCALL	xsltParseStylesheetVariable (xsltTransformContextPtr ctxt, xmlNodePtr cur)
XSLTPUBFUN void XSLTCALL	xsltParseStylesheetParam (xsltTransformContextPtr ctxt, xmlNodePtr cur)
XSLTPUBFUN xsltStackElemPtr XSLTCALL	xsltParseStylesheetCallerParam (xsltTransformContextPtr ctxt, xmlNodePtr cur)
XSLTPUBFUN int XSLTCALL	xsltAddStackElemList (xsltTransformContextPtr ctxt, xsltStackElemPtr elems)
XSLTPUBFUN void XSLTCALL	xsltFreeGlobalVariables (xsltTransformContextPtr ctxt)
XSLTPUBFUN xmlXPathObjectPtr XSLTCALL	xsltVariableLookup (xsltTransformContextPtr ctxt, const xmlChar *name, const xmlChar *ns_uri)
XSLTPUBFUN xmlXPathObjectPtr XSLTCALL	xsltXPathVariableLookup (void *ctxt, const xmlChar *name, const xmlChar *ns_uri)

Macro Definition Documentation

XSLT_REGISTER_VARIABLE_LOOKUP

#define XSLT_REGISTER_VARIABLE_LOOKUP

(

ctxt

)

Value:

    xmlXPathRegisterVariableLookup((ctxt)->xpathCtxt,       \
           xsltXPathVariableLookup, (void *)(ctxt));    \
    xsltRegisterAllFunctions((ctxt)->xpathCtxt);        \
    xsltRegisterAllElement(ctxt);               \
    (ctxt)->xpathCtxt->extra = ctxt

XSLT_REGISTER_VARIABLE_LOOKUP:

Registering macro, not general purpose at all but used in different modules.

Definition at line 30 of file variables.h.

XSLT_RVT_FUNC_RESULT

#define XSLT_RVT_FUNC_RESULT   2

XSLT_RVT_FUNC_RESULT:

RVT is part of results returned with func:result. The RVT won't be destroyed after exiting a template and will be reset to XSLT_RVT_LOCAL or XSLT_RVT_VARIABLE in the template that receives the return value.

Definition at line 55 of file variables.h.

XSLT_RVT_GLOBAL

#define XSLT_RVT_GLOBAL   3

XSLT_RVT_GLOBAL:

RVT is part of a global variable.

Definition at line 62 of file variables.h.

XSLT_RVT_LOCAL

#define XSLT_RVT_LOCAL   1

XSLT_RVT_LOCAL:

RVT is destroyed after the current instructions ends.

Definition at line 46 of file variables.h.

Function Documentation

xsltAddStackElemList()

XSLTPUBFUN int XSLTCALL xsltAddStackElemList	(	xsltTransformContextPtr	ctxt,
		xsltStackElemPtr	elems
	)

xsltAddStackElemList: @ctxt: xn XSLT transformation context @elems: a stack element list

Push an element list onto the stack.

Returns 0 in case of success, -1 in case of failure.

Definition at line 792 of file variables.c.

{
    return(xsltAddStackElem(ctxt, elems));
}

xsltEvalGlobalVariables()

XSLTPUBFUN int XSLTCALL xsltEvalGlobalVariables

(

xsltTransformContextPtr

ctxt

)

xsltEvalGlobalVariables: @ctxt: the XSLT transformation context

Evaluates all global variables and parameters of a stylesheet. For internal use only. This is called at start of a transformation.

Returns 0 in case of success, -1 in case of error

Definition at line 1279 of file variables.c.

                                                      {
    xsltStackElemPtr elem;
    xsltStylesheetPtr style;
 
    if ((ctxt == NULL) || (ctxt->document == NULL))
    return(-1);
 
#ifdef WITH_XSLT_DEBUG_VARIABLE
    XSLT_TRACE(ctxt,XSLT_TRACE_VARIABLES,xsltGenericDebug(xsltGenericDebugContext,
    "Registering global variables\n"));
#endif
    /*
     * Walk the list from the stylesheets and populate the hash table
     */
    style = ctxt->style;
    while (style != NULL) {
    elem = style->variables;
 
#ifdef WITH_XSLT_DEBUG_VARIABLE
    if ((style->doc != NULL) && (style->doc->URL != NULL)) {
        XSLT_TRACE(ctxt,XSLT_TRACE_VARIABLES,xsltGenericDebug(xsltGenericDebugContext,
                 "Registering global variables from %s\n",
                     style->doc->URL));
    }
#endif
 
    while (elem != NULL) {
        xsltStackElemPtr def;
 
        /*
         * Global variables are stored in the variables pool.
         */
        def = (xsltStackElemPtr)
            xmlHashLookup2(ctxt->globalVars,
                         elem->name, elem->nameURI);
        if (def == NULL) {
 
        def = xsltCopyStackElem(elem);
        if (xmlHashAddEntry2(ctxt->globalVars,
                     elem->name, elem->nameURI, def) < 0) {
                    xmlGenericError(xmlGenericErrorContext,
                                    "hash update failed\n");
                    xsltFreeStackElem(def);
                    return(-1);
                }
        } else if ((elem->comp != NULL) &&
               (elem->comp->type == XSLT_FUNC_VARIABLE)) {
        /*
         * Redefinition of variables from a different stylesheet
         * should not generate a message.
         */
        if ((elem->comp->inst != NULL) &&
            (def->comp != NULL) && (def->comp->inst != NULL) &&
            (elem->comp->inst->doc == def->comp->inst->doc))
        {
            xsltTransformError(ctxt, style, elem->comp->inst,
            "Global variable %s already defined\n", elem->name);
            if (style != NULL) style->errors++;
        }
        }
        elem = elem->next;
    }
 
    style = xsltNextImport(style);
    }
 
    /*
     * This part does the actual evaluation
     */
    xmlHashScan(ctxt->globalVars, xsltEvalGlobalVariableWrapper, ctxt);
 
    return(0);
}

Referenced by xsltApplyStylesheetInternal().

xsltEvalOneUserParam()

XSLTPUBFUN int XSLTCALL xsltEvalOneUserParam	(	xsltTransformContextPtr	ctxt,
		const xmlChar *	name,
		const xmlChar *	value
	)

Definition at line 1751 of file variables.c.

                                    {
    return xsltProcessUserParamInternal(ctxt, name, value,
                                1 /* xpath eval ? */);
}

Referenced by xsltEvalUserParams().

xsltEvalUserParams()

XSLTPUBFUN int XSLTCALL xsltEvalUserParams	(	xsltTransformContextPtr	ctxt,
		const char **	params
	)

xsltEvalUserParams:

@ctxt: the XSLT transformation context @params: a NULL terminated array of parameters name/value tuples

Evaluate the global variables of a stylesheet. This needs to be done on parsed stylesheets before starting to apply transformations. Each of the parameters is evaluated as an XPath expression and stored in the global variables/parameter hash table. If you want your parameter used literally, use xsltQuoteUserParams.

Returns 0 in case of success, -1 in case of error

Definition at line 1686 of file variables.c.

                                                                      {
    size_t indx = 0;
    const xmlChar *name;
    const xmlChar *value;
 
    if (params == NULL)
    return(0);
    while (params[indx] != NULL) {
    name = (const xmlChar *) params[indx++];
    value = (const xmlChar *) params[indx++];
    if (xsltEvalOneUserParam(ctxt, name, value) != 0)
        return(-1);
    }
    return 0;
}

Referenced by xsltApplyStylesheetInternal().

xsltFreeGlobalVariables()

XSLTPUBFUN void XSLTCALL xsltFreeGlobalVariables

(

xsltTransformContextPtr

ctxt

)

xsltFreeGlobalVariables: @ctxt: the XSLT transformation context

Free up the data associated to the global variables its value.

Definition at line 2254 of file variables.c.

                                                      {
    xmlHashFree(ctxt->globalVars, xsltFreeStackElemEntry);
}

Referenced by xsltFreeTransformContext().

xsltParseGlobalParam()

XSLTPUBFUN void XSLTCALL xsltParseGlobalParam	(	xsltStylesheetPtr	style,
		xmlNodePtr	cur
	)

xsltParseGlobalParam: @style: the XSLT stylesheet @cur: the "param" element

parse an XSLT transformation param declaration and record its value.

Definition at line 2114 of file variables.c.

                                                              {
#ifdef XSLT_REFACTORED
    xsltStyleItemParamPtr comp;
#else
    xsltStylePreCompPtr comp;
#endif
 
    if ((cur == NULL) || (style == NULL) || (cur->type != XML_ELEMENT_NODE))
    return;
 
#ifdef XSLT_REFACTORED
    /*
    * Note that xsltStylePreCompute() will be called from
    * xslt.c only.
    */
    comp = (xsltStyleItemParamPtr) cur->psvi;
#else
    xsltStylePreCompute(style, cur);
    comp = (xsltStylePreCompPtr) cur->psvi;
#endif
    if (comp == NULL) {
    xsltTransformError(NULL, style, cur,
         "xsl:param : compilation failed\n");
    return;
    }
 
    if (comp->name == NULL) {
    xsltTransformError(NULL, style, cur,
        "xsl:param : missing name attribute\n");
    return;
    }
 
    /*
    * Parse the content (a sequence constructor) of xsl:param.
    */
    if (cur->children != NULL) {
#ifdef XSLT_REFACTORED
        xsltParseSequenceConstructor(XSLT_CCTXT(style), cur->children);
#else
        xsltParseTemplateContent(style, cur);
#endif
    }
 
#ifdef WITH_XSLT_DEBUG_VARIABLE
    xsltGenericDebug(xsltGenericDebugContext,
    "Registering global param %s\n", comp->name);
#endif
 
    xsltRegisterGlobalVariable(style, comp->name, comp->ns,
    comp->select, cur->children, (xsltStylePreCompPtr) comp,
    NULL);
}

Referenced by xsltParseStylesheetTop().

xsltParseGlobalVariable()

XSLTPUBFUN void XSLTCALL xsltParseGlobalVariable	(	xsltStylesheetPtr	style,
		xmlNodePtr	cur
	)

xsltParseGlobalVariable: @style: the XSLT stylesheet @cur: the "variable" element

Parses a global XSLT 'variable' declaration at compilation time and registers it

Definition at line 2051 of file variables.c.

{
#ifdef XSLT_REFACTORED
    xsltStyleItemVariablePtr comp;
#else
    xsltStylePreCompPtr comp;
#endif
 
    if ((cur == NULL) || (style == NULL) || (cur->type != XML_ELEMENT_NODE))
    return;
 
#ifdef XSLT_REFACTORED
    /*
    * Note that xsltStylePreCompute() will be called from
    * xslt.c only.
    */
    comp = (xsltStyleItemVariablePtr) cur->psvi;
#else
    xsltStylePreCompute(style, cur);
    comp = (xsltStylePreCompPtr) cur->psvi;
#endif
    if (comp == NULL) {
    xsltTransformError(NULL, style, cur,
         "xsl:variable : compilation failed\n");
    return;
    }
 
    if (comp->name == NULL) {
    xsltTransformError(NULL, style, cur,
        "xsl:variable : missing name attribute\n");
    return;
    }
 
    /*
    * Parse the content (a sequence constructor) of xsl:variable.
    */
    if (cur->children != NULL) {
#ifdef XSLT_REFACTORED
        xsltParseSequenceConstructor(XSLT_CCTXT(style), cur->children);
#else
        xsltParseTemplateContent(style, cur);
#endif
    }
#ifdef WITH_XSLT_DEBUG_VARIABLE
    xsltGenericDebug(xsltGenericDebugContext,
    "Registering global variable %s\n", comp->name);
#endif
 
    xsltRegisterGlobalVariable(style, comp->name, comp->ns,
    comp->select, cur->children, (xsltStylePreCompPtr) comp,
    NULL);
}

Referenced by xsltParseStylesheetTop().

xsltParseStylesheetCallerParam()

XSLTPUBFUN xsltStackElemPtr XSLTCALL xsltParseStylesheetCallerParam	(	xsltTransformContextPtr	ctxt,
		xmlNodePtr	inst
	)

xsltParseStylesheetCallerParam: @ctxt: the XSLT transformation context @inst: the xsl:with-param instruction element

Processes an xsl:with-param instruction at transformation time. The value is computed, but not recorded. NOTE that this is also called with an xsl:param element from exsltFuncFunctionFunction().

Returns the new xsltStackElemPtr or NULL

Definition at line 1989 of file variables.c.

{
#ifdef XSLT_REFACTORED
    xsltStyleBasicItemVariablePtr comp;
#else
    xsltStylePreCompPtr comp;
#endif
    xmlNodePtr tree = NULL; /* The first child node of the instruction or
                               the instruction itself. */
    xsltStackElemPtr param = NULL;
 
    if ((ctxt == NULL) || (inst == NULL) || (inst->type != XML_ELEMENT_NODE))
    return(NULL);
 
#ifdef XSLT_REFACTORED
    comp = (xsltStyleBasicItemVariablePtr) inst->psvi;
#else
    comp = (xsltStylePreCompPtr) inst->psvi;
#endif
 
    if (comp == NULL) {
        xsltTransformError(ctxt, NULL, inst,
        "Internal error in xsltParseStylesheetCallerParam(): "
        "The XSLT 'with-param' instruction was not compiled.\n");
        return(NULL);
    }
    if (comp->name == NULL) {
    xsltTransformError(ctxt, NULL, inst,
        "Internal error in xsltParseStylesheetCallerParam(): "
        "XSLT 'with-param': The attribute 'name' was not compiled.\n");
    return(NULL);
    }
 
#ifdef WITH_XSLT_DEBUG_VARIABLE
    XSLT_TRACE(ctxt,XSLT_TRACE_VARIABLES,xsltGenericDebug(xsltGenericDebugContext,
        "Handling xsl:with-param %s\n", comp->name));
#endif
 
    if (comp->select == NULL) {
    tree = inst->children;
    } else {
#ifdef WITH_XSLT_DEBUG_VARIABLE
    XSLT_TRACE(ctxt,XSLT_TRACE_VARIABLES,xsltGenericDebug(xsltGenericDebugContext,
        "        select %s\n", comp->select));
#endif
    tree = inst;
    }
 
    param = xsltBuildVariable(ctxt, (xsltStylePreCompPtr) comp, tree);
 
    return(param);
}

Referenced by xsltApplyTemplates(), and xsltCallTemplate().

xsltParseStylesheetParam()

XSLTPUBFUN void XSLTCALL xsltParseStylesheetParam	(	xsltTransformContextPtr	ctxt,
		xmlNodePtr	cur
	)

xsltParseStylesheetParam: @ctxt: the XSLT transformation context @cur: the XSLT 'param' element

Registers a local XSLT 'param' declaration at transformation time and evaluates its value.

Definition at line 2218 of file variables.c.

{
#ifdef XSLT_REFACTORED
    xsltStyleItemParamPtr comp;
#else
    xsltStylePreCompPtr comp;
#endif
 
    if ((cur == NULL) || (ctxt == NULL) || (cur->type != XML_ELEMENT_NODE))
    return;
 
    comp = cur->psvi;
    if ((comp == NULL) || (comp->name == NULL)) {
    xsltTransformError(ctxt, NULL, cur,
        "Internal error in xsltParseStylesheetParam(): "
        "The XSLT 'param' declaration was not compiled correctly.\n");
    return;
    }
 
#ifdef WITH_XSLT_DEBUG_VARIABLE
    XSLT_TRACE(ctxt,XSLT_TRACE_VARIABLES,xsltGenericDebug(xsltGenericDebugContext,
    "Registering param %s\n", comp->name));
#endif
 
    xsltRegisterVariable(ctxt, (xsltStylePreCompPtr) comp, cur->children, 1);
}

Referenced by xsltApplyXSLTTemplate().

xsltParseStylesheetVariable()

XSLTPUBFUN void XSLTCALL xsltParseStylesheetVariable	(	xsltTransformContextPtr	ctxt,
		xmlNodePtr	inst
	)

xsltParseStylesheetVariable: @ctxt: the XSLT transformation context @inst: the xsl:variable instruction element

Registers a local XSLT 'variable' instruction at transformation time and evaluates its value.

Definition at line 2176 of file variables.c.

{
#ifdef XSLT_REFACTORED
    xsltStyleItemVariablePtr comp;
#else
    xsltStylePreCompPtr comp;
#endif
 
    if ((inst == NULL) || (ctxt == NULL) || (inst->type != XML_ELEMENT_NODE))
    return;
 
    comp = inst->psvi;
    if (comp == NULL) {
        xsltTransformError(ctxt, NULL, inst,
        "Internal error in xsltParseStylesheetVariable(): "
        "The XSLT 'variable' instruction was not compiled.\n");
        return;
    }
    if (comp->name == NULL) {
    xsltTransformError(ctxt, NULL, inst,
        "Internal error in xsltParseStylesheetVariable(): "
        "The attribute 'name' was not compiled.\n");
    return;
    }
 
#ifdef WITH_XSLT_DEBUG_VARIABLE
    XSLT_TRACE(ctxt,XSLT_TRACE_VARIABLES,xsltGenericDebug(xsltGenericDebugContext,
    "Registering variable '%s'\n", comp->name));
#endif
 
    xsltRegisterVariable(ctxt, (xsltStylePreCompPtr) comp, inst->children, 0);
}

Referenced by xsltApplySequenceConstructor().

xsltQuoteOneUserParam()

XSLTPUBFUN int XSLTCALL xsltQuoteOneUserParam	(	xsltTransformContextPtr	ctxt,
		const xmlChar *	name,
		const xmlChar *	value
	)

Definition at line 1772 of file variables.c.

                                    {
    return xsltProcessUserParamInternal(ctxt, name, value,
                    0 /* xpath eval ? */);
}

Referenced by xsltQuoteUserParams().

xsltQuoteUserParams()

XSLTPUBFUN int XSLTCALL xsltQuoteUserParams	(	xsltTransformContextPtr	ctxt,
		const char **	params
	)

xsltQuoteUserParams:

@ctxt: the XSLT transformation context @params: a NULL terminated arry of parameters names/values tuples

Similar to xsltEvalUserParams, but the values are treated literally and are * not evaluated as XPath expressions. This should be done on parsed stylesheets before starting to apply transformations.

Returns 0 in case of success, -1 in case of error.

Definition at line 1716 of file variables.c.

                                                                       {
    size_t indx = 0;
    const xmlChar *name;
    const xmlChar *value;
 
    if (params == NULL)
    return(0);
    while (params[indx] != NULL) {
    name = (const xmlChar *) params[indx++];
    value = (const xmlChar *) params[indx++];
    if (xsltQuoteOneUserParam(ctxt, name, value) != 0)
        return(-1);
    }
    return 0;
}

Referenced by node_transform_node_params().

xsltVariableLookup()

XSLTPUBFUN xmlXPathObjectPtr XSLTCALL xsltVariableLookup	(	xsltTransformContextPtr	ctxt,
		const xmlChar *	name,
		const xmlChar *	ns_uri
	)

Definition at line 1947 of file variables.c.

                                  {
    xsltStackElemPtr elem;
 
    if (ctxt == NULL)
    return(NULL);
 
    elem = xsltStackLookup(ctxt, name, ns_uri);
    if (elem == NULL) {
    return(xsltGlobalVariableLookup(ctxt, name, ns_uri));
    }
    if (elem->computed == 0) {
#ifdef WITH_XSLT_DEBUG_VARIABLE
    XSLT_TRACE(ctxt,XSLT_TRACE_VARIABLES,xsltGenericDebug(xsltGenericDebugContext,
                 "uncomputed variable %s\n", name));
#endif
        elem->value = xsltEvalVariable(ctxt, elem, NULL);
    elem->computed = 1;
    }
    if (elem->value != NULL)
    return(xmlXPathObjectCopy(elem->value));
#ifdef WITH_XSLT_DEBUG_VARIABLE
    XSLT_TRACE(ctxt,XSLT_TRACE_VARIABLES,xsltGenericDebug(xsltGenericDebugContext,
             "variable not found %s\n", name));
#endif
    return(NULL);
}

xsltXPathVariableLookup()

XSLTPUBFUN xmlXPathObjectPtr XSLTCALL xsltXPathVariableLookup	(	void *	ctxt,
		const xmlChar *	name,
		const xmlChar *	ns_uri
	)

Definition at line 2270 of file variables.c.

                                           {
    xsltTransformContextPtr tctxt;
    xmlXPathObjectPtr valueObj = NULL;
 
    if ((ctxt == NULL) || (name == NULL))
    return(NULL);
 
#ifdef WITH_XSLT_DEBUG_VARIABLE
    XSLT_TRACE(((xsltTransformContextPtr)ctxt),XSLT_TRACE_VARIABLES,xsltGenericDebug(xsltGenericDebugContext,
        "Lookup variable '%s'\n", name));
#endif
 
    tctxt = (xsltTransformContextPtr) ctxt;
    /*
    * Local variables/params ---------------------------------------------
    *
    * Do the lookup from the top of the stack, but
    * don't use params being computed in a call-param
    * First lookup expects the variable name and URI to
    * come from the disctionnary and hence pointer comparison.
    */
    if (tctxt->varsNr != 0) {
    int i;
    xsltStackElemPtr variable = NULL, cur;
 
    for (i = tctxt->varsNr; i > tctxt->varsBase; i--) {
        cur = tctxt->varsTab[i-1];
        if ((cur->name == name) && (cur->nameURI == ns_uri)) {
#if 0
        stack_addr++;
#endif
        variable = cur;
        goto local_variable_found;
        }
        cur = cur->next;
    }
    /*
    * Redo the lookup with interned strings to avoid string comparison.
    *
    * OPTIMIZE TODO: The problem here is, that if we request a
    *  global variable, then this will be also executed.
    */
    {
        const xmlChar *tmpName = name, *tmpNsName = ns_uri;
 
        name = xmlDictLookup(tctxt->dict, name, -1);
        if (ns_uri)
        ns_uri = xmlDictLookup(tctxt->dict, ns_uri, -1);
        if ((tmpName != name) || (tmpNsName != ns_uri)) {
        for (i = tctxt->varsNr; i > tctxt->varsBase; i--) {
            cur = tctxt->varsTab[i-1];
            if ((cur->name == name) && (cur->nameURI == ns_uri)) {
#if 0
            stack_cmp++;
#endif
            variable = cur;
            goto local_variable_found;
            }
        }
        }
    }
 
local_variable_found:
 
    if (variable) {
        if (variable->computed == 0) {
 
#ifdef WITH_XSLT_DEBUG_VARIABLE
        XSLT_TRACE(tctxt,XSLT_TRACE_VARIABLES,xsltGenericDebug(xsltGenericDebugContext,
            "uncomputed variable '%s'\n", name));
#endif
        variable->value = xsltEvalVariable(tctxt, variable, NULL);
        variable->computed = 1;
        }
        if (variable->value != NULL) {
        valueObj = xmlXPathObjectCopy(variable->value);
        }
        return(valueObj);
    }
    }
    /*
    * Global variables/params --------------------------------------------
    */
    if (tctxt->globalVars) {
    valueObj = xsltGlobalVariableLookup(tctxt, name, ns_uri);
    }
 
    if (valueObj == NULL) {
 
#ifdef WITH_XSLT_DEBUG_VARIABLE
    XSLT_TRACE(tctxt,XSLT_TRACE_VARIABLES,xsltGenericDebug(xsltGenericDebugContext,
             "variable not found '%s'\n", name));
#endif
 
    if (ns_uri) {
        xsltTransformError(tctxt, NULL, tctxt->inst,
        "Variable '{%s}%s' has not been declared.\n", ns_uri, name);
    } else {
        xsltTransformError(tctxt, NULL, tctxt->inst,
        "Variable '%s' has not been declared.\n", name);
    }
    } else {
 
#ifdef WITH_XSLT_DEBUG_VARIABLE
    XSLT_TRACE(tctxt,XSLT_TRACE_VARIABLES,xsltGenericDebug(xsltGenericDebugContext,
        "found variable '%s'\n", name));
#endif
    }
 
    return(valueObj);
}