compiler.java

c--词法分析

                        retval.st = templateLib.getInstanceOf("write",
                      new STAttrMap().put("expr", expr8.st).put("ref", expr8.ref).put("v1", Main.symbols.next_var()).put("v2", Main.symbols.next_var()));
                    }



                    }
                    break;
                case 5 :
                    // Compiler.g:81:5: WRITELN
                    {
                    match(input,WRITELN,FOLLOW_WRITELN_in_stmt596); 

                    // TEMPLATE REWRITE
                    // 81:14: -> writeln(v=Main.symbols.next_var())
                    {
                        retval.st = templateLib.getInstanceOf("writeln",
                      new STAttrMap().put("v", Main.symbols.next_var()));
                    }



                    }
                    break;
                case 6 :
                    // Compiler.g:82:5: BREAK
                    {
                    match(input,BREAK,FOLLOW_BREAK_in_stmt614); 

                    // TEMPLATE REWRITE
                    // 82:13: -> break(lab=$whileStmt::breaked)
                    {
                        retval.st = templateLib.getInstanceOf("break",
                      new STAttrMap().put("lab", ((whileStmt_scope)whileStmt_stack.peek()).breaked));
                    }



                    }
                    break;
                case 7 :
                    // Compiler.g:83:5: ifStmt
                    {
                    pushFollow(FOLLOW_ifStmt_in_stmt631);
                    ifStmt9=ifStmt();
                    _fsp--;


                    // TEMPLATE REWRITE
                    // 83:13: -> item(st=$ifStmt.sts=\"Start If Statement\"e=\"End If Statement\")
                    {
                        retval.st = templateLib.getInstanceOf("item",
                      new STAttrMap().put("st", ifStmt9.st).put("s", "Start If Statement").put("e", "End If Statement"));
                    }



                    }
                    break;
                case 8 :
                    // Compiler.g:84:5: whileStmt
                    {
                    pushFollow(FOLLOW_whileStmt_in_stmt655);
                    whileStmt10=whileStmt();
                    _fsp--;


                    // TEMPLATE REWRITE
                    // 84:16: -> item(st=$whileStmt.sts=\"Start While Statement\"e=\"End While Statement\")
                    {
                        retval.st = templateLib.getInstanceOf("item",
                      new STAttrMap().put("st", whileStmt10.st).put("s", "Start While Statement").put("e", "End While Statement"));
                    }



                    }
                    break;
                case 9 :
                    // Compiler.g:85:5: block
                    {
                    pushFollow(FOLLOW_block_in_stmt679);
                    block11=block();
                    _fsp--;


                    // TEMPLATE REWRITE
                    // 85:13: -> item(st=$block.sts=\"Start Block\"e=\"End Block\")
                    {
                        retval.st = templateLib.getInstanceOf("item",
                      new STAttrMap().put("st", block11.st).put("s", "Start Block").put("e", "End Block"));
                    }



                    }
                    break;
                case 10 :
                    // Compiler.g:86:5: NOP
                    {
                    match(input,NOP,FOLLOW_NOP_in_stmt704); 

                    // TEMPLATE REWRITE
                    // 86:11: ->
                    {
                        retval.st = null;;
                    }



                    }
                    break;

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

    protected static class whileStmt_scope {
        int breaked;
    }
    protected Stack whileStmt_stack = new Stack();

    public static class whileStmt_return extends TreeRuleReturnScope {
        public StringTemplate st;
        public Object getTemplate() { return st; }
        public String toString() { return st==null?null:st.toString(); }
    };

    // $ANTLR start whileStmt
    // Compiler.g:89:1: whileStmt : ^( WHILE expr stmt ) -> while(expr=$expr.stref=$expr.refstmt=$stmt.sttmp1=Main.symbols.next_var()start=Main.symbols.next_label()block_begin=Main.symbols.next_label()end=$whileStmt::breaked);
    public final whileStmt_return whileStmt() throws RecognitionException {
        whileStmt_stack.push(new whileStmt_scope());
        whileStmt_return retval = new whileStmt_return();
        retval.start = input.LT(1);

        expr_return expr12 = null;

        stmt_return stmt13 = null;

        List list_expr=new ArrayList();
        List list_stmt=new ArrayList();

        	((whileStmt_scope)whileStmt_stack.peek()).breaked =Main.symbols.next_label();

        try {
            // Compiler.g:97:4: ( ^( WHILE expr stmt ) -> while(expr=$expr.stref=$expr.refstmt=$stmt.sttmp1=Main.symbols.next_var()start=Main.symbols.next_label()block_begin=Main.symbols.next_label()end=$whileStmt::breaked))
            // Compiler.g:97:4: ^( WHILE expr stmt )
            {
            match(input,WHILE,FOLLOW_WHILE_in_whileStmt729); 

            match(input, Token.DOWN, null); 
            pushFollow(FOLLOW_expr_in_whileStmt731);
            expr12=expr();
            _fsp--;

            pushFollow(FOLLOW_stmt_in_whileStmt733);
            stmt13=stmt();
            _fsp--;


            match(input, Token.UP, null); 

            // TEMPLATE REWRITE
            // 97:24: -> while(expr=$expr.stref=$expr.refstmt=$stmt.sttmp1=Main.symbols.next_var()start=Main.symbols.next_label()block_begin=Main.symbols.next_label()end=$whileStmt::breaked)
            {
                retval.st = templateLib.getInstanceOf("while",
              new STAttrMap().put("expr", expr12.st).put("ref", expr12.ref).put("stmt", stmt13.st).put("tmp1", Main.symbols.next_var()).put("start", Main.symbols.next_label()).put("block_begin", Main.symbols.next_label()).put("end", ((whileStmt_scope)whileStmt_stack.peek()).breaked));
            }



            }

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

    public static class ifStmt_return extends TreeRuleReturnScope {
        public StringTemplate st;
        public Object getTemplate() { return st; }
        public String toString() { return st==null?null:st.toString(); }
    };

    // $ANTLR start ifStmt
    // Compiler.g:100:1: ifStmt : ^( IF ^( EXPR expr ) t= stmt f= stmt ) -> if(expr=$expr.stref=$expr.reftrue=$t.stfalse=$f.sttmp1=Main.symbols.next_var()lab1=Main.symbols.next_label()lab2=Main.symbols.next_label()lab3=Main.symbols.next_label());
    public final ifStmt_return ifStmt() throws RecognitionException {
        ifStmt_return retval = new ifStmt_return();
        retval.start = input.LT(1);

        stmt_return t = null;

        stmt_return f = null;

        expr_return expr14 = null;

        List list_expr=new ArrayList();
        List list_stmt=new ArrayList();
        try {
            // Compiler.g:100:12: ( ^( IF ^( EXPR expr ) t= stmt f= stmt ) -> if(expr=$expr.stref=$expr.reftrue=$t.stfalse=$f.sttmp1=Main.symbols.next_var()lab1=Main.symbols.next_label()lab2=Main.symbols.next_label()lab3=Main.symbols.next_label()))
            // Compiler.g:100:12: ^( IF ^( EXPR expr ) t= stmt f= stmt )
            {
            match(input,IF,FOLLOW_IF_in_ifStmt784); 

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

            match(input, Token.DOWN, null); 
            pushFollow(FOLLOW_expr_in_ifStmt789);
            expr14=expr();
            _fsp--;


            match(input, Token.UP, null); 
            pushFollow(FOLLOW_stmt_in_ifStmt794);
            t=stmt();
            _fsp--;

            pushFollow(FOLLOW_stmt_in_ifStmt798);
            f=stmt();
            _fsp--;


            match(input, Token.UP, null); 

            // TEMPLATE REWRITE
            // 100:45: -> if(expr=$expr.stref=$expr.reftrue=$t.stfalse=$f.sttmp1=Main.symbols.next_var()lab1=Main.symbols.next_label()lab2=Main.symbols.next_label()lab3=Main.symbols.next_label())
            {
                retval.st = templateLib.getInstanceOf("if",
              new STAttrMap().put("expr", expr14.st).put("ref", expr14.ref).put("true", t.st).put("false", f.st).put("tmp1", Main.symbols.next_var()).put("lab1", Main.symbols.next_label()).put("lab2", Main.symbols.next_label()).put("lab3", Main.symbols.next_label()));
            }



            }

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

    public static class expr_return extends TreeRuleReturnScope {
        public int ref;
        public StringTemplate st;
        public Object getTemplate() { return st; }
        public String toString() { return st==null?null:st.toString(); }
    };

    // $ANTLR start expr
    // Compiler.g:104:1: expr returns [int ref] : ( ^( ( 'or' | '||' ) a= expr b= expr ) -> or(ret=$refexpr1=$a.stexpr2=$b.stref1=$a.refref2=$b.reftmp1=Main.symbols.next_var()tmp2=Main.symbols.next_var()lab1=Main.symbols.next_label()lab2=Main.symbols.next_label()lab3=Main.symbols.next_label()lab4=Main.symbols.next_label()) | ^( ( 'and' | '&&' ) a= expr b= expr ) -> and(ret=$refexpr1=$a.stexpr2=$b.stref1=$a.refref2=$b.reftmp1=Main.symbols.next_var()tmp2=Main.symbols.next_var()lab1=Main.symbols.next_label()lab2=Main.symbols.next_label()lab3=Main.symbols.next_label()lab4=Main.symbols.next_label()) | ^( '==' a= expr b= expr ) -> comparison(type=\"eq\"expr1=$a.stexpr2=$b.stret=$refref1=$a.refref2=$b.ref) | ^( ( '!=' | '<>' ) a= expr b= expr ) -> comparison(type=\"ne\"expr1=$a.stexpr2=$b.stret=$refref1=$a.refref2=$b.ref) | ^( '>' a= expr b= expr ) -> comparison(type=\"gt\"expr1=$a.stexpr2=$b.stret=$refref1=$a.refref2=$b.ref) | ^( '<' a= expr b= expr ) -> comparison(type=\"lt\"expr1=$a.stexpr2=$b.stret=$refref1=$a.refref2=$b.ref) | ^( '>=' a= expr b= expr ) -> comparison(type=\"ge\"expr1=$a.stexpr2=$b.stret=$refref1=$a.refref2=$b.ref) | ^( '<=' a= expr b= expr ) -> comparison(type=\"le\"expr1=$a.stexpr2=$b.stret=$refref1=$a.refref2=$b.ref) | ^( '+' a= expr b= expr ) -> add(ea=$a.steb=$b.str=$refv1=$a.refv2=$b.ref) | ^( '-' a= expr b= expr ) -> subtract(ea=$a.steb=$b.str=$refv1=$a.refv2=$b.ref) | ^( '*' a= expr b= expr ) -> multiply(ea=$a.steb=$b.str=$refv1=$a.refv2=$b.ref) | ^( '/' a= expr b= expr ) -> divide(ea=$a.steb=$b.str=$refv1=$a.refv2=$b.ref) | ^( NEGATE a= expr ) -> negate(expr=$a.str=$refval=$a.ref) | ^( NOT a= expr ) -> not(expr=$a.stret=$refref=$a.ref) | ^( NUM INT ) -> create(r=$refval=$INT) | ^( VAR ID ) -> {(! Main.symbols.get_variable($ID.text).read_only) && Main.symbols.get_variable($ID.text).mode==\"scalar\"}? access(target=$refsource=Main.symbols.get_variable($ID.text).num) -> | ^( INDEX name= ID i= expr ) -> access_array(ret=$refname=Main.symbols.get_variable($name.text).numindex_expr=$i.stindex_ref=i.reftmp1=Main.symbols.next_var()size=Main.symbols.get_variable($name.text).length) | call[$ref] -> {$call.st} | ^( ASSIGN name= ID a= expr ) -> var_assign(ret=$refexpr=$a.stvar=Main.symbols.get_variable($name.text).numref=$a.ref) | ^( ASSIGN ^( INDEX name= ID i= expr ) a= expr ) -> array_assign(ret=$refval_expr=$a.stval_ref=$a.refindex_expr=$i.stindex_ref=i.refvar=Main.symbols.get_variable($name.text).numsize=Main.symbols.get_variable($name.text).values.lengthtmp1=Main.symbols.next_var()));
    public final expr_return expr() throws RecognitionException {
        expr_return retval = new expr_return();
        retval.start = input.LT(1);

        CommonTree name=null;
        CommonTree INT15=null;
        CommonTree ID16=null;
        expr_return a = null;

        expr_return b = null;

        expr_return i = null;

        call_return call17 = null;

        List list_call=new ArrayList();
        List list_expr=new ArrayList();

        	retval.ref =Main.symbols.next_var();

        try {
            // Compiler.g:108:4: ( ^( ( 'or' | '||' ) a= expr b= expr ) -> or(ret=$refexpr1=$a.stexpr2=$b.stref1=$a.refref2=$b.reftmp1=Main.symbols.next_var()tmp2=Main.symbols.next_var()lab1=Main.symbols.next_label()lab2=Main.symbols.next_label()lab3=Main.symbols.next_label()lab4=Main.symbols.next_label()) | ^( ( 'and' | '&&' ) a= expr b= expr ) -> and(ret=$refexpr1=$a.stexpr2=$b.stref1=$a.refref2=$b.reftmp1=Main.symbols.next_var()tmp2=Main.symbols.next_var()lab1=Main.symbols.next_label()lab2=Main.symbols.next_label()lab3=Main.symbols.next_label()lab4=Main.symbols.next_label()) | ^( '==' a= expr b= expr ) -> comparison(type=\"eq\"expr1=$a.stexpr2=$b.stret=$refref1=$a.refref2=$b.ref) | ^( ( '!=' | '<>' ) a= expr b= expr ) -> comparison(type=\"ne\"expr1=$a.stexpr2=$b.stret=$refref1=$a.refref2=$b.ref) | ^( '>' a= expr b= expr ) -> comparison(type=\"gt\"expr1=$a.stexpr2=$b.stret=$refref1=$a.refref2=$b.ref) | ^( '<' a= expr b= expr ) -> comparison(type=\"lt\"expr1=$a.stexpr2=$b.stret=$refref1=$a.refref2=$b.ref) | ^( '>=' a= expr b= expr ) -> comparison(type=\"ge\"expr1=$a.stexpr2=$b.stret=$refref1=$a.refref2=$b.ref) | ^( '<=' a= expr b= expr ) -> comparison(type=\"le\"expr1=$a.stexpr2=$b.stret=$refref1=$a.refref2=$b.ref) | ^( '+' a= expr b= expr ) -> add(ea=$a.steb=$b.str=$refv1=$a.refv2=$b.ref) | ^( '-' a= expr b= expr ) -> subtract(ea=$a.steb=$b.str=$refv1=$a.refv2=$b.ref) | ^( '*' a= expr b= expr ) -> multiply(ea=$a.steb=$b.str=$refv1=$a.refv2=$b.ref) | ^( '/' a= expr b= expr ) -> divide(ea=$a.steb=$b.str=$refv1=$a.refv2=$b.ref) | ^( NEGATE a= expr ) -> negate(expr=$a.str=$refval=$a.ref) | ^( NOT a= expr ) -> not(expr=$a.stret=$refref=$a.ref) | ^( NUM INT ) -> create(r=$refval=$INT) | ^( VAR ID ) -> {(! Main.symbols.get_variable($ID.text).read_only) && Main.symbols.get_variable($ID.text).mode==\"scalar\"}? access(target=$refsource=Main.symbols.get_variable($ID.text).num) -> | ^( INDEX name= ID i= expr ) -> access_array(ret=$refname=Main.symbols.get_variable($name.text).numindex_expr=$i.stindex_ref=i.reftmp1=Main.symbols.next_var()size=Main.symbols.get_variable($name.text).length) | call[$ref] -> {$call.st} | ^( ASSIGN name= ID a= expr ) -> var_assign(ret=$refexpr=$a.stvar=Main.symbols.get_variable($name.text).numref=$a.ref) | ^( ASSIGN ^( INDEX name= ID i= expr ) a= expr ) -> array_assign(ret=$refval_expr=$a.stval_ref=$a.refindex_expr=$i.stindex_ref=i.refvar=Main.symbols.get_variable($name.text).numsize=Main.symbols.get_variable($name.text).values.lengthtmp1=Main.symbols.next_var()))
            int alt12=20;
            switch ( input.LA(1) ) {
            case 63: