编译原理实验3——自下而上的SLR1语法分析实现（包含画DFA转换图、建表、查表）

实验目的

实现自下而上的SLR1语法分析，画出DFA图

实现流程

定义DFA状态

class DFA:
    def __init__(self, id_, item_, next_ids_):
        self.id_ = id_  # 编号
        self.item_ = item_  # productions
        self.next_ids_ = next_ids_  # { v1:id1 , v2:id2 ...}

    def __eq__(self, other):
        return set(self.item_) == set(other.item_)

类属性：

• id_：一个数字，表示状态的编号
• item_：一个集合，表示状态所含有的项目集
• next_ids_：一个字典，表示其可跳转的状态关系，key值表示经过什么符号跳转，value值表示跳转到的状态编号

类方法：

• 判断两个状态是否相等，依据这两个状态所包含的项目集判断，若项目集中包含的元素完全相同，则这两个状态相等。
  例如：
  
  如图，状态I0可以通过S、B分别跳转到I1、I2，则其DFA状态类为：
  • id_：0
  • item_： { S’->.S, S->.BB, B->.aB, B->.b }
  • next_ids_： { ‘S’: 1 , ‘B’:2 }

实现代码

代码逻辑
1.计算所有项目

如图，首先找到字符串中 -> 的位置索引，python中字符匹配得到的是 - 的索引，记为ind，因此再ind=ind+2即可得到候选式首个字符a的位置，以这个位置为起点，遍历到末尾，加入小数点即可得到一个新的项目，如：当得到ind=1时，
item1 = str[:ind+2+0] + ’.’ + str[ind+2+0:] = “B->” + “.” + “ab” = “B->.ab”
item2 = str[:ind+2+1] + ’.’ + str[ind+2+1:] = “B->a” + “.” + “b” = “B->a.b”
item3 = str[:ind+2+2] + ’.’ + str[ind+2+2:] = “B->ab” + “.” + “” = “B->ab.”
（得益于python简单的切片索引，可以通过str[start:end]取得str中索引位置为start到end-1的子字符串。）

2.计算闭包
自定义一个closure函数

• 输入：待求闭包的项目集item
• 输出：项目集item的闭包
• 求解过程：
  • 遍历项目集，对于其中的每个项目，判断“.”的位置在哪：
  • 如果“.”在最后，则表明是归约项目，不再对其进行闭包。
  • 如果“.”不在最后，看“.”后面的字符是否为非终结符，找到该非终结符所对应的产生式的项目，并将这些项目加入闭包中。
  • 再对求过一次闭包后的新的项目集再求其闭包，方法同上，直至求出的新的项目集不再有新的项目产生。（前后两次闭包后，项目集没有加入新的项目，长度不变）

3.计算GO闭包
自定义一个go函数

• 输入：待求闭包的项目集item，跳转字符v
• 输出：项目集item的闭包
• 求解过程：
  • 遍历项目集，找出“.”右边为字符v的产生式，并将“.”移动到字符v后面，得到新的产生式集item2
  • 将item2代入上述closure函数中求解闭包。

4.构建DFA状态转换图
生成初始状态0：将增广文法所在产生式传入closure函数求解闭包，记为S0_item，根据DFA类定义初始状态：S0 = DFA(0, S0_item, {})，即状态编号为0，项目集为S0_item，跳转关系为空字典。然后将初始状态加入到存储所有状态的列表：all_DFA。即 all_DFA = [S0]
遍历all_DFA中的所有状态，求解每个状态中项目集的Go闭包，记录新的状态。遍历完一轮all_DFA后，继续遍历all_DFA，直到前后两次all_DFA长度不变（没有新的状态产生）

5.判断是否为SLR1文法：

• 先判断是否符合LR0文法
  遍历all_DFA中的所有状态S，遍历状态S的项目集的所有产生式，若“.”在末尾，则为归约项目，若“.”后为终结符，则为移进项目，统计归约项目和移进项目个数，若存在2个及以上的归约项目或存在1个移进项目和1个归约项目，则相应存在“归约-归约冲突”和“移进-归约冲突”，不符合LR0文法。
