如何提取安卓游戏模型文件是IVY格式的，提取图片或者是能单独搞出来_百度知道
如何提取安卓游戏模型文件是IVY格式的，提取图片或者是能单独搞出来
如何提取安卓游戏模型文件 IVY格式的图片或者类似的
提问者采纳
这个可能难度比较大的，你在应用宝里面搜索一下这类软件就在应用宝里面搜索文件提取，看应用宝列举的软件，你看介绍，下载合适的就可以应用宝里面的资源是最齐全的，有软件游戏等资源，应有尽有呢。然后它上面的软件自己都是经过系统的审核，都是正式版本的软件不会自己出现什么不兼容或者冲突的问题，下载很简单在手机上打开应用宝软件搜索你所需要的软件或者游戏，找到下载就可以安装了。也可以通过手机连接电脑端的应用宝软件来下载的，打开PC端的应用宝软件——手机应用。可以通过搜索或者看软件或许游戏的分类来进行下载呢，都是很方便的。还望采纳
提问者评价
其他类似问题
按默认排序
其他2条回答
你好你可以用winRAR或者其他解压文件，直接解压apk安装包即可一般在media文件夹下希望可以帮到您，望采纳腾讯电脑管家企业平台：
葫芦侠理有你可以去看看！亲！！！
可以再说具体一点吗
安卓游戏的相关知识
等待您来回答
下载知道APP
随时随地咨询
出门在外也不愁您现在的位置：&&>>&&>>&&>>&&>>&正文
eclipse打开当前文件所在文件夹的方法
&&& 1.安装EasyExplorer插件，有了这个插件就可以很方便地打开资源文件所在的文件夹了。&&& &&& EasyExplorer 从 sourceforge.net/projects/easystruts，直接将该jar文件放置在eclipse的 plugin 目录下 ,然后重启eclipse平台就可以在右键中看到East Explorer菜单项，就可以打开资源所在的目录了。&&& &&& 2.eclipse打开当前文件所在文件夹的插件&&& &&& Run--&External Tools--&External Tools Configurations…&&& &&& new 一个 program&&& &&& location 里面填 :C:/WINDOWS/explorer.exe&&& &&& Arguments 里面填： ${container_loc} , （没有实验过）
【责编:ivy】
?&[]?&[]?&[]?&[]?&[]?&[]?&[]?&[]?&[]?&[]
相关产品和培训
　友情推荐链接
　认证培训
　专题推荐
　?　?　?　?　?　?　?　?　?　?
　今日更新
?&?&?&?&?&?&?&?&?&?&
　社区讨论
　博客论点
　频道精选
　Java 频道导航8 相关软件 40.5M/中文/4.5 7.6M/中文/6.1 9.0M/中文/5.0顶好评:50%踩坏评:50请简要描述您遇到的错误，我们将尽快予以修正。轮坛转帖HTML方式轮坛转帖UBB方式
536.3M/中文/6.1
87.1M/中文/8.9
27.8M/中文/3.2
5.03G/多国语言[中文]/4.1
985KB/中文/5.7
1.60G/中文/3.7
95.4M/中文/3.4
2007r2是CAXA电子图板的最新版本，它在继承了电子图板的诸多优点的基础上又多方采纳广大使用者的意见和需求，使其更加贴近工程设计人员的设计习惯，它具有以下特点：低成本运行环境，高速度图形显示；全中文人机界面，自由的定制操作；符合标准的开放体系，全方面开放的开发平台；快捷的交互方式，直观的拖画设计；动态导航定位。在操作习惯、数据接口方面与兼容，图库符合最新国标并增加了6000多各图符，提供更多快捷绘图的手段并在打印排版等多个方面有较大的改进，该版本具有&多快好省，兼容AutoCAD&的特点。
绿色软件特别提示：
1）安装时，序列号可以任意填写！
2）安装完后，将此&Eb.exe&文件替换 CAXA安装目录bin下即&X:\CAXA\CAXAEB\bin&的同名文件即可。
caxa电子图板cad软件排行榜
电子图板是具有完全自主知识产权的二维软件，是中国软件行业协会优秀软件产品。电子图板的界面和操作习惯完全与完全一致，快速地直接打开编辑存储各版本文档，并可实现图纸的双向和批量转换。除提供基本图元绘制功能
caxa2013电子图板包括二维CAD和三
CAXA电子图板文件浏览器主要用于
利用补丁轻松去除软件的试用时间
全中文人机界面易学易用、界面友
&本软件为 CAXA 电子图板 X
&CAXA电子图板2007r2是CAXA
西西软件园给大家分享优秀的软件,西西小编做了一个软件排行榜,软件下载免费中文版,软件市场很大,很多用户不知道如何选择,如果是非常专业的肯定首选软件,但是安装体积很大,对于不怎么太大需求的童鞋来说不方便，那么还
AutoCAD2007是目前工程人员使用的
AutoCAD.2008简体中文版(内含注册
每年3月autodesk都会发布autocad
著名设计软件AutoCAD 已经升级到
AutoCAD Electrical是面向电气控
 借助世界领先的二维和三维
CAXA电子图板2007 简体中文企业破解版
下载帮助西西破解版软件均来自互联网, 如有侵犯您的版权, 请与我们联系。人生就像一副复杂拼图每个人总有属於自己的记忆碎片|||
Olinescript 3.0 界面部分预览
$int:a,b=1+1
$int:tt,gg=11
$str:cv,fd=+
$str:df=++”fuck”+”shit”
$str:dfg=++”fuck”+”shitr”
自定义数据类型
stu a($int:$str:$bol:fv)
解释器核心代码公开:
.支持库 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, )
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, )
置返回值到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, )
置返回值到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, )
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, )
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 长度”, 到文本 (常量长度), 到文本 (行数), )
去标识符 ＝ 取文本中间 (删常量空, 常量长度, )
置返回值到IDE (“conast 删除token”, 去标识符, 到文本 (行数), )
等于位置 ＝ 寻找文本 (去标识符, “=”, , 假)
.如果 (取文本右边 (去标识符, 1) ＝ “=”)
置返回值到IDE (“conast 语法越境 on line ”, , 到文本 (行数), 到文本 (行数))
.如果 (等于位置 ＝ -1)
置返回值到IDE (“conast 语法越境 on line ”, , 到文本 (行数), 到文本 (行数))
分割布尔常量1 ＝ 分割文本 (去标识符, “=”, )
' 取变量名
置返回值到IDE (“conast 被分割”, 分割布尔常量1 [1], 到文本 (行数), )
取常量布尔值 ＝ 取文本中间 (去标识符, 取文本长度 (分割布尔常量1 [1] ＋ “=”) ＋ 1, )
置返回值到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:$str:$bol:fv)
数据类型删空 ＝ 到半角 (删首尾空 (被解析自定义数据类型))
置返回值到IDE (“structure 开始工作”, 数据类型删空, 到文本 (行数))
.如果 (取代码行文本首关键字 (数据类型删空, #数据类型) ＝ #数据类型)
stu标识符长度 ＝ 取文本长度 (#数据类型)
置返回值到IDE (“structure token长度”, 到文本 (stu标识符长度), 到文本 (行数))
去标识符stu ＝ 取文本中间 (数据类型删空, stu标识符长度 ＋ 1, )
置返回值到IDE (“structure 被删除token”, 去标识符stu, 到文本 (行数))
第一个括号位置 ＝ 寻找文本 (去标识符stu, “(”, , 假)
.如果 (取文本右边 (去标识符stu, 1) ＝ “)”)
.如果 (第一个括号位置 ≠ -1)
数据类型名后长 ＝ 取文本长度 (去标识符stu) － 第一个括号位置
置返回值到IDE (“structure 名称后长度”, 到文本 (数据类型名后长), 到文本 (行数))
数据类型名 ＝ 取文本左边 (去标识符stu, 第一个括号位置 － 1)
置返回值到IDE (“structure 名称”, 数据类型名, 到文本 (行数))
写配置项 (写入目录, 数据类型名, “”, “”)
数据类型名后 ＝ 取文本中间 (去标识符stu, 取文本长度 (数据类型名) ＋ 1, )
置返回值到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, 错误行)
解释器核心支持库源码公开
.支持库 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 且 取文本右边 (源文本, 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, )
连等号文本长度 ＝ 取文本长度 (取等号后所有文本)
删引号之后文本 ＝ 取指定文本 (取等号后所有文本, #脚本引号, #脚本引号)
返回 (删引号之后文本 ＋ “{---**---}” ＋ 到文本 (连等号文本长度 ＋ 1))
.子程序 判断有无引号, 逻辑型
.参数 源文本, 文本型
.局部变量 等于号位置2, 整数型
.局部变量 引号位置2, 整数型
等于号位置2 ＝ 寻找文本 (源文本, “=”, , 假)
引号位置2 ＝ 寻找文本 (源文本, #脚本引号, 等于号位置2, 假)
.如果 (引号位置2 ＝ 等于号位置2 ＋ 1 且 取文本右边 (源文本, 1) ＝ #脚本引号)
.子程序 常量_判断两边是否为引号, 逻辑型, , 真符合
.参数 愿文本, 文本型
.如果 (取文本右边 (愿文本, 1) ＝ #脚本引号 且 取文本左边 (愿文本, 1) ＝ #脚本引号)
.子程序 常量_取引号内文本, 文本型
.参数 原文本, 文本型
返回 (取指定文本 (原文本, #脚本引号, #脚本引号))
CONSOLE编译器源码公开
.支持库 iext
.程序集 console调试器_编译器类, , 公开
.子程序 _初始化, , , 当基于本类的对象被创建后，此方法会被自动调用
.子程序 _销毁, , , 当基于本类的对象被销毁前，此方法会被自动调用
.子程序 调试器_开始调试, 整数型, 公开, 0成功 1失败
.参数 dos源代码, 文本型
.参数 目录, 文本型, , 要包含文件名
.如果 (写到文件 (目录, 到字节集 (dos源代码)) ＝ 真)
.子程序 编译器_开始编译, 整数型, 公开, 0成功 1失败
.参数 写入路径, 文本型
.参数 源代码, 文本型
.如果 (写到文件 (写入路径, #pe ＋ 到字节集 (源代码)) ＝ 真)
.子程序 置编译返回自到IDE, , 公开
.参数 返回信息, 文本型
.局部变量 y, 整数型
y ＝ _启动窗口.回显列表框.插入表项 (, “”, , , , )
_启动窗口.回显列表框.置标题 (y, 0, 返回信息)
IDE源码公开
.支持库 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执行 (“”)
.如果真结束
.如果真 (按钮索引 ＝ 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, “解释器停止失败”)
新建程序源码公开
.支持库 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公开
.DLL命令 SHCreateDirectoryExA, 整数型, &shell32.dll&, &SHCreateDirectoryExA&, , 创建文件夹
.参数 窗口句柄, 整数型, , hwnd
.参数 路径, 文本型, , pszPath
.参数 参数, 整数型, , psa，any
.DLL命令 ShellExecuteA, 整数型, , &ShellExecuteA&, , 执行命令
.参数 hwnd, 整数型
.参数 lpOperation, 文本型
.参数 lpFile, 文本型
.参数 lpParameters, 文本型
.参数 lpDirectory, 文本型
.参数 nShowCmd, 短整数型