免扫码快速登录设为首页收藏本站帮助中心
查看: 114|回复: 0
收起左侧

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

[复制链接]
发表于 2019-9-28 13:00:00 |阅读模式

马上注册,结交更多好友,享用更多功能,让你轻松玩转社区。

您需要 登录 才可以下载或查看,没有帐号?加入我们

x

  1. .版本 2

  2. .程序集 程序集1

  3. .子程序 _启动子程序, 整数型, , 请在本子程序中放置易模块初始化代码


  4. _临时子程序 ()  ' 在初始化代码执行完毕后调用测试代码
  5. 返回 (0)  ' 可以根据您的需要返回任意数值

  6. .子程序 _临时子程序
  7. .局部变量 字节型, 字节型
  8. .局部变量 整数型, 整数型
  9. .局部变量 短整数型, 短整数型
  10. .局部变量 长整数型, 长整数型

  11. ' 本名称子程序用作测试程序用,仅在开发及调试环境中有效,编译发布程序前将被系统自动清空,请将所有用作测试的临时代码放在本子程序中。 ***注意不要修改本子程序的名称、参数及返回值类型。
  12. 字节型 = 123
  13. 输出调试文本 (字节型_前自增 (字节型))
  14. 输出调试文本 (字节型)
  15. 字节型 = 100
  16. 输出调试文本 (字节型_后自增 (字节型))
  17. 输出调试文本 (字节型)
  18. 字节型 = 234
  19. 输出调试文本 (字节型_前自减 (字节型))
  20. 输出调试文本 (字节型)
  21. 字节型 = 200
  22. 输出调试文本 (字节型_后自减 (字节型))
  23. 输出调试文本 (字节型)
  24. 输出调试文本 (“=====================”)
  25. 整数型 = 1234567890
  26. 输出调试文本 (整数型_前自增 (整数型))
  27. 输出调试文本 (整数型)
  28. 整数型 = 1000000000
  29. 输出调试文本 (整数型_后自增 (整数型))
  30. 输出调试文本 (整数型)
  31. 整数型 = 1000100100
  32. 输出调试文本 (整数型_前自减 (整数型))
  33. 输出调试文本 (整数型)
  34. 整数型 = 200200200
  35. 输出调试文本 (整数型_后自减 (整数型))
  36. 输出调试文本 (整数型)
  37. 输出调试文本 (“=====================”)
  38. 短整数型 = 12345
  39. 输出调试文本 (短整数型_前自增 (短整数型))
  40. 输出调试文本 (短整数型)
  41. 短整数型 = 10000
  42. 输出调试文本 (短整数型_后自增 (短整数型))
  43. 输出调试文本 (短整数型)
  44. 短整数型 = 23456
  45. 输出调试文本 (短整数型_前自减 (短整数型))
  46. 输出调试文本 (短整数型)
  47. 短整数型 = 11111
  48. 输出调试文本 (短整数型_后自减 (短整数型))
  49. 输出调试文本 (短整数型)
  50. 输出调试文本 (“=====================”)

  51. 长整数型 = 到长整数 (“1234567890123456789”)
  52. 输出调试文本 (长整数型_前自增 (长整数型))
  53. 输出调试文本 (长整数型)
  54. 长整数型 = 到长整数 (“1111111111111111111”)
  55. 输出调试文本 (长整数型_后自增 (长整数型))
  56. 输出调试文本 (长整数型)
  57. 长整数型 = 到长整数 (“1234567890123456789”)
  58. 输出调试文本 (长整数型_前自减 (长整数型))
  59. 输出调试文本 (长整数型)
  60. 长整数型 = 到长整数 (“1111111111111111111”)
  61. 输出调试文本 (长整数型_后自减 (长整数型))
  62. 输出调试文本 (长整数型)


  63. .子程序 字节型_前自增, 字节型, 公开, 先加1后返回
  64. .参数 数值, 字节型, 参考

  65. 置入代码 ({ 83, 139, 93, 8, 138, 3, 254, 192, 136, 3, 37, 255, 0, 0, 0, 91, 201, 194, 4, 0 })
  66. ' push ebx
  67. ' mov ebx,[ebp+8]
  68. ' mov al,[ebx]
  69. ' inc al
  70. ' mov [ebx],al
  71. ' and eax,255
  72. ' pop ebx
  73. ' leave
  74. ' retn 4

  75. 返回 (0)

  76. .子程序 字节型_后自增, 字节型, 公开, 先返回后加1
  77. .参数 数值, 字节型, 参考

  78. 置入代码 ({ 83, 139, 93, 8, 138, 3, 254, 192, 136, 3, 254, 200, 37, 255, 0, 0, 0, 91, 201, 194, 4, 0 })
  79. ' push ebx
  80. ' mov ebx,[ebp+8]
  81. ' mov al,[ebx]
  82. ' inc al
  83. ' mov [ebx],al
  84. ' dec al
  85. ' and eax,255
  86. ' pop ebx
  87. ' leave
  88. ' retn 4
  89. 返回 (0)

  90. .子程序 字节型_前自减, 字节型, 公开, 先减1后返回
  91. .参数 数值, 字节型, 参考

  92. 置入代码 ({ 83, 139, 93, 8, 138, 3, 254, 200, 136, 3, 37, 255, 0, 0, 0, 91, 201, 194, 4, 0 })
  93. ' push ebx
  94. ' mov ebx,[ebp+8]
  95. ' mov al,[ebx]
  96. ' dec al
  97. ' mov [ebx],al
  98. ' and eax,255
  99. ' pop ebx
  100. ' leave
  101. ' retn 4
  102. 返回 (0)

  103. .子程序 字节型_后自减, 字节型, 公开, 先返回后减1
  104. .参数 数值, 字节型, 参考

  105. 置入代码 ({ 83, 139, 93, 8, 138, 3, 254, 200, 136, 3, 254, 192, 37, 255, 0, 0, 0, 91, 201, 194, 4, 0 })
  106. ' push ebx
  107. ' mov ebx,[ebp+8]
  108. ' mov al,[ebx]
  109. ' dec al
  110. ' mov [ebx],al
  111. ' inc al
  112. ' and eax,255
  113. ' pop ebx
  114. ' leave
  115. ' retn 4
  116. 返回 (0)

  117. .子程序 整数型_前自增, 整数型, 公开
  118. .参数 数值, 整数型, 参考

  119. 置入代码 ({ 83, 139, 93, 8, 139, 3, 64, 137, 3, 91, 201, 194, 4, 0 })
  120. ' push ebx
  121. ' mov ebx,[ebp+8]
  122. ' mov eax,[ebx]
  123. ' inc eax
  124. ' mov [ebx],eax
  125. ' pop ebx
  126. ' leave
  127. ' retn 4
  128. 返回 (0)

  129. .子程序 整数型_后自增, 整数型, 公开
  130. .参数 数值, 整数型, 参考

  131. 置入代码 ({ 83, 139, 93, 8, 139, 3, 64, 137, 3, 72, 91, 201, 194, 4, 0 })
  132. ' push ebx
  133. ' mov ebx,[ebp+8]
  134. ' mov eax,[ebx]
  135. ' inc eax
  136. ' mov [ebx],eax
  137. ' dec eax
  138. ' pop ebx
  139. ' leave
  140. ' retn 4
  141. 返回 (0)

  142. .子程序 整数型_前自减, 整数型, 公开
  143. .参数 数值, 整数型, 参考

  144. 置入代码 ({ 83, 139, 93, 8, 139, 3, 72, 137, 3, 91, 201, 194, 4, 0 })
  145. ' push ebx
  146. ' mov ebx,[ebp+8]
  147. ' mov eax,[ebx]
  148. ' dec eax
  149. ' mov [ebx],eax
  150. ' pop ebx
  151. ' leave
  152. ' retn 4
  153. 返回 (0)

  154. .子程序 整数型_后自减, 整数型, 公开
  155. .参数 数值, 整数型, 参考

  156. 置入代码 ({ 83, 139, 93, 8, 139, 3, 72, 137, 3, 64, 91, 201, 194, 4, 0 })
  157. ' push ebx
  158. ' mov ebx,[ebp+8]
  159. ' mov eax,[ebx]
  160. ' dec eax
  161. ' mov [ebx],eax
  162. ' inc eax
  163. ' pop ebx
  164. ' leave
  165. ' retn 4
  166. 返回 (0)

  167. .子程序 短整数型_前自增, 短整数型, 公开
  168. .参数 数值, 短整数型, 参考

  169. 置入代码 ({ 83, 139, 93, 8, 102, 139, 3, 102, 64, 102, 137, 3, 37, 255, 255, 0, 0, 91, 201, 194, 4, 0 })
  170. ' push ebx
  171. ' mov ebx,[ebp+8]
  172. ' mov ax,[ebx]
  173. ' inc ax
  174. ' mov [ebx],ax
  175. ' and eax,65535
  176. ' pop ebx
  177. ' leave
  178. ' retn 4



  179. 返回 (0)

  180. .子程序 短整数型_后自增, 短整数型, 公开
  181. .参数 数值, 短整数型, 参考

  182. 置入代码 ({ 83, 139, 93, 8, 102, 139, 3, 102, 64, 102, 137, 3, 102, 72, 37, 255, 255, 0, 0, 91, 201, 194, 4, 0 })
  183. ' push ebx
  184. ' mov ebx,[ebp+8]
  185. ' mov ax,[ebx]
  186. ' inc ax
  187. ' mov [ebx],ax
  188. ' dec ax
  189. ' and eax,65535
  190. ' pop ebx
  191. ' leave
  192. ' retn 4


  193. 返回 (0)

  194. .子程序 短整数型_前自减, 短整数型, 公开
  195. .参数 数值, 短整数型, 参考

  196. 置入代码 ({ 83, 139, 93, 8, 102, 139, 3, 102, 72, 102, 137, 3, 37, 255, 255, 0, 0, 91, 201, 194, 4, 0 })
  197. ' push ebx
  198. ' mov ebx,[ebp+8]
  199. ' mov ax,[ebx]
  200. ' dec ax
  201. ' mov [ebx],ax
  202. ' and eax,65535
  203. ' pop ebx
  204. ' leave
  205. ' retn 4


  206. 返回 (0)

  207. .子程序 短整数型_后自减, 短整数型, 公开
  208. .参数 数值, 短整数型, 参考

  209. 置入代码 ({ 83, 139, 93, 8, 102, 139, 3, 102, 72, 102, 137, 3, 102, 64, 37, 255, 255, 0, 0, 91, 201, 194, 4, 0 })
  210. ' push ebx
  211. ' mov ebx,[ebp+8]
  212. ' mov ax,[ebx]
  213. ' dec ax
  214. ' mov [ebx],ax
  215. ' inc ax
  216. ' and eax,65535
  217. ' pop ebx
  218. ' leave
  219. ' retn 4

  220. 返回 (0)

  221. .子程序 长整数型_前自增, 长整数型, 公开
  222. .参数 数值, 长整数型, 参考

  223. 置入代码 ({ 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 })
  224. ' push ebx
  225. ' mov ebx,[ebp+8]
  226. ' mov eax,[ebx]
  227. ' mov edx,[ebx+4]
  228. ' add eax,1
  229. ' adc edx,0
  230. ' mov [ebx],eax
  231. ' mov [ebx+4],edx
  232. ' pop ebx
  233. ' leave
  234. ' retn 4

  235. 返回 (0)

  236. .子程序 长整数型_后自增, 长整数型, 公开
  237. .参数 数值, 长整数型, 参考

  238. 置入代码 ({ 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 })
  239. ' push ebx
  240. ' mov ebx,[ebp+8]
  241. ' mov eax,[ebx]
  242. ' mov edx,[ebx+4]
  243. ' add eax,1
  244. ' adc edx,0
  245. ' mov [ebx],eax
  246. ' mov [ebx+4],edx
  247. ' sub eax,1
  248. ' sbb edx,0
  249. ' pop ebx
  250. ' leave
  251. ' retn 4


  252. 返回 (0)

  253. .子程序 长整数型_前自减, 长整数型, 公开
  254. .参数 数值, 长整数型, 参考

  255. 置入代码 ({ 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 })
  256. ' push ebx
  257. ' mov ebx,[ebp+8]
  258. ' mov eax,[ebx]
  259. ' mov edx,[ebx+4]
  260. ' sub eax,1
  261. ' sbb edx,0
  262. ' mov [ebx],eax
  263. ' mov [ebx+4],edx
  264. ' pop ebx
  265. ' leave
  266. ' retn 4
  267. 返回 (0)

  268. .子程序 长整数型_后自减, 长整数型, 公开
  269. .参数 数值, 长整数型, 参考

  270. 置入代码 ({ 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 })
  271. ' push ebx
  272. ' mov ebx,[ebp+8]
  273. ' mov eax,[ebx]
  274. ' mov edx,[ebx+4]
  275. ' sub eax,1
  276. ' sbb edx,0
  277. ' mov [ebx],eax
  278. ' mov [ebx+4],edx
  279. ' add eax,1
  280. ' adc edx,0
  281. ' pop ebx
  282. ' leave
  283. ' retn 4
  284. 返回 (0)
复制代码

相关帖子

您需要登录后才可以回帖 登录 | 加入我们

本版积分规则