Method relation_rec

cel/src/parser/gen/celparser.rs:1226–1320

(&mut self, _p: i32)

    }

    fn relation_rec(&mut self, _p: i32) -> Result<Rc<RelationContextAll<'input>>, ANTLRError> {
        let recog = self;
        let _parentctx = recog.ctx.take();
        let _parentState = recog.base.get_state();
        let mut _localctx = RelationContextExt::new(_parentctx.clone(), recog.base.get_state());
        recog
            .base
            .enter_recursion_rule(_localctx.clone(), 8, RULE_relation, _p);
        let mut _localctx: Rc<RelationContextAll> = _localctx;
        let mut _prevctx = _localctx.clone();
        let _startState = 8;
        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 calc*/
                    recog.base.set_state(62);
                    recog.calc_rec(0)?;
                }
                let tmp = recog.input.lt(-1).cloned();
                recog.ctx.as_ref().unwrap().set_stop(tmp);
                recog.base.set_state(69);
                recog.err_handler.sync(&mut recog.base)?;
                _alt = recog.interpreter.adaptive_predict(3, &mut recog.base)?;
                while { _alt != 2 && _alt != INVALID_ALT } {
                    if _alt == 1 {
                        recog.trigger_exit_rule_event()?;
                        _prevctx = _localctx.clone();
                        {
                            {
                                /*recRuleAltStartAction*/
                                let mut tmp =
                                    RelationContextExt::new(_parentctx.clone(), _parentState);
                                recog.push_new_recursion_context(
                                    tmp.clone(),
                                    _startState,
                                    RULE_relation,
                                )?;
                                _localctx = tmp;
                                recog.base.set_state(64);
                                if !({
                                    let _localctx = Some(_localctx.clone());
                                    recog.precpred(None, 1)
                                }) {
                                    Err(FailedPredicateError::new(
                                        &mut recog.base,
                                        Some("recog.precpred(None, 1)".to_owned()),
                                        None,
                                    ))?;
                                }
                                recog.base.set_state(65);
                                cast_mut::<_, RelationContext>(&mut _localctx).op =
                                    recog.base.input.lt(1).cloned();

                                _la = recog.base.input.la(1);