实验1：词法分析程序

实验1 词法分析程序

一、实验目的与要求

1.复习正规文法、正规式、有限自动机之间的相互转换的原理及技术；

2.学会使用Visual C++等高级语言编程实现上述转换，并能合理显示结果；

3.以C++的一个真子集为案例，具体分析词法分析程序的设计步骤、基本架构及代码

编制，并通过一定实例验证其可行性，以加深对词法分析原理的理解；

4.通过本次实验，使学生理解模块化程序设计的思想，从而从全局角度领会一个完整

软件的设计精髓，为后续试验的顺利完成奠定坚实的基础。

二、实验仪器及设备

1.微型电子计算机80台

2.配置Windows 2000及以上版本操作系统

3.安装Visual C++6.0/V isual C#2000/Delphi6.0等以上版本的开发环境

三、实验内容及步骤

（一）正规文法与有限自动机的相互转换

1．正规文法?有限自动机

已知某正规文法G[S]如下：

S→aA

S→bB

S→ε

A→aB

A→bA

B→aS

B→bA

B→ε

请编程实现：

（1）将G[S]转换为NFA；

（2）将上述得到的NFA确定化为DFA；

（3）再将DFA最简化为MFA。

2．有限自动机?正规文法

已知某有限自动机NFA M=（Q,∑,f,q0,Z）如下：

状态集：Q={1,2,3,4,5,6,7,8,9}

字母表：∑={a,b}

转移函数：

f(1,a)=5

f(1,ε)=2

f(1,a)=4

f(5,ε)=6

f(2,b)=3

f(4,ε)=7

f(6,ε)=2

f(6,b)=9

f(3,ε)=8

f(8,a)=9

f(7,b)=9

初态：q0=1

终态集：Z={6,7,9}

请编程实现：

（1）首先将此NFA确定化为DFA；

（2）再将得到的DFA最简化为MFA；

（3）最后，将MFA转化为正规文法（左线性或右线性均可）。

（二）编程实现MiniC++的词法分析

这里的MiniC++为C++语言的一个真子集，其语言系统与C++类似。基本组成如下：（1）关键字有18个，分别为：void、int、char、bool、float、double、if、else、switch、case、default、break、continue、do、while、for、return以及struct等。

（2）标识符：定义为“以字母或下划线开头，由字母、数字或下划线组成的符号串。”

（3）常量：包括数字（暂时仅考虑无符号整数）、字符串、字符常量等。

（4）分隔符：( ) [ ] { } . , : ; ~ ? # 等。

（5）运算符：=、==、>、>=、<、<=、!、!=、&&、&=、||、|=、+、++、- 、=、->、/、/=、%、%=等。

要求同学们完成下述工作：

1．基于上述描述，根据你的理解，尝试写出该MiniC++的文法G[S]；

2．再根据你所写的文法G[S]，绘制出MiniC++的NFA状态图，并进而推导出最简化的MFA；

3．根据你推导出的MFA，编写MiniC++的词法分析程序，并用下面的源代码测试你所设计的程序。

将程序输出的单词流与理论分析的结果比较分析，若有差错，请找出原因，并进一步修改你的程序，直至得到正确的结果。

四、思考题

1.将实验内容（一）中的文法G[S]转化为正规式；

2.将实验内容（一）中的有限自动机M转化为正规式。

五、实验报告

1.实验报告撰写在统一配发的

．．．．．上，下次上课时交给老师。

．．．．．纸质报告册

2.实验报告格式如下。

六、参考代码

（一）CGrammar类

1．头文件Grammar.h

#pragma warning(disable:4786)//屏蔽“由于string和vector等STL模版产生很长的标识符而引起的警告信息”

#include

#include

#include

#include

#include //使用vector容器

#include

using namespace std;

struct CreateFormula // 产生式

{

string LeftPart; // 左部

string RightPart; // 右部

};

class CGrammar

