【蠢新学汇编】让类方法支持启动线程

笨来无一悟 · 发表于 2025-3-4 18:38:42

本帖最后由笨来无一悟于 2025-4-1 02:24 编辑

不止一次看见有小伙伴苦恼于类的内部无法用启动线程的方式调用类方法

今天这个问题完美的解决了

目前市面上主流的解决方案要么需要类的内部手动申请释放要么需要使用特制的call 还无法访问类成员

上次试着解决了一下结果约等于没解决一个线程就要占一个变量非常的不合理

贼心不死反汇编盯了好一会儿终于把ESP的顺序盯明白了优化一个原生支持多线程的版本

具体使用方法看测试用例↓↓↓

子程序名	返回值类型	公开	备注
取类方法内部	子程序指针		初始化销毁以外从1开始
参数名	类型	参考	可空	数组	备注
类方法上到下	整数型				所取编号必须存在
存放代码变量	字节集				生命周期之内使用

存放代码变量＝ { 255, 52, 36, 199, 68, 36, 4, 0, 0, 0, 0, 184, 0, 0, 0, 0, 255, 224 }
置入代码 ({ 139, 69, 12, 139, 0, 131, 192, 8, 54, 139, 85, 0, 62, 139, 82, 8, 62, 137, 80, 7, 62, 139, 18, 62, 139, 18, 54, 139, 77, 8, 62, 139, 84, 138, 4, 62, 137, 80, 12, 201, 194, 8, 0 })
' MOV EAX, DWORD [EBP+12]
' MOV EAX, DWORD [EAX]
' ADD EAX, 8
' MOV EDX, DWORD PTR SS:[EBP]
' MOV EDX, DWORD PTR DS:[EDX+8]
' MOV DWORD PTR DS:[EAX+7], EDX
' MOV EDX, DWORD PTR DS:[EDX]
' MOV EDX, DWORD PTR DS:[EDX]
' MOV ECX, DWORD PTR SS:[EBP+8]
' MOV EDX, DWORD PTR DS:[EDX+ECX*4+4]
' MOV DWORD PTR DS:[EAX+12], EDX
' LEAVE
' RET 8
返回 (&欺骗编译器) ' 已包装仅供类内部调用

子程序名	返回值类型	公开	备注
取类方法外部	子程序指针		初始化销毁以外从1开始
参数名	类型	参考	可空	数组	备注
已声明类变量	通用型				已声明类变量名称
类方法上到下	整数型				所取编号必须存在
存放代码变量	字节集				生命周期之内使用

存放代码变量＝ { 255, 52, 36, 199, 68, 36, 4, 0, 0, 0, 0, 184, 0, 0, 0, 0, 255, 224 }
置入代码 ({ 139, 69, 16, 139, 0, 131, 192, 8, 54, 139, 85, 8, 54, 137, 80, 7, 62, 139, 18, 62, 139, 18, 54, 139, 77, 12, 62, 139, 84, 138, 4, 54, 137, 80, 12, 201, 194, 12, 0 })
' MOV EAX, DWORD [EBP+16]
' MOV EAX, DWORD [EAX]
' ADD EAX, 8
' MOV EDX, DWORD PTR SS:[EBP+8]
' MOV DWORD PTR SS:[EAX+7], EDX
' MOV EDX, DWORD PTR DS:[EDX]
' MOV EDX, DWORD PTR DS:[EDX]
' MOV ECX, DWORD PTR SS:[EBP+12]
' MOV EDX, DWORD PTR DS:[EDX+ECX*4+4]
' MOV DWORD PTR SS:[EAX+12], EDX
' LEAVE
' RET 12
返回 (&欺骗编译器) ' 已包装仅供类外部调用

子程序名	返回值类型	公开	备注
欺骗编译器	子程序指针

返回 (&欺骗编译器)

