易语言MASM置入代码实现长整数型的大于/小于/大于等于/小于等于/等于比较(返回逻辑型)

EAX

1. .版本 2
   
2. 
   
3. .程序集 程序集1
   
4. 
   
5. .子程序 _启动子程序, 整数型, , 请在本子程序中放置易模块初始化代码
   
6. 
   
7. 置随机数种子 ()
   
8. 
   
9. _临时子程序 ()  ' 在初始化代码执行完毕后调用测试代码
   
10. 返回 (0)  ' 可以根据您的需要返回任意数值
    
11. 
    
12. .子程序 _临时子程序
    
13. .局部变量 A, 长整数型
    
14. .局部变量 B, 长整数型
    
15. .局部变量 大于, 逻辑型
    
16. .局部变量 小于, 逻辑型
    
17. .局部变量 大于等于, 逻辑型
    
18. .局部变量 小于等于, 逻辑型
    
19. .局部变量 等于, 逻辑型
    
20. .局部变量 次数, 整数型
    
21. .局部变量 时间, 整数型
    
22. 
    
23. 时间 ＝ 取启动时间 ()
    
24. 
    
25. .判断循环首 (真)
    
26.     A ＝ 取随机长整数 ()
    
27.     B ＝ 取随机长整数 ()
    
28.     大于 ＝ A ＞ B
    
29.     小于 ＝ A ＜ B
    
30.     大于等于 ＝ A ≥ B
    
31.     小于等于 ＝ A ≤ B
    
32.     等于 ＝ A ＝ B
    
33.     .如果真 (长整数型_大于 (A, B) ≠ 大于)
    
34.         输出调试文本 (“错误:大于”)
    
35.         跳出循环 ()
    
36.     .如果真结束
    
37.     .如果真 (长整数型_小于 (A, B) ≠ 小于)
    
38.         输出调试文本 (“错误:小于”)
    
39.         跳出循环 ()
    
40.     .如果真结束
    
41.     .如果真 (长整数型_大于等于 (A, B) ≠ 大于等于)
    
42.         输出调试文本 (“错误:大于等于”)
    
43.         跳出循环 ()
    
44.     .如果真结束
    
45.     .如果真 (长整数型_小于等于 (A, B) ≠ 小于等于)
    
46.         输出调试文本 (“错误:小于等于”)
    
47.         跳出循环 ()
    
48.     .如果真结束
    
49.     .如果真 (长整数型_等于 (A, B) ≠ 等于)
    
50.         输出调试文本 (“错误:等于”)
    
51.         跳出循环 ()
    
52.     .如果真结束
    
53.     次数 ＝ 次数 ＋ 1
    
54.     .如果真 (次数 ≤ 0)
    
55.         输出调试文本 (“正确”)
    
56.         跳出循环 ()
    
57.     .如果真结束
    
58.     .如果真 (次数 ％ 1000000 ＝ 0)
    
59.         输出调试文本 (次数)
    
60.     .如果真结束
    
61. 
    
62. .判断循环尾 ()
    
63. 输出调试文本 (“耗时(秒):” ＋ 到文本 ((取启动时间 () － 时间) ÷ 1000))
    
64. 
    
65. 
    
66. .子程序 长整数型_大于, 逻辑型, 公开
    
67. .参数 被比较值, 长整数型
    
68. .参数 比较值, 长整数型
    
69. 
    
70. 置入代码 ({ 83, 81, 82, 139, 69, 8, 139, 93, 12, 139, 77, 16, 139, 85, 20, 59, 218, 126, 9, 184, 1, 0, 0, 0, 235, 19, 235, 15, 59, 218, 117, 11, 59, 193, 118, 7, 184, 1, 0, 0, 0, 235, 2, 51, 192, 90, 89, 91, 201, 194, 16, 0 })
    
71. ' push ebx
    
72. ' push ecx
    
73. ' push edx
    
74. ' mov eax,[ebp+8]
    
75. ' mov ebx,[ebp+12]
    
76. ' mov ecx,[ebp+16]
    
77. ' mov edx,[ebp+20]
    
78. ' .if sdword ptr ebx > edx
    
79. ' mov eax,1
    
80. ' jmp ASM_END
    
81. ' .elseif ebx == edx && eax > ecx
    
82. ' mov eax,1
    
83. ' jmp ASM_END
    
84. ' .endif
    
85. ' xor eax,eax
    
86. ' ASM_END:
    
87. ' pop edx
    
88. ' pop ecx
    
89. ' pop ebx
    
90. ' leave
    
91. ' retn 16
    
92. 返回 (假)
    
93. 
    
94. .子程序 长整数型_小于, 逻辑型, 公开
    
95. .参数 被比较值, 长整数型
    
96. .参数 比较值, 长整数型
    
97. 
    
98. 置入代码 ({ 83, 81, 82, 139, 69, 8, 139, 93, 12, 139, 77, 16, 139, 85, 20, 59, 218, 125, 9, 184, 1, 0, 0, 0, 235, 19, 235, 15, 59, 218, 117, 11, 59, 193, 115, 7, 184, 1, 0, 0, 0, 235, 2, 51, 192, 90, 89, 91, 201, 194, 16, 0 })
    
