Написать синтаксический анализатор-калькулятор

//класс исключающий для ошибок для анализатора
    class ParserException : ApplicationException
    {
        public ParserException(string str) : base(str) { }
        public override string ToString()
        { return Message; }
    }
 
    class Parser
    {
        //перчисляем типы лексем.
        enum Types { NONE, DELIMITER, VARIABLE, NUMBER };
        // Перечисляем типы ошибок.
        enum Errors { SYNTAX, UNBALPARENS, NOEXP, DIVBYZERO };
 
        string ехр; // Ссылка на строку выражения,
        int expIdx; // Текущий индекс в выражении,
        string token; // Текущая лексема.
        Types tokType; // Тип лексемы.
 
        // Массив для переменных,
        double[] vars = new double[26];
 
        public Parser()
        {
            // Инициализируем переменные нулевыми значениями.
            for (int i = 0; i < vars.Length; i++)
                vars[i] = 0.0;
        }
        // Входная точка анализатора.
        public double Evaluate(string expstr)
        {
            double result;
            exp = expstr;
            expIdx = 0;
            try
            {
                GetToken();
                if (token == "")
                {
                    SyntaxErr(Errors.NOEXP); // Выражение отсутствует,
                    return 0.0;
                }
                EvalExp1(out result); // В этом варианте анализатора
                // сначала вызывается
                // метод EvalExpl().
                if (token != "") // Последняя лексема должна
                    // быть нулевой.
                    SyntaxErr(Errors.SYNTAX);
                return result;
            }
            catch (ParserException exc)
            {
                // При желании добавляем здесь обработку ошибок.
                Console.WriteLine(exc);
                return 0.0;
            }
        }
 
        // Обрабатываем присвоение,
        void EvalExp1(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();// Получаем следующую часть
                    // выражения ехр.
                    EvalExp2(out result);
                    vars[varIdx] = result;
                    return;
                }
            }
 
            EvalExp2(out result);
        }
 
        // Складываем или вычитаем два члена выражения.
        void EvalExp2(out double result)
        {
            string op;
            double partialResult;
 
            EvalExp3(out result);
            while ((op = token) == "+" || op == "-")
            {
                GetToken();
                EvalExp3(out partialResult);
                switch (op)
                {
                    case "-":
                        result = result - partialResult;
                        break;
                    case "+":
                        result = result + partialResult;
                        break;
                }
            }
        }
 
        // Выполняем умножение или деление двух множителей.
        void EvalExp3(out double result)
        {
            string op;
            double partialResult = 0.0;
            EvalExp4(out result);
            while ((op = token) == "*" || op == "/" || op == "%")
            {
                GetToken();
                EvalExp4(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;
                }
            }
        }
 
        // выполняем возведение в степень
        void EvalExp4(out double result)
        {
            double partialResult, ex;
            int t;
            EvalExp5(out result);
            if (token == "^")
            {
                GetToken();
                EvalExp4(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 EvalExp5(out double result)
        {
            string op;
 
            op = "";
            if ((tokType == Types.DELIMITER) && token == "+" || token == "-")
            {
                op = token;
                GetToken();
            }
            EvalExp6(out result);
            if (op == "-") result = -result;
        }
 
        // обрабатываем выражение в круглых скобках
        void EvalExp6(out double result)
        {
            if ((token == "("))
            {
                GetToken();
                EvalExp2(out result);
                if (token != ")")
                    SyntaxErr(Errors.UNBALPARENS);
                GetToken();
            }
            else Atom(out result);
        }
        // Получаем значение числа или переменной.
        void Atom(out double result)
        {
            switch (tokType)
            {
                case Types.NUMBER:
                    try
                    {
                        result = Double.Parse(token);
                    }
                    catch (FormatException)
                    {
                        result = 0.0;
                        SyntaxErr(Errors.SYNTAX);
                    }
                    GetToken();
                    return;
                case Types.VARIABLE:
                    result = FindVar(token);
                    GetToken();
                    return;
                default:
                    result = 0.0;
                    SyntaxErr(Errors.SYNTAX);
                    break;
            }
        }
        // Возвращаем значение переменной.
        double FindVar(string vname)
        {
            if (!Char.IsLetter(vname[0]))
            {
                SyntaxErr(Errors.SYNTAX);
                return 0.0;
            }
            return vars[Char.ToUpper(vname[0])-'A'];
        }
        // Возвращаем лексему во входной поток.
        void PutBack()
        {
            for (int i = 0; i < token.Length; i++) expIdx--;
        }
        // Обрабатываем синтаксическую ошибку
        void SyntaxErr(Errors error)
        {
            string[] err ={
                         "Синтаксическая оошибка",
                         "Дисбаланс скобок",
                         "Выражение отсутствет",
                         "Деление на нуль"};
            throw new ParserException(err[(int)error]);
        }
        // получем следующую лексему.
        void GetToken()
        {            
            tokType = Types.NONE;
            token = "";
            if (expIdx == exp.Length) return; // Конец выражения.
            // Опускаем пробел.
            while (expldx < 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;
                }
                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;
            }
        }
        // Метод возвращает значение true,
        // если с -- разделитель.
        bool IsDelim(char c)
        {
            if (("+-/*%^=()".IndexOf(c) != -1))
                return true;
            return false;
        }
    }

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
 
namespace CalcTrans
{
    class Program
    {
        static void Main(string[] args)
        {
            string expr;
            Parser p = new Parser();
 
            Console.WriteLine("Для выхода из программы введите пустое выражение. ");
 
            for (; ; )
            {
                Console.Write("Введите выражение: ");
                expr = Console.ReadLine();
                if (expr == "") break;
                Console.WriteLine("Результат: " + p.Evaluate(expr));
            } 
        }
        //класс исключающий для ошибок для анализатора
        class ParserException : ApplicationException
        {
            public ParserException(string str) : base(str) { }
            public override string ToString()
            { return Message; }
        }
 
        class Parser
        {
            //перчисляем типы лексем.
            enum Types { NONE, DELIMITER, VARIABLE, NUMBER };
            // Перечисляем типы ошибок.
            enum Errors { SYNTAX, UNBALPARENS, NOEXP, DIVBYZERO };
 
            string exp; // Ссылка на строку выражения,
            int expIdx; // Текущий индекс в выражении,
            string token; // Текущая лексема.
            Types tokType; // Тип лексемы.
 
            // Массив для переменных,
            double[] vars = new double[26];
 
            public Parser()
            {
                // Инициализируем переменные нулевыми значениями.
                for (int i = 0; i < vars.Length; i++)
                    vars[i] = 0.0;
            }
            // Входная точка анализатора.
            public double Evaluate(string expstr)
            {
                double result;
                exp = expstr;
                expIdx = 0;
                try
                {
                    GetToken();
                    if (token == "")
                    {
                        SyntaxErr(Errors.NOEXP); // Выражение отсутствует,
                        return 0.0;
                    }
                    EvalExp1(out result); // В этом варианте анализатора
                    // сначала вызывается
                    // метод EvalExpl().
                    if (token != "") // Последняя лексема должна
                        // быть нулевой.
                        SyntaxErr(Errors.SYNTAX);
                    return result;
                }
                catch (ParserException exc)
                {
                    // При желании добавляем здесь обработку ошибок.
                    Console.WriteLine(exc);
                    return 0.0;
                }
            }
 
            // Обрабатываем присвоение,
            void EvalExp1(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();// Получаем следующую часть
                        // выражения ехр.
                        EvalExp2(out result);
                        vars[varIdx] = result;
                        return;
                    }
                }
 
                EvalExp2(out result);
            }
 
            // Складываем или вычитаем два члена выражения.
            void EvalExp2(out double result)
            {
                string op;
                double partialResult;
 
                EvalExp3(out result);
                while ((op = token) == "+" || op == "-")
                {
                    GetToken();
                    EvalExp3(out partialResult);
                    switch (op)
                    {
                        case "-":
                            result = result - partialResult;
                            break;
                        case "+":
                            result = result + partialResult;
                            break;
                    }
                }
            }
 
            // Выполняем умножение или деление двух множителей.
            void EvalExp3(out double result)
            {
                string op;
                double partialResult = 0.0;
                EvalExp4(out result);
                while ((op = token) == "*" || op == "/" || op == "%")
                {
                    GetToken();
                    EvalExp4(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 EvalExp4(out double result)
            {
                double partialResult, ex;
                int t;
                EvalExp5(out result);
                if (token == "^")
                {
                    GetToken();
                    EvalExp4(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 EvalExp5(out double result)
            {
                string op;
 
                op = "";
                if ((tokType == Types.DELIMITER) && token == "+" || token == "-")
                {
                    op = token;
                    GetToken();
                }
                EvalExp6(out result);
                if (op == "-") result = -result;
            }
 
            // обрабатываем выражение в круглых скобках
            void EvalExp6(out double result)
            {
                if ((token == "("))
                {
                    GetToken();
                    EvalExp2(out result);
                    if (token != ")")
                        SyntaxErr(Errors.UNBALPARENS);
                    GetToken();
                }
                else Atom(out result);
            }
            // Получаем значение числа или переменной.
            void Atom(out double result)
            {
                switch (tokType)
                {
                    case Types.NUMBER:
                        try
                        {
                            result = Double.Parse(token);
                        }
                        catch (FormatException)
                        {
                            result = 0.0;
                            SyntaxErr(Errors.SYNTAX);
                        }
                        GetToken();
                        return;
                    case Types.VARIABLE:
                        result = FindVar(token);
                        GetToken();
                        return;
                    default:
                        result = 0.0;
                        SyntaxErr(Errors.SYNTAX);
                        break;
                }
            }
            // Возвращаем значение переменной.
            double FindVar(string vname)
            {
                if (!Char.IsLetter(vname[0]))
                {
                    SyntaxErr(Errors.SYNTAX);
                    return 0.0;
                }
                return vars[Char.ToUpper(vname[0]) - 'A'];
            }
            // Возвращаем лексему во входной поток.
            void PutBack()
            {
                for (int i = 0; i < token.Length; i++) expIdx--;
            }
            // Обрабатываем синтаксическую ошибку
            void SyntaxErr(Errors error)
            {
                string[] err ={
                         "Синтаксическая оошибка",
                         "Дисбаланс скобок",
                         "Выражение отсутствет",
                         "Деление на нуль"};
                throw new ParserException(err[(int)error]);
            }
            // получем следующую лексему.
            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;
                    }
                    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;
                }
            }
            // Метод возвращает значение true,
            // если с -- разделитель.
            bool IsDelim(char c)
            {
                if (("+-/*%^=()".IndexOf(c) != -1))
                    return true;
                return false;
            }
        }
    }
}