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

antlr_rust_sleagon/
parser.rs
