实验一：LL(1)预测分析表设计与实现

已于 2024-01-30 09:01:13 修改
阅读量708 收藏 9
点赞数 19
分类专栏： 编译原理实践 hdu 文章标签： c++
于 2024-01-30 08:54:22 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/wawa_is_studying/article/details/135924957
版权

前置知识

1.C++中输出csv格式的文件（分隔符为","）

#include <fstream>
ofstream p;
string file_path = "output" + to_string(sum) + ".csv";
p.open(file_path, ios::out | ios::trunc);
p << "," << *vn << "->" << M[*vn][*vt];

核心操作

//SELECT集
string M[255][255];

1.select 函数的主要步骤
*初始化预测分析表 (M): 预测分析表M 是一个二维数组，初始化时，所有元素设置为空字符串。
*处理每个非终结符:
*遍历每个非终结符的产生式。
*对于每个产生式，计算其 SELECT 集合，这个集合决定了在预测分析表中的填充位置。
*计算 SELECT 集合:
*对于每个产生式，首先计算其首字符串（即产生式右侧）的 FIRST 集合。
*如果 FIRST 集合包含空串（$），则将产生式左侧非终结符的 FOLLOW 集合也并入 SELECT 集合中，并从 SELECT 集合中移除空串。
*如果 FIRST 集合不包含空串，则直接将 FIRST 集合并入 SELECT 集合。
*填充预测分析表:
*对于 SELECT 集合中的每个终结符，将产生式填入预测分析表的对应位置。
*例如，如果A->α 的 SELECT 集合包含终结符b，则将α 填入表中M[A][b] 的位置。
2.打印 SELECT 集合:为了验证和调试，函数在计算每个产生式的 SELECT 集合后打印它。

具体实现

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

//G文法结构体
struct G {
	int Vt_number;
	int Vn_number;
	int P_number;
	set<char> Vt;
	set<char> Vn;
	char S;
	vector<string> P[255];
}G_instance;

//打印文法
void printG() {
	cout << "Vt is:";
	for (auto i = G_instance.Vt.begin(); i != G_instance.Vt.end(); i++) {
		cout << *i << " ";
	}
	cout << endl;
	cout << "Vn is:";
	for (auto i = G_instance.Vn.begin(); i != G_instance.Vn.end(); i++) {
		cout << *i << " ";
	}
	cout << endl;
	for (auto i = G_instance.Vn.begin(); i != G_instance.Vn.end(); i++) {
		if (!G_instance.P[*i].empty()) {
			for (auto p = G_instance.P[*i].begin(); p != G_instance.P[*i].end(); p++) {
				cout << *i << "->" << *p << endl;
			}
		}
	}
}

//FIRST集
set<char> First[255];

set<char> first_string_set;
void first_string(string str) {
	first_string_set.clear();
	for (int i = 0; i < str.length(); i++) {
		set<char> temp_first_sub_string;
		set_union(temp_first_sub_string.begin(), temp_first_sub_string.end(), First[str[i]].begin(), First[str[i]].end(), inserter(temp_first_sub_string, temp_first_sub_string.begin()));
		if (First[str[i]].find('$') != First[str[i]].end() && i != str.length() - 1) {
			temp_first_sub_string.erase('$');
			set_union(temp_first_sub_string.begin(), temp_first_sub_string.end(), first_string_set.begin(), first_string_set.end(), inserter(first_string_set, first_string_set.end()));
		}
		else {
			set_union(temp_first_sub_string.begin(), temp_first_sub_string.end(), first_string_set.begin(), first_string_set.end(), inserter(first_string_set, first_string_set.end()));
			break;
		}
	}
}

void check() {
	for (auto vn = G_instance.Vn.begin(); vn != G_instance.Vn.end(); vn++) {
		if (!G_instance.P[*vn].empty()) {
			for (auto p = G_instance.P[*vn].begin(); p != G_instance.P[*vn].end(); p++) {
				first_string(*p);
				set_union(first_string_set.begin(), first_string_set.end(), First[*vn].begin(), First[*vn].end(), inserter(First[*vn], First[*vn].begin()));
			}
		}
	}
}


