一棵树，许多模块

# 一棵树，许多模块

## 模块就是一个节点

Fun 里的一切都是同一棵树上的节点。解析器把源码变成一棵 `CNode` 对象树，解释器遍历这棵树算出值。没有字节码，没有中间表示，也没有单独的「模块运行时」。

树分成两个族：

- 语句（`CRun`，重写 `run(env)`）：`CAssign`、`CCall`、`CReturn`、`CRuns`（一个块）；
- 表达式（`CExp`，重写 `calc`/`calcValue`）：`CVar`、`CLeft`/`CId`、`CFunc`（闭包）、`CNew`/`CObj`。

对象系统也用同一批节点类搭起来，所以「调用函数」和「构造对象」共享一套机制。而模块——`CModu`——不过是记住了自己文件名的一个 `CRuns`：

```pascal
CModu = class(CRuns) ... end;
```

模块就是一块语句。这让它感觉是原生的一部分，而不是外部引进的东西。

## `use`：链接节点，而不是搬移命名空间

`use` 把另一个脚本拉进当前作用域，在核心里只是 `CRuns` 上的一个方法：

```pascal
procedure CRuns.use(n: CRuns; const id: fun.str = '');
begin
  base.add(n);
  add(n);
  if id <> '' then
    CVar.new(self, id).assign(n)   // use 'lib.fun' as name
  else
    used.add(n)                    // use 'lib.fun'
  ;
end;
```

两点值得注意。

第一，`use` 是结构上的链接，不是文本包含。模块 `n` 成为当前 `CRuns` 的一个子节点。标识符解析（`UID`）先查模块自己的变量表，再按逆序遍历 `used` 子模块，最后回退到继承查找。这是一条用同一棵树搭出来的作用域链，模块表现得就像嵌套的作用域。

第二，可选的别名把模块变成变量。`use 'lib-fd.fun' as fd` 把模块绑定到当前作用域的 `fd`，需要时才引入命名空间，不必另造一套命名空间机制。

解析器补上了让模块可靠的簿记：

- **不重复加载**：根模块维护已加载 `CModu` 的链，`find(fileName)` 遍历它，`use` 同一文件两次复用同一个已解析实例。
- **只运行一次**：`CModu.run` 用 `runed` 标志作守卫，无论多少处 `use`，模块顶层代码只执行一次。
- **路径解析**：`ParseFileName` 先试调用者所在目录，再试可执行文件旁的 `lib\` 和 `app\` 目录。库搜索路径本身就是一次小型的分层查找。

`:` 前缀拉取的是内嵌资源而不是磁盘文件：`use ':fd.bnf.fd' as rules` 加载内嵌在二进制里的文法。连解析器自己的数据都是模块。

## 核心分层

整个解释器只有几千行，装在一个不大的目录树里，每一层只依赖它上面的那些层：

```text
core/fun.pas    类型别名（int、str、bool……）+ Variant 桥
core/base.pas   CBase（引用计数根类）、CList、CHash、调用栈
core/core.pas   抽象语法树 + 对象系统 + CModu        <- 心脏
core/flow.pas   if / case / loop / for / try，建立在 CGoto/CRuns 原语之上
core/calc.pas   运算符（calc.inc 是分派表）
core/io.pas     文件 IO + 代码页处理
```

分层在类层级里看得一清二楚：`CIf`、`CCase`、`CLoop`、`CTry` 都是用*组合* `core.pas` 里的原语搭出来的，而不是新增一套机制。控制流不是独立子系统——它是 `flow.pas` 去继承 `CGoto`/`CBloc`。模块化在这里意味着「新构造用旧构造表达」，核心因此保持小。

## 内建库可插拔

当解释器无法原生解析一次调用时，它委托给 `CEnv2.call`，后者遍历已注册的 `CLib`：

```pascal
CEnv2 = class(CEnv)
protected
  libs: CList;                 // 已注册的内建库
