类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