自己动手写编译器:使用NFA识别字符串

Posted 2022-12-14 tyler_download

在前面章节中我们构建了NFA状态机，现在我们看看如何使用它来识别给定字符串是否合法。首先我们先构造如下正则表达式对应的NFA,在input文件的表达式部分输入：

(D*\\.D | D\\.D*)

这个表达式的目的是识别浮点数，用我们前面做好的代码生成的NFA状态机如下：

 

 

这里我们需要引入两个个概念及其对应操作，首先是epsilon-clousure操作， 它表示给定一系列初始状态后，然后找到从这些状态出发通过epsilon边所能抵达的状态集合，例如epsilon-closure(0)=0，27,11,9,12,13,19,从上图看出，状态0开始经过epsilon边后能抵达点27，然后从点27经过epsilon边又能抵达点11,19，依此类推，这里需要注意的是episilon-closure的结果包含其输入的状态，例如epsilon-closure(0)的结果中就包括了节点0、

第二个概念叫move操作，它指的是给定一个节点集合以及一个输入字符，然后得到跳转后的结果集合。例如epsilon-closure(0)对应的节点集合是0,27,11,9,12,13,19，此时如果输入字符为数字，那么在这些点中，只有点9和19能接收字符集D,其中节点9接收数字后进入节点10，节点19接收数字后进入节点20，于是就有move(0,27,11,9,12, 13,19， D)=10,20, 如果输入字符是'.'，由于集合0,27,11,9,12,13,19中节点13能接收字符’.',然后进入节点14，因此move(0,27,11,9,12,19, '.') 的结果就是14。

对于集合10, 20，我们有epsilon-closure(10,20)=10, 20,12,13,9, 21, 然后继续对其执行move操作，由于这些节点中，节点9接受数字然后进入节点10，因此move(10, 20,12,13,9, 21, D结果是10，而move(10, 20, 12, 13,9, 21, '.')= 14,22，因为节点13接收字符'.'后进入14,节点21接收'.'后进入22.我们继续对14,22执行epsilon-closure操作，所得结果为14, 22,15,25,23,26,28,这里需要注意的是，终结状态节点28在结果集合中，这意味着当前输入的字符串能够被状态机所接受，同理当我们依次读取输入字符，如果读入最后一个字符后，所得的epsilon-closure集合中包含终结状态节点，那么给定的字符串就能被NFA状态机所接受。

我们看看上面算法的代码实现，增加一个名为nfa_interpretation.go的文件，输入代码如下：

package nfa

import (
	"fmt"
	"math"
)

type EpsilonResult struct 
	/*
		如果结果集合中包含终结点，那么accept_str对应终结点的accept字符串，anchor对于终结点的Anchor对象
	*/
	results     []*NFA
	acceptStr   string
	hasAccepted bool
	anchor      Anchor


func stackContains(stack []*NFA, elem *NFA) bool 
	for _, i := range stack 
		if i == elem 
			return true
		
	

	return false


func EpsilonClosure(input []*NFA) *EpsilonResult 
	acceptState := math.MaxInt
	result := &EpsilonResult

	for len(input) > 0 
		node := input[len(input)-1]
		input = input[0 : len(input)-1]
		//epsilon-closure的操作结果一定包含输入节点集合
		result.results = append(result.results, node)
		/*
			如果有多个终结节点，那么选取状态值最小的那个作为接收点
		*/
		if node.next == nil && node.state < acceptState 
			result.acceptStr = node.accept
			result.anchor = node.anchor
			result.hasAccepted = true
		

		if node.edge == EPSILON 
			if node.next != nil && stackContains(input, node.next) == false 
				input = append(input, node.next)
			

			if node.next2 != nil && stackContains(input, node.next2) == false 
				input = append(input, node.next2)
			
		
	

	return result


func move(input []*NFA, c int) []*NFA 
	result := make([]*NFA, 0)
	for _, elem := range input 
		if int(elem.edge) == c || (elem.edge == CCL && elem.bitset[string(c)] == true) 
			result = append(result, elem.next)
		
	

	return result


func printEpsilonClosure(input []*NFA, output []*NFA) 
	fmt.Printf("%s(", "epsilon-closure")
	for _, elem := range input 
		fmt.Printf("%d,", elem.state)
	
	fmt.Printf(")=")
	for _, elem := range output 
		fmt.Printf("%d, ", elem.state)
	
	fmt.Printf(")\\n")


func printMove(input []*NFA, output []*NFA, c string) 
	fmt.Printf("move(")
	for _, elem := range input 
		fmt.Printf("%d,", elem.state)
	
	fmt.Printf(", %s)=", c)
	for _, elem := range output 
		fmt.Printf("%d, ", elem.state)
	
	fmt.Printf(")\\n")


func NfaMatchString(state *NFA, str string) bool 
	/*
		state是NFA状态机的起始节点，str对应要匹配的字符串
	*/
	startStates := make([]*NFA, 0)
	startStates = append(startStates, state)
	statesCopied := make([]*NFA, len(startStates))
	copy(statesCopied, startStates)
	result := EpsilonClosure(statesCopied)

	printEpsilonClosure(startStates, result.results)

	strRead := ""
	strAccepted := false
	for i, char := range str 
		moveResult := move(result.results, int(char))
		printMove(result.results, moveResult, string(char))
		if moveResult == nil 
			fmt.Printf("%s is not accepted by nfa machine\\n", str)
		
		strRead += string(char)
		statesCopied = make([]*NFA, len(moveResult))
		copy(statesCopied, moveResult)
		result = EpsilonClosure(moveResult)
		printEpsilonClosure(statesCopied, result.results)
		if result.hasAccepted 
			fmt.Printf("current string : %s is accepted by the machine\\n", strRead)
		

		if i == len(str)-1 
			strAccepted = result.hasAccepted
		
	

	return strAccepted

函数EpsilonClosure实现epsilon-closure操作，move则是实现move操作，具体的逻辑讲解和调试演示请在b站搜索coding迪斯尼，最后我们在main.go中调用上面代码用于识别给定字符串是否满足创建的nfa状态机,相应代码如下：

func main() 
	lexReader, _ := nfa.NewLexReader("input.lex", "output.py")
	lexReader.Head()
	parser, _ := nfa.NewRegParser(lexReader)
	start := parser.Parse()
	parser.PrintNFA(start)
	str := "3.14"
	if nfa.NfaMatchString(start, str) 
		fmt.Printf("string %s is accepted by given regular expression\\n", str)
	

上面代码运行后所得结果如下：

epsilon-closure(0,)=0, 27, 19, 11, 12, 13, 9, )
move(0,27,19,11,12,13,9,, 3)=20, 10, )
epsilon-closure(20,10,)=10, 9, 12, 13, 20, 21, )
move(10,9,12,13,20,21,, .)=14, 22, )
epsilon-closure(14,22,)=22, 25, 26, 28, 23, 14, 15, )
current string : 3. is accepted by the machine
move(22,25,26,28,23,14,15,, 1)=24, 16, )
epsilon-closure(24,16,)=16, 28, 24, 23, 26, 28, )
current string : 3.1 is accepted by the machine
move(16,28,24,23,26,28,, 4)=24, )
epsilon-closure(24,)=24, 23, 26, 28, )
current string : 3.14 is accepted by the machine
string 3.14 is accepted by given regular expression

代码打印出了epsilon-closure操作以及move操作时对应的输入和输出结果，最终给出输入字符串是否能被创建的NFA状态机所接受，更多详细内容请在b站搜索coding迪斯尼