编译原理：算符优先分析实验

已于 2022-07-13 23:39:00 修改
阅读量4.4k 收藏 129
点赞数 18
分类专栏： 编译原理 文章标签： 数据结构 算法
于 2022-07-13 23:36:06 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/believer_yu/article/details/125774927
版权

算符优先分析法 语法分析 编译器设计 优先关系表 文法
关键词由CSDN通过智能技术生成

什么是算符优先分析法
算符优先分析法是一种简单、直观的自下而上分析法
算符优先分析法就是仿照算术表达式的四则运算过程而设计的一种语法分析方法。
这种分析方法首先要规定运算符之间（确切地说终结符之间）的优先关系和结合性质，然后借助这种关系，比较相邻运算符的优先级来确定句型的可归约串并进行归约。

分析步骤为：
1、扩展文法
S’ →#S#

2、求FIRSTVT()和LASTVT()集合
firstvt(S)={ a,^,( }
firstvt(T)={ , } ∪ firstvt(S) = {, ,a,^,( }
lastvt(S)= { a,^,) }
lastvt(T) = { , } ∪ lastvt(S) = { , ,a,^,) }

3、求优先关系
3.1 首先找 等于关系(两个vt之间只隔一个vn)
3.2 低于关系(vt在右，vn在左)
3.3 高于关系(vn在左，vt在右)
4、构造优先关系表
5、算符优先分析过程

一、实验目的

运用算符优先语法分析的基本原理实现对于句子的语法分析

二、实验要求

1、文法及待分析符号串由用户输入
2、数据结构可自行设计

三、实验内容

1、任意输入一个文法，判断它是否为简单优先文法
2、如果是，请构造该文法对应的简单优先分析表
3、输入一个字符串，判断它是否为该文法的一个句子。

四、实验代码

#include <iostream>
#include <fstream>
#include <sstream>
#include <vector>
#include <stack>
#include <iomanip>
#include <cstdlib>

using namespace std;

string V[100][2]; //存储拆分后的文法
int vi = 0; //存储拆分后有多少行
int t = 0;
int s = 0;
int l;
int r;

string FIRSTVT[20][2]; //存储firstvt集
string LASTVT[20][2]; //存储lastvt集
string str; //存储输入文法
string str_a = "#"; // 下堆栈
string str_b; // 剩余输入串
string analysis_table[100][5]; // 文法分析过程

char table[100][100]; // 算符优先关系表

void init_string(string &a) // 删除字符串的第一个元素
{
	for (int i = 1; i <= a.length(); ++i)
	{
		a[i - 1] = a[i];
	}
}

bool is_CHAR(char c) // 判断是否为大写字母
{
	if (c >= 'A' && c <= 'Z')
	{
		return true;
	}
	else
	{
		return false;
	}
}

bool is_in(int i, string x) // 判断从字符串x从最好一个开始算起连续的i个字符是否含有非大写字母
{
	bool flag = false;
	for (int j = 0; j < i; j++)
	{
		if (!is_CHAR(x[x.length() - j - 1]))
		{
			flag = true;
		}
	}
	return flag;
}

void split(string a) // 拆分文法，使其不含有｜
{
	for (int i = 3; i < a.length(); ++i)
	{
		V[vi][0] = a[0];
		while (a[i] != '|' && i < a.length())
		{
			V[vi][1] += a[i];
			i++;
		}
		vi++;
	}
}

void read_file(string file_path) //按行读取文件
{
	fstream f;
	f.open(file_path.c_str());
	vector<string> words;
	string line;
	while (getline(f, line))
	{
		words.push_back(line);
	}
	cout << "输入文法:" << endl;
	for (int i = 0; i < words.size(); i++)
	{
		cout << words[i] << endl;
		split(words[i]);
	}
}

int find_index(char a) //寻找字符a在firstvt或者lastvt中的位置
{
	for (int i = 0; i < t; ++i)
	{
		if (FIRSTVT[i][0][0] == a)
		{
			return i;
		}
	}
	return -1;
}