99. ' push ebx
    
100. ' push ecx
     
101. ' push edx
     
102. ' mov eax,[ebp+8]
     
103. ' mov ebx,[ebp+12]
     
104. ' mov ecx,[ebp+16]
     
105. ' mov edx,[ebp+20]
     
106. ' .if sdword ptr ebx < edx
     
107. ' mov eax,1
     
108. ' jmp ASM_END
     
109. ' .elseif ebx == edx && eax < ecx
     
110. ' mov eax,1
     
111. ' jmp ASM_END
     
112. ' .endif
     
113. ' xor eax,eax
     
114. ' ASM_END:
     
115. ' pop edx
     
116. ' pop ecx
     
117. ' pop ebx
     
118. ' leave
     
119. ' retn 16
     
120. 返回 (假)
     
121. 
     
122. .子程序 长整数型_大于等于, 逻辑型, 公开
     
123. .参数 被比较值, 长整数型
     
124. .参数 比较值, 长整数型
     
125. 
     
126. 置入代码 ({ 83, 81, 82, 139, 69, 8, 139, 93, 12, 139, 77, 16, 139, 85, 20, 59, 218, 127, 8, 59, 193, 117, 13, 59, 218, 117, 9, 184, 1, 0, 0, 0, 235, 19, 235, 15, 59, 218, 117, 11, 59, 193, 118, 7, 184, 1, 0, 0, 0, 235, 2, 51, 192, 90, 89, 91, 201, 194, 16, 0 })
     
127. ' push ebx
     
128. ' push ecx
     
129. ' push edx
     
130. ' mov eax,[ebp+8]
     
131. ' mov ebx,[ebp+12]
     
132. ' mov ecx,[ebp+16]
     
133. ' mov edx,[ebp+20]
     
134. ' .if sdword ptr ebx > edx || (eax == ecx && ebx == edx)
     
135. ' mov eax,1
     
136. ' jmp ASM_END
     
137. ' .elseif ebx == edx && eax > ecx
     
138. ' mov eax,1
     
139. ' jmp ASM_END
     
140. ' .endif
     
141. ' xor eax,eax
     
142. ' ASM_END:
     
143. ' pop edx
     
144. ' pop ecx
     
145. ' pop ebx
     
146. ' leave
     
147. ' retn 16
     
148. 
     
149. 返回 (假)
     
150. 
     
151. .子程序 长整数型_小于等于, 逻辑型, 公开
     
152. .参数 被比较值, 长整数型
     
153. .参数 比较值, 长整数型
     
154. 
     
155. 置入代码 ({ 83, 81, 82, 139, 69, 8, 139, 93, 12, 139, 77, 16, 139, 85, 20, 59, 218, 124, 8, 59, 193, 117, 13, 59, 218, 117, 9, 184, 1, 0, 0, 0, 235, 19, 235, 15, 59, 218, 117, 11, 59, 193, 115, 7, 184, 1, 0, 0, 0, 235, 2, 51, 192, 90, 89, 91, 201, 194, 16, 0 })
     
156. ' push ebx
     
157. ' push ecx
     
158. ' push edx
     
159. ' mov eax,[ebp+8]
     
160. ' mov ebx,[ebp+12]
     
161. ' mov ecx,[ebp+16]
     
162. ' mov edx,[ebp+20]
     
163. ' .if sdword ptr ebx < edx || (eax == ecx && ebx == edx)
     
164. ' mov eax,1
     
165. ' jmp ASM_END
     
166. ' .elseif ebx == edx && eax < ecx
     
167. ' mov eax,1
     
168. ' jmp ASM_END
     
169. ' .endif
     
170. ' xor eax,eax
     
171. ' ASM_END:
     
172. ' pop edx
     
173. ' pop ecx
     
174. ' pop ebx
     
175. ' leave
     
176. ' retn 16
     
177. 返回 (假)
     
178. 
     
179. .子程序 长整数型_等于, 逻辑型, 公开
     
180. .参数 被比较值, 长整数型
     
181. .参数 比较值, 长整数型
     
182. 
     
183. 置入代码 ({ 83, 139, 69, 8, 139, 93, 12, 59, 69, 16, 117, 12, 59, 93, 20, 117, 7, 184, 1, 0, 0, 0, 235, 2, 51, 192, 91, 201, 194, 16, 0 })
     
184. ' push ebx
     
185. ' mov eax,[ebp+8]
     
186. ' mov ebx,[ebp+12]
     
187. ' .if eax == [ebp+16] && ebx == [ebp+20]
     
188. ' mov eax,1
     
189. ' .else
     
190. ' xor eax,eax
     
191. ' .endif
     
192. ' pop ebx
     
193. ' leave
     
194. ' retn 16
     
195. 返回 (假)
     
196. 
     
197. .子程序 取随机长整数, 长整数型
     
198. .局部变量 字节集, 字节集
     
199. .局部变量 计数, 整数型
     
200. 
     
201. 字节集 ＝ 取空白字节集 (8)
     
202. .计次循环首 (8, 计数)
     
203.     字节集 [计数] ＝ 取随机数 (, )
     
204. .计次循环尾 ()
     
205. 返回 (取字节集数据 (字节集, #长整数型, ))
     

复制代码