.版本 2
.支持库 spec
.支持库 eAPI

.程序集 抽象语法树节点, , 公开
.程序集变量 当前节点指针, 长整数型
.程序集变量 已初始化, 逻辑型
.程序集变量 失败, 逻辑型

.子程序 _初始化, , , 当基于本类的对象被创建后，此方法会被自动调用
    已初始化 ＝ 假
    
    ' {
    ' char     函数名[16],   // 定长16, 再长不支持了
    ' int32_t  参数量,
    ' int32_t  参数数组容量, // 参数数组指针后有多大容量
    ' uint64_t 参数数组指针, // 长整数, 未来迁移到x64时兼容
    ' }
    ' // 此结构单个长度为 16+8+8 = 32 字节
    

.子程序 _销毁, , , 当基于本类的对象被销毁前，此方法会被自动调用
    .如果真 (已初始化)
        ' 调试输出 (格式化文本 (“警告: %x : %s 未释放内存而销毁”, 到整数 (当前节点指针), 获取函数名 ()))
    .如果真结束
    

.子程序 初始化内存, , 公开
    .参数 函数名, 文本型, 可空
    .参数 父节点地址, 长整数型, 可空

    当前节点指针 ＝ 到长整数 (申请内存 (#语法树节点_长度, 真))
    .如果真 (是否为空 (函数名) ＝ 假)
        设置函数名 (函数名)
    .如果真结束
    .如果真 (是否为空 (父节点地址) ＝ 假)
        设置父节点指针地址 (父节点地址)
    .如果真结束
    调试输出 (“设置参数指针地址”)
    设置参数指针地址 (申请内存 (#语法树节点_参数容量初始值 × #指针大小, 真))
    设置参数容量 (#语法树节点_参数容量初始值)
    
    已初始化 ＝ 真
    

.子程序 初始化否, 逻辑型
    返回 (已初始化)

.子程序 释放结构内存, , 公开
    .如果真 (获取参数容量 () ≠ 0)
        释放内存 (获取参数指针地址 ())
    .如果真结束
    释放内存 (当前节点指针)
    已初始化 ＝ 假
    
    

.子程序 生成子节点, 抽象语法树节点, 公开
    .参数 子节点函数名, 文本型, 可空
    .局部变量 ast, 抽象语法树节点

    .如果 (是否为空 (子节点函数名))
        ast.设置函数名 (子节点函数名)
    .否则
        ast.设置函数名 (格式化文本 (“%s 的子节点”, 获取函数名 ()))
    .如果结束
    ast.设置父节点指针地址 (获取当前节点指针 ())
    返回 (ast)

.子程序 生成匹配失败节点, 抽象语法树节点, 公开
    .局部变量 ast, 抽象语法树节点

    ast ＝ 生成子节点 (格式化文本 (“%s 的失败子节点”, 获取函数名 ()))
    ast._设置失败 ()
    返回 (ast)

.子程序 失败, 逻辑型, 公开
    返回 (失败)

.子程序 成功, 逻辑型, 公开
    返回 (失败 ＝ 假)

.子程序 _设置失败, , 公开
    失败 ＝ 真
    已初始化 ＝ 假

.子程序 从内存初始化, 抽象语法树节点, 公开
    .参数 地址, 长整数型
    .局部变量 res, 抽象语法树节点

    res.设置当前节点指针 (地址)
    返回 (res)

.子程序 获取当前节点指针, 长整数型, 公开
    返回 (当前节点指针)

.子程序 设置当前节点指针, , 公开
    .参数 地址, 长整数型

    当前节点指针 ＝ 地址

.子程序 设置函数名, , 公开
    .参数 函数名, 文本型, , 最长实际上是 #语法树节点_函数名最大长度-1
    .局部变量 字节数组, 字节型, , "16"
    .局部变量 i
    .局部变量 函数名长度, 整数型

    重定义数组 (字节数组, 假, #语法树节点_函数名最大长度)
    
    函数名长度 ＝ 取文本长度 (函数名)
    
    .计次循环首 (#语法树节点_函数名最大长度, i)
        .判断开始 (i ＝ #语法树节点_函数名最大长度 或 i ＞ 函数名长度)
            字节数组 [i] ＝ 到字节 (0)
        .默认
            字节数组 [i] ＝ 取代码 (函数名, i)
        .判断结束
        
    .计次循环尾 ()
    
    写到内存 (字节数组, 当前节点指针 ＋ #语法树节点_函数名偏移, #语法树节点_函数名最大长度)
    

.子程序 获取函数名, 文本型, 公开
    返回 (指针到文本 (当前节点指针 ＋ #语法树节点_函数名偏移))

.子程序 设置参数数量, , 公开
    .参数 量, 长整数型

    写到内存 (量, 当前节点指针 ＋ #语法树节点_参数量偏移, 4)

.子程序 获取参数数量, 整数型, 公开
    .局部变量 字节数组, 通用型, , "0"

    返回 (取字节集数据 (指针到字节集 (当前节点指针 ＋ #语法树节点_参数量偏移, 4), #整数型, ))

.子程序 设置参数容量, , 公开
    .参数 量, 整数型

    写到内存 (量, 当前节点指针 ＋ #语法树节点_参数容量偏移, 4)

.子程序 获取参数容量, 整数型, 公开
    返回 (取字节集数据 (指针到字节集 (当前节点指针 ＋ #语法树节点_参数容量偏移, 4), #整数型, ))

.子程序 设置参数指针地址, , 公开
    .参数 地址, 长整数型

    写到内存 (地址, 当前节点指针 ＋ #语法树节点_参数指针偏移, #指针大小)

.子程序 获取参数指针地址, 长整数型, 公开, 已经不在本结构体了, 在远处了
    返回 (取字节集数据 (指针到字节集 (当前节点指针 ＋ #语法树节点_参数指针偏移, #指针大小), #长整数型, ))

.子程序 获取结构体字节集, 字节集, 公开
    返回 (指针到字节集 (当前节点指针, #语法树节点_长度))

.子程序 获取参数数组字节集, 字节集, 公开
    返回 (指针到字节集 (获取参数指针地址 (), 获取参数数量 () × #指针大小))

.子程序 扩容参数指针, 长整数型, 公开
    .参数 新长度, 整数型, 可空
    .局部变量 旧参数指针地址, 长整数型
    .局部变量 旧参数数组打包, 字节集
    .局部变量 新参数指针地址, 长整数型

    .如果真 (是否为空 (新长度))
        新长度 ＝ 获取参数容量 () × #语法树节点_参数容量扩张系数
    .如果真结束
    
    旧参数指针地址 ＝ 获取参数指针地址 ()
    旧参数数组打包 ＝ 获取参数数组字节集 ()
    新参数指针地址 ＝ 申请内存 (新长度 × #指针大小, 真)
    
    
    写到内存 (旧参数数组打包, 新参数指针地址, 获取参数数量 () × #指针大小)
    释放内存 (旧参数指针地址)
    
    设置参数指针地址 (新参数指针地址)
    
    设置参数容量 (新长度)
    返回 (新参数指针地址)

.子程序 添加参数节点, , 公开
    .参数 节点, 抽象语法树节点
    .局部变量 当前参数数量, 整数型

    当前参数数量 ＝ 获取参数数量 ()
    
    .如果真 (当前参数数量 ≥ 获取参数容量 ())
        扩容参数指针 ()
    .如果真结束
    节点.设置父节点指针地址 (获取当前节点指针 ())
    写到内存 (节点.获取当前节点指针 (), 获取参数指针地址 () ＋ 当前参数数量 × #指针大小, )
    设置参数数量 (当前参数数量 ＋ 1)

.子程序 插入参数节点, , 公开
    .参数 节点, 抽象语法树节点
    .局部变量 当前参数数量, 整数型
    .局部变量 新参数指针地址, 整数型
    .局部变量 旧参数数组打包, 字节集
    .局部变量 旧参数指针地址, 长整数型

    当前参数数量 ＝ 获取参数数量 ()
    .如果真 (当前参数数量 ≥ 获取参数容量 ())
        扩容参数指针 ()
    .如果真结束
    
    旧参数指针地址 ＝ 获取参数指针地址 ()
    旧参数数组打包 ＝ 获取参数数组字节集 ()
    新参数指针地址 ＝ 申请内存 (获取参数容量 () × #指针大小, 真)
    
    写到内存 (到字节集 (节点.获取当前节点指针 ()) ＋ 旧参数数组打包, 新参数指针地址, (当前参数数量 ＋ 1) × #指针大小)
    释放内存 (旧参数指针地址)
    
    设置参数指针地址 (新参数指针地址)
    设置参数数量 (当前参数数量 ＋ 1)
    

.子程序 生成自词节点, 抽象语法树节点, 公开
    .参数 词, 词
    .局部变量 n, 抽象语法树节点

    n.初始化内存 (词.内容)
    返回 (n)

.子程序 添加词节点, , 公开
    .参数 词, 词

    添加文本节点 (词.内容)

.子程序 添加文本节点, , 公开
    .参数 文本, 文本型
    .局部变量 n, 抽象语法树节点

    n.初始化内存 (文本)
    添加参数节点 (n)

.子程序 获取参数节点, 抽象语法树节点, 公开
    .参数 i, 整数型, 可空

    .如果真 (是否为空 (i))
        i ＝ 获取参数数量 ()
    .如果真结束
    
    返回 (从内存初始化 (指针到整数 (获取参数指针地址 () ＋ (i － 1) × #指针大小)))

.子程序 生成展示文本, 文本型, 公开
    返回 (格式化文本 (“%s | 基地址: %x | 参数数量: %d | 参数容量: %d | 参数数组地址: %x ”, 获取函数名 (), 到整数 (获取当前节点指针 ()), 到整数 (获取参数数量 ()), 到整数 (获取参数容量 ()), 到整数 (获取参数指针地址 ())))
    

.子程序 设置父节点, , 公开
    .参数 父节点, 抽象语法树节点

    设置父节点指针地址 (父节点.获取当前节点指针 ())

.子程序 设置父节点指针地址, , 公开
    .参数 地址, 长整数型

    写到内存 (地址, 当前节点指针 ＋ #语法树节点_父节点指针偏移, #指针大小)

.子程序 获取父节点指针地址, 长整数型, 公开, 已经不在本结构体了, 在远处了
    返回 (取字节集数据 (指针到字节集 (当前节点指针 ＋ #语法树节点_父节点指针偏移, #指针大小), #长整数型, ))

.子程序 获取父节点, 抽象语法树节点, 公开
    返回 (从内存初始化 (获取父节点指针地址 ()))