net.sf.saxon.expr

Class SystemFunctionCall

java.lang.Object

net.sf.saxon.expr.Expression

net.sf.saxon.expr.FunctionCall

net.sf.saxon.expr.StaticFunctionCall

net.sf.saxon.expr.SystemFunctionCall

All Implemented Interfaces:

Callable, Negatable, IdentityComparable

public class SystemFunctionCall
extends StaticFunctionCall
implements Negatable

A call to a system-defined function (specifically, a function implemented as an instance of SystemFunction)

Field Summary

Fields inherited from class net.sf.saxon.expr.Expression

EFFECTIVE_BOOLEAN_VALUE, EVALUATE_METHOD, ITEM_FEED_METHOD, ITERATE_METHOD, MAX_SEQUENCE_LENGTH, MAX_STRING_LENGTH, PROCESS_METHOD, staticProperties, UNBOUNDED_LOWER, UNBOUNDED_UPPER, UPDATE_METHOD, WATCH_METHOD

Constructor Summary

Constructors

Constructor and Description
SystemFunctionCall(SystemFunction target, Expression[] arguments)

Method Summary

Methods

Modifier and Type	Method and Description
PathMap.PathMapNodeSet	addToPathMap(PathMap pathMap, PathMap.PathMapNodeSet pathMapNodeSet) Add a representation of this expression to a PathMap.
protected int	computeCardinality() Compute the static cardinality of this expression
protected int	computeSpecialProperties() Compute the special properties of this expression.
Expression	copy() Copy an expression.
void	export(ExpressionPresenter out) Diagnostic print of expression structure.
ExpressionCompiler	getExpressionCompiler() Return the bytecode compiler for this system function call.
IntegerValue[]	getIntegerBounds() For an expression that returns an integer or a sequence of integers, get a lower and upper bound on the values of the integers that may be returned, from static analysis.
int	getIntrinsicDependencies() Compute the dependencies of an expression, as the union of the dependencies of its subexpressions.
ItemType	getItemType() Determine the data type of the expression, if possible.
StreamingAdjunct	getStreamingAdjunct() Get a class that supports streamed evaluation of this expression
SystemFunction	getTargetFunction() Get the target function to be called
boolean	isNegatable(TypeHierarchy th) Check whether this specific instance of the expression is negatable
boolean	isVacuousExpression() Determine whether this is a vacuous expression as defined in the XQuery update specification
Expression	negate() Create an expression that returns the negation of this expression
Expression	optimize(ExpressionVisitor visitor, ContextItemStaticInfo contextInfo) Perform optimisation of an expression and its subexpressions.
Expression	preEvaluate(ExpressionVisitor visitor) Pre-evaluate a function at compile time.
void	setRetainedStaticContext(RetainedStaticContext rsc) Set the retained static context
Pattern	toPattern(Configuration config, boolean is30) Convert this expression to an equivalent XSLT pattern
Expression	typeCheck(ExpressionVisitor visitor, ContextItemStaticInfo contextInfo) Type-check the expression.
Expression	unordered(boolean retainAllNodes, boolean forStreaming) Replace this expression by a simpler expression that delivers the results without regard to order.

Methods inherited from class net.sf.saxon.expr.StaticFunctionCall

call, getFunctionName, getTargetFunction, isCallOn, isCallOnSystemFunction

Methods inherited from class net.sf.saxon.expr.FunctionCall

addExternalFunctionCallToPathMap, adjustRequiredType, checkArgumentCount, checkArguments, checkFunctionCall, equals, evaluateArguments, getArg, getArguments, getArity, getDisplayName, getExpressionName, getImplementationMethod, getNetCost, getOperanda, hashCode, iterate, operands, pluralArguments, preEvaluateIfConstant, setArg, setArguments, setOperanda, setOperanda, simplifyArguments, toShortString, toString

Methods inherited from class net.sf.saxon.expr.Expression

adoptChildExpression, checkedOperands, checkForUpdatingSubexpressions, checkPermittedContents, clearStreamabilityData, computeDependencies, computeStaticProperties, doPromotion, dynamicError, effectiveBooleanValue, evaluateAsString, evaluateItem, evaluatePendingUpdates, explain, getCardinality, getConfiguration, getConstructType, getCost, getDependencies, getEvaluationMethod, getHostLanguage, getLocation, getObjectName, getPackageData, getParentExpression, getPosture, getPostureAndSweepIfKnown, getProperties, getProperty, getRetainedStaticContext, getSlotsUsed, getSpecialProperties, getStaticBaseURI, getStaticBaseURIString, getStreamability, getSweep, getSystemId, hasVariableBinding, identityHashCode, implementsStaticTypeCheck, isIdentical, isSubtreeExpression, isUpdatingExpression, iterateEvents, makeStreamingAdjunct, markTailFunctionCalls, operandList, operandSparseList, optimizeChildren, optimizeForType, process, promote, promoteChildren, resetLocalStaticProperties, restoreParentPointers, setEvaluationMethod, setFiltered, setFlattened, setLocation, setParentExpression, setPostureAndSweep, setRetainedStaticContextLocally, setStaticProperty, simplify, simplifyChildren, staticTypeCheck, suppressValidation, toStreamingPattern, typeCheckChildren, typeError

