net.sf.saxon.expr

Class ExpressionParser

public class ExpressionParser extends Object

Parser for XPath expressions and XSLT patterns. This code was originally inspired by James Clark's xt but has been totally rewritten (several times)

Author: Michael Kay

Nested Class Summary
static classExpressionParser.ForClause
protected static classExpressionParser.TemporaryContainer
Field Summary
protected StaticContextenv
protected intlanguage
protected NameCheckernameChecker
protected StackrangeVariables
protected booleanscanOnly
protected static intSEQUENCE_TYPE
protected Tokenizert
protected static intXPATH
protected static intXQUERY
protected static intXSLT_PATTERN
Constructor Summary
ExpressionParser()
Method Summary
protected StringcurrentTokenDisplay()
Display the current token in an error message
protected voiddeclareRangeVariable(VariableDeclaration declaration)
Declare a range variable (record its existence within the parser).
protected voidexpect(int token)
Expect a given token; fail if the current token is different.
protected StringgetLanguage()
Get the current language (XPath or XQuery)
StackgetRangeVariableStack()
Get the range variable stack.
TokenizergetTokenizer()
protected voidgrumble(String message)
Report a syntax error (a static error with error code XP0003)
protected voidgrumble(String message, String errorCode)
Report a static error
protected booleanisKeyword(String s)
Test whether the current token is a given keyword.
LocalNameTestmakeLocalNameTest(short nodeType, String localName)
Make a LocalNameTest (*:name)
intmakeNameCode(String qname, boolean useDefault)
Make a NameCode, using this Element as the context for namespace resolution
NamespaceTestmakeNamespaceTest(short nodeType, String prefix)
Make a NamespaceTest (name:*)
NameTestmakeNameTest(short nodeType, String qname, boolean useDefault)
Make a NameTest, using the static context for namespace resolution
protected StringValuemakeStringLiteral(String currentTokenValue)
Method to make a string literal from a token identified as a string literal.
protected ExpressionmakeTracer(int startOffset, Expression exp, int construct, int objectNameCode)
If tracing, wrap an instruction in a trace instruction
protected voidnextToken()
Read the next token, catching any exception thrown by the tokenizer
Expressionparse(String expression, int start, int terminator, int lineNumber, StaticContext env)
Parse a string representing an expression
protected ExpressionparseConstructor()
Parse a node constructor.
protected ExpressionparseExpression()
Parse a top-level Expression: ExprSingle ( ',' ExprSingle )*
protected ExpressionparseExprSingle()
Parse an ExprSingle
protected ExpressionparseExtensionExpression()
Parse an Extension Expression This construct is XQuery-only, so the XPath version of this method throws an error unconditionally
protected ExpressionparseForExpression()
Parse a FOR expression: for $x in expr (',' $y in expr)* 'return' expr
protected ExpressionparseMappingExpression()
Parse a mapping expression.
protected NodeTestparseNodeTest(short nodeType)
Parse a NodeTest.
PatternparsePattern(String pattern, StaticContext env)
Parse a string representing an XSLT pattern
protected ExpressionparseRelativePath()
Parse a relative path (a sequence of steps).
protected ExpressionparseRemainingPath(Expression start)
Parse the remaining steps of an absolute path expression (one starting in "/" or "//").
SequenceTypeparseSequenceType(String input, StaticContext env)
Parse a string representing a sequence type
protected SequenceTypeparseSequenceType()
Parse the sequence type production.
protected ExpressionparseStepExpression()
Parse a step (including an optional sequence of predicates)
protected ExpressionparseTypeswitchExpression()
Parse a Typeswitch Expression.
protected ExpressionparseValidateExpression()
Parse a Validate Expression.
protected voidsetLocation(Expression exp)
Set location information on an expression.
protected voidsetLocation(Expression exp, int offset)
Set location information on an expression.
voidsetRangeVariableStack(Stack stack)
Set the range variable stack.
voidsetScanOnly(boolean scanOnly)
protected voidundeclareRangeVariable()
Note when the most recently declared range variable has gone out of scope
protected voidwarning(String message)
Output a warning message

Field Detail

env

protected StaticContext env

language

protected int language

nameChecker

protected NameChecker nameChecker

rangeVariables

protected Stack rangeVariables

scanOnly

protected boolean scanOnly

SEQUENCE_TYPE

protected static final int SEQUENCE_TYPE

t

protected Tokenizer t

XPATH

protected static final int XPATH

XQUERY

protected static final int XQUERY

XSLT_PATTERN

protected static final int XSLT_PATTERN

