编译原理LL(1)文法的简单实现

最新推荐文章于 2024-01-22 21:38:22 发布
最新推荐文章于 2024-01-22 21:38:22 发布
阅读量6.7k 收藏 56
点赞数 5
分类专栏： 编译原理 文章标签： 编译原理
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_40986486/article/details/90301062
版权

LL(1)的实现：

1.输入文法

2.求first集

3.求follow集

4.求select集

5.分析串

求各个集合的过程：

1、判断各非汇总结符是否可以推出空

   （1）将各非终结符出示状态置为“未知”

   （2）按顺序扫描各产生式右部。分为下面几种情况：

        a、若遇到符号“ε”，检查左部非终结符状态，若不是“空”，将其置为“空”，继续扫描下一产生式；

        b、若遇到终结符，检查左部非终结符状态，若为“未知”，将其置为“非空”，继续扫描下一产生式；

        c、若遇到非终结符，检查该非终结符状态，若为“未知”，则跳过当前产生式，扫描下一产生式；若为“非空”，检查左部非终结符状态，若为“未知”，将其置为“非空”，继续扫描下一产生式；

若为“空”，继续扫描本产生式的下一符号；

        d、若遇到“\0”，检查左部非终结符状态，若不是“空”，将其置为“空”，继续扫描下一产生式；

        e、若上述a,b,c,d过程引起了非终结符状态的改变，则跳到(2)处继续循环，否则跳出循环，判断结束。

2、求非终结符的first集

扫描以要求first集的非终结符为左部的各产生式的右部，分为下面几种情况：

     A、若遇到终结符，将该终结符加入左部非终结符的first集，继续扫描下一产生式；

     B、若遇到符号“ε”，将“ε”加入左部非终结符的first集，继续扫描下一产生式；

  C、若遇到非终结符，将该非终结符的  first集— {ε} 加入左部非终结符的first集，然后检查该非终结符是否可以推出空，若可以为空，则扫描本产生式的下一符号；若不为空，则继续扫描下一产生式；

     D、若遇到“\0”，将“ε”加入左部非终结符的first集，继续扫描下一产生式；

3、求某一非终结符的FOLLOW集

   （1）在产生式右部找到该非终结符，扫面它后面的符号，分为下面几种情况：

   A、若是终结符，则将该终结符加入该非终结符的folow集；

   B、若是非终结符，将该非终结符的  first集— {ε} 加入该非终结符的folow集，然后检查该非终结符是否可以推出空，若可以为空，则扫描本产生式的下一符号；

   C、若是“\0”，则将该产生式的左部非终结符的follow集加入它的follow集。

   （2）在产生式的右部继续查找该非终结符，若找到，转（1）步。

4、求某产生式的select集

   扫描产生式的右部，分为下面几种情况：

  1. 若是终结符，则将该终结符加入该产生式的select集；
  2. 若是“ε”，将左部非终结符的follow集加入该产生式的select集；
  3. 若是非终结符，将该非终结符的  first集— {ε} 加入该产生式的select集，然后检查该非终结符是否可以推出空，若可以为空，则扫描本产生式的下一符号；
  4. 若是“\0”，则将该产生式的左部非终结符的follow集加入该产生式的select集。

具体实现：

