com.saxonica.expr

Class HofParserExtension

java.lang.Object

net.sf.saxon.expr.parser.ParserExtension

com.saxonica.expr.HofParserExtension

Direct Known Subclasses:

XQueryParserExtensionPE

public class HofParserExtension
extends ParserExtension

Parser extension for syntax in XPath that is accepted only in Saxon-PE and -EE. Primarily, this means XPath 3.0 syntax associated with higher-order functions.

Nested Class Summary

Nested Classes

Modifier and Type	Class and Description
static class	HofParserExtension.InlineFunctionDetails
static class	HofParserExtension.TemporaryXSLTVariableBinding

Field Summary

Fields

Modifier and Type	Field and Description
protected java.util.Stack<HofParserExtension.InlineFunctionDetails>	inlineFunctionStack

Constructor Summary

Constructors

Constructor and Description
HofParserExtension()

Method Summary

Modifier and Type	Method and Description
Expression	createDynamicCurriedFunction(XPathParser p, Expression functionItem, java.util.ArrayList<Expression> args, IntSet placeMarkers)
static Expression	curryFunction(Expression functionExp, Expression[] args, IntSet placeMarkers) Process a function expression in which one or more of the argument positions are represented as "?" placemarkers (indicating partial application or currying)
static LocalBinding	findOuterRangeVariable(StructuredQName qName, java.util.Stack<HofParserExtension.InlineFunctionDetails> inlineFunctionStack, StaticContext env) When a variable reference occurs within an inline function, it might be a reference to a variable declared outside the inline function (which needs to become part of the closure).
LocalBinding	findOuterRangeVariable(XPathParser p, StructuredQName qName) Locate a range variable with a given name.
void	handleExternalFunctionDeclaration(XQueryParser p, XQueryFunction func)
Expression	makeArgumentPlaceMarker(XPathParser p) Parse a function argument.
Expression	makeCurriedFunction(XPathParser parser, int offset, StructuredQName name, Expression[] args, IntSet placeMarkers) Process a function call in which one or more of the argument positions are represented as "?" placemarkers (indicating partial application or currying)
static Expression	makeInlineFunctionValue(XPathParser p, AnnotationList annotations, HofParserExtension.InlineFunctionDetails details, java.util.List<UserFunctionParameter> params, SequenceType resultType, Expression body)
ItemType	parseExtendedItemType(XPathParser p) Parse an ItemType within a SequenceType
ItemType	parseFunctionItemType(XPathParser p, AnnotationList annotations) Parse the item type used for function items (XQuery 3.0 higher order functions) Syntax (changed by WG decision on 2009-09-22): function '(' '*' ') | function '(' (SeqType (',' SeqType)*)? ')' 'as' SeqType For backwards compatibility with Saxon 9.2 we allow the "*" to be omitted for the time being The "function(" has already been read
protected Expression	parseInlineFunction(XPathParser p, AnnotationList annotations) Parse an inline function "function" "(" ParamList? ")" ("as" SequenceType)? EnclosedExpr On entry, "function (" has already been read
Expression	parseNamedFunctionReference(XPathParser p) Parse a literal function item (function#arity).
Expression	parseSimpleInlineFunction(XPathParser p)
Expression	parseTildePattern(XPathParser p) Parse an extended XSLT pattern in the form ~type-alias (predicate)* (but excluding the predicates)
ItemType	parseUnionType(XPathParser p) Parse a union type (Saxon 9.8 extension).

Methods inherited from class net.sf.saxon.expr.parser.ParserExtension

parseExtendedExprSingle, parseRevalidationDeclaration, parseTypeAliasDeclaration, parseUpdatingFunctionDeclaration

Methods inherited from class java.lang.Object

clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Field Detail

inlineFunctionStack

protected java.util.Stack<HofParserExtension.InlineFunctionDetails> inlineFunctionStack

Constructor Detail

HofParserExtension

public HofParserExtension()

Method Detail

parseNamedFunctionReference

public Expression parseNamedFunctionReference(XPathParser p)
                                       throws XPathException

Parse a literal function item (function#arity). On entry, the function name and the '#' token have already been read

Overrides:

parseNamedFunctionReference in class ParserExtension

Parameters:

p - the parser

Returns:

an expression representing the function value

Throws:

XPathException - in the event of a syntax error

parseFunctionItemType

public ItemType parseFunctionItemType(XPathParser p,
                                      AnnotationList annotations)
                               throws XPathException

Parse the item type used for function items (XQuery 3.0 higher order functions) Syntax (changed by WG decision on 2009-09-22): function '(' '*' ') | function '(' (SeqType (',' SeqType)*)? ')' 'as' SeqType For backwards compatibility with Saxon 9.2 we allow the "*" to be omitted for the time being The "function(" has already been read

Overrides:

parseFunctionItemType in class ParserExtension

Parameters:

annotations - the list of annotation assertions for this function item type

Throws:

XPathException

parseExtendedItemType

public ItemType parseExtendedItemType(XPathParser p)
                               throws XPathException

Parse an ItemType within a SequenceType

Overrides:

parseExtendedItemType in class ParserExtension

Returns:

the ItemType after parsing

Throws:

XPathException - if a static error is found

parseTildePattern

public Expression parseTildePattern(XPathParser p)
                             throws XPathException

Parse an extended XSLT pattern in the form ~type-alias (predicate)* (but excluding the predicates)

Overrides:

parseTildePattern in class ParserExtension

Returns:

the equivalent expression in the form .[. instance of type] (predicate)*

Throws:

XPathException

parseUnionType

public ItemType parseUnionType(XPathParser p)
                        throws XPathException

Parse a union type (Saxon 9.8 extension). Syntax: "union" "(" qname ("," qname)* ")"

Throws:

XPathException

makeArgumentPlaceMarker

public Expression makeArgumentPlaceMarker(XPathParser p)

Parse a function argument. The special marker "?" is allowed and causes "null" to be returned

Overrides:

makeArgumentPlaceMarker in class ParserExtension

parseInlineFunction

protected Expression parseInlineFunction(XPathParser p,
                                         AnnotationList annotations)
                                  throws XPathException

Description copied from class: ParserExtension

Parse an inline function "function" "(" ParamList? ")" ("as" SequenceType)? EnclosedExpr On entry, "function (" has already been read

Overrides:

parseInlineFunction in class ParserExtension

Throws:

XPathException - if a syntax error is found

makeInlineFunctionValue

public static Expression makeInlineFunctionValue(XPathParser p,
                                                 AnnotationList annotations,
                                                 HofParserExtension.InlineFunctionDetails details,
                                                 java.util.List<UserFunctionParameter> params,
                                                 SequenceType resultType,
                                                 Expression body)

parseSimpleInlineFunction

public Expression parseSimpleInlineFunction(XPathParser p)
                                     throws XPathException

Overrides:

parseSimpleInlineFunction in class ParserExtension

Throws:

XPathException

makeCurriedFunction

public Expression makeCurriedFunction(XPathParser parser,
                                      int offset,
                                      StructuredQName name,
                                      Expression[] args,
                                      IntSet placeMarkers)
                               throws XPathException

Process a function call in which one or more of the argument positions are represented as "?" placemarkers (indicating partial application or currying)

Overrides:

makeCurriedFunction in class ParserExtension

Parameters:

offset - offset in the query source of the start of the expression

name - the function call (as if there were no currying)

args - the arguments (with EmptySequence in the placemarker positions)

placeMarkers - the positions of the placemarkers @return the curried function

Throws:

XPathException - if a dynamic error occurs

curryFunction

public static Expression curryFunction(Expression functionExp,
                                       Expression[] args,
                                       IntSet placeMarkers)

Process a function expression in which one or more of the argument positions are represented as "?" placemarkers (indicating partial application or currying)

Parameters:

functionExp - an expression that returns the function to be curried

args - the arguments (with EmptySequence in the placemarker positions)

placeMarkers - the positions of the placemarkers

Returns:

the curried function

findOuterRangeVariable

public LocalBinding findOuterRangeVariable(XPathParser p,
                                           StructuredQName qName)

Locate a range variable with a given name. (By "range variable", we mean a variable declared within the expression where it is used.)

Overrides:

findOuterRangeVariable in class ParserExtension

Parameters:

qName - identifies the name of the range variable

Returns:

null if not found (this means the variable is probably a context variable); otherwise the relevant RangeVariable

findOuterRangeVariable

public static LocalBinding findOuterRangeVariable(StructuredQName qName,
                                                  java.util.Stack<HofParserExtension.InlineFunctionDetails> inlineFunctionStack,
                                                  StaticContext env)

When a variable reference occurs within an inline function, it might be a reference to a variable declared outside the inline function (which needs to become part of the closure). This code looks for such an outer variable

Parameters:

qName - the name of the variable

inlineFunctionStack - the stack of inline functions that we are within

env - the static context

Returns:

a binding for the variable; this will typically be a binding to a newly added parameter for the innermost function in which the variable reference appears. As a side effect, all the inline functions between the declaration of the variable and its use will have this variable as an additional parameter, each one bound to the corresponding parameter in the containing function.

createDynamicCurriedFunction

public Expression createDynamicCurriedFunction(XPathParser p,
                                               Expression functionItem,
                                               java.util.ArrayList<Expression> args,
                                               IntSet placeMarkers)

Overrides:

createDynamicCurriedFunction in class ParserExtension

handleExternalFunctionDeclaration

public void handleExternalFunctionDeclaration(XQueryParser p,
                                              XQueryFunction func)
                                       throws XPathException

Overrides:

handleExternalFunctionDeclaration in class ParserExtension

Throws:

XPathException