Package net.sf.saxon.pattern

Class PatternParser

java.lang.Object

net.sf.saxon.expr.parser.XPathParser

net.sf.saxon.pattern.PatternParser

public class PatternParser
extends XPathParser

Parser for XSLT patterns. This is created by overriding selected parts of the standard ExpressionParser.

Nested Class Summary

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

XPathParser.Accelerator, XPathParser.InlineFunctionDetails, XPathParser.NestedLocation, XPathParser.ParsedLanguage

Field Summary

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

allowSaxonExtensions, allowXPath30XSLTExtensions, catchDepth, charChecker, codeInjector, env, inlineFunctionStack, language, languageVersion, parserExtension, qNameParser, rangeVariables, scanOnly, t

Constructor Summary

Constructors

Constructor	Description
PatternParser(StaticContext env)

Method Summary

Modifier and Type	Method	Description
protected void	checkAllowedFunctionArgument(Expression arg)
protected void	customizeTokenizer(Tokenizer t)	Callback to tailor the tokenizer
protected boolean	isAllowArgumentKeywords()
Expression	makeTracer(Expression exp, StructuredQName qName)	If tracing, wrap an expression in a trace instruction
protected void	notAllowedInPattern()
protected Expression	parseBasicStep(boolean firstInPattern)	Parse a basic step expression (without the predicates)
Expression	parseExpression()	Override the parsing of top-level expressions
Expression	parseFunctionArgument()	Parse an argument to a function call.
Expression	parseFunctionCall(String fname, Expression prefixArgument)	Parse a function call appearing within a pattern.
Pattern	parseIntersectExceptPattern(boolean topLevel, StaticContext env)
Expression	parseParenthesizedExpression()
Pattern	parsePattern(String pattern, StaticContext env)	Parse a string representing an XSLT pattern
protected Expression	parsePredicate()	Parse an expression appearing within a predicate.
Pattern	parsePredicatePattern()
Pattern	parseUnionPattern(boolean topLevel, StaticContext env)
protected void	testPermittedAxis(int axis, String errorCode)

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

atStartOfRelativePath, checkLanguageVersion30, checkLanguageVersion31, checkLanguageVersion40, checkLanguageVersion40, checkMapExtensions, checkSyntaxExtensions, currentTokenDisplay, declareRangeVariable, expect, expectKeyword, expectName, expectStringLiteral, findOuterRangeVariable, findOuterRangeVariable, findRangeVariable, gatherComponents, getCodeInjector, getLanguage, getMissingFunctionExplanation, getOffsetAfterParsing, getPlainType, getQNameParser, getRangeVariables, getStaticContext, getTokenizer, grumble, grumble, grumble, grumble, grumble, handleExternalFunctionDeclaration, isAllowAbsentExpression, isAllowXPath31Syntax, isAllowXPath40Syntax, isKeyword, isKeyword, isKeywordPair, isMaybeNamedConstructor, isNamespaceTestAllowed, isReservedFunctionName, isReservedInQuery, makeFingerprint, makeInlineFunctionValue, makeLocalQNameTest, makeLocation, makeLocation, makeLookupExpression, makeNamedFunctionReference, makeNamespaceQNameTest, makeNameTest, makeNestedLocation, makeNodeName, makeQNameTest, makeStringLiteral, makeStructuredQName, makeStructuredQNameSilently, nextToken, parse, parseAnnotationsList, parseArrayCurlyConstructor, parseArrayItemType, parseArraySquareConstructor, parseArrowPostfix, parseBinaryExpression, parseComputedNodeConstructor, parseConstant, parseDeepUpdateExpression, parseDirectElementConstructor, parseDirectPIConstructor, parseDynamicFunctionCall, parseEnumType, parseEQName, parseExprSingle, parseExtendedSequenceType, parseExtensionExpression, parseFilterExprAM, parseFLWORExpression, parseFocusFunction, parseFunctionItemType, parseInlineFunction, parseInlineFunctionBody, parseItemType, parseItemType, parseLookup, parseMapConstructor, parseMapItemType, parseMappingArrowPostfix, parseMethodCall, parseNamedFunctionReference, parseNameTestUnion, parseNodeTest, parseNumericLiteral, parseOccurrenceIndicator, parsePathExpression, parsePredicate, parseRelativePath, parseRemainingPath, parseSequenceType, parseSequenceType, parseSimpleMappingExpression, parseStepExpression, parseStringConstructor, parseStringLiteral, parseStringTemplate, parseSwitchExpression, parseTryCatchExpression, parseTypeswitchExpression, parseUnionNodeTest, parseValidateExpression, readKeyword, readName, readOptionalAsClause, readToken, readVariableName, reportMissingFunction, requireXQuery, resolveFunctionName, resolveVariableReference, setAccelerator, setAllowAbsentExpression, setCatchDepth, setCodeInjector, setLanguage, setLocation, setLocation, setLocation, setParserExtension, setQNameParser, setRangeVariables, setRangeVariableStack, setScanOnly, tryKeyword, tryKeywordPair, undeclareRangeVariable, unescape, warning, whyDisallowedType

