Package net.sf.saxon.expr.parser

Class ExpressionVisitor

  • All Implemented Interfaces:
    TypeCheckerEnvironment
    public class ExpressionVisitor
extends java.lang.Object
implements TypeCheckerEnvironment
    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 Detail

      • ExpressionVisitor

        public ExpressionVisitor()
        Create an ExpressionVisitor

    • Method Detail

      • setConfiguration

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

      • getExecutable

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

      • setExecutable

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

      • getExpressionStack

        public java.util.Stack<Expression> getExpressionStack()
        Get the stack containing all the expressions currently being visited
        Returns:
        the expression stack holding all the containing expressions of the current expression; the objects on this Stack are instances of Expression

      • setExpressionStack

        public void setExpressionStack​(java.util.Stack<Expression> expressionStack)
        Set the stack used to hold the expressions being visited
        Parameters:
        expressionStack - the expression stack

      • 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

      • 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

      • getCurrentExpression

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

      • make

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

      • issueWarning

        public void issueWarning​(java.lang.String message,
                         javax.xml.transform.SourceLocator locator)
        Issue a warning message
        Specified by:
        issueWarning in interface TypeCheckerEnvironment
        Parameters:
        message - the message

      • simplify

        public Expression simplify​(Expression exp)
                    throws XPathException
        Simplify an expression, via the ExpressionVisitor
        Specified by:
        simplify in interface TypeCheckerEnvironment
        Parameters:
        exp - the expression to be simplified. Possibly null.
        Returns:
        the simplified expression. Returns null if and only if the supplied expression is null.
        Throws:
        XPathException - if any error occurs

      • typeCheck

        public Expression typeCheck​(Expression exp,
                            ExpressionVisitor.ContextItemType contextItemType)
                     throws XPathException
        Type check an expression, via the ExpressionVisitor
        Specified by:
        typeCheck in interface TypeCheckerEnvironment
        Parameters:
        exp - the expression to be typechecked
        contextItemType - the static type of the context item for this expression. The argument can be set to null to indicate that it is known that the context item will be absent.
        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

      • setOptimizeForStreaming

        public void setOptimizeForStreaming​(boolean option)
        Tell the visitor to optimize expressions for evaluation in a streaming environment
        Parameters:
        option - true if optimizing for streaming

      • isOptimizeForStreaming

        public boolean isOptimizeForStreaming()
        Ask whether the visitor is to optimize expressions for evaluation in a streaming environment
        Returns:
        true if optimizing for streaming

      • optimize

        public Expression optimize​(Expression exp,
                           ExpressionVisitor.ContextItemType 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. Passing null indicates that the context item will always be absent
        Returns:
        the rewritten expression
        Throws:
        XPathException - if a static error is found

      • 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)

      • 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

      • 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.