// $ANTLR 3.3 Nov 30, 2010 12:45:30 /home/luca/NetBeansProjects/10.14/Calc_java.g 2011-02-05 02:10:38

import java.util.HashMap;


import org.antlr.runtime.*;
import java.util.Stack;
import java.util.List;
import java.util.ArrayList;

import org.antlr.runtime.debug.*;
import java.io.IOException;

import org.antlr.runtime.tree.*;

public class Calc_javaParser extends DebugParser {
    public static final String[] tokenNames = new String[] {
        "<invalid>", "<EOR>", "<DOWN>", "<UP>", "EXPR", "PRINT", "NUMBER", "ID", "WS", "'+'", "'-'", "'*'", "'/'", "'('", "')'", "'='"
    };
    public static final int EOF=-1;
    public static final int T__9=9;
    public static final int T__10=10;
    public static final int T__11=11;
    public static final int T__12=12;
    public static final int T__13=13;
    public static final int T__14=14;
    public static final int T__15=15;
    public static final int EXPR=4;
    public static final int PRINT=5;
    public static final int NUMBER=6;
    public static final int ID=7;
    public static final int WS=8;

    // delegates
    // delegators

    public static final String[] ruleNames = new String[] {
        "invalidRule", "atom", "prog", "expr", "stat", "subExpr"
    };
    public static final boolean[] decisionCanBacktrack = new boolean[] {
        false, // invalid decision
        false, false, false, false, false, false
    };

     
        public int ruleLevel = 0;
        public int getRuleLevel() { return ruleLevel; }
        public void incRuleLevel() { ruleLevel++; }
        public void decRuleLevel() { ruleLevel--; }
        public Calc_javaParser(TokenStream input) {
            this(input, DebugEventSocketProxy.DEFAULT_DEBUGGER_PORT, new RecognizerSharedState());
        }
        public Calc_javaParser(TokenStream input, int port, RecognizerSharedState state) {
            super(input, state);
            DebugEventSocketProxy proxy =
                new DebugEventSocketProxy(this,port,adaptor);
            setDebugListener(proxy);
            setTokenStream(new DebugTokenStream(input,proxy));
            try {
                proxy.handshake();
            }
            catch (IOException ioe) {
                reportError(ioe);
            }
            TreeAdaptor adap = new CommonTreeAdaptor();
            setTreeAdaptor(adap);
            proxy.setTreeAdaptor(adap);
        }
    public Calc_javaParser(TokenStream input, DebugEventListener dbg) {
        super(input, dbg);

         
        TreeAdaptor adap = new CommonTreeAdaptor();
        setTreeAdaptor(adap);

    }
    protected boolean evalPredicate(boolean result, String predicate) {
        dbg.semanticPredicate(result, predicate);
        return result;
    }

    protected DebugTreeAdaptor adaptor;
    public void setTreeAdaptor(TreeAdaptor adaptor) {
        this.adaptor = new DebugTreeAdaptor(dbg,adaptor);

    }
    public TreeAdaptor getTreeAdaptor() {
        return adaptor;
    }


    public String[] getTokenNames() { return Calc_javaParser.tokenNames; }
    public String getGrammarFileName() { return "/home/luca/NetBeansProjects/10.14/Calc_java.g"; }


    HashMap memory = new HashMap();


    public static class prog_return extends ParserRuleReturnScope {
        Object tree;
        public Object getTree() { return tree; }
    };

