public BodyContext body()
    {
        BodyContext _localctx = new BodyContext(Context, State);

        EnterRule(_localctx, 2, RULE_body);
        int _la;

        try {
            EnterOuterAlt(_localctx, 1);
            {
                State = 23;
                ErrorHandler.Sync(this);
                switch (Interpreter.AdaptivePredict(TokenStream, 0, Context))
                {
                case 1:
                {
                    State = 21; query_seq();
                }
                break;

                case 2:
                {
                    State = 22; restrictions();
                }
                break;
                }
                State = 26;
                ErrorHandler.Sync(this);
                _la = TokenStream.LA(1);
                if (_la == T__0)
                {
                    {
                        State = 25; Match(T__0);
                    }
                }

                State = 30;
                ErrorHandler.Sync(this);
                _la = TokenStream.LA(1);
                if (_la == InWin)
                {
                    {
                        State = 28; Match(InWin);
                        State = 29; number();
                    }
                }
            }
        }
        catch (RecognitionException re) {
            _localctx.exception = re;
            ErrorHandler.ReportError(this, re);
            ErrorHandler.Recover(this, re);
        }
        finally {
            ExitRule();
        }
        return(_localctx);
    }
Beispiel #2
0
    public BodyContext body()
    {
        BodyContext _localctx = new BodyContext(Context, State);

        EnterRule(_localctx, 4, RULE_body);
        int _la;

        try {
            State = 46;
            ErrorHandler.Sync(this);
            switch (TokenStream.LA(1))
            {
            case IF:
            case TYPE:
            case ID:
                EnterOuterAlt(_localctx, 1);
                {
                    State = 37; statement();
                }
                break;

            case LEFT_BRACE:
                EnterOuterAlt(_localctx, 2);
                {
                    State = 38; Match(LEFT_BRACE);
                    State = 42;
                    ErrorHandler.Sync(this);
                    _la = TokenStream.LA(1);
                    while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << IF) | (1L << TYPE) | (1L << ID))) != 0))
                    {
                        {
                            {
                                State = 39; statement();
                            }
                        }
                        State = 44;
                        ErrorHandler.Sync(this);
                        _la = TokenStream.LA(1);
                    }
                    State = 45; Match(RIGHT_BRACE);
                }
                break;

            default:
                throw new NoViableAltException(this);
            }
        }
        catch (RecognitionException re) {
            _localctx.exception = re;
            ErrorHandler.ReportError(this, re);
            ErrorHandler.Recover(this, re);
        }
        finally {
            ExitRule();
        }
        return(_localctx);
    }
Beispiel #3
0
        /*
         * There's one fairly important difference between mod resolution in rustc and what we do.
         * Given following code:
         * mod bar { mod a; } mod bar { mod b; }
         * We will merget this to mod bar { mod a; mod b; }, but rustc will error out.
         */
        public static ModuleImport ParseImports(ICharStream stream)
        {
            var         lexer   = new ModuleLexer(stream);
            var         tokens  = new CommonTokenStream(lexer);
            var         parser  = new ModuleParser(tokens);
            BodyContext root    = parser.body();
            var         imports = new ModuleImport();

            TraverseForImports(root, imports);
            return(imports);
        }
