validator.java

c--词法分析

                // Validator.g:42:42: ( stmt )*
                loop6:
                do {
                    int alt6=2;
                    int LA6_0 = input.LA(1);

                    if ( ((LA6_0>=POSTFIX && LA6_0<=NOP)||(LA6_0>=BLOCK && LA6_0<=ASSIGN)||(LA6_0>=CALL && LA6_0<=NEGATE)||(LA6_0>=NUM && LA6_0<=VAR)||(LA6_0>=RETURN && LA6_0<=IF)||(LA6_0>=63 && LA6_0<=77)) ) {
                        alt6=1;
                    }


                    switch (alt6) {
                	case 1 :
                	    // Validator.g:42:42: stmt
                	    {
                	    pushFollow(FOLLOW_stmt_in_block179);
                	    stmt();
                	    _fsp--;


                	    }
                	    break;

                	default :
                	    break loop6;
                    }
                } while (true);


                match(input, Token.UP, null); 
            }

            match(input, Token.UP, null); 

            }


            	Main.symbols.exit_block();

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {
        }
        return ;
    }
    // $ANTLR end block


    // $ANTLR start stmt
    // Validator.g:45:1: stmt : ( expr | ^( RETURN expr ) | ^( READ name= ID ) | ^( WRITE expr ) | WRITELN | BREAK | ifStmt | whileStmt | block | NOP );
    public final void stmt() throws RecognitionException {
        CommonTree name=null;

        try {
            // Validator.g:46:4: ( expr | ^( RETURN expr ) | ^( READ name= ID ) | ^( WRITE expr ) | WRITELN | BREAK | ifStmt | whileStmt | block | NOP )
            int alt7=10;
            switch ( input.LA(1) ) {
            case POSTFIX:
            case PREFIX:
            case ASSIGN:
            case CALL:
            case INDEX:
            case NOT:
            case NEGATE:
            case NUM:
            case VAR:
            case 63:
            case 64:
            case 65:
            case 66:
            case 67:
            case 68:
            case 69:
            case 70:
            case 71:
            case 72:
            case 73:
            case 74:
            case 75:
            case 76:
            case 77:
                {
                alt7=1;
                }
                break;
            case RETURN:
                {
                alt7=2;
                }
                break;
            case READ:
                {
                alt7=3;
                }
                break;
            case WRITE:
                {
                alt7=4;
                }
                break;
            case WRITELN:
                {
                alt7=5;
                }
                break;
            case BREAK:
                {
                alt7=6;
                }
                break;
            case IF:
                {
                alt7=7;
                }
                break;
            case WHILE:
                {
                alt7=8;
                }
                break;
            case BLOCK:
                {
                alt7=9;
                }
                break;
            case NOP:
                {
                alt7=10;
                }
                break;
            default:
                NoViableAltException nvae =
                    new NoViableAltException("45:1: stmt : ( expr | ^( RETURN expr ) | ^( READ name= ID ) | ^( WRITE expr ) | WRITELN | BREAK | ifStmt | whileStmt | block | NOP );", 7, 0, input);

                throw nvae;
            }

            switch (alt7) {
                case 1 :
                    // Validator.g:46:4: expr
                    {
                    pushFollow(FOLLOW_expr_in_stmt195);
                    expr();
                    _fsp--;


                    }
                    break;
                case 2 :
                    // Validator.g:47:5: ^( RETURN expr )
                    {
                    match(input,RETURN,FOLLOW_RETURN_in_stmt202); 

                    match(input, Token.DOWN, null); 
                    pushFollow(FOLLOW_expr_in_stmt204);
                    expr();
                    _fsp--;


                    match(input, Token.UP, null); 

                    }
                    break;
                case 3 :
                    // Validator.g:48:5: ^( READ name= ID )
                    {
                    match(input,READ,FOLLOW_READ_in_stmt213); 

                    match(input, Token.DOWN, null); 
                    name=(CommonTree)input.LT(1);
                    match(input,ID,FOLLOW_ID_in_stmt217); 

                    match(input, Token.UP, null); 
                    Main.symbols.test_declared(name.getText());

                    }
                    break;
                case 4 :
                    // Validator.g:49:5: ^( WRITE expr )
                    {
                    match(input,WRITE,FOLLOW_WRITE_in_stmt227); 

                    match(input, Token.DOWN, null); 
                    pushFollow(FOLLOW_expr_in_stmt229);
                    expr();
                    _fsp--;


                    match(input, Token.UP, null); 

                    }
                    break;
                case 5 :
                    // Validator.g:50:5: WRITELN
                    {
                    match(input,WRITELN,FOLLOW_WRITELN_in_stmt238); 

                    }
                    break;
                case 6 :
                    // Validator.g:51:5: BREAK
                    {
                    match(input,BREAK,FOLLOW_BREAK_in_stmt246); 

                    }
                    break;
                case 7 :
                    // Validator.g:52:5: ifStmt
                    {
                    pushFollow(FOLLOW_ifStmt_in_stmt255);
                    ifStmt();
                    _fsp--;


                    }
                    break;
                case 8 :
                    // Validator.g:53:5: whileStmt
                    {
                    pushFollow(FOLLOW_whileStmt_in_stmt261);
                    whileStmt();
                    _fsp--;


                    }
                    break;
                case 9 :
                    // Validator.g:54:5: block
                    {
                    pushFollow(FOLLOW_block_in_stmt267);
                    block();
                    _fsp--;


                    }
                    break;
                case 10 :
                    // Validator.g:55:5: NOP
                    {
                    match(input,NOP,FOLLOW_NOP_in_stmt273); 

                    }
                    break;

            }
        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {
        }
        return ;
    }
    // $ANTLR end stmt


    // $ANTLR start whileStmt
    // Validator.g:58:1: whileStmt : ^( WHILE expr stmt ) ;
    public final void whileStmt() throws RecognitionException {
        try {
            // Validator.g:59:4: ( ^( WHILE expr stmt ) )
            // Validator.g:59:4: ^( WHILE expr stmt )
            {
            match(input,WHILE,FOLLOW_WHILE_in_whileStmt286); 

            match(input, Token.DOWN, null); 
            pushFollow(FOLLOW_expr_in_whileStmt288);
            expr();
            _fsp--;

            pushFollow(FOLLOW_stmt_in_whileStmt290);
            stmt();
            _fsp--;


            match(input, Token.UP, null); 

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {
        }
        return ;
    }
    // $ANTLR end whileStmt


    // $ANTLR start ifStmt
    // Validator.g:61:1: ifStmt : ^( IF ^( EXPR expr ) stmt stmt ) ;
    public final void ifStmt() throws RecognitionException {
        try {
            // Validator.g:62:5: ( ^( IF ^( EXPR expr ) stmt stmt ) )
            // Validator.g:62:5: ^( IF ^( EXPR expr ) stmt stmt )
            {
            match(input,IF,FOLLOW_IF_in_ifStmt303); 

            match(input, Token.DOWN, null); 
            match(input,EXPR,FOLLOW_EXPR_in_ifStmt306); 

            match(input, Token.DOWN, null); 
            pushFollow(FOLLOW_expr_in_ifStmt308);
            expr();
            _fsp--;


            match(input, Token.UP, null); 
            pushFollow(FOLLOW_stmt_in_ifStmt311);
            stmt();
            _fsp--;

            pushFollow(FOLLOW_stmt_in_ifStmt313);
            stmt();
            _fsp--;


            match(input, Token.UP, null); 

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {
        }
        return ;
    }
    // $ANTLR end ifStmt


    // $ANTLR start expr
    // Validator.g:66:1: expr : ( ^( ( 'or' | '||' ) expr expr ) | ^( ( 'and' | '&&' ) expr expr ) | ^( '==' expr expr ) | ^( '!=' expr expr ) | ^( '>' expr expr ) | ^( '<' expr expr ) | ^( '>=' expr expr ) | ^( '<=' expr expr ) | ^( '<>' expr expr ) | ^( '+' expr expr ) | ^( '-' expr expr ) | ^( '*' expr expr ) | ^( '/' expr expr ) | ^( NEGATE expr ) | ^( NOT expr ) | ^( NUM INT ) | ^( VAR ID ) | ^( INDEX ID expr ) | ^( PREFIX ^( VAR ID ) ^( NUM INT ) ) | ^( POSTFIX ^( VAR ID ) ^( NUM INT ) ) | call | ^( ASSIGN ID expr ) | ^( ASSIGN ^( INDEX ID expr ) expr ) );
    public final void expr() throws RecognitionException {
        CommonTree ID3=null;
        CommonTree ID4=null;
        CommonTree ID5=null;
        CommonTree ID6=null;
        CommonTree ID7=null;
        CommonTree ID8=null;

        try {
            // Validator.g:67:4: ( ^( ( 'or' | '||' ) expr expr ) | ^( ( 'and' | '&&' ) expr expr ) | ^( '==' expr expr ) | ^( '!=' expr expr ) | ^( '>' expr expr ) | ^( '<' expr expr ) | ^( '>=' expr expr ) | ^( '<=' expr expr ) | ^( '<>' expr expr ) | ^( '+' expr expr ) | ^( '-' expr expr ) | ^( '*' expr expr ) | ^( '/' expr expr ) | ^( NEGATE expr ) | ^( NOT expr ) | ^( NUM INT ) | ^( VAR ID ) | ^( INDEX ID expr ) | ^( PREFIX ^( VAR ID ) ^( NUM INT ) ) | ^( POSTFIX ^( VAR ID ) ^( NUM INT ) ) | call | ^( ASSIGN ID expr ) | ^( ASSIGN ^( INDEX ID expr ) expr ) )
            int alt8=23;
            switch ( input.LA(1) ) {
            case 63:
            case 64:
                {
                alt8=1;
                }
                break;
            case 65:
            case 66:
                {
                alt8=2;
                }
                break;
            case 67:
                {
                alt8=3;
                }
                break;
            case 68:
                {
                alt8=4;
                }
                break;
            case 70:
                {
                alt8=5;
                }
                break;
            case 71:
                {
                alt8=6;
                }