evaltreeparser.cs

antlr小例子 。

// $ANTLR 3.0b5 Eval.g 2006-12-27 11:10:22

using System.Collections;


using System;
using Antlr.Runtime;
using Antlr.Runtime.Tree;using IList 		= System.Collections.IList;
using ArrayList 	= System.Collections.ArrayList;
using Stack 		= Antlr.Runtime.Collections.StackList;



public class EvalTreeParser : TreeParser 
{
    public static readonly string[] tokenNames = new string[] 
	{
        "<invalid>", 
		"<EOR>", 
		"<DOWN>", 
		"<UP>", 
		"NEWLINE", 
		"ID", 
		"INT", 
		"WS", 
		"'='", 
		"'+'", 
		"'-'", 
		"'*'", 
		"'('", 
		"')'"
    };

    public const int INT = 6;
    public const int EOF = -1;
    public const int WS = 7;
    public const int NEWLINE = 4;
    public const int ID = 5;
    
    
        public EvalTreeParser(ITreeNodeStream input) 
    		: base(input)
    	{
    		InitializeCyclicDFAs();
        }
        

    override public string[] TokenNames
	{
		get { return tokenNames; }
	}

    override public string GrammarFileName
	{
		get { return "Eval.g"; }
	}

    
    /** Map variable name to Integer object holding value */
    public Hashtable memory = new Hashtable();


    
    // $ANTLR start prog
    // Eval.g:18:1: prog : ( stat )+ ;
    public void prog() // throws RecognitionException [1]
    {   
        try 
    	{
            // Eval.g:18:9: ( ( stat )+ )
            // Eval.g:18:9: ( stat )+
            {
            	// Eval.g:18:9: ( stat )+
            	int cnt1 = 0;
            	do 
            	{
            	    int alt1 = 2;
            	    int LA1_0 = input.LA(1);
            	    if ( ((LA1_0 >= ID && LA1_0 <= INT) || (LA1_0 >= 8 && LA1_0 <= 11)) )
            	    {
            	        alt1 = 1;
            	    }
            	    
            	
            	    switch (alt1) 
            		{
            			case 1 :
            			    // Eval.g:18:9: stat
            			    {
            			    	PushFollow(FOLLOW_stat_in_prog54);
            			    	stat();
            			    	followingStackPointer_--;

            			    
            			    }
            			    break;
            	
            			default:
            			    if ( cnt1 >= 1 ) goto loop1;
            		            EarlyExitException eee =
            		                new EarlyExitException(1, input);
            		            throw eee;
            	    }
            	    cnt1++;
            	} while (true);
            	
            	loop1:
            		;	// Stops C# compiler whinging that label 'loop1' has no statements

            
            }
    
        }
        catch (RecognitionException re) 
    	{
            ReportError(re);
            Recover(input,re);
        }
        finally 
    	{
        }
        return ;
    }
    // $ANTLR end prog

    
    // $ANTLR start stat
    // Eval.g:20:1: stat : ( expr | ^( '=' ID expr ) );
    public void stat() // throws RecognitionException [1]
    {   
        CommonTree ID2 = null;
        int expr1 = 0;

        int expr3 = 0;
        
    
        try 
    	{
            // Eval.g:20:9: ( expr | ^( '=' ID expr ) )
            int alt2 = 2;
            int LA2_0 = input.LA(1);
            if ( ((LA2_0 >= ID && LA2_0 <= INT) || (LA2_0 >= 9 && LA2_0 <= 11)) )
            {
                alt2 = 1;
            }
            else if ( (LA2_0 == 8) )
            {
                alt2 = 2;
            }
            else 
            {
                NoViableAltException nvae_d2s0 =
                    new NoViableAltException("20:1: stat : ( expr | ^( '=' ID expr ) );", 2, 0, input);
            
                throw nvae_d2s0;
            }
            switch (alt2) 
            {
                case 1 :
                    // Eval.g:20:9: expr
                    {
                    	PushFollow(FOLLOW_expr_in_stat65);
                    	expr1 = expr();
                    	followingStackPointer_--;

                    	 Console.WriteLine(expr1); 
                    
                    }
                    break;
                case 2 :
                    // Eval.g:21:9: ^( '=' ID expr )
                    {
                    	Match(input,8,FOLLOW_8_in_stat78); 
                    	
                    	Match(input, Token.DOWN, null); 
                    	ID2 = (CommonTree)input.LT(1);
                    	Match(input,ID,FOLLOW_ID_in_stat80); 
                    	PushFollow(FOLLOW_expr_in_stat82);
                    	expr3 = expr();
                    	followingStackPointer_--;

                    	
                    	Match(input, Token.UP, null); 
                    	 memory[ID2.Text] = expr3; 
                    
                    }
                    break;
            
            }
        }
        catch (RecognitionException re) 
    	{
            ReportError(re);
            Recover(input,re);
        }
        finally 
    	{
        }
        return ;
    }
    // $ANTLR end stat

    
    // $ANTLR start expr
    // Eval.g:24:1: expr returns [int value] : ( ^( '+' a= expr b= expr ) | ^( '-' a= expr b= expr ) | ^( '*' a= expr b= expr ) | ID | integer= INT );
    public int expr() // throws RecognitionException [1]
    {   

        int value = 0;
    
        CommonTree integer = null;
        CommonTree ID4 = null;
        int a = 0;

        int b = 0;
        
    
        try 
    	{
            // Eval.g:25:9: ( ^( '+' a= expr b= expr ) | ^( '-' a= expr b= expr ) | ^( '*' a= expr b= expr ) | ID | integer= INT )
            int alt3 = 5;
            switch ( input.LA(1) ) 
            {
            case 9:
                alt3 = 1;
                break;
            case 10:
                alt3 = 2;
                break;
            case 11:
                alt3 = 3;
                break;
            case ID:
                alt3 = 4;
                break;
            case INT:
                alt3 = 5;
                break;
            	default:
            	    NoViableAltException nvae_d3s0 =
            	        new NoViableAltException("24:1: expr returns [int value] : ( ^( '+' a= expr b= expr ) | ^( '-' a= expr b= expr ) | ^( '*' a= expr b= expr ) | ID | integer= INT );", 3, 0, input);
            
            	    throw nvae_d3s0;
            }
            
            switch (alt3) 
            {
                case 1 :
                    // Eval.g:25:9: ^( '+' a= expr b= expr )
                    {
                    	Match(input,9,FOLLOW_9_in_expr109); 
                    	
                    	Match(input, Token.DOWN, null); 
                    	PushFollow(FOLLOW_expr_in_expr113);
                    	a = expr();
                    	followingStackPointer_--;

                    	PushFollow(FOLLOW_expr_in_expr117);
                    	b = expr();
                    	followingStackPointer_--;

                    	
                    	Match(input, Token.UP, null); 
                    	 value =  a+b; 
                    
                    }
                    break;
                case 2 :
                    // Eval.g:26:9: ^( '-' a= expr b= expr )
                    {
                    	Match(input,10,FOLLOW_10_in_expr132); 
                    	
                    	Match(input, Token.DOWN, null); 
                    	PushFollow(FOLLOW_expr_in_expr136);
                    	a = expr();
                    	followingStackPointer_--;

                    	PushFollow(FOLLOW_expr_in_expr140);
                    	b = expr();
                    	followingStackPointer_--;

                    	
                    	Match(input, Token.UP, null); 
                    	 value =  a-b; 
                    
                    }
                    break;
                case 3 :
                    // Eval.g:27:9: ^( '*' a= expr b= expr )
                    {
                    	Match(input,11,FOLLOW_11_in_expr158); 
                    	
                    	Match(input, Token.DOWN, null); 
                    	PushFollow(FOLLOW_expr_in_expr162);
                    	a = expr();
                    	followingStackPointer_--;

                    	PushFollow(FOLLOW_expr_in_expr166);
                    	b = expr();
                    	followingStackPointer_--;

                    	
                    	Match(input, Token.UP, null); 
                    	 value =  a*b; 
                    
                    }
                    break;
                case 4 :
                    // Eval.g:28:9: ID
                    {
                    	ID4 = (CommonTree)input.LT(1);
                    	Match(input,ID,FOLLOW_ID_in_expr180); 
                    	
                    		        object obj = memory[ID4.Text];
                    		        if (obj != null){
                    		        	value =  (int)obj;
                    				} else {
                    		        	Console.WriteLine("undefined variable " + ID4.Text);
                    		        }
                    	        
                    
                    }
                    break;
                case 5 :
                    // Eval.g:37:9: integer= INT
                    {
                    	integer = (CommonTree)input.LT(1);
                    	Match(input,INT,FOLLOW_INT_in_expr203); 
                    	 value =  Int32.Parse(integer.Text); /* fix for 3.0b5 bug (will be fixed in next version so integer.Text works) */ 
                    
                    }
                    break;
            
            }
        }
        catch (RecognitionException re) 
    	{
            ReportError(re);
            Recover(input,re);
        }
        finally 
    	{
        }
        return value;
    }
    // $ANTLR end expr


