自己动手写编译器:增强语法极其实现

最新推荐文章于 2025-12-19 20:36:56 发布

原创最新推荐文章于 2025-12-19 20:36:56 发布 · 355 阅读

CC 4.0 BY-SA版权

文章标签：

我们前面章节看到的语法规则中，语法只给出了代码字符串组合规则是否符合规定，实际上我们可以在语法解析过程中增加一些特定的属性或者操作，使得语法解析流程中就能完成中间代码生成，或者是创建好特定的元信息，以便在后续处理流程中辅助代码生成。例如我们看看如何在语法解析规则中附加特定操作，使得语法解析过程就能生成中间代码，我们看一个例子，给定如下语法规则：

expr_prime -> + term {op('+');} expr_prime

其中{op(‘+’)}就是对语法的增强，它表示在解析完 term 这个符号后，执行 op(‘+’)这个操作，对应到代码实现上就如下所示：

expr_prime() {
    if (match(PLUS)) {
        term()
        op('+')
        expr_prime()
    }
}

要想理解增强语法的特性，我们还是需要去实现一个具体实例，我们现给出一个能解析算术表达式的增强语法规则：

stmt -> epsilon | expr ; stmt
expr -> term expr_prime 
expr_prime -> + term {op('+')} expr_prime | epsilon 
term -> factor term_prime 
term_prime -> * factor {op('*')} term_prime
factor -> NUM {create_tmp(lexer.lexeme)} | ( expr )

上面的语法用于识别加法，乘法，以及带括号的算术表达式，他跟我们前面用于识别表达式的语法有所不同，它这里主要是进行了“左递归消除”，在后续章节我们会详细讨论这个话题，那么我们怎么用上面语法来解析表达式呢，解析完毕后会有什么效果呢，我们看具体实现你就会明白了。首先在前dragon-compiler 项目中创建一个文件夹叫augmented_parser,在该目录下创建新文件叫 augmented_parser.go,添加代码如下：

package augmented_parser

import (
    "fmt"
    "lexer"
)

type AugmentedParser struct {
    parserLexer lexer.Lexer
    //用于存储虚拟寄存器的名字
    registerNames []string
    //存储当前已分配寄存器的名字
    regiserStack []string
    //当前可用寄存器名字的下标
    registerNameIdx int
    //存储读取后又放回去的 token
    reverseToken []lexer.Token
}

func NewAugmentedParser(parserLexer lexer.Lexer) *AugmentedParser {
    return &AugmentedParser{
        parserLexer:     parserLexer,
        registerNames:   []string{"t0", "t1", "t2", "t3", "t4", "t5", "t6", "t7"},
        regiserStack:    make([]string, 0),
        registerNameIdx: 0,
        reverseToken:    make([]lexer.Token, 0),
    }
}

func (a *AugmentedParser) putbackToken(token lexer.Token) {
    a.reverseToken = append(a.reverseToken, token)
}

func (a *AugmentedParser) newName() string {
    //返回一个寄存器的名字
    if a.registerNameIdx >= len(a.registerNames) {
        //没有寄存器可用
        panic("register name running out")
    }
    name := a.registerNames[a.registerNameIdx]
    a.registerNameIdx += 1
    return name
}

func (a *AugmentedParser) freeName(name string) {
    //释放当前寄存器名字
    if a.registerNameIdx > len(a.registerNames) {
        panic("register name index out of bound")
    }

    if a.registerNameIdx == 0 {
        panic("register name is full")
    }

    a.registerNameIdx -= 1
    a.registerNames[a.registerNameIdx] = name
}

func (a *AugmentedParser) createTmp(str string) {
    //创建一条寄存器赋值指令并
    name := a.newName()
    //生成一条寄存器赋值指令
    fmt.Printf("%s=%s\n", name, str)
    //将当前使用的寄存器压入堆栈
    a.regiserStack = append(a.regiserStack, name)
}

func (a *AugmentedParser) op(what string) {
    /*
        将寄存器堆栈顶部两个寄存器取出，生成一条计算指令，
        并赋值给第二个寄存器，然后释放第一个寄存器，第二个寄存器依然保持在堆栈上
    */
    right := a.regiserStack[len(a.regiserStack)-1]
    a.regiserStack = a.regiserStack[0 : len(a.regiserStack)-1]
    left := a.regiserStack[len(a.regiserStack)-1]
    fmt.Printf("%s %s= %s\n", left, what, right)
    a.freeName(right)
}

