variables.c File Reference

#include "precomp.h"

Include dependency graph for variables.c:

Go to the source code of this file.

Macros
#define	XSLT_VAR_GLOBAL   (1<<0)
#define	XSLT_VAR_IN_SELECT   (1<<1)
#define	XSLT_TCTXT_VARIABLE(c)   ((xsltStackElemPtr) (c)->contextVariable)

Functions
xmlDocPtr	xsltCreateRVT (xsltTransformContextPtr ctxt)
int	xsltRegisterTmpRVT (xsltTransformContextPtr ctxt, xmlDocPtr RVT)
int	xsltRegisterLocalRVT (xsltTransformContextPtr ctxt, xmlDocPtr RVT)
int	xsltExtensionInstructionResultFinalize (xsltTransformContextPtr ctxt ATTRIBUTE_UNUSED)
int	xsltExtensionInstructionResultRegister (xsltTransformContextPtr ctxt ATTRIBUTE_UNUSED, xmlXPathObjectPtr obj ATTRIBUTE_UNUSED)
int	xsltFlagRVTs (xsltTransformContextPtr ctxt, xmlXPathObjectPtr obj, void *val)
void	xsltReleaseRVT (xsltTransformContextPtr ctxt, xmlDocPtr RVT)
int	xsltRegisterPersistRVT (xsltTransformContextPtr ctxt, xmlDocPtr RVT)
void	xsltFreeRVTs (xsltTransformContextPtr ctxt)
static xsltStackElemPtr	xsltNewStackElem (xsltTransformContextPtr ctxt)
static xsltStackElemPtr	xsltCopyStackElem (xsltStackElemPtr elem)
static void	xsltFreeStackElem (xsltStackElemPtr elem)
static void	xsltFreeStackElemEntry (void *payload, const xmlChar *name ATTRIBUTE_UNUSED)
void	xsltFreeStackElemList (xsltStackElemPtr elem)
: the local part of the name
xsltStackLookup: @ctxt: an XSLT transformation context @nameURI: the URI part of the name Locate an element in the stack based on its name.
static xsltStackElemPtr	xsltStackLookup (xsltTransformContextPtr ctxt, const xmlChar *name, const xmlChar *nameURI)
: the variable name
xsltXPathVariableLookup: @ctxt: a void * but the the XSLT transformation context actually @ns_uri: the variable namespace URI This is the entry point when a varibale is needed by the XPath interpretor. Returns the value or NULL if not found
static int	xsltCheckStackElem (xsltTransformContextPtr ctxt, const xmlChar *name, const xmlChar *nameURI)
static int	xsltAddStackElem (xsltTransformContextPtr ctxt, xsltStackElemPtr elem)
int	xsltAddStackElemList (xsltTransformContextPtr ctxt, xsltStackElemPtr elems)
static xmlXPathObjectPtr	xsltEvalVariable (xsltTransformContextPtr ctxt, xsltStackElemPtr variable, xsltStylePreCompPtr castedComp)
static xmlXPathObjectPtr	xsltEvalGlobalVariable (xsltStackElemPtr elem, xsltTransformContextPtr ctxt)
static void	xsltEvalGlobalVariableWrapper (void *payload, void *data, const xmlChar *name ATTRIBUTE_UNUSED)
int	xsltEvalGlobalVariables (xsltTransformContextPtr ctxt)
static int	xsltRegisterGlobalVariable (xsltStylesheetPtr style, const xmlChar *name, const xmlChar *ns_uri, const xmlChar *sel, xmlNodePtr tree, xsltStylePreCompPtr comp, const xmlChar *value)
static xmlXPathObjectPtr	xsltGlobalVariableLookup (xsltTransformContextPtr ctxt, const xmlChar *name, const xmlChar *ns_uri)
xmlXPathObjectPtr	xsltVariableLookup (xsltTransformContextPtr ctxt, const xmlChar *name, const xmlChar *ns_uri)
xsltStackElemPtr	xsltParseStylesheetCallerParam (xsltTransformContextPtr ctxt, xmlNodePtr inst)
void	xsltParseGlobalVariable (xsltStylesheetPtr style, xmlNodePtr cur)
void	xsltParseGlobalParam (xsltStylesheetPtr style, xmlNodePtr cur)
void	xsltParseStylesheetVariable (xsltTransformContextPtr ctxt, xmlNodePtr inst)
void	xsltParseStylesheetParam (xsltTransformContextPtr ctxt, xmlNodePtr cur)
void	xsltFreeGlobalVariables (xsltTransformContextPtr ctxt)
xmlXPathObjectPtr	xsltXPathVariableLookup (void *ctxt, const xmlChar *name, const xmlChar *ns_uri)
: a null terminated parameter name
xsltProcessUserParamInternal @ctxt: the XSLT transformation context @value: a null terminated value (may be an XPath expression) @eval: 0 to treat the value literally, else evaluate as XPath expression If @eval is 0 then @value is treated literally and is stored in the global parameter/variable table without any change. Uf @eval is 1 then @value is treated as an XPath expression and is evaluated. In this case, if you want to pass a string which will be interpreted literally then it must be enclosed in single or double quotes. If the string contains single quotes (double quotes) then it cannot be enclosed single quotes (double quotes). If the string which you want to be treated literally contains both single and double quotes (e.g. Meet at Joe's for "Twelfth Night" at 7 o'clock) then there is no suitable quoting character. You cannot use ' or " inside the string because the replacement of character entities with their equivalents is done at a different stage of processing. The solution is to call xsltQuoteUserParams or xsltQuoteOneUserParam. This needs to be done on parsed stylesheets before starting to apply transformations. Normally this will be called (directly or indirectly) only from xsltEvalUserParams, xsltEvalOneUserParam, xsltQuoteUserParams, or xsltQuoteOneUserParam. Returns 0 in case of success, -1 in case of error
static int	xsltProcessUserParamInternal (xsltTransformContextPtr ctxt, const xmlChar *name, const xmlChar *value, int eval)
int	xsltEvalUserParams (xsltTransformContextPtr ctxt, const char **params)
int	xsltQuoteUserParams (xsltTransformContextPtr ctxt, const char **params)
: a null terminated string giving the name of the parameter
xsltQuoteOneUserParam: @ctxt: the XSLT transformation context @value: a null terminated string giving the parameter value This is normally called from xsltQuoteUserParams to process a single parameter from a list of parameters. The @value is stored in the context's global variable/parameter hash table. Returns 0 in case of success, -1 in case of error.
int	xsltEvalOneUserParam (xsltTransformContextPtr ctxt, const xmlChar *name, const xmlChar *value)
int	xsltQuoteOneUserParam (xsltTransformContextPtr ctxt, const xmlChar *name, const xmlChar *value)
static xsltStackElemPtr	xsltBuildVariable (xsltTransformContextPtr ctxt, xsltStylePreCompPtr castedComp, xmlNodePtr tree)
static int	xsltRegisterVariable (xsltTransformContextPtr ctxt, xsltStylePreCompPtr castedComp, xmlNodePtr tree, int isParam)

Variables
static const xmlChar *	xsltComputingGlobalVarMarker

Macro Definition Documentation

XSLT_TCTXT_VARIABLE

#define XSLT_TCTXT_VARIABLE

(

c

)

((xsltStackElemPtr) (c)->contextVariable)

Definition at line 27 of file variables.c.

XSLT_VAR_GLOBAL

#define XSLT_VAR_GLOBAL   (1<<0)

Definition at line 25 of file variables.c.

XSLT_VAR_IN_SELECT

#define XSLT_VAR_IN_SELECT   (1<<1)

Definition at line 26 of file variables.c.

Function Documentation

xsltAddStackElem()

static int xsltAddStackElem ( xsltTransformContextPtr  ctxt, xsltStackElemPtr  elem  )

static

xsltAddStackElem: @ctxt: xn XSLT transformation context @elem: a stack element

Push an element (or list) onto the stack. In case of a list, each member will be pushed into a seperate slot; i.e. there's always 1 stack entry for 1 stack element.

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

Definition at line 731 of file variables.c.

