Fun 源代码深度解读

> 项目地址:<https://github.com/Funlang/fun> · 版本 9.0 · 作者:张卫东(zwd@funlang.org)
> 本文所有结论均基于仓库源码逐文件阅读得出,引用片段保持原样(个别为版面起见做了省略号截断)。

在中文开发者的视野里,自研编程语言常常停留在"词法分析器作业"或"玩具 Lisp"的阶段。GitHub 上的 [Funlang/fun](https://github.com/Funlang/fun) 是一个不太一样的样本:它自称 Fun 语言,用 Pascal(Delphi / Free Pascal)写成,从 2005 年的 TemplateScript、2006 年的 Nuva 一路演化至今超过十五年,2026 年才首次开源核心与标准库。它不是玩具——README 里甚至给出了商业双授权条款;它也不追求时髦——没有 LLVM、没有类型系统、没有虚拟机指令集,核心就是一个几千行的树遍历解释器。

但它有一个非常罕见的卖点:**一门脚本语言,可以在不离开自身、不借助外部工具链的前提下,从处理一个 JSON 对象,一路下探到运行时编译 C 代码、手写汇编和直接执行机器码**。这篇文章会从设计哲学、语法特性,一直讲到值模型、解释器、对象系统、FFI 与 JIT 的实现细节,最后给出一份尽量客观的评价。如果你对"一门语言的完整实现要多少代码、哪些地方最见功力"感兴趣,这个仓库值得完整读一遍。

## 一、项目速览:十五年的单语言工程

先把数字摆在桌面上。仓库 `src/` 目录下的 Pascal 源码约 1.6 万行,其中手写核心约 9000 行(core、parse、lib、io、regex 等),另有约 5000 行是 lex/yacc 生成的表文件(`ltab.inc`、`ytab.inc` 等),其余为第三方 KOL 库。与之相对,`fun/lib` 目录下的标准库由 **58 个纯 Fun 脚本模块**组成,共约 7000 行——标准库几乎全部用这门语言自己写,这就是所谓的"自托管"(self-hosting)生态。

| 维度 | 内容 |
| ---- | ---- |
| 实现语言 | Pascal(Delphi 2006/2009、Free Pascal 交叉编译) |
| 目标平台 | Windows 32/64、Linux i386、ARM Linux、Windows CE |
| 分发形态 | 命令行 `fun.exe` + 可嵌入运行时 `fun.dll`(导出一个 `Run` 接口) |
| 核心构成 | LALR 解析器 + 树遍历解释器 + Variant 值模型 + PCRE 正则 |
| 标准库 | 58 个模块,纯 Fun 编写,覆盖 JSON/YAML/XML、ORM、异步、Socket、UI、TCC/JIT/汇编 |
| 授权 | MIT(内核),另有闭源修改内核与 `fun.dll` 商业嵌入的商业条款 |

演化路径也交代得很清楚:TemplateScript(2005)→ Nuva(2006)→ Fun(2010 至今)。从模板脚本语言起家,逐步长出对象系统、模块系统、正则、FD 数据格式和底层能力,最终收敛成现在这个"能力阶梯"式的运行时。理解了这个背景,很多设计决策就变得可以解释——比如它对 Windows API 和 COM 的一等公民支持,比如它把"嵌入第三方应用"作为与命令行并列的头号分发形态。

## 二、设计哲学:数据与代码都是头等公民

Fun 的 README 用了一句话定位自己:"**Fun 是一门从 JSON 一路写到机器码的脚本语言**"。这句话背后是一个明确的设计判断:多数脚本语言要么停留在高层——好用,但一到 FFI 就撞墙,性能关键处还得去写 C;要么要求你在语言之外再维护一条 C 工具链。Fun 把这条能力阶梯收敛进了同一个运行时:

![Fun 能力阶梯](fig1-capability-ladder.png)

阶梯的每一层都对应仓库里真实存在的机制,后文会逐层拆解。这里先指出这个设计里最有意思的一点:**层与层之间没有边界**。同一个值模型承载 JSON 数据和机器码地址,同一套方法调用语法既能调 Fun 函数、又能调 Windows API、还能调运行时编译出来的 C 函数。来看 README 里那个把两种极端拼在一起的例子(摘自 `fun/demos/benchmarks/test-jit-cb.fun`,有删节):

```fun
use 'lib-jit.fun';
fun cb(a, b)          # 由 JIT 编译出的代码回调的 Fun 函数
  result = a * 2^32 + b;
end fun;

# 汇编路径:x86 机器码,调用回 Fun 回调
var asm = `#!asm i:i
    mov ecx, dword ptr [esp+04]
    @sum1ton
    ...
`;
var jit = NewJit(asm, names: [test: cb.@toCallback(nil, 'ii:i', true)]);
?. jit.Run(100000);

# C 路径:用内置 TCC 在运行时编译
var c = `#!C ii:i
  int sum(int n, int (*test)(int, int)) {
    long long s = 0;
    for (int i = 1; i <= n; i++) s += i;
    test((int)(s >> 32), (int)(s & 0xFFFFFFFF));
    return 1;
  }
`;
jit = NewJit(c);
?. jit.call(100000, cb.@toCallback(nil, 'ii:C', true));
```

反引号字符串里写汇编或 C,签名串 `'ii:i'` 描述参数与返回类型,`@toCallback` 把 Fun 函数变成可以交给机器码调用的函数指针——这四个元素在后面讲 FFI 实现时都会见到真身。设计哲学的另一半是"**以数据为中心**":Fun 的集合类型(list/set/tree)直接内建在值模型里,JSON 与自研的 FD 格式(一种类 Markdown、对人和 AI 都友好的缩进式数据格式)是解释器原生能力而非第三方库。这个定位在 2026 年显得颇有先见之明——README 明确把"信创与 AI Agent 场景中连接国产 OS、数据库、芯片与业务逻辑的轻量级胶水"写进了目标场景。

## 三、语言速览:披着 Pascal 外衣的函数式脚本

Fun 的语法骨架来自 Pascal 血统:`begin/end` 思想的块结构、`if ... then`、`end fun;`、`end class;` 的对称收尾;但血肉明显偏向现代函数式脚本语言。先看最朴素的 Hello World(摘自 `fun/demo/fun.fun`):

```fun
fun foo()
  ?. 'Hello, fun!';
end fun;

foo();

fun max(a, b)
  if a > b then
    result = a;
  else
    result = b;
  end if;
end fun;

?. max(1, 9);
```

几个细节值得玩味。第一,`?.` 是输出语句——文法里"输出 ::= '?' ('.' | ',' | ':')? 算式",三个后缀分别映射为换行、空格、制表符,这是从模板脚本时代留下的"打印即语法"的传统。第二,函数没有显式 `return` 也可以工作:每个函数在解析期就自动挂了一个名为 `result` 的返回变量,并且这个变量有个别名 `@`——所以 `result = a` 其实是在给预分配的返回槽位赋值。第三,一切块都用 `end xxx` 对称闭合,配合等宽缩进,读起来有种老派的安全感。

函数式这一面就更活泼了。函数是值,匿名函数用 `->`,还带柯里化与管道(`fun/demo/fun2-closure.fun` 与 README 示例):

```fun
# 闭包:计数器
fun counter()
  var i = 0;
  return fun(){
    i += 1;
    result = i;
  };
end fun;
var c = counter();
?. c();   # 1
?. c();   # 2

# 自定义运算符 + 一等函数 + 管道
class Number(me)
  this['#'] = you -> (me + you) * me * you;
end class;
var $ = Number(2);
?. $ .# 3;            # (2 + 3) * 2 * 3 = 30

var f = a -> a * 2;
var g = a -> a + 3;
?. g(f(1 + 2) + 3);   # 12
?. 1 + 2 | f + 3 | g; # 12,同样结果,用管道写
```

`$.# 3` 里的 `.#` 不是标点堆砌,而是 Fun 独有的"点符"机制:文法允许 `.` 后跟一串符号字符(`.#`、`.@`、`.~`……)作为可自定义的运算符,类里用 `this['#'] = ...` 注册,调用时经统一的方法分发执行。管道 `x | f` 则把左侧表达式的值接到右侧第一个函数调用的参数表头部,于是 `1 + 2 | f + 3 | g` 等价于 `g(f(1 + 2) + 3)`——把 Unix 管道的直觉搬进了表达式语法。

再看两个"老派与现代混搭"的细节。其一是 `case`,它的分支条件不止支持常量匹配,还能直接用集合和正则(实现见后文 `CCase`):

```fun
case x is
  when [1, 3, 5] do  ?. '小奇数';
  when /^a.+z$/i do  ?. 'a 开头 z 结尾';
  else               ?. '其他';
end case;
```

其二是条件跳转:`exit when` / `next when` 相当于 break-if 和 continue-if,在循环里非常好用,标准库里到处是 `exit when i = -1;` 这样的写法。

还有两个展示语言"自反性"的彩蛋。一个是官方 Quine(`fun/demo/quine.fun`),整份源码只有一行,靠反引号字符串嵌套自身与 `eval`:

```fun
var s = `var s = `$s`; ?. s.eval();`; ?. s.eval();
```

另一个藏在内建方法表里:`'I am'.@uthor()` 会返回作者名字,而源码里这个名字是异或 3 加密过的(`'Ykbmd,Tfjglmd'`,逐字符 `xor 3` 解码为 `Zhang/Weidong`)——老派程序员的浪漫。

最后必须提**关键字别名层**:Fun 的关键字在词法层经过 `ParseAlias` 归一化,因此语言本身与具体关键字无关。仓库自带 `key_cn.ini`(简体中文)、`key_fr.ini`(法语)、`key_pua.ini`(自定义区)三套别名包,`fun.exe -key:key_cn.ini` 启动后即可用中文写代码:

```text
如果=if      则=then      否则=else    再如=elsif
函数=fun      变量=var      循环=loop    当=case
是=is        有=when      执行=do      属于=in
真=true      假=false      引用=use     新=new
```

这不是"中文编程语言"的营销话术,而是一个干净的本地化设计:别名表只在词法层做二分查找替换,语法、解释器、标准库对此完全无感。顺带一提,关键字表里还有一个 `atom`(中文别名"单线"),在 `ytab.inc` 的文法表中没有任何产生式引用它——一个为未来线程/原子特性预留的空位,从侧面说明这门语言仍在演化途中。

## 四、实现总览:生成表之上,语义动作为王

Fun 的编译前端是教科书式的 lex + yacc 组合:文法在 `src/parse/bnf/` 下同时提供了 `lex.l`、`yacc.y` 和一份人类可读的 EBNF(`fun.ebnf`),构建时生成 `ltab.inc`(词法表,863 行)与 `ytab.inc`(LALR 表,4322 行)。但真正定义这门语言行为的,不是这些表,而是包在表外面的两套手写代码:词法动作与 **119 个语义动作**(yacc 归约时逐个调用的 `BuildIf`、`BuildFun`、`CreateExp`……),它们在归约的瞬间直接把 AST 造出来。整个流水线如下图:

![编译执行流水线](fig2-pipeline.png)

主流程短得出乎意料,`src/prj/fun/funcmd.dpr` 的主干只有两步:

```pascal
p := CFunParser.ParseOrLoad(f);   // 编译:源码 → AST
CRun(p).run(r);                   // 执行:树遍历
```

这份简洁背后有几个值得展开的工程决策。

**第一,错误定位做在语义动作里。** 每个语法符号携带 `index/leng/row/col` 四元组,`DoLog` 在归约时把位置信息沿着语法树向上传播,最终错误消息形如 `xxx not found @ 12,5`。更重要的是,每条语句节点(`CRune`)都记录行号,运行期 `env.trace(n)` 持续更新"当前执行到哪",出错时 `lastErrorFun` 能报告"哪个函数第几行"——这些信息同时是配套 IDE(`funide`)断点调试的基础,`{$IfDef IDE}` 条件编译的调试桩遍布解释器。

**第二,嵌套函数用"重入解析器"实现。** `BuildFunDef` 遇到匿名函数体时,不是把函数体缓存成 token 流以后再解析,而是直接 new 一个子解析器、接管 yacc 状态机、就地递归 `yacc_parse(true)`:

```pascal
function CParser.BuildFunDef(...): YYSType;
begin
  ...
  p := OldC.Create;              // 子解析器
  p.Root := f;                   // 函数节点作为子解析的根
  p.Curr := f.parse(id, names);
  TParser(p.Yacc).yacc_parse(true);   // 递归解析函数体
  // del p in BuildEnd()
end;
```

这保证了 `fun(){...}` 可以出现在表达式任意位置(闭包、柯里化都依赖这一点),代价是解析器必须完全可重入——从 `BuildEnd` 里那句 `del(self)` 能看到,子解析器用完即焚。

**第三,模块系统在编译期静态链接。** `use 'lib-json.fun' as J` 在解析期就完成:按"当前文件目录 → exe 目录的 lib/、app/"顺序查找源文件,解析成 `CModu` 节点,并用一个环形链表(`LinkRoots` + `CModu.find`)按展开后的文件名去重,同一模块只会解析一次;`as` 别名则把整个模块作为一个变量绑进当前作用域。运行期变量解析(`CRuns.UID`)会沿"本块 → use 引入的模块(倒序)→ 父块"的链路查表,并用 `useLevel` 计数器防住循环引用导致的无限递归。一个文法细节是 `use ':xxx.fun' as id` 表示"仅包含":直接把目标文件解析结果注入当前作用域,类似 C 的 `#include`。

顺带看一眼文法文件本身,`fun.ebnf` 里最有辨识度的三条规则:

```text
点符       ::= '.' [~!#%^&*-+=\|<>/?]+
时间       ::= '@' 字符串
正则       ::= ( '/' [^\s/]+ '/' | '%' [^\s%]+ '%' | '$' 字符串 ) [gimsux]*
字符串     ::= "'" ... | '"' ... | '`' ( [^`]* | '``' )* '`'
```

正则字面量、时间字面量、反引号字符串(为嵌入汇编/C 而生,双反引号转义)都是词法一级的公民;点符则是自定义运算符的语法基础。一门语言的性格,往往就藏在这几条文法的边角里。

## 五、值模型:站在 Variant 肩膀上的动态类型

Fun 最省力也最大胆的决定,是**把整个值模型建在 Pascal 的 Variant(COM VARIANT)之上**。`base.pas` 开头第一行类型定义就是态度:

```pascal
type
  CValue  = System.Variant;   // 一切 Fun 值
  CData   = System.TVarData;  // 直接操作二进制布局
```

整数、浮点、字符串、时间、布尔都是现成的 Variant 类型;真正有意思的是作者注册了两个**自定义变体类型** `VarObject`(2010)与 `VarObjNew`(2011),把对象指针塞进 Variant 的 `VPointer` 槽位,并接管其 `Clear/Copy/CastTo` 语义。于是"对象也是一种值"这件事不用改解释器任何其他部分——赋值、比较、传参天然工作。布尔真值的定义也走 Variant 风格:`funBool` 对字符串按 `'True'/'Yes'/'False'/'No'/空串` 解释,对集合则看元素个数是否为零(`CVarObject.CastTo` 里有一行注释般的代码:`Dest.VBoolean := CExp(VPointer).count > 0`)。

内存管理选择了 COM 式引用计数。所有 AST 节点与运行时对象的基类 `CBase` 同时实现 `IInterface`,增减计数走两条手写内联汇编——注意 `LOCK XADD`,这是货真价实的线程安全原子操作:

```pascal
function lockInc(var I: fun.int): fun.int;
asm
      MOV   EDX,1
      XCHG  EAX,EDX
 LOCK XADD  [EDX],EAX
      INC   EAX
{$Else}                       // ARM 等平台回退为普通增减
begin
  Inc(I);  result := I;
```

容器只有三个,却个个有性格。`CList` 是倍增扩容的指针数组;`CHash` 则是一个**Trie(前缀树)而非哈希表**:每个节点是一个 41 字节的 `Index` 数组加子节点指针列表,键字符被编码进 40 个槽位(数字 0-9,`@` 到 `Z` 10-36,小写字母,`_` 37,`$` 38),遇到这 40 个字符之外的键字符(比如中文),就按 40 进制拆成多位逐层下潜:

```pascal
case c of
  '0'..'9': b := Ord(c) - Ord('0');
  '@'..'Z': b := Ord(c) - Ord('@') + 10;   // 10-36
  '_'     : b := 37;
  '$'     : b := 38;
  else      begin
    b  := Max_Char + 1;   // 其他字符按 40 进制拆位
    b2 := Ord(c);
  end;
end;
Find_b:
  if n.Index[b] > 0 then n := n.Items[n.Index[b] - 1]   // 找到,下潜
  else if p = nil then exit                             // 找不到
  else n := AddNode(b, NewNode);                        // 插入新节点
...
if b2 > 0 then begin
  b  := b2 mod Max_Char;
  b2 := b2 div Max_Char;
  goto Find_b;
end;
```

变量表、内建方法表、对象字段表,全语言所有"名字 → 东西"的映射都是这棵 Trie。它换来 O(键长) 的稳定查找和天然有序的 `EachEx` 遍历,代价是每个节点 41 字节的 Index 数组——典型的以空间换简洁。第三个容器 `CHist` 在 Trie 之上叠了一层 `CList`:Trie 的值槽存"1 起始的列表下标",从而得到**保持插入顺序的字典**——Fun 的对象和集合能按定义顺序序列化成 JSON/FD,靠的就是它。此外两个小细节颇能体现用心:`calcIndex` 让所有索引访问支持 `-1 = 末尾` 的 Python 式负下标;比较函数 `varComp` 为整型-整型、浮点-整型、字符串(默认不区分大小写)、对象指针等情形分别写快路径,`+ - * /` 的求值过程(`calc.inc`)同样为 int/double 组合写了免 Variant 开销的直算路径,整型加减乘甚至用 `jo`(溢出跳转)检查后回退——这是一门解释器语言里相当奢侈的待遇。

## 六、解释器:树遍历的工程学

Fun 的执行引擎没有指令集、没有字节码,就是最朴素的树遍历:`CRuns.run(env)` 顺序执行语句列表,每个节点实现一个 `run(env)` 或 `calc(env)`。但朴素不等于粗糙,三处设计很见功力。

**第一,break/continue/return 不用异常,用"标志位 + 父链上溯"。** `exit`、`next`、`return` 在编译期都被建成 `CGoto` 节点并记下跳转目标块;执行时从当前节点沿 parent 指针向上走,把沿途每个语句块的 `isExit` 置真,外层循环看到标志就停:

```pascal
procedure CGoto.run(env: CEnv);
var n: CNode;
begin
  n := self;
  repeat
    n := n.parent;
    if n is CRuns then CRuns(n).isExit := true;
  until n = target;
end;

procedure CReturn.run(env: CEnv);
  ...
  v := CRuns(target).UID(_RESULT);      // 找到函数的 result 槽位
  if v <> nil then v.assign(exp.calcValue(env));
  ...
end;
```

`next`(continue)多走一步 `afterRun`,`exit`(break)则在上溯之后顺手把所在 `CLoop` 的 `isExit` 置真。相比"每次循环退出都抛一个 Pascal 异常再捕获"的流行做法,这条路没有异常开销、不污染栈回溯,是对树遍历解释器控制流的干净解法。真正的异常只留给 `raise`/`try`:`CTry.run` 直接映射到 Pascal 的 `try/except/finally`,异常消息被绑进 `except` 块里的 `@` 变量。

**第二,递归与闭包靠"变量槽位栈"而不是环境拷贝。** 函数体内的每个变量在解析期是一个 `CVarRE` 节点,它持有两样东西:指向自己所属函数调用栈(`CFunStack`)的引用,以及一个槽位指针 `pp_val`。函数每次被调用,`stack.Push` 让所有变量的 `pp_val` 指向一层新槽;函数返回则 `Pop` 还原。于是递归天然正确——每层调用写的是自己的槽;闭包也天然正确——内层函数的变量节点被外层引用计数续命,返回后槽位仍在:

```pascal
if o <> nil then
begin
  result := CVarRE.new(pn, false);
  with CVarRE(result) do
  begin
    owner := o;
    stack := CVarStack.Create(o.stack, p_val, @p_val);
  end;
end
```

参数绑定同样精巧:`CExps.assign` 先按形参名在实参表里找(支持 `f(pos: 3)` 具名传参),找不到再按下标对位;最妙的是引用参数——如果实参本身是个变量节点,就直接共享其槽位指针 `e.p_val := p.p_val`,一行代码实现了 `var` 形参的按引用语义,注释里还留着修递归 bug 的痕迹。

**第三,模块即节点,加载即缓存。** 前文说过 `use` 在解析期完成链接;运行期 `CModu.run` 用一个 `runed` 布尔实现"只执行一次"的语义,无论被多少模块引用,模块顶层代码只跑一遍——这是很多自研语言会踩的坑(重复初始化、循环引用爆栈),Fun 用不到十行代码绕开了。

整体读下来,这个解释器最鲜明的气质是"**每个机制都选了最短的那条路,但把最短的路走完整**":标志位代替异常、槽位栈代替环境帧、Trie 代替哈希、Variant 代替自建类型标签。没有一处炫技,但也没有一处偷懒。

## 七、对象系统:class 即闭包

Fun 的对象系统是我在这个仓库里看到的最优雅的部分,因为它建立在一个惊人的等价关系上:**一个类就是一个标记了 `isClass` 的函数节点**。`CFun.parse` 里,`class` 与 `fun` 走的是同一条构造路径,只是类多挂了两件东西——`this` 和 `base` 两个变量:

```pascal
if isClass then
begin
  v           := CVar.new(all, '', true);
  v.name      := _This;
  v.assign(self);            // this -> 类节点自身
  vars[_This] := v;
  ...
  v.name      := _Base;      // base -> 父类(或自身)
  if upClass = nil then v.assign(self)
  else v.assign(upClass);
end;
```

类体里写的 `var name = 'CA';`、`fun showName() ... end fun;` 在执行类体时被逐一登记进 `all.vars` 这张 Trie——类体就是构造器的函数体,"字段定义"与"构造逻辑"天然是同一段代码。实例化(`var a = CA();`)时,`CFun.call` 的 class 分支开始工作:

```pascal
if isClass then
begin
  o := newObj;                       // 新建 CObj(实例 = 一个 CSet)
  doCopy(o.items, exps);             // 沿继承链拷贝字段与方法到实例
  evar.assign(o);
  pushObj(o);                        // 实例字段槽位压上调用栈
  try
    doCall(env, exps);               // 沿继承链执行类体(基类先执行)
  finally
    popObj;
  end;
end
```

`doCopy` 沿 `upClass` 继承链向上递归,把每一层类体登记过的成员抄进实例;`doCall` 同样沿链向上,**基类的类体先执行**——这就是 Fun 的构造器链。而 `pushObj` 是全场最妙的一幕:它把实例持有的每个字段值 `e2.p_val := e.p_val` 接到类体变量的槽位指针上。效果是,类体代码此后读写 `name`,读写的是**这一个实例自己的存储**——方法不需要显式转发 `this`,字段访问就像闭包捕获一样直接落到实例上。方法的调用也一样:`CObj.push` 把字段槽位压回栈,`CObj.pop` 弹出,于是"调用谁的方法,谁的字段就在现场"。

继承语法直接复用类的"前值"参数(`class B = A(...)`),`base` 变量指向父类节点,`CFun.doFind` 在本类查不到成员时自动沿 `upClass` 向上找。方法、getter、setter 则统一收敛到一个 `.` 分发器上:`CId2` 在成员不可调用时触发 `_ENV.call(..., CPropertySet/CPropertyGet)`,宿主层可以拦截属性读写——前文 `class Number(me)` 里 `$.# 3` 的自定义运算符,走的就是同一条成员分发路径,只是成员名从普通标识符换成了 `#` 这样的符号。

用不到四百行代码(源码中对象系统相关不过 `core.pas` 的若干方法),Fun 拿到了类、实例、字段、方法、继承、构造链、属性分发和运算符重载。它当然没有多分派、没有访问控制、没有元编程,但"**class 是闭包的语法糖**"这条路线被走得干净利落,和 Lua 的元表、IO 语言的原型链属于同一种"小机制大语义"的审美。

## 八、方法分发:接收者类型驱动的 lib 链

脚本语言绕不开一个问题:`'abc'.length`、`[1,2].@add(3)`、`/fun/i.match(s)` 这些内建方法,挂在哪个类型系统上?Fun 的答案是**把内建组织成一条按"接收者类型"筛选的库链**。宿主环境 `CEnv2` 持有一列 `CLib`,每次方法调用失败回落到内建时,依次询问每个库"这个接收者归你管吗"(`accept`),归你管就查它的方法表(`ids`,又是那棵 Trie):

```pascal
function CEnv2.call(...): fun.bool;
begin
  for i := 0 to libs.count - 1 do
  begin
    lib := CLib(libs[i]);
    if lib.accept(exp) then           // 接收者类型匹配?
    begin
      result := lib.call(self, exp, id, exps, val, ct);
      if result then exit;
    end;
  end;
end;
```

各库的分工泾渭分明:`CLbase` 接收**普通值**(字符串、数字、时间……),注册了 40 余个内建,从 `length/substr/format` 到 `load/save`、`md5/sha1`、`compile/GetJson`;`CLset` 接收集合,提供 `@count/@each/@add/@clone/@toJson`;`CLreg`/`CLmat` 分别接收正则与匹配对象;`CLfun` 接收函数(提供 `@toCallback`);`CLapi` 接收 FFI 函数对象;Windows 下还有 COM 与 UI 库。而方法表里存的东西再次体现了"一切皆值"的偏执——**Pascal 函数指针被当成整数存进 CExp 节点**,调用时强转回来:

```pascal
ids['length'] := CExp.new(nil).parse(fun.uint(@_length));
...
CPasFun(fun.ptr(fun.uint(v.value^)))(env, exp, exps, val);
```

每个内建只拿四样东西:接收者(`exp`)、实参表(`exps`)、返回槽(`val`)和环境(`env`),具名参数通过 `CExps.FindAsVal(exps, 'pos', 0, 0)` 读取——和脚本层函数完全一致的调用约定。这套设计的扩展方式也值得注意:嵌入方只要派生 `CEnv2`/`CLib` 子类插进链尾,就能给任意接收者类型添加新方法,`fun.dll` 的嵌入接口正是建立在这上面。

方法名前缀 `@` 在这里顺便得到解释:`@toJson`、`@toCallback`、`m.@(1)` 里的 `@` 不是魔法符号,而只是内建方法的命名习惯(同时借用了"标识符可以以 `@` 开头"这条词法规则)。`CMatch` 对象上的 `@` 与 `@@` 则被注册成了两个真正的内建——前者取分组、后者取匹配全文,于是有 `code.match(/\w++(?=\s*+\()/).@@()` 这种先匹配再取值的链式写法。正则本身在 Fun 里是货真价实的**值类型**:`/.../i` 在词法层成为独立 token,语法层直接构造 `CRegex` 节点(内嵌完整 PCRE 引擎),`=~` 与 `!~` 运算符最终调用的就是 `match` 内建,全局匹配返回集合、单次匹配返回 `CMatch`,分组、命名分组、替换回调一应俱全。把正则做成值而不是库函数,让 `case x is when /^a.+z$/` 这种写法成为可能——语言的各个特性在这里形成了相互支撑的闭环。

## 九、FFI 与运行时 C:能力阶梯的底层实现

现在拆解 Fun 最出格的部分:一个解释器语言,凭什么敢说"从 JSON 写到机器码"?下图把三条下探路径和一条回调闭环画在了一起:

![FFI 与 JIT 回调闭环](fig3-ffi-jit-loop.png)

**FFI 的核心是签名串。** `'kernel32'.getapi('VirtualAlloc', 'iiii:i')` 一步完成 LoadLibrary、GetProcAddress 和函数对象包装,`'iiii:i'` 依次编码每个参数类型,冒号后是返回类型(`i`=int、`s`=字符串、`d`=double、`p`=指针、`c`=回调、`v`=void 等)。真正的调用发生在 `CWinFun.call` 里,作者用内联汇编手工完成了一次 stdcall:

```pascal
for i := CExps.count(exps) - 1 downto 0 do    // 参数从右往左压栈
begin
  e := CExp(exps.Item[i]);
  with CData(e.value^) do
  case flag[i + 1] of
    'n', 'i', 'l':  ret := VLongWord;
    'a':            ret := LongWord(fun.ptr(AnsiString(fun.str(VString))));
    'w', 's':       ret := LongWord(fun.ptr(WideString(fun.str(VString))));
    'p':            ...
    'c':            if e.asObj is CCallback then
                      ret := LongWord(CCallback(e.asObj).Proc);
    ...
  end;
  asm
    push ret
  end;
end;
ri := CWinAPI(hfun)();                        // 直接调函数指针
```

类型转换、压栈顺序、返回值译码全部对签名串负责,十几行就是一套 FFI。这份简洁的前提是 32 位 stdcall 的简单栈约定——这也直接预示了我们后文要谈的局限:64 位与 ARM 上这条路需要绕行(用 TCC 的 C 路径,或按目标 ABI 重写)。

**回调方向靠一段三指令的机器码桩。** 原生代码怎么反过来调用 Fun 函数?`CCallback` 在内存里拼出一个极小的调用桩,它本身就可以当作函数指针交给任何 C/汇编代码:

```pascal
CCallDesc = packed record
  Eax : fun.byte; // mov  eax, obj    ; 把对象指针装进 eax
  obj : fun.ptr;
  Call: fun.byte; // call proc        ; 跳进 Pascal 桩
  proc: fun.ptr;
  Ret : fun.byte; // ret  num         ; 按约定清栈
  num : fun.word;
end;
```

机器码执行 `call proc` 落回 Pascal 的 `MyProc`,后者按类型串解包参数、调用真正的 Fun 函数、把返回值按约定放回——README 例子里 JIT 出来的 C 代码调用 `test((int)(s >> 32), ...)`,穿过的正是这根桩。这是 Windows 时代回调式 API(窗口过程、线程入口、枚举回调)的标准玩法,只是很少有脚本语言把它做进内核。

**TCC 让"运行时编译 C"成为标准库函数。** `fun/lib/lib-tcc.fun` 只有百余行:先用 FFI 包好 `libtcc.dll` 的七个接口,然后 `ccompile` 完成从字符串到可调用对象的全流程——正则剥出 `#!C` 头部的签名、自动探测函数名、`-nostdlib -nostdinc -O2` 编译、重定位、取符号地址、最后复用 `getapi` 包装:

```fun
var ts = tcc.New();
tcc.Error(ts, 0, tcc_error);                  // 错误回调也是 Fun 函数
tcc.Options(ts, "-nostdlib -nostdinc -O2");
var i  = tcc.Compile(ts, code);
i = tcc.Reloc(ts, 1);
var ptr = tcc.Get(ts, name);
result = nil.getapi(ptr, flag);               // 回到 FFI 包装
result = new [call: result, del: -> tcc.Delete(ts)];
```

**汇编路径则把"生成的代码也是数据"演绎到底。** `lib-asm.fun` 的 `Assembly` 类用 `VirtualAlloc` 申请 `PAGE_EXECUTE_READWRITE` 内存,把用户给的机器码清洗成纯十六进制写入,甚至还会自动补一个 stdcall 返回桩:`c &= 'C2%s00'.format(str2hex((args.length()*4-8).toChar()))`——如果代码没以 `ret n`(`C2....`)结尾,就按参数个数算出 `n` 自己拼一条。`lib-jit.fun` 的 `NewJit` 在两者之上做路由:`#!C` 开头交给 TCC,否则走汇编。三条路径、一个签名约定、一个回调桩,共同构成了那道"不离开脚本"的直通车。平心而论,这套东西的安全边界约等于零——任意内存读写、任意原生调用都暴露给了脚本;仓库里那份《SAFETY.zh.md》按 NAT/MEM/FSW/FSR/SRC/ENV 六类能力逐分支规划了未来 `-safe` 模式的拦截清单,说明作者对此心知肚明。能力与风险同源,这是这层设计的一体两面。

## 十、标准库:58 个模块的自托管生态

如果把解释器比作 CPU,那 `fun/lib` 就是 Fun 的固件层:58 个模块、约 7000 行**纯 Fun 代码**,覆盖数据(JSON/YAML/XML/Base64/MD5/加密)、集合与算法(set/tree/stack)、文本(string/regex/unicode)、系统与 IO(file/os/time/cmdline)、网络(winsock/ajax/jsonrpc)、数据库(六个 ORM 模块与 ADO)、原生绑定(winapi/winole/tcc/jit/asm)、UI(ui/dialog/trayicon)和并发(async/jsasync/bind/message)。平均每个模块约 120 行,最大的 `lib-winsock` 也不到 660 行。

这些数字背后有两个值得单独展开的设计。

**第一,JSON 与 FD 是"两个内建 + 一层薄封装"。** 真正的序列化逻辑在 Pascal 内建里(`set.@toJson` / `str.getJson`),脚本层的 `lib-json.fun` 只是给它们套了个命名空间,全文件不到 50 行:

```fun
fun JSON()
  fun Parse(s)
    result = s.getJson(json: true);
  end fun;
  fun Stringify(s, level)
    result = s.@toJson(level, json: true);
  end fun;
end fun;
```

更有意思的是 **FD 格式的自描述**。FD 是一种缩进式、类 Markdown 的数据格式(`person / name 张卫东 / age 46` 三行就能表达三层 JSON),它的解析器不是 Pascal 写的,而是运行时生成的:文法 `fd.bnf.fd` 用 FD 格式自身书写,`lib-fd.fun` 加载这份文法数据,交给 `lib-bnf.fun` 实现的 BNF 引擎(`CBNF`)现场生成解析器,再用一张"规则名 → 处理函数"的映射表驱动建树:

```fun
use ':fd.bnf.fd' as rules;            // 文法即数据
rules = rules.getJson(fd: true);
var cbcb = CBNF(rules, dup: 0);
var actions = [
  Key: (o,r) {
    ...
    while stak.peek().ind >= rt.ind do
      stak.pop();
    end do;
    ...
  },
  ...
];
result = cbcb.parse(s, actions);
```

"用一种格式描述自己的文法,再用语言自身实现解析器"——这个嵌套结构和 quine 是同一种趣味,也顺手验证了 BNF 引擎、缩进栈、匿名函数表这几样基础设施的成色。文法文件里那套带占有量词(`\S++`、`(?:...)++`)的正则方言,则由 `lib-regex` 与内嵌 PCRE 兜底。

**第二,异步是"Windows 原语 + Fun 语法"的混合体。** `lib-async.fun` 的 `AsyncClass` 用 `CreateThread` 起线程,线程入口是 `fxAwait.@toCallback(this, ':i', true, thread: true)` 生成的回调桩(注意 `thread: true` 会让宿主克隆一份环境,隔离线程间的全局状态),完成后 `PostMessage` 把结果投递回宿主窗口消息循环。`exec/await/done` 三个方法都返回 `this`,链出 `Async(hwnd, msg).exec(fx).await(gx).done(hx).go()` 这样的流水写法。它不是协程,更不是 Go 式的调度器,但作为"在 GUI 宿主里不卡界面地干活"的方案,恰好够用、且和 Windows 消息模型严丝合缝。同样的务实主义遍布标准库:`lib-ajax` 包 COM 的 `ServerXMLHTTP`,`lib-orm` 系列基于 ADO 与 SQL 生成,`lib-ui` 直接对接内核的 FunUI。这不是跨平台抽象的写法,而是"宿主有什么就用什么"的写法。

标准库的上层应用也证明了这套生态的可用性:`fun/demos/notepad--/` 用 301 行 Fun 代码(外加配套语法高亮配置)写出一个多文档记事本,`odbc-search` 是个数据库查询工具,`cmd-monitor` 52 行,benchmarks 目录里则摆着 Mandelbrot 与 JIT 回调基准——从系统工具到 GUI 应用到性能测试,自我供给的闭环是完整的。

## 十一、工程化细节:十五年磨出来的边角

回过头盘点那些散落在源码里的工程细节,它们单个都不起眼,合起来却解释了这门语言为什么"能活十五年"。

**性能层面**,除了前文提过的算术快路径与 Trie 查找,还有几处值得点名:`CSet.calc` 用 `calced` 标志保证集合字面量只求值一次;`CSet2` 则反过来,让表达式语境下的 `{...}` 每次求值都 `clone` 出新副本——两种语义各归其位;`NewStringReplace` 自己重写了一份单次分配的替换实现;`varComp` 对整型比较直接走整数减法。`fun.exe -v` 会在运行前后分别打印编译与执行耗时,`fun/demos/benchmarks/` 里同一份 Mandelbrot 摆了 Fun、C、汇编三个版本供对比——工具和意识都在。

**可移植层面**,构建矩阵覆盖 Delphi 2006/2009(Win32)、FPC 交叉(Win64、Linux i386、ARM Linux、WinCE),工具链路径集中在 `setenv.bat` 一处;源码里大量 `{$IfDef Unicode}/{$IfDef WinCE}/{$IfDef ARM}` 条件编译处理字符串语义与原子操作差异,甚至能看到 `{$IfDef Win64} int = int32; // NOT int64 !!!` 这种带着血泪的注释。词法扫描器在 2010 年为支持 Unicode 标识符手工改过表驱动循环(注释原话:"modify 2010-04-14: b -> Integer, + Unicode IDs and Keywords")。

**嵌入层面**,`fun.dll` 的全部对外接口是一个 `Run(arg)`:传文件路径或脚本文本即编译,再次调用即执行,传 -1 释放——三句话的嵌入协议,配上前文的 lib 链扩展点,构成了"把 Fun 塞进第三方应用"的完整故事。配套的 `funide` 提供带断点调试的 IDE(解释器里那些 `{$IfDef IDE}` 桩就是为它准备的),`funide.exe.presets` 里预置了工程模板。

**安全层面**,如前所述,`SAFETY.zh.md` 把未来 `-safe` 模式的拦截清单细化到了"同是 `move`,`s.move(地址)` 是 MEM 类、`f.move(目标)` 是 FSW 类"的分支粒度,并明确原则:"不打整个内置函数,只打具体危险的分支/参数,整函数拦截会误伤合法代码"。一份没有代码实现的安全设计文档,恰好暴露了这个项目当前的真实水位——安全是路线图,不是现状。

## 十二、客观评价:亮点、局限与适用场景

**先说亮点。**

其一,**"能力阶梯"是真实的、罕见的**。市面上带 FFI 的脚本语言不少,但把 TCC 内嵌成标准库、让脚本同时持有 C 与汇编两条逃生通道、还提供双向回调的,极其少见。对于"胶水层偶尔需要性能热点"的场景,这比"用 Python 写 90%,再用 C 写 10% 再维护一条工具链"的方案省事得多。

其二,**内核小而完整,适合当教材读**。从 lex/yacc 文法、语义动作、AST、闭包、对象、模块、异常到 FFI,一门动态语言的全部器官都在约一万行手写 Pascal 里,每个器官都能找到对应的文件与方法。对想看"语言是怎么被做出来的"的人来说,这比读 CPython 或 V8 的门槛低两个数量级,而完整度高一个数量级。

其三,**若干具体机制的品味在线**:`isExit` 标志上溯实现控制流、槽位栈实现递归与闭包、class 即闭包、Trie 化的名字表、关键字别名层、FD 的自描述文法。这些点单拿出来都不新鲜,但相互咬合得很好——正则是值,所以 case 能匹配正则;方法分发统一,所以自定义运算符零成本;引用计数贯穿,所以对象进集合不需要拷贝语义。

其四,**自托管生态的完整性**。58 个模块全部用 Fun 写成,连 FD 解析器都是运行时从数据文法生成的。语言能不能自举式生长,是检验表达力的试金石,Fun 交出的答卷超过多数同类个人项目。

**再说局限,这些同样是源码给出的事实。**

第一,**底层能力的平台绑定**。FFI 压栈与回调桩是 32 位 x86 汇编,`#!asm` 片段与架构强相关(README 自己也提醒 Linux/ARM 用 C 路径);核心虽可交叉编译到 Linux/ARM,但 58 个标准库里 winapi、winole、ado、ui、registry、trayicon 等一大批模块深度绑定 Windows,"跨平台"目前主要是内核与语言层的跨平台。

第二,**引用计数没有环回收**。对象持有类节点、闭包捕获外层变量、集合间互相引用,环状结构会泄漏——单线程内嵌场景影响有限,长驻进程需要留意。

第三,**符号设计偏"密"**。`@` 在不同语境下分别是 result 别名、异常消息、case 主体、分组取值器;`?.`、`?:`、`.#`、`|`、`` ` `` 各司其职。对熟练者是效率,对初读者是密码;内建命名(`@x`、`@@`、`GetApi`/`getapi` 混用)的可发现性也一般,错误消息以 `xxx not found` 为主,离现代语言的诊断质量有距离。

第四,**工程配套是单人项目水位**。没有测试目录(语法验证靠 demo 文件)、没有 CI、文档以 README 与源码注释为主、CHANGELOG 从开源首版才起步。核心算法(如 LALR 表)依赖外部生成器且生成产物入库,对贡献者不友好。类型系统停留在运行时判别,`isNum` 甚至逐字符验证数字字符串——灵活,但大开大合。

**适用场景**由此清晰:Windows 环境下的运维自动化、数据处理小工具、GUI 胶水、需要动态下发逻辑的嵌入宿主(游戏、工控、信创适配)——尤其是"既要操作 JSON,又要调本机 API,偶尔还想跑段 C"的组合需求,AI Agent 工具脚本与这个画像高度吻合。反过来的不适用清单也清楚:需要长期运行的服务端(环回收与线程安全存疑)、大型团队协作工程(类型与工具链缺失)、强沙箱场景(能力开关尚未落地)。

## 十三、结语:个人语言工程的一份样本

读完整个仓库,最打动人的其实不是任何一个具体机制,而是一种在今天略显稀缺的工程姿态:**用十五年时间,把一门语言连同它的标准库、IDE、应用、文档和授权体系,当成一个完整的作品来养**。Fun 没有跟进任何一个热点概念——没有泛型、没有协程、没有渐进类型——但它在自己划定的领地(数据为中心、可嵌入、能下探到机器)里,每个机制都做到了自洽和闭环。

对不同的读者,这个仓库的价值不一样。如果你是语言爱好者,建议按 `core.pas → flow.pas → parse.pas → base.pas` 的顺序读,配合 `fun/demo` 里的几十个语法切片,两周内可以通读一遍,性价比极高;如果你关心嵌入与自动化,重点看 `host.pas` 的 lib 链和 `funcmd.dpr` 的 `Run` 协议;如果你做 AI Agent,FD 格式与 `lib-bnf` 的"文法即数据"思路值得借鉴;哪怕你只是想找几个巧妙的实现段子,`CCallDesc` 那三指令桩、`isExit` 上溯和一行 quine 也值回票价。

至于它能否走出作者的机器、长出社区与生态,那就是另一场考试了——考题不再是语言设计,而是文档、治理与运气。至少目前,它已经证明了一件事:一个人、一门老当益壮的 Pascal、十五年时间,可以垒起一座从 JSON 通到机器码的塔。