从零开始实现 Lua 解释器之语法分析2

警告⚠️：这将是一个又臭又长的系列教程，教程结束的时候，你将拥有一个除了性能差劲、扩展性差、标准库不完善之外，其他方面都和官方相差无几的 Lua 语言解释器。说白了，这个系列的教程实现的是一个玩具语言，仅供学习，无实用性。请谨慎 Follow，请谨慎 Follow，请谨慎 Follow。

这是本系列教程的第六篇，如果你没有看过之前的文章，请从头观看。

前言

语法分析算是 SLua 解释器中相对复杂的一个模块了，为了避免篇幅过长，我们将分成多篇来讲解，本文是第二部分。

上一节说到了 parseStatement 的实现，现在我们就来分析一下 SLua 中到底有几种类型的 Statement：

• Do Statament，这个语句的作用是将一个 Block 封装成一个单独的语句。类似于 C 语言中将一段代码放在一对大括号中，主要用于控制局部变量的作用域。
• While Statement
• If Statement
• Local Statement，局部变量声明语句。
• Other Statement，全局变量声明及变量赋值语句，没错，SLua 中的全局变量声明语句和变量赋值语句的形式是一样的。

解析 Do Statement

Do Statement 的解析代码如下：

func (p *Parser) parseDoStatement() syntax.SyntaxTree {
    p.nextToken()
    assert(p.currentToken.Category == scanner.TokenDo, "not a do statement")
    block := p.parseBlock()
    if p.nextToken().Category != scanner.TokenEnd {
        panic(&Error{
            module: p.module,
            token:  p.currentToken,
            str:    "expect 'end' for 'do' statement",
        })
    }
    return &syntax.DoStatement{Block: block}
}

首先，我们使用 assert 函数来确保当前 Token 的类型为 TokenDo；然后调用 parseBlock 函数来解析 Do Statement 内部的 Block；紧接着，在解析完成后，我们检查下一个 Token 的类型是否为 TokenEnd，如果不是，则抛出错误。

怎么样，很简单吧。其他的语句的解析也跟这个类似，就像流水线一样，一步接一步，直到解析完成，将各部分的结果组装起来，得到我们需要的东西。

解析 While Statement

在解析之前，我们先来看一下之前在介绍抽象语法树时提到过的 WhileStatement 的定义：

type WhileStatement struct {
    Exp   SyntaxTree
    Block SyntaxTree
}

可以看到，While Statement 包含两部分，Exp 为用于判断循环是否继续的表达式，Block 则是循环体。解析代码如下：

func (p *Parser) parseWhileStatement() syntax.SyntaxTree {
    p.nextToken()
    assert(p.currentToken.Category == scanner.TokenWhile,
        "not a while statement")
    exp := p.parseExp()
    if p.nextToken().Category != scanner.TokenDo {
        panic(&Error{
            module: p.module,
            token:  p.currentToken,
            str:    "expect 'do' for 'while' statement",
        })
    }
    block := p.parseBlock()
    if p.nextToken().Category != scanner.TokenEnd {
        panic(&Error{
            module: p.module,
            token:  p.currentToken,
            str:    "expect 'end' for 'while' statement",
        })
    }
    return &syntax.WhileStatement {
        Exp:   exp,
        Block: block,
    }
}

首先，与解析 Do Statement 相同，首先我们通过调用 assert 保证当前 Token 的类型为 TokenWhile；然后调用 parseExp 解析紧接着 TokenWhile 后面的循环表达式；正常情况下，表达式后面会跟着 TokenDo，所以，如果不是的话，我们就需要报告语法错误然后退出程序；紧跟在 TokenDo 之后的是一个做为函数体的 Block，我们调用之前定义好的 parseBlock 函数来解析它；最后，我们需要判断紧跟在 Block 之后的是否为 TokenEnd，如果不是，则需要报告语法错误。

parseExp 函数的实现是整个语法分析最复杂的部分，我会在后面的文章中详细地讲解它，目前只需要知道它用于解析表达式就行了。

解析 If Statement

相比于上面介绍的 Do Statement 和 While Statement，If Statement 的结构较为复杂，它可以包含零到多个 Elseif 分支和零或一个 Else 分支，所以将整个解析过程放在一个函数中无疑会大大增加复杂度，所以我们将解析函数拆分成了多个函数。

