## net.sf.saxon.expr
Class FunctionCall

    java.lang.Object
      |
      +--net.sf.saxon.expr.ComputedExpression
            |
            +--net.sf.saxon.expr.FunctionCall

All Implemented Interfaces:
  Container, Expression, InstructionInfoProvider, java.io.Serializable, javax.xml.transform.SourceLocator

Direct Known Subclasses:
  ExtensionFunctionCall, SystemFunction, UserFunctionCall

public abstract class FunctionCall
extends ComputedExpression

Abstract superclass for calls to system-defined and user-defined functions

See Also:
  Serialized Form

Field Summary
`protected Expression[]` `argument` The array of expressions representing the actual parameters to the function call

Fields inherited from class net.sf.saxon.expr.ComputedExpression
`locationId, staticProperties`

Fields inherited from interface net.sf.saxon.expr.Expression
`EVALUATE_METHOD, ITERATE_METHOD, PROCESS_METHOD`

Constructor Summary
`FunctionCall()`

Method Summary
`Expression` `analyze(StaticContext env, ItemType contextItemType)` Type-check the expression.
`protected int` `checkArgumentCount(int min, int max, StaticContext env)` Check number of arguments.
`protected abstract void` `checkArguments(StaticContext env)` Method supplied by each class of function to check arguments during parsing, when all the argument expressions have been read
`void` `display(int level, NamePool pool, java.io.PrintStream out)` Diagnostic print of expression structure.
`java.lang.String` `getDisplayName(NamePool pool)` Diagnostic print of expression structure
`int` `getFunctionNameCode()` Get the name code of the function being called
`int` `getNumberOfArguments()` Determine the number of actual arguments supplied in the function call
`java.util.Iterator` `iterateSubExpressions()` Get the immediate subexpressions of this expression
`Expression` `preEvaluate(StaticContext env)` Pre-evaluate a function at compile time.
`Expression` `promote(PromotionOffer offer)` Promote this expression if possible
`void` `setArguments(Expression[] args)` Method called by the expression parser when all arguments have been supplied
`void` `setFunctionNameCode(int nc)` Set the name code of the function being called
`Expression` `simplify(StaticContext env)` Simplify the function call.
`protected Expression` `simplifyArguments(StaticContext env)` Simplify the arguments of the function.

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

`adoptChildExpression, computeCardinality, computeDependencies, computeSpecialProperties, computeStaticProperties, dynamicError, dynamicError, effectiveBooleanValue, evaluateAsString, evaluateItem, getCardinality, getColumnNumber, getConstructType, getDependencies, getExecutable, getImplementationMethod, getInstructionInfo, getIntrinsicDependencies, getLineNumber, getLocationId, getParentExpression, getPublicId, getSpecialProperties, getSystemId, iterate, markTailFunctionCalls, process, resetStaticProperties, setLocationId, setParentExpression, typeError`

Methods inherited from class java.lang.Object
`clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait`

Methods inherited from interface net.sf.saxon.expr.Expression
`getItemType`

Field Detail

### argument

    protected Expression[] argument

  The array of expressions representing the actual parameters to the function call

Constructor Detail

### FunctionCall

    public FunctionCall()

Method Detail

### setFunctionNameCode

    public final void setFunctionNameCode(int nc)

  Set the name code of the function being called

### getFunctionNameCode

    public final int getFunctionNameCode()

  Get the name code of the function being called

  Returns:
    the name code as recorded in the name pool

### getNumberOfArguments

    public final int getNumberOfArguments()

  Determine the number of actual arguments supplied in the function call

### setArguments

    public void setArguments(Expression[] args)

  Method called by the expression parser when all arguments have been supplied

### simplify

    public Expression simplify(StaticContext env)
                        throws XPathException

  Simplify the function call. Default method is to simplify each of the supplied arguments and evaluate the function if all are now known.

  Specified by:
    `simplify` in interface `Expression`
  Overrides:
    `simplify` in class `ComputedExpression`
  Returns:
    the simplified expression
  Throws:
    `XPathException` - if an error is discovered during expression rewriting

### simplifyArguments

    protected final Expression simplifyArguments(StaticContext env)
                                          throws XPathException

  Simplify the arguments of the function. Called from the simplify() method of each function.

  Returns:
    the result of simplifying the arguments of the expression
    `XPathException`

### analyze

    public Expression analyze(StaticContext env,
                              ItemType contextItemType)
                       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.

  Parameters:
    `env` - the static context of the expression
    `contextItemType` - 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 to perform necessary run-time type checks, and to perform other type-related optimizations
    `XPathException`

### preEvaluate

    public Expression preEvaluate(StaticContext env)
                           throws XPathException

  Pre-evaluate a function at compile time. Functions that do not allow pre-evaluation, or that need access to context information, can override this method.

    `XPathException`

### promote

    public Expression promote(PromotionOffer offer)
                       throws XPathException

  Promote this expression if possible

  Specified by:
    `promote` in interface `Expression`
  Overrides:
    `promote` in class `ComputedExpression`
  Parameters:
    `offer` - details of the offer, for example the offer to move expressions that don't depend on the context to an outer level in the containing expression
  Returns:
    if the offer is not accepted, return this expression unchanged. Otherwise return the result of rewriting the expression to promote this subexpression
  Throws:
    `XPathException` - if any error is detected

### checkArguments

    protected abstract void checkArguments(StaticContext env)
                                    throws XPathException

  Method supplied by each class of function to check arguments during parsing, when all the argument expressions have been read

    `XPathException`

### checkArgumentCount

    protected int checkArgumentCount(int min,
                                     int max,
                                     StaticContext env)
                              throws XPathException

  Check number of arguments.
  A convenience routine for use in subclasses.

  Parameters:
    `min` - the minimum number of arguments allowed
    `max` - the maximum number of arguments allowed
  Returns:
    the actual number of arguments
  Throws:
    `XPathException` - if the number of arguments is out of range

### iterateSubExpressions

    public java.util.Iterator iterateSubExpressions()

  Get the immediate subexpressions of this expression

  Specified by:
    `iterateSubExpressions` in interface `Expression`
  Overrides:
    `iterateSubExpressions` in class `ComputedExpression`
  Returns:
    an iterator containing the sub-expressions of this expression

### getDisplayName

    public final java.lang.String getDisplayName(NamePool pool)

  Diagnostic print of expression structure

### display

    public void display(int level,
                        NamePool pool,
                        java.io.PrintStream out)

  Description copied from interface: `Expression`
  Diagnostic print of expression structure. The expression is written to the System.err output stream

  Parameters:
    `level` - indentation level for this expression
    `pool` - NamePool used to expand any names appearing in the expression
    `out` - Output destination