算符優先分析及其簡單代碼實現

我們可以以下面的文法為例子進行算符優先分析：

E→E+T|T

T→T*F|F

F→(E)|i

FIRSTVT和LASTVT的構建

首先我們要通過文法規則來產生相應的FIRSTVT和LASTVT集，具體的構建規則如下：

FIRSTVT：

　若出現 E→a... 或 E→Aa 的情況，則 a∈FIRSTVT【E】，即產生式右部的第一個終結符屬於左部非終結符的FIRSTVT集

　若出現 E→A... 的情況，則 FIRSTVT【A】∈FIRSTVT【E】，即產生式右部開頭若是非終結符的情況下，該終結符的FIRSTVT屬於左部非終結符的FIRSTVT集

LASTVT：

　若出現 E→...a 或 E→...aA 的情況，則 a∈LASTVT【E】，即產生式右部倒數第一個終結符屬於左部非終結符的FIRSTVT集

　若出現 E→...A 的情況，則 LASTVT【A】∈LASTVT【E】，集產生式右部尾部若是非終結符的情況下，該終結符的LASTVT屬於左部非終結符的LASTVT集

通過以上方法得到的FIRSTVT和LASTVT集如下：

FIRSTVT：

　　FIRSTVT【E】={ ( , i , + , * }

　　FIRSTVT【T】 = { ( , i , * }

　　FIRSTVT【F】 = { ( , i }

LASTVT：

　　LASTVT【E】 = { ) , i , + , * }

　　LASTVT【T】 = { ) , i , * }

　　LASTVT【F】 = { ) , i }

算符優先關系表的構造

得到了文法的FIRSTVT和LASTVT集以后，我們需要通過它來得到算符優先關系表，具體構造方法如下：

　　若出現 E→...ab... 或者 E→....aAb... 的情況：a = b

　　若出現 E→...aA.. 且 b∈FIRSTVT【A】的情況：a < b

　　若出現 E→...Ab...且 a∈LASTVT【A】的情況：a > b

用此方法構造的算符優先分析表如下所示：

　　

	i	+	*	(	)	#
i		>	>		>	>
+	<	>	<	<	>	>
*	<	>	>	<	>	>
(	<	<	<	<	=
)		>	>		>	>
#	<	<	<	<		=

注：在討論#與其他終結符的優先級時，可以添加E→#E#來完成

算符優先分析

算符優先分析采用的是移進-歸約法，取符號棧中最左素短語的終結符，並將其與輸入串頭的元素進行優先級比較，若優先關系為 ">" ，則進行歸約，若為 "<" 或 "=" 則將輸入串頭元素壓入符號棧。

我們以i+i*i為例來進行算符優先分析：　

　　

符號棧	輸入串	動作#
#	i+i*i#	移進
#i	+i*i#	歸約
#E	+i*i#	移進
#E+	i*i#	移進
#E+i	*i#	歸約
#E+E	*i#	移進
#E+E*	i#	移進
#E+E*i	#	歸約
#E+E*E	#	歸約
#E+E	#	歸約
#E	#	結束

　　

注：算符優先分析中不關心非終結符的優先關系，因此我們在歸約的時候可以不用考慮字符串被歸約到了哪個非終結符。

 

參考代碼

用c#進行實現，代碼冗余極多，效率很低，泛用性不足，各種考慮不全面的情況也很多，大家權當做個參考。

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

namespace 算符優先分析
{

    class Program
    {
        /*-------------------------------變量聲明---------------------------------------------------------------------------------------*/
        static string effectValue = "i+*()#";   //有效的字符集合
        static List<string> grammarList = new List<string>();   //文法列表
        static Dictionary<string, List<string>> grammarDic = new Dictionary<string, List<string>>();    //文法字典
        static Dictionary<string, List<string>>.KeyCollection vertex;   //非終結符集合
        static Dictionary<string, string> firstVT = new Dictionary<string, string>();   //firstVT集
        static Dictionary<string, string> lastVT = new Dictionary<string, string>();    //lastVT集
        static char[,] priorityTable = new char[7,7];   //算符優先關系表
        static string message;      //要分析的字符串
        static MyStack stack = new MyStack();


