编译原理语法分析算法实现Word格式.docx
《编译原理语法分析算法实现Word格式.docx》由会员分享，可在线阅读，更多相关《编译原理语法分析算法实现Word格式.docx（23页珍藏版）》请在冰豆网上搜索。
}PT[MAX_VALUE];
//定义优先关系结构体数组
structARRAY2
charVT[MAX_VALUE];
}FIRSTVT[MAX_VALUE],LASTVT[MAX_VALUE];
//FIRSTVT集合和LASTVT集合
structSElemType
typedefstruct
SElemType*base;
SElemType*top;
intstacksize;
}SqStack;
voidInitStack（SqStack&
S）//对栈进行初始化
S.base=（SElemType*）malloc（STACK_INIT_SIZE*sizeof（SElemType））;
if（!
S.base）
{
cout<
<
"
存储分配失败！
endl;
exit（0）;
}
S.top=S.base;
S.stacksize=STACK_INIT_SIZE;
}
intStackEmpty（SqStack&
S）//判断栈是否为空
if（S.top==S.base）
return0;
else
return1;
voidPush（SqStack&
S,SElemTypee）//入栈
*S.top++=e;
voidPop（SqStack&
S,SElemType&
e）//出栈，并用e返回值
栈空！
e=*--S.top;
structCSS*ReadFromFile（）
structCSS*head;
structCSS*p1,*p2;
p1=p2=（structCSS*）malloc（sizeof（structCSS））;
head=NULL;
intn=0;
FILE*fp;
charS[MAX_VALUE];
cout<
请输入文件名:
;
cin>
>
S;
if（（fp=fopen（S,"
r"
））==NULL）
Cannotopenthefile!
{//从文件中读取文法
charch=fgetc（fp）;
while（!
feof（fp））
{
inti=0;
while（ch!
=10）//为回车键时，作为一个产生式的结束
{
while（ch==32）//过滤掉空格
ch=fgetc（fp）;
p1->
s[i++]=ch;
ch=fgetc（fp）;
}
p1->
s[i]='
\0'
n=n+1;
if（n==1）
head=p1;
else
p2->
next=p1;
p2=p1;
p1=（structCSS*）malloc（sizeof（structCSS））;
ch=fgetc（fp）;
}
p2->
next=NULL;
return（head）;
structCSS*creat（）//创建结构体链表来存储输入的文法
请输入文法:
p1->
s;
while（strcmp（p1->
s,"
exit"
））
n=n+1;
if（n==1）
head=p1;
else
p2->
p2=p1;
p1=（structCSS*）malloc（sizeof（structCSS））;
cin>
p2->
return（head）;
structCSS*Select（）
structCSS*p;
读取方式:
1.从文件读取；
2.从键盘读取"
请选择:
charsLetter;
sLetter;
if（sLetter=='
1'
）
p=ReadFromFile（）;
p=creat（）;
return（p）;
voidSearch（structCSS*head）//搜索产生式中的终结符和非终结符，并分别存放到数组VT和VN中
inti;
intj=0;
intk=0;
p=head;
if（head!
=NULL）
do//对每个产生式进行扫描
{
for（i=0;
p->
s[i]!
='
i++）
if（p->
s[i]>
A'
&
&
p->
s[i]<
Z'
i==0）
{//在每个产生式开头搜索非终结符
for（intn=0;
n<
=j;
n++）//扫描VN数组,看是否已经存在该非终结符
if（p->
=VN[n]）
continue;
elsebreak;
if（p->
=VN[n]）//如果不存在，就添加该非终结符
VN[j++]=p->
s[i];
}
if（!
（p->
）&
i>
=3）
{//从->
后面开始搜索终结符
=k;
n++）//扫描VT数组,看是否已经存在该终结符
if（p->
=VT[n]）
continue;
elsebreak;
=VT[n]）//如果不存在，就添加该终结符
VT[k++]=p->
p=p->
next;
}while（p!
=NULL）;
VN[j]='
VT[k]='
voidInsert（SqStack&
S,structARRAYF[],inti,intFlag）
if（Flag==0）
if（!
F[i].value）
F[i].value=1;
SElemTypee;
e.VN=F[i].VN;
e.VT=F[i].VT;
Push（S,e）;
else
if（!
L[i].value）
L[i].value=1;
e.VN=L[i].VN;
e.VT=L[i].VT;
voidDO_FIRSTVT（structCSS*head）//求FIRSTVT集合
{
intk;
inti=0,j=0,m=0,n=0;
SqStackS;
InitStack（S）;
for（;
VN[i]!
i++）//初始化布尔数组F[A,a]
for（;
VT[j]!
j++）
F[n].VN=VN[i];
F[n].VT=VT[j];
F[n].value=0;
n++;
//计数器，统计布尔数组F[A,a]中元素的个数
j=0;
do
if（!
s[3]>
s[3]<
））//处理每个形如A->
a...的产生式
for（i=0;
i<
n;
if（F[i].VN==p->
s[0]&
F[i].VT==p->
s[3]）
break;
Insert（S,F,i,0）;
if（（p->
!
s[4]>
s[4]<
{//处理每个形如A->
Ba...的产生式
s[4]）
Insert（S,F,i,0）;
while（StackEmpty（S））
p=head;
SElemTypee;
Pop（S,e）;
if（head!
do
{
s[3]==e.VN&
s[4]=='
{
for（i=0;
if（F[i].VN==p->
F[i].VT==e.VT）
break;
p=p->
}while（p!
FIRSTVT[0].VN=F[0].VN;
for（i=0,j=0,k=0;
if（（F[i].VN==FIRSTVT[j].VN）&
（F[i].value==1））
FIRSTVT[j].VT[k++]=F[i].VT;
if（（F[i].VN!
=FIRSTVT[j].VN）&
（F[i].value==1））
j++;
k=0;
FIRSTVT[j].VN=F[i].VN;
所求每个非终结符的FIRSTVT集合如下：
for（i=0;
（signed）strlen（VN）;
FIRSTVT（"
FIRSTVT[i].VN<
）={"
FIRSTVT[i].VT<
}"
voidDO_LASTVT（structCSS*head）//求LASTVT集合
inti=0,j=0,n=0;
i++）//初始化布尔数组L[A,a]
L[n].VN=VN[i];
L[n].VT=VT[j];
L[n].value=0;
//计数器，统计布尔数组L[A,a]中元素的个数
s[strlen（p->
s）-1]>
s）-1]<
...a的产生式
if（L[i].VN==p->
L[i].VT==p->
s）-1]）
Insert（S,L,i,1）;
s）-2]>
s）-2]<
...aC的产生式
s）-2]）
if（L[i].VN==p->
L[i].VT==e.VT）
Insert（S,L,i,1）;
LASTVT[0].VN=L[0].VN;
if（（L[i].VN==LASTVT[j].VN）&
（L[i].value==1））
LASTVT[j].VT[k++]=L[i].VT;
if（（L[i].VN!
=LASTVT[j].VN）&
（L[i].value==1））
LASTVT[j].VN=L[i].VN;
所求每个非终结符的LASTVT集合如下：
LASTVT（"
LASTVT[i].VN<
LASTVT[i].VT<
voidDO_PRIORITY_TABLE（structCSS*head）//求优先关系表
if（head!
{
for（intl=0;
next!
=NULL;
p=p->
next）
for（inti=3,j=0;
j<
（signed）strlen（p->
s）-3-1;
i++,j++）
if（（!
））&
（!
s[i+1]>
s[i+1]<
）））
{//p->
s[i]和p->
s[i+1]都为终结符,置'
PT[l].VT1=p->
PT[l].VT2=p->
s[i+1];
PT[l].relation='
l++;
if（（j<
=（signed）strlen（p->
s）-3-3）&
（!
s[i+2]>
s[i+2]<
s[i+2]都为终结符,p->
s[i+1]都为非终结符置'
s[i+2];
（p->
s[i]为终结符,p->
'
for（intk=0;
k++）
if（FIRSTVT[k].VN==p->
s[i+1]）
elsecontinue;
for（intm=3,x=0;
FIRSTVT[k].VT[x]!
m++,l++）
{
PT[l].VT1=p->
PT[l].VT2=FIRSTVT[k].VT[x++];
PT[l].relation='
}
if（（p->
s[i]为非终结符,p->
s[i+1]都为终结符置'
if（LASTVT[k].VN==p->
s[i]）
for（intm=3,x=0;
LASTVT[k].VT[x]!
{
PT[l].VT1=LASTVT[k].VT[x++];
PT[l].VT2=p->
PT[l].relation='
}
算符优先关系矩阵表"
------------------------------------------------------------"
for（inti=strlen（VT）-1;
i>
=0;
i--）
\t"
VT[i];
for（i=strlen（VT）-1;
VT[i]<
for（intm=strlen（VT）-1;
m>
m--）
for（intk=0;
k<
（signed）（strlen（VT）*strlen（VT））;
if（（PT[k].VT1==VT[i]）&
（PT[k].VT2==VT[m]））
cout<
PT[k].relation<
break;
elsecontinue;
if（k==（signed）（strlen（VT）*strlen（VT）））
cout<
intk=0;
intj;
intN=1;
//归约步骤序号
staticintCurrentWith（charzf[],charzfc[]）;
char*SYSRC（charzf[],charzfc[]）//返回剩余的字符串的首地址
char*str;
str=zfc;
str=str+current+1;
returnstr;
voiddo_current（charzf[],charzfc[]）
charQ=zf[j];
if（!
（zf[j-1]>
zf[j-1]<
j=j-1;
elsej=j-2;
for（inti=0;
if（（PT[i].VT1==zf[j]）&
（PT[i].VT2==Q））
break;
elsecontinue;
if（PT[i].relation=='
）//将zf[j+1]...zf[k]归约为N
k=j+1;
zf[k]='
N'
zf[k+1]='
N
升级会员 