Freigeben über

LGTemplateLexer class

  • Referenz
Paket:
botbuilder-lg
Extends

Lexer

Konstruktoren

LGTemplateLexer(CharStream)

Eigenschaften

beginOfStructureProperty
beginOfTemplateBody
beginOfTemplateLine
CASE
channelNames
channelNames
COMMENTS
DASH
DEFAULT
ELSE
ELSEIF
ESCAPE_CHARACTER
ESCAPE_CHARACTER_IN_STRUCTURE_BODY
EXPRESSION
EXPRESSION_IN_STRUCTURE_BODY
grammarFileName
IF
ignoreWS
inMultiline
inStructuredValue
INVALID_TOKEN
LEFT_SQUARE_BRACKET
modeNames
modeNames
MULTILINE_MODE
MULTILINE_PREFIX
MULTILINE_SUFFIX
NEWLINE
NEWLINE_IN_BODY
NEWLINE_IN_STRUCTURE_NAME
NORMAL_TEMPLATE_BODY_MODE
ruleNames
ruleNames
serializedATN
STRUCTURED_BODY_END
STRUCTURED_COMMENTS
STRUCTURED_NEWLINE
STRUCTURE_BODY_MODE
STRUCTURE_EQUALS
STRUCTURE_IDENTIFIER
STRUCTURE_NAME
STRUCTURE_NAME_MODE
STRUCTURE_OR_MARK
SWITCH
TEXT
TEXT_IN_STRUCTURE_BODY
TEXT_IN_STRUCTURE_NAME
VOCABULARY
vocabulary
WS
WS_IN_BODY
WS_IN_STRUCTURE_BODY
WS_IN_STRUCTURE_NAME

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

Methoden

action(RuleContext, number, number)
sempred(RuleContext, number, number)

Geerbte Methoden

addErrorListener(ANTLRErrorListener<number>)
emit()

Standardmäßig werden aus Effizienzgründen nicht mehrere Emitte pro nextToken-Aufruf unterstützt. Unterklasse und überschreiben diese Methode, nextToken und getToken (um Token in eine Liste zu pushen und aus dieser Liste anstelle einer einzelnen Variablen zu pullen, 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 Charpuffer start zeigen. Stoppen. Wenn in "text" eine Textüberschreibung vorhanden ist, verwenden Sie diese, 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 Eingabezeichendatenstrom 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()

Ruft eine Zuordnung von Regelnamen zu Regelindizes ab. Wird für die Kompilierung von XPath- und Strukturmustern verwendet.
getTokenType(string)
getTokenTypeMap()

Ruft eine Zuordnung von Tokennamen zu Tokentypen ab. Wird für die Kompilierung von XPath- und Strukturmustern 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)

Lexer können normalerweise jedes Zeichen in ihrem Vokabular nach dem Abgleich eines Tokens abgleichen, also machen Sie das Einfache und töten Sie einfach einen Charakter und hoffen, dass alles funktioniert. Sie können stattdessen den Regelaufrufstapel verwenden, um eine komplexe Fehlerwiederherstellung durchzuführen, wenn Sie sich in einer Fragmentregel befinden.
removeErrorListener(ANTLRErrorListener<number>)
removeErrorListeners()
reset()
reset(boolean)
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

LGTemplateLexer(CharStream) 

new LGTemplateLexer(input: CharStream)

Parameter

input

CharStream

Details zur Eigenschaft

beginOfStructureProperty 

beginOfStructureProperty: boolean = false

Eigenschaftswert

boolean

beginOfTemplateBody 

beginOfTemplateBody: boolean = true

Eigenschaftswert

boolean

beginOfTemplateLine 

beginOfTemplateLine: boolean = false

Eigenschaftswert

boolean

CASE 

public static CASE: 14 = 14

Eigenschaftswert

14

channelNames 

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

Eigenschaftswert

string[]

channelNames 

string[] channelNames

Eigenschaftswert

string[]

COMMENTS 

public static COMMENTS: 3 = 3

Eigenschaftswert

3

DASH 

public static DASH: 4 = 4

Eigenschaftswert

4

DEFAULT 

public static DEFAULT: 15 = 15

Eigenschaftswert

15

ELSE 

public static ELSE: 12 = 12

Eigenschaftswert

12

ELSEIF 

public static ELSEIF: 11 = 11

