Package net.sf.saxon.pattern

## Class PatternParser30

- java.lang.Object
- - net.sf.saxon.expr.parser.XPathParser
  - - net.sf.saxon.pattern.PatternParser30

- All Implemented Interfaces:
    `PatternParser`

      public class PatternParser30
      extends XPathParser
      implements PatternParser

  Parser for XSLT patterns. This is created by overriding selected parts of the standard ExpressionParser.

- - ### Nested Class Summary

    - ### Nested classes/interfaces inherited from class net.sf.saxon.expr.parser.XPathParser

      `XPathParser.Accelerator, XPathParser.NestedLocation, XPathParser.ParsedLanguage`

  - ### Field Summary

    - ### Fields inherited from class net.sf.saxon.expr.parser.XPathParser

      `allowSaxonExtensions, allowXPath30Syntax, allowXPath30XSLTExtensions, allowXPath31Syntax, catchDepth, charChecker, codeInjector, env, language, languageVersion, parserExtension, qNameParser, rangeVariables, scanOnly, t`

  - ### Constructor Summary

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

  - ### Method Summary

    All Methods Instance Methods Concrete Methods
    Modifier and Type | Method | Description
    --- | --- | ---
    `protected void` | `customizeTokenizer​(Tokenizer t)` | Callback to tailor the tokenizer
    `Expression` | `makeTracer​(Expression exp, StructuredQName qName)` | If tracing, wrap an expression in a trace instruction
    `protected Expression` | `parseBasicStep​(boolean firstInPattern)` | Parse a basic step expression (without the predicates)
    `Expression` | `parseExpression()` | Override the parsing of top-level expressions
    `Expression` | `parseFunctionArgument()` | Parse an argument to a function call.
    `Expression` | `parseFunctionCall​(Expression prefixArgument)` | Parse a function call appearing within a pattern.
    `Pattern` | `parsePattern​(java.lang.String pattern, StaticContext env)` | Parse a string representing an XSLT pattern
    `protected Expression` | `parsePredicate()` | Parse an expression appearing within a predicate.
    `protected void` | `testPermittedAxis​(int axis, java.lang.String errorCode)` |

    - ### Methods inherited from class net.sf.saxon.expr.parser.XPathParser

      `atStartOfRelativePath, checkLanguageVersion30, checkLanguageVersion31, checkMapExtensions, checkSyntaxExtensions, currentTokenDisplay, declareRangeVariable, disallowedAtStartOfRelativePath, expect, findRangeVariable, generateApplyCall, getCodeInjector, getLanguage, getMissingFunctionExplanation, getPlainType, getQNameParser, getRangeVariables, getStaticContext, getTokenizer, grumble, grumble, grumble, grumble, isAllowAbsentExpression, isAllowXPath31Syntax, isKeyword, isNamespaceTestAllowed, isReservedFunctionName30, isReservedFunctionName31, isReservedInQuery, makeCurriedFunction, makeFingerprint, makeLocalNameTest, makeLocation, makeLocation, makeNamespaceTest, makeNameTest, makeNestedLocation, makeNodeName, makeQNameTest, makeStringLiteral, makeStructuredQName, makeStructuredQNameSilently, nextToken, operatorPrecedence, parse, parseAnnotationsList, parseArrayCurlyConstructor, parseArrayItemType, parseArraySquareConstructor, parseArrowPostfix, parseBackTickedStringLiteral, parseBinaryExpression, parseConstructor, parseDynamicFunctionCall, parseExprSingle, parseExtendedItemType, parseExtendedSequenceType, parseExtensionExpression, parseFLWORExpression, parseFunctionItemType, parseInlineFunction, parseItemType, parseLookup, parseMapExpression, parseMapItemType, parseNamedFunctionReference, parseNodeTest, parseNumericLiteral, parseParenthesizedExpression, parsePathExpression, parsePredicate, parseRelativePath, parseRemainingPath, parseSequenceType, parseSequenceType, parseSimpleMappingExpression, parseStepExpression, parseStringConstructor, parseStringLiteral, parseSwitchExpression, parseTryCatchExpression, parseTypeswitchExpression, parseValidateExpression, parseVariableReference, reportMissingFunction, resolveFunctionName, setAccelerator, setAllowAbsentExpression, setCatchDepth, setCodeInjector, setLanguage, setLocation, setLocation, setLocation, setParserExtension, setQNameParser, setRangeVariables, setRangeVariableStack, setScanOnly, undeclareRangeVariable, unescape, warning, whyDisallowedType`

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

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

- - ### Constructor Detail

    - #### PatternParser30

          public PatternParser30()

  - ### Method Detail

    - #### parsePattern

          public Pattern parsePattern​(java.lang.String pattern,
                                      StaticContext env)
                               throws XPathException

      Parse a string representing an XSLT pattern
      Specified by:
        `parsePattern` in interface `PatternParser`
      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:
        `XPathException` - if the pattern contains a syntax error

    - #### customizeTokenizer

          protected void customizeTokenizer​(Tokenizer t)

      Callback to tailor the tokenizer
      Overrides:
        `customizeTokenizer` in class `XPathParser`
      Parameters:
        `t` - the Tokenizer to be customized

    - #### parseExpression

          public Expression parseExpression()
                                     throws XPathException

      Override the parsing of top-level expressions
      Overrides:
        `parseExpression` in class `XPathParser`
      Returns:
        the parsed expression
      Throws:
        `XPathException`

    - #### parseBasicStep

          protected Expression parseBasicStep​(boolean firstInPattern)
                                       throws XPathException

      Parse a basic step expression (without the predicates)
      Overrides:
        `parseBasicStep` in class `XPathParser`
      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

    - #### testPermittedAxis

          protected void testPermittedAxis​(int axis,
                                           java.lang.String errorCode)
                                    throws XPathException

      Overrides:
        `testPermittedAxis` in class `XPathParser`
      Throws:
        `XPathException`

    - #### parsePredicate

          protected Expression parsePredicate()
                                       throws XPathException

      Parse an expression appearing within a predicate. This enables full XPath parsing, without the normal rules that apply within an XSLT pattern
      Overrides:
        `parsePredicate` in class `XPathParser`
      Returns:
        the parsed expression that appears within the predicate
      Throws:
        `XPathException`

    - #### parseFunctionCall

          public Expression parseFunctionCall​(Expression prefixArgument)
                                       throws XPathException

      Parse a function call appearing within a pattern. Unless within a predicate, this imposes the constraints on which function calls are allowed to appear in a pattern
      Overrides:
        `parseFunctionCall` in class `XPathParser`
      Parameters:
        `prefixArgument` -
      Returns:
        the expression that results from the parsing (usually a FunctionCall)
      Throws:
        `XPathException`

    - #### parseFunctionArgument

          public Expression parseFunctionArgument()
                                           throws XPathException

      Description copied from class: `XPathParser`
      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.
      Overrides:
        `parseFunctionArgument` in class `XPathParser`
      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

    - #### makeTracer

          public Expression makeTracer​(Expression exp,
                                       StructuredQName qName)

      Description copied from class: `XPathParser`
      If tracing, wrap an expression in a trace instruction
      Overrides:
        `makeTracer` in class `XPathParser`
      Parameters:
        `exp` - the expression to be wrapped
        `qName` - the name of the construct (if applicable)
      Returns:
        the expression that does the tracing