Methods inherited from class java.lang.Object

clone, finalize, getClass, notify, notifyAll, wait, wait, wait

Constructor Detail

SystemFunctionCall

public SystemFunctionCall(SystemFunction target,
                  Expression[] arguments)

Method Detail

setRetainedStaticContext

public void setRetainedStaticContext(RetainedStaticContext rsc)

Set the retained static context

Overrides:

setRetainedStaticContext in class Expression

Parameters:

rsc - the static context to be retained

preEvaluate

public Expression preEvaluate(ExpressionVisitor visitor)
                       throws XPathException

Pre-evaluate a function at compile time. Functions that do not allow pre-evaluation, or that need access to context information, can prevent early evaluation by setting the LATE bit in the function properties.

Overrides:

preEvaluate in class FunctionCall

Parameters:

visitor - an expression visitor

Returns:

the result of the early evaluation, or the original expression, or potentially a simplified expression

Throws:

XPathException - if evaluation fails

typeCheck

public Expression typeCheck(ExpressionVisitor visitor,
                   ContextItemStaticInfo contextInfo)
                     throws XPathException

Type-check the expression. This also calls preEvaluate() to evaluate the function if all the arguments are constant; functions that do not require this behavior can override the preEvaluate method.

Overrides:

typeCheck in class StaticFunctionCall

Parameters:

visitor - the expression visitor

contextInfo - information about the type of the context item

Returns:

the original expression, rewritten to perform necessary run-time type checks, and to perform other type-related optimizations

Throws:

XPathException - if an error is discovered during this phase (typically a type error)

getTargetFunction

public SystemFunction getTargetFunction()

Description copied from class: StaticFunctionCall

Get the target function to be called

Overrides:

getTargetFunction in class StaticFunctionCall

Returns:

the target function

getIntrinsicDependencies

public int getIntrinsicDependencies()

Compute the dependencies of an expression, as the union of the dependencies of its subexpressions. (This is overridden for path expressions and filter expressions, where the dependencies of a subexpression are not all propogated). This method should be called only once, to compute the dependencies; after that, getDependencies should be used.

Overrides:

getIntrinsicDependencies in class Expression

Returns:

the depencies, as a bit-mask

computeCardinality

protected int computeCardinality()

Compute the static cardinality of this expression

Overrides:

computeCardinality in class StaticFunctionCall

Returns:

the computed cardinality, as one of the values StaticProperty.ALLOWS_ZERO_OR_ONE, StaticProperty.EXACTLY_ONE, StaticProperty.ALLOWS_ONE_OR_MORE, StaticProperty.ALLOWS_ZERO_OR_MORE

computeSpecialProperties

protected int computeSpecialProperties()

Compute the special properties of this expression. These properties are denoted by a bit-significant integer, possible values are in class StaticProperty. The "special" properties are properties other than cardinality and dependencies, and most of them relate to properties of node sequences, for example whether the nodes are in document order.

Overrides:

computeSpecialProperties in class Expression

Returns:

the special properties, as a bit-significant integer

optimize

public Expression optimize(ExpressionVisitor visitor,
                  ContextItemStaticInfo contextInfo)
                    throws XPathException

Description copied from class: FunctionCall

Perform optimisation of an expression and its subexpressions.

This method is called after all references to functions and variables have been resolved to the declaration of the function or variable, and after all type checking has been done.

Overrides:

optimize in class FunctionCall

Parameters:

visitor - an expression visitor

contextInfo - the static type of "." at the point where this expression is invoked. The parameter is set to null if it is known statically that the context item will be undefined. If the type of the context item is not known statically, the argument is set to Type.ITEM_TYPE

Returns:

the original expression, rewritten if appropriate to optimize execution

Throws:

XPathException - if an error is discovered during this phase (typically a type error)

isVacuousExpression

public boolean isVacuousExpression()

Description copied from class: Expression

Determine whether this is a vacuous expression as defined in the XQuery update specification

Overrides:

isVacuousExpression in class Expression

Returns:

true if this expression is vacuous

getItemType

public ItemType getItemType()

