合工大 编译原理 实验二 LL1 自动生成M[A,a]

最新推荐文章于 2023-06-03 16:45:46 发布
最新推荐文章于 2023-06-03 16:45:46 发布
阅读量1.8k 收藏 23
点赞数 7
文章标签： c++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_45205060/article/details/116242110
版权
该实验旨在通过实现LL_1预测分析法的语法分析程序，理解预测分析法和递归子程序法的区别与联系。程序首先提取文法规则中的非终结符和推导式，然后计算FIRST和FOLLOW集合，并构建查找表。最终，使用查找表进行字符串解析。实验有助于提升学生的专业素质和应用开发能力。
摘要由CSDN通过智能技术生成

实验目的
通过完成预测分析法的语法分析程序，了解预测分析法和递归子程序法的区
别和联系。使学生了解语法分析的功能，掌握语法分析程序设计的原理和构造方
法，训练学生掌握开发应用程序的基本方法。有利于提高学生的专业素质，为培
养适应社会多方面需要的能力。
实验截图
在这里插入图片描述

#include <iostream>
#include <stack>
#include <algorithm>
#include <string>
#include <vector>
#include <set>
using namespace std;

bool isVN(char a) {
	if (a >= 'A' && a <= 'Z')
		return true;
	else return false;
}

int LL_1(string grammar, string stc) {
	char start = grammar[0];          //记录开始符
	int a[10][10] = { 0 };
	vector<char> vn;
	vector<string> drived;
	vector<char> vt;
	int i = 0;
	while (i < grammar.length()) {          //获取非终结符
		if (isVN(grammar[i])) {
			vn.push_back(grammar[i]);
		}
		i++;
	}
	i = 0;
	while (i < grammar.length()) {          //获取所有推导式
		string tmp = "";
		while (grammar[i] != '\n' && i < grammar.length()) {
			tmp += grammar[i];
			i++;
		}
		i++;
		drived.push_back(tmp);
	}
	i = 0;
	while (i < grammar.length()) {          //获取zhongjiefu
		if (grammar[i] != '\n' && !isVN(grammar[i]) && grammar[i] != '|' && grammar[i] != '?' && grammar[i] != ' ') {
			vt.push_back(grammar[i]);
		}
		i++;
	}

	sort(vn.begin(), vn.end());          //非终结符去重
	auto pos = unique(vn.begin(), vn.end());
	vn.erase(pos, vn.end());

	sort(vt.begin(), vt.end());          //非终结符去重
	auto pos2 = unique(vt.begin(), vt.end());
	vt.erase(pos2, vt.end());

	int f_size = vn.size();   //sizeof FIRST and FOLLOW
	//初始化first集合
	set<char> first[10];
	for (int i = 0; i < f_size; i++) {               //init first[]
		for (int j = 0; j < drived.size(); j++) {
			for (int k = 2; k < drived[j].size(); k++) {
				if (vn[i] == drived[j][0]) {
					if ((drived[j][k - 1] == '|' && !isVN(drived[j][k])) || (drived[j][k - 1] == ' ' && !isVN(drived[j][k]))) {
						first[i].insert(drived[j][k]);
					}
				}
			}
		}
	}

	for (int j = 0; j < drived.size(); j++) {           //用矩阵记录形如E->T T->S的非终结符通路
		for (int k = 0; k < f_size; k++) {
			if (drived[j][0] == vn[k]) {
				for (int l = 2; l < drived[j].size(); l++) {
					if (isVN(drived[j][l])) {
						for (int m = 0; m < f_size; m++) {
							if (drived[j][l] == vn[m] && (drived[j][l - 1] == '|' || drived[j][l - 1] == ' ')) {
								a[k][m] = 1;

							}

						}
					}
				}
				break;
			}

		}
	}
	//初始化标志数组 记录first的改变
	int flag[10] = { 0 };
	for (int j = 0; j < 10; j++) {
		flag[j] = first[j].size();
	}
	int sig = 0;
	for (int j = 0; j < f_size; j++) {
		for (int k = 0; k < f_size; k++) {
			if (a[j][k] == 1) {
				for (set<char>::iterator it = first[k].begin(); it != first[k].end(); it++) {
					first[j].insert(*it);
				}
			}
		}
	}
	do {
		for (int j = 0; j < f_size; j++) {
			for (int k = 0; k < f_size; k++) {
				if (a[j][k] == 1) {
					for (set<char>::iterator it = first[k].begin(); it != first[k].end(); it++) {
						first[j].insert(*it);
					}
				}
			}
		}
		for (int j = 0; j < 10; j++) {
			if (flag[j] != first[j].size()) {           //当first集合发生改变时，就得执行循环，直到不改变为止
				sig = 1;
				flag[j] = first[j].size();
				break;
			}
			if (j == 9) {
				sig = 0;
			}
		}
	} while (sig);

	set<char> follow[10];
	for (int j = 0; j < f_size; j++) {
		if (vn[j] == start) {
			follow[j].insert('#');
			break;
		}
	}

	//遍历推导式从二位开始 1遇到两个大写连着 后面的first加入前面的follow 2遇到大写后面跟着终结符，加入其follow
	for (int j = 0; j < drived.size(); j++) {
		for (int k = 2; k < drived[j].size() - 1; k++) {
			if (isVN(drived[j][k]) && isVN(drived[j][k + 1])) {         //对应条件1
				for (int l = 0; l < f_size; l++) {
					if (drived[j][k + 1] == vn[l]) {
						for (int m = 0; m < f_size; m++) {
							if (drived[j][k] == vn[m]) {
								for (set<char>::iterator it = first[l].begin(); it != first[l].end(); it++) {
									if (*it != '?') {
										follow[m].insert(*it);
									}

								}
								break;
							}
						}
						break;
					}
				}
			}
			if (isVN(drived[j][k]) && !isVN(drived[j][k + 1]) && drived[j][k + 1] != '|' && drived[j][k + 1] != '?') {    //对应条件2
				for (int l = 0; l < f_size; l++) {
					if (drived[j][k] == vn[l]) {
						follow[l].insert(drived[j][k + 1]);
						break;
					}
				}
			}
		}
	}
	int flag2[10] = { 0 };
	for (int j = 0; j < 10; j++) {
		flag2[j] = follow[j].size();
	}
	sig = 0;
	//follow第三条规则 E->anyH follow E = follow H
	do {
		for (int j = 0; j < drived.size(); j++) {
			for (int k = 2; k < drived[j].size() - 1; k++) {
				if (k == drived[j].size() - 2 && isVN(drived[j][k + 1])) {
					for (int l = 0; l < f_size; l++) {
						if (drived[j][k + 1] == vn[l]) {
							for (int m = 0; m < f_size; m++) {
								if (drived[j][0] == vn[m]) {
									for (set<char>::iterator it = follow[l].begin(); it != follow[l].end(); it++) {
										follow[m].insert(*it);
									}
									for (set<char>::iterator it = follow[m].begin(); it != follow[m].end(); it++) {
										follow[l].insert(*it);
									}
									break;
								}
							}
							break;
						}
					}
				}
				if (isVN(drived[j][k]) && drived[j][k + 1] == '|') {
					for (int l = 0; l < f_size; l++) {
						if (drived[j][k] == vn[l]) {
							for (int m = 0; m < f_size; m++) {
								if (drived[j][0] == vn[m]) {
									for (set<char>::iterator it = follow[l].begin(); it != follow[l].end(); it++) {
										follow[m].insert(*it);
									}
									for (set<char>::iterator it = follow[m].begin(); it != follow[m].end(); it++) {
										follow[l].insert(*it);
									}
									break;
								}
							}
							break;
						}
					}
				}
			}
		}
		for (int j = 0; j < 10; j++) {
			if (flag2[j] != follow[j].size()) {           //当follow集合发生改变时，就得执行循环，直到不改变为止
				sig = 1;
				flag2[j] = follow[j].size();
				break;
			}
			if (j == 9) {
				sig = 0;
			}
		}
	} while (sig);
	
	// 构造M[A,a]
	string m[10][10];
	for (int i = 0; i < vt.size(); i++) {
		string tmp = "";
		tmp += vt[i];
		m[0][i + 1] = tmp;
	}
	for (int i = 0; i < vn.size(); i++) {
		string tmp = "";
		tmp += vn[i];
		m[i + 1][0] = tmp;
	}
	
	for (int i = 1; i < vt.size() + 1; i++) {
		for (int j = 1; j < vn.size() + 1; j++) {
			auto pos = first[j - 1].find(m[0][i][0]); 
			auto pos2 = first[j - 1].find('?');
			if (pos != first[j - 1].end()) {
				m[j][i] = "o";
				for (int k = 0; k < drived.size(); k++) {
					if (drived[k][0] == m[j][0][0]) {
						if (drived[k][2] == m[0][i][0]) {
							m[j][i] = drived[k];
						}
					}
				}
				
			}
			else if (pos2 != first[j - 1].end()) {
				auto pos3 = follow[j - 1].find(m[0][i][0]);
				if (pos3 != follow[j - 1].end()) {
					m[j][i] = "?";
				}
				else m[j][i] = "$";
			}
			else m[j][i] = "$";
		}
	}
	for (int i = 1; i < vt.size() + 1; i++) {
		for (int j = 1; j < vn.size() + 1; j++) {
			if (m[j][i][0] == 'o') {
				for (int k = 0; k < drived.size(); k++) {
					if (drived[k][0] == m[j][0][0]) {
						if (isVN(drived[k][2])) {
							m[j][i] = drived[k];
						}
					}
				}
			}
		}
	}

	//至此 查找表构造完成
	string st = "";
	st += start;
	st += '#';
	while (stc.length() > 1) {
		char a, b;
		a = stc[0];
		b = st[0];
		int flag = 0;
		if (a == b) {
			cout << "当前两个字符串顶相同，删去" << a << endl;
			stc.erase(0, 1);
			st.erase(0, 1);
			cout << endl;

		}
		else {
			for (int i = 1; i < vt.size() + 1; i++) {
				if (flag)
					break;
				for (int j = 1; j < vn.size() + 1; j++) {
					if (a == m[0][i][0] && b == m[j][0][0]) {
						string tmp = m[j][i];
						flag = 1;
						if (tmp[0] == '?') {
							cout << "匹配式:  " << st<<'	';
							cout << "语句:  " << stc<<'	';
							st.erase(0, 1);
							cout << "用:  ->?" ;
							cout << endl; cout << endl;
						}
						else {
							cout << "匹配式:  " << st << '	';
							cout << "语句:  " << stc << '	';
							tmp.insert(1, "->");
							cout << "用公式:  " << tmp << '	';
							tmp.erase(0, 4);
							st.erase(0, 1);
							st.insert(0, tmp);
							
							cout << endl; cout << endl;
						}
						break;
					}
					
				}
			}
		}

	}
	while (st.length() > 1) {
		cout << "用->？消除" << st[0] << endl;
		st.erase(0, 1);
	}

	return 0;
}

