编译原理实验4——SLR(1)分析器的生成

本篇博客用来记录完成的编译原理实验4的学习过程以及最终成果

目录

• 实验要求
• 学习
• 实践
  • 文法规则的存储结构
  • 所有非终结符的first集合
    • 所有非终结符first集合的存储结构
    • 求解所有非终结符first集合的算法
  • 所有非终结符的follow集合
    • 求解所有非终结符follow集合的存储结构
    • 求解所有非终结符follow集合的算法
  • DFA图、SLR(1)分析表
    • 项目的存储结构
    • 结点的存储结构
    • 移进关系(DFA的图边关系)的存储结构
    • 归约关系的存储结构
    • 结点、移进关系、归约关系、判断是否为SLR(1)文法的求解算法
    • 用结点、移进关系生成LR(0)DFA图
    • 用结点、移进关系、归约关系生成SLR(1)表
  • 分析句子
  • 运行效果

实验要求

1.必做功能：
  （1）要提供一个源程序编辑界面，让用户输入文法规则（可保存、打开存有文法规则的文件）
  （2）检查该文法是否需要进行文法的扩充。
  （3）求出该文法各非终结符号的first集合与follow集合，并提供窗口以便用户可以查看这些集合结果。
  （4）需要提供窗口以便用户可以查看文法对应的LR(0)DFA图。（可以用画图的方式呈现，也可用表格方式呈现该图点与边的关系数据）
  （5）需要提供窗口以便用户可以查看该文法是否为SLR(1)文法。（如果非SLR(1)文法，可查看其原因）
  （6）需要提供窗口以便用户可以查看文法对应的SLR(1)分析表。（如果该文法为SLR(1)文法时）
  （7）应该书写完善的软件文档

2.选做功能。如果是组队完成实验，则是必做功能,即必须把下面的两个功能也要实现。
  （1）需要提供窗口以便用户输入需要分析的句子。
  （2）需要提供窗口以便用户查看使用SLR(1)分析该句子的过程。【可以使用表格的形式逐行显示分析过程】

学习

问题：LR(0) 和 SLR(1)是什么
LR(0) 和 SLR(1)都是自底向下的语法分析方法的一个算法
项目
假设有文法

S'->S
S->(S)S|ε

那么下面列举出LR(0)的8个项目(可以把每一个项目看成是旅游地图的一部分，而其中的点是游客当前所处的位置)

S'->.S
S'->S.
S->.(S)
S->(.S)S
S->(S.)S
S->(S).S
S->(S)S.
S->.

每个项目可以看成一个状态。如果某个状态可以通过输入文法中的终结符、非终结符得到新状态，例如

S'->.S ——S——> S'->S.

则称该状态为移进状态;如果某个状态点已经到了末尾，需要原路返回，则称该状态为归约状态，例如

S->S. 为归约项

最终形成一个NFA表，NFA表通过ε闭包的改写则可成为DFA表(一个状态可能有多个项目)，通过DFA表就可以对句子进行LR(0)分析(移进归约)。
LR(0)文法:如果一个文法产生的DFA表中的每一个状态包含的都是移进项目或者只有一个归约项，那么该文法成为LR(0)文法。
SLR(1)文法:如果一个文法产生的DFA表中的每一个状态包含的归约项目的Follow集合交集为空和移进的符号不属于任何一个归约项目，则称该文法为SLR(1)文法

实践

项目基于C++实现，可视化是使用QT。所有用到的编程知识点都在此链接
项目地址

文法规则的存储结构

对于下面的文法规则，我们要如何存储呢？

E' -> E
E -> E + n | n

首先给出定义如下：
(1)产生式: 若干条产生式构成一个文法规则。例如E -> E + n | n为一条产生式
(2)key，values: 对于一条产生式来说，->左边的符号我们称作key，右边的符号序列我们称作values。例如，对于产生式E -> E + n | n来说，E为key，E + n | n为values
(3)value: 若干个value构成一个values。例如对于valuesE + n | n来说，|符号分割出了两个value，分别为E + n和n


给出定义之后，接下来就来分析一下具体的存储结构?
(1)对于每个符号(不包括->和|)，使用string对象来存储，因为一个符号可以为多个字符。
(2)对于一个value，使用vector< string>对象来存储，因为它本质为string的序列。之所以用vector对象而不用数组，是因为value的大小不确定。
(3)对于一个values，使用vector<vector< string>>来存储，本质上就是value序列。
(4)对于一个文法, 使用map<string, vector<vector< string>>>对象来存储，因为产生式本质为一个键值对，多个键值对就构成一个文法。