Beispiel #4
0
    public BodyContext body()
    {
        BodyContext _localctx = new BodyContext(Context, State);

        EnterRule(_localctx, 12, RULE_body);
        int _la;

        try {
            EnterOuterAlt(_localctx, 1);
            {
                State = 59;
                ErrorHandler.Sync(this);
                _la = TokenStream.LA(1);
                while (_la == FloatingBodyTag)
                {
                    {
                        {
                            State = 56; Match(FloatingBodyTag);
                        }
                    }
                    State = 61;
                    ErrorHandler.Sync(this);
                    _la = TokenStream.LA(1);
                }
                State = 62; Match(BodyOpenTag);
                State = 63; Match(BodyCloseTag);
            }
        }
        catch (RecognitionException re) {
            _localctx.exception = re;
            ErrorHandler.ReportError(this, re);
            ErrorHandler.Recover(this, re);
        }
        finally {
            ExitRule();
        }
        return(_localctx);
    }
        public BodyContext body()
        {
            BodyContext _localctx = new BodyContext(Context, State);

            EnterRule(_localctx, 12, RULE_body);
            int _la;

            try {
                EnterOuterAlt(_localctx, 1);
                {
                    State = 64;
                    ErrorHandler.Sync(this);
                    _la = TokenStream.LA(1);
                    while (_la == LParen || _la == Word)
                    {
                        {
                            {
                                State = 61; item();
                            }
                        }
                        State = 66;
                        ErrorHandler.Sync(this);
                        _la = TokenStream.LA(1);
                    }
                }
            }
            catch (RecognitionException re) {
                _localctx.exception = re;
                ErrorHandler.ReportError(this, re);
                ErrorHandler.Recover(this, re);
            }
            finally {
                ExitRule();
            }
            return(_localctx);
        }
	private ExprContext expr(int _p) {
		ParserRuleContext _parentctx = Context;
		int _parentState = State;
		ExprContext _localctx = new ExprContext(Context, _parentState);
		ExprContext _prevctx = _localctx;
		int _startState = 12;
		EnterRecursionRule(_localctx, 12, RULE_expr, _p);
		int _la;
		try {
			int _alt;
			EnterOuterAlt(_localctx, 1);
			{
			State = 120;
			ErrorHandler.Sync(this);
			switch ( Interpreter.AdaptivePredict(TokenStream,6,Context) ) {
			case 1:
				{
				_localctx = new Call_methodContext(_localctx);
				Context = _localctx;
				_prevctx = _localctx;

				State = 68; Match(ID);
				State = 69; Match(T__3);
				State = 70; args_call();
				State = 71; Match(T__4);
				}
				break;
			case 2:
				{
				_localctx = new IfContext(_localctx);
				Context = _localctx;
				_prevctx = _localctx;
				State = 73; Match(IF);
				State = 74; expr(0);
				State = 75; Match(THEN);
				State = 76; expr(0);
				State = 77; Match(ELSE);
				State = 78; expr(0);
				State = 79; Match(FI);
				}
				break;
			case 3:
				{
				_localctx = new WhileContext(_localctx);
				Context = _localctx;
				_prevctx = _localctx;
				State = 81; Match(WHILE);
				State = 82; expr(0);
				State = 83; Match(LOOP);
				State = 84; expr(0);
				State = 85; Match(POOL);
				}
				break;
			case 4:
				{
				_localctx = new BodyContext(_localctx);
				Context = _localctx;
				_prevctx = _localctx;
				State = 87; Match(T__1);
				State = 88; expr_list();
				State = 89; Match(T__2);
				}
				break;
			case 5:
				{
				_localctx = new New_typeContext(_localctx);
				Context = _localctx;
				_prevctx = _localctx;
				State = 91; Match(NEW);
				State = 92; Match(TYPE);
				}
				break;
			case 6:
				{
				_localctx = new IsvoidContext(_localctx);
				Context = _localctx;
				_prevctx = _localctx;
				State = 93; Match(ISVOID);
				State = 94; expr(12);
				}
				break;
			case 7:
				{
				_localctx = new Unary_expContext(_localctx);
				Context = _localctx;
				_prevctx = _localctx;
				State = 95;
				((Unary_expContext)_localctx).op = TokenStream.LT(1);
				_la = TokenStream.LA(1);
				if ( !(_la==T__16 || _la==NOT) ) {
					((Unary_expContext)_localctx).op = ErrorHandler.RecoverInline(this);
				}
				else {
					ErrorHandler.ReportMatch(this);
				    Consume();
				}
				State = 96; expr(8);
				}
				break;
			case 8:
				{
				_localctx = new ParentesisContext(_localctx);
				Context = _localctx;
				_prevctx = _localctx;
				State = 97; Match(T__3);
				State = 98; expr(0);
				State = 99; Match(T__4);
				}
				break;
			case 9:
				{
				_localctx = new IntContext(_localctx);
				Context = _localctx;
				_prevctx = _localctx;
				State = 101; Match(INTEGER);
				}
				break;
			case 10:
				{
				_localctx = new BoolContext(_localctx);
				Context = _localctx;
				_prevctx = _localctx;
				State = 102;
				((BoolContext)_localctx).cons = TokenStream.LT(1);
				_la = TokenStream.LA(1);
				if ( !(_la==TRUE || _la==FALSE) ) {
					((BoolContext)_localctx).cons = ErrorHandler.RecoverInline(this);
				}
				else {
					ErrorHandler.ReportMatch(this);
				    Consume();
				}
				}
				break;
			case 11:
				{
				_localctx = new StringContext(_localctx);
				Context = _localctx;
				_prevctx = _localctx;
				State = 103; Match(STR);
				}
				break;
			case 12:
				{
				_localctx = new AssignContext(_localctx);
				Context = _localctx;
				_prevctx = _localctx;
				State = 104; Match(ID);
				State = 105; Match(T__6);
				State = 106; expr(3);
				}
				break;
			case 13:
				{
				_localctx = new LetContext(_localctx);
				Context = _localctx;
				_prevctx = _localctx;
				State = 107; Match(LET);
				State = 108; attr();
				State = 113;
				ErrorHandler.Sync(this);
				_la = TokenStream.LA(1);
				while (_la==T__17) {
					{
					{
					State = 109; Match(T__17);
					State = 110; attr();
					}
					}
					State = 115;
					ErrorHandler.Sync(this);
					_la = TokenStream.LA(1);
				}
				State = 116; Match(IN);
				State = 117; expr(2);
				}
				break;
			case 14:
				{
				_localctx = new IdContext(_localctx);
				Context = _localctx;
				_prevctx = _localctx;
				State = 119; Match(ID);
				}
				break;
			}
			Context.Stop = TokenStream.LT(-1);
			State = 144;
			ErrorHandler.Sync(this);
			_alt = Interpreter.AdaptivePredict(TokenStream,9,Context);
			while ( _alt!=2 && _alt!=global::Antlr4.Runtime.Atn.ATN.INVALID_ALT_NUMBER ) {
				if ( _alt==1 ) {
					if ( ParseListeners!=null )
						TriggerExitRuleEvent();
					_prevctx = _localctx;
					{
					State = 142;
					ErrorHandler.Sync(this);
					switch ( Interpreter.AdaptivePredict(TokenStream,8,Context) ) {
					case 1:
						{
						_localctx = new MultdivContext(new ExprContext(_parentctx, _parentState));
						PushNewRecursionContext(_localctx, _startState, RULE_expr);
						State = 122;
						if (!(Precpred(Context, 11))) throw new FailedPredicateException(this, "Precpred(Context, 11)");
						State = 123;
						((MultdivContext)_localctx).op = TokenStream.LT(1);
						_la = TokenStream.LA(1);
						if ( !(_la==T__9 || _la==T__10) ) {
							((MultdivContext)_localctx).op = ErrorHandler.RecoverInline(this);
						}
						else {
							ErrorHandler.ReportMatch(this);
						    Consume();
						}
						State = 124; expr(12);
						}
						break;
					case 2:
						{
						_localctx = new SumarestaContext(new ExprContext(_parentctx, _parentState));
						PushNewRecursionContext(_localctx, _startState, RULE_expr);
						State = 125;
						if (!(Precpred(Context, 10))) throw new FailedPredicateException(this, "Precpred(Context, 10)");
						State = 126;
						((SumarestaContext)_localctx).op = TokenStream.LT(1);
						_la = TokenStream.LA(1);
						if ( !(_la==T__11 || _la==T__12) ) {
							((SumarestaContext)_localctx).op = ErrorHandler.RecoverInline(this);
						}
						else {
							ErrorHandler.ReportMatch(this);
						    Consume();
						}
						State = 127; expr(11);
						}
						break;
					case 3:
						{
						_localctx = new CompContext(new ExprContext(_parentctx, _parentState));
						PushNewRecursionContext(_localctx, _startState, RULE_expr);
						State = 128;
						if (!(Precpred(Context, 9))) throw new FailedPredicateException(this, "Precpred(Context, 9)");
						State = 129;
						((CompContext)_localctx).op = TokenStream.LT(1);
						_la = TokenStream.LA(1);
						if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << T__13) | (1L << T__14) | (1L << T__15))) != 0)) ) {
							((CompContext)_localctx).op = ErrorHandler.RecoverInline(this);
						}
						else {
							ErrorHandler.ReportMatch(this);
						    Consume();
						}
						State = 130; expr(10);
						}
						break;
					case 4:
						{
						_localctx = new DispatchContext(new ExprContext(_parentctx, _parentState));
						PushNewRecursionContext(_localctx, _startState, RULE_expr);
						State = 131;
						if (!(Precpred(Context, 18))) throw new FailedPredicateException(this, "Precpred(Context, 18)");
						State = 134;
						ErrorHandler.Sync(this);
						_la = TokenStream.LA(1);
						if (_la==T__7) {
							{
							State = 132; Match(T__7);
							State = 133; Match(TYPE);
							}
						}

						State = 136; Match(T__8);
						State = 137; Match(ID);
						State = 138; Match(T__3);
						State = 139; args_call();
						State = 140; Match(T__4);
						}
						break;
					}
					} 
				}
				State = 146;
				ErrorHandler.Sync(this);
				_alt = Interpreter.AdaptivePredict(TokenStream,9,Context);
			}
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			ErrorHandler.ReportError(this, re);
			ErrorHandler.Recover(this, re);
		}
		finally {
			UnrollRecursionContexts(_parentctx);
		}
		return _localctx;
	}