Struct antlr_rust::parser::BaseParser

pub struct BaseParser<Ext: ParserRecog<Recog = Self> + 'static, T: ParseTreeListener + ?Sized + 'static = dyn ParseTreeListener> {
    pub ctx: Option<ParserRuleContextType>,
    pub build_parse_trees: bool,
    pub matched_eof: bool,
    pub input: Box<dyn TokenStream>,
    // some fields omitted
}

Fields

ctx: Option<ParserRuleContextType>

build_parse_trees: bool

Track the {@link ParserRuleContext} objects during the parse and hook them up using the {@link ParserRuleContext#children} list so that it forms a parse tree. The {@link ParserRuleContext} returned from the start rule represents the root of the parse tree.

Note that if we are not building parse trees, rule contexts only point upwards. When a rule exits, it returns the context but that gets garbage collected if nobody holds a reference. It points upwards but nobody points at it.

When we build parse trees, we are adding all of these contexts to {@link ParserRuleContext#children} list. Contexts are then not candidates for garbage collection.

Returns {@code true} if a complete parse tree will be constructed while parsing, otherwise {@code false}

matched_eof: bool

input: Box<dyn TokenStream>

Methods

impl<T: ?Sized, Ext> BaseParser<Ext, T> where
    T: ParseTreeListener + 'static,
    Ext: ParserRecog<Recog = Self> + 'static, 

pub fn new_base_parser(
    input: Box<dyn TokenStream>,
    interpreter: Arc<ParserATNSimulator>,
    ext: Ext
) -> BaseParser<Ext, T>

pub fn match_token(
    &mut self,
    ttype: isize,
    err_handler: &mut dyn ErrorStrategy
) -> Result<OwningToken, ANTLRError>

pub fn match_wildcard(
    &mut self,
    err_handler: &mut dyn ErrorStrategy
) -> Result<OwningToken, ANTLRError>

pub fn add_parse_listener<L: Unsize<T>>(
    &mut self,
    listener: Box<L>
) -> ListenerId<L>

Adds parse listener for this parser returns listener_id that can be used later to get listener back

Example for listener usage:

todo

pub fn remove_parse_listener<L: Unsize<T>>(
    &mut self,
    listener_id: ListenerId<L>
) -> Box<L>

Removes parse listener with corresponding listener_id, casts it back to user type and returns it to the caller. listener_id is returned when listener is added via add_parse_listener

pub fn remove_parse_listeners(&mut self)

Removes all added parse listeners wothout returning them

pub fn trigger_enter_rule_event(&mut self)

pub fn trigger_exit_rule_event(&mut self)

pub fn enter_rule(
    &mut self,
    localctx: Rc<dyn ParserRuleContext>,
    state: isize,
    _rule_index: usize
)

pub fn exit_rule(&mut self)

pub fn enter_outer_alt(
    &mut self,
    new_ctx: Option<Rc<dyn ParserRuleContext>>,
    alt_num: isize
)

pub fn enter_recursion_rule(
    &mut self,
    localctx: Rc<dyn ParserRuleContext>,
    state: isize,
    _rule_index: usize,
    precedence: isize
)

pub fn push_new_recursion_context(
    &mut self,
    localctx: Rc<dyn ParserRuleContext>,
    state: isize,
    _rule_index: usize
)

pub fn unroll_recursion_context(
    &mut self,
    parent_ctx: Option<Rc<dyn ParserRuleContext>>
)

pub fn dump_dfa(&self)

Trait Implementations

impl<T: ?Sized, Ext> Deref for BaseParser<Ext, T> where
    T: ParseTreeListener + 'static,
    Ext: ParserRecog<Recog = Self> + 'static, 

type Target = Ext

The resulting type after dereferencing.

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

Dereferences the value.

impl<T: ?Sized, Ext> DerefMut for BaseParser<Ext, T> where
    T: ParseTreeListener + 'static,
    Ext: ParserRecog<Recog = Self> + 'static, 

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

Mutably dereferences the value.

impl<T: ?Sized, Ext> Parser for BaseParser<Ext, T> where
    T: ParseTreeListener + 'static,
    Ext: ParserRecog<Recog = Self> + 'static, 

fn get_interpreter(&self) -> &ParserATNSimulator

fn get_token_factory(&self) -> &dyn TokenFactory

fn get_parser_rule_context(&self) -> &Rc<dyn ParserRuleContext>

fn consume(&mut self, err_handler: &mut dyn ErrorStrategy)

fn precpred(
    &self,
    _localctx: Option<&dyn ParserRuleContext>,
    precedence: isize
) -> bool

fn get_input_stream_mut(&mut self) -> &mut dyn TokenStream

fn get_input_stream(&self) -> &dyn TokenStream

fn get_current_token(&self) -> &dyn Token

fn get_expected_tokens(&self) -> IntervalSet

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

fn notify_error_listeners(
    &self,
    msg: String,
    offending_token: Option<isize>,
    err: Option<&ANTLRError>
)

fn get_error_lister_dispatch<'a>(&'a self) -> Box<dyn ErrorListener + 'a>

fn is_expected_token(&self, _symbol: isize) -> bool

fn get_precedence(&self) -> isize

fn get_state(&self) -> isize

fn set_state(&mut self, v: isize)

fn get_rule_invocation_stack(&self) -> Vec<String>

impl<T: ?Sized, Ext> Recognizer for BaseParser<Ext, T> where
    T: ParseTreeListener + 'static,
    Ext: ParserRecog<Recog = Self> + 'static, 

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

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

fn action(
    &mut self,
    _localctx: &dyn ParserRuleContext,
    _rule_index: isize,
    _action_index: isize
)