CommonRegexLexer class

Paket:

adaptive-expressions

Extends

Lexer

Konstruktoren

CommonRegexLexer(CharStream)

Eigenschaften

ALC
Ampersand
AUC
Backslash
BellChar
BLC
BlockQuoted
BUC
Caret
CarriageReturn
channelNames
channelNames
CharacterClassEnd
CharacterClassStart
CharWithoutProperty
CharWithProperty
CLC
CloseBrace
CloseParen
Colon
Comma
ControlChar
CUC
D0
D1
D2
D3
D4
D5
D6
D7
D8
D9
DecimalDigit
DLC
Dot
DUC
ELC
EndOfSubject
Equals
EscapeChar
EUC
Exclamation
FLC
FormFeed
FUC
GLC
grammarFileName
GreaterThan
GUC
Hash
HexChar
HLC
HUC
Hyphen
ILC
IUC
JLC
JUC
KLC
KUC
LessThan
LLC
LUC
MLC
modeNames
modeNames
MUC
NewLine
NLC
NotDecimalDigit
NotWhiteSpace
NotWordChar
NUC
OLC
OpenBrace
OpenParen
OtherChar
OUC
Pipe
PLC
Plus
PUC
QLC
QUC
QuestionMark
Quoted
RLC
RUC
ruleNames
ruleNames
serializedATN
SingleQuote
SLC
Star
SUC
Tab
TLC
TUC
ULC
Underscore
UUC
VLC
VOCABULARY
vocabulary
VUC
WhiteSpace
WLC
WordChar
WUC
XLC
XUC
YLC
YUC
ZLC
ZUC

Geerbte Eigenschaften

atn	Rufen Sie die ab, die serializedATN von der Erkennung für Vorhersage verwendet wird.
channel
charIndex	Was ist der Index des aktuellen Charakters von Lookahead?
charPositionInLine
DEFAULT_MODE
DEFAULT_TOKEN_CHANNEL
EOF
HIDDEN
inputStream	Legen Sie den Char-Stream fest, und setzen Sie den Lexer zurück.
interpreter	Legen Sie den ATN-Interpreter fest, der von der Erkennung für die Vorhersage verwendet wird.
line
MAX_CHAR_VALUE
MIN_CHAR_VALUE
MORE
parseInfo	Wenn die Profilerstellung während der Analyse/lex erfolgt, werden DecisionInfo-Datensätze für jede Entscheidung in der Erkennung in einem ParseInfo-Objekt zurückgegeben.
SKIP
sourceName
state	Geben Sie an, dass die Erkennung den internen Zustand geändert hat, der mit dem übergebenen ATN-Zustand konsistent ist. Auf diese Weise wissen wir immer, wo wir uns im ATN befinden, während der Parser mitgeht. Die Regelkontextobjekte bilden einen Stapel, mit dem der Stapel der Aufrufregeln angezeigt werden kann. Kombinieren Sie dies, und wir haben vollständige ATN-Konfigurationsinformationen.
text	Legen Sie den vollständigen Text dieses Tokens fest. Alle vorherigen Änderungen am Text werden gelöscht.
token	Überschreiben Sie, wenn mehrere Token ausgegeben werden.
tokenFactory
type

Geerbte Methoden