{
    if ((ctxt == NULL) || (elem == NULL))
    return(-1);
 
    do {
    if (ctxt->varsMax == 0) {
        ctxt->varsMax = 10;
        ctxt->varsTab =
        (xsltStackElemPtr *) xmlMalloc(ctxt->varsMax *
        sizeof(ctxt->varsTab[0]));
        if (ctxt->varsTab == NULL) {
        xmlGenericError(xmlGenericErrorContext, "malloc failed !\n");
        return (-1);
        }
    }
    if (ctxt->varsNr >= ctxt->varsMax) {
        ctxt->varsMax *= 2;
        ctxt->varsTab =
        (xsltStackElemPtr *) xmlRealloc(ctxt->varsTab,
        ctxt->varsMax *
        sizeof(ctxt->varsTab[0]));
        if (ctxt->varsTab == NULL) {
        xmlGenericError(xmlGenericErrorContext, "realloc failed !\n");
        return (-1);
        }
    }
    ctxt->varsTab[ctxt->varsNr++] = elem;
    ctxt->vars = elem;
 
    elem = elem->next;
    } while (elem != NULL);
 
    return(0);
}

Referenced by xsltAddStackElemList(), and xsltRegisterVariable().

xsltAddStackElemList()

int 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 777 of file variables.c.

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

xsltBuildVariable()

static xsltStackElemPtr xsltBuildVariable ( xsltTransformContextPtr  ctxt, xsltStylePreCompPtr  castedComp, xmlNodePtr  tree  )

static

xsltBuildVariable: @ctxt: the XSLT transformation context @comp: the precompiled form @tree: the tree if select is NULL

Computes a new variable value.

Returns the xsltStackElemPtr or NULL in case of error

Definition at line 1766 of file variables.c.

{
#ifdef XSLT_REFACTORED
    xsltStyleBasicItemVariablePtr comp =
    (xsltStyleBasicItemVariablePtr) castedComp;
#else
    xsltStylePreCompPtr comp = castedComp;
#endif
    xsltStackElemPtr elem;
 
#ifdef WITH_XSLT_DEBUG_VARIABLE
    XSLT_TRACE(ctxt,XSLT_TRACE_VARIABLES,xsltGenericDebug(xsltGenericDebugContext,
             "Building variable %s", comp->name));
    if (comp->select != NULL)
    XSLT_TRACE(ctxt,XSLT_TRACE_VARIABLES,xsltGenericDebug(xsltGenericDebugContext,
             " select %s", comp->select));
    XSLT_TRACE(ctxt,XSLT_TRACE_VARIABLES,xsltGenericDebug(xsltGenericDebugContext, "\n"));
#endif
 
    elem = xsltNewStackElem(ctxt);
    if (elem == NULL)
    return(NULL);
    elem->comp = (xsltStylePreCompPtr) comp;
    elem->name = comp->name;
    elem->select = comp->select;
    elem->nameURI = comp->ns;
    elem->tree = tree;
    elem->value = xsltEvalVariable(ctxt, elem,
    (xsltStylePreCompPtr) comp);
    elem->computed = 1;
    return(elem);
}

Referenced by xsltParseStylesheetCallerParam(), and xsltRegisterVariable().

xsltCheckStackElem()

static int xsltCheckStackElem ( xsltTransformContextPtr  ctxt, const xmlChar *  name, const xmlChar *  nameURI  )

static

Definition at line 696 of file variables.c.

                                       {
    xsltStackElemPtr cur;
 
    if ((ctxt == NULL) || (name == NULL))
    return(-1);
 
    cur = xsltStackLookup(ctxt, name, nameURI);
    if (cur == NULL)
        return(0);
    if (cur->comp != NULL) {
        if (cur->comp->type == XSLT_FUNC_WITHPARAM)
        return(3);
    else if (cur->comp->type == XSLT_FUNC_PARAM)
        return(2);
    }
 
    return(1);
}

Referenced by xsltRegisterVariable().

xsltCopyStackElem()

static xsltStackElemPtr xsltCopyStackElem ( xsltStackElemPtr  elem )

static

xsltCopyStackElem: @elem: an XSLT stack element

Makes a copy of the stack element

Returns the copy of NULL

Definition at line 516 of file variables.c.

                                         {
    xsltStackElemPtr cur;
 
    cur = (xsltStackElemPtr) xmlMalloc(sizeof(xsltStackElem));
    if (cur == NULL) {
    xsltTransformError(NULL, NULL, NULL,
        "xsltCopyStackElem : malloc failed\n");
    return(NULL);
    }
    memset(cur, 0, sizeof(xsltStackElem));
    cur->context = elem->context;
    cur->name = elem->name;
    cur->nameURI = elem->nameURI;
    cur->select = elem->select;
    cur->tree = elem->tree;
    cur->comp = elem->comp;
    return(cur);
}

Referenced by xsltEvalGlobalVariables().

xsltCreateRVT()

xmlDocPtr xsltCreateRVT

(

xsltTransformContextPtr

ctxt

)

xsltCreateRVT: @ctxt: an XSLT transformation context

Creates a Result Value Tree (the XSLT 1.0 term for this is "Result Tree Fragment")

Returns the result value tree or NULL in case of API or internal errors.

Definition at line 44 of file variables.c.

{
    xmlDocPtr container;
 
    /*
    * Question: Why is this function public?
    * Answer: It is called by the EXSLT module.
    */
    if (ctxt == NULL)
    return(NULL);
 
    /*
    * Reuse a RTF from the cache if available.
    */
    if (ctxt->cache->RVT) {
    container = ctxt->cache->RVT;
    ctxt->cache->RVT = (xmlDocPtr) container->next;
    /* clear the internal pointers */
    container->next = NULL;
    container->prev = NULL;
    if (ctxt->cache->nbRVT > 0)
        ctxt->cache->nbRVT--;
#ifdef XSLT_DEBUG_PROFILE_CACHE
    ctxt->cache->dbgReusedRVTs++;
#endif
    return(container);
    }
 
    container = xmlNewDoc(NULL);
    if (container == NULL)
    return(NULL);
    container->dict = ctxt->dict;
    xmlDictReference(container->dict);
    XSLT_MARK_RES_TREE_FRAG(container);
    container->doc = container;
    container->parent = NULL;
    return(container);
}

Referenced by xsltEvalGlobalVariable(), and xsltEvalVariable().

xsltEvalGlobalVariable()

static xmlXPathObjectPtr xsltEvalGlobalVariable ( xsltStackElemPtr  elem, xsltTransformContextPtr  ctxt  )

static

xsltEvalGlobalVariable: @elem: the variable or parameter @ctxt: the XSLT transformation context

Evaluates a the value of a global xsl:variable or xsl:param declaration.

Returns the XPath Object value or NULL in case of error

Definition at line 1032 of file variables.c.

