Fun 源码阅读指南

# 阅读 Fun 源码

Fun 用 Pascal(Delphi / Free Pascal)编写。整个语言核心、解析器和内置运行时只有几千行,分布在一个很小的目录树里,读起来不费劲。这篇指南在你去读之前,先给你一张地图。

## 只要记住一个核心思想

Fun 里一切都是同一棵树上的一个节点。解析器把源码变成一棵 `CNode` 对象树;解释器遍历这同一棵树并计算值。没有独立的字节码或 IR。只要你理解了三个动词——`run`(执行一条语句)、`calc`/`calcValue`(计算一个表达式的值)、`call`(调用一个可调用对象)——你就理解了整个解释器。

## 代码都在哪里

```text
fun/
├── src/
│   ├── prj/fun/funcmd.dpr   # 入口:fun.exe(命令行)或 fun.dll(嵌入式)
│   ├── core/                # 解释器核心
│   │   ├── fun.pas          #   基础类型别名(int/str/bool…)与 Variant 桥接
│   │   ├── base.pas         #   根类:CBase、CList、CHash、调用栈
│   │   ├── core.pas         #   抽象语法树 + 对象系统(语言的心脏)
│   │   ├── flow.pas         #   控制流:if/case/loop/for/try
│   │   ├── calc.pas/.inc    #   运算符(calc.inc 是运算符分派)
│   │   └── io.pas           #   文件 IO(CIO)、代码页处理
│   ├── parse/               # 词法 + 语法分析
│   │   ├── parse.pas        #   CParser:YACC 胶水 + Build*/Create* 语义动作
│   │   ├── *.inc            #   生成的表:ytab/yact/ltab/lex…
│   │   └── bnf/             #   文法:fun.ebnf、yacc.y、lex.l
│   ├── lib/                 # 内置运行时方法(用 Pascal 写)
│   │   ├── host.pas         #   CLib 基类、CEnv2、向各库分发调用
│   │   ├── libase.pas       #   CLbase:庞大的默认方法集
│   │   ├── libset.pas       #   CLset:集合/列表辅助方法
│   │   ├── winapi.pas       #   Windows API 外部函数接口
│   │   └── winole.pas       #   COM / OLE 外部函数接口
│   ├── regex/pcre/          # 内置 PCRE 正则引擎
│   ├── 3rd/                 # 第三方组件(KOL)
│   └── utils/               # 工具函数
└── fun/
    ├── lib/                 # 纯 Fun 编写的标准库(58 个模块)
    ├── demo/                # 语法示例
    └── demos/               # 完整应用与基准测试
```

## 建议的阅读顺序

从上往下读。每一层只依赖它上面的层。

**1. `core/fun.pas` + `core/base.pas` —— 值模型。**

`fun.pas` 定义原始类型别名(`int`、`uint`、`real`、`str`、`bool`……)以及自定义的 Variant 类型 `VarObject`/`VarObjNew`,它们让 Pascal 的 `Variant` 能容纳一个 Fun 对象。`base.pas` 定义 `CBase`——每个节点都继承的根引用计数类——以及集合 `CList`、`CHash`、`CHist` 和调用栈类型 `CFunStack`/`CVarStack`。

**2. `core/core.pas` —— 对象系统与抽象语法树。这是最需要仔细读的文件。**

它的类继承结构就是整个语言模型:

```text
CNode  (每个语法树节点:父链接、名字、new/add、call)
 ├── CRun   (一条语句:run(env))
 │   ├── CRune / CRuna
 │   │   ├── CGoto → CReturn      # return / 跳出等跳转
 │   │   ├── CAssign              # 赋值
 │   │   └── CCall → CEcho        # 调用与 echo
 │   └── CRuns → CModu            # 块 / 模块(一串语句 + 局部变量)
 ├── CExp   (一个表达式:calc(env) / calcValue(env) → 一个值)
 │   ├── CVar → CVarRE            # 一个变量 / 引用
 │   ├── CLeft → CId → CId2 → CIdx   # 标识符与下标
 │   ├── CFunc                     # 可调用对象 / 闭包
 │   └── CSet → CNew → CNew2 → CObj # 字面量、对象构造
 └── CEnv   (运行时环境:call/echo/trace)
```