int find_table_index(char a) //寻找字符a在算符优先关系表中的位置
{
	for (int i = 0; i <= s; ++i)
	{
		if (table[i][0] == a)
		{
			return i;
		}
	}
	return -1;
}

void get_start() //获取非终结符
{
	for (int i = 0; i < vi; ++i)
	{
		bool flag = true;
		for (int j = 0; j < t; ++j)
		{
			if (FIRSTVT[j][0] == V[i][0])
			{
				flag = false;
			}
		}
		if (flag)
		{
			FIRSTVT[t][0] = V[i][0];
			LASTVT[t][0] = V[i][0];
			t++;
		}
	}
}

void add_firstvt(string b, int a) //判断字符串b是否在序号为a的firstvt中，没有则加入
{
	for (int s = 0; s < b.length(); ++s)
	{
		bool flag = true;
		char c = b[s];
		if (c <= 'Z' && c >= 'A')
		{
			continue;
		}
		for (int i = 0; i < FIRSTVT[a][1].length(); ++i)
		{
			if (c == FIRSTVT[a][1][i])
			{
				flag = false;
			}
		}
		if (flag)
		{
			FIRSTVT[a][1] += c;
		}
	}
}

void add_firstvt(char c, int a) //判断字符c是否在序号为a的firstvt中，没有则加入
{
	bool flag = true;
	for (int i = 0; i < FIRSTVT[a][1].length(); ++i)
	{
		if (c <= 'Z' && c >= 'A')
		{
			continue;
		}
		if (c == FIRSTVT[a][1][i])
		{
			flag = false;
		}
	}
	if (flag)
	{
		FIRSTVT[a][1] += c;
	}
}

void add_lastvt(string b, int a) //判断字符串b是否在序号为a的lastvt中，没有则加入
{
	for (int s = 0; s < b.length(); ++s)
	{
		bool flag = true;
		char c = b[s];
		if (c <= 'Z' && c >= 'A')
		{
			continue;
		}
		for (int i = 0; i < LASTVT[a][1].length(); ++i)
		{
			if (c == LASTVT[a][1][i])
			{
				flag = false;
			}
		}
		if (flag)
		{
			LASTVT[a][1] += c;
		}
	}
}

void add_lastvt(char c, int a) //判断字符串c是否在序号为a的lastvt中，没有则加入
{
	bool flag = true;
	for (int i = 0; i < LASTVT[a][1].length(); ++i)
	{
		if (c <= 'Z' && c >= 'A')
		{
			continue;
		}
		if (c == LASTVT[a][1][i])
		{
			flag = false;
		}
	}
	if (flag)
	{
		LASTVT[a][1] += c;
	}
}

string get_cur_firstvt(char c, int a) //获取当前字符的firstvt，并放入序号为a的firstvt中
{
	string temp;
	for (int i = 0; i < vi; ++i)
	{
		if (c == V[i][0][0])
		{
			if (!(V[i][1][0] <= 'Z' && V[i][1][0] >= 'A'))
			{
				add_firstvt(V[i][1][0], a);
			}
			else
			{
				if (c != V[i][1][0])
				{
					temp = get_cur_firstvt(V[i][1][0], find_index(V[i][1][0]));
					add_firstvt(temp, a);
				}
				if (V[i][1].length() > 2)
				{
					if (!(V[i][1][1] <= 'Z' && V[i][1][1] >= 'A'))
					{
						add_firstvt(V[i][1][1], a);
					}
				}
			}
		}
	}
	return FIRSTVT[a][1];
}

string get_cur_lastvt(char c, int a) //获取当前字符的lastvt，并放入序号为a的lastvt中
{
	string temp;
	for (int i = 0; i < vi; ++i)
	{
		int s = V[i][1].length();
		if (c == V[i][0][0])
		{
			if (!(V[i][1][s - 1] <= 'Z' && V[i][1][s - 1] >= 'A'))
			{
				add_lastvt(V[i][1][s - 1], a);
			}
			else
			{
				if (c != V[i][1][s - 1])
				{
					temp = get_cur_lastvt(V[i][1][s - 1], find_index(V[i][1][0]));
					add_lastvt(temp, a);
				}
				if (V[i][1].length() > 2)
				{
					if (!(V[i][1][s - 2] <= 'Z' && V[i][1][s - 2] >= 'A'))
					{
						add_lastvt(V[i][1][s - 2], a);
					}
				}
			}
		}
	}
	return LASTVT[a][1];
}