    // $ANTLR start "prog"
    // /home/luca/NetBeansProjects/10.14/Calc_java.g:21:1: prog : ( stat )* ;
    public final Calc_javaParser.prog_return prog() throws RecognitionException {
        Calc_javaParser.prog_return retval = new Calc_javaParser.prog_return();
        retval.start = input.LT(1);

        Object root_0 = null;

        Calc_javaParser.stat_return stat1 = null;



        try { dbg.enterRule(getGrammarFileName(), "prog");
        if ( getRuleLevel()==0 ) {dbg.commence();}
        incRuleLevel();
        dbg.location(21, 1);

        try {
            // /home/luca/NetBeansProjects/10.14/Calc_java.g:21:5: ( ( stat )* )
            dbg.enterAlt(1);

            // /home/luca/NetBeansProjects/10.14/Calc_java.g:21:9: ( stat )*
            {
            root_0 = (Object)adaptor.nil();

            dbg.location(21,9);
            // /home/luca/NetBeansProjects/10.14/Calc_java.g:21:9: ( stat )*
            try { dbg.enterSubRule(1);

            loop1:
            do {
                int alt1=2;
                try { dbg.enterDecision(1, decisionCanBacktrack[1]);

                int LA1_0 = input.LA(1);

                if ( ((LA1_0>=NUMBER && LA1_0<=ID)||LA1_0==13) ) {
                    alt1=1;
                }


                } finally {dbg.exitDecision(1);}

                switch (alt1) {
            	case 1 :
            	    dbg.enterAlt(1);

            	    // /home/luca/NetBeansProjects/10.14/Calc_java.g:21:9: stat
            	    {
            	    dbg.location(21,9);
            	    pushFollow(FOLLOW_stat_in_prog55);
            	    stat1=stat();

            	    state._fsp--;

            	    adaptor.addChild(root_0, stat1.getTree());

            	    }
            	    break;

            	default :
            	    break loop1;
                }
            } while (true);
            } finally {dbg.exitSubRule(1);}


            }

            retval.stop = input.LT(-1);

            retval.tree = (Object)adaptor.rulePostProcessing(root_0);
            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
    	retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);

        }
        finally {
        }
        dbg.location(21, 14);

        }
        finally {
            dbg.exitRule(getGrammarFileName(), "prog");
            decRuleLevel();
            if ( getRuleLevel()==0 ) {dbg.terminate();}
        }

