elang/2. 词法分析科学计算器/词法分析科学计算器.代码/代码/语法分析程序集.static.e.txt

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

.程序集 语法分析程序集
.程序集变量 AST根, 抽象语法树节点
.程序集变量 词, 词, , "0"
.程序集变量 当前词游标, 整数型

.子程序 语法分析
    .参数 _词, 词, 数组
    .局部变量 当前节点, 抽象语法树节点
    .局部变量 res, 抽象语法树节点

    复制数组 (词, _词)
    当前词游标 ＝ 0
    AST根.初始化内存 (“根”)
    
    .判断循环首 (当前词游标 ≤ 取数组成员数 (词))
        res ＝ 匹配表达式 (AST根)
        调试输出 (“匹配表达式 结束”, res.生成展示文本 ())
        
        .如果 (res.失败 ())
            跳出循环 ()
        .否则
            AST根.添加参数节点 (res)
        .如果结束
        跳出循环 ()
    .判断循环尾 ()

.子程序 匹配表达式, 抽象语法树节点
    .参数 父节点, 抽象语法树节点
    .局部变量 l, 抽象语法树节点
    .局部变量 r, 抽象语法树节点
    .局部变量 当前节点, 抽象语法树节点
    .局部变量 右侧无穷, 抽象语法树节点
    .局部变量 天父, 抽象语法树节点

    当前节点.初始化内存 (“匹配表达式 之起始”)
    调试输出 (“当前父节点”, 父节点.获取函数名 ())
    l ＝ 匹配加后表达式 (当前节点)
    
    .如果真 (l.失败 ())
        调试输出 (“未匹配到左加后表达式”)
        返回 (父节点.生成匹配失败节点 ())
    .如果真结束
    当前节点.添加参数节点 (l)
    调试输出 (“匹配到左加后表达式”, l.获取函数名 ())
    
    右侧无穷 ＝ 匹配表达式右侧无穷 (父节点)
    右侧无穷.插入参数节点 (l)
    
    天父 ＝ 右侧无穷
    .判断循环首 (天父.获取函数名 () ≠ “nop”)
        调试输出 (天父.生成展示文本 ())
        天父 ＝ 天父.获取父节点 ()
    .判断循环尾 ()
    天父 ＝ 天父.获取参数节点 (1)
    返回 (天父)
    

