Package net.sf.saxon.expr.parser

## Class ParserExtension

- java.lang.Object
- - net.sf.saxon.expr.parser.ParserExtension

- Direct Known Subclasses:
    `SaxonSyntaxExtension`

      public class ParserExtension
      extends java.lang.Object

  Dummy Parser extension for syntax in XPath that is accepted only in particular product variants. Originally, this meant XPath 3.0 syntax associated with higher-order functions. It now covers Saxon syntax extensions and XQuery Update.

- - ### Nested Class Summary

    Nested Classes
    Modifier and Type | Class | Description
    --- | --- | ---
    `static class` | `ParserExtension.InlineFunctionDetails` |
    `static class` | `ParserExtension.TemporaryXSLTVariableBinding` |

  - ### Field Summary

    Fields
    Modifier and Type | Field | Description
    --- | --- | ---
    `protected java.util.Stack<ParserExtension.InlineFunctionDetails>` | `inlineFunctionStack` |

  - ### Constructor Summary

    Constructors
    Constructor | Description
    --- | ---
    `ParserExtension()` |

  - ### Method Summary

    All Methods Static Methods Instance Methods Concrete Methods
    Modifier and Type | Method | Description
    --- | --- | ---
    `Expression` | `bindNumericParameterReference​(XPathParser p)` |
    `Expression` | `createDynamicCurriedFunction​(XPathParser p, Expression functionItem, java.util.ArrayList<Expression> args, IntSet placeMarkers)` |
    `static Expression` | `curryFunction​(Expression functionExp, Expression[] args, IntSet placeMarkers)` | Process a function expression in which one or more of the argument positions are represented as "?" placemarkers (indicating partial application or currying)
    `LocalBinding` | `findOuterRangeVariable​(XPathParser p, StructuredQName qName)` | Locate a range variable with a given name.
    `static LocalBinding` | `findOuterRangeVariable​(StructuredQName qName, java.util.Stack<ParserExtension.InlineFunctionDetails> inlineFunctionStack, StaticContext env)` | When a variable reference occurs within an inline function, it might be a reference to a variable declared outside the inline function (which needs to become part of the closure).
    `void` | `handleExternalFunctionDeclaration​(XQueryParser p, XQueryFunction func)` |
    `Expression` | `makeArgumentPlaceMarker​(XPathParser p)` | Parse a function argument.
    `Expression` | `makeCurriedFunction​(XPathParser parser, 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)
    `static Expression` | `makeInlineFunctionValue​(XPathParser p, AnnotationList annotations, ParserExtension.InlineFunctionDetails details, java.util.List<UserFunctionParameter> params, SequenceType resultType, Expression body)` |
    `Expression` | `parseDotFunction​(XPathParser p)` |
    `protected Expression` | `parseExtendedExprSingle​(XPathParser p)` |
    `ItemType` | `parseExtendedItemType​(XPathParser p)` | Parse an ItemType within a SequenceType
    `protected Expression` | `parseForMemberExpression​(XPathParser p)` | Parse a for-member expression (Saxon extension): for member $x in expr return expr
    `ItemType` | `parseFunctionItemType​(XPathParser p, AnnotationList annotations)` | Parse the item type used for function items (XQuery 3.0 higher order functions) Syntax (changed by WG decision on 2009-09-22): function '(' '*' ') | function '(' (SeqType (',' SeqType)*)? ')' 'as' SeqType For backwards compatibility with Saxon 9.2 we allow the "*" to be omitted for the time being The "function(" has already been read
    `protected Expression` | `parseInlineFunction​(XPathParser p, AnnotationList annotations)` |
    `Expression` | `parseNamedFunctionReference​(XPathParser p)` | Parse a literal function item (function#arity).
    `void` | `parseRevalidationDeclaration​(XQueryParser p)` | Parse the "declare revalidation" declaration.
    `void` | `parseTypeAliasDeclaration​(XQueryParser p)` | Parse a type alias declaration.
    `Expression` | `parseTypePattern​(XPathParser p)` | Parse an extended XSLT pattern in the form ~itemType (predicate)*
    `Expression` | `parseUnderscoreFunction​(XPathParser p)` |
    `void` | `parseUpdatingFunctionDeclaration​(XQueryParser p)` | Parse an updating function declaration (allowed in XQuery Update only)

    - ### Methods inherited from class java.lang.Object

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

- - ### Field Detail

    - #### inlineFunctionStack

          protected java.util.Stack<ParserExtension.InlineFunctionDetails> inlineFunctionStack

  - ### Constructor Detail

    - #### ParserExtension

          public ParserExtension()

  - ### Method Detail

    - #### parseNamedFunctionReference

          public Expression parseNamedFunctionReference​(XPathParser p)
                                                 throws XPathException

      Parse a literal function item (function#arity). On entry, the function name and the '#' token have already been read
      Parameters:
        `p` - the parser
      Returns:
        an expression representing the function value
      Throws:
        `XPathException` - in the event of a syntax error

    - #### parseFunctionItemType

          public ItemType parseFunctionItemType​(XPathParser p,
                                                AnnotationList annotations)
                                         throws XPathException

      Parse the item type used for function items (XQuery 3.0 higher order functions) Syntax (changed by WG decision on 2009-09-22): function '(' '*' ') | function '(' (SeqType (',' SeqType)*)? ')' 'as' SeqType For backwards compatibility with Saxon 9.2 we allow the "*" to be omitted for the time being The "function(" has already been read
      Parameters:
        `annotations` - the list of annotation assertions for this function item type
      Throws:
        `XPathException`

    - #### parseExtendedItemType

          public ItemType parseExtendedItemType​(XPathParser p)
                                         throws XPathException

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

    - #### parseTypePattern

          public Expression parseTypePattern​(XPathParser p)
                                      throws XPathException

      Parse an extended XSLT pattern in the form ~itemType (predicate)*
      Returns:
        the equivalent expression in the form .[. instance of type] (predicate)*
      Throws:
        `XPathException`

    - #### makeArgumentPlaceMarker

          public Expression makeArgumentPlaceMarker​(XPathParser p)

      Parse a function argument. The special marker "?" is allowed and causes "null" to be returned

    - #### parseInlineFunction

          protected Expression parseInlineFunction​(XPathParser p,
                                                   AnnotationList annotations)
                                            throws XPathException

      Throws:
        `XPathException`

    - #### makeInlineFunctionValue

          public static Expression makeInlineFunctionValue​(XPathParser p,
                                                           AnnotationList annotations,
                                                           ParserExtension.InlineFunctionDetails details,
                                                           java.util.List<UserFunctionParameter> params,
                                                           SequenceType resultType,
                                                           Expression body)

    - #### parseDotFunction

          public Expression parseDotFunction​(XPathParser p)
                                      throws XPathException

      Throws:
        `XPathException`

    - #### parseUnderscoreFunction

          public Expression parseUnderscoreFunction​(XPathParser p)
                                             throws XPathException

      Throws:
        `XPathException`

    - #### bindNumericParameterReference

          public Expression bindNumericParameterReference​(XPathParser p)
                                                   throws XPathException

      Throws:
        `XPathException`

    - #### makeCurriedFunction

          public Expression makeCurriedFunction​(XPathParser parser,
                                                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` - offset in the query source of the start of the expression
        `name` - the function call (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
      Throws:
        `XPathException` - if a dynamic error occurs

    - #### curryFunction

          public static Expression curryFunction​(Expression functionExp,
                                                 Expression[] args,
                                                 IntSet placeMarkers)

      Process a function expression in which one or more of the argument positions are represented as "?" placemarkers (indicating partial application or currying)
      Parameters:
        `functionExp` - an expression that returns the function to be curried
        `args` - the arguments (with EmptySequence in the placemarker positions)
        `placeMarkers` - the positions of the placemarkers
      Returns:
        the curried function

    - #### findOuterRangeVariable

          public LocalBinding findOuterRangeVariable​(XPathParser p,
                                                     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

    - #### findOuterRangeVariable

          public static LocalBinding findOuterRangeVariable​(StructuredQName qName,
                                                            java.util.Stack<ParserExtension.InlineFunctionDetails> inlineFunctionStack,
                                                            StaticContext env)

      When a variable reference occurs within an inline function, it might be a reference to a variable declared outside the inline function (which needs to become part of the closure). This code looks for such an outer variable
      Parameters:
        `qName` - the name of the variable
        `inlineFunctionStack` - the stack of inline functions that we are within
        `env` - the static context
      Returns:
        a binding for the variable; this will typically be a binding to a newly added parameter for the innermost function in which the variable reference appears. As a side effect, all the inline functions between the declaration of the variable and its use will have this variable as an additional parameter, each one bound to the corresponding parameter in the containing function.

    - #### createDynamicCurriedFunction

          public Expression createDynamicCurriedFunction​(XPathParser p,
                                                         Expression functionItem,
                                                         java.util.ArrayList<Expression> args,
                                                         IntSet placeMarkers)

    - #### handleExternalFunctionDeclaration

          public void handleExternalFunctionDeclaration​(XQueryParser p,
                                                        XQueryFunction func)
                                                 throws XPathException

      Throws:
        `XPathException`

    - #### parseTypeAliasDeclaration

          public void parseTypeAliasDeclaration​(XQueryParser p)
                                         throws XPathException

      Parse a type alias declaration. Allowed only in Saxon-PE and higher
      Throws:
        `XPathException` - if parsing fails

    - #### parseRevalidationDeclaration

          public void parseRevalidationDeclaration​(XQueryParser p)
                                            throws XPathException

      Parse the "declare revalidation" declaration. Syntax: not allowed unless XQuery update is in use
      Throws:
        `XPathException` - if the syntax is incorrect, or is not allowed in this XQuery processor

    - #### parseUpdatingFunctionDeclaration

          public void parseUpdatingFunctionDeclaration​(XQueryParser p)
                                                throws XPathException

      Parse an updating function declaration (allowed in XQuery Update only)
      Throws:
        `XPathException` - if parsing fails or if updating functions are not allowed

    - #### parseExtendedExprSingle

          protected Expression parseExtendedExprSingle​(XPathParser p)
                                                throws XPathException

      Throws:
        `XPathException`

    - #### parseForMemberExpression

          protected Expression parseForMemberExpression​(XPathParser p)
                                                 throws XPathException

      Parse a for-member expression (Saxon extension): for member $x in expr return expr
      Returns:
        the resulting subexpression
      Throws:
        `XPathException` - if any error is encountered