简单优先分析

于 2023-12-05 14:14:05 发布
阅读量834 收藏 15
点赞数 22
文章标签： c#
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_62806440/article/details/134805735
版权

实验步骤：

步骤一：先定义一个结构体g，其中包含文法的左部和文法的右部，用来记录用户输入的所有文法信息；

步骤二：定义变量，整型变量i记录文法的总条数；结构体变量G记录文法信息；一维字符数组fzjf记录所有非终结符；二维字符数组FIRST记录所有非终结符各自的FIRST集；二维字符数组LAST记录所有非终结符各自的LAST集；一维字符数组test记录所要分析的字符串；一维字符数组Q记录符号栈，并将Q[0]置为‘#’；其余变量在需要的时候再定义（存在一定的不足）；

步骤三：提示用户按规定输入文法；"请输入文法，例如Z bMb表示Z->bMb，# #表示结束，^表示空：\n"；如果用户输入的文法存在两个产生式的右部相同，提示用户重新输入；

步骤四：用一个循环接受用户输入的文法，并将非终结符号记录下来；

步骤五：进行判断，如果i>1表明用户输入了文法，否则提示用户，"你没有输入文法！"，并退出该程序；

步骤六：定义一个整型变量flag=0和count=0用来控制求FIRST和LAST集的无限循环，即一旦某一个非终结符的FIRST(LAST)被加入了新的符号，flag=1，而一旦某一个非终结符的FIRST(LAST)没有被加入了新的符号，flag=0，count根据flag的情况进行改变，flag=1，count=0；flag=0，count++;

步骤七：求FIRST(LAST)集：用一个循环无限遍历所有非终结符号，循环内用一个循环遍历所有的文法，如果文法的左部和非终结符相同，分两种情况讨论：（1）文法右部的第一个（最后一个）字符为终结符号,检查非终结符的FIRST（LAST），是否存在该终结符号，如果存在不将其加入FIRST（LAST）；如果不存在将其加入FIRST（LAST）（2）文法右部的第一个（最后一个）字符为非终结符号，检查非终结符的FIRST（LAST），是否存在该非终结符号，如果存在不将其加入FIRST（LAST）；如果不存在将其加入FIRST（LAST），再去遍历该非终结符的FIRST（LAST），并检查是否已经存在将要加入的符号，如果有则不加，如果没有要将其加入；直到退出该循环，即可求得每个非终结符的FIRST(LAST);

步骤八：定义一个二维字符串数组gx用来记录个符号之间的关系，首先求等号关系，遍历所有文法，如果文法的右部长度大于一，则存在等号关系，将等号记录在二维数组每行的第二个位置上，左右两边分别记录对应的符号；其次求大于号关系，遍历所有文法，如果文法的右部长度大于一，并且非终结符号在前，终结符号紧跟在非终结符号后面，则存在大于号关系，将大于号记录在二维数组每行的第二个位置上，左右两边分别记录非终结符号的LAST集里的所有符号，终结符号；最后求小于号关系，遍历所有文法，如果文法的右部长度大于一，并且终结符号在前，非终结符号紧跟在终结符号后面，则存在小于号关系，将小于号记录在二维数组每行的第二个位置上，左右两边分别记录终结符号，非终结符号的FIRST集里的所有符号；注意检查输入的文法是否存在两个符号有大于1中优先关系，如果有提示用户重新输入；

步骤九：打印关系表，并提示用户输入要分析的字符串，在字符串的最后一位添上‘#’；

步骤十：定义整型变量Qi = 1，testi = 0，foundflag，bt = 0；分别表示Q的栈顶“指针”，test队列的出队“指针”，出错标记，步骤序号；

