NCalcParser.additiveExpression C# (CSharp) Method

    public NCalcParser.additiveExpression_return additiveExpression()
    {
        NCalcParser.additiveExpression_return retval = new NCalcParser.additiveExpression_return();
        retval.Start = input.LT(1);

        CommonTree root_0 = null;

        IToken char_literal18 = null;
        IToken char_literal19 = null;
        NCalcParser.multiplicativeExpression_return left = null;

        NCalcParser.multiplicativeExpression_return right = null;

        CommonTree char_literal18_tree=null;
        CommonTree char_literal19_tree=null;

        BinaryExpressionType type = BinaryExpressionType.Unknown;

        try
        {
            // C:\\Users\\s.ros\\Documents\\Développement\\NCalc\\Grammar\\NCalc.g:174:2: (left= multiplicativeExpression ( ( '+' | '-' ) right= multiplicativeExpression )* )
            // C:\\Users\\s.ros\\Documents\\Développement\\NCalc\\Grammar\\NCalc.g:174:4: left= multiplicativeExpression ( ( '+' | '-' ) right= multiplicativeExpression )*
            {
                root_0 = (CommonTree)adaptor.GetNilNode();

                PushFollow(FOLLOW_multiplicativeExpression_in_additiveExpression625);
                left = multiplicativeExpression();
                state.followingStackPointer--;

                adaptor.AddChild(root_0, left.Tree);
                 retval.value =  ((left != null) ? left.value : null);
                // C:\\Users\\s.ros\\Documents\\Développement\\NCalc\\Grammar\\NCalc.g:174:60: ( ( '+' | '-' ) right= multiplicativeExpression )*
                do
                {
                    int alt14 = 2;
                    int LA14_0 = input.LA(1);

                    if ( ((LA14_0 >= 38 && LA14_0 <= 39)) )
                    {
                        alt14 = 1;
                    }

                    switch (alt14)
                    {
                        case 1 :
                            // C:\\Users\\s.ros\\Documents\\Développement\\NCalc\\Grammar\\NCalc.g:175:4: ( '+' | '-' ) right= multiplicativeExpression
                            {
                                // C:\\Users\\s.ros\\Documents\\Développement\\NCalc\\Grammar\\NCalc.g:175:4: ( '+' | '-' )
                                int alt13 = 2;
                                int LA13_0 = input.LA(1);

                                if ( (LA13_0 == 38) )
                                {
                                    alt13 = 1;
                                }
                                else if ( (LA13_0 == 39) )
                                {
                                    alt13 = 2;
                                }
                                else
                                {
                                    NoViableAltException nvae_d13s0 =
                                        new NoViableAltException("", 13, 0, input);

                                    throw nvae_d13s0;
                                }
                                switch (alt13)
                                {
                                    case 1 :
                                        // C:\\Users\\s.ros\\Documents\\Développement\\NCalc\\Grammar\\NCalc.g:175:6: '+'
                                        {
                                            char_literal18=(IToken)Match(input,38,FOLLOW_38_in_additiveExpression636);
                                                char_literal18_tree = (CommonTree)adaptor.Create(char_literal18);
                                                adaptor.AddChild(root_0, char_literal18_tree);

                                             type = BinaryExpressionType.Plus;

                                        }
                                        break;
                                    case 2 :
                                        // C:\\Users\\s.ros\\Documents\\Développement\\NCalc\\Grammar\\NCalc.g:176:6: '-'
                                        {
                                            char_literal19=(IToken)Match(input,39,FOLLOW_39_in_additiveExpression646);
                                                char_literal19_tree = (CommonTree)adaptor.Create(char_literal19);
                                                adaptor.AddChild(root_0, char_literal19_tree);

                                             type = BinaryExpressionType.Minus;

                                        }
                                        break;

                                }

                                PushFollow(FOLLOW_multiplicativeExpression_in_additiveExpression658);
                                right = multiplicativeExpression();
                                state.followingStackPointer--;

                                adaptor.AddChild(root_0, right.Tree);
                                 retval.value =  new BinaryExpression(type, retval.value, ((right != null) ? right.value : null));

                            }
                            break;

                        default:
                            goto loop14;
                    }
                } while (true);

                loop14:
                    ;	// Stops C# compiler whining that label 'loop14' has no statements

            }

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