Method calc_rec

cel/src/parser/gen/celparser.rs:1454–1606

(&mut self, _p: i32)

    }

    fn calc_rec(&mut self, _p: i32) -> Result<Rc<CalcContextAll<'input>>, ANTLRError> {
        let recog = self;
        let _parentctx = recog.ctx.take();
        let _parentState = recog.base.get_state();
        let mut _localctx = CalcContextExt::new(_parentctx.clone(), recog.base.get_state());
        recog
            .base
            .enter_recursion_rule(_localctx.clone(), 10, RULE_calc, _p);
        let mut _localctx: Rc<CalcContextAll> = _localctx;
        let mut _prevctx = _localctx.clone();
        let _startState = 10;
        let mut _la: i32 = -1;
        let result: Result<(), ANTLRError> = (|| {
            let mut _alt: i32;
            //recog.base.enter_outer_alt(_localctx.clone(), 1)?;
            recog.base.enter_outer_alt(None, 1)?;
            {
                {
                    /*InvokeRule unary*/
                    recog.base.set_state(73);
                    recog.unary()?;
                }
                let tmp = recog.input.lt(-1).cloned();
                recog.ctx.as_ref().unwrap().set_stop(tmp);
                recog.base.set_state(83);
                recog.err_handler.sync(&mut recog.base)?;
                _alt = recog.interpreter.adaptive_predict(5, &mut recog.base)?;
                while { _alt != 2 && _alt != INVALID_ALT } {
                    if _alt == 1 {
                        recog.trigger_exit_rule_event()?;
                        _prevctx = _localctx.clone();
                        {
                            recog.base.set_state(81);
                            recog.err_handler.sync(&mut recog.base)?;
                            match recog.interpreter.adaptive_predict(4, &mut recog.base)? {
                                1 => {
                                    {
                                        /*recRuleAltStartAction*/
                                        let mut tmp =
                                            CalcContextExt::new(_parentctx.clone(), _parentState);
                                        recog.push_new_recursion_context(
                                            tmp.clone(),
                                            _startState,
                                            RULE_calc,
                                        )?;
                                        _localctx = tmp;
                                        recog.base.set_state(75);
                                        if !({
                                            let _localctx = Some(_localctx.clone());
                                            recog.precpred(None, 2)
                                        }) {
                                            Err(FailedPredicateError::new(
                                                &mut recog.base,
                                                Some("recog.precpred(None, 2)".to_owned()),
                                                None,
                                            ))?;
                                        }
                                        recog.base.set_state(76);