《Language Implementation Patterns》之 解释器
前面讲述了如何验证语句，这章讲述如何构建一个解释器来执行语句，解释器有两种，高级解释器直接执行语句源码或AST这样的中间结构，低级解释器执行执行字节码(更接近机器指令的形式）。
高级解释器比较适合DSL，而不适合通用编程语言；一般来说，DSL更需要简单、廉价的实现，不是很在乎执行效率；这个笔记只学习高级解释器，下面的文字如果提到解释器就是指“高级”解释器。为了简单起见，下面的讨论假定目标DSL是动态类型的。
解释器有两种模式：
- Pattern 24，Syntax-Directed Interpreter，通过Parser来触发解释器执行；
- Pattern 25，Tree-Based Interpreter，解释器通过遍历AST树来执行操作。
解释器模拟了一个计算机，“计算机”应该包含CPU，代码存储，数据存储，栈。CPU从代码存储里面读取指令，并解释执行；指令可能读写数据和栈；函数调用需要记住返回地址以便继续执行。实现一个解释器需要考虑3个核心问题：
- 如何存储数据；
- 如何追踪符号；
- 如何执行指令
设计解释器存储系统
解释器通过变量名字来存储对应的值，而不是内存地址；因此我们通过一个name:value的字典来代表内存区域；有三种内存空间需要我们考虑，全局内存，函数栈，数据聚合实例(struct或对象)；一个内存空间实际对应着一个作用域。
解释器有一个全局空间，多个函数内存空间；每个函数调用创建一个新的内存空间来存储局部变量和参数变量；解释器通过一个栈来管理函数内存空间。
看下面的C++代码：
int x = 1;
void g(int x) { int z = 2; }
void f(int x) { int y = 1; g(2*x); }
int main() { f(3); }
在执行z=2时，内存空间类似下图：
同样，解释器也可能存在多个数据聚合内存空间，看下面的C++代码：
struct A { int x; };
int main() {
A *a = new A(); a->x = 1;
A *b = new A(); b->x = 2;
}
对应的内存空间类似下图：
main函数的内存空间里面有两个变量a、b，分别指向一个struct内存空间，a->x=1这样的操作类似a.put('x',1)。对class的实例来说，最简单的方式是将所有的字段打包到一个内存空间里面，“继承”在这里是“include”的含义。
追踪符号
对于语言里面的一个变量x引用，解释器必须要判断它属于哪个内存空间，才能执行读写操作。解释器通过解析符号x，询问它的作用域；作用域告诉解释器变量属于何种内存空间：全局、函数、数据聚合，这样解释器就能挑选合适的内存空间字典。如果变量是一个全局变量，那么解释器从全局空间加载它；如果变量是一个函数局部变量，那么解释器从栈顶的函数内存空间；如果变量是一个字段，那么解释器先加载this变量，再从this指向的内存空间加载字段值。
符号表管理也发生在运行时，因此解析变量和加载变量很容易被混淆；前者主要依据程序的静态结构，判定符号所属的作用域；后者是纯粹的运行时行为，绑定符号和值，同一个函数局部变量，在运行时可能指向不同的内存值。在运行时解析一个变量是很昂贵的操作，因此有些语言强制符号自身要指出自己的作用域，比如Ruby，$x指示x是一个全局变量，@x指示x是一个对象字段。
动态类型的语言在使用变量之前不会提前声明，因此定义一个严格的符号表没有什么意义；但是符号表管理仍然是需要的，因为至少我们需要知道语言是否在访问一个未定义的变量。在下面的python函数中：
def fun(x):
x = 5;
y = 6;
如果没有符号表，那么在运行时解释器无法分别x=5是在操作参数变量，y=6创建了一个新的局部变量。
而C++&java这些静态类型的语言则需要完整的scope tree。
Pattern 24, Syntax- Directed Interpreter
该模式直接执行源码，不会将源码转换成某种中间形式或其他语言；实现上实际就是对Parser的功能进行增强，直接插入指定执行代码；适合简单的语言，代码是有声明和指令语句序列。
这种解释器模拟了人手动理解并计算代码结果的过程，我们逐句读代码，解析&验证&执行指令；只包含两个关键部分：
- Source Code Parser，解析语句并直接触发操作；
- Interpretor，保持状态，并为语句指令提供内部实现方法；可能包含一个code内存空间，和一个global内存空间。
Parser在解析到某个语句模式的时候，直接触发相应的操作，因此语言的语法描述类似"match this, call that"这样的模式；当Parser遇到一个赋值表达式，就会期望intepretor提供assgin()和store()方法来完成操作。
assignment : ID '=' expr {interp.assign($ID, $expr.value);} ;
expr returns [Object value] : ... ; // compute and return value
这里以一个SQL子集为例来构建解释器，SQL是一个用来执行数据库操的DSL，这个子集允许这样的语句：
create table users (primary key name, passwd);
insert into users set name='parrt', passwd='foobar';
insert into users set name='tombu', passwd='spork';
p = select passwd, name from users; // reverse column order print p;
对应的语法定义如下：
table
: 'create' 'table' tbl=ID
'(' 'primary' 'key' key=ID (',' columns+=ID)+ ')' ';'
{interp.createTable($tbl.text, $key.text, $columns);}; //create table sql 调用Interpreter的createTable方法
assign : ID '=' expr ';' {interp.store($ID.text, $expr.value);} ; //assign语句调用Interpreter的store方法来存储变量
// Match a simple value or do a query
expr returns [Object value] //表达式语法不仅匹配对应的表达式，而且对表达式进行求值
: ID {$value = interp.load($ID.text);}
| INT {$value = $INT.int;}
| STRING {$value = $STRING.text;}
| query {$value = $query.value;}
;
解释器构建了两个存储空间，一个用来存储内存全局变量，一个用来存储数据表：
class Interpreter {
Map<String, Object> globals = new HashMap<String, Object>();
Map<String, Table> tables = new HashMap<String, Table>();
}
Pattern 25, Tree- Based Interpreter
该模式基于AST来执行指令，通过AST访问器来驱动解释器，支持前向应用等复杂特性；由于预先构建了AST和scope Tree，因此可以进行一些预处理，比如AST改写，将某些x引用改写为this.x的形式；执行速度上也要快一些。
该模式解释器类比编译程序的话，相当于保留编译器前端，将后端替换成一个执行器；这一节通过构建一种类Python的动态类型语言Pie来讲述解释器。
Pie语言概述
Pie程序包含一系列的函数定义、struct定义和语句；赋值语句左侧的变量如果尚未定义，那么则定义一个，但是其他方式访问一个未定义的变量会产生一个错误；Pie有return，if，while这些控制结构；支持字符、字符串、整形这些子面量；支持操作符==, <, +, -, *, new，还有.(成员访问)；struct可以定义在globle作用域也可以定义函数作用域。
x= 1 # define global variable x
def f(y): # define f in the global space
x=2 # set global variable x
y=3 # set parameter y
z=4 # create local variable z
. # end of statement list
f(5) # call f with parameter y = 5
struct Point {x, y} # define a struct symbol in global scope
p = new Point # create a new Point instance; store in global var
p.x = 1 # set the fields of p
p.y = 2
该模式预先定义好了函数、struct，通过传统的scope tree来解析符号。将符号表构建与程序执行分开极大地简化了解释器，解释器只负责内存空间；当然，在执行的过程中仍然需要scope信息来解析符号。
为了能够从parse阶段传递scope信息给解释执行阶段，我们可以标记AST节点；函数调用f()创建了一个(CALL f)子树，此时Parser将CALL节点的scope字段设置为当前Scope。在执行的时候，call指令基于那个scope来解析名字f。
解释器相当于Pattern13介绍的External Tree Visitor，当遇到=、if、CALL根节点的时候，dispatcher方法触发assign( ), ifstat( )和call( )这样的执行方法。”执行方法“有一个AST节点作为参数，需要访问该节点的子节点。
解释器实现
首先定义好语法规则Pie.g，构建好scope tree和AST；然后为解释器编写内部方法来实现Pie的各种指令和操作，解释器提供一个接口exec()给AST Visitor。
Pie的AST节点类型都继承自PieAST，PieAST有scope字段，是从一般的AST节点类型CommonTree继承的。
Pie的scope tree符合Pattern 18(Symbol Table for Data Aggregates)，包含了若干symbol类型：VariableSymbol、FunctionSymbol、StructSymbol。
我们看一下解释器的核心成员变量：
public class Interpreter {
GlobalScope globalScope; // global作用域，scope tree的root node
MemorySpace globals = new MemorySpace("globals"); // global内存空间
MemorySpace currentSpace = globals; //当前内存空间
Stack<FunctionSpace> stack = new Stack<FunctionSpace>();// 函数内存空间组成调用栈
PieAST root; // AST根节点，代表了code内存空间
TokenRewriteStream tokens;
PieLexer lex; // 词法分析器
PieParser parser; //语法解析器
//这是visitor的dispatcher方法，要来执行AST各种subtree对应的操作
public Object exec(PieAST t) {
switch ( t.getType() ) {
case PieParser.BLOCK : block(t); break;
case PieParser.ASSIGN : assign(t); break;
case PieParser.RETURN : ret(t); break;
case PieParser.PRINT : print(t); break;
case PieParser.IF : ifstat(t); break;
case PieParser.CALL : return call(t);
case PieParser.NEW : return instance(t);
case PieParser.ADD : return add(t);
case PieParser.INT : return Integer.parseInt(t.getText()); case PieParser.DOT : return load(t);
case PieParser.ID : return load(t);
...
default : «error» // catch unhandled node types
}
}
//唯一的参数是AST subtree root节点
//执行一个AST subtree，意味着执行对应的指令，并访问子树的节点；
public void assign(PieAST t) {
PieAST lhs = (PieAST)t.getChild(0); //左侧操作数
PieAST expr = (PieAST)t.getChild(1); //右侧表达式
Object value = exec(expr); //递归调用exec来对表达式求值
if ( lhs.getType()==PieParser.DOT ) { //左侧额操作数是ID.memeber的形式，struct字段
fieldassign(lhs, value); // field ^('=' ^('.' a x) expr)
return;
}
// var assign ^('=' a expr)
MemorySpace space = getSpaceWithSymbol(lhs.getText());
if ( space==null ) space = currentSpace; //如果变量不存在，则在当前内存空间创建它
space.put(lhs.getText(), value); // store
}
//获取符号对应的内存空间
public MemorySpace getSpaceWithSymbol(String id) {
if (stack.size()>0 && stack.peek().get(id)!=null) { //先在栈空间里找
return stack.peek();
}
if ( globals.get(id)!=null ) return globals; //再在全局空间里面找
return null; // nowhere
}
//给struct的字段赋值，与对global空间或函数空间的变量赋值并没有本质的不同
//区别在于，会在scope tree里面去寻找这个字段名，如果发现没有，会产生一个错误
public void fieldassign(PieAST lhs, Object value) {
PieAST o = (PieAST) lhs.getChild(0);
PieAST f = (PieAST) lhs.getChild(1);
String fieldname = f.getText();
Object a = load(o);
StructInstance struct = (StructInstance)a;
if ( struct.def.resolveMember(fieldname) == null ) {
listener.error("can't assign; "+struct.name+" has no "+fieldname+
" field", f.token);
return;
}
struct.put(fieldname, value);
}
//函数分几个步骤，创建内存空间，构建参数变量，执行函数体，返回
public Object call(PieAST t) {
String fname = t.getChild(0).getText();
FunctionSymbol fs = (FunctionSymbol)t.scope.resolve(fname);
if ( fs==null ) {
listener.error("no such function "+fname, t.token);
return null;
}
FunctionSpace fspace = new FunctionSpace(fs); //创建一个新的函数内存空间
MemorySpace saveSpace = currentSpace;
currentSpace = fspace;
int i = 0; //在函数内存空间做好参数名字和参数值的映射
for (Symbol argS : fs.formalArgs.values()) {
VariableSymbol arg = (VariableSymbol)argS;
PieAST ithArg = (PieAST)t.getChild(i+1);
Object argValue = exec(ithArg);
fspace.put(arg.name, argValue);
i++;
}
Object result = null;
stack.push(fspace);
try {
exec(fs.blockAST); // 执行函数体，return语句通过一个异常来提前返回
}
catch (ReturnValue rv) {
result = rv.value;
} // trap return value
stack.pop();
currentSpace = saveSpace;
return result;
}
//return指令，通过抛出异常来结束函数体执行
public void ret(PieAST t) {
sharedReturnValue.value = exec((PieAST)t.getChild(0));
throw sharedReturnValue;
}
由于scope tree和AST是提前构建好的，所以Pie支持前向引用，下面的代码可以正常执行：
print f(4) # references definition on next line
def f(x) return 2*x
print new User # references definition on next line
struct User { name, password }
