警告??：這將是一個(gè)又臭又長(zhǎng)的系列教程，教程結(jié)束的時(shí)候，你將擁有一個(gè)除了性能差勁、擴(kuò)展性差、標(biāo)準(zhǔn)庫(kù)不完善之外，其他方面都和官方相差無(wú)幾的 Lua 語(yǔ)言解釋器。說(shuō)白了，這個(gè)系列的教程實(shí)現(xiàn)的是一個(gè)玩具語(yǔ)言，僅供學(xué)習(xí)，無(wú)實(shí)用性。請(qǐng)謹(jǐn)慎 Follow，請(qǐng)謹(jǐn)慎 Follow，請(qǐng)謹(jǐn)慎 Follow。

這是本系列教程的第五篇，如果你沒(méi)有看過(guò)之前的文章，請(qǐng)從頭觀看。

前言

語(yǔ)法分析算是 SLua 解釋器中相對(duì)復(fù)雜的一個(gè)模塊了，為了避免篇幅過(guò)長(zhǎng)，我們將分成多篇來(lái)講解，本文是第一部分。

有了上一節(jié)定義的一系列 AST 節(jié)點(diǎn)，本節(jié)可以開(kāi)始定義 Parser 類(lèi)型及其方法了。 Parser 以 Scanner 類(lèi)型輸出的 Token 序列作為輸入，將其解析為一棵 AST。

使用方式

在實(shí)現(xiàn)之前，先來(lái)看一下在 Parser 完成之后，我們應(yīng)該怎樣來(lái)使用它：

// slua.go

package main

import (
    "fmt"
    "strings"

    "github.com/ksco/SLua/parser"
    "github.com/ksco/slua/scanner"
)

func main() {
    defer func() {
        if err := recover(); err != nil {
            fmt.Println(err)
        }
    }()
    r := strings.NewReader("local さよなら = 'Hello, 世界'")
    s := scanner.New(r)
    p := parser.New(s)
    tree := p.Parse()
    // do something with tree next...
}

可以看到，parser 導(dǎo)出了一個(gè) New 函數(shù)，用于生成 Parser 實(shí)例，它接受一個(gè) Scanner 類(lèi)型的實(shí)例，以便在內(nèi)部調(diào)用它的 Scan 方法來(lái)獲得 Token 序列。Parser 類(lèi)型有一個(gè)名為 Parse 的公共方法，這個(gè)方法所做的工作就是語(yǔ)法分析器的全部，它的返回值即我們需要的語(yǔ)法分析樹(shù)(AST)。在后續(xù)的語(yǔ)義分析、代碼生成階段，我們都是通過(guò)遍歷 AST 來(lái)完成工作的。

具體實(shí)現(xiàn)

下面就來(lái)看一下 parser 模塊的具體實(shí)現(xiàn)。

Parser 類(lèi)型定義

type Parser struct {
    s              *scanner.Scanner
    module         string
    currentToken   *scanner.Token
    lookAheadToken *scanner.Token
}

下面我們來(lái)詳細(xì)講一下每個(gè)參數(shù)的作用。

• s：用于存儲(chǔ)傳進(jìn)來(lái)的 Scanner 實(shí)例。
• module：與 Scanner 中的 module 模塊作用相同，都是保存模塊名稱(chēng)，用于報(bào)錯(cuò)。
• currentToken：存儲(chǔ)當(dāng)前所在位置的 Token。
• lookAheadToken：因?yàn)樵诮馕鲞^(guò)程中，有時(shí)需要“向前看一步”才能確定如何進(jìn)行解析，所以我們需要存儲(chǔ)當(dāng)前位置的下一個(gè) Token。

New 函數(shù)定義

New 函數(shù)的定義非常簡(jiǎn)單：

func New(s *scanner.Scanner) *Parser {
    p := new(Parser)
    p.s = s
    p.module = "parser"
    p.currentToken = scanner.NewToken()
    p.lookAheadToken = scanner.NewToken()
    return p
}

初始化時(shí)，currentToken 和 lookAheadToken 的類(lèi)型都為 TokenEOF。

Parse 方法初探

在定義 Parse 方法之前，我們需要定義兩個(gè)輔助性的私有方法來(lái)操作 currentToken 和 lookAheadToken 變量。函數(shù)定義如下：

