【脚本架构开源】易语言.至臻Script。开源项目编译器解释器

Dhs过客 · 发表于 2021-10-11 20:54:42

自己整编译器确实很牛啊！

支持一下吧

咖啡胤sky · 发表于 2021-10-11 20:19:42

本帖最后由咖啡胤sky 于 2021-10-11 20:27 编辑

已经有同学开始不信了，认为这是虚构的东西，虽然没做完那也放出点代码，这是我们最基本的信任

窗口程序集名	保留	保留	备注
至臻脚本, , 公开, 全中文，多语种，跨平台脚本语言
变量名	类型	数组	备注
嵌套函数编译	文本型	0
处理	整数型		编译处理
执行指令	文本型	0	指令集
函数定义	函数过程	0
BIFN	文本型	0	易语言内定义函数名称
BIF	子程序指针	0	易语言内定义函数
全局变量	变量类		全局变量
MT	文本型	0	文本宏
DLL	动态链接库		动态指令库
运行日志	Json对象
M	整数型		日志序列

子程序名	返回值类型	公开	备注
_初始化			当基于本类的对象被创建后，此方法会被自动调用

子程序名	返回值类型	公开	备注
_销毁			当基于本类的对象被销毁前，此方法会被自动调用

子程序名	返回值类型	公开	备注
编译	文本型		属于编译器,已完工
参数名	类型	参考	可空	数组	备注
至臻代码	文本型

变量名	类型	静态	数组	备注
R	文本型			编译后
S	文本型			编译中
SR	文本型
SRS	文本型
I	整数型
当前行	文本型
SJ	文本型

S ＝文本_删空行 (至臻代码)
' 清除注释

计次循环首 (L_文本_取行数 (S), I)

如果 (SR ＝ “”)