• 判断是否符合SLR1文法
  如图，依据归约项目和移进项目的follow集进行判断
  

6.构造SLR1表：
定义actions={} 、 gotos={}，分别表示action表和gotos表，key值为一个二元组，如（1,’#’），表示状态1和字符’#’所对应的单元格。
遍历all_DFA中的所有状态S：

• 如果S的next_ids_为空字典，即它没有箭头指向其他状态，则S的项目集中必只包含一个项目，为归约项目或接受项目。
  - 若该项目去除“.”后与增广文法所在产生式相等，该项目为接受项目，记录actions[ (id_,’#’) ]=“acc”，id_为当前状态S的编号。
  - 否则，则为归约项目。将该产生式依据“->”拆成左部和右部，遍历左部的follow集，记录actions[ (id_,ch) ] = rn，ch为左部follow集的元素，rn为产生式编号。
• 如果S的next_ids字典不为空，即表明有指向下一个项目的箭头，从而当前状态S可能存在接受、归约、移进等项目。
  - 遍历S的项目集：判断是否为接受项目和归约项目同上
  - 遍历S的next_ids字典：若key值为终结符，记录actions[ (id_, key) ] = S+value，value为下一个状态的编号；若key值为非终结符，记录gotos[ (id_, key) ] = value。

7.根据输入串查表分析
建立变量，状态栈state、符号栈symbol、字符指针sp。

• 给state加入0，symbol加入#，sp=0
• 取出state栈顶状态St和symbol栈顶符号Sy，如果actions的key中不存在（St，Sy）二元组，则分析失败，否则进行下一步。
• 用（St，Sy）查actions得到动作a
  • 如果a是Sn，为移进操作，将状态Sn加入到状态栈state，将sp指向的字符加入到符号栈中symbol，并且sp+=1
  • 如果a是rn， 为归约操作，找到产生式rn，将符号栈symbol中对应产生式右部的字符弹出，也将状态栈state对应产生式右部字符个数的状态弹出。取此时state和symbol栈顶元素St、Sy，查gotos表，如果gotos的key中不存在（St，Sy）二元组，则分析失败，否则将查到的对应的状态加入状态栈state中。
  • 如果a是“acc”，分析成功，退出循环
• 循环条件为sp！=分析串长度

需要用到graphviz库，用于画DFA转换图，自行百度搜索下载，不难
（下载graphviz.exe软件–>改环境变量–>python安装graphviz库）

import copy
from collections import defaultdict
import graphviz
import pandas as pd


class DFA:
    def __init__(self, id_, item_, next_ids_):
        self.id_ = id_  # 编号
        self.item_ = item_  # productions
        self.next_ids_ = next_ids_  # { v1:id1 , v2:id2 ...}

    def __eq__(self, other):
        return set(self.item_) == set(other.item_)


class FirstAndFollow:
    def __init__(self, formulas_str_list):
        self.formulas_str_list = formulas_str_list
        self.formulas_dict = defaultdict(set)
        self.first = defaultdict(set)
        self.follow = defaultdict(set)
        self.S = ""
        self.Vn = set()
        self.Vt = set()
        self.info = {}

    def process(self, formulas_str_list):
        formulas_dict = defaultdict(set)  # 存储产生式 ---dict 形式
        # 转为特定类型
        for production in formulas_str_list:
            left, right = production.split('->')
            if "|" in right:
                r_list = right.split("|")
                for r in r_list:
                    formulas_dict[left].add(r)
            else:
                formulas_dict[left].add(right)  # 若left不存在，会自动创建 left: 空set

        S = list(formulas_dict.keys())[0]  # 文法开始符
        Vn = set()
        Vt = set()
        for left, right in formulas_dict.items():  # 获取终结符和非终结符
            Vn.add(left)
            for r_candidate in right:
                for symbol in r_candidate:
                    if not symbol.isupper() and symbol != '@':
                        Vt.add(symbol)
        # 消除左递归
        # formulas_dict = self.eliminate_left_recursion(formulas_dict)

        return formulas_dict, S, Vn, Vt

    def cal_v_first(self, v):  # 计算符号v的first集
        # 如果是终结符或ε，直接加入到First集合
        if not v.isupper():
            self.first[v].add(v)
        else:
            for r_candidate in self.formulas_dict[v]:
                i = 0

                while i < len(r_candidate):
                    next_symbol = r_candidate[i]
                    # 如果是非终结符，递归计算其First集合
                    if next_symbol.isupper():
                        if next_symbol == v:
                            break
                        self.cal_v_first(next_symbol)
                        self.first[v] = self.first[v].union(self.first[next_symbol] - {'@'})  # 合并first(next_symbol)/{@}
                        if '@' not in self.first[next_symbol]:
                            break
                    # 如果是终结符，加入到First集合
                    else:
                        self.first[v].add(next_symbol)
                        break
                    i += 1
                # 如果所有符号的First集合都包含ε，将ε加入到First集合
                if i == len(r_candidate):
                    self.first[v].add('@')

    def cal_all_first(self):
        for vn in self.formulas_dict.keys():
            self.cal_v_first(vn)
        for vt in self.Vt:
            self.cal_v_first(vt)
        self.cal_v_first('@')

    # def: 计算Follow集合1——考虑 添加first(Vn后一个非终结符)/{ε}， 而 不考虑 添加follow(left)
    def cal_follow1(self, vn):
        self.follow[vn] = set()
        if vn == self.S:  # 若为开始符，加入#
            self.follow[vn].add('#')
        for left, right in self.formulas_dict.items():  # 遍历所有文法，取出左部单Vn、右部候选式集合
            for r_candidate in right:  # 遍历当前 右部候选式集合
                i = 0
                while i <= len(r_candidate) - 1:  # 遍历当前 右部候选式
                    if r_candidate[i] == vn:  # ch == Vn
                        if i + 1 == len(r_candidate):  # 如果是最后一个字符  >>>>>  S->....V
                            self.follow[vn].add('#')
                            break
                        else:  # 后面还有字符  >>>>> S->...V..
                            while i != len(r_candidate):
                                i += 1
                                # if r_candidate[i] == vn:  # 又遇到Vn，回退 >>>>> S->...V..V..
                                #     break
                                if r_candidate[i].isupper():  # 非终结符  >>>>> S->...VA..
                                    self.follow[vn] = self.follow[vn].union(self.first[r_candidate[i]] - {'@'})
                                    if '@' in self.first[r_candidate[i]]:  # 能推空  >>>>> S->...VA..  A可推空
                                        if i + 1 == len(r_candidate):  # 是最后一个字符  >>>>> S->...VA  A可推空 可等价为 S->...V
                                            self.follow[vn].add('#')
                                            break
                                    else:  # 不能推空 >>>>> S->...VA..  A不可推空
                                        break
                                else:  # 终结符  >>>>> S->...Va..
                                    self.follow[vn].add(r_candidate[i])
                                    break
                    else:
                        i += 1

    # def: 计算Follow集合2——考虑 添加follow(left)
    def cal_follow2(self, vn):
        for left, right in self.formulas_dict.items():  # 遍历所有文法，取出左部单Vn、右部候选式集合
            for r_candidate in right:  # 遍历当前 右部候选式集合
                i = 0
                while i <= len(r_candidate) - 1:  # 遍历当前 右部候选式
                    if r_candidate[i] == vn:  # 找到Vn
                        if i == len(r_candidate) - 1:  # 如果当前是最后一个字符，添加 follow(left) >>>>>  S->..V
                            self.follow[vn] = self.follow[vn].union(self.follow[left])
                            break
                        else:  # 看看后面的字符能否推空 >>>>>  S->..V..
                            while i != len(r_candidate):
                                i += 1
                                if '@' in self.first[r_candidate[i]]:  # 能推空  >>>>> S->..VB..  B可推空
                                    if i == len(r_candidate) - 1:  # 且是最后一个字符  >>>>> S->..VB  B可推空
                                        self.follow[vn] = self.follow[vn].union(self.follow[left])
                                        break
                                    else:  # 不是最后一个字符，继续看  >>>>> S->..VBA..  B可推空
                                        continue
                                else:  # 不能推空  >>>>>  S->..VB..  B不可为空
                                    break
                    i += 1

    # def: 计算所有Follow集合的总长度，用于判断是否还需要继续完善
    def cal_follow_total_Len(self):
        total_Len = 0
        for vn, vn_follow in self.follow.items():
            total_Len += len(vn_follow)
        return total_Len

    def cal_all_follow(self):
        # 先用 cal_follow1 算
        for vn in self.formulas_dict.keys():
            self.cal_follow1(vn)

        # 在循环用 cal_follow2 算， 直到所有follow集总长度不再变化，说明计算完毕
        while True:
            old_len = self.cal_follow_total_Len()
            for vn in self.formulas_dict.keys():
                self.cal_follow2(vn)
            new_len = self.cal_follow_total_Len()
            if old_len == new_len:
                break

    def solve(self):
        # print("\n=============FirstFollow=============")
        self.formulas_dict, self.S, self.Vn, self.Vt = self.process(self.formulas_str_list)
        self.cal_all_first()
        self.cal_all_follow()
        # print(f"first: {self.first}")
        # print(f"follow: {self.follow}")
        # print("=============FirstFollow=============\n")

        return self.first, self.follow


class SLR1:
    def __init__(self, formulas_str_list):
        self.formulas_str_list = formulas_str_list  # list
        self.S = ""
        self.Vn = []
        self.Vt = []
        self.dot_items = []  # 所有可能的.项目集
        self.all_DFA = []
        self.actions = []
        self.gotos = []
        self.first = defaultdict(set)
        self.follow = defaultdict(set)

    def step1_pre_process(self, grammar_list):
        formulas_str_list = []
        S = grammar_list[0][0]  # 开始符
        Vt = []  # 终结符
        Vn = []  # 非终结符
        for pro in grammar_list:
            pro_left, pro_right = pro.split("->")
            if "|" in pro_right:
                r_list = pro_right.split("|")
                for r in r_list:
                    formulas_str_list.append(pro_left + "->" + r)
            else:
                formulas_str_list.append(pro)

        # 增广文法
        formulas_str_list.insert(0, S + "'->" + S)
        # print(formulas_str_list)

        for pro in formulas_str_list:
            pro_left, pro_right = pro.split("->")
            if pro_left not in Vn:
                Vn.append(pro_left)
            for r_candidate in pro_right:
                for symbol in r_candidate:
                    if not symbol.isupper() and symbol != '@':
                        if symbol not in Vt:
                            Vt.append(symbol)
        print("S:",S)
        print("Vn:", Vn)
        print("Vt:", Vt)

        ff = FirstAndFollow(formulas_str_list)
        first, follow = ff.solve()
        return S, Vn, Vt, formulas_str_list, first, follow

    def step2_all_dot_pros(self, grammar_str):
        dot_items = []
        for pro in grammar_str:
            ind = pro.find("->")  # 返回-的下标
            for i in range(len(pro) - ind - 1):
                tmp = pro[:ind + 2 + i] + "." + pro[ind + 2 + i:]
                dot_items.append(tmp)

        return dot_items

    def closure(self, item):  # 求item所有的产生式的闭包
        c_item = item
        old_c_item = []
        while len(old_c_item) != len(c_item):
            old_c_item = copy.deepcopy(c_item)
            for pro in old_c_item:
                if pro not in c_item:
                    c_item.append(pro)
                dot_left, dot_right = pro.split(".")
                if dot_right == "":  # 当前产生式为最后一项为. .不能继续移动，跳过
                    continue
                if dot_right[0] in self.Vn:  # .后面为非终结符， 加入它的Vn->.xxxx
                    for dot_p in self.dot_items:
                        ind = dot_p.find("->")  # 返回-的下标
                        if dot_p[0] == dot_right[0] \
                                and dot_p[ind + 2] == "." \
                                and dot_p[1] != "'" \
                                and dot_p not in c_item:  # 首字符匹配 且不为增广符
                            c_item.append(dot_p)

        return c_item

    def go(self, item, v):  # 生成item向v移动后的item_production
        to_v_item = []
        for pro in item:  # 生成item能够用v跳转的新的产生式
            dot_left, dot_right = pro.split(".")
            if dot_right != "":
                if dot_right[0] == v:  # .右边是跳转符v
                    to_v_item.append(dot_left + dot_right[0] + "." + dot_right[1:])

        new_item = None
        if len(to_v_item) != 0:  # 求新产生式的闭包
            new_item = self.closure(to_v_item)

        return new_item

    def exist_idx(self, all_DFA, new_dfa):
        if new_dfa.item_ is None:
            return -1
        for i in range(len(all_DFA)):
            if new_dfa == all_DFA[i]:
                return i
        return -1

    def step3_construct_LR0_DFA(self, dot_items):
        # 生成初始Item0
        all_DFA = []
        item0_pros = []
        item0_pros.extend(self.closure([dot_items[0]]))
        all_DFA.append(DFA(0, item0_pros, {}))

        visited_dfa = []  # close表
        old_visted_dfa = []  # 用于判断close表长度是否再变化

        V = list(self.Vn) + list(self.Vt)  # 合并非终结符和终结符
        while True:
            old_visted_dfa = copy.deepcopy(visited_dfa)  # 副本

            for dfa in all_DFA:
                if dfa in visited_dfa:  # 已经访问过，则continue
                    continue
                visited_dfa.append(dfa)  # 加入close表
                item = dfa.item_
                for v in V:
                    new_item = self.go(item, v)
                    if new_item is not None:
                        new_dfa = DFA(-1, new_item, {})
                        idx = self.exist_idx(all_DFA, new_dfa)
                        if idx == -1:  # 不存在
                            new_dfa.id_ = len(all_DFA)
                            dfa.next_ids_[v] = new_dfa.id_
                            all_DFA.append(new_dfa)
                        else:  # 存在
                            dfa.next_ids_[v] = idx

            if len(old_visted_dfa) == len(visited_dfa):  # close表长度不变，退出循环
                break

        return all_DFA

    def print_DFA(self, all_DFA):
        for dfa in all_DFA:
            print("====")
            print(f"id={dfa.id_}")
            print(f"item={dfa.item_}")
            print(f"next={dfa.next_ids_} \n")

    def step4_draw_DFA(self, all_DFA):
        # 创建Digraph对象
        dot = graphviz.Digraph()
        for dfa in all_DFA:
            label = f"I{dfa.id_}\n"
            node_color = "lightblue"
            if dfa.id_ == 0:
                node_color = "lightpink"
            for pro in dfa.item_:
                label += pro + "\n"
            dot.node(str(dfa.id_), label=label,
                     style='filled', fillcolor=node_color,
                     shape='rectangle', fontname='Verdana')

            if len(dfa.next_ids_) != 0:
                for v, to_id in dfa.next_ids_.items():
                    dot.edge(str(dfa.id_), str(to_id), label=v, fontcolor='red')
        # 显示图形
        dot.view()
        return dot

    def step5_check_LR0(self, all_DFA):  # 判断是否为LR0文法
        flag = True
        for dfa in all_DFA:
            item = dfa.item_
            shift_num = 0  # 移进数目
            protocol_num = 0  # 归约数目
            shift_vt = set()
            protocol_vn = set()
            shift_pro = set()
            protocol_pro = set()
            for pro in item:
                dot_left, dot_right = pro.split(".")
                if dot_right == "":  # .在最后，为归约项目
                    # if dot_left[:2] == self.S + "'":  # 接受项目，不考虑为归约项目
                    #     continue
                    protocol_num += 1
                    pro_left, pro_right = pro.split("->")
                    protocol_vn.add(pro_left)
                    protocol_pro.add(pro)
                elif dot_right[0] in self.Vt:  # .后面为终结符，为移进项目
                    shift_num += 1
                    shift_vt.add(dot_right[0])
                    shift_pro.add(pro)
            if protocol_num == 1 and shift_num >= 1:
                shift_conf_msg = ""
                for s_pro in shift_pro:
                    shift_conf_msg += s_pro + " "
                print(f"I{dfa.id_}中：{shift_conf_msg} 与  {next(iter(protocol_pro))}存在移进-归约冲突")
                for vt in shift_vt:
                    for vn in protocol_vn:
                        if self.first[vt].intersection(self.follow[vn]):  # 有交集
                            flag = False
                            print(f"它们的first与follow交集不为空，不满足SLR")
                            return flag
                flag = True
                print(f"但它们的first与follow交集为空，可忽略")
            elif protocol_num >= 2:
                pro_conf_msg = ""
                for p_pro in protocol_pro:
                    pro_conf_msg += p_pro + " "
                print(f"I{dfa.id_}中: {pro_conf_msg} 存在归约-归约冲突，不满足SLR")
                flag = False

        return flag

    def step6_construct_LR0_table(self, all_DFA, formulas_str_list):

        actions = {}
        gotos = {}
        for dfa in all_DFA:
            id_ = dfa.id_
            next_ids = dfa.next_ids_
            if len(next_ids) == 0:  # 无下一个状态，必定为归约项目或接受项目，且只有一个
                pro = dfa.item_[0].replace(".", "")  # 去除.
                if pro == formulas_str_list[0]:  # 如果这一个为接受项目：S'->S
                    actions[(id_, "#")] = "acc"
                else:  # 其他的指定产生式
                    # ===========SLR1===========
                    # for vt in self.Vt:
                    #     actions[(id_, vt)] = "r" + str(formulas_str_list.index(pro))
                    # actions[(id_, "#")] = "r" + str(formulas_str_list.index(pro))

                    # ===========SLR===========
                    pro_left, pro_right = pro.split("->")
                    for ch in self.follow[pro_left]:
                        actions[(id_, ch)] = "r" + str(formulas_str_list.index(pro))
                    actions[(id_, "#")] = "r" + str(formulas_str_list.index(pro))
            else:  # 有指向下一个项目，同时当前项目可能存在接受项目、归约项目（点在末尾）、移进项目
                for item in dfa.item_:
                    pro_left, pro_right = item.split(".")
                    if pro_right == "":  # .在最后   为归约项目
                        pro = item.replace(".", "")
                        if pro == formulas_str_list[0]:  # 为接受项目
                            actions[(id_, "#")] = "acc"
                        else:  # 其他的归约项目
                            left, right = pro.split("->")
                            for ch in self.follow[left]:
                                actions[(id_, ch)] = "r" + str(formulas_str_list.index(pro))
                            actions[(id_, "#")] = "r" + str(formulas_str_list.index(pro))

                for v, to_dfa_id in next_ids.items():
                    if v in self.Vt:
                        actions[(id_, v)] = "S" + str(to_dfa_id)
                    elif v in self.Vn:
                        gotos[(id_, v)] = to_dfa_id

        # 转成df对象
        merged_dict = {key: value for d in (actions, gotos) for key, value in d.items()}
        sorted_keys = sorted(merged_dict.keys(), key=lambda x:
        (x[1].isupper(), x[1] == "#", x[1]))
        sort_dict = {key: merged_dict[key] for key in sorted_keys}
        columns = []
        for k in sort_dict.keys():
            if k[1] not in columns:
                columns.append(k[1])
        rows = set(key[0] for key in sort_dict.keys())
        df = pd.DataFrame(index=rows, columns=columns)
        for key, value in sort_dict.items():
            df.loc[key[0], key[1]] = value

        print(df)
        return actions, gotos

    def step7_LR0_analyse(self, actions, gotos, formulas_str_list, input_str):
        s = list(input_str)
        s.append("#")
        sp = 0  # 字符串指针

        state_stack = []
        symbol_stack = []
        state_stack.append(0)
        symbol_stack.append("#")

        step = 0
        msg = ""
        info_step, info_state_stack, info_symbol_stack, info_str, info_msg, info_res = [], [], [], [], [], ""
        # 分析
        while sp != len(s):
            step += 1
            ch = s[sp]
            top_state = state_stack[-1]
            top_symbol = symbol_stack[-1]
            info_step.append(step)
            info_state_stack.append("".join([str(x) for x in state_stack]))
            info_symbol_stack.append("".join(symbol_stack))
            info_str.append("".join(s[sp:]))
            if (top_state, ch) not in actions.keys():
                info_res = f"error：分析失败，找不到Action({(top_state, ch)})"
                info_msg.append("error")
                break
            find_action = actions[(top_state, ch)]

            if find_action[0] == "S":  # 移进操作
                state_stack.append(int(find_action[1:]))
                symbol_stack.append(ch)
                sp += 1
                msg = f"Action[{top_state},{ch}]={find_action}: 状态{find_action[1:]}入栈"
            elif find_action[0] == 'r':  # 归约操作
                pro = formulas_str_list[int(find_action[1:])]  # 获取第r行的产生式
                pro_left, pro_right = pro.split("->")
                pro_right_num = len(pro_right)
                for i in range(pro_right_num):
                    state_stack.pop()
                    symbol_stack.pop()
                symbol_stack.append(pro_left)
                goto_key = (state_stack[-1], symbol_stack[-1])
                if goto_key in gotos.keys():
                    state_stack.append(gotos[goto_key])
                    msg = f"{find_action}: 用{pro}归约，Goto[{top_state},{symbol_stack[-1]}]={gotos[goto_key]}入栈"
                else:
                    info_res = f"error：分析失败，找不到GOTO({state_stack[-1]},{symbol_stack[-1]})"
            elif find_action == "acc":
                msg = "acc: 分析成功！"
                info_msg.append(msg)
                info_res = "Success！"
                break
            info_msg.append(msg)
        # print
        print("{:<10} {:<10} {:<10} {:<10} {:<20}".format("步骤","状态栈","输入串","符号栈","分析"))
        for i in range(len(info_step)):
            print("{:<10} {:<10} {:<10} {:<10} {:<20}".format(info_step[i],info_state_stack[i],info_symbol_stack[i],info_str[i],info_msg[i]))
        info = {
            "info_step": info_step,
            "info_state_stack": info_state_stack,
            "info_symbol_stack": info_symbol_stack,
            "info_str": info_str,
            "info_msg": info_msg,
            "info_res": info_res
        }
        return info

    def init(self):
        print("===========基本信息==========")
        self.S, self.Vn, self.Vt, self.formulas_str_list, self.first, self.follow = self.step1_pre_process(
            self.formulas_str_list)
        self.dot_items = self.step2_all_dot_pros(self.formulas_str_list)  # 计算所有项目（带点）
        self.all_DFA = self.step3_construct_LR0_DFA(self.dot_items)  # 计算项目集的DFA转换关系
        # self.print_DFA(self.all_DFA)
        self.step4_draw_DFA(self.all_DFA)  # 画项目集的DFA转换图
        print("===========移进-归约重冲突=========")
        self.step5_check_LR0(self.all_DFA)  # 检测是否符合LR0文法
        print("===========SLR1表=========")
        self.actions, self.gotos = self.step6_construct_LR0_table(self.all_DFA, self.formulas_str_list)  # 画表

    def solve(self, input_str):
        print("===========分析过程=========")
        self.info = self.step7_LR0_analyse(self.actions, self.gotos, self.formulas_str_list, input_str)


if __name__ == "__main__":
    grammar1 = [  # ＋ ()
        "E->E+T",
        "E->T",
        "T->(E)",
        "T->i"
    ]
    grammar2 = [  # 课本例子
        "S->BB",
        "B->aB",
        "B->b"
    ]
    grammar3 = [  # + * ()
        "E->E+T",
        "E->T",
        "T->T*F",
        "T->F",
        "F->(E)",
        "F->i"
    ]
    lr0 = SLR1(grammar1)
    lr0.init()
    lr0.solve("i+i")

运行结果

测试1

输入：
文法：
分析串：

输出：

测试2

输入：
文法：
分析串：

输出：

测试3

输入：
文法：
分析串：

输出：

总结

对于SLR1分析法，检查是否符合SLR1文法时，需要在LR1文法的基础上，增加了各个项目对于follow集是否有交集的判断，因此需要另外实现first集和follow集的求解，另外。而且，SLR文法主要解决了LR0文法中出现的“移进-归约”冲突，但对于“归约-归约”冲突仍然不能解决。