.版本 2

.程序集 程序集1
.子程序 _启动子程序, 整数型, , 本子程序在程序启动后最先执行
    求值并输出 (“12345”)
    求值并输出 (“1+1”)
    求值并输出 (“1+2*3”)
    求值并输出 (“1-999+999*2”)
    求值并输出 (“(1)”)
    求值并输出 (“(1+1)”)
    求值并输出 (“(1) + (2) + (3) * (4)”)
    求值并输出 (“(1) + (2) + (3) * (4)*8”)
    求值并输出 (“10 * (2 + 2)”)
    求值并输出 (“10 * (2 + 2) +  2 * (808080 - 808080)”)
    
    .判断循环首 (真)
        标准输出 (, “> ”)
        求值并输出 (标准输入 ())
    .判断循环尾 ()
    
    
    返回 (0) ' 可以根据您的需要返回任意数值

.子程序 求值并输出
    .参数 exp, 文本型
    .局部变量 res, 四则运算栈

    res ＝ 求值 (exp)
    标准输出 (, exp ＋ “ 之计算结果为 ” ＋ 到文本 (res.操作数栈 [1]) ＋ #换行符)
    

.子程序 求值, 四则运算栈, 公开
    .参数 表达式, 文本型
    .局部变量 res, 四则运算栈
    .局部变量 i, 整数型
    .局部变量 等待下一数字, 逻辑型
    .局部变量 当前字符, 文本型
    .局部变量 当前操作数, 整数型

    .局部变量 括号求值结果, 四则运算栈

    重定义数组 (res.操作符栈, 假, 0)
    重定义数组 (res.操作数栈, 假, 0)
    res.已食用文本 ＝ 表达式
    
    i ＝ 1
    等待下一数字 ＝ 假
    .判断循环首 (i ≤ 取文本长度 (表达式))
        当前字符 ＝ 取文本中间 (表达式, i, 1)
        
        .判断开始 (寻找文本 (“0123456789”, 当前字符, , 假) ≠ -1)
            当前操作数 ＝ 到整数 (当前字符)
            标准输出 (, “遇到数: ” ＋ 当前字符 ＋ #换行符)
            
            .判断循环首 (i ＋ 1 ≤ 取文本长度 (表达式) 且 寻找文本 (“0123456789”, 取文本中间 (表达式, i ＋ 1, 1), , 假) ≠ -1)
                标准输出 (, “遇到数: ” ＋ 取文本中间 (表达式, i ＋ 1, 1) ＋ #换行符)
                
                当前操作数 ＝ 当前操作数 × 10 ＋ 到整数 (取文本中间 (表达式, i ＋ 1, 1))
                i ＝ i ＋ 1
            .判断循环尾 ()
            加入成员 (res.操作数栈, 当前操作数)
            
        .判断 (寻找文本 (“+-*/”, 当前字符, , 假) ≠ -1)
            标准输出 (, “遇到符: ” ＋ 当前字符 ＋ #换行符)
            
            加入成员 (res.操作符栈, 当前字符)
            合并栈 (res.操作符栈, res.操作数栈, 假)
            
        .判断 (寻找文本 (“(”, 当前字符, , 假) ≠ -1)
            标准输出 (, “准备求值括号内容: ” ＋ 取文本右边 (表达式, 取文本长度 (表达式) － i) ＋ #换行符)
            
            括号求值结果 ＝ 求值 (取文本右边 (表达式, 取文本长度 (表达式) － i))
            加入成员 (res.操作数栈, 括号求值结果.操作数栈 [1])
            标准输出 (, “已食用文本: ” ＋ 括号求值结果.已食用文本 ＋ #换行符)
            i ＝ i ＋ 取文本长度 (括号求值结果.已食用文本)
        .判断 (寻找文本 (“)”, 当前字符, , 假) ≠ -1)
            res.已食用文本 ＝ 取文本左边 (res.已食用文本, i)
            合并栈 (res.操作符栈, res.操作数栈, 真)
            返回 (res)
        .默认
            
        .判断结束
        等待下一数字 ＝ 取反 (等待下一数字)
        i ＝ i ＋ 1
    .判断循环尾 ()
    合并栈 (res.操作符栈, res.操作数栈, 真)
    
    res.已食用文本 ＝ 取文本左边 (res.已食用文本, i)
    
    返回 (res)

.子程序 合并栈
    .参数 操作符栈, 文本型, 数组
    .参数 操作数栈, 整数型, 数组
    .参数 是否最终合并, 逻辑型
    .局部变量 上个操作符, 文本型
    .局部变量 上上个操作符, 文本型

    .局部变量 左操作数, 整数型
    .局部变量 右操作数, 整数型

    
    .判断循环首 (真)
        标准输出 (, “准备合并, 当前操作数|操作符栈长度 ” ＋ 到文本 (取数组成员数 (操作符栈)) ＋ “ | ” ＋ 到文本 (取数组成员数 (操作数栈)) ＋ #换行符)
        
        .判断开始 (取数组成员数 (操作符栈) ≥ 2)
            上个操作符 ＝ 弹出_文本 (操作符栈)
            上上个操作符 ＝ 弹出_文本 (操作符栈)
            .如果真 (是否最终合并)
                交换变量 (上个操作符, 上上个操作符)
            .如果真结束
            
        .判断 (取数组成员数 (操作符栈) ≥ 1 且 取数组成员数 (操作数栈) ≥ 2)
            上个操作符 ＝ “$”
            上上个操作符 ＝ 弹出_文本 (操作符栈)
        .默认
            跳出循环 ()
        .判断结束
        
        .如果 (取算符优先级 (上上个操作符) ≤ 取算符优先级 (上个操作符) 或 是否最终合并)
            右操作数 ＝ 弹出_整数 (操作数栈)
            左操作数 ＝ 弹出_整数 (操作数栈)
            
            加入成员 (操作数栈, 二元运算 (左操作数, 右操作数, 上上个操作符))
            .如果真 (上个操作符 ≠ “$”)
                加入成员 (操作符栈, 上个操作符)
            .如果真结束
            
        .否则
            加入成员 (操作符栈, 上上个操作符)
            .如果真 (上个操作符 ≠ “$”)
                加入成员 (操作符栈, 上个操作符)
            .如果真结束
            跳出循环 ()
        .如果结束
        
    .判断循环尾 ()

.子程序 取算符优先级, 整数型, 公开
    .参数 算符, 文本型

    ' 易语言的哈希表比较麻烦
    
    .如果真 (算符 ＝ “*” 或 算符 ＝ “/”)
        返回 (1)
    .如果真结束
    
    .如果真 (算符 ＝ “+” 或 算符 ＝ “-”)
        返回 (2)
    .如果真结束
    
    .如果真 (算符 ＝ “$”)
        返回 (9999) ' 终止符号
    .如果真结束
    
    返回 (9999)
    

.子程序 弹出_整数, 整数型
    .参数 变量, 整数型, 数组
    .局部变量 最后一个, 整数型

    ' 怎么搞一个泛型出来?
    
    最后一个 ＝ 变量 [取数组成员数 (变量)]
    删除成员 (变量, 取数组成员数 (变量), )
    返回 (最后一个)
    

.子程序 弹出_文本, 文本型
    .参数 变量, 文本型, 数组
    .局部变量 最后一个, 文本型

    ' 怎么搞一个泛型出来?
    
    最后一个 ＝ 变量 [取数组成员数 (变量)]
    删除成员 (变量, 取数组成员数 (变量), )
    返回 (最后一个)

.子程序 二元运算, 整数型
    .参数 左, 整数型
    .参数 右, 整数型
    .参数 符号, 文本型
    .局部变量 结果, 整数型

    
    .判断开始 (符号 ＝ “+”)
        结果 ＝ 左 ＋ 右
    .判断 (符号 ＝ “-”)
        结果 ＝ 左 － 右
    .判断 (符号 ＝ “*”)
        结果 ＝ 左 × 右
    .判断 (符号 ＝ “/”)
        结果 ＝ 左 ÷ 右
    .默认
        
    .判断结束
    返回 (结果)
    

.子程序 包含, 逻辑型
    .参数 数组, 文本型, 数组
    .参数 元素, 文本型
    .局部变量 i, 整数型

    .计次循环首 (取数组成员数 (数组), i)
        .如果真 (元素 ＝ 数组 [i])
            返回 (真)
        .如果真结束
        
    .计次循环尾 ()
    返回 (假)