예제 #1
0
        private bool mainExpr_sempred(MainExprContext _localctx, int predIndex)
        {
            switch (predIndex)
            {
            case 0: return(Precpred(Context, 4));

            case 1: return(Precpred(Context, 3));
            }
            return(true);
        }
예제 #2
0
        private MainExprContext mainExpr(int _p)
        {
            ParserRuleContext _parentctx = Context;
            int             _parentState = State;
            MainExprContext _localctx    = new MainExprContext(Context, _parentState);
            MainExprContext _prevctx     = _localctx;
            int             _startState  = 2;

            EnterRecursionRule(_localctx, 2, RULE_mainExpr, _p);
            try {
                int _alt;
                EnterOuterAlt(_localctx, 1);
                {
                    State = 21;
                    ErrorHandler.Sync(this);
                    switch (Interpreter.AdaptivePredict(TokenStream, 1, Context))
                    {
                    case 1:
                    {
                        _localctx = new ParenthesisExpContext(_localctx);
                        Context   = _localctx;
                        _prevctx  = _localctx;

                        State = 11; Match(T__0);
                        State = 12; mainExpr(0);
                        State = 13; Match(T__1);
                    }
                    break;

                    case 2:
                    {
                        _localctx = new CompareNumberExpContext(_localctx);
                        Context   = _localctx;
                        _prevctx  = _localctx;
                        State     = 15; Match(PROPERTY);
                        State     = 16; Match(OPERATOR);
                        State     = 17; Match(NUMBER);
                    }
                    break;

                    case 3:
                    {
                        _localctx = new CompareStringExpContext(_localctx);
                        Context   = _localctx;
                        _prevctx  = _localctx;
                        State     = 18; Match(PROPERTY);
                        State     = 19; Match(OPERATOR);
                        State     = 20; Match(ESCAPEDSTRING);
                    }
                    break;
                    }
                    Context.Stop = TokenStream.LT(-1);
                    State        = 31;
                    ErrorHandler.Sync(this);
                    _alt = Interpreter.AdaptivePredict(TokenStream, 3, Context);
                    while (_alt != 2 && _alt != global::Antlr4.Runtime.Atn.ATN.INVALID_ALT_NUMBER)
                    {
                        if (_alt == 1)
                        {
                            if (ParseListeners != null)
                            {
                                TriggerExitRuleEvent();
                            }
                            _prevctx = _localctx;
                            {
                                State = 29;
                                ErrorHandler.Sync(this);
                                switch (Interpreter.AdaptivePredict(TokenStream, 2, Context))
                                {
                                case 1:
                                {
                                    _localctx = new AndExpContext(new MainExprContext(_parentctx, _parentState));
                                    PushNewRecursionContext(_localctx, _startState, RULE_mainExpr);
                                    State = 23;
                                    if (!(Precpred(Context, 4)))
                                    {
                                        throw new FailedPredicateException(this, "Precpred(Context, 4)");
                                    }
                                    State = 24; Match(AND);
                                    State = 25; mainExpr(5);
                                }
                                break;

                                case 2:
                                {
                                    _localctx = new OrExpContext(new MainExprContext(_parentctx, _parentState));
                                    PushNewRecursionContext(_localctx, _startState, RULE_mainExpr);
                                    State = 26;
                                    if (!(Precpred(Context, 3)))
                                    {
                                        throw new FailedPredicateException(this, "Precpred(Context, 3)");
                                    }
                                    State = 27; Match(OR);
                                    State = 28; mainExpr(4);
                                }
                                break;
                                }
                            }
                        }
                        State = 33;
                        ErrorHandler.Sync(this);
                        _alt = Interpreter.AdaptivePredict(TokenStream, 3, Context);
                    }
                }
            }
            catch (RecognitionException re) {
                _localctx.exception = re;
                ErrorHandler.ReportError(this, re);
                ErrorHandler.Recover(this, re);
            }
            finally {
                UnrollRecursionContexts(_parentctx);
            }
            return(_localctx);
        }
예제 #3
0
 public CompareStringExpContext(MainExprContext context)
 {
     CopyFrom(context);
 }
예제 #4
0
 public OrExpContext(MainExprContext context)
 {
     CopyFrom(context);
 }
예제 #5
0
 public ParenthesisExpContext(MainExprContext context)
 {
     CopyFrom(context);
 }
예제 #6
0
 public CompareNumberExpContext(MainExprContext context)
 {
     CopyFrom(context);
 }
예제 #7
0
 public virtual void CopyFrom(MainExprContext context)
 {
     base.CopyFrom(context);
 }