SLR文法分析器实现 - C# 代码示例

{ "title": "SLR文法分析器实现 - C# 代码示例", "description": "本文提供了一个使用C#实现的SLR文法分析器，展示了如何构建项目集、构造DFA，以及生成SLR分析表。代码示例清晰易懂，适合学习SLR文法分析的初学者。", "keywords": "SLR文法, 分析器, C#, 项目集, DFA, 分析表, 代码示例", "content": "```C# using System; using System.Collections.Generic;

public class LR { //产生式结点类 public class LRproNode { public string Left; public string Right; public LRproNode(string Left, string Right) { this.Left = Left; this.Right = Right; } } //项目集类 public class LR_club { 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 DFA[] dfa = new DFA[100];
public int Pindex = 0; //dfa数组指针
public Table[][] LRAna; //分析表
public int[][] Goto; // goto状态表

public List<LRproNode> LRproNum = new List<LRproNode>(50); //产生式 列表
public List<LRproNode> LRobjNum = new List<LRproNode>(50); //项目 列表
public List<LR_club> pro_club = new List<LR_club>(100); //项目集合
public List<int> Gy_obj = new List<int>(50); //归约项目序号集合
public List<int> Gy_club = new List<int>(50); //含有归约项目的集合的序号 的集合
public List<char> Nchar = new List<char>(50); //非终结符集合
public List<char> Echar = new List<char>(50); //终结符集合

public string RETStr = "";
public string RETStr_obclub = ""; //输出返回
public string RETStr_DFA = "";
public string RETStr_ANA = "";

//读取传递过来的文件信息str后，对str的或运算加以处理，变成多个产生式
//返回处理过的信息
public void Start(string str)
{
    LRproNode Lr;
    int i = 0;
    string left = "";
    string right = "";
    left += "S'";
    right += str[0];
    Lr = new LRproNode(left, right); //拓广文法开始
    LRproNum.Add(Lr);
    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] == '|') // 遇到'|'可构造一条产生式
            {
                Lr = new LRproNode(left, right);
                LRproNum.Add(Lr);
                right = ""; //产生式左边相同 右边重新积累
                i++; //跳过'|'
                continue;
            }
            if ((i - j) == 0)
            {
                if (!iscexist(Nchar, str[i])) //如果非终结符集合中不存在str[i],加入Nchar  产生式左边 只有非终结符 不必判断终结符
                    Nchar.Add(str[i]);
                left += str[i++];
            }
            else if (i - j <= 2)
                i++;
            else
            {
                if (isFinalsymbol(str[i]) && !iscexist(Nchar, str[i])) //如果非终结符集合中不存在str[i],加入Nchar  isfinalsymbol 非终结符返回T 终结符返回F
                    Nchar.Add(str[i]);
                else if (!isFinalsymbol(str[i]) && !iscexist(Echar, str[i])) //产生式右边 需要判断终结符
                    Echar.Add(str[i]);
                right += str[i++];
            }
        } //while

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

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

