实验二 自上而下的语法分析.docx
《实验二 自上而下的语法分析.docx》由会员分享，可在线阅读，更多相关《实验二 自上而下的语法分析.docx（32页珍藏版）》请在冰豆网上搜索。
实验二自上而下的语法分析
上海电力学院
编译原理
实验报告
实验题目：
自上而下的语法分析
院 系：
计算机科学与技术学院
专业年级：
20年 月 日
实验二自上而下的语法分析
一、实验目的：
通过本实验理解语法分析的作用，分析对象、分析的方式和处理的结果，是重点内容。
二、实验学时：
4学时。
三、实验内容
根据给出的简单语言的语法构成规则（见五），编制语法分析程序，要求能将词法分析输出的单词文件用给定的语法规则书写的源程序进行语法分析，输出相应的语法分析结果和错误信息。
关于错误信息：
不要求错误种类，只需给出出错位置（当前的输入符号）。
四、实验方法
递归下降法及LL
（1）分析法。
首先需手工将文法改写成LL
（1）文法。
选用递归下降法时需手工求出各个候选的首符集和非终结符号的FOLLOW集；选用LL
（1）分析法时需手工求出预测分析表。
对于整数和标识符的识别可以借助实验1。
五、文法定义
简单的表达式文法如下：
E->E+T|E-T|T
T->T*F|T/F|F
F->（E）|i
上式中，i为整数或标识符
六、程序源代码
#include
#include
#include
/*******************************************/
intcount=0;/*分解的产生式的个数*/
intnumber;/*所有终结符和非终结符的总数*/
charstart;/*开始符号*/
chartermin[50];/*终结符号*/
charnon_ter[50];/*非终结符号*/
charv[50];/*所有符号*/
charleft[50];/*左部*/
charright[50][50];/*右部*/
charfirst[50][50],follow[50][50];/*各产生式右部的FIRST和左部的FOLLOW集合*/
charfirst1[50][50];/*所有单个符号的FIRST集合*/
charselect[50][50];/*各单个产生式的SELECT集合*/
charf[50],F[50];/*记录各符号的FIRST和FOLLOW是否已求过*/
charempty[20];/*记录可直接推出^的符号*/
charTEMP[50];/*求FOLLOW时存放某一符号串的FIRST集合*/
intvalidity=1;/*表示输入文法是否有效*/
intll=1;/*表示输入文法是否为LL
（1）文法*/
intM[20][20];/*分析表*/
charchoose;/*用户输入时使用*/
charempt[20];/*求_emp（）时使用*/
charfo[20];/*求FOLLOW集合时使用*/
intin（charc,char*p）
{
inti;
if（strlen（p）==0）
return（0）;
for（i=0;;i++）
{
if（p[i]==c）
return
（1）;/*若在，返回1*/
if（i==strlen（p））
return（0）;/*若不在，返回0*/
}
}
charc（）
{
charc='A';
while（in（c,non_ter）==1）
c++;
return（c）;
}
voidrecur（char*point）
{/*完整的产生式在point[]中*/
intj,m=0,n=3,k;
chartemp[20],ch;
ch=c（）;/*得到一个非终结符*/
k=strlen（non_ter）;
non_ter[k]=ch;
non_ter[k+1]='\0';
for（j=0;j<=strlen（point）-1;j++）
{
if（point[n]==point[0]）
{/*如果‘|’后的首符号和左部相同*/
for（j=n+1;j<=strlen（point）-1;j++）
{
while（point[j]!
='|'&&point[j]!
='\0'）
temp[m++]=point[j++];
left[count]=ch;
memcpy（right[count],temp,m）;
right[count][m]=ch;
right[count][m+1]='\0';
m=0;
count++;
if（point[j]=='|'）
{
n=j+1;
break;
}
}
}
else
{/*如果‘|’后的首符号和左部不同*/
left[count]=ch;
right[count][0]='^';
right[count][1]='\0';
count++;
for（j=n;j<=strlen（point）-1;j++）
{
if（point[j]!
='|'）
temp[m++]=point[j];
else
{
left[count]=point[0];
memcpy（right[count],temp,m）;
right[count][m]=ch;
right[count][m+1]='\0';
printf（"count=%d",count）;
m=0;
count++;
}
}
left[count]=point[0];
memcpy（right[count],temp,m）;
right[count][m]=ch;
right[count][m+1]='\0';
count++;
m=0;
}
}
}
voidnon_re（char*point）
{
intm=0,j;
chartemp[20];
for（j=3;j<=strlen（point）-1;j++）
{
if（point[j]!
='|'）
temp[m++]=point[j];
else
{
left[count]=point[0];
memcpy（right[count],temp,m）;
right[count][m]='\0';
m=0;
count++;
}
}
left[count]=point[0];
memcpy（right[count],temp,m）;
right[count][m]='\0';
count++;
m=0;
}
chargrammer（char*t,char*n,char*left,charright[50][50]）
{
charvn[50],vt[50];
chars;
charp[50][50];
inti,j,k;
printf（"请输入文法的非终结符号串：
"）;
scanf（"%s",vn）;
getchar（）;
i=strlen（vn）;
memcpy（n,vn,i）;
n[i]='\0';
printf（"请输入文法的终结符号串：
"）;
scanf（"%s",vt）;
getchar（）;
i=strlen（vt）;
memcpy（t,vt,i）;
t[i]='\0';
printf（"请输入文法的开始符号：
"）;
scanf（"%c",&s）;
getchar（）;
printf（"请输入文法产生式的条数：
"）;
scanf（"%d",&i）;
getchar（）;
for（j=1;j<=i;j++）
{
printf（"请输入文法的第%d条（共%d条）产生式：
",j,i）;
scanf（"%s",p[j-1]）;
getchar（）;
}
for（j=0;j<=i-1;j++）
if（p[j][1]!
='-'||p[j][2]!
='>'）
{printf（"\ninputerror!
"）;
validity=0;
return（'\0'）;
}/*检测输入错误*/
for（k=0;k<=i-1;k++）
{/*分解输入的各产生式*/
if（p[k][3]==p[k][0]）
recur（p[k]）;
else
non_re（p[k]）;
}
return（s）;
}
voidmerge（char*d,char*s,inttype）
{/*d是目标符号串，s是源串，type＝1，源串中的‘^’一并并入目串；
type＝2，源串中的‘^’不并入目串*/
inti,j;
for（i=0;i<=strlen（s）-1;i++）
{
if（type==2&&s[i]=='^'）
;
else
{
for（j=0;;j++）
{
if（jbreak;
if（j==strlen（d））
{
d[j]=s[i];
d[j+1]='\0';
break;
}
}
}
}
}
voidemp（charc）
{/*即求所有由‘^’推出的符号*/
chartemp[10];
inti;
for（i=0;i<=count-1;i++）
{
if（right[i][0]==c&&strlen（right[i]）==1）
{
temp[0]=left[i];
temp[1]='\0';
merge（empty,temp,1）;
emp（left[i]）;
}
}
}
int_emp（charc）
{/*若能推出，返回1；否则，返回0*/
inti,j,k,result=1,mark=0;
chartemp[20];
temp[0]=c;
temp[1]='\0';
merge（empt,temp,1）;
if（in（c,empty）==1）
return
（1）;
for（i=0;;i++）
{
if（i==count）
return（0）;
if（left[i]==c）/*找一个左部为c的产生式*/
{
j=strlen（right[i]）;/*j为右部的长度*/
if（j==1&&in（right[i][0],empty）==1）
return
（1）;
elseif（j==1&&in（right[i][0],termin）==1）
return（0）;
else
{
for（k=0;k<=j-1;k++）
if（in（right[i][k],empt）==1）
mark=1;
if（mark==1）
continue;
else
{
for（k=0;k<=j-1;k++）
{
result*=_emp（right[i][k]）;
temp[0]=right[i][k];
temp[1]='\0';
merge（empt,temp,1）;
}
}
}
if（result==0&&icontinue;
elseif（result==1&&ireturn
（1）;
}
}
}
intjudge（）
{
inti,j;
for（i=0;i<=count-1;i++）
{
if（in（left[i],non_ter）==0）
{/*若左部不在非终结符中，报错*/
printf（"\nerror1!
"）;
validity=0;
return（0）;
}
for（j=0;j<=strlen（right[i]）-1;j++）
{
if（in（right[i][j],non_ter）==0&&in（right[i][j],termin）==0&&right[i][j]!
='^'）
{/*若右部某一符号不在非终结符、终结符中且不为‘^’，报错*/
printf（"\nerror2!
"）;
validity=0;
return（0）;
}
}
}
return
（1）;
}
voidfirst2（inti）
{/*i为符号在所有输入符号中的序号*/
charc,temp[20];
intj,k,m;
c=v[i];
charch='^';
emp（ch）;
if（in（c,termin）==1）/*若为终结符*/
{
first1[i][0]=c;
first1[i][1]='\0';
}
elseif（in（c,non_ter）==1）/*若为非终结符*/
{
for（j=0;j<=count-1;j++）
{
if（left[j]==c）
{
if（in（right[j][0],termin）==1||right[j][0]=='^'）
{
temp[0]=right[j][0];
temp[1]='\0';
merge（first1[i],temp,1）;
}
elseif（in（right[j][0],non_ter）==1）
{
if（right[j][0]==c）
continue;
for（k=0;;k++）
if（v[k]==right[j][0]）
break;
if（f[k]=='0'）
{
first2（k）;
f[k]='1';
}
merge（first1[i],first1[k],2）;
for（k=0;k<=strlen（right[j]）-1;k++）
{
empt[0]='\0';
if（_emp（right[j][k]）==1&&k{
for（m=0;;m++）
if（v[m]==right[j][k+1]）
break;
if（f[m]=='0'）
{
first2（m）;
f[m]='1';
}
merge（first1[i],first1[m],2）;
}
elseif（_emp（right[j][k]）==1&&k==strlen（right[j]）-1）
{
temp[0]='^';
temp[1]='\0';
merge（first1[i],temp,1）;
}
else
break;
}
}
}
}
}
f[i]='1';
}
voidFIRST（inti,char*p）
{
intlength;
intj,k,m;
chartemp[20];
length=strlen（p）;
if（length==1）/*如果右部为单个符号*/
{
if（p[0]=='^'）
{
if（i>=0）
{
first[i][0]='^';
first[i][1]='\0';
}
else
{
TEMP[0]='^';
TEMP[1]='\0';
}
}
else
{
for（j=0;;j++）
if（v[j]==p[0]）
break;
if（i>=0）
{
memcpy（first[i],first1[j],strlen（first1[j]））;
first[i][strlen（first1[j]）]='\0';
}
else
{
memcpy（TEMP,first1[j],strlen（first1[j]））;
TEMP[strlen（first1[j]）]='\0';
}
}
}
else/*如果右部为符号串*/
{
for（j=0;;j++）
if（v[j]==p[0]）
break;
if（i>=0）
merge（first[i],first1[j],2）;
else
merge（TEMP,first1[j],2）;
for（k=0;k<=length-1;k++）
{
empt[0]='\0';
if（_emp（p[k]）==1&&k{
for（m=0;;m++）
if（v[m]==right[i][k+1]）
break;
if（i>=0）
merge（first[i],first1[m],2）;
else
merge（TEMP,first1[m],2）;
}
elseif（_emp（p[k]）==1&&k==length-1）
{
temp[0]='^';
temp[1]='\0';
if（i>=0）
merge（first[i],temp,1）;
else
merge（TEMP,temp,1）;
}
elseif（_emp（p[k]）==0）
break;
}
}
}
voidFOLLOW（inti）
{
intj,k,m,n,result=1;
charc,temp[20];
c=non_ter[i];/*c为待求的非终结符*/
temp[0]=c;
temp[1]='\0';
merge（fo,temp,1）;
if（c==start）
{/*若为开始符号*/
temp[0]='#';
temp[1]='\0';
merge（follow[i],temp,1）;
}
for（j=0;j<=count-1;j++）
{
if（in（c,right[j]）==1）/*找一个右部含有c的产生式*/
{
for（k=0;;k++）
if（right[j][k]==c）
break;/*k为c在该产生式右部的序号*/
for（m=0;;m++）
if（v[m]==left[j]）
break;/*m为产生式左部非终结符在所有符号中的序号*/
if（k==strlen（right[j]）-1）
{/*如果c在产生式右部的最后*/
if（in（v[m],fo）==1）
{
merge（follow[i],follow[m],1）;
continue;
}
if（F[m]=='0'）
{
FOLLOW（m）;
F[m]='1';
}
merge（follow[i],follow[m],1）;
}
else
{/*如果c不在产生式右部的最后*/
for（n=k+1;n<=strlen（right[j]）-1;n++）
{
empt[0]='\0';
result*=_emp（right[j][n]）;
}
if（result==1）
{/*如果右部c后面的符号串能推出^*/
if（in（v[m],fo）==1）
{/*避免循环递归*/
merge（follow[i],follow[m],1）;
continue;
}
if（F[m]=='0'）
{
FOLLOW（m）;
F[m]='1';
}
merge（follow[i],follow[m],1）;
}
for（n=k+1;n<=strlen（right[j]）-1;n++）
temp[n-k-1]=right[j][n];
temp[strlen（right[j]）-k-1]='\0';
FIRST（-1,temp）;
merge（follow[i],TEMP,2）;
}
}
}
F[i]='1';
}
intll1（）
{
inti,j,length,result=1;
chartemp[50];
for（j=0;j<=49;j++）
{/*初始化*/
first[j][0]='\0';
follow[j][0]='\0';
first1[j][0]='\0';
select[j][0]='\0';
TEMP[j]='\0';
temp[j]='\0';
f[j]='0';
F[j]='0';
}
for（j=0;j<=strlen（v）-1;j++）
first2（j）;/*求单个符号的FIRST集合*/
printf（"\nfirst1:
"）;
for（j=0;j<=strlen（v）-1;j++）
printf（"%c:
%s",v[j],first1[j]）;
printf（"\nempty:
%s",empty）;
printf（"\n_emp:
"）;
for（j=0;j<=strlen（v）-1;j++）
printf（"%d",_emp（v[j]））;
for（i=0;i<=count-1;i++）
FIRST（i,right[i]）;/*求FIRST*/
for（j=0;j<=strlen（non_ter）-
升级会员 