action(RuleContext | undefined, number, number)
addErrorListener(ANTLRErrorListener<number>)
emit()	Standardmäßig werden mehrere Emits pro nextToken-Aufruf aus Effizienzgründen nicht unterstützt. Unterklasse und überschreiben Sie diese Methode, nextToken und getToken (zum Pushen von Token in eine Liste und zum Pullen aus dieser Liste anstelle einer einzelnen Variablen, wie dies bei dieser Implementierung der Fall ist).
emit(Token)	Die Standardmethode, die aufgerufen wird, um automatisch ein Token an der äußersten lexikalischen Regel auszustellen. Das Tokenobjekt sollte auf den char-Puffer start.. Stoppen. Wenn in "text" eine Textüberschreibung vorhanden ist, verwenden Sie dies, um den Text des Tokens festzulegen. Überschreiben Sie diese Methode, um benutzerdefinierte Tokenobjekte auszustellen oder eine neue Factory bereitzustellen.
emitEOF()
getAllTokens()	Gibt eine Liste aller Tokenobjekte im Eingabe-Char-Stream zurück. Erzwingt das Laden aller Token. Enthält kein EOF-Token.
getCharErrorDisplay(number)
getErrorDisplay(string | number)
getErrorHeader(RecognitionException)	Was ist der Fehlerheader, normalerweise Zeilen-/Zeichenpositionsinformationen?
getErrorListenerDispatch()
getErrorListeners()
getRuleIndexMap()	Abrufen einer Zuordnung von Regelnamen zu Regelindizes. Wird für die XPath- und Strukturmusterkompilierung verwendet.
getTokenType(string)
getTokenTypeMap()	Rufen Sie eine Zuordnung von Tokennamen zu Tokentypen ab. Wird für die XPath- und Strukturmusterkompilierung verwendet.
mode(number)
more()
nextToken()	Gibt ein Token aus dieser Quelle zurück. Das heißt, ein Token im Char-Stream abgleichen.
notifyListeners(LexerNoViableAltException)
popMode()
precpred(RuleContext | undefined, number)
pushMode(number)
recover(LexerNoViableAltException)
recover(RecognitionException)	Lexers können normalerweise mit jedem Zeichen in ihrem Vokabular übereinstimmen, nachdem ein Token abgeglichen wurde. Machen Sie also die einfache Sache und töten Sie einfach einen Charakter und hoffen, dass alles funktioniert. Sie können stattdessen den Regelaufrufstapel verwenden, um eine komplexe Fehlerwiederherstellung auszuführen, wenn Sie sich in einer Fragmentregel befinden.
removeErrorListener(ANTLRErrorListener<number>)
removeErrorListeners()
reset()
reset(boolean)
sempred(RuleContext | undefined, number, number)
skip()	Weisen Sie den Lexer an, das Erstellen eines Tokens für die aktuelle Lexerregel zu überspringen und nach einem anderen Token zu suchen. nextToken() weiß, dass sie weiterhin suchen, wenn eine Lexerregel das Token auf SKIP_TOKEN festgelegt hat. Denken Sie daran, dass, wenn token==am Ende einer Tokenregel nicht definiert ist, es eine für Sie erstellt und ausgibt.

Details zum Konstruktor

CommonRegexLexer(CharStream)

new CommonRegexLexer(input: CharStream)

Parameter

input

CharStream

Details zur Eigenschaft

ALC

public static ALC: 44 = 44

Eigenschaftswert

44

Ampersand

public static Ampersand: 43 = 43

Eigenschaftswert

43

AUC

public static AUC: 70 = 70

Eigenschaftswert

70

Backslash

public static Backslash: 10 = 10

Eigenschaftswert

10

BellChar

public static BellChar: 3 = 3

Eigenschaftswert

3

BLC

public static BLC: 45 = 45

Eigenschaftswert

45

BlockQuoted

public static BlockQuoted: 2 = 2

Eigenschaftswert

2

BUC

public static BUC: 71 = 71

Eigenschaftswert

71

Caret

public static Caret: 23 = 23

Eigenschaftswert

23

CarriageReturn

public static CarriageReturn: 8 = 8

Eigenschaftswert

8

channelNames

public static channelNames: string[] = [
		"DEFAULT_TOKEN_CHANNEL", "HIDDEN",
	]

Eigenschaftswert

string[]

channelNames

string[] channelNames

Eigenschaftswert

string[]

CharacterClassEnd

public static CharacterClassEnd: 22 = 22

Eigenschaftswert

22

CharacterClassStart

public static CharacterClassStart: 21 = 21

Eigenschaftswert

21

CharWithoutProperty

public static CharWithoutProperty: 16 = 16

Eigenschaftswert

16

CharWithProperty

public static CharWithProperty: 15 = 15

Eigenschaftswert

15

CLC

public static CLC: 46 = 46

Eigenschaftswert

46

CloseBrace

public static CloseBrace: 29 = 29

Eigenschaftswert

