Struct antlr_rust::BaseLexer

pub struct BaseLexer<'input, T: LexerRecog<'input, Self> + 'static, Input: CharStream<TF::From>, TF: TokenFactory<'input> = CommonTokenFactory> {
    pub interpreter: Option<LexerATNSimulator>,
    pub input: Option<Input>,
    pub token_start_char_index: isize,
    pub token_start_line: isize,
    pub token_start_column: isize,
    pub token_type: isize,
    pub token: Option<TF::Tok>,
    pub channel: isize,
    pub mode: usize,
    pub text: Option<<TF::Data as ToOwned>::Owned>,
    // some fields omitted
}

Fields

interpreter: Option<LexerATNSimulator>

input: Option<Input>

token_start_char_index: isize

token_start_line: isize

token_start_column: isize

token_type: isize

token: Option<TF::Tok>

channel: isize

mode: usize

text: Option<<TF::Data as ToOwned>::Owned>

text of token if overridden by user action

Implementations

impl<'input, T, Input, TF> BaseLexer<'input, T, Input, TF> where
    T: LexerRecog<'input, Self> + 'static,
    Input: CharStream<TF::From>,
    TF: TokenFactory<'input>, 

pub fn get_type(&self) -> isize

pub fn get_char_index(&self) -> isize

pub fn get_text<'a>(&'a self) -> Cow<'a, TF::Data> where
    'input: 'a, 

Current token text

pub fn set_text(&mut self, _text: <TF::Data as ToOwned>::Owned)

Used from lexer actions to override text of the token that will be emitted next

pub fn add_error_listener(
    &mut self,
    listener: Box<dyn ErrorListener<'input, Self>>
)

Add error listener

pub fn remove_error_listeners(&mut self)

pub fn new_base_lexer(
    input: Input,
    interpreter: LexerATNSimulator,
    recog: T,
    factory: &'input TF
) -> Self

Trait Implementations

impl<'input, T, Input, TF> Lexer<'input> for BaseLexer<'input, T, Input, TF> where
    T: LexerRecog<'input, Self> + 'static,
    Input: CharStream<TF::From>,
    TF: TokenFactory<'input>, 

fn set_channel(&mut self, v: isize)

Sets channel where current token will be pushed

fn push_mode(&mut self, m: usize)

Pushes current mode to internal mode stack and sets m as current lexer mode `pop_mode should be used to recover previous mode

fn pop_mode(&mut self) -> Option<usize>

Pops mode from internal mode stack

fn set_type(&mut self, t: isize)

Sets type of the current token Called from action to override token that will be emitted by lexer

fn set_mode(&mut self, m: usize)

Sets lexer mode discarding current one

fn more(&mut self)

Used to informs lexer that it should consider next token as a continuation of the current one

fn skip(&mut self)

Tells lexer to completely ignore and not emit current token.

fn reset(&mut self)

fn get_interpreter(&self) -> Option<&LexerATNSimulator>

impl<'input, T, Input, TF> Recognizer<'input> for BaseLexer<'input, T, Input, TF> where
    T: LexerRecog<'input, Self> + 'static,
    Input: CharStream<TF::From>,
    TF: TokenFactory<'input>, 

type Node = EmptyContextType<'input, TF>

fn sempred(
    &mut self,
    _localctx: Option<&<Self::Node as ParserNodeType<'input>>::Type>,
    rule_index: isize,
    action_index: isize
) -> bool

fn action(
    &mut self,
    _localctx: Option<&<Self::Node as ParserNodeType<'input>>::Type>,
    rule_index: isize,
    action_index: isize
)

fn get_rule_names(&self) -> &[&str]

Returns array of rule names. Used for debugging and error reporting

fn get_vocabulary(&self) -> &dyn Vocabulary

fn get_grammar_file_name(&self) -> &str

Name of the file this recognizer was generated from

fn get_atn(&self) -> &ATN

impl<'input, T, Input, TF> TokenAware<'input> for BaseLexer<'input, T, Input, TF> where
    T: LexerRecog<'input, Self> + 'static,
    Input: CharStream<TF::From>,
    TF: TokenFactory<'input>, 

type TF = TF

impl<'input, T, Input, TF> TokenSource<'input> for BaseLexer<'input, T, Input, TF> where
    T: LexerRecog<'input, Self> + 'static,
    Input: CharStream<TF::From>,
    TF: TokenFactory<'input>, 

fn next_token(&mut self) -> <Self::TF as TokenFactory<'input>>::Tok

fn get_line(&self) -> isize

Get the line number for the current position in the input stream. The first line in the input is line 1.

fn get_char_position_in_line(&self) -> isize

Get the index into the current line for the current position in the input stream. The first character on a line has position 0.

fn get_input_stream(&mut self) -> Option<&mut dyn IntStream>

fn get_source_name(&self) -> String

fn get_token_factory(&self) -> &'input TF

Gets the {@link TokenFactory} this token source is currently using for creating {@link Token} objects from the input.