编译原理 预测分析法

最新推荐文章于 2022-10-19 16:23:25 发布
最新推荐文章于 2022-10-19 16:23:25 发布
阅读量4.4k 收藏 51
点赞数 10
分类专栏： 编译原理
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_42482815/article/details/109584310
版权

实验二 预测分析算法的设计与实现

一、实验目的

通过预测分析算法的设计与实现，加深对自上而下语法分析方法的理解，尤其是对自上而下分析条件的理解。

二、实验要求

输入文法及待分析的输入串，输出其预测分析过程及结果。

三、实验步骤

1、确定目标数据结构

先看下输入的文法结构

E->TK
K->+TK|$
T->FM
M->*FM|$
F->i|(E)
#

$代表空，#代表结束

将文法使用具体的数据结构描述出来使用C++好像只有结构体有可操作性了。所以我果断使用结构体。用一个结构体代表一个非终结符的所有产生式，该终结符的所有产生式之间使用‘|’隔开。
废话不多说，直接上代码

struct Node
{
	char Left;
	int RightCount;
	char Right[100][100];
	int FirstCount;
	int FollowCount;
	char First[100];
	char Follow[100];
};

Node GrammerSet[100];

接下来再定义这下数据

int grammersetcount = 0;
int tersymbolcount = 0;//终结符数量
int nontercount = 0;//非终结符数量  默认第一个非终结符为开始符号
char TerSymbol[200];//终结符 非大写字母
map<char, bool> isfirsted;//该终结符是否已经求过其first集
bool isfollowed[200];
char Non_Ter[200];//非终结符 大写字母
char AllSymbol[400];//所有符号

grammersetcount在数值上等于nontercount。

2、读入数据

这个没啥好说的，直接读就行。另外注意字符数组的初始化。

void ReadGrammerSet()
{
	char str[100];
	while (1)
	{
		cin >> str;
		if (str[0] == '#')
			break;
		GrammerSet[grammersetcount].Left = str[0];
		SymbolProcess(str[0]);//处理左边的
		for (int i = 3;i<strlen(str); i++)
		{
			
			int j = 0;
			char str2[100];
			while ((str[i] != '|')&&(str[i]!='\0'))
			{
				SymbolProcess(str[i]);//处理右边的
				str2[j++] = str[i++];
			}
			str2[j] = '\0';
			strcpy_s(GrammerSet[grammersetcount].Right[GrammerSet[grammersetcount].RightCount], str2);
			GrammerSet[grammersetcount].RightCount++;
		}
		grammersetcount++;
	}
}

3、求first集

first集就是一个非终结符所能推出的式子中第一个终结符的集合就是这个非终结符的first集。广义上来讲，对于一个终结符来讲，它的first集就是他本身。对于一个串来讲，他的first集就是从这个串中第一个字符开始，将这个字符的first集并入这个字符串的first集，若这个字符的first集中有$，则指向下一个字符，否则break。直到遍历完这个串。
知道了first集究竟是个什么之后，就很容易想到求解的方法。就是拿着一个产生式进行遍历推到罢了。
上代码

void First(char sym)
{
	//cout << "正在查找" << sym << "的first集" << endl;
	int i;
	for (i = 0; i < grammersetcount; i++)
	{
		if (GrammerSet[i].Left == sym)//找到这个非终结符所在产生式的位置
			break;
	}
	for (int j = 0; j < GrammerSet[i].RightCount; j++)
	{
		//如果first(ch)中包含$，则ch=它的下一个字符 否则退出这个循环
		int shouldbreak = 1;
		for (int pos = 0; pos < strlen(GrammerSet[i].Right[j]); pos++)
		{
			//产生式右部第一个字符为终结符，将其计入左部first集
			char ch = GrammerSet[i].Right[j][pos];
			//cout << "正在判断" << ch << endl;
			if (isTerSymbol(ch))
			{
				//是否已经收录过
				int flag = 0;
				for (int k = 0; k < GrammerSet[i].FirstCount; k++)
				{
					if (GrammerSet[i].First[k] == ch)
					{
						flag = 1;//已收录
						break;
					}
				}
				if (flag == 0)//未收录
					GrammerSet[i].First[GrammerSet[i].FirstCount++] = ch;
			}
			else//非终结符，求该非终结符的first集 如果first(ch)中包含$，则ch=它的下一个字符
			{
				//if(isfirsted(ch)==false)
				First(ch);
				//如果first(ch)中包含$，则ch=它的下一个字符 如果已经是最后一个字符，则程序还是会自动退出循环
				int i;
				for (i = 0; i < grammersetcount; i++)
				{
					if (GrammerSet[i].Left == ch)//找到这个非终结符所在产生式的位置
						break;
				}
				int flag = 0;
				for (int position = 0; position < GrammerSet[i].FirstCount; position++)
				{
					if (GrammerSet[i].First[position] == '$')
					{
						flag = 1;//包含$
						break;
					}
				}
				if (flag == 1)//包含$ ch=它的下一个字符 不应该推出循环
				{
					shouldbreak = 0;
				}
				//将ch的first集并入sym非终结符
				AddFirst(sym, ch);
			}
			if (shouldbreak == 1)
			{
				break;
			}
		}
	}
	//cout << "已经查找完成" << sym << "的first集为"<<GrammerSet[i].First<<endl;
}

4、求follow集