        /*----------------------------主函數--------------------------------------------------------------------------------------------*/
        static void Main(string[] args)
        {
            inputGrammar();    //獲得文法字符串
            getVT();           //獲得firstVT和lastVT
            printVT();         //輸出firstVT和lastVT
            getPriorityTable();//得到優先關系表
            printPriorityTable();//打印優先關系表
            inputMessage();     //獲得要分析的字符串

            //判斷字符串是否符合要求
            if (judgeMessage())
                //進行算符優先分析
                if (analyze())
                    Console.WriteLine("分析成功！該句子符合算符優先。");
                else Console.WriteLine("分析失敗！該句子不符合算符優先。");
        }

        /*---------------------------------------輸入數據---------------------------------------------------------------------*/
        static void inputGrammar()
        {
            Console.WriteLine("該系統支持的終結符有：i,+,*,(,)，請勿輸入其他終結符！");
            Console.WriteLine("請輸入要分析的文法：（在單獨一行輸入#結束輸入）");
            Console.WriteLine("如：E→E+T|T\nT→T*F|F\nF→(E)|i\n#\n");
            while (true)
            {
                string str = Console.ReadLine();
                if (str.Equals("#"))
                    break;
                else grammarList.Add(str);
            }
            //將文法轉存為文法字典保存
            foreach (string str in grammarList)
            {
                List<string> l1 = new List<string>();
                string[] s1 = str.Split('→');
                string[] s2 = s1[1].Split('|');
                foreach (string s in s2)
                    l1.Add(s);
                grammarDic.Add(s1[0], l1);
            }
            vertex = grammarDic.Keys;   //將文法字典的key值給vector
        }

        /*---------------------------------------得到firstVT和lastVT----------------------------------------------------------*/
        static void getVT()
        {
            //第一遍遍歷，將第一個非終結符和在串頭的終結符加入firstVT
            foreach (string v in vertex)
            {
                List<string> l = grammarDic[v];
                foreach (string s in l)
                {
                    getFirstVT(s, v);
                    getLastVT(s, v);
                }
            }
            trimFirstVT();
            trimLastVT();

        }

        //得到firstVT
        static void getFirstVT(string s, string v)
        {
            //從前往后，找合適字符加入firstVT
            for (int i = 0; i < s.Length; i++)
            {
                string t = Convert.ToString(s[i]);
                //如果是非終結符，且在字符串最前，將其加入firstVT
                if (grammarDic.ContainsKey(t) && i == 0)
                    if (firstVT.ContainsKey(v))
                        if (!firstVT[v].Contains(t))
                            firstVT[v] += t;
                        else firstVT.Add(v, t);
                //將第一個終結符加入firstVT
                if (!grammarDic.ContainsKey(t))
                {
                    if (firstVT.ContainsKey(v))
                        firstVT[v] += t;
                    else firstVT.Add(v, t);
                    break;
                }
            }
        }
        
        //得到lastVT
        static void getLastVT(string s, string v)
        {
            //從后往前，找合適字符加入lastVT
            for (int i = s.Length - 1; i >= 0; i--)
            {
                string t = Convert.ToString(s[i]);
                //如果是非終結符，且在字符串最后，將其加入lastVT
                if (grammarDic.ContainsKey(t) && i == s.Length - 1)
                    if (lastVT.ContainsKey(v))
                        if (!lastVT[v].Contains(t))
                            lastVT[v] += t;
                        else lastVT.Add(v, t);
                //將最后一個終結符加入firstVT
                if (!grammarDic.ContainsKey(t))
                {
                    if (lastVT.ContainsKey(v))
                        lastVT[v] += t;
                    else lastVT.Add(v, t);
                    break;
                }
            }
        }

        //將firstVT中的終結符去掉
        static void trimFirstVT()
        {
            //逆序遍歷終結符集（必須逆序）
            foreach (string v in vertex.Reverse())
            {
                string s1 = firstVT[v];
                for (int i = 0; i < s1.Length; i++)
                {
                    string t = Convert.ToString(s1[i]);
                    //若firstVT集中含有終結符，進行整理
                    if (grammarDic.ContainsKey(t))
                    {
                        firstVT[v] = firstVT[v].Replace(t, ""); //刪除此終結符
                        string s2 = firstVT[t];
                        //將此終結符的firstVT集添加進來
                        for (int j = 0; j < s2.Length; j++)
                        {
                            if (!s1.Contains(s2[j]) && !grammarDic.ContainsKey(Convert.ToString(s2[j])))
                                firstVT[v] += s2[j];
                        }
                    }
                }
            }
        }