29

CloseParen

public static CloseParen: 34 = 34

Eigenschaftswert

34

Colon

public static Colon: 39 = 39

Eigenschaftswert

39

Comma

public static Comma: 30 = 30

Eigenschaftswert

30

ControlChar

public static ControlChar: 4 = 4

Eigenschaftswert

4

CUC

public static CUC: 72 = 72

Eigenschaftswert

72

D0

public static D0: 105 = 105

Eigenschaftswert

105

D1

public static D1: 96 = 96

Eigenschaftswert

96

D2

public static D2: 97 = 97

Eigenschaftswert

97

D3

public static D3: 98 = 98

Eigenschaftswert

98

D4

public static D4: 99 = 99

Eigenschaftswert

99

D5

public static D5: 100 = 100

Eigenschaftswert

100

D6

public static D6: 101 = 101

Eigenschaftswert

101

D7

public static D7: 102 = 102

Eigenschaftswert

102

D8

public static D8: 103 = 103

Eigenschaftswert

103

D9

public static D9: 104 = 104

Eigenschaftswert

104

DecimalDigit

public static DecimalDigit: 13 = 13

Eigenschaftswert

13

DLC

public static DLC: 47 = 47

Eigenschaftswert

47

Dot

public static Dot: 12 = 12

Eigenschaftswert

12

DUC

public static DUC: 73 = 73

Eigenschaftswert

73

ELC

public static ELC: 48 = 48

Eigenschaftswert

48

EndOfSubject

public static EndOfSubject: 31 = 31

Eigenschaftswert

31

Equals

public static Equals: 41 = 41

Eigenschaftswert

41

EscapeChar

public static EscapeChar: 5 = 5

Eigenschaftswert

5

EUC

public static EUC: 74 = 74

Eigenschaftswert

74

Exclamation

public static Exclamation: 42 = 42

Eigenschaftswert

42

FLC

public static FLC: 49 = 49

Eigenschaftswert

49

FormFeed

public static FormFeed: 6 = 6

Eigenschaftswert

6

FUC

public static FUC: 75 = 75

Eigenschaftswert

75

GLC

public static GLC: 50 = 50

Eigenschaftswert

50

grammarFileName

string grammarFileName

Eigenschaftswert

string

GreaterThan

public static GreaterThan: 36 = 36

Eigenschaftswert

36

GUC

public static GUC: 76 = 76

Eigenschaftswert

76

Hash

public static Hash: 40 = 40

Eigenschaftswert

40

HexChar

public static HexChar: 11 = 11

Eigenschaftswert

11

HLC

public static HLC: 51 = 51

Eigenschaftswert

51

HUC

public static HUC: 77 = 77

Eigenschaftswert

77

Hyphen

public static Hyphen: 24 = 24

Eigenschaftswert

24

ILC

public static ILC: 52 = 52

Eigenschaftswert

52

IUC

public static IUC: 78 = 78

Eigenschaftswert

78

JLC

public static JLC: 53 = 53

Eigenschaftswert

53

JUC

public static JUC: 79 = 79

Eigenschaftswert

79

KLC

public static KLC: 54 = 54

Eigenschaftswert

54

KUC

public static KUC: 80 = 80

Eigenschaftswert

80

LessThan

public static LessThan: 35 = 35

Eigenschaftswert

35

LLC

public static LLC: 55 = 55

Eigenschaftswert

55

LUC

public static LUC: 81 = 81

Eigenschaftswert

81

MLC

public static MLC: 56 = 56

Eigenschaftswert

56

modeNames

public static modeNames: string[] = [
		"DEFAULT_MODE",
	]

Eigenschaftswert

string[]

modeNames

string[] modeNames

Eigenschaftswert

string[]

MUC

public static MUC: 82 = 82

Eigenschaftswert

82

NewLine

public static NewLine: 7 = 7

Eigenschaftswert

7

NLC

public static NLC: 57 = 57

Eigenschaftswert

57

NotDecimalDigit

public static NotDecimalDigit: 14 = 14

Eigenschaftswert

14

NotWhiteSpace

public static NotWhiteSpace: 18 = 18

