Struct antlr_rust::BaseParser

pub struct BaseParser<'input, Ext: 'static, I: TokenStream<'input>, Ctx: ParserNodeType<'input, TF = I::TF>, T: ParseTreeListener<'input, Ctx> + ?Sized = dyn ParseTreeListener<'input, Ctx>> {
    pub ctx: Option<Rc<Ctx::Type>>,
    pub build_parse_trees: bool,
    pub matched_eof: bool,
    pub input: I,
    // some fields omitted
}

Main underlying Parser struct

It is a member of generated parser struct, so almost always you don't need to create it yourself. Generated parser hides complexity of this struct and expose required flexibility via generic parameters

Fields

ctx: Option<Rc<Ctx::Type>>

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 bute 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: I

Implementations

impl<'input, Ext, I, Ctx, T: ?Sized> BaseParser<'input, Ext, I, Ctx, T> where
    Ext: ParserRecog<'input, Self> + 'static,
    I: TokenStream<'input>,
    Ctx: ParserNodeType<'input, TF = I::TF>,
    T: ParseTreeListener<'input, Ctx>,
    Ctx::Type: Listenable<T>,
    Rc<TerminalNode<'input, Ctx>>: CoerceUnsized<Rc<Ctx::Type>>,
    Rc<ErrorNode<'input, Ctx>>: CoerceUnsized<Rc<Ctx::Type>>, 

pub fn new_base_parser(
    input: I,
    interpreter: Arc<ParserATNSimulator>,
    ext: Ext
) -> Self

pub fn match_token(
    &mut self,
    ttype: isize,
    err_handler: &mut dyn ErrorStrategy<'input, Self>
) -> Result<<I::TF as TokenFactory<'input>>::Tok, ANTLRError>

pub fn match_wildcard(
    &mut self,
    err_handler: &mut dyn ErrorStrategy<'input, Self>
) -> Result<<I::TF as TokenFactory<'input>>::Tok, 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

Embedded listener currently must outlive 'input. If you need to have arbitrary listener use ParseTreeWalker.

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 without 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<Ctx::Type>,
    state: isize,
    _rule_index: usize
)

pub fn exit_rule(&mut self)

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

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

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

pub fn unroll_recursion_context(&mut self, parent_ctx: Option<Rc<Ctx::Type>>)

pub fn dump_dfa(&self)

Trait Implementations

impl<'input, Ext, I, Ctx, T: ?Sized> Deref for BaseParser<'input, Ext, I, Ctx, T> where
    Ext: ParserRecog<'input, Self> + 'static,
    I: TokenStream<'input>,
    Ctx: ParserNodeType<'input, TF = I::TF>,
    T: ParseTreeListener<'input, Ctx>, 

type Target = Ext

The resulting type after dereferencing.

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

Dereferences the value.

impl<'input, Ext, I, Ctx, T: ?Sized> DerefMut for BaseParser<'input, Ext, I, Ctx, T> where
    Ext: ParserRecog<'input, Self> + 'static,
    I: TokenStream<'input>,
    Ctx: ParserNodeType<'input, TF = I::TF>,
    T: ParseTreeListener<'input, Ctx>, 

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

Mutably dereferences the value.

impl<'input, Ext, I, Ctx, T: ?Sized> Parser<'input> for BaseParser<'input, Ext, I, Ctx, T> where
    Ext: ParserRecog<'input, Self> + 'static,
    I: TokenStream<'input>,
    Ctx: ParserNodeType<'input, TF = I::TF>,
    T: ParseTreeListener<'input, Ctx>,
    Ctx::Type: Listenable<T>,
    Rc<TerminalNode<'input, Ctx>>: CoerceUnsized<Rc<Ctx::Type>>,
    Rc<ErrorNode<'input, Ctx>>: CoerceUnsized<Rc<Ctx::Type>>, 

fn get_interpreter(&self) -> &ParserATNSimulator

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

fn get_parser_rule_context(&self) -> &Rc<Ctx::Type>

fn consume(&mut self, err_handler: &mut dyn ErrorStrategy<'input, Self>)

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

fn get_input_stream_mut(
    &mut self
) -> &mut dyn TokenStream<'input, TF = Self::TF>

fn get_input_stream(&self) -> &dyn TokenStream<'input, TF = Self::TF>

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

fn get_expected_tokens(&self) -> IntervalSet

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

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<'input, Self> + '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<'input, Ext, I, Ctx, T: ?Sized> Recognizer<'input> for BaseParser<'input, Ext, I, Ctx, T> where
    Ext: ParserRecog<'input, Self> + 'static,
    I: TokenStream<'input>,
    Ctx: ParserNodeType<'input, TF = I::TF>,
    T: ParseTreeListener<'input, Ctx>, 

type Node = Ctx

fn sempred(
    &mut self,
    localctx: Option<&Ctx::Type>,
    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: Option<&<Self::Node as ParserNodeType<'input>>::Type>,
    rule_index: isize,
    action_index: isize
) where
    Self: Sized, 

impl<'input, Ext: 'static, I: TokenStream<'input>, Ctx: ParserNodeType<'input, TF = I::TF>, T: ParseTreeListener<'input, Ctx> + ?Sized> TidAble<'input> for BaseParser<'input, Ext, I, Ctx, T> where
    I: TidAble<'input>,
    Ctx: TidAble<'input>,
    T: TidAble<'input>, 

type Static = __BaseParserinputExtICtxT_should_never_exist<Ext, I::Static, Ctx::Static, T::Static>

impl<'input, Ext, I, Ctx, T: ?Sized> TokenAware<'input> for BaseParser<'input, Ext, I, Ctx, T> where
    Ext: ParserRecog<'input, Self> + 'static,
    I: TokenStream<'input>,
    Ctx: ParserNodeType<'input, TF = I::TF>,
    T: ParseTreeListener<'input, Ctx>, 

type TF = I::TF