易语言代码转火山代码 残值版本 AI跑的
<火山程序 类型 = "通常" 版本 = 1 />包 易语言转火山工具
类 启动类 <公开 基础类 = 窗口程序类>
{
变量 主窗口对象 <公开 类型 = 主窗口>
方法 启动方法 <公开 类型 = 整数>
{
主窗口对象.创建主窗口 ()
返回 (1)
}
}
类 主窗口 <公开 基础类 = 窗口 标题 = "易语言 → 火山PC 代码一键转换工具 v1.0" @视窗.布局 = "client_size = \"960, 600\"">
{
变量 标签1 <类型 = 标签 标题 = "易语言源码（粘贴到左侧）" @视窗.布局 = "id = 301\r\npos = \"12, 10, 440, 20\"">
变量 编辑框1 <类型 = 编辑框 是否允许多行 = 真 滚动条 = 横向及纵向滚动条 @视窗.布局 = "id = 101\r\npos = \"12, 34, 448, 520\"">
变量 按钮_转换 <类型 = 按钮 标题 = "→ 一键转换 →" @视窗.布局 = "id = 201\r\npos = \"474, 40, 120, 36\"">
变量 按钮_复制 <类型 = 按钮 标题 = "复制结果" @视窗.布局 = "id = 202\r\npos = \"474, 88, 120, 36\"">
变量 按钮_清空 <类型 = 按钮 标题 = "清空" @视窗.布局 = "id = 203\r\npos = \"474, 136, 120, 36\"">
变量 按钮_示例 <类型 = 按钮 标题 = "填入示例" @视窗.布局 = "id = 204\r\npos = \"474, 184, 120, 36\"">
变量 标签2 <类型 = 标签 标题 = "火山PC 代码（转换结果）" @视窗.布局 = "id = 302\r\npos = \"606, 10, 340, 20\"">
变量 编辑框2 <类型 = 编辑框 是否允许多行 = 真 滚动条 = 纵向滚动条 输入方式 = 只读方式 @视窗.布局 = "id = 102\r\npos = \"606, 34, 342, 520\"">
变量 标签_状态 <类型 = 标签 标题 = "就绪：左侧粘贴易语言代码 → 点【一键转换】" @视窗.布局 = "id = 303\r\npos = \"12, 562, 936, 22\"">
变量 转换器 <类型 = 代码转换器>
方法 按钮_被单击 <接收事件 类型 = 整数>
参数 来源对象 <类型 = 按钮>
参数 标记值 <类型 = 整数>
{
如果 (来源对象 == 按钮_转换)
{
执行转换 ()
}
否则 (来源对象 == 按钮_复制)
{
复制结果 ()
}
否则 (来源对象 == 按钮_清空)
{
编辑框1.内容 = ""
编辑框2.内容 = ""
标签_状态.标题 = "已清空，请重新粘贴易语言代码"
}
否则 (来源对象 == 按钮_示例)
{
编辑框1.内容 = 转换器.取示例文本 ()
标签_状态.标题 = "已填入示例易语言代码，点【一键转换】查看效果"
}
返回 (0)
}
方法 执行转换
{
如果 (删首尾空 (编辑框1.内容) == "")
{
标签_状态.标题 = "提示：请先在左侧编辑框粘贴易语言代码"
返回
}
编辑框2.内容 = 转换器.转换易语言到火山 (编辑框1.内容)
标签_状态.标题 = "转换完成！右侧已生成火山PC代码，可点【复制结果】"
}
方法 复制结果
{
如果 (编辑框2.内容 == "")
{
标签_状态.标题 = "右侧还没有内容可复制"
返回
}
编辑框2.选择文本 (0, -1)
编辑框2.复制 ()
标签_状态.标题 = "火山PC代码已复制到剪贴板"
}
}
类 代码转换器 <公开>
{
变量 输出缓冲 <类型 = 文本型>
变量 缩进级 <类型 = 整数>
变量 区块状态 <类型 = 文本型>
变量 方法内 <类型 = 逻辑型>
变量 当前方法返回类型 <类型 = 文本型>
变量 方法见返回 <类型 = 逻辑型>
变量 在Dll参数 <类型 = 逻辑型>
变量 块栈 <类型 = 文本数组类>
变量 支持库列表 <类型 = 文本型>
变量 转换提示 <类型 = 文本型>
变量 参数数组 <类型 = 文本数组类>
变量 全局变量名单 <类型 = 文本数组类>
变量 常量名单 <类型 = 文本数组类>
变量 Dll命令名单 <类型 = 文本数组类>
变量 当前程序集名 <类型 = 文本型>
方法 转换易语言到火山 <公开 类型 = 文本型>
参数 易源码 <类型 = 文本型>
{
变量 行数组 <类型 = 文本数组类>
变量 行数 <类型 = 整数>
变量 行 <类型 = 文本型>
输出缓冲 = ""
缩进级 = 0
区块状态 = ""
方法内 = 假
当前方法返回类型 = ""
方法见返回 = 假
在Dll参数 = 假
当前程序集名 = ""
块栈.删除所有成员 ()
支持库列表 = ""
转换提示 = ""
全局变量名单.删除所有成员 ()
常量名单.删除所有成员 ()
Dll命令名单.删除所有成员 ()
行数 = 分割文本 (易源码, "\n", 行数组, 真, 真)
// 第一遍：收集全局变量 / 常量 / DLL命令 名称，供引用处自动加类名前缀
计次循环 (行数)
{
收集名单 (行数组.取成员 (取循环索引 ()))
}
输出缓冲 = "<火山程序 类型 = \"通常\" 版本 = 1 />\r\n\r\n包 易语言转换\r\n\r\n"
计次循环 (行数)
{
行 = 删首尾空 (行数组.取成员 (取循环索引 ()))
子文本替换 (行, " ", "", 0, -1)
如果 (行 == "")
{
到循环尾
}
如果 (取文本左边 (行, 1) == ".")
{
处理指令行 (取文本右边 (行, 取文本长度 (行) - 1))
}
否则
{
如果真 (在Dll参数)
{
关闭Dll方法 ()
}
如果真 (区块状态 == "" 且 方法内 == 假)
{
加提示 ("游离代码行已忽略: " + 行)
到循环尾
}
处理语句行 (行)
}
}
关闭当前区块 ()
输出缓冲 = 输出缓冲 + 生成转换说明 ()
返回 (输出缓冲)
}
方法 取示例文本 <公开 类型 = 文本型>
{
变量 文本 <类型 = 文本型>
文本 = ".版本 2\r\n"
文本 = 文本 + ".支持库 spec\r\n\r\n"
文本 = 文本 + ".程序集 程序集1\r\n"
文本 = 文本 + ".常量 版本号, 1.0\r\n"
文本 = 文本 + ".常量 提示文本, hello\r\n"
文本 = 文本 + ".全局变量 全局计数, 整数型\r\n"
文本 = 文本 + ".程序集变量 程序集名称, 文本型\r\n"
文本 = 文本 + ".DLL命令 取窗口标题, 整数型, user32.dll, GetWindowTextA\r\n"
文本 = 文本 + ".参数 窗口句柄, 整数型\r\n"
文本 = 文本 + ".参数 缓冲区, 文本型\r\n"
文本 = 文本 + ".参数 长度, 整数型\r\n"
文本 = 文本 + ".数据类型 学生信息\r\n"
文本 = 文本 + ".成员 姓名, 文本型\r\n"
文本 = 文本 + ".成员 年龄, 整数型\r\n"
文本 = 文本 + ".子程序 计算总和, 整数型, 公开\r\n"
文本 = 文本 + ".参数 数值1, 整数型\r\n"
文本 = 文本 + ".参数 数值2, 整数型\r\n"
文本 = 文本 + ".局部变量 结果, 整数型\r\n"
文本 = 文本 + ".局部变量 i, 整数型\r\n"
文本 = 文本 + "结果 ＝ 数值1 ＋ 数值2\r\n"
文本 = 文本 + ".如果 (结果 ＞ 100 且 数值1 ＞ 0)\r\n"
文本 = 文本 + "结果 ＝ 结果 － 50\r\n"
文本 = 文本 + ".否则\r\n"
文本 = 文本 + "结果 ＝ 结果 ＋ 1\r\n"
文本 = 文本 + ".如果结束\r\n"
文本 = 文本 + ".计次循环首 (10, i)\r\n"
文本 = 文本 + "结果 ＝ 结果 ＋ i\r\n"
文本 = 文本 + ".计次循环尾 ()\r\n"
文本 = 文本 + ".判断循环首 (结果 ＜ 200)\r\n"
文本 = 文本 + "结果 ＝ 结果 ＋ 1\r\n"
文本 = 文本 + "跳出循环 ()\r\n"
文本 = 文本 + ".判断循环尾 ()\r\n"
文本 = 文本 + "返回 (结果)\r\n"
文本 = 文本 + ".子程序 取学生年龄, 整数型, 公开\r\n"
文本 = 文本 + ".参数 学生, 学生信息\r\n"
文本 = 文本 + "返回 (学生.年龄)\r\n"
文本 = 文本 + ".子程序 _启动子程序, 整数型, , , 启动子程序\r\n"
文本 = 文本 + ".局部变量 总数, 整数型\r\n"
文本 = 文本 + "总数 ＝ 计算总和 (1, 2)\r\n"
文本 = 文本 + "信息框 (到文本 (总数), 0, , )\r\n"
文本 = 文本 + "返回 (0)\r\n"
返回 (文本)
}
方法 收集名单
参数 行 <类型 = 文本型>
{
变量 内容 <类型 = 文本型>
变量 空格位置 <类型 = 整数>
变量 指令名 <类型 = 文本型>
变量 参数文本 <类型 = 文本型>
内容 = 删首尾空 (行)
如果 (取文本长度 (内容) < 2 或 取文本左边 (内容, 1) != ".")
{
返回
}
内容 = 取文本右边 (内容, 取文本长度 (内容) - 1)
空格位置 = 寻找文本 (内容, " ", 0, 假)
如果 (空格位置 == -1)
{
指令名 = 内容
参数文本 = ""
}
否则
{
指令名 = 取文本左边 (内容, 空格位置)
参数文本 = 删首尾空 (取文本右边 (内容, 取文本长度 (内容) - 空格位置 - 1))
}
指令名 = 到小写 (指令名)
分割参数 (参数文本)
如果 (指令名 == "常量" 且 参数数组.取成员数 () >= 1)
{
常量名单.加入成员 (参数数组.取成员 (0))
}
如果 (指令名 == "全局变量" 且 参数数组.取成员数 () >= 1)
{
全局变量名单.加入成员 (参数数组.取成员 (0))
}
如果 (指令名 == "dll命令" 且 参数数组.取成员数 () >= 1)
{
Dll命令名单.加入成员 (参数数组.取成员 (0))
}
}
方法 处理指令行
参数 行 <类型 = 文本型>
{
变量 空格位置 <类型 = 整数>
变量 指令名 <类型 = 文本型>
变量 参数文本 <类型 = 文本型>
变量 段数 <类型 = 整数>
变量 名称 <类型 = 文本型>
变量 返回类型 <类型 = 文本型>
变量 条件文本 <类型 = 文本型>
变量 声明 <类型 = 文本型>
变量 数组段 <类型 = 文本型>
变量 值文本 <类型 = 文本型>
变量 输出值 <类型 = 文本型>
变量 类型输出 <类型 = 文本型>
变量 变量名 <类型 = 文本型>
变量 循环次数 <类型 = 文本型>
变量 公开标志 <类型 = 逻辑型>
空格位置 = 寻找文本 (行, " ", 0, 假)
如果 (空格位置 == -1)
{
指令名 = 行
参数文本 = ""
}
否则
{
指令名 = 取文本左边 (行, 空格位置)
参数文本 = 删首尾空 (取文本右边 (行, 取文本长度 (行) - 空格位置 - 1))
}
指令名 = 到小写 (指令名)
段数 = 分割参数 (参数文本)
如果真 (在Dll参数 且 指令名 != "参数")
{
关闭Dll方法 ()
}
如果真 (指令名 == "版本")
{
返回
}
如果真 (指令名 == "图片" 或 指令名 == "声音" 或 指令名 == "资源" 或 指令名 == "内容" 或 指令名 == "窗口" 或 指令名 == "组件")
{
加提示 ("已忽略资源/窗体相关定义: ." + 指令名)
返回
}
如果真 (指令名 == "支持库")
{
如果真 (段数 >= 1 且 参数数组.取成员 (0) != "")
{
支持库列表 = 支持库列表 + 参数数组.取成员 (0) + "、"
}
返回
}
如果真 (指令名 == "程序集")
{
如果真 (段数 >= 1)
{
当前程序集名 = 参数数组.取成员 (0)
打开类 ("类 " + 参数数组.取成员 (0) + " <公开 @全局类 = 真>")
区块状态 = "程序集"
如果真 (寻找文本 (参数数组.取成员 (0), "窗口程序集", 0, 假) != -1)
{
加提示 ("程序集 " + 参数数组.取成员 (0) + " 为窗口程序集，请在火山中手动建立窗口类并将事件子程序改为接收事件方法")
}
}
返回
}
如果真 (指令名 == "程序集变量")
{
如果真 (段数 >= 2)
{
如果真 (区块状态 != "程序集" 且 区块状态 != "类")
{
如果真 (当前程序集名 == "")
{
当前程序集名 = "程序集1"
}
打开类 ("类 " + 当前程序集名 + " <公开 @全局类 = 真>")
区块状态 = "程序集"
}
数组段 = ""
如果真 (段数 >= 4)
{
数组段 = 参数数组.取成员 (3)
}
声明 = "变量 " + 参数数组.取成员 (0) + " <公开 静态 类型 = " + 映射类型 (参数数组.取成员 (1))
如果 (数组段 != "")
{
如果 (数组段 == "\"0\"")
{
声明 = 声明 + " []>"
}
否则
{
声明 = 声明 + " [" + 删外层引号 (数组段) + "]>"
}
}
否则
{
声明 = 声明 + ">"
}
输出行缩进 (声明, 1)
}
返回
}
如果真 (指令名 == "全局变量")
{
如果真 (段数 >= 2)
{
如果真 (区块状态 != "全局")
{
打开类 ("类 全局变量类 <公开 @全局类 = 真>")
区块状态 = "全局"
}
数组段 = ""
如果真 (段数 >= 4)
{
数组段 = 参数数组.取成员 (3)
}
声明 = "变量 " + 参数数组.取成员 (0) + " <公开 静态 类型 = " + 映射类型 (参数数组.取成员 (1))
如果 (数组段 != "")
{
如果 (数组段 == "\"0\"")
{
声明 = 声明 + " []>"
}
否则
{
声明 = 声明 + " [" + 删外层引号 (数组段) + "]>"
}
}
否则
{
声明 = 声明 + ">"
}
输出行缩进 (声明, 1)
}
返回
}
如果真 (指令名 == "常量")
{
如果真 (段数 >= 2)
{
如果真 (区块状态 != "常量" 且 区块状态 != "类")
{
打开类 ("类 常量类 <公开 @全局类 = 真>")
区块状态 = "常量"
}
值文本 = 删首尾空 (参数数组.取成员 (1))
值文本 = 删外层引号 (值文本)
如果 (值文本 == "真" 或 值文本 == "假")
{
类型输出 = "逻辑型"
输出值 = 值文本
}
否则
{
如果 (是数字 (值文本))
{
如果 (寻找文本 (值文本, ".", 0, 假) != -1)
{
类型输出 = "小数"
}
否则
{
类型输出 = "整数"
}
输出值 = 值文本
}
否则
{
类型输出 = "文本型"
输出值 = 加引号 (值文本)
}
}
输出行缩进 ("常量 " + 参数数组.取成员 (0) + " <公开 类型 = " + 类型输出 + " 值 = " + 输出值 + ">", 1)
}
返回
}
如果真 (指令名 == "dll命令")
{
如果真 (段数 >= 1)
{
打开类 ("类 Dll命令类 <公开 @全局类 = 真>")
区块状态 = "Dll"
名称 = 参数数组.取成员 (0)
返回类型 = ""
如果真 (段数 >= 2)
{
返回类型 = 参数数组.取成员 (1)
}
声明 = "方法 " + 名称 + " <公开 静态"
如果真 (返回类型 != "")
{
声明 = 声明 + " 类型 = " + 映射类型 (返回类型)
}
如果真 (段数 >= 4 且 参数数组.取成员 (3) != "")
{
声明 = 声明 + " @输出名 = " + 加引号 (删外层引号 (参数数组.取成员 (3)))
}
如果真 (段数 >= 3 且 参数数组.取成员 (2) != "")
{
声明 = 声明 + " @视窗.输入 = " + 加引号 (删外层引号 (参数数组.取成员 (2)))
}
声明 = 声明 + ">"
输出行缩进 (声明, 1)
在Dll参数 = 真
}
返回
}
如果真 (指令名 == "数据类型")
{
如果真 (段数 >= 1)
{
打开类 ("类 " + 参数数组.取成员 (0) + " <公开 @视窗.结构类 = 0>")
区块状态 = "类型"
}
返回
}
如果真 (指令名 == "成员")
{
如果真 (段数 >= 2)
{
如果 (区块状态 == "类型" 或 区块状态 == "类")
{
数组段 = ""
如果真 (段数 >= 4)
{
数组段 = 参数数组.取成员 (3)
}
声明 = "变量 " + 参数数组.取成员 (0) + " <公开 类型 = " + 映射类型 (参数数组.取成员 (1))
如果 (数组段 != "")
{
如果 (数组段 == "\"0\"")
{
声明 = 声明 + " []>"
}
否则
{
声明 = 声明 + " [" + 删外层引号 (数组段) + "]>"
}
}
否则
{
声明 = 声明 + ">"
}
输出行缩进 (声明, 1)
}
否则
{
加提示 ("成员 " + 参数数组.取成员 (0) + " 不在数据类型/类中，已忽略")
}
}
返回
}
如果真 (指令名 == "类")
{
如果真 (段数 >= 1)
{
声明 = "类 " + 参数数组.取成员 (0) + " <公开"
如果真 (段数 >= 2 且 参数数组.取成员 (1) != "" 且 参数数组.取成员 (1) != "公开")
{
声明 = 声明 + " 基础类 = " + 参数数组.取成员 (1)
}
如果真 (段数 >= 3 且 参数数组.取成员 (2) != "" 且 参数数组.取成员 (2) != "公开")
{
声明 = 声明 + " 基础类 = " + 参数数组.取成员 (2)
}
声明 = 声明 + ">"
打开类 (声明)
区块状态 = "类"
}
返回
}
如果真 (指令名 == "子程序")
{
如果真 (段数 >= 1)
{
名称 = 参数数组.取成员 (0)
返回类型 = ""
如果真 (段数 >= 2)
{
返回类型 = 参数数组.取成员 (1)
}
公开标志 = 假
如果真 (段数 >= 3 且 参数数组.取成员 (2) == "公开")
{
公开标志 = 真
}
如果 (名称 == "_启动子程序" 或 (段数 >= 5 且 参数数组.取成员 (4) == "启动子程序"))
{
打开类 ("类 启动类 <公开 基础类 = 程序类>")
区块状态 = "启动类"
输出行缩进 ("方法 启动方法 <公开 类型 = 整数>", 1)
输出行缩进 ("{", 1)
缩进级 = 2
方法内 = 真
当前方法返回类型 = "整数"
方法见返回 = 假
加提示 ("_启动子程序 已转换为 启动类.启动方法（基础类 程序类，需视窗基本类模块）")
}
否则
{
如果 (区块状态 != "程序集" 且 区块状态 != "类" 且 区块状态 != "启动类")
{
如果真 (当前程序集名 == "")
{
当前程序集名 = "程序集1"
}
打开类 ("类 " + 当前程序集名 + " <公开 @全局类 = 真>")
区块状态 = "程序集"
}
关闭方法 ()
声明 = "方法 " + 名称 + " <"
如果真 (公开标志)
{
声明 = 声明 + "公开 "
}
声明 = 声明 + "静态"
如果真 (返回类型 != "")
{
声明 = 声明 + " 类型 = " + 映射类型 (返回类型)
}
声明 = 声明 + ">"
输出行缩进 (声明, 1)
输出行缩进 ("{", 1)
缩进级 = 2
方法内 = 真
当前方法返回类型 = 返回类型
方法见返回 = 假
如果真 (取文本左边 (名称, 1) == "_")
{
加提示 ("子程序 " + 名称 + " 疑似窗口事件子程序，请在火山窗口类中改为接收事件方法")
}
}
}
返回
}
如果真 (指令名 == "参数")
{
如果真 (段数 >= 2)
{
如果 (区块状态 == "Dll" 且 在Dll参数)
{
如果真 (段数 >= 3 且 参数数组.取成员 (2) == "传址")
{
加提示 ("DLL命令参数 " + 参数数组.取成员 (0) + " 原为传址，请在火山中改用 变整数 类型并配合 取变量地址 ()")
}
输出行缩进 ("参数 " + 参数数组.取成员 (0) + " <类型 = " + 映射类型 (参数数组.取成员 (1)) + ">", 2)
}
否则
{
如果 (方法内)
{
数组段 = ""
如果真 (段数 >= 3 且 参数数组.取成员 (2) == "数组")
{
数组段 = "0"
}
如果真 (段数 >= 4 且 参数数组.取成员 (3) == "数组")
{
数组段 = "0"
}
如果真 (段数 >= 5 且 参数数组.取成员 (4) == "数组")
{
数组段 = "0"
}
如果真 (段数 >= 5 且 参数数组.取成员 (4) != "" 且 参数数组.取成员 (4) != "数组" 且 参数数组.取成员 (4) != "参考")
{
数组段 = 删外层引号 (参数数组.取成员 (4))
}
声明 = "参数 " + 参数数组.取成员 (0) + " <类型 = " + 映射类型 (参数数组.取成员 (1))
如果 (数组段 != "")
{
如果 (数组段 == "0")
{
声明 = 声明 + " []>"
}
否则
{
声明 = 声明 + " [" + 数组段 + "]>"
}
}
否则
{
声明 = 声明 + ">"
}
输出行缩进 (声明, 2)
如果真 (段数 >= 3 且 参数数组.取成员 (2) == "参考")
{
加提示 ("子程序参数 " + 参数数组.取成员 (0) + " 原为参考参数，火山文本型/对象参数本身按参考传递")
}
}
否则
{
加提示 ("参数 " + 参数数组.取成员 (0) + " 不在方法内，已忽略")
}
}
}
返回
}
如果真 (指令名 == "局部变量")
{
如果真 (段数 >= 2)
{
如果 (方法内)
{
数组段 = ""
如果真 (段数 >= 4)
{
数组段 = 参数数组.取成员 (3)
}
声明 = "变量 " + 参数数组.取成员 (0) + " <"
如果真 (段数 >= 3 且 参数数组.取成员 (2) == "静态")
{
声明 = 声明 + "静态 "
}
声明 = 声明 + "类型 = " + 映射类型 (参数数组.取成员 (1))
如果 (数组段 != "")
{
如果 (数组段 == "\"0\"")
{
声明 = 声明 + " []>"
}
否则
{
声明 = 声明 + " [" + 删外层引号 (数组段) + "]>"
}
}
否则
{
声明 = 声明 + ">"
}
输出行缩进 (声明, 2)
}
否则
{
加提示 ("局部变量 " + 参数数组.取成员 (0) + " 不在方法内，已忽略")
}
}
返回
}
如果真 (指令名 == "如果" 或 指令名 == "如果真")
{
条件文本 = 提取括号内 (参数文本)
条件文本 = 处理表达式文本 (条件文本, 真)
如果 (指令名 == "如果")
{
输出行 ("如果 (" + 条件文本 + ")")
}
否则
{
输出行 ("如果真 (" + 条件文本 + ")")
}
输出行 ("{")
块栈.加入成员 (指令名)
缩进级 = 缩进级 + 1
返回
}
如果真 (指令名 == "否则")
{
如果真 (块栈.取成员数 () > 0)
{
缩进级 = 缩进级 - 1
输出行 ("}")
输出行 ("否则")
输出行 ("{")
缩进级 = 缩进级 + 1
}
返回
}
如果真 (指令名 == "如果结束" 或 指令名 == "如果真结束")
{
如果真 (块栈.取成员数 () > 0)
{
缩进级 = 缩进级 - 1
输出行 ("}")
块栈.删除成员 (块栈.取成员数 () - 1, 1)
}
返回
}
如果真 (指令名 == "判断循环首")
{
条件文本 = 提取括号内 (参数文本)
条件文本 = 处理表达式文本 (条件文本, 真)
输出行 ("判断循环 (" + 条件文本 + ")")
输出行 ("{")
块栈.加入成员 ("判断循环")
缩进级 = 缩进级 + 1
返回
}
如果真 (指令名 == "判断循环尾")
{
如果真 (块栈.取成员数 () > 0)
{
缩进级 = 缩进级 - 1
输出行 ("}")
块栈.删除成员 (块栈.取成员数 () - 1, 1)
}
返回
}
如果真 (指令名 == "循环判断首")
{
输出行 ("循环判断首 ()")
输出行 ("{")
块栈.加入成员 ("循环判断首")
缩进级 = 缩进级 + 1
返回
}
如果真 (指令名 == "循环判断尾")
{
如果真 (块栈.取成员数 () > 0)
{
缩进级 = 缩进级 - 1
输出行 ("}")
条件文本 = 提取括号内 (参数文本)
条件文本 = 处理表达式文本 (条件文本, 真)
输出行 ("循环判断尾 (" + 条件文本 + ")")
块栈.删除成员 (块栈.取成员数 () - 1, 1)
}
返回
}
如果真 (指令名 == "计次循环首")
{
循环次数 = ""
变量名 = ""
如果真 (段数 >= 1)
{
循环次数 = 参数数组.取成员 (0)
}
如果真 (段数 >= 2)
{
变量名 = 参数数组.取成员 (1)
}
输出行 ("计次循环 (" + 循环次数 + ")")
输出行 ("{")
块栈.加入成员 ("计次循环")
缩进级 = 缩进级 + 1
如果真 (变量名 != "")
{
加提示 ("计次循环变量 " + 变量名 + " 请改用火山内置 取循环索引 ()，注意火山索引从 0 开始")
}
返回
}
如果真 (指令名 == "计次循环尾")
{
如果真 (块栈.取成员数 () > 0)
{
缩进级 = 缩进级 - 1
输出行 ("}")
块栈.删除成员 (块栈.取成员数 () - 1, 1)
}
返回
}
如果真 (指令名 == "变量循环首")
{
// 易语言顺序: 起始, 目标, 递增, 变量 → 火山顺序: 起始, 目标, 变量, 递增
如果真 (段数 >= 4)
{
输出行 ("循环 (" + 参数数组.取成员 (0) + ", " + 参数数组.取成员 (1) + ", " + 参数数组.取成员 (3) + ", " + 参数数组.取成员 (2) + ")")
输出行 ("{")
块栈.加入成员 ("变量循环")
缩进级 = 缩进级 + 1
加提示 ("火山循环到达目标值即跳出（易语言为超过才跳出），请检查循环边界")
}
返回
}
如果真 (指令名 == "变量循环尾")
{
如果真 (块栈.取成员数 () > 0)
{
缩进级 = 缩进级 - 1
输出行 ("}")
块栈.删除成员 (块栈.取成员数 () - 1, 1)
}
返回
}
如果真 (指令名 == "判断")
{
条件文本 = 提取括号内 (参数文本)
条件文本 = 处理表达式文本 (条件文本, 假)
输出行 ("分支判断 (" + 条件文本 + ")")
输出行 ("{")
块栈.加入成员 ("判断")
缩进级 = 缩进级 + 1
返回
}
如果真 (指令名 == "分支" 或 指令名 == "默认")
{
如果真 (块栈.取成员数 () > 0 且 块栈.取成员 (块栈.取成员数 () - 1) == "分支")
{
缩进级 = 缩进级 - 1
输出行 ("}")
块栈.删除成员 (块栈.取成员数 () - 1, 1)
}
如果 (指令名 == "默认")
{
输出行 ("默认分支")
}
否则
{
值文本 = 提取括号内 (参数文本)
输出行 ("分支 (" + 值文本 + ")")
}
输出行 ("{")
块栈.加入成员 ("分支")
缩进级 = 缩进级 + 1
返回
}
如果真 (指令名 == "判断结束")
{
如果真 (块栈.取成员数 () > 0 且 块栈.取成员 (块栈.取成员数 () - 1) == "分支")
{
缩进级 = 缩进级 - 1
输出行 ("}")
块栈.删除成员 (块栈.取成员数 () - 1, 1)
}
如果真 (块栈.取成员数 () > 0 且 块栈.取成员 (块栈.取成员数 () - 1) == "判断")
{
缩进级 = 缩进级 - 1
输出行 ("}")
块栈.删除成员 (块栈.取成员数 () - 1, 1)
}
返回
}
如果真 (指令名 == "跳出循环")
{
输出行 ("跳出循环")
返回
}
如果真 (指令名 == "到循环尾")
{
输出行 ("到循环尾")
返回
}
如果真 (指令名 == "跳出判断")
{
输出行 ("跳出分支")
返回
}
如果真 (指令名 == "返回")
{
条件文本 = 提取括号内 (参数文本)
如果 (条件文本 == "")
{
输出行 ("返回")
}
否则
{
输出行 ("返回 (" + 条件文本 + ")")
}
方法见返回 = 真
返回
}
加提示 ("已忽略未识别指令: ." + 指令名 + " " + 参数文本)
}
方法 处理语句行
参数 行 <类型 = 文本型>
{
变量 注释位置 <类型 = 整数>
变量 代码部分 <类型 = 文本型>
变量 注释部分 <类型 = 文本型>
注释位置 = 找行尾注释 (行)
如果 (注释位置 == 0)
{
输出行 ("//" + 删首尾空 (取文本右边 (行, 取文本长度 (行) - 1)))
返回
}
如果 (注释位置 > 0)
{
代码部分 = 删首尾空 (取文本左边 (行, 注释位置))
注释部分 = 取文本右边 (行, 取文本长度 (行) - 注释位置 - 1)
}
否则
{
代码部分 = 行
注释部分 = ""
}
代码部分 = 变换信息框 (代码部分)
代码部分 = 变换数组命令 (代码部分)
代码部分 = 替换命令名 (代码部分)
代码部分 = 处理表达式文本 (代码部分, 假)
如果 (取文本左边 (代码部分, 4) == "返回 (")
{
方法见返回 = 真
}
如果真 (代码部分 != "")
{
输出行 (代码部分)
}
如果真 (注释部分 != "")
{
输出行 ("//" + 删首尾空 (注释部分))
}
}
方法 处理表达式文本 <类型 = 文本型>
参数 文本 <类型 = 文本型>
参数 是否条件 <类型 = 逻辑型>
{
变量 结果 <类型 = 文本型>
结果 = 处理代码行 (文本, 是否条件)
结果 = 加名单前缀 (结果, 1)
结果 = 加名单前缀 (结果, 2)
结果 = 加名单前缀 (结果, 3)
返回 (结果)
}
方法 处理代码行 <类型 = 文本型>
参数 行 <类型 = 文本型>
参数 是否条件 <类型 = 逻辑型>
{
变量 i <类型 = 整数>
变量 长度 <类型 = 整数>
变量 当前字符 <类型 = 文本型>
变量 下一字符 <类型 = 文本型>
变量 前字符 <类型 = 文本型>
变量 在引号 <类型 = 逻辑型>
变量 结果 <类型 = 文本型>
长度 = 取文本长度 (行)
在引号 = 假
前字符 = ""
结果 = ""
i = 0
判断循环 (i < 长度)
{
当前字符 = 取文本中间 (行, i, 1)
下一字符 = ""
如果真 (i + 1 < 长度)
{
下一字符 = 取文本中间 (行, i + 1, 1)
}
如果 (是否引号字符 (当前字符))
{
在引号 = 取反 (在引号)
结果 = 结果 + "\""
}
否则
{
如果 (在引号)
{
结果 = 结果 + 当前字符
}
否则
{
如果 (长度 - i >= 5 且 取文本中间 (行, i, 5) == "#换行符")
{
结果 = 结果 + "\"\\r\\n\""
i = i + 5
到循环尾
}
如果 (长度 - i >= 3 且 取文本中间 (行, i, 3) == "#引号")
{
结果 = 结果 + "\"\\\"\""
i = i + 3
到循环尾
}
如果 (长度 - i >= 4 且 (取文本中间 (行, i, 4) == "#Tab键" 或 取文本中间 (行, i, 4) == "#TAB键"))
{
结果 = 结果 + "\"\\t\""
i = i + 4
到循环尾
}
如果 (当前字符 == "＝" 或 当前字符 == "=")
{
如果 (下一字符 == "＝" 或 下一字符 == "=")
{
结果 = 结果 + "=="
i = i + 1
}
否则
{
如果 (前字符 == "<" 或 前字符 == ">" 或 前字符 == "!" 或 前字符 == "＜" 或 前字符 == "＞")
{
结果 = 结果 + "="
}
否则
{
如果 (是否条件)
{
结果 = 结果 + "=="
}
否则
{
结果 = 结果 + "="
}
}
}
}
否则
{
如果 (当前字符 == "＜")
{
如果 (下一字符 == "＞")
{
结果 = 结果 + "!="
i = i + 1
}
否则 (下一字符 == "＝" 或 下一字符 == "=")
{
结果 = 结果 + "<="
i = i + 1
}
否则
{
结果 = 结果 + "<"
}
}
否则
{
如果 (当前字符 == "＞")
{
如果 (下一字符 == "＝" 或 下一字符 == "=")
{
结果 = 结果 + ">="
i = i + 1
}
否则
{
结果 = 结果 + ">"
}
}
否则
{
如果 (当前字符 == "<" 且 下一字符 == ">")
{
结果 = 结果 + "!="
i = i + 1
}
否则
{
如果 (当前字符 == "≠")
{
结果 = 结果 + "!="
}
否则
{
如果 (当前字符 == "≥")
{
结果 = 结果 + ">="
}
否则
{
如果 (当前字符 == "≤")
{
结果 = 结果 + "<="
}
否则
{
如果 (当前字符 == "＋")
{
结果 = 结果 + "+"
}
否则
{
如果 (当前字符 == "－")
{
结果 = 结果 + "-"
}
否则
{
如果 (当前字符 == "×")
{
结果 = 结果 + "*"
}
否则
{
如果 (当前字符 == "÷")
{
结果 = 结果 + "/"
}
否则
{
如果 (当前字符 == "且" 且 是否名称字符 (前字符) == 假 且 是否名称字符 (下一字符) == 假)
{
结果 = 结果 + "&&"
}
否则
{
如果 (当前字符 == "或" 且 是否名称字符 (前字符) == 假 且 是否名称字符 (下一字符) == 假)
{
结果 = 结果 + "||"
}
否则
{
如果 (当前字符 == "空" 且 是否名称字符 (前字符) == 假 且 是否名称字符 (下一字符) == 假)
{
结果 = 结果 + "空对象"
}
否则
{
结果 = 结果 + 当前字符
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
前字符 = 当前字符
i = i + 1
}
返回 (结果)
}
方法 加名单前缀 <类型 = 文本型>
参数 行 <类型 = 文本型>
参数 名单序号 <类型 = 整数>
{
变量 结果 <类型 = 文本型>
变量 i <类型 = 整数>
变量 长度 <类型 = 整数>
变量 在引号 <类型 = 逻辑型>
变量 当前字符 <类型 = 文本型>
变量 名 <类型 = 文本型>
变量 名长度 <类型 = 整数>
变量 前字符 <类型 = 文本型>
变量 后字符 <类型 = 文本型>
变量 命中 <类型 = 逻辑型>
变量 名单 <类型 = 文本数组类>
变量 前缀 <类型 = 文本型>
分支判断 (名单序号)
{
分支 (1)
{
名单.从数组复制 (全局变量名单)
前缀 = "全局变量类."
}
分支 (2)
{
名单.从数组复制 (常量名单)
前缀 = "常量类."
}
默认分支
{
名单.从数组复制 (Dll命令名单)
前缀 = "Dll命令类."
}
}
结果 = ""
长度 = 取文本长度 (行)
在引号 = 假
i = 0
判断循环 (i < 长度)
{
当前字符 = 取文本中间 (行, i, 1)
如果 (是否引号字符 (当前字符))
{
在引号 = 取反 (在引号)
结果 = 结果 + "\""
i = i + 1
到循环尾
}
如果 (在引号)
{
结果 = 结果 + 当前字符
i = i + 1
到循环尾
}
命中 = 假
计次循环 (名单.取成员数 ())
{
名 = 名单.取成员 (取循环索引 ())
如果真 (名 == "")
{
到循环尾
}
名长度 = 取文本长度 (名)
如果真 (i + 名长度 > 长度)
{
到循环尾
}
如果 (取文本中间 (行, i, 名长度) == 名)
{
前字符 = ""
如果真 (i > 0)
{
前字符 = 取文本中间 (行, i - 1, 1)
}
后字符 = ""
如果真 (i + 名长度 < 长度)
{
后字符 = 取文本中间 (行, i + 名长度, 1)
}
如果 (是否名称字符 (前字符) == 假 且 是否名称字符 (后字符) == 假 且 前字符 != ".")
{
结果 = 结果 + 前缀 + 名
i = i + 名长度
命中 = 真
跳出循环
}
}
}
如果真 (命中 == 假)
{
结果 = 结果 + 当前字符
i = i + 1
}
}
返回 (结果)
}
方法 寻找命令调用 <类型 = 整数>
参数 文本 <类型 = 文本型>
参数 命令名 <类型 = 文本型>
参数 起始位置 <类型 = 整数>
{
变量 位置 <类型 = 整数>
位置 = 起始位置
判断循环 (真)
{
位置 = 寻找文本 (文本, 命令名 + " (", 位置, 假)
如果 (位置 == -1)
{
返回 (-1)
}
// 跳过位于更长名称内部的匹配（如"全局信息框 ("中的"信息框 ("）
如果 (位置 > 0 且 是否名称字符 (取文本中间 (文本, 位置 - 1, 1)))
{
位置 = 位置 + 1
到循环尾
}
返回 (位置)
}
返回 (-1)
}
方法 变换信息框 <类型 = 文本型>
参数 行 <类型 = 文本型>
{
变量 结果 <类型 = 文本型>
变量 位置 <类型 = 整数>
变量 括号左 <类型 = 整数>
变量 括号右 <类型 = 整数>
变量 内部 <类型 = 文本型>
变量 段数 <类型 = 整数>
变量 新调用 <类型 = 文本型>
结果 = 行
循环判断首 ()
{
位置 = 寻找命令调用 (结果, "信息框", 0)
如果真 (位置 == -1)
{
跳出循环
}
括号左 = 寻找文本 (结果, "(", 位置, 假)
如果真 (括号左 == -1)
{
跳出循环
}
括号右 = 找配对括号 (结果, 括号左)
如果真 (括号右 == -1)
{
跳出循环
}
内部 = 取文本中间 (结果, 括号左 + 1, 括号右 - 括号左 - 1)
段数 = 分割参数 (内部)
如果 (段数 >= 4 且 删首尾空 (参数数组.取成员 (3)) != "")
{
新调用 = "全局信息框 (" + 参数数组.取成员 (0) + ", " + 参数数组.取成员 (1) + ", " + 加引号 ("信息") + ", " + 参数数组.取成员 (3) + ")"
}
否则 (段数 >= 3 且 删首尾空 (参数数组.取成员 (2)) != "")
{
新调用 = "全局信息框 (" + 参数数组.取成员 (0) + ", " + 参数数组.取成员 (1) + ", " + 加引号 ("信息") + ")"
}
否则 (段数 >= 2 且 删首尾空 (参数数组.取成员 (1)) != "")
{
新调用 = "全局信息框 (" + 参数数组.取成员 (0) + ", " + 参数数组.取成员 (1) + ")"
}
否则
{
新调用 = "全局信息框 (" + 内部 + ")"
}
子文本替换 (结果, 取文本中间 (结果, 位置, 括号右 - 位置 + 1), 新调用, 0, -1)
如果真 (寻找文本 (转换提示, "信息框 () 已转换", 0, 假) == -1)
{
加提示 ("信息框 () 已转换为 全局信息框 (提示, 按钮, 标题, 父句柄)，原图标参数已舍弃")
}
}
循环判断尾 (真)
返回 (结果)
}
方法 变换数组命令 <类型 = 文本型>
参数 行 <类型 = 文本型>
{
变量 结果 <类型 = 文本型>
变量 位置 <类型 = 整数>
变量 括号左 <类型 = 整数>
变量 括号右 <类型 = 整数>
变量 内部 <类型 = 文本型>
变量 段数 <类型 = 整数>
变量 新调用 <类型 = 文本型>
结果 = 行
循环判断首 ()
{
位置 = 寻找命令调用 (结果, "取数组下标", 0)
如果真 (位置 == -1)
{
跳出循环
}
括号左 = 寻找文本 (结果, "(", 位置, 假)
如果真 (括号左 == -1)
{
跳出循环
}
括号右 = 找配对括号 (结果, 括号左)
如果真 (括号右 == -1)
{
跳出循环
}
内部 = 取文本中间 (结果, 括号左 + 1, 括号右 - 括号左 - 1)
段数 = 分割参数 (内部)
如果 (段数 >= 2 且 删首尾空 (参数数组.取成员 (1)) == "1")
{
新调用 = 删首尾空 (参数数组.取成员 (0)) + ".成员数"
子文本替换 (结果, 取文本中间 (结果, 位置, 括号右 - 位置 + 1), 新调用, 0, -1)
}
否则
{
跳出循环
}
}
循环判断尾 (真)
返回 (结果)
}
方法 替换命令名 <类型 = 文本型>
参数 行 <类型 = 文本型>
{
变量 结果 <类型 = 文本型>
结果 = 行
子文本替换 (结果, "延时 (", "延迟 (", 0, -1)
子文本替换 (结果, "写到文件 (", "写出文件 (", 0, -1)
子文本替换 (结果, "输出调试文本 (", "调试输出 (", 0, -1)
子文本替换 (结果, "跳出循环 ()", "跳出循环", 0, -1)
子文本替换 (结果, "到循环尾 ()", "到循环尾", 0, -1)
子文本替换 (结果, "跳出判断 ()", "跳出分支", 0, -1)
返回 (结果)
}
方法 分割参数 <类型 = 整数>
参数 文本 <类型 = 文本型>
{
变量 i <类型 = 整数>
变量 长度 <类型 = 整数>
变量 当前字符 <类型 = 文本型>
变量 深度 <类型 = 整数>
变量 在引号 <类型 = 逻辑型>
变量 当前段 <类型 = 文本型>
参数数组.删除所有成员 ()
子文本替换 (文本, "，", ",", 0, -1)
子文本替换 (文本, "（", "(", 0, -1)
子文本替换 (文本, "）", ")", 0, -1)
长度 = 取文本长度 (文本)
在引号 = 假
深度 = 0
当前段 = ""
循环 (1, 长度 + 1, i, 1)
{
当前字符 = 取文本中间 (文本, i - 1, 1)
如果 (是否引号字符 (当前字符))
{
在引号 = 取反 (在引号)
当前段 = 当前段 + 当前字符
}
否则
{
如果 (在引号)
{
当前段 = 当前段 + 当前字符
}
否则
{
如果 (当前字符 == "(")
{
深度 = 深度 + 1
当前段 = 当前段 + 当前字符
}
否则
{
如果 (当前字符 == ")")
{
深度 = 深度 - 1
当前段 = 当前段 + 当前字符
}
否则
{
如果 (当前字符 == "," 且 深度 == 0)
{
参数数组.加入成员 (当前段)
当前段 = ""
}
否则
{
当前段 = 当前段 + 当前字符
}
}
}
}
}
}
参数数组.加入成员 (当前段)
返回 (参数数组.取成员数 ())
}
方法 提取括号内 <类型 = 文本型>
参数 文本 <类型 = 文本型>
{
变量 长度 <类型 = 整数>
长度 = 取文本长度 (文本)
如果 (长度 >= 2 且 取文本左边 (文本, 1) == "(" 且 取文本右边 (文本, 1) == ")")
{
返回 (取文本中间 (文本, 1, 长度 - 2))
}
返回 (文本)
}
方法 找配对括号 <类型 = 整数>
参数 文本 <类型 = 文本型>
参数 左位置 <类型 = 整数>
{
变量 i <类型 = 整数>
变量 深度 <类型 = 整数>
变量 长度 <类型 = 整数>
变量 当前字符 <类型 = 文本型>
变量 在引号 <类型 = 逻辑型>
长度 = 取文本长度 (文本)
深度 = 0
在引号 = 假
循环 (左位置, 长度, i, 1)
{
当前字符 = 取文本中间 (文本, i, 1)
如果 (是否引号字符 (当前字符))
{
在引号 = 取反 (在引号)
}
否则
{
如果 (在引号 == 假)
{
如果 (当前字符 == "(")
{
深度 = 深度 + 1
}
如果 (当前字符 == ")")
{
深度 = 深度 - 1
如果真 (深度 == 0)
{
返回 (i)
}
}
}
}
}
返回 (-1)
}
方法 找行尾注释 <类型 = 整数>
参数 行 <类型 = 文本型>
{
变量 长度 <类型 = 整数>
变量 在引号 <类型 = 逻辑型>
变量 当前字符 <类型 = 文本型>
变量 代码 <类型 = 整数>
长度 = 取文本长度 (行)
在引号 = 假
计次循环 (长度)
{
当前字符 = 取文本中间 (行, 取循环索引 (), 1)
如果 (是否引号字符 (当前字符))
{
在引号 = 取反 (在引号)
}
否则
{
如果 (在引号 == 假)
{
代码 = (整数) 取字符 (当前字符, 0)
如果 (代码 == 39)
{
返回 (取循环索引 ())
}
}
}
}
返回 (-1)
}
方法 是否引号字符 <类型 = 逻辑型>
参数 字符文本 <类型 = 文本型>
{
如果 (字符文本 == "\"" 或 字符文本 == "\u201C" 或 字符文本 == "\u201D")
{
返回 (真)
}
返回 (假)
}
方法 是否名称字符 <类型 = 逻辑型>
参数 字符文本 <类型 = 文本型>
{
变量 代码 <类型 = 整数>
如果 (字符文本 == "")
{
返回 (假)
}
代码 = (整数) 取字符 (字符文本, 0)
如果 (代码 >= 128 或 (代码 >= 48 且 代码 <= 57) 或 (代码 >= 65 且 代码 <= 90) 或 (代码 >= 97 且 代码 <= 122) 或 代码 == 95)
{
返回 (真)
}
返回 (假)
}
方法 是数字 <类型 = 逻辑型>
参数 文本 <类型 = 文本型>
{
变量 长度 <类型 = 整数>
变量 点数 <类型 = 整数>
变量 当前字符 <类型 = 文本型>
变量 代码 <类型 = 整数>
长度 = 取文本长度 (文本)
如果 (长度 == 0)
{
返回 (假)
}
点数 = 0
计次循环 (长度)
{
当前字符 = 取文本中间 (文本, 取循环索引 (), 1)
代码 = (整数) 取字符 (当前字符, 0)
如果 (代码 >= 48 且 代码 <= 57)
{
}
否则 (代码 == 46)
{
点数 = 点数 + 1
如果 (点数 > 1)
{
返回 (假)
}
}
否则 (代码 == 45 且 取循环索引 () == 0)
{
}
否则
{
返回 (假)
}
}
返回 (真)
}
方法 删外层引号 <类型 = 文本型>
参数 文本 <类型 = 文本型>
{
变量 结果 <类型 = 文本型>
结果 = 文本
如果 (取文本长度 (结果) >= 2 且 是否引号字符 (取文本左边 (结果, 1)) 且 是否引号字符 (取文本右边 (结果, 1)))
{
结果 = 取文本中间 (结果, 1, 取文本长度 (结果) - 2)
}
返回 (结果)
}
方法 加引号 <类型 = 文本型>
参数 文本 <类型 = 文本型>
{
返回 ("\"" + 文本 + "\"")
}
方法 映射类型 <类型 = 文本型>
参数 易类型 <类型 = 文本型>
{
如果 (易类型 == "整数型")
{
返回 ("整数")
}
如果 (易类型 == "长整数型")
{
返回 ("长整数")
}
如果 (易类型 == "短整数型")
{
返回 ("短整数")
}
如果 (易类型 == "字节型")
{
返回 ("字节")
}
如果 (易类型 == "小数型")
{
返回 ("单精度小数")
}
如果 (易类型 == "双精度小数型")
{
返回 ("小数")
}
如果 (易类型 == "逻辑型")
{
返回 ("逻辑型")
}
如果 (易类型 == "文本型")
{
返回 ("文本型")
}
如果 (易类型 == "字节集")
{
返回 ("字节集类")
}
如果 (易类型 == "日期时间型")
{
返回 ("长整数")
}
如果 (易类型 == "子程序指针")
{
返回 ("变整数")
}
如果 (易类型 == "通用型")
{
返回 ("对象类")
}
返回 (易类型)
}
方法 兜底返回文本 <类型 = 文本型>
参数 返回类型 <类型 = 文本型>
{
如果 (返回类型 == "整数型" 或 返回类型 == "整数" 或 返回类型 == "长整数型" 或 返回类型 == "长整数" 或 返回类型 == "短整数型" 或 返回类型 == "短整数" 或 返回类型 == "字节型" 或 返回类型 == "字节" 或 返回类型 == "小数型" 或 返回类型 == "单精度小数" 或 返回类型 == "双精度小数型" 或 返回类型 == "小数")
{
返回 ("返回 (0)")
}
如果 (返回类型 == "逻辑型")
{
返回 ("返回 (假)")
}
如果 (返回类型 == "文本型")
{
返回 ("返回 (\"\")")
}
返回 ("返回 (空对象)")
}
方法 输出行
参数 文本 <类型 = 文本型>
{
输出缓冲 = 输出缓冲 + 取重复文本 (" ", 缩进级 * 4) + 文本 + "\r\n"
}
方法 输出行缩进
参数 文本 <类型 = 文本型>
参数 深度 <类型 = 整数>
{
输出缓冲 = 输出缓冲 + 取重复文本 (" ", 深度 * 4) + 文本 + "\r\n"
}
方法 加提示
参数 文本 <类型 = 文本型>
{
转换提示 = 转换提示 + "# " + 文本 + "\r\n"
}
方法 关闭Dll方法
{
如果真 (在Dll参数 == 假)
{
返回
}
输出行缩进 ("{", 2)
输出行缩进 ("}", 2)
在Dll参数 = 假
}
方法 关闭方法
{
如果真 (方法内 == 假)
{
返回
}
判断循环 (块栈.取成员数 () > 0)
{
缩进级 = 缩进级 - 1
输出行 ("}")
块栈.删除成员 (块栈.取成员数 () - 1, 1)
}
如果 (当前方法返回类型 != "" 且 方法见返回 == 假)
{
输出行 (兜底返回文本 (当前方法返回类型))
}
缩进级 = 1
输出行 ("}")
方法内 = 假
当前方法返回类型 = ""
方法见返回 = 假
}
方法 关闭当前区块
{
关闭Dll方法 ()
如果真 (方法内)
{
关闭方法 ()
}
如果真 (区块状态 != "")
{
缩进级 = 0
输出行 ("}")
区块状态 = ""
}
}
方法 打开类
参数 声明 <类型 = 文本型>
{
关闭当前区块 ()
输出行缩进 (声明, 0)
输出行缩进 ("{", 0)
缩进级 = 1
}
方法 生成转换说明 <类型 = 文本型>
{
变量 说明 <类型 = 文本型>
说明 = "\r\n"
如果真 (支持库列表 != "")
{
说明 = 说明 + "# 注意: 原代码使用了支持库: " + 支持库列表 + " 请在火山项目中添加功能对应的模块\r\n"
}
说明 = 说明 + "# ===================== 转换说明 =====================\r\n"
说明 = 说明 + "# 1. 程序集已转为全局类(@全局类 = 真)，子程序为公开静态方法，调用方式与易语言基本一致\r\n"
说明 = 说明 + "# 2. 自定义数据类型已转为结构类(@视窗.结构类 = 0)，需在项目中添加【视窗基本类】模块\r\n"
说明 = 说明 + "# 3. 相等比较 ＝ 已转 ==；赋值转 =；且→&&；或→||；<>→!=\r\n"
说明 = 说明 + "# 4. 火山数组下标从 0 开始（易语言从 1），请检查所有数组访问 → \r\n"
说明 = 说明 + "# 5. 计次循环变量已移除，请改用火山内置 取循环索引 ()（从 0 开始）\r\n"
说明 = 说明 + "# 6. 字节集→字节集类；日期时间型→长整数（时间戳）；子程序指针→变整数\r\n"
说明 = 说明 + "# 7. DLL命令已集中放入 Dll命令类，传址参数请改用 变整数 类型并配合 取变量地址 ()\r\n"
说明 = 说明 + "# 8. 生成的代码为逻辑骨架，窗口/组件/事件需在火山IDE设计器中手动建立\r\n"
如果真 (转换提示 != "")
{
说明 = 说明 + "\r\n" + 转换提示
}
返回 (说明)
}
}
没token了 转换了还得在自己修
很顶 写得很好！能否加一个函数映射表来将某个命令替换成另一个命令呢？
页:
[1]