.版本 2<br />
<br />
.子程序 取类方法内部, 子程序指针, 公开, 初始化销毁以外 从1开始<br />
.参数 类方法上到下, 整数型, , 所取编号必须存在<br />
.参数 存放代码变量, 字节集, 参考, 生命周期之内使用<br />
<br />
存放代码变量 ＝ { 255, 52, 36, 199, 68, 36, 4, 0, 0, 0, 0, 184, 0, 0, 0, 0, 255, 224 }<br />
置入代码 ({ 139, 69, 12, 139, 0, 131, 192, 8, 54, 139, 85, 0, 62, 139, 82, 8, 62, 137, 80, 7, 62, 139, 18, 62, 139, 18, 54, 139, 77, 8, 62, 139, 84, 138, 4, 62, 137, 80, 12, 201, 194, 8, 0 })<br />
' MOV EAX, DWORD [EBP+12]<br />
' MOV EAX, DWORD [EAX]<br />
' ADD EAX, 8<br />
' MOV EDX, DWORD PTR SS:[EBP]<br />
' MOV EDX, DWORD PTR DS:[EDX+8]<br />
' MOV DWORD PTR DS:[EAX+7], EDX<br />
' MOV EDX, DWORD PTR DS:[EDX]<br />
' MOV EDX, DWORD PTR DS:[EDX]<br />
' MOV ECX, DWORD PTR SS:[EBP+8]<br />
' MOV EDX, DWORD PTR DS:[EDX+ECX*4+4]<br />
' MOV DWORD PTR DS:[EAX+12], EDX<br />
' LEAVE<br />
' RET 8<br />
返回 (&欺骗编译器)  ' 已包装 仅供 类内部 调用<br />
<br />
.子程序 取类方法外部, 子程序指针, 公开, 初始化销毁以外 从1开始<br />
.参数 已声明类变量, 通用型, 参考, 已声明类变量名称<br />
.参数 类方法上到下, 整数型, , 所取编号必须存在<br />
.参数 存放代码变量, 字节集, 参考, 生命周期之内使用<br />
<br />
存放代码变量 ＝ { 255, 52, 36, 199, 68, 36, 4, 0, 0, 0, 0, 184, 0, 0, 0, 0, 255, 224 }<br />
置入代码 ({ 139, 69, 16, 139, 0, 131, 192, 8, 54, 139, 85, 8, 54, 137, 80, 7, 62, 139, 18, 62, 139, 18, 54, 139, 77, 12, 62, 139, 84, 138, 4, 54, 137, 80, 12, 201, 194, 12, 0 })<br />
' MOV EAX, DWORD [EBP+16]<br />
' MOV EAX, DWORD [EAX]<br />
' ADD EAX, 8<br />
' MOV EDX, DWORD PTR SS:[EBP+8]<br />
' MOV DWORD PTR SS:[EAX+7], EDX<br />
' MOV EDX, DWORD PTR DS:[EDX]<br />
' MOV EDX, DWORD PTR DS:[EDX]<br />
' MOV ECX, DWORD PTR SS:[EBP+12]<br />
' MOV EDX, DWORD PTR DS:[EDX+ECX*4+4]<br />
' MOV DWORD PTR SS:[EAX+12], EDX<br />
' LEAVE<br />
' RET 12<br />
返回 (&欺骗编译器)  ' 已包装 仅供 类外部 调用<br />
<br />
.子程序 欺骗编译器, 子程序指针<br />
<br />
返回 (&欺骗编译器)

来自群组: 热心网友

笨来无一悟 · 发表于 2025-3-4 20:42:40

7ian 发表于 2025-3-4 18:55
看看我的用法

优化了一下

子程序名	返回值类型	公开	备注
取类方法地址	子程序指针		初始化销毁以外从1开始
参数名	类型	参考	可空	数组	备注
类方法上到下	整数型				所取编号必须存在
存放代码变量	字节集				生命周期之内使用

存放代码变量＝ { 91, 184, 0, 0, 0, 0, 104, 0, 0, 0, 0, 83, 255, 224 }
置入代码 ({ 139, 69, 12, 139, 0, 131, 192, 8, 54, 139, 85, 0, 62, 139, 82, 8, 62, 137, 80, 7, 62, 139, 18, 62, 139, 18, 54, 139, 77, 8, 62, 139, 84, 138, 4, 62, 137, 80, 2, 201, 194, 8, 0 })
' MOV EAX, DWORD [EBP+12]
' MOV EAX, DWORD [EAX]
' ADD EAX, 8
' MOV EDX, DWORD PTR SS:[EBP]
' MOV EDX, DWORD PTR DS:[EDX+8]
' MOV DWORD PTR DS:[EAX+7], EDX
' MOV EDX, DWORD PTR DS:[EDX]
' MOV EDX, DWORD PTR DS:[EDX]
' MOV ECX, DWORD PTR SS:[EBP+8]
' MOV EDX, DWORD PTR DS:[EDX+ECX*4+4]
' MOV DWORD PTR DS:[EAX+2], EDX
' LEAVE
' RET 8
返回 (&欺骗编译器) ' 仅供类内部调用

子程序名	返回值类型	公开	备注
欺骗编译器	子程序指针

