编译原理实验报告LL1分析法Word格式文档下载.docx

编译原理实验报告LL1分析法Word格式文档下载.docx

《编译原理实验报告LL1分析法Word格式文档下载.docx》由会员分享，可在线阅读，更多相关《编译原理实验报告LL1分析法Word格式文档下载.docx（17页珍藏版）》请在冰豆网上搜索。

输出过程如下：

步骤

分析栈

剩余输入串

所用产生式

1

E

i+i*i#

E->

...

二.实验过程及结果

代码如下：

#include<

iostream>

#include"

edge.h"

usingnamespacestd;

edge:

:

edge（）

{

cin>

>

left>

right;

rlen=right.length（）;

if（NODE.find（left）>

NODE.length（））

NODE+=left;

}

stringedge:

getlf（）

returnleft;

getrg（）

returnright;

getfirst（）

returnfirst;

getfollow（）

returnfollow;

getselect（）

returnselect;

getro（）

stringstr;

str+=right[0];

returnstr;

intedge:

getrlen（）

returnright.length（）;

voidedge:

newfirst（stringw）

inti;

for（i=0;

i<

w.length（）;

i++）

if（first.find（w[i]）>

first.length（））

first+=w[i];

newfollow（stringw）

if（follow.find（w[i]）>

follow.length（）&

&

w[i]!

='

@'

）

follow+=w[i];

newselect（stringw）

if（select.find（w[i]）>

select.length（）&

select+=w[i];

delfirst（）

inti=first.find（'

）;

first.erase（i,1）;

intSUM;

stringNODE,ENODE;

//计算first

voidfirst（edgeni,edge*n,intx）

inti,j;

for（j=0;

j<

SUM;

j++）

{

if（ni.getlf（）==n[j].getlf（））

{

if（NODE.find（n[j].getro（））<

{

for（i=0;

if（n[i].getlf（）==n[j].getro（））

first（n[i],n,x）;

}

else

n[x].newfirst（n[j].getro（））;

}

}

//计算follow

voidfollow（edgeni,edge*n,intx）

inti,j,k,s;

ni.getrlen（）;

s=NODE.find（ni.getrg（）[i]）;

if（s<

NODE.length（）&

s>

-1）//是非终结符

if（i<

ni.getrlen（）-1）//不在最右

for（j=0;

if（n[j].getlf（）.find（ni.getrg（）[i]）==0）

if（NODE.find（ni.getrg（）[i+1]）<

for（k=0;

k<

k++）

if（n[k].getlf（）.find（ni.getrg（）[i+1]）==0）

{

n[j].newfollow（n[k].getfirst（））;

if（n[k].getfirst（）.find（"

@"

）<

n[k].getfirst（）.length（））

n[j].newfollow（ni.getfollow（））;

}

str.erase（）;

str+=ni.getrg（）[i+1];

n[j].newfollow（str）;

}

//计算select

voidselect（edge&

ni,edge*n）

if（ENODE.find（ni.getro（））<

ENODE.length（））

ni.newselect（ni.getro（））;

if（ni.getro（）=="

ni.newselect（ni.getfollow（））;

else

if（ni.getrg（）[i]==n[j].getlf（）[0]）

ni.newselect（n[j].getfirst（））;

if（n[j].getfirst（）.find（'

）>

n[j].getfirst（）.length（））

return;

//输出集合

voidout（stringp）

if（p.length（）==0）

return;

cout<

<

"

{"

;

p.length（）-1;

p[i]<

"

}"

//连续输出符号

voidoutfu（inta,stringc）

a;

c;

//输出预测分析表

voidoutgraph（edge*n,string（*yc）[50]）

inti,j,k;

boolflag;

ENODE.length（）;

if（ENODE[i]!

outfu（10,"

"

cout<

ENODE[i];

outfu（10,"

#"

endl;

intx;

NODE.length（）;

outfu（4,"

cout<

NODE[i];

outfu（5,"

for（k=0;

flag=1;

for（j=0;

if（NODE[i]==n[j].getlf（）[0]）

x=n[j].getselect（）.find（ENODE[k]）;

if（x<

n[j].getselect（）.length（）&

x>

-1）

{

cout<

->

n[j].getrg（）;

yc[i][k]=n[j].getrg（）;

outfu（9-n[j].getrlen（）,"

flag=0;

}

x=n[j].getselect（）.find（'

#'

if（k==ENODE.length（）-1&

x<

yc[i][j]=n[j].getrg（）;

if（flag&

ENODE[k]!

outfu（11,"

//分析符号串

intpipei（string&

chuan,string&

fenxi,string（*yc）[50],int&

b）

charch,a;

intx,i,j,k;

b++;

endl<

b;

if（b>

9）

outfu（8,"

outfu（9,"

fenxi;

outfu（26-chuan.length（）-fenxi.length（）,"

chuan;

a=chuan[0];

ch=fenxi[fenxi.length（）-1];

x=ENODE.find（ch）;

if（x<

ENODE.length（）&

if（ch==a）

fenxi.erase（fenxi.length（）-1,1）;

chuan.erase（0,1）;

'

a<

匹配"

if（pipei（chuan,fenxi,yc,b））

return1;

return0;

if（ch=='

if（ch==a）

分析成功"

else

if（ch=='

i=NODE.find（ch）;

if（a=='

x=ENODE.find（'

if（x<