net.sf.saxon.expr
public class ExpressionTool extends Object
Field Summary | |
---|---|
static int | CALL_EVALUATE_ITEM |
static int | EVALUATE_AND_MATERIALIZE_VARIABLE |
static int | EVALUATE_SUPPLIED_PARAMETER |
static int | EVALUATE_VARIABLE |
static int | ITERATE_AND_MATERIALIZE |
static int | LAZY_TAIL_EXPRESSION |
static int | MAKE_CLOSURE |
static int | MAKE_INDEXED_VARIABLE |
static int | MAKE_MEMO_CLOSURE |
static int | MAKE_SINGLETON_CLOSURE |
static int | NO_EVALUATION_NEEDED |
static int | PROCESS |
static int | RETURN_EMPTY_SEQUENCE |
static int | SHARED_APPEND_EXPRESSION |
static int | UNDECIDED |
Method Summary | |
---|---|
static int | allocateSlots(Expression exp, int nextFree, SlotManager frame)
Allocate slot numbers to range variables |
static boolean | callsFunction(Expression exp, StructuredQName qName)
Determine whether an expression contains a call on the function with a given fingerprint |
static void | copyLocationInfo(Expression from, Expression to)
Copy location information (the line number and reference to the container) from one expression
to another |
static boolean | dependsOnFocus(Expression exp)
Ask whether an expression has a dependency on the focus |
static boolean | dependsOnVariable(Expression e, Binding[] bindingList)
Determine whether an expression depends on any one of a set of variables |
static ValueRepresentation | eagerEvaluate(Expression exp, XPathContext context)
Evaluate an expression now; lazy evaluation is not permitted in this case |
static int | eagerEvaluationMode(Expression exp)
Determine the method of evaluation to be used when lazy evaluation of an expression is
preferred. |
static void | ebvError(String reason)
Report an error in computing the effective boolean value of an expression |
static boolean | effectiveBooleanValue(SequenceIterator iterator)
Determine the effective boolean value of a sequence, given an iterator over the sequence |
static boolean | effectiveBooleanValue(Item item)
Determine the effective boolean value of a single item |
static ValueRepresentation | evaluate(Expression exp, int evaluationMode, XPathContext context, int ref)
Do lazy evaluation of an expression. |
static int | expressionSize(Expression exp)
Get the size of an expression tree (the number of subexpressions it contains) |
static void | gatherAllSubExpressions(Expression exp, HashSet set)
Gather the set of all the subexpressions of an expression (the transitive closure) |
static void | gatherCalledFunctionNames(Expression e, List list)
Gather a list of the names of the user-defined functions which a given expression calls directly |
static void | gatherCalledFunctions(Expression e, List list)
Gather a list of all the user-defined functions which a given expression calls directly |
static void | gatherReferencedVariables(Expression e, List list)
Gather a list of all the variable bindings on which a given expression depends |
static void | gatherVariableReferences(Expression exp, Binding binding, List list)
Get a list of all references to a particular variable within a subtree |
static int | getReferenceCount(Expression exp, Binding binding, boolean inLoop)
Determine how often a variable is referenced. |
static String | indent(int level)
Construct indent string, for diagnostic output
|
static boolean | isAllowedInUpdatingContext(Expression exp)
Determine whether the expression is either an updating expression, or an expression that is permitted
in a context where updating expressions are allowed |
static ValueRepresentation | lazyEvaluate(Expression exp, XPathContext context, int ref)
Do lazy evaluation of an expression. |
static int | lazyEvaluationMode(Expression exp)
Determine the method of evaluation to be used when lazy evaluation of an expression is
preferred. |
static Expression | make(String expression, StaticContext env, int start, int terminator, int lineNumber, boolean compileWithTracing)
Parse an expression. |
static int | markTailFunctionCalls(Expression exp, StructuredQName qName, int arity)
Scan an expression to find and mark any recursive tail function calls |
static void | rebindVariableReferences(Expression exp, Binding oldBinding, Binding newBinding)
Rebind all variable references to a binding |
static void | resetPropertiesWithinSubtree(Expression exp)
Reset cached static properties within a subtree, meaning that they have to be
recalulated next time they are required |
static Expression | resolveCallsToCurrentFunction(Expression exp, Configuration config)
Resolve calls to the XSLT current() function within an expression |
static Expression | tryToFactorOutDot(Expression exp, ItemType contextItemType)
Try to factor out dependencies on the context item, by rewriting an expression f(.) as
let $dot := . return f($dot). |
static Expression | unsorted(Optimizer opt, Expression exp, boolean retainAllNodes)
Remove unwanted sorting from an expression, at compile time |
static Expression | unsortedIfHomogeneous(Optimizer opt, Expression exp)
Remove unwanted sorting from an expression, at compile time, if and only if it is known
that the result of the expression will be homogeneous (all nodes, or all atomic values).
|
Parameters: exp the expression whose range variables need to have slot numbers assigned nextFree the next slot number that is available for allocation frame a SlotManager object that is used to track the mapping of slot numbers to variable names for debugging purposes. May be null.
Returns: the next unallocated slot number.
Parameters: exp The expression being tested qName The name of the function
Returns: true if the expression contains a call on the function
Parameters: from the expression containing the location information to the expression to which the information is to be copied
Parameters: exp the expression
Returns: true if the value of the expression depends on the context item, position, or size
Parameters: e the expression being tested bindingList the set of variables being tested
Returns: true if the expression depends on one of the given variables
Parameters: exp the expression to be evaluated context the run-time evaluation context
Returns: the result of evaluating the expression
Throws: net.sf.saxon.trans.XPathException if any dynamic error occurs evaluating the expression
Parameters: exp the expression to be evaluated
Returns: an integer constant identifying the evaluation mode
Parameters: reason the nature of the error
Throws: XPathException
Parameters: iterator An iterator over the sequence whose effective boolean value is required
Returns: the effective boolean value
Throws: XPathException if a dynamic error occurs
Parameters: item the item whose effective boolean value is required
Returns: the effective boolean value
Throws: XPathException if a dynamic error occurs
Parameters: exp the expression to be evaluated evaluationMode the evaluation mode for this expression context the run-time evaluation context for the expression. If the expression is not evaluated immediately, then parts of the context on which the expression depends need to be saved as part of the Closure ref an indication of how the value will be used. The value 1 indicates that the value is only expected to be used once, so that there is no need to keep it in memory. A small value >1 indicates multiple references, so the value will be saved when first evaluated. The special value FILTERED indicates a reference within a loop of the form $x[predicate], indicating that the value should be saved in a way that permits indexing.
Returns: a value: either the actual value obtained by evaluating the expression, or a Closure containing all the information needed to evaluate it later
Throws: XPathException if any error occurs in evaluating the expression
Parameters: exp the expression whose size is required
Returns: the size of the expression tree, as the number of nodes
Parameters: exp the parent expression set the set to be populated; on return it will contain all the subexpressions. Beware that testing for membership of a set of expressions relies on the equals() comparison, which does not test identity.
Parameters: e the expression being tested list a list of the functions that are called. The items in this list are strings in the format "{uri}local/arity"
Parameters: e the expression being tested list a list of the functions that are called. The items in this list must be objects of class UserFunction
Parameters: e the expression being tested list a list to which the bindings are to be added. The items in this list must implement Binding
Parameters: exp the expression at the root of the subtree binding the variable binding whose references are sought list a list to be populated with the references to this variable
Parameters: exp the expression within which variable references are to be counted binding identifies the variable of interest inLoop true if the expression is within a loop, in which case a reference counts as many. This should be set to false on the initial call, it may be set to true on an internal recursive call
Returns: the number of references. The interesting values are 0, 1, "many" (represented by any value >1), and the special value FILTERED, which indicates that there are multiple references and one or more of them is of the form $x[....] indicating that an index might be useful.
Parameters: level the indentation level (the number of spaces to return)
Returns: a string of "level*2" spaces
Parameters: exp the expression under test
Returns: true if the expression is an updating expression, or an empty sequence, or a call on error()
Parameters: exp the expression to be evaluated context the run-time evaluation context for the expression. If the expression is not evaluated immediately, then parts of the context on which the expression depends need to be saved as part of the Closure ref an indication of how the value will be used. The value 1 indicates that the value is only expected to be used once, so that there is no need to keep it in memory. A small value >1 indicates multiple references, so the value will be saved when first evaluated. The special value FILTERED indicates a reference within a loop of the form $x[predicate], indicating that the value should be saved in a way that permits indexing.
Returns: a value: either the actual value obtained by evaluating the expression, or a Closure containing all the information needed to evaluate it later
Throws: XPathException if any error occurs in evaluating the expression
Parameters: exp the expression to be evaluated
Returns: an integer constant identifying the evaluation mode
Parameters: expression The expression (as a character string) env An object giving information about the compile-time context of the expression start position of the first significant character in the expression terminator The token that marks the end of this expression; typically Tokenizer.EOF, but may for example be a right curly brace lineNumber the line number of the start of the expression compileWithTracing true if diagnostic tracing during expression parsing is required
Returns: an object of type Expression
Throws: XPathException if the expression contains a static error
Parameters: exp the expression to be analyzed qName the name of the containing function arity the arity of the containing function
Returns: 0 if no tail call was found; 1 if a tail call to a different function was found; 2 if a tail call to the specified function was found. In this case the UserFunctionCall object representing the tail function call will also have been marked as a tail call.
Parameters: exp the expression whose contained variable references are to be rebound oldBinding the old binding for the variable references newBinding the new binding to which the variables should be rebound
Parameters: exp the root of the subtree within which static properties should be reset
Parameters: exp the expression within which calls to current() should be resolved config the Saxon configuration
Returns: the expression after resolving calls to current()
Parameters: exp the expression from which references to "." should be factored out if possible contextItemType the static type of the context item
Returns: either the expression, after binding "." to a local variable and replacing all references to it; or null, if no changes were made.
Parameters: opt the expression optimizer exp the expression to be optimized retainAllNodes true if there is a need to retain exactly those nodes returned by exp even if there are duplicates; false if the caller doesn't mind whether duplicate nodes are retained or eliminated
Returns: the expression after rewriting
Parameters: opt the expression optimizer exp the expression to be optimized
Returns: the expression after rewriting