Struct antlr_rust::lexer::BaseLexer

pub struct BaseLexer<T: LexerRecog<Recog = Self> + 'static> {
    pub interpreter: Option<LexerATNSimulator>,
    pub input: Option<Box<dyn CharStream>>,
    pub token_start_char_index: isize,
    pub token_start_line: isize,
    pub token_start_column: isize,
    pub token_type: isize,
    pub token: Option<Box<dyn Token>>,
    pub channel: isize,
    pub mode: usize,
    pub text: String,
    // some fields omitted
}

Fields

interpreter: Option<LexerATNSimulator>

input: Option<Box<dyn CharStream>>

token_start_char_index: isize

token_start_line: isize

token_start_column: isize

token_type: isize

token: Option<Box<dyn Token>>

channel: isize

mode: usize

text: String

Implementations

impl<T: LexerRecog<Recog = Self> + 'static> BaseLexer<T>

pub fn get_type(&self) -> isize

pub fn get_char_index(&self) -> isize

pub fn get_text(&self) -> String

pub fn set_text(&self, _text: String)

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

Add error listener

pub fn remove_error_listeners(&mut self)

pub fn new_base_lexer(
    input: Box<dyn CharStream>,
    interpreter: LexerATNSimulator,
    recog: Box<T>
) -> BaseLexer<T>

Trait Implementations

impl<T: LexerRecog<Recog = Self> + 'static> Deref for BaseLexer<T>

type Target = T

The resulting type after dereferencing.

fn deref(&self) -> &Self::Target

Dereferences the value.

impl<T: LexerRecog<Recog = Self> + 'static> DerefMut for BaseLexer<T>

fn deref_mut(&mut self) -> &mut Self::Target

Mutably dereferences the value.

impl<T: LexerRecog<Recog = Self> + 'static> Lexer for BaseLexer<T>

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 continution 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<T: LexerRecog<Recog = Self> + 'static> Recognizer for BaseLexer<T>

fn sempred(
    &mut self,
    _localctx: &dyn ParserRuleContext,
    rule_index: isize,
    action_index: isize
) -> bool

fn action(
    &mut self,
    _localctx: &dyn ParserRuleContext,
    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<T: LexerRecog<Recog = Self> + 'static> TokenSource for BaseLexer<T>

fn next_token(&mut self) -> Box<dyn Token>

fn get_line(&self) -> isize

fn get_char_position_in_line(&self) -> isize

fn get_input_stream(&mut self) -> &mut dyn CharStream

fn get_source_name(&self) -> String

fn get_token_factory(&self) -> &dyn TokenFactory