返回 (&欺骗编译器)

li6607 · 发表于 2025-4-10 14:36:42

笨来无一悟发表于 2025-4-10 13:45
这样
[e=4].版本 2
.支持库 spec

可以了可以了，谢谢

笨来无一悟 · 发表于 2025-4-10 13:57:05

li6607 发表于 2025-4-10 10:19
20250401版本多参数崩溃，能否继续优化一下

也可以直接用子程序这样也能获取到字节集数组文本自定义数据类型作为参数的子程序指针

窗口程序集名	保留	保留	备注
窗口程序集_启动窗口

子程序名	返回值类型	公开	备注
__启动窗口_创建完毕

变量名	类型	静态	数组	备注
地址	子程序指针

地址＝取某某子程序地址 ()
调用子程序 (地址, , , 0, 0) ' 自定义数据类型取变量地址() 或取变量数据地址()

子程序名	返回值类型	公开	备注
取某某子程序地址	子程序指针		针对参数为字节集数组或者自定义类型

变量名	类型	静态	数组	备注
A	自定义
B	字节集

返回 (下层地址 ()) ' 除了局部自定义非静态别的都能获取因为局部非静态自定义数据会call一个构造函数(自定义数据类型初始化)
某某子程序 (A, B)

子程序名	返回值类型	公开	备注
某某子程序	整数型
参数名	类型	参考	可空	数组	备注
一	自定义
二	字节集

调试输出 (“被调用”)
返回 (0)

子程序名	返回值类型	公开	备注
下层地址	子程序指针		返回(下层地址()) 所取子程序(须带参数,来源不限) 若传局部变量必须静态

置入代码 ({ 83, 81, 82, 139, 69, 4 })
' PUSH EBX
' PUSH ECX
' PUSH EDX
' MOV EAX,DWORD [EBP+4]
置入代码 ({ 64, 128, 56, 195, 117, 34, 128, 120, 255, 93, 117, 244, 128, 120, 254, 229, 117, 8, 128, 120, 253, 139, 117, 232, 235, 50 })
' 向下:
' INC EAX
' CMP BYTE[EAX],195
' JNE 带参
' 平栈:
' CMP BYTE[EAX-1],93
' JNE 向下
' CMP BYTE[EAX-2],229
' JNE 等价
' CMP BYTE[EAX-3],139
' JNE 向下
' JMP 向上
置入代码 ({ 128, 120, 254, 236, 117, 224, 128, 120, 253, 137, 117, 218, 235, 36 })
' 等价:
' CMP BYTE[EAX-2],236
' JNE 向下
' CMP BYTE[EAX-3],137
' JNE 向下
' JMP 向上
置入代码 ({ 128, 56, 194, 117, 211, 128, 120, 2, 0, 117, 205, 137, 193, 80, 49, 210, 49, 192, 138, 65, 1, 187, 4, 0, 0, 0, 247, 243, 88, 131, 250, 0, 117, 182, 235, 186 })
' 带参:
' CMP BYTE[EAX],194
' JNE 向下
' CMP BYTE [EAX+2],0
' JNE 向下
' MOV ECX,EAX
' PUSH EAX
' XOR EDX,EDX
' XOR EAX,EAX
' MOV AL,BYTE [ECX+1]
' MOV EBX,4
' DIV EBX
' POP EAX
' CMP EDX,0
' JNE 向下
' JMP 平栈
置入代码 ({ 72, 128, 56, 232, 117, 250, 128, 120, 251, 104, 117, 2, 235, 12 })
' 向上:
' DEC EAX
' CMP BYTE [EAX],232
' JNE 向上
' CMP BYTE[EAX-5],104
' JNE 传参
' JMP 找到
置入代码 ({ 128, 120, 253, 255, 117, 236, 128, 120, 254, 117, 117, 230, 139, 72, 1, 141, 76, 8, 5, 128, 57, 85, 117, 218 })
' 传参:
' CMP BYTE[EAX-3],255
' JNE 向上
' CMP BYTE[EAX-2],117
' JNE 向上
' 找到:
' MOV ECX,DWORD [EAX+1]
' LEA ECX,DWORD [EAX+ECX+5]
' CMP BYTE [ECX],85
' JNE 向上
置入代码 ({ 137, 200, 90, 89, 91, 201, 195 })
' MOV EAX,ECX
' POP EDX
' POP ECX
' POP EBX
' LEAVE
' RET
返回 (&下层地址)

