NCalcParser.value C# (CSharp) Method

    public NCalcParser.value_return value()
    {
        NCalcParser.value_return retval = new NCalcParser.value_return();
        retval.Start = input.LT(1);

        CommonTree root_0 = null;

        IToken INTEGER35 = null;
        IToken FLOAT36 = null;
        IToken STRING37 = null;
        IToken DATETIME38 = null;
        IToken TRUE39 = null;
        IToken FALSE40 = null;

        CommonTree INTEGER35_tree=null;
        CommonTree FLOAT36_tree=null;
        CommonTree STRING37_tree=null;
        CommonTree DATETIME38_tree=null;
        CommonTree TRUE39_tree=null;
        CommonTree FALSE40_tree=null;

        try
        {
            // C:\\Users\\s.ros\\Documents\\Développement\\NCalc\\Grammar\\NCalc.g:208:2: ( INTEGER | FLOAT | STRING | DATETIME | TRUE | FALSE )
            int alt20 = 6;
            switch ( input.LA(1) )
            {
            case INTEGER:
                {
                alt20 = 1;
                }
                break;
            case FLOAT:
                {
                alt20 = 2;
                }
                break;
            case STRING:
                {
                alt20 = 3;
                }
                break;
            case DATETIME:
                {
                alt20 = 4;
                }
                break;
            case TRUE:
                {
                alt20 = 5;
                }
                break;
            case FALSE:
                {
                alt20 = 6;
                }
                break;
                default:
                    NoViableAltException nvae_d20s0 =
                        new NoViableAltException("", 20, 0, input);

                    throw nvae_d20s0;
            }

            switch (alt20)
            {
                case 1 :
                    // C:\\Users\\s.ros\\Documents\\Développement\\NCalc\\Grammar\\NCalc.g:208:5: INTEGER
                    {
                        root_0 = (CommonTree)adaptor.GetNilNode();

                        INTEGER35=(IToken)Match(input,INTEGER,FOLLOW_INTEGER_in_value876);
                            INTEGER35_tree = (CommonTree)adaptor.Create(INTEGER35);
                            adaptor.AddChild(root_0, INTEGER35_tree);

                            try
                            {
                                retval.value = new ValueExpression(int.Parse(((INTEGER35 != null) ? INTEGER35.Text : null)));
                            }
                            catch (System.OverflowException)
                            {
                                retval.value = new ValueExpression(long.Parse(((INTEGER35 != null) ? INTEGER35.Text : null)));
                            }

                    }
                    break;
                case 2 :
                    // C:\\Users\\s.ros\\Documents\\Développement\\NCalc\\Grammar\\NCalc.g:209:4: FLOAT
                    {
                        root_0 = (CommonTree)adaptor.GetNilNode();

                        FLOAT36=(IToken)Match(input,FLOAT,FOLLOW_FLOAT_in_value884);
                            FLOAT36_tree = (CommonTree)adaptor.Create(FLOAT36);
                            adaptor.AddChild(root_0, FLOAT36_tree);

                         retval.value =  new ValueExpression(double.Parse(((FLOAT36 != null) ? FLOAT36.Text : null), NumberStyles.Float, numberFormatInfo));

                    }
                    break;
                case 3 :
                    // C:\\Users\\s.ros\\Documents\\Développement\\NCalc\\Grammar\\NCalc.g:210:4: STRING
                    {
                        root_0 = (CommonTree)adaptor.GetNilNode();

                        STRING37=(IToken)Match(input,STRING,FOLLOW_STRING_in_value892);
                            STRING37_tree = (CommonTree)adaptor.Create(STRING37);
                            adaptor.AddChild(root_0, STRING37_tree);

                         retval.value =  new ValueExpression(extractString(((STRING37 != null) ? STRING37.Text : null)));

                    }
                    break;
                case 4 :
                    // C:\\Users\\s.ros\\Documents\\Développement\\NCalc\\Grammar\\NCalc.g:211:5: DATETIME
                    {
                        root_0 = (CommonTree)adaptor.GetNilNode();

                        DATETIME38=(IToken)Match(input,DATETIME,FOLLOW_DATETIME_in_value901);
                            DATETIME38_tree = (CommonTree)adaptor.Create(DATETIME38);
                            adaptor.AddChild(root_0, DATETIME38_tree);

                         retval.value =  new ValueExpression(DateTime.Parse(((DATETIME38 != null) ? DATETIME38.Text : null).Substring(1, ((DATETIME38 != null) ? DATETIME38.Text : null).Length-2)));

                    }
                    break;
                case 5 :
                    // C:\\Users\\s.ros\\Documents\\Développement\\NCalc\\Grammar\\NCalc.g:212:4: TRUE
                    {
                        root_0 = (CommonTree)adaptor.GetNilNode();

                        TRUE39=(IToken)Match(input,TRUE,FOLLOW_TRUE_in_value908);
                            TRUE39_tree = (CommonTree)adaptor.Create(TRUE39);
                            adaptor.AddChild(root_0, TRUE39_tree);

                         retval.value =  new ValueExpression(true);

                    }
                    break;
                case 6 :
                    // C:\\Users\\s.ros\\Documents\\Développement\\NCalc\\Grammar\\NCalc.g:213:4: FALSE
                    {
                        root_0 = (CommonTree)adaptor.GetNilNode();

                        FALSE40=(IToken)Match(input,FALSE,FOLLOW_FALSE_in_value916);
                            FALSE40_tree = (CommonTree)adaptor.Create(FALSE40);
                            adaptor.AddChild(root_0, FALSE40_tree);

                         retval.value =  new ValueExpression(false);

                    }
                    break;

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

                retval.Tree = (CommonTree)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 = (CommonTree)adaptor.ErrorNode(input, (IToken) retval.Start, input.LT(-1), re);

        }
        finally
        {
        }
        return retval;
    }