Struct BaseParserRuleContext

pub struct BaseParserRuleContext<'input, Ctx: CustomRuleContext<'input>> {
    pub exception: Option<Box<ANTLRError>>,
    /* private fields */
}

Default rule context implementation that keeps everything provided by parser

Fields

exception: Option<Box<ANTLRError>>

error if there was any in this node

Implementations

impl<'input, Ctx: CustomRuleContext<'input> + 'input> BaseParserRuleContext<'input, Ctx>

pub fn new_parser_ctx( parent_ctx: Option<Rc<<Ctx::Ctx as ParserNodeType<'input>>::Type>>, invoking_state: isize, ext: Ctx, ) -> Self

pub fn copy_from<T: ParserRuleContext<'input, TF = Ctx::TF, Ctx = Ctx::Ctx> + ?Sized>( ctx: &T, ext: Ctx, ) -> Self

Trait Implementations

impl<'input, Ctx: CustomRuleContext<'input>> Borrow<Ctx> for BaseParserRuleContext<'input, Ctx>

fn borrow(&self) -> &Ctx

Immutably borrows from an owned value.

impl<'input, Ctx: CustomRuleContext<'input>> BorrowMut<Ctx> for BaseParserRuleContext<'input, Ctx>

fn borrow_mut(&mut self) -> &mut Ctx

Mutably borrows from an owned value.

impl<'input, Ctx: CustomRuleContext<'input>> CustomRuleContext<'input> for BaseParserRuleContext<'input, Ctx>

type TF = <Ctx as CustomRuleContext<'input>>::TF

type Ctx = <Ctx as CustomRuleContext<'input>>::Ctx

Type that describes type of context nodes, stored in this context

fn get_rule_index(&self) -> usize

Rule index that corresponds to this context type

fn get_alt_number(&self) -> isize

fn set_alt_number(&self, _alt_number: isize)

fn get_node_text(&self, rule_names: &[&str]) -> String

Returns text representation of current node type, rule name for context nodes and token text for terminal nodes

impl<'input, Ctx: CustomRuleContext<'input>> Debug for BaseParserRuleContext<'input, Ctx>

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

Formats the value using the given formatter.

impl<'input, Ctx: CustomRuleContext<'input>> DerefMut for BaseParserRuleContext<'input, Ctx>

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

Mutably dereferences the value.

impl<'input, Ctx: CustomRuleContext<'input> + TidAble<'input>> ParseTree<'input> for BaseParserRuleContext<'input, Ctx>

fn get_source_interval(&self) -> Interval

Return an {@link Interval} indicating the index in the {@link TokenStream} of the first and last token associated with this subtree. If this node is a leaf, then the interval represents a single token and has interval i..i for token index i.

fn get_text(&self) -> String

Return combined text of this AST node. To create resulting string it does traverse whole subtree, also it includes only tokens added to the parse tree

fn to_string_tree( &self, r: &dyn Recognizer<'input, TF = Self::TF, Node = Self::Ctx>, ) -> String

Print out a whole tree, not just a node, in LISP format (root child1 .. childN). Print just a node if this is a leaf. We have to know the recognizer so we can get rule names.

impl<'input, Ctx: CustomRuleContext<'input> + TidAble<'input>> ParserRuleContext<'input> for BaseParserRuleContext<'input, Ctx>

fn set_exception(&self, _e: ANTLRError)

fn set_start(&self, t: Option<<Ctx::TF as TokenFactory<'input>>::Tok>)

fn start<'a>(&'a self) -> Ref<'a, <Ctx::TF as TokenFactory<'input>>::Inner>

where 'input: 'a,

Get the initial token in this context. Note that the range from start to stop is inclusive, so for rules that do not consume anything (for example, zero length or error productions) this token may exceed stop.

fn start_mut<'a>( &'a self, ) -> RefMut<'a, <Self::TF as TokenFactory<'input>>::Tok>

where 'input: 'a,

fn set_stop(&self, t: Option<<Ctx::TF as TokenFactory<'input>>::Tok>)

fn stop<'a>(&'a self) -> Ref<'a, <Ctx::TF as TokenFactory<'input>>::Inner>

where 'input: 'a,

Get the final token in this context. Note that the range from start to stop is inclusive, so for rules that do not consume anything (for example, zero length or error productions) this token may precede start.

fn stop_mut<'a>(&'a self) -> RefMut<'a, <Self::TF as TokenFactory<'input>>::Tok>

where 'input: 'a,

fn add_child(&self, child: Rc<<Ctx::Ctx as ParserNodeType<'input>>::Type>)

fn remove_last_child(&self)

fn child_of_type<T>(&self, pos: usize) -> Option<Rc<T>>

where T: ParserRuleContext<'input, TF = Self::TF, Ctx = Self::Ctx> + 'input, Self: Sized,

fn children_of_type<T>(&self) -> Vec<Rc<T>>

where T: ParserRuleContext<'input, TF = Self::TF, Ctx = Self::Ctx> + 'input, Self: Sized,

fn get_token( &self, ttype: isize, pos: usize, ) -> Option<Rc<TerminalNode<'input, Self::Ctx>>>

fn get_tokens(&self, ttype: isize) -> Vec<Rc<TerminalNode<'input, Self::Ctx>>>

impl<'input, Ctx: CustomRuleContext<'input>> RuleContext<'input> for BaseParserRuleContext<'input, Ctx>

fn get_invoking_state(&self) -> isize

Internal parser state

fn set_invoking_state(&self, t: isize)

Sets internal parser state

fn get_parent_ctx( &self, ) -> Option<Rc<<Ctx::Ctx as ParserNodeType<'input>>::Type>>

Get parent context

fn set_parent( &self, parent: &Option<Rc<<Ctx::Ctx as ParserNodeType<'input>>::Type>>, )

Set parent context

fn is_empty(&self) -> bool

A context is empty if there is no invoking state; meaning nobody called current context. Which is usually true for the root of the syntax tree

impl<'input, Ctx: CustomRuleContext<'input>> Tree<'input> for BaseParserRuleContext<'input, Ctx>

fn get_parent(&self) -> Option<Rc<<Ctx::Ctx as ParserNodeType<'input>>::Type>>

fn has_parent(&self) -> bool

fn get_payload(&self) -> Box<dyn Any>

fn get_child( &self, i: usize, ) -> Option<Rc<<Self::Ctx as ParserNodeType<'input>>::Type>>

fn get_child_count(&self) -> usize

fn get_children<'a>( &'a self, ) -> Box<dyn Iterator<Item = Rc<<Self::Ctx as ParserNodeType<'input>>::Type>> + 'a>

where 'input: 'a,

impl<'input, Ctx: CustomRuleContext<'input>> Deref for BaseParserRuleContext<'input, Ctx>

type Target = Ctx

The resulting type after dereferencing.

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

Dereferences the value.

impl<'i, Ctx> TidAble<'i> for BaseParserRuleContext<'i, Ctx>

where Ctx: CustomRuleContext<'i> + TidAble<'i>,