既然已经知道了文法的存储结构，下面就需要解决如何把用户输入的文法字符串(转换前需要先进行文法扩充)转换为上面的存储结构。首先我们必须给用户输入文法字符串给予一定的约束，因为不同的输入形式会对应不同的转换算法。我的字符串约束为:

E' -> E
E -> (E) + n | n

(1)每个产生式用' '分割
(2)每一个value用'|'分割
(3)符号之间用' '分割，但是左右括号除外
(4)key为开始符号的产生式必须置于最前面(开始符号会在转换的过程中通过string对象保存起来)


得到了文法的存储结构后，我们可以很容易求得文法规则的非终结符集，通过set< string>对象来存储

所有非终结符的first集合

首先说明一下用原来自顶向下的方法来求first集合是行不通的，因为自底向上的文法规则可以有左递归，该算法无法解决有左递归的情况甚至一些不是左递归的情况。比如下面的文法。

A -> A s | ε

A -> B A | ε
B -> b | ε

所有非终结符first集合的存储结构

(1)一个非终结符的first集合用set< string>来存储
(2)所有非终结符的first集合用map<string, set< string>>来存储，因为通过映射我们可以直接找到某个非终结符的first集合

求解所有非终结符first集合的算法

算法描述如下:

初始化所有非终结符对应的first集合(置为空)
while 存在非终结符的first集合发生改变：
    for 产生式 in 文法规则:
        定义产生式对应的key, values
        for value in values:
            for value[k] in value: //遍历value中每一个符号，value[k]中为value的第k个符号(编号从0开始)
                定义符号value[k]的first集合为k_first_set
                if value[k]为终结符:
                    k_first_set = {value[k]}
                else:
                    k_first_set = 非终结符value[k]对应的first集合
                add k_first_set - {"ε"} to 非终结符key对应的first集合
                if "ε" not in k_first_set:
                    break;
           if k == value.size: //value元素的大小
                add {"ε"} to 非终结符key对应的first集合

所有非终结符的follow集合

下面算法求解必须在first集合求解完毕后进行

求解所有非终结符follow集合的存储结构

(1)一个非终结符的follow集合用set< string>来存储
(2)所有非终结符的follow集合用map<string, set< string>>来存储，因为通过映射我们可以直接找到某个非终结符的follow集合

求解所有非终结符follow集合的算法

我们需要先定义求解一个符号序列first集合的算法，因为求解所有非终结符的follow集合需要用到
first(符号序列)算法描述如下:

定义空集合set
for s[k] in 符号序列: //遍历符号序列的每一个符号，其中s[k]为符号序列第k个符号(编号从0开始)
    求解s[k]的first集合k_set //s[k]如果为终结符就是{s[k]}, 如果为非终结符就在原来的存储first集合的地方获取
    add k_set - {"ε"} to set
    if "ε" not in k_set:
        break;
if k == 符号序列.size:
    add {"ε"} to set
return set

求解所有非终结符的follow集合的算法描述如下:

初始化所有非终结符的follow集合(置为空)
while 存在一个非终结符的follow集合发生改变：
    for 产生式 in 文法:
        定义产生式对应的key, values
        for value[k] in values:
            if value[k]为非终结符:
                add first(value[k+1, ]) to 非终结符value[k]对应的follow集合 //value[k+1, ]是value1的子序列
                if "ε" in first(value[k+1, ]):
                    add 非终结符key对应的follow集合 to 非终结符value[k]对应的follow集合

DFA图、SLR(1)分析表

项目的存储结构

首先给出项目的定义：
项目就是key -> 被加上了'.'的value
例如，对于文法规则

E' -> E
E -> E + n | n

来说，对应的8个项目为

E' -> .E
E' -> E.
E -> .E + n
E -> E. + n
E -> E +. n
E -> E + n.
E -> .n
E -> n.

项目还有不同的类型
形如E -> n.的项目称为归约项, 其'.'在项目最后
形如E -> .n的项目称为移进项, 其'.'不在项目最后

那么，该如何存储一个项目呢？
首先我们发现一个项目由key，value，'.'的位置唯一确定，为了节省存储空间，value可以用在key对应的values下的编号表示
所以我们定义一个数据结构Project来存储项目

Class Project{
    string key;
    int value_num; //在key对应的values下value的编号
    int index;  //'.'的位置编号，表示'.'在value中第index个符号前面
    int type; //项目的类型: 1为移进项 2为归约项
}

