Интерпретатор простейших команд

   class Parser
        {
            List<int> IntegerValues = new List<int>();
            // Перечисляем типы лексем.
            enum Types { NONE, DELIMITER, VARIABLE, NUMBER, SETINTEGER, SETDOUBLE, SETSTRING};
            // Перечисляем типы ошибок.
            enum Errors { SYNTAX, DIVBYZERO, DIFFTYPES };
            string exp; // Ссылка на строку выражения.
            int expIdx; // Текущий индекс в выражении.
            string token; // Текущая лексема.
            Types tokType; // Тип лексемы.
            double[] IntegerVars = new double[26]; //массив, хранящий значения integer
            bool IsDouble = false;
            bool IsInteger = false;
            bool IsString = false;
            int Line;
 
            public Parser()
            {
                // Инициализируем переменные нулевыми значениями.
                for (int i = 0; i < IntegerVars.Length; i++)
                { 
                    IntegerVars[i] = 0.0;
                }
            }
 
            //Получаем номер строки
            public void GetNumberLine (int s)
            {
                Line = s;
            }
 
            // Входная точка анализатора.
            public double Evaluate(string expstr)
            {
                double result;
                exp = expstr;
                expIdx = 0;
                try
                {
                    GetToken();
                    if (token == "")
                    {
                        SyntaxErr(Errors.SYNTAX); // Выражение  отсутствует.
                        return 0.0;
                    }
                    SetValue(out result);
                    if (token != "") // Последняя лексема должна быть null-значением.
                    {
                        // SyntaxErr(Errors.SYNTAX);
                        SetValue(out result);
                    }
                    return result;
                }
                catch (ParserException exc)
                {
                    // Здесь обработка ошибок
                   // Console.WriteLine(exc);
                    return 0.0;
                }
            }
 
            //Операция присвоения
            void SetValue(out double result)
            {
                int varIdx;
                Types ttokType;
                string temptoken;
                if (tokType == Types.VARIABLE)
                {
                    // Сохраняем старую лексему.
                    temptoken = String.Copy(token);
                    ttokType = tokType;
                    // Вычисляем индекс переменной.
                    varIdx = Char.ToUpper(token[0]) - 'A';
                    GetToken();
                    if (token != "=")
                    {
                        PutBack();
                        // Возвращаем текущую лексему в поток
                        // и восстанавливаем старую,
                        // поскольку у нас не присвоение.
                        token = String.Copy(temptoken);
                        tokType = ttokType;
                    }
                    else
                    {
                        GetToken(); // Получаем следующую часть
                        PlusMinus(out result);
                        IntegerVars[varIdx] = result;
                        return;
                    }
                }
                if(tokType == Types.SETINTEGER)
                {
                    temptoken = String.Copy(token);
                    ttokType = tokType;
                    varIdx = Char.ToUpper(token[0]) - 'A';
                    GetToken();
                    PutBack();
                    token = String.Copy(temptoken);
                    tokType = ttokType;
                }
                if(tokType == Types.SETDOUBLE)
                {
                    temptoken = String.Copy(token);
                    ttokType = tokType;
                    varIdx = Char.ToUpper(token[0]) - 'A';
                    GetToken();
                    PutBack();
                    token = String.Copy(temptoken);
                    tokType = ttokType;
                }
                PlusMinus(out result);
            }
        
            // Возвращаем лексему во входной поток.
            void PutBack()
            {
                for (int i = 0; i < token.Length; i++)
                    expIdx--;
            }
 
            // Метод возвращает значение переменной.
            double FindVar(string vname)
            {
                return IntegerVars[Char.ToUpper(vname[0]) - 'A'];
            }
 
            // Получаем значение числа.
            void GetValue(out double result)
            {
                switch (tokType)
                {
                    case Types.NUMBER:
                        try
                        { 
                            result = 0.0;
                             if(IsInteger==true)
                             {
                                 result = Int32.Parse(token);
                                 IsInteger = false;
                             }
                             if(IsDouble==true)
                             {
                                 result = Double.Parse(token);
                                 IsDouble = false;
                             }
                             if(IsInteger==false && IsDouble == false) //для дебага оставлю пока, когда подчет обычных выражений идёт
                            { 
                                result = Double.Parse(token) ;
                            }
                        }
                        catch(FormatException exc)
                        {
                            SyntaxErr(Errors.DIFFTYPES);
                            result = 0;
                        }
                        GetToken();
                        return;
                    case Types.VARIABLE:
                        result = FindVar(token);
                        GetToken();
                        return;
                    default:
                        result = 0.0;
                        SyntaxErr(Errors.SYNTAX);
                        break;
                }
            }
            
            // Получаем следующую лексему.
            void GetToken()
            {
                tokType = Types.NONE;
                token = "";
                // конец выражения
                if (expIdx == exp.Length)
                {
                    return;
                }
                // Пропускаем пробелы.Хвостовой пробел завершает выражение.
                while (expIdx < exp.Length && Char.IsWhiteSpace(exp[expIdx]))
                {
                    ++expIdx;
                }
                if (expIdx == exp.Length)
                {
                    return;
                }
                if (IsDelim(exp[expIdx])) // Это оператор?
                {
                    token += exp[expIdx];
                    expIdx++;
                    tokType = Types.DELIMITER;
                }
                else if (Char.IsLetter(exp[expIdx])) // Это  переменная?
                {
                    while (!IsDelim(exp[expIdx]))
                    {
                        
                        token += exp[expIdx];
                        expIdx++;
                        if (expIdx >= exp.Length)
                        {
                            break;
                        }
                        if (token == "int")
                        {
                            tokType = Types.SETINTEGER;
                            IsInteger = true;
                        }
                        if(token == "double")
                        {
                            tokType = Types.SETDOUBLE;
                            IsDouble = true;
                        }
                        if(token == "string")
                        {
                            tokType = Types.SETSTRING;
                            IsString = true;
                        }
                        tokType = Types.VARIABLE;
                    }
                }
                else if (Char.IsDigit(exp[expIdx])) // Это число?
                {
                    while (!IsDelim(exp[expIdx]))
                    {
                        token += exp[expIdx];
                        expIdx++;
                        if (expIdx >= exp.Length)
                        {
                            break;
                        }
                    }
                    tokType = Types.NUMBER;
                }
                
            }
 
            // Сложение или вычитание двух членов выражения.
            void PlusMinus(out double result)
            {
                string op;
                double partialResult;
                MultipleDivide(out result);
                while ((op = token) == "+" || op == "-")
                {
                    GetToken();
                    MultipleDivide(out partialResult);
                    switch (op)
                    {
                        case "-":
                            result = result - partialResult;
                            break;
                        case "+":
                            result = result + partialResult;
                            break;
                    }
                }
            }
 
            // Умножение или деление двух множителей с остатком.
            void MultipleDivide(out double result)
            {
                string op;
                double partialResult = 0.0;
                Elevate(out result);
                while ((op = token) == "*" || op == "/" || op == "%")
                {
                    GetToken();
                    Elevate(out partialResult);
                    switch (op)
                    {
                        case "*":
                            result = result * partialResult;
                            break;
                        case "/":
                            if (partialResult == 0.0)
                            { 
                                SyntaxErr(Errors.DIVBYZERO);
                            }
                            result = result / partialResult;
                            break;
                        case "%":
                            if (partialResult == 0.0)
                            { 
                                SyntaxErr(Errors.DIVBYZERO);
                            }
                            result = (int)result % (int)partialResult;
                            break;
                    }
                }
            }
 
            // Возведение в степень.
            void Elevate(out double result)
            {
                double partialResult, ex;
                int t;
                UnarPlusMinus(out result);
                if (token == "^")
                {
                    GetToken();
                    Elevate(out partialResult);
                    ex = result;
                    if (partialResult == 0.0)
                    {
                        result = 1.0;
                        return;
                    }
                    for (t = (int)partialResult - 1; t > 0; t--)
                    { 
                        result = result * (double)ex;
                    }
                }
            }
 
            // Выполнение операции унарного + или -.
            void UnarPlusMinus(out double result)
            {
                string op;
                op = "";
                if ((tokType == Types.DELIMITER) && token == "+" || token == "-")
                {
                    op = token;
                    GetToken();
                }
                Brackets(out result);
                if (op == "-")
                {
                    result = -result;
                }
            }
 
            // Обработка выражения в круглых скобках.
            void Brackets(out double result)
            {
                if ((token == "("))
                {
                    GetToken();
                    PlusMinus(out result);
                    if (token != ")")
                    {
                        SyntaxErr(Errors.SYNTAX);
                    }
                    GetToken();
                }
                else
                {
                    GetValue(out result);
                }
            }
 
            // обрабатываем синтаксическую ошибку.
            void SyntaxErr(Errors error)
            {
                string[] err = {
                                "Синтаксическая ошибка",
                                "Деление на нуль",
                                "Ошибка приведения типов"
                                };
                MessageException = MessageException.Insert(MessageException.Length, DateTime.Now.ToLongTimeString()+" |"+"Строка: "+ Line + "|" + err[(int)error].ToString() + System.Environment.NewLine);
                throw new ParserException(err[(int)error]);
            }
            
            // Метод возвращает значение true, если символ с является разделителем.
            bool IsDelim(char c)
            {
                if ((" +-/*%^=()".IndexOf(c) != -1))
                {
                    return true;
                }
                return false;
            }
            
        }