UnityGame/Library/PackageCache/com.unity.visualscripting/Runtime/VisualScripting.Flow/Dependencies/NCalc/NCalcParser.cs

#pragma warning disable 219
// $ANTLR 3.2 Sep 23, 2009 12:02:23 C:\\Users\\s.ros\\Documents\\D<>veloppement\\NCalc\\Grammar\\NCalc.g 2009-11-11 17:56:42

using System;
using System.Collections.Generic;
using System.Globalization;
using System.Text;
using Unity.VisualScripting.Antlr3.Runtime;
using Unity.VisualScripting.Antlr3.Runtime.Tree;

namespace Unity.VisualScripting.Dependencies.NCalc
{
    public class NCalcParser : Parser
    {
        // delegates
        // delegators

        public NCalcParser(ITokenStream input)
            : this(input, new RecognizerSharedState()) { }

        public NCalcParser(ITokenStream input, RecognizerSharedState state)
            : base(input, state)
        {
            InitializeCyclicDFAs();
        }

        protected ITreeAdaptor adaptor = new CommonTreeAdaptor();

        public ITreeAdaptor TreeAdaptor
        {
            get
            {
                return adaptor;
            }
            set
            {
                adaptor = value;
            }
        }

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

        override public string GrammarFileName
        {
            get
            {
                return "C:\\Users\\s.ros\\Documents\\D<>veloppement\\NCalc\\Grammar\\NCalc.g";
            }
        }

        public List<string> Errors { get; private set; }

        // $ANTLR end "arguments"

        // Delegated rules

        private void InitializeCyclicDFAs() { }

        private string extractString(string text)
        {
            var sb = new StringBuilder(text);
            var startIndex = 1; // Skip initial quote
            var slashIndex = -1;

            while ((slashIndex = sb.ToString().IndexOf(BS, startIndex)) != -1)
            {
                var escapeType = sb[slashIndex + 1];
                switch (escapeType)
                {
                    case 'u':
                        var hcode = String.Concat(sb[slashIndex + 4], sb[slashIndex + 5]);
                        var lcode = String.Concat(sb[slashIndex + 2], sb[slashIndex + 3]);
                        var unicodeChar = Encoding.Unicode.GetChars(new[] { Convert.ToByte(hcode, 16), Convert.ToByte(lcode, 16) })[0];
                        sb.Remove(slashIndex, 6).Insert(slashIndex, unicodeChar);
                        break;
                    case 'n':
                        sb.Remove(slashIndex, 2).Insert(slashIndex, '\n');
                        break;
                    case 'r':
                        sb.Remove(slashIndex, 2).Insert(slashIndex, '\r');
                        break;
                    case 't':
                        sb.Remove(slashIndex, 2).Insert(slashIndex, '\t');
                        break;
                    case '\'':
                        sb.Remove(slashIndex, 2).Insert(slashIndex, '\'');
                        break;
                    case '\\':
                        sb.Remove(slashIndex, 2).Insert(slashIndex, '\\');
                        break;
                    default:
                        throw new RecognitionException("Unvalid escape sequence: \\" + escapeType);
                }

                startIndex = slashIndex + 1;
            }

            sb.Remove(0, 1);
            sb.Remove(sb.Length - 1, 1);

            return sb.ToString();
        }

        public override void DisplayRecognitionError(String[] tokenNames, RecognitionException e)
        {
            base.DisplayRecognitionError(tokenNames, e);

            if (Errors == null)
            {
                Errors = new List<string>();
            }

            var hdr = GetErrorHeader(e);
            var msg = GetErrorMessage(e, tokenNames);
            Errors.Add(msg + " at " + hdr);
        }