{
    xmlXPathObjectPtr result = NULL;
    xmlNodePtr oldInst;
    const xmlChar* oldVarName;
 
#ifdef XSLT_REFACTORED
    xsltStyleBasicItemVariablePtr comp;
#else
    xsltStylePreCompPtr comp;
#endif
 
    if ((ctxt == NULL) || (elem == NULL))
    return(NULL);
    if (elem->computed)
    return(elem->value);
 
 
#ifdef WITH_XSLT_DEBUG_VARIABLE
    XSLT_TRACE(ctxt,XSLT_TRACE_VARIABLES,xsltGenericDebug(xsltGenericDebugContext,
    "Evaluating global variable %s\n", elem->name));
#endif
 
#ifdef WITH_DEBUGGER
    if ((ctxt->debugStatus != XSLT_DEBUG_NONE) &&
        elem->comp && elem->comp->inst)
        xslHandleDebugger(elem->comp->inst, NULL, NULL, ctxt);
#endif
 
    oldInst = ctxt->inst;
#ifdef XSLT_REFACTORED
    comp = (xsltStyleBasicItemVariablePtr) elem->comp;
#else
    comp = elem->comp;
#endif
    oldVarName = elem->name;
    elem->name = xsltComputingGlobalVarMarker;
    /*
    * OPTIMIZE TODO: We should consider instantiating global vars/params
    *  on-demand. The vars/params don't need to be evaluated if never
    *  called; and in the case of global params, if values for such params
    *  are provided by the user.
    */
    if (elem->select != NULL) {
    xmlXPathCompExprPtr xpExpr = NULL;
    xmlDocPtr oldXPDoc;
    xmlNodePtr oldXPContextNode;
    int oldXPProximityPosition, oldXPContextSize, oldXPNsNr;
    xmlNsPtr *oldXPNamespaces;
    xmlXPathContextPtr xpctxt = ctxt->xpathCtxt;
 
    if ((comp != NULL) && (comp->comp != NULL)) {
        xpExpr = comp->comp;
    } else {
        xpExpr = xmlXPathCtxtCompile(ctxt->xpathCtxt, elem->select);
    }
    if (xpExpr == NULL)
        goto error;
 
 
    if (comp != NULL)
        ctxt->inst = comp->inst;
    else
        ctxt->inst = NULL;
    /*
    * SPEC XSLT 1.0:
    * "At top-level, the expression or template specifying the
    *  variable value is evaluated with the same context as that used
    *  to process the root node of the source document: the current
    *  node is the root node of the source document and the current
    *  node list is a list containing just the root node of the source
    *  document."
    */
    /*
    * Save context states.
    */
    oldXPDoc = xpctxt->doc;
    oldXPContextNode = xpctxt->node;
    oldXPProximityPosition = xpctxt->proximityPosition;
    oldXPContextSize = xpctxt->contextSize;
    oldXPNamespaces = xpctxt->namespaces;
    oldXPNsNr = xpctxt->nsNr;
 
    xpctxt->node = ctxt->initialContextNode;
    xpctxt->doc = ctxt->initialContextDoc;
    xpctxt->contextSize = 1;
    xpctxt->proximityPosition = 1;
 
    if (comp != NULL) {
 
#ifdef XSLT_REFACTORED
        if (comp->inScopeNs != NULL) {
        xpctxt->namespaces = comp->inScopeNs->list;
        xpctxt->nsNr = comp->inScopeNs->xpathNumber;
        } else {
        xpctxt->namespaces = NULL;
        xpctxt->nsNr = 0;
        }
#else
        xpctxt->namespaces = comp->nsList;
        xpctxt->nsNr = comp->nsNr;
#endif
    } else {
        xpctxt->namespaces = NULL;
        xpctxt->nsNr = 0;
    }
 
    result = xmlXPathCompiledEval(xpExpr, xpctxt);
 
    /*
    * Restore Context states.
    */
    xpctxt->doc = oldXPDoc;
    xpctxt->node = oldXPContextNode;
    xpctxt->contextSize = oldXPContextSize;
    xpctxt->proximityPosition = oldXPProximityPosition;
    xpctxt->namespaces = oldXPNamespaces;
    xpctxt->nsNr = oldXPNsNr;
 
    if ((comp == NULL) || (comp->comp == NULL))
        xmlXPathFreeCompExpr(xpExpr);
    if (result == NULL) {
        if (comp == NULL)
        xsltTransformError(ctxt, NULL, NULL,
            "Evaluating global variable %s failed\n", elem->name);
        else
        xsltTransformError(ctxt, NULL, comp->inst,
            "Evaluating global variable %s failed\n", elem->name);
        ctxt->state = XSLT_STATE_STOPPED;
            goto error;
        }
 
        /*
         * Mark all RVTs that are referenced from result as part
         * of this variable so they won't be freed too early.
         */
        xsltFlagRVTs(ctxt, result, XSLT_RVT_GLOBAL);
 
#ifdef WITH_XSLT_DEBUG_VARIABLE
#ifdef LIBXML_DEBUG_ENABLED
    if ((xsltGenericDebugContext == stdout) ||
        (xsltGenericDebugContext == stderr))
        xmlXPathDebugDumpObject((FILE *)xsltGenericDebugContext,
                    result, 0);
#endif
#endif
    } else {
    if (elem->tree == NULL) {
        result = xmlXPathNewCString("");
    } else {
        xmlDocPtr container;
        xmlNodePtr oldInsert;
        xmlDocPtr  oldOutput, oldXPDoc;
        /*
        * Generate a result tree fragment.
        */
        container = xsltCreateRVT(ctxt);
        if (container == NULL)
        goto error;
        /*
        * Let the lifetime of the tree fragment be handled by
        * the Libxslt's garbage collector.
        */
        xsltRegisterPersistRVT(ctxt, container);
 
        oldOutput = ctxt->output;
        oldInsert = ctxt->insert;
 
        oldXPDoc = ctxt->xpathCtxt->doc;
 
        ctxt->output = container;
        ctxt->insert = (xmlNodePtr) container;
 
        ctxt->xpathCtxt->doc = ctxt->initialContextDoc;
        /*
        * Process the sequence constructor.
        */
        xsltApplyOneTemplate(ctxt, ctxt->node, elem->tree, NULL, NULL);
 
        ctxt->xpathCtxt->doc = oldXPDoc;
 
        ctxt->insert = oldInsert;
        ctxt->output = oldOutput;
 
        result = xmlXPathNewValueTree((xmlNodePtr) container);
        if (result == NULL) {
        result = xmlXPathNewCString("");
        } else {
            result->boolval = 0; /* Freeing is not handled there anymore */
        }
#ifdef WITH_XSLT_DEBUG_VARIABLE
#ifdef LIBXML_DEBUG_ENABLED
        if ((xsltGenericDebugContext == stdout) ||
        (xsltGenericDebugContext == stderr))
        xmlXPathDebugDumpObject((FILE *)xsltGenericDebugContext,
                    result, 0);
#endif
#endif
    }
    }
 
error:
    elem->name = oldVarName;
    ctxt->inst = oldInst;
    if (result != NULL) {
    elem->value = result;
    elem->computed = 1;
    }
    return(result);
}

Referenced by xsltEvalGlobalVariableWrapper(), and xsltGlobalVariableLookup().

xsltEvalGlobalVariables()

int 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 1260 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);
        xmlHashAddEntry2(ctxt->globalVars,
                 elem->name, elem->nameURI, def);
        } 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().

xsltEvalGlobalVariableWrapper()

static void xsltEvalGlobalVariableWrapper ( void *  payload, void *  data, const xmlChar *name  ATTRIBUTE_UNUSED  )

static

Definition at line 1244 of file variables.c.

                                                                    {
    xsltEvalGlobalVariable((xsltStackElemPtr) payload,
                           (xsltTransformContextPtr) data);
}

Referenced by xsltEvalGlobalVariables().

xsltEvalOneUserParam()

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

Definition at line 1727 of file variables.c.

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

Referenced by xsltEvalUserParams().

xsltEvalUserParams()