子程序名	返回值类型	公开	备注
下层地址_简版	子程序指针		返回(下层地址_简版()) 所取子程序(须带参数,且,来自局部) 需传静态变量

置入代码 ({ 81, 139, 69, 4, 64, 128, 56, 232, 117, 250, 128, 120, 251, 104, 117, 244, 139, 72, 1, 141, 76, 8, 5, 128, 57, 85, 117, 232, 137, 200, 89, 201, 195 })
返回 (&下层地址_简版)
' PUSH ECX
' MOV EAX, DWORD [EBP+4]
' 向下:
' INC EAX
' CMP BYTE[EAX],232
' JNE 向下
' CMP BYTE[EAX-5],104
' JNE 向下
' MOV ECX, DWORD [EAX+1]
' LEA ECX, DWORD [EAX+ECX+5]
' CMP BYTE [ECX],85
' JNE 向下
' MOV EAX, ECX
' POP ECX
' LEAVE
' RET

i支持库列表	支持库注释
spec	特殊功能支持库

.版本 2<br />
.支持库 spec<br />
<br />
.程序集 窗口程序集_启动窗口<br />
<br />
.子程序 __启动窗口_创建完毕<br />
.局部变量 地址, 子程序指针<br />
<br />
地址 ＝ 取某某子程序地址 ()<br />
调用子程序 (地址, , , 0, 0)  ' 自定义数据类型 取变量地址() 或 取变量数据地址()<br />
<br />
.子程序 取某某子程序地址, 子程序指针, , 针对 参数为 字节集 数组 或者 自定义类型<br />
.局部变量 A, 自定义, 静态<br />
.局部变量 B, 字节集, 静态<br />
<br />
返回 (下层地址 ())  ' 除了局部自定义非静态 别的都能获取 因为局部非静态自定义数据会call一个 构造函数(自定义数据类型初始化)<br />
某某子程序 (A, B)<br />
<br />
.子程序 某某子程序, 整数型<br />
.参数 一, 自定义<br />
.参数 二, 字节集<br />
<br />
调试输出 (“被调用”)<br />
返回 (0)<br />
<br />
.子程序 下层地址, 子程序指针, , 返回(下层地址()) 所取子程序(须带参数,来源不限) 若传局部变量必须静态 <br />
<br />
置入代码 ({ 83, 81, 82, 139, 69, 4 })<br />
' PUSH EBX<br />
' PUSH ECX<br />
' PUSH EDX<br />
' MOV EAX,DWORD [EBP+4]<br />
置入代码 ({ 64, 128, 56, 195, 117, 34, 128, 120, 255, 93, 117, 244, 128, 120, 254, 229, 117, 8, 128, 120, 253, 139, 117, 232, 235, 50 })<br />
' 向下:<br />
' INC EAX<br />
' CMP BYTE[EAX],195<br />
' JNE 带参<br />
' 平栈:<br />
' CMP BYTE[EAX-1],93<br />
' JNE 向下<br />
' CMP BYTE[EAX-2],229<br />
' JNE 等价<br />
' CMP BYTE[EAX-3],139<br />
' JNE 向下<br />
' JMP 向上<br />
置入代码 ({ 128, 120, 254, 236, 117, 224, 128, 120, 253, 137, 117, 218, 235, 36 })<br />
' 等价:<br />
' CMP BYTE[EAX-2],236<br />
' JNE 向下<br />
' CMP BYTE[EAX-3],137<br />
' JNE 向下<br />
' JMP 向上<br />
置入代码 ({ 128, 56, 194, 117, 211, 128, 120, 2, 0, 117, 205, 137, 193, 80, 49, 210, 49, 192, 138, 65, 1, 187, 4, 0, 0, 0, 247, 243, 88, 131, 250, 0, 117, 182, 235, 186 })<br />
' 带参:<br />
' CMP BYTE[EAX],194<br />
' JNE 向下<br />
' CMP BYTE [EAX+2],0<br />
' JNE 向下<br />
' MOV ECX,EAX<br />
' PUSH EAX<br />
' XOR EDX,EDX<br />
' XOR EAX,EAX<br />
' MOV AL,BYTE [ECX+1]<br />
' MOV EBX,4<br />
' DIV EBX<br />
' POP EAX<br />
' CMP EDX,0<br />
' JNE 向下<br />
' JMP 平栈<br />
置入代码 ({ 72, 128, 56, 232, 117, 250, 128, 120, 251, 104, 117, 2, 235, 12 })<br />
' 向上:<br />
' DEC EAX<br />
' CMP BYTE [EAX],232<br />
' JNE 向上<br />
' CMP BYTE[EAX-5],104<br />
' JNE 传参<br />
' JMP 找到<br />
置入代码 ({ 128, 120, 253, 255, 117, 236, 128, 120, 254, 117, 117, 230, 139, 72, 1, 141, 76, 8, 5, 128, 57, 85, 117, 218 })<br />
' 传参:<br />
' CMP BYTE[EAX-3],255<br />
' JNE 向上<br />
' CMP BYTE[EAX-2],117<br />
' JNE 向上<br />
' 找到:<br />
' MOV ECX,DWORD [EAX+1]<br />
' LEA ECX,DWORD [EAX+ECX+5]<br />
' CMP BYTE [ECX],85<br />
' JNE 向上<br />
置入代码 ({ 137, 200, 90, 89, 91, 201, 195 })<br />
' MOV EAX,ECX<br />
' POP EDX<br />
' POP ECX<br />
' POP EBX<br />
' LEAVE<br />
' RET<br />
返回 (&下层地址)<br />
<br />
.子程序 下层地址_简版, 子程序指针, , 返回(下层地址_简版()) 所取子程序(须带参数,且,来自局部) 需传静态变量<br />
<br />
置入代码 ({ 81, 139, 69, 4, 64, 128, 56, 232, 117, 250, 128, 120, 251, 104, 117, 244, 139, 72, 1, 141, 76, 8, 5, 128, 57, 85, 117, 232, 137, 200, 89, 201, 195 })<br />
返回 (&下层地址_简版)<br />
' PUSH ECX<br />
' MOV EAX, DWORD [EBP+4]<br />
' 向下:<br />
' INC EAX<br />
' CMP BYTE[EAX],232<br />
' JNE 向下<br />
' CMP BYTE[EAX-5],104<br />
' JNE 向下<br />
' MOV ECX, DWORD [EAX+1]<br />
' LEA ECX, DWORD [EAX+ECX+5]<br />
' CMP BYTE [ECX],85<br />
' JNE 向下<br />
' MOV EAX, ECX<br />
' POP ECX<br />
' LEAVE<br />
' RET

