通用内存修改器+注入器源码
.版本 2
.支持库 iext
.程序集 窗口程序集1
.程序集变量 停止搜索, 逻辑型
.程序集变量 搜索结果, 整数型, , "0"
.程序集变量 列表框_十六进制, 逻辑型
.子程序 _窗口1_鼠标左键被按下1, 逻辑型, , 事件拦截
.参数 横向位置, 整数型
.参数 纵向位置, 整数型
.参数 功能键状态, 整数型
鼠标显示 ()
返回 (真)
.子程序 _窗口1_位置被改变
.如果真 (位置 ＝ 2)
位置 ＝ 1
可视 ＝ 假
.如果真结束
.子程序 _窗口1_可否被关闭, 逻辑型
位置 ＝ 1
可视 ＝ 假
返回 (假)
.子程序 _窗口1_创建完毕
宽度 ＝ 412
高度 ＝ 317
鼠标显示 ()
内存操作.提升权限 ()
内存操作.打开进程 ()
编辑框_结束地址.内容 ＝ 到文本 (到数值 (&RunDllHostCallBack))
事件拦截.鼠标左键被按下 (取窗口句柄 (), &_窗口1_鼠标左键被按下1)
监视热键 (&回调热键事件, #Home键)
.子程序 回调热键事件
可视 ＝ 真
.子程序 _组合框_搜索类型_列表项被选择, , , 搜索功能区
.判断开始 (组合框_搜索类型.现行选中项 ＝ 0)
编辑框_搜索数据.输入方式 ＝ 7 ' 输入整数
.判断 (组合框_搜索类型.现行选中项 ＝ 1)
编辑框_搜索数据.输入方式 ＝ 8 ' 输入长整数
.判断 (组合框_搜索类型.现行选中项 ＝ 2)
编辑框_搜索数据.输入方式 ＝ 9 ' 输入小数
.判断 (组合框_搜索类型.现行选中项 ＝ 3)
编辑框_搜索数据.输入方式 ＝ 10 ' 输入双精度小数
.默认
编辑框_搜索数据.输入方式 ＝ 0 ' 输入文本
.判断结束
.子程序 _组合框_搜索类型2_列表项被选择
.判断开始 (组合框_搜索类型2.现行选中项 ＝ 5)
编辑框_搜索数据.输入方式 ＝ 0 ' 输入文本
.判断 (组合框_搜索类型2.现行选中项 ＝ 4)
编辑框_搜索数据.输入方式 ＝ 7 ' 输入整数
.默认
_组合框_搜索类型_列表项被选择 ()
.判断结束
.子程序 获取搜索数据, 字节集
.局部变量 待搜索数据, 字节集
.判断开始 (组合框_搜索类型2.现行选中项 ＝ 4)
待搜索数据 ＝ 到字节集 (到整数 (编辑框_搜索数据.内容))
.判断 (组合框_搜索类型2.现行选中项 ＝ 5)
待搜索数据 ＝ 到字节集 (编辑框_搜索数据.内容)
.判断 (组合框_搜索类型.现行选中项 ＝ 0)
待搜索数据 ＝ 到字节集 (到整数 (编辑框_搜索数据.内容))
.判断 (组合框_搜索类型.现行选中项 ＝ 1)
待搜索数据 ＝ 到字节集 (到长整数 (编辑框_搜索数据.内容))
.判断 (组合框_搜索类型.现行选中项 ＝ 2)
待搜索数据 ＝ 到字节集 (到小数 (编辑框_搜索数据.内容))
.判断 (组合框_搜索类型.现行选中项 ＝ 3)
待搜索数据 ＝ 到字节集 (到数值 (编辑框_搜索数据.内容))
.判断 (组合框_搜索类型.现行选中项 ＝ 4)
待搜索数据 ＝ 到字节集 (编辑框_搜索数据.内容)
.判断 (组合框_搜索类型.现行选中项 ＝ 5)
.如果 (取文本左边 (编辑框_搜索数据.内容, 1) ＝ “{”)
待搜索数据 ＝ 还原字节集 (编辑框_搜索数据.内容)
.否则
待搜索数据 ＝ 还原字节集2 (编辑框_搜索数据.内容)
.如果结束
.默认
.判断结束
返回 (待搜索数据)
.子程序 _按钮_开始搜索_被单击
.如果真 (按钮_开始搜索.标题 ＝ “<初始>”)
连续赋值 (假, 按钮_开始搜索.禁止, 组合框_搜索类型.禁止, 组合框_搜索类型2.禁止, 组合框_搜索类型2.可视, 编辑框_搜索数据.禁止, 按钮_智能搜集.禁止, 编辑框_搜集代码.可视, 组合框_显示数据类型.可视)
连续赋值 (真, 按钮_再次搜索.禁止, 按钮_智能搜集.可视)
组合框_搜索类型2.现行选中项 ＝ 0
超级列表框1.全部删除 ()
按钮_开始搜索.标题 ＝ “首次搜索”
编辑框_搜索数据.内容 ＝ “”
.如果真结束
.如果真 (编辑框_搜索数据.内容 ＝ “”)
编辑框_搜索数据.获取焦点 ()
标签_搜索.标题 ＝ “请您输入待搜索的数据→”
标签_搜索.文本颜色 ＝ #红色
返回 ()
.如果真结束
按钮_智能搜集.禁止 ＝ 真
按钮_智能搜集.可视 ＝ 假
按钮_停止.可视 ＝ 真
搜索内存并显示 (真)
.子程序 搜索内存并显示
.参数 是否首次搜索, 逻辑型, 可空
.局部变量 计次, 整数型
.局部变量 时间, 整数型
.局部变量 结果数目, 整数型
.局部变量 索引, 整数型
时间 ＝ 取启动时间 ()
进度条1.位置 ＝ 0
超级列表框1.全部删除 ()
标签_搜索.文本颜色 ＝ #绿色
标签_搜索.标题 ＝ “正在进行搜索...”
停止搜索 ＝ 假
连续赋值 (真, 按钮_开始搜索.禁止, 按钮_再次搜索.禁止, 组合框_搜索类型.禁止, 组合框_搜索类型2.禁止, 编辑框_搜索数据.禁止)
.如果 (是否首次搜索)
.判断开始 (单选框1.选中)
索引 ＝ 0
.判断 (单选框2.选中)
索引 ＝ 1
.判断 (单选框3.选中)
索引 ＝ 2
.判断 (单选框4.选中)
索引 ＝ 3
.判断 (单选框5.选中)
索引 ＝ 4
.判断 (单选框6.选中)
索引 ＝ 十六到十 (编辑框_首次搜索偏移量.内容)
.默认
.判断结束
组合框_搜索类型2.可视 ＝ 真
结果数目 ＝ 内存操作.搜索 (获取搜索数据 (), 搜索结果, &回调进度, 到整数 (编辑框_起始地址.内容), 到整数 (编辑框_结束地址.内容), 索引, 选择框_深入搜索.选中)
.否则
.判断开始 (组合框_搜索类型2.现行选中项 ＝ 1)
索引 ＝ -4
.判断 (组合框_搜索类型2.现行选中项 ＝ 2)
索引 ＝ -3
.判断 (组合框_搜索类型2.现行选中项 ＝ 3)
索引 ＝ -2
.判断 (组合框_搜索类型2.现行选中项 ＝ 4)
索引 ＝ -5
.判断 (组合框_搜索类型2.现行选中项 ＝ 5)
索引 ＝ -6
.默认
索引 ＝ -1
.判断结束
结果数目 ＝ 内存操作.再次搜索 (获取搜索数据 (), 搜索结果, &回调进度, 索引)
.如果结束
.如果 (列表框_十六进制) ' 10进制为真 16进制为假
.计次循环首 (选择 (结果数目 ＞ 3000, 3000, 结果数目), 计次) ' 只显示5000个到列表
.如果 (内存操作.是否静态地址 (搜索结果 [计次]))
.如果 (内存操作.是否基址 (搜索结果 [计次]))
索引 ＝ 1
.否则
索引 ＝ 0
.如果结束
超级列表框1.插入表项 (0, 十到十六 (搜索结果 [计次], 真), 索引, , , 搜索结果 [计次])
.否则
超级列表框1.插入表项 (-1, 十到十六 (搜索结果 [计次], 真), -1, , , 搜索结果 [计次])
.如果结束
.计次循环尾 ()
.否则
.计次循环首 (选择 (结果数目 ＞ 5000, 5000, 结果数目), 计次)
.如果 (内存操作.是否静态地址 (搜索结果 [计次]))
.如果 (内存操作.是否基址 (搜索结果 [计次]))
索引 ＝ 1
.否则
索引 ＝ 0
.如果结束
超级列表框1.插入表项 (0, 十到十六 (搜索结果 [计次], 真), 索引, , , 搜索结果 [计次])
.否则
超级列表框1.插入表项 (-1, 十到十六 (搜索结果 [计次], 真), -1, , , 搜索结果 [计次])
.如果结束
.计次循环尾 ()
.如果结束
.判断开始 (组合框_搜索类型.现行选中项 ＝ 0)
超级列表框1.置列标题 (1, “整数”)
超级列表框1.置列宽 (1, 100)
.判断 (组合框_搜索类型.现行选中项 ＝ 1)
超级列表框1.置列标题 (1, “长整数”)
超级列表框1.置列宽 (1, 160)
.判断 (组合框_搜索类型.现行选中项 ＝ 2)
超级列表框1.置列标题 (1, “小数”)
超级列表框1.置列宽 (1, 100)
.判断 (组合框_搜索类型.现行选中项 ＝ 3)
超级列表框1.置列标题 (1, “双精度小数”)
超级列表框1.置列宽 (1, 160)
.判断 (组合框_搜索类型.现行选中项 ＝ 4)
超级列表框1.置列标题 (1, “文本”)
超级列表框1.置列宽 (1, 100)
.判断 (组合框_搜索类型.现行选中项 ＝ 5)
超级列表框1.置列标题 (1, “字节集”)
超级列表框1.置列宽 (1, 200)
.默认
.判断结束
组合框_显示数据类型.现行选中项 ＝ 组合框_搜索类型.现行选中项 ＋ 1
组合框_显示数据类型.可视 ＝ 真
标签_搜索.标题 ＝ “搜索结果：” ＋ 到文本 (结果数目) ＋ “ 用时：” ＋ 到文本 (取启动时间 () － 时间) ＋ “毫秒”
按钮_开始搜索.标题 ＝ “<初始>”
连续赋值 (假, 按钮_开始搜索.禁止, 按钮_再次搜索.禁止, 组合框_搜索类型2.禁止, 编辑框_搜索数据.禁止, 按钮_停止.可视)
_组合框_搜索类型_列表项被选择 ()
选择夹_内存.现行子夹 ＝ 0
.子程序 回调进度, 逻辑型
.参数 进度, 整数型
进度条1.位置 ＝ 进度
返回 (停止搜索)
.子程序 _按钮_再次搜索_被单击
搜索内存并显示 ()
.子程序 _按钮_智能搜集_被单击
.如果真 (编辑框_搜索数据.内容 ＝ “”)
编辑框_搜索数据.获取焦点 ()
标签_搜索.标题 ＝ “请您输入待搜索的数据→”
标签_搜索.文本颜色 ＝ #红色
返回 ()
.如果真结束
创建线程 (&智能搜集线程)
.子程序 智能搜集线程
.局部变量 结果代码, 文本型, , "0"
.局部变量 计次, 整数型
.局部变量 时间, 整数型
.局部变量 索引, 整数型
时间 ＝ 取启动时间 ()
进度条1.位置 ＝ 0
超级列表框1.全部删除 ()
标签_搜索.文本颜色 ＝ #绿色
标签_搜索.标题 ＝ “正在进行智能搜集...”
停止搜索 ＝ 假
连续赋值 (真, 编辑框_搜集代码.可视, 按钮_智能搜集.禁止, 按钮_开始搜索.禁止, 组合框_搜索类型.禁止, 组合框_搜索类型2.禁止, 编辑框_搜索数据.禁止, 按钮_停止.可视)
.判断开始 (单选框1.选中)
索引 ＝ 0
.判断 (单选框2.选中)
索引 ＝ 1
.判断 (单选框3.选中)
索引 ＝ 2
.判断 (单选框4.选中)
索引 ＝ 3
.判断 (单选框5.选中)
索引 ＝ 4
.判断 (单选框6.选中)
索引 ＝ 十六到十 (编辑框_首次搜索偏移量.内容)
.默认
.判断结束
.计次循环首 (内存操作.搜集代码 (获取搜索数据 (), 结果代码, &回调进度, 到整数 (编辑框_起始地址.内容), 到整数 (编辑框_结束地址.内容)), 计次)
编辑框_搜集代码.加入文本 (结果代码 [计次] ＋ #换行符)
.计次循环尾 ()
标签_搜索.标题 ＝ “搜索结果：” ＋ 到文本 (取数组成员数 (结果代码)) ＋ “ 用时：” ＋ 到文本 (取启动时间 () － 时间) ＋ “毫秒”
按钮_开始搜索.标题 ＝ “<初始>”
连续赋值 (假, 按钮_开始搜索.禁止, 按钮_停止.可视)
选择夹_内存.现行子夹 ＝ 0
.子程序 _按钮_停止_被单击
停止搜索 ＝ 真
连续赋值 (假, 按钮_开始搜索.禁止, 组合框_搜索类型.禁止, 组合框_搜索类型2.禁止, 组合框_搜索类型2.可视, 编辑框_搜索数据.禁止, 按钮_智能搜集.禁止, 编辑框_搜集代码.可视, 按钮_停止.可视)
连续赋值 (真, 按钮_再次搜索.禁止, 按钮_智能搜集.可视)
超级列表框1.全部删除 ()
按钮_开始搜索.标题 ＝ “首次搜索”
选择夹_内存.现行子夹 ＝ 0
.子程序 _组合框_显示数据类型_列表项被选择
.局部变量 当前文本, 文本型
当前文本 ＝ 组合框_显示数据类型.取项目文本 (组合框_显示数据类型.现行选中项)
超级列表框1.置列标题 (1, 当前文本)
.判断开始 (当前文本 ＝ “整数”)
超级列表框1.置列宽 (1, 100)
.判断 (当前文本 ＝ “长整数”)
超级列表框1.置列宽 (1, 160)
.判断 (当前文本 ＝ “小数”)
超级列表框1.置列宽 (1, 100)
.判断 (当前文本 ＝ “双精度小数”)
超级列表框1.置列宽 (1, 160)
.判断 (当前文本 ＝ “文本”)
超级列表框1.置列宽 (1, 100)
.判断 (当前文本 ＝ “字节集”)
超级列表框1.置列宽 (1, 200)
.默认
超级列表框1.置列宽 (1, 160)
.判断结束
编辑框_搜索数据.获取焦点 ()
.子程序 _超级列表框1_表头被单击
.参数 被单击列索引, 整数型
.局部变量 计次, 整数型
.局部变量 临时地址, 文本型
.如果真 (被单击列索引 ＝ 0)
.如果 (超级列表框1.取列标题 (0) ＝ “地址(10进制)”)
.计次循环首 (超级列表框1.取表项数 (), 计次)
超级列表框1.置标题 (计次 － 1, 0, 十到十六 (超级列表框1.取表项数值 (计次 － 1), 真))
.计次循环尾 ()
超级列表框1.置列标题 (0, “地址(16进制)”)
列表框_十六进制 ＝ 真
.否则
.计次循环首 (超级列表框1.取表项数 (), 计次)
超级列表框1.置标题 (计次 － 1, 0, 到文本 (超级列表框1.取表项数值 (计次 － 1)))
.计次循环尾 ()
超级列表框1.置列标题 (0, “地址(10进制)”)
列表框_十六进制 ＝ 假
.如果结束
.如果真结束
.如果真 (被单击列索引 ＝ 1)
.判断开始 (超级列表框1.取列标题 (1) ＝ “数据(字符串)”)
超级列表框1.置列标题 (1, “整数”)
超级列表框1.置列宽 (1, 100)
.判断 (超级列表框1.取列标题 (1) ＝ “整数”)
超级列表框1.置列标题 (1, “长整数”)
超级列表框1.置列宽 (1, 160)
.判断 (超级列表框1.取列标题 (1) ＝ “长整数”)
超级列表框1.置列标题 (1, “小数”)
超级列表框1.置列宽 (1, 100)
.判断 (超级列表框1.取列标题 (1) ＝ “小数”)
超级列表框1.置列标题 (1, “双精度小数”)
超级列表框1.置列宽 (1, 160)
.判断 (超级列表框1.取列标题 (1) ＝ “双精度小数”)
超级列表框1.置列标题 (1, “文本”)
超级列表框1.置列宽 (1, 100)
.判断 (超级列表框1.取列标题 (1) ＝ “文本”)
超级列表框1.置列标题 (1, “字节集”)
超级列表框1.置列宽 (1, 200)
.默认
超级列表框1.置列标题 (1, “数据(字符串)”)
超级列表框1.置列宽 (1, 160)
.判断结束
.如果真结束
.子程序 _超级列表框1_左键单击表项
.局部变量 地址, 整数型
.局部变量 内存属性, 内存属性
.如果真 (超级列表框1.现行选中项 ＝ -1)
返回 ()
.如果真结束
地址 ＝ 超级列表框1.取表项数值 (超级列表框1.现行选中项)
编辑框_内存属性.内容 ＝ “地址:” ＋ 十到十六 (地址, 真) ＋ “ (” ＋ 到文本 (地址) ＋ “)” ＋ #换行符
内存属性 ＝ 内存操作.查询内存属性 (地址)
编辑框_内存属性.加入文本 (“状态:” ＋ 到文本 (内存属性.状态) ＋ “ (保护:” ＋ 到文本 (内存属性.保护) ＋ “,原始:” ＋ 到文本 (内存属性.原始保护) ＋ “)” ＋ #换行符)
' 编辑框_内存属性.加入文本 (“原始保护:” ＋ 到文本 (内存属性.原始保护) ＋ #换行符)
编辑框_内存属性.加入文本 (“区域大小:” ＋ 到文本 (内存属性.区域大小) ＋ #换行符)
编辑框_内存属性.加入文本 (“区域基址:” ＋ 十到十六 (内存属性.区域基地址, 真) ＋ “ (” ＋ 到文本 (内存属性.区域基地址) ＋ “)” ＋ #换行符)
编辑框_内存属性.加入文本 (“区域偏移量:” ＋ 十到十六 (地址 － 内存属性.区域基地址) ＋ #换行符)
编辑框_内存属性.加入文本 (“分配基址:” ＋ 十到十六 (内存属性.分配基地址, 真) ＋ “ (” ＋ 到文本 (内存属性.分配基地址) ＋ “)” ＋ #换行符)
编辑框_内存属性.加入文本 (“分配偏移量:” ＋ 十到十六 (地址 － 内存属性.分配基地址))
选择夹_内存.现行子夹 ＝ 1
超级列表框1.获取焦点 ()
.子程序 _时钟_刷新搜索结果_周期事件
.局部变量 列标题, 文本型
.局部变量 计次, 整数型
.局部变量 数据, 字节集
.局部变量 文本, 文本型
列标题 ＝ 超级列表框1.取列标题 (1)
.计次循环首 (超级列表框1.取表项数 (), 计次)
数据 ＝ 内存操作.读取 (超级列表框1.取表项数值 (计次 － 1), 8)
.判断开始 (列标题 ＝ “字节集”)
文本 ＝ 查看字节集 (数据)
.判断 (列标题 ＝ “数据(字符串)”)
文本 ＝ 查看字节集2 (数据)
.判断 (列标题 ＝ “整数”)
文本 ＝ 到文本 (取字节集数据 (数据, #整数型, ))
.判断 (列标题 ＝ “长整数”)
文本 ＝ 到文本 (取字节集数据 (数据, #长整数型, ))
.判断 (列标题 ＝ “小数”)
文本 ＝ 到文本 (取字节集数据 (数据, #小数型, ))
.判断 (列标题 ＝ “双精度小数”)
文本 ＝ 到文本 (取字节集数据 (数据, #双精度小数型, ))
.判断 (列标题 ＝ “文本”)
文本 ＝ 取字节集数据 (数据, #文本型, )
.默认
.判断结束
.如果真 (超级列表框1.取标题 (计次 － 1, 1) ≠ 文本)
超级列表框1.置标题 (计次 － 1, 1, 文本)
.如果真结束
.如果真 (计次 ＞ 300) ' 太多了,刷新会卡的.
跳出循环 ()
.如果真结束
.计次循环尾 ()
.子程序 _超级列表框1_右键单击表项
.如果真 (超级列表框1.现行选中项 ≠ -1)
弹出菜单 (列表框1菜单, , )
.如果真结束
.子程序 _超级列表框2_右键单击表项
.如果 (超级列表框2.现行选中项 ≠ -1)
弹出菜单 (列表框2菜单, , )
.否则
弹出菜单 (列表框2菜单2, , )
.如果结束
.子程序 _超级列表框1_被双击, 逻辑型, , 到添加地址
.参数 横向位置, 整数型
.参数 纵向位置, 整数型
.参数 功能键状态, 整数型
.如果真 (超级列表框1.现行选中项 ≠ -1)
_添加到列表_被选择 ()
.如果真结束
.子程序 _超级列表框2_被双击, 逻辑型, , 到修改地址
.参数 横向位置, 整数型
.参数 纵向位置, 整数型
.参数 功能键状态, 整数型
.局部变量 类型, 文本型
.如果真 (超级列表框2.现行选中项 ≠ -1)
_修改地址_被选择 ()
.如果真结束
.子程序 _按钮_添加地址_被单击, , , 添加地址
载入 (窗口2, , 假)
窗口2.按钮_删除地址.可视 ＝ 假
窗口2.标题 ＝ “添加地址”
.子程序 _时钟_锁定保存地址_周期事件, , , 锁定地址
.局部变量 计次, 整数型
.局部变量 数据, 字节集
.局部变量 文本, 文本型
.局部变量 待锁定数据, 字节集
.局部变量 类型, 整数型
.计次循环首 (超级列表框2.取表项数 (), 计次)
类型 ＝ 到数值 (超级列表框2.取标题 (计次 － 1, 3))
.如果 (超级列表框2.取标题 (计次 － 1, 4) ＝ “1”)
文本 ＝ 超级列表框2.取标题 (计次 － 1, 1)
.判断开始 (类型 ＝ 0)
待锁定数据 ＝ 到字节集 (到整数 (文本))
.判断 (类型 ＝ 1)
待锁定数据 ＝ 到字节集 (到长整数 (文本))
.判断 (类型 ＝ 2)
待锁定数据 ＝ 到字节集 (到小数 (文本))
.判断 (类型 ＝ 3)
待锁定数据 ＝ 到字节集 (到数值 (文本))
.判断 (类型 ＝ 4)
待锁定数据 ＝ 到字节集 (文本) ＋ { 0 }
.判断 (类型 ＝ 5)
待锁定数据 ＝ 还原字节集 (文本)
.默认
.判断结束
内存操作.写入 (超级列表框2.取表项数值 (计次 － 1), 待锁定数据)
.否则
数据 ＝ 内存操作.读取 (超级列表框2.取表项数值 (计次 － 1), 8)
.判断开始 (类型 ＝ 0)
文本 ＝ 到文本 (取字节集数据 (数据, #整数型, ))
.判断 (类型 ＝ 1)
文本 ＝ 到文本 (取字节集数据 (数据, #长整数型, ))
.判断 (类型 ＝ 2)
文本 ＝ 到文本 (取字节集数据 (数据, #小数型, ))
.判断 (类型 ＝ 3)
文本 ＝ 到文本 (取字节集数据 (数据, #双精度小数型, ))
.判断 (类型 ＝ 4)
文本 ＝ 取字节集数据 (数据, #文本型, )
.判断 (类型 ＝ 5)
文本 ＝ 查看字节集 (数据)
.默认
.判断结束
.如果真 (超级列表框2.取标题 (计次 － 1, 1) ≠ 文本)
超级列表框2.置标题 (计次 － 1, 1, 文本)
.如果真结束
.如果结束
.计次循环尾 ()
.子程序 _超级列表框2_检查框状态被改变
.参数 表项索引, 整数型
.参数 检查框状态, 整数型
超级列表框2.置标题 (表项索引, 4, 到文本 (检查框状态))
.子程序 _添加到列表_被选择, , , 添加地址
选择夹_内存.现行子夹 ＝ 0
载入 (窗口2, , 假)
窗口2.按钮_删除地址.可视 ＝ 假
窗口2.标题 ＝ “添加地址”
窗口2.编辑框_地址.内容 ＝ 到文本 (超级列表框1.取表项数值 (超级列表框1.现行选中项))
窗口2.组合框_搜索类型.现行选中项 ＝ 组合框_搜索类型.现行选中项
窗口2.编辑框_说明.内容 ＝ 窗口2.编辑框_地址.内容
_按钮_读_被单击 ()
.子程序 _复制数据_被选择
置剪辑板文本 (超级列表框1.取标题 (超级列表框1.现行选中项, 1))
.子程序 _内存编辑器1_被选择, , , 载入内存编辑器1
编辑器_地址 ＝ 超级列表框1.取表项数值 (超级列表框1.现行选中项)
载入 (窗口3, , 假)
.子程序 _修改地址_被选择, , , 修改地址
载入 (窗口2, , 假)
窗口2.按钮_删除地址.可视 ＝ 真
窗口2.标题 ＝ “修改地址”
窗口2.编辑框_地址.内容 ＝ 到文本 (超级列表框2.取表项数值 (超级列表框2.现行选中项))
窗口2.编辑框_说明.内容 ＝ 超级列表框2.取标题 (超级列表框2.现行选中项, 0)
窗口2.编辑框_数据.内容 ＝ 超级列表框2.取标题 (超级列表框2.现行选中项, 1)
窗口2.组合框_搜索类型.现行选中项 ＝ 到数值 (超级列表框2.取标题 (超级列表框2.现行选中项, 3))
.子程序 _查看属性_被选择, , , 查看属性
.局部变量 地址, 整数型
.局部变量 内存属性, 内存属性
.如果真 (超级列表框2.现行选中项 ＝ -1)
返回 ()
.如果真结束
地址 ＝ 超级列表框2.取表项数值 (超级列表框2.现行选中项)
编辑框_内存属性.内容 ＝ “地址:” ＋ 十到十六 (地址, 真) ＋ “ (” ＋ 到文本 (地址) ＋ “)” ＋ #换行符
内存属性 ＝ 内存操作.查询内存属性 (地址)
编辑框_内存属性.加入文本 (“状态:” ＋ 到文本 (内存属性.状态) ＋ “ (保护:” ＋ 到文本 (内存属性.保护) ＋ “,原始:” ＋ 到文本 (内存属性.原始保护) ＋ “)” ＋ #换行符)
' 编辑框_内存属性.加入文本 (“原始保护:” ＋ 到文本 (内存属性.原始保护) ＋ #换行符)
编辑框_内存属性.加入文本 (“区域大小:” ＋ 到文本 (内存属性.区域大小) ＋ #换行符)
编辑框_内存属性.加入文本 (“区域基址:” ＋ 十到十六 (内存属性.区域基地址, 真) ＋ “ (” ＋ 到文本 (内存属性.区域基地址) ＋ “)” ＋ #换行符)
编辑框_内存属性.加入文本 (“区域偏移量:” ＋ 十到十六 (地址 － 内存属性.区域基地址) ＋ #换行符)
编辑框_内存属性.加入文本 (“分配基址:” ＋ 十到十六 (内存属性.分配基地址, 真) ＋ “ (” ＋ 到文本 (内存属性.分配基地址) ＋ “)” ＋ #换行符)
编辑框_内存属性.加入文本 (“分配偏移量:” ＋ 十到十六 (地址 － 内存属性.分配基地址))
选择夹_内存.现行子夹 ＝ 1
.子程序 _移除地址_被选择, , , 删除1
.如果真 (超级列表框2.现行选中项 ≠ -1)
超级列表框2.删除表项 (超级列表框2.现行选中项)
.如果真结束
.子程序 _清空地址_被选择
超级列表框2.全部删除 ()
.子程序 _导入表_被选择
.局部变量 文本组1, 文本型, , "0"
.局部变量 文本组2, 文本型, , "0"
.局部变量 计次, 整数型
.局部变量 a, 整数型
通用对话框1.初始目录 ＝ 取特殊目录 ()
通用对话框1.类型 ＝ 0
.如果真 (通用对话框1.打开 ())
超级列表框2.全部删除 ()
文本组1 ＝ 分割文本 (到文本 (读入文件 (通用对话框1.文件名)), #换行符, )
.计次循环首 (取数组成员数 (文本组1), 计次)
文本组2 ＝ 分割文本 (文本组1 [计次], “|”, )
.如果真 (取数组成员数 (文本组2) ＝ 4)
a ＝ 内存操作.取代码地址 (文本组2 [4])
超级列表框2.插入表项 (, 文本组2 [1], , , , a)
.如果真 (a ＝ 0)
超级列表框2.置标题 (计次 － 1, 0, “失效!”)
.如果真结束
超级列表框2.置标题 (计次 － 1, 1, 文本组2 [2])
超级列表框2.置标题 (计次 － 1, 3, 文本组2 [3])
超级列表框2.置标题 (计次 － 1, 5, 文本组2 [4])
a ＝ 到数值 (文本组2 [3])
.判断开始 (a ＝ 0)
超级列表框2.置标题 (计次 － 1, 2, “整数型”)
.判断 (a ＝ 1)
超级列表框2.置标题 (计次 － 1, 2, “长整数”)
.判断 (a ＝ 2)
超级列表框2.置标题 (计次 － 1, 2, “小数型”)
.判断 (a ＝ 3)
超级列表框2.置标题 (计次 － 1, 2, “长小数”)
.判断 (a ＝ 4)
超级列表框2.置标题 (计次 － 1, 2, “文本型”)
.判断 (a ＝ 5)
超级列表框2.置标题 (计次 － 1, 2, “字节集”)
.默认
.判断结束
.如果真结束
.计次循环尾 ()
.如果真结束
.子程序 _导出表_被选择
.局部变量 数据, 字节集
.局部变量 计次, 整数型
通用对话框1.初始目录 ＝ 取特殊目录 ()
通用对话框1.类型 ＝ 1
.如果真 (通用对话框1.打开 ())
.计次循环首 (超级列表框2.取表项数 (), 计次)
数据 ＝ 数据 ＋ 到字节集 (超级列表框2.取标题 (计次 － 1, 0) ＋ “|” ＋ 超级列表框2.取标题 (计次 － 1, 1) ＋ “|” ＋ 超级列表框2.取标题 (计次 － 1, 3) ＋ “|” ＋ 超级列表框2.取标题 (计次 － 1, 5) ＋ #换行符)
.计次循环尾 ()
写到文件 (通用对话框1.文件名, 数据)
.如果真结束
.子程序 _导入表2_被选择
_导入表_被选择 ()
.子程序 _从列表中移除_被选择, , , 删除2
.如果真 (超级列表框1.现行选中项 ≠ -1)
超级列表框1.删除表项 (超级列表框1.现行选中项)
.如果真结束
.子程序 _内存编辑器2_被选择, , , 载入内存编辑器2
编辑器_地址 ＝ 超级列表框2.取表项数值 (超级列表框2.现行选中项)
载入 (窗口3, , 假)
3904
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