void get_firstvt() //获取所有文法的firstvt
{
	for (int i = 0; i < t; i++)
	{
		get_cur_firstvt(FIRSTVT[i][0][0], i);
	}
}

void get_lastvt() //获取所有文法的lastvt
{
	for (int i = 0; i < t; i++)
	{
		get_cur_lastvt(LASTVT[i][0][0], i);
	}
}

void print_firstvt(string t, string a) //打印非终极符为t的firstvt
{
	cout << "FIRSTVT(" << t << ") = {";
	for (int i = 0; i < a.length(); ++i)
	{
		if (i == a.length() - 1)
		{
			cout << "\"" << a[i] << "\"";
		}
		else
		{
			cout << "\"" << a[i] << "\"" << ", ";
		}
	}
	cout << "}" << endl;
}

void print_lastvt(string t, string a) //打印非终结符为t的lastvt
{
	cout << "LASTVT(" << t << ") = {";
	for (int i = 0; i < a.length(); ++i)
	{
		if (i == a.length() - 1)
		{
			cout << "\"" << a[i] << "\"";
		}
		else
		{
			cout << "\"" << a[i] << "\"" << ", ";
		}
	}
	cout << "}" << endl;
}

void init_table() //初始化算符优先关系表
{
	table[0][0] = '\\';
	for (int i = 0; i < vi; ++i)
	{
		for (int j = 0; j < V[i][1].length(); ++j)
		{
			bool flag = true;
			for (int k = 0; k < s + 1; ++k)
			{
				if (table[k + 1][0] == V[i][1][j] || (V[i][1][j] <= 'Z' && V[i][1][j] >= 'A'))
				{
					flag = false;
				}
			}
			if (flag)
			{
				table[s + 1][0] = V[i][1][j];
				table[0][s + 1] = V[i][1][j];
				s++;
			}
		}
	}
	for (int l = 1; l < s + 1; ++l)
	{
		for (int i = 1; i < s + 1; ++i)
		{
			table[l][i] = ' ';
		}
	}
}

void get_table() //生成算符优先关系表
{
	for (int i = 0; i < vi; ++i)
	{
		for (int j = 0; j < V[i][1].length(); ++j)
		{
			//ab
			if (!(V[i][1][j] <= 'Z' && V[i][1][j] >= 'A') && !(V[i][1][j + 1] <= 'Z' && V[i][1][j + 1] >= 'A') &&
				j + 1 < V[i][1].length())
			{
				table[find_table_index(V[i][1][j])][find_table_index(V[i][1][j + 1])] = '=';
			}
			//aQb
			if ((!(V[i][1][j] <= 'Z' && V[i][1][j] >= 'A')) && (V[i][1][j + 1] <= 'Z' && V[i][1][j + 1] >= 'A') &&
				(!(V[i][1][j + 2] <= 'Z' && V[i][1][j + 2] >= 'A')) && j + 2 < V[i][1].length())
			{
				table[find_table_index(V[i][1][j])][find_table_index(V[i][1][j + 2])] = '=';
			}
			//aQ
			if ((!(V[i][1][j] <= 'Z' && V[i][1][j] >= 'A')) && (V[i][1][j + 1] <= 'Z' && V[i][1][j + 1] >= 'A') &&
				j + 1 < V[i][1].length())
			{
				for (int k = 0; k < FIRSTVT[find_index(V[i][1][j + 1])][1].length(); ++k)
				{
					table[find_table_index(V[i][1][j])][find_table_index(
							FIRSTVT[find_index(V[i][1][j + 1])][1][k])] = '<';
				}
			}
			//Qa
			if ((V[i][1][j] <= 'Z' && V[i][1][j] >= 'A') && !(V[i][1][j + 1] <= 'Z' && V[i][1][j + 1] >= 'A') &&
				j + 1 < V[i][1].length())
			{
				for (int k = 0; k < LASTVT[find_index(V[i][1][j])][1].length(); ++k)
				{
					table[find_table_index(LASTVT[find_index(V[i][1][j])][1][k])][find_table_index(
							V[i][1][j + 1])] = '>';
				}
			}
		}
	}
}


