elang/2. 词法分析科学计算器/词法分析科学计算器.代码/代码/抽象语法树节点.class.e.txt

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

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

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

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

.子程序 初始化内存, , 公开
    .参数 函数名, 文本型, 可空

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

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

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

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

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

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

    当前节点指针 ＝ 地址

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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