SLR 分析法 C# 实现 - 解析语法分析器的核心代码

{
//产生式结点类
public class SLRNode
{
public string Left;
public string Right;
public SLRNode(string Left, string Right)
{
this.Left = Left;
this.Right = Right;
}
}
//项目集类
public class SLRitemsets
{
public List Container
= new List(100);
//记录项目在项目集合中的序号
}

//DFA结点  
public struct DFA  
{  
    public int from;  
    public char symbol;  
    public int to;  
    public DFA(int from, char symbol, int to)  
    {  
        this.from = from;  
        this.symbol = symbol;  
        this.to = to;  
    }  
}  

//分析表 结点  
public class Table  
{  
    public bool error;//是否为ERROR  
    public char type;//结点类型  
    public int id;//数值  
    public Table()  
    {  
        this.error = true;  
    }  
    public Table(char type, int id)  
    {  
        this.type = type;  
        this.id = id;  
        this.error = false;  
    }  
}  

//分析句子  
public class Analyze  
{  
    public List<string> stack_state = new List<string>(100);//记录状态栈  
    public List<string> stack_symbol = new List<string>(100);//记录符号栈  
    public List<string> Input_str = new List<string>(100);//记录输入串  
    public List<string> Tran_pro = new List<string>(100);//记录所用产生式  
}  

public DFA[] dfa = new DFA[100];  
public int Pindex = 0; //dfa数组指针  
public Table[][] SLRAna;//分析表  
public Analyze Jz;  
public bool Success = false;  
public List<SLRNode> SLRproNum = new List<SLRNode>(50);//产生式 列表  
public List<SLRNode> SLRobjNum = new List<SLRNode>(50);//项目 列表  
public List<SLRitemsets> proitemset = new List<SLRitemsets>(100);//项目集合  
public List<int> Gy_obj = new List<int>(50);//归约项目序号集合  
public List<int> Gy_itemset = new List<int>(50);//含有归约项目的集合的序号 的集合  
public List<char> Nchar = new List<char>(50);//非终结符集合  
public List<char> Echar = new List<char>(50);//终结符集合  

Dictionary<char, HashSet<char>> follow = new Dictionary<char, HashSet<char>>();//非终结符的Follow集  

public string RStr = '';  
public string RStr_obitemset = '';//输出返回  
public string RStr_DFA = '';  
public string RStr_ANA = '';  


public void Buildprod(string str)  
{  

    SLRNode SLr;  
    int i = 0;  
    string left = '';  
    string right = '';  
    left += 'S'';  
    right += str[0];  
    SLr = new SLRNode(left, right);//拓广文法开始  
    SLRproNum.Add(SLr);  
    while (i < str.Length)  
    {  
        left = right = '';//还原  
        int j = i;  
        while (i < str.Length && str[i] != '\r' && str[i] != '\n')//换行符‘\r\n’  
        {  
            if (str[i] == ' ')  
            {  
                i++;  
                continue;  
            }  
            if (str[i] == '|')                 //  遇到'|'可构造一条产生式  
            {  
                SLr = new SLRNode(left, right);  
                SLRproNum.Add(SLr);  
                right = '';                    //产生式左边相同 右边重新积累  
                i++;                           //跳过'|'  
                continue;  
            }  
            if ((i - j) == 0)  
            {  
                if (!exist(Nchar, str[i]))//如果非终结符集合中不存在str[i],加入Nchar  产生式左边 只有非终结符 不必判断终结符  
                    Nchar.Add(str[i]);  
                left += str[i++];  
            }  
            else if (i - j <= 2)  
                i++;  
            else  
            {  
                if (isFinalsymbol(str[i]) && !exist(Nchar, str[i]))//如果非终结符集合中不存在str[i],加入Nchar  isfinalsymbol 非终结符返回T 终结符返回F  
                    Nchar.Add(str[i]);  
                else if (!isFinalsymbol(str[i]) && !exist(Echar, str[i]))//产生式右边 需要判断终结符  
                    Echar.Add(str[i]);  
                right += str[i++];  
            }  


        }//while  

        i++;//跳过换行符  
        if (left != '' && right != '')  
        {  
            SLr = new SLRNode(left, right);//构造每一行最后一个产生式，不存在'|'时就是该行产生式本身  
            SLRproNum.Add(SLr);  
        }  
    }//while  
    Echar.Add('#');  

    //构造项目 对产生式集合LRproNum中的所有产生式都循环插'.'  
    SLRNode Lobj;  
    for (i = 0; i < SLRproNum.Count; i++)  
    {  
        left = '';  
        right = '';  
        for (int j = 0; j <= SLRproNum[i].Right.Length; j++)//j可以等于length  项目共length+1个  
        {  
            left = SLRproNum[i].Left;  
            right = CreObj(SLRproNum[i].Right, j);//在第j个位置插入'.'  
            if (j == SLRproNum[i].Right.Length && SLRobjNum.Count != 1)  
            {  
                //在产生式最后的位置插入. 即为归约项目   项目集中1号位置为接受项目  
                Gy_obj.Add(SLRobjNum.Count);//归约项目在项目集中的序号 不用+1 本身就是从0开始的  
            }  
            Lobj = new SLRNode(left, right);  
            SLRobjNum.Add(Lobj);  
            left = '';//还原  
            right = '';  
        }  
    }  
    Creteitemsets();//项目集  
    RStr_obitemset += '\r\n项目集构建：\r\n';  
    for (int j = 0; j < proitemset.Count; j++)  
    {  
        RStr_obitemset += 'I' + j.ToString() + ':' + '\r\n';  
        for (i = 0; i < proitemset[j].Container.Count; i++)  
        {  
            RStr_obitemset += SLRobjNum[proitemset[j].Container[i]].Left.ToString() + '->' + SLRobjNum[proitemset[j].Container[i]].Right.ToString() + '\r\n';  
        }  
    }  
    //return RStr_obitemset;  

}  




//求项目集  
public void Creteitemsets()  
{  
    List<int> lr_item = new List<int>(100);//记录项目的序号  
    lr_item.Add(0);  
    lr_item = Closure(lr_item);//构造初始项目集 求闭包  

    SLRitemsets LR_C = new SLRitemsets();  
    LR_C.Container = lr_item;//集合----项目集序号的集合  
    proitemset.Add(LR_C);//集合的集合----存放项目集序号集合 的集合  


    for (int i = 0; i < proitemset.Count; i++)//整体集合中 第i个项目集  
    {  
        proitemset[i].Container.Sort();//排序由小到大 后面用于判断是否存在的比较  
        int[] flag = new int[proitemset[i].Container.Count];  
        for (int fi = 0; fi < proitemset[i].Container.Count; fi++)//标志位，用来判断该序号是否已经构造  
        {  
            flag[fi] = 0;  
        }  

        for (int j = 0; j < proitemset[i].Container.Count; j++)//第i个项目集的第j个项目  
        {  
            if (flag[j] == 1)//如果已经访问过 就不再构造 找下一个项目  
                continue;  
            int index = proitemset[i].Container[j];  
            for (int pi = 0; pi < SLRobjNum[index].Right.Length - 1; pi++)//length-1是避免匹配到.在最后的规约项目  
            {  
                if (SLRobjNum[index].Right[pi] == '.')  
                {  

                    List<int> lr2_club = new List<int>(100);//记录项目的序号  
                    char symbol = SLRobjNum[index].Right[pi + 1];//记录.a转移状态a.的符号a  
                    lr2_club.Add((index + 1));//如果遇到.a形式的项目序号为index 那么项目a.的序号为index+1  
                    for (int m1 = j + 1; m1 < proitemset[i].Container.Count; m1++)  
                    {//在第i个项目集中找到了可以移动的.：.a  重新遍历第i个项目集j项目之后的 找到同样可以移动a的项目集  
                        int index2 = proitemset[i].Container[m1];  
                        for (int m2 = 0; m2 < SLRobjNum[index2].Right.Length - 1; m2++)  
                        {  
                            if (SLRobjNum[index2].Right[m2] == '.' && SLRobjNum[index2].Right[m2 + 1] == symbol)  
                            {  
                                flag[m1] = 1;//标记位置为1 已经访问 之后不再访问  
                                lr2_club.Add(index2 + 1);  
                            }  
                        }  
                    }  
                    lr2_club = Closure(lr2_club);//求闭包  
                    int value = isexist(lr2_club);  
                    if (value == -1)//-1表示不存在相同的  
                    {  
                        for (int m3 = 0; m3 < Gy_obj.Count; m3++)  
                        {  
                            if (isnexist(lr2_club, Gy_obj[m3]))  
                            {  
                                Gy_itemset.Add(proitemset.Count);  
                            }  
                        }  
                        SLRitemsets LR_C2 = new SLRitemsets();  
                        dfa[Pindex++] = new DFA(i, symbol, proitemset.Count);//count不用加1  本身从0开始  
                        LR_C2.Container = lr2_club;  
                        proitemset.Add(LR_C2);  
                    }  
                    else  
                    {  
                        dfa[Pindex++] = new DFA(i, symbol, value);  
                    }  
                    break;  
                }  
            }  
        }//end-forj  
    }//end-fori  

}//end-Cre_club  

public void SLRAnaly()  
{  
    Table tnode = new Table();  

    SLRAna = new Table[proitemset.Count][];  
    for (int i = 0; i < proitemset.Count; i++)  
        SLRAna[i] = new Table[Echar.Count + Nchar.Count];  

    for (int i = 0; i < proitemset.Count; i++)//初始化 赋予ERROR属性  
        for (int j = 0; j < Echar.Count + Nchar.Count; j++)//为终结符加r状态  
            SLRAna[i][j] = tnode;  

    tnode = new Table('A', 0);  
    SLRAna[1][FindID(Echar, '#')] = tnode;//项目集1必定是接受项目   构建[1][#]:acc的情况 先直接赋值好 dfa里没有  

    for (int i = 0; i < Gy_itemset.Count; i++)  
    {  
        SLRNode item = SLRobjNum[proitemset[Gy_itemset[i]].Container[0]];  
        char left = item.Left[0];  
        List<char> follow = GetFollow(left);  
        foreach (char c in follow)  
        {  
            int CID = FindID(Echar, c);  
            SLRAna[Gy_itemset[i]][CID] = new Table('r', Find_pro(item));   
        }  
       
    }  

    for (int i = 0; i < Pindex; i++)  
    {  
        if (isFinalsymbol(dfa[i].symbol))//symbol为非终结符  添加状态N  
        {  
            int CID = FindID(Nchar, dfa[i].symbol);  
            SLRAna[dfa[i].from][CID + Echar.Count] = new Table('N', dfa[i].to);  
        }  
        else //不是归约项目 添加状态S  
        {  
            int CID = FindID(Echar, dfa[i].symbol);  
            SLRAna[dfa[i].from][CID] = new Table('S', dfa[i].to);  
        }  
    }  
}  

根据上述代码，补充的GetFollow函数的构造内容：public HashSet<char> GetFollow(char c)  
{  
    HashSet<char> followSet = new HashSet<char>();  
    if (c == 'S')  
        followSet.Add('#');  
    foreach (SLRNode item in SLRproNum)  
    {  
        for (int i = 0; i < item.Right.Length; i++)  
        {  
            if (item.Right[i] == c)  
            {  
                if (i == item.Right.Length - 1)//c在产生式右部最后一个位置  
                {  
                    if (item.Left[0] != c)//避免左递归  
                    {  
                        HashSet<char> tempSet = GetFollow(item.Left[0]);  
                        followSet.UnionWith(tempSet);  
                    }  
                }  
                else//c不在产生式右部最后一个位置  
                {  
                    if (isFinalsymbol(item.Right[i + 1]))//c后面是终结符  
                    {  
                        followSet.Add(item.Right[i + 1]);  
                    }  
                    else//c后面是非终结符  
                    {  
                        HashSet<char> tempSet = First(item.Right.Substring(i + 1));  
                        if (tempSet.Contains('#'))  
                        {  
                            tempSet.Remove('#');  
                            followSet.UnionWith(tempSet);  
                            if (item.Left[0] != c)//避免左递归  
                            {  
                                HashSet<char> tempSet2 = GetFollow(item.Left[0]);  
                                followSet.UnionWith(tempSet2);  
                            }  
                        }  
                        else  
                        {  
                            followSet.UnionWith(tempSet);  
                        }  
                    }  
                }  
            }  
        }  
    }  
    return followSet;  
}