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>>

Rule context parser is currently processing

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

true if parser reached EOF

input: I

Token stream that is currently used by this parser

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 impl ErrorStrategy<'input, Self>
) -> Result<<I::TF as TokenFactory<'input>>::Tok, ANTLRError>

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

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

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>(&mut self, listener_id: ListenerId<L>) -> Box<L> where
    Box<L>: CoerceUnsized<Box<T>>, 

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)

Text representation of generated DFA for debugging purposes

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.

pub 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>, 

pub 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>>, 

pub fn get_interpreter(&self) -> &ParserATNSimulator

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

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

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

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

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

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

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

pub fn get_expected_tokens(&self) -> IntervalSet

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

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

pub fn get_error_lister_dispatch<'a>(
    &'a self
) -> Box<dyn ErrorListener<'input, Self> + 'a>

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

pub fn get_precedence(&self) -> isize

pub fn get_state(&self) -> isize

pub fn set_state(&mut self, v: isize)

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

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>