IVY DOM


 

人生就像一副复杂拼图
每个人总有属於自己的记忆碎片
优质美国空间-老薛主机|IVY DOM|Flowline|

联系我

RSS




十一月 18, 2011

OlineScript

Olinescript 3.0 界面部分预览

变量

$int:a,b=1+1
$int:c=2
$int:t
$int:tt,gg=11
$str:cv,fd=”111″
$str:df=”111″+”fuck”+”shit”
$str:dfg=”111″+”fuck”+”shitr”

常量

const a=0

自定义数据类型

stu a($int:ac;$str:cd;$bol:fv)

解释器核心代码公开:

.版本 2
.支持库 script
.支持库 iext

.程序集 零线脚本解释器类, , 公开
.程序集变量 自动代码, 文本型

.子程序 _初始化, , , 当基于本类的对象被创建后,此方法会被自动调用

.子程序 _销毁, , , 当基于本类的对象被销毁前,此方法会被自动调用

.子程序 变量解析器, , 公开
.参数 被解析变量, 文本型
.参数 行数, 整数型
.参数 脚本组件, 脚本组件
.参数 目录, 文本型, , 涉资保存基本配置文件的目录
.参数 方法, 整数型, , 1普通变量 2 数据类型
.参数 数据类型名, 文本型, 可空, 为数据类型准备
.局部变量 backint, 文本型, , , 整数型变量后半部分内容
.局部变量 backstr, 文本型, , , 文本型变量后半部分内容
.局部变量 backbol, 文本型, , , 布尔型变量后半部分内容
.局部变量 arrybol, 文本型, , "0", 布尔数组
.局部变量 casebol, 文本型, , , 半角后bool变量
.局部变量 jhbol, 文本型, , , 解析后的变量
.局部变量 tespbol, 文本型, , "0", 分割被解析后的多bool变量
.局部变量 itespbol, 整数型, , , 计次被解析bool变量循环次数
.局部变量 withebol, 文本型, , , 带有等于号的被解析变量
.局部变量 iwespbol, 整数型, , , 计次带等于被解析变量循环次数
.局部变量 whespbol, 文本型, , "0", 分割被解析后的带有等于多bol变量
.局部变量 caseint, 文本型, , , 半角int变量
.局部变量 jbint, 文本型, , , 解析后的int变量
.局部变量 tespint, 文本型, , "0", 分割被解析后的多int变量
.局部变量 itespint, 整数型, , , 计次被解析int变量循环次数
.局部变量 witheint, 文本型, , "0", 分割带=的int变量
.局部变量 whejbint, 文本型, , , 解析带等于号的int多变量
.局部变量 whespint, 文本型, , "0", 分割被解析后的带有等于多int变量
.局部变量 iwhspint, 整数型, , , 计次带等于被解析int变量循环次数
.局部变量 删空之后, 文本型
.局部变量 cASESTR, 文本型
.局部变量 jbpstr, 文本型
.局部变量 tespstr, 文本型, , "0"
.局部变量 itespstr, 整数型
.局部变量 yhconten, 文本型, , , 引号内内容储存变量
.局部变量 bestr, 文本型
.局部变量 spbestr, 文本型, , "0", 分割引号内内容返回信息
.局部变量 wejbpstr, 文本型
.局部变量 wrtepstr, 文本型, , "0"
.局部变量 iwtepstr, 整数型
.局部变量 wespstr, 文本型
.局部变量 有等于str, 文本型
.局部变量 有等于str多, 文本型

