TFCS-2 3.2 Fin

/*

BY: Iurchak Aleksei BI-14-1

G = {A, N, P, S}

A = {‘0’ .. ‘9’, ‘a’ .. ’z’, ‘A’ .. ‘Z’, ‘_’, ‘+’, ‘-’, ‘*’, ‘/’}

N = {Digit, Int, Number, Letter, Variable, Expression, Addend, Factor)

P = {
<Expression> ::= <Addend> { ‘+’ <Addend> | ‘–‘ <Addend> }
<Addend> ::= <Factor> { ‘*’ <Factor> | ‘/‘ <Factor> }
<Fac> ::= <Variable> | <Number> | ‘(‘ <Expression> ‘)’
<Digit> ::= ‘0’ | ‘1’ | ‘2’ | ‘3’ | ‘4’ | ‘5’ | ‘6’ | ‘7’ | ‘8’ | ‘9’
<Int> ::= <Digit> { <Digit> }
<Number> ::= <Int> ’.’ [<Int>]
<Letter> ::= ‘a’ | 'b' | ..  | ’z’ | ‘A’ | 'B' | .. | ‘Z’
<Variable> ::= <L> { <L> | <Z> | ‘_’ }
}

S ::= <Expression>
*/

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace TFCS_2
{
    public class BinTree // BinTree root
    {
        public BinTree()
        {
        }
        public string Info { get; set; }
        public BinTree Left { get; set; }
        public BinTree Right { get; set; }
    }

    class Program
    {
        static string s = "";
        static string error = "";
        static int tick = -1;
        static int m = 0;
        static BinTree Root = null;
        static BinTree Node = new BinTree();
        static Dictionary<string, double> dict = new Dictionary<string, double>();
        static BinTree AddNewNode(string s) //Adding new node
        {
            BinTree NewNode = new BinTree();
            NewNode.Info = s;
            NewNode.Left = null;
            NewNode.Right = null;
            return NewNode;
        }
        static BinTree Expression() // Expression parse
        {
            if (Is() && error == "" && (Letter(s[m]) || Digit(s[m]) || s[m] == '('))
            {
                BinTree mid = null;
                BinTree left = Addend();

                while (Is() && error == "" && (s[m] == '+' || s[m] == '-'))
                {
                    string sym = s[m].ToString();
                    Next();

                    BinTree right = Addend();
                    mid = AddNewNode(sym);
                    mid.Left = left;
                    mid.Right = right;
                    left = mid;
                }
                /*
                if (Is() && error == "")
                {
                    error = "Operator expected\n";
                    tick = m;
                    return null;
                }
                */
                return left;
            }
            else
            {
                error = "Number, variable or '(' expected\n";
                tick = m;
                return null;
            }
        }
        static BinTree Addend() // Addend parse
        {
            if (Is() && error == "" && (Letter(s[m]) || Digit(s[m]) || s[m] == '('))
            {
                BinTree mid = null;
                BinTree left = Factor();
                while (Is() && error == "" && (s[m] == '*' || s[m] == '/'))
                {
                    string sym = s[m].ToString();
                    Next();
                    if (Is())
                    {
                        BinTree right = Factor();
                        mid = AddNewNode(sym);
                        mid.Left = left;
                        mid.Right = right;
                    }
                    else
                    {
                        error = "Number, variable or '(' expected\n";
                        tick = m;
                        return null;
                    }
                    left = mid;
                }
                return left;
            }
            else
            {
                error = "Number, variable or '(' expected\n";
                tick = m;
                return null;
            }
        }
        static BinTree Factor() // Factor parse
        {
            if (Is() && error == "" && Letter(s[m]))
            {
                return AddNewNode(Variable());
            }
            else
            {
                if (Is() && Digit(s[m]))
                {
                    return AddNewNode(Number());
                }
                else
                {
                    if (Is() && s[m] == '(')
                    {
                        Next();
                        BinTree mid = Expression();
                        if (Is() && s[m] == ')')
                        {
                            Next();
                            return mid;
                        }
                        else
                        {
                            error = "')' expected\n";
                            tick = m;
                            return null;
                        }
                    }
                    else
                    {
                        error = "Number, variable or '(' expected\n";
                        tick = m;
                        return null;
                    }
                }
            }
        }
        static string Number() // Number parse
        {
            char[] ar = new char[0];
            while (Is() && Digit(s[m]))
            {
                ar = Add(ar, s[m]);
                m++;
            }
            if (Is() && s[m] == ',')
            {
                ar = Add(ar, s[m]);
                m++;

                while (Is() && Digit(s[m]))
                {
                    ar = Add(ar, s[m]);
                    m++;
                }
            }
            if (Is() && s[m] == ' ')
            {
                Next();
            }

            return new string(ar);
        }
        static string Variable() // Variable parse
        {
            char[] ar = new char[0];
            while (Is() && (Letter(s[m]) || Digit(s[m]) || s[m] == '_'))
            {
                ar = Add(ar, s[m]);
                m++;
            }
            if (Is() && s[m] == ' ')
            {
                Next();
            }
            string var = new string(ar);
            return var;
        }
        static void Next() // Getting to the next meaningful symbol
        {
            m++;
            while (Is() && s[m] == ' ')
            {
                m++;
            }
        }
        static bool Is() // Element exists
        {
            return m < s.Length;
        }
        static bool Letter(char sym) // Symbol is a letter
        {
            return char.IsLetter(sym);
        }
        static bool Digit(char sym) // Symbol is a digit
        {
            return char.IsDigit(sym);
        }
        static char[] Add(char[] ar, char sym) // Adding the element to char array end
        {
            char[] newAr = new char[ar.Length + 1];
            int i = 0;
            for (i = 0; i < ar.Length; i++)
            {
                newAr[i] = ar[i];
            }
            newAr[i] = sym;
            return newAr;
        }
        static string[] Add(string[] ar, string strToAdd) // Adding the element to string array end
        {
            string[] newAr = new string[ar.Length + 1];
            int i = 0;
            for (i = 0; i < ar.Length; i++)
            {
                newAr[i] = ar[i];
            }
            newAr[i] = strToAdd;
            return newAr;
        }
        static void PrintTree(BinTree Root) // BinTree print
        {
            if (Root != null)
            {
                PrintTree(Root.Left);
                Console.Write(" ");
                PrintTree(Root.Right);
                Console.Write(" ");
                Console.Write(Root.Info);
            }
        }
        static double Calcul(BinTree R) // Calculating RPN
        {
            if (Digit(R.Info[0]))
            {
                return Convert.ToDouble(R.Info);
            }
            else
            {
                if (R.Info == "+")
                {
                    return Calcul(R.Left) + Calcul(R.Right);
                }
                else
                {
                    if (R.Info == "-")
                    {
                        return Calcul(R.Left) - Calcul(R.Right);
                    }
                    else
                    {
                        if (R.Info == "*")
                        {
                            return Calcul(R.Left) * Calcul(R.Right);
                        }
                        else
                        {
                            if (R.Info == "/")
                            {
                                double rRight = Calcul(R.Right);
                                if (rRight == 0)
                                {
                                    error = "Division by zero error";
                                }
                                else
                                {
                                    return Calcul(R.Left) / rRight;
                                }
                            }
                            else
                            {
                                if (Letter(R.Info[0]))
                                {
                                    if (dict.ContainsKey(R.Info))
                                    {
                                        return dict[R.Info];
                                    }
                                    else
                                    {
                                        bool ok;
                                        double value;
                                        do
                                        {
                                            Console.Write(R.Info + ": ");
                                            ok = double.TryParse(Console.ReadLine(), out value);
                                            if (!ok)
                                            {
                                                Console.ForegroundColor = ConsoleColor.Red;
                                                Console.WriteLine("Integer or real value expected");
                                                Console.ResetColor();
                                            }
                                        } while (!ok);
                                        dict.Add(R.Info, value);
                                        return value;
                                    }
                                }
                            }
                        }
                    }
                }
            }

            return 0;
        }

        static void Main(string[] args) // Entering point
        {
            Console.Clear();
            Console.WriteLine("Enter an expression");
            Console.WriteLine();

            s = Console.ReadLine();

            if (s != "")
            {
                if (s[0] == ' ')
                {
                    Next();
                }
                Root = Expression();

                if (error == "" && m < s.Length)
                {
                    error = "Operator expected\n";
                    tick = m;
                }
                if (error != "")
                {
                    for (int i = 0; i < tick; i++)
                    {
                        Console.Write(' ');
                    }
                    Console.ForegroundColor = ConsoleColor.Red;
                    Console.Write("^");
                    Console.WriteLine();
                    Console.WriteLine(error);
                    Console.ResetColor();
                }
                else
                {

                    Console.WriteLine();
                    Console.Write("RPN:");
                    PrintTree(Root);
                    Console.WriteLine();
                    Console.WriteLine();

                    double res = Calcul(Root);

                    if (error == "")
                    {
                        Console.WriteLine(s + " = " + res);
                    }
                    else
                    {
                        Console.ForegroundColor = ConsoleColor.Red;
                        Console.WriteLine(error);
                        Console.ResetColor();
                    }
                }
            }
            Console.WriteLine();
        }
    }
}