结点的存储结构

首先给出结点的定义：
一个结点如图所示：若个项目的集合为结点
(1)单个结点的存储结构: 因为结点是若干个项目的集合，所以我们使用vector< Project>对象来存储

(2)所有结点的存储结构: 用vector<vector< Project>>来存储，这样我们也可以通过vector的下标得到结点编号

注意：结点的存储结构应该使用排序树会更好，因为后面算法有搜索步骤。

移进关系(DFA的图边关系)的存储结构

移进关系就是结点间的转移关系，就是上图中的那些边。存储结构为：
(1)某个结点(作为起点)的转移关系用map<string, int>对象存储，其中string存储移进符号，int存储转移后的结点编号
(2)所有结点(作为起点)的转移关系用map<int, map<string, int>对象来存储，其中int是起点的结点编号，map<string, int>存储着对应结点的转移关系

归约关系的存储结构

归约关系是某个结点的回退操作(与移进相对)。存储结构为：
(1)某个结点(作为回退起点)的归约关系用map<string, int>对象存储，其中string存储导致归约发生的下一个符号(follow)，int存储归约项在结点中的编号。
(2)所有结点(作为回退起点)的归约关系用map<int, map<string, int>>对象存储

结点、移进关系、归约关系、判断是否为SLR(1)文法的求解算法

首先通过举例的方式定义扩展这个概念：对于文法规则

E' -> E
E -> E + n | n

项目E' -> .E扩展得到

E' -> .E
E -> .E + n
E -> n

就是把'.'后面的非终结符用其对应的项目('.'在value最前面)来具体化。就像你走到门口推开大门看到里面具体的风景一样。

然后描述算法:

初始化结点序列(只有一个结点, 并且结点只有一个项目，项目=Project(开始符号，0，0，1))  
for 结点 in 结点序列:
    初始化该结点对应的移进关系 //置为空字典
    初始化该结点对应的归约关系 //置为空字典
    扩展该结点(中的每一个项目)
    for 项目j in 结点:
        if 项目为移进项:
            定义该项目的转换符号为t
            定义移进后的新项目为p
            if t未在移进关系的关键字集合里面:
                if p in 结点k:
                    将t：k键值对加入移进关系中
                else:
                    向结点集合插入一个含有p的新结点k
                    将t:k键值对加入移进关系中
            else: //t已经在移进关系的关键字集合里面
                获取转移到的结点k
                if p not in 结点k：
                    p加入结点k中
        else:  //项目为归约项
            获取项目j.key对应的follow集合follow
            for t in follow:
                if t:j 已经存在:
                    说明文法不是SLR(1)文法   //因为不满足SLR(1)结点中归约项.key的follow集合交集为空的原则
                将t:j加入移进关系
for 结点 in 结点序列:
    if 结点的移进符号集和归约符号集有交集:
        说明文法不是SLR(1)文法  //因为不满足SLR(1)结点中移进符号不存在于该结点中任何一个归约项key的follow集合

用结点、移进关系生成LR(0)DFA图

有了结点序列和所有结点的移进关系，就已经包含了LR(0)DFA图的所有信息，自己想怎么生成就怎么生成

用结点、移进关系、归约关系生成SLR(1)表

有了结点序列和所有结点的移进关系、归约关系，就已经包含了SLR(1)表的所有信息，自己想怎么生成就怎么生成

分析句子

实现句子的分析需要一个分析栈和输入队列，存储结构我选择vector< string>，之所以不用stack和queue，是因为stack和queue没有迭代器，没有办法遍历，而vector只要在使用时给一定约束就可以当作stack或queue使用。
算法描述如下：

定义分析栈为stack，用户队列为queue
初始化stack(0压入栈顶)
初始化queue(用户输入的句子分割成一个个符号后加入queue，最后再加入"$")
for i in range(0, 无穷大):
    输出步骤i
    输出分析栈
    输出输入队列
    获取栈顶元素f
    获取队列头元素s
    if s为结点f的移进字符：
       弹出队首元素
       t = 结点k由s转换后的结点编号
       s、t分别入栈
       输出"移进s"
    else:
       t = 结点f的归约项目编号
       得到归约项p
       定义p对应的key -> value
       if key为开始符号:
           输出"接受"
           break
       if value[0] != "ε":
           弹出stack的2*value.size个元素
       f = 栈顶元素
       s = key
       t = 结点k由s转换后的结点编号
       s、t入栈
       输出"归约key -> value"     

运行效果