do_not_use_antlr_rust/
parser.rs

1//! Base parser implementation
2use std::borrow::Borrow;
3use std::cell::{Cell, RefCell};
4use std::marker::PhantomData;
5use std::ops::{Deref, DerefMut};
6use std::rc::Rc;
7use std::sync::Arc;
8
9use crate::atn::ATN;
10use crate::atn_simulator::IATNSimulator;
11use crate::error_listener::{ConsoleErrorListener, ErrorListener, ProxyErrorListener};
12use crate::error_strategy::ErrorStrategy;
13use crate::errors::ANTLRError;
14use crate::interval_set::IntervalSet;
15use crate::parser_atn_simulator::ParserATNSimulator;
16use crate::parser_rule_context::ParserRuleContext;
17use crate::recognizer::{Actions, Recognizer};
18use crate::rule_context::{states_stack, CustomRuleContext, RuleContext};
19use crate::token::{Token, TOKEN_EOF};
20use crate::token_factory::{TokenAware, TokenFactory};
21use crate::token_stream::TokenStream;
22use crate::tree::{ErrorNode, Listenable, ParseTreeListener, TerminalNode};
23use crate::utils::cell_update;
24use crate::vocabulary::Vocabulary;
25use crate::{CoerceFrom, CoerceTo};
26use better_any::{Tid, TidAble};
27
28/// parser functionality required for `ParserATNSimulator` to work
29#[allow(missing_docs)] // todo rewrite it so downstream crates actually could meaningfully implement it
30pub trait Parser<'input>: Recognizer<'input> {
31    fn get_interpreter(&self) -> &ParserATNSimulator;
32
33    fn get_token_factory(&self) -> &'input Self::TF;
34    fn get_parser_rule_context(&self) -> &Rc<<Self::Node as ParserNodeType<'input>>::Type>;
35    //    fn set_parser_rule_context(&self, v: ParserRuleContext);
36    fn consume(&mut self, err_handler: &mut impl ErrorStrategy<'input, Self>)
37    where
38        Self: Sized;
39    //    fn get_parse_listeners(&self) -> Vec<ParseTreeListener>;
40    //fn sempred(&mut self, _localctx: Option<&dyn ParserRuleContext>, rule_index: isize, action_index: isize) -> bool { true }
41
42    fn precpred(
43        &self,
44        localctx: Option<&<Self::Node as ParserNodeType<'input>>::Type>,
45        precedence: isize,
46    ) -> bool;
47
48    //    fn get_error_handler(&self) -> ErrorStrategy;
49    //    fn set_error_handler(&self, e: ErrorStrategy);
50    fn get_input_stream_mut(&mut self) -> &mut dyn TokenStream<'input, TF = Self::TF>;
51    fn get_input_stream(&self) -> &dyn TokenStream<'input, TF = Self::TF>;
52    fn get_current_token(&self) -> &<Self::TF as TokenFactory<'input>>::Tok;
53    fn get_expected_tokens(&self) -> IntervalSet;
54
55    fn add_error_listener(&mut self, listener: Box<dyn ErrorListener<'input, Self>>)
56    where
57        Self: Sized;
58    fn notify_error_listeners(
59        &self,
60        msg: String,
61        offending_token: Option<isize>,
62        err: Option<&ANTLRError>,
63    );
64    fn get_error_lister_dispatch<'a>(&'a self) -> Box<dyn ErrorListener<'input, Self> + 'a>
65    where
66        Self: Sized;
67
68    fn is_expected_token(&self, symbol: isize) -> bool;
69    fn get_precedence(&self) -> isize;
70
71    fn get_state(&self) -> isize;
72    fn set_state(&mut self, v: isize);
73    fn get_rule_invocation_stack(&self) -> Vec<String>;
74}
75
76// trait CsvContext<'input>: for<'x> Listenable<'input, dyn CsvParseTreeListener<'input,CsvTreeNodeType> + 'x> + ParserRuleContext<'input,TF=CommonTokenFactory,Ctx=CsvTreeNodeType>{}
77//
78// struct CsvTreeNodeType;
79// impl<'a> ParserNodeType<'a> for CsvTreeNodeType{
80//     type Type = dyn CsvContext<'a>;
81// }
82
83// workaround trait for rustc not being able to handle cycles in trait defenition yet, e.g. `trait A: Super<Assoc=dyn A>{}`
84// whyyy rustc... whyyy... (╯°□°）╯︵ ┻━┻  It would have been so much cleaner.
85/// Workaround trait for rustc current limitations.
86///
87/// Basically you can consider it as if context trait for generated parser has been implemented as
88/// ```text
89/// trait GenratedParserContext:ParserRuleContext<Ctx=dyn GeneratedParserContext>{ ... }
90/// ```
91/// which is not possible, hence this a bit ugly workaround.
92///
93/// Implemented by generated parser for the type that is going to carry information about
94/// parse tree node.
95pub trait ParserNodeType<'input>: TidAble<'input> + Sized {
96    /// Shortcut for `Type::TF`
97    type TF: TokenFactory<'input> + 'input;
98    /// Actual type of the parse tree node
99    type Type: ?Sized + ParserRuleContext<'input, Ctx = Self, TF = Self::TF> + 'input;
100    // type Visitor: ?Sized + ParseTreeVisitor<'input, Self>;
101}
102
103/// ### Main underlying Parser struct
104///
105/// It is a member of generated parser struct, so
106/// almost always you don't need to create it yourself.
107/// Generated parser hides complexity of this struct and expose required flexibility via generic parameters
108pub struct BaseParser<
109    'input,
110    Ext: 'static, //: ParserRecog<'input, Self> + 'static, // user provided behavior, such as semantic predicates
111    I: TokenStream<'input>, // input stream
112    Ctx: ParserNodeType<'input, TF = I::TF>, // Ctx::Type is trait object type for tree node of the parser
113    T: ParseTreeListener<'input, Ctx> + ?Sized = dyn ParseTreeListener<'input, Ctx>,
114> {
115    interp: Arc<ParserATNSimulator>,
116    /// Rule context parser is currently processing
117    pub ctx: Option<Rc<Ctx::Type>>,
118
119    /// Track the {@link ParserRuleContext} objects during the parse and hook
120    /// them up using the {@link ParserRuleContext#children} list so that it
121    /// forms a parse tree. The {@link ParserRuleContext} returned from the start
122    /// rule represents the root of the parse tree.
123    ///
124    /// <p>Note that if we are not building parse trees, rule contexts only point
125    /// upwards. When a rule exits, it returns the context bute that gets garbage
126    /// collected if nobody holds a reference. It points upwards but nobody
127    /// points at it. </p>
128    ///
129    /// <p>When we build parse trees, we are adding all of these contexts to
130    /// {@link ParserRuleContext#children} list. Contexts are then not candidates
131    /// for garbage collection.</p>
132    ///
133    /// Returns {@code true} if a complete parse tree will be constructed while
134    /// parsing, otherwise {@code false}
135    pub build_parse_trees: bool,
136
137    /// true if parser reached EOF
138    pub matched_eof: bool,
139
140    state: isize,
141    /// Token stream that is currently used by this parser
142    pub input: I,
143    precedence_stack: Vec<isize>,
144
145    parse_listeners: Vec<Box<T>>,
146    _syntax_errors: Cell<isize>,
147    error_listeners: RefCell<Vec<Box<dyn ErrorListener<'input, Self>>>>,
148
149    ext: Ext,
150    pd: PhantomData<fn() -> &'input str>,
151}
152
153better_any::tid! {
154    impl<'input, Ext:'static, I, Ctx, T> TidAble<'input> for BaseParser<'input,Ext, I, Ctx, T>
155    where I: TokenStream<'input>,
156        Ctx: ParserNodeType<'input, TF = I::TF>,
157        T: ParseTreeListener<'input, Ctx> + ?Sized
158}
159
160impl<'input, Ext, I, Ctx, T> Deref for BaseParser<'input, Ext, I, Ctx, T>
161where
162    Ext: ParserRecog<'input, Self> + 'static,
163    I: TokenStream<'input>,
164    Ctx: ParserNodeType<'input, TF = I::TF>,
165    T: ParseTreeListener<'input, Ctx> + ?Sized,
166    // Ctx::Type: Listenable<T>,
167{
168    type Target = Ext;
169
170    fn deref(&self) -> &Self::Target { &self.ext }
171}
172
173impl<'input, Ext, I, Ctx, T> DerefMut for BaseParser<'input, Ext, I, Ctx, T>
174where
175    Ext: ParserRecog<'input, Self> + 'static,
176    I: TokenStream<'input>,
177    Ctx: ParserNodeType<'input, TF = I::TF>,
178    T: ParseTreeListener<'input, Ctx> + ?Sized,
179    // Ctx::Type: Listenable<T>,
180{
181    fn deref_mut(&mut self) -> &mut Self::Target { &mut self.ext }
182}
183
184///
185pub trait ParserRecog<'a, P: Recognizer<'a>>: Actions<'a, P> {}
186
187impl<'input, Ext, I, Ctx, T> Recognizer<'input> for BaseParser<'input, Ext, I, Ctx, T>
188where
189    Ext: ParserRecog<'input, Self> + 'static,
190    I: TokenStream<'input>,
191    Ctx: ParserNodeType<'input, TF = I::TF>,
192    T: ParseTreeListener<'input, Ctx> + ?Sized,
193    // Ctx::Type: Listenable<T>,
194{
195    type Node = Ctx;
196
197    fn sempred(
198        &mut self,
199        localctx: Option<&Ctx::Type>,
200        rule_index: isize,
201        action_index: isize,
202    ) -> bool {
203        <Ext as Actions<'input, Self>>::sempred(localctx, rule_index, action_index, self)
204    }
205
206    fn get_rule_names(&self) -> &[&str] { self.ext.get_rule_names() }
207
208    fn get_vocabulary(&self) -> &dyn Vocabulary { self.ext.get_vocabulary() }
209
210    fn get_grammar_file_name(&self) -> &str { self.ext.get_grammar_file_name() }
211
212    fn get_atn(&self) -> &ATN { self.interp.atn() }
213}
214
215impl<'input, Ext, I, Ctx, T> TokenAware<'input> for BaseParser<'input, Ext, I, Ctx, T>
216where
217    Ext: ParserRecog<'input, Self> + 'static,
218    I: TokenStream<'input>,
219    Ctx: ParserNodeType<'input, TF = I::TF>,
220    T: ParseTreeListener<'input, Ctx> + ?Sized,
221    // Ctx::Type: Listenable<T>,
222{
223    type TF = I::TF;
224}
225
226impl<'input, Ext, I, Ctx, T> Parser<'input> for BaseParser<'input, Ext, I, Ctx, T>
227where
228    Ext: ParserRecog<'input, Self> + 'static,
229    I: TokenStream<'input>,
230    Ctx: ParserNodeType<'input, TF = I::TF>,
231    T: ParseTreeListener<'input, Ctx> + ?Sized,
232    Ctx::Type:
233        Listenable<T> + CoerceFrom<TerminalNode<'input, Ctx>> + CoerceFrom<ErrorNode<'input, Ctx>>,
234    // TerminalNode<'input, Ctx>: CoerceTo<Ctx::Type>,
235    // ErrorNode<'input, Ctx>: CoerceTo<Ctx::Type>,
236{
237    fn get_interpreter(&self) -> &ParserATNSimulator { self.interp.as_ref() }
238
239    fn get_token_factory(&self) -> &'input Self::TF {
240        // &**crate::common_token_factory::COMMON_TOKEN_FACTORY_DEFAULT
241        self.input.get_token_source().get_token_factory()
242    }
243
244    #[inline(always)]
245    fn get_parser_rule_context(&self) -> &Rc<Ctx::Type> { self.ctx.as_ref().unwrap() }
246
247    fn consume(&mut self, err_handler: &mut impl ErrorStrategy<'input, Self>) {
248        let o = self.get_current_token().clone();
249        if o.borrow().get_token_type() != TOKEN_EOF {
250            self.input.consume();
251        }
252        if self.build_parse_trees || !self.parse_listeners.is_empty() {
253            if err_handler.in_error_recovery_mode(self) {
254                // todo report ructc inference issue
255                let node: Rc<ErrorNode<'_, Ctx>> = self.create_error_node(o.clone());
256                self.ctx
257                    .as_deref()
258                    .unwrap()
259                    .add_child(node.clone().coerce_rc_to());
260                for listener in &mut self.parse_listeners {
261                    listener.visit_error_node(&*node)
262                }
263            } else {
264                let node: Rc<TerminalNode<'_, Ctx>> = self.create_token_node(o.clone());
265                self.ctx
266                    .as_deref()
267                    .unwrap()
268                    .add_child(node.clone().coerce_rc_to());
269                for listener in &mut self.parse_listeners {
270                    listener.visit_terminal(&*node)
271                }
272            }
273        }
274    }
275
276    fn precpred(&self, _localctx: Option<&Ctx::Type>, precedence: isize) -> bool {
277        //        localctx.map(|it|println!("check at{}",it.to_string_tree(self)));
278        //        println!("{}",self.get_precedence());
279        precedence >= self.get_precedence()
280    }
281
282    fn get_input_stream_mut(&mut self) -> &mut dyn TokenStream<'input, TF = Self::TF> {
283        &mut self.input //.as_mut()
284    }
285
286    fn get_input_stream(&self) -> &dyn TokenStream<'input, TF = Self::TF> { &self.input }
287
288    #[inline]
289    fn get_current_token(&self) -> &<Self::TF as TokenFactory<'input>>::Tok {
290        self.input.get(self.input.index())
291    }
292
293    fn get_expected_tokens(&self) -> IntervalSet {
294        let states_stack = states_stack(self.ctx.as_ref().unwrap().clone());
295        self.interp
296            .atn()
297            .get_expected_tokens(self.state, states_stack)
298    }
299
300    fn add_error_listener(&mut self, listener: Box<dyn ErrorListener<'input, Self>>) {
301        self.error_listeners.borrow_mut().push(listener)
302    }
303
304    fn notify_error_listeners(
305        &self,
306        msg: String,
307        offending_token: Option<isize>,
308        err: Option<&ANTLRError>,
309    ) {
310        cell_update(&self._syntax_errors, |it| it + 1);
311        let offending_token: Option<&_> = match offending_token {
312            None => Some(self.get_current_token().borrow()),
313            Some(x) => Some(self.input.get(x).borrow()),
314        };
315        let line = offending_token.map(|x| x.get_line()).unwrap_or(-1);
316        let column = offending_token.map(|x| x.get_column()).unwrap_or(-1);
317
318        for listener in self.error_listeners.borrow().iter() {
319            listener.syntax_error(self, offending_token, line, column, &msg, err)
320        }
321    }
322
323    fn get_error_lister_dispatch<'a>(&'a self) -> Box<dyn ErrorListener<'input, Self> + 'a> {
324        Box::new(ProxyErrorListener {
325            delegates: self.error_listeners.borrow(),
326        })
327    }
328
329    fn is_expected_token(&self, _symbol: isize) -> bool { unimplemented!() }
330
331    fn get_precedence(&self) -> isize { *self.precedence_stack.last().unwrap_or(&-1) }
332
333    #[inline(always)]
334    fn get_state(&self) -> isize { self.state }
335
336    #[inline(always)]
337    fn set_state(&mut self, v: isize) { self.state = v; }
338
339    fn get_rule_invocation_stack(&self) -> Vec<String> {
340        let mut vec = Vec::new();
341        let rule_names = self.get_rule_names();
342        let mut ctx = self.get_parser_rule_context().clone();
343        loop {
344            let rule_index = ctx.get_rule_index();
345            vec.push(rule_names.get(rule_index).unwrap_or(&"n/a").to_string());
346            ctx = if let Some(parent) = ctx.get_parent_ctx() {
347                parent
348            } else {
349                break;
350            }
351        }
352        vec
353    }
354
355    //    fn get_rule_invocation_stack(&self, c: _) -> Vec<String> {
356    //        unimplemented!()
357    //    }
358}
359
360#[allow(missing_docs)] // todo docs
361impl<'input, Ext, I, Ctx, T> BaseParser<'input, Ext, I, Ctx, T>
362where
363    Ext: ParserRecog<'input, Self> + 'static,
364    I: TokenStream<'input>,
365    Ctx: ParserNodeType<'input, TF = I::TF>,
366    T: ParseTreeListener<'input, Ctx> + ?Sized,
367    Ctx::Type:
368        Listenable<T> + CoerceFrom<TerminalNode<'input, Ctx>> + CoerceFrom<ErrorNode<'input, Ctx>>,
369    //     TerminalNode<'input, Ctx>: CoerceTo<Ctx::Type>,
370    //     ErrorNode<'input, Ctx>: CoerceTo<Ctx::Type>,
371{
372    pub fn new_base_parser(input: I, interpreter: Arc<ParserATNSimulator>, ext: Ext) -> Self {
373        Self {
374            interp: interpreter,
375            ctx: None,
376            build_parse_trees: true,
377            matched_eof: false,
378            state: -1,
379            input,
380            precedence_stack: vec![0],
381            parse_listeners: vec![],
382            _syntax_errors: Cell::new(0),
383            error_listeners: RefCell::new(vec![Box::new(ConsoleErrorListener {})]),
384            ext,
385            pd: PhantomData,
386        }
387    }
388
389    //
390    //    fn reset(&self) { unimplemented!() }
391
392    #[inline]
393    pub fn match_token(
394        &mut self,
395        ttype: isize,
396        err_handler: &mut impl ErrorStrategy<'input, Self>,
397    ) -> Result<<I::TF as TokenFactory<'input>>::Tok, ANTLRError> {
398        let mut token = self.get_current_token().clone();
399        if token.borrow().get_token_type() == ttype {
400            if ttype == TOKEN_EOF {
401                self.matched_eof = true;
402            }
403
404            err_handler.report_match(self);
405            self.consume(err_handler);
406        } else {
407            token = err_handler.recover_inline(self)?;
408            if self.build_parse_trees && token.borrow().get_token_index() == -1 {
409                self.ctx
410                    .as_ref()
411                    .unwrap()
412                    .add_child(self.create_error_node(token.clone()).coerce_rc_to());
413            }
414        }
415        return Ok(token);
416    }
417
418    #[inline]
419    pub fn match_wildcard(
420        &mut self,
421        err_handler: &mut impl ErrorStrategy<'input, Self>,
422    ) -> Result<<I::TF as TokenFactory<'input>>::Tok, ANTLRError> {
423        let mut t = self.get_current_token().clone();
424        if t.borrow().get_token_type() > 0 {
425            err_handler.report_match(self);
426            self.consume(err_handler);
427        } else {
428            t = err_handler.recover_inline(self)?;
429            if self.build_parse_trees && t.borrow().get_token_index() == -1 {
430                self.ctx
431                    .as_ref()
432                    .unwrap()
433                    .add_child(self.create_error_node(t.clone()).coerce_rc_to());
434            }
435        }
436        return Ok(t);
437    }
438
439    /// Adds parse listener for this parser
440    /// returns `listener_id` that can be used later to get listener back
441    ///
442    /// Embedded listener currently must outlive `'input`. If you need to have arbitrary listener use ParseTreeWalker.
443    ///
444    /// ### Example for listener usage:
445    /// todo
446    pub fn add_parse_listener<L>(&mut self, listener: Box<L>) -> ListenerId<L>
447    where
448        L: CoerceTo<T>,
449    {
450        let id = ListenerId::new(&listener);
451        self.parse_listeners.push(listener.coerce_box_to());
452        id
453    }
454
455    /// Removes parse listener with corresponding `listener_id`, casts it back to user type and returns it to the caller.
456    /// `listener_id` is returned when listener is added via `add_parse_listener`
457    pub fn remove_parse_listener<L>(&mut self, listener_id: ListenerId<L>) -> Box<L>
458    where
459        L: CoerceTo<T>,
460    {
461        let index = self
462            .parse_listeners
463            .iter()
464            .position(|it| ListenerId::new(it).actual_id == listener_id.actual_id)
465            .expect("listener not found");
466        unsafe { listener_id.into_listener(self.parse_listeners.remove(index)) }
467    }
468
469    /// Removes all added parse listeners without returning them
470    pub fn remove_parse_listeners(&mut self) { self.parse_listeners.clear() }
471
472    pub fn trigger_enter_rule_event(&mut self) {
473        let ctx = self.ctx.as_deref().unwrap();
474        for listener in self.parse_listeners.iter_mut() {
475            // listener.enter_every_rule(ctx);
476            ctx.enter(listener);
477        }
478    }
479
480    pub fn trigger_exit_rule_event(&mut self) {
481        let ctx = self.ctx.as_deref().unwrap();
482        for listener in self.parse_listeners.iter_mut().rev() {
483            ctx.exit(listener);
484            // listener.exit_every_rule(ctx);
485        }
486    }
487    //
488    //    fn set_token_factory(&self, factory: TokenFactory) { unimplemented!() }
489    //
490    //
491    //    fn get_atn_with_bypass_alts(&self) { unimplemented!() }
492    //
493    //    fn compile_parse_tree_pattern(&self, pattern, patternRuleIndex: Lexer, lexer: Lexer) { unimplemented!() }
494    //
495    //    fn set_input_stream(&self, input: TokenStream) { unimplemented!() }
496    //
497    //    fn set_token_stream(&self, input: TokenStream) { unimplemented!() }
498
499    fn add_context_to_parse_tree(&mut self) {
500        let parent = self.ctx.as_ref().unwrap().get_parent_ctx();
501
502        if let Some(parent) = parent {
503            parent.add_child(self.ctx.clone().unwrap())
504        }
505    }
506
507    #[inline]
508    pub fn enter_rule(&mut self, localctx: Rc<Ctx::Type>, state: isize, _rule_index: usize) {
509        self.set_state(state);
510        localctx.set_start(self.input.lt(1).cloned());
511        self.ctx = Some(localctx);
512        //        let mut localctx = Rc::get_mut(self.ctx.as_mut().unwrap()).unwrap();
513        if self.build_parse_trees {
514            self.add_context_to_parse_tree()
515        }
516    }
517
518    #[inline]
519    pub fn exit_rule(&mut self) {
520        if self.matched_eof {
521            self.ctx
522                .as_ref()
523                .unwrap()
524                .set_stop(self.input.lt(1).cloned())
525        } else {
526            self.ctx
527                .as_ref()
528                .unwrap()
529                .set_stop(self.input.lt(-1).cloned())
530        }
531        self.trigger_exit_rule_event();
532        self.set_state(self.get_parser_rule_context().get_invoking_state());
533        let parent = self.ctx.as_ref().unwrap().get_parent_ctx();
534        // mem::replace(&mut self.ctx, parent);
535        self.ctx = parent;
536    }
537
538    // todo make new_ctx not option
539    #[inline]
540    pub fn enter_outer_alt(&mut self, new_ctx: Option<Rc<Ctx::Type>>, alt_num: isize) {
541        if let Some(new_ctx) = new_ctx {
542            new_ctx.set_alt_number(alt_num);
543
544            let ctx = self.ctx.as_ref().unwrap();
545            if self.build_parse_trees && self.ctx.is_some() && !Rc::ptr_eq(&new_ctx, ctx) {
546                if let Some(parent) = ctx.get_parent_ctx() {
547                    parent.remove_last_child();
548                    parent.add_child(new_ctx.clone())
549                }
550            }
551
552            self.ctx = Some(new_ctx);
553        }
554
555        self.trigger_enter_rule_event();
556    }
557
558    pub fn enter_recursion_rule(
559        &mut self,
560        localctx: Rc<Ctx::Type>,
561        state: isize,
562        _rule_index: usize,
563        precedence: isize,
564    ) {
565        self.set_state(state);
566        self.precedence_stack.push(precedence);
567        localctx.set_start(self.input.lt(1).cloned());
568        //println!("{}",self.input.lt(1).map(Token::to_owned).unwrap());
569        self.ctx = Some(localctx);
570    }
571
572    pub fn push_new_recursion_context(
573        &mut self,
574        localctx: Rc<Ctx::Type>,
575        state: isize,
576        _rule_index: usize,
577    ) {
578        let prev = self.ctx.take().unwrap();
579        prev.set_parent(&Some(localctx.clone()));
580        prev.set_invoking_state(state);
581        prev.set_stop(self.input.lt(-1).cloned());
582
583        //        println!("{}",prev.get_start().unwrap());
584        localctx.set_start(Some(prev.start_mut().clone()));
585        self.ctx = Some(localctx);
586
587        if self.build_parse_trees {
588            self.ctx.as_ref().unwrap().add_child(prev);
589        }
590        self.trigger_enter_rule_event();
591    }
592
593    pub fn unroll_recursion_context(&mut self, parent_ctx: Option<Rc<Ctx::Type>>) {
594        self.precedence_stack.pop();
595        let retctx = self.ctx.clone().unwrap();
596        retctx.set_stop(self.input.lt(-1).cloned());
597        if !self.parse_listeners.is_empty() {
598            while self.ctx.as_ref().map(|x| Rc::as_ptr(x))
599                != parent_ctx.as_ref().map(|x| Rc::as_ptr(x))
600            {
601                self.trigger_exit_rule_event();
602                self.ctx = self.ctx.as_ref().unwrap().get_parent_ctx()
603            }
604        } else {
605            self.ctx = parent_ctx;
606        }
607
608        //self.ctx is now parent
609        retctx.set_parent(&self.ctx);
610
611        //        println!("{:?}",self.ctx.as_ref().map(|it|it.to_string_tree(self)));
612        if self.build_parse_trees && self.ctx.is_some() {
613            self.ctx.as_ref().unwrap().add_child(retctx);
614        }
615    }
616
617    fn create_token_node(
618        &self,
619        token: <I::TF as TokenFactory<'input>>::Tok,
620    ) -> Rc<TerminalNode<'input, Ctx>> {
621        TerminalNode::new(token).into()
622    }
623
624    fn create_error_node(
625        &self,
626        token: <I::TF as TokenFactory<'input>>::Tok,
627    ) -> Rc<ErrorNode<'input, Ctx>> {
628        ErrorNode::new(token).into()
629    }
630
631    /// Text representation of generated DFA for debugging purposes
632    pub fn dump_dfa(&self) {
633        let mut seen_one = false;
634        for dfa in self.interp.decision_to_dfa() {
635            let dfa = dfa.read();
636            // because s0 is saved in dfa for Rust version
637            if dfa.states.len() > 1 + (dfa.is_precedence_dfa() as usize) {
638                if seen_one {
639                    println!()
640                }
641                println!("Decision {}:", dfa.decision);
642                print!("{}", dfa.to_string(self.get_vocabulary()));
643                seen_one = true;
644            }
645        }
646    }
647
648    //    fn get_invoking_context(&self, ruleIndex: isize) -> ParserRuleContext { unimplemented!() }
649    //
650    //    fn in_context(&self, context: ParserRuleContext) -> bool { unimplemented!() }
651    //
652    //    fn get_expected_tokens_within_current_rule(&self) -> * IntervalSet { unimplemented!() }
653    //
654    //
655    //    fn get_rule_index(&self, ruleName: String) -> int { unimplemented!() }
656    //
657    //    fn get_dfaStrings(&self) -> String { unimplemented!() }
658    //
659    //    fn get_source_name(&self) -> String { unimplemented!() }
660    //
661    //    fn set_trace(&self, trace: * TraceListener) { unimplemented!() }
662}
663
664/// Allows to safely cast listener back to user type
665#[derive(Debug)]
666pub struct ListenerId<T: ?Sized> {
667    pub(crate) actual_id: usize,
668    phantom: PhantomData<fn() -> T>,
669}
670
671impl<T: ?Sized> ListenerId<T> {
672    fn new(listener: &Box<T>) -> ListenerId<T> {
673        ListenerId {
674            actual_id: listener.as_ref() as *const T as *const () as usize,
675            phantom: Default::default(),
676        }
677    }
678}
679
680impl<T> ListenerId<T> {
681    unsafe fn into_listener<U: ?Sized>(self, boxed: Box<U>) -> Box<T> {
682        Box::from_raw(Box::into_raw(boxed) as *mut T)
683    }
684}
do_not_use_antlr_rust/parser.rs

do_not_use_antlr_rust/
parser.rs