void print_table() //打印算符优先关系表
{
	for (int i = 0; i < s + 1; ++i)
	{
		for (int j = 0; j < s + 1; ++j)
		{
			cout << table[i][j] << " ";
		}
		cout << endl;
	}
}

char get_relationship(char a, char b) //获取终结符a，b的优先关系
{
	return table[find_table_index(a)][find_table_index(b)];
}

bool is_reduce() //判断是否可以规约
{
	for (int i = 0; i < vi; ++i)
	{
		int count = 0;
		int f = str_a.length() - 1;
		for (int j = V[i][1].length() - 1; j >= 0 && f >= 0; j--, f--)
		{
			if (is_in(V[i][1].length(), str_a))
			{
				if (is_CHAR(str_a[f]) && is_CHAR(V[i][1][j]))
				{
					count++;
				}
				else if (str_a[f] == V[i][1][j])
				{
					count++;
				}
			}
			else
			{
				continue;
			}
		}
		if (count == V[i][1].length())
		{
			r = i;
			return true;
		}
	}
	return false;
}


void analyze_input_string() // 生成算符优先文法的分析过程
{
	analysis_table[0][0] = "步骤";
	analysis_table[0][1] = "下堆栈";
	analysis_table[0][2] = "优先关系";
	analysis_table[0][3] = "剩余输入串";
	analysis_table[0][4] = "移进或规约";
	str_b = str;
	char relationship;
	l = 1;
	int x;
	stringstream ss;
	while (true)
	{
		ss << l;
		int index = str_a.length() - 1;
		analysis_table[l][0] = ss.str();
		analysis_table[l][3] = str_b;
		analysis_table[l][1] = str_a;
		ss.clear();
		ss.str("");
		if (is_CHAR(str_a[index]))
		{
			for (int i = str_a.length() - 1; i >= 0; i--)
			{
				if (!is_CHAR(str_a[i]))
				{
					index = i;
					break;
				}
			}
		}
		relationship = get_relationship(str_a[index], str_b[0]);
		analysis_table[l][2] = relationship;
		if (relationship == '=')
		{
			if (str_a[index] == '#' && str_b[0] == '#')
			{
				analysis_table[l][4] = "完成";
				break;
			}
			else
			{
				analysis_table[l][4] = "移进";
				str_a += str_b[0];
				analysis_table[l + 1][1] = str_a;
				init_string(str_b);
			}
		}
		else if (relationship == '<')
		{
			analysis_table[l][4] = "移进";
			str_a += str_b[0];
			analysis_table[l + 1][1] = str_a;
			init_string(str_b);
		}
		else if (relationship == '>')
		{
			if (is_reduce())
			{
				analysis_table[l][4] = "规约";
				str_a[str_a.length() - V[r][1].length()] = V[r][0][0];
				str_a.erase(str_a.length() - V[r][1].length() + 1, V[r][1].length() - 1);
			}
			else
			{
				cout << "输入串非法" << endl;
				exit(-1);
			}
		}
		l++;
	}
}

void print_analyze_process() //打印算符优先文法的分析过程
{
	cout << "算符优先分析过程" << endl;
	cout << setw(12) << analysis_table[0][0] << setw(16) << analysis_table[0][1] << setw(16) << analysis_table[0][2]
		 << setw(24)
		 << analysis_table[0][3] << setw(20)
		 << analysis_table[0][4] << endl;
	for (int i = 1; i <= l; ++i)
	{
		cout.width(10);
		cout << analysis_table[i][0];
		cout.width(12);
		cout << analysis_table[i][1];
		cout.width(10);
		cout << analysis_table[i][2];
		cout.width(20);
		cout << analysis_table[i][3];
		cout << analysis_table[i][4];
		cout << endl;
	}
}

