Redy词法识别－－状态机的合并算法

返回文档首页

（一）简介

代码下载: git clone git://git.code.sf.net/p/redy/code redy-code

这一章的内容有：

1. 通过一个实例来说明状态机合并的方法
2. 状态机合并算法
3. 状态链在合并中的优点
   

（二）状态机的合并

　　在这一章里面，你会看到两个简单的状态机：

　　一个为状态机用于识别正则式   [0-7]+abf 所表于的语言，[0-7]　表于数字0-7中的任意一个，'+'表示重复一次或多次。

　　别一个状态机用于识别正则式　[4-9]+acd所表于的语言。同样[4-9]表示数字4-7中的任意一个。'+'表示重复一次或多次。

（１）状态机１

根据正则式[0-7]+abf，绘出的状态图如下：

　　我们使用状态链的算法来用程序来构造该状态机，从状态中可以看出，该状态机总共有５个状态，其中Abegin为开始状态，A4为终态，由于每个状态，都只在一个输入类型下发生状态转移，所以每一个状态，这里采用函数指钍的方法来判断输入类型。

在程序开头，我们对于每一个状态都进行申明，以使后面引用：

extern struct state Abegin;
extern struct state A1;
extern struct state A2;
extern struct state A3;
extern struct state A4;

状态Abegin在数据输入字符0-7的情况下转移到状态A1，在其它输入情况下让状态Abegin转移到错误状态lex_state_err。

int input_map_abegin(char c)
{
	if(c>='0'&&c<='7') return 1;
	else return 0;
}
struct state* Abegin_targets[]= {&lex_state_err,&A1};
struct state Abegin= { "Abegin",2,1,0, input_map_abegin, Abegin_targets, 0, };

状态A1begin在输入入字符0-7的情况下转移到自身，当输入为字符‘a’时转移到A2，其它则转移到状态lex_state_err。

int input_map_a1(char c)
{
	if(c=='a')return 1;
	if(c>='0'&&c<='7') return 2;
	else return 0;
}
struct state* A1_targets[]= {&lex_state_err,&A2,&A1};
struct state A1= { "A1",2,1,0, input_map_a1, A1_targets, 0, };

状态A2,A3,A4构造方法和前面一样，所以我就全部贴出。

int input_map_a2(char c)
{
	if(c=='b')return 1;
	else return 0;
}
struct state* A2_targets[]= {&lex_state_err,&A3};
struct state A2= { "A2",2,1,0, input_map_a2, A2_targets, 0, };

int input_map_a3(char c)
{
	if(c=='f')return 1;
	else return 0;
}
struct state* A3_targets[]= {&lex_state_err,&A4};
struct state A3= { "A3",2,1,0, input_map_a3, A3_targets, 0, };

int input_map_a4(char c)
{
	return 0;
}
struct state* A4_targets[]= {&lex_state_err};
struct state A4= { "[0-7]+abf",2,1,0, input_map_a4, A4_targets, 1, };

这样我们已经用状态链的方法构造出了整个状态机１的模型。把该模型带入驱动程序，就可能对类似于011444abf ，2122abf，4abf，的字符串进行识别了。

状态机１的程序可以在下载的文件夹下面的tutorial/lexical/merge1中找到，对程序进行编译，运行可执行文件a1。｀

下面我们来构造状态机２

（２）状态机２

根据正则式[4-9]+acd，绘出状态图：

同样我们也使用状态链的方法来构造状态机２，状态机２总共有５个状态，开始状态为Bbegin，终态为B4，同构造状态机１的方法一样。我这里就直接贴出程序，不进行说明。

状态申明：

extern struct state Bbegin;
extern struct state B1;
extern struct state B2;
extern struct state B3;
extern struct state B4;

状态机２的５个状态：

int input_map_bbegin(char c)
{
	if(c>='4'&&c<='9')return 1;
	else return 0;
}

struct state* Bbegin_targets[]= {&lex_state_err,&B1};
struct state Bbegin= { "Bbegin",2,1,0, input_map_bbegin, Bbegin_targets, 0, };


int input_map_b1(char c)
{
	if(c=='a')return 1;
	if(c>='4'&&c<='9') return 2;
	else return 0;
}
struct state* B1_targets[]= {&lex_state_err,&B2,&B1};
struct state B1= { "B1",2,1,0, input_map_b1, B1_targets, 0, };

int input_map_b2(char c)
{
	if(c=='c')return 1;
	else return 0;
}
struct state* B2_targets[]= {&lex_state_err,&B3};
struct state B2= { "B2",2,1,0, input_map_b2, B2_targets, 0, };

int input_map_b3(char c)
{
	if(c=='d')return 1;
	else return 0;
}
struct state* B3_targets[]= {&lex_state_err,&B4};
struct state B3= { "B3",2,1,0, input_map_b3, B3_targets, 0, };

int input_map_b4(char c)
{
	return 0;
}
struct state* B4_targets[]= {&lex_state_err};
struct state B4= { "[4-9]+acd",2,1,0, input_map_b4, B4_targets, 1, };

现在我们就用状态链的方法构造出状态机２模型，同样把该模型带入驱动程序，这样我们就可以识别例如：4578589acd , 87acd , 9978acd , 等类似的字符串。

状态机２的程序可以在下载的文件夹下面的tutorial/lexical/merge1中找到，对程序进行编译，运行可执行文件b1。

（３）状态机的合并

　　现在我们要把两个状态机合并在一起，以便我们的程序同时能够识别正则式[0-7]+abc所表示的语言和[4-9]+acd所表示的语言，合并状态机的方法与自动机ENFA转化为NFA的算法理论基本一样。总共分为下面几步：

a）输入类型分析

对于状态机1来说，输入类型有这么５种

1. 数字0到7　　（D0_7）
2. 字符'a'　　　（S_a）
3. 字符'b' 　　　（S_b）
4. 字符'f'　　　（S_f）
5. 除以上以外的所有字符　　（Other）

对于状态机２来说，输入类型有么５种

1. 数字4到9 　　（D4_9）
2. 字符'a'　　　（S_a)
3. 字符'c' 　　　（S_c）
4. 字符'd'　　　（S_d）
5. 除以上以外的所有字符　　（Other）

把两个状态机的输入类型进行合并得到下面９种输入类型

1. 数字0到3　　（D0_3）
2. 数字4到7　　（D4_7）
3. 数字8到9　　（D8_9）
4. 字符'a'　　　（D_a）
5. 字符‘b‘　　　（D_b）
6. 字符‘f’　　　（D_f）
7. 字符‘c’　　　（D_c）
8. 字符‘d‘　　　（D_d)
9. 除以上以外的所有字符 　　（other）

　　其中类型D0_7包括：D0_3，D4_7；类型D4_9包括：D4_7，D8_9。

b）合并第一步

状态机１的开始状态为Abegin，状态机２的开始状态为Bbegin，把两个状态合成一个状态Cbegin，Abegin和Bbegin两个状态能发生的状态转移，Cbegin同样能发生。

这时状态图为：