易语言MASM置入代码字节型/整数型/短整数型/长整数型变量前自增/后自增/前自减/后自减

QAQ

1. 
   
2. .版本 2
   
3. 
   
4. .程序集 程序集1
   
5. 
   
6. .子程序 _启动子程序, 整数型, , 请在本子程序中放置易模块初始化代码
   
7. 
   
8. 
   
9. _临时子程序 ()  ' 在初始化代码执行完毕后调用测试代码
   
10. 返回 (0)  ' 可以根据您的需要返回任意数值
    
11. 
    
12. .子程序 _临时子程序
    
13. .局部变量 字节型, 字节型
    
14. .局部变量 整数型, 整数型
    
15. .局部变量 短整数型, 短整数型
    
16. .局部变量 长整数型, 长整数型
    
17. 
    
18. ' 本名称子程序用作测试程序用，仅在开发及调试环境中有效，编译发布程序前将被系统自动清空，请将所有用作测试的临时代码放在本子程序中。 ***注意不要修改本子程序的名称、参数及返回值类型。
    
19. 字节型 ＝ 123
    
20. 输出调试文本 (字节型_前自增 (字节型))
    
21. 输出调试文本 (字节型)
    
22. 字节型 ＝ 100
    
23. 输出调试文本 (字节型_后自增 (字节型))
    
24. 输出调试文本 (字节型)
    
25. 字节型 ＝ 234
    
26. 输出调试文本 (字节型_前自减 (字节型))
    
27. 输出调试文本 (字节型)
    
28. 字节型 ＝ 200
    
29. 输出调试文本 (字节型_后自减 (字节型))
    
30. 输出调试文本 (字节型)
    
31. 输出调试文本 (“=====================”)
    
32. 整数型 ＝ 1234567890
    
33. 输出调试文本 (整数型_前自增 (整数型))
    
34. 输出调试文本 (整数型)
    
35. 整数型 ＝ 1000000000
    
36. 输出调试文本 (整数型_后自增 (整数型))
    
37. 输出调试文本 (整数型)
    
38. 整数型 ＝ 1000100100
    
39. 输出调试文本 (整数型_前自减 (整数型))
    
40. 输出调试文本 (整数型)
    
41. 整数型 ＝ 200200200
    
42. 输出调试文本 (整数型_后自减 (整数型))
    
43. 输出调试文本 (整数型)
    
44. 输出调试文本 (“=====================”)
    
45. 短整数型 ＝ 12345
    
46. 输出调试文本 (短整数型_前自增 (短整数型))
    
47. 输出调试文本 (短整数型)
    
48. 短整数型 ＝ 10000
    
49. 输出调试文本 (短整数型_后自增 (短整数型))
    
50. 输出调试文本 (短整数型)
    
51. 短整数型 ＝ 23456
    
52. 输出调试文本 (短整数型_前自减 (短整数型))
    
53. 输出调试文本 (短整数型)
    
54. 短整数型 ＝ 11111
    
55. 输出调试文本 (短整数型_后自减 (短整数型))
    
56. 输出调试文本 (短整数型)
    
57. 输出调试文本 (“=====================”)
    
58. 
    
59. 长整数型 ＝ 到长整数 (“1234567890123456789”)
    
60. 输出调试文本 (长整数型_前自增 (长整数型))
    
61. 输出调试文本 (长整数型)
    
62. 长整数型 ＝ 到长整数 (“1111111111111111111”)
    
63. 输出调试文本 (长整数型_后自增 (长整数型))
    
64. 输出调试文本 (长整数型)
    
65. 长整数型 ＝ 到长整数 (“1234567890123456789”)
    
66. 输出调试文本 (长整数型_前自减 (长整数型))
    
67. 输出调试文本 (长整数型)
    
68. 长整数型 ＝ 到长整数 (“1111111111111111111”)
    
69. 输出调试文本 (长整数型_后自减 (长整数型))
    