int main(int argv, char *arg[])
{
	cout.setf(std::ios::left);
	read_file("D:\\in.txt");
	cout << "拆分后文法:" << endl;
	for (int i = 0; i < vi; ++i)
	{
		cout << V[i][0] << "->" << V[i][1] << endl;
	}
	cout << "非终结符:" << endl;
	get_start();
	for (int j = 0; j < t; ++j)
	{
		cout << FIRSTVT[j][0] << endl;
	}
	cout << "FIRSTVT:" << endl;
	get_firstvt();
	for (int k = 0; k < t; ++k)
	{
		print_firstvt(FIRSTVT[k][0], FIRSTVT[k][1]);
	}
	cout << "LASTVT:" << endl;
	get_lastvt();
	for (int k = 0; k < t; ++k)
	{
		print_lastvt(LASTVT[k][0], LASTVT[k][1]);
	}
	cout << "算符优先关系表" << endl;
	init_table();
	get_table();
	print_table();
	cout << "请输入文法并以#结束:" << endl;
	cin >> str;
	analyze_input_string();
	print_analyze_process();
	return 0;
}

//E→E+T∣T

//T→T*F∣F

//F→(E)∣i

五、测试结果

1.从文件中读取文法，然后构造优先表
2.输入待分析串，输出分析过程
in.txt中文法为：
S->#E#
E->E+T|T
T->T*F|F
F->(E)|i
在这里插入图片描述

在这里插入图片描述

Believer_YU
关注
专栏目录
编译原理实验——算符优先算法
katyusha77的专栏
12-02 2269
 /*本实验参照学校实验报告册的算法所作,行事仓促,有很多不足,望加指正*//*验证文法1:  E->E+T|T  T->T*F|F  F->(E)|a  语句示例:a+a$  验证文法2:  S->a|b|(T)  T->T,S|S  语句示例:(a,(a,a))$  因未加入对'|'的拆分,所以输入文法是需手动拆分产生式.  本程序所输文法,必须为算符优先文法*//*结束符号是$;  vn[]中第一个字符是开始符号;  FIRST集、FOLLOW集和优先分析表T的字符顺序和vt[]及vn[]一致*/#i