func (a *AugmentedParser) getToken() lexer.Token {
    //先看看有没有上次退回去的 token
    if len(a.reverseToken) > 0 {
        token := a.reverseToken[len(a.reverseToken)-1]
        a.reverseToken = a.reverseToken[0 : len(a.reverseToken)-1]
        return token
    }

    token, err := a.parserLexer.Scan()
    if err != nil && token.Tag != lexer.EOF {
        sErr := fmt.Sprintf("get token with err:%s\n", err)
        panic(sErr)
    }

    return token
}

func (a *AugmentedParser) match(tag lexer.Tag) bool {
    token := a.getToken()
    if token.Tag != tag {
        a.putbackToken(token)
        return false
    }

    return true
}

func (a *AugmentedParser) Parse() {
    a.stmt()
}

func (a *AugmentedParser) isEOF() bool {
    token := a.getToken()
    if token.Tag == lexer.EOF {
        return true
    } else {
        a.putbackToken(token)
    }
    return false
}

func (a *AugmentedParser) stmt() {
    //stmt-> epsilon
    if a.isEOF() {
        return
    }
    //stmt -> expr ; stmt
    a.expr()
    if a.match(lexer.SEMI) != true {
        panic("mismatch token, expect semi")
    }
    a.stmt()
}

func (a *AugmentedParser) expr() {
    //expr -> term expr_prime
    a.term()
    a.expr_prime()
}

func (a *AugmentedParser) expr_prime() {
    //expr_prime -> + term {op('+')} expr_prime
    if a.match(lexer.PLUS) == true {
        a.term()
        a.op("+")
        a.expr_prime()
    }

    //expr -> epsilon
    return
}

func (a *AugmentedParser) term() {
    //term -> factor term_prime
    a.factor()
    a.term_prime()
}

func (a *AugmentedParser) term_prime() {
    //term_prime -> * factor {op('*')} term_prime
    if a.match(lexer.MUL) == true {
        a.factor()
        a.op("*")
        a.term_prime()
    }
    //term_prime -> epsilon
    return
}

func (a *AugmentedParser) factor() {
    // factor -> NUM {create_tmp(lexer.lexeme)}
    if a.match(lexer.NUM) == true {
        a.createTmp(a.parserLexer.Lexeme)
        return
    } else if a.match(lexer.LEFT_BRACKET) == true {
        a.expr()
        if a.match(lexer.RIGHT_BRACKET) != true {
            panic("mismatch token, expect right_paren")
        }
        return
    }

    //should not come here
    panic("factor parsing error")
}

在代码实现中有几处需要留意，一是代码存储了多个虚拟寄存器的名称，在读取表达式时，一旦读取到数字字符，那么就会将其数值赋值给某个寄存器，例如“1+2”，当代码读取字符1 时就会取出寄存器 t0,然后生成语句 t0=1，这个功能是由 createTmp 函数实现，调用该接口时输入的参数就对应当前读取到的数字。

在前面的语法规则中有{op(‘+’)}这样的指令，它在代码中对应函数 op，该函数从当前指令堆栈中取出顶部两个寄存处，然后执行加法指令，假设当前栈顶两个寄存器是 t0,t1,那么 op(‘+’)执行后就会创建指令 t1+=t0，然后它会把 t0 从堆栈去除，但是会保留 t1 在堆栈顶部。

在 main.go 中调用上面实现的代码测试一下效果：

package main

import (
    "augmented_parser"
    "lexer"
)

func main() {
    exprLexer := lexer.NewLexer("1+2*(4+3);")
    augmentedParser := augmented_parser.NewAugmentedParser(exprLexer)
    augmentedParser.Parse()
}

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

t0=1
t1=2
t2=4
t3=3
t2 += t3
t1 *= t2
t0 += t1

可以看成生成的虚拟指令确实能对应得上给定的算术表达式，更详细的调试演示过程请在 b 站搜索 coding 迪斯尼。代码下载：

https://github.com/wycl16514/augmented-grammar.git