对于一个非终结符来讲，follow就是这个非终结符在这个文法所能推导出的所有式子中在它后面的那个字符的集合。
有以下两种情况。
1: A–>”a"B
2: A->“a"B"b”
其中“a"与”b"都代表一个可以为空的串。
1，经过这个产生式的推到之后，可以知道，A后面跟着的那个肯定也跟着B，但是反过来就不一定了。所以将follow(A)并入Follow(B)
2: 与1差不多，不过要与first集联系起来懒得说了，直接上图吧。这个是前两天写的，看看就好。在这里插入图片描述
还是看代码比较省力

void Follow(char sym)
{
//	cout << "正在寻找" << sym << "的follow集" << endl;
	//对全部的产生式找一个右部含有当前字符sym的产生式
	for (int i = 0; i < grammersetcount; i++)
	{
		for (int j = 0; j < GrammerSet[i].RightCount; j++)
		{
			for (int k = 0; k < strlen(GrammerSet[i].Right[j]); k++)
			{
				//找到一个右部含有当前字符sym的产生式
				if (GrammerSet[i].Right[j][k] == sym)
				{
					//如果sym在产生式右部的最后(形如产生式A->aX)
					//X的follow不一定是A的，但是A的一定是X的。
					if (strlen(GrammerSet[i].Right[j]) - 1 == k)
					{
						char ch = GrammerSet[i].Left;
						if (sym != ch)
						{
							//求ch 的follow
							if (!isfollowed[ch])
								Follow(ch);
							//把FOLLOW(ch)中的元素加入FOLLOW(X)
							AddFollow(sym, ch);
						}
					}
					//if X不在产生式右部的最后(A->aXB) B在这里代表一个符号串
					else
					{
						//遍历B中所有字符
						for (int r = k + 1; r < strlen(GrammerSet[i].Right[j]); r++)
						{
							char ch = GrammerSet[i].Right[j][r];
							//是终结符  加入follow(sym)
							if (isTerSymbol(ch))
							{
								AddCharToFollow(sym, ch);
								break;
							}
							else
							{
								//将first(ch)加入follow(sym)
								AddFirstToFollow(sym, ch);
								if (!hasnullinfirst(ch))
								{
									break;
								}
								//如果ch的first含有空值且sym!=ch则将ch的follow并入follow(sym)
								if(sym!=ch)
								{
									if (isfollowed[ch])
										AddFollow(sym, ch);
									else
										Follow(ch);
								}
							}
						}
					}
				}
			}
		}
	}
	isfollowed[sym] = 1;
//	cout << "已经完成寻找" << sym << "的follow集" << endl;
}

5、构造分析预测表

这个没啥好说的，按书上的方法来就行。懒得说了。在这里插入图片描述
注意阿尔法与a。别弄错了。

void CreateForecastTable()
{
	//初始化预测表
	int $pos = -1;//不是每一种文法都有空
	length1 = nontercount;//有几个非终结符就有几行
	length2 = tersymbolcount;//列
	for (int i = 0; i < grammersetcount; i++)//注意从一开始
		ForcastTable[i + 1][0][0] = GrammerSet[i].Left;
	for (int j = 0; j < tersymbolcount; j++)
	{
		if (TerSymbol[j] == '$')
		{
			ForcastTable[0][j + 1][0] = '#';
			$pos = j + 1;
		}
		else
			ForcastTable[0][j + 1][0] = TerSymbol[j];
//		cout << TerSymbol[j] << "---------------------------" << endl;
	}
	if ($pos != -1)//不是每一种文法都有空   这个文法有空
	{
		ForcastTable[0][$pos][0] = TerSymbol[tersymbolcount - 1];
		ForcastTable[0][tersymbolcount][0] = '#';
	}
	else//这个文法没有空
	{
		ForcastTable[0][tersymbolcount + 1][0] = '#';
		length2++;//没有空则列数要加1
	}

	//遍历所有的产生式
	for (int i = 0; i < grammersetcount; i++)
	{
		for (int j = 0; j < GrammerSet[i].RightCount; j++)
		{
			for (int ll = 0; ll < 100; ll++)
				str_fir[ll] = '\0';
			//遍历串  
			for (int k = 0; k < strlen(GrammerSet[i].Right[j]); k++)
			{
				char ch = GrammerSet[i].Right[j][k];
				//非终结符
				if (!isTerSymbol(ch))
				{
					int pos = 0;
					for (pos = 0; pos < grammersetcount; pos++)
						if (GrammerSet[pos].Left == ch)
							break;
					for (int r = 0; r <= strlen(GrammerSet[pos].First); r++)
					{
						int strlength = strlen(str_fir);
						str_fir[strlength] = GrammerSet[pos].First[r];
						str_fir[strlength + 1] = '\0';
					}
					if (!hasnullinfirst(ch))
						break;
				}
				else//终结符
				{
					int strlength = strlen(str_fir);
					str_fir[strlength] = ch;
					str_fir[strlength + 1] = '\0';
					break;
				}
			}
//			cout << GrammerSet[i].Right[j] << "的first集为" << str_fir << endl;
			int flag = 0;
			for(int k=0;k<strlen(str_fir);k++)
				if (str_fir[k] == '$')
				{
					flag = 1;
					break;
				}
			//有空，则进行follow的处理
			if (flag == 1)
			{
				//A=GrammerSet[i].Left;
				//遍历follow
				for (int k = 0; k < GrammerSet[i].FollowCount; k++)
				{
					char ch = GrammerSet[i].Follow[k];
					int pos1 = 0;
					int pos2 = 0;
					for (pos1 = 0; pos1 <= length1; pos1++)
						if (ForcastTable[pos1][0][0] == GrammerSet[i].Left)
							break;
					for (pos2 = 0; pos2 <= length2; pos2++)
						if (ForcastTable[0][pos2][0] == ch)
							break;
					//添加 A->串
					char s[100];
					strcpy_s(s, "A->");
					strcat_s(s, GrammerSet[i].Right[j]);
					s[0] = GrammerSet[i].Left;
					strcpy_s(ForcastTable[pos1][pos2], s);
				//	cout << "follow-------------------------------" << endl;
				}
			}
			//对first（串）中的每一个字符进行处理
			for (int k = 0; k < strlen(str_fir); k++)
			{
				char ch = str_fir[k];
				int pos1 = 0;
				int pos2 = 0;
				for (pos1 = 0; pos1 <= length1; pos1++)
					if (ForcastTable[pos1][0][0] == GrammerSet[i].Left)
						break;
				for (pos2 = 0; pos2 <= length2; pos2++)
					if (ForcastTable[0][pos2][0] == ch)
						break;
				//添加 A->串
				char s[100];
				strcpy_s(s, "A->");
				strcat_s(s, GrammerSet[i].Right[j]);
				s[0] = GrammerSet[i].Left;
				strcpy_s(ForcastTable[pos1][pos2], s);
			}
		}
	}
}