Eigenschaftswert

11

ESCAPE_CHARACTER 

public static ESCAPE_CHARACTER: 16 = 16

Eigenschaftswert

16

ESCAPE_CHARACTER_IN_STRUCTURE_BODY 

public static ESCAPE_CHARACTER_IN_STRUCTURE_BODY: 31 = 31

Eigenschaftswert

31

EXPRESSION 

public static EXPRESSION: 17 = 17

Eigenschaftswert

17

EXPRESSION_IN_STRUCTURE_BODY 

public static EXPRESSION_IN_STRUCTURE_BODY: 32 = 32

Eigenschaftswert

32

grammarFileName 

string grammarFileName

Eigenschaftswert

string

IF 

public static IF: 10 = 10

Eigenschaftswert

10

ignoreWS 

ignoreWS: boolean = true

Eigenschaftswert

boolean

inMultiline 

inMultiline: boolean = false

Eigenschaftswert

boolean

inStructuredValue 

inStructuredValue: boolean = false

Eigenschaftswert

boolean

INVALID_TOKEN 

public static INVALID_TOKEN: 6 = 6

Eigenschaftswert

6

LEFT_SQUARE_BRACKET 

public static LEFT_SQUARE_BRACKET: 5 = 5

Eigenschaftswert

5

modeNames 

public static modeNames: string[] = [
		"DEFAULT_MODE", "NORMAL_TEMPLATE_BODY_MODE", "MULTILINE_MODE", "STRUCTURE_NAME_MODE", 
		"STRUCTURE_BODY_MODE",
	]

Eigenschaftswert

string[]

modeNames 

string[] modeNames

Eigenschaftswert

string[]

MULTILINE_MODE 

public static MULTILINE_MODE: 2 = 2

Eigenschaftswert

2

MULTILINE_PREFIX 

public static MULTILINE_PREFIX: 8 = 8

Eigenschaftswert

8

MULTILINE_SUFFIX 

public static MULTILINE_SUFFIX: 19 = 19

Eigenschaftswert

19

NEWLINE 

public static NEWLINE: 2 = 2

Eigenschaftswert

2

NEWLINE_IN_BODY 

public static NEWLINE_IN_BODY: 9 = 9

Eigenschaftswert

9

NEWLINE_IN_STRUCTURE_NAME 

public static NEWLINE_IN_STRUCTURE_NAME: 21 = 21

Eigenschaftswert

21

NORMAL_TEMPLATE_BODY_MODE 

public static NORMAL_TEMPLATE_BODY_MODE: 1 = 1

Eigenschaftswert

1

ruleNames 

public static ruleNames: string[] = [
		"A", "C", "D", "E", "F", "H", "I", "L", "S", "T", "U", "W", "LETTER", 
		"NUMBER", "WHITESPACE", "STRING_LITERAL", "STRING_INTERPOLATION", "ESCAPE_CHARACTER_FRAGMENT", 
		"IDENTIFIER", "OBJECT_DEFINITION", "EXPRESSION_FRAGMENT", "NEWLINE_FRAGMENT", 
		"WS", "NEWLINE", "COMMENTS", "DASH", "LEFT_SQUARE_BRACKET", "INVALID_TOKEN", 
		"WS_IN_BODY", "MULTILINE_PREFIX", "NEWLINE_IN_BODY", "IF", "ELSEIF", "ELSE", 
		"SWITCH", "CASE", "DEFAULT", "ESCAPE_CHARACTER", "EXPRESSION", "TEXT", 
		"MULTILINE_SUFFIX", "MULTILINE_ESCAPE_CHARACTER", "MULTILINE_EXPRESSION", 
		"MULTILINE_TEXT", "WS_IN_STRUCTURE_NAME", "NEWLINE_IN_STRUCTURE_NAME", 
		"STRUCTURE_NAME", "TEXT_IN_STRUCTURE_NAME", "STRUCTURED_COMMENTS", "WS_IN_STRUCTURE_BODY", 
		"STRUCTURED_NEWLINE", "STRUCTURED_BODY_END", "STRUCTURE_IDENTIFIER", "STRUCTURE_EQUALS", 
		"STRUCTURE_OR_MARK", "ESCAPE_CHARACTER_IN_STRUCTURE_BODY", "EXPRESSION_IN_STRUCTURE_BODY", 
		"TEXT_IN_STRUCTURE_BODY",
	]