删空之后 = 删首尾空 (被解析变量)
置返回值到IDE (到文本 (行数) + “次处理”, 删空之后, 到文本 (行数))
.如果真 (取代码行文本首关键字 (删空之后, #varstr) = #varstr)  ' 如果是声明字符串型变量段
    backint = 取文本中间 (删空之后, 取文本长度 (#varstr) + 1, 100000000)
    cASESTR = 删首尾空 (到半角 (backint))
    置返回值到IDE (“str 类型变量首次被处理=”, cASESTR, 到文本 (行数))
    .如果 (解析引号_有等于号的情况 (cASESTR) = 真)  ' 有等于号且有引号的情况
        置返回值到IDE (“str 类型变量符合语法”, “true”, 到文本 (行数))
        yhconten = 获取引号内内容 (cASESTR)
        置返回值到IDE (“str 类型变量符合语法”, yhconten, 到文本 (行数))
        spbestr = 分割文本 (yhconten, “{---**---}”, )
        bestr = 取文本左边 (cASESTR, 取文本长度 (cASESTR) - 到数值 (spbestr [2]))
        置返回值到IDE (“str 类型变量名称”, bestr, 到文本 (行数))
        .如果 (寻找文本 (bestr, “,”, , 假) = -1)  ' 检测有没有多变量声明,无等于号部分
            .如果 (方法 = 1)
                写配置项 (目录, “varstr”, bestr, 四则运算 (spbestr [1], 脚本组件))  ' 直接写出变量名
            .否则
                写配置项 (目录, 数据类型名, bestr, 四则运算 (spbestr [1], 脚本组件))  ' 直接写出变量名
            .如果结束

            ' -----------------------运算部分------------------------
            有等于str = 取文本中间 (cASESTR, 取文本长度 (bestr) + 2, 10000000000)
            置返回值到IDE (“str 类型赋值”, 有等于str, 到文本 (行数))
            .如果 (方法 = 1)
                写配置项 (目录, “varstr”, bestr, 四则运算 (有等于str, 脚本组件))
            .否则
                写配置项 (目录, 数据类型名, bestr, 四则运算 (有等于str, 脚本组件))
            .如果结束

            ' -----------------------运算部分------------------------

        .否则
            wejbpstr = 解析一行多变量声明 (bestr)
            置返回值到IDE (“str 类型变量符合语法”, jbpstr, 到文本 (行数))
            wrtepstr = 分割文本 (wejbpstr, “{{-*-}}”, )
            .计次循环首 (取数组成员数 (wrtepstr), iwtepstr)
                置返回值到IDE (“str 值被得到”, wrtepstr [iwtepstr], 到文本 (行数))
                .如果 (方法 = 1)
                    写配置项 (目录, “varstr”, wrtepstr [iwtepstr], 四则运算 (spbestr [1], 脚本组件))
                .否则
                    写配置项 (目录, 数据类型名, wrtepstr [iwtepstr], 四则运算 (spbestr [1], 脚本组件))
                .如果结束
                ' -----------------------运算部分------------------------
                有等于str多 = 取文本中间 (cASESTR, 取文本长度 (wrtepstr [iwtepstr]) + 2, 10000000000)
                置返回值到IDE (“str 赋值更多”, 有等于str多, 到文本 (行数))
                .如果 (方法 = 1)
                    写配置项 (目录, “varstr”, wrtepstr [iwtepstr], 四则运算 (有等于str多, 脚本组件))
                .否则
                    写配置项 (目录, 数据类型名, wrtepstr [iwtepstr], 四则运算 (有等于str多, 脚本组件))
                .如果结束
                ' -----------------------运算部分------------------------
            .计次循环尾 ()
        .如果结束

    .否则
        .如果 (判断有无引号 (cASESTR) = 真)
            .如果 (寻找文本 (cASESTR, “,”, , 假) = -1)  ' 检测有没有多变量声明,无等于号部分
                .如果 (方法 = 1)
                    写配置项 (目录, “varstr”, cASESTR, “”)  ' 直接写出变量名
                .否则
                    写配置项 (目录, 数据类型名, cASESTR, “”)  ' 直接写出变量名
                .如果结束

            .否则
                jbpstr = 解析一行多变量声明 (cASESTR)
                置返回值到IDE (“str 类型变量符合语法”, jbpstr, 到文本 (行数))
                tespstr = 分割文本 (jbpstr, “{{-*-}}”, )
                .计次循环首 (取数组成员数 (tespstr), itespstr)
                    置返回值到IDE (“str 值被得到”, tespstr [itespstr], 到文本 (行数))
                    .如果 (方法 = 1)
                        写配置项 (目录, “varstr”, tespstr [itespstr], “”)
                    .否则
                        写配置项 (目录, 数据类型名, tespstr [itespstr], “”)
                    .如果结束

                .计次循环尾 ()
            .如果结束

        .否则
            置返回值到IDE (“str 类型变量赋值时不能没有引号”, , 到文本 (行数), 到文本 (行数))
            .如果 (方法 = 1)
                写配置项 (目录, “varstr”, cASESTR, “”)
            .否则
                写配置项 (目录, 数据类型名, cASESTR, “”)
            .如果结束

        .如果结束

    .如果结束

.如果真结束
.如果真 (取代码行文本首关键字 (删空之后, #varint) = #varint)  ' 如果是声明整数型变量段
    backstr = 取文本中间 (删空之后, 取文本长度 (#varint) + 1, 100000000)
    caseint = 删首尾空 (到半角 (backstr))
    置返回值到IDE (“int 类型变量首次处理”, caseint, 到文本 (行数))
    .如果 (寻找文本 (caseint, “=”, , 假) = -1)  ' 如果没找到等于号
        .如果 (寻找文本 (caseint, “,”, , 假) = -1)  ' 检测有没有多变量声明,这里为没有
            .如果 (方法 = 1)
                写配置项 (目录, “varint”, caseint, “”)  ' 直接写出变量名
            .否则
                写配置项 (目录, 数据类型名, caseint, “”)  ' 直接写出变量名
            .如果结束

        .否则
            jbint = 解析一行多变量声明 (caseint)
            置返回值到IDE (, jbint, 到文本 (行数))
            tespint = 分割文本 (jbint, “{{-*-}}”, )
            .计次循环首 (取数组成员数 (tespint), itespint)
                置返回值到IDE (“int 值被得到”, tespint [itespint], 到文本 (行数))
                .如果 (方法 = 1)
                    写配置项 (目录, “varint”, tespint [itespint], “”)
                .否则
                    写配置项 (目录, 数据类型名, tespint [itespint], “”)
                .如果结束

            .计次循环尾 ()
        .如果结束

    .否则
        witheint = 分割文本 (caseint, “=”, )
        .如果 (取数组成员数 (witheint) > 2)  ' 如果成员数大于2
            置返回值到IDE (“语法越境 on line”, , 到文本 (行数), 到文本 (行数))
        .否则
            .如果 (寻找文本 (witheint [1], “,”, , 假) = -1)  ' 解析变量部分
                .如果 (判断是否为整数 (witheint [2]) = 真)
                    .如果 (方法 = 1)
                        写配置项 (目录, “varint”, witheint [1], 四则运算 (witheint [2], 脚本组件))
                    .否则
                        写配置项 (目录, 数据类型名, witheint [1], 四则运算 (witheint [2], 脚本组件))
                    .如果结束

                .否则
                    .如果 (判断是否有运算符号 (四则运算 (witheint [2], 脚本组件)) = 1)
                        .如果 (方法 = 1)
                            写配置项 (目录, “varint”, witheint [1], 四则运算 (witheint [2], 脚本组件))
                        .否则
                            写配置项 (目录, 数据类型名, witheint [1], 四则运算 (witheint [2], 脚本组件))
                        .如果结束

                    .否则
                        ' _启动窗口.回显框.加入文本 (“beyond int's structure on line ” + 到文本 (行数) + #换行符)
                        置返回值到IDE (“int 变量语法越境 on line”, , 到文本 (行数), 到文本 (行数))
                    .如果结束

                .如果结束

            .否则
                whejbint = 解析一行多变量声明 (witheint [1])
                置返回值到IDE (, whejbint, 到文本 (行数), )
                whespint = 分割文本 (whejbint, “{{-*-}}”, )
                .计次循环首 (取数组成员数 (whespint), iwhspint)
                    .如果 (判断是否为整数 (四则运算 (witheint [2], 脚本组件)) = 真)
                        .如果 (方法 = 1)
                            写配置项 (目录, “varint”, whespint [iwhspint], 四则运算 (witheint [2], 脚本组件))
                        .否则
                            写配置项 (目录, 数据类型名, whespint [iwhspint], 四则运算 (witheint [2], 脚本组件))
                        .如果结束

                    .否则
                        置返回值到IDE (“int 变量语法越境 on line”, , 到文本 (行数), 到文本 (行数))
                        跳出循环 ()
                    .如果结束

                .计次循环尾 ()
            .如果结束

        .如果结束

    .如果结束

.如果真结束
.如果真 (取代码行文本首关键字 (删空之后, #varbol) = #varbol)  ' 如果是声明布尔型变量段
    backbol = 取文本中间 (删空之后, 取文本长度 (#varbol) + 1, 100000000)
    casebol = 删首尾空 (到半角 (backbol))
    置返回值到IDE (“bol 类型变量首次处理”, casebol, 到文本 (行数), )
    .如果 (寻找文本 (casebol, “=”, , 假) = -1)  ' 如果没找到等于号
        .如果 (寻找文本 (casebol, “,”, , 假) = -1)  ' 检测有没有多变量声明,这里为没有
            .如果 (方法 = 1)
                写配置项 (目录, “varbol”, casebol, “”)
            .否则
                写配置项 (目录, 数据类型名, casebol, “”)
            .如果结束

        .否则
            jhbol = 解析一行多变量声明 (casebol)
            置返回值到IDE (, jhbol, 到文本 (行数), )
            tespbol = 分割文本 (jhbol, “{{-*-}}”, )
            .计次循环首 (取数组成员数 (tespbol), itespbol)
                置返回值到IDE (“bol 类型变量值被得到”, tespbol [itespbol], 到文本 (行数), )
                .如果 (方法 = 1)
                    写配置项 (目录, “varbol”, tespbol [itespbol], “”)
                .否则
                    写配置项 (目录, 数据类型名, tespbol [itespbol], “”)
                .如果结束

            .计次循环尾 ()
        .如果结束

    .否则
        arrybol = 分割文本 (casebol, “=”, )  ' 如果找到等于号就分割
        .如果 (取数组成员数 (arrybol) > 2)  ' 如果成元数大于2
            置返回值到IDE (“bol变量语法越境 on line”, , 到文本 (行数), 到文本 (行数))
        .否则
            .如果 (arrybol [2] = “true” 或 arrybol [2] = “false”)
                .如果 (寻找文本 (casebol, “,”, , 假) ≠ -1)  ' 检测有没有多变量声明,这里为有
                    withebol = 解析一行多变量声明 (arrybol [1])
                    置返回值到IDE (, withebol, 到文本 (行数), )
                    whespbol = 分割文本 (withebol, “{{-*-}}”, )
                    .计次循环首 (取数组成员数 (whespbol), iwespbol)
                        .如果 (方法 = 1)
                            写配置项 (目录, “varbol”, whespbol [iwespbol], arrybol [2])  ' 写入各项变量值
                        .否则
                            写配置项 (目录, 数据类型名, whespbol [iwespbol], arrybol [2])  ' 写入各项变量值
                        .如果结束

                    .计次循环尾 ()
                .否则
                    .如果 (方法 = 1)
                        写配置项 (目录, “varbol”, arrybol [1], arrybol [2])
                    .否则
                        写配置项 (目录, 数据类型名, arrybol [1], arrybol [2])
                    .如果结束

                .如果结束

            .否则
                置返回值到IDE (“bol变量语法越境 on line”, , 到文本 (行数), 到文本 (行数))
            .如果结束

        .如果结束

    .如果结束

.如果真结束

.子程序 数组解析器, , 公开
.参数 被解析数组, 文本型
.参数 行数, 整数型

.子程序 常量解析器, , 公开
.参数 行数, 整数型
.参数 被解析常量, 文本型
.参数 目录, 文本型
.局部变量 删常量空, 文本型
.局部变量 常量长度, 整数型
.局部变量 去标识符, 文本型
.局部变量 等于位置, 整数型
.局部变量 分割布尔常量1, 文本型, , "0"
.局部变量 分割布尔常量2, 文本型, , "0"
.局部变量 集合布尔常量, 文本型
.局部变量 ijhbolcon, 整数型, , , 集合布尔变量整合计数器
.局部变量 取常量布尔值, 文本型
.局部变量 str引号内文本, 文本型

' const a=""
' const a=11
' const a=true
删常量空 = 到半角 (删首尾空 (被解析常量))
置返回值到IDE (“conast 首次处理”, 删常量空, 到文本 (行数), )
.如果真 (取代码行文本首关键字 (删常量空, #conast) = #conast)  ' 如果是声明常量段
    常量长度 = 取文本长度 (#conast) + 1
    置返回值到IDE (“conast 长度”, 到文本 (常量长度), 到文本 (行数), )
    去标识符 = 取文本中间 (删常量空, 常量长度, 10000000000)
    置返回值到IDE (“conast 删除token”, 去标识符, 到文本 (行数), )
    等于位置 = 寻找文本 (去标识符, “=”, , 假)
    .如果 (取文本右边 (去标识符, 1) = “=”)
        置返回值到IDE (“conast 语法越境 on line ”, , 到文本 (行数), 到文本 (行数))
    .否则
        .如果 (等于位置 = -1)
            置返回值到IDE (“conast 语法越境 on line ”, , 到文本 (行数), 到文本 (行数))
        .否则
            分割布尔常量1 = 分割文本 (去标识符, “=”, )  ' 取变量名
            置返回值到IDE (“conast 被分割”, 分割布尔常量1 [1], 到文本 (行数), )
            取常量布尔值 = 取文本中间 (去标识符, 取文本长度 (分割布尔常量1 [1] + “=”) + 1, 10000000000)
            置返回值到IDE (“conast l”, 取常量布尔值, 到文本 (行数), )
            .如果 (取常量布尔值 = “true”)
                写配置项 (目录, “conastbol”, 分割布尔常量1 [1], “true”)
            .否则
                .如果 (取常量布尔值 = “false”)
                    写配置项 (目录, “conastbol”, 分割布尔常量1 [1], “false”)
                .否则
                    .如果 (判断是否为整数 (取常量布尔值) = 真)
                        写配置项 (目录, “conastint”, 分割布尔常量1 [1], 取常量布尔值)
                    .否则
                        .如果 (常量_判断两边是否为引号 (取常量布尔值) = 真)
                            str引号内文本 = 常量_取引号内文本 (取常量布尔值)
                            置返回值到IDE (“conaststr l”, str引号内文本, 到文本 (行数), )
                            写配置项 (目录, “conaststr”, 分割布尔常量1 [1], str引号内文本)
                        .否则
                            置返回值到IDE (“conast 语法越境”, , 到文本 (行数), 到文本 (行数))
                        .如果结束

                    .如果结束

                .如果结束

            .如果结束

        .如果结束

    .如果结束

.如果真结束

.子程序 自定义数据类型解析器, , 公开
.参数 行数, 整数型
.参数 被解析自定义数据类型, 文本型
.参数 脚本_数据类型, 脚本组件
.参数 写入目录, 文本型
.局部变量 数据类型删空, 文本型
.局部变量 stu标识符长度, 整数型
.局部变量 去标识符stu, 文本型
.局部变量 第一个括号位置, 整数型
.局部变量 数据类型名后长, 整数型
.局部变量 数据类型名, 文本型
.局部变量 数据类型名后, 文本型
.局部变量 去右括号, 文本型
.局部变量 去左括号, 文本型
.局部变量 int位置, 整数型
.局部变量 分割分号, 文本型, , "0"
.局部变量 计次数据类型, 整数型

' stu a($int:ac;$str:cd;$bol:fv)
数据类型删空 = 到半角 (删首尾空 (被解析自定义数据类型))
置返回值到IDE (“structure 开始工作”, 数据类型删空, 到文本 (行数))
.如果 (取代码行文本首关键字 (数据类型删空, #数据类型) = #数据类型)
    stu标识符长度 = 取文本长度 (#数据类型)
    置返回值到IDE (“structure token长度”, 到文本 (stu标识符长度), 到文本 (行数))
    去标识符stu = 取文本中间 (数据类型删空, stu标识符长度 + 1, 1000000000)
    置返回值到IDE (“structure 被删除token”, 去标识符stu, 到文本 (行数))
    第一个括号位置 = 寻找文本 (去标识符stu, “(”, , 假)
    .如果 (取文本右边 (去标识符stu, 1) = “)”)
        .如果 (第一个括号位置 ≠ -1)
            数据类型名后长 = 取文本长度 (去标识符stu) - 第一个括号位置
            置返回值到IDE (“structure 名称后长度”, 到文本 (数据类型名后长), 到文本 (行数))
            数据类型名 = 取文本左边 (去标识符stu, 第一个括号位置 - 1)
            置返回值到IDE (“structure 名称”, 数据类型名, 到文本 (行数))
            写配置项 (写入目录, 数据类型名, “”, “”)
            数据类型名后 = 取文本中间 (去标识符stu, 取文本长度 (数据类型名) + 1, 100000000000)
            置返回值到IDE (“structure 名称后”, 数据类型名后, 到文本 (行数))
            去右括号 = 子文本替换 (数据类型名后, “)”, , 取文本长度 (数据类型名后), 1, 真)
            去左括号 = 子文本替换 (去右括号, “(”, , 1, 1, 真)
            置返回值到IDE (“structure 删除右”, 去左括号, 到文本 (行数))
            int位置 = 寻找文本 (去左括号, “$int:”, , 假)
            置返回值到IDE (“structure int点”, 到文本 (int位置), 到文本 (行数))
            分割分号 = 分割文本 (去左括号, “;”, )
            .计次循环首 (取数组成员数 (分割分号), 计次数据类型)
                变量解析器 (分割分号 [计次数据类型], 计次数据类型, 脚本_数据类型, 写入目录, 2, 数据类型名)
            .计次循环尾 ()
        .否则
            置返回值到IDE (“structure 声明时找不到左括号”, , 到文本 (行数), 到文本 (行数))
        .如果结束

    .否则
        置返回值到IDE (“structure 声明时找不到右括号”, , 到文本 (行数), 到文本 (行数))
    .如果结束

.否则

.如果结束

.子程序 函数解析器, , 公开
.参数 所在行, 整数型
.参数 行文本, 文本型
.参数 脚本组件, 脚本组件
.局部变量 清空函数首位空白, 文本型

清空函数首位空白 = 删首尾空 (行文本)
' 置返回值到IDE (“Function 首次处理”, 清空函数首位空白, 到文本 (所在行))
.' 如果 (取代码行文本首关键字 (清空函数首位空白, “msgbox”) = “msgbox”)
    脚本组件.执行 (清空函数首位空白)
.否则

.如果结束

.子程序 整体调用解析器, , 公开

.子程序 变量数组调用解析器, , 公开

.子程序 置返回值到IDE, , 公开
.参数 正文, 文本型, 可空
.参数 处理值, 文本型, 可空
.参数 运行行, 文本型, 可空
.参数 错误行, 文本型, 可空
.局部变量 x, 整数型

x = _启动窗口.回显列表框.插入表项 (, “”, , , , )
_启动窗口.回显列表框.置标题 (x, 0, 正文)
_启动窗口.回显列表框.置标题 (x, 1, 处理值)
_启动窗口.回显列表框.置标题 (x, 2, 运行行)
_启动窗口.回显列表框.置标题 (x, 3, 错误行)

解释器核心支持库源码公开

.版本 2
.支持库 script

.程序集 零线解释器支持库

.子程序 解析一行多变量声明, 文本型, , 返回被解析文本
.参数 变量名文本, 文本型
.局部变量 ivatstr, 整数型
.局部变量 分割多变量, 文本型, , "0"
.局部变量 result, 文本型

分割多变量 = 分割文本 (变量名文本, “,”, )
.计次循环首 (取数组成员数 (分割多变量), ivatstr)
    result = result + 分割多变量 [ivatstr] + “{{-*-}}”
.计次循环尾 ()
返回 (result)

.子程序 取代码行文本首关键字, 文本型
.参数 原文本, 文本型
.参数 关键字, 文本型

返回 (取文本左边 (原文本, 取文本长度 (关键字)))

.子程序 判断是否为整数, 逻辑型, , 真全是数字,假有非数字
.参数 字符串, 文本型
.局部变量 文本长度, 整数型
.局部变量 iint, 整数型
.局部变量 最后, 整数型
.局部变量 save, 文本型

文本长度 = 取文本长度 (字符串)
.计次循环首 (文本长度, iint)
    最后 = 取代码 (取文本中间 (字符串, iint, 1), 1)
    .如果 (最后 ≥ 48 且 最后 ≤ 57)
        save = save + 到文本 (1)
    .否则
        save = save + 到文本 (0)
    .如果结束

.计次循环尾 ()
.如果 (寻找文本 (save, “0”, , 假) ≠ -1)
    返回 (假)
.否则
    返回 (真)
.如果结束

.子程序 判断是否有运算符号, 整数型, , 1有,0没有,-1未知
.参数 原文本, 文本型, 参考
.局部变量 分割元文本, 文本型, , "0"
.局部变量 ijjcc, 整数型

分割元文本 = 分割文本 (#加减乘除, “|”, )
.计次循环首 (取数组成员数 (分割元文本), ijjcc)
    .如果 (寻找文本 (原文本, 分割元文本 [ijjcc], , 假) = -1)
        返回 (1)
    .否则
        返回 (0)
    .如果结束

.计次循环尾 ()
返回 (-1)

.子程序 四则运算, 文本型
.参数 原文本, 文本型
.参数 脚本, 脚本组件

返回 (脚本.计算表达式 (原文本))

.子程序 解析引号_有等于号的情况, 逻辑型
.参数 源文本, 文本型
.局部变量 等于号位置, 整数型
.局部变量 引号位置, 整数型

等于号位置 = 寻找文本 (源文本, “=”, , 假)
引号位置 = 寻找文本 (源文本, #脚本引号, 等于号位置, 假)
.如果 (引号位置 = 等于号位置 + 1 且 取文本右边 (源文本, 1) = #脚本引号)
    返回 (真)
.否则
    返回 (假)
.如果结束

.子程序 取指定文本, 文本型
.参数 fulltext, 文本型
.参数 left, 文本型
.参数 right, 文本型
.局部变量 length, 整数型
.局部变量 lstr, 文本型
.局部变量 lswz, 整数型

length = 取文本长度 (fulltext)
lswz = 寻找文本 (fulltext, left, , 假) + 取文本长度 (left)
lstr = 取文本中间 (fulltext, lswz, length)
length = 取文本长度 (lstr)
lswz = 寻找文本 (lstr, right, , 假) - 1
lstr = 取文本中间 (lstr, 1, lswz)
返回 (lstr)

.子程序 获取引号内内容, 文本型
.参数 源文本, 文本型
.局部变量 取第一个等号位置, 整数型
.局部变量 删引号之后文本, 文本型
.局部变量 取等号后所有文本, 文本型
.局部变量 连等号文本长度, 整数型

' A="==ss"
取第一个等号位置 = 寻找文本 (源文本, “=”, , 假)
取等号后所有文本 = 取文本中间 (源文本, 取第一个等号位置 + 1, 10000000)
连等号文本长度 = 取文本长度 (取等号后所有文本)
删引号之后文本 = 取指定文本 (取等号后所有文本, #脚本引号, #脚本引号)
返回 (删引号之后文本 + “{---**---}” + 到文本 (连等号文本长度 + 1))

.子程序 判断有无引号, 逻辑型
.参数 源文本, 文本型
.局部变量 等于号位置2, 整数型
.局部变量 引号位置2, 整数型

等于号位置2 = 寻找文本 (源文本, “=”, , 假)
引号位置2 = 寻找文本 (源文本, #脚本引号, 等于号位置2, 假)
.如果 (引号位置2 = 等于号位置2 + 1 且 取文本右边 (源文本, 1) = #脚本引号)
    返回 (真)
.否则
    返回 (假)
.如果结束

.子程序 常量_判断两边是否为引号, 逻辑型, , 真符合
.参数 愿文本, 文本型

.如果 (取文本右边 (愿文本, 1) = #脚本引号 且 取文本左边 (愿文本, 1) = #脚本引号)
    返回 (真)
.否则
    返回 (假)
.如果结束

.子程序 常量_取引号内文本, 文本型
.参数 原文本, 文本型

返回 (取指定文本 (原文本, #脚本引号, #脚本引号))

CONSOLE编译器源码公开

.版本 2
.支持库 iext

.程序集 console调试器_编译器类, , 公开

.子程序 _初始化, , , 当基于本类的对象被创建后,此方法会被自动调用

.子程序 _销毁, , , 当基于本类的对象被销毁前,此方法会被自动调用

.子程序 调试器_开始调试, 整数型, 公开, 0成功 1失败
.参数 dos源代码, 文本型
.参数 目录, 文本型, , 要包含文件名

.如果 (写到文件 (目录, 到字节集 (dos源代码)) = 真)
    返回 (0)
.否则
    返回 (1)
.如果结束

.子程序 编译器_开始编译, 整数型, 公开, 0成功 1失败
.参数 写入路径, 文本型
.参数 源代码, 文本型

.如果 (写到文件 (写入路径, #pe + 到字节集 (源代码)) = 真)
    返回 (0)
.否则
    返回 (1)
.如果结束

.子程序 置编译返回自到IDE, , 公开
.参数 返回信息, 文本型
.局部变量 y, 整数型

y = _启动窗口.回显列表框.插入表项 (, “”, , , , )
_启动窗口.回显列表框.置标题 (y, 0, 返回信息)

IDE源码公开

.版本 2
.支持库 iext
.支持库 CodeStyleEdit
.支持库 EThread

.程序集 集成编程环境程序集
.程序集变量 许可证, 整数型

.子程序 解释器开始执行, , , 这里是获取代码框的内容并链接到解释器
.局部变量 iusual, 整数型
.局部变量 行文本, 文本型, , "0"
.局部变量 零线解释器, 零线脚本解释器类
.局部变量 分割返回文本, 文本型, , "0"
.局部变量 isprestr, 整数型
.局部变量 自定义数据类型内容, 文本型
.局部变量 分割自定义数据类型, 文本型, , "0"
.局部变量 istructure, 整数型

回显列表框.全部删除 ()
.如果 (取代码框文本_oline () ≠ “”)
    行文本 = 分割文本 (取代码框文本_oline (), #换行符, )  ' 取得代码行数
    状态条.置文本 (0, “code line=” + 到文本 (取数组成员数 (行文本)))  ' 取得代码行数
    .计次循环首 (取数组成员数 (行文本), iusual)  ' 循环每行文本
        零线解释器.变量解析器 (行文本 [iusual], iusual, script, 通用程序目录 + “basvarcon.olsc”, 1)  ' 开始变量解析
        零线解释器.数组解析器 (行文本 [iusual], iusual)  ' 开始数组解析
        零线解释器.常量解析器 (iusual, 行文本 [iusual], 通用程序目录 + “basvarcon.olsc”)  ' 开始常量解析
        零线解释器.变量数组调用解析器 ()  ' 开始变量数组调用解析
        零线解释器.函数解析器 (iusual, 行文本 [iusual], script)  ' 开始函数解析
    .计次循环尾 ()
.否则
    零线解释器.置返回值到IDE (“代码框不能为空!”)
.如果结束

自定义数据类型内容 = 自定义数据类型框.取文本 (自定义数据类型框.取长度 ())
.如果 (自定义数据类型内容 ≠ “”)
    分割自定义数据类型 = 分割文本 (自定义数据类型内容, #换行符, )
    .计次循环首 (取数组成员数 (分割自定义数据类型), istructure)
        零线解释器.自定义数据类型解析器 (istructure, 分割自定义数据类型 [istructure], script, 通用程序目录 + “\structure.olsc”)  ' 开始自定义数据类型解析
    .计次循环尾 ()
.否则

.如果结束

.子程序 取代码框文本_oline, 文本型

返回 (代码框.取文本 (代码框.取长度 ()))

.子程序 _工具条2_被下拉
.参数 按钮索引, 整数型
.参数 下拉横座标, 整数型
.参数 下拉纵座标, 整数型

.如果真 (按钮索引 = 2)
    弹出菜单 (插入, 下拉横座标, 下拉纵座标)
.如果真结束

.子程序 __启动窗口_创建完毕
.局部变量 任务栏, 整数型

代码框.置旁注栏宽度 (0, 36)
console代码框.置旁注栏宽度 (0, 36)
自定义数据类型框.置旁注栏宽度 (0, 36)
宽度 = 取屏幕宽度 ()
任务栏 = 高度 - 取用户区高度 ()
高度 = 取屏幕高度 () - 任务栏

.子程序 _查找_被选择

查找替换窗口.是否替换 = 假
载入 (查找替换窗口, , 假)

.子程序 _替换_被选择

查找替换窗口.是否替换 = 真
载入 (查找替换窗口, , 假)

.子程序 _工具条2_被单击
.参数 按钮索引, 整数型

.如果真 (按钮索引 = 5)
    _启动_被选择 ()
.如果真结束
.如果真 (按钮索引 = 1)
    _到指定行_被选择 ()
.如果真结束
.如果真 (按钮索引 = 11)
    IDE执行 (“ivysoft.sinaapp.com”)
.如果真结束
.如果真 (按钮索引 = 10)
    _关于_被选择 ()
.如果真结束

.子程序 _工具条1_被单击
.参数 按钮索引, 整数型

.如果真 (按钮索引 = 16)
    _查找_被选择 ()
.如果真结束
.如果真 (按钮索引 = 17)
    _替换_被选择 ()
.如果真结束
.如果真 (按钮索引 = 14)
    代码框.撤消 ()
.如果真结束
.如果真 (按钮索引 = 15)
    代码框.重复 ()
.如果真结束
.如果真 (按钮索引 = 9)
    代码框.剪切 ()
.如果真结束
.如果真 (按钮索引 = 10)
    代码框.重复 ()
.如果真结束
.如果真 (按钮索引 = 11)
    代码框.拷贝 ()
.如果真结束
.如果真 (按钮索引 = 12)
    代码框.粘贴 ()
.如果真结束
.如果真 (按钮索引 = 19)
    ' 帮助
.如果真结束
.如果真 (按钮索引 = 20)
    结束 ()
.如果真结束
.如果真 (按钮索引 = 13)
    ' 删除行
.如果真结束
.如果真 (按钮索引 = 1)
    _打开_被选择 ()
.如果真结束
.如果真 (按钮索引 = 6)
    _另存为_被选择 ()
.如果真结束
.如果真 (按钮索引 = 0)
    _新建_被选择 ()
.如果真结束
.如果真 (按钮索引 = 2)
    _保存_被选择 ()
.如果真结束

.子程序 _启动_被选择

许可证 = 创建进入许可证 ()
.如果真 (IDE编译器解释器状态.状态 = 1)
    进入许可区 (许可证)
    启动线程 (&解释器开始执行, , 许可证)
.如果真结束
.如果真 (IDE编译器解释器状态.状态 = 0)
    进入许可区 (许可证)
    启动线程 (&console调试器开始执行, , 许可证)
.如果真结束

.子程序 _到指定行_被选择
.局部变量 输入内容

.如果真 (输入框 (“请输入行号”, “到指定行”, , 输入内容, #输入整数))
    代码框.到指定行 (输入内容)
.如果真结束

.子程序 _撤销_被选择

代码框.撤消 ()

.子程序 _重复_被选择

代码框.重复 ()

.子程序 _复制_被选择

代码框.拷贝 ()

.子程序 _粘贴_被选择

代码框.粘贴 ()

.子程序 _剪贴_被选择

代码框.剪切 ()

.子程序 _删除行_被选择

.子程序 寻找行数标识符, 整数型
.参数 被搜寻文本, 文本型
.参数 标识符, 文本型

返回 (寻找文本 (被搜寻文本, 标识符, , 假))

.子程序 _变量_被选择
.局部变量 要被加入的变量, 文本型
.局部变量 要被加入的变量值, 文本型
.局部变量 变量类型, 文本型

选择夹1.现行子夹 = 0
输入框 (“请输入变量类型.1为整数型,2为字符串型,3为逻辑布尔型”, “插入变量”, , 变量类型, )
输入框 (“请输入变量名”, “插入变量”, , 要被加入的变量, )
输入框 (“请输入变量值,留空为不添加变量值”, “插入变量”, , 要被加入的变量值, )
.如果 (变量类型 = “1”)
    .如果 (要被加入的变量值 = “”)
        代码框.追加文本 (“$int:” + 要被加入的变量 + #换行符, -1)
    .否则
        代码框.追加文本 (“$int:” + 要被加入的变量 + “=” + 要被加入的变量值 + #换行符, -1)
    .如果结束

.否则

.如果结束

.如果 (变量类型 = “2”)
    .如果 (要被加入的变量值 = “”)
        代码框.追加文本 (“$str:” + 要被加入的变量 + #换行符, -1)
    .否则
        代码框.追加文本 (“$str:” + 要被加入的变量 + “=” + #脚本引号 + 要被加入的变量值 + #脚本引号 + #换行符, -1)
    .如果结束

.否则

.如果结束

.如果 (变量类型 = “3”)
    .如果 (要被加入的变量值 = “”)
        代码框.追加文本 (“$bol:” + 要被加入的变量 + #换行符, -1)
    .否则
        代码框.追加文本 (“$bol:” + 要被加入的变量 + “=” + 要被加入的变量值 + #换行符, -1)
    .如果结束

.否则

.如果结束

.子程序 _打开_被选择
.局部变量 分割文件名, 文本型, , "0"
.局部变量 新目录名, 文本型
.局部变量 处理, 文本型
.局部变量 中间, 文本型
.局部变量 inew, 整数型

.如果真 (IDE编译器解释器状态.状态 = 1)
    打开对话框.过滤器 = “ols文件(*.ols)|*.ols”
    打开对话框.初始目录 = 取运行目录 () + “\data\oline\”
    .如果 (打开对话框.打开 () = 真)
        代码框.清空编辑框 ()
        标题 = “Oline Studio - ” + 打开对话框.文件名
        分割文件名 = 分割文本 (打开对话框.文件名, “\”, )
        .计次循环首 (取数组成员数 (分割文件名), inew)
            .如果 (inew = 取数组成员数 (分割文件名))
                跳出循环 ()
            .否则
                新目录名 = 新目录名 + “\” + 分割文件名 [inew]
                处理 = 新目录名 + “\”
                中间 = 子文本替换 (处理, “\”, “”, 1, 1, 真)
            .如果结束

        .计次循环尾 ()
        连续赋值 (中间, 通用程序目录)
        输出调试文本 (通用程序目录)
        代码框.加入文本 (到文本 (读入文件 (打开对话框.文件名)), -1)
    .否则

    .如果结束

.如果真结束
.如果真 (IDE编译器解释器状态.状态 = 0)
    打开对话框.过滤器 = “olc文件(*.olc)|*.olc”
    打开对话框.初始目录 = 取运行目录 () + “\data\console\”
    .如果 (打开对话框.打开 () = 真)
        console代码框.清空编辑框 ()
        标题 = “Oline Studio - ” + 打开对话框.文件名
        分割文件名 = 分割文本 (打开对话框.文件名, “\”, )
        .计次循环首 (取数组成员数 (分割文件名), inew)
            .如果 (inew = 取数组成员数 (分割文件名))
                跳出循环 ()
            .否则
                新目录名 = 新目录名 + “\” + 分割文件名 [inew]
                处理 = 新目录名 + “\”
                中间 = 子文本替换 (处理, “\”, “”, 1, 1, 真)
            .如果结束

        .计次循环尾 ()
        连续赋值 (中间, 通用程序目录)
        输出调试文本 (通用程序目录)
        console代码框.加入文本 (到文本 (读入文件 (打开对话框.文件名)), -1)
    .否则

    .如果结束

.如果真结束

.子程序 __启动窗口_尺寸被改变
.局部变量 零线脚本界面类, 零线脚本界面类

零线脚本界面类.装备初始化界面 (回显列表框, 代码框, 选择夹1, _启动窗口, 自定义数据类型框, console代码框)

.子程序 _新建_被选择

.如果真 (IDE编译器解释器状态.状态 = 1)
    .如果 (代码框.取文本 (代码框.取长度 ()) ≠ “”)
        保存文件 (取运行目录 () + “\data\oline\” + 通用名 + “\” + 通用名 + “.ols”, 取运行目录 () + “\data\oline\” + 通用名, 代码框)
        代码框.清空编辑框 ()
        载入 (Newpro, , 真)
    .否则
        载入 (Newpro, , 真)
    .如果结束

.如果真结束
.如果真 (IDE编译器解释器状态.状态 = 0)
    .如果 (console代码框.取文本 (console代码框.取长度 ()) ≠ “”)
        保存文件 (取运行目录 () + “\data\console\” + console名 + “\” + console名 + “.olc”, 取运行目录 () + “\data\console\” + console名, console代码框)
        console代码框.清空编辑框 ()
        载入 (Newpro, , 真)
    .否则
        载入 (Newpro, , 真)
    .如果结束

.如果真结束

.子程序 _保存_被选择

.如果真 (IDE编译器解释器状态.状态 = 1)
    .如果 (代码框.取文本 (代码框.取长度 ()) ≠ “”)
        保存文件 (取运行目录 () + “\data\oline\” + 通用名 + “\” + 通用名 + “.ols”, 取运行目录 () + “\data\oline\” + 通用名, 代码框)
    .否则
        信息框 (“源代码不能为空!”, 0, “onlinescript”)
    .如果结束

.如果真结束
.如果真 (IDE编译器解释器状态.状态 = 0)
    .如果 (console代码框.取文本 (console代码框.取长度 ()) ≠ “”)
        保存文件 (取运行目录 () + “\data\console\” + console名 + “\” + console名 + “.olc”, 取运行目录 () + “\data\console\” + console名, console代码框)
    .否则
        信息框 (“源代码不能为空!”, 0, “onlineIDEconsole”)
    .如果结束

.如果真结束

.子程序 保存文件
.参数 参数_文件名, 文本型
.参数 参数_目录名, 文本型
.参数 参数_代码框, 代码编辑框

' 如果 (SHCreateDirectoryExA (_启动窗口.取窗口句柄 (), 参数_目录名, 0) = 0)
.如果 (写到文件 (参数_文件名, 到字节集 (参数_代码框.取文本 (参数_代码框.取长度 ()))) = 真)
    信息框 (“保存成功!”, 0, “onlinescript”)
.否则
    信息框 (“保存失败!”, 0, “onlinescript”)
.如果结束

' 信息框 (“创建目录失败!”, 0, “onlinescript”)

.子程序 _关闭_被选择

.如果真 (IDE编译器解释器状态.状态 = 1)
    .如果 (代码框.取文本 (代码框.取长度 ()) ≠ “”)
        保存文件 (取运行目录 () + “\data\oline\” + 通用名 + “\” + 通用名 + “.ols”, 取运行目录 () + “\data\oline\” + 通用名, 代码框)
        代码框.清空编辑框 ()
    .否则

    .如果结束

.如果真结束
.如果真 (IDE编译器解释器状态.状态 = 0)
    .如果 (console代码框.取文本 (console代码框.取长度 ()) ≠ “”)
        保存文件 (console文件名 + “.olc”, 取运行目录 () + “\data\console\” + console名, console代码框)
        console代码框.清空编辑框 ()
    .否则

    .如果结束

.如果真结束

.子程序 _另存为_被选择

.子程序 _退出_被选择

结束 ()

.子程序 _ifelse_被选择

.子程序 _for_被选择

.子程序 _whiledo_被选择

.子程序 _常量_被选择
.局部变量 要被加入的常量, 文本型
.局部变量 要被加入的常量值, 文本型
.局部变量 常量类型, 文本型

选择夹1.现行子夹 = 0
输入框 (“请输入常量类型.1为整数型,2为字符串型,3为逻辑布尔型”, “插入常量”, , 常量类型, )
输入框 (“请输入常量名”, “插入常量”, , 要被加入的常量, )
输入框 (“请输入常量值,留空为不添加常量值”, “插入常量”, , 要被加入的常量值, )
.如果 (常量类型 = “1”)
    .如果 (要被加入的常量值 = “”)
        代码框.追加文本 (“const ” + 要被加入的常量 + #换行符, -1)
    .否则
        代码框.追加文本 (“const ” + 要被加入的常量 + “=” + 要被加入的常量值 + #换行符, -1)
    .如果结束

.否则

.如果结束

.如果 (常量类型 = “2”)
    .如果 (要被加入的常量值 = “”)
        代码框.追加文本 (“const ” + 要被加入的常量 + #换行符, -1)
    .否则
        代码框.追加文本 (“const ” + 要被加入的常量 + “=” + #脚本引号 + 要被加入的常量值 + #脚本引号 + #换行符, -1)
    .如果结束

.否则

.如果结束

.如果 (常量类型 = “3”)
    .如果 (要被加入的常量值 = “”)
        代码框.追加文本 (“const ” + 要被加入的常量 + #换行符, -1)
    .否则
        代码框.追加文本 (“const ” + 要被加入的常量 + “=” + 要被加入的常量值 + #换行符, -1)
    .如果结束

.否则

.如果结束

.子程序 _自定义数据类型_被选择

选择夹1.现行子夹 = 1
载入 (stu, , 真)

.子程序 _对象浏览器_被选择

.子程序 _系统配置_被选择

.子程序 _按钮1_被单击

.子程序 _关于_被选择

载入 (关于窗口, , 假)

.子程序 __启动窗口_首次激活

载入 (Newpro, , 真)

.子程序 __启动窗口_将被销毁

结束 ()

.子程序 _静态编译_被选择
.局部变量 console编译器类, console调试器_编译器类

.如果 (取代码框文本_console () ≠ “”)
    .如果 (console编译器类.编译器_开始编译 (通用程序目录 + console名 + “.exe”, 取代码框文本_console ()) = 0)
        console编译器类.置编译返回自到IDE (“编译成功!”)
        .如果 (信息框 (“是否立即运行?”, #是否钮, “idos”) = #是钮)
            运行 (console文件名, 假, )
        .否则

        .如果结束

    .否则
        console编译器类.置编译返回自到IDE (“编译失败!”)
    .如果结束

.否则

.如果结束

.子程序 console调试器开始执行
.局部变量 console调试器类, console调试器_编译器类

.如果 (取代码框文本_console () ≠ “”)
    .如果 (console调试器类.调试器_开始调试 (取代码框文本_console (), console文件名) = 0)
        运行 (console文件名, 假, )
    .否则
        console调试器类.置编译返回自到IDE (“调试器链接出现问题!”)
    .如果结束

.否则
    console调试器类.置编译返回自到IDE (“代码不能为空!”)
.如果结束

.子程序 取代码框文本_console, 文本型

返回 (console代码框.取文本 (console代码框.取长度 ()))

.子程序 _打开当前目录_被选择

IDE执行 (通用程序目录)

.子程序 _停止_被选择

.如果 (强制结束线程 (许可证) = 真)
    状态条.置文本 (0, “解释器已停止”)
.否则
    状态条.置文本 (0, “解释器停止失败”)
.如果结束

新建程序源码公开

.版本 2
.支持库 iext
.支持库 CodeStyleEdit

.程序集 新建窗口程序集
.程序集变量 是否结束, 逻辑型

.子程序 _按钮2_被单击

结束 ()

.子程序 _Newpro_将被销毁

.如果 (是否结束 = 真)
    结束 ()
.否则
    销毁 ()
.如果结束

.子程序 _按钮3_被单击

.如果真 (选择夹1.现行子夹 = 0)
    IDE编译器解释器状态.状态 = 1
.如果真结束
.如果真 (选择夹1.现行子夹 = 1)
    IDE编译器解释器状态.状态 = 0
.如果真结束

是否结束 = 假
_打开_被选择 ()
_Newpro_将被销毁 ()

.子程序 _Newpro_创建完毕

是否结束 = 真

.子程序 _按钮1_被单击
.局部变量 hw工程名, 文本型
.局部变量 bt工程名, 文本型
.局部变量 bthw工程名, 文本型
.局部变量 pt工程名, 文本型

是否结束 = 假
.如果真 (通用介绍.现行选中项 = 0)
    输入框 (“请输入工程名称”, “工程名将作为源代码保存目录名称”, , hw工程名, )
    .如果 (hw工程名 ≠ “”)
        .如果 (SHCreateDirectoryExA (取窗口句柄 (), 取运行目录 () + “\data\oline\” + hw工程名, 0) = 0)
            通用程序目录 = 取运行目录 () + “\data\oline\” + hw工程名 + “\”
            .如果 (写到文件 (通用程序目录 + hw工程名 + “.ols”, 到字节集 (#helloworld)) = 真)
                置OLShelloworld程序 ()
                _启动窗口.标题 = “Oline Studio - ” + 通用程序目录 + hw工程名 + “.ols” + “ - 通用介绍[ols HelloWorld]程序”
                IDE编译器解释器状态.状态 = 1
                pt工程名 = hw工程名
                _Newpro_将被销毁 ()
            .否则
                信息框 (“新建工程出现不明错误!”, 16, “错误”)
            .如果结束

        .否则
            信息框 (“新建文件夹发生错误!请从新启动本程序”, 16, “错误”)
        .如果结束

    .否则
        信息框 (“工程名不能为空!”, 16, “错误”)
        _按钮1_被单击 ()
    .如果结束

.如果真结束
.如果真 (通用基本.现行选中项 = 1)
    输入框 (“请输入工程名称”, “工程名将作为源代码保存目录名称”, , bt工程名, )
    .如果 (bt工程名 ≠ “”)
        .如果 (SHCreateDirectoryExA (取窗口句柄 (), 取运行目录 () + “\data\console\” + bt工程名, 0) = 0)
            通用程序目录 = 取运行目录 () + “\data\console\” + bt工程名 + “\”
            _启动窗口.标题 = “Oline Studio - ” + 通用程序目录 + bt工程名 + “.bat” + “ - 通用基本[console]程序”
            初始化consleIDE ()
            console文件名 = 通用程序目录 + bt工程名 + “.bat”
            IDE编译器解释器状态.状态 = 0
            console名 = bt工程名
            _Newpro_将被销毁 ()
        .否则
            信息框 (“新建文件夹发生错误!请从新启动本程序”, 16, “错误”)
        .如果结束

    .否则
        信息框 (“工程名不能为空!”, 16, “错误”)
        _按钮1_被单击 ()
    .如果结束

.如果真结束
.如果真 (通用介绍.现行选中项 = 1)
    输入框 (“请输入工程名称”, “工程名将作为源代码保存目录名称”, , bthw工程名, )
    .如果 (bthw工程名 ≠ “”)
        .如果 (SHCreateDirectoryExA (取窗口句柄 (), 取运行目录 () + “\data\console\” + bthw工程名, 0) = 0)
            通用程序目录 = 取运行目录 () + “\data\console\” + bthw工程名 + “\”
            .如果 (写到文件 (通用程序目录 + bthw工程名 + “.bat”, 到字节集 (#bathw)) = 真)
                置CONSOLEhelloworld程序 ()
                初始化consleIDE ()
                _启动窗口.标题 = “Oline Studio - ” + 通用程序目录 + bthw工程名 + “.bat” + “ - 通用介绍[console HelloWorld]程序”
                console文件名 = 通用程序目录 + bthw工程名 + “.bat”
                IDE编译器解释器状态.状态 = 0
                console名 = bthw工程名
                _Newpro_将被销毁 ()
            .否则
                信息框 (“新建工程出现不明错误!”, 16, “错误”)
            .如果结束

        .否则
            信息框 (“新建文件夹发生错误!请从新启动本程序”, 16, “错误”)
        .如果结束

    .否则
        信息框 (“工程名不能为空!”, 16, “错误”)
        _按钮1_被单击 ()
    .如果结束

.如果真结束
.如果真 (通用基本.现行选中项 = 0)
    输入框 (“请输入工程名称”, “工程名将作为源代码保存目录名称”, , pt工程名, )
    .如果 (pt工程名 ≠ “”)
        .如果 (SHCreateDirectoryExA (取窗口句柄 (), 取运行目录 () + “\data\oline\” + pt工程名, 0) = 0)
            通用程序目录 = 取运行目录 () + “\data\oline\” + pt工程名 + “\”
            _启动窗口.标题 = “Oline Studio - ” + 通用程序目录 + pt工程名 + “.bat” + “ - 通用基本[olinescript]程序”
            初始化olinescriptIDE ()
            IDE编译器解释器状态.状态 = 1
            通用名 = pt工程名
            _Newpro_将被销毁 ()
        .否则
            信息框 (“新建文件夹发生错误!请从新启动本程序”, 16, “错误”)
        .如果结束

    .否则
        信息框 (“工程名不能为空!”, 16, “错误”)
        _按钮1_被单击 ()
    .如果结束

.如果真结束

.子程序 初始化consleIDE

_启动窗口.静态编译.禁止 = 假
_启动窗口.自定义数据类型框.可视 = 假
_启动窗口.代码框.可视 = 假
_启动窗口.选择夹1.置子夹名称 (1, “console应用(MS-DOS)”)
_启动窗口.选择夹1.置子夹名称 (2, “暂时搁置”)
_启动窗口.console代码框.左边 = 2
_启动窗口.console代码框.顶边 = 24
_启动窗口.console代码框.可视 = 真
_启动窗口.插入.禁止 = 真
_启动窗口.变量.禁止 = 真
_启动窗口.ifelse.禁止 = 真
_启动窗口.for.禁止 = 真
_启动窗口.常量.禁止 = 真
_启动窗口.自定义数据类型.禁止 = 真
_启动窗口.whiledo.禁止 = 真

.子程序 初始化olinescriptIDE

_启动窗口.静态编译.禁止 = 真
_启动窗口.自定义数据类型框.可视 = 真
_启动窗口.代码框.可视 = 真
_启动窗口.选择夹1.置子夹名称 (1, “常规程序集”)
_启动窗口.选择夹1.置子夹名称 (2, “自定义数据类型(structure)”)
_启动窗口.console代码框.可视 = 假
_启动窗口.插入.禁止 = 假
_启动窗口.变量.禁止 = 假
_启动窗口.ifelse.禁止 = 假
_启动窗口.for.禁止 = 假
_启动窗口.常量.禁止 = 假
_启动窗口.自定义数据类型.禁止 = 假
_启动窗口.whiledo.禁止 = 假

.子程序 _按钮4_被单击

是否结束 = 假
销毁 ()

用到的API公开

.版本 2

.DLL命令 SHCreateDirectoryExA, 整数型, "shell32.dll", "SHCreateDirectoryExA", , 创建文件夹
    .参数 窗口句柄, 整数型, , hwnd
    .参数 路径, 文本型, , pszPath
    .参数 参数, 整数型, , psa,any

.DLL命令 ShellExecuteA, 整数型, , "ShellExecuteA", , 执行命令
    .参数 hwnd, 整数型
    .参数 lpOperation, 文本型
    .参数 lpFile, 文本型
    .参数 lpParameters, 文本型
    .参数 lpDirectory, 文本型
    .参数 nShowCmd, 短整数型
    • ivy
    • 六月 15th, 2012

    现在就还剩最后一项逻辑推理没完成了!!期待吧各位

  1. 强大

  2. 噗居然就没有外国人看到这里你真是败了~
    虽然这货是新出的~

  3. 这是啥?

  4. 哈哈做得很不错呐

  5. 这是一门逻辑编程语言和它的IDE,INTERPRETER

    • GW
    • 七月 13th, 2012

    快折腾吧

  6. 额 我了去

    现在高中生 都牛逼了

  7. 中文编程语言 还是你写的伪代码

    • leepood
    • 十月 22nd, 2014

    挺有意思的

  1. 暂无 Trackback

You must be logged in to post a comment.