编译原理实验报告3.docx

编译原理实验报告3.docx

《编译原理实验报告3.docx》由会员分享，可在线阅读，更多相关《编译原理实验报告3.docx（26页珍藏版）》请在冰豆网上搜索。

编译原理实验报告3

实验三词法分析一一有穷自动机的应用

实验目的：

一：

输入正则文法

二：

FA

1.生成FA（DFA或NFA）

2.运行FADFA（自动）；NFA（交互）

3.**NFA—DFA

实验设想：

对输入的文法存储并判断是确定的有穷状态自动机还是不确定是有

穷状态自动机，并给出标准的表示形式，若是DFA，可直接测试一

个符号串是否是文法的句子，即能否被有穷状态机接受，给出过程

及结果；若是NFA，首先将其转化为DFA，再测试一个符号串是否是文法的句子，亦即是否能被DFA接受。

例如：

输入文法规则的数目：

7

输入开始状态：

S

输入文法Z:

:

=ZaZ:

:

=BbZ:

:

=AaB:

:

=AbB:

:

=bA:

:

=BaA:

:

=a

此为确定有穷状态自动机！

DFAD=（{Z,A,B},{a,b},M,S,{Z}）

其中M:

M（Z,a）=Z

M（B,b）=Z

M（B,a）=A

M（A,a）=Z

M（A,b）=B

M（S,b）=B

M（S,a）=A

输入要推导的符号串:

ababaa

M（S,ababaa）

=M（M（S,a）,babaa）

=M（A,babaa）

=M（M（A,b）,abaa）

=M（B,abaa）

=M（M（B,a）,baa）

=M（A,baa）

=M（M（A,b）,aa）

=M（B,aa）

=M（M（B,a）,a）

=M（A,a）

=Z

该符号串能被有穷状态所接受！

输入文法规则的数目：

7

输入开始状态：

S

B:

:

=b

输入规则：

Z:

:

=AbZ:

:

=BaZ:

:

=ZcA:

:

=BaA:

:

=aB:

:

=Ab

文法规则存储完毕！

此为非确定有穷状态自动机！

NFAN=（{Z,B,A},{b,a,c},M,{S},{Z}）

其中M:

M（A,a）=$

M（A,b）={Z,B}

M（A,c）=$

M（B,a）={Z,A}

M（B,b）=$

M（B,c）=$

M（Z,a）=$

M（Z,b）=$

M（Z,c）={Z}

M（S,a）={A}

M（S,b）={B}

M（S,c）=$

将NFA转化为DFA!

DFAN'=（{[S],[B],[A],[AZ],[BZ],[Z]},{[b],[a],[c]},M',[S],F'）

其中M':

M'（[S],b）=[B]

M'（[S],a）=[A]

M'（[B],a）=[AZ]

M'（[A],b）=[BZ]

M'（[AZ],b）=[BZ]

M'（[AZ],c）=[Z]

M'（[BZ],a）=[AZ]

M'（[BZ],c）=[Z]

M'（[Z],c）=[Z]其中F'={[AZ],[BZ],[Z]}输入要推导的字符串:

ababc

M'（[S],ababc）=M'（M'（[S],a）,babc）=M'（[A],babc）=M'（M'（[A],b）,abc）=M'（[BZ],abc）=M'（M'（[BZ],a）,bc）=M'（[AZ],bc）=M'（M'（[AZ],b）,c）=M'（[BZ],c）=[Z]

[Z]属于终止状态集合！

该字符串能被有穷状态所接受

实验结果:

7

abah曰**zB-AAh-BTn=-三=--==

szzzBBAA

一屉£]赶；□皿d血a屉!

JRdEi

:

法规则存储完毕¥

此为确定有穷状态自动机，

DFA

箕中Fl：

M=Z

M=Z

M=A

M=Z

M=B

MCS.h>=B

M-n

生危fa请

退出请捋m请输入要推导的符号串:

