RegexLexer

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

Direct Known Subclasses:

JSRegexLexer, PythonRegexLexer
```
public abstract class RegexLexer
extends Object
```

Nested Class Summary

Nested Classes
Modifier and Type	Class and Description
`protected static interface`	`RegexLexer.ErrorHandler`
`static class`	`RegexLexer.ParseGroupNameResult`
`protected static class`	`RegexLexer.ParseGroupNameResultState`

Field Summary

Fields
Modifier and Type	Field and Description
`protected Map<String,Integer>`	`namedCaptureGroups`
`protected String`	`pattern` The source of the input pattern.
`protected int`	`position` The index of the next character in `RegexLexer.pattern` to be parsed.
`RegexSource`	`source`

Constructor Summary

Constructors
Constructor and Description

RegexLexer(RegexSource source)

Constructors
Constructor and Description
`RegexLexer(RegexSource source)`

Method Summary

All Methods Static Methods Instance Methods Abstract Methods Concrete Methods
Modifier and Type	Method and Description
`protected void`	`advance()`
`protected void`	`advance(int len)`
`protected boolean`	`atEnd()`
`protected abstract void`	`caseFold(CodePointSetAccumulator charClass)` Case folds a given character class.
`protected Token`	`charClass(int codePoint)`
`protected char`	`consumeChar()`
`protected boolean`	`consumingLookahead(Predicate<Character> predicate, int length)`
`protected boolean`	`consumingLookahead(String match)`
`protected int`	`count(Predicate<Character> predicate)`
`protected int`	`count(Predicate<Character> predicate, int fromIndex, int toIndex)`
`protected int`	`countDecimalDigits()`
`protected int`	`countFrom(Predicate<Character> predicate, int fromIndex)`
`protected int`	`countUpTo(Predicate<Character> predicate, int max)`
`protected char`	`curChar()`
`protected abstract boolean`	`featureEnabledAZPositionAssertions()` Returns `true` if `\A` and `\Z` position assertions are supported.
`protected abstract boolean`	`featureEnabledBoundedQuantifierEmptyMin()` Returns `true` if empty minimum values in bounded quantifiers (e.g.
`protected abstract 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 abstract boolean`	`featureEnabledForwardReferences()` Returns `true` if forward references are allowed.
`protected abstract boolean`	`featureEnabledGroupComments()` Returns `true` if group comments (e.g.
`protected abstract boolean`	`featureEnabledIgnoreCase()` Returns `true` if ignore-case mode is currently enabled.
`protected abstract boolean`	`featureEnabledLineComments()` Returns `true` if line comments (e.g.
`protected abstract boolean`	`featureEnabledOctalEscapes()` Returns `true` if octal escapes (e.g.
`protected abstract boolean`	`featureEnabledUnicodePropertyEscapes()` Returns `true` if unicode property escapes (e.g.
`protected boolean`	`findChars(char... chars)`
`protected int`	`finishSurrogatePair(char c)`
`protected abstract CodePointSet`	`getDotCodePointSet()` Returns the code point set represented by the dot operator.
`protected abstract CodePointSet`	`getIdContinue()` Returns the set of all codepoints a group identifier may continue with.
`protected abstract CodePointSet`	`getIdStart()` Returns the set of all codepoints a group identifier may begin with.
`protected int`	`getLastAtomPosition()`
`int`	`getLastTokenPosition()` Returns the last token's position in the pattern string.
`protected abstract int`	`getMaxBackReferenceDigits()` Returns the maximum number of digits to parse when parsing a back-reference.
`Map<String,Integer>`	`getNamedCaptureGroups()`
`protected abstract CodePointSet`	`getPredefinedCharClass(char c)` Returns the CodePointSet associated with the given predefined character class (e.g.
`protected abstract RegexSyntaxException`	`handleBoundedQuantifierOutOfOrder()` Handle `{2,1}`.
`protected abstract Token`	`handleBoundedQuantifierSyntaxError()` Handle syntax errors in bounded quantifiers (missing }, non-digit characters).
`protected abstract RegexSyntaxException`	`handleCCRangeOutOfOrder(int startPos)` Handle out of order character class range elements, e.g.
`protected abstract void`	`handleCCRangeWithPredefCharClass(int startPos)` Handle non-codepoint character class range elements, e.g.
`protected abstract RegexSyntaxException`	`handleEmptyGroupName()` Handle empty group name in group references.
`protected abstract RegexSyntaxException`	`handleGroupRedefinition(String name, int newId, int oldId)`
`protected abstract void`	`handleIncompleteEscapeX()` Handle incomplete hex escapes, e.g.
`protected abstract void`	`handleInvalidBackReference(int reference)` Handle group references to non-existent groups.
`protected abstract void`	`handleInvalidBackReference(String reference)` Handle group references to non-existent groups.
`protected abstract RegexSyntaxException`	`handleInvalidGroupBeginQ()` Handle groups starting with `(?` and invalid next char.
`protected abstract void`	`handleOctalOutOfRange()` Handle octal values larger than 255.
`protected abstract void`	`handleUnfinishedEscape()` Handle unfinished escape (e.g.
`protected abstract void`	`handleUnfinishedGroupComment()` Handle unfinished group comment `(#...)`.
`protected abstract RegexSyntaxException`	`handleUnfinishedGroupQ()` Handle unfinished group with question mark `(?`.
`protected abstract RegexSyntaxException`	`handleUnmatchedLeftBracket()` Handle unmatched `[`.
`protected abstract void`	`handleUnmatchedRightBrace()` Handle unmatched }.
`protected abstract void`	`handleUnmatchedRightBracket()` Handle unmatched `]`.
`protected boolean`	`hasNamedCaptureGroups()` Checks whether this regular expression contains any named capture groups.
`boolean`	`hasNext()`
`protected static boolean`	`isDecimalDigit(int c)`
`protected boolean`	`isEscaped()`
`protected static boolean`	`isHexDigit(int c)`
`protected static boolean`	`isOctalDigit(int c)`
`protected boolean`	`lookahead(Predicate<Character> predicate, int length)`
`protected boolean`	`lookahead(String match)`
`protected boolean`	`lookbehind(char c)`
`Token`	`next()`
`int`	`numberOfCaptureGroupsSoFar()`
`protected abstract int`	`parseCodePointInGroupName()` Parse the next codepoint in a group name and return it.
`protected abstract Token`	`parseCustomEscape(char c)` Parse any escape sequence starting with `\` and the argument `c`.
`protected abstract 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 abstract 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 abstract Token`	`parseCustomGroupBeginQ(char charAfterQuestionMark)` Parse group starting with `(?`.
`protected abstract Token`	`parseGroupLt()` Parse group starting with `(<`.
`protected RegexLexer.ParseGroupNameResult`	`parseGroupName(char terminator)` Parse a `GroupName`, i.e.
`protected int`	`parseIntSaturated(int firstDigit, int length, int returnOnOverflow)`
`protected int`	`parseOctal(int firstDigit)`
`protected void`	`registerNamedCaptureGroup(String name)`
`protected void`	`retreat()`
`RegexSyntaxException`	`syntaxError(String msg)`
`int`	`totalNumberOfCaptureGroups()`

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

Field Detail
- source
```
public final RegexSource source
```
- pattern
```
protected final String pattern
```
  The source of the input pattern.
- position
```
protected int position
```
  The index of the next character in RegexLexer.pattern to be parsed.
- namedCaptureGroups
```
protected Map<String,Integer> namedCaptureGroups
```

Constructor Detail
- RegexLexer
```
public RegexLexer(RegexSource source)
```

Method Detail

featureEnabledIgnoreCase
```
protected abstract boolean featureEnabledIgnoreCase()
```
Returns true if ignore-case mode is currently enabled.

featureEnabledAZPositionAssertions
```
protected abstract boolean featureEnabledAZPositionAssertions()
```
Returns true if \A and \Z position assertions are supported.

featureEnabledBoundedQuantifierEmptyMin
```
protected abstract boolean featureEnabledBoundedQuantifierEmptyMin()
```
Returns true if empty minimum values in bounded quantifiers (e.g. {,1}) are allowed and treated as zero.

featureEnabledCharClassFirstBracketIsLiteral
```
protected abstract 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 ']'.

featureEnabledForwardReferences
```
protected abstract boolean featureEnabledForwardReferences()
```
Returns true if forward references are allowed.

featureEnabledGroupComments
```
protected abstract boolean featureEnabledGroupComments()
```
Returns true if group comments (e.g. (# ... )) are supported.

featureEnabledLineComments
```
protected abstract boolean featureEnabledLineComments()
```
Returns true if line comments (e.g. # ... ) are supported.

featureEnabledOctalEscapes
```
protected abstract boolean featureEnabledOctalEscapes()
```
Returns true if octal escapes (e.g. \012) are supported.

featureEnabledUnicodePropertyEscapes
```
protected abstract boolean featureEnabledUnicodePropertyEscapes()
```
Returns true if unicode property escapes (e.g. \p{...}) are supported.

caseFold

protected abstract void caseFold(CodePointSetAccumulator charClass)

Case folds a given character class.

getDotCodePointSet
```
protected abstract CodePointSet getDotCodePointSet()
```
Returns the code point set represented by the dot operator.

getIdStart
```
protected abstract CodePointSet getIdStart()
```
Returns the set of all codepoints a group identifier may begin with.

getIdContinue
```
protected abstract CodePointSet getIdContinue()
```
Returns the set of all codepoints a group identifier may continue with.

getMaxBackReferenceDigits
```
protected abstract int getMaxBackReferenceDigits()
```
Returns the maximum number of digits to parse when parsing a back-reference.

getPredefinedCharClass
```
protected abstract CodePointSet getPredefinedCharClass(char c)
```
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.

handleBoundedQuantifierOutOfOrder

protected abstract RegexSyntaxException handleBoundedQuantifierOutOfOrder()

Handle {2,1}.

handleBoundedQuantifierSyntaxError
```
protected abstract Token handleBoundedQuantifierSyntaxError()
```
Handle syntax errors in bounded quantifiers (missing }, non-digit characters).

handleCCRangeOutOfOrder
```
protected abstract RegexSyntaxException handleCCRangeOutOfOrder(int startPos)
```
Handle out of order character class range elements, e.g. [b-a].

handleCCRangeWithPredefCharClass
```
protected abstract void handleCCRangeWithPredefCharClass(int startPos)
```
Handle non-codepoint character class range elements, e.g. [\w-a].

handleEmptyGroupName

protected abstract RegexSyntaxException handleEmptyGroupName()

Handle empty group name in group references.

handleGroupRedefinition

protected abstract RegexSyntaxException handleGroupRedefinition(String name,
                                                                int newId,
                                                                int oldId)

handleIncompleteEscapeX
```
protected abstract void handleIncompleteEscapeX()
```
Handle incomplete hex escapes, e.g. \x1.

handleInvalidBackReference
```
protected abstract void handleInvalidBackReference(int reference)
```
Handle group references to non-existent groups.

handleInvalidBackReference

protected abstract void handleInvalidBackReference(String reference)

Handle group references to non-existent groups.

handleInvalidGroupBeginQ
```
protected abstract RegexSyntaxException handleInvalidGroupBeginQ()
```
Handle groups starting with (? and invalid next char.

handleOctalOutOfRange
```
protected abstract void handleOctalOutOfRange()
```
Handle octal values larger than 255.

handleUnfinishedEscape
```
protected abstract void handleUnfinishedEscape()
```
Handle unfinished escape (e.g. \).

handleUnfinishedGroupComment
```
protected abstract void handleUnfinishedGroupComment()
```
Handle unfinished group comment (#...).

handleUnfinishedGroupQ

protected abstract RegexSyntaxException handleUnfinishedGroupQ()

Handle unfinished group with question mark (?.

handleUnmatchedRightBrace

protected abstract void handleUnmatchedRightBrace()

Handle unmatched }.

handleUnmatchedLeftBracket

protected abstract RegexSyntaxException handleUnmatchedLeftBracket()

Handle unmatched [.

handleUnmatchedRightBracket

protected abstract void handleUnmatchedRightBracket()

Handle unmatched ].

parseCodePointInGroupName

protected abstract int parseCodePointInGroupName()
                                          throws RegexSyntaxException

Parse the next codepoint in a group name and return it.

Throws:: RegexSyntaxException

parseCustomEscape
```
protected abstract Token parseCustomEscape(char c)
```
Parse any escape sequence starting with \ and the argument c.

parseCustomEscapeChar
```
protected abstract 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}.

parseCustomEscapeCharFallback
```
protected abstract 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.

parseCustomGroupBeginQ

protected abstract Token parseCustomGroupBeginQ(char charAfterQuestionMark)

Parse group starting with (?.

parseGroupLt

protected abstract Token parseGroupLt()

Parse group starting with (<.

findChars

protected boolean findChars(char... chars)

advance
```
protected void advance()
```

retreat
```
protected void retreat()
```

hasNext
```
public boolean hasNext()
```

public Token next()
           throws RegexSyntaxException

Throws:: RegexSyntaxException

getLastTokenPosition
```
public int getLastTokenPosition()
```
Returns the last token's position in the pattern string.

getLastAtomPosition
```
protected int getLastAtomPosition()
```

curChar
```
protected char curChar()
```

consumeChar
```
protected char consumeChar()
```

advance
```
protected void advance(int len)
```

lookahead

protected boolean lookahead(String match)

lookahead

protected boolean lookahead(Predicate<Character> predicate,
                            int length)

consumingLookahead

protected boolean consumingLookahead(String match)

consumingLookahead

protected boolean consumingLookahead(Predicate<Character> predicate,
                                     int length)

lookbehind
```
protected boolean lookbehind(char c)
```

isEscaped
```
protected boolean isEscaped()
```

count

protected int count(Predicate<Character> predicate)

countUpTo

protected int countUpTo(Predicate<Character> predicate,
                        int max)

countFrom

protected int countFrom(Predicate<Character> predicate,
                        int fromIndex)

count

protected int count(Predicate<Character> predicate,
                    int fromIndex,
                    int toIndex)

atEnd
```
protected boolean atEnd()
```

totalNumberOfCaptureGroups

public int totalNumberOfCaptureGroups()
                               throws RegexSyntaxException

Throws:: RegexSyntaxException

numberOfCaptureGroupsSoFar

public int numberOfCaptureGroupsSoFar()

getNamedCaptureGroups

public Map<String,Integer> getNamedCaptureGroups()
                                          throws RegexSyntaxException

Throws:: RegexSyntaxException

hasNamedCaptureGroups
```
protected boolean hasNamedCaptureGroups()
                                 throws RegexSyntaxException
```
Checks whether this regular expression contains any named capture groups.
This method is a way to check whether we are parsing the goal symbol Pattern[~U, +N] or Pattern[~U, ~N] (see the ECMAScript RegExp grammar).

Throws:

RegexSyntaxException

registerNamedCaptureGroup

protected void registerNamedCaptureGroup(String name)

charClass

protected Token charClass(int codePoint)

parseGroupName
```
protected RegexLexer.ParseGroupNameResult parseGroupName(char terminator)
                                                  throws RegexSyntaxException
```
Parse a GroupName, i.e. <RegExpIdentifierName>, assuming that the opening < bracket was already read.

Returns:

the StringValue of the RegExpIdentifierName

Throws:

RegexSyntaxException

parseIntSaturated

protected int parseIntSaturated(int firstDigit,
                                int length,
                                int returnOnOverflow)

countDecimalDigits
```
protected int countDecimalDigits()
```

finishSurrogatePair

protected int finishSurrogatePair(char c)

parseOctal

protected int parseOctal(int firstDigit)

syntaxError

public RegexSyntaxException syntaxError(String msg)

isDecimalDigit

protected static boolean isDecimalDigit(int c)

isOctalDigit

protected static boolean isOctalDigit(int c)

isHexDigit

protected static boolean isHexDigit(int c)

Class RegexLexer

Nested Class Summary

Field Summary

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Field Detail

source

pattern

position

namedCaptureGroups

Constructor Detail

RegexLexer

Method Detail

featureEnabledIgnoreCase

featureEnabledAZPositionAssertions

featureEnabledBoundedQuantifierEmptyMin

featureEnabledCharClassFirstBracketIsLiteral

featureEnabledForwardReferences

featureEnabledGroupComments

featureEnabledLineComments

featureEnabledOctalEscapes

featureEnabledUnicodePropertyEscapes

caseFold

getDotCodePointSet

getIdStart

getIdContinue

getMaxBackReferenceDigits

getPredefinedCharClass

handleBoundedQuantifierOutOfOrder

handleBoundedQuantifierSyntaxError

handleCCRangeOutOfOrder

handleCCRangeWithPredefCharClass

handleEmptyGroupName

handleGroupRedefinition

handleIncompleteEscapeX

handleInvalidBackReference

handleInvalidBackReference

handleInvalidGroupBeginQ

handleOctalOutOfRange

handleUnfinishedEscape

handleUnfinishedGroupComment

handleUnfinishedGroupQ

handleUnmatchedRightBrace

handleUnmatchedLeftBracket

handleUnmatchedRightBracket

parseCodePointInGroupName

parseCustomEscape

parseCustomEscapeChar

parseCustomEscapeCharFallback

parseCustomGroupBeginQ

parseGroupLt

findChars

advance

retreat

hasNext

next

getLastTokenPosition

getLastAtomPosition

curChar

consumeChar

advance

lookahead

lookahead

consumingLookahead

consumingLookahead

lookbehind

isEscaped

count

countUpTo

countFrom

count

atEnd

totalNumberOfCaptureGroups

numberOfCaptureGroupsSoFar

getNamedCaptureGroups

hasNamedCaptureGroups

registerNamedCaptureGroup

charClass

parseGroupName