从零初阶已毕 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 可以在第一时间获得更新提示哦。