Class UserFunctionCall

    • Constructor Detail

      • UserFunctionCall

        public UserFunctionCall()
        Create a function call to a user-written function in a query or stylesheet
    • Method Detail

      • setStaticType

        public void setStaticType​(SequenceType type)
        Set the static type
        Parameters:
        type - the static type of the result of the function call
      • setFunction

        public void setFunction​(UserFunction compiledFunction)
        Create the reference to the function to be called
        Parameters:
        compiledFunction - the function being called
      • checkFunctionCall

        public void checkFunctionCall​(UserFunction compiledFunction,
                                      ExpressionVisitor visitor)
                               throws XPathException
        Check the function call against the declared function signature
        Parameters:
        compiledFunction - the function being called
        visitor - an expression visitor
        Throws:
        XPathException
      • getFunction

        public UserFunction getFunction()
        Get the function that is being called by this function call
        Returns:
        the function being called
      • isTailCall

        public boolean isTailCall()
        Determine whether this is a tail call (not necessarily a recursive tail call)
        Returns:
        true if this function call is a tail call
      • isRecursiveTailCall

        public boolean isRecursiveTailCall()
      • getArgumentEvaluationModes

        public int[] getArgumentEvaluationModes()
        Get the evaluation modes that have been determined for each of the arguments
        Returns:
        an array of integers representing the evaluation modes, one for each argument
      • preEvaluate

        public Expression preEvaluate​(ExpressionVisitor visitor)
        Pre-evaluate a function at compile time. This version of the method suppresses early evaluation by doing nothing.
        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
      • getItemType

        public ItemType getItemType​(TypeHierarchy th)
        Determine the data type of the expression, if possible
        Specified by:
        getItemType in class Expression
        Parameters:
        th - the type hierarchy cache
        Returns:
        Type.ITEM (meaning not known in advance)
      • getIntrinsicDependencies

        public int getIntrinsicDependencies()
        Description copied from class: Expression
        Determine the intrinsic dependencies of an expression, that is, those which are not derived from the dependencies of its subexpressions. For example, position() has an intrinsic dependency on the context position, while (position()+1) does not. The default implementation of the method returns 0, indicating "no dependencies".
        Overrides:
        getIntrinsicDependencies in class Expression
        Returns:
        a set of bit-significant flags identifying the "intrinsic" dependencies. The flags are documented in class net.sf.saxon.value.StaticProperty
      • isUpdatingExpression

        public boolean isUpdatingExpression()
        Determine whether this is an updating expression as defined in the XQuery update specification
        Overrides:
        isUpdatingExpression in class Expression
        Returns:
        true if this is an updating expression
      • 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
      • copy

        public Expression copy()
        Copy an expression. This makes a deep copy.
        Specified by:
        copy in class Expression
        Returns:
        the copy of the original expression
      • typeCheck

        public Expression typeCheck​(ExpressionVisitor visitor,
                                    ExpressionVisitor.ContextItemType contextItemType)
                             throws XPathException
        Description copied from class: FunctionCall
        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 FunctionCall
        Parameters:
        visitor - an expression visitor
        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
        Throws:
        XPathException - if an error is discovered during this phase (typically a type error)
      • optimize

        public Expression optimize​(ExpressionVisitor visitor,
                                   ExpressionVisitor.ContextItemType contextItemType)
                            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
        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 if appropriate to optimize execution
        Throws:
        XPathException - if an error is discovered during this phase (typically a type error)
      • promote

        public Expression promote​(PromotionOffer offer,
                                  Expression parent)
                           throws XPathException
        Promote this expression if possible
        Overrides:
        promote in class FunctionCall
        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
        parent - the containing expression in the expression tree
        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
      • computeArgumentEvaluationModes

        public void computeArgumentEvaluationModes()
        Compute the evaluation mode of each argument
      • replaceSubExpression

        public boolean replaceSubExpression​(Expression original,
                                            Expression replacement)
        Description copied from class: FunctionCall
        Replace one subexpression by a replacement subexpression
        Overrides:
        replaceSubExpression in class FunctionCall
        Parameters:
        original - the original subexpression
        replacement - the replacement subexpression
        Returns:
        true if the original subexpression is found
      • 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 pathMapNode representing the focus established by this expression, in the case where this expression is the first operand of a path expression or filter 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.
      • markTailFunctionCalls

        public int markTailFunctionCalls​(StructuredQName qName,
                                         int arity)
        Mark tail-recursive calls on stylesheet functions. This marks the function call as tailRecursive if if is a call to the containing function, and in this case it also returns "true" to the caller to indicate that a tail call was found.
        Overrides:
        markTailFunctionCalls in class Expression
        Parameters:
        qName - the name of the function
        arity - the arity (number of parameters) of the function
        Returns:
        NOT_TAIL_CALL if no tail call was found; FOREIGN_TAIL_CALL if a tail call on a different function was found;
      • getImplementationMethod

        public int getImplementationMethod()
        Description copied from class: Expression
        An implementation of Expression must provide at least one of the methods evaluateItem(), iterate(), or process(). This method indicates which of these methods is provided directly. The other methods will always be available indirectly, using an implementation that relies on one of the other methods.
        Overrides:
        getImplementationMethod in class Expression
        Returns:
        the implementation method, for example Expression.ITERATE_METHOD or Expression.EVALUATE_METHOD or Expression.PROCESS_METHOD
      • evaluateItem

        public Item evaluateItem​(XPathContext c)
                          throws XPathException
        Call the function, returning the value as an item. This method will be used only when the cardinality is zero or one. If the function is tail recursive, it returns an Object representing the arguments to the next (recursive) call
        Overrides:
        evaluateItem in class Expression
        Parameters:
        c - The context in which the expression is to be evaluated
        Returns:
        the node or atomic value that results from evaluating the expression; or null to indicate that the result is an empty sequence
        Throws:
        XPathException - if any dynamic error occurs evaluating the expression
      • iterate

        public SequenceIterator iterate​(XPathContext c)
                                 throws XPathException
        Call the function, returning an iterator over the results. (But if the function is tail recursive, it returns an iterator over the arguments of the recursive call)
        Overrides:
        iterate in class Expression
        Parameters:
        c - supplies the context for evaluation
        Returns:
        a SequenceIterator that can be used to iterate over the result of the expression
        Throws:
        XPathException - if any dynamic error occurs evaluating the expression
      • evaluatePendingUpdates

        public void evaluatePendingUpdates​(XPathContext context,
                                           PendingUpdateList pul)
                                    throws XPathException
        Evaluate an updating expression, adding the results to a Pending Update List. The default implementation of this method, which is used for non-updating expressions, throws an UnsupportedOperationException
        Overrides:
        evaluatePendingUpdates in class Expression
        Parameters:
        context - the XPath dynamic evaluation context
        pul - the pending update list to which the results should be written
        Throws:
        XPathException - if evaluation fails
      • dynamicCall

        public ValueRepresentation dynamicCall​(ValueRepresentation[] suppliedArguments,
                                               XPathContext context)
                                        throws XPathException
        Call the function dynamically. For this to be possible, the static arguments of the function call must have been set up as SuppliedParameterReference objects. The actual arguments are placed on the callee's stack, and the type conversion takes place "in situ".
        Parameters:
        suppliedArguments - the values to be used for the arguments of the function
        context - the dynamic evaluation context
        Returns:
        the result of evaluating the function
        Throws:
        XPathException
      • explain

        public void explain​(ExpressionPresenter out)
        Diagnostic print of expression structure. The abstract expression tree is written to the supplied output destination.
        Overrides:
        explain in class FunctionCall
        Parameters:
        out - the expression presenter used to display the structure
      • getProperty

        public java.lang.Object getProperty​(java.lang.String name)
        Description copied from interface: InstructionInfo
        Get the value of a particular property of the instruction. Properties of XSLT instructions are generally known by the name of the stylesheet attribute that defines them.
        Specified by:
        getProperty in interface InstructionInfo
        Overrides:
        getProperty in class Expression
        Parameters:
        name - The name of the required property
        Returns:
        The value of the requested property, or null if the property is not available
      • getObjectName

        public StructuredQName getObjectName()
        Description copied from interface: InstructionInfo
        Get a name identifying the object of the expression, for example a function name, template name, variable name, key name, element name, etc. This is used only where the name is known statically.
        Specified by:
        getObjectName in interface InstructionInfo
        Overrides:
        getObjectName in class Expression
        Returns:
        the QName of the object declared or manipulated by this instruction or expression
      • getLineNumber

        public int getLineNumber​(long locationId)
        Get the line number within the document or module containing a particular location
        Specified by:
        getLineNumber in interface LocationProvider
        Overrides:
        getLineNumber in class Expression
        Parameters:
        locationId - identifier of the location in question (as passed down the Receiver pipeline)
        Returns:
        the line number within the document or module.
      • getSystemId

        public java.lang.String getSystemId​(long locationId)
        Get the URI of the document or module containing a particular location
        Specified by:
        getSystemId in interface LocationProvider
        Overrides:
        getSystemId in class Expression
        Parameters:
        locationId - identifier of the location in question (as passed down the Receiver pipeline)
        Returns:
        the URI of the document or module.