6、构造总控程序

这个是整个实验中最简单的一步了。我不废话了。

void MainControlProcess()
{
	
	ReadInput();
	stack<char>Stack;
	Stack.push('#');
	Stack.push(GrammerSet[0].Left);
	int flag = 0;
	char X;
	char a;
	char instack[100];
	int posstack = 0;
	int pos = 0;
	int step = 0;
	for (int i = 0; i < 100; i++)
		instack[i] = '\0';
	instack[0] = '#';
	instack[1] = GrammerSet[0].Left;
	posstack = 1;
	cout << endl;
	while (1)
	{
		cout << step++ << "   ";
		a = text[pos];
		X=Stack.top();//获取栈顶元素
		cout << "X=" << X << " a=" << a<<"   ";
		cout << "符号栈：" << instack << "     ";
		cout << "输入串：";
		for (int i = pos; i < strlen(text); i++)
			cout << text[i];
		Stack.pop();
		instack[posstack] = '\0';
		posstack--;
		if (X == '#')//结束
		{
			if (a=='#')
			{
				flag = 1;
				cout << "successful" << flag << endl;
				return;
			}
			else
			{
				flag = -1;
				cout << "匹配失败" << flag << endl;
			}
		}
		else if (isTerSymbol(X))//终结符 匹配
		{
		//	cout << "终结符匹配" << X << a << endl;
			if (X == a)
			{
				pos++;
				a = text[pos];
			}
			else
			{
				flag = -2;
				cout << "error" << flag << endl;
				return;
			}
		}
		else//使用规则进行匹配
		{
			int pos1 = 0;
			int pos2 = 0;
			for (pos1 = 0; pos1 <= length1; pos1++)
				if (ForcastTable[pos1][0][0] == X)
					break;
			for (pos2 = 0; pos2 <= length2; pos2++)
				if (ForcastTable[0][pos2][0] == a)
					break;
			char ch;
			for (int i = strlen(ForcastTable[pos1][pos2])-1; i >= 3; i--)
			{
				ch = ForcastTable[pos1][pos2][i];
				if (ch == '$')
					break;
				if (ch == '\0')
				{
					flag = -3;
					cout << "error" << flag << endl;
					return;
				}
				Stack.push(ch);
				instack[++posstack] = ch;
			}
			//这里是使用产生式 书上是所用产生式，不一样 哈哈哈哈哈哈哈哈哈
			cout << "使用产生式：" << ForcastTable[pos1][pos2];
		}
		cout << endl;
	}
}

7、结果

在这里插入图片描述
不太好看，不过算了。
其中最后读取的那个要分析的串在example.txt中。
我的内容是
i*i+i#书上一样

8、代码

#include <iostream>
#include <fstream>
#include <stack>
#include <map>

using namespace std;

int grammersetcount = 0;
int tersymbolcount = 0;//终结符数量
int nontercount = 0;//非终结符数量  默认第一个非终结符为开始符号
char TerSymbol[200];//终结符 非大写字母
map<char, bool> isfirsted;//该终结符是否已经求过其first集
bool isfollowed[200];
char Non_Ter[200];//非终结符 大写字母
char AllSymbol[400];//所有符号
char ForcastTable[100][100][100];
int length1 = nontercount;//有几个非终结符就有几行
int length2 = tersymbolcount;//列
char str_fir[100];//求出first（串） GrammerSet[i].Right[j];
char text[1000];//输入要处理的字符串
struct Node
{
	char Left;
	int RightCount;
	char Right[100][100];
	int FirstCount;
	int FollowCount;
	char First[100];
	char Follow[100];
};

Node GrammerSet[100];
void ShowGrammerSet(Node Grammer[]);//打印全部产生式
void ReadGrammerSet();
bool isTerSymbol(char ch);//true为终结符false为非终结符
void SymbolProcess(char ch);//字符归类
void First(char sym);
void AddFirst(char sym, char ch);//并入first集
void Follow(char sym);
void AddFollow(char sym, char  ch);
void AddFirstToFollow(char sym, char  ch);//将ch的first加入sym的follow中
void AddCharToFollow(char sym, char  ch);//将ch加入sym的follow中
bool hasnullinfirst(char ch);//判断一个非终结符的first中是否有空
void CreateForecastTable();
void ShowForecastTable();
void ReadInput();//读入
void MainControlProcess();//主控程序