步骤十一：一个无限循环，当符号栈里只有一个‘#’和一个开始符号，并且输入符号串只剩下一个‘#’时，打印当前的状态并退出该循环；否则用一个循环遍历关系表里的所有关系此时foundflag=0，并用关系表里的每条关系的比较符号的左右两边的符号分别与符号栈Q的最顶的符号和test[testi]进行匹配，如果都相同，看其比较符号为什么，有两种情况（1）‘<’和‘=’，下一步动作为移进，（2）‘>’下一步动作为规约；否则foundflag一直等于0，退出该循环后，判断foundflag的值，如果为0，退出无限循环并显示出错位置，如果为1，看是否满足退出大循环的条件，满足退出大循环，不满足继续进行循环。

步骤十二：步骤十一的两种情况：（1）移进：在移进的过程中，先把比较符号‘<’或‘=’移进再将testi所指的字符移进，testi++；（2）归约：找到可归约的文法，将文法的左部非终结符号与字符栈Q中的靠近栈顶小于号的左边的非‘#’符号进行比较，如果能找到关系先将其比较符号入栈在将归约后的非终结符入栈，否则提示用户出错。

特别说明：在本次实验中的简单优先分析表也是算法实现的。

#include<stdio.h>
#include<string.h>
struct g{
	char left[2];//为1的时候可能越界了！！！ 
	char right[100];
};
int main()
{
	int i = 0,pf;//i表示共有i文法 
	struct g G[100];
	char fzjf[100]; 
	char FIRST[100][100];
	char LAST[100][100]; 
	char test[100];
	char Q[100];//符号栈 
	Q[0] = '#'; 
	printf("请输入文法，例如Z bMb表示Z->bMb，# #表示结束，^表示空：\n");
	while(1) //后续应该加强输入的健壮性 
	{
		i++;
		scanf("%s %s",&G[i].left,&G[i].right);
		
		for(int wf = 1;wf<i;wf++)//如果有两个产生式的右部相同，那么在寻找左部时，会出错！ 
		{
			int a = 0,aa = 0;
			while(G[wf].right[a]!='\0'||G[i].right[aa]!='\0')
			{
				if(G[wf].right[a] != G[i].right[aa])
				break;
				else
				{
					a++;
					aa++;
				}
			}
			if(G[wf].right[a]=='\0'&&G[i].right[aa]=='\0')
			{
				printf("输入的文法存在两个产生式的右部相同！请重新输入！\n"); 
				return 0; 
			}
		}
		if(G[i].left[0] == '#' && G[i].right[0] == '#')
		break;
		for(pf = 0;pf<strlen(fzjf);pf++)//求得所有的非终结符号 
		{
			if(G[i].left[0] == fzjf[pf])
			break;
		} 
		if(pf == strlen(fzjf))
		{
			fzjf[pf] = G[i].left[0];
			fzjf[pf + 1] = '\0';
		}
	}
	if(i>1)
	{
		G[0].left[0] = '@';
		G[0].right[0] = '#';
		G[0].right[1] = G[1].left[0];
		G[0].right[2] = '#';
	}
	else
	{
		printf("你没有输入文法！");
		return (0);
	} 
//	for(int j = 0;j<i;j++)//j变量用来遍历文法数组 
//	{
//		printf("%s %s\n",G[j].left,G[j].right);
//	}
//	for(int j = 0;j<strlen(fzjf);j++)//遍历非终结符号数组 
//	{
//		printf("%c\n",fzjf[j]);
//	}
	//求FIRST
	int flag,count = 0;
	for(int k = 0;;k++)//遍历所有非终结符
	{
		flag = 0;
		k = k%strlen(fzjf);
		for(int j = 0;j<i;j++)//遍历所有的文法
		{
			if(G[j].left[0] == fzjf[k])
			{
				if(!(G[j].right[0] >='A' && G[j].right[0] <='Z'))//文法右部的第一个字符为终结符号,将其去重后再加入对应的FIRST集中 
				{
					int bl;
					for(bl = 0;bl < strlen(FIRST[k]);bl++)
					{
						if(FIRST[k][bl] == G[j].right[0])
						break;
					} 
					if(bl == strlen(FIRST[k]))
					{
						FIRST[k][strlen(FIRST[k])] = G[j].right[0];
						FIRST[k][strlen(FIRST[k]) + 1] = '\0';
						flag = 1;
					}
				}
				else//文法右部的第一个字符为非终结符号，去重后要将其本身加入，再去遍历该非终结符再看看其推导出来的右部 
				{
					int bl1;
					for(bl1 = 0;bl1 < strlen(FIRST[k]);bl1++)
					{
						if(FIRST[k][bl1] == G[j].right[0])
						break;
					} 
					if(bl1 == strlen(FIRST[k]))///
					{
						FIRST[k][strlen(FIRST[k])] = G[j].right[0];//将非终结符加入 
						FIRST[k][strlen(FIRST[k]) + 1] = '\0';
						//将非终结符的FIRST集加入
					}
						int wz;//找到位置 
						for(wz = 0;wz<strlen(fzjf);wz++)
						{
							if(fzjf[wz] == G[j].right[0])
							break;
						}
						int bl2;
						for(bl2 = 0;bl2<strlen(FIRST[wz]);bl2++)
						{
							int a;
							for(a = 0;a<strlen(FIRST[k]);a++)
							{
								if(FIRST[k][a] == FIRST[wz][bl2])
								break;
							}
							if(a == strlen(FIRST[k]))
							{
								FIRST[k][strlen(FIRST[k])] = FIRST[wz][bl2];//将非终结符加入 
								FIRST[k][strlen(FIRST[k]) + 1] = '\0';
								flag = 1;/
							}
						}
				}
			}
		} 
		if(flag == 1)
		count = 0;
		else
		count++;
		if(count == strlen(fzjf))
		break;
	} 
//	for(int jj = 0;jj<strlen(fzjf);jj++)//遍历非FIRST数组 
//	{
//		printf("%s\n",FIRST[jj]);
//	} printf("\n"); 
	//求LAST 
	flag,count = 0;
	for(int k = 0;;k++)//遍历所有非终结符
	{
		flag = 0;
		k = k%strlen(fzjf);
		for(int j = 0;j<i;j++)//遍历所有的文法
		{
			if(G[j].left[0] == fzjf[k])
			{
				if(!(G[j].right[strlen(G[j].right)-1] >='A' && G[j].right[strlen(G[j].right)-1] <='Z'))//文法右部的最后一个字符为终结符号,将其去重后再加入对应的FIRST集中 
				{
					int bl;
					for(bl = 0;bl < strlen(LAST[k]);bl++)
					{
						if(LAST[k][bl] == G[j].right[strlen(G[j].right)-1])
						break;
					} 
					if(bl == strlen(LAST[k]))
					{
						LAST[k][strlen(LAST[k])] = G[j].right[strlen(G[j].right)-1];
						LAST[k][strlen(LAST[k]) + 1] = '\0';
						flag = 1;
					}
				}
				else//文法右部的最后一个字符为非终结符号，去重后要将其本身加入，再去遍历该非终结符再看看其推导出来的右部 
				{
					int bl1;
					for(bl1 = 0;bl1 < strlen(LAST[k]);bl1++)
					{
						if(LAST[k][bl1] == G[j].right[strlen(G[j].right)-1])
						break;
					} 
					if(bl1 == strlen(LAST[k]))
					{
						LAST[k][strlen(LAST[k])] = G[j].right[strlen(G[j].right)-1];//将非终结符加入 
						LAST[k][strlen(LAST[k]) + 1] = '\0';
						//将非终结符的LAST集加入
					}
						int wz;//找到位置 
						for(wz = 0;wz<strlen(fzjf);wz++)
						{
							if(fzjf[wz] == G[j].right[strlen(G[j].right)-1])
							break;
						}
						int bl2;
						for(bl2 = 0;bl2<strlen(LAST[wz]);bl2++)
						{
							int a;
							for(a = 0;a<strlen(LAST[k]);a++)
							{
								if(LAST[k][a] == LAST[wz][bl2])
								break;
							}
							if(a == strlen(LAST[k]))
							{
								LAST[k][strlen(LAST[k])] = LAST[wz][bl2];//将非终结符加入 
								LAST[k][strlen(LAST[k]) + 1] = '\0';
								flag = 1;
							}
						}
				}
			}
		} 
		if(flag == 1)
		count = 0;
		else
		count++;
		if(count == strlen(fzjf))
		break;
	} 
//	for(int jj = 0;jj<strlen(fzjf);jj++)//遍历非LAST数组 
//	{
//		printf("%s\n",LAST[jj]);
//	}
	printf("\n"); 
	char gx[200][5];
	//求等号关系 
	int gxi = 0;
	for(int j = 1;j<i;j++)//遍历所有文法
	{
		if(strlen(G[j].right)>1) 
		{
			for(int t = 0;t<strlen(G[j].right)-1;t++)
			{
				for(int a = 0;a<gxi;a++)//判断输入的文法是否存在两个符号有大于1中优先关系
				{
					if(gx[a][0] == G[j].right[t]&&gx[a][1] != '='&&gx[a][2] == G[j].right[t+1])
					{
						printf("输入的文法存在两个符号有大于1中优先关系！请重新输入！\n") ;
						return 0;
					}
				} 
				gx[gxi][0] = G[j].right[t];
				gx[gxi][1] = '=';
				gx[gxi][2] = G[j].right[t+1];
				gxi++;
			}
		}
	}
	//求大于号关系 
	gx[gxi][0] = G[1].left[0];
	gx[gxi][1] = '>';
	gx[gxi][2] = '#';
	gxi++;
	for(int j = 0;j<i;j++)//遍历所有文法
	{
		if(strlen(G[j].right)>1) 
		{
			for(int t = 0;t<strlen(G[j].right)-1;t++)
			{
				if((G[j].right[t]>='A'&&G[j].right[t]<='Z')&&!(G[j].right[t+1]>='A'&&G[j].right[t+1]<='Z'))
				{
					int wz;
					for(wz = 0;wz<strlen(fzjf);wz++)
					{
						if(G[j].right[t] == fzjf[wz])
						break;
					} 
					for(int fz = 0;fz<strlen(LAST[wz]);fz++)
					{
						for(int a = 0;a<gxi;a++)
						{
							if(gx[a][0] == LAST[wz][fz]&&gx[a][1] != '>'&&gx[a][2] == G[j].right[t+1])//判断输入的文法是否存在两个符号有大于1中优先关系
							{
								printf("输入的文法存在两个符号有大于1中优先关系！请重新输入！\n") ;
								return 0;
							}
						} 
						gx[gxi][0] = LAST[wz][fz];
						gx[gxi][1] = '>';
						gx[gxi][2] = G[j].right[t+1];
						gxi++;
					}
				}
			}
		}
	}
	//求小于号关系 
	gx[gxi][0] = '#';
	gx[gxi][1] = '<';
	gx[gxi][2] = G[1].left[0];
	gxi++;
	for(int j = 0;j<i;j++)//遍历所有文法
	{
		if(strlen(G[j].right)>1) 
		{
			for(int t = 0;t<strlen(G[j].right)-1;t++)
			{
				if(!(G[j].right[t]>='A'&&G[j].right[t]<='Z')&&(G[j].right[t+1]>='A'&&G[j].right[t+1]<='Z'))
				{
					int wz;
					for(wz = 0;wz<strlen(fzjf);wz++)
					{
						if(G[j].right[t+1] == fzjf[wz])
						break;
					} 
					for(int fz = 0;fz<strlen(FIRST[wz]);fz++)
					{
						for(int a = 0;a<gxi;a++)
						{
							if(gx[a][0] == G[j].right[t]&&gx[a][1] != '<'&&gx[a][2] == FIRST[wz][fz])//判断输入的文法是否存在两个符号有大于1中优先关系
							{
								printf("输入的文法存在两个符号有大于1中优先关系！请重新输入！\n") ;
								return 0;
							}
						} 
						gx[gxi][0] = G[j].right[t];
						gx[gxi][1] = '<';
						gx[gxi][2] = FIRST[wz][fz];
						gxi++;
					}
				}
			}
		}
	}
	printf("关系表\n"); 
	for(int j = 0;j<gxi;j++)
	{
		printf("%c %c %c\n",gx[j][0],gx[j][1],gx[j][2]);
	}printf("\n"); 
	printf("输入要识别的字符串：\n");
	scanf("%s",&test);
	test[strlen(test)] = '#';
	test[strlen(test)+1] = '\0';
	int Qi = 1,testi = 0,foundflag,bt = 0;
	while(1)
	{
		int found = 0;
		if(strlen(Q) == 2&&test[testi] == '#')
		{
			printf("%d	",bt++);
			for(int f = 0;f<strlen(Q);f++)//输出符号栈 
			{
				if(Q[f]!='>'&&Q[f]!='='&&Q[f]!='<')
				printf("%c",Q[f]); 
			}printf("			");
			for(int bl = testi;bl<strlen(test);bl++)//输出剩余符号 
			{
				printf("%c",test[bl]); 
			}printf("			");
			printf(" 接受");
			break;
		}
		foundflag = 0;
		for(found = 0;found<gxi;found++)
		{
			if(gx[found][0] == Q[strlen(Q) - 1] && gx[found][2] == test[testi])//查关系表 (第一个终结符和队列先出的字符进行比较！！！！！！！！！！！！！！！！) 
			{
				if(gx[found][1] == '<'||gx[found][1] == '=')//动作：移进
				{
					if(bt == 0)
					{
						printf("步骤	符号栈			输入符号串		 动作			出错信息\n"); 
						bt++; 
					}
					printf("%d	",bt++);
					for(int f = 0;f<strlen(Q);f++)//输出符号栈 
					{
						if(Q[f]!='>'&&Q[f]!='='&&Q[f]!='<')
						printf("%c",Q[f]); 
					}printf("			");
					for(int bl = testi;bl<strlen(test);bl++)//输出剩余符号 
					{
						printf("%c",test[bl]); 
					}printf("			");
					printf(" 移进\n");
					
					
					Q[Qi] = gx[found][1];
					Q[Qi+1] = test[testi];
					Q[Qi+2] = '\0';
					Qi = strlen(Q);
					testi++;
				}
				else if(gx[found][1] == '>')//动作：归约 
				{
					printf("%d	",bt++);
					for(int f = 0;f<strlen(Q);f++)
					{
						if(Q[f]!='>'&&Q[f]!='='&&Q[f]!='<')
						printf("%c",Q[f]); 
					}printf("			");
					for(int bl = testi;bl<strlen(test);bl++)
					{
						printf("%c",test[bl]); 
					}printf("			");
					printf(" 归约");
					
					
					
					for(int bl1 = 0;bl1<i;bl1++)//遍历文法 
					{
						int bl2,bl3,count = 0;
						for(bl2 = strlen(G[bl1].right)-1,bl3 = strlen(Q)-1;bl2>=0;bl2--)
						{//printf("找归约式"); 
							if(Q[bl3] == '>'||Q[bl3] == '='||Q[bl3] == '<')
							{
								bl3--;
							}
							if(Q[bl3] != G[bl1].right[bl2])
							break;
							bl3--;
						}
						if(bl2 == -1&&Q[bl3] == '<')
						{//printf("\n找到归约式\n");
							if(Q[bl3-1]!='#')
							{
								int y;
								for(y = 0;y<gxi;y++)
								{//printf("\n%c %c %c %c\n",gx[y][0],Q[bl3-1],gx[y][2],G[bl1].left[0]); 
									if(gx[y][0] == Q[bl3-1] && gx[y][2] == G[bl1].left[0])
									{
										Q[bl3] = gx[y][1];
										Q[bl3 + 1] = G[bl1].left[0];
										Q[bl3 + 2] = '\0';
										Qi = strlen(Q);
									}
								}
							}
							else
							{
								Q[bl3] = G[bl1].left[0];
								Q[bl3+1] = '\0';
								Qi = strlen(Q);
							}printf("(%c->%s)\n",G[bl1].left[0],G[bl1].right);
							break;

						}
					}
				}
				foundflag = 1;
			}
		}
		if(foundflag == 0)
		{
			printf("%d	",bt++);
			for(int f = 0;f<strlen(Q);f++)
			{
				if(Q[f]!='>'&&Q[f]!='='&&Q[f]!='<')
				printf("%c",Q[f]); 
			}printf("			");
			for(int bl = testi;bl<strlen(test);bl++)
			{
				printf("%c",test[bl]); 
			}printf("			");
			printf(" 出错！			%c与%c没有关系",Q[strlen(Q)-1],test[testi]);
			break;
		}
	}
	return 0;
}