70. 输出调试文本 (长整数型)
    
71. 
    
72. 
    
73. .子程序 字节型_前自增, 字节型, 公开, 先加1后返回
    
74. .参数 数值, 字节型, 参考
    
75. 
    
76. 置入代码 ({ 83, 139, 93, 8, 138, 3, 254, 192, 136, 3, 37, 255, 0, 0, 0, 91, 201, 194, 4, 0 })
    
77. ' push ebx
    
78. ' mov ebx,[ebp+8]
    
79. ' mov al,[ebx]
    
80. ' inc al
    
81. ' mov [ebx],al
    
82. ' and eax,255
    
83. ' pop ebx
    
84. ' leave
    
85. ' retn 4
    
86. 
    
87. 返回 (0)
    
88. 
    
89. .子程序 字节型_后自增, 字节型, 公开, 先返回后加1
    
90. .参数 数值, 字节型, 参考
    
91. 
    
92. 置入代码 ({ 83, 139, 93, 8, 138, 3, 254, 192, 136, 3, 254, 200, 37, 255, 0, 0, 0, 91, 201, 194, 4, 0 })
    
93. ' push ebx
    
94. ' mov ebx,[ebp+8]
    
95. ' mov al,[ebx]
    
96. ' inc al
    
97. ' mov [ebx],al
    
98. ' dec al
    
99. ' and eax,255
    
100. ' pop ebx
     
101. ' leave
     
102. ' retn 4
     
103. 返回 (0)
     
104. 
     
105. .子程序 字节型_前自减, 字节型, 公开, 先减1后返回
     
106. .参数 数值, 字节型, 参考
     
107. 
     
108. 置入代码 ({ 83, 139, 93, 8, 138, 3, 254, 200, 136, 3, 37, 255, 0, 0, 0, 91, 201, 194, 4, 0 })
     
109. ' push ebx
     
110. ' mov ebx,[ebp+8]
     
111. ' mov al,[ebx]
     
112. ' dec al
     
113. ' mov [ebx],al
     
114. ' and eax,255
     
115. ' pop ebx
     
116. ' leave
     
117. ' retn 4
     
118. 返回 (0)
     
119. 
     
120. .子程序 字节型_后自减, 字节型, 公开, 先返回后减1
     
121. .参数 数值, 字节型, 参考
     
122. 
     
123. 置入代码 ({ 83, 139, 93, 8, 138, 3, 254, 200, 136, 3, 254, 192, 37, 255, 0, 0, 0, 91, 201, 194, 4, 0 })
     
124. ' push ebx
     
125. ' mov ebx,[ebp+8]
     
126. ' mov al,[ebx]
     
127. ' dec al
     
128. ' mov [ebx],al
     
129. ' inc al
     
130. ' and eax,255
     
131. ' pop ebx
     
132. ' leave
     
133. ' retn 4
     
134. 返回 (0)
     
135. 
     
136. .子程序 整数型_前自增, 整数型, 公开
     
137. .参数 数值, 整数型, 参考
     
138. 
     
139. 置入代码 ({ 83, 139, 93, 8, 139, 3, 64, 137, 3, 91, 201, 194, 4, 0 })
     
140. ' push ebx
     
141. ' mov ebx,[ebp+8]
     
142. ' mov eax,[ebx]
     
143. ' inc eax
     
144. ' mov [ebx],eax
     
145. ' pop ebx
     
146. ' leave
     
147. ' retn 4
     
148. 返回 (0)
     
149. 
     
150. .子程序 整数型_后自增, 整数型, 公开
     
151. .参数 数值, 整数型, 参考
     
152. 
     
153. 置入代码 ({ 83, 139, 93, 8, 139, 3, 64, 137, 3, 72, 91, 201, 194, 4, 0 })
     
154. ' push ebx
     
155. ' mov ebx,[ebp+8]
     
156. ' mov eax,[ebx]
     
157. ' inc eax
     
158. ' mov [ebx],eax
     
