Overview | Package | Class | Tree | Deprecated | Index | Help
PREV CLASS NEXT CLASS | FRAMES NO FRAMES
SUMMARY: NESTED | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD

## net.sf.saxon.expr.parser
Class ExpressionParser

    java.lang.Object
      net.sf.saxon.expr.parser.ExpressionParser

Direct Known Subclasses:
  PatternParser, QueryParser, SelectionParser, XPath30Parser

    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)

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.

Author:
  Michael Kay

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

### t

    protected Tokenizer t

### env

    protected StaticContext env

### rangeVariables

    protected Stack<Binding> rangeVariables

### defaultContainer

    protected Container defaultContainer

### nameChecker

    protected NameChecker nameChecker

### allowXPath30Syntax

    protected boolean allowXPath30Syntax

### scanOnly

    protected boolean scanOnly

### language

    protected int language

### XPATH

    public static final int XPATH

See Also:
  Constant Field Values

### XSLT_PATTERN

    public static final int XSLT_PATTERN

See Also:
  Constant Field Values

### SEQUENCE_TYPE

    public static final int SEQUENCE_TYPE

See Also:
  Constant Field Values

### XQUERY

    public static final int XQUERY

See Also:
  Constant Field Values

### languageVersion

    protected DecimalValue languageVersion

Constructor Detail

### ExpressionParser

    public ExpressionParser()

  Create an expression parser

Method Detail

### setCodeInjector

    public 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. This is typically used to add tracing code.

  Parameters:
    `injector` - the code injector to be used

### getCodeInjector

    public 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. This is typically used to add tracing code.

  Returns:
    the code injector in use, if any; or null otherwise

### getTokenizer

    public Tokenizer getTokenizer()

  Get the tokenizer (the lexical analyzer)

  Returns:
    the tokenizer (the lexical analyzer)

### getStaticContext

    public StaticContext getStaticContext()

  Get the static context used by this expression parser

  Returns:
    the static context

### setDefaultContainer

    public void setDefaultContainer(Container container)

  Set the default container for newly constructed expressions

  Parameters:
    `container` - the default container

### getDefaultContainer

    public Container getDefaultContainer()

  Get the default container for newly constructed expressions

  Returns:
    the default container