void first() {
	//flag为1表示first集有更新
	//      0表示first集无更新
	int flag = 1;
	while (flag == 1) {
		flag = 0;
		for (auto i = G_instance.Vn.begin(); i != G_instance.Vn.end(); i++) {
			//遍历非终结符号*i的产生式
			//*p为当前的产生式
			int len = First[*i].size();
			if (!G_instance.P[*i].empty()) {
				for (auto p = G_instance.P[*i].begin(); p != G_instance.P[*i].end(); p++) {
					//首字符为终结符号
					if (G_instance.Vt.find((*p)[0]) != G_instance.Vt.end()) {
						First[*i].insert((*p)[0]);
					}
					else {
						//首字符为非终结符号
						for (int index = 0; index < (*p).length(); index++) {
							//temp为FIRST(Y_k)
							set<char> temp;
							set_union(temp.begin(), temp.end(), First[(*p)[index]].begin(), First[(*p)[index]].end(), inserter(temp, temp.begin()));
							if (temp.find('$') != temp.end() && index != (*p).length() - 1) {
								temp.erase('$');
								set_union(First[*i].begin(), First[*i].end(), temp.begin(), temp.end(), inserter(First[*i], First[*i].end()));
							}
							else {
								set_union(First[*i].begin(), First[*i].end(), temp.begin(), temp.end(), inserter(First[*i], First[*i].end()));
								break;
							}
						}
					}
				}
			}
			int new_len = First[*i].size();
			if (new_len > len) {
				flag = 1;
			}
		}
	}
	//终结符号的first集
	for (auto i = G_instance.Vt.begin(); i != G_instance.Vt.end(); i++) {
		First[*i].insert(*i);
	}
	check();
}

//打印first集
void print_first() {
	for (auto i = G_instance.Vn.begin(); i != G_instance.Vn.end(); i++) {
		cout << "first(" << *i << "):";
		for (auto item = First[*i].begin(); item != First[*i].end(); item++) {
			cout << *item << " ";
		}
		cout << endl;
	}
}


//FOLLOW集
//#表示结束标志
set<char> Follow[255];
void follow() {
	Follow[G_instance.S].insert('#');
	//flag为1表示FOLLOW集有更新
	//		0			 无更新
	int flag = 1;
	while (flag == 1) {
		flag = 0;
		for (auto i = G_instance.Vn.begin(); i != G_instance.Vn.end(); i++) {
			//遍历非终结符号*i
			if (!G_instance.P[*i].empty()) {
				for (auto p = G_instance.P[*i].begin(); p != G_instance.P[*i].end(); p++) {
					//*p为当前非终结符号*i->产生式*p
					for (int j = 0; j < (*p).length(); j++) {
						char temp_vn = (*p)[j];
						int len = Follow[temp_vn].size();
						if (G_instance.Vn.find(temp_vn) != G_instance.Vn.end()) {
							//当前字符为产生式中最后一个字符
							if (j == (*p).length() - 1) {
								set_union(Follow[temp_vn].begin(), Follow[temp_vn].end(), Follow[*i].begin(), Follow[*i].end(), inserter(Follow[temp_vn], Follow[temp_vn].end()));
							}
							else {
								string temp_string = (*p).substr(j + 1, (*p).length() - j - 1);
								//后继first集中包含空
								first_string(temp_string);
								if (first_string_set.find('$') != first_string_set.end()) {
									first_string_set.erase('$');
									set_union(first_string_set.begin(), first_string_set.end(), Follow[temp_vn].begin(), Follow[temp_vn].end(), inserter(Follow[temp_vn], Follow[temp_vn].end()));
									set_union(Follow[temp_vn].begin(), Follow[temp_vn].end(), Follow[*i].begin(), Follow[*i].end(), inserter(Follow[temp_vn], Follow[temp_vn].end()));
								}
								else {
									//后继first集不含空
									set_union(first_string_set.begin(), first_string_set.end(), Follow[temp_vn].begin(), Follow[temp_vn].end(), inserter(Follow[temp_vn], Follow[temp_vn].end()));
								}
							}
						}
						if (len < Follow[temp_vn].size()) {
							flag = 1;
						}
					}
				}
			}
		}
	}
}