159. ' dec eax
     
160. ' pop ebx
     
161. ' leave
     
162. ' retn 4
     
163. 返回 (0)
     
164. 
     
165. .子程序 整数型_前自减, 整数型, 公开
     
166. .参数 数值, 整数型, 参考
     
167. 
     
168. 置入代码 ({ 83, 139, 93, 8, 139, 3, 72, 137, 3, 91, 201, 194, 4, 0 })
     
169. ' push ebx
     
170. ' mov ebx,[ebp+8]
     
171. ' mov eax,[ebx]
     
172. ' dec eax
     
173. ' mov [ebx],eax
     
174. ' pop ebx
     
175. ' leave
     
176. ' retn 4
     
177. 返回 (0)
     
178. 
     
179. .子程序 整数型_后自减, 整数型, 公开
     
180. .参数 数值, 整数型, 参考
     
181. 
     
182. 置入代码 ({ 83, 139, 93, 8, 139, 3, 72, 137, 3, 64, 91, 201, 194, 4, 0 })
     
183. ' push ebx
     
184. ' mov ebx,[ebp+8]
     
185. ' mov eax,[ebx]
     
186. ' dec eax
     
187. ' mov [ebx],eax
     
188. ' inc eax
     
189. ' pop ebx
     
190. ' leave
     
191. ' retn 4
     
192. 返回 (0)
     
193. 
     
194. .子程序 短整数型_前自增, 短整数型, 公开
     
195. .参数 数值, 短整数型, 参考
     
196. 
     
197. 置入代码 ({ 83, 139, 93, 8, 102, 139, 3, 102, 64, 102, 137, 3, 37, 255, 255, 0, 0, 91, 201, 194, 4, 0 })
     
198. ' push ebx
     
199. ' mov ebx,[ebp+8]
     
200. ' mov ax,[ebx]
     
201. ' inc ax
     
202. ' mov [ebx],ax
     
203. ' and eax,65535
     
204. ' pop ebx
     
205. ' leave
     
206. ' retn 4
     
207. 
     
208. 
     
209. 
     
210. 返回 (0)
     
211. 
     
212. .子程序 短整数型_后自增, 短整数型, 公开
     
213. .参数 数值, 短整数型, 参考
     
214. 
     
215. 置入代码 ({ 83, 139, 93, 8, 102, 139, 3, 102, 64, 102, 137, 3, 102, 72, 37, 255, 255, 0, 0, 91, 201, 194, 4, 0 })
     
216. ' push ebx
     
217. ' mov ebx,[ebp+8]
     
218. ' mov ax,[ebx]
     
219. ' inc ax
     
220. ' mov [ebx],ax
     
221. ' dec ax
     
222. ' and eax,65535
     
223. ' pop ebx
     
224. ' leave
     
225. ' retn 4
     
226. 
     
227. 
     
228. 返回 (0)
     
229. 
     
230. .子程序 短整数型_前自减, 短整数型, 公开
     
231. .参数 数值, 短整数型, 参考
     
232. 
     
233. 置入代码 ({ 83, 139, 93, 8, 102, 139, 3, 102, 72, 102, 137, 3, 37, 255, 255, 0, 0, 91, 201, 194, 4, 0 })
     
234. ' push ebx
     
235. ' mov ebx,[ebp+8]
     
236. ' mov ax,[ebx]
     
237. ' dec ax
     
238. ' mov [ebx],ax
     
239. ' and eax,65535
     
240. ' pop ebx
     
241. ' leave
     
242. ' retn 4
     
243. 
     
244. 
     
245. 返回 (0)
     
246. 
     
247. .子程序 短整数型_后自减, 短整数型, 公开
     
248. .参数 数值, 短整数型, 参考
     
249. 
     
250. 置入代码 ({ 83, 139, 93, 8, 102, 139, 3, 102, 72, 102, 137, 3, 102, 64, 37, 255, 255, 0, 0, 91, 201, 194, 4, 0 })
     
