编译原理实验报告FIRST集与FOLLOW集.docx
《编译原理实验报告FIRST集与FOLLOW集.docx》由会员分享，可在线阅读，更多相关《编译原理实验报告FIRST集与FOLLOW集.docx（13页珍藏版）》请在冰豆网上搜索。
编译原理实验报告FIRST集与FOLLOW集
编译原理实验报告
实验名称计算first集合和follow集合
实验时间
院系计算机科学与技术
班级软件工程1班
学号
姓名
1.实验目的
输入：
任意的上下文无关文法。
输出：
所输入的上下文无关文法一切非终结符的first集合和follow集合。
2.实验原理
设文法G[S]＝（VN，VT，P，S），则首字符集为：
FIRST（α）＝{a|α
aβ，a∈VT，α,β∈V*}。
若α
ε，ε∈FIRST（α）。
由定义可以看出，FIRST（α）是指符号串α能够推导出的所有符号串中处于串首的终结符号组成的集合。
所以FIRST集也称为首符号集。
设α＝x1x2…xn，FIRST（α）可按下列方法求得：
令FIRST（α）＝Φ，i＝1；
（1）若xi∈VT，则xi∈FIRST（α）；
（2）若xi∈VN；
①若ε
FIRST（xi），则FIRST（xi）∈FIRST（α）；
②若ε∈FIRST（xi），则FIRST（xi）－{ε}∈FIRST（α）；
（3）i＝i+1，重复
（1）、
（2），直到xi∈VT，（i＝2，3，…，n）或xi∈VN且若ε
FIRST（xi）或i>n为止。
当一个文法中存在ε产生式时，例如，存在A→ε，只有知道哪些符号可以合法地出现在非终结符A之后，才能知道是否选择A→ε产生式。
这些合法地出现在非终结符A之后的符号组成的集合被称为FOLLOW集合。
下面我们给出文法的FOLLOW集的定义。
设文法G[S]＝（VN，VT，P，S），则
FOLLOW（A）＝{a|S
…Aa…，a∈VT}。
若S
…A，#∈FOLLOW（A）。
由定义可以看出，FOLLOW（A）是指在文法G[S]的所有句型中，紧跟在非终结符A后的终结符号的集合。
FOLLOW集可按下列方法求得：
（1）对于文法G[S]的开始符号S，有#∈FOLLOW（S）；
（2）若文法G[S]中有形如B→xAy的规则，其中x，y∈V*，则FIRST（y）－{ε}∈FOLLOW（A）；
（3）若文法G[S]中有形如B→xA的规则，或形如B→xAy的规则且ε∈FIRST（y），其中x，y∈V*，则FOLLOW（B）∈FOLLOW（A）；
3.实验内容
计算first集合和follow集合
4.实验心得
通过上机实验我对文法符号的FIRST集和FOLLOW集有了更深刻的理解，已经熟练的掌握了求解的思想和方法，同时也锻炼了自己的动手解决问题的能力，对编程能力也有所提高。
5.实验代码与结果
#include
#include
#include
usingnamespacestd。
#defineMAXS50
intNONE[MAXS]={0}。
stringstrings。
//产生式
stringVn。
//非终结符
stringVt。
//终结符
stringfirst[MAXS]。
//用于存放每个终结符的first集
stringFirst[MAXS]。
//用于存放每个非终结符的first集
stringFollow[MAXS]。
//用于存放每个非终结符的follow集
intN。
//产生式个数
structSTR
{
stringleft。
stringright。
}。
//求VN和VT
voidVNVT（STR*p）
{
inti,j。
for（i=0。
ii++）
{
for（j=0。
j<（int）p[i].left.length（）。
j++）
{
if（（p[i].left[j]>='A'&&p[i].left[j]<='Z'））
{
if（Vn.find（p[i].left[j]）>100）
Vn+=p[i].left[j]。
}
else
{
if（Vt.find（p[i].left[j]）>100）
Vt+=p[i].left[j]。
}
}
for（j=0。
j<（int）p[i].right.length（）。
j++）
{
if（!
（p[i].right[j]>='A'&&p[i].right[j]<='Z'））
{
if（Vt.find（p[i].right[j]）>100）
Vt+=p[i].right[j]。
}
else
{
if（Vn.find（p[i].right[j]）>100）
Vn+=p[i].right[j]。
}
}
}
}
voidgetlr（STR*p,inti）
{
intj。
for（j=0。
jj++）
{
if（strings[j]=='-'&&strings[j+1]=='>'）
{
p[i].left=strings.substr（0,j）。
p[i].right=strings.substr（j+2,strings.length（）-j）。
}
}
}
//对每个文法符号求first集
stringLetter_First（STR*p,charch）
{
intt。
if（!
（Vt.find（ch）>100））
{
first[Vt.find（ch）]="ch"。
returnfirst[Vt.find（ch）-1]。
}
if（!
（Vn.find（ch）>100））
{
for（inti=0。
ii++）
{
if（p[i].left[0]==ch）
{
if（!
（Vt.find（p[i].right[0]）>100））
{
if（First[Vn.find（ch）].find（p[i].right[0]）>100）
{
First[Vn.find（ch）]+=p[i].right[0]。
}
}
if（p[i].right[0]=='*'）
{
if（First[Vn.find（ch）].find（'*'）>100）
{
First[Vn.find（ch）]+='*'。
}
}
if（!
（Vn.find（p[i].right[0]）>100））
{
if（p[i].right.length（）==1）
{
stringff。
ff=Letter_First（p,p[i].right[0]）。
for（inti_i=0。
i_ii_i++）
{
if（First[Vn.find（ch）].find（ff[i_i]）>100）
{
First[Vn.find（ch）]+=ff[i_i]。
}
}
}
else
{
for（intj=0。
jj++）
{
stringTT。
TT=Letter_First（p,p[i].right[j]）。
if（!
（TT.find（'*'）>100）&&（j+1）{
sort（TT.begin（）,TT.end（））。
stringtt。
for（intt=1。
tt++）
{
tt+=TT[t]。
}
TT=tt。
tt=""。
for（t=0。
tt++）
{
if（First[Vn.find（ch）].find（TT[t]）>100）
{
First[Vn.find（ch）]+=TT[t]。
}
}
}
else
{
for（t=0。
tt++）
{
if（First[Vn.find（ch）].find（TT[t]）>100）
{
First[Vn.find（ch）]+=TT[t]。
}
}
break。
}
}
}
}
}
}
returnFirst[Vn.find（ch）]。
}
}
//求每个非终结符的Follow集
stringLetter_Follow（STR*p,charch）
{
intt,k。
NONE[Vn.find（ch）]++。
if（NONE[Vn.find（ch）]==2）
{
NONE[Vn.find（ch）]=0。
returnFollow[Vn.find（ch）]。
}
for（inti=0。
ii++）
{
for（intj=0。
jj++）
{
if（p[i].right[j]==ch）
{
if（j+1==p[i].right.length（））
{
stringgg。
gg=Letter_Follow（p,p[i].left[0]）。
NONE[Vn.find（p[i].left[0]）]=0。
for（intk=0。
kk++）
{
if（Follow[Vn.find（ch）].find（gg[k]）>100）
{
Follow[Vn.find（ch）]+=gg[k]。
}
}
}
else
{
stringFF。
for（intjj=j+1。
jjjj++）
{
stringTT。
TT=Letter_First（p,p[i].right[jj]）。
if（!
（TT.find（'*'）>100）&&（jj+1）{
sort（TT.begin（）,TT.end（））。
stringtt。
for（intt=1。
tt++）
{
tt+=TT[t]。
}
TT=tt。
tt=""。
for（t=0。
tt++）
{
if（FF.find（TT[t]）>100&&TT[t]!
='*'）
{
FF+=TT[t]。
}
}
}
else
{
for（t=0。
tt++）
{
if（FF.find（TT[t]）>100）
{
FF+=TT[t]。
}
}
break。
}
}
if（FF.find（'*'）>100）
{
for（k=0。
kk++）
{
if（Follow[Vn.find（ch）].find（FF[k]）>100）
{
Follow[Vn.find（ch）]+=FF[k]。
}
}
}
else
{
for（k=0。
kk++）
{
if（（Follow[Vn.find（ch）].find（FF[k]）>100）&&FF[k]!
='*'）
{
Follow[Vn.find（ch）]+=FF[k]。
}
}
stringdd。
dd=Letter_Follow（p,p[i].left[0]）。
NONE[Vn.find（p[i].left[0]）]=0。
for（k=0。
kk++）
{
if（Follow[Vn.find（ch）].find（dd[k]）>100）
{
Follow[Vn.find（ch）]+=dd[k]。
}
}
}
}
}
}
}
returnFollow[Vn.find（ch）]。
}
voidresult（）
{
cout<<"\n该文法不是LL
（1）型文法"<}
//主函数
intmain（）
{
inti,j,k。
cout<<"请输入产生式总数:
"。
cin>>N。
cout<<"\n请输入各产生式（*代表空）:
"<STR*p=newSTR[MAXS]。
for（i=0。
ii++）
{
cin>>strings。
getlr（p,i）。
}
VNVT（p）。
cout<cout<<"\n========================================="<cout<<"非终结符"<<"\t"<<"FIRST"<<"\t\t"<<"FOLLOW"<for（i=0。
ii++）
{
cout<<""<stringpp。
pp=Letter_First（p,Vn[i]）。
for（j=0。
j+1j++）
{
cout<}
cout<Follow[0]+='#'。
cout<<"{"。
stringppp。
ppp=Letter_Follow（p,Vn[i]）。
for（k=0。
k+1k++）
{
cout<}
cout<}
result（）。
cout<<"\n========================================="<return0。
}
升级会员 