Eigenschaftswert

string[]

ruleNames 

string[] ruleNames

Eigenschaftswert

string[]

serializedATN 

string serializedATN

Eigenschaftswert

string

STRUCTURED_BODY_END 

public static STRUCTURED_BODY_END: 27 = 27

Eigenschaftswert

27

STRUCTURED_COMMENTS 

public static STRUCTURED_COMMENTS: 24 = 24

Eigenschaftswert

24

STRUCTURED_NEWLINE 

public static STRUCTURED_NEWLINE: 26 = 26

Eigenschaftswert

26

STRUCTURE_BODY_MODE 

public static STRUCTURE_BODY_MODE: 4 = 4

Eigenschaftswert

4

STRUCTURE_EQUALS 

public static STRUCTURE_EQUALS: 29 = 29

Eigenschaftswert

29

STRUCTURE_IDENTIFIER 

public static STRUCTURE_IDENTIFIER: 28 = 28

Eigenschaftswert

28

STRUCTURE_NAME 

public static STRUCTURE_NAME: 22 = 22

Eigenschaftswert

22

STRUCTURE_NAME_MODE 

public static STRUCTURE_NAME_MODE: 3 = 3

Eigenschaftswert

3

STRUCTURE_OR_MARK 

public static STRUCTURE_OR_MARK: 30 = 30

Eigenschaftswert

30

SWITCH 

public static SWITCH: 13 = 13

Eigenschaftswert

13

TEXT 

public static TEXT: 18 = 18

Eigenschaftswert

18

TEXT_IN_STRUCTURE_BODY 

public static TEXT_IN_STRUCTURE_BODY: 33 = 33

Eigenschaftswert

33

TEXT_IN_STRUCTURE_NAME 

public static TEXT_IN_STRUCTURE_NAME: 23 = 23

Eigenschaftswert

23

VOCABULARY 

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

Eigenschaftswert

Vocabulary

vocabulary 

Vocabulary vocabulary

Eigenschaftswert

Vocabulary

WS 

public static WS: 1 = 1

Eigenschaftswert

1

WS_IN_BODY 

public static WS_IN_BODY: 7 = 7

Eigenschaftswert

7

WS_IN_STRUCTURE_BODY 

public static WS_IN_STRUCTURE_BODY: 25 = 25

Eigenschaftswert

25

WS_IN_STRUCTURE_NAME 

public static WS_IN_STRUCTURE_NAME: 20 = 20

Eigenschaftswert

20

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 Methode

action(RuleContext, number, number) 

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

Parameter

_localctx

RuleContext

ruleIndex

number

actionIndex

number

sempred(RuleContext, number, number) 

function sempred(_localctx: RuleContext, ruleIndex: number, predIndex: number): boolean

Parameter

_localctx

RuleContext

ruleIndex

number

predIndex

number

Gibt zurück

boolean

Details zur geerbten Methode

addErrorListener(ANTLRErrorListener<number>) 

function addErrorListener(listener: ANTLRErrorListener<number>)

Parameter

listener

ANTLRErrorListener<number>

Geerbt von Recognizer.addErrorListener

emit()

Standardmäßig werden aus Effizienzgründen nicht mehrere Emitte pro nextToken-Aufruf unterstützt. Unterklasse und überschreiben diese Methode, nextToken und getToken (um Token in eine Liste zu pushen und aus dieser Liste anstelle einer einzelnen Variablen zu pullen, 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 Charpuffer start zeigen. Stoppen. Wenn in "text" eine Textüberschreibung vorhanden ist, verwenden Sie diese, 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 Eingabezeichendatenstrom 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()

Ruft eine Zuordnung von Regelnamen zu Regelindizes ab. Wird für die Kompilierung von XPath- und Strukturmustern 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()

Ruft eine Zuordnung von Tokennamen zu Tokentypen ab. Wird für die Kompilierung von XPath- und Strukturmustern 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)

Lexer können normalerweise jedes Zeichen in ihrem Vokabular nach dem Abgleich eines Tokens abgleichen, also machen Sie das Einfache und töten Sie einfach einen Charakter und hoffen, dass alles funktioniert. Sie können stattdessen den Regelaufrufstapel verwenden, um eine komplexe Fehlerwiederherstellung durchzufü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

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