...
```

一个内建方法只是一个固定签名的过程：

```pascal
CPasFun = procedure (env: CEnv; exp: CExp; exps: CExps; val: PValue);
```

任何单元都能注册一个应答方法调用的 `CLib`。又因为功能在构建时可选，运行时本身也是模块化的——`host.pas` 在编译开关后面拉入可选单元：

```pascal
uses libase, libset
     {$IfDef WinCOM}, winole{$EndIf}
     {$IfDef WinAPI}, winapi{$EndIf}
     {$IfDef Regex} , regex {$EndIf}
     {$IfDef FunUI} , ui    {$EndIf}
     ;
```

同样的开关也出现在 `fun.pas` 等处。内建代码因此有**三层**模块化：解释器核心、运行时扩展它的已注册 `CLib`、以及决定哪些单元被编进去的编译期特性开关。

## 自托管的标准库

在那一小撮内建方法之上，是 `fun/lib` 里的标准库：**58 个用 Fun 自己写成的模块**。库用同一种语言写成，「语言」和「库」之间的界线因此被压得很薄。

这些模块形成一个依赖 DAG，而不是一堆平铺的文件：

```text
lib-base    -> lib-math -> lib-unicode -> lib-ajax
lib-base    -> lib-async
lib-async   -> lib-os
lib-os      -> lib-set
lib-fd      -> lib-bnf
lib-jit     -> lib-tcc
lib-orm     -> lib-xml
lib-orm     -> lib-set
lib-orm-pro -> lib-orm
lib-orm-gen -> lib-orm
lib-ui      -> lib-ui-base
lib-ui-base -> lib-os
lib-jsasync -> lib-ui
lib-jsasync -> lib-async
lib-jsasync -> lib-ajax
```

箭头表示依赖：`lib-math` `use` 了 `lib-base`，依此类推。

「基础」模块不依赖任何库：`lib-base`、`lib-set`、`lib-string`、`lib-json`、`lib-time`、`lib-file`、`lib-tcc`、`lib-winapi`、`lib-winole`、`lib-regex`、`lib-xml`、`lib-stack`、`lib-tree`。其它都叠在它们之上。绝大多数模块很小，大多在 200 行以内，总共约 7000 行，每个模块都可读、可单独测试。

有两处细节让这不止是一堆脚本：

- **自描述的数据驱动解析器**：`lib-fd` 的解析器由一份用 FD 写成的 BNF 文法（`fd.bnf.fd`）生成，`lib-bnf` 能把一段文法字符串编译成解析器；`lib-asm-pro` 把 `asm-list.fd.2.gz`（一张机器指令表）当内嵌数据模块拉进来。库把语言自己的数据格式当配置用。
- **命名空间按 use 划分，不按文件划分**：因为 `use ... as` 把模块绑定到变量，同一个模块可以在不同作用域用不同名字拉进来，互不冲突。

## 连关键字都是数据

模块化一直延伸到表层语法。关键字通过一层别名（`ParseAlias` / `ParseKeyAlias`）解析，解释器的英文规范关键字可以在启动时被一份别名包重新映射：

```text
fun.exe -key:key_cn.ini   # 函数=fun, 如果=if, ...
fun.exe -key:key_fr.ini   # 法语关键字
```

这门语言是「关键字中立」的：本地化是一个你放进去的数据文件，而不是解析器的一个分支。别名包（`key_cn.ini`、`key_fr.ini`、`key_pua.ini`）也当作模块加载。这和库是同一个哲学：给一个通用小机制喂数据，来扩展行为。

## 结语

把核心和库放在一起看，模块化哲学有五条一致的线索：

1. **一棵树，一个模型**：模块、对象、函数、作用域都是 `CNode`，没有第二套模块运行时需要你去学、去同步。
2. **组合，而不是增殖**：新的控制构造继承已有的原语，新的库 `use` 已有的库，核心因为用旧词表达新事而保持小。
3. **小而专注的单元**：解释器只有几千行，每个标准库模块只做一件事，最多两三百行。
4. **语言与库的界线很薄**：标准库用它服务的语言写成，你读到和扩展的是同一种代码。
5. **配置即数据**：文法文件、机器指令表，甚至关键字别名，都作为模块打包，走同一条 `use` 机制。

Fun 配得上「可嵌入」这个标签，不是因为它恰好很小，而是因为模块化被织进了模型本身：模块就是一个节点，库就是一个作用域，而它们之间的界线薄得你几乎感觉不到它的存在。