测试样例

Z bMb
M a
M (L
L Ma)
# #
b(aa)b

//出错 
Z bMb
M a
M (L
L Ma)
# #
b(aa)

//文法不全，导致分析出错 
Z bMb
M (L
L Ma)
# #
b(aa)

//非简单优先文法
//有两种字符的优先关系大于一 
S aAcBe
A b
A Ab
B d
# #
abbcde

//有两个文法的产生式相同 
Z bMb
Z a 
M a
M (L
L Ma)
# #
b(aa)b

结果

若输入的文法不是简单优先文法

若输入的文法是简单优先文法，开始分析字符串

接受

出错

总结：

  1. 数组要注意长度防止越界；
  2. 文法的输入有待提升其健壮性，比如当用户输入空行或非法的字符时，应提醒用户重新输入；
  3. 在使用简单优先分析法时，必须保证输入的文法是简单优先分析文法，当用户输入的文法有两个产生式的右部相同或者在分析关系表时两个字符有大于1的优先关系时，退出该程序并提示用户输入的文法不是简单优先文法。因不是简单优先算符文法，在归约时会有歧义；
  4. 在计算FIRST（LAST）集时，用变量去记录是否得到最终的FIRST（LAST）集；
  5. 在分析各个字符间的关系时，不能忘记#的优先性小于所有符号，所有符号的优先性大于#，当然这里只是对与#号有相邻关系的文法符号而言；
  6. 在分析各个字符间的关系时，同时还要看看是否已经存在不同的优先关系了，如果存在则退出该程序并提示用户输入的文法不是简单优先文法。因不是简单优先算符文法，在归约时会有歧义；
  7. 当用户输入识别的字符串后要在字符串后加入#号；
  8. 在识别字符串时要进行出错处理；
  9. 注意在归约得到非终结符号不能先将其压入栈中，而是将归约前的小于号前面的符号与归约后的非终结符去查关系表，得到比较符号，将比较符号替换原来的小于号，并将非终结符号压入栈中（即紧挨着查表得到的比较符号存放）；
  10. 归约后得到的是非终结符号，将其与小于号前面的符号进行查表，不可能查到大于符号。
