C转易语言源码

C转易语言源码

.版本 2
.支持库 spec

.程序集 窗口程序集_窗口1

.子程序 _窗口1_创建完毕

' ============ ============   www.sanye.cx  =============--
’本站收录资源，如有密码，默认解压密码都为：www.sanye.cx
’三叶资源网官方③群：33301895
' 投稿邮箱：tg@sanye.cx
' ============ ==================================--
’专注易语言，按键精灵等编程源码分享的网站
’三叶资源网收集的软件和源码，大部分为软件作者或网友推荐，
’版权归原作者所有，仅供学习和研究使用。
’转载本站提供的资源请勿删除本说明文件。
' 本站提供资源只可供研究使用，请在下载24小时内删除，勿用于商业用途，由此引起一切后果与本站无关。
' ============ ============   www.sanye.cx  =============--



.子程序 子程序1, 文本型
.参数 原代码, 文本型, 可空 数组, 指针
.局部变量 程序, 整数型, , "1,1"

程序 ＝ 0
.如果 (程序 ＝ 0)
    程序 ＝ 0
.否则
    程序 ＝ 0
.如果结束
.循环判断首 ()
.循环判断尾 ()

.子程序 _分析子程序_被单击
.局部变量 C原代码, 文本型
.局部变量 C分割原代码, 文本型, , "0"
.局部变量 C分割代码行, 文本型, , "0"
.局部变量 C原代码i, 整数型
.局部变量 C起始位置, 整数型
.局部变量 C结束位置, 整数型
.局部变量 C子程序名称, 文本型
.局部变量 C子程序返回类型, 文本型
.局部变量 C参数集i, 整数型
.局部变量 C代码参数集, 文本型, , "0"
.局部变量 C代码参数, 文本型, , "0"
.局部变量 C参数名, 文本型, , "0"
.局部变量 C参数类型, 文本型, , "0"
.局部变量 C参数备注, 文本型, , "0"
.局部变量 C参数数组, 文本型, , "0"
.局部变量 C局部变量i, 整数型
.局部变量 C局部变量临时集, 文本型, , "0"
.局部变量 C局部变量名, 文本型, , "0"
.局部变量 C局部变量类型, 文本型, , "0"
.局部变量 C局部变量初始值, 文本型, , "0"
.局部变量 C局部变量数组, 文本型, , "0"
.局部变量 C流程指令, 整数型
.局部变量 C单字符, 文本型
.局部变量 C流程多余指令, 文本型
.局部变量 C流程多余指令数组, 文本型, , "0"
.局部变量 C括号个数, 整数型
.局部变量 C话阔, 逻辑型
.局部变量 C流程, 逻辑型
.局部变量 C括号i, 整数型
.局部变量 C否则, 逻辑型
.局部变量 C是否已被占用, 逻辑型
.局部变量 E代码, 文本型
.局部变量 E代码i, 整数型

C原代码 ＝ 编辑框1.内容

