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

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

    public class PatternParser

extends ExpressionParser

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.ExpressionParser
`ExpressionParser.TemporaryContainer`

Field Summary

Fields inherited from class net.sf.saxon.expr.parser.ExpressionParser
`allowXPath30Syntax, defaultContainer, env, language, languageVersion, nameChecker, rangeVariables, scanOnly, SEQUENCE_TYPE, t, XPATH, XQUERY, XSLT_PATTERN`

Constructor Summary
`PatternParser()`

Method Summary
`protected void` | `customizeTokenizer(Tokenizer t)` Callback to tailor the tokenizer
`Expression` | `makeTracer(int startOffset, Expression exp, int construct, 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.
`protected Expression` | `parseFunctionCall()` Parse a function call appearing within a pattern.
`Pattern` | `parsePattern(String pattern, StaticContext env)` Parse a string representing an XSLT pattern
`protected Expression` | `parsePredicate()` Parse an expression appearing within a predicate.
`protected Expression` | `parseTypePattern()` Parse a type pattern of the form "~ ItemType" (introduced in XSLT 3.0)

Methods inherited from class net.sf.saxon.expr.parser.ExpressionParser
`atStartOfRelativePath, currentTokenDisplay, declareRangeVariable, disallowedAtStartOfRelativePath, expect, findRangeVariable, getCodeInjector, getDefaultContainer, getLanguage, getNameChecker, getRangeVariables, getStaticContext, getTokenizer, grumble, grumble, grumble, grumble, grumble, isKeyword, isNamespaceTestAllowed, makeCurriedFunction, makeLocalNameTest, makeNameCode, makeNameCodeSilently, makeNamespaceTest, makeNameTest, makeNodeName, makeStringLiteral, makeStructuredQName, nextToken, normalizeEQName, parse, parseBinaryExpression, parseConstructor, parseDynamicFunctionCall, parseExprSingle, parseExtensionExpression, parseFLWORExpression, parseFunctionItemType, parseInlineFunction, parseItemType, parseLiteralFunctionItem, parseMapExpression, parseMapItemType, parseNodeTest, parseNumericLiteral, parseParenthesizedItemType, parsePathExpression, parseRelativePath, parseRemainingPath, parseSequenceType, parseSequenceType, parseStepExpression, parseStringLiteral, parseSwitchExpression, parseTryCatchExpression, parseTypeswitchExpression, parseValidateExpression, parseVariableReference, reportMissingFunction, resolveFunctionName, setCodeInjector, setDefaultContainer, setLanguage, setLocation, setLocation, setRangeVariables, setRangeVariableStack, setScanOnly, undeclareRangeVariable, warning`

Methods inherited from class java.lang.Object
`clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait`

Constructor Detail

### PatternParser

    public PatternParser()

Method Detail

### parsePattern

    public Pattern parsePattern(String pattern,
                                StaticContext env)
                         throws XPathException

  Parse a string representing an XSLT pattern

  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 `ExpressionParser`
  Parameters:
    `t` - the Tokenizer to be customized

### parseExpression

    public Expression parseExpression()
                               throws XPathException

  Override the parsing of top-level expressions

  Overrides:
    `parseExpression` in class `ExpressionParser`
  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 `ExpressionParser`
  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

### parseTypePattern

    protected Expression parseTypePattern()
                                   throws XPathException

  Parse a type pattern of the form "~ ItemType" (introduced in XSLT 3.0)

  Overrides:
    `parseTypePattern` in class `ExpressionParser`
  Returns:
    the type pattern, wrapped in a PatternSponsor to satisfy the parsing interface
  Throws:
    `XPathException` - if any error is found, for example if XSLT 3.0 is not enabled

### 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 `ExpressionParser`
  Returns:
    the parsed expression that appears within the predicate
  Throws:
    `XPathException`

### parseFunctionCall

    protected Expression parseFunctionCall()
                                    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 `ExpressionParser`
  Returns:
    the expression that results from the parsing (usually a FunctionCall)
  Throws:
    `XPathException`

### parseFunctionArgument

    public Expression parseFunctionArgument()
                                     throws XPathException

  Description copied from class: `ExpressionParser`
  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 `ExpressionParser`
  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(int startOffset,
                                 Expression exp,
                                 int construct,
                                 StructuredQName qName)

  Description copied from class: `ExpressionParser`
  If tracing, wrap an expression in a trace instruction

  Overrides:
    `makeTracer` in class `ExpressionParser`
  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

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.