	private void InitializeCyclicDFAs()
	{
	}

 

    public static readonly BitSet FOLLOW_stat_in_prog54 = new BitSet(new ulong[]{0x0000000000000F62UL});
    public static readonly BitSet FOLLOW_expr_in_stat65 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_8_in_stat78 = new BitSet(new ulong[]{0x0000000000000004UL});
    public static readonly BitSet FOLLOW_ID_in_stat80 = new BitSet(new ulong[]{0x0000000000000E60UL});
    public static readonly BitSet FOLLOW_expr_in_stat82 = new BitSet(new ulong[]{0x0000000000000008UL});
    public static readonly BitSet FOLLOW_9_in_expr109 = new BitSet(new ulong[]{0x0000000000000004UL});
    public static readonly BitSet FOLLOW_expr_in_expr113 = new BitSet(new ulong[]{0x0000000000000E60UL});
    public static readonly BitSet FOLLOW_expr_in_expr117 = new BitSet(new ulong[]{0x0000000000000008UL});
    public static readonly BitSet FOLLOW_10_in_expr132 = new BitSet(new ulong[]{0x0000000000000004UL});
    public static readonly BitSet FOLLOW_expr_in_expr136 = new BitSet(new ulong[]{0x0000000000000E60UL});
    public static readonly BitSet FOLLOW_expr_in_expr140 = new BitSet(new ulong[]{0x0000000000000008UL});
    public static readonly BitSet FOLLOW_11_in_expr158 = new BitSet(new ulong[]{0x0000000000000004UL});
    public static readonly BitSet FOLLOW_expr_in_expr162 = new BitSet(new ulong[]{0x0000000000000E60UL});
    public static readonly BitSet FOLLOW_expr_in_expr166 = new BitSet(new ulong[]{0x0000000000000008UL});
    public static readonly BitSet FOLLOW_ID_in_expr180 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_INT_in_expr203 = new BitSet(new ulong[]{0x0000000000000002UL});

}