Hulo 编程语言开发 解释器

书接上回，在《 Hulo 编程语言开发 包管理与模块解析》一文中，我们介绍了Hulo 编程语言的模块系统。今天，让我们深入探讨编译流程中的第三个关键环节解释器。

作为大杂烩语言的集大成者，Hulo 吸收了 Zig 语言的comptime语法糖。在comptime { ... }表达式的包裹下，代码会在编译的时候执行，就像传统的解释型语言一样。这也为 Hulo 的元编程提供了强大的支撑，使得 Hulo 可以实现类似 Rust 过程宏、编译期反射、直接操作 AST 等强大功能。

编译时执行

假设我们现在有如下代码：

let a = comptime { let sum = 0 loop $i := 0; $i < 10; $i++ { echo $i; $sum += $i; } return $sum } 

在翻译成目标语法的时候会以 let a = 45 进行翻译，中间的一大串代码都会被提前执行。这个执行的过程其实就是解释。

对象化 & 求值

求值就是解释器执行代码的过程。在 Hulo 中，解释器需要能够执行各种类型的表达式和语句。

对象化

在 Hulo 中，所有的值都被"对象化"处理。这意味着无论是数字、字符串还是函数，都被包装成统一的对象接口。

下面是 Hulo 代码中关于对象系统的设计：

// 定义类型的基本行为 type Type interface { Name() string // 获取类型名称 Text() string // 获取类型的文本表示 Kind() ObjKind // 获取类型种类（如基本类型、对象类型等） Implements(u Type) bool // 检查是否实现了某个接口 AssignableTo(u Type) bool // 检查是否可以赋值给某个类型 ConvertibleTo(u Type) bool // 检查是否可以转换为某个类型 } // 继承 Type 接口，定义对象的行为 type Object interface { Type NumMethod() int // 获取方法数量 Method(i int) Method // 根据索引获取方法 MethodByName(name string) Method // 根据名称获取方法 NumField() int // 获取字段数量 Field(i int) Type // 根据索引获取字段 FieldByName(name string) Type // 根据名称获取字段 } // 定义值的基本行为 type Value interface { Type() Type // 获取值的类型 Text() string // 获取值的文本表示 Interface() any // 获取底层的 Go 值 } 

通过这段代码不难看出，这有点类似于 Golang 的反射系统。实际上，对象系统的实现上的确参考了反射机制，所有的单元测试接口甚至也和反射的测试如出一辙。可以说，Hulo 的解释器在抽象 AST 的过程中就是将值与类型转换成反射操作，通过统一的接口来操作不同类型的值。

求值过程

在对象化的基础上，解释器通过遍历 AST 节点来执行代码，根据节点类型执行相应的操作。

假设这个我们有1 + 2 * 3这样一个表达式，它的 AST 结构和求值步骤如下：

BinaryExpr { X: Literal(1), Op: PLUS, Y: BinaryExpr { X: Literal(2), Op: MULTIPLY, Y: Literal(3) } } 

1. 访问根节点 BinaryExpr(PLUS)
2. 先求值左子树 Literal(1) → 1
3. 先求值右子树 BinaryExpr(MULTIPLY)：
   • 求值左子树 Literal(2) → 2
   • 求值右子树 Literal(3) → 3
   • 执行乘法 2 * 3 → 6
4. 执行加法 1 + 6 → 7

而这个求值的过程，我们可以用伪代码表示为：

func (interp *Interpreter) Eval(node ast.Node) Object { switch node := node.(type) { case *ast.Literal: return interp.evalLiteral(node) case *ast.BinaryExpr: return interp.evalBinaryExpr(node) // ... } } func (interp *Interpreter) evalLiteral(node *ast.Literal) Object { // 简化复杂度，我们假设字面量类型都是 number 类型 return &object.NumberValue{Value: node.Value} } func (interp *Interpreter) evalBinaryExpr(node *ast.BinaryExpr) Object { lhs := interp.Eval(node.Lhs) // 计算左值 rhs := interp.Eval(node.Rhs) // 计算右值 // 由 evalLiteral 可知 lhs 、rhs 都是 *object.NumberValue ，并假设 NumberValue 的类型为 NumberType switch node.Op { case token.PLUS: // 根据值进行加法 // 假设 NumberType 有 add 方法可以直接运算 return lhs.Type().(*object.NumberType).MethodByName("add").call(rhs) case token.MULTIPLY: // 根据值进行乘法 } } 

节点会逐层递归求值，每一层的求值结果作为上一层节点的子树继续求值。最终返回的不是原始的string、int、any等类型，而是包装成Object接口的对象，体现了"一切皆对象"的设计理念。

环境管理

解释器维护一个环境(Environment)来存储变量，但为什么要环境管理？这涉及到作用域和变量查找的问题。

为什么需要环境管理？

var globalVar = 100 // 全局变量 fn test() { let localVar = 200 // 局部变量 echo $globalVar // 可以访问全局变量 echo $localVar // 可以访问局部变量 } fn another() { echo $globalVar // 可以访问全局变量 echo $localVar // 错误！无法访问 test 函数的局部变量 } 

作用域链

Hulo 采用词法作用域，变量查找遵循"就近原则"：

let x = 1 // 全局作用域 fn outer() { let x = 2 // 局部作用域，遮蔽了全局的 x fn inner() { let x = 3 // 更内层的作用域 echo $x // 输出 3 ，找到最近的 x } echo $x // 输出 2 ，找到 outer 函数中的 x } echo $x // 输出 1 ，找到全局的 x 

环境链实现

环境通过链表结构实现作用域链：

type Environment struct { store map[string]Value // 当前作用域的变量 outer *Environment // 外层环境（父作用域） } func (e *Environment) Get(name string) (Value, bool) { // 先从当前环境查找 obj, ok := e.store[name] if ok { return obj, true } // 如果没找到，继续在外层环境查找 if e.outer != nil { return e.outer.Get(name) } // 所有环境都没找到 return nil, false } // Fork 创建新的环境，类似于函数调用的栈帧 func (e *Environment) Fork() *Environment { env := NewEnvironment() // 创建新的环境 env.outer = e // 将当前环境作为外层环境 return env // 返回新环境 } 

Ps. 这个代码只是用于展示的最小实现，实际 Hulo 的实现将更为复杂。

环境创建过程

栈帧(Stack Frame) 是函数调用时在调用栈上分配的一块内存，用于存储函数的局部变量、参数和返回地址。

在 Hulo 中，每次函数调用都会通过 Fork() 创建一个新的环境，这个新环境就是一个栈帧：

fn outer() { let x = 10 fn inner() { let y = 20 echo $x + $y // 30 } inner() } 

执行过程：

1. 全局环境 {}
2. 调用 outer() → Fork() → 创建栈帧 1 {x: 10, outer: 全局环境}
3. 调用 inner() → Fork() → 创建栈帧 2 {y: 20, outer: 栈帧 1}
4. 执行 echo → 在栈帧 2 中查找变量
   • 查找 y：栈帧 2 中找到 20
   • 查找 x：栈帧 2 没有 → 栈帧 1 中找到 10
5. inner()返回 → 销毁栈帧 2 ，回到栈帧 1
6. outer()返回 → 销毁栈帧 1 ，回到全局环境