func (p *Parser) nextToken() *scanner.Token {
    if p.lookAheadToken.Category != scanner.TokenEOF {
        p.currentToken = p.lookAheadToken.Clone()
        p.lookAheadToken.Category = scanner.TokenEOF
    } else {
        p.currentToken = p.s.Scan()
    }
    return p.currentToken
}

func (p *Parser) lookAhead() *scanner.Token {
    if p.lookAheadToken.Category == scanner.TokenEOF {
        p.lookAheadToken = p.s.Scan()
    }
    return p.lookAheadToken
}

先來(lái)看 lookAhead 方法，它的邏輯是，如果 lookAheadToken 的類(lèi)型為 TokenEOF，則說(shuō)明其沒(méi)有存儲(chǔ)有效值，就調(diào)用 Scan 函數(shù)讀取一個(gè)新的 Token 存儲(chǔ)到 lookAheadToken 中，并將其返回。如果已經(jīng)存儲(chǔ)了有效值了，則直接返回。

而 nextToken 方法則用于讀取下一個(gè) Token 作為當(dāng)前的 Token，將其存儲(chǔ)于 currentToken 中，并返回。它的邏輯是，如果 lookAheadToken 的類(lèi)型不是 TokenEOF，則說(shuō)明之前調(diào)用過(guò) lookAhead 函數(shù)，所以我們就直接讀取它的值作為 currentToken，否則，就調(diào)用 Scan 方法來(lái)獲取下一個(gè) Token。

有了兩個(gè)函數(shù)，我們就可以正式開(kāi)始定義 Parse 函數(shù)了。上一節(jié)我們提到過(guò)，AST 的根節(jié)點(diǎn)為 Chunk，而 Chunk 的唯一子節(jié)點(diǎn)是 Block。所以，Parse 函數(shù)的定義其實(shí)非常簡(jiǎn)單：

func (p *Parser) Parse() syntax.SyntaxTree {
    return p.parseChunk()
}

在實(shí)現(xiàn) parseChunk 函數(shù)之前，我們先要介紹一下 parser 模塊的錯(cuò)誤處理方式，跟 scanner 模塊相同，我們定義了滿(mǎn)足 error 接口的 Error 類(lèi)型來(lái)表示錯(cuò)誤：

package parser

import (
    "fmt"

    "github.com/ksco/slua/scanner"
)

type Error struct {
    module string
    token  *scanner.Token
    str    string
}

func (e *Error) Error() string {
    return fmt.Sprintf("%v:%v:%v: '%v' %v", e.module, e.token.Line,
        e.token.Column, e.token.String(), e.str)
}

func assert(cond bool, msg string) {
    if !cond {
        panic("lemon/parser internal error: " + msg)
    }
}

此外，我們還定義了一個(gè) assert 函數(shù)來(lái)表示斷言。因?yàn)?Go 語(yǔ)言沒(méi)有提供系統(tǒng)斷言函數(shù)，所以就只能自己定義一個(gè)。

parseChunk 函數(shù)定義如下：

func (p *Parser) parseChunk() syntax.SyntaxTree {
    block := p.parseBlock()
    if p.nextToken().Category != scanner.TokenEOF {
        panic(&Error{module: p.module, token: p.currentToken,
            str: "expect <eof>"})
    }
    return &syntax.Chunk{Block: block}
}

因?yàn)?Chunk 的唯一子節(jié)點(diǎn)是一個(gè) Block，所以我們首先調(diào)用 parseBlock 函數(shù)去解析它，如果源代碼沒(méi)有語(yǔ)法問(wèn)題，則在解析完成后，Scanner 應(yīng)該剛好解析到代碼結(jié)尾，所以下一個(gè) Token 的類(lèi)型應(yīng)該為 TokenEOF，如果不是，則說(shuō)明代碼存在語(yǔ)法錯(cuò)誤，所以使用 panic 函數(shù)拋出錯(cuò)誤。如果代碼沒(méi)有錯(cuò)誤，我們將解析完成后得到的 Chunk 返回，這就是我們要得到的 AST 了。

在討論怎樣去解析 Block 之前，我們先看一下 Block 到底是什么。簡(jiǎn)單來(lái)說(shuō)，Block 是一系列語(yǔ)句的集合。那么都在哪些情況下的語(yǔ)句集合算 Block 呢？首先，我們知道，整個(gè)程序是一個(gè) Block。除此之外 ，以下列表中的 <block> 部分都屬于 Block：