Eigenschaftswert

18

NotWordChar

public static NotWordChar: 20 = 20

Eigenschaftswert

20

NUC

public static NUC: 83 = 83

Eigenschaftswert

83

OLC

public static OLC: 58 = 58

Eigenschaftswert

58

OpenBrace

public static OpenBrace: 28 = 28

Eigenschaftswert

28

OpenParen

public static OpenParen: 33 = 33

Eigenschaftswert

33

OtherChar

public static OtherChar: 106 = 106

Eigenschaftswert

106

OUC

public static OUC: 84 = 84

Eigenschaftswert

84

Pipe

public static Pipe: 32 = 32

Eigenschaftswert

32

PLC

public static PLC: 59 = 59

Eigenschaftswert

59

Plus

public static Plus: 26 = 26

Eigenschaftswert

26

PUC

public static PUC: 85 = 85

Eigenschaftswert

85

QLC

public static QLC: 60 = 60

Eigenschaftswert

60

QUC

public static QUC: 86 = 86

Eigenschaftswert

86

QuestionMark

public static QuestionMark: 25 = 25

Eigenschaftswert

25

Quoted

public static Quoted: 1 = 1

Eigenschaftswert

1

RLC

public static RLC: 61 = 61

Eigenschaftswert

61

RUC

public static RUC: 87 = 87

Eigenschaftswert

87

ruleNames

public static ruleNames: string[] = [
		"Quoted", "BlockQuoted", "BellChar", "ControlChar", "EscapeChar", "FormFeed", 
		"NewLine", "CarriageReturn", "Tab", "Backslash", "HexChar", "Dot", "DecimalDigit", 
		"NotDecimalDigit", "CharWithProperty", "CharWithoutProperty", "WhiteSpace", 
		"NotWhiteSpace", "WordChar", "NotWordChar", "CharacterClassStart", "CharacterClassEnd", 
		"Caret", "Hyphen", "QuestionMark", "Plus", "Star", "OpenBrace", "CloseBrace", 
		"Comma", "EndOfSubject", "Pipe", "OpenParen", "CloseParen", "LessThan", 
		"GreaterThan", "SingleQuote", "Underscore", "Colon", "Hash", "Equals", 
		"Exclamation", "Ampersand", "ALC", "BLC", "CLC", "DLC", "ELC", "FLC", 
		"GLC", "HLC", "ILC", "JLC", "KLC", "LLC", "MLC", "NLC", "OLC", "PLC", 
		"QLC", "RLC", "SLC", "TLC", "ULC", "VLC", "WLC", "XLC", "YLC", "ZLC", 
		"AUC", "BUC", "CUC", "DUC", "EUC", "FUC", "GUC", "HUC", "IUC", "JUC", 
		"KUC", "LUC", "MUC", "NUC", "OUC", "PUC", "QUC", "RUC", "SUC", "TUC", 
		"UUC", "VUC", "WUC", "XUC", "YUC", "ZUC", "D1", "D2", "D3", "D4", "D5", 
		"D6", "D7", "D8", "D9", "D0", "OtherChar", "UnderscoreAlphaNumerics", 
		"AlphaNumerics", "AlphaNumeric", "NonAlphaNumeric", "HexDigit", "ASCII",
	]

Eigenschaftswert

string[]

ruleNames

string[] ruleNames

Eigenschaftswert

string[]

serializedATN

string serializedATN

Eigenschaftswert

string

SingleQuote

public static SingleQuote: 37 = 37

Eigenschaftswert

37

SLC

public static SLC: 62 = 62

Eigenschaftswert

62

Star

public static Star: 27 = 27

Eigenschaftswert

27

SUC

public static SUC: 88 = 88

Eigenschaftswert

88

Tab

public static Tab: 9 = 9

Eigenschaftswert

9

TLC

public static TLC: 63 = 63

Eigenschaftswert

63

TUC

public static TUC: 89 = 89

Eigenschaftswert

89

ULC

public static ULC: 64 = 64

Eigenschaftswert

64

Underscore

public static Underscore: 38 = 38

Eigenschaftswert

