Class Optimizer

Method Details

• getConfiguration

  public Configuration getConfiguration()

  Get the Saxon configuration object

  Returns:

  the configuration

• makeGeneralComparison

  public BinaryExpression makeGeneralComparison(Expression p0, int op, Expression p1, boolean backwardsCompatible)

  Create a GeneralComparison expression

  Parameters:

  p0 - the first operand

  op - the operator

  p1 - the second operand

  backwardsCompatible - true if XPath 1.0 backwards compatibility is in force

  Returns:

  the constructed expression

• optimizeCopy

  public Expression optimizeCopy(Expression select) throws XPathException

  Attempt to optimize a copy operation. Return null if no optimization is possible.

  Parameters:

  select - the expression that selects the items to be copied

  Returns:

  null if no optimization is possible, or an expression that does an optimized copy of these items otherwise

  Throws:

  XPathException

• makeClosure

  public Value makeClosure(Expression expression, int ref, XPathContext context) throws XPathException

  Make a Closure, given the expected reference count

  Parameters:

  expression - the expression to be evaluated

  ref - the (nominal) number of times the value of the expression is required

  context - the XPath dynamic evaluation context

  Returns:

  the constructed Closure

  Throws:

  XPathException

• makeSequenceExtent

  public ValueRepresentation makeSequenceExtent(Expression expression, int ref, XPathContext context) throws XPathException

  Make a SequenceExtent, given the expected reference count

  Parameters:

  expression - the expression to be evaluated

  ref - the (nominal) number of times the value of the expression is required

  context - the XPath dynamic evaluation context

  Returns:

  the constructed Closure

  Throws:

  XPathException

• convertPathExpressionToKey

  public Expression convertPathExpressionToKey(PathExpression pathExp, ExpressionVisitor visitor) throws XPathException

  Examine a path expression to see whether it can be replaced by a call on the key() function; if so, generate an appropriate key definition and return the call on key(). If not, return null.

  Parameters:

  pathExp - The path expression to be converted.

  visitor - The expression visitor

  Returns:

  the optimized expression, or null if no optimization is possible

  Throws:

  XPathException

• tryIndexedFilter

  public Expression tryIndexedFilter(FilterExpression f, ExpressionVisitor visitor, boolean indexFirstOperand)

  Try converting a filter expression to a call on the key function. Return the supplied expression unchanged if not possible

  Parameters:

  f - the filter expression to be converted

  visitor - the expression visitor, which must be currently visiting the filter expression f

  indexFirstOperand - true if the first operand of the filter comparison is to be indexed; false if it is the second operand

  Returns:

  the optimized expression, or the unchanged expression f if no optimization is possible

• convertToFilterExpression

  public FilterExpression convertToFilterExpression(PathExpression pathExp, TypeHierarchy th) throws XPathException

  Convert a path expression such as a/b/c[predicate] into a filter expression of the form (a/b/c)[predicate]. This is possible whenever the predicate is non-positional. The conversion is useful in the case where the path expression appears inside a loop, where the predicate depends on the loop variable but a/b/c does not.

  Parameters:

  pathExp - the path expression to be converted

  th - the type hierarchy cache

  Returns:

  the resulting filterexpression if conversion is possible, or null if not

  Throws:

  XPathException

• isIndexableFilter

  public int isIndexableFilter(Expression filter)

  Test whether a filter predicate is indexable.

  Parameters:

  filter - the predicate expression

  Returns:

  0 if not indexable; +1 if the predicate is in the form expression=value; -1 if it is in the form value=expression

• makeIndexedValue

  public ValueRepresentation makeIndexedValue(SequenceIterator iter) throws XPathException

  Create an indexed value

  Parameters:

  iter - the iterator that delivers the sequence of values to be indexed

  Returns:

  the indexed value

  Throws:

  XPathException

• isVariableReplaceableByDot

  public boolean isVariableReplaceableByDot(Expression exp, Binding[] binding)

  Determine whether it is possible to rearrange an expression so that all references to a given variable are replaced by a reference to ".". This is true of there are no references to the variable within a filter predicate or on the rhs of a "/" operator.

  Parameters:

  exp - the expression in question

  binding - an array of bindings defining range variables; the method tests that there are no references to any of these variables within a predicate or on the rhs of "/"

  Returns:

  true if the variable reference can be replaced

• makeConditionalDocumentSorter

  public Expression makeConditionalDocumentSorter(DocumentSorter sorter, PathExpression path)

  Make a conditional document sorter. This optimization is attempted when a DocumentSorter is wrapped around a path expression

  Parameters:

  sorter - the document sorter

  path - the path expression

  Returns:

  the original sorter unchanged when no optimization is possible, which is always the case in Saxon-B

• tryInlineFunctionCall

  public Expression tryInlineFunctionCall(UserFunctionCall functionCall, ExpressionVisitor visitor, ItemType contextItemType)

  Replace a function call by the body of the function, assuming all conditions for inlining the function are satisfied

  Parameters:

  functionCall - the functionCall expression

  visitor - the expression visitor

  contextItemType - the context item type

  Returns:

  either the original expression unchanged, or an expression that consists of the inlined function body, with all function parameters bound as required. In Saxon-B, function inlining is not supported, so the original functionCall is always returned unchanged

• promoteExpressionsToGlobal

  public Expression promoteExpressionsToGlobal(Expression body, ExpressionVisitor visitor) throws XPathException

  Identify expressions within a function or template body that can be promoted to be evaluated as global variables.

  Parameters:

  body - the body of the template or function

  visitor - the expression visitor

  Returns:

  the expression after subexpressions have been promoted to global variables

  Throws:

  XPathException

• trySwitch

  public Expression trySwitch(Choose choose, StaticContext env)

  Try to convert a Choose expression into a switch

  Parameters:

  choose - the Choose expression

  env - the static context

  Returns:

  the result of optimizing this (the original expression if no optimization was possible)

• extractGlobalVariables

  public Expression extractGlobalVariables(Expression body, ExpressionVisitor visitor) throws XPathException

  Extract subexpressions from the body of a function that can be evaluated as global variables

  Parameters:

  body - the body of the function

  Returns:

  a reference to the new global variable if a variable has been created, or null if not

  Throws:

  XPathException

• trace

  public void trace(String message, Expression exp)

  Trace optimization actions

  Parameters:

  message - the message to be displayed

  exp - the expression after being rewritten

• trace

  public void trace(String message)

  Trace optimization actions

  Parameters:

  message - the message to be displayed