易语言置入代码逻辑型变量(数组)BUG检测,在内存中存储的数据是否正确(并进行异常修复)

EAX

1. 
   
2. 
   
3. .版本 2
   
4. .支持库 spec
   
5. 
   
6. .程序集 程序集1
   
7. 
   
8. .子程序 _启动子程序, 整数型, , 请在本子程序中放置易模块初始化代码
   
9. 
   
10. 
    
11. _临时子程序 ()  ' 在初始化代码执行完毕后调用测试代码
    
12. 返回 (0)  ' 可以根据您的需要返回任意数值
    
13. 
    
14. .子程序 _临时子程序
    
15. .局部变量 A, 逻辑型, , "0"
    
16. .局部变量 B, 逻辑型
    
17. 
    
18. ' 易语言中1个逻辑型占4字节，在内存中只有0和1，出现其他值则有问题，使用其他置入代码或内存指针写入程序可能会造成逻辑型变量、数组在内存中的数据出现异常，从而造成赋值，逻辑比较结果出错，最后造成程序出现崩溃等未知BUG，如果你的程序存在问题则使用此模块检查。
    
19. A ＝ { 假, 真, 假, 真 }
    
20. 
    
21. 
    
22. 调试输出 (A, 逻辑型数组_数据是否正确 (A))
    
23. A [1] ＝ 整数型强制到逻辑型 (-1)
    
24. A [2] ＝ 整数型强制到逻辑型 (12345)
    
25. 调试输出 (A, A [1] ＝ A [2], 逻辑型数组_数据是否正确 (A))
    
26. 逻辑型数组_数据修复 (A)
    
27. 调试输出 (A, A [1] ＝ A [2], 逻辑型数组_数据是否正确 (A))
    
28. 调试输出 (逻辑型变量_数据是否正确 (真))
    
29. 调试输出 (逻辑型变量_数据是否正确 (假))
    
30. 调试输出 (逻辑型变量_数据是否正确 (B))
    
31. B ＝ 整数型强制到逻辑型 (-1)
    
32. 调试输出 (B, 逻辑型变量_数据是否正确 (B))
    
33. B ＝ 逻辑型变量_数据修复 (B)
    
34. 调试输出 (B, 逻辑型变量_数据是否正确 (B))
    
35. 
    
36. .子程序 逻辑型数组_数据是否正确, 逻辑型, , 检测一个逻辑型数组在内存中是否存在异常数据，一但存在异常将会造成逻辑比较、赋值出错
    
37. .参数 逻辑型数组, 逻辑型, 数组
    
38. 
    
39. 置入代码 ({ 83, 81, 82, 139, 69, 8, 139, 0, 139, 80, 4, 131, 192, 8, 187, 0, 0, 0, 0, 235, 20, 139, 12, 152, 11, 201, 116, 12, 131, 249, 1, 116, 7, 184, 0, 0, 0, 0, 235, 10, 67, 59, 218, 114, 232, 184, 1, 0, 0, 0, 90, 89, 91, 201, 194, 4, 0 })
    
40. ' push ebx
    
41. ' push ecx
    
42. ' push edx
    
43. ' mov eax,[ebp+8]
    
44. ' mov eax,[eax]
    
45. ' mov edx,[eax+4]
    
46. ' add eax,8
    
47. ' mov ebx,0
    
48. ' .while ebx < edx
    
49. ' mov ecx,[eax+ebx*4]
    
50. ' .if ecx != 0 && ecx !=1
    
51. ' mov eax,0
    
52. ' jmp ASM_END
    
53. ' .endif
    
54. ' inc ebx
    
55. ' .endw
    
56. ' mov eax,1
    
57. ' ASM_END:
    
58. ' pop edx
    
59. ' pop ecx
    
60. ' pop ebx
    
61. ' leave
    
62. ' retn 4
    
63. 
    
64. 返回 (假)
    
65. 
    
66. 
    
67. 
    
68. 
    
69. .子程序 逻辑型数组_数据修复, , , 修复逻辑型数组中的异常数据 (谨慎使用)
    
70. .参数 逻辑型数组, 逻辑型, 参考 数组, 在内存中1为真，其他值为假，必须为数组变量
    
71. 
    
72. 置入代码 ({ 96, 139, 69, 8, 139, 0, 139, 80, 4, 131, 192, 8, 187, 0, 0, 0, 0, 235, 21, 139, 12, 152, 131, 249, 1, 116, 12, 11, 201, 116, 8, 185, 0, 0, 0, 0, 137, 12, 152, 67, 59, 218, 114, 231, 97, 201, 194, 4, 0 })
    
73. ' pusha
    
74. ' mov eax,[ebp+8]
    
75. ' mov eax,[eax]
    
76. ' mov edx,[eax+4]
    
77. ' add eax,8
    
78. ' mov ebx,0
    
79. ' .while ebx < edx
    
80. ' mov ecx,[eax+ebx*4]
    
81. ' .if ecx != 1 && ecx != 0
    
82. ' mov ecx,0
    
83. ' mov [eax+ebx*4],ecx
    
84. ' .endif
    
85. ' inc ebx
    
86. ' .endw
    
87. ' popa
    
88. ' leave
    
89. ' retn 4
    
90. 
    
91. 
    
92. .子程序 整数型强制到逻辑型, 逻辑型, , 使用此程序可将任意整数转换成数据异常的逻辑型
    
93. .参数 变量, 整数型
    
94. 
    
95. 置入代码 ({ 139, 69, 8, 201, 194, 4, 0 })
    
96. ' mov eax,[ebp+8]
    
97. ' leave
    
98. ' retn 4
    
99. 返回 (假)
    
100. 
     
101. .子程序 逻辑型强制到整数型, 整数型, , 使用此程序可将数据异常逻辑型还原成整数型
     
102. .参数 变量, 逻辑型
     
103. 
     
104. 置入代码 ({ 139, 69, 8, 201, 194, 4, 0 })
     
105. ' mov eax,[ebp+8]
     
106. ' leave
     
107. ' retn 4
     
108. 返回 (0)
     
109. 
     
110. .子程序 逻辑型变量_数据是否正确, 逻辑型
     
111. .参数 变量, 逻辑型
     
112. 
     
113. 置入代码 ({ 139, 69, 8, 11, 192, 116, 12, 131, 248, 1, 116, 7, 184, 0, 0, 0, 0, 235, 5, 184, 1, 0, 0, 0, 201, 194, 4, 0 })
     
114. ' mov eax,[ebp+8]
     
115. ' .if eax != 0 && eax != 1
     
116. ' mov eax,0
     
117. ' .elseif
     
118. ' mov eax,1
     
119. ' .endif
     
120. ' leave
     
121. ' retn 4
     
122. 返回 (假)
     
123. 
     
124. .子程序 逻辑型变量_数据修复, 逻辑型
     
125. .参数 变量, 逻辑型, , 在内存中0为假，其他值为真
     
126. 
     
127. 置入代码 ({ 139, 69, 8, 11, 192, 116, 5, 184, 1, 0, 0, 0, 201, 194, 4, 0 })
     
128. ' mov eax,[ebp+8]
     
129. ' .if eax != 0
     
130. ' mov eax,1
     
131. ' .endif
     
132. ' leave
     
133. ' retn 4
     
134. 返回 (假)
     

复制代码