LR语法分析器的实现代码(python)
《编译原理》中LR(0)语法分析动态演示系统分析与设计
《编译原理》中LR(0)语法分析动态演示系统分析与设计1. 引言1.1 研究背景编译原理是计算机科学领域的重要基础课程，而LR(0)语法分析是编译原理中一个关键的内容。
LR(0)语法分析是一种自底向上的语法分析方法，能够准确地判断一个输入串是否是给定文法的句子，同时可以生成句子对应的语法树。
LR(0)语法分析比上下文无关文法分析更为强大，因此被广泛应用于编译器的设计和实现中。
对于学习者来说，理解和掌握LR(0)语法分析并不是一件容易的事情。
传统的教学方法往往是通过讲解和演示来进行，但存在一定的局限性，学生很难深入理解其中的逻辑和原理。
设计一个LR(0)语法分析动态演示系统是十分必要和有意义的。
这样的系统可以通过图形化的界面展示LR(0)语法分析的每个步骤和过程，帮助学生更直观地理解LR(0)语法分析的原理和实现。
1.2 研究目的研究目的是为了通过设计和实现一个LR(0)语法分析动态演示系统，帮助学生和从业者更好地理解和应用LR(0)语法分析算法。
具体来说，研究目的包括但不限于以下几点：通过分析LR(0)语法分析算法的原理和流程，深入探讨其在编译原理中的重要性和应用价值，为用户提供一个直观、动态的学习工具，帮助他们更好地理解和掌握这一算法的核心概念。
通过设计和实现一个功能齐全、易于操作的LR(0)语法分析动态演示系统，提供用户友好的界面和交互功能，使用户可以通过实际操作和观察，加深对LR(0)语法分析算法的认识，并在实践中掌握其使用方法和技巧。
通过系统测试和优化，不断改进系统性能和用户体验，确保系统稳定运行并具有良好的可用性和可靠性，为用户提供一个高质量的学习工具和应用工具。
通过这些努力，旨在提高用户对LR(0)语法分析算法的理解和应用能力，促进编译原理领域的教学和研究工作的发展。
1.3 研究意义编译原理是计算机专业的重要基础课程，而LR(0)语法分析是编译原理中一项重要的内容。
通过设计和实现一个LR(0)语法分析动态演示系统，可以帮助学生更加直观地理解和掌握LR(0)语法分析的原理和算法。
编译原理词法分析器-ll1-lr0-python实现代码
编译原理词法分析器-ll1-lr0-python实现代码计算机科学与通信工程学院编译原理实验报告题目： 1.词法分析器2. LL(1)分析器3. LR(0)分析器班级：姓名:学号：指导老师：2017年月目录一、实验题目 (1)二、实验目的和要求 (1)三、代码实现 (2)四、总结 (25)一、实验题目1.词法分析器分析一段程序代码，将代码中的单词符号分解出来，并对其进行检查，输出token表和error表2.LL(1)文法分析器分析给定文法。
求出文法的FIRST集，FOLLOW集，并构建分析表，对给定输入串进行分析。
3.LR(0)文法分析器分析给定文法。
用Ꜫ_CLOSURE方法构造文法的LR(0)项目集规范族，根据状态转换函数GO构造出文法的DFA,并转换为分析表，对给定输入串进行分析。
二、实验目的和要求1.学会词法分析器的实现思路。
2.学会求解FIRST集， FOLLOW集，构造LL(1)分析表。
3.学会Ꜫ_CLOSURE方法，状态转换函数GO, 构造LR(0)分析表。
三、代码实现1.词法分析器program.txt 中存放要分析的文法：E->TRR->+TR|-TR|~T->FGG->*FG|/FG|~F->(E)|i代码：KEYWORD_LIST = ['while', 'if', 'else', 'switch', 'case']SEPARATOR_LIST = [';', ':', ',', '(', ')', '[', ']', '{', '}']OPERATOR_LIST1 = ['+', '-', '*']OPERATOR_LIST2 = ['<=', '<', '==', '=', '>', '>=']CATEGORY_DICT = {# KEYWORD"while": {"while": ""},"if": {"if": ""},"else": {"else": ""},"switch": {"switch": ""},"case": {"case": ""},# OPERATOR"+": {"+": ""},"-": {"-": ""},"*": {"*": ""},"<=": {"relop": "LE"},"<": {"relop": "LT"},">=": {"relop": "GE"},">": {"relop": "GT"},"==": {"relop": "EQ"},"=": {"=": ""},# SEPARATOR";": {";": ""},":": {":": ""},",": {",": ""},"(": {"(": ""},")": {")": ""},"[": {"]": ""},"]": {"]": ""},"{": {"{": ""},"}": {"}": ""},}CONSTANTTABLE = []TOKENTABLE = []OPERATORTABLE = []KEYWORDTABLE = []SEPARATORTABLE = []UNDEFINEDTABLE = []# READ FILEdef read_file(path, method):temp_str = ""try:file = open(path, method)for line in file:line = line.replace('\n', " ") temp_str += linetemp_str = str(temp_str)except IOError as e:print(e)exit()finally:file.close()return temp_str.strip() + " "# GETBEdef getbe():global tokengetchar()token = ""return# GETCHARdef getchar():global characterglobal locationwhile all_string[location] == " ":location = location + 1character = all_string[location]return character# LINK TOKENdef concatenation():global tokenglobal charactertoken = token + character# IS NUMBERdef digit():if '0' <= character <= '9':return Truereturn False# IS ALPHABETdef letter():if 'A' <= character <= 'Z' or 'a' <= character <= 'z': return Truereturn False# IS IDENTIFIERdef reserve():if token in KEYWORD_LIST:return CATEGORY_DICT[token]else:return 0# RETRACTdef retract():global locationglobal character# location = location - 1character = ""return# MAIN FUNCTIONdef main():global tokenglobal characters = getchar()getbe()if 'a' <= s <= 'z' or 'A' <= s <= 'Z':while letter() or digit():concatenation()location = location + 1character = all_string[location]retract()c = reserve()if c == 0:TOKENTABLE.append(token)print("这是标识符：{'", token, "':'", TOKENTABLE.index(token), "'}") else:KEYWORDTABLE.append(token)print("这是保留字：", CATEGORY_DICT[token])elif '0' <= s <= '9':while digit():concatenation()location = location + 1character = all_string[location]retract()CONSTANTTABLE.append(token)print("这是常数：{'", token, "':'", CONSTANTTABLE.index(token), "'}") elif s in OPERATOR_LIST1:location = location + 1OPERATORTABLE.append(s)print("这是单操作符：", CATEGORY_DICT[s])elif s in OPERATOR_LIST2:location = location + 1character = all_string[location]if character == '=':OPERATORTABLE.append(s + character)print("这是双操作符：", CATEGORY_DICT[s + character])else:retract()location = location + 1OPERATORTABLE.append(s)print("这是单操作符:", CATEGORY_DICT[s])elif s in SEPARATOR_LIST:location = location + 1SEPARATORTABLE.append(s)print("这是分隔符：", CATEGORY_DICT[s])else:UNDEFINEDTABLE.append(s)print("error:undefined identity :'", s, "'")if __name__ == '__main__':character = ""token = ""all_string = read_file("program.txt", "r")location = 0while location + 1 < len(all_string):main()print('KEYWORDTABLE:', KEYWORDTABLE)print('TOKENTABLE:', TOKENTABLE)print('CONSTANTTABLE:', CONSTANTTABLE)print('OPERATORTABLE:', OPERATORTABLE)print('SEPARATORTABLE:', SEPARATORTABLE)运行结果：2.LL(1)分析器program.txt 中存放要分析的文法：E->TRR->+TR|-TR|~T->FGG->*FG|/FG|~F->(E)|i输入串：i+i*i代码：NonTermSet = set() # 非终结符集合TermSet = set() # 终结符集合First = {} # First集Follow = {} # Follow集GramaDict = {} # 处理过的产生式Code = [] # 读入的产生式AnalysisList = {} # 分析表StartSym = "" # 开始符号EndSym = '#' # 结束符号为“#“Epsilon = "~" # 由于没有epsilon符号用“~”代替# 构造First集def getFirst():global NonTermSet, TermSet, First, Follow, FirstAfor X in NonTermSet:First[X] = set() # 初始化非终结符First集为空for X in TermSet:First[X] = set(X) # 初始化终结符First集为自己Change = Truewhile Change: # 当First集没有更新则算法结束Change = Falsefor X in NonTermSet:for Y in GramaDict[X]:k = 0Continue = Truewhile Continue and k < len(Y):if not First[Y[k]] - set(Epsilon) <= First[X]: # 没有一样的就添加，并且改变标志if Epsilon not in First[Y[k]] and Y[k] in NonTermSet and k > 0: # Y1到Yi候选式都有~存在Continue = Falseelse:First[X] |= First[Y[k]] - set(Epsilon)Change = Trueif Epsilon not in First[Y[k]]:Continue = Falsek += 1if Continue: # X->~或者Y1到Yk均有~产生式First[X] |= set(Epsilon)# FirstA[Y] |= set(Epsilon)# 构造Follow集def getFollow():global NonTermSet, TermSet, First, Follow, StartSymfor A in NonTermSet:Follow[A] = set()Follow[StartSym].add(EndSym) # 将结束符号加入Follow[开始符号]中Change = Truewhile Change: # 当Follow集没有更新算法结束Change = Falsefor X in NonTermSet:for Y in GramaDict[X]:for i in range(len(Y)):if Y[i] in TermSet:continueFlag = Truefor j in range(i + 1, len(Y)): # continueif not First[Y[j]] - set(Epsilon) <= Follow[Y[i]]:Follow[Y[i]] |= First[Y[j]] - set(Epsilon) # 步骤2 FIRST(β)/~ 加入到FOLLOW(B)中。
语法法分析实验报告
一、实验目的1. 理解语法分析的基本概念和原理。
2. 掌握语法分析器的构建方法。
3. 培养实际操作能力，提高编程水平。
二、实验环境1. 操作系统：Windows 102. 编程语言：Python3.83. 开发工具：PyCharm三、实验内容1. 语法分析概述2. 词法分析3. 语法分析4. 实验实现四、实验步骤1. 语法分析概述（1）了解语法分析的定义、作用和意义。
（2）掌握语法分析的基本原理和流程。
2. 词法分析（1）编写词法分析器代码，将源代码分解成单词序列。
（2）实现词法分析器的各个功能，如：识别标识符、关键字、运算符等。
3. 语法分析（1）设计语法分析器，将单词序列转换为抽象语法树（AST）。
（2）实现语法分析器的各个功能，如：识别表达式、语句、函数等。
4. 实验实现（1）创建Python项目，导入相关库。
（2）编写词法分析器代码，实现单词序列的分解。
（3）编写语法分析器代码，实现抽象语法树的构建。
（4）测试语法分析器，验证其正确性。
五、实验结果与分析1. 词法分析结果实验中，我们成功地将源代码分解成单词序列，包括标识符、关键字、运算符等。
词法分析器的输出结果如下：```identifier: akeyword: intoperator: +identifier: boperator: =integer: 5```2. 语法分析结果通过语法分析器，我们将单词序列转换成抽象语法树。
以下是一个示例的抽象语法树：```Program├── Declaration│ ├── Type│ │ ├── Identifier│ │ └── Integer│ └── Identifier│ └── a└── Statement├── Expression│ ├── Identifier│ └── a└── Operator└── =└── Expression├── Identifier└── b└── Integer└── 5```从实验结果可以看出，我们的语法分析器能够正确地将源代码转换为抽象语法树。
语法分析代码2(LR分析器 C语言实现)
#include"status_stack.h"#include"symbol_instr_stack.h"#include"lr.h"//打印LR分析器的工作过程void print(status *status_p,symbol_instr *symbol_p,symbol_instr *instr_p) {int i;out_stack(status_p);for(i=0;i<20-status_p->top;i++)printf(" ");out_stack1(symbol_p);for(i=0;i<20;i++)printf(" ");out_stack2(instr_p);printf("\n");}//状态转换函数int goto_char(status *status_p,symbol_instr *instr_p){char x;int y,z;x = get_top(instr_p);y = get_top(status_p);z = get_index_char(x);return table[y][z];}//移进－－规约函数void action(status *status_p,symbol_instr *symbol_p,symbol_instr *instr_p) {int i,j,x;char a;i = goto_char(status_p,instr_p);//规约出错if(i == -1)printf("\n===============规约出错!================\n");//规约成功if(i == 12)printf("\n===============规约成功!================\n");//移进动作if(i>=0 && i<=11){push(status_p,i);a = pop(instr_p);push(symbol_p,a);print(status_p,symbol_p,instr_p);action(status_p,symbol_p,instr_p);}//规约动作if(i>=21 && i<=26){x = r[i-21].y;for(j=0;j<x;j++){pop(status_p);pop(symbol_p);}push(instr_p,r[i-21].x);action(status_p,symbol_p,instr_p);}}int main(){char x;//分配空间status *status_p;symbol_instr *symbol_p,*instr_p ;status_p = (status *)malloc(sizeof(status));symbol_p = (symbol_instr *)malloc(sizeof(symbol_instr));instr_p = (symbol_instr *)malloc(sizeof(symbol_instr));//初始化各栈init_stack(status_p);init_stack(symbol_p);init_stack(instr_p);//压进栈初始元素push(status_p,0);//push(symbol_p,'#');////输入表达式printf("\n请输入要规约的输入串，各字符之间不能有空格，以'#'字符结束!\n");printf("===========Expression =");//先将输入串压进符号栈do{scanf("%c",&x);push(symbol_p,x);}while(x != '#');//然后由符号栈弹出，压进输入栈while( symbol_p->top != 0){x = pop(symbol_p);push(instr_p,x);}printf("\n\n");//打印框架printf("\n状态栈==============符号栈==============输入串\n");print(status_p,symbol_p,instr_p);//打印初始分析表//移进，规约，并打印每一步分析过程action(status_p,symbol_p,instr_p);return 0;}。
第讲LR分析法
第讲LR分析法LR分析法是一种常用的语法分析方法，可以用于生成语法树，它是自底向上的语法分析方法。
在LR分析法中，L表示“自左向右扫描输入串的方式”，R表示“反向构建和规约的方式”。
LR分析法包括以下几个步骤：1.构造LR(0)项目集规范族：LR(0)项目集是指在一些语法分析的过程中，每个项目表示对应的产生式的哪一部分已经被扫描过了，哪一部分还没有被扫描过。
根据给定的文法，构造出所有可能的项目集，并将它们进行编号，得到项目集规范族。
2.构造LR(0)项目集规范族的DFA：根据构造出的LR(0)项目集规范族，可以构造出一个DFA（确定性有限自动机）来表示LR(0)语法分析的过程。
DFA的每个状态表示一个项目集，每个转移表示在一个状态下扫描一些符号后转移到另一个状态。
3.构造LR(0)分析表：根据构造出的LR(0)项目集规范族的DFA，可以构造出一个分析表，即LR(0)分析表。
分析表的行表示当前状态，列表示当前输入符号，表格中的每个元素表示下一步应该做的动作，可以是移进一些符号，也可以是规约一些项目。
4.进行LR(0)分析：根据构造出的LR(0)分析表，可以进行LR(0)语法分析。
分析的过程是根据当前状态和输入符号，在分析表中查找对应的动作，并执行该动作。
如果遇到移进动作，就将符号加入到解析栈中，同时移动输入指针；如果遇到规约动作，就从解析栈中弹出一些符号，然后根据规约产生式将新的非终结符加入到解析栈中。
5.构造SLR(1)分析表：LR(0)分析表中存在冲突的情况，无法完全正确地进行语法分析。
为了解决这个问题，需要对LR(0)分析表进行优化，得到SLR(1)分析表。
SLR(1)分析表与LR(0)分析表的结构类似，只是在一些冲突的情况下给出更加具体的动作指令。
6.进行SLR(1)分析：根据构造出的SLR(1)分析表，可以进行SLR(1)语法分析。
与LR(0)分析类似，根据当前状态和输入符号，在分析表中查找对应的动作，并执行该动作。
词法分析实验报告代码
一、实验目的1. 理解词法分析的概念和作用。
2. 掌握词法分析器的设计和实现方法。
3. 通过实验加深对编译原理中词法分析阶段的理解。
二、实验环境1. 操作系统：Windows 102. 编程语言：Python3.83. 开发工具：PyCharm三、实验内容1. 设计一个简单的词法分析器，能够识别并输出源代码中的单词。
2. 实现词法分析器的关键功能，包括：- 字符串预处理- 单词识别- 生成词法分析表四、实验步骤1. 字符串预处理- 读取源代码字符串。
- 移除字符串中的空白字符（空格、制表符、换行符等）。
- 转义字符串中的特殊字符。
2. 单词识别- 使用正则表达式匹配单词。
- 根据正则表达式匹配结果，将单词分类为关键字、标识符、常量等。
3. 生成词法分析表- 创建一个列表，用于存储词法分析表中的每个单词及其对应的类别。
- 遍历源代码字符串，将识别出的单词添加到词法分析表中。
五、实验代码```pythonimport re# 定义词法分析表结构class Token:def __init__(self, type, value):self.type = typeself.value = value# 单词识别函数def tokenize(source_code):# 移除空白字符source_code = re.sub(r'\s+', '', source_code)# 转义特殊字符source_code = re.sub(r'\\', '\\\\', source_code)# 使用正则表达式匹配单词tokens = re.findall(r'\b\w+\b', source_code)# 生成词法分析表token_table = []for token in tokens:if re.match(r'\bint\b', token):token_table.append(Token('KEYWORD', token))elif re.match(r'\bfloat\b', token):token_table.append(Token('KEYWORD', token))elif re.match(r'\bchar\b', token):token_table.append(Token('KEYWORD', token))elif re.match(r'\bif\b', token):token_table.append(Token('KEYWORD', token))elif re.match(r'\belse\b', token):token_table.append(Token('KEYWORD', token))elif re.match(r'\breturn\b', token):token_table.append(Token('KEYWORD', token))elif re.match(r'\b\w+\b', token):token_table.append(Token('IDENTIFIER', token)) else:token_table.append(Token('CONSTANT', token)) return token_table# 主函数def main():# 读取源代码source_code = '''int main() {int a = 10;float b = 3.14;char c = 'A';if (a > b) {return a;} else {return b;}}'''# 进行词法分析token_table = tokenize(source_code)# 输出词法分析结果for token in token_table:print(f'Type: {token.type}, Value: {token.value}') if __name__ == '__main__':main()```六、实验结果运行实验代码后，输出如下：```Type: KEYWORD, Value: intType: IDENTIFIER, Value: mainType: KEYWORD, Value: (Type: KEYWORD, Value: )Type: KEYWORD, Value: intType: IDENTIFIER, Value: a Type: KEYWORD, Value: = Type: CONSTANT, Value: 10 Type: KEYWORD, Value: ; Type: KEYWORD, Value: float Type: IDENTIFIER, Value: b Type: KEYWORD, Value: = Type: CONSTANT, Value: 3.14 Type: KEYWORD, Value: ; Type: KEYWORD, Value: char Type: IDENTIFIER, Value: c Type: KEYWORD, Value: = Type: CONSTANT, Value: A Type: KEYWORD, Value: ; Type: KEYWORD, Value: if Type: IDENTIFIER, Value: ( Type: IDENTIFIER, Value: a Type: KEYWORD, Value: > Type: IDENTIFIER, Value: b Type: KEYWORD, Value: ) Type: KEYWORD, Value: { Type: KEYWORD, Value: return Type: IDENTIFIER, Value: aType: KEYWORD, Value: ;Type: KEYWORD, Value: }Type: KEYWORD, Value: elseType: KEYWORD, Value: {Type: KEYWORD, Value: returnType: IDENTIFIER, Value: bType: KEYWORD, Value: ;Type: KEYWORD, Value: }```七、实验总结通过本次实验，我们成功地设计并实现了一个简单的词法分析器，能够识别并输出源代码中的单词。
实验5---语法分析器(自下而上)：LR(1)分析法
实验5---语法分析器（自下而上）：LR(1)分析法一、实验目的构造LR(1)分析程序，利用它进行语法分析，判断给出的符号串是否为该文法识别的句子，了解LR（K）分析方法是严格的从左向右扫描，和自底向上的语法分析方法。
二、实验内容程序输入/输出示例（以下仅供参考）：对下列文法，用LR（1）分析法对任意输入的符号串进行分析：（1）E->E+T（2）E->E—T（3）T->T*F（4）T->T/F（5）F-> (E)（6）F->i输出的格式如下：(1)LR（1）分析程序，编制人：姓名，学号，班级(2)输入一个以#结束的符号串(包括+—*/（）i#)：在此位置输入符号串(3)输出过程如下：3.对学有余力的同学，测试用的表达式事先放在文本文件中，一行存放一个表达式，同时以分号分割。
同时将预期的输出结果写在另一个文本文件中，以便和输出进行对照。
三、实验方法1．实验采用C++程序语言进行设计，文法写入程序中，用户可以自定义输入语句；2．实验开发工具为DEV C++。
四、实验步骤1．定义LR(1)分析法实验设计思想及算法①若ACTION[sm , ai] = s则将s移进状态栈，并把输入符号加入符号栈，则三元式变成为：(s0s1…sm s , #X1X2…Xm ai , ai+1…an#)；②若ACTION[sm , ai] = rj则将第j个产生式A->β进行归约。
此时三元式变为(s0s1…sm-r s , #X1X2…Xm-rA , aiai+1…an#)；③若ACTION[sm , ai]为“接收”，则三元式不再变化，变化过程终止，宣布分析成功；④若ACTION[sm , ai]为“报错”，则三元式的变化过程终止，报告错误。
2．定义语法构造的代码，与主代码分离，写为头文件LR.h。
3．编写主程序利用上文描述算法实现本实验要求。
五、实验结果1. 实验文法为程序既定的文法，写在头文件LR.h中，运行程序，用户可以自由输入测试语句。
语法树解析 python
语法树解析python在自然语言处理领域，语法树发挥着至关重要的作用。
它是句子结构的一种树状表示，能帮助我们更好地理解句子的语法结构和意义。
Python作为一门流行的编程语言，拥有丰富的自然语言处理库，可以方便地进行语法树的解析。
本文将详细介绍如何使用Python进行语法树解析。
一、什么是语法树？语法树（Syntax Tree），又称作句法树，是源代码、自然语言句子等结构的一种抽象语法结构的树状表示。
在自然语言处理中，语法树能够清晰地展示句子的成分结构，如主语、谓语、宾语等，以及它们之间的关系。
二、Python中的语法树解析在Python中，可以使用自然语言处理库（如NLTK、spaCy等）进行语法树的解析。
以下以NLTK库为例，介绍如何实现语法树的解析。
1.安装NLTK库首先，需要安装NLTK库。
在命令行执行以下命令：```pip install nltk```2.使用NLTK解析语法树（1）导入所需模块```pythonimport nltkfrom nltk import CFGfrom nltk.parse import ChartParser```（2）定义语法规则使用上下文无关文法（CFG）定义语法规则。
```pythongrammar = CFG.fromstring("""S -> NP VPVP -> V NPNP -> "I" | "you"V -> "love"""")```（3）创建解析器```pythonparser = ChartParser(grammar)```（4）解析句子将句子转换为词列表，然后使用解析器进行解析。
```pythonsentence = "I love you".split()trees = list(parser.parse(sentence))```（5）显示语法树```pythonfor tree in trees:tree.pretty_print()```三、总结通过使用Python中的自然语言处理库，如NLTK，我们可以方便地进行语法树的解析。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
LR语法分析器的实现代码（python）
•构造LR(0)项目集：
–构造I的闭包CLOSURE(I)的算法如下：
i.I的任何项目都属于CLOSURE(I)；
ii.若A→α•Bβ属于CLOSURE(I)，对任何产生式B→γ，B→•γ也属于CLOSURE(I)；
iii.重复执行上述两步骤直至CLOSURE(I)不再增大为止。
iv.实现代码如下
def get_CLOSURE(tmp): # 生成闭包 CLOSURE = [] for it in tmp:
if(it not in CLOSURE): CLOSURE.append(it) x, y = it.split
(".") if(y == ""): continue v = y[0] if(v in VN): r
es = get_VN_gram(v) # 返回非终结符产生的A->.aBb形式 for
re in res: if(re not in CLOSURE): CLOSURE.append(r
e) return CLOSURE
–Go(I,a)函数构造算法
i.I为当前状态，X为文法符号，J为I中所有形如A->α·Xβ的
项目的后续项目所组成的集合，而CLOSURE(J)就是项目集I
关于X的后续状态
ii.实现代码如下
def go(item, v): #生成并返回下一个item tmp = [] for it in ite
m: x, y = it.split(".") if(y!=""): if(y[0] == v): new_
it = x + y[0] + "." + y[1:] tmp.append(new_it) if(len(tmp)!=
0): new_item = get_CLOSURE(tmp) #print(tmp) #print("g
o(item, "+v + ") = " + str(new_item)) return new_item
–判别LR项目集是否合法：
•无移进项目和规约项目并存
•无多个规约项目并存
•代码如下：
def lr_is_legal(: # 判别lr是否合法 has_protocol = 0 #是否存在规约项目 has_shift = 0 #是否存在移进项目 for item in items: for it in item: x, y = it.split(".") if(y ==""): if(has_protocol != 0 or has_shift !
= 0): return False has_protocol = 1 else: if(y
[0] in VT): has_shift = 1 return True
•构造LR(0)分析表
–构造算法：
i.假定项目集规范族C={I0,I1,…,In}。
令每一个项目集Ik的下标
k作为分析器的状态。
分析表的ACTION子表和GOTO子表可
按如下方法构造
ii.令那个包含项目S’→•S的集合Ik的下标k为分析器的初态。
iii.若项目A→α•aβ属于Ik且GO(Ik , a)= Ij,a为终结符，置
ACTION[k,a]为“把(j,a)移进栈”，简记为“sj”。
iv.若项目A→α•属于Ik，对任何终结符a(或结束符#)，置
ACTION[k,a]为“用产生式A→α进行归约”，简记为“rj”（假定
产生式A→α是文法G’的第j个产生式）。
v.若项目S’→S•属于Ik，则置ACTION[k,#]为“接受”，简记为
“acc”。
vi.若GO(Ik , A)= Ij，A为非终结符，则置GOTO[k,A]=j。
vii.分析表中凡不能用规则1至4填入信息的空白格均填上“err”。
def get_lr_table(: #构建lr分析表 init_lr_table( lr_is_legal( i=
0 j=0 for item in items: for it in item: x, y = it.split(".")
if(y==""): #判断是否写入ACTION if (it == "S'->S."): AC
TION[i][len(VT)-1] = "acc" ind = find_gram(it) if(ind != -
1): for k in range(len(ACTION[i])): ACTION[i][k]="r
"+str(ind+1) else: next_item = go(item, y[0]) # print
("go(%s, %s)-->%s" % (str(item), y[0], str(next_item))) ind = is_
inItems(next_item) if(ind != -1): #判断是否写入GOTO i
f (y[0] in VT): j = VT2Int[y[0]] ACTION[i][j] = "s"
+ str(ind) if(y[0] in VN): j = VN2Int[y[0]]
GOTO[i][j] = ind i = i + 1
•LR0规约算法
–遍历输入字符串，对于每一个字符，获取当前状态栈的顶部的状态值，通过查询action表获取的当前的操作是移进、规约还是接受–如果当前操作是移进，将新的状态放入状态栈当中，当移入的字符放入符号栈中。
–如果当前操作是规约，那么将需要规约的部分的状态从状态栈中弹出，将规约后的状态放入状态栈，将规约后的左部放入符号栈，当前的字
符不向下推进
–如果接收，则结束
def stipulations(: # 根据LR(0)表进行规约 global location print('----分析
过程----') print("index\t\t", end='') print('%-20s' % 'Status', end='') print ('%-50s' % 'Symbol', end='') print('%-30s' % 'Input', end='') print('Action
') for i in range(len(dot_grams)): print('---', end='') print( symbol_stac k.append('#') status_stack.append(0) while not is_end(: now_state = sta
tus_stack[-1] input_ch = input_str[location] if(input_ch not in Vs):
print("错误字符") return -1 output( find = ACTION[now_state][V T2Int[input_ch]] if find[0] == 's': # 进入action symbol_stack.append (input_ch) status_stack.append(int(find[1])) location += 1 pri nt('action[%s][%s]=s%s' % (now_state, input_ch, find[1])) elif find[0] ==
'r': # 进入goto num = int(find[1]) g = grams[num - 1] right_n um = count_right_num(g) #print("\n%s"%g) for i in range(right_n um): status_stack.pop( symbol_stack.pop( symbol_stack.a ppend(g[0]) now_state = status_stack[-1] symbol_ch = symbol_stac k[-1] find = GOTO[now_state][VN2Int.get(symbol_ch, -1)] if find == -1: print('分析失败') return -1 status_stack.append(fin
d) print('%s' % g) else: return -1 print("\n is done") return 0 •全部代码：。