C分割原代码 ＝ 分割文本 (C原代码, #换行符, )
C原代码 ＝ “”
.计次循环首 (取数组成员数 (C分割原代码), C原代码i)
    .如果真 (子文本替换 (C分割原代码 [C原代码i], “ ”, , , , 真) ＝ “”)
        到循环尾 ()
    .如果真结束
    C原代码 ＝ C原代码 ＋ C分割原代码 [C原代码i] ＋ #换行符
.计次循环尾 ()

C分割原代码 ＝ 分割文本 (C原代码, #换行符, )
C原代码 ＝ “”
.计次循环首 (取数组成员数 (C分割原代码), C原代码i)
    C分割原代码 [C原代码i] ＝ 子文本替换 (C分割原代码 [C原代码i], “（”, “(”, , , 真)
    C分割原代码 [C原代码i] ＝ 子文本替换 (C分割原代码 [C原代码i], “）”, “)”, , , 真)

    .计次循环首 (1, )  ' 子程序
        .如果真 (C子程序返回类型 ＝ “”)
            .如果真 (寻找文本 (C分割原代码 [C原代码i], “{”, , 假) ＝ -1)
                .如果真 (C原代码i ＋ 1 ＞ 取数组成员数 (C分割原代码))
                    跳出循环 ()
                .如果真结束
                .如果真 (寻找文本 (C分割原代码 [C原代码i ＋ 1], “{”, , 假) ＝ -1)
                    跳出循环 ()
                .如果真结束

            .如果真结束
            C分割代码行 ＝ 分割文本 (C分割原代码 [C原代码i], “ ”, )
            C子程序返回类型 ＝ 判断类型 (C分割代码行 [1])
            .如果真 (C子程序返回类型 ＝ “”)
                到循环尾 ()
            .如果真结束
            C子程序名称 ＝ 取文本左边 (C分割代码行 [2], 寻找文本 (C分割代码行 [2], “(”, , 假) － 1)
            C起始位置 ＝ 寻找文本 (C分割原代码 [C原代码i], “(”, , 假)
            C结束位置 ＝ 寻找文本 (C分割原代码 [C原代码i], “)”, , 假)
            C代码参数集 ＝ 分割文本 (取文本中间 (C分割原代码 [C原代码i], C起始位置 ＋ 1, C结束位置 － C起始位置 － 1), “,”, )
            .计次循环首 (取数组成员数 (C代码参数集), C参数集i)
                加入成员 (C参数备注, 选择 (寻找文本 (C代码参数集 [C参数集i], “*”, , 假) ＝ -1, “”, “指针*”))

                C代码参数集 [C参数集i] ＝ 子文本替换 (C代码参数集 [C参数集i], “*”, , , , 真)
                C代码参数 ＝ 分割文本 (C代码参数集 [C参数集i], “ ”, )

                删除空白数组 (C代码参数)

                加入成员 (C参数类型, 判断类型 (C代码参数 [1]))

                加入成员 (C参数数组, 选择 (寻找文本 (C代码参数 [取数组成员数 (C代码参数)], “[”, , 假) ＝ -1, “”, “数组”))
                C代码参数 [2] ＝ 子文本替换 (C代码参数 [取数组成员数 (C代码参数)], “[” ＋ 判断数组 (C代码参数 [取数组成员数 (C代码参数)]) ＋ “]”, , , , 真)
                加入成员 (C参数名, C代码参数 [取数组成员数 (C代码参数)])
            .计次循环尾 ()
            C是否已被占用 ＝ 真
        .如果真结束

    .计次循环尾 ()
    .如果真 (C是否已被占用)
        C是否已被占用 ＝ 假
        到循环尾 ()
    .如果真结束
    .计次循环首 (1, )  ' 局部变量
        C局部变量临时集 ＝ 分割文本 (C分割原代码 [C原代码i], “ ”, )
        C局部变量i ＝ 取数组成员数 (C局部变量临时集)
        .如果真 (C局部变量i ≤ 1)
            跳出循环 ()
        .如果真结束

        加入成员 (C局部变量类型, 判断类型 (C局部变量临时集 [1]))
        .如果真 (C局部变量类型 [取数组成员数 (C局部变量类型)] ＝ C局部变量临时集 [1])
            .如果真 (寻找文本 (C分割原代码 [C原代码i], “(”, , 假) ≠ -1 或 寻找文本 (C分割原代码 [C原代码i], “{”, , 假) ≠ -1 或 寻找文本 (C分割原代码 [C原代码i], “}”, , 假) ≠ -1 或 判断是否为关键词 (C局部变量临时集 [1]))
                删除成员 (C局部变量类型, 取数组成员数 (C局部变量类型), )
                到循环尾 ()
            .如果真结束

        .如果真结束

        C起始位置 ＝ 寻找文本 (C分割原代码 [C原代码i], “=”, , 假)
        C结束位置 ＝ 寻找文本 (C分割原代码 [C原代码i], “;”, , 假)
        .如果真 (C结束位置 ＝ -1)
            C结束位置 ＝ 取文本长度 (C分割原代码 [C原代码i])
        .如果真结束
        C局部变量临时集 [2] ＝ 子文本替换 (C局部变量临时集 [2], “;”, , , , 真)
        .判断开始 (C起始位置 ＝ -1)
            加入成员 (C局部变量名, 删全部空 (取文本中间 (C局部变量临时集 [2], 1, 取文本长度 (C局部变量临时集 [2]))))
            加入成员 (C局部变量初始值, “0”)
        .默认
            C局部变量临时集 [2] ＝ 取文本中间 (C分割原代码 [C原代码i], 寻找文本 (C分割原代码 [C原代码i], “ ”, , 假) ＋ 1, C结束位置 － 寻找文本 (C分割原代码 [C原代码i], “ ”, , 假) － 1)
            加入成员 (C局部变量名, 删全部空 (取文本中间 (C局部变量临时集 [2], 1, 寻找文本 (C局部变量临时集 [2], “=”, , 假) － 1)))
            加入成员 (C局部变量初始值, 删全部空 (到大写 (取文本中间 (C分割原代码 [C原代码i], C起始位置 ＋ 1, C结束位置 － C起始位置 － 1))))
            调试输出 (C局部变量名)
        .判断结束
        .如果真 (C局部变量名 [取数组成员数 (C局部变量名)] ＝ “”)
            删除成员 (C局部变量名, 取数组成员数 (C局部变量名), )
            删除成员 (C局部变量初始值, 取数组成员数 (C局部变量初始值), )
            删除成员 (C局部变量类型, 取数组成员数 (C局部变量类型), )
            跳出循环 ()
        .如果真结束
        加入成员 (C局部变量数组, 判断数组 (C局部变量名 [取数组成员数 (C局部变量名)]))
        C是否已被占用 ＝ 真
    .计次循环尾 ()
    .如果真 (C是否已被占用)
        C是否已被占用 ＝ 假
        到循环尾 ()
    .如果真结束

    .如果真 (寻找文本 (C分割原代码 [C原代码i], “if (”, , 假) ≠ -1)  ' 判断语句

        .如果 (寻找文本 (C分割原代码 [C原代码i], “return (”, , 假) ＝ -1)
            C流程 ＝ 真
        .否则
            C否则 ＝ 真
        .如果结束

        .计次循环首 (取文本长度 (C分割原代码 [C原代码i]), C括号i)
            C单字符 ＝ 取文本中间 (C分割原代码 [C原代码i], C括号i, 1)
            .如果真 (C单字符 ＝ “(”)
                C括号个数 ＝ C括号个数 ＋ 1
            .如果真结束
            .如果真 (C单字符 ＝ “)”)
                C括号个数 ＝ C括号个数 － 1
                .如果真 (C括号个数 ＝ 0)
                    跳出循环 ()
                .如果真结束

            .如果真结束

        .计次循环尾 ()

        C流程多余指令 ＝ 取文本右边 (C分割原代码 [C原代码i], 取文本长度 (C分割原代码 [C原代码i]) － C括号i － 1)

        C分割原代码 [C原代码i] ＝ 取文本左边 (C分割原代码 [C原代码i], C括号i)
        .如果真 (到字节集 (C流程多余指令) ≠ { 123, 10 } 且 C流程多余指令 ≠ “ ”)
            C流程多余指令数组 ＝ 分割文本 (C流程多余指令, “;”, )
            C分割原代码 [C原代码i] ＝ C分割原代码 [C原代码i] ＋ #换行符
            .计次循环首 (取数组成员数 (C流程多余指令数组), C括号i)
                调试输出 (C流程多余指令数组 [C括号i], 到字节集 (C流程多余指令数组 [C括号i]))
                .如果真 (C流程多余指令数组 [C括号i] ＝ #换行符 或 C流程多余指令数组 [C括号i] ＝ “” 或 到字节集 (C流程多余指令数组 [C括号i]) ＝ { 10 })
                    到循环尾 ()
                .如果真结束
                C分割原代码 [C原代码i] ＝ C分割原代码 [C原代码i] ＋ 取空白文本 ((C流程指令 ＋ 1) × 4) ＋ C流程多余指令数组 [C括号i] ＋ “;” ＋ #换行符
            .计次循环尾 ()
            C分割原代码 [C原代码i] ＝ 取文本左边 (C分割原代码 [C原代码i], 取文本长度 (C分割原代码 [C原代码i]) － 2)
        .如果真结束
        .如果真 (C否则)
            C分割原代码 [C原代码i] ＝ C分割原代码 [C原代码i] ＋ #换行符 ＋ 取空白文本 (C流程指令 × 4) ＋ “.否则” ＋ #换行符 ＋ 取空白文本 ((C流程指令 ＋ 1) × 4) ＋ #换行符 ＋ 取空白文本 (C流程指令 × 4) ＋ “.如果结束”
            C否则 ＝ 假
        .如果真结束

    .如果真结束


    .如果真 (寻找文本 (C分割原代码 [C原代码i], “}”, , 假) ≠ -1)
        .如果 (寻找文本 (C分割原代码 [C原代码i], “} else {”, , 假) ≠ -1)
            C分割原代码 [C原代码i] ＝ 子文本替换 (C分割原代码 [C原代码i], “} else {”, “.否则” ＋ #换行符 ＋ 取空白文本 (C流程指令 × 4), , 1, 真)
            C否则 ＝ 真
            C流程指令 ＝ C流程指令 － 1
        .否则

            .如果真 (C流程指令 － 到整数 (C话阔) ＞ 0 或 C流程 或 C否则)
                调试输出 (C分割原代码 [C原代码i])
                C分割原代码 [C原代码i] ＝ 子文本替换 (C分割原代码 [C原代码i], “}”, “.如果结束”, , 1, 真)
                C话阔 ＝ 真
            .如果真结束

        .如果结束

    .如果真结束
    .如果真 (C话阔)
        C流程指令 ＝ C流程指令 － 1
        C话阔 ＝ 假
    .如果真结束

    C原代码 ＝ C原代码 ＋ 取空白文本 (C流程指令 × 4) ＋ 解析命令 (C分割原代码 [C原代码i]) ＋ #换行符
    .如果真 (C流程)
        C流程指令 ＝ C流程指令 ＋ 1
        C流程 ＝ 假
    .如果真结束
    .如果真 (C否则)
        C流程指令 ＝ C流程指令 ＋ 1
        C否则 ＝ 假
    .如果真结束


.计次循环尾 ()
E代码 ＝ “.子程序 ” ＋ C子程序名称 ＋ “,” ＋ C子程序返回类型 ＋ #换行符
.计次循环首 (取数组成员数 (C参数名), E代码i)
    E代码 ＝ E代码 ＋ “.参数 ” ＋ C参数名 [E代码i] ＋ “,” ＋ C参数类型 [E代码i] ＋ “,” ＋ C参数数组 [E代码i] ＋ “,” ＋ C参数备注 [E代码i] ＋ #换行符
.计次循环尾 ()
.计次循环首 (取数组成员数 (C局部变量名), E代码i)
    E代码 ＝ E代码 ＋ “.局部变量 ” ＋ C局部变量名 [E代码i] ＋ “,” ＋ C局部变量类型 [E代码i] ＋ “,” ＋ “,” ＋ C局部变量数组 [E代码i] ＋ #换行符
.计次循环尾 ()
.计次循环首 (取数组成员数 (C局部变量初始值), E代码i)
    .如果真 (C局部变量初始值 [E代码i] ＝ “0”)
        到循环尾 ()
    .如果真结束
    .如果真 (C局部变量初始值 [E代码i] ＝ “NULL”)
        到循环尾 ()
    .如果真结束
    .如果真 (C局部变量初始值 [E代码i] ＝ “FALSE”)
        到循环尾 ()
    .如果真结束

    E代码 ＝ E代码 ＋ C局部变量名 [E代码i] ＋ “ = ” ＋ C局部变量初始值 [E代码i] ＋ #换行符
.计次循环尾 ()
替换符号命令 (E代码)
替换符号命令 (C原代码)

调试输出 (E代码 ＋ C原代码)

.子程序 判断类型, 文本型
.参数 类型, 文本型
.参数 a, , 可空

类型 ＝ 到大写 (类型)
.判断开始 (类型 ＝ “BOOL”)
    返回 (“逻辑型”)
.判断 (类型 ＝ “HANDLE”)
    返回 (“整数型”)
.判断 (类型 ＝ “INT”)
    返回 (“整数型”)
.判断 (类型 ＝ “DWORD”)
    返回 (“整数型”)
.判断 (类型 ＝ “STRING”)
    返回 (“文本型”)
.判断 (类型 ＝ “BYTE”)
    返回 (“字节型”)
.判断 (类型 ＝ “VOID”)
    返回 (“ ”)
.判断 (类型 ＝ “HMODULE”)
    返回 (“整数型”)
.判断 (类型 ＝ “CHAR”)
    返回 (“字节型”)
.判断 (类型 ＝ “FLOAT”)
    返回 (“小数型”)
.默认

.判断结束
返回 (类型)

.子程序 判断数组, 文本型, , ' 本源码来自三叶资源网(www.sanye.cx)
.参数 代码, 文本型, 参考
.局部变量 结束位置, 整数型
.局部变量 起始位置, 整数型
.局部变量 数值, 文本型
.局部变量 返回文本, 文本型

.循环判断首 ()
    起始位置 ＝ 寻找文本 (代码, “[”, 起始位置, 假)
    结束位置 ＝ 寻找文本 (代码, “]”, 起始位置, 假)
    .如果真 (起始位置 ＝ -1)
        跳出循环 ()
    .如果真结束
    数值 ＝ 取文本中间 (代码, 起始位置 ＋ 1, 结束位置 － 起始位置 － 1)
    代码 ＝ 子文本替换 (代码, “[” ＋ 数值 ＋ “]”, , , , 真)
    .如果真 (到大写 (数值) ＝ “SECURITY_MAX_SID_SIZE”)
        返回文本 ＝ “0,”
        跳出循环 ()
    .如果真结束
    返回文本 ＝ 返回文本 ＋ 数值 ＋ “,”
.循环判断尾 (真)
返回文本 ＝ 取文本左边 (返回文本, 取文本长度 (返回文本) － 1)
返回 (选择 (返回文本 ＝ “”, “”, #引号 ＋ 返回文本 ＋ #引号))

.子程序 判断是否为关键词, 逻辑型
.参数 代码, 文本型

代码 ＝ 到大写 (代码)
.判断开始 (代码 ＝ “RETURN”)
    返回 (真)
.判断 (代码 ＝ “CASE”)
    返回 (真)
.默认

.判断结束
返回 (假)

.子程序 解析命令, 文本型
.参数 代码, 文本型
.局部变量 中间, 文本型
.局部变量 位置, 整数型

.循环判断首 ()
    位置 ＝ 寻找文本 (代码, “& ”, , 假)
    .如果真 (位置 ≠ -1)
        中间 ＝ 取文本中间 (代码, 位置 ＋ 取文本长度 (“& ”), 取文本长度 (代码) － 位置)
        中间 ＝ 判断终止符 (中间)
        代码 ＝ 子文本替换 (代码, “& ” ＋ 中间, “取变量数据地址(” ＋ 中间 ＋ “)”, , , 真)
        到循环尾 ()
    .如果真结束
    位置 ＝ 寻找文本 (代码, “sizeof(”, , 假)
    .如果真 (位置 ≠ -1)
        中间 ＝ 取文本中间 (代码, 位置 ＋ 取文本长度 (“sizeof(”), 取文本长度 (代码) － 位置)
        中间 ＝ 判断终止符 (中间)
        代码 ＝ 子文本替换 (代码, “sizeof(” ＋ 中间, “取字节集长度(到字节集(” ＋ 中间 ＋ “))”, , , 真)
        到循环尾 ()
    .如果真结束

.循环判断尾 (位置 ≠ -1)
返回 (代码)

.子程序 判断终止符, 文本型, , ' 本源码来自三叶资源网(www.sanye.cx)
.参数 参数, 文本型
.局部变量 i
.局部变量 括号, 逻辑型
.局部变量 长度
.局部变量 字符, 文本型
.局部变量 括号个数, 整数型

长度 ＝ 取文本长度 (参数)
.计次循环首 (长度, i)
    字符 ＝ 取文本中间 (参数, i, 1)
    .如果真 (字符 ＝ “(”)
        括号 ＝ 真
    .如果真结束
    .判断开始 (括号)
        .如果真 (字符 ＝ “(”)
            括号个数 ＝ 括号个数 ＋ 1
        .如果真结束
        .如果真 (字符 ＝ “)”)
            括号个数 ＝ 括号个数 － 1
            .如果真 (括号个数 ＝ 0)
                跳出循环 ()
            .如果真结束

        .如果真结束
        ' 本源码来自三叶资源网(www.sanye.cx)
    .默认
        .如果真 (字符 ＝ “,”)
            跳出循环 ()
        .如果真结束
        .如果真 (字符 ＝ “)”)
            跳出循环 ()
        .如果真结束

    .判断结束

.计次循环尾 ()

返回 (取文本左边 (参数, i － 1))

.子程序 替换符号命令
.参数 文本, 文本型, 参考

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

文本 ＝ 子文本替换 (文本, “if(”, “.如果(”, , , 假)
文本 ＝ 子文本替换 (文本, “if (”, “.如果(”, , , 假)

文本 ＝ 子文本替换 (文本, “=TRUE;”, “= 真”, , , 假)
文本 ＝ 子文本替换 (文本, “=FALSE;”, “= 假”, , , 假)

文本 ＝ 子文本替换 (文本, “= TRUE;”, “= 真”, , , 假)
文本 ＝ 子文本替换 (文本, “= FALSE;”, “= 假”, , , 假)

文本 ＝ 子文本替换 (文本, “TRUE)”, “真)”, , , 假)
文本 ＝ 子文本替换 (文本, “FALSE)”, “假)”, , , 假)

文本 ＝ 子文本替换 (文本, “==TRUE”, “= 真”, , , 假)
文本 ＝ 子文本替换 (文本, “==FALSE”, “= 假”, , , 假)

文本 ＝ 子文本替换 (文本, “== TRUE”, “= 真”, , , 假)
文本 ＝ 子文本替换 (文本, “== FALSE”, “= 假”, , , 假)

文本 ＝ 子文本替换 (文本, “return ”, “返回”, , , 假)
文本 ＝ 子文本替换 (文本, “return (”, “返回(”, , , 假)

文本 ＝ 子文本替换 (文本, “ || ”, “ 且 ”, , , 假)
文本 ＝ 子文本替换 (文本, “ && ”, “ 或 ”, , , 假)

文本 ＝ 子文本替换 (文本, “->”, “.”, , , 假)
文本 ＝ 子文本替换 (文本, “ - > ”, “.”, , , 假)

.子程序 删除空白数组
.参数 数组, 文本型, 参考 数组
.局部变量 i
.局部变量 删除个数, 整数型

.计次循环首 (取数组成员数 (数组), i)
    .如果真 (数组 [i － 删除个数] ＝ “”)
        删除成员 (数组, i － 删除个数, 1)
        删除个数 ＝ 删除个数 ＋ 1
    .如果真结束

.计次循环尾 ()

.子程序 _格式子程序_被单击

编辑框1.内容 ＝ 子文本替换 (网页_JS格式化 (编辑框1.内容, 假), “    ”, #换行符, , , 真)

@明月黄籽实况主