### getNameChecker

    public NameChecker getNameChecker()

  Get the name checker used by this parser

  Returns:
    the name checker (specific to XML 1.0o

### nextToken

    public void nextToken()
                   throws XPathException

  Read the next token, catching any exception thrown by the tokenizer

  Throws:
    `XPathException` - if an invalid token is found

### expect

    public void expect(int token)
                throws XPathException

  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:
    `XPathException` - if the current token is not the expected token

### grumble

    public void grumble(String message)
                 throws XPathException

  Report a syntax error (a static error with error code XP0003)

  Parameters:
    `message` - the error message
  Throws:
    `XPathException` - always thrown: an exception containing the supplied message

### grumble

    public void grumble(String message,
                        String errorCode)
                 throws XPathException

  Report a static error

  Parameters:
    `message` - the error message
    `errorCode` - the error code
  Throws:
    `XPathException` - always thrown: an exception containing the supplied message

### grumble

    public void grumble(String message,
                        String errorCode,
                        int offset)
                 throws XPathException

  Report a static error, with location information

  Parameters:
    `message` - the error message
    `errorCode` - the error code
    `offset` - the coded location of the error, or -1 if the location of the current token should be used
  Throws:
    `XPathException` - always thrown: an exception containing the supplied message

### grumble

    public void grumble(XPathException error)

### grumble

    protected void grumble(String message,
                           StructuredQName errorCode,
                           int offset)
                    throws XPathException

  Report a static error

  Parameters:
    `message` - the error message
    `errorCode` - the error code
    `offset` - the coded location of the error, or -1 if the location of the current token should be used
  Throws:
    `XPathException` - always thrown: an exception containing the supplied message

### warning

    protected void warning(String message)
                    throws XPathException

  Output a warning message

  Parameters:
    `message` - the text of the message
  Throws:
    `XPathException` - if the message cannot be output

### setLanguage

    public void setLanguage(int language,
                            DecimalValue version)

  Set the current language (XPath or XQuery, XSLT Pattern, or SequenceType)

  Parameters:
    `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.

### getLanguage

    protected String getLanguage()

  Get the current language (XPath or XQuery)

  Returns:
    a string representation of the language being parsed, for use in error messages

### currentTokenDisplay

    protected String currentTokenDisplay()

  Display the current token in an error message

  Returns:
    the display representation of the token

### parse

    public Expression parse(String expression,
                            int start,
                            int terminator,
                            int lineNumber,
                            StaticContext env)
                     throws XPathException

  Parse a string representing an expression. This will accept an XPath expression if called on an ExpressionParser, or an XQuery expression if called on a QueryParser.

  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:
    `XPathException` - if the expression contains a syntax error

### customizeTokenizer

    protected void customizeTokenizer(Tokenizer t)

  Callback to tailor the tokenizer

  Parameters:
    `t` - the Tokenizer to be customized

### parseSequenceType

    public SequenceType parseSequenceType(String input,
                                          StaticContext env)
                                   throws XPathException

  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:
    `XPathException` - if any error is encountered

### parseExpression

    public Expression parseExpression()
                               throws XPathException

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

  Returns:
    the Expression object that results from parsing
  Throws:
    `XPathException` - if the expression contains a syntax error

### parseExprSingle

    public Expression parseExprSingle()
                               throws XPathException

  Parse an ExprSingle

  Returns:
    the resulting subexpression
  Throws:
    `XPathException` - if any error is encountered

### parseBinaryExpression

    public Expression parseBinaryExpression(Expression lhs,
                                            int minPrecedence)
                                     throws XPathException

  Parse a binary expression, using operator precedence parsing. This is used to parse the part of the grammary consisting largely of binary operators distinguished by precedence: from "or expressions" down to "unary expressions". Algorithm for the mainstream binary operators is from Wikipedia article on precedence parsing; operator precedences are from the XQuery specification appendix B.

  Parameters:
    `lhs` - Left-hand side "basic expression"
    `minPrecedence` - the minimum precedence of an operator that is to be treated as not terminating the current expression
  Returns:
    the parsed expression
  Throws:
    `XPathException` - if a static error is found

### parseTypeswitchExpression

    protected Expression parseTypeswitchExpression()
                                            throws XPathException

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

  Returns:
    the expression that results from the parsing
  Throws:
    `XPathException` - if a static error is found

### parseSwitchExpression

    protected Expression parseSwitchExpression()
                                        throws XPathException

  Parse a Switch Expression. This construct is XQuery-1.1 only, so the XPath and XQuery 1.0 versions of this method throw an error unconditionally

  Returns:
    the expression that results from the parsing
  Throws:
    `XPathException` - if a static error is found

### parseValidateExpression

    protected Expression parseValidateExpression()
                                          throws XPathException

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

  Returns:
    the parsed expression; except that this version of the method always throws an exception
  Throws:
    `XPathException` - if a static error is found

### parseExtensionExpression

    protected Expression parseExtensionExpression()
                                           throws XPathException

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

  Returns:
    the parsed expression; except that this version of the method always throws an exception
  Throws:
    `XPathException` - if a static error is found

### parseTypePattern

    protected Expression parseTypePattern()
                                   throws XPathException

  Parse a Type Pattern This construct is used only in XSLT patterns, so the XPath version of this method throws an error unconditionally

  Returns:
    the parsed expression; except that this version of the method always throws an exception
  Throws:
    `XPathException` - if a static error is found

### parseTryCatchExpression

    protected Expression parseTryCatchExpression()
                                          throws XPathException

  Parse a try/catch Expression This construct is XQuery-1.1 only, so the XPath version of this method throws an error unconditionally

  Returns:
    the parsed expression; except that this version of the method always throws an exception
  Throws:
    `XPathException` - if a static error is found

### parseFLWORExpression

    protected Expression parseFLWORExpression()
                                       throws XPathException

  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

  Returns:
    the resulting subexpression
  Throws:
    `XPathException` - if any error is encountered

### parseSequenceType

    public SequenceType parseSequenceType()
                                   throws XPathException

  Parse the sequence type production. The QName must be the name of a built-in schema-defined data type.

  Returns:
    the resulting subexpression
  Throws:
    `XPathException` - if any error is encountered

### parseItemType

    public ItemType parseItemType()
                           throws XPathException

  Parse an ItemType within a SequenceType

  Returns:
    the ItemType after parsing
  Throws:
    `XPathException` - if a static error is found

### parseFunctionItemType

    protected ItemType parseFunctionItemType()
                                      throws XPathException

  Get the item type used for function items (XPath 3.0 higher order functions)

  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)

### parseMapItemType

    protected ItemType parseMapItemType()
                                 throws XPathException

  Get the item type used for map items (XPath 3.0)

  Returns:
    the item type of the map
  Throws:
    `XPathException` - if a parsing error occurs or if the map syntax is not available

### parseParenthesizedItemType

    protected ItemType parseParenthesizedItemType()
                                           throws XPathException

  Parse a parenthesized item type (XPath 3.0)

  Returns:
    the item type
  Throws:
    `XPathException` - if a syntax error is found

### atStartOfRelativePath

    protected boolean atStartOfRelativePath()

  Test whether the current token is one that can start a RelativePathExpression

  Returns:
    the resulting subexpression

### disallowedAtStartOfRelativePath

    protected boolean disallowedAtStartOfRelativePath()

  Test whether the current token is one that is disallowed after a "leading lone slash". These composite tokens have been parsed as operators, but are not allowed after "/" under the rules of erratum E24

  Returns:
    the resulting subexpression

### parsePathExpression

    protected Expression parsePathExpression()
                                      throws XPathException

  Parse a PathExpresssion. This includes "true" path expressions such as A/B/C, and also constructs that may start a path expression such as a variable reference $name or a parenthesed expression (A|B). Numeric and string literals also come under this heading.

  Returns:
    the resulting subexpression
  Throws:
    `XPathException` - if any error is encountered

### parseRelativePath

    protected Expression parseRelativePath()
                                    throws XPathException

  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:
    `XPathException` - if any error is encountered

### parseRemainingPath

    protected Expression parseRemainingPath(Expression start)
                                     throws XPathException

  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:
    `XPathException` - if a static error is found

### parseStepExpression

    protected Expression parseStepExpression(boolean firstInPattern)
                                      throws XPathException

  Parse a step (including an optional sequence of predicates)

  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

### parsePredicate

    protected Expression parsePredicate()
                                 throws XPathException

  Parse the expression within a predicate. A separate method so it can be overridden

  Returns:
    the expression within the predicate
  Throws:
    `XPathException` - if a static error is found

### parseBasicStep

    protected Expression parseBasicStep(boolean firstInPattern)
                                 throws XPathException

  Parse a basic step expression (without the predicates)

  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

### parseNumericLiteral

    protected Expression parseNumericLiteral()
                                      throws XPathException

  Throws:
    `XPathException`

### parseStringLiteral

    protected Expression parseStringLiteral()
                                     throws XPathException

  Throws:
    `XPathException`

### parseVariableReference

    protected Expression parseVariableReference()
                                         throws XPathException

  Throws:
    `XPathException`

### makeStringLiteral

    protected Literal makeStringLiteral(String currentTokenValue)
                                 throws XPathException

  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` - the token as read (excluding quotation marks)
  Returns:
    The string value of the string literal
  Throws:
    `XPathException` - if a static error is found

### parseConstructor

    protected Expression parseConstructor()
                                   throws XPathException

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

  Returns:
    the expression that results from the parsing
  Throws:
    `XPathException` - if a static error occurs

### parseDynamicFunctionCall

    protected Expression parseDynamicFunctionCall(Expression functionItem)
                                           throws XPathException

  Parse a dynamic function call

  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

### parseNodeTest

    protected NodeTest parseNodeTest(short nodeType)
                              throws XPathException

  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:
    `XPathException` - if any error is encountered

### isNamespaceTestAllowed

    protected boolean isNamespaceTestAllowed()

  Ask whether the syntax namespace-node() is allowed in a node kind test.

  Returns:
    false (currently allowed only in XQuery 1.1)

### parseMapExpression

    protected Expression parseMapExpression()
                                     throws XPathException

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

  Returns:
    the map expression
  Throws:
    `XPathException` - if a static error occurs

### parseFunctionCall

    protected Expression parseFunctionCall()
                                    throws XPathException

  Parse a function call. function-name '(' ( Expression (',' Expression )* )? ')'

  Returns:
    the resulting subexpression
  Throws:
    `XPathException` - if any error is encountered

### reportMissingFunction

    public Expression reportMissingFunction(int offset,
                                            StructuredQName functionName,
                                            Expression[] arguments)
                                     throws XPathException

  Throws:
    `XPathException`

### resolveFunctionName

    protected StructuredQName resolveFunctionName(String fname)
                                           throws XPathException

  Interpret a function name, returning it as a resolved QName

  Parameters:
    `fname` - the lexical QName used as the function name; or an EQName presented by the tokenizer as a name in Clark notation
  Returns:
    the Structured QName obtained by resolving any prefix in the function name
  Throws:
    `XPathException` - if the supplied name is not a valid QName or if its prefix is not in scope

### parseFunctionArgument

    public Expression parseFunctionArgument()
                                     throws XPathException

  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.

  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

### parseLiteralFunctionItem

    protected Expression parseLiteralFunctionItem()
                                           throws XPathException

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

  Returns:
    an ExternalObject representing the function item
  Throws:
    `XPathException` - if a static error is encountered

### parseInlineFunction

    protected Expression parseInlineFunction()
                                      throws XPathException

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

  Returns:
    the parsed inline function
  Throws:
    `XPathException` - if a syntax error is found

### 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)

  Parameters:
    `offset` - the position of the expression in the source text
    `name` - 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
  Returns:
    the curried function
  Throws:
    `XPathException` - if a static error is found

### getRangeVariables

    public Stack<Binding> getRangeVariables()

  Get the stack of in-scope range variables

  Returns:
    the stack of variables

### setRangeVariables

    public void setRangeVariables(Stack<Binding> variables)

  Set a new stack of in-scope range variables

  Parameters:
    `variables` - the stack of variables

### declareRangeVariable

    public void declareRangeVariable(Binding declaration)
                              throws XPathException

  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 variable declaration to be added to the stack
  Throws:
    `XPathException` - if any error is encountered

### undeclareRangeVariable

    public void undeclareRangeVariable()

  Note when the most recently declared range variable has gone out of scope

### findRangeVariable

    protected Binding 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.)

  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