        // $ANTLR start "ncalcExpression"
        // C:\\Users\\s.ros\\Documents\\D<>veloppement\\NCalc\\Grammar\\NCalc.g:77:1: ncalcExpression returns [LogicalExpression value] : logicalExpression EOF ;
        public ncalcExpression_return ncalcExpression() // throws RecognitionException [1]
        {
            var retval = new ncalcExpression_return();
            retval.Start = input.LT(1);

            CommonTree root_0 = null;

            IToken EOF2 = null;
            logicalExpression_return logicalExpression1 = null;

            CommonTree EOF2_tree = null;

            try
            {
                // C:\\Users\\s.ros\\Documents\\D<>veloppement\\NCalc\\Grammar\\NCalc.g:78:2: ( logicalExpression EOF )
                // C:\\Users\\s.ros\\Documents\\D<>veloppement\\NCalc\\Grammar\\NCalc.g:78:4: logicalExpression EOF
                {
                    root_0 = (CommonTree)adaptor.GetNilNode();

                    PushFollow(FOLLOW_logicalExpression_in_ncalcExpression56);
                    logicalExpression1 = logicalExpression();
                    state.followingStackPointer--;

                    adaptor.AddChild(root_0, logicalExpression1.Tree);
                    EOF2 = (IToken)Match(input, EOF, FOLLOW_EOF_in_ncalcExpression58);
                    retval.value = logicalExpression1 != null ? logicalExpression1.value : null;
                }

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

        // $ANTLR start "logicalExpression"
        // C:\\Users\\s.ros\\Documents\\D<>veloppement\\NCalc\\Grammar\\NCalc.g:81:1: logicalExpression returns [LogicalExpression value] : left= conditionalExpression ( '?' middle= conditionalExpression ':' right= conditionalExpression )? ;
        public logicalExpression_return logicalExpression() // throws RecognitionException [1]
        {
            var retval = new logicalExpression_return();
            retval.Start = input.LT(1);

            CommonTree root_0 = null;

            IToken char_literal3 = null;
            IToken char_literal4 = null;
            conditionalExpression_return left = null;

            conditionalExpression_return middle = null;

            conditionalExpression_return right = null;

            CommonTree char_literal3_tree = null;
            CommonTree char_literal4_tree = null;

            try
            {
                // C:\\Users\\s.ros\\Documents\\D<>veloppement\\NCalc\\Grammar\\NCalc.g:82:2: (left= conditionalExpression ( '?' middle= conditionalExpression ':' right= conditionalExpression )? )
                // C:\\Users\\s.ros\\Documents\\D<>veloppement\\NCalc\\Grammar\\NCalc.g:82:4: left= conditionalExpression ( '?' middle= conditionalExpression ':' right= conditionalExpression )?
                {
                    root_0 = (CommonTree)adaptor.GetNilNode();

                    PushFollow(FOLLOW_conditionalExpression_in_logicalExpression78);
                    left = conditionalExpression();
                    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:82:57: ( '?' middle= conditionalExpression ':' right= conditionalExpression )?
                    var alt1 = 2;
                    var LA1_0 = input.LA(1);

                    if (LA1_0 == 19)
                    {
                        alt1 = 1;
                    }
                    switch (alt1)
                    {
                        case 1:
                            // C:\\Users\\s.ros\\Documents\\D<>veloppement\\NCalc\\Grammar\\NCalc.g:82:59: '?' middle= conditionalExpression ':' right= conditionalExpression
                            {
                                char_literal3 = (IToken)Match(input, 19, FOLLOW_19_in_logicalExpression84);
                                char_literal3_tree = (CommonTree)adaptor.Create(char_literal3);
                                adaptor.AddChild(root_0, char_literal3_tree);

                                PushFollow(FOLLOW_conditionalExpression_in_logicalExpression88);
                                middle = conditionalExpression();
                                state.followingStackPointer--;

                                adaptor.AddChild(root_0, middle.Tree);
                                char_literal4 = (IToken)Match(input, 20, FOLLOW_20_in_logicalExpression90);
                                char_literal4_tree = (CommonTree)adaptor.Create(char_literal4);
                                adaptor.AddChild(root_0, char_literal4_tree);

                                PushFollow(FOLLOW_conditionalExpression_in_logicalExpression94);
                                right = conditionalExpression();
                                state.followingStackPointer--;

                                adaptor.AddChild(root_0, right.Tree);
                                retval.value = new TernaryExpression(left != null ? left.value : null, middle != null ? middle.value : null, right != null ? right.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;
        }

        // $ANTLR start "conditionalExpression"
        // C:\\Users\\s.ros\\Documents\\D<>veloppement\\NCalc\\Grammar\\NCalc.g:85:1: conditionalExpression returns [LogicalExpression value] : left= booleanAndExpression ( ( '||' | 'or' ) right= conditionalExpression )* ;
        public conditionalExpression_return conditionalExpression() // throws RecognitionException [1]
        {
            var retval = new conditionalExpression_return();
            retval.Start = input.LT(1);

            CommonTree root_0 = null;

            IToken set5 = null;
            booleanAndExpression_return left = null;

            conditionalExpression_return right = null;

            CommonTree set5_tree = null;

            var type = BinaryExpressionType.Unknown;

            try
            {
                // C:\\Users\\s.ros\\Documents\\D<>veloppement\\NCalc\\Grammar\\NCalc.g:89:2: (left= booleanAndExpression ( ( '||' | 'or' ) right= conditionalExpression )* )
                // C:\\Users\\s.ros\\Documents\\D<>veloppement\\NCalc\\Grammar\\NCalc.g:89:4: left= booleanAndExpression ( ( '||' | 'or' ) right= conditionalExpression )*
                {
                    root_0 = (CommonTree)adaptor.GetNilNode();

                    PushFollow(FOLLOW_booleanAndExpression_in_conditionalExpression121);
                    left = booleanAndExpression();
                    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:89:56: ( ( '||' | 'or' ) right= conditionalExpression )*
                    do
                    {
                        var alt2 = 2;
                        var LA2_0 = input.LA(1);

                        if (LA2_0 >= 21 && LA2_0 <= 22)
                        {
                            alt2 = 1;
                        }

                        switch (alt2)
                        {
                            case 1:
                                // C:\\Users\\s.ros\\Documents\\D<>veloppement\\NCalc\\Grammar\\NCalc.g:90:4: ( '||' | 'or' ) right= conditionalExpression
                                {
                                    set5 = (IToken)input.LT(1);
                                    if (input.LA(1) >= 21 && input.LA(1) <= 22)
                                    {
                                        input.Consume();
                                        adaptor.AddChild(root_0, (CommonTree)adaptor.Create(set5));
                                        state.errorRecovery = false;
                                    }
                                    else
                                    {
                                        var mse = new MismatchedSetException(null, input);
                                        throw mse;
                                    }

                                    type = BinaryExpressionType.Or;
                                    PushFollow(FOLLOW_conditionalExpression_in_conditionalExpression146);
                                    right = conditionalExpression();
                                    state.followingStackPointer--;

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

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

                loop2:
                    ; // Stops C# compiler whining that label 'loop2' 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;
        }

        // $ANTLR start "booleanAndExpression"
        // C:\\Users\\s.ros\\Documents\\D<>veloppement\\NCalc\\Grammar\\NCalc.g:95:1: booleanAndExpression returns [LogicalExpression value] : left= bitwiseOrExpression ( ( '&&' | 'and' ) right= bitwiseOrExpression )* ;
        public booleanAndExpression_return booleanAndExpression() // throws RecognitionException [1]
        {
            var retval = new booleanAndExpression_return();
            retval.Start = input.LT(1);

            CommonTree root_0 = null;

            IToken set6 = null;
            bitwiseOrExpression_return left = null;

            bitwiseOrExpression_return right = null;

            CommonTree set6_tree = null;

            var type = BinaryExpressionType.Unknown;

            try
            {
                // C:\\Users\\s.ros\\Documents\\D<>veloppement\\NCalc\\Grammar\\NCalc.g:99:2: (left= bitwiseOrExpression ( ( '&&' | 'and' ) right= bitwiseOrExpression )* )
                // C:\\Users\\s.ros\\Documents\\D<>veloppement\\NCalc\\Grammar\\NCalc.g:99:4: left= bitwiseOrExpression ( ( '&&' | 'and' ) right= bitwiseOrExpression )*
                {
                    root_0 = (CommonTree)adaptor.GetNilNode();

                    PushFollow(FOLLOW_bitwiseOrExpression_in_booleanAndExpression180);
                    left = bitwiseOrExpression();
                    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:99:55: ( ( '&&' | 'and' ) right= bitwiseOrExpression )*
                    do
                    {
                        var alt3 = 2;
                        var LA3_0 = input.LA(1);

                        if (LA3_0 >= 23 && LA3_0 <= 24)
                        {
                            alt3 = 1;
                        }

                        switch (alt3)
                        {
                            case 1:
                                // C:\\Users\\s.ros\\Documents\\D<>veloppement\\NCalc\\Grammar\\NCalc.g:100:4: ( '&&' | 'and' ) right= bitwiseOrExpression
                                {
                                    set6 = (IToken)input.LT(1);
                                    if (input.LA(1) >= 23 && input.LA(1) <= 24)
                                    {
                                        input.Consume();
                                        adaptor.AddChild(root_0, (CommonTree)adaptor.Create(set6));
                                        state.errorRecovery = false;
                                    }
                                    else
                                    {
                                        var mse = new MismatchedSetException(null, input);
                                        throw mse;
                                    }

                                    type = BinaryExpressionType.And;
                                    PushFollow(FOLLOW_bitwiseOrExpression_in_booleanAndExpression205);
                                    right = bitwiseOrExpression();
                                    state.followingStackPointer--;

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

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

                loop3:
                    ; // Stops C# compiler whining that label 'loop3' 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;
        }

        // $ANTLR start "bitwiseOrExpression"
        // C:\\Users\\s.ros\\Documents\\D<>veloppement\\NCalc\\Grammar\\NCalc.g:105:1: bitwiseOrExpression returns [LogicalExpression value] : left= bitwiseXOrExpression ( '|' right= bitwiseOrExpression )* ;
        public bitwiseOrExpression_return bitwiseOrExpression() // throws RecognitionException [1]
        {
            var retval = new bitwiseOrExpression_return();
            retval.Start = input.LT(1);

            CommonTree root_0 = null;

            IToken char_literal7 = null;
            bitwiseXOrExpression_return left = null;

            bitwiseOrExpression_return right = null;

            CommonTree char_literal7_tree = null;

            var type = BinaryExpressionType.Unknown;

            try
            {
                // C:\\Users\\s.ros\\Documents\\D<>veloppement\\NCalc\\Grammar\\NCalc.g:109:2: (left= bitwiseXOrExpression ( '|' right= bitwiseOrExpression )* )
                // C:\\Users\\s.ros\\Documents\\D<>veloppement\\NCalc\\Grammar\\NCalc.g:109:4: left= bitwiseXOrExpression ( '|' right= bitwiseOrExpression )*
                {
                    root_0 = (CommonTree)adaptor.GetNilNode();

                    PushFollow(FOLLOW_bitwiseXOrExpression_in_bitwiseOrExpression237);
                    left = bitwiseXOrExpression();
                    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:109:56: ( '|' right= bitwiseOrExpression )*
                    do
                    {
                        var alt4 = 2;
                        var LA4_0 = input.LA(1);

                        if (LA4_0 == 25)
                        {
                            alt4 = 1;
                        }

                        switch (alt4)
                        {
                            case 1:
                                // C:\\Users\\s.ros\\Documents\\D<>veloppement\\NCalc\\Grammar\\NCalc.g:110:4: '|' right= bitwiseOrExpression
                                {
                                    char_literal7 = (IToken)Match(input, 25, FOLLOW_25_in_bitwiseOrExpression246);
                                    char_literal7_tree = (CommonTree)adaptor.Create(char_literal7);
                                    adaptor.AddChild(root_0, char_literal7_tree);

                                    type = BinaryExpressionType.BitwiseOr;
                                    PushFollow(FOLLOW_bitwiseOrExpression_in_bitwiseOrExpression256);
                                    right = bitwiseOrExpression();
                                    state.followingStackPointer--;

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

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

                loop4:
                    ; // Stops C# compiler whining that label 'loop4' 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;
        }

        // $ANTLR start "bitwiseXOrExpression"
        // C:\\Users\\s.ros\\Documents\\D<>veloppement\\NCalc\\Grammar\\NCalc.g:115:1: bitwiseXOrExpression returns [LogicalExpression value] : left= bitwiseAndExpression ( '^' right= bitwiseAndExpression )* ;
        public bitwiseXOrExpression_return bitwiseXOrExpression() // throws RecognitionException [1]
        {
            var retval = new bitwiseXOrExpression_return();
            retval.Start = input.LT(1);

            CommonTree root_0 = null;

            IToken char_literal8 = null;
            bitwiseAndExpression_return left = null;

            bitwiseAndExpression_return right = null;

            CommonTree char_literal8_tree = null;

            var type = BinaryExpressionType.Unknown;

            try
            {
                // C:\\Users\\s.ros\\Documents\\D<>veloppement\\NCalc\\Grammar\\NCalc.g:119:2: (left= bitwiseAndExpression ( '^' right= bitwiseAndExpression )* )
                // C:\\Users\\s.ros\\Documents\\D<>veloppement\\NCalc\\Grammar\\NCalc.g:119:4: left= bitwiseAndExpression ( '^' right= bitwiseAndExpression )*
                {
                    root_0 = (CommonTree)adaptor.GetNilNode();

                    PushFollow(FOLLOW_bitwiseAndExpression_in_bitwiseXOrExpression290);
                    left = bitwiseAndExpression();
                    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:119:56: ( '^' right= bitwiseAndExpression )*
                    do
                    {
                        var alt5 = 2;
                        var LA5_0 = input.LA(1);

                        if (LA5_0 == 26)
                        {
                            alt5 = 1;
                        }

                        switch (alt5)
                        {
                            case 1:
                                // C:\\Users\\s.ros\\Documents\\D<>veloppement\\NCalc\\Grammar\\NCalc.g:120:4: '^' right= bitwiseAndExpression
                                {
                                    char_literal8 = (IToken)Match(input, 26, FOLLOW_26_in_bitwiseXOrExpression299);
                                    char_literal8_tree = (CommonTree)adaptor.Create(char_literal8);
                                    adaptor.AddChild(root_0, char_literal8_tree);

                                    type = BinaryExpressionType.BitwiseXOr;
                                    PushFollow(FOLLOW_bitwiseAndExpression_in_bitwiseXOrExpression309);
                                    right = bitwiseAndExpression();
                                    state.followingStackPointer--;

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

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

                loop5:
                    ; // Stops C# compiler whining that label 'loop5' 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;
        }

        // $ANTLR start "bitwiseAndExpression"
        // C:\\Users\\s.ros\\Documents\\D<>veloppement\\NCalc\\Grammar\\NCalc.g:125:1: bitwiseAndExpression returns [LogicalExpression value] : left= equalityExpression ( '&' right= equalityExpression )* ;
        public bitwiseAndExpression_return bitwiseAndExpression() // throws RecognitionException [1]
        {
            var retval = new bitwiseAndExpression_return();
            retval.Start = input.LT(1);

            CommonTree root_0 = null;

            IToken char_literal9 = null;
            equalityExpression_return left = null;

            equalityExpression_return right = null;

            CommonTree char_literal9_tree = null;

            var type = BinaryExpressionType.Unknown;

            try
            {
                // C:\\Users\\s.ros\\Documents\\D<>veloppement\\NCalc\\Grammar\\NCalc.g:129:2: (left= equalityExpression ( '&' right= equalityExpression )* )
                // C:\\Users\\s.ros\\Documents\\D<>veloppement\\NCalc\\Grammar\\NCalc.g:129:4: left= equalityExpression ( '&' right= equalityExpression )*
                {
                    root_0 = (CommonTree)adaptor.GetNilNode();

                    PushFollow(FOLLOW_equalityExpression_in_bitwiseAndExpression341);
                    left = equalityExpression();
                    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:129:54: ( '&' right= equalityExpression )*
                    do
                    {
                        var alt6 = 2;
                        var LA6_0 = input.LA(1);

                        if (LA6_0 == 27)
                        {
                            alt6 = 1;
                        }

                        switch (alt6)
                        {
                            case 1:
                                // C:\\Users\\s.ros\\Documents\\D<>veloppement\\NCalc\\Grammar\\NCalc.g:130:4: '&' right= equalityExpression
                                {
                                    char_literal9 = (IToken)Match(input, 27, FOLLOW_27_in_bitwiseAndExpression350);
                                    char_literal9_tree = (CommonTree)adaptor.Create(char_literal9);
                                    adaptor.AddChild(root_0, char_literal9_tree);

                                    type = BinaryExpressionType.BitwiseAnd;
                                    PushFollow(FOLLOW_equalityExpression_in_bitwiseAndExpression360);
                                    right = equalityExpression();
                                    state.followingStackPointer--;

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

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

                loop6:
                    ; // Stops C# compiler whining that label 'loop6' 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;
        }

        // $ANTLR start "equalityExpression"
        // C:\\Users\\s.ros\\Documents\\D<>veloppement\\NCalc\\Grammar\\NCalc.g:135:1: equalityExpression returns [LogicalExpression value] : left= relationalExpression ( ( ( '==' | '=' ) | ( '!=' | '<>' ) ) right= relationalExpression )* ;
        public equalityExpression_return equalityExpression() // throws RecognitionException [1]
        {
            var retval = new equalityExpression_return();
            retval.Start = input.LT(1);

            CommonTree root_0 = null;

            IToken set10 = null;
            IToken set11 = null;
            relationalExpression_return left = null;

            relationalExpression_return right = null;

            CommonTree set10_tree = null;
            CommonTree set11_tree = null;

            var type = BinaryExpressionType.Unknown;

            try
            {
                // C:\\Users\\s.ros\\Documents\\D<>veloppement\\NCalc\\Grammar\\NCalc.g:139:2: (left= relationalExpression ( ( ( '==' | '=' ) | ( '!=' | '<>' ) ) right= relationalExpression )* )
                // C:\\Users\\s.ros\\Documents\\D<>veloppement\\NCalc\\Grammar\\NCalc.g:139:4: left= relationalExpression ( ( ( '==' | '=' ) | ( '!=' | '<>' ) ) right= relationalExpression )*
                {
                    root_0 = (CommonTree)adaptor.GetNilNode();

                    PushFollow(FOLLOW_relationalExpression_in_equalityExpression394);
                    left = relationalExpression();
                    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:139:56: ( ( ( '==' | '=' ) | ( '!=' | '<>' ) ) right= relationalExpression )*
                    do
                    {
                        var alt8 = 2;
                        var LA8_0 = input.LA(1);

                        if (LA8_0 >= 28 && LA8_0 <= 31)
                        {
                            alt8 = 1;
                        }

                        switch (alt8)
                        {
                            case 1:
                                // C:\\Users\\s.ros\\Documents\\D<>veloppement\\NCalc\\Grammar\\NCalc.g:140:4: ( ( '==' | '=' ) | ( '!=' | '<>' ) ) right= relationalExpression
                                {
                                    // C:\\Users\\s.ros\\Documents\\D<>veloppement\\NCalc\\Grammar\\NCalc.g:140:4: ( ( '==' | '=' ) | ( '!=' | '<>' ) )
                                    var alt7 = 2;
                                    var LA7_0 = input.LA(1);

                                    if (LA7_0 >= 28 && LA7_0 <= 29)
                                    {
                                        alt7 = 1;
                                    }
                                    else if (LA7_0 >= 30 && LA7_0 <= 31)
                                    {
                                        alt7 = 2;
                                    }
                                    else
                                    {
                                        var nvae_d7s0 =
                                            new NoViableAltException("", 7, 0, input);

                                        throw nvae_d7s0;
                                    }
                                    switch (alt7)
                                    {
                                        case 1:
                                            // C:\\Users\\s.ros\\Documents\\D<>veloppement\\NCalc\\Grammar\\NCalc.g:140:6: ( '==' | '=' )
                                            {
                                                set10 = (IToken)input.LT(1);
                                                if (input.LA(1) >= 28 && input.LA(1) <= 29)
                                                {
                                                    input.Consume();
                                                    adaptor.AddChild(root_0, (CommonTree)adaptor.Create(set10));
                                                    state.errorRecovery = false;
                                                }
                                                else
                                                {
                                                    var mse = new MismatchedSetException(null, input);
                                                    throw mse;
                                                }

                                                type = BinaryExpressionType.Equal;
                                            }
                                            break;
                                        case 2:
                                            // C:\\Users\\s.ros\\Documents\\D<>veloppement\\NCalc\\Grammar\\NCalc.g:141:6: ( '!=' | '<>' )
                                            {
                                                set11 = (IToken)input.LT(1);
                                                if (input.LA(1) >= 30 && input.LA(1) <= 31)
                                                {
                                                    input.Consume();
                                                    adaptor.AddChild(root_0, (CommonTree)adaptor.Create(set11));
                                                    state.errorRecovery = false;
                                                }
                                                else
                                                {
                                                    var mse = new MismatchedSetException(null, input);
                                                    throw mse;
                                                }

                                                type = BinaryExpressionType.NotEqual;
                                            }
                                            break;
                                    }

                                    PushFollow(FOLLOW_relationalExpression_in_equalityExpression441);
                                    right = relationalExpression();
                                    state.followingStackPointer--;

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

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

                loop8:
                    ; // Stops C# compiler whining that label 'loop8' 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;
        }

        // $ANTLR start "relationalExpression"
        // C:\\Users\\s.ros\\Documents\\D<>veloppement\\NCalc\\Grammar\\NCalc.g:146:1: relationalExpression returns [LogicalExpression value] : left= shiftExpression ( ( '<' | '<=' | '>' | '>=' ) right= shiftExpression )* ;
        public relationalExpression_return relationalExpression() // throws RecognitionException [1]
        {
            var retval = new relationalExpression_return();
            retval.Start = input.LT(1);

            CommonTree root_0 = null;

            IToken char_literal12 = null;
            IToken string_literal13 = null;
            IToken char_literal14 = null;
            IToken string_literal15 = null;
            shiftExpression_return left = null;

            shiftExpression_return right = null;

            CommonTree char_literal12_tree = null;
            CommonTree string_literal13_tree = null;
            CommonTree char_literal14_tree = null;
            CommonTree string_literal15_tree = null;

            var type = BinaryExpressionType.Unknown;

            try
            {
                // C:\\Users\\s.ros\\Documents\\D<>veloppement\\NCalc\\Grammar\\NCalc.g:150:2: (left= shiftExpression ( ( '<' | '<=' | '>' | '>=' ) right= shiftExpression )* )
                // C:\\Users\\s.ros\\Documents\\D<>veloppement\\NCalc\\Grammar\\NCalc.g:150:4: left= shiftExpression ( ( '<' | '<=' | '>' | '>=' ) right= shiftExpression )*
                {
                    root_0 = (CommonTree)adaptor.GetNilNode();

                    PushFollow(FOLLOW_shiftExpression_in_relationalExpression474);
                    left = shiftExpression();
                    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:150:51: ( ( '<' | '<=' | '>' | '>=' ) right= shiftExpression )*
                    do
                    {
                        var alt10 = 2;
                        var LA10_0 = input.LA(1);

                        if (LA10_0 >= 32 && LA10_0 <= 35)
                        {
                            alt10 = 1;
                        }

                        switch (alt10)
                        {
                            case 1:
                                // C:\\Users\\s.ros\\Documents\\D<>veloppement\\NCalc\\Grammar\\NCalc.g:151:4: ( '<' | '<=' | '>' | '>=' ) right= shiftExpression
                                {
                                    // C:\\Users\\s.ros\\Documents\\D<>veloppement\\NCalc\\Grammar\\NCalc.g:151:4: ( '<' | '<=' | '>' | '>=' )
                                    var alt9 = 4;
                                    switch (input.LA(1))
                                    {
                                        case 32:
                                            {
                                                alt9 = 1;
                                            }
                                            break;
                                        case 33:
                                            {
                                                alt9 = 2;
                                            }
                                            break;
                                        case 34:
                                            {
                                                alt9 = 3;
                                            }
                                            break;
                                        case 35:
                                            {
                                                alt9 = 4;
                                            }
                                            break;
                                        default:
                                            var nvae_d9s0 =
                                                new NoViableAltException("", 9, 0, input);

                                            throw nvae_d9s0;
                                    }

                                    switch (alt9)
                                    {
                                        case 1:
                                            // C:\\Users\\s.ros\\Documents\\D<>veloppement\\NCalc\\Grammar\\NCalc.g:151:6: '<'
                                            {
                                                char_literal12 = (IToken)Match(input, 32, FOLLOW_32_in_relationalExpression485);
                                                char_literal12_tree = (CommonTree)adaptor.Create(char_literal12);
                                                adaptor.AddChild(root_0, char_literal12_tree);

                                                type = BinaryExpressionType.Lesser;
                                            }
                                            break;
                                        case 2:
                                            // C:\\Users\\s.ros\\Documents\\D<>veloppement\\NCalc\\Grammar\\NCalc.g:152:6: '<='
                                            {
                                                string_literal13 = (IToken)Match(input, 33, FOLLOW_33_in_relationalExpression495);
                                                string_literal13_tree = (CommonTree)adaptor.Create(string_literal13);
                                                adaptor.AddChild(root_0, string_literal13_tree);

                                                type = BinaryExpressionType.LesserOrEqual;
                                            }
                                            break;
                                        case 3:
                                            // C:\\Users\\s.ros\\Documents\\D<>veloppement\\NCalc\\Grammar\\NCalc.g:153:6: '>'
                                            {
                                                char_literal14 = (IToken)Match(input, 34, FOLLOW_34_in_relationalExpression506);
                                                char_literal14_tree = (CommonTree)adaptor.Create(char_literal14);
                                                adaptor.AddChild(root_0, char_literal14_tree);

                                                type = BinaryExpressionType.Greater;
                                            }
                                            break;
                                        case 4:
                                            // C:\\Users\\s.ros\\Documents\\D<>veloppement\\NCalc\\Grammar\\NCalc.g:154:6: '>='
                                            {
                                                string_literal15 = (IToken)Match(input, 35, FOLLOW_35_in_relationalExpression516);
                                                string_literal15_tree = (CommonTree)adaptor.Create(string_literal15);
                                                adaptor.AddChild(root_0, string_literal15_tree);

                                                type = BinaryExpressionType.GreaterOrEqual;
                                            }
                                            break;
                                    }

                                    PushFollow(FOLLOW_shiftExpression_in_relationalExpression528);
                                    right = shiftExpression();
                                    state.followingStackPointer--;

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

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

                loop10:
                    ; // Stops C# compiler whining that label 'loop10' 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;
        }

        // $ANTLR start "shiftExpression"
        // C:\\Users\\s.ros\\Documents\\D<>veloppement\\NCalc\\Grammar\\NCalc.g:159:1: shiftExpression returns [LogicalExpression value] : left= additiveExpression ( ( '<<' | '>>' ) right= additiveExpression )* ;
        public shiftExpression_return shiftExpression() // throws RecognitionException [1]
        {
            var retval = new shiftExpression_return();
            retval.Start = input.LT(1);

            CommonTree root_0 = null;

            IToken string_literal16 = null;
            IToken string_literal17 = null;
            additiveExpression_return left = null;

            additiveExpression_return right = null;

            CommonTree string_literal16_tree = null;
            CommonTree string_literal17_tree = null;

            var type = BinaryExpressionType.Unknown;

            try
            {
                // C:\\Users\\s.ros\\Documents\\D<>veloppement\\NCalc\\Grammar\\NCalc.g:163:2: (left= additiveExpression ( ( '<<' | '>>' ) right= additiveExpression )* )
                // C:\\Users\\s.ros\\Documents\\D<>veloppement\\NCalc\\Grammar\\NCalc.g:163:4: left= additiveExpression ( ( '<<' | '>>' ) right= additiveExpression )*
                {
                    root_0 = (CommonTree)adaptor.GetNilNode();

                    PushFollow(FOLLOW_additiveExpression_in_shiftExpression560);
                    left = additiveExpression();
                    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:163:54: ( ( '<<' | '>>' ) right= additiveExpression )*
                    do
                    {
                        var alt12 = 2;
                        var LA12_0 = input.LA(1);

                        if (LA12_0 >= 36 && LA12_0 <= 37)
                        {
                            alt12 = 1;
                        }

                        switch (alt12)
                        {
                            case 1:
                                // C:\\Users\\s.ros\\Documents\\D<>veloppement\\NCalc\\Grammar\\NCalc.g:164:4: ( '<<' | '>>' ) right= additiveExpression
                                {
                                    // C:\\Users\\s.ros\\Documents\\D<>veloppement\\NCalc\\Grammar\\NCalc.g:164:4: ( '<<' | '>>' )
                                    var alt11 = 2;
                                    var LA11_0 = input.LA(1);

                                    if (LA11_0 == 36)
                                    {
                                        alt11 = 1;
                                    }
                                    else if (LA11_0 == 37)
                                    {
                                        alt11 = 2;
                                    }
                                    else
                                    {
                                        var nvae_d11s0 =
                                            new NoViableAltException("", 11, 0, input);

                                        throw nvae_d11s0;
                                    }
                                    switch (alt11)
                                    {
                                        case 1:
                                            // C:\\Users\\s.ros\\Documents\\D<>veloppement\\NCalc\\Grammar\\NCalc.g:164:6: '<<'
                                            {
                                                string_literal16 = (IToken)Match(input, 36, FOLLOW_36_in_shiftExpression571);
                                                string_literal16_tree = (CommonTree)adaptor.Create(string_literal16);
                                                adaptor.AddChild(root_0, string_literal16_tree);

                                                type = BinaryExpressionType.LeftShift;
                                            }
                                            break;
                                        case 2:
                                            // C:\\Users\\s.ros\\Documents\\D<>veloppement\\NCalc\\Grammar\\NCalc.g:165:6: '>>'
                                            {
                                                string_literal17 = (IToken)Match(input, 37, FOLLOW_37_in_shiftExpression581);
                                                string_literal17_tree = (CommonTree)adaptor.Create(string_literal17);
                                                adaptor.AddChild(root_0, string_literal17_tree);

                                                type = BinaryExpressionType.RightShift;
                                            }
                                            break;
                                    }

                                    PushFollow(FOLLOW_additiveExpression_in_shiftExpression593);
                                    right = additiveExpression();
                                    state.followingStackPointer--;

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

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

                loop12:
                    ; // Stops C# compiler whining that label 'loop12' 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;
        }

        // $ANTLR start "additiveExpression"
        // C:\\Users\\s.ros\\Documents\\D<>veloppement\\NCalc\\Grammar\\NCalc.g:170:1: additiveExpression returns [LogicalExpression value] : left= multiplicativeExpression ( ( '+' | '-' ) right= multiplicativeExpression )* ;
        public additiveExpression_return additiveExpression() // throws RecognitionException [1]
        {
            var retval = new additiveExpression_return();
            retval.Start = input.LT(1);

            CommonTree root_0 = null;

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

            multiplicativeExpression_return right = null;

            CommonTree char_literal18_tree = null;
            CommonTree char_literal19_tree = null;

            var 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
                    {
                        var alt14 = 2;
                        var 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: ( '+' | '-' )
                                    var alt13 = 2;
                                    var LA13_0 = input.LA(1);

                                    if (LA13_0 == 38)
                                    {
                                        alt13 = 1;
                                    }
                                    else if (LA13_0 == 39)
                                    {
                                        alt13 = 2;
                                    }
                                    else
                                    {
                                        var 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;
        }

        // $ANTLR start "multiplicativeExpression"
        // C:\\Users\\s.ros\\Documents\\D<>veloppement\\NCalc\\Grammar\\NCalc.g:181:1: multiplicativeExpression returns [LogicalExpression value] : left= unaryExpression ( ( '*' | '/' | '%' ) right= unaryExpression )* ;
        public multiplicativeExpression_return multiplicativeExpression() // throws RecognitionException [1]
        {
            var retval = new multiplicativeExpression_return();
            retval.Start = input.LT(1);

            CommonTree root_0 = null;

            IToken char_literal20 = null;
            IToken char_literal21 = null;
            IToken char_literal22 = null;
            unaryExpression_return left = null;

            unaryExpression_return right = null;

            CommonTree char_literal20_tree = null;
            CommonTree char_literal21_tree = null;
            CommonTree char_literal22_tree = null;

            var type = BinaryExpressionType.Unknown;

            try
            {
                // C:\\Users\\s.ros\\Documents\\D<>veloppement\\NCalc\\Grammar\\NCalc.g:185:2: (left= unaryExpression ( ( '*' | '/' | '%' ) right= unaryExpression )* )
                // C:\\Users\\s.ros\\Documents\\D<>veloppement\\NCalc\\Grammar\\NCalc.g:185:4: left= unaryExpression ( ( '*' | '/' | '%' ) right= unaryExpression )*
                {
                    root_0 = (CommonTree)adaptor.GetNilNode();

                    PushFollow(FOLLOW_unaryExpression_in_multiplicativeExpression690);
                    left = unaryExpression();
                    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:185:52: ( ( '*' | '/' | '%' ) right= unaryExpression )*
                    do
                    {
                        var alt16 = 2;
                        var LA16_0 = input.LA(1);

                        if (LA16_0 >= 40 && LA16_0 <= 42)
                        {
                            alt16 = 1;
                        }

                        switch (alt16)
                        {
                            case 1:
                                // C:\\Users\\s.ros\\Documents\\D<>veloppement\\NCalc\\Grammar\\NCalc.g:186:4: ( '*' | '/' | '%' ) right= unaryExpression
                                {
                                    // C:\\Users\\s.ros\\Documents\\D<>veloppement\\NCalc\\Grammar\\NCalc.g:186:4: ( '*' | '/' | '%' )
                                    var alt15 = 3;
                                    switch (input.LA(1))
                                    {
                                        case 40:
                                            {
                                                alt15 = 1;
                                            }
                                            break;
                                        case 41:
                                            {
                                                alt15 = 2;
                                            }
                                            break;
                                        case 42:
                                            {
                                                alt15 = 3;
                                            }
                                            break;
                                        default:
                                            var nvae_d15s0 =
                                                new NoViableAltException("", 15, 0, input);

                                            throw nvae_d15s0;
                                    }

                                    switch (alt15)
                                    {
                                        case 1:
                                            // C:\\Users\\s.ros\\Documents\\D<>veloppement\\NCalc\\Grammar\\NCalc.g:186:6: '*'
                                            {
                                                char_literal20 = (IToken)Match(input, 40, FOLLOW_40_in_multiplicativeExpression701);
                                                char_literal20_tree = (CommonTree)adaptor.Create(char_literal20);
                                                adaptor.AddChild(root_0, char_literal20_tree);

                                                type = BinaryExpressionType.Times;
                                            }
                                            break;
                                        case 2:
                                            // C:\\Users\\s.ros\\Documents\\D<>veloppement\\NCalc\\Grammar\\NCalc.g:187:6: '/'
                                            {
                                                char_literal21 = (IToken)Match(input, 41, FOLLOW_41_in_multiplicativeExpression711);
                                                char_literal21_tree = (CommonTree)adaptor.Create(char_literal21);
                                                adaptor.AddChild(root_0, char_literal21_tree);

                                                type = BinaryExpressionType.Div;
                                            }
                                            break;
                                        case 3:
                                            // C:\\Users\\s.ros\\Documents\\D<>veloppement\\NCalc\\Grammar\\NCalc.g:188:6: '%'
                                            {
                                                char_literal22 = (IToken)Match(input, 42, FOLLOW_42_in_multiplicativeExpression721);
                                                char_literal22_tree = (CommonTree)adaptor.Create(char_literal22);
                                                adaptor.AddChild(root_0, char_literal22_tree);

                                                type = BinaryExpressionType.Modulo;
                                            }
                                            break;
                                    }

                                    PushFollow(FOLLOW_unaryExpression_in_multiplicativeExpression733);
                                    right = unaryExpression();
                                    state.followingStackPointer--;

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

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

                loop16:
                    ; // Stops C# compiler whining that label 'loop16' 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;
        }

        // $ANTLR start "unaryExpression"
        // C:\\Users\\s.ros\\Documents\\D<>veloppement\\NCalc\\Grammar\\NCalc.g:194:1: unaryExpression returns [LogicalExpression value] : ( primaryExpression | ( '!' | 'not' ) primaryExpression | ( '~' ) primaryExpression | '-' primaryExpression );
        public unaryExpression_return unaryExpression() // throws RecognitionException [1]
        {
            var retval = new unaryExpression_return();
            retval.Start = input.LT(1);

            CommonTree root_0 = null;

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

            primaryExpression_return primaryExpression25 = null;

            primaryExpression_return primaryExpression27 = null;

            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 )
                var 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:
                        var 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
                            {
                                var 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;
        }

        // $ANTLR start "primaryExpression"
        // C:\\Users\\s.ros\\Documents\\D<>veloppement\\NCalc\\Grammar\\NCalc.g:201:1: primaryExpression returns [LogicalExpression value] : ( '(' logicalExpression ')' | expr= value | identifier ( arguments )? );
        public primaryExpression_return primaryExpression() // throws RecognitionException [1]
        {
            var retval = new primaryExpression_return();
            retval.Start = input.LT(1);

            CommonTree root_0 = null;

            IToken char_literal30 = null;
            IToken char_literal32 = null;
            value_return expr = null;

            logicalExpression_return logicalExpression31 = null;

            identifier_return identifier33 = null;

            arguments_return arguments34 = null;

            CommonTree char_literal30_tree = null;
            CommonTree char_literal32_tree = null;

            try
            {
                // C:\\Users\\s.ros\\Documents\\D<>veloppement\\NCalc\\Grammar\\NCalc.g:202:2: ( '(' logicalExpression ')' | expr= value | identifier ( arguments )? )
                var alt19 = 3;
                switch (input.LA(1))
                {
                    case 46:
                        {
                            alt19 = 1;
                        }
                        break;
                    case INTEGER:
                    case FLOAT:
                    case STRING:
                    case DATETIME:
                    case TRUE:
                    case FALSE:
                        {
                            alt19 = 2;
                        }
                        break;
                    case ID:
                    case NAME:
                        {
                            alt19 = 3;
                        }
                        break;
                    default:
                        var nvae_d19s0 =
                            new NoViableAltException("", 19, 0, input);

                        throw nvae_d19s0;
                }

                switch (alt19)
                {
                    case 1:
                        // C:\\Users\\s.ros\\Documents\\D<>veloppement\\NCalc\\Grammar\\NCalc.g:202:4: '(' logicalExpression ')'
                        {
                            root_0 = (CommonTree)adaptor.GetNilNode();

                            char_literal30 = (IToken)Match(input, 46, FOLLOW_46_in_primaryExpression829);
                            char_literal30_tree = (CommonTree)adaptor.Create(char_literal30);
                            adaptor.AddChild(root_0, char_literal30_tree);

                            PushFollow(FOLLOW_logicalExpression_in_primaryExpression831);
                            logicalExpression31 = logicalExpression();
                            state.followingStackPointer--;

                            adaptor.AddChild(root_0, logicalExpression31.Tree);
                            char_literal32 = (IToken)Match(input, 47, FOLLOW_47_in_primaryExpression833);
                            char_literal32_tree = (CommonTree)adaptor.Create(char_literal32);
                            adaptor.AddChild(root_0, char_literal32_tree);

                            retval.value = logicalExpression31 != null ? logicalExpression31.value : null;
                        }
                        break;
                    case 2:
                        // C:\\Users\\s.ros\\Documents\\D<>veloppement\\NCalc\\Grammar\\NCalc.g:203:4: expr= value
                        {
                            root_0 = (CommonTree)adaptor.GetNilNode();

                            PushFollow(FOLLOW_value_in_primaryExpression843);
                            expr = value();
                            state.followingStackPointer--;

                            adaptor.AddChild(root_0, expr.Tree);
                            retval.value = expr != null ? expr.value : null;
                        }
                        break;
                    case 3:
                        // C:\\Users\\s.ros\\Documents\\D<>veloppement\\NCalc\\Grammar\\NCalc.g:204:4: identifier ( arguments )?
                        {
                            root_0 = (CommonTree)adaptor.GetNilNode();

                            PushFollow(FOLLOW_identifier_in_primaryExpression851);
                            identifier33 = identifier();
                            state.followingStackPointer--;

                            adaptor.AddChild(root_0, identifier33.Tree);
                            retval.value = (LogicalExpression)(identifier33 != null ? identifier33.value : null);
                            // C:\\Users\\s.ros\\Documents\\D<>veloppement\\NCalc\\Grammar\\NCalc.g:204:66: ( arguments )?
                            var alt18 = 2;
                            var LA18_0 = input.LA(1);

                            if (LA18_0 == 46)
                            {
                                alt18 = 1;
                            }
                            switch (alt18)
                            {
                                case 1:
                                    // C:\\Users\\s.ros\\Documents\\D<>veloppement\\NCalc\\Grammar\\NCalc.g:204:67: arguments
                                    {
                                        PushFollow(FOLLOW_arguments_in_primaryExpression856);
                                        arguments34 = arguments();
                                        state.followingStackPointer--;

                                        adaptor.AddChild(root_0, arguments34.Tree);
                                        retval.value = new FunctionExpression(identifier33 != null ? identifier33.value : null, (arguments34 != null ? arguments34.value : null).ToArray());
                                    }
                                    break;
                            }
                        }
                        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;
        }

        // $ANTLR start "value"
        // C:\\Users\\s.ros\\Documents\\D<>veloppement\\NCalc\\Grammar\\NCalc.g:207:1: value returns [ValueExpression value] : ( INTEGER | FLOAT | STRING | DATETIME | TRUE | FALSE );
        public value_return value() // throws RecognitionException [1]
        {
            var retval = new 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 )
                var 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:
                        var 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 (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;
        }

        // $ANTLR start "identifier"
        // C:\\Users\\s.ros\\Documents\\D<>veloppement\\NCalc\\Grammar\\NCalc.g:216:1: identifier returns [Identifier value] : ( ID | NAME );
        public identifier_return identifier() // throws RecognitionException [1]
        {
            var retval = new identifier_return();
            retval.Start = input.LT(1);

            CommonTree root_0 = null;

            IToken ID41 = null;
            IToken NAME42 = null;

            CommonTree ID41_tree = null;
            CommonTree NAME42_tree = null;

            try
            {
                // C:\\Users\\s.ros\\Documents\\D<>veloppement\\NCalc\\Grammar\\NCalc.g:217:2: ( ID | NAME )
                var alt21 = 2;
                var LA21_0 = input.LA(1);

                if (LA21_0 == ID)
                {
                    alt21 = 1;
                }
                else if (LA21_0 == NAME)
                {
                    alt21 = 2;
                }
                else
                {
                    var nvae_d21s0 =
                        new NoViableAltException("", 21, 0, input);

                    throw nvae_d21s0;
                }
                switch (alt21)
                {
                    case 1:
                        // C:\\Users\\s.ros\\Documents\\D<>veloppement\\NCalc\\Grammar\\NCalc.g:217:5: ID
                        {
                            root_0 = (CommonTree)adaptor.GetNilNode();

                            ID41 = (IToken)Match(input, ID, FOLLOW_ID_in_identifier934);
                            ID41_tree = (CommonTree)adaptor.Create(ID41);
                            adaptor.AddChild(root_0, ID41_tree);

                            retval.value = new IdentifierExpression(ID41 != null ? ID41.Text : null);
                        }
                        break;
                    case 2:
                        // C:\\Users\\s.ros\\Documents\\D<>veloppement\\NCalc\\Grammar\\NCalc.g:218:5: NAME
                        {
                            root_0 = (CommonTree)adaptor.GetNilNode();

                            NAME42 = (IToken)Match(input, NAME, FOLLOW_NAME_in_identifier942);
                            NAME42_tree = (CommonTree)adaptor.Create(NAME42);
                            adaptor.AddChild(root_0, NAME42_tree);

                            retval.value = new IdentifierExpression((NAME42 != null ? NAME42.Text : null).Substring(1, (NAME42 != null ? NAME42.Text : null).Length - 2));
                        }
                        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;
        }

        // $ANTLR start "expressionList"
        // C:\\Users\\s.ros\\Documents\\D<>veloppement\\NCalc\\Grammar\\NCalc.g:221:1: expressionList returns [List<LogicalExpression> value] : first= logicalExpression ( ',' follow= logicalExpression )* ;
        public expressionList_return expressionList() // throws RecognitionException [1]
        {
            var retval = new expressionList_return();
            retval.Start = input.LT(1);

            CommonTree root_0 = null;

            IToken char_literal43 = null;
            logicalExpression_return first = null;

            logicalExpression_return follow = null;

            CommonTree char_literal43_tree = null;

            var expressions = new List<LogicalExpression>();

            try
            {
                // C:\\Users\\s.ros\\Documents\\D<>veloppement\\NCalc\\Grammar\\NCalc.g:225:2: (first= logicalExpression ( ',' follow= logicalExpression )* )
                // C:\\Users\\s.ros\\Documents\\D<>veloppement\\NCalc\\Grammar\\NCalc.g:225:4: first= logicalExpression ( ',' follow= logicalExpression )*
                {
                    root_0 = (CommonTree)adaptor.GetNilNode();

                    PushFollow(FOLLOW_logicalExpression_in_expressionList966);
                    first = logicalExpression();
                    state.followingStackPointer--;

                    adaptor.AddChild(root_0, first.Tree);
                    expressions.Add(first != null ? first.value : null);
                    // C:\\Users\\s.ros\\Documents\\D<>veloppement\\NCalc\\Grammar\\NCalc.g:225:62: ( ',' follow= logicalExpression )*
                    do
                    {
                        var alt22 = 2;
                        var LA22_0 = input.LA(1);

                        if (LA22_0 == 48)
                        {
                            alt22 = 1;
                        }

                        switch (alt22)
                        {
                            case 1:
                                // C:\\Users\\s.ros\\Documents\\D<>veloppement\\NCalc\\Grammar\\NCalc.g:225:64: ',' follow= logicalExpression
                                {
                                    char_literal43 = (IToken)Match(input, 48, FOLLOW_48_in_expressionList973);
                                    char_literal43_tree = (CommonTree)adaptor.Create(char_literal43);
                                    adaptor.AddChild(root_0, char_literal43_tree);

                                    PushFollow(FOLLOW_logicalExpression_in_expressionList977);
                                    follow = logicalExpression();
                                    state.followingStackPointer--;

                                    adaptor.AddChild(root_0, follow.Tree);
                                    expressions.Add(follow != null ? follow.value : null);
                                }
                                break;

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

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

                    retval.value = expressions;
                }

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

        // $ANTLR start "arguments"
        // C:\\Users\\s.ros\\Documents\\D<>veloppement\\NCalc\\Grammar\\NCalc.g:229:1: arguments returns [List<LogicalExpression> value] : '(' ( expressionList )? ')' ;
        public arguments_return arguments() // throws RecognitionException [1]
        {
            var retval = new arguments_return();
            retval.Start = input.LT(1);

            CommonTree root_0 = null;

            IToken char_literal44 = null;
            IToken char_literal46 = null;
            expressionList_return expressionList45 = null;

            CommonTree char_literal44_tree = null;
            CommonTree char_literal46_tree = null;

            retval.value = new List<LogicalExpression>();

            try
            {
                // C:\\Users\\s.ros\\Documents\\D<>veloppement\\NCalc\\Grammar\\NCalc.g:233:2: ( '(' ( expressionList )? ')' )
                // C:\\Users\\s.ros\\Documents\\D<>veloppement\\NCalc\\Grammar\\NCalc.g:233:4: '(' ( expressionList )? ')'
                {
                    root_0 = (CommonTree)adaptor.GetNilNode();

                    char_literal44 = (IToken)Match(input, 46, FOLLOW_46_in_arguments1006);
                    char_literal44_tree = (CommonTree)adaptor.Create(char_literal44);
                    adaptor.AddChild(root_0, char_literal44_tree);

                    // C:\\Users\\s.ros\\Documents\\D<>veloppement\\NCalc\\Grammar\\NCalc.g:233:8: ( expressionList )?
                    var alt23 = 2;
                    var LA23_0 = input.LA(1);

                    if (LA23_0 >= INTEGER && LA23_0 <= NAME || LA23_0 == 39 || LA23_0 >= 43 && LA23_0 <= 46)
                    {
                        alt23 = 1;
                    }
                    switch (alt23)
                    {
                        case 1:
                            // C:\\Users\\s.ros\\Documents\\D<>veloppement\\NCalc\\Grammar\\NCalc.g:233:10: expressionList
                            {
                                PushFollow(FOLLOW_expressionList_in_arguments1010);
                                expressionList45 = expressionList();
                                state.followingStackPointer--;

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

                    char_literal46 = (IToken)Match(input, 47, FOLLOW_47_in_arguments1017);
                    char_literal46_tree = (CommonTree)adaptor.Create(char_literal46);
                    adaptor.AddChild(root_0, char_literal46_tree);
                }

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

        public const int T__29 = 29;
        public const int T__28 = 28;
        public const int T__27 = 27;
        public const int T__26 = 26;
        public const int T__25 = 25;
        public const int T__24 = 24;
        public const int T__23 = 23;
        public const int LETTER = 12;
        public const int T__22 = 22;
        public const int T__21 = 21;
        public const int T__20 = 20;
        public const int FLOAT = 5;
        public const int ID = 10;
        public const int EOF = -1;
        public const int HexDigit = 17;
        public const int T__19 = 19;
        public const int NAME = 11;
        public const int DIGIT = 13;
        public const int T__42 = 42;
        public const int INTEGER = 4;
        public const int E = 14;
        public const int T__43 = 43;
        public const int T__40 = 40;
        public const int T__41 = 41;
        public const int T__46 = 46;
        public const int T__47 = 47;
        public const int T__44 = 44;
        public const int T__45 = 45;
        public const int T__48 = 48;
        public const int DATETIME = 7;
        public const int TRUE = 8;
        public const int T__30 = 30;
        public const int T__31 = 31;
        public const int T__32 = 32;
        public const int WS = 18;
        public const int T__33 = 33;
        public const int T__34 = 34;
        public const int T__35 = 35;
        public const int T__36 = 36;
        public const int T__37 = 37;
        public const int T__38 = 38;
        public const int T__39 = 39;
        public const int UnicodeEscape = 16;
        public const int FALSE = 9;
        public const int EscapeSequence = 15;
        public const int STRING = 6;

        private const char BS = '\\';

        public static readonly string[] tokenNames = new[]
        {
            "<invalid>",
            "<EOR>",
            "<DOWN>",
            "<UP>",
            "INTEGER",
            "FLOAT",
            "STRING",
            "DATETIME",
            "TRUE",
            "FALSE",
            "ID",
            "NAME",
            "LETTER",
            "DIGIT",
            "E",
            "EscapeSequence",
            "UnicodeEscape",
            "HexDigit",
            "WS",
            "'?'",
            "':'",
            "'||'",
            "'or'",
            "'&&'",
            "'and'",
            "'|'",
            "'^'",
            "'&'",
            "'=='",
            "'='",
            "'!='",
            "'<>'",
            "'<'",
            "'<='",
            "'>'",
            "'>='",
            "'<<'",
            "'>>'",
            "'+'",
            "'-'",
            "'*'",
            "'/'",
            "'%'",
            "'!'",
            "'not'",
            "'~'",
            "'('",
            "')'",
            "','"
        };

        private static NumberFormatInfo numberFormatInfo = new NumberFormatInfo();

        public static readonly BitSet FOLLOW_logicalExpression_in_ncalcExpression56 = new BitSet(new[] { 0x0000000000000000UL });
        public static readonly BitSet FOLLOW_EOF_in_ncalcExpression58 = new BitSet(new[] { 0x0000000000000002UL });
        public static readonly BitSet FOLLOW_conditionalExpression_in_logicalExpression78 = new BitSet(new[] { 0x0000000000080002UL });
        public static readonly BitSet FOLLOW_19_in_logicalExpression84 = new BitSet(new[] { 0x0000788000000FF0UL });
        public static readonly BitSet FOLLOW_conditionalExpression_in_logicalExpression88 = new BitSet(new[] { 0x0000000000100000UL });
        public static readonly BitSet FOLLOW_20_in_logicalExpression90 = new BitSet(new[] { 0x0000788000000FF0UL });
        public static readonly BitSet FOLLOW_conditionalExpression_in_logicalExpression94 = new BitSet(new[] { 0x0000000000000002UL });
        public static readonly BitSet FOLLOW_booleanAndExpression_in_conditionalExpression121 = new BitSet(new[] { 0x0000000000600002UL });
        public static readonly BitSet FOLLOW_set_in_conditionalExpression130 = new BitSet(new[] { 0x0000788000000FF0UL });
        public static readonly BitSet FOLLOW_conditionalExpression_in_conditionalExpression146 = new BitSet(new[] { 0x0000000000600002UL });
        public static readonly BitSet FOLLOW_bitwiseOrExpression_in_booleanAndExpression180 = new BitSet(new[] { 0x0000000001800002UL });
        public static readonly BitSet FOLLOW_set_in_booleanAndExpression189 = new BitSet(new[] { 0x0000788000000FF0UL });
        public static readonly BitSet FOLLOW_bitwiseOrExpression_in_booleanAndExpression205 = new BitSet(new[] { 0x0000000001800002UL });
        public static readonly BitSet FOLLOW_bitwiseXOrExpression_in_bitwiseOrExpression237 = new BitSet(new[] { 0x0000000002000002UL });
        public static readonly BitSet FOLLOW_25_in_bitwiseOrExpression246 = new BitSet(new[] { 0x0000788000000FF0UL });
        public static readonly BitSet FOLLOW_bitwiseOrExpression_in_bitwiseOrExpression256 = new BitSet(new[] { 0x0000000002000002UL });
        public static readonly BitSet FOLLOW_bitwiseAndExpression_in_bitwiseXOrExpression290 = new BitSet(new[] { 0x0000000004000002UL });
        public static readonly BitSet FOLLOW_26_in_bitwiseXOrExpression299 = new BitSet(new[] { 0x0000788000000FF0UL });
        public static readonly BitSet FOLLOW_bitwiseAndExpression_in_bitwiseXOrExpression309 = new BitSet(new[] { 0x0000000004000002UL });
        public static readonly BitSet FOLLOW_equalityExpression_in_bitwiseAndExpression341 = new BitSet(new[] { 0x0000000008000002UL });
        public static readonly BitSet FOLLOW_27_in_bitwiseAndExpression350 = new BitSet(new[] { 0x0000788000000FF0UL });
        public static readonly BitSet FOLLOW_equalityExpression_in_bitwiseAndExpression360 = new BitSet(new[] { 0x0000000008000002UL });
        public static readonly BitSet FOLLOW_relationalExpression_in_equalityExpression394 = new BitSet(new[] { 0x00000000F0000002UL });
        public static readonly BitSet FOLLOW_set_in_equalityExpression405 = new BitSet(new[] { 0x0000788000000FF0UL });
        public static readonly BitSet FOLLOW_set_in_equalityExpression422 = new BitSet(new[] { 0x0000788000000FF0UL });
        public static readonly BitSet FOLLOW_relationalExpression_in_equalityExpression441 = new BitSet(new[] { 0x00000000F0000002UL });
        public static readonly BitSet FOLLOW_shiftExpression_in_relationalExpression474 = new BitSet(new[] { 0x0000000F00000002UL });
        public static readonly BitSet FOLLOW_32_in_relationalExpression485 = new BitSet(new[] { 0x0000788000000FF0UL });
        public static readonly BitSet FOLLOW_33_in_relationalExpression495 = new BitSet(new[] { 0x0000788000000FF0UL });
        public static readonly BitSet FOLLOW_34_in_relationalExpression506 = new BitSet(new[] { 0x0000788000000FF0UL });
        public static readonly BitSet FOLLOW_35_in_relationalExpression516 = new BitSet(new[] { 0x0000788000000FF0UL });
        public static readonly BitSet FOLLOW_shiftExpression_in_relationalExpression528 = new BitSet(new[] { 0x0000000F00000002UL });
        public static readonly BitSet FOLLOW_additiveExpression_in_shiftExpression560 = new BitSet(new[] { 0x0000003000000002UL });
        public static readonly BitSet FOLLOW_36_in_shiftExpression571 = new BitSet(new[] { 0x0000788000000FF0UL });
        public static readonly BitSet FOLLOW_37_in_shiftExpression581 = new BitSet(new[] { 0x0000788000000FF0UL });
        public static readonly BitSet FOLLOW_additiveExpression_in_shiftExpression593 = new BitSet(new[] { 0x0000003000000002UL });
        public static readonly BitSet FOLLOW_multiplicativeExpression_in_additiveExpression625 = new BitSet(new[] { 0x000000C000000002UL });
        public static readonly BitSet FOLLOW_38_in_additiveExpression636 = new BitSet(new[] { 0x0000788000000FF0UL });
        public static readonly BitSet FOLLOW_39_in_additiveExpression646 = new BitSet(new[] { 0x0000788000000FF0UL });
        public static readonly BitSet FOLLOW_multiplicativeExpression_in_additiveExpression658 = new BitSet(new[] { 0x000000C000000002UL });
        public static readonly BitSet FOLLOW_unaryExpression_in_multiplicativeExpression690 = new BitSet(new[] { 0x0000070000000002UL });
        public static readonly BitSet FOLLOW_40_in_multiplicativeExpression701 = new BitSet(new[] { 0x0000788000000FF0UL });
        public static readonly BitSet FOLLOW_41_in_multiplicativeExpression711 = new BitSet(new[] { 0x0000788000000FF0UL });
        public static readonly BitSet FOLLOW_42_in_multiplicativeExpression721 = new BitSet(new[] { 0x0000788000000FF0UL });
        public static readonly BitSet FOLLOW_unaryExpression_in_multiplicativeExpression733 = new BitSet(new[] { 0x0000070000000002UL });
        public static readonly BitSet FOLLOW_primaryExpression_in_unaryExpression760 = new BitSet(new[] { 0x0000000000000002UL });
        public static readonly BitSet FOLLOW_set_in_unaryExpression771 = new BitSet(new[] { 0x0000400000000FF0UL });
        public static readonly BitSet FOLLOW_primaryExpression_in_unaryExpression779 = new BitSet(new[] { 0x0000000000000002UL });
        public static readonly BitSet FOLLOW_45_in_unaryExpression791 = new BitSet(new[] { 0x0000400000000FF0UL });
        public static readonly BitSet FOLLOW_primaryExpression_in_unaryExpression794 = new BitSet(new[] { 0x0000000000000002UL });
        public static readonly BitSet FOLLOW_39_in_unaryExpression805 = new BitSet(new[] { 0x0000400000000FF0UL });
        public static readonly BitSet FOLLOW_primaryExpression_in_unaryExpression807 = new BitSet(new[] { 0x0000000000000002UL });
        public static readonly BitSet FOLLOW_46_in_primaryExpression829 = new BitSet(new[] { 0x0000788000000FF0UL });
        public static readonly BitSet FOLLOW_logicalExpression_in_primaryExpression831 = new BitSet(new[] { 0x0000800000000000UL });
        public static readonly BitSet FOLLOW_47_in_primaryExpression833 = new BitSet(new[] { 0x0000000000000002UL });
        public static readonly BitSet FOLLOW_value_in_primaryExpression843 = new BitSet(new[] { 0x0000000000000002UL });
        public static readonly BitSet FOLLOW_identifier_in_primaryExpression851 = new BitSet(new[] { 0x0000400000000002UL });
        public static readonly BitSet FOLLOW_arguments_in_primaryExpression856 = new BitSet(new[] { 0x0000000000000002UL });
        public static readonly BitSet FOLLOW_INTEGER_in_value876 = new BitSet(new[] { 0x0000000000000002UL });
        public static readonly BitSet FOLLOW_FLOAT_in_value884 = new BitSet(new[] { 0x0000000000000002UL });
        public static readonly BitSet FOLLOW_STRING_in_value892 = new BitSet(new[] { 0x0000000000000002UL });
        public static readonly BitSet FOLLOW_DATETIME_in_value901 = new BitSet(new[] { 0x0000000000000002UL });
        public static readonly BitSet FOLLOW_TRUE_in_value908 = new BitSet(new[] { 0x0000000000000002UL });
        public static readonly BitSet FOLLOW_FALSE_in_value916 = new BitSet(new[] { 0x0000000000000002UL });
        public static readonly BitSet FOLLOW_ID_in_identifier934 = new BitSet(new[] { 0x0000000000000002UL });
        public static readonly BitSet FOLLOW_NAME_in_identifier942 = new BitSet(new[] { 0x0000000000000002UL });
        public static readonly BitSet FOLLOW_logicalExpression_in_expressionList966 = new BitSet(new[] { 0x0001000000000002UL });
        public static readonly BitSet FOLLOW_48_in_expressionList973 = new BitSet(new[] { 0x0000788000000FF0UL });
        public static readonly BitSet FOLLOW_logicalExpression_in_expressionList977 = new BitSet(new[] { 0x0001000000000002UL });
        public static readonly BitSet FOLLOW_46_in_arguments1006 = new BitSet(new[] { 0x0000F88000000FF0UL });
        public static readonly BitSet FOLLOW_expressionList_in_arguments1010 = new BitSet(new[] { 0x0000800000000000UL });
        public static readonly BitSet FOLLOW_47_in_arguments1017 = new BitSet(new[] { 0x0000000000000002UL });

        public class ncalcExpression_return : ParserRuleReturnScope
        {
            public LogicalExpression value;
            private CommonTree tree;

            override public object Tree
            {
                get
                {
                    return tree;
                }
                set
                {
                    tree = (CommonTree)value;
                }
            }
        };

        // $ANTLR end "ncalcExpression"

        public class logicalExpression_return : ParserRuleReturnScope
        {
            public LogicalExpression value;
            private CommonTree tree;

            override public object Tree
            {
                get
                {
                    return tree;
                }
                set
                {
                    tree = (CommonTree)value;
                }
            }
        };

        // $ANTLR end "logicalExpression"

        public class conditionalExpression_return : ParserRuleReturnScope
        {
            public LogicalExpression value;
            private CommonTree tree;

            override public object Tree
            {
                get
                {
                    return tree;
                }
                set
                {
                    tree = (CommonTree)value;
                }
            }
        };

        // $ANTLR end "conditionalExpression"

        public class booleanAndExpression_return : ParserRuleReturnScope
        {
            public LogicalExpression value;
            private CommonTree tree;

            override public object Tree
            {
                get
                {
                    return tree;
                }
                set
                {
                    tree = (CommonTree)value;
                }
            }
        };

        // $ANTLR end "booleanAndExpression"

        public class bitwiseOrExpression_return : ParserRuleReturnScope
        {
            public LogicalExpression value;
            private CommonTree tree;

            override public object Tree
            {
                get
                {
                    return tree;
                }
                set
                {
                    tree = (CommonTree)value;
                }
            }
        };

        // $ANTLR end "bitwiseOrExpression"

        public class bitwiseXOrExpression_return : ParserRuleReturnScope
        {
            public LogicalExpression value;
            private CommonTree tree;

            override public object Tree
            {
                get
                {
                    return tree;
                }
                set
                {
                    tree = (CommonTree)value;
                }
            }
        };

        // $ANTLR end "bitwiseXOrExpression"

        public class bitwiseAndExpression_return : ParserRuleReturnScope
        {
            public LogicalExpression value;
            private CommonTree tree;

            override public object Tree
            {
                get
                {
                    return tree;
                }
                set
                {
                    tree = (CommonTree)value;
                }
            }
        };

        // $ANTLR end "bitwiseAndExpression"

        public class equalityExpression_return : ParserRuleReturnScope
        {
            public LogicalExpression value;
            private CommonTree tree;

            override public object Tree
            {
                get
                {
                    return tree;
                }
                set
                {
                    tree = (CommonTree)value;
                }
            }
        };

        // $ANTLR end "equalityExpression"

        public class relationalExpression_return : ParserRuleReturnScope
        {
            public LogicalExpression value;
            private CommonTree tree;

            override public object Tree
            {
                get
                {
                    return tree;
                }
                set
                {
                    tree = (CommonTree)value;
                }
            }
        };

        // $ANTLR end "relationalExpression"

        public class shiftExpression_return : ParserRuleReturnScope
        {
            public LogicalExpression value;
            private CommonTree tree;

            override public object Tree
            {
                get
                {
                    return tree;
                }
                set
                {
                    tree = (CommonTree)value;
                }
            }
        };

        // $ANTLR end "shiftExpression"

        public class additiveExpression_return : ParserRuleReturnScope
        {
            public LogicalExpression value;
            private CommonTree tree;

            override public object Tree
            {
                get
                {
                    return tree;
                }
                set
                {
                    tree = (CommonTree)value;
                }
            }
        };

        // $ANTLR end "additiveExpression"

        public class multiplicativeExpression_return : ParserRuleReturnScope
        {
            public LogicalExpression value;
            private CommonTree tree;

            override public object Tree
            {
                get
                {
                    return tree;
                }
                set
                {
                    tree = (CommonTree)value;
                }
            }
        };

        // $ANTLR end "multiplicativeExpression"

        public class unaryExpression_return : ParserRuleReturnScope
        {
            public LogicalExpression value;
            private CommonTree tree;

            override public object Tree
            {
                get
                {
                    return tree;
                }
                set
                {
                    tree = (CommonTree)value;
                }
            }
        };

        // $ANTLR end "unaryExpression"

        public class primaryExpression_return : ParserRuleReturnScope
        {
            public LogicalExpression value;
            private CommonTree tree;

            override public object Tree
            {
                get
                {
                    return tree;
                }
                set
                {
                    tree = (CommonTree)value;
                }
            }
        };

        // $ANTLR end "primaryExpression"

        public class value_return : ParserRuleReturnScope
        {
            public ValueExpression value;
            private CommonTree tree;

            override public object Tree
            {
                get
                {
                    return tree;
                }
                set
                {
                    tree = (CommonTree)value;
                }
            }
        };

        // $ANTLR end "value"

        public class identifier_return : ParserRuleReturnScope
        {
            public IdentifierExpression value;
            private CommonTree tree;

            override public object Tree
            {
                get
                {
                    return tree;
                }
                set
                {
                    tree = (CommonTree)value;
                }
            }
        };

        // $ANTLR end "identifier"

        public class expressionList_return : ParserRuleReturnScope
        {
            public List<LogicalExpression> value;
            private CommonTree tree;

            override public object Tree
            {
                get
                {
                    return tree;
                }
                set
                {
                    tree = (CommonTree)value;
                }
            }
        };

        // $ANTLR end "expressionList"

        public class arguments_return : ParserRuleReturnScope
        {
            public List<LogicalExpression> value;
            private CommonTree tree;

            override public object Tree
            {
                get
                {
                    return tree;
                }
                set
                {
                    tree = (CommonTree)value;
                }
            }
        };
    }
}