        return retval;
    }
    // $ANTLR end "prog"

    public static class stat_return extends ParserRuleReturnScope {
        public double value;
        Object tree;
        public Object getTree() { return tree; }
    };

    // $ANTLR start "stat"
    // /home/luca/NetBeansProjects/10.14/Calc_java.g:23:1: stat returns [double value] : e= expr ( ( PRINT )+ | EOF ) -> ^( EXPR expr ) ;
    public final Calc_javaParser.stat_return stat() throws RecognitionException {
        Calc_javaParser.stat_return retval = new Calc_javaParser.stat_return();
        retval.start = input.LT(1);

        Object root_0 = null;

        Token PRINT2=null;
        Token EOF3=null;
        Calc_javaParser.expr_return e = null;


        Object PRINT2_tree=null;
        Object EOF3_tree=null;
        RewriteRuleTokenStream stream_EOF=new RewriteRuleTokenStream(adaptor,"token EOF");
        RewriteRuleTokenStream stream_PRINT=new RewriteRuleTokenStream(adaptor,"token PRINT");
        RewriteRuleSubtreeStream stream_expr=new RewriteRuleSubtreeStream(adaptor,"rule expr");
        try { dbg.enterRule(getGrammarFileName(), "stat");
        if ( getRuleLevel()==0 ) {dbg.commence();}
        incRuleLevel();
        dbg.location(23, 1);

        try {
            // /home/luca/NetBeansProjects/10.14/Calc_java.g:24:5: (e= expr ( ( PRINT )+ | EOF ) -> ^( EXPR expr ) )
            dbg.enterAlt(1);

            // /home/luca/NetBeansProjects/10.14/Calc_java.g:24:9: e= expr ( ( PRINT )+ | EOF )
            {
            dbg.location(24,10);
            pushFollow(FOLLOW_expr_in_stat92);
            e=expr();

            state._fsp--;

            stream_expr.add(e.getTree());
            dbg.location(24,16);
            // /home/luca/NetBeansProjects/10.14/Calc_java.g:24:16: ( ( PRINT )+ | EOF )
            int alt3=2;
            try { dbg.enterSubRule(3);
            try { dbg.enterDecision(3, decisionCanBacktrack[3]);

            int LA3_0 = input.LA(1);

            if ( (LA3_0==PRINT) ) {
                alt3=1;
            }
            else if ( (LA3_0==EOF) ) {
                alt3=2;
            }
            else {
                NoViableAltException nvae =
                    new NoViableAltException("", 3, 0, input);

                dbg.recognitionException(nvae);
                throw nvae;
            }
            } finally {dbg.exitDecision(3);}

            switch (alt3) {
                case 1 :
                    dbg.enterAlt(1);

                    // /home/luca/NetBeansProjects/10.14/Calc_java.g:24:17: ( PRINT )+
                    {
                    dbg.location(24,17);
                    // /home/luca/NetBeansProjects/10.14/Calc_java.g:24:17: ( PRINT )+
                    int cnt2=0;
                    try { dbg.enterSubRule(2);

                    loop2:
                    do {
                        int alt2=2;
                        try { dbg.enterDecision(2, decisionCanBacktrack[2]);

                        int LA2_0 = input.LA(1);

                        if ( (LA2_0==PRINT) ) {
                            alt2=1;
                        }


                        } finally {dbg.exitDecision(2);}

                        switch (alt2) {
                    	case 1 :
                    	    dbg.enterAlt(1);

                    	    // /home/luca/NetBeansProjects/10.14/Calc_java.g:24:17: PRINT
                    	    {
                    	    dbg.location(24,17);
                    	    PRINT2=(Token)match(input,PRINT,FOLLOW_PRINT_in_stat95);  
                    	    stream_PRINT.add(PRINT2);


                    	    }
                    	    break;

                    	default :
                    	    if ( cnt2 >= 1 ) break loop2;
                                EarlyExitException eee =
                                    new EarlyExitException(2, input);
                                dbg.recognitionException(eee);

                                throw eee;
                        }
                        cnt2++;
                    } while (true);
                    } finally {dbg.exitSubRule(2);}


                    }
                    break;
                case 2 :
                    dbg.enterAlt(2);

                    // /home/luca/NetBeansProjects/10.14/Calc_java.g:24:26: EOF
                    {
                    dbg.location(24,26);
                    EOF3=(Token)match(input,EOF,FOLLOW_EOF_in_stat100);  
                    stream_EOF.add(EOF3);


                    }
                    break;

            }
            } finally {dbg.exitSubRule(3);}

            dbg.location(24,31);
            retval.value = (e!=null?e.value:0.0); System.out.println((e!=null?e.value:0.0));


            // AST REWRITE
            // elements: expr
            // token labels: 
            // rule labels: retval
            // token list labels: 
            // rule list labels: 
            // wildcard labels: 
            retval.tree = root_0;
            RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);

            root_0 = (Object)adaptor.nil();
            // 24:85: -> ^( EXPR expr )
            {
                dbg.location(24,88);
                // /home/luca/NetBeansProjects/10.14/Calc_java.g:24:88: ^( EXPR expr )
                {
                Object root_1 = (Object)adaptor.nil();
                dbg.location(24,90);
                root_1 = (Object)adaptor.becomeRoot((Object)adaptor.create(EXPR, "EXPR"), root_1);

                dbg.location(24,95);
                adaptor.addChild(root_1, stream_expr.nextTree());

                adaptor.addChild(root_0, root_1);
                }

            }

            retval.tree = root_0;
            }

            retval.stop = input.LT(-1);

            retval.tree = (Object)adaptor.rulePostProcessing(root_0);
            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
    	retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);

        }
        finally {
        }
        dbg.location(25, 5);

        }
        finally {
            dbg.exitRule(getGrammarFileName(), "stat");
            decRuleLevel();
            if ( getRuleLevel()==0 ) {dbg.terminate();}
        }

        return retval;
    }
    // $ANTLR end "stat"

    public static class expr_return extends ParserRuleReturnScope {
        public double value;
        Object tree;
        public Object getTree() { return tree; }
    };

    // $ANTLR start "expr"
    // /home/luca/NetBeansProjects/10.14/Calc_java.g:27:1: expr returns [double value] : e= subExpr ( '+' e= subExpr | '-' e= subExpr )* ;
    public final Calc_javaParser.expr_return expr() throws RecognitionException {
        Calc_javaParser.expr_return retval = new Calc_javaParser.expr_return();
        retval.start = input.LT(1);

        Object root_0 = null;

        Token char_literal4=null;
        Token char_literal5=null;
        Calc_javaParser.subExpr_return e = null;


        Object char_literal4_tree=null;
        Object char_literal5_tree=null;

        try { dbg.enterRule(getGrammarFileName(), "expr");
        if ( getRuleLevel()==0 ) {dbg.commence();}
        incRuleLevel();
        dbg.location(27, 1);

        try {
            // /home/luca/NetBeansProjects/10.14/Calc_java.g:28:5: (e= subExpr ( '+' e= subExpr | '-' e= subExpr )* )
            dbg.enterAlt(1);

            // /home/luca/NetBeansProjects/10.14/Calc_java.g:28:9: e= subExpr ( '+' e= subExpr | '-' e= subExpr )*
            {
            root_0 = (Object)adaptor.nil();

            dbg.location(28,10);
            pushFollow(FOLLOW_subExpr_in_expr136);
            e=subExpr();

            state._fsp--;

            adaptor.addChild(root_0, e.getTree());
            dbg.location(28,19);
            retval.value = (e!=null?e.value:0.0);
            dbg.location(29,9);
            // /home/luca/NetBeansProjects/10.14/Calc_java.g:29:9: ( '+' e= subExpr | '-' e= subExpr )*
            try { dbg.enterSubRule(4);

            loop4:
            do {
                int alt4=3;
                try { dbg.enterDecision(4, decisionCanBacktrack[4]);

                int LA4_0 = input.LA(1);

                if ( (LA4_0==9) ) {
                    alt4=1;
                }
                else if ( (LA4_0==10) ) {
                    alt4=2;
                }


                } finally {dbg.exitDecision(4);}

                switch (alt4) {
            	case 1 :
            	    dbg.enterAlt(1);

            	    // /home/luca/NetBeansProjects/10.14/Calc_java.g:29:13: '+' e= subExpr
            	    {
            	    dbg.location(29,16);
            	    char_literal4=(Token)match(input,9,FOLLOW_9_in_expr152); 
            	    char_literal4_tree = (Object)adaptor.create(char_literal4);
            	    root_0 = (Object)adaptor.becomeRoot(char_literal4_tree, root_0);

            	    dbg.location(29,19);
            	    pushFollow(FOLLOW_subExpr_in_expr157);
            	    e=subExpr();

            	    state._fsp--;

            	    adaptor.addChild(root_0, e.getTree());
            	    dbg.location(29,28);
            	    retval.value += (e!=null?e.value:0.0);

            	    }
            	    break;
            	case 2 :
            	    dbg.enterAlt(2);

            	    // /home/luca/NetBeansProjects/10.14/Calc_java.g:30:13: '-' e= subExpr
            	    {
            	    dbg.location(30,16);
            	    char_literal5=(Token)match(input,10,FOLLOW_10_in_expr173); 
            	    char_literal5_tree = (Object)adaptor.create(char_literal5);
            	    root_0 = (Object)adaptor.becomeRoot(char_literal5_tree, root_0);

            	    dbg.location(30,19);
            	    pushFollow(FOLLOW_subExpr_in_expr178);
            	    e=subExpr();

            	    state._fsp--;

            	    adaptor.addChild(root_0, e.getTree());
            	    dbg.location(30,28);
            	    retval.value -= (e!=null?e.value:0.0);

            	    }
            	    break;

            	default :
            	    break loop4;
                }
            } while (true);
            } finally {dbg.exitSubRule(4);}


            }

            retval.stop = input.LT(-1);

            retval.tree = (Object)adaptor.rulePostProcessing(root_0);
            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
    	retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);

        }
        finally {
        }
        dbg.location(32, 5);

        }
        finally {
            dbg.exitRule(getGrammarFileName(), "expr");
            decRuleLevel();
            if ( getRuleLevel()==0 ) {dbg.terminate();}
        }

        return retval;
    }
    // $ANTLR end "expr"

    public static class subExpr_return extends ParserRuleReturnScope {
        public double value;
        Object tree;
        public Object getTree() { return tree; }
    };

    // $ANTLR start "subExpr"
    // /home/luca/NetBeansProjects/10.14/Calc_java.g:34:1: subExpr returns [double value] : e= atom ( '*' e= atom | '/' e= atom )* ;
    public final Calc_javaParser.subExpr_return subExpr() throws RecognitionException {
        Calc_javaParser.subExpr_return retval = new Calc_javaParser.subExpr_return();
        retval.start = input.LT(1);

        Object root_0 = null;

        Token char_literal6=null;
        Token char_literal7=null;
        Calc_javaParser.atom_return e = null;


        Object char_literal6_tree=null;
        Object char_literal7_tree=null;

        try { dbg.enterRule(getGrammarFileName(), "subExpr");
        if ( getRuleLevel()==0 ) {dbg.commence();}
        incRuleLevel();
        dbg.location(34, 1);

        try {
            // /home/luca/NetBeansProjects/10.14/Calc_java.g:35:5: (e= atom ( '*' e= atom | '/' e= atom )* )
            dbg.enterAlt(1);

            // /home/luca/NetBeansProjects/10.14/Calc_java.g:35:9: e= atom ( '*' e= atom | '/' e= atom )*
            {
            root_0 = (Object)adaptor.nil();

            dbg.location(35,10);
            pushFollow(FOLLOW_atom_in_subExpr216);
            e=atom();

            state._fsp--;

            adaptor.addChild(root_0, e.getTree());
            dbg.location(35,16);
            retval.value = (e!=null?e.value:0.0);
            dbg.location(36,9);
            // /home/luca/NetBeansProjects/10.14/Calc_java.g:36:9: ( '*' e= atom | '/' e= atom )*
            try { dbg.enterSubRule(5);

            loop5:
            do {
                int alt5=3;
                try { dbg.enterDecision(5, decisionCanBacktrack[5]);

                int LA5_0 = input.LA(1);

                if ( (LA5_0==11) ) {
                    alt5=1;
                }
                else if ( (LA5_0==12) ) {
                    alt5=2;
                }


                } finally {dbg.exitDecision(5);}

                switch (alt5) {
            	case 1 :
            	    dbg.enterAlt(1);

            	    // /home/luca/NetBeansProjects/10.14/Calc_java.g:36:11: '*' e= atom
            	    {
            	    dbg.location(36,14);
            	    char_literal6=(Token)match(input,11,FOLLOW_11_in_subExpr231); 
            	    char_literal6_tree = (Object)adaptor.create(char_literal6);
            	    root_0 = (Object)adaptor.becomeRoot(char_literal6_tree, root_0);

            	    dbg.location(36,17);
            	    pushFollow(FOLLOW_atom_in_subExpr236);
            	    e=atom();

            	    state._fsp--;

            	    adaptor.addChild(root_0, e.getTree());
            	    dbg.location(36,23);
            	    retval.value *= (e!=null?e.value:0.0);

            	    }
            	    break;
            	case 2 :
            	    dbg.enterAlt(2);

            	    // /home/luca/NetBeansProjects/10.14/Calc_java.g:37:11: '/' e= atom
            	    {
            	    dbg.location(37,14);
            	    char_literal7=(Token)match(input,12,FOLLOW_12_in_subExpr250); 
            	    char_literal7_tree = (Object)adaptor.create(char_literal7);
            	    root_0 = (Object)adaptor.becomeRoot(char_literal7_tree, root_0);

            	    dbg.location(37,17);
            	    pushFollow(FOLLOW_atom_in_subExpr255);
            	    e=atom();

            	    state._fsp--;

            	    adaptor.addChild(root_0, e.getTree());
            	    dbg.location(37,23);
            	    retval.value /= (e!=null?e.value:0.0);

            	    }
            	    break;

            	default :
            	    break loop5;
                }
            } while (true);
            } finally {dbg.exitSubRule(5);}


            }

            retval.stop = input.LT(-1);

            retval.tree = (Object)adaptor.rulePostProcessing(root_0);
            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
    	retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);

        }
        finally {
        }
        dbg.location(39, 5);

        }
        finally {
            dbg.exitRule(getGrammarFileName(), "subExpr");
            decRuleLevel();
            if ( getRuleLevel()==0 ) {dbg.terminate();}
        }

        return retval;
    }
    // $ANTLR end "subExpr"

    public static class atom_return extends ParserRuleReturnScope {
        public double value;
        Object tree;
        public Object getTree() { return tree; }
    };

    // $ANTLR start "atom"
    // /home/luca/NetBeansProjects/10.14/Calc_java.g:41:1: atom returns [double value] : ( NUMBER | ID | '(' expr ')' | ID '=' expr );
    public final Calc_javaParser.atom_return atom() throws RecognitionException {
        Calc_javaParser.atom_return retval = new Calc_javaParser.atom_return();
        retval.start = input.LT(1);

        Object root_0 = null;

        Token NUMBER8=null;
        Token ID9=null;
        Token char_literal10=null;
        Token char_literal12=null;
        Token ID13=null;
        Token char_literal14=null;
        Calc_javaParser.expr_return expr11 = null;

        Calc_javaParser.expr_return expr15 = null;


        Object NUMBER8_tree=null;
        Object ID9_tree=null;
        Object char_literal10_tree=null;
        Object char_literal12_tree=null;
        Object ID13_tree=null;
        Object char_literal14_tree=null;

        try { dbg.enterRule(getGrammarFileName(), "atom");
        if ( getRuleLevel()==0 ) {dbg.commence();}
        incRuleLevel();
        dbg.location(41, 1);

        try {
            // /home/luca/NetBeansProjects/10.14/Calc_java.g:42:5: ( NUMBER | ID | '(' expr ')' | ID '=' expr )
            int alt6=4;
            try { dbg.enterDecision(6, decisionCanBacktrack[6]);

            switch ( input.LA(1) ) {
            case NUMBER:
                {
                alt6=1;
                }
                break;
            case ID:
                {
                int LA6_2 = input.LA(2);

                if ( (LA6_2==15) ) {
                    alt6=4;
                }
                else if ( (LA6_2==EOF||LA6_2==PRINT||(LA6_2>=9 && LA6_2<=12)||LA6_2==14) ) {
                    alt6=2;
                }
                else {
                    NoViableAltException nvae =
                        new NoViableAltException("", 6, 2, input);

                    dbg.recognitionException(nvae);
                    throw nvae;
                }
                }
                break;
            case 13:
                {
                alt6=3;
                }
                break;
            default:
                NoViableAltException nvae =
                    new NoViableAltException("", 6, 0, input);

                dbg.recognitionException(nvae);
                throw nvae;
            }

            } finally {dbg.exitDecision(6);}

            switch (alt6) {
                case 1 :
                    dbg.enterAlt(1);

                    // /home/luca/NetBeansProjects/10.14/Calc_java.g:42:9: NUMBER
                    {
                    root_0 = (Object)adaptor.nil();

                    dbg.location(42,9);
                    NUMBER8=(Token)match(input,NUMBER,FOLLOW_NUMBER_in_atom292); 
                    NUMBER8_tree = (Object)adaptor.create(NUMBER8);
                    adaptor.addChild(root_0, NUMBER8_tree);

                    dbg.location(42,16);
                    retval.value = Double.parseDouble((NUMBER8!=null?NUMBER8.getText():null));

                    }
                    break;
                case 2 :
                    dbg.enterAlt(2);

                    // /home/luca/NetBeansProjects/10.14/Calc_java.g:43:9: ID
                    {
                    root_0 = (Object)adaptor.nil();

                    dbg.location(43,9);
                    ID9=(Token)match(input,ID,FOLLOW_ID_in_atom304); 
                    ID9_tree = (Object)adaptor.create(ID9);
                    adaptor.addChild(root_0, ID9_tree);

                    dbg.location(44,9);

                            Double v = (Double)memory.get((ID9!=null?ID9.getText():null));
                            if ( v != null )
                            	retval.value = v.doubleValue();
                            else 
                            	System.err.println("undefined variable "+(ID9!=null?ID9.getText():null));
                            

                    }
                    break;
                case 3 :
                    dbg.enterAlt(3);

                    // /home/luca/NetBeansProjects/10.14/Calc_java.g:51:9: '(' expr ')'
                    {
                    root_0 = (Object)adaptor.nil();

                    dbg.location(51,12);
                    char_literal10=(Token)match(input,13,FOLLOW_13_in_atom324); 
                    dbg.location(51,14);
                    pushFollow(FOLLOW_expr_in_atom327);
                    expr11=expr();

                    state._fsp--;

                    adaptor.addChild(root_0, expr11.getTree());
                    dbg.location(51,22);
                    char_literal12=(Token)match(input,14,FOLLOW_14_in_atom329); 
                    dbg.location(51,24);
                    retval.value = (expr11!=null?expr11.value:0.0);

                    }
                    break;
                case 4 :
                    dbg.enterAlt(4);

                    // /home/luca/NetBeansProjects/10.14/Calc_java.g:52:9: ID '=' expr
                    {
                    root_0 = (Object)adaptor.nil();

                    dbg.location(52,9);
                    ID13=(Token)match(input,ID,FOLLOW_ID_in_atom342); 
                    ID13_tree = (Object)adaptor.create(ID13);
                    adaptor.addChild(root_0, ID13_tree);

                    dbg.location(52,15);
                    char_literal14=(Token)match(input,15,FOLLOW_15_in_atom344); 
                    char_literal14_tree = (Object)adaptor.create(char_literal14);
                    root_0 = (Object)adaptor.becomeRoot(char_literal14_tree, root_0);

                    dbg.location(52,17);
                    pushFollow(FOLLOW_expr_in_atom347);
                    expr15=expr();

                    state._fsp--;

                    adaptor.addChild(root_0, expr15.getTree());
                    dbg.location(52,22);
                    memory.put((ID13!=null?ID13.getText():null), new Double((expr15!=null?expr15.value:0.0))); retval.value = (expr15!=null?expr15.value:0.0);

                    }
                    break;

            }
            retval.stop = input.LT(-1);

            retval.tree = (Object)adaptor.rulePostProcessing(root_0);
            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
    	retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);

        }
        finally {
        }
        dbg.location(54, 5);

        }
        finally {
            dbg.exitRule(getGrammarFileName(), "atom");
            decRuleLevel();
            if ( getRuleLevel()==0 ) {dbg.terminate();}
        }

        return retval;
    }
    // $ANTLR end "atom"

    // Delegated rules


 

    public static final BitSet FOLLOW_stat_in_prog55 = new BitSet(new long[]{0x00000000000020C2L});
    public static final BitSet FOLLOW_expr_in_stat92 = new BitSet(new long[]{0x0000000000000020L});
    public static final BitSet FOLLOW_PRINT_in_stat95 = new BitSet(new long[]{0x0000000000000022L});
    public static final BitSet FOLLOW_EOF_in_stat100 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_subExpr_in_expr136 = new BitSet(new long[]{0x0000000000000602L});
    public static final BitSet FOLLOW_9_in_expr152 = new BitSet(new long[]{0x00000000000026C0L});
    public static final BitSet FOLLOW_subExpr_in_expr157 = new BitSet(new long[]{0x0000000000000602L});
    public static final BitSet FOLLOW_10_in_expr173 = new BitSet(new long[]{0x00000000000026C0L});
    public static final BitSet FOLLOW_subExpr_in_expr178 = new BitSet(new long[]{0x0000000000000602L});
    public static final BitSet FOLLOW_atom_in_subExpr216 = new BitSet(new long[]{0x0000000000001802L});
    public static final BitSet FOLLOW_11_in_subExpr231 = new BitSet(new long[]{0x00000000000038C0L});
    public static final BitSet FOLLOW_atom_in_subExpr236 = new BitSet(new long[]{0x0000000000001802L});
    public static final BitSet FOLLOW_12_in_subExpr250 = new BitSet(new long[]{0x00000000000038C0L});
    public static final BitSet FOLLOW_atom_in_subExpr255 = new BitSet(new long[]{0x0000000000001802L});
    public static final BitSet FOLLOW_NUMBER_in_atom292 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_ID_in_atom304 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_13_in_atom324 = new BitSet(new long[]{0x00000000000060C0L});
    public static final BitSet FOLLOW_expr_in_atom327 = new BitSet(new long[]{0x0000000000004000L});
    public static final BitSet FOLLOW_14_in_atom329 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_ID_in_atom342 = new BitSet(new long[]{0x0000000000008000L});
    public static final BitSet FOLLOW_15_in_atom344 = new BitSet(new long[]{0x00000000000020C0L});
    public static final BitSet FOLLOW_expr_in_atom347 = new BitSet(new long[]{0x0000000000000002L});

}