{

public:

CGrammar();

~CGrammar();

//外部操作函数：

void SetGrammar(char *Filename);// 根据文件内容设置文法产生式

void DelDirectLeftRecursion(int i);// 消除“直接”左递归

bool DelIndirectLeftRecursion(); // 消除“间接”左递归

bool HavingRedundance(); // 含有无用产生式

void MiniGrammar(); // 文法化简

void DisplayGrammar(); // 显示文法

void DisplayGrammar(char *Filename);// 将文法产生式保存在txt文件

//返回文法属性的函数：

int GetGrammarType(); // 返回文法类型

bool GetHavingLeftRecursion(); // 是否存在左递归

vectorGetVN(); // 返回非终结符

vectorGetVT(); // 返回终结符

vectorGetCF(); // 返回产生式数据

string GetStartSign(); // 返回开始符号

public:

//基本函数：

bool FindSign(string str,vector&VnVt); // 查找某符号串str是否属于VnVt

vector GetSingleSign(string str); //分解字符串为单个符号（包括形式为E'的符号）

private:

void CountVn_and_Vt(); // 求非终结符和终结符集

bool EnableDelLeftRecursion(); // 能否删除左递归

void ExistDirectLeftRecursion(); // 含有“直接”左递归

void ExistIndirectLeftRecursion();// 含有“间接”左递归

bool IS_0_Grammar(); // 识别0型文法

bool IS_1_Grammar(); // 识别1型文法

bool IS_2_Grammar(); // 识别2型文法

bool IS_3_Grammar(); // 识别3型文法

void GrammarType(); // 判断文法类型

string CreateNewVn(string vn); // 构造新的非终结符

protected:

// 文法结构

vectorNoEndSign; // 非终结符集

vectorEndSign; // 终结符集

vectorGR_Array;// 产生式集合

string StartSign; // 开始符号

int GrammarTypeNum; // 文法类型号码

private:

int GR_Number; // 产生式的总数

bool IsDirectLeftRecursion; // 含有直接左递归的标识

bool IsIndirectLeftRecursion; // 含有间接左递归的标识

};

2．实现文件Grammar.cpp

#include "Grammar.h"

#define KONG "ε"

CGrammar::CGrammar()

{

GR_Array.reserve(1000); //很重要，预先划分一块内存给vector使用

GrammarTypeNum=-1;

IsDirectLeftRecursion=false;

IsIndirectLeftRecursion=false;

}

CGrammar::~CGrammar()

{

}

//从txt文件中获取文法的产生式集合：

//规则：不用简写；用“→”连接；用“ε”表示空串；每行一条产生式。

void CGrammar::SetGrammar(char *Filename)

{

ifstream fin(Filename,ios::in);

char line[1024]={0};

int pos;

CreateFormula temp;

if(!GR_Array.empty())

GR_Array.clear(); //清空

while(fin.getline(line, sizeof(line)))

{

//下面的一段代码用于删除产生式中的所有空格：

char templine[200]="";

int i=0,j=0;

while(line[i])

{

if(line[i]!=' '&&line[i]!=''&&line[i]!=' ')

{

templine[j]=line[i];

j++;

}

i++;

}

templine[j+1]='\0';

//操作结束

string s(templine);

if((pos=s.find("→"))>=100)

continue;

temp.LeftPart=s.substr(0,pos);

temp.RightPart =s.substr(pos+2,s.length()-pos);//"→"是汉字符号，所以“+2”

GR_Array.push_back(temp);

}

GR_Number=GR_Array.size();

fin.clear();

fin.close();

//初始化操作：

CountVn_and_Vt(); // 求非终结符集、终结符集

GrammarType(); // 判断文法的分类类型

ExistDirectLeftRecursion(); // 判断是否存在直接左递归

ExistIndirectLeftRecursion(); // 判断是否存在间接左递归

}

// 将文法产生式保存在txt文件

void CGrammar::DisplayGrammar(char *Filename)