Constructor Detail

ExpressionParser

public ExpressionParser()

Method Detail

currentTokenDisplay

protected String currentTokenDisplay()
Display the current token in an error message

Returns: the display representation of the token

declareRangeVariable

protected void declareRangeVariable(VariableDeclaration declaration)
Declare a range variable (record its existence within the parser). A range variable is a variable declared within an expression, as distinct from a variable declared in the context.

Parameters: declaration the VariableDeclaration to be added to the stack

Throws: net.sf.saxon.trans.StaticError if any error is encountered

expect

protected void expect(int token)
Expect a given token; fail if the current token is different. Note that this method does not read any tokens.

Parameters: token the expected token

Throws: net.sf.saxon.trans.StaticError if the current token is not the expected token

getLanguage

protected String getLanguage()
Get the current language (XPath or XQuery)

getRangeVariableStack

public Stack getRangeVariableStack()
Get the range variable stack. Used when parsing a nested subexpression inside an attribute constructor

getTokenizer

public Tokenizer getTokenizer()

grumble

protected void grumble(String message)
Report a syntax error (a static error with error code XP0003)

Parameters: message the error message

Throws: net.sf.saxon.trans.StaticError always thrown: an exception containing the supplied message

grumble

protected void grumble(String message, String errorCode)
Report a static error

Parameters: message the error message errorCode the error code

Throws: net.sf.saxon.trans.StaticError always thrown: an exception containing the supplied message

isKeyword

protected boolean isKeyword(String s)
Test whether the current token is a given keyword.

Parameters: s The string to be compared with the current token

Returns: true if they are the same

makeLocalNameTest

public LocalNameTest makeLocalNameTest(short nodeType, String localName)
Make a LocalNameTest (*:name)

Parameters: nodeType the kind of node to be matched localName the requred local name

Returns: a LocalNameTest, a pattern which matches all nodes of a given local name, regardless of namespace

Throws: net.sf.saxon.trans.StaticError if the local name is invalid

makeNameCode

public final int makeNameCode(String qname, boolean useDefault)
Make a NameCode, using this Element as the context for namespace resolution

Parameters: qname The name as written, in the form "[prefix:]localname" useDefault Defines the action when there is no prefix. If true, use the default namespace URI for element names. If false, use no namespace URI (as for attribute names).

Returns: the namecode, which can be used to identify this name in the name pool

Throws: net.sf.saxon.trans.StaticError if the name is invalid, or the prefix undeclared

makeNamespaceTest

public NamespaceTest makeNamespaceTest(short nodeType, String prefix)
Make a NamespaceTest (name:*)

Parameters: nodeType integer code identifying the type of node required prefix the namespace prefix

Returns: the NamespaceTest, a pattern that matches all nodes in this namespace

Throws: net.sf.saxon.trans.StaticError if the namespace prefix is not declared

makeNameTest

public NameTest makeNameTest(short nodeType, String qname, boolean useDefault)
Make a NameTest, using the static context for namespace resolution

Parameters: nodeType the type of node required (identified by a constant in class Type) qname the lexical QName of the required node useDefault true if the default namespace should be used when the QName is unprefixed

Returns: a NameTest, representing a pattern that tests for a node of a given node kind and a given name

Throws: net.sf.saxon.trans.StaticError if the QName is invalid

makeStringLiteral

protected StringValue makeStringLiteral(String currentTokenValue)
Method to make a string literal from a token identified as a string literal. This is trivial in XPath, but in XQuery the method is overridden to identify pseudo-XML character and entity references. Note that the job of handling doubled string delimiters is done by the tokenizer.

Parameters: currentTokenValue

Returns: The string value of the string literal

makeTracer

protected Expression makeTracer(int startOffset, Expression exp, int construct, int objectNameCode)
If tracing, wrap an instruction in a trace instruction

nextToken

protected void nextToken()
Read the next token, catching any exception thrown by the tokenizer

parse

public Expression parse(String expression, int start, int terminator, int lineNumber, StaticContext env)
Parse a string representing an expression

Parameters: expression the expression expressed as a String start offset within the string where parsing is to start terminator character to treat as terminating the expression lineNumber location of the start of the expression, for diagnostics env the static context for the expression

Returns: an Expression object representing the result of parsing

Throws: net.sf.saxon.trans.StaticError if the expression contains a syntax error

parseConstructor

protected Expression parseConstructor()
Parse a node constructor. This is allowed only in XQuery, so the method throws an error for XPath.

parseExpression

protected Expression parseExpression()
Parse a top-level Expression: ExprSingle ( ',' ExprSingle )*