SR ＝子文本替换 (文本_取指定文本行 (S, I), “//” ＋ L_文本_取右边 (文本_取指定文本行 (S, I), “//”, , ), “”, , , 真)

SR ＝ SR ＋ #换行符＋子文本替换 (文本_取指定文本行 (S, I), “//” ＋ L_文本_取右边 (文本_取指定文本行 (S, I), “//”, , ), “”, , , 真)

计次循环尾 ()
S ＝ SR
SR ＝ “”
I ＝ 0
S ＝子文本替换 (S, “#”, “@”, , , 真)
' 定义字符串宏

计次循环首 (取整 (L_文本_取出现次数 (S, #引号, 真) ÷ 2), I)

SR ＝ L_文本_取出中间文本 (S, #引号, #引号, , 假)

S ＝子文本替换 (S, #引号＋ SR ＋ #引号, “#T” ＋到文本 (I), , 1, 真)

如果 (R ＝ “”)

R ＝ “const #T” ＋到文本 (I) ＋ “ ” ＋ L_编码_base64编码 (到字节集 (SR))

R ＝ R ＋ #换行符＋ “const #T” ＋到文本 (I) ＋ “ ” ＋ L_编码_base64编码 (到字节集 (SR))

计次循环尾 ()
SR ＝ “”
I ＝ 0
S ＝子文本替换 (S, “ && ”, “^&^”, , , 真)
S ＝子文本替换 (S, “ || ”, “^|^”, , , 真)
S ＝子文本替换 (S, “{”, “[”, , , 真)
S ＝子文本替换 (S, “}”, “]”, , , 真)
' 多样化变量声明

计次循环首 (L_文本_取行数 (S), I)

当前行＝文本_取指定文本行 (S, I)

SJ ＝取缩进 (当前行)

如果真 (寻找文本 (当前行, “全局 ”, , 假) ≠ -1 且寻找文本 (当前行, “=”, , 假) ≠ -1)

S ＝文本_替换行内容 (S, I, SJ ＋ “全局 ” ＋文本_取出中间文本 (当前行, “全局 ”, “=”, , 假))

S ＝文本_插入文本到某行后 (S, I, #换行符＋ SJ ＋文本_取出中间文本 (当前行, “全局 ”, “=”, , 假) ＋ “ = ” ＋文本_取右边 (当前行, “=”, , 假))

计次循环尾 ()
I ＝ 0
SJ ＝ “”

计次循环首 (L_文本_取行数 (S), I)

当前行＝文本_取指定文本行 (S, I)

SJ ＝取缩进 (当前行)

如果真 (寻找文本 (当前行, “变量 ”, , 假) ≠ -1 且寻找文本 (当前行, “=”, , 假) ≠ -1)

S ＝文本_替换行内容 (S, I, SJ ＋ “变量 ” ＋文本_取出中间文本 (当前行, “变量 ”, “=”, , 假))

S ＝文本_插入文本到某行后 (S, I, #换行符＋ SJ ＋文本_取出中间文本 (当前行, “变量 ”, “=”, , 假) ＋ “ = ” ＋文本_取右边 (当前行, “=”, , 假))

计次循环尾 ()
I ＝ 0
' 逐行编译

计次循环首 (L_文本_取行数 (S), I)

处理＝ 0

清除数组 (嵌套函数编译)

' 信息框 (I, 0, , )

如果 (R ＝ “”)

R ＝行语义 (文本_取指定文本行 (S, I))

R ＝ R ＋ #换行符＋行语义 (文本_取指定文本行 (S, I))

计次循环尾 ()

判断循环首 (寻找文本 (R, “ ”, , 假) ≠ -1)

R ＝子文本替换 (R, “ ”, “ ”, , , 真)

判断循环尾 ()
返回 (R)

.版本 2<br />
<br />
.子程序 编译, 文本型, 公开, 属于编译器,已完工<br />
.参数 至臻代码, 文本型<br />
.局部变量 R, 文本型, , , 编译后<br />
.局部变量 S, 文本型, , , 编译中<br />
.局部变量 SR, 文本型<br />
.局部变量 SRS, 文本型<br />
.局部变量 I, 整数型<br />
.局部变量 当前行, 文本型<br />
.局部变量 SJ, 文本型<br />
<br />
S ＝ 文本_删空行 (至臻代码)<br />
' 清除注释<br />
.计次循环首 (L_文本_取行数 (S), I)<br />
    .如果 (SR ＝ “”)<br />
        SR ＝ 子文本替换 (文本_取指定文本行 (S, I), “//” ＋ L_文本_取右边 (文本_取指定文本行 (S, I), “//”, , ), “”, , , 真)<br />
    .否则<br />
        SR ＝ SR ＋ #换行符 ＋ 子文本替换 (文本_取指定文本行 (S, I), “//” ＋ L_文本_取右边 (文本_取指定文本行 (S, I), “//”, , ), “”, , , 真)<br />
    .如果结束<br />
<br />
.计次循环尾 ()<br />
S ＝ SR<br />
SR ＝ “”<br />
I ＝ 0<br />
S ＝ 子文本替换 (S, “#”, “@”, , , 真)<br />
' 定义字符串宏<br />
.计次循环首 (取整 (L_文本_取出现次数 (S, #引号, 真) ÷ 2), I)<br />
    SR ＝ L_文本_取出中间文本 (S, #引号, #引号, , 假)<br />
    S ＝ 子文本替换 (S, #引号 ＋ SR ＋ #引号, “#T” ＋ 到文本 (I), , 1, 真)<br />
    .如果 (R ＝ “”)<br />
        R ＝ “const #T” ＋ 到文本 (I) ＋ “ ” ＋ L_编码_base64编码 (到字节集 (SR))<br />
    .否则<br />
        R ＝ R ＋ #换行符 ＋ “const #T” ＋ 到文本 (I) ＋ “ ” ＋ L_编码_base64编码 (到字节集 (SR))<br />
    .如果结束<br />
<br />
.计次循环尾 ()<br />
SR ＝ “”<br />
I ＝ 0<br />
S ＝ 子文本替换 (S, “ && ”, “^&^”, , , 真)<br />
S ＝ 子文本替换 (S, “ || ”, “^|^”, , , 真)<br />
S ＝ 子文本替换 (S, “{”, “[”, , , 真)<br />
S ＝ 子文本替换 (S, “}”, “]”, , , 真)<br />
' 多样化变量声明<br />
.计次循环首 (L_文本_取行数 (S), I)<br />
    当前行 ＝ 文本_取指定文本行 (S, I)<br />
    SJ ＝ 取缩进 (当前行)<br />
    .如果真 (寻找文本 (当前行, “全局 ”, , 假) ≠ -1 且 寻找文本 (当前行, “=”, , 假) ≠ -1)<br />
        S ＝ 文本_替换行内容 (S, I, SJ ＋ “全局 ” ＋ 文本_取出中间文本 (当前行, “全局 ”, “=”, , 假))<br />
        S ＝ 文本_插入文本到某行后 (S, I, #换行符 ＋ SJ ＋ 文本_取出中间文本 (当前行, “全局 ”, “=”, , 假) ＋ “ = ” ＋ 文本_取右边 (当前行, “=”, , 假))<br />
    .如果真结束<br />
<br />
.计次循环尾 ()<br />
I ＝ 0<br />
SJ ＝ “”<br />
.计次循环首 (L_文本_取行数 (S), I)<br />
    当前行 ＝ 文本_取指定文本行 (S, I)<br />
    SJ ＝ 取缩进 (当前行)<br />
    .如果真 (寻找文本 (当前行, “变量 ”, , 假) ≠ -1 且 寻找文本 (当前行, “=”, , 假) ≠ -1)<br />
        S ＝ 文本_替换行内容 (S, I, SJ ＋ “变量 ” ＋ 文本_取出中间文本 (当前行, “变量 ”, “=”, , 假))<br />
        S ＝ 文本_插入文本到某行后 (S, I, #换行符 ＋ SJ ＋ 文本_取出中间文本 (当前行, “变量 ”, “=”, , 假) ＋ “ = ” ＋ 文本_取右边 (当前行, “=”, , 假))<br />
    .如果真结束<br />
<br />
.计次循环尾 ()<br />
I ＝ 0<br />
' 逐行编译<br />
.计次循环首 (L_文本_取行数 (S), I)<br />
    处理 ＝ 0<br />
    清除数组 (嵌套函数编译)<br />
    ' 信息框 (I, 0, , )<br />
    .如果 (R ＝ “”)<br />
        R ＝ 行语义 (文本_取指定文本行 (S, I))<br />
    .否则<br />
        R ＝ R ＋ #换行符 ＋ 行语义 (文本_取指定文本行 (S, I))<br />
    .如果结束<br />
<br />
.计次循环尾 ()<br />
.判断循环首 (寻找文本 (R, “  ”, , 假) ≠ -1)<br />
    R ＝ 子文本替换 (R, “  ”, “ ”, , , 真)<br />
.判断循环尾 ()<br />
返回 (R)

子程序名	返回值类型	公开	备注
行语义	文本型
参数名	类型	参考	可空	数组	备注
代码	文本型

变量名	类型	静态	数组	备注
R	文本型
RS	文本型
RA	文本型		0
本行缩进数	整数型
I	整数型
有逻辑运算	逻辑型			== != <= >= < > (! \|\| && and or
ARRS	文本型		0

如果 (代码 ≠ “”)

本行缩进数＝取缩进数 (代码)

判断 (寻找文本 (代码, “==”, , 假) ≠ -1)

有逻辑运算＝真

判断 (寻找文本 (代码, “!=”, , 假) ≠ -1)

有逻辑运算＝真

判断 (寻找文本 (代码, “<=”, , 假) ≠ -1)

有逻辑运算＝真

判断 (寻找文本 (代码, “>=”, , 假) ≠ -1)

有逻辑运算＝真

判断 (寻找文本 (代码, “<”, , 假) ≠ -1)

有逻辑运算＝真

判断 (寻找文本 (代码, “>”, , 假) ≠ -1)

有逻辑运算＝真

判断 (寻找文本 (代码, “^|^”, , 假) ≠ -1)

有逻辑运算＝真

判断 (寻找文本 (代码, “^&^”, , 假) ≠ -1)

有逻辑运算＝真

如果真 (寻找文本 (文本_去空 (代码), “(!”, , 假) ≠ -1)

有逻辑运算＝真

判断 (本行缩进数＝ 0 且文本_取头位 (代码, 4) ＝ “定义”)

R ＝ “def ”

RS ＝ L_文本_取右边 (代码, “定义 ”, , )

RS ＝文本_去空 (L_文本_取左边 (RS, “(”, , 真))

R ＝ R ＋ RS

如果 (L_文本_取出现次数 (文本_两极取中间 (代码, “(”, “)”, , 真), “,”, 真) ≠ 0)

RA ＝分割文本 (文本_两极取中间 (代码, “(”, “)”, , 真), “,”, )

计次循环首 (取数组成员数 (RA), I)

R ＝ R ＋ “ ” ＋文本_去空 (RA [I])

计次循环尾 ()

R ＝ R ＋ “ ” ＋文本_去空 (文本_两极取中间 (代码, “(”, “)”, , 真))

R ＝ L_文本_删首尾指定文本 (R, “ ”, 真, 真, , )

判断 (寻找文本 (文本_去空 (代码), “如果(”, , 假) ≠ -1)

' R ＝ “lbr ” ＋到文本 (本行缩进数) ＋ “ ” ＋文本_两极取中间 (文本_去空 (代码), “如果(”, “):”, , )

R ＝生成函数指令码 (“(” ＋文本_两极取中间 (文本_去空 (代码), “如果(”, “):”, , ) ＋ “)”, 到文本 (本行缩进数), 真, “lbr ” ＋到文本 (本行缩进数), 真)

判断 (寻找文本 (代码, “如果 ”, , 假) ≠ -1)

R ＝生成函数指令码 (“(” ＋文本_去空 (文本_两极取中间 (代码, “如果 ”, “:”, , )) ＋ “)”, 到文本 (本行缩进数), 真, “lbr ” ＋到文本 (本行缩进数), 真)

判断 (寻找文本 (代码, “否则:”, , 假) ≠ -1)

R ＝ “els ” ＋到文本 (本行缩进数)

判断 (寻找文本 (文本_去空 (代码), “循环(”, , 假) ≠ -1)

R ＝ “wle ” ＋到文本 (本行缩进数) ＋ “ ”

R ＝ R ＋生成函数指令码 (“(” ＋文本_两极取中间 (文本_去空 (代码), “循环(”, “):”, , ) ＋ “)”, 到文本 (本行缩进数), 真, , 真)

判断 (寻找文本 (代码, “循环 ”, , 假) ≠ -1)

R ＝ “wle ” ＋到文本 (本行缩进数) ＋ “ ”

R ＝ R ＋生成函数指令码 (“(” ＋文本_去空 (文本_两极取中间 (代码, “循环 ”, “:”, , )) ＋ “)”, 到文本 (本行缩进数), 真, , 真)

判断 (寻找文本 (文本_去空 (代码), “返回(”, , 假) ≠ -1)

R ＝ “ret ” ＋到文本 (本行缩进数) ＋ “ ”

R ＝ R ＋生成函数指令码 (“(” ＋文本_两极取中间 (文本_去空 (代码), “返回(”, “)”, , ) ＋ “)”, 到文本 (本行缩进数), 真, , 真)

判断 (寻找文本 (代码, “返回 ”, , 假) ≠ -1)

R ＝ “ret ” ＋到文本 (本行缩进数) ＋ “ ”

R ＝ R ＋生成函数指令码 (“(” ＋文本_去空 (L_文本_取右边 (代码, “返回 ”, , )) ＋ “)”, 到文本 (本行缩进数), 真, , 真)

判断 (寻找文本 (文本_去空 (代码), “=”, , 假) ≠ -1 且 L_文本_取左边 (文本_去空 (代码), “=”, , ) ≠ “” 且 L_文本_取右边 (文本_去空 (代码), “=”, , ) ≠ “”)

R ＝ “pei ” ＋到文本 (本行缩进数) ＋ “ ”

如果 (寻找文本 (L_文本_取右边 (文本_去空 (代码), “=”, , ), “[”, , 假) ≠ -1)

' 调试输出 (代码＋ “ AAA”)

ARRS ＝分割文本 (文本_两极取中间 (L_文本_取右边 (文本_去空 (代码), “=”, , ), “[”, “]”, , ), “,”, )

R ＝ R ＋文本_取左边 (L_文本_取左边 (文本_去空 (代码), “=”, , ), “[”, , ) ＋ “ ”

如果 (取数组成员数 (ARRS) ＞ 1)

R ＝ R ＋ “1,” ＋到文本 (取数组成员数 (ARRS)) ＋ “ ”

R ＝ R ＋ “1 ”

R ＝ R ＋生成函数指令码 (“(” ＋文本_两极取中间 (L_文本_取右边 (文本_去空 (代码), “=”, , ), “[”, “]”, , ) ＋ “)”, 到文本 (本行缩进数), 真, , 真)

如果 (寻找文本 (L_文本_取左边 (文本_去空 (代码), “=”, , ), “[”, , 假) ≠ -1)

R ＝ R ＋文本_取左边 (L_文本_取左边 (文本_去空 (代码), “=”, , ), “[”, , ) ＋ “ ” ＋取成员下标 (L_文本_取左边 (文本_去空 (代码), “=”, , )) ＋ “ ”

R ＝ R ＋ L_文本_取左边 (文本_去空 (代码), “=”, , ) ＋ “ ” ＋取成员下标 (L_文本_取左边 (文本_去空 (代码), “=”, , )) ＋ “ ”

R ＝ R ＋生成函数指令码 (“(” ＋ L_文本_取右边 (文本_去空 (代码), “=”, , ) ＋ “)”, 到文本 (本行缩进数), 真, , 真)

' R ＝ R ＋生成函数指令码 (“(” ＋ L_文本_取右边 (文本_去空 (代码), “=”, , ) ＋ “)”, 到文本 (本行缩进数), 真, , 真)

判断 (寻找文本 (代码, “全局 ”, , 假) ≠ -1 且 L_文本_取右边 (文本_去空 (代码), “全局”, , ) ≠ “”)

R ＝ “nvr ” ＋到文本 (本行缩进数) ＋ “ ”

如果 (寻找文本 (L_文本_取右边 (文本_去空 (代码), “全局”, , ), “[”, , 假) ≠ -1)

R ＝ R ＋文本_取左边 (L_文本_取右边 (文本_去空 (代码), “全局”, , ), “[”, , ) ＋ “ ” ＋到文本 (取成员下标 (L_文本_取右边 (文本_去空 (代码), “全局”, , )))

R ＝ R ＋ L_文本_取右边 (文本_去空 (代码), “全局”, , ) ＋ “ ” ＋到文本 (取成员下标 (L_文本_取右边 (文本_去空 (代码), “全局”, , )))

判断 (寻找文本 (代码, “变量 ”, , 假) ≠ -1 且 L_文本_取右边 (文本_去空 (代码), “变量”, , ) ≠ “”)

R ＝ “new ” ＋到文本 (本行缩进数) ＋ “ ”

如果 (寻找文本 (L_文本_取右边 (文本_去空 (代码), “变量”, , ), “[”, , 假) ≠ -1)

R ＝ R ＋文本_取左边 (L_文本_取右边 (文本_去空 (代码), “变量”, , ), “[”, , ) ＋ “ ” ＋到文本 (取成员下标 (L_文本_取右边 (文本_去空 (代码), “变量”, , )))

R ＝ R ＋ L_文本_取右边 (文本_去空 (代码), “变量”, , ) ＋ “ ” ＋到文本 (取成员下标 (L_文本_取右边 (文本_去空 (代码), “变量”, , )))

判断 (文本_去空 (代码) ＝ “跳出” 或文本_去空 (代码) ＝ “跳出()”)

R ＝ “jmp ” ＋到文本 (本行缩进数)

判断 (寻找文本 (文本_去空 (代码), “跨越(”, , 假) ≠ -1)

R ＝ “mov ” ＋到文本 (本行缩进数) ＋文本_去空 (文本_取出中间文本 (代码, “(”, “)”, , ))

判断 (寻找文本 (文本_去空 (代码), “(”, , 假) ≠ -1 且寻找文本 (文本_去空 (代码), “)”, , 假) ≠ -1 且有逻辑运算＝假)

R ＝生成函数指令码 (代码, 到文本 (本行缩进数), 真, , )

判断 (寻找文本 (文本_去空 (代码), “--”, , 假) ≠ -1 且有逻辑运算＝假)

R ＝ “dec ” ＋到文本 (本行缩进数) ＋ “ ” ＋文本_取左边 (文本_去空 (代码), “--”, , )

判断 (寻找文本 (文本_去空 (代码), “++”, , 假) ≠ -1 且有逻辑运算＝假)

R ＝ “neg ” ＋到文本 (本行缩进数) ＋ “ ” ＋文本_取左边 (文本_去空 (代码), “++”, , )

R ＝ “nle”

R ＝ “nle”
返回 (R)

子程序名	返回值类型	公开	备注
取成员下标	文本型
参数名	类型	参考	可空	数组	备注
变量读取表达式	文本型

如果 (L_文本_取出现次数 (变量读取表达式, “[”, ) ≠ 0 且 L_文本_取出现次数 (变量读取表达式, “]”, ) ≠ 0)

返回 (L_文本_取出中间文本 (变量读取表达式, “[”, “]”, , ))

返回 (“0”)

子程序名	返回值类型	公开	备注
取变量名	文本型
参数名	类型	参考	可空	数组	备注
变量读取表达式	文本型

如果 (L_文本_取出现次数 (变量读取表达式, “[”, ) ≠ 0 且 L_文本_取出现次数 (变量读取表达式, “]”, ) ≠ 0)

返回 (L_文本_取左边 (变量读取表达式, “[”, , ))

返回 (变量读取表达式)

.版本 2<br />
<br />
.子程序 行语义, 文本型<br />
.参数 代码, 文本型<br />
.局部变量 R, 文本型<br />
.局部变量 RS, 文本型<br />
.局部变量 RA, 文本型, , "0"<br />
.局部变量 本行缩进数, 整数型<br />
.局部变量 I, 整数型<br />
.局部变量 有逻辑运算, 逻辑型, , , == != <= >= < > (! || && and or<br />
.局部变量 ARRS, 文本型, , "0"<br />
<br />
.如果 (代码 ≠ “”)<br />
    本行缩进数 ＝ 取缩进数 (代码)<br />
    .判断开始 (寻找文本 (代码, “==”, , 假) ≠ -1)<br />
        有逻辑运算 ＝ 真<br />
    .判断 (寻找文本 (代码, “!=”, , 假) ≠ -1)<br />
        有逻辑运算 ＝ 真<br />
    .判断 (寻找文本 (代码, “<=”, , 假) ≠ -1)<br />
        有逻辑运算 ＝ 真<br />
    .判断 (寻找文本 (代码, “>=”, , 假) ≠ -1)<br />
        有逻辑运算 ＝ 真<br />
    .判断 (寻找文本 (代码, “<”, , 假) ≠ -1)<br />
        有逻辑运算 ＝ 真<br />
    .判断 (寻找文本 (代码, “>”, , 假) ≠ -1)<br />
        有逻辑运算 ＝ 真<br />
    .判断 (寻找文本 (代码, “^|^”, , 假) ≠ -1)<br />
        有逻辑运算 ＝ 真<br />
    .判断 (寻找文本 (代码, “^&^”, , 假) ≠ -1)<br />
        有逻辑运算 ＝ 真<br />
    .默认<br />
        .如果真 (寻找文本 (文本_去空 (代码), “(!”, , 假) ≠ -1)<br />
            有逻辑运算 ＝ 真<br />
        .如果真结束<br />
<br />
    .判断结束<br />
<br />
    .判断开始 (本行缩进数 ＝ 0 且 文本_取头位 (代码, 4) ＝ “定义”)<br />
        R ＝ “def ”<br />
        RS ＝ L_文本_取右边 (代码, “定义 ”, , )<br />
        RS ＝ 文本_去空 (L_文本_取左边 (RS, “(”, , 真))<br />
        R ＝ R ＋ RS<br />
        .如果 (L_文本_取出现次数 (文本_两极取中间 (代码, “(”, “)”, , 真), “,”, 真) ≠ 0)<br />
            RA ＝ 分割文本 (文本_两极取中间 (代码, “(”, “)”, , 真), “,”, )<br />
            .计次循环首 (取数组成员数 (RA), I)<br />
                R ＝ R ＋ “ ” ＋ 文本_去空 (RA [I])<br />
            .计次循环尾 ()<br />
        .否则<br />
            R ＝ R ＋ “ ” ＋ 文本_去空 (文本_两极取中间 (代码, “(”, “)”, , 真))<br />
        .如果结束<br />
        R ＝ L_文本_删首尾指定文本 (R, “ ”, 真, 真, , )<br />
<br />
    .判断 (寻找文本 (文本_去空 (代码), “如果(”, , 假) ≠ -1)<br />
        ' R ＝ “lbr ” ＋ 到文本 (本行缩进数) ＋ “ ” ＋ 文本_两极取中间 (文本_去空 (代码), “如果(”, “):”, , )<br />
        R ＝ 生成函数指令码 (“(” ＋ 文本_两极取中间 (文本_去空 (代码), “如果(”, “):”, , ) ＋ “)”, 到文本 (本行缩进数), 真, “lbr ” ＋ 到文本 (本行缩进数), 真)<br />
<br />
    .判断 (寻找文本 (代码, “如果 ”, , 假) ≠ -1)<br />
        R ＝ 生成函数指令码 (“(” ＋ 文本_去空 (文本_两极取中间 (代码, “如果 ”, “:”, , )) ＋ “)”, 到文本 (本行缩进数), 真, “lbr ” ＋ 到文本 (本行缩进数), 真)<br />
<br />
    .判断 (寻找文本 (代码, “否则:”, , 假) ≠ -1)<br />
        R ＝ “els ” ＋ 到文本 (本行缩进数)<br />
<br />
    .判断 (寻找文本 (文本_去空 (代码), “循环(”, , 假) ≠ -1)<br />
        R ＝ “wle ” ＋ 到文本 (本行缩进数) ＋ “ ”<br />
        R ＝ R ＋ 生成函数指令码 (“(” ＋ 文本_两极取中间 (文本_去空 (代码), “循环(”, “):”, , ) ＋ “)”, 到文本 (本行缩进数), 真, , 真)<br />
<br />
    .判断 (寻找文本 (代码, “循环 ”, , 假) ≠ -1)<br />
        R ＝ “wle ” ＋ 到文本 (本行缩进数) ＋ “ ”<br />
        R ＝ R ＋ 生成函数指令码 (“(” ＋ 文本_去空 (文本_两极取中间 (代码, “循环 ”, “:”, , )) ＋ “)”, 到文本 (本行缩进数), 真, , 真)<br />
<br />
    .判断 (寻找文本 (文本_去空 (代码), “返回(”, , 假) ≠ -1)<br />
        R ＝ “ret ” ＋ 到文本 (本行缩进数) ＋ “ ”<br />
        R ＝ R ＋ 生成函数指令码 (“(” ＋ 文本_两极取中间 (文本_去空 (代码), “返回(”, “)”, , ) ＋ “)”, 到文本 (本行缩进数), 真, , 真)<br />
<br />
    .判断 (寻找文本 (代码, “返回 ”, , 假) ≠ -1)<br />
        R ＝ “ret ” ＋ 到文本 (本行缩进数) ＋ “ ”<br />
        R ＝ R ＋ 生成函数指令码 (“(” ＋ 文本_去空 (L_文本_取右边 (代码, “返回 ”, , )) ＋ “)”, 到文本 (本行缩进数), 真, , 真)<br />
<br />
    .判断 (寻找文本 (文本_去空 (代码), “=”, , 假) ≠ -1 且 L_文本_取左边 (文本_去空 (代码), “=”, , ) ≠ “” 且 L_文本_取右边 (文本_去空 (代码), “=”, , ) ≠ “”)<br />
        R ＝ “pei ” ＋ 到文本 (本行缩进数) ＋ “ ”<br />
        .如果 (寻找文本 (L_文本_取右边 (文本_去空 (代码), “=”, , ), “[”, , 假) ≠ -1)<br />
            ' 调试输出 (代码 ＋ “          AAA”)<br />
            ARRS ＝ 分割文本 (文本_两极取中间 (L_文本_取右边 (文本_去空 (代码), “=”, , ), “[”, “]”, , ), “,”, )<br />
            R ＝ R ＋ 文本_取左边 (L_文本_取左边 (文本_去空 (代码), “=”, , ), “[”, , ) ＋ “ ”<br />
            .如果 (取数组成员数 (ARRS) ＞ 1)<br />
                R ＝ R ＋ “1,” ＋ 到文本 (取数组成员数 (ARRS)) ＋ “ ”<br />
            .否则<br />
                R ＝ R ＋ “1 ”<br />
            .如果结束<br />
            R ＝ R ＋ 生成函数指令码 (“(” ＋ 文本_两极取中间 (L_文本_取右边 (文本_去空 (代码), “=”, , ), “[”, “]”, , ) ＋ “)”, 到文本 (本行缩进数), 真, , 真)<br />
        .否则<br />
<br />
            .如果 (寻找文本 (L_文本_取左边 (文本_去空 (代码), “=”, , ), “[”, , 假) ≠ -1)<br />
                R ＝ R ＋ 文本_取左边 (L_文本_取左边 (文本_去空 (代码), “=”, , ), “[”, , ) ＋ “ ” ＋ 取成员下标 (L_文本_取左边 (文本_去空 (代码), “=”, , )) ＋ “ ”<br />
            .否则<br />
                R ＝ R ＋ L_文本_取左边 (文本_去空 (代码), “=”, , ) ＋ “ ” ＋ 取成员下标 (L_文本_取左边 (文本_去空 (代码), “=”, , )) ＋ “ ”<br />
            .如果结束<br />
            R ＝ R ＋ 生成函数指令码 (“(” ＋ L_文本_取右边 (文本_去空 (代码), “=”, , ) ＋ “)”, 到文本 (本行缩进数), 真, , 真)<br />
        .如果结束<br />
<br />
        ' R ＝ R ＋ 生成函数指令码 (“(” ＋ L_文本_取右边 (文本_去空 (代码), “=”, , ) ＋ “)”, 到文本 (本行缩进数), 真, , 真)<br />
<br />
    .判断 (寻找文本 (代码, “全局 ”, , 假) ≠ -1 且 L_文本_取右边 (文本_去空 (代码), “全局”, , ) ≠ “”)<br />
        R ＝ “nvr ” ＋ 到文本 (本行缩进数) ＋ “ ”<br />
        .如果 (寻找文本 (L_文本_取右边 (文本_去空 (代码), “全局”, , ), “[”, , 假) ≠ -1)<br />
            R ＝ R ＋ 文本_取左边 (L_文本_取右边 (文本_去空 (代码), “全局”, , ), “[”, , ) ＋ “ ” ＋ 到文本 (取成员下标 (L_文本_取右边 (文本_去空 (代码), “全局”, , )))<br />
        .否则<br />
            R ＝ R ＋ L_文本_取右边 (文本_去空 (代码), “全局”, , ) ＋ “ ” ＋ 到文本 (取成员下标 (L_文本_取右边 (文本_去空 (代码), “全局”, , )))<br />
        .如果结束<br />
<br />
    .判断 (寻找文本 (代码, “变量 ”, , 假) ≠ -1 且 L_文本_取右边 (文本_去空 (代码), “变量”, , ) ≠ “”)<br />
        R ＝ “new ” ＋ 到文本 (本行缩进数) ＋ “ ”<br />
        .如果 (寻找文本 (L_文本_取右边 (文本_去空 (代码), “变量”, , ), “[”, , 假) ≠ -1)<br />
            R ＝ R ＋ 文本_取左边 (L_文本_取右边 (文本_去空 (代码), “变量”, , ), “[”, , ) ＋ “ ” ＋ 到文本 (取成员下标 (L_文本_取右边 (文本_去空 (代码), “变量”, , )))<br />
        .否则<br />
            R ＝ R ＋ L_文本_取右边 (文本_去空 (代码), “变量”, , ) ＋ “ ” ＋ 到文本 (取成员下标 (L_文本_取右边 (文本_去空 (代码), “变量”, , )))<br />
        .如果结束<br />
<br />
    .判断 (文本_去空 (代码) ＝ “跳出” 或 文本_去空 (代码) ＝ “跳出()”)<br />
        R ＝ “jmp ” ＋ 到文本 (本行缩进数)<br />
<br />
    .判断 (寻找文本 (文本_去空 (代码), “跨越(”, , 假) ≠ -1)<br />
        R ＝ “mov ” ＋ 到文本 (本行缩进数) ＋ 文本_去空 (文本_取出中间文本 (代码, “(”, “)”, , ))<br />
<br />
    .判断 (寻找文本 (文本_去空 (代码), “(”, , 假) ≠ -1 且 寻找文本 (文本_去空 (代码), “)”, , 假) ≠ -1 且 有逻辑运算 ＝ 假)<br />
        R ＝ 生成函数指令码 (代码, 到文本 (本行缩进数), 真, , )<br />
<br />
    .判断 (寻找文本 (文本_去空 (代码), “--”, , 假) ≠ -1 且 有逻辑运算 ＝ 假)<br />
        R ＝ “dec ” ＋ 到文本 (本行缩进数) ＋ “ ” ＋ 文本_取左边 (文本_去空 (代码), “--”, , )<br />
<br />
    .判断 (寻找文本 (文本_去空 (代码), “++”, , 假) ≠ -1 且 有逻辑运算 ＝ 假)<br />
        R ＝ “neg ” ＋ 到文本 (本行缩进数) ＋ “ ” ＋ 文本_取左边 (文本_去空 (代码), “++”, , )<br />
    .默认<br />
        R ＝ “nle”<br />
    .判断结束<br />
<br />
.否则<br />
    R ＝ “nle”<br />
.如果结束<br />
返回 (R)<br />
<br />
<br />
.子程序 取成员下标, 文本型<br />
.参数 变量读取表达式, 文本型<br />
<br />
.如果 (L_文本_取出现次数 (变量读取表达式, “[”, ) ≠ 0 且 L_文本_取出现次数 (变量读取表达式, “]”, ) ≠ 0)<br />
    返回 (L_文本_取出中间文本 (变量读取表达式, “[”, “]”, , ))<br />
.否则<br />
    返回 (“0”)<br />
.如果结束<br />
<br />
<br />
.子程序 取变量名, 文本型<br />
.参数 变量读取表达式, 文本型<br />
<br />
.如果 (L_文本_取出现次数 (变量读取表达式, “[”, ) ≠ 0 且 L_文本_取出现次数 (变量读取表达式, “]”, ) ≠ 0)<br />
    返回 (L_文本_取左边 (变量读取表达式, “[”, , ))<br />
.否则<br />
    返回 (变量读取表达式)<br />
.如果结束

子程序名	返回值类型	公开	备注
置入代码			设置指令集代码
参数名	类型	参考	可空	数组	备注
执行码	文本型				至臻.编译() 得出的指令执行码
INIT代码	文本型				初始化代码,准备用作独立版的头文件代码摄入非指令码

变量名	类型	静态	数组	备注
I	整数型
JSON	Json对象
EXECC	文本型		0
EXEC	文本型		0
FUNC	函数过程

' 载入指令集
加入成员 (执行指令, “def System_Init”)

如果真 (是否为空 (INIT代码) ＝假)
EXECC ＝分割文本 (执行码, #换行符, )

计次循环首 (取数组成员数 (EXECC), I)

加入成员 (执行指令, EXECC [I])

计次循环尾 ()
I ＝ 0
JSON.写文本 (到文本 (M), “载入指令集代码 EXEC EZ LEN” ＋到文本 (取数组成员数 (执行指令)) ＋ GT ())
' 分配文本宏

计次循环首 (取数组成员数 (执行指令), I)

如果真 (寻找文本 (执行指令 [I], “const ”, , 假) ≠ -1)

分析 (执行指令 [I], EXEC)

' 调试输出 (M)

加入成员 (MT, 数据解码 (EXEC [3]))

JSON.写文本 (到文本 (M), “配置宏文本 #T” ＋到文本 (取数组成员数 (MT)) ＋ #引号＋ MT [取数组成员数 (MT)] ＋ #引号＋ GT ())

计次循环尾 ()
I ＝ 0
' 区分函数定义

计次循环首 (取数组成员数 (执行指令), I)

' 调试输出 (到文本 (I) ＋ “ ” ＋执行指令 [I])

分析 (执行指令 [I], EXEC)

如果 (I ＝取数组成员数 (执行指令)) ' 代表最后一行

如果 (EXEC [1] ＝ “def”)

FUNC.起始＝ I

FUNC.名＝ EXEC [2]

FUNC.终止＝ I

加入成员 (函数定义, FUNC)

JSON.写文本 (到文本 (M), “定义函数过程 ” ＋函数定义 [取数组成员数 (函数定义)].名＋ “ S:” ＋到文本 (函数定义 [取数组成员数 (函数定义)].起始) ＋ “ E:” ＋到文本 (函数定义 [取数组成员数 (函数定义)].终止) ＋ GT ())

如果真 (FUNC.起始 ≠ 0)

FUNC.终止＝ I

加入成员 (函数定义, FUNC)

JSON.写文本 (到文本 (M), “定义函数过程 ” ＋函数定义 [取数组成员数 (函数定义)].名＋ “ S:” ＋到文本 (函数定义 [取数组成员数 (函数定义)].起始) ＋ “ E:” ＋到文本 (函数定义 [取数组成员数 (函数定义)].终止) ＋ GT ())

如果真 (EXEC [1] ＝ “def”)

如果 (FUNC.起始 ≠ 0)

FUNC.终止＝ I － 1

加入成员 (函数定义, FUNC)

JSON.写文本 (到文本 (M), “定义函数过程 ” ＋函数定义 [取数组成员数 (函数定义)].名＋ “ S:” ＋到文本 (函数定义 [取数组成员数 (函数定义)].起始) ＋ “ E:” ＋到文本 (函数定义 [取数组成员数 (函数定义)].终止) ＋ GT ())

FUNC.名＝ “”

FUNC.起始＝ 0

FUNC.终止＝ 0

' 上一个def终止

FUNC.起始＝ I

FUNC.名＝ EXEC [2]

' 新的定义

' 开始搜寻新的def

FUNC.起始＝ I

FUNC.名＝ EXEC [2]

计次循环尾 ()
' 设置系统核心数据、内定函数
全局变量.创建变量 (“@换行符”, )
全局变量.创建变量 (“@引号”, )
全局变量.赋值 (“@换行符”, #换行符, )
全局变量.赋值 (“@引号”, #引号, )
运行日志.置对象 (“解析指令集”, JSON)

子程序名	返回值类型	公开	备注
设置全局变量
参数名	类型	参考	可空	数组	备注
变量名	文本型
值	文本型
成员	整数型				成员数或成员下标

如果 (全局变量.变量是否存在 (变量名) ＝真)

全局变量.赋值 (变量名, 值, 成员)

全局变量.创建变量 (变量名, 成员)

全局变量.赋值 (变量名, 值, 成员)

子程序名	返回值类型	公开	备注
定义函数			绑定易语言子程序
参数名	类型	参考	可空	数组	备注
函数名	文本型
易函数	子程序指针

加入成员 (BIF, 易函数)
加入成员 (BIFN, 函数名)

子程序名	返回值类型	公开	备注
GT	文本型		日志取时间

M ＝ M ＋ 1
返回 (“ ” ＋时间_格式化EX (取现行时间 (), , , ))

.版本 2<br />
<br />
.子程序 置入代码, , 公开, 设置指令集代码<br />
.参数 执行码, 文本型, , 至臻.编译() 得出的指令执行码<br />
.参数 INIT代码, 文本型, 可空, 初始化代码,准备用作独立版的头文件代码摄入 非指令码<br />
.局部变量 I, 整数型<br />
.局部变量 JSON, Json对象<br />
.局部变量 EXECC, 文本型, , "0"<br />
.局部变量 EXEC, 文本型, , "0"<br />
.局部变量 FUNC, 函数过程<br />
<br />
' 载入指令集<br />
加入成员 (执行指令, “def System_Init”)<br />
.如果真 (是否为空 (INIT代码) ＝ 假)<br />
<br />
.如果真结束<br />
EXECC ＝ 分割文本 (执行码, #换行符, )<br />
.计次循环首 (取数组成员数 (EXECC), I)<br />
    加入成员 (执行指令, EXECC [I])<br />
.计次循环尾 ()<br />
I ＝ 0<br />
JSON.写文本 (到文本 (M), “载入指令集代码 EXEC EZ LEN” ＋ 到文本 (取数组成员数 (执行指令)) ＋ GT ())<br />
' 分配文本宏<br />
.计次循环首 (取数组成员数 (执行指令), I)<br />
    .如果真 (寻找文本 (执行指令 [I], “const ”, , 假) ≠ -1)<br />
        分析 (执行指令 [I], EXEC)<br />
        ' 调试输出 (M)<br />
        加入成员 (MT, 数据解码 (EXEC [3]))<br />
        JSON.写文本 (到文本 (M), “配置宏文本 #T” ＋ 到文本 (取数组成员数 (MT)) ＋ #引号 ＋ MT [取数组成员数 (MT)] ＋ #引号 ＋ GT ())<br />
    .如果真结束<br />
<br />
.计次循环尾 ()<br />
I ＝ 0<br />
' 区分函数定义<br />
.计次循环首 (取数组成员数 (执行指令), I)<br />
    ' 调试输出 (到文本 (I) ＋ “   ” ＋ 执行指令 [I])<br />
    分析 (执行指令 [I], EXEC)<br />
    .如果 (I ＝ 取数组成员数 (执行指令))  ' 代表最后一行<br />
        .如果 (EXEC [1] ＝ “def”)<br />
            FUNC.起始 ＝ I<br />
            FUNC.名 ＝ EXEC [2]<br />
            FUNC.终止 ＝ I<br />
            加入成员 (函数定义, FUNC)<br />
            JSON.写文本 (到文本 (M), “定义函数过程 ” ＋ 函数定义 [取数组成员数 (函数定义)].名 ＋ “ S:” ＋ 到文本 (函数定义 [取数组成员数 (函数定义)].起始) ＋ “ E:” ＋ 到文本 (函数定义 [取数组成员数 (函数定义)].终止) ＋ GT ())<br />
        .否则<br />
            .如果真 (FUNC.起始 ≠ 0)<br />
                FUNC.终止 ＝ I<br />
                加入成员 (函数定义, FUNC)<br />
                JSON.写文本 (到文本 (M), “定义函数过程 ” ＋ 函数定义 [取数组成员数 (函数定义)].名 ＋ “ S:” ＋ 到文本 (函数定义 [取数组成员数 (函数定义)].起始) ＋ “ E:” ＋ 到文本 (函数定义 [取数组成员数 (函数定义)].终止) ＋ GT ())<br />
            .如果真结束<br />
<br />
        .如果结束<br />
<br />
    .否则<br />
        .如果真 (EXEC [1] ＝ “def”)<br />
            .如果 (FUNC.起始 ≠ 0)<br />
                FUNC.终止 ＝ I － 1<br />
                加入成员 (函数定义, FUNC)<br />
                JSON.写文本 (到文本 (M), “定义函数过程 ” ＋ 函数定义 [取数组成员数 (函数定义)].名 ＋ “ S:” ＋ 到文本 (函数定义 [取数组成员数 (函数定义)].起始) ＋ “ E:” ＋ 到文本 (函数定义 [取数组成员数 (函数定义)].终止) ＋ GT ())<br />
                FUNC.名 ＝ “”<br />
                FUNC.起始 ＝ 0<br />
                FUNC.终止 ＝ 0<br />
                ' 上一个def终止<br />
                FUNC.起始 ＝ I<br />
                FUNC.名 ＝ EXEC [2]<br />
                ' 新的定义<br />
            .否则<br />
                ' 开始搜寻新的def<br />
                FUNC.起始 ＝ I<br />
                FUNC.名 ＝ EXEC [2]<br />
            .如果结束<br />
<br />
        .如果真结束<br />
<br />
    .如果结束<br />
<br />
.计次循环尾 ()<br />
' 设置系统核心数据、内定函数<br />
全局变量.创建变量 (“@换行符”, )<br />
全局变量.创建变量 (“@引号”, )<br />
全局变量.赋值 (“@换行符”, #换行符, )<br />
全局变量.赋值 (“@引号”, #引号, )<br />
<br />
运行日志.置对象 (“解析指令集”, JSON)<br />
<br />
<br />
.子程序 设置全局变量, , 公开<br />
.参数 变量名, 文本型<br />
.参数 值, 文本型<br />
.参数 成员, 整数型, 可空, 成员数或成员下标<br />
<br />
.如果 (全局变量.变量是否存在 (变量名) ＝ 真)<br />
    全局变量.赋值 (变量名, 值, 成员)<br />
.否则<br />
    全局变量.创建变量 (变量名, 成员)<br />
    全局变量.赋值 (变量名, 值, 成员)<br />
.如果结束<br />
<br />
<br />
<br />
.子程序 定义函数, , 公开, 绑定易语言子程序<br />
.参数 函数名, 文本型<br />
.参数 易函数, 子程序指针<br />
<br />
加入成员 (BIF, 易函数)<br />
加入成员 (BIFN, 函数名)<br />
<br />
<br />
.子程序 GT, 文本型, , 日志取时间<br />
<br />
M ＝ M ＋ 1<br />
返回 (“   ” ＋ 时间_格式化EX (取现行时间 (), , , ))

子程序名	返回值类型	公开	备注
数据解码	文本型
参数名	类型	参考	可空	数组	备注
代码	文本型

返回 (到文本 (L_编码_base64解码 (代码)))

子程序名	返回值类型	公开	备注
分析	整数型
参数名	类型	参考	可空	数组	备注
指令条	文本型
结果	文本型

清除数组 (结果)
结果＝分割文本 (指令条, “ ”, )
返回 (取数组成员数 (结果))

子程序名	返回值类型	公开	备注
重置			卸载之前的运行数据

变量名	类型	静态	数组	备注
N	文本型		0
I	整数型

清除数组 (执行指令)
清除数组 (MT)
全局变量.取变量名列表 (N)

计次循环首 (取数组成员数 (N), I)

全局变量.释放变量 (N [I])

计次循环尾 ()

[/e=1].版本 2
.支持库 shellEx

.子程序调用, 文本型, 公开, 属于解释器,暂未开发
.参数函数名, 文本型
.参数参数, 文本型, 可空数组
.局部变量变量库, 变量类, , , 局部变量
.局部变量全变, 逻辑型
.局部变量 R, 文本型, , , 结论返回值
.局部变量 I, 整数型, , , 计数索引 1
.局部变量 J, 整数型, , , 计数索引 2
.局部变量 K, 整数型, , , 计数索引 3
.局部变量 FX, 整数型, , , 函数索引 <重要信息>
.局部变量 FOK, 整数型, , , 1=函数过程 2=BIF 3=DLL 0=无定义
.局部变量预备参数, 文本型, , "10"
.局部变量 EXEC, 文本型, , "0"
.局部变量状态, 整数型, , "999999"
.局部变量执行层, 整数型, , , 缩进层
.局部变量循环I, 整数型
.局部变量 JSON, Json对象, , , 日志
.局部变量 BOOLER, 文本型
.局部变量 EED, 逻辑型

' 获取函数源
.计次循环首 (取数组成员数 (函数定义), FX)
.如果真 (函数定义 [FX].名＝函数名)
      FOK ＝ 1
      JSON.写文本 (到文本 (M), “获取函数执行源头 ” ＋函数名＋ “ FOK1 代码过程” ＋ GT ())
      跳出循环 ()
.如果真结束

.计次循环尾 ()
.如果真 (FOK ＝ 0)
FX ＝ 0
.计次循环首 (取数组成员数 (BIFN), FX)
      .如果真 (BIFN [FX] ＝函数名)
         FOK ＝ 2
         JSON.写文本 (到文本 (M), “获取函数执行源头 ” ＋函数名＋ “ FOK2 易函数” ＋ GT ())
         跳出循环 ()
      .如果真结束

.计次循环尾 ()
.如果真结束
.如果真 (FOK ＝ 0)
.如果真 (DLL.指令是否存在 (函数名) ＝真)
      FOK ＝ 3
      JSON.写文本 (到文本 (M), “获取函数执行源头 ” ＋函数名＋ “ FOK3 动态链接库” ＋ GT ())
.如果真结束
FX ＝ 0
.如果真结束
.如果真 (FOK ＝ 0)
JSON.写文本 (到文本 (M), “<ERROR>获取函数执行源头 ” ＋函数名＋ “ FOK0 ERROR 未定义的函数” ＋ GT ())
返回 (“”)
.如果真结束
' 按函数源执行函数
.判断开始 (FOK ＝ 1)
' 定义参数
分析 (执行指令 [函数定义 [FX].起始], EXEC)
K ＝ 2
.计次循环首 (取数组成员数 (EXEC) － 2, I)
      J ＝ J ＋ 1
      K ＝ K ＋ 1
      变量库.创建变量 (EXEC [K], )
      变量库.赋值 (EXEC [K], 数据提纯 (参数 [J], 变量库, I), )
      JSON.写文本 (到文本 (M), “定义过程参数存储:局部变量 ” ＋ EXEC [K] ＋ “ ” ＋参数 [J] ＋ GT ())
.计次循环尾 ()
J ＝ 0
K ＝ 0
I ＝ 0
' 执行层从1起步
执行层＝ 1
I ＝函数定义 [FX].起始
' 调试输出 (“定义其实行：” ＋到文本 (函数定义 [FX].起始))
.判断循环首 (I ＜函数定义 [FX].终止)
      ' 调试输出 (执行层)
      ' 调试输出 (变量库.取值 (“i”, 1))
      I ＝ I ＋ 1
      J ＝ 0
      EED ＝假
      分析 (执行指令 [I], EXEC)
      JSON.写文本 (到文本 (M), “分析指令集行 INDEX ” ＋到文本 (I) ＋ “[ ” ＋执行指令 [I] ＋ “ ]” ＋ GT ())
      .如果真 (到整数 (EXEC [2]) ＜执行层)  ' 流程语句降级回归控制
         .判断开始 (状态 [执行层－ 1] ＝ #至臻_状态_如果真)
            执行层＝执行层－ 1
            置状态 (执行层, #至臻_状态_无状态, 状态)
            JSON.写文本 (到文本 (M), “流程改变如果真结束执行层-1” ＋ GT ())
         .判断 (状态 [执行层－ 1] ＝ #至臻_状态_如果假)
            执行层＝执行层－ 1
            置状态 (执行层, #至臻_状态_无状态, 状态)
            EED ＝真
         .判断 (状态 [执行层－ 1] ＝ #至臻_状态_循环中)
            I ＝循环I － 1
            JSON.写文本 (到文本 (M), “循环语句即将重新判断条件” ＋ GT ())
            到循环尾 ()
         .默认
            执行层＝执行层－ 1
            JSON.写文本 (到文本 (M), “流程改变正常或未知降级执行层-1” ＋ GT ())
         .判断结束

      .如果真结束
      .如果真 (状态 [执行层] ＝ #至臻_状态_如果假且到文本 (执行层) ＝ EXEC [2])  ' 如果假晋级执行层
         .如果真 (EXEC [1] ＝ “els”)
            执行层＝执行层＋ 1
            JSON.写文本 (到文本 (M), “流程改变开始如果假执行层+1” ＋ GT ())
         .如果真结束

      .如果真结束

      .判断开始 (EXEC [1] ＝ “new”)  ' 创建局部变量
         .如果真 (EXEC [2] ＝到文本 (执行层))
            变量库.创建变量 (EXEC [3], 到整数 (EXEC [4]))
            JSON.写文本 (到文本 (M), “创建局部变量 ” ＋ EXEC [3] ＋ “ 成员数含量” ＋ EXEC [4] ＋ GT ())
         .如果真结束

      .判断 (EXEC [1] ＝ “nvr”)  ' 创建全局变量
         .如果真 (EXEC [2] ＝到文本 (执行层))
            全局变量.创建变量 (EXEC [3], 到整数 (EXEC [4]))
            JSON.写文本 (到文本 (M), “创建全局变量 ” ＋ EXEC [3] ＋ “ 成员数含量” ＋ EXEC [4] ＋ GT ())
         .如果真结束

      .判断 (EXEC [1] ＝ “pei”)  ' 变量赋值
         .如果真 (EXEC [2] ＝到文本 (执行层))
            .如果真 (全局变量.变量是否存在 (EXEC [3]))  ' 判断是否为全局变量，否则为局域变量
                  全变＝真
            .如果真结束
            ' 判断是不是数组变量批量定义，批量定义需要特殊处理;
            .如果 (寻找文本 (EXEC [4], “,”, , 假) ≠ -1)  ' 为真则批量处理
                  .如果 (全变＝真)
                     J ＝ 0
                     K ＝ 4
                     .计次循环首 (到整数 (L_文本_取右边 (EXEC [4], “,”, , )), J)
                        K ＝ K ＋ 1
                        全局变量.赋值 (EXEC [3], 数据提纯 (EXEC [K], 变量库, I), J)
                        JSON.写文本 (到文本 (M), “变量操作赋值 ” ＋ EXEC [3] ＋ “ 成员下标” ＋到文本 (I) ＋ “ WR:” ＋ EXEC [K] ＋ GT ())
                     .计次循环尾 ()
                  .否则
                     J ＝ 0
                     K ＝ 4
                     .计次循环首 (到整数 (L_文本_取右边 (EXEC [4], “,”, , )), J)
                        K ＝ K ＋ 1
                        变量库.赋值 (EXEC [3], 数据提纯 (EXEC [K], 变量库, I), J)
                        JSON.写文本 (到文本 (M), “变量操作赋值 ” ＋ EXEC [3] ＋ “ 成员下标” ＋到文本 (I) ＋ “ WR:” ＋ EXEC [K] ＋ GT ())
                     .计次循环尾 ()
                  .如果结束

            .否则
                  .如果 (全变＝真)
                     全局变量.赋值 (EXEC [3], 数据提纯 (EXEC [5], 变量库, I), 到整数 (EXEC [4]))
                  .否则
                     变量库.赋值 (EXEC [3], 数据提纯 (EXEC [5], 变量库, I), 到整数 (EXEC [4]))
                  .如果结束
                  JSON.写文本 (到文本 (M), “变量操作赋值 ” ＋ EXEC [3] ＋ “ 成员下标” ＋ EXEC [4] ＋ “ WR:” ＋ EXEC [5] ＋ GT ())
            .如果结束

         .如果真结束

      .判断 (EXEC [1] ＝ “ret”)  ' 返回数据并终止当前过程执行进度
         .如果真 (EXEC [2] ＝到文本 (执行层))
            JSON.写文本 (到文本 (M), “结束返回数据提纯>” ＋ EXEC [3] ＋ GT ())
            运行日志.置对象 (“函数调用执行”, JSON)
            返回 (数据提纯 (EXEC [3], 变量库, I))
         .如果真结束

      .判断 (EXEC [1] ＝ “fun”)  ' 递归执行函数或过程
         .如果真 (EXEC [2] ＝到文本 (执行层))
            K ＝ 2
            J ＝ 0
            .计次循环首 (取数组成员数 (EXEC) － 2, J)
                  K ＝ K ＋ 1
                  预备参数 [J] ＝数据提纯 (EXEC [K], 变量库, I)
            .计次循环尾 ()
            R ＝调用 (EXEC [3], 预备参数)
            JSON.写文本 (到文本 (M), “执行FUNC 调用函数(CODE/BIF/DLL) ” ＋ EXEC [3] ＋ GT ())
         .如果真结束

      .判断 (EXEC [1] ＝ “--flt”)
         JSON.写文本 (到文本 (M), “子函数寄托跳过本行 --flt 在主函数执行中不凑效,该指令属于数据提纯” ＋ EXEC [3] ＋ GT ())

      .判断 (EXEC [1] ＝ “lbr”)  ' 判断条件 - 流程语句
         .如果真 (EXEC [2] ＝到文本 (执行层))
            BOOLER ＝数据提纯 (EXEC [3], 变量库, I)
            .如果 (BOOLER ≠ “0”)  ' 非零为真
                  置状态 (执行层, #至臻_状态_如果真, 状态)
                  执行层＝执行层＋ 1
                  JSON.写文本 (到文本 (M), “流程改变开始如果真执行层+1” ＋ GT ())
            .否则
                  置状态 (执行层, #至臻_状态_如果假, 状态)
            .如果结束

         .如果真结束

      .判断 (EXEC [1] ＝ “jmp”)  ' 跳出一层循环
         .如果真 (EXEC [2] ＝到文本 (执行层))
            执行层＝执行层－ 1
            置状态 (执行层, #至臻_状态_无状态, 状态)
            JSON.写文本 (到文本 (M), “流程改变跳出本层循环执行层-1” ＋ GT ())
         .如果真结束

      .判断 (EXEC [1] ＝ “wle”)
         .如果真 (EXEC [2] ＝到文本 (执行层))
            BOOLER ＝数据提纯 (EXEC [3], 变量库, I)
            .如果 (BOOLER ≠ “0”)  ' 非零为真
                  循环I ＝ I
                  置状态 (执行层, #至臻_状态_循环中, 状态)
                  执行层＝执行层＋ 1
                  JSON.写文本 (到文本 (M), “流程改变开始新循环执行层+1” ＋ GT ())
            .否则
                  .如果真 (状态 [执行层－ 1] ＝ #至臻_状态_循环中)
                     执行层＝执行层－ 1
                     置状态 (执行层, #至臻_状态_无状态, 状态)
                     JSON.写文本 (到文本 (M), “流程改变结束循环执行层-1” ＋ GT ())
                  .如果真结束

            .如果结束

         .如果真结束

      .判断 (EXEC [1] ＝ “mov”)
         JSON.写文本 (到文本 (M), “GOTO指令暂未定义，或已被遗弃 ” ＋ GT ())
      .判断 (EXEC [1] ＝ “dec”)
         .如果真 (EXEC [2] ＝到文本 (执行层))
            .如果真 (全局变量.变量是否存在 (EXEC [3]))  ' 判断是否为全局变量，否则为局域变量
                  全变＝真
            .如果真结束
            ' 判断是不是数组变量批量定义，批量定义需要特殊处理;
            .如果 (全变＝真)
                  全局变量.赋值 (EXEC [3], 数据提纯 (EXEC [3] ＋ “-1”, 变量库, I), 1)
            .否则
                  变量库.赋值 (EXEC [3], 数据提纯 (EXEC [3] ＋ “-1”, 变量库, I), 1)
            .如果结束
            JSON.写文本 (到文本 (M), “变量自减操作 ” ＋ EXEC [3] ＋ GT ())
         .如果真结束

      .判断 (EXEC [1] ＝ “neg”)
         .如果真 (EXEC [2] ＝到文本 (执行层))
            .如果真 (全局变量.变量是否存在 (EXEC [3]))  ' 判断是否为全局变量，否则为局域变量
                  全变＝真
            .如果真结束
            ' 判断是不是数组变量批量定义，批量定义需要特殊处理;
            .如果 (全变＝真)
                  全局变量.赋值 (EXEC [3], 数据提纯 (EXEC [3] ＋ “+1”, 变量库, I), 1)
            .否则
                  变量库.赋值 (EXEC [3], 数据提纯 (EXEC [3] ＋ “+1”, 变量库, I), 1)
            .如果结束
            JSON.写文本 (到文本 (M), “变量自增操作 ” ＋ EXEC [3] ＋ GT ())
         .如果真结束

      .默认

      .判断结束
      .如果真 (EED ＝真)
         JSON.写文本 (到文本 (M), “流程改变如果假结束执行层-1” ＋ GT ())
      .如果真结束

.判断循环尾 ()

.判断 (FOK ＝ 2)
I ＝ 0
.计次循环首 (取数组成员数 (参数), I)
      预备参数 [I] ＝数据提纯 (参数 [I], 变量库, I)
.计次循环尾 ()
R ＝ BIF (函数名, 预备参数 [1], 预备参数 [2], 预备参数 [3], 预备参数 [4], 预备参数 [5], 预备参数 [6], 预备参数 [7], 预备参数 [8], 预备参数 [9], 预备参数 [10])
JSON.写文本 (到文本 (M), “执行FUNC 易函数 ” ＋函数名＋ GT ())
.默认
.如果真 (FOK ＝ 3)
      I ＝ 0
      .计次循环首 (取数组成员数 (参数), I)
         预备参数 [I] ＝数据提纯 (参数 [I], 变量库, I)
      .计次循环尾 ()
      R ＝指针到文本 (DLL.调用 (函数名, 取指针地址 (预备参数 [1]), 取指针地址 (预备参数 [2]), 取指针地址 (预备参数 [3]), 取指针地址 (预备参数 [4]), 取指针地址 (预备参数 [5]), 取指针地址 (预备参数 [6]), 取指针地址 (预备参数 [7]), 取指针地址 (预备参数 [8]), 取指针地址 (预备参数 [9]), 取指针地址 (预备参数 [10])))
      JSON.写文本 (到文本 (M), “执行FUNC 动态库函数 ” ＋函数名＋ GT ())
.如果真结束

.判断结束
运行日志.置对象 (“函数调用执行”, JSON)
返回 (R)

.子程序置状态
.参数执行层, 整数型
.参数状态, 整数型
.参数状态源, 整数型, 数组

状态源 [执行层] ＝状态
[/e]
[/e=1].版本 2

.子程序取运行日志, 文本型, 公开

返回 (运行日志.取JSON文本 ())

.子程序数据提纯, 文本型
.参数数据, 文本型
.参数局部, 变量类
.参数当前执行行, 整数型, 可空
.局部变量 R, 文本型
.局部变量 JS, L_JScript
.局部变量 S, 文本型, , "0"
.局部变量 I, 整数型
.局部变量全变, 逻辑型

表达式分割 (“(” ＋数据＋ “)”, S)
' 变量提取
.计次循环首 (取数组成员数 (S), I)
.如果 (是否符号 (S [I]) ＝真)
      R ＝ R ＋ S [I]
.否则
      .如果 (属性格式 (S [I]) ＝真)  ' 说明是正确的变量格式
         .如果真 (全局变量.变量是否存在 (S [I]))  ' 判断是否为全局变量，否则为局域变量
            全变＝真
         .如果真结束
         .如果 (全变＝真)
            R ＝ R ＋全局变量.取值 (取变量名 (S [I]), 到整数 (取成员下标 (S [I])))
         .否则
            R ＝ R ＋局部.取值 (取变量名 (S [I]), 到整数 (取成员下标 (S [I])))
         .如果结束

      .否则
         R ＝ R ＋ S [I]
      .如果结束

.如果结束

.计次循环尾 ()
' 子函数寄托归位
' 文本宏归位
返回 (JS.Eval (R).取文本 ())

.子程序属性格式, 逻辑型, , 正确返回真否则返回假
.参数属性表达式, 文本型
.局部变量 BOOL, 逻辑型

.如果真 (文本_取头位 (属性表达式, 1) ≠ “~” 且文本_取头位 (属性表达式, 1) ≠ “`” 且文本_取头位 (属性表达式, 1) ≠ “!” 且文本_取头位 (属性表达式, 1) ≠ “@” 且文本_取头位 (属性表达式, 1) ≠ “#” 且文本_取头位 (属性表达式, 1) ≠ “$” 且文本_取头位 (属性表达式, 1) ≠ “%” 且文本_取头位 (属性表达式, 1) ≠ “^” 且文本_取头位 (属性表达式, 1) ≠ “&” 且文本_取头位 (属性表达式, 1) ≠ “*” 且文本_取头位 (属性表达式, 1) ≠ “(” 且文本_取头位 (属性表达式, 1) ≠ “)” 且文本_取头位 (属性表达式, 1) ≠ “_” 且文本_取头位 (属性表达式, 1) ≠ “+” 且文本_取头位 (属性表达式, 1) ≠ “-” 且文本_取头位 (属性表达式, 1) ≠ “=” 且文本_取头位 (属性表达式, 1) ≠ “/” 且文本_取头位 (属性表达式, 1) ≠ “[” 且文本_取头位 (属性表达式, 1) ≠ “]” 且文本_取头位 (属性表达式, 1) ≠ “\” 且文本_取头位 (属性表达式, 1) ≠ “|” 且文本_取头位 (属性表达式, 1) ≠ “{” 且文本_取头位 (属性表达式, 1) ≠ “}” 且文本_取头位 (属性表达式, 1) ≠ “;” 且文本_取头位 (属性表达式, 1) ≠ “'” 且文本_取头位 (属性表达式, 1) ≠ #引号且文本_取头位 (属性表达式, 1) ≠ “:” 且文本_取头位 (属性表达式, 1) ≠ “.” 且文本_取头位 (属性表达式, 1) ≠ “<” 且文本_取头位 (属性表达式, 1) ≠ “>” 且文本_取头位 (属性表达式, 1) ≠ “1” 且文本_取头位 (属性表达式, 1) ≠ “2” 且文本_取头位 (属性表达式, 1) ≠ “3” 且文本_取头位 (属性表达式, 1) ≠ “4” 且文本_取头位 (属性表达式, 1) ≠ “5” 且文本_取头位 (属性表达式, 1) ≠ “6” 且文本_取头位 (属性表达式, 1) ≠ “7” 且文本_取头位 (属性表达式, 1) ≠ “8” 且文本_取头位 (属性表达式, 1) ≠ “9” 且文本_取头位 (属性表达式, 1) ≠ “0”)
BOOL ＝真
.如果真结束
返回 (BOOL)

[/e]
[/e=1].版本 2
.支持库 shellEx

.子程序 BIF, 文本型, , 返回数据指针指针转换可使用取指针地址() 或指针到XXX()
.参数 BIFS, 文本型, , 自己定义的指令名
.参数参数1, 文本型, 可空, 不同数据类型可使用指针转换
.参数参数2, 文本型, 可空, 不同数据类型可使用指针转换
.参数参数3, 文本型, 可空, 不同数据类型可使用指针转换
.参数参数4, 文本型, 可空, 不同数据类型可使用指针转换
.参数参数5, 文本型, 可空, 不同数据类型可使用指针转换
.参数参数6, 文本型, 可空, 不同数据类型可使用指针转换
.参数参数7, 文本型, 可空, 不同数据类型可使用指针转换
.参数参数8, 文本型, 可空, 不同数据类型可使用指针转换
.参数参数9, 文本型, 可空, 不同数据类型可使用指针转换
.参数参数10, 文本型, 可空, 不同数据类型可使用指针转换
.局部变量 I, 整数型
.局部变量函数句柄, 整数型
.局部变量 R, 文本型

.如果真 (取数组成员数 (BIFN) ≠ 0)
.计次循环首 (取数组成员数 (BIFN), I)
      .如果真 (BIFS ＝ BIFN [I])
         函数句柄＝到整数 (BIF [I])
         跳出循环 ()
      .如果真结束

.计次循环尾 ()
.如果真结束
.如果真 (函数句柄 ≠ 0)
R ＝指针到文本 (_Call (函数句柄, 取指针地址 (参数1), 取指针地址 (参数2), 取指针地址 (参数3), 取指针地址 (参数4), 取指针地址 (参数5), 取指针地址 (参数6), 取指针地址 (参数7), 取指针地址 (参数8), 取指针地址 (参数9), 取指针地址 (参数10)))
.如果真结束
返回 (R)

.子程序逐行添加缩进, 文本型, , 总添加1个缩进
.参数代码, 文本型
.局部变量 S, 文本型, , "0"
.局部变量 I, 整数型

S ＝分割文本 (代码, #换行符, )
.计次循环首 (取数组成员数 (S), I)
.如果 (I ＝取数组成员数 (S))
      S [I] ＝ “ ” ＋ S [I]
.否则
      S [I] ＝ “ ” ＋ S [I] ＋ #换行符
.如果结束

.计次循环尾 ()
返回 (文本数组拼接 (S))

.子程序取缩进, 文本型
.参数代码行, 文本型
.局部变量 S, 文本型, , "0"
.局部变量 I, 整数型
.局部变量后段, 文本型
.局部变量缩进, 文本型

.计次循环首 (文本_逐字分割 (代码行, S), I)
.如果真 (S [I] ≠ “ ”)
      .循环判断首 ()
         后段＝后段＋ S [I]
         I ＝ I ＋ 1
      .循环判断尾 (I ≤ 取数组成员数 (S))
      跳出循环 ()
.如果真结束

.计次循环尾 ()
缩进＝ L_文本_取左边 (代码行, 后段, , )
返回 (缩进)

.子程序取缩进数, 整数型, , 四个空格存在几个
.参数代码行, 文本型
.局部变量 S, 文本型, , "0"
.局部变量 I, 整数型
.局部变量后段, 文本型
.局部变量缩进, 文本型
.局部变量数量, 整数型

.计次循环首 (文本_逐字分割 (代码行, S), I)
.如果真 (S [I] ≠ “ ”)
      .循环判断首 ()
         后段＝后段＋ S [I]
         I ＝ I ＋ 1
      .循环判断尾 (I ≤ 取数组成员数 (S))
      跳出循环 ()
.如果真结束

.计次循环尾 ()
缩进＝ L_文本_取左边 (代码行, 后段, , )
.判断循环首 (寻找文本 (缩进, “ ”, , 假) ≠ -1)
缩进＝子文本替换 (缩进, “ ”, “”, , 1, 真)
数量＝数量＋ 1
.判断循环尾 ()
返回 (数量)

.子程序文本数组拼接, 文本型
.参数文本数组, 文本型, 数组
.局部变量 I, 整数型
.局部变量 S, 文本型

.计次循环首 (取数组成员数 (文本数组), I)
S ＝ S ＋文本数组 [I]
.计次循环尾 ()
返回 (S)

.子程序逗号减层, 文本型
.参数表达式, 文本型
.局部变量 D, 整数型, , "0"
.局部变量 S, 文本型
.局部变量 I, 整数型

S ＝表达式
.计次循环首 (L_文本_取出现次数 (S, “{”, ), I)
加入成员 (D, 到整数 (文本_取出中间文本 (S, “{”, “}”, , )))
S ＝子文本替换 (S, “{” ＋文本_取出中间文本 (S, “{”, “}”, , ) ＋ “}”, “$^D” ＋到文本 (取数组成员数 (D)) ＋ “^$”, , 1, 真)
.计次循环尾 ()
I ＝ 0
.计次循环首 (取数组成员数 (D), I)
S ＝子文本替换 (S, “$^D” ＋到文本 (I) ＋ “^$”, “{” ＋到文本 (D [I] － 1) ＋ “}”, , 1, 真)
.计次循环尾 ()
返回 (S)

.子程序逗号转义, 文本型
.参数表达式, 文本型
.局部变量 S, 文本型, , "0"
.局部变量 R, 文本型
.局部变量 I, 整数型
.局部变量层, 整数型

文本_逐字分割 (表达式, S)
.计次循环首 (取数组成员数 (S), I)
.如果 (S [I] ＝ “(”)
      层＝层＋ 1
      R ＝ R ＋ S [I]
.否则
      .如果 (S [I] ＝ “)”)
         层＝层－ 1
         R ＝ R ＋ S [I]
      .否则
         .如果 (S [I] ＝ “,”)
            R ＝ R ＋ “{” ＋到文本 (层) ＋ “}”
         .否则
            R ＝ R ＋ S [I]
         .如果结束

      .如果结束

.如果结束

.计次循环尾 ()
返回 (子文本替换 (R, “{1}”, “,”, , , 真))
[/e]
[/e=1].版本 2

.子程序生成函数指令码, 文本型
.参数调用表达式, 文本型
.参数 CN, 文本型
.参数主动, 逻辑型
.参数表头, 文本型, 可空
.参数使用表头, 逻辑型, 可空
.局部变量 R, 文本型
.局部变量 CNS, 整数型
.局部变量 C, 文本型
.局部变量 FLT, 文本型
.局部变量 S, 文本型, , "0"
.局部变量 I, 整数型
.局部变量 SR, 文本型

CNS ＝到整数 (CN)
.如果真 (主动＝真)
.如果 (使用表头＝真)
      R ＝表头
.否则
      R ＝ “fun ” ＋ CN ＋ “ ” ＋ L_文本_取左边 (文本_去空 (调用表达式), “(”, , )
.如果结束

.如果真结束
C ＝文本_去空 (“(” ＋文本_两极取中间 (调用表达式, “(”, “)”, , ) ＋ “)”)
C ＝逗号转义 (C)

.如果真 (文本_去空 (C) ＝ “”)
' 调试输出 (文本_去空 (C))
' 调试输出 (1)

返回 (R)
.如果真结束
.如果 (寻找文本 (文本_两极取中间 (文本_去空 (C), “(”, “)”, , ), “,”, , 假) ＝ -1 且寻找文本 (文本_两极取中间 (文本_去空 (C), “(”, “)”, , ), “(”, , 假) ＝ -1)
' 调试输出 (文本_去空 (C))
' 调试输出 (2)
R ＝ R ＋ “ ” ＋文本_两极取中间 (C, “(”, “)”, , )
返回 (R)
.否则
.如果 (L_文本_取出现次数 (文本_两极取中间 (文本_去空 (C), “(”, “)”, , ), “(”, ) ≠ 0)
      ' 调试输出 (文本_去空 (C))
      ' 调试输出 (3)
      I ＝ 0
      S ＝分割文本 (文本_两极取中间 (C, “(”, “)”, , ), “,”, )
      ' 恢复逗号 (S)
      FLT ＝取出参数 (S, CNS)
      .' 计次循环首 (取数组成员数 (S), I)
         ' R ＝ R ＋ “ ” ＋ S [I]
      .' 计次循环尾 ()
      R ＝ R ＋ “ ” ＋ FLT

.否则
      ' L_文本_取左边 (C, , , )
      ' 调试输出 (文本_去空 (C))
      ' 调试输出 (4)
      I ＝ 0
      S ＝分割文本 (C, “,”, )
      ' FLT ＝参数处理 (S, CNS)
      ' 调试输出 (S)
      .计次循环首 (取数组成员数 (S), I)
         SR ＝ SR ＋ “ ” ＋文本_去空 (S [I])
      .计次循环尾 ()
      R ＝ R ＋ “ ” ＋文本_两极取中间 (SR, “(”, “)”, , )
.如果结束

.如果结束

返回 (子文本替换 (R, “  ”, “ ”, , , 真))

.子程序恢复初级逗号, 文本型
.参数参数, 文本型

返回 (子文本替换 (参数, “{1}”, “,”, , , 真))

.子程序恢复逗号
.参数 S, 文本型, 数组
.局部变量 I, 整数型
.局部变量 J, 整数型

.计次循环首 (取数组成员数 (S), I)
.如果真 (寻找文本 (S [I], “{”, , 假) ≠ -1)
      .计次循环首 (寻找文本 (S [I], “{”, , 假), J)
         S [I] ＝子文本替换 (S [I], “{” ＋ L_文本_取出中间文本 (S [I], “{”, “}”, , ) ＋ “}”, “,”, , 1, 真)
      .计次循环尾 ()
      J ＝ 0
.如果真结束

.计次循环尾 ()

.子程序取出参数, 文本型, , 返回FLT
.参数参数, 文本型, 数组
.参数 CN, 整数型
.局部变量 R, 文本型
.局部变量 I, 整数型
.局部变量 AR, 文本型, , "0"
.局部变量 AS, 文本型
.局部变量主参显, 文本型
.局部变量 J, 整数型
.局部变量 OCT, 逻辑型
.局部变量 RJT, 文本型

.计次循环首 (取数组成员数 (参数), I)
AS ＝ “”
参数 [I] ＝逗号减层 (“(” ＋参数 [I] ＋ “)”)
表达式分割 (参数 [I], AR)
' 调试输出 (AR)
.计次循环首 (取数组成员数 (AR), J)
      OCT ＝假
      .如果 (寻找文本 (AR [J], “(”, , 假) ≠ -1)
         加入成员 (嵌套函数编译, AR [J])
         OCT ＝真
         ' 调试输出 (AR [J])
         ' 信息框 (“成功加入”, 0, , )
         AS ＝ AS ＋ “<F” ＋到文本 (取数组成员数 (嵌套函数编译)) ＋ “>”
      .否则
         AS ＝ AS ＋ AR [J]
      .如果结束
      .如果真 (取数组成员数 (嵌套函数编译) ≠ 0 且 OCT ＝真)
         处理＝处理＋ 1
         .如果 (RJT ＝ “”)
            .如果真 (文本_两极取中间 (嵌套函数编译 [处理], “(”, “)”, , ) ＝ “”)
                  RJT ＝子文本替换 (“--flt ” ＋到文本 (CN) ＋ “ <F” ＋到文本 (处理) ＋ “> ” ＋ L_文本_取左边 (嵌套函数编译 [处理], “(”, , ) ＋ “ ” ＋文本_两极取中间 (嵌套函数编译 [处理], “(”, “)”, , ), “  ”, “ ”, , , 真)
            .如果真结束
            .如果 (寻找文本 (文本_两极取中间 (嵌套函数编译 [处理], “(”, “)”, , ), “{”, , 假) ＝ -1 且寻找文本 (文本_两极取中间 (嵌套函数编译 [处理], “(”, “)”, , ), “(”, , 假) ＝ -1)
                  RJT ＝子文本替换 (“--flt ” ＋到文本 (CN) ＋ “ <F” ＋到文本 (处理) ＋ “> ” ＋ L_文本_取左边 (嵌套函数编译 [处理], “(”, , ) ＋ “ ” ＋文本_两极取中间 (嵌套函数编译 [处理], “(”, “)”, , ), “  ”, “ ”, , , 真)
            .否则
                  RJT ＝子文本替换 (“--flt ” ＋到文本 (CN) ＋ “ <F” ＋到文本 (处理) ＋ “> ” ＋ L_文本_取左边 (嵌套函数编译 [处理], “(”, , ) ＋ “ ” ＋生成函数指令码 (嵌套函数编译 [处理], 到文本 (CN), 假), “  ”, “ ”, , , 真)
            .如果结束
            ' RJT ＝子文本替换 (“--flt ” ＋到文本 (CN) ＋ “ <F” ＋到文本 (处理) ＋ “> ” ＋ L_文本_取左边 (嵌套函数编译 [处理], “(”, , ) ＋ “ ” ＋生成函数指令码 (嵌套函数编译 [处理], 到文本 (CN), 假), “  ”, “ ”, , , 真)
         .否则
            .如果真 (文本_两极取中间 (嵌套函数编译 [处理], “(”, “)”, , ) ＝ “”)
                  RJT ＝ RJT ＋ #换行符＋子文本替换 (“--flt ” ＋到文本 (CN) ＋ “ <F” ＋到文本 (处理) ＋ “> ” ＋ L_文本_取左边 (嵌套函数编译 [处理], “(”, , ) ＋ “ ” ＋文本_两极取中间 (嵌套函数编译 [处理], “(”, “)”, , ), “  ”, “ ”, , , 真)
            .如果真结束
            .如果 (寻找文本 (文本_两极取中间 (嵌套函数编译 [处理], “(”, “)”, , ), “{”, , 假) ＝ -1 且寻找文本 (文本_两极取中间 (嵌套函数编译 [处理], “(”, “)”, , ), “(”, , 假) ＝ -1)
                  RJT ＝ RJT ＋ #换行符＋子文本替换 (“--flt ” ＋到文本 (CN) ＋ “ <F” ＋到文本 (处理) ＋ “> ” ＋ L_文本_取左边 (嵌套函数编译 [处理], “(”, , ) ＋ “ ” ＋文本_两极取中间 (嵌套函数编译 [处理], “(”, “)”, , ), “  ”, “ ”, , , 真)
            .否则
                  RJT ＝ RJT ＋ #换行符＋子文本替换 (“--flt ” ＋到文本 (CN) ＋ “ <F” ＋到文本 (处理) ＋ “> ” ＋ L_文本_取左边 (嵌套函数编译 [处理], “(”, , ) ＋ “ ” ＋生成函数指令码 (嵌套函数编译 [处理], 到文本 (CN), 假), “  ”, “ ”, , , 真)
            .如果结束

            ' RJT ＝ RJT ＋ #换行符＋子文本替换 (“--flt ” ＋到文本 (CN) ＋ “ <F” ＋到文本 (处理) ＋ “> ” ＋ L_文本_取左边 (嵌套函数编译 [处理], “(”, , ) ＋ “ ” ＋生成函数指令码 (嵌套函数编译 [处理], 到文本 (CN), 假), “  ”, “ ”, , , 真)
         .如果结束

      .如果真结束

.计次循环尾 ()

主参显＝主参显＋ “ ” ＋ AS
.计次循环尾 ()
R ＝主参显＋ #换行符＋ RJT
I ＝ 0
返回 (R)

.子程序表达式分割
.参数表达式, 文本型
.参数返, 文本型, 数组
.局部变量 S, 文本型, , "0"
.局部变量 SR, 文本型
.局部变量 I, 整数型
.局部变量占位, 整数型, , , 0-2
.局部变量 D, 逻辑型, , , 0-2
.局部变量 DXN, 逻辑型
.局部变量括号组, 文本型, , "0"
.局部变量数组框, 文本型, , "0"
.局部变量 HC, 文本型
.局部变量 STR, 文本型
.局部变量 J, 整数型

STR ＝文本_去空 (文本_两极取中间 (表达式, “(”, “)”, , ))
.计次循环首 (L_文本_取出现次数 (STR, “(”, ), I)
HC ＝ L_文本_取出中间文本 (STR, “(”, “)”, , )
加入成员 (括号组, “(” ＋ HC ＋ “)”)
STR ＝子文本替换 (STR, “(” ＋ HC ＋ “)”, “$括号_” ＋到文本 (取数组成员数 (括号组)) ＋ “$”, , 1, 真)
.计次循环尾 ()
I ＝ 0
.计次循环首 (L_文本_取出现次数 (STR, “[”, ), I)
HC ＝ L_文本_取出中间文本 (STR, “[”, “]”, , )
加入成员 (数组框, “[” ＋ HC ＋ “]”)
STR ＝子文本替换 (STR, “[” ＋ HC ＋ “]”, “$方号_” ＋到文本 (取数组成员数 (数组框)) ＋ “$”, , 1, 真)
.计次循环尾 ()
I ＝ 0
' 信息框 (STR, 0, , )
文本_逐字分割 (STR, S)
清除数组 (返)

.计次循环首 (取数组成员数 (S), I)
.如果 (是否符号 (S [I]) ＝真)
      .判断开始 (S [I] ＝ “^”)
         DXN ＝假
         占位＝占位＋ 1
         .如果 (占位＜ 2)
            SR ＝ SR ＋ S [I]
         .否则
            占位＝ 0
            SR ＝ SR ＋ S [I]
            加入成员 (返, SR)
            SR ＝ “”
         .如果结束

      .判断 (S [I] ＝ “<”)
         加入成员 (返, SR)
         SR ＝ “”

         DXN ＝真
         SR ＝ SR ＋ S [I]

      .判断 (S [I] ＝ “>”)
         加入成员 (返, SR)
         SR ＝ “”

         DXN ＝真
         SR ＝ SR ＋ S [I]

      .判断 (S [I] ＝ “!”)
         加入成员 (返, SR)
         SR ＝ “”

         DXN ＝真
         SR ＝ SR ＋ S [I]

      .判断 (S [I] ＝ “=” 且 DXN ＝假)
         .如果 (D ＝假)
            加入成员 (返, SR)
            SR ＝ “”

            D ＝真
            SR ＝ SR ＋ S [I]
         .否则

            SR ＝ SR ＋ S [I]
            加入成员 (返, SR)
            SR ＝ “”
            D ＝假
         .如果结束

      .默认
         .如果 (DXN ＝真)
            SR ＝ SR ＋ S [I]
            DXN ＝假
            加入成员 (返, SR)
            SR ＝ “”
         .否则

            DXN ＝假
            加入成员 (返, SR)
            加入成员 (返, S [I])
            SR ＝ “”
         .如果结束

      .判断结束

.否则
      .如果 (I ＝取数组成员数 (S))
         .如果 (DXN ＝真)
            .如果真 (D ＝真)
                  D ＝假
            .如果真结束
            加入成员 (返, SR)
            SR ＝ “”
            SR ＝ SR ＋ S [I]
            加入成员 (返, SR)
            SR ＝ “”

         .否则
            DXN ＝假
            .如果 (D ＝真)
                  D ＝假
                  加入成员 (返, SR)
                  SR ＝ “”
                  SR ＝ SR ＋ S [I]
                  加入成员 (返, SR)
                  SR ＝ “”
            .否则

                  SR ＝ SR ＋ S [I]
                  加入成员 (返, SR)
                  SR ＝ “”

            .如果结束

         .如果结束

      .否则
         .如果 (DXN ＝真)
            .如果真 (D ＝真)
                  D ＝假
            .如果真结束
            加入成员 (返, SR)
            SR ＝ “”
            SR ＝ SR ＋ S [I]

         .否则
            DXN ＝假
            .如果 (D ＝真)
                  D ＝假
                  加入成员 (返, SR)
                  SR ＝ “”
                  SR ＝ SR ＋ S [I]
            .否则

                  SR ＝ SR ＋ S [I]
            .如果结束

         .如果结束

      .如果结束

.如果结束
' 调试输出 (“{  ” ＋ SR ＋ “ }[” ＋ S [I] ＋ “]DXN:” ＋到文本 (DXN) ＋ “  D:” ＋到文本 (D))
.计次循环尾 ()
I ＝ 0
.计次循环首 (取数组成员数 (返), I)
.计次循环首 (取数组成员数 (括号组), J)
      .如果真 (寻找文本 (返 [I], “$括号_”, , 假) ≠ -1)
         返 [I] ＝子文本替换 (返 [I], “$括号_” ＋ L_文本_取出中间文本 (返 [I], “$括号_”, “$”, , ) ＋ “$”, 括号组 [到整数 (L_文本_取出中间文本 (返 [I], “$括号_”, “$”, , ))], , 1, 真)
      .如果真结束

.计次循环尾 ()

.计次循环尾 ()
I ＝ 0
J ＝ 0
.计次循环首 (取数组成员数 (返), I)
.计次循环首 (取数组成员数 (括号组), J)
      .如果真 (寻找文本 (返 [I], “$方号_”, , 假) ≠ -1)
         返 [I] ＝子文本替换 (返 [I], “$方号_” ＋ L_文本_取出中间文本 (返 [I], “$方号_”, “$”, , ) ＋ “$”, 数组框 [到整数 (L_文本_取出中间文本 (返 [I], “$方号_”, “$”, , ))], , 1, 真)
      .如果真结束

.计次循环尾 ()

.计次循环尾 ()

.子程序是否符号, 逻辑型
.参数值, 文本型
.局部变量 B, 逻辑型

.如果真 (值＝ “+”)
B ＝真
.如果真结束
.如果真 (值＝ “-”)
B ＝真
.如果真结束
.如果真 (值＝ “*”)
B ＝真
.如果真结束
.如果真 (值＝ “/”)
B ＝真
.如果真结束
.如果真 (值＝ “=”)
B ＝真
.如果真结束
.如果真 (值＝ “!=”)
B ＝真
.如果真结束
.如果真 (值＝ “<”)
B ＝真
.如果真结束
.如果真 (值＝ “>”)
B ＝真
.如果真结束
.如果真 (值＝ “<=”)
B ＝真
.如果真结束
.如果真 (值＝ “>=”)
B ＝真
.如果真结束
.如果真 (值＝ “^&^”)
B ＝真
.如果真结束
.如果真 (值＝ “^|^”)
B ＝真
.如果真结束
.如果真 (值＝ “!”)
B ＝真
.如果真结束
返回 (B)
[/e]