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

EAX

1. .版本 2
   
2. 
   
3. .程序集 程序集1
   
4. 
   
5. .子程序 _启动子程序, 整数型, , 请在本子程序中放置易模块初始化代码
   
6. 
   
7. 置随机数种子 ()
   
8. _临时子程序 ()  ' 在初始化代码执行完毕后调用测试代码
   
9. 返回 (0)  ' 可以根据您的需要返回任意数值
   
10. 
    
11. .子程序 _临时子程序
    
12. .局部变量 A, 整数型
    
13. .局部变量 B, 整数型
    
14. .局部变量 大于, 逻辑型
    
15. .局部变量 小于, 逻辑型
    
16. .局部变量 大于等于, 逻辑型
    
17. .局部变量 小于等于, 逻辑型
    
18. .局部变量 等于, 逻辑型
    
19. .局部变量 C, 整数型
    
20. 
    
21. .判断循环首 (真)
    
22.     A ＝ 取随机整数 ()
    
23.     B ＝ 取随机整数 ()
    
24.     大于 ＝ A ＞ B
    
25.     小于 ＝ A ＜ B
    
26.     大于等于 ＝ A ≥ B
    
27.     小于等于 ＝ A ≤ B
    
28.     等于 ＝ A ＝ B
    
29.     .判断开始 (整数型_大于 (A, B) ≠ 大于)
    
30.         暂停 ()
    
31.     .判断 (整数型_小于 (A, B) ≠ 小于)
    
32.         暂停 ()
    
33.     .判断 (整数型_大于等于 (A, B) ≠ 大于等于)
    
34.         暂停 ()
    
35.     .判断 (整数型_小于等于 (A, B) ≠ 小于等于)
    
36.         暂停 ()
    
37.     .判断 (整数型_等于 (A, B) ≠ 等于)
    
38.         暂停 ()
    
39.     .默认
    
40. 
    
41.     .判断结束
    
42.     C ＝ C ＋ 1
    
43.     .如果真 (C ≥ 1000000)
    
44.         C ＝ 0
    
45.         输出调试文本 (取现行时间 ())
    
46.     .如果真结束
    
47. 
    
48. .判断循环尾 ()
    
49. 
    
50. 
    
51. 
    
52. 
    
53. 
    
54. .子程序 取随机整数, 整数型
    
55. .局部变量 字节集, 字节集, 静态
    
56. .局部变量 计数, 整数型
    
57. 
    
58. .如果真 (取字节集长度 (字节集) ≠ 4)
    
59.     字节集 ＝ 取空白字节集 (4)
    
60. .如果真结束
    
61. .计次循环首 (4, 计数)
    
62.     字节集 [计数] ＝ 取随机数 (, )
    
63. .计次循环尾 ()
    
64. 
    
65. 返回 (取字节集数据 (字节集, #整数型, ))
    
66. 
    
67. 
    
68. .子程序 整数型_大于, 逻辑型, 公开
    
69. .参数 被比较值, 整数型
    
70. .参数 比较值, 整数型
    
71. 
    
72. 置入代码 ({ 139, 69, 8, 59, 69, 12, 126, 7, 184, 1, 0, 0, 0, 235, 2, 51, 192, 201, 194, 8, 0 })
    
73. ' mov eax,[ebp+8]
    
74. ' .if sdword ptr eax > [ebp+12]
    
75. ' mov eax,1
    
76. ' .else
    
77. ' xor eax,eax
    
78. ' .endif
    
79. ' leave
    
80. ' retn 8
    
81. 返回 (假)
    
82. 
    
83. .子程序 整数型_小于, 逻辑型, 公开
    
84. .参数 被比较值, 整数型
    
85. .参数 比较值, 整数型
    
86. 
    
87. 置入代码 ({ 139, 69, 8, 59, 69, 12, 125, 7, 184, 1, 0, 0, 0, 235, 2, 51, 192, 201, 194, 8, 0 })
    
88. ' mov eax,[ebp+8]
    
89. ' .if sdword ptr eax < [ebp+12]
    
90. ' mov eax,1
    
91. ' .else
    
92. ' xor eax,eax
    
93. ' .endif
    
94. ' leave
    
95. ' retn 8
    
96. 返回 (假)
    
97. 
    
98. .子程序 整数型_大于等于, 逻辑型, 公开
    
99. .参数 被比较值, 整数型
    
100. .参数 比较值, 整数型
     
101. 
     
102. 置入代码 ({ 139, 69, 8, 59, 69, 12, 124, 7, 184, 1, 0, 0, 0, 235, 2, 51, 192, 201, 194, 8, 0 })
     
103. ' mov eax,[ebp+8]
     
104. ' .if sdword ptr eax >= [ebp+12]
     
105. ' mov eax,1
     
106. ' .else
     
107. ' xor eax,eax
     
108. ' .endif
     
109. ' leave
     
110. ' retn 8
     
111. 返回 (假)
     
112. 
     
113. .子程序 整数型_小于等于, 逻辑型, 公开
     
114. .参数 被比较值, 整数型
     
115. .参数 比较值, 整数型
     
116. 
     
117. 置入代码 ({ 139, 69, 8, 59, 69, 12, 127, 7, 184, 1, 0, 0, 0, 235, 2, 51, 192, 201, 194, 8, 0 })
     
118. ' mov eax,[ebp+8]
     
119. ' .if sdword ptr eax <= [ebp+12]
     
120. ' mov eax,1
     
121. ' .else
     
122. ' xor eax,eax
     
123. ' .endif
     
124. ' leave
     
125. ' retn 8
     
126. 返回 (假)
     
127. 
     
128. .子程序 整数型_等于, 逻辑型, 公开
     
129. .参数 被比较值, 整数型
     
130. .参数 比较值, 整数型
     
131. 
     
132. 置入代码 ({ 139, 69, 8, 59, 69, 12, 117, 7, 184, 1, 0, 0, 0, 235, 2, 51, 192, 201, 194, 8, 0 })
     
133. ' mov eax,[ebp+8]
     
134. ' .if eax == [ebp+12]
     
135. ' mov eax,1
     
136. ' .else
     
137. ' xor eax,eax
     
138. ' .endif
     
139. ' leave
     
140. ' retn 8
     
141. 返回 (假)
     

复制代码