.版本 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], 语类展示名, 到整数 (获取参数数量 ()))) .子程序 设置父节点, , 公开 .参数 父节点, 抽象语法树节点 设置父节点指针地址 (父节点.获取当前节点指针 ()) .子程序 设置父节点指针地址, , 公开 .参数 地址, 长整数型 写到内存 (地址, 当前节点指针 ＋ #语法树节点_父节点指针偏移, #指针大小) .子程序 获取父节点指针地址, 长整数型, 公开, 已经不在本结构体了, 在远处了 返回 (取字节集数据 (指针到字节集 (当前节点指针 ＋ #语法树节点_父节点指针偏移, #指针大小), #长整数型, )) .子程序 获取父节点, 抽象语法树节点, 公开 返回 (从内存初始化 (获取父节点指针地址 ()))