Methods inherited from class java.lang.Object

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

Constructor Details

PatternParser

public PatternParser(StaticContext env)

Method Details

parsePattern

public Pattern parsePattern(String pattern,
 StaticContext env)
                     throws XPathException

Parse a string representing an XSLT pattern

Parameters:

pattern - the pattern expressed as a String

env - the static context for the pattern

Returns:

a Pattern object representing the result of parsing

Throws:

XPathException - if the pattern contains a syntax error

parseUnionPattern

public Pattern parseUnionPattern(boolean topLevel,
 StaticContext env)
                          throws XPathException

Throws:

XPathException

parseIntersectExceptPattern

public Pattern parseIntersectExceptPattern(boolean topLevel,
 StaticContext env)
                                    throws XPathException

Throws:

XPathException

notAllowedInPattern

protected void notAllowedInPattern()
                            throws XPathException

Overrides:

notAllowedInPattern in class XPathParser

Throws:

XPathException

parsePredicatePattern

public Pattern parsePredicatePattern()
                              throws XPathException

Throws:

XPathException

parseParenthesizedExpression

public Expression parseParenthesizedExpression()
                                        throws XPathException

Overrides:

parseParenthesizedExpression in class XPathParser

Throws:

XPathException

customizeTokenizer

protected void customizeTokenizer(Tokenizer t)

Callback to tailor the tokenizer

Overrides:

customizeTokenizer in class XPathParser

Parameters:

t - the Tokenizer to be customized

parseExpression

public Expression parseExpression()
                           throws XPathException

Override the parsing of top-level expressions

Overrides:

parseExpression in class XPathParser

Returns:

the parsed expression

Throws:

XPathException - if the pattern is invalid

parseBasicStep

protected Expression parseBasicStep(boolean firstInPattern)
                             throws XPathException

Parse a basic step expression (without the predicates)

Overrides:

parseBasicStep in class XPathParser

Parameters:

firstInPattern - true only if we are parsing the first step in a RelativePathPattern in the XSLT Pattern syntax

Returns:

the resulting subexpression

Throws:

XPathException - if any error is encountered

isAllowArgumentKeywords

protected boolean isAllowArgumentKeywords()

Overrides:

isAllowArgumentKeywords in class XPathParser

checkAllowedFunctionArgument

protected void checkAllowedFunctionArgument(Expression arg)
                                     throws XPathException

Overrides:

checkAllowedFunctionArgument in class XPathParser

Throws:

XPathException

testPermittedAxis

protected void testPermittedAxis(int axis,
 String errorCode)
                          throws XPathException

Overrides:

testPermittedAxis in class XPathParser

Throws:

XPathException

parsePredicate

protected Expression parsePredicate()
                             throws XPathException

Parse an expression appearing within a predicate. This enables full XPath parsing, without the normal rules that apply within an XSLT pattern

Overrides:

parsePredicate in class XPathParser

Returns:

the parsed expression that appears within the predicate

Throws:

XPathException - if the predicate is invalid

parseFunctionCall

public Expression parseFunctionCall(String fname,
 Expression prefixArgument)
                             throws XPathException

Parse a function call appearing within a pattern. Unless within a predicate, this imposes the constraints on which function calls are allowed to appear in a pattern

Overrides:

parseFunctionCall in class XPathParser

Parameters:

prefixArgument - left hand operand of arrow operator, or null in the case of a conventional function call

Returns:

the expression that results from the parsing (usually a FunctionCall)

Throws:

XPathException - if the function call is invalid

parseFunctionArgument

public Expression parseFunctionArgument()
                                 throws XPathException

Description copied from class: XPathParser

Parse an argument to a function call. Separate method so it can be overridden. With higher-order-function syntax in XPath 3.0/XQuery 3.0, this returns null if the pseudo-argument "?" is found.

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

makeTracer

public Expression makeTracer(Expression exp,
 StructuredQName qName)

Description copied from class: XPathParser

If tracing, wrap an expression in a trace instruction

NB, this no longer happens. Instead of creating trace expressions in the course of parsing and buildint the expression tree, trace code is now injected into the tree after the event, when parsing is complete. See ExpressionTool.injectCode(Expression, CodeInjector).

However, the method has another effect, which is to set the retainedStaticContext in the node in the expression tree.

Overrides:

makeTracer in class XPathParser

Parameters:

exp - the expression to be wrapped

qName - the name of the construct (if applicable)

Returns:

the expression that does the tracing