Determine the data type of the expression, if possible. All expression return sequences, in general; this method determines the type of the items within the sequence, assuming that (a) this is known in advance, and (b) it is the same for all items in the sequence.

This method should always return a result, though it may be the best approximation that is available at the time.

Overrides:

getItemType in class StaticFunctionCall

Returns:

a value such as Type.STRING, Type.BOOLEAN, Type.NUMBER, Type.NODE, or Type.ITEM (meaning not known at compile time)

copy

public Expression copy()

Copy an expression. This makes a deep copy.

Overrides:

copy in class StaticFunctionCall

Returns:

the copy of the original expression

getIntegerBounds

public IntegerValue[] getIntegerBounds()

For an expression that returns an integer or a sequence of integers, get a lower and upper bound on the values of the integers that may be returned, from static analysis. The default implementation returns null, meaning "unknown" or "not applicable". Other implementations return an array of two IntegerValue objects, representing the lower and upper bounds respectively. The values UNBOUNDED_LOWER and UNBOUNDED_UPPER are used by convention to indicate that the value may be arbitrarily large. The values MAX_STRING_LENGTH and MAX_SEQUENCE_LENGTH are used to indicate values limited by the size of a string or the size of a sequence.

Overrides:

getIntegerBounds in class Expression

Returns:

the lower and upper bounds of integer values in the result, or null to indicate unknown or not applicable.

isNegatable

public boolean isNegatable(TypeHierarchy th)

Check whether this specific instance of the expression is negatable

Specified by:

isNegatable in interface Negatable

Parameters:

th - the TypeHierarchy (in case it's needed)

Returns:

true if it is

negate

public Expression negate()

Create an expression that returns the negation of this expression

Specified by:

negate in interface Negatable

Returns:

the negated expression

Throws:

UnsupportedOperationException - if isNegatable() returns false

unordered

public Expression unordered(boolean retainAllNodes,
                   boolean forStreaming)
                     throws XPathException

Replace this expression by a simpler expression that delivers the results without regard to order.

Overrides:

unordered in class Expression

Parameters:

retainAllNodes - set to true if the result must contain exactly the same nodes as the original; set to false if the result can eliminate (or introduce) duplicates.

forStreaming - set to true if the result is to be optimized for streaming

Returns:

an expression that delivers the same nodes in a more convenient order

Throws:

XPathException - if the rewrite fails

addToPathMap

public PathMap.PathMapNodeSet addToPathMap(PathMap pathMap,
                                  PathMap.PathMapNodeSet pathMapNodeSet)

Add a representation of this expression to a PathMap. The PathMap captures a map of the nodes visited by an expression in a source tree.

The default implementation of this method assumes that an expression does no navigation other than the navigation done by evaluating its subexpressions, and that the subexpressions are evaluated in the same context as the containing expression. The method must be overridden for any expression where these assumptions do not hold. For example, implementations exist for AxisExpression, ParentExpression, and RootExpression (because they perform navigation), and for the doc(), document(), and collection() functions because they create a new navigation root. Implementations also exist for PathExpression and FilterExpression because they have subexpressions that are evaluated in a different context from the calling expression.

Overrides:

addToPathMap in class Expression

Parameters:

pathMap - the PathMap to which the expression should be added

pathMapNodeSet - the PathMapNodeSet to which the paths embodied in this expression should be added

Returns:

the pathMapNodeSet representing the points in the source document that are both reachable by this expression, and that represent possible results of this expression. For an expression that does navigation, it represents the end of the arc in the path map that describes the navigation route. For other expressions, it is the same as the input pathMapNode.

toPattern

public Pattern toPattern(Configuration config,
                boolean is30)
                  throws XPathException

Convert this expression to an equivalent XSLT pattern

Overrides:

toPattern in class Expression

Parameters:

config - the Saxon configuration

is30 - true if this is XSLT 3.0

Returns:

the equivalent pattern

Throws:

XPathException - if conversion is not possible

export

public void export(ExpressionPresenter out)

Diagnostic print of expression structure. The abstract expression tree is written to the supplied output destination.

Overrides:

export in class StaticFunctionCall

Parameters:

out -

getExpressionCompiler

public ExpressionCompiler getExpressionCompiler()
                                         throws CannotCompileException

Return the bytecode compiler for this system function call.

Overrides:

getExpressionCompiler in class StaticFunctionCall

Returns:

the relevant ExpressionCompiler

Throws:

CannotCompileException - if it is not possible to generate bytecode for this expression

getStreamingAdjunct

public StreamingAdjunct getStreamingAdjunct()

Get a class that supports streamed evaluation of this expression

Overrides:

getStreamingAdjunct in class Expression

Returns:

the relevant StreamingAdjunct, or null if none is available