NCalcParser.unaryExpression C# (CSharp) Method

    public NCalcParser.unaryExpression_return unaryExpression()
    {
        NCalcParser.unaryExpression_return retval = new NCalcParser.unaryExpression_return();
        retval.Start = input.LT(1);

        CommonTree root_0 = null;

        IToken set24 = null;
        IToken char_literal26 = null;
        IToken char_literal28 = null;
        NCalcParser.primaryExpression_return primaryExpression23 = null;

        NCalcParser.primaryExpression_return primaryExpression25 = null;

        NCalcParser.primaryExpression_return primaryExpression27 = null;

        NCalcParser.primaryExpression_return primaryExpression29 = null;

        CommonTree set24_tree=null;
        CommonTree char_literal26_tree=null;
        CommonTree char_literal28_tree=null;

        try
        {
            // C:\\Users\\s.ros\\Documents\\Développement\\NCalc\\Grammar\\NCalc.g:195:2: ( primaryExpression | ( '!' | 'not' ) primaryExpression | ( '~' ) primaryExpression | '-' primaryExpression )
            int alt17 = 4;
            switch ( input.LA(1) )
            {
            case INTEGER:
            case FLOAT:
            case STRING:
            case DATETIME:
            case TRUE:
            case FALSE:
            case ID:
            case NAME:
            case 46:
                {
                alt17 = 1;
                }
                break;
            case 43:
            case 44:
                {
                alt17 = 2;
                }
                break;
            case 45:
                {
                alt17 = 3;
                }
                break;
            case 39:
                {
                alt17 = 4;
                }
                break;
                default:
                    NoViableAltException nvae_d17s0 =
                        new NoViableAltException("", 17, 0, input);

                    throw nvae_d17s0;
            }

            switch (alt17)
            {
                case 1 :
                    // C:\\Users\\s.ros\\Documents\\Développement\\NCalc\\Grammar\\NCalc.g:195:4: primaryExpression
                    {
                        root_0 = (CommonTree)adaptor.GetNilNode();

                        PushFollow(FOLLOW_primaryExpression_in_unaryExpression760);
                        primaryExpression23 = primaryExpression();
                        state.followingStackPointer--;

                        adaptor.AddChild(root_0, primaryExpression23.Tree);
                         retval.value =  ((primaryExpression23 != null) ? primaryExpression23.value : null);

                    }
                    break;
                case 2 :
                    // C:\\Users\\s.ros\\Documents\\Développement\\NCalc\\Grammar\\NCalc.g:196:8: ( '!' | 'not' ) primaryExpression
                    {
                        root_0 = (CommonTree)adaptor.GetNilNode();

                        set24 = (IToken)input.LT(1);
                        if ( (input.LA(1) >= 43 && input.LA(1) <= 44) )
                        {
                            input.Consume();
                            adaptor.AddChild(root_0, (CommonTree)adaptor.Create(set24));
                            state.errorRecovery = false;
                        }
                        else
                        {
                            MismatchedSetException mse = new MismatchedSetException(null,input);
                            throw mse;
                        }

                        PushFollow(FOLLOW_primaryExpression_in_unaryExpression779);
                        primaryExpression25 = primaryExpression();
                        state.followingStackPointer--;

                        adaptor.AddChild(root_0, primaryExpression25.Tree);
                         retval.value =  new UnaryExpression(UnaryExpressionType.Not, ((primaryExpression25 != null) ? primaryExpression25.value : null));

                    }
                    break;
                case 3 :
                    // C:\\Users\\s.ros\\Documents\\Développement\\NCalc\\Grammar\\NCalc.g:197:8: ( '~' ) primaryExpression
                    {
                        root_0 = (CommonTree)adaptor.GetNilNode();

                        // C:\\Users\\s.ros\\Documents\\Développement\\NCalc\\Grammar\\NCalc.g:197:8: ( '~' )
                        // C:\\Users\\s.ros\\Documents\\Développement\\NCalc\\Grammar\\NCalc.g:197:9: '~'
                        {
                            char_literal26=(IToken)Match(input,45,FOLLOW_45_in_unaryExpression791);
                                char_literal26_tree = (CommonTree)adaptor.Create(char_literal26);
                                adaptor.AddChild(root_0, char_literal26_tree);

                        }

                        PushFollow(FOLLOW_primaryExpression_in_unaryExpression794);
                        primaryExpression27 = primaryExpression();
                        state.followingStackPointer--;

                        adaptor.AddChild(root_0, primaryExpression27.Tree);
                         retval.value =  new UnaryExpression(UnaryExpressionType.BitwiseNot, ((primaryExpression27 != null) ? primaryExpression27.value : null));

                    }
                    break;
                case 4 :
                    // C:\\Users\\s.ros\\Documents\\Développement\\NCalc\\Grammar\\NCalc.g:198:8: '-' primaryExpression
                    {
                        root_0 = (CommonTree)adaptor.GetNilNode();

                        char_literal28=(IToken)Match(input,39,FOLLOW_39_in_unaryExpression805);
                            char_literal28_tree = (CommonTree)adaptor.Create(char_literal28);
                            adaptor.AddChild(root_0, char_literal28_tree);

                        PushFollow(FOLLOW_primaryExpression_in_unaryExpression807);
                        primaryExpression29 = primaryExpression();
                        state.followingStackPointer--;

                        adaptor.AddChild(root_0, primaryExpression29.Tree);
                         retval.value =  new UnaryExpression(UnaryExpressionType.Negate, ((primaryExpression29 != null) ? primaryExpression29.value : null));

                    }
                    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;
    }