#include<iostream>
#include<map>
#include<stack>
#include<unordered_map>
#include<unordered_set>
#include<string.h>
using namespace std;
char chan[100][50];
string S;
unordered_map<char,int> mp;
unordered_map<char,int> mpx;
unordered_set <char> Fir[50];
unordered_set <char> Foll[50];
unordered_set <char> Sele[50];
stack<char> st;
int fei;    //非终结符数量
int cntchan;  //产生式数量
int Cal[50][50]; //预测分析表
int f[50]; //能否推出空的标记数组
void mune();
void input();
void output();
void JudgeIsNull();
void displayNULL();
void First();
void displayFirst();
void Follow();
void displayFollow();
void Select();
void displaySele();
void Analyse();
int main()
{
	int sel;
	while(1)
	{
		mune();
		cin>>sel;
		switch(sel)
		{
			case 1:
				input();
				break;
			case 2:
				output();
				break;
			case 3:
				displayNULL();
				break;
			case 4:
				displayFirst();
				break;
			case 5:
				displayFollow();
				break;
			case 6:
				displaySele();
				break;
			case 7:
				Analyse();
				break;
		}
		system("cls");
	}

}
void mune()
{
	printf("1.输入LL(1)文法\n");
	printf("2.显示输入的LL(1)文法\n");
	printf("3.判定非终结符是否为空\n");
	printf("4.输出非终结符的First集\n");
	printf("5.输出非终结符的Follow集\n");
	printf("6.输出产生式的Sellect集\n");
	printf("7.分析过程演示\n");
}
void input()
{
	cntchan=0; //此处考虑新增产生式，而非从头开始
	system("cls");
	int n;
	int k=1;
	printf("输入文法产生式的个数:");
	cin>>n;
	printf("输入各产生式（每行一条,空用'@'表示）中间用'->'隔开，如 A->b:\n");
	for(int i=0; i<n; i++)
	{
		printf("%d) ",i);
		cin>>chan[i];
		if(!mp[chan[i][0]])
			mp[chan[i][0]]=k++;
		cntchan++;
	}
	JudgeIsNull();
	First();
	Follow();
	Select();
	system("pause");
}
void output()
{
	system("cls");
	for(int i=0; i<cntchan; i++)
		cout<<chan[i]<<endl;
	system("pause");
}
void JudgeIsNull()
{
	/*
	1、判断各非汇总结符是否可以推出空
	（1）将各非终结符出示状态置为"未知"
	（2）按顺序扫描各产生式右部。分为下面几种情况：
	    a、若遇到符号"ε"，检查左部非终结符状态，若不是"空"，将其置为"空"，继续扫描下一产生式；
	    b、若遇到终结符，检查左部非终结符状态，若为"未知"，将其置为"非空"，继续扫描下一产生式；
	    c、若遇到非终结符，检查该非终结符状态，若为"未知"，则跳过当前产生式，扫描下一产生式；若为"非空"，检查左部非终结符状态，若为"未知"，将其置为"非空"，继续扫描下一产生式；
		若为"空"，继续扫描本产生式的下一符号；
	    d、若遇到"\0"，检查左部非终结符状态，若不是"空"，将其置为"空"，继续扫描下一产生式；
	    e、若上述a,b,c,d过程引起了非终结符状态的改变，则跳到(2)处继续循环，否则跳出循环，判断结束。
	2、求非终结符的first集
	扫描以要求first集的非终结符为左部的各产生式的右部，分为下面几种情况：
	 A、若遇到终结符，将该终结符加入左部非终结符的first集，继续扫描下一产生式；
	 B、若遇到符号"ε"，将"ε"加入左部非终结符的first集，继续扫描下一产生式；
	 C、若遇到非终结符，将该非终结符的  first集- {ε} 加入左部非终结符的first集，然后检查该非终结符是否可以推出空，若可以为空，则扫描本产生式的下一符号；若不为空，则继续扫描下一产生式；
	 D、若遇到"\0"，将"ε"加入左部非终结符的first集，继续扫描下一产生式；

	*/
	//0->空  1->非空  -1->未知

	int i,j;
	for(i=1; i<=cntchan; i++)
		f[i]=-1;
	while(1)
	{
		for(i=0; i<cntchan; i++)
		{
			int indexA=mp[chan[i][0]];
			for(j=3; j<strlen(chan[i]); j++)
			{
				if(chan[i][j]=='@')
				{
					f[indexA]=0;
					break;
				}
				if(chan[i][j]<'A'||chan[i][j]>'Z')
				{
					if(f[indexA]==-1)
						f[indexA]=1;
					break;
				}
				if(chan[i][j]>='A'&&chan[i][j]<='Z')
				{
					if(f[mp[chan[i][j]]]==-1)
						break;
					if(f[mp[chan[i][j]]]==1)
					{
						if(f[indexA]==-1)
							f[indexA]=1;
						break;
					}
					else if(f[mp[chan[i][j]]]==0)
						continue;
				}
			}
			if(j==strlen(chan[i]))//  \0
				if(f[indexA]!=0)
					f[indexA]=0;
		}
		for(i=0; i<cntchan; i++)
			if(f[mp[chan[i][0]]]==-1)
				break;
		if(i==cntchan)
			break;
	}
	unordered_map<char,int> :: iterator it;
	for(it=mp.begin(); it!=mp.end(); it++)
		fei++;
}
void displayNULL()
{
	unordered_map<char,int> :: iterator it;
	for(it=mp.begin(); it!=mp.end(); it++)
		printf("%c->%d\n",it->first,f[it->second]);
	system("pause");
}
void First()
{
//	JudgeIsNull();
	/*
	2、求非终结符的first集
	扫描以要求first集的非终结符为左部的各产生式的右部，分为下面几种情况：
	 A、若遇到终结符，将该终结符加入左部非终结符的first集，继续扫描下一产生式；
	 B、若遇到符号“ε”，将“ε”加入左部非终结符的first集，继续扫描下一产生式；
	  C、若遇到非终结符，将该非终结符的  first集— {ε} 加入左部非终结符的first集，
	  然后检查该非终结符是否可以推出空，若可以为空，则扫描本产生式的下一符号；若不为空，则继续扫描下一产生式；
	 D、若遇到 “\0” ，将“ε”加入左部非终结符的first集，继续扫描下一产生式；
	*/
	int J[50];
	int i,j;
	Foll[mp[chan[0][0]]].insert('#');
	while(1)
	{
		for(i=1; i<=fei; i++)
			J[i]=Fir[i].size();
		for(i=0; i<cntchan; i++)
		{
			char left=chan[i][0];
			int indexL=mp[left];
			int len=strlen(chan[i]);
		//	Foll[indexL].insert('#');
			for(j=3; j<len; j++)
			{
				char now=chan[i][j];
				int indexR=0;
				if(now>='A'&&now<='Z')
					indexR=mp[now];
				if(now<'A'||now>'Z') //终结符 a
				{
					Fir[indexL].insert(now);
					break;
				}
				if(now=='@')
				{
					Fir[indexL].insert(now);
					break;
				}
				if(now>='A'&&now<='Z')//非终结符
				{
					if(Fir[indexR].find('@')!=Fir[indexR].end())
						Fir[indexR].erase(Fir[indexR].find('@'));
					Fir[indexL].insert(Fir[indexR].begin(),Fir[indexR].end());
					if(f[indexR]==0)
						continue;
					if(f[indexR]==1)
						break;
				}
			}
			if(j==len)	// \0
				Fir[indexL].insert('@');
		}
		int ff=0;
		for(i=1; i<=fei; i++)
			if(J[i]!=Fir[i].size())
				ff=1;
		if(ff==0)
			break;
	}
}
void displayFirst()
{
	for(auto ii : mp)
	{
		int index = ii.second;
		printf("First(%c) = { ",ii.first);
		for(auto it : Fir[index])
			printf("%c ",it);
		printf("}\n");
	}
	system("pause");
}
void Follow()
{
//	First();
	/*
	3、求某一非终结符的FOLLOW集
	（1）在产生式右部找到该非终结符，扫面它后面的符号，分为下面几种情况：
	A、若是终结符，则将该终结符加入该非终结符的folow集；
	B、若是非终结符，将该非终结符的  first集— {ε} 加入该非终结符的folow集，
		然后检查该非终结符是否可以推出空，若可以为空，则扫描本产生式的下一符号；
	C、若是“\0”，则将该产生式的左部非终结符的follow集加入它的follow集。
	（2）在产生式的右部继续查找该非终结符，若找到，转（1）步。
	*/
	int i,j;
	int J[50];
	while(1)
	{
		for(i=1; i<=fei; i++)
			J[i]=Foll[i].size();
		for(auto ii : mp)
		{
			int index = ii.second;
			char now = ii.first;
			for(i=0; i<cntchan; i++)
			{
				int len = strlen(chan[i]);
				int indexL = mp[chan[i][0]];
				int ff=0;
				for(j=3; j<len; j++)
				{
					if(ff==1||chan[i][j]==now)
					{
						char c = chan[i][j+1];
						int indexc = 0;
						if(c==0) // \0
						{
							Foll[index].insert(Foll[indexL].begin(),Foll[indexL].end());
							break;
						}
						if(c>='A'&&c<='Z') //非终结符
						{
							indexc = mp[c];
							if(Fir[indexc].find('@')!=Fir[indexc].end())
								Fir[indexc].erase(Fir[indexc].find('@'));
							Foll[index].insert(Fir[indexc].begin(),Fir[indexc].end());
							if(f[indexc] == 0)
							{
								ff=1;
								continue;
							}
							else
								break;
						}
						if(c<'A'||c>'Z')//终结符
						{
							Foll[index].insert(c);
							break;
						}
					}
				}
			}
		}
		int fff=0;
		for(i=1; i<=fei; i++)
			if(J[i]!=Foll[i].size())
				fff=1;
		if(fff==0)
			break;
	}
}
void displayFollow()
{
	for(auto ii : mp)
	{
		int index = ii.second;
		printf("Follow(%c) = { ",ii.first);
		for(auto it : Foll[index])
			printf("%c ",it);
		printf("}\n");
	}
	system("pause");
}
void Select()
{
	/*
	4、求某产生式的select集
	扫描产生式的右部，分为下面几种情况：
	(1)若是终结符，则将该终结符加入该产生式的select集；
	(2)若是“ε”，将左部非终结符的follow集加入该产生式的select集；
	(3)若是非终结符，将该非终结符的  first集— {ε} 加入该产生式的select集，
	然后检查该非终结符是否可以推出空，若可以为空，则扫描本产生式的下一符号；
	(4)若是“\0”，则将该产生式的左部非终结符的follow集加入该产生式的select集。
	*/
	int i,j,index;
	for(i=0; i<cntchan; i++)
	{
		int indexL = mp[chan[i][0]];
		int len = strlen(chan[i]);
		for(j=3; j<len; j++)
		{
			char c = chan[i][j];
			if(c=='@')
			{
				Sele[i].insert(Foll[indexL].begin(),Foll[indexL].end());
				break;
			}
			if(c <'A'||c>'Z')
			{
				printf("\n%c\n",c);
				Sele[i].insert(c);
				break;
			}
			if(c>='A'&&c<='Z')
			{
				index = mp[c];
				if(Fir[index].find('@')!=Fir[index].end())
					Fir[index].erase(Fir[index].find('@'));
				Sele[i].insert(Fir[index].begin(),Fir[index].end());
				if(f[index]==0)
					continue;
				else
					break;
			}
		}
		if(j==len)
			Sele[i].insert(Foll[indexL].begin(),Foll[index].end());
	}
}
void displaySele()
{

	for(int i=0; i<cntchan; i++)
	{
		printf("SELECT(%s)\t= { ",chan[i]);
		for(auto it : Sele[i])
			printf("%c ",it);
		printf("}\n");
	}
	system("pause");
}
void Analyse()
{
	int i,j,k=1;
	for(i=0; i<50; i++)
		for(j=0; j<50; j++)
			Cal[i][j]=-1;
	for(i=0; i<cntchan; i++)
	{
		int len=strlen(chan[i]);
		for(j=3; j<len; j++)
			if((chan[i][j]<'A'||chan[i][j]>'Z')&&!mpx[chan[i][j]])
				mpx[chan[i][j]]=k++;
	}
	mpx['#']=k;
	for(k=0; k<cntchan; k++)
	{
		int i = mp[chan[k][0]];
		for(auto ii : Sele[k])
		{
			int j = mpx[ii];
			Cal[i][j] = k;
		}
	}
	string now ;//模拟输出串
	cin>>S;
	//处理字符串，结尾加 #
	S+='#';
	//初始化栈
	now+='#';
	now+=chan[0][0];
	st.push('#');
	st.push(chan[0][0]);
	int ind = 0;
	k=1;
	printf("步骤\t分析栈\t剩余输入串\t推导产生式或匹配\n");
	while(1)
	{
		printf("%d\t",k++);
		cout<<now<<'\t'<<S.substr(ind,S.size()-ind)<<'\t'<<'\t';
		if(S[ind]!='#') //当剩余串不为空
		{
			char Top = st.top();
			char Sheng = S[ind];
			if(Top == Sheng) //匹配
			{
				printf("'%c'匹配\n",Top);
				st.pop();
				ind++;
				now = now.substr(0,now.size()-1);
				continue;
			}
			int indexT = 0;
			int indexS = 0;
			if(Top >= 'A'&& Top <= 'Z') //分析栈顶为非终结符
				indexT = mp[Top];
			else
				indexT = mpx[Top];
			if(Sheng >= 'A'&& Sheng <= 'Z') //剩余串头为非终结符
				indexS = mp[Sheng];
			else
				indexS = mpx[Sheng];
			if(Cal[indexT][indexS]==-1) //不匹配
			{
				printf("分析错误!\n");
				break;
			}
			else                    //匹配
			{
				char ss[50];
				strcpy(ss,chan[Cal[indexT][indexS]]);
				printf("%s\n",ss);
				st.pop();
				now = now.substr(0,now.size()-1);
				if(ss[strlen(ss)-1]!='@')
				{
					for(i=strlen(ss)-1; i>=3; i--)
					{
						st.push(ss[i]);
						now+=ss[i];
					}
				}
			}
		}
		else
		{
			if(st.size()!=1) //当剩余串为空，分析栈不空时
			{
				char Top = st.top();
				char Sheng = '@';

				int indexT = mp[Top];
				if(f[indexT]==0)
				{
					printf("%c->@\n",Top);
				}
				st.pop();
				now = now.substr(0,now.size()-1);
			}
			else if(st.top()==S[ind])
			{
				printf("接受\n");
				break;
			}
			else
			{
				printf("分析错误\n");
				break;
			}
		}

	}
	system("pause");
}
/*
E->TX
X->+TX
X->@
T->FY
Y->*FY
Y->@
F->i
F->(E)
*/

//  -std=c++11

 

GhostRiderQin
关注
专栏目录
编译原理LL（1）分析程序
01-03
任意给定一个上下文无关文法，通过程序计算文法所有非终结符FIRST和FOLLOW集，和每个产生式的SELECT集； 判断该文法是否为LL(1)文法； 构造相应文法的预测分析表； 基于相应文法的预测分析表，动态演示（分步）一个句子分析过程。如果报错，请提示可能的原因。参见教材P95表4.5； 设计、实现能根据分析结果（产生式序列）构建句子或者源程序的语法分析树； 如果给定的文法含有左递归，尝试对文法进行改写，消除左递归；
《编译原理》-用例题理解-自顶向下语法分析及 FIRST，FOLLOW，SELECT集，LL(1)文法
热门推荐
肖朋伟
06-06 1万+
《编译原理》-用例题理解-自顶向下语法分析及 FIRST，FOLLOW，SELECT集，LL(1)文法 本笔记是对教材《编译原理》-张晶老师版 做学习笔记。 最近在学《编译原理》，前三章感觉还可以理解，到了第四章就感觉这难度就上来了，于是想做个笔记， （一）前言 第4章 - 自顶向下的语法分析 自顶向下分析法就是从文法的开始符号出发，不断建立直接推导，试图构造一个最左推导序列，最终由它推导出与输入符号串完全匹配（相同...
编译原理习题（含答案）
rainbow14115的博客
10-09 1万+
1.【单选题】一个文法G，若( )，则称它是LL（1）文法 A、 G无二义性 B、 G中不含左递归 C、 G中产生式不含左公因子 D、 G的LL（1）分析表中不含多重定义的条目 我的答案：D 【单选题】 2.在递归子程序方法中，若文法存在左递归，则会使分析过程产生( )。 A、 回溯 B、 非法调用 C、 无限循环 D、 有限次循环 我的答案：C 3【单选题】 ...
编译原理：求非终结符的First集合
Lee.rw的博客
05-06 8646
题目目的：熟练掌握自上而下的语法分析方法，并能用程序实现。 要求： 例如. 使用的文法如下： E->TE' E'->+TE'|# T->FT' T'->*FT'|# F->(E)|id 编写First函数，实现其求解过程。 提示： 1， 非终结符为大写字母；或后面带'的大写字母 2， 终结符为 小写字母和符号（+、*）(#代表空串) 3， 推导符号为-> 4， 用end结束文法。 5，
1001. LL(1)语法分析程序
wlllssd的博客
04-12 542
Description 输入开始符号，非终结符，终结符，产生式，LL(1)分析表 输出LL(1)分析表 此题需要提交实验报告；“实验报告用“学号+姓名+72” Input 输入开始符号； 非终结符个数，非终结符，空格符分隔； 终结符个数，终结符，空格符分隔； 产生式的个数，各产生式的序号，产生式的左边和右边符号，空格符分隔； LL(1)分析表中的产生式个数，序号，行符号，列符号，产生式...
编译原理实验四LL（1）文法【C语言实现】
05-30
编译原理实验四 LL（1）文法 C 语言实现 本实验报告的主要目的是通过实现 LL（1）分析法来加深对预测分析的理解。 LL（1）分析法是一种常用的语法分析方法，它可以对输入的符号串进行自上而下的分析。 实验报告的...
编译原理实验 LL1文法分析 first集合 follow集合
05-08
语言为C++，使用了set，map容器，输入格式：S -> Aa | g | e，支持多‘|’ 符号，采用文件输入
编译原理之LL1文法的java代码实现
05-06
在编译原理中，LL1文法是一种重要的前向预测分析方法，主要用于解析程序源代码。这个实验将探讨如何使用Java语言实现一个LL1文法分析器。LL1文法的特点在于它允许编译器从左到右扫描输入，只需要查看当前符号（L）...
LL(1)文法——vc.rar_LL(1)文法_LL1 文法 实现_ll1_ll1 文法_编译原理
09-23
在本资源包中，包含了LL(1)文法的VC实现，对于学习编译原理和理解LL(1)文法的实践操作具有极大的帮助。 首先，我们来详细探讨LL(1)文法的概念。LL(1)中的"L"表示自左至右扫描输入，"L"后的第一个"1"表示在做解析...
编译原理大作业 LL(1)文法.zip
07-21
编译原理大作业 LL（1）文法实现完整代码 + 报告 ！！！ 求出能推出ε的非终结符、计算FIRST集、计算FOLLOW集、计算SELECT集、构造预测分析表、判断LL(1)文法 1. 给定无左递归和无回溯的文法，计算FIRST集合和...
LL(1)词法分析程序
New Day New Plan
01-27 3099
程序功能： 一、LL(1)文法合法性的判断 包括： 1.      非终结符是否可以退出空 2.      表达式是否退出空 3.      非终结符的First集合 4.      表达式的First集合 5.      非终结符的Follow集合 6.      Select集合 7.      是否符合LL(1)文法 二、主控程序，判断句子是否符合当前文法 1.
LL（1）文法分析代码
朱发财的博客
05-28 5759
11、判断各非汇总结符是否可以推出空 （1）将各非终结符出示状态置为“未知” （2）按顺序扫描各产生式右部。分为下面几种情况： a、若遇到符号“ε”，检查左部非终结符状态，若不是“空”，将其置为“空”，继续扫描下一产生式； b、若遇到终结符，检查左部非终结符状态，若为“未知”，将其置为“非空”，继续扫描下一产生式； c、若遇到非...
编译原理实验：ll（1）文法分析
Believer_YU的博客
07-13 3175
编译原理实验，实现ll（1）文法分析的过程
LL(1)型文法的改造及预测分析（实验）
张居然的博客
10-15 1799
α可以看出，在结果中一定有一个β，并且β的位置排在第一个，然后后面紧跟着n个α，从这可以看出有两部分，一部分是β的，一部分是n个α的，然后给大家看一下消除左递归等价变换的例子。'，这个符号的是或的意思，也就是说A既可以推出Aα，也可以推出β，如果不使该文法陷入死循环，那么该文法的最后一个推导一定是A -> β，因为只有进行到A -> β，推导才会结束，因为推导时，只能选择Aα和β这两者中的一个，没有被选择的将会被抛弃。在拿到我们自己的文法后，首先要对自己的文法进行LL(1)型判别，判别的方法有以下两种。
《编译原理》：LL(1)语法分析设计实现
最新发布
weixin_61248653的博客
01-22 2515
《编译原理》：LL(1)语法分析设计实现
编译原理：LL(1)、LR(0)、SLR(1)分析（大招）
weixin_57165154的博客
04-25 2296
编译原理重点学习
编译原理简易LL(1)分析器自动生成程序
hhypractise的博客
07-05 1783
设计并编写一个根据文法自动生成LL(1)分析器的程序，理解文法回溯等现象在LL分析中的不良影响，掌握FIRST集、FOLLOW集的定义和计算方法，掌握LL（1）分析器的工作原理和实现方法。 设计思想 （1）first集的算法思想 1.如果产生式右部第一个字符为终结符，则将其计入左部first集 2.如果产生式右部第一个字符为非终结符执行以下步骤 2.1.求该非终结符的first集 2.2.将该非终结符的非first集计入左部的first集2.3若存在first集计入左部的first集 2.3若存在first
语法设计——基于LL(1)文法的预测分析表法
weixin_33701251的博客
01-04 4877
实验二、语法设计——基于LL(1)文法的预测分析表法 一、实验目的 通过实验教学，加深学生对所学的关于编译的理论知识的理解，增强学生对所学知识的综合应用能力，并通过实践达到对所学的知识进行验证。通过对基于LL(1)文法的预测分析表法DFA模拟程序实验，使学生掌握确定的自上而下的语法分析的实现技术，及具体实现方法。通过本实验加深对语词法分析程序的功能及实现方法的理解 。 二、实验环境 供Window...
编译原理：LL(1)文法分析与代码生成
"该资源为编译原理课程的LL(1)文法分析课件，包含第八章关于代码生成的内容，讲解了目标机器的地址模式、指令系统、基本块、程序流图，以及代码生成器设计的问题和指令选择。课件还列举了一些典型指令的示例，如取、...
评论 4
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值