注意两个家族:语句派生自 `CRun` 并覆写 `run`;表达式派生自 `CExp` 并覆写 `calc`/`calcValue`。对象模型(`CNew`/`CObj`)并不是另一套引擎,它由同样的节点类构造出来,所以「调用函数」和「构造对象」共用同一套机制。`CEnv` 是执行上下文,把标识符绑定到变量,并通过 `CEnv2.call` 路由调用。

**3. `core/flow.pas` —— 控制流。**

`CIf`、`CCase`、`CLoop`、`CForTo`、`CForIn`、`CNext`/`CExit`、`CTry`、`CRaise`。它们继承 `core.pas` 里的 `CGoto`/`CBloc` 机制;读它们能看出核心原语如何组合出每一种控制结构。

**4. `core/calc.pas` + `calc.inc` —— 运算符。**

`CCalc`/`CCone`/`CCtwo` 建模一元与二元运算;`CCAnd`/`CCOr` 提供短路求值的 `and`/`or`。`calc.inc` 保存实际的运算符分派表。

**5. `parse/parse.pas` + `parse/bnf/` —— 解析器。**

`CParser` 是前端。它是一个**表驱动的 YACC 解析器**:`ytab.inc`/`yact.inc`/`ltab.inc`/`lex.inc` 是生成的解析/词法表,而可读的文法在 `parse/bnf/fun.ebnf`(规范)以及 `yacc.y`/`lex.l`(生成器输入)里。`parse.pas` 中的 `Build*` 与 `Create*` 方法就是语义动作——每条文法规则会调用其中一个来构建对应的 `CNode`。源码在这里变成 AST。(关键字别名系统也在这里:`_C_` 开关下的 `ParseAlias`/`ParseKeyAlias`。)

**6. `lib/host.pas` + `lib/libase.pas` + `lib/libset.pas` —— 内置方法。**

当解释器无法原生解析某个调用时,它会通过 `CEnv2.call` 委托给已注册的 `CLib` 们。`host.pas` 定义 `CLib`、`CLfun`、`CEnv2` 与 `CCallObj`。`libase.pas`(`CLbase`)保存庞大的默认方法集(`arg`、`count`……),`libset.pas`(`CLset`)保存集合辅助方法。一个方法就是一个 `CPasFun` 过程,签名是 `(env, exp, exps, val)`。

**7. `core/io.pas`、`regex/`、`lib/winapi.pas`、`lib/winole.pas` —— IO 与 FFI。**

`CIO` 是文件层(带 UTF-8/UCS2 代码页处理);其余部分说明 Fun 如何触达 C、操作系统和 COM。这些是由编译开关控制的可选单元。

**8. `fun/lib` —— 自举的标准库。**

读完核心之后,最该看的是这里。全部 58 个模块都用 Fun 自身、基于那套很小的内置方法集写成——这是这门语言用自己的机制能做出什么的直观例子。

## 端到端追踪一条语句

跟着 `a = 1 + 2`:

1. `fun.exe`(`funcmd.dpr`)调用 `CFunParser.ParseOrLoad(f)`。
2. `parse.pas` 把源码送入词法表和 YACC 解析器。
3. 语义动作(对 `1 + 2` 用 `CreateExp`,对 `=` 用 `BuildSet`/`CAssign`)构建 AST:一条 `CAssign` 语句,内含一个带两个数字常量的二元表达式 `CCtwo`。
4. `CRun(p).run(r)` 从模块根部启动解释器。
5. `CAssign.run` 对其表达式调用 `calcValue`;`CCtwo.calc` 通过 `calc.inc` 计算出 `1 + 2`,并把结果存入变量。
6. 如果某个名字或运算符不是内置的,`CEnv2.call` 会把它交给已注册的 `CLib`,最终交给 Fun 标准库。

这就是整门语言的端到端全貌。**先读 `core.pas`**;其余一切都是围绕它的细节。