int 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 1662 of file variables.c.

                                                                      {
    int 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().

xsltEvalVariable()

static xmlXPathObjectPtr xsltEvalVariable ( xsltTransformContextPtr  ctxt, xsltStackElemPtr  variable, xsltStylePreCompPtr  castedComp  )

static

xsltEvalVariable: @ctxt: the XSLT transformation context @variable: the variable or parameter item @comp: the compiled XSLT instruction

Evaluate a variable value.

Returns the XPath Object value or NULL in case of error

Definition at line 799 of file variables.c.

{
#ifdef XSLT_REFACTORED
    xsltStyleItemVariablePtr comp =
    (xsltStyleItemVariablePtr) castedComp;
#else
    xsltStylePreCompPtr comp = castedComp;
#endif
    xmlXPathObjectPtr result = NULL;
    xmlNodePtr oldInst;
 
    if ((ctxt == NULL) || (variable == NULL))
    return(NULL);
 
    /*
    * A variable or parameter are evaluated on demand; thus the
    * context (of XSLT and XPath) need to be temporarily adjusted and
    * restored on exit.
    */
    oldInst = ctxt->inst;
 
#ifdef WITH_XSLT_DEBUG_VARIABLE
    XSLT_TRACE(ctxt,XSLT_TRACE_VARIABLES,xsltGenericDebug(xsltGenericDebugContext,
    "Evaluating variable '%s'\n", variable->name));
#endif
    if (variable->select != NULL) {
    xmlXPathCompExprPtr xpExpr = NULL;
    xmlDocPtr oldXPDoc;
    xmlNodePtr oldXPContextNode;
    int oldXPProximityPosition, oldXPContextSize, oldXPNsNr;
    xmlNsPtr *oldXPNamespaces;
    xmlXPathContextPtr xpctxt = ctxt->xpathCtxt;
    xsltStackElemPtr oldVar = ctxt->contextVariable;
 
    if ((comp != NULL) && (comp->comp != NULL)) {
        xpExpr = comp->comp;
    } else {
        xpExpr = xmlXPathCtxtCompile(ctxt->xpathCtxt, variable->select);
    }
    if (xpExpr == NULL)
        return(NULL);
    /*
    * Save context states.
    */
    oldXPDoc = xpctxt->doc;
    oldXPContextNode = xpctxt->node;
    oldXPProximityPosition = xpctxt->proximityPosition;
    oldXPContextSize = xpctxt->contextSize;
    oldXPNamespaces = xpctxt->namespaces;
    oldXPNsNr = xpctxt->nsNr;
 
    xpctxt->node = ctxt->node;
    /*
    * OPTIMIZE TODO: Lame try to set the context doc.
    *   Get rid of this somehow in xpath.c.
    */
    if ((ctxt->node->type != XML_NAMESPACE_DECL) &&
        ctxt->node->doc)
        xpctxt->doc = ctxt->node->doc;
    /*
    * BUG TODO: The proximity position and the context size will
    *  potentially be wrong.
    *  Example:
    *  <xsl:template select="foo">
    *    <xsl:variable name="pos" select="position()"/>
    *    <xsl:for-each select="bar">
    *      <xsl:value-of select="$pos"/>
    *    </xsl:for-each>
    *  </xsl:template>
    *  Here the proximity position and context size are changed
    *  to the context of <xsl:for-each select="bar">, but
    *  the variable needs to be evaluated in the context of
    *  <xsl:template select="foo">.
    */
    if (comp != NULL) {
 
#ifdef XSLT_REFACTORED
        if (comp->inScopeNs != NULL) {
        xpctxt->namespaces = comp->inScopeNs->list;
        xpctxt->nsNr = comp->inScopeNs->xpathNumber;
        } else {
        xpctxt->namespaces = NULL;
        xpctxt->nsNr = 0;
        }
#else
        xpctxt->namespaces = comp->nsList;
        xpctxt->nsNr = comp->nsNr;
#endif
    } else {
        xpctxt->namespaces = NULL;
        xpctxt->nsNr = 0;
    }
 
    /*
    * We need to mark that we are "selecting" a var's value;
    * if any tree fragments are created inside the expression,
    * then those need to be stored inside the variable; otherwise
    * we'll eventually free still referenced fragments, before
    * we leave the scope of the variable.
    */
    ctxt->contextVariable = variable;
    variable->flags |= XSLT_VAR_IN_SELECT;
 
    result = xmlXPathCompiledEval(xpExpr, xpctxt);
 
    variable->flags ^= XSLT_VAR_IN_SELECT;
    /*
    * Restore Context states.
    */
    ctxt->contextVariable = oldVar;
 
    xpctxt->doc = oldXPDoc;
    xpctxt->node = oldXPContextNode;
    xpctxt->contextSize = oldXPContextSize;
    xpctxt->proximityPosition = oldXPProximityPosition;
    xpctxt->namespaces = oldXPNamespaces;
    xpctxt->nsNr = oldXPNsNr;
 
    if ((comp == NULL) || (comp->comp == NULL))
        xmlXPathFreeCompExpr(xpExpr);
    if (result == NULL) {
        xsltTransformError(ctxt, NULL,
        (comp != NULL) ? comp->inst : NULL,
        "Failed to evaluate the expression of variable '%s'.\n",
        variable->name);
        ctxt->state = XSLT_STATE_STOPPED;
 
#ifdef WITH_XSLT_DEBUG_VARIABLE
#ifdef LIBXML_DEBUG_ENABLED
    } else {
        if ((xsltGenericDebugContext == stdout) ||
        (xsltGenericDebugContext == stderr))
        xmlXPathDebugDumpObject((FILE *)xsltGenericDebugContext,
                    result, 0);
#endif
#endif
    }
    } else {
    if (variable->tree == NULL) {
        result = xmlXPathNewCString("");
    } else {
        if (variable->tree) {
        xmlDocPtr container;
        xmlNodePtr oldInsert;
        xmlDocPtr  oldOutput;
                const xmlChar *oldLastText;
                int oldLastTextSize, oldLastTextUse;
        xsltStackElemPtr oldVar = ctxt->contextVariable;
 
        /*
        * Generate a result tree fragment.
        */
        container = xsltCreateRVT(ctxt);
        if (container == NULL)
            goto error;
        /*
        * NOTE: Local Result Tree Fragments of params/variables
        * are not registered globally anymore; the life-time
        * is not directly dependant of the param/variable itself.
        *
        * OLD: xsltRegisterTmpRVT(ctxt, container);
        */
        /*
        * Attach the Result Tree Fragment to the variable;
        * when the variable is freed, it will also free
        * the Result Tree Fragment.
        */
        variable->fragment = container;
                container->psvi = XSLT_RVT_LOCAL;
 
        oldOutput = ctxt->output;
        oldInsert = ctxt->insert;
                oldLastText = ctxt->lasttext;
                oldLastTextSize = ctxt->lasttsize;
                oldLastTextUse = ctxt->lasttuse;
 
        ctxt->output = container;
        ctxt->insert = (xmlNodePtr) container;
        ctxt->contextVariable = variable;
        /*
        * Process the sequence constructor (variable->tree).
        * The resulting tree will be held by @container.
        */
        xsltApplyOneTemplate(ctxt, ctxt->node, variable->tree,
            NULL, NULL);
 
        ctxt->contextVariable = oldVar;
        ctxt->insert = oldInsert;
        ctxt->output = oldOutput;
                ctxt->lasttext = oldLastText;
                ctxt->lasttsize = oldLastTextSize;
                ctxt->lasttuse = oldLastTextUse;
 
        result = xmlXPathNewValueTree((xmlNodePtr) container);
        }
        if (result == NULL) {
        result = xmlXPathNewCString("");
        } else {
        /*
        * Freeing is not handled there anymore.
        * QUESTION TODO: What does the above comment mean?
        */
            result->boolval = 0;
        }
#ifdef WITH_XSLT_DEBUG_VARIABLE
#ifdef LIBXML_DEBUG_ENABLED
 
        if ((xsltGenericDebugContext == stdout) ||
        (xsltGenericDebugContext == stderr))
        xmlXPathDebugDumpObject((FILE *)xsltGenericDebugContext,
                    result, 0);
#endif
#endif
    }
    }
 
error:
    ctxt->inst = oldInst;
    return(result);
}

Referenced by xsltBuildVariable(), xsltVariableLookup(), and xsltXPathVariableLookup().

xsltExtensionInstructionResultFinalize()

int xsltExtensionInstructionResultFinalize

(

xsltTransformContextPtr ctxt

ATTRIBUTE_UNUSED

)

xsltExtensionInstructionResultFinalize: @ctxt: an XSLT transformation context

Finalizes the data (e.g. result tree fragments) created within a value-returning process (e.g. EXSLT's function). Tree fragments marked as being returned by a function are set to normal state, which means that the fragment garbage collector will free them after the function-calling process exits.

Returns 0 in case of success and -1 in case of API or internal errors.

This function is unsupported in newer releases of libxslt.

Definition at line 187 of file variables.c.

{
    xmlGenericError(xmlGenericErrorContext,
            "xsltExtensionInstructionResultFinalize is unsupported "
            "in this release of libxslt.\n");
    return(-1);
}

xsltExtensionInstructionResultRegister()

int xsltExtensionInstructionResultRegister	(	xsltTransformContextPtr ctxt	ATTRIBUTE_UNUSED,
		xmlXPathObjectPtr obj	ATTRIBUTE_UNUSED
	)

xsltExtensionInstructionResultRegister: @ctxt: an XSLT transformation context @obj: an XPath object to be inspected for result tree fragments

Marks the result of a value-returning extension instruction in order to avoid it being garbage collected before the extension instruction exits. Note that one still has to additionally register any newly created tree fragments (via xsltCreateRVT()) with xsltRegisterLocalRVT().

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

It isn't necessary to call this function in newer releases of libxslt.

Definition at line 213 of file variables.c.

{
    return(0);
}

xsltFlagRVTs()

int xsltFlagRVTs	(	xsltTransformContextPtr	ctxt,
		xmlXPathObjectPtr	obj,
		void *	val
	)

xsltFlagRVTs: @ctxt: an XSLT transformation context @obj: an XPath object to be inspected for result tree fragments @val: the flag value

Updates ownership information of RVTs in @obj according to @val.

@val = XSLT_RVT_FUNC_RESULT for the result of an extension function, so its RVTs won't be destroyed after leaving the returning scope. @val = XSLT_RVT_LOCAL for the result of an extension function to reset the state of its RVTs after it was returned to a new scope. @val = XSLT_RVT_GLOBAL for parts of global variables.

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

Definition at line 237 of file variables.c.

                                                                             {
    int i;
    xmlNodePtr cur;
    xmlDocPtr doc;
 
    if ((ctxt == NULL) || (obj == NULL))
    return(-1);
 
    /*
    * OPTIMIZE TODO: If no local variables/params and no local tree
    * fragments were created, then we don't need to analyse the XPath
    * objects for tree fragments.
    */
 
    if ((obj->type != XPATH_NODESET) && (obj->type != XPATH_XSLT_TREE))
    return(0);
    if ((obj->nodesetval == NULL) || (obj->nodesetval->nodeNr == 0))
    return(0);
 
    for (i = 0; i < obj->nodesetval->nodeNr; i++) {
    cur = obj->nodesetval->nodeTab[i];
    if (cur->type == XML_NAMESPACE_DECL) {
        /*
        * The XPath module sets the owner element of a ns-node on
        * the ns->next field.
        */
        if ((((xmlNsPtr) cur)->next != NULL) &&
        (((xmlNsPtr) cur)->next->type == XML_ELEMENT_NODE))
        {
        cur = (xmlNodePtr) ((xmlNsPtr) cur)->next;
        doc = cur->doc;
        } else {
        xsltTransformError(ctxt, NULL, ctxt->inst,
            "Internal error in xsltFlagRVTs(): "
            "Cannot retrieve the doc of a namespace node.\n");
        return(-1);
        }
    } else {
        doc = cur->doc;
    }
    if (doc == NULL) {
        xsltTransformError(ctxt, NULL, ctxt->inst,
        "Internal error in xsltFlagRVTs(): "
        "Cannot retrieve the doc of a node.\n");
        return(-1);
    }
    if (doc->name && (doc->name[0] == ' ') &&
            doc->psvi != XSLT_RVT_GLOBAL) {
        /*
        * This is a result tree fragment.
        * We store ownership information in the @psvi field.
        * TODO: How do we know if this is a doc acquired via the
        *  document() function?
        */
#ifdef WITH_XSLT_DEBUG_VARIABLE
            XSLT_TRACE(ctxt,XSLT_TRACE_VARIABLES,xsltGenericDebug(xsltGenericDebugContext,
                "Flagging RVT %p: %p -> %p\n", doc, doc->psvi, val));
#endif
 
            if (val == XSLT_RVT_LOCAL) {
                if (doc->psvi == XSLT_RVT_FUNC_RESULT)
                    doc->psvi = XSLT_RVT_LOCAL;
            } else if (val == XSLT_RVT_GLOBAL) {
                if (doc->psvi != XSLT_RVT_LOCAL) {
            xmlGenericError(xmlGenericErrorContext,
                            "xsltFlagRVTs: Invalid transition %p => GLOBAL\n",
                            doc->psvi);
                    doc->psvi = XSLT_RVT_GLOBAL;
                    return(-1);
                }
 
                /* Will be registered as persistant in xsltReleaseLocalRVTs. */
                doc->psvi = XSLT_RVT_GLOBAL;
            } else if (val == XSLT_RVT_FUNC_RESULT) {
            doc->psvi = val;
            }
    }
    }
 
    return(0);
}

Referenced by xsltEvalGlobalVariable().

xsltFreeGlobalVariables()

void xsltFreeGlobalVariables

(

xsltTransformContextPtr

ctxt

)

xsltFreeGlobalVariables: @ctxt: the XSLT transformation context

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

Definition at line 2227 of file variables.c.

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

Referenced by xsltFreeTransformContext().

xsltFreeRVTs()

void xsltFreeRVTs

(

xsltTransformContextPtr

ctxt

)

xsltFreeRVTs: @ctxt: an XSLT transformation context

Frees all registered result value trees (Result Tree Fragments) of the transformation. Internal function; should not be called by user-code.

Definition at line 416 of file variables.c.

{
    xmlDocPtr cur, next;
 
    if (ctxt == NULL)
    return;
    /*
    * Local fragments.
    */
    cur = ctxt->localRVT;
    while (cur != NULL) {
        next = (xmlDocPtr) cur->next;
    if (cur->_private != NULL) {
        xsltFreeDocumentKeys(cur->_private);
        xmlFree(cur->_private);
    }
    xmlFreeDoc(cur);
    cur = next;
    }
    ctxt->localRVT = NULL;
    /*
    * User-created per-template fragments.
    */
    cur = ctxt->tmpRVT;
    while (cur != NULL) {
        next = (xmlDocPtr) cur->next;
    if (cur->_private != NULL) {
        xsltFreeDocumentKeys(cur->_private);
        xmlFree(cur->_private);
    }
    xmlFreeDoc(cur);
    cur = next;
    }
    ctxt->tmpRVT = NULL;
    /*
    * Global fragments.
    */
    cur = ctxt->persistRVT;
    while (cur != NULL) {
        next = (xmlDocPtr) cur->next;
    if (cur->_private != NULL) {
        xsltFreeDocumentKeys(cur->_private);
        xmlFree(cur->_private);
    }
    xmlFreeDoc(cur);
    cur = next;
    }
    ctxt->persistRVT = NULL;
}

Referenced by xsltApplyStylesheetInternal(), and xsltFreeTransformContext().

xsltFreeStackElem()

static void xsltFreeStackElem ( xsltStackElemPtr  elem )

static

xsltFreeStackElem: @elem: an XSLT stack element

Free up the memory allocated by @elem

Definition at line 542 of file variables.c.

                                         {
    if (elem == NULL)
    return;
    if (elem->value != NULL)
    xmlXPathFreeObject(elem->value);
    /*
    * Release the list of temporary Result Tree Fragments.
    */
    if (elem->context) {
    xmlDocPtr cur;
 
    while (elem->fragment != NULL) {
        cur = elem->fragment;
        elem->fragment = (xmlDocPtr) cur->next;
 
            if (cur->psvi == XSLT_RVT_LOCAL) {
        xsltReleaseRVT(elem->context, cur);
            } else if (cur->psvi == XSLT_RVT_FUNC_RESULT) {
                xsltRegisterLocalRVT(elem->context, cur);
                cur->psvi = XSLT_RVT_FUNC_RESULT;
            } else {
                xmlGenericError(xmlGenericErrorContext,
                        "xsltFreeStackElem: Unexpected RVT flag %p\n",
                        cur->psvi);
            }
    }
    }
    /*
    * Cache or free the variable structure.
    */
    if (elem->context && (elem->context->cache->nbStackItems < 50)) {
    /*
    * Store the item in the cache.
    */
    xsltTransformContextPtr ctxt = elem->context;
    memset(elem, 0, sizeof(xsltStackElem));
    elem->context = ctxt;
    elem->next = ctxt->cache->stackItems;
    ctxt->cache->stackItems = elem;
    ctxt->cache->nbStackItems++;
#ifdef XSLT_DEBUG_PROFILE_CACHE
    ctxt->cache->dbgCachedVars++;
#endif
    return;
    }
    xmlFree(elem);
}

Referenced by xsltFreeStackElemEntry(), xsltFreeStackElemList(), and xsltProcessUserParamInternal().

xsltFreeStackElemEntry()

static void xsltFreeStackElemEntry ( void *  payload, const xmlChar *name  ATTRIBUTE_UNUSED  )

static

Definition at line 591 of file variables.c.

                                                                            {
    xsltFreeStackElem((xsltStackElemPtr) payload);
}

Referenced by xsltFreeGlobalVariables().

xsltFreeStackElemList()

void xsltFreeStackElemList

(

xsltStackElemPtr

elem

)

xsltFreeStackElemList: @elem: an XSLT stack element

Free up the memory allocated by @elem

Definition at line 603 of file variables.c.

                                             {
    xsltStackElemPtr next;
 
    while (elem != NULL) {
    next = elem->next;
    xsltFreeStackElem(elem);
    elem = next;
    }
}

Referenced by xsltApplyStylesheetInternal(), xsltApplyTemplates(), xsltCallTemplate(), xsltFreeStylesheet(), xsltLocalVariablePop(), and xsltTemplateParamsCleanup().

xsltGlobalVariableLookup()

static xmlXPathObjectPtr xsltGlobalVariableLookup ( xsltTransformContextPtr  ctxt, const xmlChar *  name, const xmlChar *  ns_uri  )

static

Definition at line 1873 of file variables.c.

                                        {
    xsltStackElemPtr elem;
    xmlXPathObjectPtr ret = NULL;
 
    /*
     * Lookup the global variables in XPath global variable hash table
     */
    if ((ctxt->xpathCtxt == NULL) || (ctxt->globalVars == NULL))
    return(NULL);
    elem = (xsltStackElemPtr)
        xmlHashLookup2(ctxt->globalVars, name, ns_uri);
    if (elem == NULL) {
#ifdef WITH_XSLT_DEBUG_VARIABLE
    XSLT_TRACE(ctxt,XSLT_TRACE_VARIABLES,xsltGenericDebug(xsltGenericDebugContext,
             "global variable not found %s\n", name));
#endif
    return(NULL);
    }
    /*
    * URGENT TODO: Move the detection of recursive definitions
    * to compile-time.
    */
    if (elem->computed == 0) {
    if (elem->name == xsltComputingGlobalVarMarker) {
        xsltTransformError(ctxt, NULL, elem->comp->inst,
        "Recursive definition of %s\n", name);
        return(NULL);
    }
    ret = xsltEvalGlobalVariable(elem, ctxt);
    } else
    ret = elem->value;
    return(xmlXPathObjectCopy(ret));
}

Referenced by xsltVariableLookup(), and xsltXPathVariableLookup().

xsltNewStackElem()

static xsltStackElemPtr xsltNewStackElem ( xsltTransformContextPtr  ctxt )

static

xsltNewStackElem:

Create a new XSLT ParserContext

Returns the newly allocated xsltParserStackElem or NULL in case of error

Definition at line 480 of file variables.c.

{
    xsltStackElemPtr ret;
    /*
    * Reuse a stack item from the cache if available.
    */
    if (ctxt && ctxt->cache->stackItems) {
    ret = ctxt->cache->stackItems;
    ctxt->cache->stackItems = ret->next;
    ret->next = NULL;
    ctxt->cache->nbStackItems--;
#ifdef XSLT_DEBUG_PROFILE_CACHE
    ctxt->cache->dbgReusedVars++;
#endif
    return(ret);
    }
    ret = (xsltStackElemPtr) xmlMalloc(sizeof(xsltStackElem));
    if (ret == NULL) {
    xsltTransformError(NULL, NULL, NULL,
        "xsltNewStackElem : malloc failed\n");
    return(NULL);
    }
    memset(ret, 0, sizeof(xsltStackElem));
    ret->context = ctxt;
    return(ret);
}

Referenced by xsltBuildVariable(), xsltProcessUserParamInternal(), and xsltRegisterGlobalVariable().

xsltParseGlobalParam()

void 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 2087 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()

void 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 2024 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()

xsltStackElemPtr 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 1962 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()

void 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 2191 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()

void 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 2149 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().

xsltProcessUserParamInternal()

static int xsltProcessUserParamInternal ( xsltTransformContextPtr  ctxt, const xmlChar *  name, const xmlChar *  value, int  eval  )

static

Definition at line 1438 of file variables.c.

                           {
 
    xsltStylesheetPtr style;
    const xmlChar *prefix;
    const xmlChar *href;
    xmlXPathCompExprPtr xpExpr;
    xmlXPathObjectPtr result;
 
    xsltStackElemPtr elem;
    int res;
    void *res_ptr;
 
    if (ctxt == NULL)
    return(-1);
    if (name == NULL)
    return(0);
    if (value == NULL)
    return(0);
 
    style = ctxt->style;
 
#ifdef WITH_XSLT_DEBUG_VARIABLE
    XSLT_TRACE(ctxt,XSLT_TRACE_VARIABLES,xsltGenericDebug(xsltGenericDebugContext,
        "Evaluating user parameter %s=%s\n", name, value));
#endif
 
    /*
     * Name lookup
     */
    href = NULL;
 
    if (name[0] == '{') {
        int len = 0;
 
        while ((name[len] != 0) && (name[len] != '}')) len++;
        if (name[len] == 0) {
           xsltTransformError(ctxt, style, NULL,
           "user param : malformed parameter name : %s\n", name);
        } else {
           href = xmlDictLookup(ctxt->dict, &name[1], len-1);
           name = xmlDictLookup(ctxt->dict, &name[len + 1], -1);
       }
    }
    else {
        name = xsltSplitQName(ctxt->dict, name, &prefix);
        if (prefix != NULL) {
            xmlNsPtr ns;
 
            ns = xmlSearchNs(style->doc, xmlDocGetRootElement(style->doc),
                             prefix);
            if (ns == NULL) {
                xsltTransformError(ctxt, style, NULL,
                "user param : no namespace bound to prefix %s\n", prefix);
                href = NULL;
            } else {
                href = ns->href;
            }
        }
    }
 
    if (name == NULL)
    return (-1);
 
    res_ptr = xmlHashLookup2(ctxt->globalVars, name, href);
    if (res_ptr != 0) {
    xsltTransformError(ctxt, style, NULL,
        "Global parameter %s already defined\n", name);
    }
    if (ctxt->globalVars == NULL)
    ctxt->globalVars = xmlHashCreate(20);
 
    /*
     * do not overwrite variables with parameters from the command line
     */
    while (style != NULL) {
        elem = ctxt->style->variables;
    while (elem != NULL) {
        if ((elem->comp != NULL) &&
            (elem->comp->type == XSLT_FUNC_VARIABLE) &&
        (xmlStrEqual(elem->name, name)) &&
        (xmlStrEqual(elem->nameURI, href))) {
        return(0);
        }
            elem = elem->next;
    }
        style = xsltNextImport(style);
    }
    style = ctxt->style;
    elem = NULL;
 
    /*
     * Do the evaluation if @eval is non-zero.
     */
 
    result = NULL;
    if (eval != 0) {
        xpExpr = xmlXPathCtxtCompile(ctxt->xpathCtxt, value);
    if (xpExpr != NULL) {
        xmlDocPtr oldXPDoc;
        xmlNodePtr oldXPContextNode;
        int oldXPProximityPosition, oldXPContextSize, oldXPNsNr;
        xmlNsPtr *oldXPNamespaces;
        xmlXPathContextPtr xpctxt = ctxt->xpathCtxt;
 
        /*
        * Save context states.
        */
        oldXPDoc = xpctxt->doc;
        oldXPContextNode = xpctxt->node;
        oldXPProximityPosition = xpctxt->proximityPosition;
        oldXPContextSize = xpctxt->contextSize;
        oldXPNamespaces = xpctxt->namespaces;
        oldXPNsNr = xpctxt->nsNr;
 
        /*
        * SPEC XSLT 1.0:
        * "At top-level, the expression or template specifying the
        *  variable value is evaluated with the same context as that used
        *  to process the root node of the source document: the current
        *  node is the root node of the source document and the current
        *  node list is a list containing just the root node of the source
        *  document."
        */
        xpctxt->doc = ctxt->initialContextDoc;
        xpctxt->node = ctxt->initialContextNode;
        xpctxt->contextSize = 1;
        xpctxt->proximityPosition = 1;
        /*
        * There is really no in scope namespace for parameters on the
        * command line.
        */
        xpctxt->namespaces = NULL;
        xpctxt->nsNr = 0;
 
        result = xmlXPathCompiledEval(xpExpr, xpctxt);
 
        /*
        * Restore Context states.
        */
        xpctxt->doc = oldXPDoc;
        xpctxt->node = oldXPContextNode;
        xpctxt->contextSize = oldXPContextSize;
        xpctxt->proximityPosition = oldXPProximityPosition;
        xpctxt->namespaces = oldXPNamespaces;
        xpctxt->nsNr = oldXPNsNr;
 
        xmlXPathFreeCompExpr(xpExpr);
    }
    if (result == NULL) {
        xsltTransformError(ctxt, style, NULL,
        "Evaluating user parameter %s failed\n", name);
        ctxt->state = XSLT_STATE_STOPPED;
        return(-1);
    }
    }
 
    /*
     * If @eval is 0 then @value is to be taken literally and result is NULL
     *
     * If @eval is not 0, then @value is an XPath expression and has been
     * successfully evaluated and result contains the resulting value and
     * is not NULL.
     *
     * Now create an xsltStackElemPtr for insertion into the context's
     * global variable/parameter hash table.
     */
 
#ifdef WITH_XSLT_DEBUG_VARIABLE
#ifdef LIBXML_DEBUG_ENABLED
    if ((xsltGenericDebugContext == stdout) ||
        (xsltGenericDebugContext == stderr))
        xmlXPathDebugDumpObject((FILE *)xsltGenericDebugContext,
                    result, 0);
#endif
#endif
 
    elem = xsltNewStackElem(NULL);
    if (elem != NULL) {
    elem->name = name;
    elem->select = xmlDictLookup(ctxt->dict, value, -1);
    if (href != NULL)
        elem->nameURI = xmlDictLookup(ctxt->dict, href, -1);
    elem->tree = NULL;
    elem->computed = 1;
    if (eval == 0) {
        elem->value = xmlXPathNewString(value);
    }
    else {
        elem->value = result;
    }
    }
 
    /*
     * Global parameters are stored in the XPath context variables pool.
     */
 
    res = xmlHashAddEntry2(ctxt->globalVars, name, href, elem);
    if (res != 0) {
    xsltFreeStackElem(elem);
    xsltTransformError(ctxt, style, NULL,
        "Global parameter %s already defined\n", name);
    }
    return(0);
}

Referenced by xsltEvalOneUserParam(), and xsltQuoteOneUserParam().

xsltQuoteOneUserParam()

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

Definition at line 1748 of file variables.c.

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

Referenced by xsltQuoteUserParams().

xsltQuoteUserParams()

int 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 1692 of file variables.c.

                                                                       {
    int 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;
}

xsltRegisterGlobalVariable()

static int xsltRegisterGlobalVariable ( xsltStylesheetPtr  style, const xmlChar *  name, const xmlChar *  ns_uri, const xmlChar *  sel, xmlNodePtr  tree, xsltStylePreCompPtr  comp, const xmlChar *  value  )

static

Definition at line 1345 of file variables.c.

                                   {
    xsltStackElemPtr elem, tmp;
    if (style == NULL)
    return(-1);
    if (name == NULL)
    return(-1);
    if (comp == NULL)
    return(-1);
 
#ifdef WITH_XSLT_DEBUG_VARIABLE
    if (comp->type == XSLT_FUNC_PARAM)
    xsltGenericDebug(xsltGenericDebugContext,
             "Defining global param %s\n", name);
    else
    xsltGenericDebug(xsltGenericDebugContext,
             "Defining global variable %s\n", name);
#endif
 
    elem = xsltNewStackElem(NULL);
    if (elem == NULL)
    return(-1);
    elem->comp = comp;
    elem->name = xmlDictLookup(style->dict, name, -1);
    elem->select = xmlDictLookup(style->dict, sel, -1);
    if (ns_uri)
    elem->nameURI = xmlDictLookup(style->dict, ns_uri, -1);
    elem->tree = tree;
    tmp = style->variables;
    if (tmp == NULL) {
    elem->next = NULL;
    style->variables = elem;
    } else {
    while (tmp != NULL) {
        if ((elem->comp->type == XSLT_FUNC_VARIABLE) &&
        (tmp->comp->type == XSLT_FUNC_VARIABLE) &&
        (xmlStrEqual(elem->name, tmp->name)) &&
        ((elem->nameURI == tmp->nameURI) ||
         (xmlStrEqual(elem->nameURI, tmp->nameURI))))
        {
        xsltTransformError(NULL, style, comp->inst,
        "redefinition of global variable %s\n", elem->name);
        style->errors++;
        }
        if (tmp->next == NULL)
            break;
        tmp = tmp->next;
    }
    elem->next = NULL;
    tmp->next = elem;
    }
    if (value != NULL) {
    elem->computed = 1;
    elem->value = xmlXPathNewString(value);
    }
    return(0);
}

Referenced by xsltParseGlobalParam(), and xsltParseGlobalVariable().

xsltRegisterLocalRVT()

int xsltRegisterLocalRVT	(	xsltTransformContextPtr	ctxt,
		xmlDocPtr	RVT
	)

xsltRegisterLocalRVT: @ctxt: an XSLT transformation context @RVT: a result value tree (Result Tree Fragment; xmlDocPtr)

Registers a result value tree (XSLT 1.0 term: Result Tree Fragment) in the RVT garbage collector. The fragment will be freed when the instruction which created the fragment exits.

Returns 0 in case of success and -1 in case of API or internal errors.

Definition at line 138 of file variables.c.

{
    if ((ctxt == NULL) || (RVT == NULL))
    return(-1);
 
    RVT->prev = NULL;
    RVT->psvi = XSLT_RVT_LOCAL;
 
    /*
    * When evaluating "select" expressions of xsl:variable
    * and xsl:param, we need to bind newly created tree fragments
    * to the variable itself; otherwise the fragment will be
    * freed before we leave the scope of a var.
    */
    if ((ctxt->contextVariable != NULL) &&
    (XSLT_TCTXT_VARIABLE(ctxt)->flags & XSLT_VAR_IN_SELECT))
    {
    RVT->next = (xmlNodePtr) XSLT_TCTXT_VARIABLE(ctxt)->fragment;
    XSLT_TCTXT_VARIABLE(ctxt)->fragment = RVT;
    return(0);
    }
    /*
    * Store the fragment in the scope of the current instruction.
    * If not reference by a returning instruction (like EXSLT's function),
    * then this fragment will be freed, when the instruction exits.
    */
    RVT->next = (xmlNodePtr) ctxt->localRVT;
    if (ctxt->localRVT != NULL)
    ctxt->localRVT->prev = (xmlNodePtr) RVT;
    ctxt->localRVT = RVT;
    return(0);
}

Referenced by xsltFreeStackElem(), and xsltReleaseLocalRVTs().

xsltRegisterPersistRVT()

int xsltRegisterPersistRVT	(	xsltTransformContextPtr	ctxt,
		xmlDocPtr	RVT
	)

xsltRegisterPersistRVT: @ctxt: an XSLT transformation context @RVT: a result value tree (Result Tree Fragment)

Register the result value tree (XSLT 1.0 term: Result Tree Fragment) in the fragment garbage collector. The fragment will be freed when the transformation context is freed.

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

Definition at line 394 of file variables.c.

{
    if ((ctxt == NULL) || (RVT == NULL)) return(-1);
 
    RVT->psvi = XSLT_RVT_GLOBAL;
    RVT->prev = NULL;
    RVT->next = (xmlNodePtr) ctxt->persistRVT;
    if (ctxt->persistRVT != NULL)
    ctxt->persistRVT->prev = (xmlNodePtr) RVT;
    ctxt->persistRVT = RVT;
    return(0);
}

Referenced by xsltEvalGlobalVariable(), and xsltReleaseLocalRVTs().

xsltRegisterTmpRVT()

int xsltRegisterTmpRVT	(	xsltTransformContextPtr	ctxt,
		xmlDocPtr	RVT
	)

xsltRegisterTmpRVT: @ctxt: an XSLT transformation context @RVT: a result value tree (Result Tree Fragment)

Registers the result value tree (XSLT 1.0 term: Result Tree Fragment) in the garbage collector. The fragment will be freed at the exit of the currently instantiated xsl:template. Obsolete; this function might produce massive memory overhead, since the fragment is only freed when the current xsl:template exits. Use xsltRegisterLocalRVT() instead.

Returns 0 in case of success and -1 in case of API or internal errors.

Definition at line 99 of file variables.c.

{
    if ((ctxt == NULL) || (RVT == NULL))
    return(-1);
 
    RVT->prev = NULL;
    RVT->psvi = XSLT_RVT_LOCAL;
 
    /*
    * We'll restrict the lifetime of user-created fragments
    * insinde an xsl:variable and xsl:param to the lifetime of the
    * var/param itself.
    */
    if (ctxt->contextVariable != NULL) {
    RVT->next = (xmlNodePtr) XSLT_TCTXT_VARIABLE(ctxt)->fragment;
    XSLT_TCTXT_VARIABLE(ctxt)->fragment = RVT;
    return(0);
    }
 
    RVT->next = (xmlNodePtr) ctxt->tmpRVT;
    if (ctxt->tmpRVT != NULL)
    ctxt->tmpRVT->prev = (xmlNodePtr) RVT;
    ctxt->tmpRVT = RVT;
    return(0);
}

xsltRegisterVariable()

static int xsltRegisterVariable ( xsltTransformContextPtr  ctxt, xsltStylePreCompPtr  castedComp, xmlNodePtr  tree, int  isParam  )

static

xsltRegisterVariable: @ctxt: the XSLT transformation context @comp: the compiled XSLT-variable (or param) instruction @tree: the tree if select is NULL @isParam: indicates if this is a parameter

Computes and registers a new variable.

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

Definition at line 1813 of file variables.c.

{
#ifdef XSLT_REFACTORED
    xsltStyleBasicItemVariablePtr comp =
    (xsltStyleBasicItemVariablePtr) castedComp;
#else
    xsltStylePreCompPtr comp = castedComp;
    int present;
#endif
    xsltStackElemPtr variable;
 
#ifdef XSLT_REFACTORED
    /*
    * REFACTORED NOTE: Redefinitions of vars/params are checked
    *  at compilation time in the refactored code.
    * xsl:with-param parameters are checked in xsltApplyXSLTTemplate().
    */
#else
    present = xsltCheckStackElem(ctxt, comp->name, comp->ns);
    if (isParam == 0) {
    if ((present != 0) && (present != 3)) {
        /* TODO: report QName. */
        xsltTransformError(ctxt, NULL, comp->inst,
        "XSLT-variable: Redefinition of variable '%s'.\n", comp->name);
        return(0);
    }
    } else if (present != 0) {
    if ((present == 1) || (present == 2)) {
        /* TODO: report QName. */
        xsltTransformError(ctxt, NULL, comp->inst,
        "XSLT-param: Redefinition of parameter '%s'.\n", comp->name);
        return(0);
    }
#ifdef WITH_XSLT_DEBUG_VARIABLE
    XSLT_TRACE(ctxt,XSLT_TRACE_VARIABLES,xsltGenericDebug(xsltGenericDebugContext,
         "param %s defined by caller\n", comp->name));
#endif
    return(0);
    }
#endif /* else of XSLT_REFACTORED */
 
    variable = xsltBuildVariable(ctxt, (xsltStylePreCompPtr) comp, tree);
    xsltAddStackElem(ctxt, variable);
    return(0);
}

Referenced by xsltParseStylesheetParam(), and xsltParseStylesheetVariable().

xsltReleaseRVT()

void xsltReleaseRVT	(	xsltTransformContextPtr	ctxt,
		xmlDocPtr	RVT
	)

xsltReleaseRVT: @ctxt: an XSLT transformation context @RVT: a result value tree (Result Tree Fragment)

Either frees the RVT (which is an xmlDoc) or stores it in the context's cache for later reuse.

Definition at line 328 of file variables.c.

{
    if (RVT == NULL)
    return;
 
    if (ctxt && (ctxt->cache->nbRVT < 40)) {
    /*
    * Store the Result Tree Fragment.
    * Free the document info.
    */
    if (RVT->_private != NULL) {
        xsltFreeDocumentKeys((xsltDocumentPtr) RVT->_private);
        xmlFree(RVT->_private);
        RVT->_private = NULL;
    }
    /*
    * Clear the document tree.
    */
    if (RVT->children != NULL) {
        xmlFreeNodeList(RVT->children);
        RVT->children = NULL;
        RVT->last = NULL;
    }
    if (RVT->ids != NULL) {
        xmlFreeIDTable((xmlIDTablePtr) RVT->ids);
        RVT->ids = NULL;
    }
 
    /*
    * Reset the ownership information.
    */
    RVT->psvi = NULL;
 
    RVT->next = (xmlNodePtr) ctxt->cache->RVT;
    ctxt->cache->RVT = RVT;
 
    ctxt->cache->nbRVT++;
 
#ifdef XSLT_DEBUG_PROFILE_CACHE
    ctxt->cache->dbgCachedRVTs++;
#endif
    return;
    }
    /*
    * Free it.
    */
    if (RVT->_private != NULL) {
    xsltFreeDocumentKeys((xsltDocumentPtr) RVT->_private);
    xmlFree(RVT->_private);
    }
    xmlFreeDoc(RVT);
}

Referenced by xsltApplyXSLTTemplate(), xsltFreeStackElem(), and xsltReleaseLocalRVTs().

xsltStackLookup()

static xsltStackElemPtr xsltStackLookup ( xsltTransformContextPtr  ctxt, const xmlChar *  name, const xmlChar *  nameURI  )

static

Definition at line 627 of file variables.c.

                                    {
    int i;
    xsltStackElemPtr cur;
 
    if ((ctxt == NULL) || (name == NULL) || (ctxt->varsNr == 0))
    return(NULL);
 
    /*
     * 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.
     */
    for (i = ctxt->varsNr; i > ctxt->varsBase; i--) {
    cur = ctxt->varsTab[i-1];
    while (cur != NULL) {
        if ((cur->name == name) && (cur->nameURI == nameURI)) {
#if 0
        stack_addr++;
#endif
        return(cur);
        }
        cur = cur->next;
    }
    }
 
    /*
     * Redo the lookup with interned string compares
     * to avoid string compares.
     */
    name = xmlDictLookup(ctxt->dict, name, -1);
    if (nameURI != NULL)
        nameURI = xmlDictLookup(ctxt->dict, nameURI, -1);
 
    for (i = ctxt->varsNr; i > ctxt->varsBase; i--) {
    cur = ctxt->varsTab[i-1];
    while (cur != NULL) {
        if ((cur->name == name) && (cur->nameURI == nameURI)) {
#if 0
        stack_cmp++;
#endif
        return(cur);
        }
        cur = cur->next;
    }
    }
 
    return(NULL);
}

Referenced by xsltCheckStackElem(), and xsltVariableLookup().

xsltVariableLookup()

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

Definition at line 1920 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()

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

Definition at line 2243 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);
}

Variable Documentation

xsltComputingGlobalVarMarker

const xmlChar* xsltComputingGlobalVarMarker

static

Initial value:

=
 (const xmlChar *) " var/param being computed"

Definition at line 22 of file variables.c.

Referenced by xsltEvalGlobalVariable(), and xsltGlobalVariableLookup().