int main()
{
	ReadGrammerSet();
//	cout << "first___________________________________" << endl;
	for (int i = 0; i < grammersetcount; i++)
	{
		First(GrammerSet[i].Left);
	//	cout <<GrammerSet[i].Left<<" "<< GrammerSet[i].First << endl;
	}
//	cout << "follow___________________________________" << endl;
	for (int i = 0; i < grammersetcount; i++)
	{
	//	cout << i<<"main函数这里要去寻找" << GrammerSet[i].Left << "的follow集了" << endl;
		Follow(GrammerSet[i].Left);
	//	cout << GrammerSet[i].Left << " " << GrammerSet[i].Follow << endl;
	}
	//将# 加入到follow(x)中
//	cout << "为开始符号将# 加入到follow(x)中" << endl;
	for (int i = 0; i < grammersetcount; i++)
		GrammerSet[i].Follow[GrammerSet[i].FollowCount++] = '#';
	ShowGrammerSet(GrammerSet);
	cout << "first----------------------------------------------------------------------------" << endl;
	for (int i = 0; i < grammersetcount; i++)
		cout << GrammerSet[i].Left << " " << GrammerSet[i].FirstCount << " " << GrammerSet[i].First << endl;
	cout << "follow----------------------------------------------------------------------------" << endl;
	for (int i = 0; i < grammersetcount; i++)
		cout << GrammerSet[i].Left << " " << GrammerSet[i].FollowCount << " " << GrammerSet[i].Follow << endl;
	CreateForecastTable();
	ShowForecastTable();
	MainControlProcess();
}
void ShowGrammerSet(Node GrammerSet[])
{
	/*
	for (int i = 0; i < grammersetcount; i++)
	{
		cout << i << "   " << GrammerSet[i].Left << endl;
		for (int j = 0; j < GrammerSet[i].RightCount; j++)
			cout << j << "   " << GrammerSet[i].Right[j] << endl;
	}
	cout << "非终结符的数量" << nontercount << endl;
	cout << "非终结符" << endl;
	for (int i = 0; i <nontercount; i++)
		cout << Non_Ter[i]<<" ";
	cout << endl;
	cout << "终结符的数量" << tersymbolcount << endl;
	cout << "终结符" << endl;
	for (int i = 0; i < tersymbolcount; i++)
		cout << TerSymbol[i]<<" ";
	cout << endl;
	
	for (int i = 0; i < grammersetcount; i++)
	{
		for (int j = 0; j < GrammerSet[i].RightCount; j++)
		{
			cout << GrammerSet[i].Left << "->" << GrammerSet[i].Right[j] << endl;
		}
	}
	*/
}
void ReadGrammerSet()
{
	char str[100];
	while (1)
	{
		cin >> str;
		if (str[0] == '#')
			break;
		GrammerSet[grammersetcount].Left = str[0];
		SymbolProcess(str[0]);//处理左边的
		for (int i = 3;i<strlen(str); i++)
		{
			
			int j = 0;
			char str2[100];
			while ((str[i] != '|')&&(str[i]!='\0'))
			{
				SymbolProcess(str[i]);//处理右边的
				str2[j++] = str[i++];
			}
			str2[j] = '\0';
			strcpy_s(GrammerSet[grammersetcount].Right[GrammerSet[grammersetcount].RightCount], str2);
			GrammerSet[grammersetcount].RightCount++;
		}
		grammersetcount++;
	}
}
bool isTerSymbol(char ch)
{
//	cout << "正在判断"<<ch<<"是否为终结符" << endl;
	if ( ch >= 'A' && ch <= 'Z')
		return false;
	return true;
}
void SymbolProcess(char ch)
{
	//非终结符
	if (ch <= 'Z' && ch>='A')
	{
		int flag = 0;
		for (int i = 0; i < nontercount; i++)
		{
			if (ch == Non_Ter[i])
			{
				flag = 1;
				break;//已收录
			}
		}
		if (flag == 0)
		{
			Non_Ter[nontercount++] = ch;
			isfirsted.insert(pair<char, bool>(ch, false));
		}
	}
	else//终结符
	{
		int flag = 0;
		for (int i = 0; i < tersymbolcount; i++)
		{
			if (ch == TerSymbol[i])
			{
				flag = 1;
				break;//已收录
			}
		}
		if (flag == 0)
		{
			TerSymbol[tersymbolcount++] = ch;
		}
	}
}
void First(char sym)
{
	//cout << "正在查找" << sym << "的first集" << endl;
	int i;
	for (i = 0; i < grammersetcount; i++)
	{
		if (GrammerSet[i].Left == sym)//找到这个非终结符所在产生式的位置
			break;
	}
	for (int j = 0; j < GrammerSet[i].RightCount; j++)
	{
		//如果first(ch)中包含$，则ch=它的下一个字符 否则退出这个循环
		int shouldbreak = 1;
		for (int pos = 0; pos < strlen(GrammerSet[i].Right[j]); pos++)
		{
			//产生式右部第一个字符为终结符，将其计入左部first集
			char ch = GrammerSet[i].Right[j][pos];
			//cout << "正在判断" << ch << endl;
			if (isTerSymbol(ch))
			{
				//是否已经收录过
				int flag = 0;
				for (int k = 0; k < GrammerSet[i].FirstCount; k++)
				{
					if (GrammerSet[i].First[k] == ch)
					{
						flag = 1;//已收录
						break;
					}
				}
				if (flag == 0)//未收录
					GrammerSet[i].First[GrammerSet[i].FirstCount++] = ch;
			}
			else//非终结符，求该非终结符的first集 如果first(ch)中包含$，则ch=它的下一个字符
			{
				//if(isfirsted(ch)==false)
				First(ch);
				//如果first(ch)中包含$，则ch=它的下一个字符 如果已经是最后一个字符，则程序还是会自动退出循环
				int i;
				for (i = 0; i < grammersetcount; i++)
				{
					if (GrammerSet[i].Left == ch)//找到这个非终结符所在产生式的位置
						break;
				}
				int flag = 0;
				for (int position = 0; position < GrammerSet[i].FirstCount; position++)
				{
					if (GrammerSet[i].First[position] == '$')
					{
						flag = 1;//包含$
						break;
					}
				}
				if (flag == 1)//包含$ ch=它的下一个字符 不应该推出循环
				{
					shouldbreak = 0;
				}
				//将ch的first集并入sym非终结符
				AddFirst(sym, ch);
			}
			if (shouldbreak == 1)
			{
				break;
			}
		}
	}
	//cout << "已经查找完成" << sym << "的first集为"<<GrammerSet[i].First<<endl;
}
void AddFirst(char sym, char ch)//并入first集 将ch的first集并入sym的first集
{
	//cout << "正在将" << ch << "的first集并入" << sym << "的first集" << endl;
	int p1 = 0;
	int p2 = 0;
	int pos1 = 0;
	int pos2 = 0;
	for (pos1 = 0; pos1 < grammersetcount; pos1++)
	{
		if (GrammerSet[pos1].Left == sym)
			break;
	}
	for (pos2 = 0; pos2 < grammersetcount; pos2++)
	{
		if (GrammerSet[pos2].Left == ch)
			break;
	}
	//cout << sym << "的first集为" << GrammerSet[pos1].First << endl;
	//cout << ch << "的first集为" << GrammerSet[pos2].First << endl;
	for (p2 = 0; p2 < GrammerSet[pos2].FirstCount; p2++)
	{
		int flag = 0;
		for (int p1 = 0; p1 < GrammerSet[pos1].FirstCount; p1++)
		{
			if (GrammerSet[pos1].First[p1] == GrammerSet[pos2].First[p2])
			{
				flag = 1;
				break;
			}
		}
		if (flag == 0)
		{
			GrammerSet[pos1].First[GrammerSet[pos1].FirstCount++] = GrammerSet[pos2].First[p2];
		}
	}
	//cout << "完成并入" << endl;
	//cout << sym << "的first集为" << GrammerSet[pos1].First << endl;
	//cout << ch << "的first集为" << GrammerSet[pos2].First << endl;
}
void Follow(char sym)
{
//	cout << "正在寻找" << sym << "的follow集" << endl;
	//对全部的产生式找一个右部含有当前字符sym的产生式
	for (int i = 0; i < grammersetcount; i++)
	{
		for (int j = 0; j < GrammerSet[i].RightCount; j++)
		{
			for (int k = 0; k < strlen(GrammerSet[i].Right[j]); k++)
			{
				//找到一个右部含有当前字符sym的产生式
				if (GrammerSet[i].Right[j][k] == sym)
				{
					//如果sym在产生式右部的最后(形如产生式A->aX)
					//X的follow不一定是A的，但是A的一定是X的。
					if (strlen(GrammerSet[i].Right[j]) - 1 == k)
					{
						char ch = GrammerSet[i].Left;
						if (sym != ch)
						{
							//求ch 的follow
							if (!isfollowed[ch])
								Follow(ch);
							//把FOLLOW(ch)中的元素加入FOLLOW(X)
							AddFollow(sym, ch);
						}
					}
					//if X不在产生式右部的最后(A->aXB) B在这里代表一个符号串
					else
					{
						//遍历B中所有字符
						for (int r = k + 1; r < strlen(GrammerSet[i].Right[j]); r++)
						{
							char ch = GrammerSet[i].Right[j][r];
							//是终结符  加入follow(sym)
							if (isTerSymbol(ch))
							{
								AddCharToFollow(sym, ch);
								break;
							}
							else
							{
								//将first(ch)加入follow(sym)
								AddFirstToFollow(sym, ch);
								if (!hasnullinfirst(ch))
								{
									break;
								}
								//如果ch的first含有空值且sym!=ch则将ch的follow并入follow(sym)
								if(sym!=ch)
								{
									if (isfollowed[ch])
										AddFollow(sym, ch);
									else
										Follow(ch);
								}
							}
						}
					}
				}
			}
		}
	}
	isfollowed[sym] = 1;
//	cout << "已经完成寻找" << sym << "的follow集" << endl;
}
void AddFollow(char sym, char  ch)
{
//	cout << "正在将" << ch << "的Follow集并入" << sym << "的Follow集" << endl;
	int p1 = 0;
	int p2 = 0;
	int pos1 = 0;
	int pos2 = 0;
	for (pos1 = 0; pos1 < grammersetcount; pos1++)
	{
		if (GrammerSet[pos1].Left == sym)
			break;
	}
	for (pos2 = 0; pos2 < grammersetcount; pos2++)
	{
		if (GrammerSet[pos2].Left == ch)
			break;
	}
//	cout << sym << "的Follow集为" << GrammerSet[pos1].Follow << endl;
//	cout << ch << "的Follow集为" << GrammerSet[pos2].Follow << endl;
	for (p2 = 0; p2 < GrammerSet[pos2].FollowCount; p2++)
	{
		int flag = 0;
		for (int p1 = 0; p1 < GrammerSet[pos1].FollowCount; p1++)
		{
			if (GrammerSet[pos1].Follow[p1] == GrammerSet[pos2].Follow[p2])
			{
				flag = 1;
				break;
			}
		}
		if (flag == 0)
		{
			GrammerSet[pos1].Follow[GrammerSet[pos1].FollowCount++] = GrammerSet[pos2].Follow[p2];
		}
	}
//	cout << "完成并入" << endl;
//	cout << sym << "的Follow集为" << GrammerSet[pos1].Follow << endl;
//	cout << ch << "的Follow集为" << GrammerSet[pos2].Follow << endl;
}
void AddFirstToFollow(char sym, char  ch)
{
//	cout << "正在将" << ch << "的First集并入" << sym << "的Follow集" << endl;
	int p1 = 0;
	int p2 = 0;
	int pos1 = 0;
	int pos2 = 0;
	for (pos1 = 0; pos1 < grammersetcount; pos1++)
	{
		if (GrammerSet[pos1].Left == sym)
			break;
	}
	for (pos2 = 0; pos2 < grammersetcount; pos2++)
	{
		if (GrammerSet[pos2].Left == ch)
			break;
	}
//	cout << sym << "的Follow集为" << GrammerSet[pos1].Follow << endl;
//	cout << ch << "的First集为" << GrammerSet[pos2].First << endl;
	for (p2 = 0; p2 < GrammerSet[pos2].FirstCount; p2++)
	{
		int flag = 0;
		for (int p1 = 0; p1 < GrammerSet[pos1].FollowCount; p1++)
		{
			if (GrammerSet[pos1].Follow[p1] == GrammerSet[pos2].First[p2])
			{
				flag = 1;
				break;
			}
		}
		if ((flag == 0)&&(GrammerSet[pos2].First[p2]!='$'))
		{
			GrammerSet[pos1].Follow[GrammerSet[pos1].FollowCount++] = GrammerSet[pos2].First[p2];
		}
	}
//	cout << "完成并入" << endl;
//	cout << sym << "的Follow集为" << GrammerSet[pos1].Follow << endl;
//	cout << ch << "的First集为" << GrammerSet[pos2].First << endl;
}
void AddCharToFollow(char sym, char  ch)
{
	if (ch == '$')
		return;
//	cout << "正在将字符" << ch << "并入"<<sym<<"的follow集中" << endl;
	int pos = 0;
	for (pos = 0; pos < grammersetcount; pos++)
	{
		if (GrammerSet[pos].Left == sym)
			break;
	}
	int flag = 0;
	for (int i = 0; i < strlen(GrammerSet[pos].Follow); i++)
	{
		if (GrammerSet[pos].Follow[i] == 'ch')
		{
			flag = 1;
			break;
		}
	}
	if (flag == 0)
	{
		GrammerSet[pos].Follow[GrammerSet[pos].FollowCount++] = ch;
	}
}
bool hasnullinfirst(char ch)
{
//	cout << "正在查找" << ch << "的first集中是否有空" << endl;
	int pos = 0;
	for (pos = 0; pos < grammersetcount; pos++)
	{
		if (GrammerSet[pos].Left == ch)
			break;
	}
	int flag = 0;
	for (int i = 0; i < strlen(GrammerSet[pos].First); i++)
	{
		if (GrammerSet[pos].First[i] == '$')
		{
			flag = 1;
			break;
		}
	}
//	if(flag==1)
//		cout << ch << "的first集中有空" << endl;
//	else
//		cout << ch << "的first集中没有空" << endl;
	return flag;
}
void CreateForecastTable()
{
	//初始化预测表
	int $pos = -1;//不是每一种文法都有空
	length1 = nontercount;//有几个非终结符就有几行
	length2 = tersymbolcount;//列
	for (int i = 0; i < grammersetcount; i++)//注意从一开始
		ForcastTable[i + 1][0][0] = GrammerSet[i].Left;
	for (int j = 0; j < tersymbolcount; j++)
	{
		if (TerSymbol[j] == '$')
		{
			ForcastTable[0][j + 1][0] = '#';
			$pos = j + 1;
		}
		else
			ForcastTable[0][j + 1][0] = TerSymbol[j];
//		cout << TerSymbol[j] << "---------------------------" << endl;
	}
	if ($pos != -1)//不是每一种文法都有空   这个文法有空
	{
		ForcastTable[0][$pos][0] = TerSymbol[tersymbolcount - 1];
		ForcastTable[0][tersymbolcount][0] = '#';
	}
	else//这个文法没有空
	{
		ForcastTable[0][tersymbolcount + 1][0] = '#';
		length2++;//没有空则列数要加1
	}

	//遍历所有的产生式
	for (int i = 0; i < grammersetcount; i++)
	{
		for (int j = 0; j < GrammerSet[i].RightCount; j++)
		{
			for (int ll = 0; ll < 100; ll++)
				str_fir[ll] = '\0';
			//遍历串  
			for (int k = 0; k < strlen(GrammerSet[i].Right[j]); k++)
			{
				char ch = GrammerSet[i].Right[j][k];
				//非终结符
				if (!isTerSymbol(ch))
				{
					int pos = 0;
					for (pos = 0; pos < grammersetcount; pos++)
						if (GrammerSet[pos].Left == ch)
							break;
					for (int r = 0; r <= strlen(GrammerSet[pos].First); r++)
					{
						int strlength = strlen(str_fir);
						str_fir[strlength] = GrammerSet[pos].First[r];
						str_fir[strlength + 1] = '\0';
					}
					if (!hasnullinfirst(ch))
						break;
				}
				else//终结符
				{
					int strlength = strlen(str_fir);
					str_fir[strlength] = ch;
					str_fir[strlength + 1] = '\0';
					break;
				}
			}
//			cout << GrammerSet[i].Right[j] << "的first集为" << str_fir << endl;
			int flag = 0;
			for(int k=0;k<strlen(str_fir);k++)
				if (str_fir[k] == '$')
				{
					flag = 1;
					break;
				}
			//有空，则进行follow的处理
			if (flag == 1)
			{
				//A=GrammerSet[i].Left;
				//遍历follow
				for (int k = 0; k < GrammerSet[i].FollowCount; k++)
				{
					char ch = GrammerSet[i].Follow[k];
					int pos1 = 0;
					int pos2 = 0;
					for (pos1 = 0; pos1 <= length1; pos1++)
						if (ForcastTable[pos1][0][0] == GrammerSet[i].Left)
							break;
					for (pos2 = 0; pos2 <= length2; pos2++)
						if (ForcastTable[0][pos2][0] == ch)
							break;
					//添加 A->串
					char s[100];
					strcpy_s(s, "A->");
					strcat_s(s, GrammerSet[i].Right[j]);
					s[0] = GrammerSet[i].Left;
					strcpy_s(ForcastTable[pos1][pos2], s);
				//	cout << "follow-------------------------------" << endl;
				}
			}
			//对first（串）中的每一个字符进行处理
			for (int k = 0; k < strlen(str_fir); k++)
			{
				char ch = str_fir[k];
				int pos1 = 0;
				int pos2 = 0;
				for (pos1 = 0; pos1 <= length1; pos1++)
					if (ForcastTable[pos1][0][0] == GrammerSet[i].Left)
						break;
				for (pos2 = 0; pos2 <= length2; pos2++)
					if (ForcastTable[0][pos2][0] == ch)
						break;
				//添加 A->串
				char s[100];
				strcpy_s(s, "A->");
				strcat_s(s, GrammerSet[i].Right[j]);
				s[0] = GrammerSet[i].Left;
				strcpy_s(ForcastTable[pos1][pos2], s);
			}
		}
	}
}
void ShowForecastTable()
{
	for (int i = 0; i <=length1; i++)
	{
		for (int j = 0; j <= length2; j++)
		{
			cout << ForcastTable[i][j];
			for (int k = 0; k < 10 - strlen(ForcastTable[i][j]); k++)
				cout << ".";
		}
		cout << endl << endl;
	}
}
void ReadInput()
{
	int pos = 0;
	ifstream fin;
	fin.open("example.txt");
	while (!fin.eof())
	{
		text[pos++] = fin.get();
	}
	fin.close();
	cout << text;
	pos = 0;
}
void MainControlProcess()
{
	
	ReadInput();
	stack<char>Stack;
	Stack.push('#');
	Stack.push(GrammerSet[0].Left);
	int flag = 0;
	char X;
	char a;
	char instack[100];
	int posstack = 0;
	int pos = 0;
	int step = 0;
	for (int i = 0; i < 100; i++)
		instack[i] = '\0';
	instack[0] = '#';
	instack[1] = GrammerSet[0].Left;
	posstack = 1;
	cout << endl;
	while (1)
	{
		cout << step++ << "   ";
		a = text[pos];
		X=Stack.top();//获取栈顶元素
		cout << "X=" << X << " a=" << a<<"   ";
		cout << "符号栈：" << instack << "     ";
		cout << "输入串：";
		for (int i = pos; i < strlen(text); i++)
			cout << text[i];
		Stack.pop();
		instack[posstack] = '\0';
		posstack--;
		if (X == '#')//结束
		{
			if (a=='#')
			{
				flag = 1;
				cout << "successful" << flag << endl;
				return;
			}
			else
			{
				flag = -1;
				cout << "匹配失败" << flag << endl;
			}
		}
		else if (isTerSymbol(X))//终结符 匹配
		{
		//	cout << "终结符匹配" << X << a << endl;
			if (X == a)
			{
				pos++;
				a = text[pos];
			}
			else
			{
				flag = -2;
				cout << "error" << flag << endl;
				return;
			}
		}
		else//使用规则进行匹配
		{
			int pos1 = 0;
			int pos2 = 0;
			for (pos1 = 0; pos1 <= length1; pos1++)
				if (ForcastTable[pos1][0][0] == X)
					break;
			for (pos2 = 0; pos2 <= length2; pos2++)
				if (ForcastTable[0][pos2][0] == a)
					break;
			char ch;
			for (int i = strlen(ForcastTable[pos1][pos2])-1; i >= 3; i--)
			{
				ch = ForcastTable[pos1][pos2][i];
				if (ch == '$')
					break;
				if (ch == '\0')
				{
					flag = -3;
					cout << "error" << flag << endl;
					return;
				}
				Stack.push(ch);
				instack[++posstack] = ch;
			}
			//这里是使用产生式 书上是所用产生式，不一样 哈哈哈哈哈哈哈哈哈
			cout << "使用产生式：" << ForcastTable[pos1][pos2];
		}
		cout << endl;
	}
}
易水凌波
关注
专栏目录
编译原理预测分析算法
11-27
编译原理的实验之一，预测分析算法。用C语言写的，包括左递归的处理。
【编译原理】语法分析之预测分析法
Newtopython的博客
07-29 1330
关于编译原理中语法分析的预测分析法步骤详解
编译原理实验（四）：预测分析法
欢迎来到 晨 的博客
05-21 2661
预测分析法
编译原理实验——预测分析法
katyusha77的专栏
12-13 1648
编译原理 课程设计 语法分析 预测分析 源程序
编译原理（预测分析法）
typename 记录点滴
11-12 3628
#include #include #include #include #define MAXSIZE  100 typedef struct //定义顺序栈 {  int data[MAXSIZE];  int top;//栈顶指针 }SeqStack; SeqStack *s;//定义一个指向顺序栈的指针变量 void Scaner();//词法分析扫描函数 vo
编译原理 预测分析法 C语言 代码.docx
07-03
编译原理预测分析法C语言代码.docx 本资源文件讲解了编译原理预测分析法的实现，通过C语言代码来展示如何使用预测分析法来识别语法错误。 预测分析法的基本概念 预测分析法是一种语法分析技术，用于识别语法错误...
编译原理预测分析法C语言的实验报告.docx
07-03
《编译原理预测分析法C语言的实验报告》 在编译原理中，预测分析法是一种用于构造解析器的技术，特别是在构建LL(1)解析器时尤为重要。LL(1)代表自左至右扫描输入，每次最多向前看一个符号进行预测。本实验报告将...
(完整word版)编译原理预测分析法实验报告(C语言编写).doc
最新发布
10-24
《编译原理预测分析法实验报告》涉及到的是编译原理中的一个重要概念——预测分析法，尤其是LL(1)预测分析法。在这个实验中，学生需要使用C语言编写一个程序，该程序能对给定的文法进行语法分析，判断输入的字符串...
编译原理实验 词法分析 语法分析递归下降 预测分析 Python
12-11
在编程领域，编译原理是理解计算机语言处理过程的关键部分，它涉及将源代码转换为目标...通过词法分析、语法分析、递归下降和预测分析的学习与实践，你不仅将掌握编译原理的核心概念，还将提升你的编程和问题解决能力。
编译原理预测分析法语法分析程序
12-22
预测分析法是一种自顶向下的语法分析方法，常用于实现递归下降解析器。本文将深入探讨预测分析法的概念、工作原理以及如何应用于给定的文法规则。 预测分析法，又称LR分析（Lookahead Rightmost Derivation），它以...
编译原理实验预测分析C语言
07-28
编译原理实验 C语言 预测分析方法 预测分析 预测分析
编译原理--预测分析法 java
06-20
编译原理--预测分析法 由java编写 从求first集 follow集合开始 构造预测分析表 输出分析过程 完整过程！！！
编译原理的预测分析表语法器
12-01
用预测分析表实现的语法器 vc++语言 比较简单
编译原理LL(1)预测分析法JAVA实现
06-21
1、项目开发工具为MyEclipse2014 2、使用了Struts2框架作为控制层 3、HTML5图形用户界面 4、JAVA语言写后端 该项目完成的功能有：自动消去规则左递归；自动计算出First、Follow集；自动构造预测分析表；可输入句子进行判断。 代码我都写了注释，由于项目后期完成的比较急促，所以代码冗余度比较大，还没有时间进行精简。 如果不需要网页的图形用户界面，可将项目中的算法部分单独取出，也可直接运行得到结果。算法部分位于项目中的MyClass包中。
编译原理 语法分析 预测分析法（含代码）
04-23
　　由于预测分析和递归子程序都是自顶向下的分析方法，这里给出无回溯的和无左公因子的文法。无左递归和无左公因子的BNF如下： 　→. 　→PROGRAM 标识符; 　→ 　→CONST;|ε 　→标识符=无符号整数 　→, |ε 　→VAR|ε 　→标识符:; 　→,标识符|ε 　→|ε 　→INTEGER|LONG 　→;|ε 　→PROCEDURE 标识符: 　→(标识符:)|ε 　→;|ε 　→||||| 　→标识符 　→:=|()|ε 　→IFTHEN 　→WHILEDO 　→READ (标识符) 　→WRITE (表达式) 　→, |ε 　→BEGIN END 　→; |ε 　→ |ODD 　→+|-| 　→|ε 　→ 　→|ε 　→标识符|无符号整数|（） 　→+|- 　→*|/ 　→=||<||>=
编译原理 --- 预测分析程序
qq_51947882的博客
10-19 2451
还是与离他最远的 if 匹配呢？分析表本身的数据结构是矩阵，第一个坐标是非终结符A，第二则是终结符a，根据坐标找到的元素则是在输入符号为终结符a，文法匹配符号为非终结符A时用来进行扩展的非终结符A的候选式。1.在弹出非终结符，并用其候选式来代替它的位置时，指向输入串字符的指针没有变动且也没有进行匹配，直到栈中无法再进行替换（入栈）后，我们才开始进行输入串的匹配。4.所有与语法相关的知识都在分析表中，而总控程序只是负责去执行这些知识的机器，这个机器在不同的语法分析程序中都是通用的（执行的步骤都是一样的）
编译原理之预测分析
weixin_44935877的博客
12-05 184
#include <stdio.h> #include <stdlib.h> #include <string.h> #include <windows.h> #include <conio.h> typedef struct{ char* formula;//产生式 char right[100][100]; //产...
编译原理实现预测分析法（LL（1））
热门推荐
是我是我都是我的博客
12-25 1万+
编译原理实现预测分析法（LL（1））
编译原理_预测分析法
流沙-岁月
04-30 995
#include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include using namespace std; const int N=1000; i
编译原理：预测分析法在togaf 9.1中的应用
"预测分析法-togaf 9.1 foundation中文试题 编译原理 课件" 在计算机科学领域，编译原理是理解和构建编译器的基础，它涉及到将高级编程语言转换为机器可执行代码的过程。预测分析法是编译器设计中的一个重要概念，...
评论 5
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值