//返回分析表 额外功能 可以不要
public Table[][] GET_ANA()
{
    LRAnaly();
    RETStr_ANA += "\r\nSLR分析表:\r\n    ";
    int i;
    for (i = 0; i < Echar.Count; i++)
    {
        RETStr_ANA += Echar[i].ToString() + "     ";
    }
    for (i = 0; i < Nchar.Count; i++)
    {
        RETStr_ANA += Nchar[i].ToString() + "     ";
    }
    RETStr_ANA += "\r\n";
    for (i = 0; i < pro_club.Count; i++)
    {
        RETStr_ANA += i.ToString() + "  ";
        for (int j = 0; j < Echar.Count + Nchar.Count; j++)
        {
            if (LRAna[i][j].error)
            {
                RETStr_ANA += "  " + "    ";
            }
            else if (i == 1 && j == Echar.Count - 1)
            {
                RETStr_ANA += "AC" + "    ";
            }
            else if (LRAna[i][j].type != 'N')
            {
                RETStr_ANA += LRAna[i][j].type.ToString() + LRAna[i][j].id.ToString() + "    ";
            }
            else
                RETStr_ANA += LRAna[i][j].id.ToString() + "    ";
        }
        RETStr_ANA += "\r\n";
    }

    return LRAna;

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

    LR_club LR_C = new LR_club();
    LR_C.Container = lr_club; //集合----项目集序号的集合
    pro_club.Add(LR_C); //集合的集合----存放项目集序号集合 的集合


    Goto = new int[pro_club.Count][];
    for (int i = 0; i < pro_club.Count; i++)
        Goto[i] = new int[Nchar.Count];

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

        for (int j = 0; j < pro_club[i].Container.Count; j++) //第i个项目集的第j个项目
        {
            if (flag[j] == 1) //如果已经访问过 就不再构造 找下一个项目
                continue;
            int index = pro_club[i].Container[j];
            for (int pi = 0; pi < LRobjNum[index].Right.Length - 1; pi++) //length-1是避免匹配到.在最后的规约项目
            {
                if (LRobjNum[index].Right[pi] == '.')
                {
                    List<int> lr2_club = new List<int>(100); //记录项目的序号
                    char symbol = LRobjNum[index].Right[pi + 1]; //记录.a转移状态a.的符号a
                    lr2_club.Add((index + 1)); //如果遇到.a形式的项目序号为index 那么项目a.的序号为index+1
                    for (int m1 = j + 1; m1 < pro_club[i].Container.Count; m1++)
                    { //在第i个项目集中找到了可以移动的.：.a  重新遍历第i个项目集j项目之后的 找到同样可以移动a的项目集
                        int index2 = pro_club[i].Container[m1];
                        for (int m2 = 0; m2 < LRobjNum[index2].Right.Length - 1; m2++)
                        {
                            if (LRobjNum[index2].Right[m2] == '.' && LRobjNum[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_club.Add(pro_club.Count);
                            }
                        }
                        LR_club LR_C2 = new LR_club();
                        dfa[Pindex++] = new DFA(i, symbol, pro_club.Count); //count不用加1  本身从0开始
                        LR_C2.Container = lr2_club;
                        pro_club.Add(LR_C2);
                    }
                    else
                    {
                        dfa[Pindex++] = new DFA(i, symbol, value);
                    }
                    break;
                }
            }
            for (int j = 0; j < Nchar.Count; j++) //对于每个非终结符
            {
                List<int> lr2_club = new List<int>(100); //记录项目的序号
                char symbol = Nchar[j]; //记录非终结符
                for (int m1 = 0; m1 < pro_club[i].Container.Count; m1++)
                { //在第i个项目集中找到了可以移动的.：.A  重新遍历第i个项目集j项目之后的 找到同样可以移动A的项目集
                    int index2 = pro_club[i].Container[m1];
                    for (int m2 = 0; m2 < LRobjNum[index2].Right.Length - 1; m2++)
                    {
                        if (LRobjNum[index2].Right[m2] == '.' && LRobjNum[index2].Right[m2 + 1] == symbol)
                        {
                            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_club.Add(pro_club.Count);
                        }
                    }
                    LR_club LR_C2 = new LR_club();
                    Goto[i][j] = pro_club.Count;
                    LR_C2.Container = lr2_club;
                    pro_club.Add(LR_C2);
                }
                else
                {
                    Goto[i][j] = value;
                }
            }
        } //end-forj
    } //end-fori

} //end-Cre_club

//分析表
public void LRAnaly()
{
    Table tnode = new Table();

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

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

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

    //添加“goto”状态
    for (int i = 0; i < pro_club.Count; i++)
    {
        for (int j = 0; j < Nchar.Count; j++)
        {
            if (Goto[i][j] != 0)
            {
                int CID = FindID(Nchar, Nchar[j]);
                tnode = new Table('G', Goto[i][j]);
                LRAna[i][CID + Echar.Count] = tnode;
            }
        }
    }

    for (int i = 0; i < Gy_club.Count; i++)
    {
        tnode = new Table('r', Find_pro(LRobjNum[pro_club[Gy_club[i]].Container[0]])); //归约项目 找到原产生式序号 添加状态r
        for (int j = 0; j < Echar.Count; j++)
        {
            LRAna[Gy_club[i]][j] = tnode;
        }
    }
    for (int i = 0; i < Pindex; i++)
    {
        if (isFinalsymbol(dfa[i].symbol)) //symbol为非终结符  添加状态N
        {
            int CID = FindID(Nchar, dfa[i].symbol);
            tnode = new Table('N', dfa[i].to);
            LRAna[dfa[i].from][CID + Echar.Count] = tnode;
        }
        else //不是归约项目 添加状态S
        {
            int CID = FindID(Echar, dfa[i].symbol);
            tnode = new Table('S', dfa[i].to);
            LRAna[dfa[i].from][CID] = tnode;
        }
    }
}

//以下函数需要根据具体需求实现
public List<int> Closure(List<int> lr_club) { }
public bool isFinalsymbol(char symbol) { }
public bool iscexist(List<char> list, char symbol) { }
public bool isnexist(List<int> list, int symbol) { }
public int isexist(List<int> lr2_club) { }
public string CreObj(string right, int j) { }
public int FindID(List<char> list, char symbol) { }
public int Find_pro(LRproNode lr) { }

}