Returns: the Expression object that results from parsing

Throws: net.sf.saxon.trans.StaticError if the expression contains a syntax error

parseExprSingle

protected Expression parseExprSingle()
Parse an ExprSingle

Returns: the resulting subexpression

Throws: net.sf.saxon.trans.StaticError if any error is encountered

parseExtensionExpression

protected Expression parseExtensionExpression()
Parse an Extension Expression This construct is XQuery-only, so the XPath version of this method throws an error unconditionally

parseForExpression

protected Expression parseForExpression()
Parse a FOR expression: for $x in expr (',' $y in expr)* 'return' expr

Returns: the resulting subexpression

Throws: net.sf.saxon.trans.StaticError if any error is encountered

parseMappingExpression

protected Expression parseMappingExpression()
Parse a mapping expression. This is a common routine that handles XPath for expressions and quantified expressions.

Syntax:
(for|some|every) $x in expr (',' $y in expr)* (return|satisfies) expr

On entry, the current token indicates whether a for, some, or every expression is expected.

Returns: the resulting subexpression

Throws: net.sf.saxon.trans.StaticError if any error is encountered

parseNodeTest

protected NodeTest parseNodeTest(short nodeType)
Parse a NodeTest. One of QName, prefix:*, *:suffix, *, text(), node(), comment(), or processing-instruction(literal?), or element(~,~), attribute(~,~), etc.

Parameters: nodeType the node type being sought if one is specified

Returns: the resulting NodeTest object

Throws: net.sf.saxon.trans.StaticError if any error is encountered

parsePattern

public Pattern parsePattern(String pattern, StaticContext env)
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: net.sf.saxon.trans.StaticError if the pattern contains a syntax error

parseRelativePath

protected Expression parseRelativePath()
Parse a relative path (a sequence of steps). Called when the current token immediately follows a separator (/ or //), or an implicit separator (XYZ is equivalent to ./XYZ)

Returns: the resulting subexpression

Throws: net.sf.saxon.trans.StaticError if any error is encountered

parseRemainingPath

protected Expression parseRemainingPath(Expression start)
Parse the remaining steps of an absolute path expression (one starting in "/" or "//"). Note that the token immediately after the "/" or "//" has already been read, and in the case of "/", it has been confirmed that we have a path expression starting with "/" rather than a standalone "/" expression.

Parameters: start the initial implicit expression: root() in the case of "/", root()/descendant-or-self::node in the case of "//"

Returns: the completed path expression

Throws: StaticError

parseSequenceType

public SequenceType parseSequenceType(String input, StaticContext env)
Parse a string representing a sequence type

Parameters: input the string, which should conform to the XPath SequenceType production env the static context

Returns: a SequenceType object representing the type

Throws: net.sf.saxon.trans.StaticError if any error is encountered

parseSequenceType

protected SequenceType parseSequenceType()
Parse the sequence type production. Provisionally, we use the syntax (QName | node-kind "()") ( "*" | "+" | "?" )? We also allow "element of type QName" and "attribute of type QName" The QName must be the name of a built-in schema-defined data type.

Returns: the resulting subexpression

Throws: net.sf.saxon.trans.StaticError if any error is encountered

parseStepExpression

protected Expression parseStepExpression()
Parse a step (including an optional sequence of predicates)

Returns: the resulting subexpression

Throws: net.sf.saxon.trans.StaticError if any error is encountered

parseTypeswitchExpression

protected Expression parseTypeswitchExpression()
Parse a Typeswitch Expression. This construct is XQuery-only, so the XPath version of this method throws an error unconditionally

parseValidateExpression

protected Expression parseValidateExpression()
Parse a Validate Expression. This construct is XQuery-only, so the XPath version of this method throws an error unconditionally

setLocation

protected void setLocation(Expression exp)
Set location information on an expression. At present this consists of a simple line number. Needed mainly for XQuery.

setLocation

protected void setLocation(Expression exp, int offset)
Set location information on an expression. At present only the line number is retained. Needed mainly for XQuery. This version of the method supplies an explicit offset (character position within the expression or query), which the tokenizer can convert to a line number and column number.

setRangeVariableStack

public void setRangeVariableStack(Stack stack)
Set the range variable stack. Used when parsing a nested subexpression inside an attribute constructor.

setScanOnly

public void setScanOnly(boolean scanOnly)

undeclareRangeVariable

protected void undeclareRangeVariable()
Note when the most recently declared range variable has gone out of scope

warning

protected void warning(String message)
Output a warning message