int main() {
	string s = "E#";
	string wenfa = "E TG\nG +TG\nG -TG\nG ?\nT FS\nS *FS\nS /FS\nS ?\nF (E)\nF i"; //文法输入
	string s_in = "i/i-i+i*i#";            //待解析语句
	LL_1(wenfa, s_in);
	return 0;
}

https://download.csdn.net/download/qq_45205060/18212579?spm=1001.2014.3001.5503
带界面的qt文件

flowrnolak
关注
合肥工业大学编译原理实验二 LL1分析
一个苦逼研究僧的博客
11-03 3010
写在开头 当老师说这个实验最好写成图形界面时，我笑了（滑稽），心想终于可以用到python了，python真香，用python的数据结构可以很方便的表示LL1的某些东西（当然有利也有弊，方便的同时也会有一些坑）。当然Java也牛逼，Java的图形库有些东西用起来比python的还要方便。只是本人当前最熟的就是python。 准备工作 （熟悉python的可以跳过）首先至少得会基础的python语法...
合工大编译原理实验二语法分析李宏芒
06-27
合工大编译原理实验二语法分析李宏芒 一、实验目的 通过完成预测分析法的语法分析程序，了解预测分析法和递归子程序法的区 别和联系。使学生了解语法分析的功能，掌握语法分析程序设计的原理和构造方 法，训练学生掌握开发应用程序的基本方法。有利于提高学生的专业素质，为培 养适应社会多方面需要的能力。 二、功能描述 1. 可在界面文本框上手动输入或由文件读取方式导入.txt文件内需要分析的产生式文法。产生式文法及分析式都可任意。 2. 如果发现错误则报告出错ERROR。 3. 删除空格类字符，包括但不限于‘\t’, ‘\r’, ‘\n’, ‘ ’. 4. 可显示出分析过程、所有非终结符的first集合、follow集合和构造出的预测分析表；
合工大 编译原理 实验二
wjh776a68的博客
10-24 1643
合工大 编译原理实验二 LL(1)文法 本实验为必做实验，使用C++开发，利用Windows API制作了简易的界面。 基本功能： 支持自定义文法 多个显示窗口，支持显示FIRST集、FOLLOW集、状态转换表、分析表 支持直接/间接左递归文法转化为LL(1)文法后识别 详细功能，示例截图、项目代码请见GitHub页面：LL(1)文法 部分核心代码如下： 消除直接/间接左递归 /*************************************************************
合工大编译原理实验二：构造LL1分析程序
最新发布
m0_63254971的博客
06-03 531
【代码】合工大编译原理实验二：构造LL1分析程序。
合肥工业大学编译原理实验LL(1)完整Scala实现代码（Java完成GUI封装）与测试数据
u25th_engineer的博客
10-19 4287
Table of Contents 测试数据： 无GUI的代码： LL1 object类（Scala）： 含GUI的代码： LL1_try_GUI object类（Scala）： FileUtil class类（Java）： 包pojo中的Analyse c...
编译原理实验 LL1文法分析 first集合 follow集合
05-08
语言为C++，使用了set，map容器，输入格式：S -> Aa | g | e，支持多‘|’ 符号，采用文件输入
编译原理语法分析 LL1分析代码
09-13
编译原理 从词法分析器到语法分析器的实现，词法分析器以有穷状态机实现，而语法分析器主要使用LL1算法实现，中间使用了大量的图论算法。
北邮编译原理课程实验LL1语法分析器.zip
02-28
《编译原理：LL(1)语法分析器的构建与应用》 编译原理是计算机科学中的重要领域，它涉及到程序设计语言的翻译过程。在编译器的设计中，语法分析是一个关键步骤，用于理解源代码的结构和语义。LL(1)语法分析是一种自...
合工大 编译原理 实验
wjh776a68的博客
10-15 1784
目前仅有实验一二，Windows桌面应用程序项目（开发语言：c++；开发环境：Visual Studio） 需要加2977295009 实验一大致功能： 支持程序运行时输入关键词，支持已保存关键词的表格化查看； 支持调用文件浏览框读写文件。 实验二大致功能： 支持程序运行时输入文法，支持输入文法的直接间接左递归文法向LL(1)文法转化； 支持FIRST、FOLLOW集，状态转换表的表格化查看； 支持调用文件浏览框读写文件。 ...
合肥工业大学 编译原理实验 LL(1)分析法
08-27
1、根据某一文法编制调试 LL （ 1 ）分析程序，以便对任意输入的符号串进行分析。 2、构造预测分析表，并利用分析表和一个栈来实现对上述程序设计语言的分析程序。 3、分析法的功能是利用 LL（1）控制程序根据显示栈栈顶内容、向前看符号以及 LL（1）分析表，对输入符号串自上而下的分析过程。
合肥工业大学 编译原理实验 词法分析器设计实现
08-27
1) 可选择文件读取多行字符进行分析 2) 可手动输入多行字符并读入进行分析 3) 关键字、标识符、分界符号、算术运算符、关系运算符、常数表用户自定义 4) 统计行数和列数用于错误单词的定位 5) 删除空格类字符，包括回车、制表符空格 6) 按拼写单词（关键字、标识符、分界符号），并用（内码，属性）二元式表示。 7) 如果发现错误则报告出错 8) 根据需要是否填写标识符表供以后各阶段使用 9) 识别常数，可辨别整数、浮点数 10) 识别算术运算符，支持++,--,==,&&,|| 11) 识别注释部分、空格，并跳过
合工大课程实验LL（1）分析器
09-02
合工大课程实验 含图形界面、所使用文法。 Java语言 LL（1）分析器 不可消除左递归 求非终结符、终结符、first集、follow集
编译原理实验二语法分析
06-17
编译原理语法分析，教材后面试验二，java版
编译原理实验报告-合肥工业大学版.pdf
07-13
编译原理实验报告-合肥工业大学版.pdf编译原理实验报告-合肥工业大学版.pdf编译原理实验报告-合肥工业大学版.pdf编译原理实验报告-合肥工业大学版.pdf编译原理实验报告-合肥工业大学版.pdf编译原理实验报告-合肥工业大学版.pdf编译原理实验报告-合肥工业大学版.pdf编译原理实验报告-合肥工业大学版.pdf编译原理实验报告-合肥工业大学版.pdf
合肥工业大学 编译原理实验 LR(1)分析法
08-27
对下列文法，用 LR（1）分析法对任意输入的符号串进行分析： （1）E-> E+T （2）E->T （3）T-> T*F （4）T->F （5）F-> (E) （6）F-> i
合工大编译原理实验一词法分析李宏芒
06-27
合工大编译原理实验一词法分析李宏芒 一、实验目的 通过本实验的编程实践，使学生了解词法分析的任务，掌握词法分析程序设计的原理和构造方法，使学生对编译的基本概念、原理和方法有完整的和清楚的理解，并能正确地、熟练地运用。 二、功能描述 1) 可在界面文本框上手动输入或由文件读取方式导入.c或.txt文件内需要分析的程序段。 2) 如果发现错误则报告出错ERROR且将统计的行数和列数用于错误单词的定位 3) 删除空格类字符，包括但不限于‘\t’, ‘\r’, ‘\n’, ‘ ’. 4) 按拼写单词（关键字、标识符、常数、运算符、关系运算符、分界符号，错误），分别对应内码1，2，3，4，5，6，7，并用（内码，属性）二元式表示 5) 根据需要可任意扩充标识符表供以后更加广泛的范围使用 6) 对于二元运算符 ++、 --、 ==、 >=、 <= 可进行整体识别
合肥工业大学编译原理实验报告代码
04-02
合肥工业大学编译原理实验，实验一与实验三利用c++开发，实验二利用python和pyqt实现
编译原理上机实习c语言小子集编译程序的实现报告,合肥工业大学编译原理实验报告(完整代码版)...
weixin_42307290的博客
05-18 634
《合肥工业大学编译原理实验报告(完整代码版)》由会员分享，可在线阅读，更多相关《合肥工业大学编译原理实验报告(完整代码版)(58页珍藏版)》请在人人文库网上搜索。1、计算机与信息学院编译原理实验报告专业班级信息安全13-1班Word文档学生姓名及学号马骏 2013211869课程教学班号 任课教师宏芒实验指导教师宏芒实验地点实验楼机房20152016 学年第二学期实验1词法分析设计、实验目的通过本...
合肥工业大学编译原理实验代码及报告大全
03-22
合肥工业大学编译原理实验代码及报告大全
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值