void print_follow() {
	for (auto i = G_instance.Vn.begin(); i != G_instance.Vn.end(); i++) {
		cout << "follow(" << *i << "):";
		for (auto item = Follow[*i].begin(); item != Follow[*i].end(); item++) {
			cout << *item << " ";
		}
		cout << endl;
	}
}

//SELECT集
string M[255][255];
void select() {
	//初始化M
	for (int i = 0; i < 255; i++) {
		for (int j = 0; j < 255; j++) {
			M[i][j] = "";
		}
	}
	for (auto i = G_instance.Vn.begin(); i != G_instance.Vn.end(); i++) {
		//遍历非终结符号*i
		if (!G_instance.P[*i].empty()) {
			for (auto p = G_instance.P[*i].begin(); p != G_instance.P[*i].end(); p++) {
				//*p为当前非终结符号*i->产生式*p
				set<char> select;
				first_string(*p);
				if (first_string_set.find('$') != first_string_set.end()) {
					set_union(Follow[*i].begin(), Follow[*i].end(), select.begin(), select.end(), inserter(select, select.end()));
				}
				first_string_set.erase('$');
				set_union(first_string_set.begin(), first_string_set.end(), select.begin(), select.end(), inserter(select, select.end()));
				for (auto select_ = select.begin(); select_ != select.end(); select_++) {
					M[*i][*select_] = *p;
				}
				cout << "SELECT(" << *i << "->" << *p << "):";
				for (auto p_s = select.begin(); p_s != select.end(); p_s++) {
					cout << *p_s << " ";
				}
				cout << endl;
			}
		}
	}
}

void print_select(int sum) {
	ofstream p;
	string file_path = "output" + to_string(sum) + ".csv";
	p.open(file_path, ios::out | ios::trunc);
	p << "Vn" << ",";
	set<char> input_set;
	set_union(input_set.begin(), input_set.end(), G_instance.Vt.begin(), G_instance.Vt.end(), inserter(input_set, input_set.begin()));
	input_set.erase('$');
	input_set.insert('#');
	for (auto vt = input_set.begin(); vt != input_set.end(); vt++) {
		p << *vt << ",";
	}
	p << endl;
	for (auto vn = G_instance.Vn.begin(); vn != G_instance.Vn.end(); vn++) {
		p << *vn;
		for (auto vt = input_set.begin(); vt != input_set.end(); vt++) {
			if (M[*vn][*vt] != "") {
				p << "," << *vn << "->" << M[*vn][*vt];
			}
			else {
				p << "," << " ";
			}
		}
		p << endl;
	}
	p.close();
}

void clear() {
	G_instance.P_number = 0;
	G_instance.Vn_number = 0;
	G_instance.Vt_number = 0;
	G_instance.S = ' ';
	for (int i = 0; i < 255; i++) {
		G_instance.P[i].clear();
		Follow[i].clear();
		First[i].clear();
	}
	G_instance.Vn.clear();
	G_instance.Vt.clear();
	first_string_set.clear();
	for (int i = 0; i < 255; i++) {
		for (int j = 0; j < 255; j++) {
			M[i][j] = "";
		}
	}
}