38

UUC

public static UUC: 90 = 90

Eigenschaftswert

90

VLC

public static VLC: 65 = 65

Eigenschaftswert

65

VOCABULARY

public static VOCABULARY: Vocabulary = new VocabularyImpl(CommonRegexLexer._LITERAL_NAMES, CommonRegexLexer._SYMBOLIC_NAMES, [])

Eigenschaftswert

Vocabulary

vocabulary

Vocabulary vocabulary

Eigenschaftswert

Vocabulary

VUC

public static VUC: 91 = 91

Eigenschaftswert

91

WhiteSpace

public static WhiteSpace: 17 = 17

Eigenschaftswert

17

WLC

public static WLC: 66 = 66

Eigenschaftswert

66

WordChar

public static WordChar: 19 = 19

Eigenschaftswert

19

WUC

public static WUC: 92 = 92

Eigenschaftswert

92

XLC

public static XLC: 67 = 67

Eigenschaftswert

67

XUC

public static XUC: 93 = 93

Eigenschaftswert

93

YLC

public static YLC: 68 = 68

Eigenschaftswert

68

YUC

public static YUC: 94 = 94

Eigenschaftswert

94

ZLC

public static ZLC: 69 = 69

Eigenschaftswert

69

ZUC

public static ZUC: 95 = 95

Eigenschaftswert

95

Geerbte Eigenschaftsdetails

atn

Rufen Sie die ab, die serializedATN von der Erkennung für Vorhersage verwendet wird.

atn: ATN

Eigenschaftswert

ATN

Geerbt von Recognizer.atn

channel

channel: number

Eigenschaftswert

number

Geerbt von Lexer.channel

charIndex

Was ist der Index des aktuellen Charakters von Lookahead?

charIndex: number

Eigenschaftswert

number

Geerbt von Lexer.charIndex

charPositionInLine

charPositionInLine: number

Eigenschaftswert

number

Geerbt von Lexer.charPositionInLine

DEFAULT_MODE

static DEFAULT_MODE: number

Eigenschaftswert

number

Geerbt von Lexer.DEFAULT_MODE

DEFAULT_TOKEN_CHANNEL

static DEFAULT_TOKEN_CHANNEL: number

Eigenschaftswert

number

Geerbt von Lexer.DEFAULT_TOKEN_CHANNEL

EOF

static EOF: number

Eigenschaftswert

number

Geerbt von Recognizer.EOF

HIDDEN

static HIDDEN: number

Eigenschaftswert

number

Geerbt von Lexer.HIDDEN

inputStream

Legen Sie den Char-Stream fest, und setzen Sie den Lexer zurück.

inputStream: CharStream

Eigenschaftswert

CharStream

Geerbt von Lexer.inputStream

interpreter

Legen Sie den ATN-Interpreter fest, der von der Erkennung für die Vorhersage verwendet wird.

interpreter: LexerATNSimulator

Eigenschaftswert

LexerATNSimulator

Geerbt von Recognizer.interpreter

line

line: number

Eigenschaftswert

number

Geerbt von Lexer.line

MAX_CHAR_VALUE

static MAX_CHAR_VALUE: number

Eigenschaftswert

number

Geerbt von Lexer.MAX_CHAR_VALUE

MIN_CHAR_VALUE

static MIN_CHAR_VALUE: number

Eigenschaftswert

number

Geerbt von Lexer.MIN_CHAR_VALUE

MORE

static MORE: number

Eigenschaftswert

number

Geerbt von Lexer.MORE

parseInfo

Wenn die Profilerstellung während der Analyse/lex erfolgt, werden DecisionInfo-Datensätze für jede Entscheidung in der Erkennung in einem ParseInfo-Objekt zurückgegeben.

parseInfo: Promise<ParseInfo | undefined>

Eigenschaftswert

Promise<ParseInfo | undefined>

Geerbt von Recognizer.parseInfo

SKIP

static SKIP: number

Eigenschaftswert

number

Geerbt von Lexer.SKIP

sourceName

sourceName: string

Eigenschaftswert

string

Geerbt von Lexer.sourceName

state