m0_62806440
关注
  • 22
    点赞
  • 踩
  • 15
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
简单优先分析和算符优先分析的联系与比较
W.J.Z
09-26 5508
概述 简单优先分析的基本思想是对一个文法按照一定的原则求出该文法所有符号之间的优先关系，按照这种关系确定规约过程中的句柄。算符优先分析的基本思想是只规定算符之间的优先关系，在规约过程中只要找到可规约串就规约。 简单优先分析 1 :优先关系定义 （1）：若X优先级等于Y， 当且仅当G中含有产生式规则A-&gt;.... XY..... 。 （2）：若X优先级小于Y，当且仅当G中含有产...
简单算符优先文法分析程序（编译原理）
热门推荐
一只小菜鸟
11-28 1万+
题目                       实现算符优先文法分析程序；完成对以下表达式文法的分析程序。        G[E]:             E->E+T             E->T             T->T*F             T->F             F->(E)             F->i       优
【编译原理】第5章 自下而上的语法分析——优先分析法
小羊咩咩的博客
04-30 6434
5 自下而上的语法分析 目录一、自下而上语法分析概述二、自下而上的分析算法1、 简单优先分析优先关系2、算符优先分析 一、自下而上语法分析概述 自下而上语法分析试图将一个字符串反向规约至开始符号。 自下而上语法分析比自上而下语法分析更有效率，对语法的限制更少。 自下而上语法分析的策略：移进–规约分析； 移进就是将一个终结符推进栈 归约就是将0个或多个符号从栈中弹出，根据产生式将一个非终结...
编译原理实验Sicily--简单优先分析程序
Hickey_Chen的博客
12-29 1434
Description  输入开始符号，非终结符，终结符，产生式 输出简单优先分析过程 以简单优先算术表达式G[E]: 为例 E→E+T | E-T | A A→T T→F*T | F/T | F F→(B) | D B→E D→x | y | z Input  输入开始符号； 非终结符个数，非终结符，空格符分隔； 终结符个数，终结符，空格符分隔； 产生式的个数，各产生式的序号，产生式的...
编译原理_简单优先文法_语法分析器_Java
随笔_博客
04-24 3689
本贴完全原创 根据《编译原理》何炎祥第三版第六章语法分析器实现 原理：简单优先分析算法 语言：Java若需要查看算符优先算法，请进入主页查看https://blog.csdn.net/qq_24065713/article/details/71375421 MainMethod.java     public class MainMethod { public Str...
简单优先分析算法
04-09
简单优先分析算法，也称为简单优先文法分析或LL(k)分析，是编译器设计领域中的一个重要概念，主要用于解析程序源代码。该算法是一种自左向右扫描输入符号串，自顶向下尝试构造语法树的语法分析方法。在本教程中，...
简单优先分析法演示系统-C/C++程序设计、Qt图形化界面
09-01
2. 系统能够演示利用简单优先关系矩阵分析符号串的过程。 3. 系统用的 Qt 界面展示，较为美观。 4. 对所采用的算法、程序结构和主要函数过程以及关键变量，都进行了详细的说明。 5. 提供了关键程序的清单、源程序及...
编译原理上机实验-简单优先分析—C#[收集].pdf
10-12
《编译原理上机实验-简单优先分析—C#[收集].pdf》的实验主要围绕编译原理中的简单优先分析展开，旨在让学生理解简单优先文法分析的基础原理，并提升实际操作和团队协作的能力。实验内容包括输入或打开文法，生成...
编译原理语法分析简单优先
04-17
编译原理 语法分析 简单优先 参考清华大学出版社
编译原理课程设计简单优先文法判定和分析器的构造
06-11
这是我做的编译原理简单优先文法判定和分析器的构造。 包括第一章 概述 3 1.1 项目背景 3 1.2 设计目的 3 1.3 实验环境与开发工具 3 1.4 C++语言 4 第二章 需求分析 5 2.1 问题陈述 5 2.1.1 简单优先文法 5 2.1.2 简单优先文法的定义 6 2.1.3 简单优先文法的算法 6 2.1.4 简单优先分析法的操作步骤 6 2.2 需要完成的功能 7 2.2.1 判定输入的文法是否是简单优先文法 7 2.2.2 构造文法的简单优先关系矩阵 7 2.3 分析器的构造 7 第三章 逻辑设计 9 3.1系统的组织与基本工作流程 9 3.2 总体结构逻辑结构图 9 第思章 软件功能设计 11 4.1 软件功能分析 11 4.1.1 判定文法是否为简单优先文法 11 4.1.2 查找分析文法优先关系相等 12 4.1.3 查找分析文法中小于的关系 14 4.1.4 查找分析文法中大于的关系 15 4.1.5 构造文法的简单优先关系矩阵 16 第五章 界面设计 18 5.1用户输入文法界面 19 5.2优先矩阵的初始状态 20 5.3 文法中等于关系 21 5.4 小于关系 22 5.5 大于关系 23 5.6 优先关系矩阵 25 小结 27 参考文献 28 附录 29
编译原理简单优先文法的判定以及分析器的构造
06-11
刚做完的。简单优先文法的判定以及分析器的构造。代码可以用，但觉得不够完美，像是没有句子分析的过程。
简单的算符优先分析法
10-28
编译原理（第二版）的课后试验。很实用！！！！！
0905计算机高级语言,DOWHILE循环语句的翻译程序设计（简单优先法、输出四元式）.doc...
weixin_30133813的博客
07-25 445
Y当且仅当Y为G的终结符，G中含有形如P…QR…的产生式，其中Q，R为非终结符，且Q …X，YFirst(R)D)对任何X，若文法开始符号SX…，则##。3.1.2简单优先法的基本思想根据优先关系的定义，将简单优先文法中各文法符号之间的这种关系用一个矩阵表示，称作简单优先矩阵。PDA读入一个单词后，比较栈顶符号和该单词的优先级，若栈顶符号优先级低于该单词，继续读入；若栈顶符号优先级高于或等于读入符...
简单优先分析法
最新发布
小李学不完的博客
12-03 679
（1）X=Y:存在产生式A-->...XY...（2）X...XB...，B有限次推导出Y...（3）X>Y:存在产生式A-->...BD...，B至少一次推导出...X，D有限次推导出Y...（或者说D-->Y）在文法符号集中，任意两个符号之间最多只有一种优先关系任意两个产生式没有相同的右部 A-->a B-->a不含空产生式 A-->
编译原理实验语义分析_「编译原理」LL(1)文法分析，简单优先分析
weixin_39633455的博客
11-23 1008
首先我们来介绍一下LL(1)文法分析。LL(1)文法是一种自顶向下的分析方式，是从非终结符到终结符的分析方式，这种方式和我们之前说的LR(0)分析方式是刚好相反的，在我们使用LR(0)分析方式的时候。我们可以看到这个符号栈是由开始空的而后变为终结符之后再变为非终结符的过程。下面介绍一下用LL(1)文法进行分析句子的过程。首先要写出FIRST集和FOLLOW集。之后根据FIRST集和FOLLOW集来...
简单优先分析法演示系统——C/C++/Qt实现
Wang_Dou_Dou_的博客
09-01 1361
关键字：该系统支持通过友好的界面展示 L 关系、R 关系、L+ 关系、R+ 关系、等于关系、小于关系、大于关系和简单优先关系矩阵，并利用堆栈算法思想来分析输入的符号串，判断通过该文法能否生成该符号串。
编译原理系列之五 自底向上优先分析(1)-简单优先分析法
getianao的博客
12-03 1万+
简单优先分析法 1.基本概念 通过语法树来理解这三个概念更加简单： 文法G1[S]： S→AB A→bB A→Aa B→a B→Sb 语法树 短语：若S=*=&gt;αAδ且A=+=&gt;β，则称β是相对于非终结符A的句型αβδ的短语。 即：语法树中以非终结符的作为根的子树的叶子所组成的字符串。 如：ba是相对于非终结符A的句型AB的短语。句型baSb的短语有ba，...
算符优先分析及其简单代码实现
weixin_33696106的博客
05-29 1861
我们可以以下面的文法为例子进行算符优先分析： E→E+T|T T→T*F|F F→(E)|i FIRSTVT和LASTVT的构建 首先我们要通过文法规则来产生相应的FIRSTVT和LASTVT集，具体的构建规则如下： FIRSTVT： 　若出现 E→a... 或 E→Aa 的情况，则 a∈FIRSTVT【E】，即产生式右部的第一个终结符属于左部非终结符的FIRSTVT集 　若出现 ...
编译原理课程设计-For语句的翻译程序设计(简单优-先法、输出三地址码).docx
06-29
编译原理课程设计-For语句的翻译程序设计(简单优-先法、输出三地址码).docx

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值