我们在第四篇文章中介绍过 If Statement 的结构：

IfStatement AST

由上图可以看到，If Statement 包含三个部分：Exp、True Branch、False Branch，其中 True Branch 为表达式求值为真的时候执行的 Block，而 FalseBranch 可以是 Elseif Statement 或 Else Statement 或 nil。Elseif Statement 的构成与 If Statement 相同，Else Statement 则只包含一个 Block。

下面先来看一下 If Statement 的实现：

func (p *Parser) parseIfStatement() syntax.SyntaxTree {
    p.nextToken()
    assert(p.currentToken.Category == scanner.TokenIf, "not a if statement")
    exp := p.parseExp()
    if p.nextToken().Category != scanner.TokenThen {
        panic(&Error{
            module: p.module,
            token:  p.currentToken,
            str:    "expect 'then' for 'if' statement",
        })
    }
    trueBranch := p.parseBlock()
    falseBranch := p.parseFalseBranchStatement()
    return &syntax.IfStatement{
        Exp:         exp,
        TrueBranch:  trueBranch,
        FalseBranch: falseBranch,
    }
}

首先，自然是判断当前的 Token 类型是否为 TokenIf；然后调用 parseExp 解析紧随其后的表达式；然后判断下一个 Token 的类型是否为 TokenThen，如果不是，则报告语法错误；然后我们调用 parseBlock 来解析 True Branch，调用 parseFalseBranchStatement 解析 False Branch。

上面说过，False Branch 有三种情况，容易想到，parseFalseBranchStatement 方法会根据下一个 Token 的类型是 TokenElseif、TokenElse 还是 TokenEnd 来执行不同的动作，下面就来看一下具体的实现：

func (p *Parser) parseFalseBranchStatement() syntax.SyntaxTree {
    if p.lookAhead().Category == scanner.TokenElseif {
        return p.parseElseifStatement()
    } else if p.lookAhead().Category == scanner.TokenElse {
        return p.parseElseStatement()
    } else if p.lookAhead().Category == scanner.TokenEnd {
        p.nextToken()
    } else {
        panic(&Error{
            module: p.module,
            token:  p.lookAheadToken,
            str:    "expect 'end' for 'if' statement",
        })
    }
    return nil
}

parseFalseBranchStatement 方法的实现很容易懂，这里就不再详细解释了。因为 Elseif Statement 与 If Statement 的形式完全相同，所以解析它的方法的实现也基本相同，而 Else Statement 则只是简单地调用一个 parseBlock 方法就可以了，也不再细说，这两个方法的实现在下面：

func (p *Parser) parseElseifStatement() syntax.SyntaxTree {
    p.nextToken()
    assert(p.currentToken.Category == scanner.TokenElseif,
        "not a 'elseif' statement")
    exp := p.parseExp()
    if p.nextToken().Category != scanner.TokenThen {
        panic(&Error{
            module: p.module,
            token:  p.currentToken,
            str:    "expect 'then' for 'elseif' statement",
        })
    }
    trueBranch := p.parseBlock()
    falseBranch := p.parseFalseBranchStatement()
    return &syntax.ElseifStatement{
        Exp:         exp,
        TrueBranch:  trueBranch,
        FalseBranch: falseBranch,
    }
}

func (p *Parser) parseElseStatement() syntax.SyntaxTree {
    p.nextToken()
    assert(p.currentToken.Category == scanner.TokenElse,
        "not a 'else' statement")
    block := p.parseBlock()
    if p.nextToken().Category != scanner.TokenEnd {
        panic(&Error{
            module: p.module,
            token:  p.currentToken,
            str:    "expect 'end' for 'else' statement",
        })
    }
    return &syntax.ElseStatement{Block: block}
}

本节就先说到这里，在下一节中，我们将继续讲解解析 Local Statement 和 Other Statement 的方法实现。

获取源代码

---

代码已托管到 GitHub 上：SLua，每一个阶段的代码我都会创建一个 release，你可以直接下载作为参照。虽然提供了源代码，但并不建议直接复制粘贴，因为这样学到的知识会很容易忘记。

如果你觉得这篇教程有帮助，请不要吝啬给文章点个喜欢，我会更加有动力将这个系列写下去。关注一下简书和 GitHub 可以在第一时间获得更新提醒哦。