### setRangeVariableStack

    public void setRangeVariableStack(Stack<Binding> stack)

  Set the range variable stack. Used when parsing a nested subexpression inside an attribute constructor.

  Parameters:
    `stack` - the stack to be used for local variables declared within the expression

### makeNameCode

    public final int makeNameCode(String qname,
                                  boolean useDefault)
                           throws XPathException

  Make a NameCode, using the static context for namespace resolution

  Parameters:
    `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).
  Returns:
    the namecode, which can be used to identify this name in the name pool
  Throws:
    `XPathException` - if the name is invalid, or the prefix undeclared

### makeNameCodeSilently

    public final int makeNameCodeSilently(String qname,
                                          boolean useDefault)
                                   throws XPathException,
                                          QNameException

  Make a NameCode, using the static context for namespace resolution. This variant of the method does not call "grumble" to report any errors to the ErrorListener, it only reports errors by throwing exceptions. This allows the caller to control the message output.

  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:
    `XPathException` - if the name is invalid, or the prefix undeclared
    `QNameException` - if the name is not a lexically valid QName

### makeStructuredQName

    public final StructuredQName makeStructuredQName(String qname,
                                                     boolean useDefault)
                                              throws XPathException

  Make a Structured QName, using the static context for namespace resolution

  Parameters:
    `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).
  Returns:
    the QName as an instance of StructuredQName
  Throws:
    `XPathException` - if the name is invalid, or the prefix undeclared

