特别行政区界线lisp_类Lisp解释器JavaScript实现

类 Lisp 语言语法

(define fib (lambda (n)

(if (< n 2) 1

(+ (fib (- n 1)) (fib (- n 2))))))

观察上述斐波那契数生成函数。

使用 define 关键字绑定变量与实体

全部使用前缀表达式

没有 return 关键字

循环多采用递归实现

函数被称为“lambda表达式”，使用 lambda 关键字定义

函数必须有返回值

编译原理基本知识

使用某种语言来编写的一段程序本质上是字符串，编译器/解释器的任务是将这段字符串翻译为某个“执行器”可以理解的编码。

我认为编译器和解释器最大的不同在于，前者存在明显输出，且输出为某执行器可以理解的字符串(编码)；后者没有明显输出，它直接执行了该段字符串(源程序)所表达的东西(此处应当被提出质疑)。

本文只介绍解释器的基本组成。

解释器从接受源程序到最终执行的基本过程有：

词法分析。这个步骤会将源代码分解为该语言的最小组成元素(一个一个的短字符串)。如 var a = 1; 会被分解为 ['var', 'a', '=', '1']。形如这样的短字符串，我们称其为“Token”。

语法分析。这个步骤会根据该语言的自身语法规则分析 Token 列表，检查源代码是否有语法错误，如果没有，则解析出一个抽象语法树(AST)，语义及代码块之间的关系都由树状数据结构进行描述。

执行。当 AST 被生成之后，解释器会继续对 AST 进行分析，遵照 AST 表达出的语义来执行，其执行结果就是源代码所想要的执行结果。一些语言特性，比如闭包，就是在执行函数中实现的。

实现

接下来我们将实现一个支持整数与浮点数运算、数组类型、lambda 表达式，有着基本逻辑语句的类 Lisp 语言解释器。

词法分析

由于类 Lisp 语言本身语法比较简洁，所以词法分析的实现也会比较简单：

function tokenize(program) {

return program.replace(/\(/g, ' ( ').replace(/\)/g, ' ) ').split(' ')

}

语法分析

在生成 AST 的过程中，需要将每一个 Token 的“身份”做确认，比如 var 和 a 是关键字，1 是整数，给 Token 做身份标记。这里使用数组实现 AST。

// 生成抽象语法树

function read_from_tokens(tokens) {

if (tokens.length === 0) {

throw new Error('unexpected EOF while reading')

}

let token = tokens.shift()

while (token === '') {

token = tokens.shift()

}

if ('(' === token) {

let L = []

while (tokens[0] === '') {

tokens.shift()

}

while (tokens[0] !== ')') {

L.push(read_from_tokens(tokens))

while (tokens[0] === '') {

tokens.shift()

}

}

tokens.shift()

return L

} else if (')' === token) {

throw new Error('unexpected )')

} else {

return atom(token)

}

}

// 元类型 Meta，所有数据类型的基类，随着解释器的完善会变得有用，亦在语义的角度可体现出其合理性，但在本文中不做讨论

class Meta {

constructor(value) {

this.value = value

}

}

// 符号类型 如 if define 自定义变量等语言关键字都属于此类型

class Sym extends Meta {

constructor(value) {

super(value)

}

}

// 将 token 的类型具体化

function atom(token) {

let temp = parseInt(token)

if (isNaN(temp)) {

return new Sym(token)

} else if (token - temp === 0) {

return temp

} else {

return parseFloat(token)

}

}

执行

执行的过程是解释器的核心，在这里实现为一个 eval 函数。

eval 函数

eval 函数的大致结构是一个状态机，按照该语言的语法规则对 AST 进行解析。

function eval(x, env=global_env) {

if (x instanceof Sym) { // 如果该 Token 是关键字

return env.find(x.value)[x.value] // 在当前作用域中寻找与该 Token 绑定的实体

} else if (! (x instanceof Array)) { // 不是数组

return x // 直接返回(因为此时会认为它是整数或浮点数)

} else if (x[0].value == 'if') { // 如果是 if

let [sym, test, conseq, alt] = x // 按照该语言语法中约定的 if 语句的格式提取信息

let exp = (eval(test, env) ? conseq : alt)

return eval(exp, env)

} else if (x[0].value == 'define') { // 如果是 define

let [vari, exp] = x.slice(1)

env.add(vari.value, eval(exp, env))

} else if (x[0].value == 'lambda') { // 如果是 lambda

let [parms, body] = x.slice(1)

return new Procedure(parms, body, env) // 创建一个 Procedure 实例

} else if (x[0].value == 'quote') { // 如果是 quote

let [sym, exp] = x

return exp

} else { // 否则(这里可能的情况是：x 是一个数组或一个过程(函数，在这里的实现为 Procedure 的实例，下面会讲到))

let proc = eval(x[0], env)

let args = []

x.slice(1).forEach(function(arg) {

args.push(eval(arg, env))

})

if (proc instanceof Procedure) {

return proc.execute.call(proc, args)

}

return proc.apply(this, args)

}

}

函数与环境

在该语言中，我们规定，作用域的界线是函数，且该作用域是词法作用域(与 JavaScript 相同)。

所以每当碰到函数调用的时候，我们都需要创建一个新的求值环境，并使该函数被声明时所在的环境成为这个新的求值环境的父环境(如果不明白为什么这样规定，请自行搜索词法作用域)。故当我们在任何地方查找变量时，都应顺着环境链(作用域链)向上查找，直到找到。如果找不到，则抛异常。

由此，我们可以将作用域理解为一个类似单向链表的数据结构。

// Procedure 类，该语言中函数的实现

class Procedure {

constructor(parms, body, env) {

this.parms = parms

this.body = body

this.env = env

}

execute(args) {

return eval(this.body, new Env(this.parms, args, this.env))

}

}

// Env 类，该语言中求值环境的实现

class Env {

constructor(parms=[], args=[], outer=null) {

this.e = new Object()

this.init(parms, args)

this.outer = outer // 父环境

}

// 在该环境中查找某个变量

find(vari) {

if ((! (vari in this.e)) && (! this.outer)) {

throw new ReferenceError('variable ' + vari + ' is undefined.')

}

return vari in this.e ? this.e : this.outer.find(vari)

}

init(keys, values) {

keys.forEach((key, index) => {

this.e[key.value] = values[index]

})

}

assign(subEnv) {

Object.assign(this.e, subEnv)

}

add(key, value) {

this.e[key] = value

}

}

// 初始化一个全局环境

let global_env = new Env()

global_env.assign(baseEnv)

尾声

至此，这个简单的解释器就已经完成了，涉及到更多细节，如异常定义、全局环境定义，可以点此查看完整的代码。

我建议大家如果有兴趣可以自己动手实现一下，对解释器原理以及闭包会有更深刻的理解。

本文的完成比较仓促，如果大家有什么疑问可以点此阅读该解释器的 Python 实现，作者讲解得非常详细，也有很多测试用例，我正是阅读了这篇文章才写了 JavaScript 版。

如果有任何错误之处，请通过邮箱(sevenskey@163.com)和 GitHub (Sevenskey)联系我。

感谢阅读qwq