笨来无一悟 · 发表于 2025-4-10 13:45:33

li6607 发表于 2025-4-10 10:41
好像文本型都会崩

这样

子程序名	返回值类型	公开	备注
方法5			内部多线程测试

变量名	类型	静态	数组	备注
计次	整数型
地址	整数型

如果真 (到整数 (指针六) ＝ 0) ' 取指针的操作不能放在初始化和销毁里面其他任意一个方法里面都可以写初始化传参有误如果需要多线程请严格按照这种格式书写

指针六＝取类方法内部 (6, 方法六)

计次循环首 (100, 计次)

地址＝申请内存 (10, )

写到内存 (“1234567”, 地址, 10)

启动线程 (指针六, 地址, ) ' 至于怎么传递多个参数就不在本帖的讨论范围了高兴咋传就咋传和普通的子程序跑多线程是一样的

计次循环尾 ()

子程序名	返回值类型	公开	备注
方法6			内部多线程测试
参数名	类型	参考	可空	数组	备注
参数一	整数型

调试输出 (“内部”, 指针到文本 (参数一))
释放内存 (参数一)

i支持库列表	支持库注释
spec	特殊功能支持库
EThread	多线程支持库

li6607 · 发表于 2025-4-10 10:41:32

li6607 发表于 2025-4-10 10:19
20250401版本多参数崩溃，能否继续优化一下

好像文本型都会崩

li6607 · 发表于 2025-4-10 10:19:56

20250401版本多参数崩溃，能否继续优化一下

li6607 · 发表于 2025-4-10 09:38:43

大神牛逼！(破音)

imquange · 发表于 2025-3-31 11:57:32

非常感谢，开始研究

youxigw · 发表于 2025-3-10 08:25:52

宝贵经验啊，很值得学习

用LOvE寫歌 · 发表于 2025-3-8 22:30:02

感谢大神分享~！

胖子葛格 · 发表于 2025-3-8 14:16:28

感谢大神分享~！

		自动登录	找回密码
密码			注册

[易语言纯源码] 【蠢新学汇编】让类方法支持启动线程

点评

评分

本帖被以下淘专辑推荐:

点评

点评

点评

[易语言纯源码] 【蠢新学汇编】让 类方法 支持 启动线程

点评

评分

本帖被以下淘专辑推荐:

点评

点评

点评

[易语言纯源码] 【蠢新学汇编】让类方法支持启动线程