|
|||||||||
PREV CLASS NEXT CLASS | FRAMES NO FRAMES | ||||||||
SUMMARY: NESTED | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD |
java.lang.Object net.sf.saxon.expr.parser.ExpressionParser
public class ExpressionParser
Parser for XPath expressions and XSLT patterns.
This code was originally inspired by James Clark's xt but has been totally rewritten (several times) The base class handles parsing of XPath 2.0 and XPath 3.0 syntax (switched by a languageVersion variable). Subclasses refine this to handle XQuery syntax (1.0 and 3.0) and XQuery Update syntax.
Nested Class Summary | |
---|---|
protected static class |
ExpressionParser.TemporaryContainer
A Container used on a temporary basis to hold an expression while it is being parsed |
Field Summary | |
---|---|
protected boolean |
allowXPath30Syntax
|
protected Container |
defaultContainer
|
protected StaticContext |
env
|
protected int |
language
|
protected DecimalValue |
languageVersion
|
protected NameChecker |
nameChecker
|
protected Stack<Binding> |
rangeVariables
|
protected boolean |
scanOnly
|
static int |
SEQUENCE_TYPE
|
protected Tokenizer |
t
|
static int |
XPATH
|
static int |
XQUERY
|
static int |
XSLT_PATTERN
|
Constructor Summary | |
---|---|
ExpressionParser()
Create an expression parser |
Method Summary | |
---|---|
protected boolean |
atStartOfRelativePath()
Test whether the current token is one that can start a RelativePathExpression |
protected String |
currentTokenDisplay()
Display the current token in an error message |
protected void |
customizeTokenizer(Tokenizer t)
Callback to tailor the tokenizer |
void |
declareRangeVariable(Binding declaration)
Declare a range variable (record its existence within the parser). |
protected boolean |
disallowedAtStartOfRelativePath()
Test whether the current token is one that is disallowed after a "leading lone slash". |
void |
expect(int token)
Expect a given token; fail if the current token is different. |
protected Binding |
findRangeVariable(StructuredQName qName)
Locate a range variable with a given name. |
CodeInjector |
getCodeInjector()
Set a CodeInjector which can be used to modify or wrap expressions on the tree as the expression is parsed and the tree is constructed. |
Container |
getDefaultContainer()
Get the default container for newly constructed expressions |
protected String |
getLanguage()
Get the current language (XPath or XQuery) |
NameChecker |
getNameChecker()
Get the name checker used by this parser |
Stack<Binding> |
getRangeVariables()
Get the stack of in-scope range variables |
StaticContext |
getStaticContext()
Get the static context used by this expression parser |
Tokenizer |
getTokenizer()
Get the tokenizer (the lexical analyzer) |
void |
grumble(String message)
Report a syntax error (a static error with error code XP0003) |
void |
grumble(String message,
String errorCode)
Report a static error |
void |
grumble(String message,
String errorCode,
int offset)
Report a static error, with location information |
protected void |
grumble(String message,
StructuredQName errorCode,
int offset)
Report a static error |
void |
grumble(XPathException error)
|
protected boolean |
isKeyword(String s)
Test whether the current token is a given keyword. |
protected boolean |
isNamespaceTestAllowed()
Ask whether the syntax namespace-node() is allowed in a node kind test. |
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) |
LocalNameTest |
makeLocalNameTest(short nodeType,
String localName)
Make a LocalNameTest (*:name) |
int |
makeNameCode(String qname,
boolean useDefault)
Make a NameCode, using the static context for namespace resolution |
int |
makeNameCodeSilently(String qname,
boolean useDefault)
Make a NameCode, using the static 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 |
NodeName |
makeNodeName(String qname,
boolean useDefault)
Make a FingerprintedQName, using the static context for namespace resolution |
protected Literal |
makeStringLiteral(String currentTokenValue)
Method to make a string literal from a token identified as a string literal. |
StructuredQName |
makeStructuredQName(String qname,
boolean useDefault)
Make a Structured QName, using the static context for namespace resolution |
Expression |
makeTracer(int startOffset,
Expression exp,
int construct,
StructuredQName qName)
If tracing, wrap an expression in a trace instruction |
void |
nextToken()
Read the next token, catching any exception thrown by the tokenizer |
protected String |
normalizeEQName(String s)
Normalize an EQName. |
Expression |
parse(String expression,
int start,
int terminator,
int lineNumber,
StaticContext env)
Parse a string representing an expression. |
protected Expression |
parseBasicStep(boolean firstInPattern)
Parse a basic step expression (without the predicates) |
Expression |
parseBinaryExpression(Expression lhs,
int minPrecedence)
Parse a binary expression, using operator precedence parsing. |
protected Expression |
parseConstructor()
Parse a node constructor. |
protected Expression |
parseDynamicFunctionCall(Expression functionItem)
Parse a dynamic function call |
Expression |
parseExpression()
Parse a top-level Expression: ExprSingle ( ',' ExprSingle )* |
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 |
parseFLWORExpression()
Parse a FOR or LET expression: for $x in expr (',' $y in expr)* 'return' expr let $x := expr (', $y := expr)* 'return' expr This version of the method handles the subset of the FLWOR syntax allowed in XPath |
Expression |
parseFunctionArgument()
Parse an argument to a function call. |
protected Expression |
parseFunctionCall()
Parse a function call. |
protected ItemType |
parseFunctionItemType()
Get the item type used for function items (XPath 3.0 higher order functions) |
protected Expression |
parseInlineFunction()
Parse an inline function "function" "(" ParamList? ")" ("as" SequenceType)? EnclosedExpr On entry, "function (" has already been read |
ItemType |
parseItemType()
Parse an ItemType within a SequenceType |
protected Expression |
parseLiteralFunctionItem()
Parse a literal function item (introduced in XQuery 1.1) Syntax: QName # integer The QName and # have already been read |
protected Expression |
parseMapExpression()
Parse a map expression. |
protected ItemType |
parseMapItemType()
Get the item type used for map items (XPath 3.0) |
protected NodeTest |
parseNodeTest(short nodeType)
Parse a NodeTest. |
protected Expression |
parseNumericLiteral()
|
protected ItemType |
parseParenthesizedItemType()
Parse a parenthesized item type (XPath 3.0) |
protected Expression |
parsePathExpression()
Parse a PathExpresssion. |
protected Expression |
parsePredicate()
Parse the expression within a predicate. |
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()
Parse the sequence type production. |
SequenceType |
parseSequenceType(String input,
StaticContext env)
Parse a string representing a sequence type |
protected Expression |
parseStepExpression(boolean firstInPattern)
Parse a step (including an optional sequence of predicates) |
protected Expression |
parseStringLiteral()
|
protected Expression |
parseSwitchExpression()
Parse a Switch Expression. |
protected Expression |
parseTryCatchExpression()
Parse a try/catch Expression This construct is XQuery-1.1 only, so the XPath version of this method throws an error unconditionally |
protected Expression |
parseTypePattern()
Parse a Type Pattern This construct is used only in XSLT patterns, so the XPath version of this method throws an error unconditionally |
protected Expression |
parseTypeswitchExpression()
Parse a Typeswitch Expression. |
protected Expression |
parseValidateExpression()
Parse a Validate Expression. |
protected Expression |
parseVariableReference()
|
Expression |
reportMissingFunction(int offset,
StructuredQName functionName,
Expression[] arguments)
|
protected StructuredQName |
resolveFunctionName(String fname)
Interpret a function name, returning it as a resolved QName |
void |
setCodeInjector(CodeInjector injector)
Set a CodeInjector which can be used to modify or wrap expressions on the tree as the expression is parsed and the tree is constructed. |
void |
setDefaultContainer(Container container)
Set the default container for newly constructed expressions |
void |
setLanguage(int language,
DecimalValue version)
Set the current language (XPath or XQuery, XSLT Pattern, or SequenceType) |
protected void |
setLocation(Expression exp)
Set location information on an expression. |
void |
setLocation(Expression exp,
int offset)
Set location information on an expression. |
void |
setRangeVariables(Stack<Binding> variables)
Set a new stack of in-scope range variables |
void |
setRangeVariableStack(Stack<Binding> stack)
Set the range variable stack. |
void |
setScanOnly(boolean scanOnly)
Set that we are parsing in "scan only" |
void |
undeclareRangeVariable()
Note when the most recently declared range variable has gone out of scope |
protected void |
warning(String message)
Output a warning message |
Methods inherited from class java.lang.Object |
---|
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait |
Field Detail |
---|
protected Tokenizer t
protected StaticContext env
protected Stack<Binding> rangeVariables
protected Container defaultContainer
protected NameChecker nameChecker
protected boolean allowXPath30Syntax
protected boolean scanOnly
protected int language
public static final int XPATH
public static final int XSLT_PATTERN
public static final int SEQUENCE_TYPE
public static final int XQUERY
protected DecimalValue languageVersion
Constructor Detail |
---|
public ExpressionParser()
Method Detail |
---|
public void setCodeInjector(CodeInjector injector)
injector
- the code injector to be usedpublic CodeInjector getCodeInjector()
public Tokenizer getTokenizer()
public StaticContext getStaticContext()
public void setDefaultContainer(Container container)
container
- the default containerpublic Container getDefaultContainer()
public NameChecker getNameChecker()
public void nextToken() throws XPathException
XPathException
- if an invalid token is foundpublic void expect(int token) throws XPathException
token
- the expected token
XPathException
- if the current token is not the expected
tokenpublic void grumble(String message) throws XPathException
message
- the error message
XPathException
- always thrown: an exception containing the
supplied messagepublic void grumble(String message, String errorCode) throws XPathException
message
- the error messageerrorCode
- the error code
XPathException
- always thrown: an exception containing the
supplied messagepublic void grumble(String message, String errorCode, int offset) throws XPathException
message
- the error messageerrorCode
- the error codeoffset
- the coded location of the error, or -1 if the location of the current token should be used
XPathException
- always thrown: an exception containing the
supplied messagepublic void grumble(XPathException error)
protected void grumble(String message, StructuredQName errorCode, int offset) throws XPathException
message
- the error messageerrorCode
- the error codeoffset
- the coded location of the error, or -1 if the location of the current token should be used
XPathException
- always thrown: an exception containing the
supplied messageprotected void warning(String message) throws XPathException
message
- the text of the message
XPathException
- if the message cannot be outputpublic void setLanguage(int language, DecimalValue version)
language
- one of the constants XPATH
, XQUERY
, XSLT_PATTERN
, SEQUENCE_TYPE
version
- The XPath or XQuery language version. For XQuery the value must be
"1.0" or "3.0; for XPath it must be "2.0" or "3.0". Currently
support for XQuery 3.0 and XPath 3.0 is incomplete: check the release notes.protected String getLanguage()
protected String currentTokenDisplay()
public Expression parse(String expression, int start, int terminator, int lineNumber, StaticContext env) throws XPathException
expression
- the expression expressed as a Stringstart
- offset within the string where parsing is to startterminator
- character to treat as terminating the expressionlineNumber
- location of the start of the expression, for diagnosticsenv
- the static context for the expression
XPathException
- if the expression contains a syntax errorprotected void customizeTokenizer(Tokenizer t)
t
- the Tokenizer to be customizedpublic SequenceType parseSequenceType(String input, StaticContext env) throws XPathException
input
- the string, which should conform to the XPath SequenceType
productionenv
- the static context
XPathException
- if any error is encounteredpublic Expression parseExpression() throws XPathException
XPathException
- if the expression contains a syntax errorpublic Expression parseExprSingle() throws XPathException
XPathException
- if any error is encounteredpublic Expression parseBinaryExpression(Expression lhs, int minPrecedence) throws XPathException
lhs
- Left-hand side "basic expression"minPrecedence
- the minimum precedence of an operator that is to be treated as not terminating the
current expression
XPathException
- if a static error is foundprotected Expression parseTypeswitchExpression() throws XPathException
XPathException
- if a static error is foundprotected Expression parseSwitchExpression() throws XPathException
XPathException
- if a static error is foundprotected Expression parseValidateExpression() throws XPathException
XPathException
- if a static error is foundprotected Expression parseExtensionExpression() throws XPathException
XPathException
- if a static error is foundprotected Expression parseTypePattern() throws XPathException
XPathException
- if a static error is foundprotected Expression parseTryCatchExpression() throws XPathException
XPathException
- if a static error is foundprotected Expression parseFLWORExpression() throws XPathException
XPathException
- if any error is encounteredpublic SequenceType parseSequenceType() throws XPathException
XPathException
- if any error is encounteredpublic ItemType parseItemType() throws XPathException
XPathException
- if a static error is foundprotected ItemType parseFunctionItemType() throws XPathException
XPathException
- if a static error occurs (including the case
where XPath 3.0 syntax is not enabled)protected ItemType parseMapItemType() throws XPathException
XPathException
- if a parsing error occurs or if the map syntax
is not availableprotected ItemType parseParenthesizedItemType() throws XPathException
XPathException
- if a syntax error is foundprotected boolean atStartOfRelativePath()
protected boolean disallowedAtStartOfRelativePath()
protected Expression parsePathExpression() throws XPathException
XPathException
- if any error is encounteredprotected Expression parseRelativePath() throws XPathException
XPathException
- if any error is encounteredprotected Expression parseRemainingPath(Expression start) throws XPathException
start
- the initial implicit expression: root() in the case of "/", root()/descendant-or-self::node in
the case of "//"
XPathException
- if a static error is foundprotected Expression parseStepExpression(boolean firstInPattern) throws XPathException
firstInPattern
- true only if we are parsing the first step in a
RelativePathPattern in the XSLT Pattern syntax
XPathException
- if any error is encounteredprotected Expression parsePredicate() throws XPathException
XPathException
- if a static error is foundprotected Expression parseBasicStep(boolean firstInPattern) throws XPathException
firstInPattern
- true only if we are parsing the first step in a
RelativePathPattern in the XSLT Pattern syntax
XPathException
- if any error is encounteredprotected Expression parseNumericLiteral() throws XPathException
XPathException
protected Expression parseStringLiteral() throws XPathException
XPathException
protected Expression parseVariableReference() throws XPathException
XPathException
protected Literal makeStringLiteral(String currentTokenValue) throws XPathException
currentTokenValue
- the token as read (excluding quotation marks)
XPathException
- if a static error is foundprotected Expression parseConstructor() throws XPathException
XPathException
- if a static error occursprotected Expression parseDynamicFunctionCall(Expression functionItem) throws XPathException
functionItem
- the expression that determines the function to be called
XPathException
- if a static error is foundprotected NodeTest parseNodeTest(short nodeType) throws XPathException
nodeType
- the node type being sought if one is specified
XPathException
- if any error is encounteredprotected boolean isNamespaceTestAllowed()
protected Expression parseMapExpression() throws XPathException
XPathException
- if a static error occursprotected Expression parseFunctionCall() throws XPathException
XPathException
- if any error is encounteredpublic Expression reportMissingFunction(int offset, StructuredQName functionName, Expression[] arguments) throws XPathException
XPathException
protected StructuredQName resolveFunctionName(String fname) throws XPathException
fname
- the lexical QName used as the function name; or an EQName presented
by the tokenizer as a name in Clark notation
XPathException
- if the supplied name is not a valid QName or if its prefix
is not in scopepublic Expression parseFunctionArgument() throws XPathException
XPathException
- if the argument expression does not parse correctlyprotected Expression parseLiteralFunctionItem() throws XPathException
XPathException
- if a static error is encounteredprotected Expression parseInlineFunction() throws XPathException
XPathException
- if a syntax error is foundprotected Expression makeCurriedFunction(int offset, StructuredQName name, Expression[] args, IntSet placeMarkers) throws XPathException
offset
- the position of the expression in the source textname
- the function name (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
XPathException
- if a static error is foundpublic Stack<Binding> getRangeVariables()
public void setRangeVariables(Stack<Binding> variables)
variables
- the stack of variablespublic void declareRangeVariable(Binding declaration) throws XPathException
declaration
- the variable declaration to be added to the stack
XPathException
- if any error is encounteredpublic void undeclareRangeVariable()
protected Binding findRangeVariable(StructuredQName qName)
qName
- identifies the name of the range variable
public void setRangeVariableStack(Stack<Binding> stack)
stack
- the stack to be used for local variables declared within the expressionpublic final int makeNameCode(String qname, boolean useDefault) throws XPathException
qname
- The name as written, in the form "[prefix:]localname"; alternatively,
a QName in Clark notation ({uri}local)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).
XPathException
- if the name is invalid, or the prefix
undeclaredpublic final int makeNameCodeSilently(String qname, boolean useDefault) throws XPathException, QNameException
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).
XPathException
- if the name is invalid, or the prefix
undeclared
QNameException
- if the name is not a lexically valid QNamepublic final StructuredQName makeStructuredQName(String qname, boolean useDefault) throws XPathException
qname
- The name as written, in the form "[prefix:]localname"; alternatively, a QName in
Clark format ({uri}local)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).
XPathException
- if the name is invalid, or the prefix
undeclaredpublic final NodeName makeNodeName(String qname, boolean useDefault) throws XPathException, QNameException
qname
- The name as written, in the form "[prefix:]localname"; alternatively, a QName in
Clark format ({uri}local)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).
XPathException
- if the name is invalid, or the prefix
undeclared
QNameException
- if the supplied qname is not a lexically valid QNamepublic NameTest makeNameTest(short nodeType, String qname, boolean useDefault) throws XPathException
nodeType
- the type of node required (identified by a constant in
class Type)qname
- the lexical QName of the required node; alternatively,
a QName in Clark notation ({uri}local)useDefault
- true if the default namespace should be used when
the QName is unprefixed
XPathException
- if the QName is invalidpublic NamespaceTest makeNamespaceTest(short nodeType, String prefix) throws XPathException
nodeType
- integer code identifying the type of node requiredprefix
- the namespace prefix
XPathException
- if the namespace prefix is not declaredpublic LocalNameTest makeLocalNameTest(short nodeType, String localName) throws XPathException
nodeType
- the kind of node to be matchedlocalName
- the requred local name
XPathException
- if the local name is invalidprotected void setLocation(Expression exp)
exp
- the expression whose location information is to be setpublic void setLocation(Expression exp, int offset)
exp
- the expression whose location information is to be setoffset
- the character position within the expression (ignoring newlines)public Expression makeTracer(int startOffset, Expression exp, int construct, StructuredQName qName)
startOffset
- the position of the expression in the soruceexp
- the expression to be wrappedconstruct
- integer constant identifying the kind of constructqName
- the name of the construct (if applicable)
protected boolean isKeyword(String s)
s
- The string to be compared with the current token
protected String normalizeEQName(String s) throws XPathException
s
- the EQName in the form of a Clark name
XPathException
- so that the XQuery implementation in a subclass can do so.public void setScanOnly(boolean scanOnly)
scanOnly
- true if parsing is to proceed in scan-only mode. In this mode
namespace bindings are not yet known, so no attempt is made to look up namespace
prefixes.
|
|||||||||
PREV CLASS NEXT CLASS | FRAMES NO FRAMES | ||||||||
SUMMARY: NESTED | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD |