LL(1)词法分析程序

最新推荐文章于 2024-05-25 20:20:30 发布
最新推荐文章于 2024-05-25 20:20:30 发布
阅读量3k 收藏 13
点赞数 1
分类专栏： 编译原理 文章标签： iterator string struct 测试 c
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/dingyaguang117/article/details/7216475
版权

程序功能：

一、LL(1)文法合法性的判断

包括：

1.      非终结符是否可以退出空

2.      表达式是否退出空

3.      非终结符的First集合

4.      表达式的First集合

5.      非终结符的Follow集合

6.      Select集合

7.      是否符合LL(1)文法

二、主控程序，判断句子是否符合当前文法

1.      预测分析表

2.      语法分析程序


特别说明：

(1)    求First集合的时候，并没有使用递归，只是不断的重复扫描，直到集合不再增大。

(2)    求Follow集合的时候使用了递归。

 

#include <iostream>
#include <string>
#include <cstring>
#include <vector>
#include <cstdio>
#include <map>
#include <stack>
#include <set>
#include <algorithm>

using namespace  std;

struct NT
{
	char m_name;
	int m_isE;
	int m_F_num;
	bool m_flag;
	set<char> FirstSet;
	set<char> FollowSet;

	NT():m_isE(0),m_flag(false),m_F_num(0){};
	NT(char c):m_name(c),m_isE(0),m_flag(false),m_F_num(0){};
};
struct T
{
	char m_name;
	int m_isE;
	bool m_flag;
	
	T():m_isE(0),m_flag(false){};
	T(char c):m_name(c),m_isE(0),m_flag(false){};
};
struct FORMULA
{
	char m_L;
	string m_R;
	int m_isE;
	bool m_flag;

	set<char> SelectSet;
	set<char> FirstSet;

	FORMULA():m_isE(0),m_flag(false){}
};

//全局变量

int FormulaNumber;
vector<NT> NTs;
vector<T>  Ts;
vector<FORMULA> Fs;
FORMULA *AnalysisTable;
map<char,int> GetId;		//获取非终结符的下标
map<char,int> GetId2;
char Start;
FILE* FP;

void readNT()
{
	string s;
	int i;
	cin>>s;
	for (i=0;i<s.size();++i)
	{
		NTs.push_back(NT(s[i]));
		//建立非终结符下标映射
		GetId.insert(map<char,int>::value_type(s[i],GetId.size()));
	}
}
void readT()
{
	string s;
	int i;
	cin>>s;
	for (i=0;i<s.size();++i)
	{
		Ts.push_back(T(s[i]));
		//建立终结符下标映射
		GetId2.insert(map<char,int>::value_type(s[i],GetId2.size()));
	}
}
void readFormula()
{
	int i;
	string s;
	char c;
	FORMULA f;
	for (i=0;i<FormulaNumber;++i)
	{
		cin>>f.m_L>>c>>c;
		cin>>f.m_R;
		NTs[GetId[f.m_L]].m_F_num++;
		Fs.push_back(f);
	}
}

bool isNT(char c)
{
	int i;
	for (i=0;i<NTs.size();++i)
	{
		if (NTs[i].m_name == c)
		{
			return true;
		}
	}
	return false;
}
bool isT(char c)
{
	int i;
	for (i=0;i<Ts.size();++i)
	{
		if (Ts[i].m_name == c)
		{
			return true;
		}
	}
	return false;	
}

void printFormula()
{
	int i;
	cout<<"Formula:"<<endl;
	for (i=0;i<Fs.size();++i)
	{
		cout<<Fs[i].m_L<<"->"<<Fs[i].m_R<<endl;
	}
}
//是否推出空
void DoIfIsE()
{
	int i;
	int done=0;
	while (done<NTs.size())
	{
		
		for (i=0;i<Fs.size();++i)
		{
			//处理过,或者已经推导出结果 跳过
			if(Fs[i].m_flag || NTs[GetId[Fs[i].m_L]].m_isE!=0)
			{
				continue;
			}
			
			//推出空
			if (Fs[i].m_R=="&")
			{
				NTs[GetId[Fs[i].m_L]].m_isE = 1;
				//标记处理过
				Fs[i].m_flag = true;
				done++;
			}
			//推出终结符 T
			else if (isT(Fs[i].m_R[0]))
			{
				//标记处理过
				Fs[i].m_flag = true;
				//NTs[i]的待处理 产生式-1
				if ((--NTs[GetId[Fs[i].m_L]].m_F_num)==0)
				{
					//所有产生式被删除
					NTs[GetId[Fs[i].m_L]].m_isE = -1;
					done++;
				}
			}
			//推出终结符 NT
			else
			{
				int k;
				bool flag=true;
				bool allempty=true;
				for (k=0;k<Fs[i].m_R.size();++k)
				{
					if (NTs[GetId[Fs[i].m_R[k]]].m_isE==0)
					{
						flag=false;
						break;
					}
					if (NTs[GetId[Fs[i].m_R[k]]].m_isE==-1)
					{
						allempty=false;
					}
				}
				
				if (!flag)
				{
					continue;
				}
				if (allempty)
				{
					Fs[i].m_flag =true;
					NTs[GetId[Fs[i].m_L]].m_isE = 1;
					done++;
				}else
				{
					Fs[i].m_flag =true;
					NTs[GetId[Fs[i].m_L]].m_isE = -1;
					done++;
					
				}
			}
		}
	}

	
	
	cout<<"推空:"<<endl;
	for (i=0;i<NTs.size();++i)
	{
		cout<<NTs[i].m_name<<"\t "<<NTs[i].m_isE<<endl;
		
	}
}
//表达式右侧是否空
void DoFormulaisE()
{
	int i,j;
	bool flag;
	for (i=0;i<Fs.size();++i)
	{
		if (Fs[i].m_R[0]=='&')
		{
			Fs[i].m_isE=1;
			continue;
		}
		flag=true;
		for (j=0;j<Fs[i].m_R.size();++j)
		{
			//if (Fs[i].m_R[j]<='z' && Fs[i].m_R[j]>='a')
			if (isT(Fs[i].m_R[j]))
			{
				flag=false;
				break;
			}else if(NTs[GetId[Fs[i].m_R[j]]].m_isE==-1)
			{
				flag=false;
				break;
			}
		}
		if (flag)
		{
			Fs[i].m_isE=1;
		}else
			Fs[i].m_isE=-1;
	}
	for (i=0;i<Fs.size();++i)
	{
		cout<<Fs[i].m_L<<"->"<<Fs[i].m_R<<"\t "<<Fs[i].m_isE<<endl;

	}
}

//获取终结符 NTchar 当前的first集合内容
string getFirst(char NTchar)
{
	set<char>::iterator it,itend;
	string r;

	it=NTs[GetId[NTchar]].FirstSet.begin();
	itend=NTs[GetId[NTchar]].FirstSet.end();
	while (it!=itend)
	{
		r+=*it;
		it++;
	}
	return r;
}
void printFirstSet()
{
	int i;
	cout<<"FirstSet:"<<endl;
	for(i=0;i<NTs.size();++i)
	{
		cout<<NTs[i].m_name<<"\t: ";
		if (NTs[i].m_isE==1) cout<<'&';
		cout<<getFirst(NTs[i].m_name)<<endl;
	}
	cout<<endl;
}
void DoGetFirstSet()
{
	int i;
	for (i=0;i<Fs.size();++i)
	{
		Fs[i].m_flag=0;
	}

	vector<FORMULA> FF(Fs.begin(),Fs.end());
	
	while (true)
	{
		//f表示是否 未更新
		bool f=true;
		//遍历每个 表达式
		for (i=0;i<FF.size();++i)
		{
			//可以跳过的
			if (FF[i].m_flag) continue;

			//如果表达式右边第一个是非终结符
			if(FF[i].m_R[0]=='&')
			{
				FF[i].m_flag=true;
				continue;
			}
			//if (FF[i].m_R[0]<='z' && FF[i].m_R[0]>='a' )
			if (isT(FF[i].m_R[0]) )
			{
				FF[i].m_flag=true;
				NTs[GetId[FF[i].m_L]].FirstSet.insert(FF[i].m_R[0]);
				f=false;
				continue;
			}
			
			int k;//遍历 FF[i] 右侧所有符号
			for (k=0;k<FF[i].m_R.size();++k)
			{
				//如果是终结符 结束
				//if (FF[i].m_R[k]<='z' && FF[i].m_R[k]>='a')
				if (isT(FF[i].m_R[k]))
				{
					//FF[i].m_flag=true;
					if(NTs[GetId[FF[i].m_L]].FirstSet.insert(FF[i].m_R[k]).second)
						f=false;
					break;
				}
				
				//如果是非终结符，获取此非终结符的 fitsrt
				string r=getFirst(FF[i].m_R[k]);
				int j;
				for (j=0;j<r.size();++j)
				{
					if (NTs[GetId[FF[i].m_L]].FirstSet.insert(r[j]).second)
						f=false;
				}
				//如果此非终结符 不能推出空 则结束右侧的查找
				if (NTs[GetId[FF[i].m_R[k]]].m_isE==-1)
					break;
	
			}
		}
		//printFirstSet();
		//集合未更新 退出
		if (f)
		{
			break;
		}
	}
	
	printFirstSet();
}

//合并集合
void unionSet(set<char> &a,set<char> &b)
{
	set<char>::iterator it=b.begin();
	while (it!=b.end())
	{
		a.insert(*it);
		++it;
	}
}
set<char> getFollow(char NTchar)
{
	int i,j,k;
	set<char> R=NTs[GetId[NTchar]].FollowSet;

	//遇到递归标记返回
	if (NTs[GetId[NTchar]].m_flag)
	{
		return R;
	}
	//递归标记
	NTs[GetId[NTchar]].m_flag=true;
	//搜索所有表达式
	for (i=0;i<Fs.size();++i)
	{
		bool flag=true;
	/*	if (NTs[GetId[Fs[i].m_L]].m_flag)
		{
			continue;
		}*/
		//搜索表达式中的非终结符
		for (j=0;j<Fs[i].m_R.size();++j)
		{
			//如果找到，搜索 后面的非终结符
			if (Fs[i].m_R[j]==NTchar)
			{
				for (k=j+1;k<Fs[i].m_R.size();++k)
				{
					
					//if (Fs[i].m_R[k]<='z'&&Fs[i].m_R[k]>='a')
					if (isT(Fs[i].m_R[k]) )
					{
						R.insert(Fs[i].m_R[k]);
						flag=false;
						break;
					}
					unionSet(R,NTs[GetId[Fs[i].m_R[k]]].FirstSet);
					if (NTs[GetId[Fs[i].m_R[k]]].m_isE==-1)
					{
						flag=false;
						break;
					}	
				}
				if (flag)
				{
					unionSet(R,getFollow(Fs[i].m_L));
				}
				break;
			}
		}
	}
	NTs[GetId[NTchar]].m_flag=false;
	return R;
}

void printFollowSet()
{


	int i,j;
	cout<<"FollowSet:"<<endl;
	for (i=0;i<NTs.size();++i)
	{
		set<char>::iterator it;
		it=NTs[i].FollowSet.begin();
		cout<<NTs[i].m_name<<"\t: ";
		while (it!=NTs[i].FollowSet.end())
		{
			cout<<*it;
			++it;
		}
		cout<<endl;
	}
}

void DoGetFollowSet()
{
	

	//初始化 非终结符的 递归标记
	int p;
	for (p=0;p<NTs.size();++p)
	{
		NTs[p].m_flag=false;
	}

	NTs[GetId[Start]].FollowSet.insert('#');
	while (true)
	{
		bool f=true;
		//cout<<"done one time"<<endl;
		int i;
		for (i=0;i<NTs.size();++i)
		{
			set<char> R=getFollow(NTs[i].m_name);
			set<char>::iterator it=R.begin();
			while (it!=R.end())
			{
				if (NTs[i].FollowSet.insert(*it).second)	//更新成功
				{
					f=false;
				}
				++it;
			}
		}
		if (f)
		{
			break;
		}
	}
	printFollowSet();
}

void DoGetFormulaFirstSet()
{
	int i,j;
	//遍历所有表达式
	for (i=0;i<Fs.size();++i)
	{
		//跳过空
		if (Fs[i].m_R[0]=='&')
		{
			continue;
		}
		//遍历表达式右边 
		for (j=0;j<Fs[i].m_R.size();++j)
		{
			//如果是终结符，加入first 结束
			//if (Fs[i].m_R[j]<='z'&& Fs[i].m_R[j]>='a')
			if (isT(Fs[i].m_R[j]) )
			{
				Fs[i].FirstSet.insert(Fs[i].m_R[j]);
				break;
			}else
			{
				unionSet(Fs[i].FirstSet,NTs[GetId[Fs[i].m_R[j]]].FirstSet);
			}
			//不能推出空 结束
			if (NTs[GetId[Fs[i].m_R[j]]].m_isE == -1)
			{
				break;
			}
		}
		
	}
	//输出。
	cout<<"Formula FirstSet:"<<endl;
	for (i=0;i<Fs.size();++i)
	{
		set<char>::iterator it=Fs[i].FirstSet.begin();

		cout<<Fs[i].m_L<<"->"<<Fs[i].m_R<<" \t: ";
		if (Fs[i].m_isE==1)
		{
			cout<<'&';
		}
		while (it!=Fs[i].FirstSet.end())
		{
			cout<<*it;
			++it;
		}
		cout<<endl;
	}
}

bool cmp(const FORMULA &a,const FORMULA &b)
{
	return a.m_L<b.m_L;
}

bool IsLL1()
{
	bool charHash[256]={0};
	char preChar=0;
	//拷贝一份 表达式集
	vector<FORMULA> FF(Fs.begin(),Fs.end());
	int i;
	//按照左部字典序排序
	sort(FF.begin(),FF.end(),cmp);
	for (i=0;i<FF.size();++i)
	{
		//左部不同 清空 hash数组
		if (FF[i].m_L!=preChar)
		{
			memset(charHash,0,sizeof(charHash));
		}
		preChar=FF[i].m_L;
		//开始比较
		set<char>::iterator it=FF[i].SelectSet.begin();
		while (it!=FF[i].SelectSet.end())
		{
			if (charHash[*it])
			{
				return false;
			}else
				charHash[*it]=1;
			it++;
		}
	}
	return true;
}

void DoGetSelectSet()
{
	int i;

	for (i=0;i<Fs.size();++i)
	{
		unionSet(Fs[i].SelectSet,Fs[i].FirstSet);
		if (Fs[i].m_isE==1)
		{
			unionSet(Fs[i].SelectSet,NTs[GetId[Fs[i].m_L]].FollowSet);
		}
	}

	cout<<"SelectSet:"<<endl;
	for (i=0;i<Fs.size();++i)
	{
		set<char>::iterator it=Fs[i].SelectSet.begin();

		cout<<Fs[i].m_L<<"->"<<Fs[i].m_R<<" \t: ";
		while (it!=Fs[i].SelectSet.end())
		{
			cout<<*it;
			++it;
		}
		cout<<endl;
	}


}

void DoGetAnalysisTable()
{
	int i;
	Ts.push_back(T('#'));
	GetId2.insert(map<char,int>::value_type('#',GetId2.size()));
	AnalysisTable = new FORMULA[NTs.size()*(Ts.size()+1)];

	for (i=0;i<Fs.size();++i)
	{
		set<char>::iterator it=Fs[i].SelectSet.begin();
		while (it!=Fs[i].SelectSet.end())
		{
			AnalysisTable[Ts.size()*GetId[Fs[i].m_L]+GetId2[*it]]=Fs[i];
			++it;
		}
	}

}
FORMULA AnalysisTableAt(char NTchar,char Tchar)
{
	return AnalysisTable[Ts.size()*GetId[NTchar]+GetId2[Tchar]];
}
FORMULA AnalysisTableAt(int i,int j)
{
	return AnalysisTable[Ts.size()*i+j];
}
void printAnalysisTable()
{
	int i,j;
	for (i=0;i<(Ts.size()+1)*9;++i) cout<<"=";
	cout<<endl<<"|     |";
	for (i=0;i<Ts.size();++i) cout<<"   "<<Ts[i].m_name<<"   |";
	cout<<endl;
	for (i=0;i<NTs.size();++i)
	{
		cout<<"| "<<NTs[i].m_name<<"   |";
		for (j=0;j<Ts.size();++j)
		{
			printf("%5s  |",AnalysisTableAt(i,j).m_R.c_str());
		}
		cout<<endl;
	}
	for (i=0;i<(Ts.size()+1)*9;++i) cout<<"=";
	cout<<endl;
}


void DoMainControl()
{
	char S[1001];
	string ss;
	vector<char> ST;
	int it=0,n=1,i;
	cout<<"请输入分析串：(长度小于1000)"<<endl;
	//fflush(stdin);
	cin>>ss;
	cout<<ss<<endl;
	ss+='#';
	//cout<<ss<<endl;
	strcpy(S,ss.c_str());
	for (i=0;i<(Ts.size()+1)*9;++i) cout<<"=";
	cout<<endl;
	ST.push_back('#');
	ST.push_back(Start);
	

	while (true)
	{
		if (*ST.rbegin()=='#' && S[it]=='#')
		{
			cout<<n++<<"\t";
			for (i=0;i<ST.size();++i)cout<<ST[i];
			cout<<"\t\t"<<S+it<<"\t\t"<<"分析成功"<<endl;
			break;
		}
		if (isT(*ST.rbegin()))
		{
			if (*ST.rbegin()==S[it])
			{
				cout<<n++<<"\t";
				for (i=0;i<ST.size();++i)cout<<ST[i];
				cout<<"\t\t"<<S+it<<"\t\t"<<S[it]<<"匹配"<<endl;
				it++;ST.pop_back();
				continue;
			}else
			{
				cout<<"不匹配"<<endl;
				break;
			}

		}
		FORMULA f=AnalysisTableAt(*ST.rbegin(),S[it]);
		if (f.m_R=="&")
		{
			cout<<n++<<"\t";
			for (i=0;i<ST.size();++i)cout<<ST[i];
			cout<<"\t\t"<<S+it<<"\t\t"<<f.m_L<<"->"<<f.m_R<<endl;
			ST.pop_back();
			it++;
			continue;
		}
		else
		{
			cout<<n++<<"\t";
			for (i=0;i<ST.size();++i)cout<<ST[i];
			printf("\t\t%s",S+it);
			cout<<"\t\t"<<f.m_L<<"->"<<f.m_R<<endl;
			
			ST.pop_back();
			for (i=f.m_R.size()-1;i>=0;--i) ST.push_back(f.m_R[i]);
		}
	}

}
int main()
{
	string s;
	int i;
	cout<<"1.文件输入"<<endl;
	cout<<"2.手动输入"<<endl;
	cin>>i;
	if (i==1)
	{
		cout<<"请输入文件名"<<endl;
		cin>>s;
		FP=freopen(s.c_str(),"r",stdin);
		readNT();
		readT();
		cin>>Start;
		cin>>FormulaNumber;
		readFormula();
	}
	else
	{	
		cout<<"请输入非终结符:";
		readNT();
		cout<<"请输入非终结符:";
		readT();
		cout<<"请输入开始符号:";
		cin>>Start;
		cout<<"请输入产生式数:";
		cin>>FormulaNumber;
		readFormula();
	}
	
	printFormula();
	DoIfIsE();
	DoFormulaisE();
	DoGetFirstSet();
	DoGetFormulaFirstSet();
	DoGetFollowSet();
	DoGetSelectSet();
	if (IsLL1())
	{
		cout<<"=======此文法符合LL(1)文法========"<<endl;
		DoGetAnalysisTable();
		printAnalysisTable();
		DoMainControl();
	}else
	{
		cout<<"=======此文法不符合LL(1)文法========"<<endl;
		DoGetAnalysisTable();
		printAnalysisTable();
	}

}

第一个测试数据







第一个测试数据









dingyaguang117
关注
  • 1
    点赞
  • 踩
  • 13
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
LL（1）文法分析代码
朱发财的博客
05-28 5754
11、判断各非汇总结符是否可以推出空 （1）将各非终结符出示状态置为“未知” （2）按顺序扫描各产生式右部。分为下面几种情况： a、若遇到符号“ε”，检查左部非终结符状态，若不是“空”，将其置为“空”，继续扫描下一产生式； b、若遇到终结符，检查左部非终结符状态，若为“未知”，将其置为“非空”，继续扫描下一产生式； c、若遇到非...
编译原理LL（1）分析程序
01-03
任意给定一个上下文无关文法，通过程序计算文法所有非终结符FIRST和FOLLOW集，和每个产生式的SELECT集； 判断该文法是否为LL(1)文法； 构造相应文法的预测分析表； 基于相应文法的预测分析表，动态演示（分步）一个句子分析过程。如果报错，请提示可能的原因。参见教材P95表4.5； 设计、实现能根据分析结果（产生式序列）构建句子或者源程序的语法分析树； 如果给定的文法含有左递归，尝试对文法进行改写，消除左递归；
1001. LL(1)语法分析程序
wlllssd的博客
04-12 539
Description 输入开始符号，非终结符，终结符，产生式，LL(1)分析表 输出LL(1)分析表 此题需要提交实验报告；“实验报告用“学号+姓名+72” Input 输入开始符号； 非终结符个数，非终结符，空格符分隔； 终结符个数，终结符，空格符分隔； 产生式的个数，各产生式的序号，产生式的左边和右边符号，空格符分隔； LL(1)分析表中的产生式个数，序号，行符号，列符号，产生式...
【编译原理】LL(1)预测分析法
最新发布
记录我的学习历程
05-25 843
确定的自顶向下分析思想是指自顶向下地对输入串进行分析，在每一步都根据当前的符号栈顶符号和输入串的当前符号，在分析表中查找所用产生式，然后将产生式右部的符号依次推入符号栈中，直到符号栈中只剩下底符号和输入串中所有符号都被读入为止。为了降低实现的难度，本实验只要求实现步骤（3）的部分，即手动实现步骤（1）和（2），然后依据步骤（2）建立的分析表编写一个总控程序，实现的句子的分析。读取文件内容和预测分析的时间复杂度主要取决于文法的长度和输入长度，通常为 O(m), 其中 m 为文法或输入的长度。
检查非终结符能否推导出空(epsilon)
04-09
检查文法，分析每个非终结符是否能推导出空(epsilon)
LL（1）文法解析
qq_44791528的博客
06-17 3451
一、 问题描述 给定上下文无关文法，对其进行解析，得出first集和follow集。在有能力的情况下，可以求出LL（1）分析表。 二、 算法设计 本程序主要分成三块内容，第一是文法的读入解析，第二是first集的求解，第三为follow集的求解。 文法的解析需要根据整行读入的文法，生成rulelist 表，存储文法的左部和右部，num为产生式的条数。Start list表存储非终结符，startnum为非终结符个数，endlist存储终结符，endnum为终结符个数。 First集求解过程伪代码： Firs
C语言词法分析程序(编译原理)
06-21
总之，本项目提供的“C语言词法分析程序”旨在让学生或开发者深入理解编译原理，通过实际操作学习词法分析的过程。这不仅有助于提升编程技能，也能增强对底层语言机制的理解，为将来设计更复杂的编译器或解析器打下...
一个小语言的词法分析程序原理及其实现.zip_词法分析_词法分析程序
09-24
在这个名为"一个小语言的词法分析程序原理及其实现.zip"的压缩包中，包含了一个关于词法分析的详细讲解以及可能的源代码实现。 词法分析，也称为扫描或Tokenization，其主要任务是读取源代码，识别并提取出符合语法...
编译原理LL1词法分析器.rar_LL1 词法分析_LL1分析程序_编译原理LL1_编译程序
09-22
《深入理解LL1词法分析器的实现》 在编程语言的世界里，编译器扮演着至关重要的角色，它是连接高级语言与机器语言的桥梁。其中，词法分析是编译器的第一步，它将源代码分解成一个个有意义的符号，为后续的语法分析...
词法分析与语法分析程序设计
10-31
词法分析与语法分析程序设计 词法分析是编译器前端的重要组件之一，它负责将源代码转换为词法单元序列，以便于后续的语法分析和中间代码生成。词法分析器读入输入串，将其转换成将被语法分析器分析的词法单元序列。...
LL1文法识别 词法分析程序 编译原理程序
06-16
这个程序是利用C++语言实现的，旨在帮助理解和学习编译原理中的词法分析和语法分析过程。 词法分析是编译器的第一步，它将源代码文本转换成一系列有意义的符号或标记（tokens）。在这个程序中，词法分析部分采用了...
LL(1)预测语法分析器
06-01
LL(1)预测语法分析器 LL(1)预测语法分析器 LL(1)预测语法分析器 LL(1)预测语法分析器
LL(1)文法的实现
06-22
用C++实现LL（1）文法，程序虽然简单，但是很好的体现了编译原理中算法的精髓
编译原理中LL(1)文法求FIRST集和FOLLOW集的方法
热门推荐
datoucaiyy的专栏
12-08 1万+
一、求FIRST集 1、右部首个字符是终结符则加入左部字符的FIRST集中，比如对形如U－>a…的产生式（其中a是终结符），把a收入到First(U)中。 2、右部首个字符是非终结符， 若此非终结符能推出空字符，则把它的FIRST集传送到左部字符的FIRST集中，*   若此非终结符后是终结符，则把此终结符加入到左部字符的FIRST集中，同时推导结束；   若此非终结符后是非终结符，
编译原理—实验三 LL(1)语法分析（二）
顾道长生的科研笔记
05-10 4027
实验三 LL(1)语法分析（二）（2学时） 一、实验目的 1．熟悉LL(1)语法分析的基本原理，语法分析的过程，以及语法分析中要注意的一些问题。 2. 复习高级语言及线性表、栈、图等典型数据结构，进一步加强用高级语言来解决实际问题的能力。 二、实验内容 将实验二编写的程序的基础之上，实现下面的功能： 按照教材5.2节算法，求出各个非终结符的first集和follow集并采用适当的数据结构存储，并...
编译原理LL(1)文法的简单实现
蒟蒻达的博客
05-17 6774
LL(1)的实现： 1.输入文法 2.求first集 3.求follow集 4.求select集 5.分析串 求各个集合的过程： 1、判断各非汇总结符是否可以推出空 （1）将各非终结符出示状态置为“未知” （2）按顺序扫描各产生式右部。分为下面几种情况： a、若遇到符号“ε”，检查左部非终结符状态，若不是“空”，将其置为“空”，继续扫描下一产生式； ...
编译原理LL（1）文法-判断，first，follow，select，分析字符串
weixin_43864170的博客
06-02 3300
编译原理LL（1）文法-判断，first，follow，select，分析字符串 好久不更新了，U盘格式化了，之前的代码都丢了，诶，好久了才想起来有个CSDN还没更新过，以后会坚持更新的，这次先挂上LLI文法吧，之后补上之前总结的算法，之后的内容大都是跟着课堂的，然后再根据自己跟大佬自学的东西，进行更新吧 —————————————————————————————————————————— 这是实...
编译原理 LL(1)文法判别 python实现
qq_43853047的博客
05-19 1619
上下文无关文法的输入与存储 按文法的四元组输入，用list存储，其中每个产生式用tuple保存，然后存在list中。 list：可以存储任意类型，同时可以通过下表索引 set：非常方便的实现判重，同时可以实现很多集合运算，轻松实现first、follow和select的存储运算 tuple：数据不能修改，可以通过下表索引，用来存储产生式，同时可以作为dict的键来索引（list不能作为dict的键） 求出能推出空的非终结符 ...
7-1 LL(1)分析-判断非终结符是否可以推出空
qq_62052130的博客
05-08 353
PTA测试题LL(1)分析-判断非终结符是否可以推出空
S语言词法分析程序C实现与解析
"这篇资源是关于S语言的词法分析程序的C代码实现，以及相关的S语言编译和说明。程序定义了一个`token`结构体用于表示识别出的单词符号，包括序号、名字、机内码和地址。此外，还提供了一些S语言源程序的例子和对应的...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值