类_内存

jixun66

感觉应该加个函数【初始化】，然后允许用户选择初始化使用【进程句柄】还是【进程ID】。
然后就是里面的函数，应该不需要二次提交进程ID —— 因为开启进程然后关闭句柄太过频繁肯定对性能有所影响。而且类的存在本来就是用来减少代码量的嘛。
就这样。

小磊

暂不考虑{:soso_e113:}

jixun66

自己需要方便一点的操作类… 于是改成了这样。
[e]
.版本 2

.程序集 类_内存, , 公开
.程序集变量 内_操作句柄, 整数型

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



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


.子程序 初始化, 逻辑型, 公开, 会自动关闭上次的句柄. 开启进程失败返回假
.参数 进程ID, 整数型

.如果真 (内_操作句柄 ＞ 0)
    释放 ()
.如果真结束
内_操作句柄 ＝ OpenProcess (#PROCESS_ALL_ACCESS, 0, 进程ID)
返回 (内_操作句柄 ≠ 0)

.子程序 释放, , , 释放句柄

CloseHandle (内_操作句柄)

.子程序 置属性, 整数型, 公开
.参数 内存地址, 整数型
.参数 内存属性, 整数型, , 2 = 只读; 4 = 可读写
.局部变量 虚拟保护, 精易_内存属性
.局部变量 原保护, 整数型
.局部变量 返回, 整数型

.如果真 (VirtualQueryEx (内_操作句柄, 内存地址, 虚拟保护, 28) ＝ 1)
    返回 ＝ VirtualProtectEx (内_操作句柄, 虚拟保护.区域地址, 虚拟保护.区域长度, 内存属性, 虚拟保护.当前属性)
.如果真结束
返回 (返回)

.子程序 取属性, 逻辑型, 公开, 取内存属性信息;成功返回真,失败返回假;
.参数 内存地址, 整数型, , 要取内存属性的内存地址;
.参数 内存属性, 精易_内存属性, 参考, 内存属性.当前属性 0=未分配,不可访问=1,2=可读,读写=4,可写与拷贝=8,可运行=16,可运行与可读=32,可运行可读写=64,可运行读写拷贝=128,guard=256,非物理内存=512

返回 (VirtualQueryEx (内_操作句柄, 内存地址, 内存属性, 28) ≠ 0)

.子程序 搜索, 整数型, 公开, 某些情况，需提升权限(返回结果数目,失败返回0)
.参数 搜索内容, 字节集, , 欲搜索的内容  其他类型-需自行转换为字节集类型
.参数 结果数组, 整数型, 参考 数组, 用来保存搜索的结果
.局部变量 长度, 整数型
.局部变量 内存地址, 整数型
.局部变量 内存块信息, 精易_内存属性
.局部变量 数据缓冲区, 字节集
.局部变量 读取结果, 整数型
.局部变量 找到地址, 整数型

清除数组 (结果数组)
长度 ＝ 取字节集长度 (搜索内容)
.判断循环首 (VirtualQueryEx (内_操作句柄, 内存地址, 内存块信息, 28) ≠ 0)  ' 取得内存块信息
    .如果真 (内存块信息.当前属性 ≠ 16 且 内存块信息.当前属性 ≠ 1 且 内存块信息.当前属性 ≠ 512)  ' 判断保护状态
        数据缓冲区 ＝ 取空白字节集 (内存块信息.区域长度)
        读取结果 ＝ ReadProcessMemory_字节集 (内_操作句柄, 内存地址, 数据缓冲区, 内存块信息.区域长度, 0)
        .判断循环首 (读取结果 ＞ 0)
            找到地址 ＝ 寻找字节集 (数据缓冲区, 搜索内容, 找到地址)  ' 查找是否有要搜索的数据
            .如果 (找到地址 ＝ -1)  ' 跳出 进行下次循环
                跳出循环 ()

            .否则
                加入成员 (结果数组, 到数值 (内存地址 ＋ 找到地址 － 1))
            .如果结束
            找到地址 ＝ 找到地址 ＋ 长度
        .判断循环尾 ()
    .如果真结束
    内存地址 ＝ 内存地址 ＋ 内存块信息.区域长度  ' 搜索下一内存块
    处理事件 ()
.判断循环尾 ()
返回 (取数组成员数 (结果数组))

.子程序 读小数, 小数型, 公开
.参数 内存地址, 整数型
.局部变量 临时整数, 小数型

ReadProcessMemory_小数型 (内_操作句柄, 内存地址, 临时整数, 4, 0)
返回 (临时整数)

.子程序 写小数, 逻辑型, 公开
.参数 内存地址, 整数型, , 内存地址
.参数 要写入的值, 小数型, , 写入数据

返回 (WriteProcessMemory_小数型 (内_操作句柄, 内存地址, 要写入的值, 4, 0) ＝ 1)

.子程序 读文本, 文本型, 公开, 读取文本型数据(返回文本 失败返回空文本)
.参数 内存地址, 整数型
.参数 长度, 整数型, 可空, 默认为20 欲读取的长度字节
.局部变量 临时字节集, 字节集

.如果真 (长度 ＝ 0)
    长度 ＝ 20
.如果真结束
' --读文本---------------------------------
临时字节集 ＝ 取空白字节集 (长度)
ReadProcessMemory_字节集 (内_操作句柄, 内存地址, 临时字节集, 长度, 长度)
返回 (到文本 (临时字节集))

.子程序 写文本, 逻辑型, 公开, 写入文本数据(成功返回真,失败返回假)
.参数 内存地址, 整数型, , 内存地址
.参数 要写入的数据, 文本型, , 写入数据

返回 (WriteProcessMemory_文本型 (内_操作句柄, 内存地址, 要写入的数据, 取文本长度 (要写入的数据), 0) ≠ 0)

.子程序 读整数, 整数型, 公开, 读取整数型数据(返回整数内容 失败返回0)
.参数 内存地址, 整数型
.局部变量 临时整数, 整数型

ReadProcessMemory_整数型 (内_操作句柄, 内存地址, 临时整数, 4, 0)
返回 (临时整数)

.子程序 读短整数, 短整数型, 公开, 读取短整数型数据(返回整数内容 失败返回0)
.参数 内存地址, 整数型
.局部变量 临时整数, 短整数型

ReadProcessMemory_短整数型 (内_操作句柄, 内存地址, 临时整数, 2, 0)
返回 (临时整数)

.子程序 读长整数, 长整数型, 公开
.参数 内存地址, 整数型
.局部变量 临时整数, 长整数型

ReadProcessMemory_长整数型 (内_操作句柄, 内存地址, 临时整数, 8, 0)
返回 (临时整数)

.子程序 写整数, 逻辑型, 公开, 写入四字节数据(成功返回真,失败返回假)
.参数 内存地址, 整数型, , 内存地址
.参数 要写入的值, 整数型, , 写入数据
.参数 写入类型, 整数型, 可空, 默认为1  0=短整数型 1=整数型 2=长整数型
.局部变量 局_长度, 整数型

.如果真 (写入类型 ＜ 0 或 写入类型 ＞ 2)
    返回 (假)
.如果真结束
局_长度 ＝ (选择 (是否为空 (写入类型), 1, 写入类型) ＋ 1) × 2
返回 (WriteProcessMemory_整数型 (内_操作句柄, 内存地址, 要写入的值, 局_长度, 0) ＝ 1)

.子程序 读字节, 字节型, 公开, 读取字节型数据(返回整数内容 失败返回0)
.参数 内存地址, 整数型
.局部变量 临时整数, 字节型

ReadProcessMemory_字节型 (内_操作句柄, 内存地址, 临时整数, 1, 0)
返回 (临时整数)

.子程序 写字节, 逻辑型, 公开, 写入1字节数据(成功返回真,失败返回假)
.参数 内存地址, 整数型, , 内存地址
.参数 要写入的数据, 字节型, , 写入数据

返回 (_内存写字节 (内_操作句柄, 内存地址, 要写入的数据, 1, 0) ≠ 0)

.子程序 读字节集, 字节集, 公开, 读取字节集数据(返回字节集 失败返回空)
.参数 内存地址, 整数型, , 内存地址
.参数 长度, 整数型, 可空, 可空。留空将智能读取长度
.局部变量 变量, 字节集, , , 保存读取数据的变量
.局部变量 内存块信息, 精易_内存属性

.如果真 (长度 ＜ 1)
    VirtualQueryEx (内_操作句柄, 内存地址, 内存块信息, 28)
    长度 ＝ 内存块信息.区域长度 ＋ 内存块信息.区域地址 － 内存地址
.如果真结束
变量 ＝ 取空白字节集 (长度)
ReadProcessMemory_字节集 (内_操作句柄, 内存地址, 变量, 长度, 0)
返回 (变量)

.子程序 写字节集, 逻辑型, 公开, 写入字节集数据(成功返回真,失败返回假)
.参数 内存地址, 整数型, , 内存地址
.参数 要写入的数据, 字节集, , 写入数据

返回 (WriteProcessMemory_字节集 (内_操作句柄, 内存地址, 要写入的数据, 取字节集长度 (要写入的数据), 0) ≠ 0)

.子程序 读日期时间, 日期时间型, 公开, 从内存中读取日期时间型数据,失败将返回100年1月1日
.参数 地址, 整数型, , 内存地址
.局部变量 局_变量, 字节集, , , 保存读取数据的变量

局_变量 ＝ 取空白字节集 (8)
.如果真 (ReadProcessMemory_字节集 (内_操作句柄, 地址, 局_变量, 8, 0) ＝ 0)
    返回 (到时间 (0))
.如果真结束
返回 (取字节集数据 (局_变量, #日期时间型, ))

.子程序 读子程序指针, 子程序指针, 公开, 从内存中读取子程序指针,失败返回空指针
.参数 地址, 整数型, , 内存地址
.局部变量 空指针, 子程序指针
.局部变量 变量, 字节集, , , 保存读取数据的变量
.局部变量 a, 整数型
.局部变量 长度, 整数型

变量 ＝ 取空白字节集 (4)
.如果真 (ReadProcessMemory_字节集 (内_操作句柄, 地址, 变量, 4, 0) ＝ 0)
    返回 (空指针)
.如果真结束
返回 (取字节集数据 (变量, #子程序指针型, ))

.子程序 读双精度小数, 双精度小数型, 公开, 从内存中读取双精度小数型数据
.参数 地址, 整数型, , 内存地址
.局部变量 变量, 字节集, , , 保存读取数据的变量

变量 ＝ 取空白字节集 (8)
ReadProcessMemory_字节集 (内_操作句柄, 地址, 变量, 8, 0)
返回 (取字节集数据 (变量, #双精度小数型, ))

.子程序 写代码, 逻辑型, 公开, 写内存整数型,写内存字节集。[坛友：“啄啄”提供]
.参数 地址表达式, 文本型, , 比如“0A1574D+1D45+547=999”
.局部变量 局部_写入的值, 文本型
.局部变量 局部_一级分割, 文本型, , "0"
.局部变量 局部_二级分割, 文本型, , "0"
.局部变量 局部_计次, 整数型
.局部变量 局部_读取的值, 整数型

局部_一级分割 ＝ 分割文本 (地址表达式, “=”, )
局部_写入的值 ＝ 局部_一级分割 [2]
局部_二级分割 ＝ 分割文本 (局部_一级分割 [1], “+”, )
.判断开始 (取文本左边 (局部_写入的值, 1) ＝ “{”)
    .计次循环首 (取数组成员数 (局部_二级分割), 局部_计次)
        .判断开始 (局部_计次 ＝ 取数组成员数 (局部_二级分割))
            局部_读取的值 ＝ 进制_十六到十 (局部_二级分割 [局部_计次]) ＋ 局部_读取的值
        .默认
            局部_读取的值 ＝ 到整数 (读字节集 (进制_十六到十 (局部_二级分割 [局部_计次]) ＋ 局部_读取的值, ))
        .判断结束

    .计次循环尾 ()
    返回 (写字节集 (局部_读取的值, 字节集_还原 (局部_写入的值)))
.默认
    .计次循环首 (取数组成员数 (局部_二级分割), 局部_计次)
        .判断开始 (局部_计次 ＝ 取数组成员数 (局部_二级分割))
            局部_读取的值 ＝ 进制_十六到十 (局部_二级分割 [局部_计次]) ＋ 局部_读取的值
        .默认
            局部_读取的值 ＝ 读整数 (进制_十六到十 (局部_二级分割 [局部_计次]) ＋ 局部_读取的值)
        .判断结束

    .计次循环尾 ()
    返回 (写整数 (局部_读取的值, 到整数 (局部_写入的值)))
.判断结束


.子程序 读代码_整数, 整数型, 公开, 读内存整数型。[坛友：“啄啄”提供]
.参数 地址表达式, 文本型, , 比如“0A1574D+1D45+547”
.局部变量 局部_计次, 整数型
.局部变量 局部_读取的值, 整数型
.局部变量 局部_分割, 文本型, , "0"

局部_分割 ＝ 分割文本 (地址表达式, “+”, )
.计次循环首 (取数组成员数 (局部_分割), 局部_计次)
    .判断开始 (局部_计次 ＝ 取数组成员数 (局部_分割))
        局部_读取的值 ＝ 进制_十六到十 (局部_分割 [局部_计次]) ＋ 局部_读取的值
    .默认
        局部_读取的值 ＝ 读整数 (进制_十六到十 (局部_分割 [局部_计次]) ＋ 局部_读取的值)
    .判断结束

.计次循环尾 ()
返回 (读整数 (局部_读取的值))

.子程序 读代码_字节集, 字节集, 公开, 读内存字节集。[坛友：“啄啄”提供]
.参数 地址表达式, 文本型, , 比如“0A1574D+1D45+547”
.局部变量 局部_计次, 整数型
.局部变量 局部_读取的值, 整数型
.局部变量 局部_分割, 文本型, , "0"

局部_分割 ＝ 分割文本 (地址表达式, “+”, )
.计次循环首 (取数组成员数 (局部_分割), 局部_计次)
    .判断开始 (局部_计次 ＝ 取数组成员数 (局部_分割))
        局部_读取的值 ＝ 进制_十六到十 (局部_分割 [局部_计次]) ＋ 局部_读取的值
    .默认
        局部_读取的值 ＝ 到整数 (读字节集 (进制_十六到十 (局部_分割 [局部_计次]) ＋ 局部_读取的值, ))
    .判断结束

.计次循环尾 ()
返回 (读字节集 (局部_读取的值, ))
[/e]

三咲智子

路过路过。。

默默`

我只能说路过，


　　　————默默的守护着你，默默的等奇迹，默默的让自己像是空气。

Hoibben

我只能说呵呵。。。。。。