易语言MASM置入代码实现逻辑门运算:与,或,非,与非,或非,异或,同或 (返回逻辑型)

EAX

1. .版本 2
   
2. .支持库 spec
   
3. 
   
4. .程序集 程序集1
   
5. 
   
6. .子程序 _启动子程序, 整数型, , 请在本子程序中放置易模块初始化代码
   
7. 
   
8. 
   
9. _临时子程序 ()  ' 在初始化代码执行完毕后调用测试代码
   
10. 返回 (0)  ' 可以根据您的需要返回任意数值
    
11. 
    
12. .子程序 _临时子程序
    
13. 
    
14. ' 本名称子程序用作测试程序用，仅在开发及调试环境中有效，编译发布程序前将被系统自动清空，请将所有用作测试的临时代码放在本子程序中。 ***注意不要修改本子程序的名称、参数及返回值类型。
    
15. 调试输出 (逻辑与 (假, 假), 逻辑或 (假, 假), 逻辑与非 (假, 假), 逻辑或非 (假, 假), 逻辑异或 (假, 假), 逻辑同或 (假, 假))
    
16. 调试输出 (逻辑与 (假, 真), 逻辑或 (假, 真), 逻辑与非 (假, 真), 逻辑或非 (假, 真), 逻辑异或 (假, 真), 逻辑同或 (假, 真))
    
17. 调试输出 (逻辑与 (真, 假), 逻辑或 (真, 假), 逻辑与非 (真, 假), 逻辑或非 (真, 假), 逻辑异或 (真, 假), 逻辑同或 (真, 假))
    
18. 调试输出 (逻辑与 (真, 真), 逻辑或 (真, 真), 逻辑与非 (真, 真), 逻辑或非 (真, 真), 逻辑异或 (真, 真), 逻辑同或 (真, 真))
    
19. 调试输出 (逻辑非 (假))
    
20. 调试输出 (逻辑非 (真))
    
21. 
    
22. 
    
23. .子程序 逻辑与, 逻辑型, 公开
    
24. .参数 A, 逻辑型
    
25. .参数 B, 逻辑型
    
26. 
    
27. 置入代码 ({ 82, 139, 69, 8, 139, 85, 12, 131, 248, 1, 117, 12, 131, 250, 1, 117, 7, 184, 1, 0, 0, 0, 235, 2, 51, 192, 90, 201, 194, 8, 0 })
    
28. ' push edx
    
29. ' mov eax,[ebp+8]
    
30. ' mov edx,[ebp+12]
    
31. ' .if eax == 1 && edx == 1
    
32. ' mov eax,1
    
33. ' .else
    
34. ' xor eax,eax
    
35. ' .endif
    
36. ' pop edx
    
37. ' leave
    
38. ' retn 8
    
39. 返回 (假)
    
40. 
    
41. .子程序 逻辑或, 逻辑型, 公开
    
42. .参数 A, 逻辑型
    
43. .参数 B, 逻辑型
    
44. 
    
45. 置入代码 ({ 82, 139, 69, 8, 139, 85, 12, 131, 248, 1, 116, 5, 131, 250, 1, 117, 7, 184, 1, 0, 0, 0, 235, 2, 51, 192, 90, 201, 194, 8, 0 })
    
46. ' push edx
    
47. ' mov eax,[ebp+8]
    
48. ' mov edx,[ebp+12]
    
49. ' .if eax == 1 || edx == 1
    
50. ' mov eax,1
    
51. ' .else
    
52. ' xor eax,eax
    
53. ' .endif
    
54. ' pop edx
    
55. ' leave
    
56. ' retn 8
    
57. 返回 (假)
    
58. 
    
59. .子程序 逻辑非, 逻辑型, 公开
    
60. .参数 A, 逻辑型
    
61. 
    
62. 置入代码 ({ 139, 69, 8, 131, 248, 1, 117, 4, 51, 192, 235, 5, 184, 1, 0, 0, 0, 201, 194, 4, 0 })
    
63. ' mov eax,[ebp+8]
    
64. ' .if eax == 1
    
65. ' xor eax,eax
    
66. ' .else
    
67. ' mov eax,1
    
68. ' .endif
    
69. ' leave
    
70. ' retn 4
    
71. 返回 (假)
    
72. 
    
73. .子程序 逻辑与非, 逻辑型, 公开
    
74. .参数 A, 逻辑型
    
75. .参数 B, 逻辑型
    
76. 
    
77. 置入代码 ({ 82, 139, 69, 8, 139, 85, 12, 131, 248, 1, 117, 9, 131, 250, 1, 117, 4, 51, 192, 235, 5, 184, 1, 0, 0, 0, 90, 201, 194, 8, 0 })
    
78. ' push edx
    
79. ' mov eax,[ebp+8]
    
80. ' mov edx,[ebp+12]
    
81. ' .if eax == 1 && edx == 1
    
82. ' xor eax,eax
    
83. ' .else
    
84. ' mov eax,1
    
85. ' .endif
    
86. ' pop edx
    
87. ' leave
    
88. ' retn 8
    
89. 返回 (假)
    
90. 
    
91. .子程序 逻辑或非, 逻辑型, 公开
    
92. .参数 A, 逻辑型
    
93. .参数 B, 逻辑型
    
94. 
    
95. 置入代码 ({ 82, 139, 69, 8, 139, 85, 12, 131, 248, 1, 116, 5, 131, 250, 1, 117, 4, 51, 192, 235, 5, 184, 1, 0, 0, 0, 90, 201, 194, 8, 0 })
    
96. ' push edx
    
97. ' mov eax,[ebp+8]
    
98. ' mov edx,[ebp+12]
    
99. ' .if eax == 1 || edx == 1
    
100. ' xor eax,eax
     
101. ' .else
     
102. ' mov eax,1
     
103. ' .endif
     
104. ' pop edx
     
105. ' leave
     
106. ' retn 8
     
107. 返回 (假)
     
108. 
     
109. .子程序 逻辑异或, 逻辑型, 公开
     
110. .参数 A, 逻辑型
     
111. .参数 B, 逻辑型
     
112. 
     
113. 置入代码 ({ 139, 69, 8, 59, 69, 12, 116, 7, 184, 1, 0, 0, 0, 235, 2, 51, 192, 201, 194, 8, 0 })
     
114. ' mov eax,[ebp+8]
     
115. ' .if eax != [ebp+12]
     
116. ' mov eax,1
     
117. ' .else
     
118. ' xor eax,eax
     
119. ' .endif
     
120. ' leave
     
121. ' retn 8
     
122. 返回 (假)
     
123. 
     
124. .子程序 逻辑同或, 逻辑型, 公开
     
125. .参数 A, 逻辑型
     
126. .参数 B, 逻辑型
     
127. 
     
128. 置入代码 ({ 139, 69, 8, 59, 69, 12, 117, 7, 184, 1, 0, 0, 0, 235, 2, 51, 192, 201, 194, 8, 0 })
     
129. ' mov eax,[ebp+8]
     
130. ' .if eax == [ebp+12]
     
131. ' mov eax,1
     
132. ' .else
     
133. ' xor eax,eax
     
134. ' .endif
     
135. ' leave
     
136. ' retn 8
     
137. 
     
138. 返回 (假)
     

复制代码