Geben Sie an, dass die Erkennung den internen Zustand geändert hat, der mit dem übergebenen ATN-Zustand konsistent ist. Auf diese Weise wissen wir immer, wo wir uns im ATN befinden, während der Parser mitgeht. Die Regelkontextobjekte bilden einen Stapel, mit dem der Stapel der Aufrufregeln angezeigt werden kann. Kombinieren Sie dies, und wir haben vollständige ATN-Konfigurationsinformationen.

state: number

Eigenschaftswert

number

Geerbt von Recognizer.state

text

Legen Sie den vollständigen Text dieses Tokens fest. Alle vorherigen Änderungen am Text werden gelöscht.

text: string

Eigenschaftswert

string

Geerbt von Lexer.text

token

Überschreiben Sie, wenn mehrere Token ausgegeben werden.

token: Token | undefined

Eigenschaftswert

Token | undefined

Geerbt von Lexer.token

tokenFactory

tokenFactory: TokenFactory

Eigenschaftswert

TokenFactory

Geerbt von Lexer.tokenFactory

type

type: number

Eigenschaftswert

number

Geerbt von Lexer.type

Details zur geerbten Methode

action(RuleContext | undefined, number, number)

function action(_localctx: RuleContext | undefined, ruleIndex: number, actionIndex: number)

Parameter

_localctx

RuleContext | undefined

ruleIndex

number

actionIndex

number

Geerbt von Recognizer.action

addErrorListener(ANTLRErrorListener<number>)

function addErrorListener(listener: ANTLRErrorListener<number>)

Parameter

listener

ANTLRErrorListener<number>

Geerbt von Recognizer.addErrorListener

emit()

Standardmäßig werden mehrere Emits pro nextToken-Aufruf aus Effizienzgründen nicht unterstützt. Unterklasse und überschreiben Sie diese Methode, nextToken und getToken (zum Pushen von Token in eine Liste und zum Pullen aus dieser Liste anstelle einer einzelnen Variablen, wie dies bei dieser Implementierung der Fall ist).

function emit(): Token

Gibt zurück

Token

Geerbt von Lexer.emit

emit(Token)

Die Standardmethode, die aufgerufen wird, um automatisch ein Token an der äußersten lexikalischen Regel auszustellen. Das Tokenobjekt sollte auf den char-Puffer start.. Stoppen. Wenn in "text" eine Textüberschreibung vorhanden ist, verwenden Sie dies, um den Text des Tokens festzulegen. Überschreiben Sie diese Methode, um benutzerdefinierte Tokenobjekte auszustellen oder eine neue Factory bereitzustellen.

function emit(token: Token): Token

Parameter

token

Token

Gibt zurück

Token

Geerbt von Lexer.emit

emitEOF()

function emitEOF(): Token

Gibt zurück

Token

Geerbt von Lexer.emitEOF

getAllTokens()

Gibt eine Liste aller Tokenobjekte im Eingabe-Char-Stream zurück. Erzwingt das Laden aller Token. Enthält kein EOF-Token.

function getAllTokens(): Token[]

Gibt zurück

Token[]

Geerbt von Lexer.getAllTokens

getCharErrorDisplay(number)

function getCharErrorDisplay(c: number): string

Parameter

c

number

Gibt zurück

string

Geerbt von Lexer.getCharErrorDisplay

getErrorDisplay(string | number)

function getErrorDisplay(s: string | number): string

Parameter

s

string | number

Gibt zurück

string

Geerbt von Lexer.getErrorDisplay

getErrorHeader(RecognitionException)

Was ist der Fehlerheader, normalerweise Zeilen-/Zeichenpositionsinformationen?

function getErrorHeader(e: RecognitionException): string

Parameter

e

RecognitionException

Gibt zurück

string

Geerbt von Recognizer.getErrorHeader

getErrorListenerDispatch()

function getErrorListenerDispatch(): ANTLRErrorListener<number>

Gibt zurück

ANTLRErrorListener<number>

Geerbt von Recognizer.getErrorListenerDispatch

getErrorListeners()

function getErrorListeners(): Array<ANTLRErrorListener<number>>