int main() {
	string file_path = "./FIRST-FOLLOW.txt";
	ifstream file(file_path);
	string arr[100];
	int count = 0;
	int sum = 0;
	while (getline(file, arr[count]) && count < 100) {
		if (arr[count].empty()) {
			clear();
			G_instance.P_number = count;
			G_instance.S = arr[0][0];
			for (int i = 0; i < count; i++) {
				int len = arr[i].length();
				string str = arr[i];
				G_instance.Vn.insert(str[0]);
				G_instance.P[str[0]].push_back(str.substr(2, len - 2));
				for (int index = 0; index < len; index++) {
					if ((str[index] >= 'a' && str[index] <= 'z') || str[index] == '$') {
						G_instance.Vt.insert(str[index]);
					}
				}
			}
			G_instance.Vt_number = G_instance.Vt.size();
			G_instance.Vn_number = G_instance.Vn.size();
			printG();
			cout << endl;
			count = 0;
			first();
			print_first();
			follow();
			print_follow();
			select();
			sum++;
			print_select(sum);
			cout << endl;
		}
		else {
			count++;
		}
	}
	file.close();
	return 0;
}
哇哇哇哇池
关注
  • 19
    点赞
  • 踩
  • 9
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
编译原理实验LL(1)分析法
qq_52252193的博客
12-13 7779
LL(1)分析法 LL(1)分析法又称预测分析法，是一种不带回溯的非递归自上而下分析法。LL(1)的含义是：第一个L表明自上而下分析是从左至右扫描输入串的；第二个L表明分析过程中将用最左推导；“1”表明只需向右查看一个符号就可决定如何推导(即可知用哪个产生式进行推导)。 LL(1)分析法的基本思想是根据输入串的当前输入符号来惟一确定选用某条规则(产生式)来进行推导；当这个输入符号与推导的第一个符号相同时，再取输入串的下一个符号，继续确定下一个推导应选的规则；如此下去，直到推导出被分析的...
实验：使用Java实现预测分析法设计与实现
slow_sparrow的博客
06-08 3929
文章目录一、实验目的二、实验内容三、实验方法四、实验步骤五、实验结果六、实验结论七、实验小结 一、实验目的 加深对语法分析器工作过程的理解； 加强对预测分析法实现分析程序的掌握； 能够采用一种编程语言实现简单的语法分析程序； 能够使用自己编写的分析程序对简单的程序段进行语法翻译 二、实验内容   用预测分析法编制语法分析程序，语法分析程序的实现可以采用任何一种编程语言和工具。 三、实验方法 实验方法：采用Java程序语言进行设计，有控制台根据提示语句进行输入 实验原理：预测分析法 实验工具：Intel
简易LL(1)分析器自动生成程序
07-05
设计并编写一个根据文法自动生成LL(1)分析器的程序，理解文法回溯等现象在LL分析中的不良影响，掌握FIRST集、FOLLOW集的定义和计算方法，掌握LL（1）分析器的工作原理和实现方法。
基于C++构造LL(1)文法的预测分析表(编译原理)【100012214】
05-18
实验要求 用C++ 实现； 编程构造如下LL(1)文法的预测分析表，文法G[A]： (0) A→baB (1) A→ε (2) B→bN (3) B→a (4) N→aBbb (5) N→b 预测分析表输出到output.txt文件。 提供名为LL1.exe的执行文件实现上述功能，还需提供源文件以及名为设计说明.doc的说明文件。
编绎原理 - LL(1)预测分析表与预测分析过程表
weixin_54009581的博客
04-25 846
课本看不懂？老师讲得听不懂？没关系，一篇技巧文章让你轻松掌握
基于LL(1)文法的预测分析表法
05-15
通过实验教学，加深学生对所学的关于编译的理论知识的理解，增强学生对所学知识的综合应用能力，并通过实践达到对所学的知识进行验证。通过对基于LL(1)文法的预测分析表法DFA模拟程序实验，使学生掌握确定的自上而下的语法分析的实现技术，及具体实现方法。通过本实验加深对语词法分析程序的功能及实现方法的理解
编译原理实验二：预测分析算法的设计与实现
每天都在梦想退休
12-10 1202
通过预测分析算法的设计与实现，加深对自上而下语法分析方法的理解，尤其是对自上而下分析条件的理解。输入文法及待分析的输入串，输出其预测分析过程及结果。3.根据文法求FIRST集和FOLLOW集。6.对给定的输入串，给出分析过程及结果。求 FOLLOW 集的算法。求 First 集的算法。定义产生式的语法集结构。（1）变量及函数的定义。（4）求FOLLOW集。4.构造预测分析表。（3）求FIRST集。（5）创建预测分析表。
编译原理实验二：预测分析算法的设计与实现（python）
CK_0ff的博客
12-15 1372
利用python，通过预测分析算法的设计与实现，加深对自上而下语法分析方法的理解，尤其是对自上而下分析条件的理解。
《编译原理》：LL(1)语法分析设计实现
weixin_61248653的博客
01-22 1935
《编译原理》：LL(1)语法分析设计实现
编译原理实验《预测分析法设计与实现》
m0_75073812的博客
10-17 1041
用预测分析法编制语法分析程序
编译原理LL(1)预测分析法JAVA实现
06-21
自动构造预测分析表；可输入句子进行判断。 代码我都写了注释，由于项目后期完成的比较急促，所以代码冗余度比较大，还没有时间进行精简。 如果不需要网页的图形用户界面，可将项目中的算法部分单独取出，也可直接...
语法分析 编译原理实验/课程设计（C++实现）
09-08
设计要求：创建一个语法分析程序，它采用LL（1）方法或LR（1）方法。该程序的输入是一个文本文档，包括一组2型文法（上下文无关文法）的产生式和任务1程序输出的符号表。任务2的输出是一个YES或NO，即源代码字符串...
预测分析表方法（LL1分析法） 编译原理
04-19
可适用任何文法 可输出匹配过程 有错误处理不会影响执行 文法有使用者输入 很好啊 莫要错过 经vc6.0编译执行通过100%可用
实验：使用C#实现预测分析法设计与实现
weixin_53177803的博客
10-21 889
实验：使用C#实现预测分析法设计与实现
编译原理实验二 《预测分析法设计与实现》
Atlas
06-07 4738
编译原理实验二 《预测分析法设计与实现》 一、实验目的 加深对语法分析器工作过程的理解；加强对预测分析法实现语法分析程序的掌握；能够采用一种编程语言实现简单的语法分析程序；能够使用自己编写的分析程序对简单的程序段进行语法翻译。 二、实验内容 用预测分析法编制语法分析程序，语法分析程序的实现可以采用任何一种编程语言和工具。 三、实验方法 1、使用C++语言及其STL容器与STL算法进行实验编码。 2、开发工具为JetBrains CLion 2019.2.4，编译环境1为Visual Studio (vers
编译原理：LL(1)文法 语法分析器（预测分析表法）
热门推荐
NK_test的博客
05-22 8万+
设计要求：对于任意输入的一个LL(1)文法，构造其预测分析表，并对指定输入串分析其是否为该文法的句子。 思路：首先实现集合FIRST(X)构造算法和集合FOLLOW(A)构造算法，再根据FIRST和FOLLOW集合构造出预测分析表，并对指定的句子打印出分析栈的分析过程，判断是否为该文法的句子。 指定文法： //文法 E->TK K->+TK K->$ T->FM M->*FM M
C++：round函数用法
最新发布
Solititude的博客
05-28 340
C++：round函数用法
精通C++ STL（二）：string类的模拟实现
Russ_Leo的博客
05-27 817
string类各函数接口。
第1关：预测分析法设计与实现
11-07
预测分析法是一种语法分析方法，它通过构建预测分析表来实现对输入串的分析。预测分析表是由非终结符和终结符构成的二维表格，表格中的每个元素都是一个产生式。预测分析法的设计和实现主要包括以下几个步骤： 1. 定义目标语言的语法规则，通常使用上下文无关文法来描述语法规则。 2. 求解预测分析方法需要的符号集和分析表。符号集包括终结符和非终结符，分析表是由符号集构成的二维表格，表格中的每个元素都是一个产生式。 3. 依次读入测试用例，根据预测分析的方法进行语法分析，直到源程序结束。 4. 对遇到的语法错误做出错误处理，例如报错或者进行恢复。 在预测分析法的实现中，LL(1)分析法是一种常用的实现方法。它是一种自顶向下的语法分析方法，可以通过构建LL(1)分析表来实现对输入串的分析。LL(1)分析法的特点是简单、高效，但是它只能处理一类文法，即LL(1)文法。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值