编译课程设计递归下降语法分析Word文档下载推荐.docx
《编译课程设计递归下降语法分析Word文档下载推荐.docx》由会员分享，可在线阅读，更多相关《编译课程设计递归下降语法分析Word文档下载推荐.docx（23页珍藏版）》请在冰豆网上搜索。
s.top--;
4.intIsEmpty（charstacks）
{//判断栈是否为空
if（s.top==-1）
return1;
elsereturn0;
5.intIsLetter（charch）
{//判断是否为非终结符
if（ch>
='
A'
&
ch<
Z'
）
elsereturn0;
6.intjudge1（intn）
{//judge1是判断是否是算符文法：
若产生式中含有两个相继的非终结符则不是算符文法
7.voidjudge2（intn）
{//judge2是判断文法G是否为算符优先文法：
若不是算符文法或若文法中含空字或终结符的优先级不唯一则不是算符优先文法
8.intsearch1（charr[],intkk,chara）
{//search1是查看存放终结符的数组r中是否含有重复的终结符}
9.voidcreateF（intn）
{//createF函数是用F数组存放每个终结符与非终结符和组合，并且值每队的标志位为0;
F数组是一个结构体}
10.voidsearch（charLodew）
{//search函数是将在F数组中寻找到的终结符与非终结符对的标志位值为1}
分情况讨论：
//产生式的后选式的第一个字符就是终结符的情况
//产生式的后选式的第一个字符是非终结符的情况
11.voidLastVT（intn）
{//求LastVT
12.voidFirstVT（intn）
{//求FirstVT
13.voidcreateYXB（intn）
{//构造优先表
//优先级等于的情况，用1值表示等于}
//优先级小于的情况，用2值表示小于
//优先级大于的情况，用3值表示大于
14.intjudge3（chars,chara）
{//judge3是用来返回在归约过程中两个非终结符相比较的值
15.voidprint（chars[],charSTR[][20],intq,intu,intii,intk）
{//打印归约的过程}
16.voidprocess（charSTR[][20],intii）
{//对输入的字符串进行归约的过程
四、设计结果
分两大类，四种不同的情况
第一类情况：
产生式的候选式以终结符开始候选式以终结符开始经过存在递归式的非终结符后再以终结符结束
第二类情况：
产生式的候选式是两个或以上的非终结符
五、设计总结与心得
通过对语法分析的实践操作，对它在实践中的应用有了更深刻的理解，通过上机实践，提高了从错误中分析问题，解决问题的能力。
在实践的基础上，把所学的知识得到了实际应用，通过本次的编译原理课程设计，让我对用C++编程的大致思路又进行了一次回顾，设计一个可运行的程序代码的思路规范，声明变量，定义各大需要调用的函数及其调用。
在这个实验的过程中，如何运用栈，指针来达到判断是否是算符优先文法的规约的目的，当然其中也设计了多个供调用的函数，声明了多个变量，锻炼了思维逻辑能力，同时在和同学的探讨下锻炼了我的发现问题分析问题的能力。
六、程序完整代码
#include<
iostream.h>
string.h>
stdio.h>
typedefstruct
{
charR;
charr;
intflag;
}array;
typedefstruct
charE;
chare;
}charLode;
charLode*base;
inttop;
}charstack;
charstr[80][80],arr[80][80],brr[80][80];
arrayF[20];
intm,kk,p,ppp,FF=1;
charr[10];
intcrr[20][20],FLAG=0;
charccrr1[1][20],ccrr2[20][1];
voidInitstack（charstack&
s）{
voidpush（charstack&
voidpop（charstack&
intIsEmpty（charstacks）
intIsLetter（charch）
intjudge1（intn）
intj=3,flag=0;
for（inti=0;
i<
=n;
i++）
while（str[i][j]!
\0'
{
chara=str[i][j];
charb=str[i][j+1];
if（IsLetter（a）&
IsLetter（b））
{flag=1;
break;
elsej++;
if（flag==1）
return0;
else
voidjudge2（intn）
if（str[i][3]=='
~'
||judge1（n）==0||FLAG==1）//'
代表空字
{cout<
<
"
文法G不是算符优先文法!
endl;
FF=0;
if（i>
n）
cout<
文法G是算符优先文法!
intsearch1（charr[],intkk,chara）
kk;
if（r[i]==a）
break;
if（i==kk）return0;
elsereturn1;
voidcreateF（intn）
intk=0,i=1;
charg;
chart[10];
//t数组用来存放非终结符
t[0]=str[0][0];
while（i<
=n）
if（t[k]!
=str[i][0]）
{k++;
t[k]=str[i][0];
g=t[k];
i++;
elsei++;
kk=0;
charc;
for（i=0;
{intj=3;
c=str[i][j];
if（IsLetter（c）==0）
if（!
search1（r,kk,c））
r[kk]=c;
kk++;
//r数组用来存放终结符
j++;
m=0;
k;
for（intj=0;
j<
kk-1;
j++）
F[m].R=t[i];
F[m].r=r[j];
F[m].flag=0;
m++;
voidsearch（charLodew）
m;
if（F[i].R==w.E&
F[i].r==w.e）
{F[i].flag=1;
voidFirstVT（intn）{
charstacksta;
charLodew;
inti=0;
Initstack（sta）;
intk=3;
w.E=str[i][0];
chara=str[i][k];
charb=str[i][k+1];
IsLetter（a））{
w.e=a;
push（sta,w）;
search（w）;
i++;
elseif（IsLetter（a）&
b!
!
IsLetter（b））{
w.e=b;
charLodeww;
while（!
IsEmpty（sta））
pop（sta,ww）;
for（i=0;
if（str[i][3]==ww.E&
str[i][4]=='
w.e=ww.e;
p=0;
intk=1;
i=1;
m）
if（F[i-1].flag==1）
arr[p][0]=F[i-1].R;
arr[p][k]=F[i-1].r;
while（F[i].flag==0&
if（F[i].flag==1）
if（F[i].R==arr[p][0]）
k++;
else{arr[p][k+1]='
;
p++;
k=1;
}
voidLastVT（intn）{
F[i].flag=0;
i=0;
intk=strlen（str[i]）;
chara=str[i][k-1];
charb=str[i][k-2];
IsLetter（a））
charLodeee;
pop（sta,ee）;
if（str[i][3]==ee.E&
w.e=ee.e;
ppp=0;
brr[ppp][0]=F[i-1].R;
brr[ppp][k]=F[i-1].r;
if（F[i].R==arr[ppp][0]）
else{brr[ppp][k+1]='
ppp++;
voidcreateYXB（intn）
inti,j;
for（j=1;
=kk;
ccrr1[0][j]=r[j-1];
for（i=1;
ccrr2[i][0]=r[i-1];
for（i=1;
crr[i][j]=0;
intI=0,J=3;
while（I<
if（str[I][J+1]=='
{I++;
J=3;
while（str[I][J+1]!
charaa=str[I][J];
charbb=str[I][J+1];
IsLetter（aa）&
IsLetter（bb））
{
for（i=1;
if（ccrr2[i][0]==aa）
if（ccrr1[0][j]==bb）
if（crr[i][j]==0）
crr[i][j]=1;
else{FLAG=1;
I=n+1;
J++;
IsLetter（bb）&
str[I][J+2]!
IsLetter（str[I][J+2]））{
for（intj=1;
{if（ccrr1[0][j]==str[I][J+2]）
IsLetter（bb））{
{if（aa==ccrr2[i][0]）
for（j=0;
=p;
{if（bb==arr[j][0]）
for（intmm=1;
arr[j][mm]!
mm++）
for（intpp=1;
pp<
pp++）
if（ccrr1[0][pp]==arr[j][mm]）
if（crr[i][pp]==0）
crr[i][pp]=2;
if（IsLetter（aa）&
if（ccrr1[0][i]==bb）
=ppp;
if（aa==brr[j][0]）
brr[j][mm]!
if（ccrr2[pp][0]==brr[j][mm]）
if（crr[pp][i]==0）
crr[pp][i]=3;
intjudge3（chars,chara）
inti=1,j=1;
while（ccrr2[i][0]!
=s）
if（crr[i][j]==3）return3;
while（ccrr1[0][j]!
=a）
elseif（crr[i][j]==2）
return2;
elseif（crr[i][j]==1）
voidprint（chars[],charSTR[][20],intq,intu,intii,intk）{
cout<
u<
"
=k;
s[i];
for（i=q;
=ii;
STR[0][i];
voidprocess（charSTR[][20],intii）//对输入的字符串进行归约的过程
{
步骤"
符号栈"
输入串"
动作"
intk=0,q=0,u=0,b,i,j;
chars[40],a;
s[k]='
#'
print（s,STR,q,u,ii,k）;
预备"
k++;
u++;
s[k]=STR[0][q];
q++;
移进"
while（q<
=ii）
a=STR[0][q];
IsLetter（s[k]））j=k;
elsej=k-1;
b=judge3（s[j],a）;
if（b==3）//大于的情况进行归约
while（IsLetter（s[j-1]））
j--;
for（i=j;
s[i]='
k=j;
N'
print（s,STR,q,u,ii,k）;
归约"
elseif（b==2||b==1）//小于或等于的情况移进
s[k]=a;
u++;
q++;
if（s[0]=='
s[1]=='
s[2]=='
接受"
elsecout<
else
出错"
if（s[0]=='
归约成功"
elsecout<
归约失败"
voidmain（）
intn,i,j;
请输入你要定义的文法G的产生式的个数n:
cin>
>
n;
gets（str[i]）;
j=strlen（str[i]）;
str[i][j]='
str[i][0]='
Q'
str[i][1]='
-'
str[i][2]='
'
str[i][3]='
str[i][4]=str[0][0];
str[i][5]='
str[i][6]='
你定义的产生式如下:
str[i]<
if（judge1（n）==0）//判断文法G是否为算符文法
文法G不是算符文法!
if（judge1（n）==1）
文法G是算符文法!
createF（n）;
FirstVT（n）;
LastVT（n）;
createYXB（n）;
judge2（n）;
//判断文法G是否为算符优先文法
if（FLAG==0）
i++）//打印FirstVT
FirstVT（"
arr[i][0]<
）={"
for（intl=1;
arr[i][l+1]!
l++）
arr[i][l]<
"
}"
FirstVT（Q）={#}"
i++）//打印LastVT
LastVT（"
brr[i][l+1]!
brr[i][l]<
LastVT（Q）={#}"
优先表如下:
i++）//打印优先关系表
ccrr1[0][i];
ccrr2[i][0]<
elseif（crr[i][j]==1）
="
elseif（crr[i][j]==2）
elseif（crr[i][j]==3）
升级会员 