.版本 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)
        .判断结束
        
    .计次循环尾 ()
    
    写到内存 (字节数组, 当前节点指针 ＋ #语法树节点_函数名偏移, #语法树节点_函数名最大长度)
    

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

.子程序 设置语类, , 公开
    .参数 类, 整数型
    .局部变量 当前语类, 整数型
    .局部变量 新类, 整数型

    当前语类 ＝ 获取语类 ()
    新类 ＝ 到整数 (当前语类 ＋ 类)
    
    ' 调试输出 (当前语类, 类, 新类)
    .如果 (位与 (当前语类, 类) ≠ 0)
        ' 调试输出 (“警告: 重复设置语类”, 类)
    .否则
        写到内存 (新类, 当前节点指针 ＋ #语法树节点_语类, 4)
    .如果结束
    
    

.子程序 清理语类, , 公开
    .参数 类, 整数型
    .局部变量 当前语类, 整数型
    .局部变量 新类, 整数型

    当前语类 ＝ 获取语类 ()
    新类 ＝ 到整数 (当前语类 － 类)
    
    ' 调试输出 (当前语类, 类, 新类)
    .如果 (位与 (当前语类, 类) ＝ 0)
        ' 调试输出 (“警告: 尝试清除不存在语类”, 类)
    .否则
        写到内存 (新类, 当前节点指针 ＋ #语法树节点_语类, 4)
    .如果结束
    

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

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

.子程序 包含语类, 逻辑型, 公开
    .参数 类, 整数型
    .局部变量 当前语类, 整数型

    当前语类 ＝ 获取语类 ()
    返回 (位与 (当前语类, 类) ≠ 0)

.子程序 设置词类, , 公开
    .参数 类, 整数型

    写到内存 (类, 当前节点指针 ＋ #语法树节点_词类, 4)
    

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    n.初始化内存 (词.内容, )
    n.设置词类 (词.类型)
    返回 (n)
    

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

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

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

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

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

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

.子程序 生成展示文本, 文本型, 公开
    .局部变量 词类展示名集合, 文本型, , "0"
    .局部变量 语类展示名集合, 文本型, , "0"

    .局部变量 语类, 整数型
    .局部变量 语类展示名, 文本型
    .局部变量 i, 整数型
    .局部变量 当前掩码, 整数型

    ' 返回 (格式化文本 (“%s | 基地址: %x | 参数数量: %d | 参数容量: %d | 参数数组地址: %x ”, 获取函数名 (), 到整数 (获取当前节点指针 ()), 到整数 (获取参数数量 ()), 到整数 (获取参数容量 ()), 到整数 (获取参数指针地址 ())))
    语类展示名集合 ＝ { “语类_未定义”, “语类_定义”, “语类_函数调用”, “语类_函数原型”, “语类_形式参数”, “语类_实际参数”, “语类_根” }
    语类 ＝ 获取语类 ()
    .如果 (语类 ＝ 0)
        语类展示名 ＝ 语类展示名 ＋ 语类展示名集合 [语类 ＋ 1]
    .否则
        .计次循环首 (取数组成员数 (语类展示名集合), i)
            当前掩码 ＝ 左移 (1, i) ÷ 2
            .如果真 (位与 (当前掩码, 语类) ≠ 0)
                语类展示名 ＝ 语类展示名 ＋ 语类展示名集合 [i ＋ 1] ＋ “ ”
            .如果真结束
            
        .计次循环尾 ()
        
    .如果结束
    
    
    词类展示名集合 ＝ { “词类_未定义”, “词类_数字”, “词类_整数部分”, “词类_小数部分”, “词类_标识符”, “词类_算符”, “词类_括号”, “词类_注释”, “词类_逗号”, “词类_双等号”, “词类_单等号”, “词类_空格”, “词类_结尾” }
    
    返回 (格式化文本 (“%s | %s | %s| 参数数量: %d ”, 获取函数名 (), 词类展示名集合 [获取词类 () ＋ 1], 语类展示名, 到整数 (获取参数数量 ())))

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

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

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

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

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

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