Package net.sf.saxon.expr.parser

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

    • 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

      • 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

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

      • 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

      • 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