com.saxonica.expr

Class XPathParserPE

java.lang.Object

net.sf.saxon.expr.parser.XPathParser

com.saxonica.expr.XPathParserPE

Direct Known Subclasses:

PatternParser30

public class XPathParserPE
extends XPathParser

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.

This contains code duplicated with the XQuery3.0 parser. This is handled by putting the common code into static methods of this class, which are invoked from both the EnterpriseXPathParser and the EnterpriseXQueryParser.

Nested Class Summary

Nested Classes

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

Nested classes/interfaces inherited from class net.sf.saxon.expr.parser.XPathParser

XPathParser.TemporaryContainer

Field Summary

Fields inherited from class net.sf.saxon.expr.parser.XPathParser

allowXPath30Syntax, catchDepth, charChecker, codeInjector, defaultContainer, env, language, rangeVariables, scanOnly, SEQUENCE_TYPE, t, XPATH, XQUERY, XSLT_PATTERN

Constructor Summary

Constructors

Constructor and Description
XPathParserPE()

Method Summary

Methods

Modifier and Type	Method and Description
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, Stack<XPathParserPE.InlineFunctionDetails> inlineFunctionStack, StaticContext env)
protected LocalBinding	findRangeVariable(StructuredQName qName) Locate a range variable with a given name.
protected Expression	makeCurriedFunction(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	makeCurriedFunction(XPathParser parser, StaticContext env, int offset, StructuredQName name, Expression[] args, IntSet placeMarkers)
protected Expression	parseDynamicFunctionCall(Expression functionItem) Parse a dynamic function call
static Expression	parseDynamicFunctionCall(Expression functionItem, XPathParser p)
Expression	parseFunctionArgument() Parse a function argument.
ItemType	parseFunctionItemType() 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
static ItemType	parseFunctionItemType(XPathParser p)
protected Expression	parseInlineFunction(Map<StructuredQName,Annotation> annotations) Parse an inline function "function" "(" ParamList? ")" ("as" SequenceType)? EnclosedExpr On entry, "function (" has already been read
static Expression	parseInlineFunction(XPathParser p, Stack<XPathParserPE.InlineFunctionDetails> inlineFunctionStack, Map<StructuredQName,Annotation> annotations)
protected Expression	parseLiteralFunctionItem() Parse a literal function item (introduced in XQuery 3.0 and XPath 3.0) Syntax: QName # integer The QName and # have already been read
static Expression	parseLiteralFunctionItem(XPathParser p) Parse a literal function item (function#arity).
protected Expression	parseMapExpression() Parse a map expression.
protected static Expression	parseMapExpression(XPathParser parser)
ItemType	parseMapItemType() Parse the item type used for maps (XSLT extension to XPath 3.0) Syntax: map '(' '*' ') | map '(' ItemType ',' SeqType ')' 'as' SeqType The "map(" has already been read
static ItemType	parseMapItemType(XPathParser p)

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

atStartOfRelativePath, currentTokenDisplay, customizeTokenizer, declareRangeVariable, disallowedAtStartOfRelativePath, expect, getCodeInjector, getDefaultContainer, getLanguage, getMissingFunctionExplanation, getRangeVariables, getStaticContext, getTokenizer, grumble, grumble, grumble, grumble, isKeyword, isNamespaceTestAllowed, isReservedInQuery, makeLocalNameTest, makeNameCode, makeNamespaceTest, makeNameTest, makeNodeName, makeStringLiteral, makeStructuredQName, makeStructuredQNameSilently, makeTracer, nextToken, normalizeEQName, parse, parseAnnotations, parseBasicStep, parseBinaryExpression, parseConstructor, parseExpression, parseExprSingle, parseExtensionExpression, parseFLWORExpression, parseFunctionCall, parseItemType, parseNodeTest, parseNumericLiteral, parsePathExpression, parsePredicate, parseRelativePath, parseRemainingPath, parseSequenceType, parseSequenceType, parseSimpleMappingExpression, parseStepExpression, parseStringLiteral, parseSwitchExpression, parseTryCatchExpression, parseTypeswitchExpression, parseValidateExpression, parseVariableReference, reportMissingFunction, resolveFunctionName, setCodeInjector, setDefaultContainer, setLanguage, setLocation, setLocation, setLocation, setRangeVariables, setRangeVariableStack, setScanOnly, testPermittedAxis, undeclareRangeVariable, warning

Methods inherited from class java.lang.Object

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

Constructor Detail

XPathParserPE

public XPathParserPE()

Method Detail

parseLiteralFunctionItem

protected Expression parseLiteralFunctionItem()
                                       throws XPathException

Parse a literal function item (introduced in XQuery 3.0 and XPath 3.0) Syntax: QName # integer The QName and # have already been read

Overrides:

parseLiteralFunctionItem in class XPathParser

Returns:

an ExternalObject representing the function item

Throws:

XPathException - if a static error is encountered

parseLiteralFunctionItem

public static Expression parseLiteralFunctionItem(XPathParser p)
                                           throws XPathException

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

Parameters:

p - the parser

Returns:

an expression representing the function value

Throws:

XPathException - in the event of a syntax error

parseFunctionItemType

public ItemType parseFunctionItemType()
                               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 XPathParser

Returns:

the item type representing a function item

Throws:

XPathException - if a static error occurs (including the case where XPath 3.0 syntax is not enabled)

parseFunctionItemType

public static ItemType parseFunctionItemType(XPathParser p)
                                      throws XPathException

Throws:

XPathException

parseFunctionArgument

public Expression parseFunctionArgument()
                                 throws XPathException

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

Overrides:

parseFunctionArgument in class XPathParser

Returns:

the Expression used as the argument, or null if the argument is the place-holder "?"

Throws:

XPathException - if the argument expression does not parse correctly

parseMapItemType

public ItemType parseMapItemType()
                          throws XPathException

Parse the item type used for maps (XSLT extension to XPath 3.0) Syntax: map '(' '*' ') | map '(' ItemType ',' SeqType ')' 'as' SeqType The "map(" has already been read

Overrides:

parseMapItemType in class XPathParser

Returns:

the item type of the map

Throws:

XPathException - if a parsing error occurs or if the map syntax is not available

parseMapItemType

public static ItemType parseMapItemType(XPathParser p)
                                 throws XPathException

Throws:

XPathException

parseDynamicFunctionCall

protected Expression parseDynamicFunctionCall(Expression functionItem)
                                       throws XPathException

Parse a dynamic function call

Overrides:

parseDynamicFunctionCall in class XPathParser

Parameters:

functionItem - the expression that determines the function to be called

Returns:

the expression that results from the parsing

Throws:

XPathException - if a static error is found

parseDynamicFunctionCall

public static Expression parseDynamicFunctionCall(Expression functionItem,
                                  XPathParser p)
                                           throws XPathException

Throws:

XPathException

parseInlineFunction

protected Expression parseInlineFunction(Map<StructuredQName,Annotation> annotations)
                                  throws XPathException

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

Overrides:

parseInlineFunction in class XPathParser

Parameters:

annotations - the function annotations, which have already been read, or null if there are none

Returns:

the parsed inline function

Throws:

XPathException - if a syntax error is found

parseInlineFunction

public static Expression parseInlineFunction(XPathParser p,
                             Stack<XPathParserPE.InlineFunctionDetails> inlineFunctionStack,
                             Map<StructuredQName,Annotation> annotations)
                                      throws XPathException

Throws:

XPathException

makeCurriedFunction

protected Expression makeCurriedFunction(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 XPathParser

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

Returns:

the curried function

Throws:

XPathException

makeCurriedFunction

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

Throws:

XPathException

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

parseMapExpression

protected Expression parseMapExpression()
                                 throws XPathException

Parse a map expression. Requires XPath/XQuery 3.0 Provisional syntax map { expr := expr (, expr := expr )*} }

Overrides:

parseMapExpression in class XPathParser

Returns:

the map expression

Throws:

XPathException

parseMapExpression

protected static Expression parseMapExpression(XPathParser parser)
                                        throws XPathException

Throws:

XPathException

findRangeVariable

protected LocalBinding findRangeVariable(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:

findRangeVariable in class XPathParser

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,
                                  Stack<XPathParserPE.InlineFunctionDetails> inlineFunctionStack,
                                  StaticContext env)