Struct BaseParser 

pub struct BaseParser<'input, 'arena, Ext, Node, Input, TF>
where
    Ext: ParserRecog<'input, 'arena, Self, TF::Tok>,
    TF: TokenFactory<'input, 'arena> + 'arena,
    Input: TokenStream<'input, 'arena, TF>,
    Node: NodeKindType<'arena, TF::Tok>,
    'input: 'arena,
{
    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

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::Tok>, TF: TokenFactory<'input, 'arena> + 'arena, Input: TokenStream<'input, 'arena, TF>, Node: NodeKindType<'arena, TF::Tok>, 'input: 'arena,

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

pub fn set_global_cache_threshold(&mut self, threshold: usize)

pub fn get_interpreter_mut(&mut self) -> &mut ParserATNSimulator<'arena>

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

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

pub fn ctx(&self) -> Option<&'arena TreeNode<'input, 'arena, Node, TF::Tok>>

Gets a reference to current context.

pub unsafe fn ctx_mut( &mut self, ) -> Option<&'arena mut TreeNode<'input, 'arena, Node, TF::Tok>>

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 TreeNode<'input, 'arena, Node, TF::Tok>>

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

where F: FnOnce(&mut TreeNode<'input, 'arena, Node, TF::Tok>) -> 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<'arena, Node, TF::Tok>,

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: &'arena mut TreeNode<'input, 'arena, Node, TF::Tok>, state: i32, _rule_index: usize, ) -> Result<(), ANTLRError>

pub fn exit_rule( &mut self, ) -> Result<&'arena TreeNode<'input, 'arena, Node, TF::Tok>, ANTLRError>

pub fn enter_recursion_rule( &mut self, localctx: &'arena mut TreeNode<'input, 'arena, Node, TF::Tok>, state: i32, _rule_index: usize, precedence: i32, ) -> Result<(), ANTLRError>

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

pub fn unroll_recursion_context( &mut self, parent_ctx: Option<&'arena TreeNode<'input, 'arena, Node, TF::Tok>>, ) -> Result<&'arena TreeNode<'input, 'arena, Node, TF::Tok>, 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::Tok>, TF: TokenFactory<'input, 'arena> + 'arena, Input: TokenStream<'input, 'arena, TF>, Node: NodeKindType<'arena, TF::Tok>, '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::Tok>, TF: TokenFactory<'input, 'arena> + 'arena, Input: TokenStream<'input, 'arena, TF>, Node: NodeKindType<'arena, TF::Tok>, 'input: 'arena,

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

Mutably dereferences the value.

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

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

fn drop(&mut self)

Executes the destructor for this type.

fn pin_drop(self: Pin<&mut Self>)

🔬This is a nightly-only experimental API. (pin_ergonomics)

Execute the destructor for this type, but different to Drop::drop, it requires self to be pinned.

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::Tok>, TF: TokenFactory<'input, 'arena> + 'arena, Input: TokenStream<'input, 'arena, TF>, Node: NodeKindType<'arena, TF::Tok>, 'input: 'arena,

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

fn get_interpreter(&self) -> &'arena ParserATNSimulator<'arena>

fn get_token_factory(&self) -> &TF

fn get_current_context(&self) -> &'arena TreeNode<'input, 'arena, Node, TF::Tok>

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

fn precpred( &self, _localctx: Option<&TreeNode<'input, 'arena, Node, TF::Tok>>, 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<'a>(&'a self) -> Cow<'a, IntervalSet>

fn add_error_listener( &mut self, listener: Box<dyn ErrorListener<'input, 'arena, Self, TF::Tok> + '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, TF::Tok> + '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>