Struct BaseParser 

pub struct BaseParser<'input, 'arena, Ext, Node, Input, TF>
where
    Ext: ParserRecog<'input, 'arena, Self>,
    TF: TokenFactory<'input, 'arena> + 'arena,
    Input: TokenStream<'input, 'arena, TF>,
    Node: RuleNode<'input, 'arena>,
{
    pub interp: Arc<ParserATNSimulator>,
    pub build_parse_trees: bool,
    pub matched_eof: bool,
    pub input: Input,
    pub arena: &'arena Arena,
    /* private fields */
}

Abstract base parser implementation

Only meant to be instantiated by generated parsers

Fields

interp: Arc<ParserATNSimulator>

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

Token stream that is currently used by this parser

arena: &'arena Arena

Implementations

impl<'input, 'arena, Ext, Node, Input, TF> BaseParser<'input, 'arena, Ext, Node, Input, TF>

where Ext: ParserRecog<'input, 'arena, Self>, TF: TokenFactory<'input, 'arena> + 'arena, Input: TokenStream<'input, 'arena, TF>, Node: RuleNode<'input, 'arena>,

pub fn new_base_parser( arena: &'arena Arena, input: Input, interpreter: Arc<ParserATNSimulator>, ext: Ext, ) -> Self

pub fn ctx_is(&self, other: Option<&'arena Node>) -> bool

If current context is same as the given one by pointer comparison

pub fn ctx(&self) -> Option<&'arena Node>

Gets a reference to current context.

pub unsafe fn ctx_mut(&mut self) -> Option<&'arena mut Node>

Gets a mutable reference to current context.

Safety

Follows the same safety rules as dereferencing *mut to &mut

pub fn take_ctx(&mut self) -> Option<&'arena Node>

pub fn with_mut_ctx<F, R>(&mut self, f: F) -> R

where F: FnOnce(&mut Node) -> R,

pub fn match_token( &mut self, ttype: i32, err_handler: &mut impl ErrorStrategy<'input, 'arena, TF, Self>, ) -> Result<&'arena TF::Tok, ANTLRError>

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

pub fn add_dyn_parse_listener(&mut self, listener: Box<Node::Listener>)

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

where L: ParseTreeListener<'input, 'arena, Node>,

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) -> Result<(), ANTLRError>

pub fn trigger_exit_rule_event(&mut self) -> Result<(), ANTLRError>

pub fn enter_rule( &mut self, localctx: Node, state: i32, _rule_index: usize, ) -> Result<(), ANTLRError>

pub fn exit_rule(&mut self) -> Result<&'arena Node, ANTLRError>

pub fn enter_recursion_rule( &mut self, localctx: Node, state: i32, _rule_index: usize, precedence: i32, ) -> Result<(), ANTLRError>

pub fn push_new_recursion_context( &mut self, localctx: Node, state: i32, _rule_index: usize, ) -> Result<&'arena Node, ANTLRError>

pub fn unroll_recursion_context( &mut self, parent_ctx: Option<&'arena Node>, ) -> Result<&'arena Node, ANTLRError>

pub fn dump_dfa(&self)

Text representation of generated DFA for debugging purposes

Trait Implementations

impl<'input, 'arena, Ext, Node, Input, TF> Deref for BaseParser<'input, 'arena, Ext, Node, Input, TF>

where Ext: ParserRecog<'input, 'arena, Self>, TF: TokenFactory<'input, 'arena> + 'arena, Input: TokenStream<'input, 'arena, TF>, Node: RuleNode<'input, 'arena>,

type Target = Ext

The resulting type after dereferencing.

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

Dereferences the value.

impl<'input, 'arena, Ext, Node, Input, TF> DerefMut for BaseParser<'input, 'arena, Ext, Node, Input, TF>

where Ext: ParserRecog<'input, 'arena, Self>, TF: TokenFactory<'input, 'arena> + 'arena, Input: TokenStream<'input, 'arena, TF>, Node: RuleNode<'input, 'arena>,

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

Mutably dereferences the value.

impl<'input, 'arena, Ext, Node, Input, TF> Parser<'input, 'arena, TF> for BaseParser<'input, 'arena, Ext, Node, Input, TF>

where Ext: ParserRecog<'input, 'arena, Self>, TF: TokenFactory<'input, 'arena> + 'arena, Input: TokenStream<'input, 'arena, TF>, Node: RuleNode<'input, 'arena>, 'input: 'arena,

fn get_arena(&self) -> &'arena Arena

fn get_interpreter(&self) -> &ParserATNSimulator

fn get_token_factory(&self) -> &TF

fn get_current_context(&self) -> &'arena Node

fn consume( &mut self, err_handler: &mut impl ErrorStrategy<'input, 'arena, TF, Self>, ) -> Result<(), ANTLRError>

fn precpred(&self, _localctx: Option<&Node>, precedence: i32) -> bool

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

fn get_input_stream(&self) -> &dyn TokenStream<'input, 'arena, TF>

fn get_current_token(&self) -> &'arena TF::Tok

fn get_expected_tokens(&self) -> IntervalSet

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

fn remove_error_listeners(&mut 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, 'arena, Self> + 'a>

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

fn get_precedence(&self) -> i32

fn get_state(&self) -> i32

fn set_state(&mut self, v: i32)

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