net.sf.saxon.expr
public class ExpressionParser extends Object
Nested Class Summary | |
---|---|
static class | ExpressionParser.ForClause |
protected static class | ExpressionParser.TemporaryContainer |
Field Summary | |
---|---|
protected StaticContext | env |
protected int | language |
protected NameChecker | nameChecker |
protected Stack | rangeVariables |
protected boolean | scanOnly |
protected static int | SEQUENCE_TYPE |
protected Tokenizer | t |
protected static int | XPATH |
protected static int | XQUERY |
protected static int | XSLT_PATTERN |
Constructor Summary | |
---|---|
ExpressionParser() |
Method Summary | |
---|---|
protected String | currentTokenDisplay()
Display the current token in an error message
|
protected void | declareRangeVariable(VariableDeclaration declaration)
Declare a range variable (record its existence within the parser).
|
protected void | expect(int token)
Expect a given token; fail if the current token is different. |
protected String | getLanguage()
Get the current language (XPath or XQuery) |
Stack | getRangeVariableStack()
Get the range variable stack. |
Tokenizer | getTokenizer() |
protected void | grumble(String message)
Report a syntax error (a static error with error code XP0003) |
protected void | grumble(String message, String errorCode)
Report a static error
|
protected boolean | isKeyword(String s)
Test whether the current token is a given keyword. |
LocalNameTest | makeLocalNameTest(short nodeType, String localName)
Make a LocalNameTest (*:name)
|
int | makeNameCode(String qname, boolean useDefault)
Make a NameCode, using this Element as the context for namespace resolution
|
NamespaceTest | makeNamespaceTest(short nodeType, String prefix)
Make a NamespaceTest (name:*)
|
NameTest | makeNameTest(short nodeType, String qname, boolean useDefault)
Make a NameTest, using the static context for namespace resolution
|
protected StringValue | makeStringLiteral(String currentTokenValue)
Method to make a string literal from a token identified as a string
literal. |
protected Expression | makeTracer(int startOffset, Expression exp, int construct, int objectNameCode)
If tracing, wrap an instruction in a trace instruction |
protected void | nextToken()
Read the next token, catching any exception thrown by the tokenizer |
Expression | parse(String expression, int start, int terminator, int lineNumber, StaticContext env)
Parse a string representing an expression
|
protected Expression | parseConstructor()
Parse a node constructor. |
protected Expression | parseExpression()
Parse a top-level Expression:
ExprSingle ( ',' ExprSingle )*
|
protected Expression | parseExprSingle()
Parse an ExprSingle
|
protected Expression | parseExtensionExpression()
Parse an Extension Expression
This construct is XQuery-only, so the XPath version of this
method throws an error unconditionally |
protected Expression | parseForExpression()
Parse a FOR expression:
for $x in expr (',' $y in expr)* 'return' expr
|
protected Expression | parseMappingExpression()
Parse a mapping expression. |
protected NodeTest | parseNodeTest(short nodeType)
Parse a NodeTest.
|
Pattern | parsePattern(String pattern, StaticContext env)
Parse a string representing an XSLT pattern
|
protected Expression | parseRelativePath()
Parse a relative path (a sequence of steps). |
protected Expression | parseRemainingPath(Expression start)
Parse the remaining steps of an absolute path expression (one starting in "/" or "//"). |
SequenceType | parseSequenceType(String input, StaticContext env)
Parse a string representing a sequence type
|
protected SequenceType | parseSequenceType()
Parse the sequence type production.
|
protected Expression | parseStepExpression()
Parse a step (including an optional sequence of predicates)
|
protected Expression | parseTypeswitchExpression()
Parse a Typeswitch Expression.
|
protected Expression | parseValidateExpression()
Parse a Validate Expression.
|
protected void | setLocation(Expression exp)
Set location information on an expression. |
protected void | setLocation(Expression exp, int offset)
Set location information on an expression. |
void | setRangeVariableStack(Stack stack)
Set the range variable stack. |
void | setScanOnly(boolean scanOnly) |
protected void | undeclareRangeVariable()
Note when the most recently declared range variable has gone out of scope |
protected void | warning(String message)
Output a warning message |
Returns: the display representation of the token
Parameters: declaration the VariableDeclaration to be added to the stack
Throws: net.sf.saxon.trans.StaticError if any error is encountered
Parameters: token the expected token
Throws: net.sf.saxon.trans.StaticError if the current token is not the expected token
Parameters: message the error message
Throws: net.sf.saxon.trans.StaticError always thrown: an exception containing the supplied message
Parameters: message the error message errorCode the error code
Throws: net.sf.saxon.trans.StaticError always thrown: an exception containing the supplied message
Parameters: s The string to be compared with the current token
Returns: true if they are the same
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
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
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
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
Parameters: currentTokenValue
Returns: The string value of the string literal
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
Returns: the Expression object that results from parsing
Throws: net.sf.saxon.trans.StaticError if the expression contains a syntax error
Returns: the resulting subexpression
Throws: net.sf.saxon.trans.StaticError if any error is encountered
Returns: the resulting subexpression
Throws: net.sf.saxon.trans.StaticError if any error is encountered
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
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
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
Returns: the resulting subexpression
Throws: net.sf.saxon.trans.StaticError if any error is encountered
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
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
Returns: the resulting subexpression
Throws: net.sf.saxon.trans.StaticError if any error is encountered
Returns: the resulting subexpression
Throws: net.sf.saxon.trans.StaticError if any error is encountered