算符优先分析程序及实验报告
08-25
本程序用C语言编写，在Visual studio 6.0 下运行成功 拷贝之后便可以运行。 本程序是本人在学习编译原理课程时所编写的，现在不用了，发出来供大家一起参考讨论之用。 由于只是为了实验课的需要而用，所以程序的功能还十分简单，程序中也还存在很多问题和不足，欢迎大家给予指正。
编译原理 算符优先文法 实验报告 代码 运行成功
12-01
编译原理 算符优先文法 实验报告 代码 运行成功
编译原理实验二——算符优先分析法设计与实现
08-29
用算符优先分析方法设计一个分析解释程序，对输入的赋值语句、输出语句、清除语句进行词法分析、语法分析、表达式求值并存储于指定变量中；若存在错误，提示错误相关信息。
算符优先算法在编译原理中的实现及实验报告
最新发布
weixin_42465140的博客
09-25 1105
本文还有配套的精品资源，点击获取 简介：编译原理中，算符优先算法是一种用于处理表达式语法分析的重要技术。本资源提供算法代码实现及实验报告，详细阐述了算法的实现步骤和实验过程，包括构造解析表、符号栈操作和错误处理。实验报告深入分析了算法正确性、效率，并讨论了实现挑战和性能评估，对理解编译器工作原理和提升编程能力有着重要价值。 1. 编译原理与算符优先算法基础 ...
算符优先分析算法（实验报告）
12-15
三 设计源码 算符优先分析器 #include "stdio.h" #include "stdlib.h" #include "iostream.h" char data[20][20]; //算符优先关系 char s[100]; //模拟符号栈s char lable[20]; //文法终极符集 char input[100]; //文法输入符号串 char string[20][10]; //用于输入串的分析 int k; char a; int j; char q; int r; //文法规则个数 int r1;
算符优先分析
10-23
用java写的算符优先程序，可以运行，但是必须以#结尾。比如i+i*i#或者i+i+i+i-i*i+i#
编译原理课程设计报告_算符优先分析表
06-21
编译原理课程设计报告_算符优先分析表word电子稿，应该和老师出的题目一模一样的直接下载打印
[编译原理] 算符优先分析实验报告
nebois的博客
05-24 1468
算符优先分析法的基本思想是，为每个运算符赋予一个优先级，然后利用这些优先级来确定运算符之间的顺序。在算符优先分析法中，每个运算符都有一个左优先级和一个右优先级，用来指示它在与相邻运算符结合时的优先级。通常，左结合性指示运算符与其左边的运算符结合，右结合性指示运算符与其右边的运算符结合。算符优先分析法的优点是简单而高效，特别适用于具有相对简单运算符优先级关系的表达式。然而，对于包含复杂优先级规则的表达式，算符优先分析法可能无法适应，需要使用其他更复杂的语法分析方法。3.实验算法及流程图。
编译原理实验3（基于算符优先文法分析的语法分析器 ）
qq_53682472的博客
04-07 1871
把产生式以->推导符号为边界分为左右两部分，左边一定是VN，右边大写字母是VN，小写字母是VT，为了避免重复记录，可以用一个map来记录是否出现过，map里key是VN或VT，值是它们在数组里的下标。用栈存储已经看到的输入符号，用优先关系指导移动规约语法分析器的动作，如果栈顶的终结符和下一个输入符之间的优先关系时<或者=，则语法分析器移动,表示还没有发现句柄的右端，如果时>关系，就调用归约。IF X[i]和X[i+2]均为终结符,X[i+1]为非终结符,i≤n-2,DO 置 X[i]<a。
自下而上的分析法——算符优先分析法
热门推荐
记录时间带走的东西
05-13 4万+
概述 算符优先分析法(Operator Precedence Parse)是仿效四则运算的计算过程而构造的一种语法分析方法。算符优先分析法的关键是比较两个相继出现的终结符的优先级而决定应采取的动作。 优点：简单，有效，适合表达式的分析。 缺点：只适合于算符优先文法，是一个不大的文法类。 名词解释 定义： 短语：设有文法G，S是开始符号，...
编译原理实验报告（词法语法分析 算符优先分析 有限自动机 LL(1)文法分析法等）
12-20
编程 词法分析编程实现 语法分析的编程实现 （C语言，C-free下编译） 算法 算符优先分析 确定的有限自动机 中间代码——a 建立链可用函数b 回填函数 LL(1)文法分析法
算符优先分析法
05-22
设有文法G[S]：S→SaF | F F→FbP | P P→c | d (1) 构造G[S]的算符优先关系表 (2) 分别给出cadbdac# 和 dbcabc# 的分析过程
算符优先文法实验
06-30
编译原理的算符优先文法，以及实验报告，截图等
《编译原理》设计性实验二：算符优先分析相关算法模拟
05-22
《编译原理》 设计性实验二： 算符优先分析相关算法模拟
编译原理算符优先分析法分析器的设计及报告
06-29
编译原理 算符优先分析法分析器的设计 实验报告
编译原理：算符优先分析实验源码详解
在编译原理实验课程设计中，主要任务是实现算符优先分析算法。该算法的核心在于处理表达式的解析，通过操作数栈和运算符栈的交互作用，根据预设的算符优先级规则来解析输入的文法符号。以下是实验的关键知识点： 1....
编译原理：算符优先分析算法详解
"算符优先算法-编译原理课件" 算符优先算法是编译原理中的一种重要技术，主要用于解析程序中的表达式。在编译器设计中，语法规则的处理是关键环节，算符优先算法就是解决这个问题的一种方法。它通过维护一个堆栈来...
编译原理实验——利用算符优先分析方法设计一个计算器
09-23
（Python实现，注释详细）直接输入：3+4*5，一般的...(1)第一阶段，运用算符优先分析算法完成计算器中对算术表达式的语法分析； (2)第二阶段，设计属性文法，改造第一阶段的程序，完成算术表达式的计算和相关的输出。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值