ababaaMC£rababaa>=MCM,habaa>=M^lbaa>=MCB.abaa>=M.baa5=MCArbaa）-rKM,aa>=M

=M

競符号串能被有穷状态所接受*

7

bacab

8ABzBaAb-一=一=■一一一一s

数gZ:

Z:

Z:

A:

A:

B:

B;w则则则则则则则

—f畐m-劈___鸟-a_=&g^

生遽巒

运行m请按2退岀雷霽一

花为非确定有穷状态自动机？

UFAH-«Z,B.A>.,M.,

Mnpn：

n=$

M=$

tt=$

M=$

n=

HCE,a>-

M=n=$将NPA转牝为DFfHDFAN1=«[SJ,LB],Eft],[AZ],LBZJ,tai,Lc]>,MJ,[S],FJ>

其中护:

C[Sl,b>=*[B]

HJC[B],a>-CAZl

MJ=EBZJ

NJ=[ZJ

M1=tAZJ

NJC[BZl,c>-rZl

mj=iZ]

其中F，=<[fiZJ,LBZJ,czn

生成曲

f青输入要推导的字符串=ababc

NfC[S],abalK>

=MJ,babc>

-Mf<[A],babc>

=MJ,abc>

WIB却“be〉

=MJ

MJ.c>

=MJ

-[Z]

参考程序

#include

#include

structLeftitem;

structRightNode//存储状态转换关系中弧与终止状态结点结构

{

chartran;

charnextstate;

RightNode*nextsibling;

RightNode（charx,chary）

{

tran=x;nextstate=y;nextsibling=NULL;

}

};

structLeftitem//存储状态转换关系中初始状态结点结构

{

charstate;

RightNode*link;

};

〃存放确定化的NFA状态结点结构

structStateitem

{

charnewstates[10];

Stateitem（）

{

newstates[0]='\0';

}

};

//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////intCheckState（LeftltemArray[],intsize）

{

RightNode*p;

RightNode*q;

for（inti=0;i

{

p=Array[i].link;

q=p->nextsibling;if（q==NULL）return1;while（q!

=NULL）

{

if（p_>tran==q_>tran）return0;q=q->nextsibling;

}

}

return1;

}intCheckExist（StateltemSArray[],int&length,chartemp[]）

//将NFA确定化创建二维矩阵时判别新产生的状态是否在状态数组中存储过

{

inti=0,k,m;

while（i<=length）

{

if（strlen（SArray[i].newstates）==strlen（temp））

{

if（strcmp（SArray[i].newstates,temp）==0）

{

k=i;

break;

}

}

i++;

}

if（i>length）

{

length++;

m=length;

returnm;

}

else

returnk;

}

intgetcount1（LeftltemArray[],intsize）//取得FA中状态的个数

{

chartemp[20];

intlen=0,count=0;

inti,j;

RightNode*pNode;

for（i=0;i

{

pNode=Array[i].link;

while（pNode）

{

for（j=0;j

if（pNode->nextstate==temp[j]）break;

if（j==len）

{

count++;

temp[len]=pNode->nextstate;

len++;

}

pNode=pNode->nextsibling;

}

}

returncount;

}

intgetcount2（LeftltemArray[],intsize）//取得FA中输入字母的个数

{

chartemp[20];

intlen=0,count=0;

inti,j;

RightNode*pNode;

for（i=0;i

{

pNode=Array[i].link;

while（pNode）

{

for（j=0;j

if（pNode->tran==temp[j]）break;

if（j==len）

{

count++;

temp[len]=pNode->tran;

len++;

}

pNode=pNode->nextsibling;

}

}

returncount;

}

intgetstate（RightNode*pNode,chararc）〃判定一个状态是否能通过一条弧进入下一状态

{

while（pNode）

{

if（pNode->tran==arc）return1;

pNode=pNode->nextsibling;

}

return0;

}

voidSort（charA[],intn）//将取得的新状态进行排序

{

for（inti=n_1;i>0;i__）

for（intj=O;j

{

if（A[j+1]

{

chartemp=A[j+1];

A[j+1]=A[j];

A[j]=temp;

}

}

}

voidBianli1（LeftltemArray[],intsize）〃输出FA中有穷非空的状态集合

{

chartemp[20];

intlen=0;

inti,j;

RightNode*pNode;

for（i=0;i

{

pNode=Array[i].link;

while（pNode）

{

for（j=0;j

if（pNode->nextstate==temp[j]）break;

if（j==len）

{

if（len==0）cout«pNode->nextstate;

else

coutnextstate;

temp[len]=pNode->nextstate;

len++;

}

pNode=pNode->nextsibling;

}

voidBianli2（LeftltemArray[],intsize）

〃输岀FA中有穷的输入字母表

{

chartemp[20];

intlen=0;

inti,j;

RightNode*pNode;

for（i=0;i

{

pNode=Array[i].link;

while（pNode）

{

for（j=0;j

if（pNode->tran==temp[j]）break;

if（j==len）

{

if（len==0）cout«pNode->tran;else

couttran;

temp[len]=pNode->tran;len++;

}pNode=pNode->nextsibling;

}

}

}voidBianli31（LeftItemArray[],intsize）

〃输岀DFA状态转换关系的集合M{

inti;

RightNode*pNode;

for（i=0;i

{

pNode=Array[i].link;

while（pNode!

=NULL）

{

coutvv"M（"vtran

vv"）="vvpNode->nextstate

pNode=pNode->nextsibling;

}

}

voidBianli32（LeftltemArray[],intsize）〃输出NFA状态转换关系集合M

{

charK[20];

intlen=0;

inti,j;

RightNode*pNode;

RightNode*qNode;

for（i=0;i

{

pNode=Array[i].link;

while（pNode）

{

for（j=0;j

if（pNode->tran==K[j]）break;

if（j==len）

{

K[len]=pNode->tran;

len++;

}

pNode=pNode->nextsibling;

}

}

Sort（K,len）;

for（i=0;i

{

for（j=0;j

{

pNode=Array[i].link;

cout«"M（"v

if（getstate（pNode,K[j]））

{

cout<<"{";

while（pNode）

{

if（pNode->tran==K[j]）

{

qNode=pNode->nextsibling;

cout«pNode->nextstate;

break;

}

pNode=pNode->nextsibling;

while（qNode）

{

if（qNode->tran==K[j]）

coutnextstate;

qNode=qNode->nextsibling;

}

cout

}

else

coutvv"$"vvendl;

}

}

}

TArray[]

voidlnitiate（LeftltemArray[],intsize,charTArray[]）〃将FA中的输入字母表存入数组

{

intlen=0;

inti,j;

RightNode*pNode;

for（i=0;ivsize;i++）

{

pNode=Array[i].link;

while（pNode）

{

for（j=0;jvlen;j++）

if（pNode->tran==TArray[j]）break;

if（j==len）

{

TArray[len]=pNode->tran;

len++;

}

pNode=pNode->nextsibling;

}

}

}voidGetState（LeftltemArray[],intsize,charnstate[],chararc,chartemp[]）//将NFA确定化创建二维矩阵时取得新状态

{

inti=0;

while（nstate[i]!

='\0'）

{

for（intj=0;jvsize;j++）

{

if（Array[j].state==nstate[i]）

{

RightNode*p=Array[j].link;

while（p!

=NULL）

{

if（p_>tran==arc）

{

intk=0;

while（temp[k]!

='\0'）

{

if（p->nextstate==temp[k]）break;k++;

}

if（temp[k]=='\0'）

{

temp[k]=p->nextstate;

temp[k+1]='\0：

}

}

p=p->nextsibling;

}

}

}

i++;

}

}voidChange（StateltemSArray[],chartemp[],int&length,intMArray[][20],intindex,inti）

//取得新状态后对状态数组以及状态转换矩阵进行对应变化

{

intk;

if（temp[0]!

='\0'）

{

k=CheckExist（SArray,length,temp）;

MArray[index][i]=k;

if（k==length）

strcpy（SArray[length].newstates,temp）;

}

}

charFindNewState（LeftltemArray[],intsize,charS,chararc）//得到当前状态的下一状态

{

inti;

for（i=0;i

{

if（Array[i].state==S）

{

RightNode*p=Array[i].link;

while（p!

=NULL）

{

if（p_>tran==arc）returnp->nextstate;p=p->nextsibling;

}

}

}

returnNULL;

//取得输入字母在字母表中的下表

}intFindy（charTArray[],chars）

{

inti=0;

while（TArray[i]!

='\0'）

{

if（TArray[i]==s）returni;i++;

}

}voidCreateFA1（LeftltemArray[],intsize,charstart,charend）

//根据输入文法创建FA{

if（CheckState（Array,size））

{

coutvv"此为确定有穷状态自动机!

"<

cout«"DFAD=（";

}

else

{

coutvv"此为非确定有穷状态自动机!

"<

cout

}

coutvv"{";

Bianli1（Array,size）;

coutvv"},{";

Bianli2（Array,size）;

coutvv"},M,";

coutvvstart;

if（CheckState（Array,size））

elsecout

"vvendl;if（CheckState（Array,size））Bianli31（Array,size）;

else

Bianli32（Array,size）;

length,int

}voidCreateFA2（LeftltemArray[],intsize,charstart,charend,StateltemSArray[],charTArray[],int&MArray[][20]）

//将NFA转换为DFA

{

chartemp[20];

intindex=0;

inti;

do

{

i=0;

while（TArray[i]!

='\0'）

{

temp[0]='\0：

GetState（Array,size,SArray[index].newstates,TArray[i],temp）;

Sort（temp,strlen（temp））;

Change（SArray,temp,length,MArray,index,i）;

i++;

}

index++;

}while（index<=length）;

}

voidDisplay（StateItemSArray[],charTArray[],intMArray[][20],intx,inty,charstart,charend）

〃输出确定化的NFA

{

inti,j,k;

coutvv"将NFA转化为DFA!

"v

cout

for（i=0;ivx;i++）

{

if（i==0）coutvv"["vvSArray[i].newstatesvv"]";

elsecoutvv",["vvSArray[i].newstatesvv"]";

}

coutvv"},{";

for（i=0;ivy;i++）

{

if（i==O）coutv

else

coutvv",["v

}

cout«"},M',["v

cout«"其中M':

"v

for（i=0;i

for（j=0;jvy;j++）

{

if（MArray[i][j]!

=-1）

{

k=MArray[i][j];

coutvv"

M'（["vvSArray[i].newstatesvv"],"vvTArray[j]vv"）=["vvSArray[k].newstatesvv"]"vvendl;

}

}

coutvv"其中F'={";

k=0;

for（i=0;ivx;i++）

{

j=0;

while（SArray[i].newstates[j]!

='\0'）

{

if（SArray[i].newstates[j]==end）break;

j++;

}

if（SArray[i].newstates[j]!

='\0'）

{

if（k==0）coutvv"["vvSArray[i].newstatesvv"]";

else

coutvv",["vvSArray[i].newstatesvv"]";

k++;

}

}

coutvv"}"vvendl;

}

voidRunFA1（LeftltemArray[],intsize,charstart,charend）

charTD[20];

inti=0,j;

chars=start;

COUt«"请输入要推导的符号串：

"；

cin»TD;

cout«"M（"v

for（j=0;TD[j]!

='\0';j++）

cout<

cout

while（TD[i]!

='\0'）

{

if（TD[i+1]!

='\0'）

{

cout