guiyue.txt

找可规约串进行规约

using System;
using System.Collections.Generic;
using System.Text;

namespace 编译实验3
{
    class Program
    {
        static void Main(string[] args)
        {
            string[] expression ={ "E->E+T|T", "T->T*F|F", "F->(E)|i" };
            bool[,] FirstVT = new bool[3, 5];
            bool[,] LastVT = new bool[3, 5];
            Stack<string> stack = new Stack<string>();
            string[] noendArry ={"E","T","F"};
            string[]  endArry={ "+", "*", "(", ")", "i" ,"#"};
            List<string> end = new List<string>(endArry);
            List<string> noend = new List<string>(noendArry);
            char[,] table = new char[6, 6];
           //求firstvt的集合
            for (int i = 0; i < FirstVT .GetLength (0); i++)
            {
                for (int j = 0; j < FirstVT .GetLength (1); j++)
                {
                    FirstVT[i, j] = false;
                }
            }
            for (int i = 0; i < expression .Length; i++)
            {
               //确定产生式的第一个字母是否为终结符
                int index=end.IndexOf(expression[i][3].ToString ());
                if (index!=-1&& FirstVT[i, index] ==false)
                {
                        stack.Push( noend[i]+expression[i][3]);
                        FirstVT[i, index] = true;
                }
                //确定产生式第一个字母为非终结符，第二个字母为终结符
                int index1=noend.IndexOf(expression[i][3].ToString ());
                int index2=end.IndexOf(expression[i][4].ToString ());
                if (index1 != -1 && index2 != -1 && FirstVT[i, index2] == false)
                {
                    stack.Push(noend[i] + expression[i][4]);
                    FirstVT[i, index2] = true;
                }
                //确定产生式的第二个表达式的第一个字母是否为终结符
                int index3 = end.IndexOf(expression[i][7].ToString ());
                if (index3 != -1 && FirstVT[i, index3] == false)
                {
                    stack.Push(noend[i] + expression[i][7]);
                    FirstVT[i, index3] = true;
                }
            }
            while (stack.Count != 0)
            {
                string element = stack.Pop();
                for (int i = 0; i < expression .Length; i++)
                {
                    if (expression[i][3] == element[0]&&FirstVT[i,end.IndexOf (element[1].ToString ())]==false)
                    {
                        stack.Push(noend[i] + element[1]);
                        FirstVT[i, end.IndexOf(element[1].ToString())] = true;
                    }
                    if (expression[i][7] == element[0] && FirstVT[i, end.IndexOf(element[1].ToString())] == false)
                    {
                        stack.Push(noend[i] + element[1]);
                        FirstVT[i, end.IndexOf(element[1].ToString())] = true;
                    }
                }
            }
            //打印FirstVT集合
            Console.WriteLine("FirstVT集为：");
            for (int i = 0; i < FirstVT .GetLength (0); i++)
            {
                for (int j = 0; j< FirstVT .GetLength (1); j++)
                {
                    Console.Write(FirstVT[i,j]+" ");
                }
                Console.WriteLine();
            }
          //求Lastvt的集合
            for (int i = 0; i < LastVT.GetLength(0); i++)
            {
                for (int j = 0; j <LastVT.GetLength(1); j++)
                {
                   LastVT[i, j] = false;
                }
            }
            for (int i = 0; i < expression.Length; i++)
            {
                //确定产生式的倒数第一个字母是否为终结符
                int index = end.IndexOf(expression[i][4].ToString());
                if (index != -1 && LastVT[i, index] == false)
                {
                    stack.Push(noend[i] + expression[i][4]);
                    LastVT[i, index] = true;
                }
                //确定产生式的倒数第一个字母为非终结符，倒数第二个字母为终结符
                int index1 = noend.IndexOf(expression[i][4].ToString());
                int index2 = end.IndexOf(expression[i][5].ToString());
                if (index1 != -1 && index2 != -1 && LastVT[i, index2] == false)
                {
                    stack.Push(noend[i] + expression[i][5]);
                    LastVT[i, index2] = true;
                }
                //确定产生式的第二个表达式的倒数第一个字母是否为终结符
                int index3 = end.IndexOf(expression[i][7].ToString());
                if (index3 != -1 && LastVT[i, index3] == false)
                {
                    stack.Push(noend[i] + expression[i][7]);
                    LastVT[i, index3] = true;
                }
            }

            while (stack.Count != 0)
            {
                string element = stack.Pop();
                for (int i = 0; i < expression.Length; i++)
                {
                    if (expression[i][5] == element[0] && LastVT[i, end.IndexOf(element[1].ToString())] == false)
                    {
                        stack.Push(noend[i] + element[1]);
                        LastVT[i, end.IndexOf(element[1].ToString())] = true;
                    }
                    if (expression[i][7] == element[0] && LastVT[i, end.IndexOf(element[1].ToString())] == false)
                    {
                        stack.Push(noend[i] + element[1]);
                        LastVT[i, end.IndexOf(element[1].ToString())] = true;
                    }
                }
            }
            Console.WriteLine();
            //打印LastVT集合
            Console.WriteLine("LastVT集为：");
            for (int i = 0; i < LastVT.GetLength(0); i++)
            {
                for (int j = 0; j < LastVT.GetLength(1); j++)
                {
                    Console.Write(LastVT[i, j] + " ");
                }
                Console.WriteLine();
            }
            //求算符优先表
            for (int i = 0; i < expression .Length ; i++)
            {
                for (int j = 3 ; j < expression [i].Length -3; j++)
                {
                    int index3;
                    int index = end.IndexOf(expression[i][j].ToString ());
                    int index4 = noend.IndexOf(expression[i][j].ToString ());
                    int index1 = end.IndexOf(expression[i][j + 1].ToString ());
                    int index2 = noend.IndexOf(expression[i][j + 1].ToString ());
                    if (index == -1 && index1 == -1)
                    {
                        table[index,index1] = '=';
                    }
                    if (j <= expression[i].Length - 4 &&(index3= end.IndexOf(expression[i][j + 2].ToString ()))!=-1&&index!=-1)
                    {
                        if (index2 != -1)
                        {
                            table[index,index3] = '=';
                        }
                    }
                    if (index != -1 && index2 != -1)
                    {
                        for (int k = 0; k < 5; k++)
                        {
                            if (FirstVT[index2,k] == true)
                            {
                                table[index,k] = '<';
                            }
                        }
                    }
                    if (index4 != -1 && index1 != -1)
                    {
                        for (int k = 0; k < 5; k++)
                        {
                            if (LastVT[index4, k] == true)
                            {
                                table[k, index1] = '>';
                            }
                        }
                    }

                }
            }
            for (int i = 0; i <5; i++)
            {
                if (FirstVT[0, i] == true)
                {
                    table[5,i] = '<';
                }
                if (LastVT[0, i] == true)
                {
                    table[i, 5] = '>';
                }
            }
            table[5, 5] = '=';
            //打印算符优先表
            Console.WriteLine();
            Console.WriteLine("算符优先表为：");
            Console.Write("  ");
            for (int i = 0; i < end.Count; i++)
            {
                Console.Write(end[i]+" ");
            }
            Console.WriteLine();
            for (int i = 0; i < table.GetLength(0); i++)
            {
                Console.Write(end[i]+" ");
                for (int j = 0; j < table.GetLength (1); j++)
                {
                    Console.Write(table[i,j]+" ");
                }
                Console.WriteLine();
            }
            Console.WriteLine("请输入要规约的句子以#结尾：");
            string sentence = Console.ReadLine();
            int top = 1;
            int h,next=0;
            char a;
            char[] s = new char[20];
            s[0]=' ';
            s[1] = '#';
            Console.WriteLine(s[1]);
            do
            {
                a = sentence[next];
                h = top;
                //bool yes1;
                int index0=-1;
                int index=end.IndexOf(s[top].ToString());
                int index1=end.IndexOf(a.ToString());
                bool yes=(table[index,index1]=='>');
            //找到了可规约串
                while(yes)
                {
                    //寻找可规约串
                    //do
                    //{
                    //    char q=s[h];
                    //    int index2=end.IndexOf(s[h-1].ToString());
                    //    if(index2!=-1)
                    //    {
                    //        h=h-1;
                    //    }
                    //    else
                    //    {
                    //        h=h-2;
                    //    }
                    //    int index11 = end.IndexOf(s[h].ToString());
                    //   // if (index != -1 && index11 != -1)
                    //    //{
                    //        yes1 = (table[index11, index] == '<');
                    //   // }
                    //   // else
                    //   // {
                    //    //    yes1 = (table[index0, index11] == '>');
                    //   // }
                    //}
                    //while(!yes1);
                  //  int j = h;
                    //用产生式进行规约
                    for (int i = 0; i < 3; i++)
                    {
                        bool guiyue=false;
                        h = top;
                        for (int m = 5; m >2; m--)
                        {
                           
                            int index4=end.IndexOf(expression[i][m].ToString ());
                            int index5 = end.IndexOf(s[h].ToString());
                            if (index4 != -1 && index5 != -1 && end[index4] == s[h].ToString())
                            {
                                h--;
                            }
                            else
                            {
                                if (index4 == -1 && index5 == -1)
                                {
                                    h--;
                                }
                                else break;
                            }
                            if(m==3)
                            {
                                s[h+1] = expression[i][0];
                                top = h+1;
                                guiyue = true;
                                for (int j = 1; j<=top; j++)
                                {
                                    Console.Write(s[j]);
                                }
                                Console.WriteLine();
                            }
                        }
                        if (guiyue==true) break;
                        h = top;
                        int index6 = end.IndexOf(expression[i][7].ToString());
                        if (index6!= -1 && end[index6] == s[h].ToString())
                        {
                            s[h] = expression[i][0];
                            top = h;
                            guiyue = true;
                            for ( int j = 1; j <= top; j++)
                            {
                                Console.Write(s[j]);
                            }
                            Console.WriteLine();
                        }
                        if (guiyue==true) break;
                    }
                   // index = end.IndexOf(s[top].ToString());
                    index1 = end.IndexOf(a.ToString());
                    index0 = end.IndexOf(s[top - 1].ToString());
                  //  if (index != -1 && index1 != -1)
                 //   {
                  //      yes = (table[index, index1] == '>');
                  //  }
                  //  else
                  //  {
                        yes = (table[index0, index1] == '>');
                  //  }
                }
           // 找到了可规约串
               // bool yesless = (table[index, index1] == '<');
               // bool yesequal = (table[index, index1] == '=');
               // if (yesless  || yesequal)
               //{
                    top++;
                    s[top] = a;
                    for (int i = 1; i <= top; i++)
                    {
                        Console.Write(s[i]);
                    }
                    Console.WriteLine();
                //}
                //else
                //{
                //    Console.WriteLine("句子错误");
                //    return;
                //}
                next++;
            } 
            while (a != '#');
            Console.ReadLine();
        }
    }
}