.子程序 匹配表达式右侧无穷, 抽象语法树节点
    .参数 父节点, 抽象语法树节点
    .局部变量 当前节点, 抽象语法树节点
    .局部变量 m, 抽象语法树节点
    .局部变量 r, 抽象语法树节点
    .局部变量 后续无穷, 抽象语法树节点

    当前节点.初始化内存 (“nop”)
    
    .如果真 (下个词 ().内容 ≠ “+” 且 下个词 ().内容 ≠ “-”)
        调试输出 (“未匹配到+-中算符”)
        返回 (当前节点)
    .如果真结束
    m ＝ 父节点.生成自词节点 (下个词 ())
    词游标自增 ()
    
    r ＝ 匹配加后表达式 (当前节点)
    
    .如果真 (r.失败 ())
        返回 (父节点.生成匹配失败节点 ())
    .如果真结束
    
    
    .如果 (下个词 ().类型 ≠ #词类_结尾)
        后续无穷 ＝ 匹配表达式右侧无穷 (r)
        .如果真 (后续无穷.失败 ())
            返回 (后续无穷)
        .如果真结束
        
    .否则
        后续无穷.初始化内存 (“nop”, )
    .如果结束
    
    调试输出 (下个词 ().类型)
    m.设置父节点 (后续无穷)
    m.添加参数节点 (r)
    后续无穷.插入参数节点 (m)
    返回 (m)
    

.子程序 匹配加后表达式, 抽象语法树节点
    .参数 父节点, 抽象语法树节点
    .局部变量 l, 抽象语法树节点
    .局部变量 当前节点, 抽象语法树节点
    .局部变量 右侧无穷, 抽象语法树节点
    .局部变量 r, 抽象语法树节点

    .局部变量 天父, 抽象语法树节点

    当前节点.初始化内存 ()
    调试输出 (“当前父节点”, 父节点.获取函数名 ())
    l ＝ 匹配因子 (父节点)
    
    .如果真 (l.失败 ())
        调试输出 (“未匹配到左数字”)
        返回 (父节点.生成匹配失败节点 ())
    .如果真结束
    调试输出 (“匹配到左数字”, l.获取函数名 ())
    当前节点.添加参数节点 (l)
    
    右侧无穷 ＝ 匹配加后表达式右侧无穷 (父节点)
    .如果真 (右侧无穷.获取参数数量 () ＞ 0)
        调试输出 (“右侧无穷”, 右侧无穷.获取参数节点 (1).生成展示文本 ())
    .如果真结束
    右侧无穷.插入参数节点 (l)
    调试输出 (“右侧无穷”, 右侧无穷.获取参数节点 (1).生成展示文本 ())
    
    天父 ＝ 右侧无穷
    .判断循环首 (天父.获取函数名 () ≠ “nop”)
        调试输出 (天父.生成展示文本 ())
        天父 ＝ 天父.获取父节点 ()
    .判断循环尾 ()
    天父 ＝ 天父.获取参数节点 (1)
    返回 (天父)
    

.子程序 匹配加后表达式右侧无穷, 抽象语法树节点
    .参数 父节点, 抽象语法树节点
    .局部变量 当前节点, 抽象语法树节点
    .局部变量 m, 抽象语法树节点
    .局部变量 r, 抽象语法树节点
    .局部变量 后续无穷, 抽象语法树节点

    当前节点.初始化内存 (“nop”)
    
    .如果真 (下个词 ().内容 ≠ “*” 且 下个词 ().内容 ≠ “/”)
        调试输出 (“未匹配到*/中算符”)
        返回 (当前节点)
    .如果真结束
    m ＝ 父节点.生成自词节点 (下个词 ())
    词游标自增 ()
    
    r ＝ 匹配因子 (父节点)
    
    .如果真 (r.失败 ())
        返回 (父节点.生成匹配失败节点 ())
    .如果真结束
    
    
    .如果 (下个词 ().类型 ≠ #词类_结尾)
        后续无穷 ＝ 匹配加后表达式右侧无穷 (r)
        .如果真 (后续无穷.失败 ())
            返回 (后续无穷)
        .如果真结束
        
    .否则
        后续无穷.初始化内存 (“nop”, )
    .如果结束
    
    调试输出 (下个词 ().类型)
    m.设置父节点 (后续无穷)
    m.添加参数节点 (r)
    后续无穷.插入参数节点 (m)
    返回 (m)
    

.子程序 匹配因子, 抽象语法树节点
    .参数 父节点, 抽象语法树节点
    .局部变量 当前节点, 抽象语法树节点
    .局部变量 左括号, 抽象语法树节点
    .局部变量 中表达式, 抽象语法树节点
    .局部变量 右括号, 抽象语法树节点
    .局部变量 数字, 抽象语法树节点
    .局部变量 函数, 抽象语法树节点

    .判断开始 (下个词 ().类型 ＝ #词类_括号)
        .如果真 (下个词 ().内容 ≠ “(”)
            返回 (父节点.生成匹配失败节点 ())
        .如果真结束
        左括号 ＝ 当前节点.生成自词节点 (下个词 ())
        词游标自增 ()
        中表达式 ＝ 匹配表达式 (当前节点)
        .如果真 (下个词 ().内容 ≠ “)”)
            返回 (父节点.生成匹配失败节点 ())
        .如果真结束
        
        右括号 ＝ 当前节点.生成自词节点 (下个词 ())
        词游标自增 ()
        当前节点.初始化内存 (“括号”, 父节点.获取当前节点指针 ())
        当前节点.添加参数节点 (中表达式)
        返回 (当前节点)
        
    .判断 (下个词 ().类型 ＝ #词类_数字)
        数字 ＝ 匹配数字 ()
        返回 (数字)
        
    .默认
        函数 ＝ 匹配函数 (当前节点)
        .如果真 (函数.失败 ())
            返回 (父节点.生成匹配失败节点 ())
        .如果真结束
        ' 当前节点.初始化内存 (“函数”, 父节点.获取当前节点指针 ())
        ' 当前节点.添加参数节点 (函数)
        返回 (函数)
    .判断结束
    
    
    
    

.子程序 匹配函数, 抽象语法树节点
    .参数 父节点, 抽象语法树节点
    .局部变量 当前节点, 抽象语法树节点
    .局部变量 标识符, 抽象语法树节点
    .局部变量 参数, 抽象语法树节点
    .局部变量 右侧无穷, 抽象语法树节点
    .局部变量 括号内下一表达式, 抽象语法树节点

    .如果真 (下个词 ().类型 ≠ #词类_标识符)
        返回 (父节点.生成匹配失败节点 ())
    .如果真结束
    标识符 ＝ 匹配标识符 (当前节点)
    
    .如果真 (下个词 ().内容 ≠ “(”)
        返回 (父节点.生成匹配失败节点 ())
    .如果真结束
    词游标自增 ()
    .如果真 (下个词 ().内容 ＝ “)”)
        词游标自增 ()
        返回 (标识符)
    .如果真结束
    
    参数 ＝ 匹配表达式 (当前节点)
    
    .如果真 (下个词 ().内容 ＝ “)”)
        标识符.添加参数节点 (参数)
        词游标自增 ()
        
        返回 (标识符)
        返回 (父节点.生成匹配失败节点 ())
    .如果真结束
    标识符.添加参数节点 (参数)
    
    .判断循环首 (真)
        .如果真 (下个词 ().类型 ≠ #词类_逗号  或 假)  ' 去掉「 或 假」后会触发e2txt的bug, 无法从.txt转回.e
            返回 (父节点.生成匹配失败节点 ())
        .如果真结束
        词游标自增 ()
        括号内下一表达式 ＝ 匹配表达式 (当前节点)
        .如果真 (括号内下一表达式.失败 ())
            返回 (父节点.生成匹配失败节点 ())
        .如果真结束
        标识符.添加参数节点 (括号内下一表达式)
        
        .如果真 (下个词 ().内容 ＝ “)”)
            词游标自增 ()
            跳出循环 ()
        .如果真结束
        
    .判断循环尾 ()
    返回 (标识符)
    

.子程序 匹配标识符, 抽象语法树节点
    .参数 父节点, 抽象语法树节点
    .局部变量 当前节点, 抽象语法树节点

    当前节点.初始化内存 ()
    
    .如果 (下个词 ().类型 ≠ #词类_标识符)
        当前节点.释放结构内存 ()
        返回 (当前节点.生成匹配失败节点 ())
    .否则
        当前节点.设置函数名 (下个词 ().内容)
        词游标自增 ()
        返回 (当前节点)
    .如果结束
    

.子程序 匹配数字, 抽象语法树节点
    .局部变量 当前节点, 抽象语法树节点

    当前节点.初始化内存 ()
    
    .如果 (下个词 ().类型 ≠ #词类_数字)
        当前节点.释放结构内存 ()
        返回 (当前节点.生成匹配失败节点 ())
    .否则
        当前节点.设置函数名 (下个词 ().内容)
        词游标自增 ()
        返回 (当前节点)
    .如果结束
    

.子程序 下个词, 词
    .局部变量 返回词, 词

    
    .如果 (当前词游标 ≥ 取数组成员数 (词))
        返回词.内容 ＝ “”
        返回词.类型 ＝ #词类_结尾
    .否则
        返回词 ＝ 词 [当前词游标 ＋ 1]
    .如果结束
    
    返回 (返回词)

.子程序 词游标自增
    当前词游标 ＝ 当前词游标 ＋ 1
    调试输出 (格式化文本 (“游标增至 %d 下一个:(%d,%s)”, 当前词游标, 下个词 ().类型, 下个词 ().内容))

.子程序 词游标自减
    当前词游标 ＝ 当前词游标 － 1
    调试输出 (格式化文本 (“游标减至 %d 下一个:(%d,%s)”, 当前词游标, 下个词 ().类型, 下个词 ().内容))

.子程序 重复文本, 文本型
    .参数 n, 整数型
    .参数 s, 文本型
    .局部变量 res, 文本型

    res ＝ “”
    .计次循环首 (n, )
        res ＝ res ＋ s
    .计次循环尾 ()
    返回 (res)

.子程序 输出语法分析结果
    .参数 AST, 抽象语法树节点
    .参数 当前层级, 整数型, 可空
    .局部变量 i, 整数型

    .如果真 (是否为空 (当前层级))
        当前层级 ＝ 0
    .如果真结束
    标准输出 (, 重复文本 (当前层级 × 2, “ ”))
    标准输出 (, AST.生成展示文本 () ＋ #换行符)
    .计次循环首 (AST.获取参数数量 (), i)
        输出语法分析结果 (AST.获取参数节点 (i), 当前层级 ＋ 1)
    .计次循环尾 ()

.子程序 语法分析并输出
    .参数 表达式, 文本型
    .局部变量 t0, 长整数型

    t0 ＝ 时间_取现行时间戳1 (真)
    词法分析 (表达式, 词)
    语法分析 (词)
    标准输出 (, “用时 ” ＋ 到文本 (时间_取现行时间戳1 (真) － t0) ＋ “ms” ＋ #换行符)
    输出语法分析结果 (AST根)