PythonRegexLexer

java.lang.Object
- com.oracle.truffle.regex.tregex.parser.RegexLexer
- - com.oracle.truffle.regex.tregex.parser.flavors.PythonRegexLexer

public final class PythonRegexLexer
extends RegexLexer

Nested Class Summary
- Nested classes/interfaces inherited from class com.oracle.truffle.regex.tregex.parser.RegexLexer
  RegexLexer.ClassSetOperator, RegexLexer.ParseGroupNameResult, RegexLexer.ParseGroupNameResultState

Field Summary
- Fields inherited from class com.oracle.truffle.regex.tregex.parser.RegexLexer
  compilationBuffer, DEFAULT_WHITESPACE, namedCaptureGroups, pattern, position, PREDEFINED_CHAR_CLASSES, source

Constructor Summary

Constructors
Constructor and Description

PythonRegexLexer(RegexSource source, PythonREMode mode, CompilationBuffer compilationBuffer)

Constructors
Constructor and Description
`PythonRegexLexer(RegexSource source, PythonREMode mode, CompilationBuffer compilationBuffer)`

Method Summary

All Methods Instance Methods Concrete Methods
Modifier and Type	Method and Description
`void`	`addGlobalFlags(PythonFlags newGlobalFlags)`
`protected long`	`boundedQuantifierMaxValue()` The maximum value allowed while parsing bounded quantifiers.
`protected ClassSetContents`	`caseFoldClassSetAtom(ClassSetContents classSetContents)` Case folds an atom in a class set expression.
`protected void`	`caseFoldUnfold(CodePointSetAccumulator charClass)` Updates a character set by expanding it to the set of characters that case fold to the same characters as the characters currently in the set.
`protected void`	`checkClassSetCharacter(int codePoint)` Checks whether `codepoint` can appear as an unescaped literal class set character.
`protected CodePointSet`	`complementClassSet(CodePointSet codePointSet)` Returns the complement of a class set element.
`protected boolean`	`featureEnabledAZPositionAssertions()` Returns `true` if `\A` and `\Z` position assertions are supported.
`protected boolean`	`featureEnabledBoundedQuantifierEmptyMin()` Returns `true` if empty minimum values in bounded quantifiers (e.g.
`protected boolean`	`featureEnabledCharClassFirstBracketIsLiteral()` Returns `true` if the first character in a character class must be interpreted as part of the character set, even if it is the closing bracket `']'`.
`protected boolean`	`featureEnabledClassSetExpressions()` Returns `true` if class set expressions (e.g.
`protected boolean`	`featureEnabledForwardReferences()` Returns `true` if forward references are allowed.
`protected boolean`	`featureEnabledGroupComments()` Returns `true` if group comments (e.g.
`protected boolean`	`featureEnabledIgnoreCase()` Returns `true` if ignore-case mode is currently enabled.
`protected boolean`	`featureEnabledIgnoreWhiteSpace()` Returns `true` if white space in the pattern is ignored.
`protected boolean`	`featureEnabledLineComments()` Returns `true` if line comments (e.g.
`protected boolean`	`featureEnabledNestedCharClasses()` Returns `true` if nested character classes are supported.
`protected boolean`	`featureEnabledOctalEscapes()` Returns `true` if octal escapes (e.g.
`protected boolean`	`featureEnabledPOSIXCharClasses()` Returns `true` if POSIX character classes, character equivalence classes, and the POSIX Collating Element Operator are supported.
`protected boolean`	`featureEnabledPossessiveQuantifiers()` Returns `true` if possessive quantifiers (`+` suffix) are allowed.
`protected boolean`	`featureEnabledSpecialGroups()` Returns `true` if any constructs that alter a capture group's function, such as non-capturing groups `(?:)` or look-around assertions `(?=)`, are supported.
`protected boolean`	`featureEnabledUnicodePropertyEscapes()` Returns `true` if unicode property escapes (e.g.
`protected boolean`	`featureEnabledWordBoundaries()` Returns `true` if `\w` and `\W` word boundary position assertions are supported.
`protected boolean`	`featureEnabledZLowerCaseAssertion()` Returns `true` if `\z` position assertion is supported.
`void`	`fixFlags()`
`protected CodePointSet`	`getDotCodePointSet()` Returns the code point set represented by the dot operator.
`PythonFlags`	`getGlobalFlags()`
`protected CodePointSet`	`getIdContinue()` Returns the set of all codepoints a group identifier may continue with.
`protected CodePointSet`	`getIdStart()` Returns the set of all codepoints a group identifier may begin with.
`PythonLocaleData`	`getLocaleData()`
`PythonFlags`	`getLocalFlags()`
`protected int`	`getMaxBackReferenceDigits()` Returns the maximum number of digits to parse when parsing a back-reference.
`protected CodePointSet`	`getPOSIXCharClass(String name)` Returns the POSIX character class associated to the given name.
`protected CodePointSet`	`getPredefinedCharClass(char c)` Returns the CodePointSet associated with the given predefined character class (e.g.
`protected TBitSet`	`getWhitespace()` The set of codepoints to consider as whitespace in comments and "ignore white space" mode.
`protected RegexSyntaxException`	`handleBoundedQuantifierOutOfOrder()` Handle `{2,1}`.
`protected Token`	`handleBoundedQuantifierOverflow(long min, long max)` Handle integer overflows in quantifier bounds, e.g.
`protected Token`	`handleBoundedQuantifierOverflowMin(long min, long max)` Handle integer overflows in quantifier bounds, e.g.
`protected Token`	`handleBoundedQuantifierSyntaxError()` Handle syntax errors in bounded quantifiers (missing }, non-digit characters).
`protected RegexSyntaxException`	`handleCCRangeOutOfOrder(int rangeStart)` Handle out of order character class range elements, e.g.
`protected void`	`handleCCRangeWithPredefCharClass(int rangeStart, ClassSetContents firstAtom, ClassSetContents secondAtom)` Handle non-codepoint character class range elements, e.g.
`protected RegexSyntaxException`	`handleComplementOfStringSet()` Handle complement of class set expressions containing strings, e.g.
`protected RegexSyntaxException`	`handleEmptyGroupName()` Handle empty group name in group references.
`protected void`	`handleGroupRedefinition(String name, int newId, int oldId)`
`protected void`	`handleIncompleteEscapeX()` Handle incomplete hex escapes, e.g.
`protected void`	`handleInvalidBackReference(int reference)` Handle group references to non-existent groups.
`protected void`	`handleInvalidBackReference(String reference)` Handle group references to non-existent groups.
`protected RegexSyntaxException`	`handleInvalidCharInCharClass()`
`protected RegexSyntaxException`	`handleInvalidGroupBeginQ()` Handle groups starting with `(?` and invalid next char.
`protected RegexSyntaxException`	`handleMissingClassSetOperand(RegexLexer.ClassSetOperator operator)` Handle missing operands in class set expressions, e.g.
`protected RegexSyntaxException`	`handleMixedClassSetOperators(RegexLexer.ClassSetOperator leftOperator, RegexLexer.ClassSetOperator rightOperator)` Handle class set expressions with mixed set operators in the same nested set.
`protected void`	`handleOctalOutOfRange()` Handle octal values larger than 255.
`protected RegexSyntaxException`	`handleRangeAsClassSetOperand(RegexLexer.ClassSetOperator operator)` Handle character ranges as operands in class set expressions with operators other than union.
`protected void`	`handleUnfinishedEscape()` Handle unfinished escape (e.g.
`protected void`	`handleUnfinishedGroupComment()` Handle unfinished group comment `(#...)`.
`protected RegexSyntaxException`	`handleUnfinishedGroupQ()` Handle unfinished group with question mark `(?`.
`protected RegexSyntaxException`	`handleUnfinishedRangeInClassSet()` Handle unfinished range in class set expression `[a-]`.
`protected RegexSyntaxException`	`handleUnmatchedLeftBracket()` Handle unmatched `[`.
`protected void`	`handleUnmatchedRightBrace()` Handle unmatched }.
`protected void`	`handleUnmatchedRightBracket()` Handle unmatched `]`.
`protected int`	`parseCodePointInGroupName()` Parse the next codepoint in a group name and return it.
`protected Token`	`parseCustomEscape(char c)` Parse any escape sequence starting with `\` and the argument `c`.
`protected int`	`parseCustomEscapeChar(char c, boolean inCharClass)` Parse an escape character sequence (inside character class, or other escapes have already been tried) starting with `\` and the argument {code c}.
`protected int`	`parseCustomEscapeCharFallback(int c, boolean inCharClass)` Parse an escape character sequence (inside character class, or other escapes have already been tried) starting with `\` and the code point `c`.This method is called after all other means of parsing the escape sequence have been exhausted.
`protected Token`	`parseCustomGroupBeginQ(char charAfterQuestionMark)` Parse group starting with `(?`.
`protected Token`	`parseGroupLt()` Parse group starting with `(<`.
`void`	`popLocalFlags()`
`void`	`pushLocalFlags(PythonFlags localFlags)`
`RegexSyntaxException`	`syntaxErrorAtAbs(String msg, int i)`
`RegexSyntaxException`	`syntaxErrorHere(String msg)`
`protected void`	`validatePOSIXCollationElement(String sequence)` Checks if the given string is a valid collation element.
`protected void`	`validatePOSIXEquivalenceClass(String sequence)` Checks if the given string is a valid equivalence class.

Methods inherited from class com.oracle.truffle.regex.tregex.parser.RegexLexer
advance, advance, atEnd, consumeChar, consumingLookahead, consumingLookahead, count, count, countDecimalDigits, countFrom, countUpTo, curChar, findChars, finishSurrogatePair, getLastAtomPosition, getLastCharacterClassBeginPosition, getLastTokenPosition, getNamedCaptureGroups, hasNamedCaptureGroups, hasNext, inCharacterClass, isAscii, isCurCharClassInverted, isDecimalDigit, isEscaped, isHexDigit, isOctalDigit, isPredefCharClass, literalChar, lookahead, lookahead, lookbehind, next, numberOfCaptureGroupsSoFar, parseGroupName, parseIntSaturated, parseIntSaturated, parseOctal, registerNamedCaptureGroup, retreat, syntaxError, totalNumberOfCaptureGroups

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

- Constructor Detail
  - PythonRegexLexer
```
public PythonRegexLexer(RegexSource source,
                        PythonREMode mode,
                        CompilationBuffer compilationBuffer)
```
- Method Detail
  - getLocaleData
```
public PythonLocaleData getLocaleData()
```
  - fixFlags
```
public void fixFlags()
```
  - getGlobalFlags
```
public PythonFlags getGlobalFlags()
```
  - addGlobalFlags
```
public void addGlobalFlags(PythonFlags newGlobalFlags)
```
  - getLocalFlags
```
public PythonFlags getLocalFlags()
```
  - pushLocalFlags
```
public void pushLocalFlags(PythonFlags localFlags)
```
  - popLocalFlags
```
public void popLocalFlags()
```
  - featureEnabledIgnoreCase
```
protected boolean featureEnabledIgnoreCase()
```
    Description copied from class: RegexLexer
    
    Returns true if ignore-case mode is currently enabled.
    
    Specified by:
    
    featureEnabledIgnoreCase in class RegexLexer
  - featureEnabledAZPositionAssertions
```
protected boolean featureEnabledAZPositionAssertions()
```
    Description copied from class: RegexLexer
    
    Returns true if \A and \Z position assertions are supported.
    
    Specified by:
    
    featureEnabledAZPositionAssertions in class RegexLexer
  - featureEnabledZLowerCaseAssertion
```
protected boolean featureEnabledZLowerCaseAssertion()
```
    Description copied from class: RegexLexer
    
    Returns true if \z position assertion is supported.
    
    Specified by:
    
    featureEnabledZLowerCaseAssertion in class RegexLexer
  - featureEnabledWordBoundaries
```
protected boolean featureEnabledWordBoundaries()
```
    Description copied from class: RegexLexer
    
    Returns true if \w and \W word boundary position assertions are supported.
    
    Specified by:
    
    featureEnabledWordBoundaries in class RegexLexer
  - featureEnabledBoundedQuantifierEmptyMin
```
protected boolean featureEnabledBoundedQuantifierEmptyMin()
```
    Description copied from class: RegexLexer
    
    Returns true if empty minimum values in bounded quantifiers (e.g. {,1}) are allowed and treated as zero.
    
    Specified by:
    
    featureEnabledBoundedQuantifierEmptyMin in class RegexLexer
  - featureEnabledPossessiveQuantifiers
```
protected boolean featureEnabledPossessiveQuantifiers()
```
    Description copied from class: RegexLexer
    
    Returns true if possessive quantifiers (+ suffix) are allowed.
    
    Specified by:
    
    featureEnabledPossessiveQuantifiers in class RegexLexer
  - featureEnabledCharClassFirstBracketIsLiteral
```
protected boolean featureEnabledCharClassFirstBracketIsLiteral()
```
    Description copied from class: RegexLexer
    
    Returns true if the first character in a character class must be interpreted as part of the character set, even if it is the closing bracket ']'.
    
    Specified by:
    
    featureEnabledCharClassFirstBracketIsLiteral in class RegexLexer
  - featureEnabledNestedCharClasses
```
protected boolean featureEnabledNestedCharClasses()
```
    Description copied from class: RegexLexer
    
    Returns true if nested character classes are supported. This is required for RegexLexer.featureEnabledPOSIXCharClasses() .
    
    Specified by:
    
    featureEnabledNestedCharClasses in class RegexLexer
  - featureEnabledPOSIXCharClasses
```
protected boolean featureEnabledPOSIXCharClasses()
```
    Description copied from class: RegexLexer
    
    Returns true if POSIX character classes, character equivalence classes, and the POSIX Collating Element Operator are supported. Requires RegexLexer.featureEnabledNestedCharClasses().
    
    Specified by:
    
    featureEnabledPOSIXCharClasses in class RegexLexer
  - featureEnabledForwardReferences
```
protected boolean featureEnabledForwardReferences()
```
    Description copied from class: RegexLexer
    
    Returns true if forward references are allowed.
    
    Specified by:
    
    featureEnabledForwardReferences in class RegexLexer
  - featureEnabledGroupComments
```
protected boolean featureEnabledGroupComments()
```
    Description copied from class: RegexLexer
    
    Returns true if group comments (e.g. (# ... )) are supported.
    
    Specified by:
    
    featureEnabledGroupComments in class RegexLexer
  - featureEnabledLineComments
```
protected boolean featureEnabledLineComments()
```
    Description copied from class: RegexLexer
    
    Returns true if line comments (e.g. # ... ) are supported.
    
    Specified by:
    
    featureEnabledLineComments in class RegexLexer
  - featureEnabledIgnoreWhiteSpace
```
protected boolean featureEnabledIgnoreWhiteSpace()
```
    Description copied from class: RegexLexer
    
    Returns true if white space in the pattern is ignored. This is relevant only if line comments are not supported.
    
    Specified by:
    
    featureEnabledIgnoreWhiteSpace in class RegexLexer
  - getWhitespace
```
protected TBitSet getWhitespace()
```
    Description copied from class: RegexLexer
    
    The set of codepoints to consider as whitespace in comments and "ignore white space" mode.
    
    Specified by:
    
    getWhitespace in class RegexLexer
  - featureEnabledOctalEscapes
```
protected boolean featureEnabledOctalEscapes()
```
    Description copied from class: RegexLexer
    
    Returns true if octal escapes (e.g. \012) are supported.
    
    Specified by:
    
    featureEnabledOctalEscapes in class RegexLexer
  - featureEnabledSpecialGroups
```
protected boolean featureEnabledSpecialGroups()
```
    Description copied from class: RegexLexer
    
    Returns true if any constructs that alter a capture group's function, such as non-capturing groups (?:) or look-around assertions (?=), are supported. If this flag is false, groups starting with a question mark (? do not have any special meaning.
    
    Specified by:
    
    featureEnabledSpecialGroups in class RegexLexer
  - featureEnabledUnicodePropertyEscapes
```
protected boolean featureEnabledUnicodePropertyEscapes()
```
    Description copied from class: RegexLexer
    
    Returns true if unicode property escapes (e.g. \p{...}) are supported.
    
    Specified by:
    
    featureEnabledUnicodePropertyEscapes in class RegexLexer
  - featureEnabledClassSetExpressions
```
protected boolean featureEnabledClassSetExpressions()
```
    Description copied from class: RegexLexer
    
    Returns true if class set expressions (e.g. [[\w\q{abc|xyz}]--[a-cx-z]]) are supported.
    
    Specified by:
    
    featureEnabledClassSetExpressions in class RegexLexer
  - getDotCodePointSet
```
protected CodePointSet getDotCodePointSet()
```
    Description copied from class: RegexLexer
    
    Returns the code point set represented by the dot operator.
    
    Specified by:
    
    getDotCodePointSet in class RegexLexer
  - getIdContinue
```
protected CodePointSet getIdContinue()
```
    Description copied from class: RegexLexer
    
    Returns the set of all codepoints a group identifier may continue with.
    
    Specified by:
    
    getIdContinue in class RegexLexer
  - getIdStart
```
protected CodePointSet getIdStart()
```
    Description copied from class: RegexLexer
    
    Returns the set of all codepoints a group identifier may begin with.
    
    Specified by:
    
    getIdStart in class RegexLexer
  - getMaxBackReferenceDigits
```
protected int getMaxBackReferenceDigits()
```
    Description copied from class: RegexLexer
    
    Returns the maximum number of digits to parse when parsing a back-reference.
    
    Specified by:
    
    getMaxBackReferenceDigits in class RegexLexer
  - caseFoldUnfold
```
protected void caseFoldUnfold(CodePointSetAccumulator charClass)
```
    Description copied from class: RegexLexer
    
    Updates a character set by expanding it to the set of characters that case fold to the same characters as the characters currently in the set. This is done by case folding the set and then "unfolding" it by finding all inverse case fold mappings.
    
    Specified by:
    
    caseFoldUnfold in class RegexLexer
  - complementClassSet
```
protected CodePointSet complementClassSet(CodePointSet codePointSet)
```
    Description copied from class: RegexLexer
    
    Returns the complement of a class set element. In ECMAScript, this behavior can vary with the flags.
    
    Specified by:
    
    complementClassSet in class RegexLexer
  - caseFoldClassSetAtom
```
protected ClassSetContents caseFoldClassSetAtom(ClassSetContents classSetContents)
```
    Description copied from class: RegexLexer
    
    Case folds an atom in a class set expression. This maps the elements of the expression into their case folded variant.
    
    Specified by:
    
    caseFoldClassSetAtom in class RegexLexer
  - getPredefinedCharClass
```
protected CodePointSet getPredefinedCharClass(char c)
```
    Description copied from class: RegexLexer
    
    Returns the CodePointSet associated with the given predefined character class (e.g. \d).
    Note that the CodePointSet returned by this function has already been case-folded and negated.
    
    Specified by:
    
    getPredefinedCharClass in class RegexLexer
  - checkClassSetCharacter
```
protected void checkClassSetCharacter(int codePoint)
                               throws RegexSyntaxException
```
    Description copied from class: RegexLexer
    
    Checks whether codepoint can appear as an unescaped literal class set character.
    
    Specified by:
    
    checkClassSetCharacter in class RegexLexer
    
    Throws:
    
    RegexSyntaxException
  - boundedQuantifierMaxValue
```
protected long boundedQuantifierMaxValue()
```
    Description copied from class: RegexLexer
    
    The maximum value allowed while parsing bounded quantifiers. Larger values will cause a call to RegexLexer.handleBoundedQuantifierOverflow(long, long).
    
    Specified by:
    
    boundedQuantifierMaxValue in class RegexLexer
  - handleBoundedQuantifierOutOfOrder
```
protected RegexSyntaxException handleBoundedQuantifierOutOfOrder()
```
    Description copied from class: RegexLexer
    
    Handle {2,1}.
    
    Specified by:
    
    handleBoundedQuantifierOutOfOrder in class RegexLexer
  - handleBoundedQuantifierSyntaxError
```
protected Token handleBoundedQuantifierSyntaxError()
                                            throws RegexSyntaxException
```
    Description copied from class: RegexLexer
    
    Handle syntax errors in bounded quantifiers (missing }, non-digit characters).
    
    Specified by:
    
    handleBoundedQuantifierSyntaxError in class RegexLexer
    
    Throws:
    
    RegexSyntaxException
  - handleBoundedQuantifierOverflow
```
protected Token handleBoundedQuantifierOverflow(long min,
                                                long max)
```
    Description copied from class: RegexLexer
    
    Handle integer overflows in quantifier bounds, e.g. {2147483649}. If this method returns a non-null value, it will be returned instead of the current quantifier.
    
    Specified by:
    
    handleBoundedQuantifierOverflow in class RegexLexer
  - handleBoundedQuantifierOverflowMin
```
protected Token handleBoundedQuantifierOverflowMin(long min,
                                                   long max)
```
    Description copied from class: RegexLexer
    
    Handle integer overflows in quantifier bounds, e.g. {2147483649}. If this method returns a non-null value, it will be returned instead of the current quantifier. This method is called when no explicit max value is present.
    
    Specified by:
    
    handleBoundedQuantifierOverflowMin in class RegexLexer
  - handleCCRangeOutOfOrder
```
protected RegexSyntaxException handleCCRangeOutOfOrder(int rangeStart)
```
    Description copied from class: RegexLexer
    
    Handle out of order character class range elements, e.g. [b-a].
    
    Specified by:
    
    handleCCRangeOutOfOrder in class RegexLexer
  - handleCCRangeWithPredefCharClass
```
protected void handleCCRangeWithPredefCharClass(int rangeStart,
                                                ClassSetContents firstAtom,
                                                ClassSetContents secondAtom)
```
    Description copied from class: RegexLexer
    
    Handle non-codepoint character class range elements, e.g. [\w-a].
    
    Specified by:
    
    handleCCRangeWithPredefCharClass in class RegexLexer
  - getPOSIXCharClass
```
protected CodePointSet getPOSIXCharClass(String name)
```
    Description copied from class: RegexLexer
    
    Returns the POSIX character class associated to the given name.
    
    Specified by:
    
    getPOSIXCharClass in class RegexLexer
  - validatePOSIXCollationElement
```
protected void validatePOSIXCollationElement(String sequence)
```
    Description copied from class: RegexLexer
    
    Checks if the given string is a valid collation element.
    
    Specified by:
    
    validatePOSIXCollationElement in class RegexLexer
  - validatePOSIXEquivalenceClass
```
protected void validatePOSIXEquivalenceClass(String sequence)
```
    Description copied from class: RegexLexer
    
    Checks if the given string is a valid equivalence class.
    
    Specified by:
    
    validatePOSIXEquivalenceClass in class RegexLexer
  - handleComplementOfStringSet
```
protected RegexSyntaxException handleComplementOfStringSet()
```
    Description copied from class: RegexLexer
    
    Handle complement of class set expressions containing strings, e.g. [^\q{abc}] or \P{RGI_Emoji}.
    
    Specified by:
    
    handleComplementOfStringSet in class RegexLexer
  - handleEmptyGroupName
```
protected RegexSyntaxException handleEmptyGroupName()
```
    Description copied from class: RegexLexer
    
    Handle empty group name in group references.
    
    Specified by:
    
    handleEmptyGroupName in class RegexLexer
  - handleGroupRedefinition
```
protected void handleGroupRedefinition(String name,
                                       int newId,
                                       int oldId)
```
    Specified by:
    
    handleGroupRedefinition in class RegexLexer
  - handleIncompleteEscapeX
```
protected void handleIncompleteEscapeX()
```
    Description copied from class: RegexLexer
    
    Handle incomplete hex escapes, e.g. \x1.
    
    Specified by:
    
    handleIncompleteEscapeX in class RegexLexer
  - handleInvalidBackReference
```
protected void handleInvalidBackReference(int reference)
```
    Description copied from class: RegexLexer
    
    Handle group references to non-existent groups.
    
    Specified by:
    
    handleInvalidBackReference in class RegexLexer
  - handleInvalidBackReference
```
protected void handleInvalidBackReference(String reference)
```
    Description copied from class: RegexLexer
    
    Handle group references to non-existent groups.
    
    Specified by:
    
    handleInvalidBackReference in class RegexLexer
  - handleInvalidCharInCharClass
```
protected RegexSyntaxException handleInvalidCharInCharClass()
```
    Specified by:
    
    handleInvalidCharInCharClass in class RegexLexer
  - handleInvalidGroupBeginQ
```
protected RegexSyntaxException handleInvalidGroupBeginQ()
```
    Description copied from class: RegexLexer
    
    Handle groups starting with (? and invalid next char.
    
    Specified by:
    
    handleInvalidGroupBeginQ in class RegexLexer
  - handleMixedClassSetOperators
```
protected RegexSyntaxException handleMixedClassSetOperators(RegexLexer.ClassSetOperator leftOperator,
                                                            RegexLexer.ClassSetOperator rightOperator)
```
    Description copied from class: RegexLexer
    
    Handle class set expressions with mixed set operators in the same nested set.
    
    Specified by:
    
    handleMixedClassSetOperators in class RegexLexer
  - handleMissingClassSetOperand
```
protected RegexSyntaxException handleMissingClassSetOperand(RegexLexer.ClassSetOperator operator)
```
    Description copied from class: RegexLexer
    
    Handle missing operands in class set expressions, e.g. [\s&&] or [\w--].
    
    Specified by:
    
    handleMissingClassSetOperand in class RegexLexer
  - handleOctalOutOfRange
```
protected void handleOctalOutOfRange()
```
    Description copied from class: RegexLexer
    
    Handle octal values larger than 255.
    
    Specified by:
    
    handleOctalOutOfRange in class RegexLexer
  - handleRangeAsClassSetOperand
```
protected RegexSyntaxException handleRangeAsClassSetOperand(RegexLexer.ClassSetOperator operator)
```
    Description copied from class: RegexLexer
    
    Handle character ranges as operands in class set expressions with operators other than union.
    
    Specified by:
    
    handleRangeAsClassSetOperand in class RegexLexer
  - handleUnfinishedEscape
```
protected void handleUnfinishedEscape()
```
    Description copied from class: RegexLexer
    
    Handle unfinished escape (e.g. \).
    
    Specified by:
    
    handleUnfinishedEscape in class RegexLexer
  - handleUnfinishedGroupComment
```
protected void handleUnfinishedGroupComment()
```
    Description copied from class: RegexLexer
    
    Handle unfinished group comment (#...).
    
    Specified by:
    
    handleUnfinishedGroupComment in class RegexLexer
  - handleUnfinishedGroupQ
```
protected RegexSyntaxException handleUnfinishedGroupQ()
```
    Description copied from class: RegexLexer
    
    Handle unfinished group with question mark (?.
    
    Specified by:
    
    handleUnfinishedGroupQ in class RegexLexer
  - handleUnfinishedRangeInClassSet
```
protected RegexSyntaxException handleUnfinishedRangeInClassSet()
```
    Description copied from class: RegexLexer
    
    Handle unfinished range in class set expression [a-].
    
    Specified by:
    
    handleUnfinishedRangeInClassSet in class RegexLexer
  - handleUnmatchedRightBrace
```
protected void handleUnmatchedRightBrace()
```
    Description copied from class: RegexLexer
    
    Handle unmatched }.
    
    Specified by:
    
    handleUnmatchedRightBrace in class RegexLexer
  - handleUnmatchedLeftBracket
```
protected RegexSyntaxException handleUnmatchedLeftBracket()
```
    Description copied from class: RegexLexer
    
    Handle unmatched [.
    
    Specified by:
    
    handleUnmatchedLeftBracket in class RegexLexer
  - handleUnmatchedRightBracket
```
protected void handleUnmatchedRightBracket()
```
    Description copied from class: RegexLexer
    
    Handle unmatched ].
    
    Specified by:
    
    handleUnmatchedRightBracket in class RegexLexer
  - parseCodePointInGroupName
```
protected int parseCodePointInGroupName()
                                 throws RegexSyntaxException
```
    Description copied from class: RegexLexer
    
    Parse the next codepoint in a group name and return it.
    
    Specified by:
    
    parseCodePointInGroupName in class RegexLexer
    
    Throws:
    
    RegexSyntaxException
  - parseCustomEscape
```
protected Token parseCustomEscape(char c)
```
    Description copied from class: RegexLexer
    
    Parse any escape sequence starting with \ and the argument c.
    
    Specified by:
    
    parseCustomEscape in class RegexLexer
  - parseCustomEscapeChar
```
protected int parseCustomEscapeChar(char c,
                                    boolean inCharClass)
```
    Description copied from class: RegexLexer
    
    Parse an escape character sequence (inside character class, or other escapes have already been tried) starting with \ and the argument {code c}.
    
    Specified by:
    
    parseCustomEscapeChar in class RegexLexer
  - parseCustomEscapeCharFallback
```
protected int parseCustomEscapeCharFallback(int c,
                                            boolean inCharClass)
```
    Description copied from class: RegexLexer
    
    Parse an escape character sequence (inside character class, or other escapes have already been tried) starting with \ and the code point c.This method is called after all other means of parsing the escape sequence have been exhausted.
    
    Specified by:
    
    parseCustomEscapeCharFallback in class RegexLexer
  - parseCustomGroupBeginQ
```
protected Token parseCustomGroupBeginQ(char charAfterQuestionMark)
```
    Description copied from class: RegexLexer
    
    Parse group starting with (?.
    
    Specified by:
    
    parseCustomGroupBeginQ in class RegexLexer
  - parseGroupLt
```
protected Token parseGroupLt()
```
    Description copied from class: RegexLexer
    
    Parse group starting with (<.
    
    Specified by:
    
    parseGroupLt in class RegexLexer
  - syntaxErrorAtAbs
```
public RegexSyntaxException syntaxErrorAtAbs(String msg,
                                             int i)
```
  - syntaxErrorHere
```
public RegexSyntaxException syntaxErrorHere(String msg)
```

Class PythonRegexLexer

Nested Class Summary

Nested classes/interfaces inherited from class com.oracle.truffle.regex.tregex.parser.RegexLexer

Field Summary

Fields inherited from class com.oracle.truffle.regex.tregex.parser.RegexLexer

Constructor Summary

Method Summary

Methods inherited from class com.oracle.truffle.regex.tregex.parser.RegexLexer

Methods inherited from class java.lang.Object

Constructor Detail

PythonRegexLexer

Method Detail

getLocaleData

fixFlags

getGlobalFlags

addGlobalFlags

getLocalFlags

pushLocalFlags

popLocalFlags

featureEnabledIgnoreCase

featureEnabledAZPositionAssertions

featureEnabledZLowerCaseAssertion

featureEnabledWordBoundaries

featureEnabledBoundedQuantifierEmptyMin

featureEnabledPossessiveQuantifiers

featureEnabledCharClassFirstBracketIsLiteral

featureEnabledNestedCharClasses

featureEnabledPOSIXCharClasses

featureEnabledForwardReferences

featureEnabledGroupComments

featureEnabledLineComments

featureEnabledIgnoreWhiteSpace

getWhitespace

featureEnabledOctalEscapes

featureEnabledSpecialGroups

featureEnabledUnicodePropertyEscapes

featureEnabledClassSetExpressions

getDotCodePointSet

getIdContinue

getIdStart

getMaxBackReferenceDigits

caseFoldUnfold

complementClassSet

caseFoldClassSetAtom

getPredefinedCharClass

checkClassSetCharacter

boundedQuantifierMaxValue

handleBoundedQuantifierOutOfOrder

handleBoundedQuantifierSyntaxError

handleBoundedQuantifierOverflow

handleBoundedQuantifierOverflowMin

handleCCRangeOutOfOrder

handleCCRangeWithPredefCharClass

getPOSIXCharClass

validatePOSIXCollationElement

validatePOSIXEquivalenceClass

handleComplementOfStringSet

handleEmptyGroupName

handleGroupRedefinition

handleIncompleteEscapeX

handleInvalidBackReference

handleInvalidBackReference

handleInvalidCharInCharClass

handleInvalidGroupBeginQ

handleMixedClassSetOperators

handleMissingClassSetOperand

handleOctalOutOfRange

handleRangeAsClassSetOperand

handleUnfinishedEscape

handleUnfinishedGroupComment

handleUnfinishedGroupQ

handleUnfinishedRangeInClassSet

handleUnmatchedRightBrace

handleUnmatchedLeftBracket

handleUnmatchedRightBracket

parseCodePointInGroupName

parseCustomEscape

parseCustomEscapeChar

parseCustomEscapeCharFallback

parseCustomGroupBeginQ