        //將firstVT中的終結符去掉，過程同trimFirstVT()
        static void trimLastVT()
        {
            foreach (string v in vertex.Reverse())
            {
                string s1 = lastVT[v];
                for (int i = 0; i < s1.Length; i++)
                {
                    string t = Convert.ToString(s1[i]);
                    if (grammarDic.ContainsKey(t))
                    {
                        lastVT[v] = lastVT[v].Replace(t, "");
                        string s2 = lastVT[t];
                        for (int j = 0; j < s2.Length; j++)
                        {
                            if (!s1.Contains(s2[j]) && !grammarDic.ContainsKey(Convert.ToString(s2[j])))
                                lastVT[v] += s2[j];
                        }
                    }
                }
            }
        }

        /*------------------------------------------------------打印firstVT和lastVT------------------------------------------------------*/
        static void printVT()
        {
            //輸出firstVT
            Console.WriteLine("\nfirstVT：");
            foreach (string s in firstVT.Keys)
            {
                Console.Write("firstVT " + s + " : ");
                for (int i = 0; i < firstVT[s].Length; i++)
                    Console.Write(firstVT[s][i] + "  ");
                Console.WriteLine("");
            }
            //輸出lastVT
            Console.WriteLine("lastVT：");
            foreach (string s in lastVT.Keys)
            {
                Console.Write("lastVT " + s + " : ");
                for (int i = 0; i < lastVT[s].Length; i++)
                    Console.Write(lastVT[s][i] + "  ");
                Console.WriteLine();
            }
        }