251. ' push ebx
     
252. ' mov ebx,[ebp+8]
     
253. ' mov ax,[ebx]
     
254. ' dec ax
     
255. ' mov [ebx],ax
     
256. ' inc ax
     
257. ' and eax,65535
     
258. ' pop ebx
     
259. ' leave
     
260. ' retn 4
     
261. 
     
262. 返回 (0)
     
263. 
     
264. .子程序 长整数型_前自增, 长整数型, 公开
     
265. .参数 数值, 长整数型, 参考
     
266. 
     
267. 置入代码 ({ 83, 139, 93, 8, 139, 3, 139, 83, 4, 131, 192, 1, 131, 210, 0, 137, 3, 137, 83, 4, 91, 201, 194, 4, 0 })
     
268. ' push ebx
     
269. ' mov ebx,[ebp+8]
     
270. ' mov eax,[ebx]
     
271. ' mov edx,[ebx+4]
     
272. ' add eax,1
     
273. ' adc edx,0
     
274. ' mov [ebx],eax
     
275. ' mov [ebx+4],edx
     
276. ' pop ebx
     
277. ' leave
     
278. ' retn 4
     
279. 
     
280. 返回 (0)
     
281. 
     
282. .子程序 长整数型_后自增, 长整数型, 公开
     
283. .参数 数值, 长整数型, 参考
     
284. 
     
285. 置入代码 ({ 83, 139, 93, 8, 139, 3, 139, 83, 4, 131, 192, 1, 131, 210, 0, 137, 3, 137, 83, 4, 131, 232, 1, 131, 218, 0, 91, 201, 194, 4, 0 })
     
286. ' push ebx
     
287. ' mov ebx,[ebp+8]
     
288. ' mov eax,[ebx]
     
289. ' mov edx,[ebx+4]
     
290. ' add eax,1
     
291. ' adc edx,0
     
292. ' mov [ebx],eax
     
293. ' mov [ebx+4],edx
     
294. ' sub eax,1
     
295. ' sbb edx,0
     
296. ' pop ebx
     
297. ' leave
     
298. ' retn 4
     
299. 
     
300. 
     
301. 返回 (0)
     
302. 
     
303. .子程序 长整数型_前自减, 长整数型, 公开
     
304. .参数 数值, 长整数型, 参考
     
305. 
     
306. 置入代码 ({ 83, 139, 93, 8, 139, 3, 139, 83, 4, 131, 232, 1, 131, 218, 0, 137, 3, 137, 83, 4, 91, 201, 194, 4, 0 })
     
307. ' push ebx
     
308. ' mov ebx,[ebp+8]
     
309. ' mov eax,[ebx]
     
310. ' mov edx,[ebx+4]
     
311. ' sub eax,1
     
312. ' sbb edx,0
     
313. ' mov [ebx],eax
     
314. ' mov [ebx+4],edx
     
315. ' pop ebx
     
316. ' leave
     
317. ' retn 4
     
318. 返回 (0)
     
319. 
     
320. .子程序 长整数型_后自减, 长整数型, 公开
     
321. .参数 数值, 长整数型, 参考
     
322. 
     
323. 置入代码 ({ 83, 139, 93, 8, 139, 3, 139, 83, 4, 131, 232, 1, 131, 218, 0, 137, 3, 137, 83, 4, 131, 192, 1, 131, 210, 0, 91, 201, 194, 4, 0 })
     
324. ' push ebx
     
325. ' mov ebx,[ebp+8]
     
326. ' mov eax,[ebx]
     
327. ' mov edx,[ebx+4]
     
328. ' sub eax,1
     
329. ' sbb edx,0
     
330. ' mov [ebx],eax
     
331. ' mov [ebx+4],edx
     
332. ' add eax,1
     
333. ' adc edx,0
     
334. ' pop ebx
     
335. ' leave
     
336. ' retn 4
     
337. 返回 (0)
     

复制代码