Gibt zurück

Array<ANTLRErrorListener<number>>

Geerbt von Recognizer.getErrorListeners

getRuleIndexMap()

Abrufen einer Zuordnung von Regelnamen zu Regelindizes. Wird für die XPath- und Strukturmusterkompilierung verwendet.

function getRuleIndexMap(): ReadonlyMap<string, number>

Gibt zurück

ReadonlyMap<string, number>

Geerbt von Recognizer.getRuleIndexMap

getTokenType(string)

function getTokenType(tokenName: string): number

Parameter

tokenName

string

Gibt zurück

number

Geerbt von Recognizer.getTokenType

getTokenTypeMap()

Rufen Sie eine Zuordnung von Tokennamen zu Tokentypen ab. Wird für die XPath- und Strukturmusterkompilierung verwendet.

function getTokenTypeMap(): ReadonlyMap<string, number>

Gibt zurück

ReadonlyMap<string, number>

Geerbt von Recognizer.getTokenTypeMap

mode(number)

function mode(m: number)

Parameter

m

number

Geerbt von Lexer.mode

more()

function more()

Geerbt von Lexer.more

nextToken()

Gibt ein Token aus dieser Quelle zurück. Das heißt, ein Token im Char-Stream abgleichen.

function nextToken(): Token

Gibt zurück

Token

Geerbt von Lexer.nextToken

notifyListeners(LexerNoViableAltException)

function notifyListeners(e: LexerNoViableAltException)

Parameter

e

LexerNoViableAltException

Geerbt von Lexer.notifyListeners

popMode()

function popMode(): number

Gibt zurück

number

Geerbt von Lexer.popMode

precpred(RuleContext | undefined, number)

function precpred(localctx: RuleContext | undefined, precedence: number): boolean

Parameter

localctx

RuleContext | undefined

precedence

number

Gibt zurück

boolean

Geerbt von Recognizer.precpred

pushMode(number)

function pushMode(m: number)

Parameter

m

number

Geerbt von Lexer.pushMode

recover(LexerNoViableAltException)

function recover(re: LexerNoViableAltException)

Parameter

re

LexerNoViableAltException

Geerbt von Lexer.recover

recover(RecognitionException)

Lexers können normalerweise mit jedem Zeichen in ihrem Vokabular übereinstimmen, nachdem ein Token abgeglichen wurde. Machen Sie also die einfache Sache und töten Sie einfach einen Charakter und hoffen, dass alles funktioniert. Sie können stattdessen den Regelaufrufstapel verwenden, um eine komplexe Fehlerwiederherstellung auszuführen, wenn Sie sich in einer Fragmentregel befinden.

function recover(re: RecognitionException)

Parameter

re

RecognitionException

Geerbt von Lexer.recover

removeErrorListener(ANTLRErrorListener<number>)

function removeErrorListener(listener: ANTLRErrorListener<number>)

Parameter

listener

ANTLRErrorListener<number>

Geerbt von Recognizer.removeErrorListener

removeErrorListeners()

function removeErrorListeners()

Geerbt von Recognizer.removeErrorListeners

reset()

function reset()

Geerbt von Lexer.reset

reset(boolean)

function reset(resetInput: boolean)

Parameter

resetInput

boolean

Geerbt von Lexer.reset

sempred(RuleContext | undefined, number, number)

function sempred(_localctx: RuleContext | undefined, ruleIndex: number, actionIndex: number): boolean

Parameter

_localctx

RuleContext | undefined

ruleIndex

number

actionIndex

number

Gibt zurück

boolean

Geerbt von Recognizer.sempred

skip()

Weisen Sie den Lexer an, das Erstellen eines Tokens für die aktuelle Lexerregel zu überspringen und nach einem anderen Token zu suchen. nextToken() weiß, dass sie weiterhin suchen, wenn eine Lexerregel das Token auf SKIP_TOKEN festgelegt hat. Denken Sie daran, dass, wenn token==am Ende einer Tokenregel nicht definiert ist, es eine für Sie erstellt und ausgibt.

function skip()

Geerbt von Lexer.skip