• do <block> end
• while <exp> do <block> end
• if <exp> then <block> end
• if <exp> then <block> elseif ...
• if <exp> then <block> else ...

根據(jù)上面的總結(jié)，我們可以得出一個(gè)結(jié)論：所有的 Block 結(jié)尾的下一個(gè) Token 的類(lèi)型必然是 TokenEOF、TokenEnd、TokenElseif、TokenElse 其中之一，我們可以根據(jù)這個(gè)信息來(lái)判斷當(dāng)前的 Block 是否結(jié)束。知道了這個(gè)方法，解析 Block 的工作就簡(jiǎn)單多了。接下來(lái)，我們就看一下 parseBlock 函數(shù)是如何工作的吧。

func (p *Parser) parseBlock() syntax.SyntaxTree {
    block := &syntax.Block{}
    for p.lookAhead().Category != scanner.TokenEOF &&
        p.lookAhead().Category != scanner.TokenEnd &&
        p.lookAhead().Category != scanner.TokenElseif &&
        p.lookAhead().Category != scanner.TokenElse {
        stmt := p.parseStatement()
        if stmt != nil {
            block.Stmts = append(block.Stmts, stmt)
        }
    }
    return block
}

很容易理解吧，我們不斷地判斷下一個(gè) Token 是不是 Block 的結(jié)束 Token 之一，如果不是，那就說(shuō)明接下來(lái)碰到的是一個(gè)語(yǔ)句，我們就調(diào)用 parseStatement 函數(shù)來(lái)解析它，并將解析結(jié)果加入到 Block 節(jié)點(diǎn)的 Stmts 列表中，直到結(jié)束為止。

在 SLua 中，共有以下幾種類(lèi)型的語(yǔ)句(Statement)：空語(yǔ)句、Do 語(yǔ)句，While 循環(huán)語(yǔ)句，If 判斷語(yǔ)句、Local 變量聲明語(yǔ)句、其他語(yǔ)句。所以 parseStatement 的邏輯也非常簡(jiǎn)單，我們只需借助 lookhAhead 函數(shù)“往前看一步”：

• 如果看到的是分號(hào)，則說(shuō)明是一個(gè)空語(yǔ)句，直接跳過(guò)，返回 nil。
• 如果看到的是 do，就調(diào)用 parseDoStatement 函數(shù)。
• 如果看到的是 while，就調(diào)用 parseWhileStatement 函數(shù)
• 剩下的同理...

parseStatement 函數(shù)的定義如下：

func (p *Parser) parseStatement() syntax.SyntaxTree {
    switch p.lookAhead().Category {
    case ";":
        p.nextToken()
    case scanner.TokenDo:
        p.parseDoStatement()
    case scanner.TokenWhile:
        p.parseWhileStatement()
    case scanner.TokenIf:
        p.parseIfStatement()
    case scanner.TokenLocal:
        p.parseLocalStatement()
    default:
        p.parseOtherStatement()
    }
    return nil
}

本節(jié)就先說(shuō)到這里，在下一節(jié)中，我們將繼續(xù)介紹 parseStatement 函數(shù)中用到的各個(gè)函數(shù)的定義。

在第三篇關(guān)于詞法分析的文章的最后部分，我簡(jiǎn)單提及了 Go 語(yǔ)言中進(jìn)行單元測(cè)試的方法，但因?yàn)閷?duì)詞法分析器進(jìn)行單元測(cè)試比較簡(jiǎn)單，所以沒(méi)有詳細(xì)展開(kāi)，而是留給了讀者自己去探索。但對(duì)語(yǔ)法分析器進(jìn)行單元測(cè)試卻比較麻煩，所以在語(yǔ)法分析器編寫(xiě)完成之后，我會(huì)單獨(dú)寫(xiě)一篇文章對(duì) parser 模塊進(jìn)行單元測(cè)試。

獲取源代碼

代碼已托管到 Github 上：SLua，每一個(gè)階段的代碼我都會(huì)創(chuàng)建一個(gè) release，你可以直接下載作為參照。雖然提供了源代碼，但并不建議直接復(fù)制粘貼，因?yàn)檫@樣學(xué)到的知識(shí)會(huì)很容易忘記。

如果你覺(jué)得這篇教程有幫助，請(qǐng)不要吝嗇給文章點(diǎn)個(gè)喜歡，我會(huì)更加有動(dòng)力將這個(gè)系列寫(xiě)下去。：）