net.sf.saxon.expr

Class ExpressionVisitor


public class ExpressionVisitor
extends java.lang.Object

The ExpressionVisitor supports the various phases of processing of an expression tree which require a recursive walk of the tree structure visiting each node in turn. In maintains a stack holding the ancestor nodes of the node currently being visited.

Constructor Summary

ExpressionVisitor()
Create an ExpressionVisitor

Method Summary

Configuration
getConfiguration()
Get the Saxon configuration
Container
getContainer()
Get the container of the expressions being visited
Expression
getCurrentExpression()
Get the current expression, the one being visited
Executable
getExecutable()
Get the Executable containing the expressions being visited
Expression
getParentExpression()
Get the parent expression of the current expression in the expression tree
Stack
getStack()
Get the stack containing all the expressions currently being visited
StaticContext
getStaticContext()
Get the static context for the expressions being visited.
boolean
isLoopingSubexpression(Expression ancestor)
Return true if the current expression at the top of the visitor's stack is evaluated repeatedly when a given ancestor expression is evaluated once
static ExpressionVisitor
make(StaticContext env)
Factory method: make an expression visitor
Expression
optimize(Expression exp, ItemType contextItemType)
Optimize an expression, via the ExpressionVisitor
void
resetStaticProperties()
Reset the static properties for the current expression and for all its containing expressions.
void
setConfiguration(Configuration configuration)
Set the Saxon configuration
void
setContainer(Container container)
Set the container of the expressions being visited
void
setExecutable(Executable executable)
Set the Executable containing the expressions being visited
void
setStack(Stack stack)
Set the stack used to hold the expressions being visited
void
setStaticContext(StaticContext staticContext)
Set the static context for the expressions being visited.
Expression
simplify(Expression exp)
Simplify an expression, via the ExpressionVisitor
Expression
typeCheck(Expression exp, ItemType contextItemType)
Type check an expression, via the ExpressionVisitor

Constructor Details

ExpressionVisitor

public ExpressionVisitor()
Create an ExpressionVisitor

Method Details

getConfiguration

public Configuration getConfiguration()
Get the Saxon configuration
Returns:
the Saxon configuration

getContainer

public Container getContainer()
Get the container of the expressions being visited
Returns:
the container

getCurrentExpression

public Expression getCurrentExpression()
Get the current expression, the one being visited
Returns:
the current expression

getExecutable

public Executable getExecutable()
Get the Executable containing the expressions being visited
Returns:
the Executable

getParentExpression

public Expression getParentExpression()
Get the parent expression of the current expression in the expression tree
Returns:
the parent of the current expression (or null if this is the root)

getStack

public Stack getStack()
Get the stack containing all the expressions currently being visited

getStaticContext

public StaticContext getStaticContext()
Get the static context for the expressions being visited. Note: this may not reflect all changes in static context (e.g. namespace context, base URI) applying to nested expressions
Returns:
the static context

isLoopingSubexpression

public boolean isLoopingSubexpression(Expression ancestor)
Return true if the current expression at the top of the visitor's stack is evaluated repeatedly when a given ancestor expression is evaluated once
Parameters:
ancestor - the ancestor expression. May be null, in which case the search goes all the way to the base of the stack.
Returns:
true if the current expression is evaluated repeatedly

make

public static ExpressionVisitor make(StaticContext env)
Factory method: make an expression visitor
Parameters:
env - the static context
Returns:
the new expression visitor

optimize

public Expression optimize(Expression exp,
                           ItemType contextItemType)
            throws XPathException
Optimize an expression, via the ExpressionVisitor
Parameters:
exp - the expression to be typechecked
contextItemType - the static type of the context item for this expression
Returns:
the rewritten expression
Throws:
XPathException -

resetStaticProperties

public final void resetStaticProperties()
Reset the static properties for the current expression and for all its containing expressions. This should be done whenever the expression is changed in a way that might affect the properties. It causes the properties to be recomputed next time they are needed.

setConfiguration

public void setConfiguration(Configuration configuration)
Set the Saxon configuration
Parameters:
configuration - the Saxon configuration

setContainer

public void setContainer(Container container)
Set the container of the expressions being visited
Parameters:
container - the container

setExecutable

public void setExecutable(Executable executable)
Set the Executable containing the expressions being visited
Parameters:
executable - the Executable

setStack

public void setStack(Stack stack)
Set the stack used to hold the expressions being visited
Parameters:
stack - the expression stack

setStaticContext

public void setStaticContext(StaticContext staticContext)
Set the static context for the expressions being visited. Note: this may not reflect all changes in static context (e.g. namespace context, base URI) applying to nested expressions
Parameters:
staticContext - the static context

simplify

public Expression simplify(Expression exp)
            throws XPathException
Simplify an expression, via the ExpressionVisitor
Parameters:
exp - the expression to be simplified
Returns:
the simplified expression
Throws:
XPathException -

typeCheck

public Expression typeCheck(Expression exp,
                            ItemType contextItemType)
            throws XPathException
Type check an expression, via the ExpressionVisitor
Parameters:
exp - the expression to be typechecked
contextItemType - the static type of the context item for this expression
Returns:
the expression that results from type checking (this may be wrapped in expressions that perform dynamic checking of the item type or cardinality, or that perform atomization or numeric promotion)
Throws:
XPathException - if static type checking fails, that is, if the expression cannot possibly deliver a value of the required type