ES3Parser.literal C# (CSharp) Method

    public ES3Parser.literal_return literal() // throws RecognitionException [1]
    {   
        ES3Parser.literal_return retval = new ES3Parser.literal_return();
        retval.Start = input.LT(1);

        object root_0 = null;

        IToken exp1 = null;
        IToken exp4 = null;
        IToken exp5 = null;
        ES3Parser.booleanLiteral_return exp2 = default(ES3Parser.booleanLiteral_return);

        ES3Parser.numericLiteral_return exp3 = default(ES3Parser.numericLiteral_return);


        object exp1_tree=null;
        object exp4_tree=null;
        object exp5_tree=null;

        try 
    	{
            // C:\\Users\\s.ros\\Projets\\Jint\\Jint\\ES3.g:833:2: (exp1= NULL | exp2= booleanLiteral | exp3= numericLiteral | exp4= StringLiteral | exp5= RegularExpressionLiteral )
            int alt3 = 5;
            switch ( input.LA(1) ) 
            {
            case NULL:
            	{
                alt3 = 1;
                }
                break;
            case TRUE:
            case FALSE:
            	{
                alt3 = 2;
                }
                break;
            case DecimalLiteral:
            case OctalIntegerLiteral:
            case HexIntegerLiteral:
            	{
                alt3 = 3;
                }
                break;
            case StringLiteral:
            	{
                alt3 = 4;
                }
                break;
            case RegularExpressionLiteral:
            	{
                alt3 = 5;
                }
                break;
            	default:
            	    NoViableAltException nvae_d3s0 =
            	        new NoViableAltException("", 3, 0, input);

            	    throw nvae_d3s0;
            }

            switch (alt3) 
            {
                case 1 :
                    // C:\\Users\\s.ros\\Projets\\Jint\\Jint\\ES3.g:833:4: exp1= NULL
                    {
                    	root_0 = (object)adaptor.GetNilNode();

                    	exp1=(IToken)Match(input,NULL,FOLLOW_NULL_in_literal2484); 
                    		exp1_tree = (object)adaptor.Create(exp1);
                    		adaptor.AddChild(root_0, exp1_tree);

                    	 retval.value =  new Identifier(exp1.Text); 

                    }
                    break;
                case 2 :
                    // C:\\Users\\s.ros\\Projets\\Jint\\Jint\\ES3.g:834:4: exp2= booleanLiteral
                    {
                    	root_0 = (object)adaptor.GetNilNode();

                    	PushFollow(FOLLOW_booleanLiteral_in_literal2493);
                    	exp2 = booleanLiteral();
                    	state.followingStackPointer--;

                    	adaptor.AddChild(root_0, exp2.Tree);
                    	 retval.value =  new ValueExpression(exp2.value, TypeCode.Boolean); 

                    }
                    break;
                case 3 :
                    // C:\\Users\\s.ros\\Projets\\Jint\\Jint\\ES3.g:835:4: exp3= numericLiteral
                    {
                    	root_0 = (object)adaptor.GetNilNode();

                    	PushFollow(FOLLOW_numericLiteral_in_literal2502);
                    	exp3 = numericLiteral();
                    	state.followingStackPointer--;

                    	adaptor.AddChild(root_0, exp3.Tree);
                    	 retval.value =  new ValueExpression(exp3.value, TypeCode.Double); 

                    }
                    break;
                case 4 :
                    // C:\\Users\\s.ros\\Projets\\Jint\\Jint\\ES3.g:836:4: exp4= StringLiteral
                    {
                    	root_0 = (object)adaptor.GetNilNode();

                    	exp4=(IToken)Match(input,StringLiteral,FOLLOW_StringLiteral_in_literal2511); 
                    		exp4_tree = (object)adaptor.Create(exp4);
                    		adaptor.AddChild(root_0, exp4_tree);

                    	 retval.value =  new ValueExpression(extractString(exp4.Text), TypeCode.String); 

                    }
                    break;
                case 5 :
                    // C:\\Users\\s.ros\\Projets\\Jint\\Jint\\ES3.g:837:4: exp5= RegularExpressionLiteral
                    {
                    	root_0 = (object)adaptor.GetNilNode();

                    	exp5=(IToken)Match(input,RegularExpressionLiteral,FOLLOW_RegularExpressionLiteral_in_literal2521); 
                    		exp5_tree = (object)adaptor.Create(exp5);
                    		adaptor.AddChild(root_0, exp5_tree);

                    	 retval.value =  new RegexpExpression(extractRegExpPattern(exp5.Text), extractRegExpOption(exp5.Text)); 

                    }
                    break;

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

            	retval.Tree = (object)adaptor.RulePostProcessing(root_0);
            	adaptor.SetTokenBoundaries(retval.Tree, (IToken) retval.Start, (IToken) retval.Stop);
        }
        catch (RecognitionException re) 
    	{
            ReportError(re);
            Recover(input,re);
    	// Conversion of the second argument necessary, but harmless
    	retval.Tree = (object)adaptor.ErrorNode(input, (IToken) retval.Start, input.LT(-1), re);

        }
        finally 
    	{
        }
        return retval;
    }
    // $ANTLR end "literal"