        /*--------------------------------------------------------算符優先關系表----------------------------------------------------*/
        //得到算符優先關系表
        static void getPriorityTable()
        {
            //添加文法：E→#E#
            string str = vertex.FirstOrDefault();
            grammarDic[str].Add("#" + str + "#");
            int i1, j1;
            //對優先關系表進行初始化
            for (int i = 1; i <= effectValue.Length; i++)
            {
                priorityTable[0,i] = effectValue[i - 1];
                priorityTable[i,0] = effectValue[i - 1];
            }
            //對產生式右部進行遍歷
            foreach (string v in vertex)
            {
                List<string> g = grammarDic[v];
                foreach (string s in g)
                {
                    for (int i = 0; i < s.Length; i++)
                    {
                        string t = Convert.ToString(s[i]);
                        //若只有一個非終結符，則#=#
                        if (s.Length == 1)
                        {
                            if (grammarDic.ContainsKey(t))
                                priorityTable[6, 6] = '=';
                        }
                        else
                        {
                            if (i > 0)
                            {
                                string tp = Convert.ToString(s[i - 1]);
                                //出現ab型的產生式，則a=b
                                if ((!grammarDic.ContainsKey(tp)) && (!grammarDic.ContainsKey(t)))
                                {
                                    i1 = effectValue.IndexOf(tp);
                                    j1 = effectValue.IndexOf(t);
                                    priorityTable[i1, j1] = '=';
                                }
                                //出現aA型的產生式，則a<firstVT[A]
                                if ((!grammarDic.ContainsKey(tp)) && grammarDic.ContainsKey(t))
                                {
                                    i1 = effectValue.IndexOf(tp)+1;
                                    string fir = firstVT[t];
                                    for (int j = 0; j < fir.Length; j++)
                                    {
                                        j1 = effectValue.IndexOf(fir[j])+1;
                                        priorityTable[i1, j1] = '<';
                                    }
                                }
                                //出現Aa型的產生式，則lastVT[A]>a
                                if(grammarDic.ContainsKey(tp) && (!grammarDic.ContainsKey(t)))
                                {
                                    j1 = effectValue.IndexOf(t) + 1;
                                    string lat = lastVT[tp];
                                    for(int j=0;j<lat.Length;j++)
                                    {
                                        i1 = effectValue.IndexOf(lat[j]) + 1;
                                        priorityTable[i1, j1] = '>';
                                    }
                                }
                                if(i<s.Length-1)
                                {
                                    string tn = Convert.ToString(s[i + 1]);
                                    //出現aAb型的產生式，則a=b
                                    if((!grammarDic.ContainsKey(tp)) && grammarDic.ContainsKey(t) && (!grammarDic.ContainsKey(tn)))
                                    {
                                        i1 = effectValue.IndexOf(tp)+1;
                                        j1 = effectValue.IndexOf(tn)+1;
                                        priorityTable[i1, j1] = '=';
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }

        //輸出算符優先關系表
        static void printPriorityTable()
        {
            Console.WriteLine("\n算符優先關系表如下：");
            for (int i = 0; i < 7; i++)
            {
                for (int j = 0; j < 7; j++)
                    Console.Write(priorityTable[i,j] + "\t");
                Console.WriteLine("\n");
            }
        }

        /*-------------------------------------------算符優先分析-----------------------------------------------------------------*/
        //得到要分析的字符串
        static void inputMessage()
        {
            Console.WriteLine("\n該分析器只能識別i,+,*,(,),#，請勿輸入其他字符！");
            Console.WriteLine("請輸入要分析的字符串，用#結尾（如i+i*i#）");
            message = Console.ReadLine();
        }
        
        //檢測輸入的字符串是否符合要求
        static Boolean judgeMessage()
        {
            //檢測輸入的字符串是否合法
            bool isLegal = true;
            bool flag = true;
            if (message[message.Length - 1] != '#')
            {
                Console.WriteLine("字符串必須以#結尾！");
                flag = false;
            }
            for (int i = 0; i < message.Length; i++)
                if (!effectValue.Contains(message[i]))
                    isLegal = false;
            if (!isLegal)
            {
                Console.WriteLine("該字符串中含有非法字符！");
                flag = false;
            }

            return flag;
        }

        //進行算符優先分析
        static Boolean analyze()
        {
            bool flag = true;
            stack.push("#");    //對棧進行初始化

            //對待處理串中的每個字符進行遍歷
            for (int i = 0; i < message.Length; )
            {
                string s = stack.getString();   //獲得棧中數據
                int j = s.Length - 1;

                //尋找棧中第一個終結符
                while (grammarDic.ContainsKey(s[j].ToString()) || s[j] == 'E')
                {
                    j--;
                }

                //獲取棧中第一個終結符，與字符串頭元素在優先表中的位置
                int i1 = effectValue.IndexOf(s[j]) + 1;
                int j1 = effectValue.IndexOf(message[i]) + 1;

                //優先表值進行相應的操作
                switch (priorityTable[i1, j1])
                {
                    case '<': moveIn(i); i++; break;
                    case '=': moveIn(i); i++; break;
                    case '>': flag = reduction(i,j); break;
                    default: break;
                }

                //分析完成輸出結果
                if (stack.getString().Equals("#E") && i >= message.Length-1)
                {
                    Console.WriteLine(stack.getString() + "\t\t" + message.Substring(i) +  "\t\t" + "分析完成");
                    break;
                }
                //分析失敗退出循環
                if (!flag)
                    break;
            }
            return flag;
        }

        //移進操作
        static void moveIn(int i)
        {
            Console.WriteLine(stack.getString() + "\t\t" + message.Substring(i) + "\t\t移進");
            stack.push(message[i].ToString());
        }

        //歸約操作
        static Boolean reduction(int n,int i)
        {
            string s = stack.getString();
            bool flag = true;
            int k = i-1;

            //遍歷每一個文法
            foreach (string v in vertex)
            {
                string c = s[i].ToString();
                List<string> list = grammarDic[v];
                foreach (string g in list)
                {
                    if (g.Contains(c))
                    {
                        Console.WriteLine(s + "\t\t" + message.Substring(n) + "\t\t規約");
                        if (c == "i")
                        {
                            //防止多個i連一起的情況發生
                            if (s[i - 1] == 'i')
                                flag = false;
                            else
                            {
                                stack.pop();
                                stack.push("E");
                            }
                        }
                        else if (s.Length > g.Length)
                        {
                            for (int j = 0; j < g.Length; j++)
                                stack.pop();
                            stack.push("E");
                        }
                        //開頭不能為運算符
                        else if (s[i - 1] != 'i')
                            flag = false;
                    }
                }
            }
            return flag;
        }

        /*----------------------------------------------------堆棧操作--------------------------------------------------------------*/
        //系統自帶的堆棧不是很好用，於是我自己寫了一個
        class MyStack
        {
            string data;
            int top;
            public MyStack()
            {
                data = "";
                top = -1;
            }
            public void push(string s)
            {
                data += s;
                top++;
            }
            public string pop()
            {
                data = data.Substring(0, data.Length - 1);
                top--;
                return data;
            }
            public string getString()
            {
                return data;
            }
        }
    }
}

運行結果