### makeNodeName

    public final NodeName makeNodeName(String qname,
                                       boolean useDefault)
                                throws XPathException,
                                       QNameException

  Make a FingerprintedQName, using the static context for namespace resolution

  Parameters:
    `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).
  Returns:
    the fingerprinted QName
  Throws:
    `XPathException` - if the name is invalid, or the prefix undeclared
    `QNameException` - if the supplied qname is not a lexically valid QName

### makeNameTest

    public NameTest makeNameTest(short nodeType,
                                 String qname,
                                 boolean useDefault)
                          throws XPathException

  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; alternatively, a QName in Clark notation ({uri}local)
    `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:
    `XPathException` - if the QName is invalid

### makeNamespaceTest

    public NamespaceTest makeNamespaceTest(short nodeType,
                                           String prefix)
                                    throws XPathException

  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:
    `XPathException` - if the namespace prefix is not declared

### makeLocalNameTest

    public LocalNameTest makeLocalNameTest(short nodeType,
                                           String localName)
                                    throws XPathException

  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:
    `XPathException` - if the local name is invalid

### 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.

  Parameters:
    `exp` - the expression whose location information is to be set

### setLocation

    public 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.

  Parameters:
    `exp` - the expression whose location information is to be set
    `offset` - the character position within the expression (ignoring newlines)

### makeTracer

    public Expression makeTracer(int startOffset,
                                 Expression exp,
                                 int construct,
                                 StructuredQName qName)

  If tracing, wrap an expression in a trace instruction

  Parameters:
    `startOffset` - the position of the expression in the soruce
    `exp` - the expression to be wrapped
    `construct` - integer constant identifying the kind of construct
    `qName` - the name of the construct (if applicable)
  Returns:
    the expression that does the tracing

### 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

### normalizeEQName

    protected String normalizeEQName(String s)
                              throws XPathException

  Normalize an EQName. This is written in the source code in the form "uri":local, but by the time it gets here it has been converted to Clark format {uri}local. This method collapses whitespace within the URI

  Parameters:
    `s` - the EQName in the form of a Clark name
  Returns:
    the normalized EQName
  Throws:
    `XPathException` - so that the XQuery implementation in a subclass can do so.

### setScanOnly

    public void setScanOnly(boolean scanOnly)

  Set that we are parsing in "scan only"

  Parameters:
    `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.

Overview | Package | Class | Tree | Deprecated | Index | Help
PREV CLASS NEXT CLASS | FRAMES NO FRAMES
SUMMARY: NESTED | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD

Copyright (c) 2004-2011 Saxonica Limited. All rights reserved.