{

ofstream fout(Filename,ios::out);

for(int i=0;i

fout<

fout.clear();

fout.close();

}

// 查找某符号串str是否属于某个容器VnVt

bool CGrammar::FindSign(string str,vector&VnVt)

{

for(int i=0;i

if(!(VnVt[i].compare(str)))

return true;

return false;

}

//求非终结符集Vn、终结符集Vt

void CGrammar::CountVn_and_Vt()

{

if(!NoEndSign.empty())

NoEndSign.clear();

if(!EndSign.empty())

EndSign.clear();

for(int i=0;i

{

//观察产生式的左部

vectorstrtemp=GetSingleSign(GR_Array[i].LeftPart);//分解左部为单个符号

for(int j=0;j

{

string tempvn=strtemp[j];

if(tempvn[0]>='A'&&tempvn[0]<='Z')//若为大写字母则是非终结符

{

if(!FindSign(tempvn,NoEndSign))//若是新的非终结符，则添加进去

NoEndSign.push_back(tempvn);

}

else //否则，则为终结符

{

if(!FindSign(tempvn,EndSign))//若是新的终结符，则添加进去

EndSign.push_back(tempvn);

}

}

//观察产生式的右部

if((GR_Array[i]https://www.360docs.net/doc/d716242251.html,pare("ε")))//若不是X→ε形式，则

{

//分解右部为单个符号

vectorstrtemp1=GetSingleSign(GR_Array[i].RightPart);

for(int k=0;k

{

string tempvt=strtemp1[k];

if(!(tempvt[0]>='A'&&tempvt[0]<='Z'))//若不是大写字母，则是终结符

{

if(!FindSign(tempvt,EndSign)) //若是新的终结符，则添加进去

EndSign.push_back(tempvt);

}

else //否则，则为非终结符

{

if(!FindSign(tempvt,NoEndSign)) //若是新的终结符，则添加进去

NoEndSign.push_back(tempvt);

}

}

}

}

if(!NoEndSign.empty())

StartSign=NoEndSign[0]; // 文法开始符号默认为遇到的第一个非终结符

}

//识别0型文法（所有产生式的左部含有非终结符）：

bool CGrammar::IS_0_Grammar()

{

int CapitalNumInLeftPart; //某产生式左部的非终结符的数目，即大写字母数int count=0;

for(int i=0;i

{

CapitalNumInLeftPart=0;

for(int j=0;j

{

string temp3=GR_Array[i].LeftPart.substr(j,1);

if(FindSign(temp3,NoEndSign))

CapitalNumInLeftPart++;

}

if(CapitalNumInLeftPart<=0)

return false; //表示当前产生式的左部没有非终结符，则直接终止}

return true; //是0 型文法

}

//识别1型文法（即上下文有关文法，所有产生式的左部长度<=右部长度）:

bool CGrammar::IS_1_Grammar()

{

for(int i=0;i

if(GR_Array[i].LeftPart.length()>GR_Array[i].RightPart.length()) //若左部大于右部，return false;

return true;

}

//识别2型文法（即上下文无关文法：左部长度=1，且左部为非终结符Vn）

bool CGrammar::IS_2_Grammar()

{

for(int i=0;i

{

if(GR_Array[i].LeftPart.length()!=1)//若左部长度不为1

return false;

string temp4=GR_Array[i].LeftPart.substr(0,1);

if(!FindSign(temp4,NoEndSign))

return false;

}

return true;

}

//识别3型文法（即正规文法，分为右线性、左线性）

bool CGrammar::IS_3_Grammar()

{

int Flag1=0,Flag2=0; //分别代表右线性A→aB、左线性A→Ba 的个数

for(int i=0;i

{

if(GR_Array[i].RightPart.length()==1) //右部字符个数等于1，

{

string temp1=GR_Array[i].RightPart.substr(0,1);//取右部字符

if(!FindSign(temp1,NoEndSign)&&!FindSign(temp1,EndSign))// 若右部既不是终结符

//，即不满足A→a形式，也不是非终结符，既不满足A→B形式，则

return false;

}

else if(GR_Array[i].RightPart.length()==2) //判断是否右线性A→aB或左线性A→Ba形式

{

if((GR_Array[i]https://www.360docs.net/doc/d716242251.html,pare("ε")))//若不是X→ε形式，则

{

string temp2=GR_Array[i].RightPart.substr(0,1);

string temp3=GR_Array[i].RightPart.substr(1,1);

if(FindSign(temp2,EndSign)// 若右部首字符是终结符

&&FindSign(temp3,NoEndSign)) // 次首字符为非终结符，即A→aB

Flag1++;

else if(FindSign(temp2,NoEndSign)// 若右部首字符是非终结符

&&FindSign(temp3,EndSign)) // 次首字符为终结符，即A→Ba

Flag2++;

else

return false;

}

}

else

return false;

}

if(Flag1>0&&Flag2>0) //同时含有右线性、左线性

return false;

else

return true;

}

//判断文法的类型

void CGrammar::GrammarType()

{

GrammarTypeNum=-1;

if(IS_0_Grammar())

{

GrammarTypeNum=0;

if(IS_1_Grammar())

{

GrammarTypeNum=1;

if(IS_2_Grammar())

{

GrammarTypeNum=2;

if(IS_3_Grammar())

GrammarTypeNum=3;

}

}

}

}

// 判断是否含有“直接”左递归

void CGrammar::ExistDirectLeftRecursion()

{

for(int i=0;i

{

string temp1=GR_Array[i].LeftPart.substr(0,1);

if(FindSign(temp1,NoEndSign)&& //若左部首字符为指定非终结符NoEndSign[i]，GR_Array[i].LeftPart[0]==GR_Array[i].RightPart[0]) // ，且存在直接左递归{

IsDirectLeftRecursion=true;

return;

}

}

IsDirectLeftRecursion=false;

}

// 判断是否含有“间接”左递归

void CGrammar::ExistIndirectLeftRecursion()

{

vector::iterator Iter1,Iter2;

vectorGR_ArrayTemp;//备份用：

GR_ArrayTemp.reserve(1000);

GR_ArrayTemp=GR_Array; //此处仅是判断是否存在左递归，

//所有不能对原产生式进行破坏性操作，而只能对备份数据操作。

for(int i=0;i

{

for(int j=0;j

{

for(Iter1=GR_ArrayTemp.begin();Iter1!=GR_ArrayTemp.end();Iter1++)

{

string temp1=(*Iter1).LeftPart.substr(0,1);

string temp2=(*Iter1).RightPart.substr(0,1);

if(!https://www.360docs.net/doc/d716242251.html,pare(NoEndSign[i])//左部首字符为Pi，

&&!https://www.360docs.net/doc/d716242251.html,pare(NoEndSign[j]))//右部首字符为Pj，即形如Pi→Pjγ

//注：这里，γ是终结符，i、j是下标。

{

// 寻找所有形为：Pj→...的产生式：

for(Iter2=GR_ArrayTemp.begin();Iter2!=GR_ArrayTemp.end();Iter2++)

{

string temp3=(*Iter2).LeftPart.substr(0,1);

if(!https://www.360docs.net/doc/d716242251.html,pare(NoEndSign[j]))//若某产生式的左部为Pj，则替换，

{

CreateFormula temp;

temp=(*Iter1);

temp.RightPart.replace(0,1,(*Iter2).RightPart);

GR_ArrayTemp.push_back(temp);

}

}

//当替换完成后，需要删除第k条产生式（(*Iter1)），

Iter1=GR_ArrayTemp.erase(Iter1);

}

}

}

}

for(Iter1=GR_ArrayTemp.begin();Iter1!=GR_ArrayTemp.end();Iter1++)

{

string temp1=(*Iter1).LeftPart.substr(0,1);

if(FindSign(temp1,NoEndSign)&& //若左部首字符为指定非终结符NoEndSign[i]，(*Iter1).LeftPart[0]==(*Iter1).RightPart[0]) // ，且存在直接左递归

{

IsIndirectLeftRecursion=true;

return ;

}

}

IsIndirectLeftRecursion=false;

}

// 能否删除左递归

bool CGrammar::EnableDelLeftRecursion()

{

int Sum=GR_Array.size();

for(int i=0;i

{

if(GR_Array[i].LeftPart[0]==GR_Array[i].RightPart[0]// 若“左部首字符=右部首字符，”

&&GR_Array[i].RightPart.length()==1) // “且右部长度=1”，即“满足P→P回路”。

{

// 则再检查是否存在与P→P有相同左部首字符、且右部首字符=ε的产生式，即P→ε形式

for(int j=0;j

if(GR_Array[j].LeftPart[0]==GR_Array[i].LeftPart[0]//相同的左部首字符，

&&GR_Array[j].RightPart[0]=='ε') // 且右部首字符=ε

return false;//若存在这样的情况，则无法消除左递归。退出!

}

}

return true;

}

//构造新的非终结符，例如“E”变换为“E'”：

string CGrammar::CreateNewVn(string NoEndSigntemp)

{

return NoEndSigntemp+'\'';

}

//消除直接“左”递归

void CGrammar::DelDirectLeftRecursion(int i)

{

string c;

vector::iterator Iter1,Iter2; // 迭代器1

for(Iter1=GR_Array.begin();Iter1!=GR_Array.end();Iter1++)

{

string temp1=(*Iter1).LeftPart.substr(0,1);

if(!https://www.360docs.net/doc/d716242251.html,pare(NoEndSign[i])&& //若左部首字符为指定非终结符NoEndSign[i]，(*Iter1).LeftPart[0]==(*Iter1).RightPart[0]) // ，且存在直接左递归{

//（1）：修改产生式P→a为P→aP'

c=CreateNewVn(NoEndSign[i]);

for(Iter2=GR_Array.begin();Iter2!=GR_Array.end();Iter2++)

{

string temp2=(*Iter2).LeftPart.substr(0,1);

if(!https://www.360docs.net/doc/d716242251.html,pare(NoEndSign[i])&& //对于左部首字符同样=指定非终结符NoEndSign[i]，

(*Iter2).LeftPart[0]!=(*Iter2).RightPart[0])//但左部首字符不等于右部首字符，即不是左递归，例如P→a

(*Iter2).RightPart+=c;//在右部尾端添补新的非终结符号，即：P→a变为P→aP' }

//（2）：对递归式(*Iter1)进行改造：

(*Iter1).LeftPart=c; //①左部变为新的非终结符号c，即P'

(*Iter1).RightPart=(*Iter1).RightPart.erase(0,1); //②右部删除首字符，即“去除”原递归字符

(*Iter1).RightPart+=c; //③在右部尾端添加c，即P'

// 例如：P→Pa变为P'→aP'，即变为右递归。

//（3）：为文法增加一条空“ε”产生式：

CreateFormula temp;

temp.LeftPart=(*Iter1).LeftPart;

temp.RightPart="ε";

GR_Array.push_back(temp);

//（4）：将P'加入非终结符集：

if(!FindSign(c,NoEndSign))

NoEndSign.push_back(c);

}

}

}

//消除间接“左”递归

bool CGrammar::DelIndirectLeftRecursion()

{

//首先判断能否消除左递归

if(!EnableDelLeftRecursion())

return false;

vector::iterator Iter1,Iter2;

for(int i=0;i

{

for(int j=0;j

{

for(Iter1=GR_Array.begin();Iter1!=GR_Array.end();Iter1++)

{

string temp1=(*Iter1).LeftPart.substr(0,1);

string temp2=(*Iter1).RightPart.substr(0,1);

if(!https://www.360docs.net/doc/d716242251.html,pare(NoEndSign[i])//左部首字符为Pi，

&&!https://www.360docs.net/doc/d716242251.html,pare(NoEndSign[j]))//右部首字符为Pj，即形如Pi→Pjγ

//注：这里，γ是终结符，i、j是下标。

{

// 寻找所有形为：Pj→...的产生式：

for(Iter2=GR_Array.begin();Iter2!=GR_Array.end();Iter2++)

{

string temp3=(*Iter2).LeftPart.substr(0,1);

if(!https://www.360docs.net/doc/d716242251.html,pare(NoEndSign[j]))//若某产生式的左部为Pj，则替换，

{

CreateFormula temp;

temp=(*Iter1);

temp.RightPart.replace(0,1,(*Iter2).RightPart);

GR_Array.push_back(temp);

}

}

//当替换完成后，需要删除第k条产生式（(*Iter1)），

Iter1=GR_Array.erase(Iter1);

}

}

}

DelDirectLeftRecursion(i); //消除直接左递归

}

GR_Number=GR_Array.size();

return true;

}

//判断是否含有多余产生式（规则）

// 多余规则（即无用产生式）满足下述条件：

//（1）每一个非终结符号A(S除外)必须在某句型中（规则右端）出现，

// 即若某条规则左部的非终结符A不在任何其他规则右部出现，

// 那么所有的推导始终不会用到此规则，也就是说A是“不可到达”的。

// （2）非终结符A必须推出终结符串t来。否则在推导句子的过程中，

// 一旦使用了该规则，将推不出任何终结符号串，称为“不可终止”的。

bool CGrammar::HavingRedundance()

{

vectorNoEndSignTemp;//保存能由开始符号到达的非终结符的集合

vector::iterator Iter1,Iter3; // 迭代器

vector::iterator Iter2; // 迭代器

//第（1）种情况：删除“不可达”产生式

NoEndSignTemp.reserve(1000);//为NoEndSignTemp与分配存储空间，否则可能出错。

//（A）求解能由开始符号到达的非终结符的集合：

NoEndSignTemp.push_back(GR_Array[0].LeftPart);

for(Iter1=NoEndSignTemp.begin();Iter1!=NoEndSignTemp.end();Iter1++)

for(Iter2=GR_Array.begin();Iter2!=GR_Array.end();Iter2++)

{

if(NoEndSign==NoEndSignTemp)

return false;

if(!((*Iter2)https://www.360docs.net/doc/d716242251.html,pare(*Iter1)))

{

for(Iter3=NoEndSign.begin();Iter3!=NoEndSign.end();Iter3++)

{

int L=(*Iter2).RightPart.length();

if((*Iter2).RightPart.find(*Iter3)

{

//，且该非终结符*Iter3不在NoEndSignTemp中，则

if(!FindSign(*Iter3,NoEndSignTemp))

NoEndSignTemp.push_back(*Iter3);// 添加到NoEndSignTemp中

}

}

}

}

//（B）删除不能由开始符号到达的非终结符引导的产生式：

for(Iter3=NoEndSign.begin();Iter3!=NoEndSign.end();Iter3++)

if(!FindSign(*Iter3,NoEndSignTemp)) //若非终结符*Iter3不在NoEndSignTemp中，则return true;

return false;

}

//文法化简，即删除无用产生式。

void CGrammar::MiniGrammar()

{

vectorNoEndSignTemp;//保存能由开始符号到达的非终结符的集合

vector::iterator Iter1,Iter3; // 迭代器

vector::iterator Iter2; // 迭代器

//第（1）种情况：删除“不可达”产生式

NoEndSignTemp.reserve(1000);//为NoEndSignTemp与分配存储空间，否则可能出错。

//（A）求解能由开始符号到达的非终结符的集合：

NoEndSignTemp.push_back(GR_Array[0].LeftPart);

for(Iter1=NoEndSignTemp.begin();Iter1!=NoEndSignTemp.end();Iter1++)

for(Iter2=GR_Array.begin();Iter2!=GR_Array.end();Iter2++)

{

if(NoEndSign==NoEndSignTemp)

return;

if(!((*Iter2)https://www.360docs.net/doc/d716242251.html,pare(*Iter1)))

{

for(Iter3=NoEndSign.begin();Iter3!=NoEndSign.end();Iter3++)

{

int L=(*Iter2).RightPart.length();

if((*Iter2).RightPart.find(*Iter3)

{

//，且该非终结符*Iter3不在NoEndSignTemp中，则

if(!FindSign(*Iter3,NoEndSignTemp))

NoEndSignTemp.push_back(*Iter3);// 添加到NoEndSignTemp中

}

}

}

}

//（B）删除不能由开始符号到达的非终结符引导的产生式：

for(Iter3=NoEndSign.begin();Iter3!=NoEndSign.end();Iter3++)

{

if(!FindSign(*Iter3,NoEndSignTemp)) //若非终结符*Iter3不在NoEndSignTemp中，

则

{

//删除所有左部为*Iter3的产生式：

for(Iter2=GR_Array.begin();Iter2!=GR_Array.end();Iter2++)

if(!((*Iter2)https://www.360docs.net/doc/d716242251.html,pare(*Iter3)))

Iter2=GR_Array.erase(Iter2);

}

}

}

//分解字符串为单个符号（包括形式为E'的符号）

vector CGrammar::GetSingleSign(string str)

{

vector temp1;

for(int i=0;i

{

string temp2=str.substr(i,1);

if(i

temp2+=str[++i];

temp1.push_back(temp2);

}

return temp1;

}

//显示文法（四元组形式）

void CGrammar::DisplayGrammar()

{

int sum=NoEndSign.size(),i;

//显示开始符号

cout<<"G["<

//显示非终结符

cout<

for(i=1;i

{

cout<<",";

cout<

}

cout<<"},{";

//显示终结符

sum=EndSign.size();

cout<

for(i=1;i

{

cout<<",";

cout<

}

cout<<"},P,"<

//显示产生式集合：

vector::iterator Iter1;

for(Iter1=GR_Array.begin();Iter1!=GR_Array.end();Iter1++)

cout<<" "<

<

}

//返回文法类型

int CGrammar::GetGrammarType()

{

return GrammarTypeNum;

}

//返回是否存在左递归的标识

bool CGrammar::GetHavingLeftRecursion()

{

return IsDirectLeftRecursion||IsIndirectLeftRecursion; }

//返回非终结符

vectorCGrammar::GetVN()

{

return NoEndSign;

}

//返回终结符

vectorCGrammar::GetVT()

{

return EndSign;

}

// 返回产生式数据

vectorCGrammar::GetCF()

{

return GR_Array;

}

// 返回开始符号

string CGrammar::GetStartSign()

{

return StartSign;

}

（二）CRGrammar类

1．头文件RGrammar.h

#include "Grammar.h"

#define PRO_MAX_LEN 20480 // 源程序最大长度

// 为便于描述，这里我们将有关单词归纳为如下五类：#define KEY 1 // 关键字

#define OPERA T 2 // 运算符

#define DIVIDE 3 // 界符

#define ID 4 // 标识符

#define CONST 5 // 常量

struct SignProperty // 属性字

{

int SignKind; // 单词种别

string SignV alue; // 单词值

};

struct tp // 临时用

{

string tp_start,tp_end;

};

struct MoveFunction // 状态转移函数

{

string Startstate; // 当前状态

string Endstate; // 目标状态

string InputSign; // 输入符号

};

struct FA // 有限自动机结构，五元组形式

{

vectorQState; // 状态集

vectorSigema; // 字母表

string q0; // 初始状态

vectorZState; // 终态集

vectorFAf;// 转移函数

};

struct NFAStateMovetable // NFA确定化表

{

vectorNFAStart;// 当前状态集

string NFAinputsign; // 输入符号

vectorNFAEnd; // 目标状态集

};

#include "Grammar.h"

class CRGrammar:public CGrammar

{

public:

CRGrammar();

virtual ~CRGrammar();

public:

void MiniCLex(char *Filename);// 小型C++语言的词法分析（演示程序）

void FA2RG(); // 有限自动机（FA）转换为正规文法（右线性）

void SetFA(char *Filename); // 从txt文件中获取FA信息

void DFA2MFA(); // DFA化简

void NFA2DFA(); // NFA确定化

void DisplayNFA(); // 显示NFA

void DisplayDFA(); // 显示DFA

void DisplayMFA(); // 显示MFA

void RG2NFA(); // 正规文法（RG）转换为有限自动机（NFA）private:

void DiplayFA(FA fa); // 显示有限自动机

void CreateMovefunction(); // 构造NFA的转移函数

bool IsRightlineGrammar(); // 判断是否为右线性文法

void KongClosure(string I_state,vector&EClosure);// 求单符号的闭包

void I_KongClosure(vectorI_state,vector&EClosure);// 求符号集的闭包void Ia_KongClosure(vectorI_state,vector&EClosure,string sign);// 求符号

集I_state的a-闭包

bool StartEQEnd(vectorlist1,vectorlist2);// 判断两个串等价

bool HaveEndstate(vectorlist1,vectorlist2);// 判断list1中含有list2的元素vectorFA1(char *line); // 从一串字符中提取FA信息

void AClosure(string I_state,vector&EClosure,string sign);// 求单符号的a-闭包void DelOtioseState(); // 删除多余状态

bool IsNFA(); // 判断一个FA是否为NFA

void CarveState(); // 合并等价状态

int stringToNum(const string& str); //string 转为int

bool MiniC_Pretreatment(); // 滤除注释等

bool MiniC_InputSource(char *Filename); // 输入源码

void MiniC_CreateErrortable(); // 构造错误码表

bool MiniC_Lexanalyse(); // 词法分析程序

int MiniC_InKeyTable(string str); // 在关键字表中查找str

void MiniC_CreateKeyTable(); // 构造关键字表

int MiniC_InsertSigntable(string str,vector&table);// 插入表

void MiniC_DisplayPropertytable(); // 显示属性值表

void MiniC_DisplaySigntable(); // 显示符号表

string MiniC_GetSignIntable(int No,vectortable);

private:

FA NFA; // 非确定有限自动机NFA

FA DFA; // 确定的有限自动机DFA

FA MFA; // 最小化的有限自动机MFA

string proBuffer; // 存储程序代码的全局缓冲区

vectorErrortable; // 错误代码表

vectorKeytable; // 关键字表

vectorSigntable; // 标识符表

vectorConsttable; // 常量表

vectorPropertytable; // 属性字表

};

2．实现文件RGrammar.cpp

#include "RGrammar.h"

// 正规文法（RG）转换为NFA

void CRGrammar::RG2NFA()

{

if(IsRightlineGrammar()) // 要求必须是右线性3型文法，

{

NFA.Sigema=GetVT(); //（1）设置字母表：∑

NFA.q0=GetStartSign(); //（2）设置初始状态：q0

NFA.QState=GetVN(); //（3）设置状态集：Q

string temp("Z");

NFA.QState.push_back(temp);

if(!NFA.ZState.empty())

NFA.ZState.clear(); //清空

NFA.ZState.push_back(temp); //（4）设置终态集：Z

CreateMovefunction(); //（5）设置FA的转移函数

}

}

// 构造NFA的转移函数

void CRGrammar::CreateMovefunction()

{

if(!IsRightlineGrammar())

return ;

if(!NFA.FAf.empty())

NFA.FAf.clear(); //清空

MoveFunction tempMove; // 临时转移函数

for(int i=0;i

{

string tempLeft=GR_Array[i].LeftPart.substr(0,1);//保存左部

if(!FindSign(tempLeft,NFA.QState))

continue;

if(!(GR_Array[i]https://www.360docs.net/doc/d716242251.html,pare("ε"))) // 若右部是A→ε形式，则

{

tempMove.Startstate =tempLeft;

tempMove.InputSign ="ε";

tempMove.Endstate ="Z";

NFA.FAf.push_back(tempMove); //保存状态转移函数

}

else

{

if(GR_Array[i].RightPart.length()==1) // 若右部字符个数等于1，

{

string temp1=GR_Array[i].RightPart.substr(0,1);//取右部字符

if(FindSign(temp1,NFA.Sigema))// 若右部字符是终结符，即满足A→a形式

{

tempMove.Startstate =tempLeft;

tempMove.InputSign =temp1;

tempMove.Endstate ="Z";

NFA.FAf.push_back(tempMove); // 保存状态转移函数

}

else if(FindSign(temp1,NFA.QState))// 若右部字符是非终结符，即A→B形式

{

tempMove.Startstate =tempLeft;

tempMove.InputSign ="ε";

tempMove.Endstate =temp1;

NFA.FAf.push_back(tempMove); //保存状态转移函数

}

}

else if(GR_Array[i].RightPart.length()==2) //判断是否为右线性A→aB

{

string temp2=GR_Array[i].RightPart.substr(0,1); // 取右部首字符

string temp3=GR_Array[i].RightPart.substr(1,1); // 取右部第2个字符

if(FindSign(temp2,NFA.Sigema)// 若右部首字符是终结符

&&FindSign(temp3,NFA.QState)) // 次字符为非终结符，即A→aB {

tempMove.Startstate =tempLeft;

tempMove.InputSign =temp2;

tempMove.Endstate =temp3;

NFA.FAf.push_back(tempMove); //保存状态转移函数

}

}

}

}

}

// 判断是否为右线性正规文法

bool CRGrammar::IsRightlineGrammar()

{

if(GrammarTypeNum!=3) // 首先必须是3型文法，如果不是，则return false;

for(int i=0;i

{

if((GR_Array[i]https://www.360docs.net/doc/d716242251.html,pare("ε")))// 若右部不是A→ε形式，则

{

if(GR_Array[i].RightPart.length()==1) // 若右部字符个数等于1，

{

string temp1=GR_Array[i].RightPart.substr(0,1);//取右部字符

// 若右部既不是终结符，即不满足A→a形式，也不是非终结符，既不满足A→B形式，则if(!FindSign(temp1,NoEndSign)&&!FindSign(temp1,EndSign))

return false;

}

else if(GR_Array[i].RightPart.length()==2) //判断是否为右线性A→aB

{

string temp2=GR_Array[i].RightPart.substr(0,1); // 取右部首字符

string temp3=GR_Array[i].RightPart.substr(1,1); // 取右部第2个字符

if(!FindSign(temp2,EndSign) // 若右部首字符是终结符

||!FindSign(temp3,NoEndSign))// 次字符为非终结符，即满足A→aB

return false;

}

else

return false;

}

}

return true;

}

// 显示FA：五元组形式

void CRGrammar::DiplayFA(FA fa)

{

cout<<"五元组如下："<

int i;

cout<

for(i=0;i

cout<

cout<

for(i=0;i

cout<

cout<

for(i=0;i

cout<

<

cout<

cout<

for(i=0;i

cout<

cout<

}

void CRGrammar::DisplayNFA()

{

if(IsNFA())

{

cout<

DiplayFA(NFA);

}

}

void CRGrammar::DisplayDFA()

{

cout<

DiplayFA(DFA);

}

void CRGrammar::DisplayMFA()

{

cout<

DiplayFA(MFA);

}

//求单符号的ε-闭包

void CRGrammar::KongClosure(string I_state,vector&EClosure)

{

if(!FindSign(I_state,EClosure)) // 若I_state尚未添入闭包中，则EClosure.push_back(I_state); // 加入闭包。

for(int i=0;i

{

if(!(I_https://www.360docs.net/doc/d716242251.html,pare(NFA.FAf[i].Startstate)) // 找到当前状态为I_state,

&&(!(NFA.FAf[i]https://www.360docs.net/doc/d716242251.html,pare("ε")))) // 且输入符号为sign，则{

if(!FindSign(NFA.FAf[i].Endstate,EClosure)) // 若尚未添入闭包中，则

{

EClosure.push_back(NFA.FAf[i].Endstate); // 加入闭包

KongClosure(NFA.FAf[i].Endstate,EClosure); // 递归求解

}

}

}

}

//求符号集的ε-闭包

/*

参数EClosure：保存求得的闭包

参数I_state：所求对象，即是求I_state得闭包