API tools faq
paste
Guest User

Untitled

a guest
Apr 23rd, 2018
73
0
Never
Add comment
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
text 14.91 KB | None | 0 0
raw download clone embed print report
  1. #include once "vb_hacks.bi"
  2.  
  3. #include once "fbmodMain.bi"
  4. #include once "fbmodZ80.bi"
  5.  
  6. #include once "debug.bi"
  7.  
  8. Sub execute_id_cb(byref op As Long, ByVal z As Long)
  9.  
  10. select case as const op
  11. case 0
  12. ' 000 RLC B
  13. op = rlc(peekb(z))
  14. regB = op
  15. pokeb z, op
  16. case 1
  17. ' 001 RLC C
  18. op = rlc(peekb(z))
  19. regC = op
  20. pokeb z, op
  21. case 2
  22. ' 002 RLC D
  23. op = rlc(peekb(z))
  24. setD op
  25. pokeb z, op
  26. case 3
  27. ' 003 RLC E
  28. op = rlc(peekb(z))
  29. setE op
  30. pokeb z, op
  31. case 4
  32. ' 004 RLC H
  33. op = rlc(peekb(z))
  34. setH op
  35. pokeb z, op
  36. case 5
  37. ' 005 RLC L
  38. op = rlc(peekb(z))
  39. setL op
  40. pokeb z, op
  41. case 6
  42. ' 006 RLC (HL)
  43. pokeb z, rlc(peekb(z))
  44. case 7
  45. ' 007 RLC A
  46. op = rlc(peekb(z))
  47. regA = op
  48. pokeb z, op
  49. case 8
  50. ' 008 RRC B
  51. op = rrc(peekb(z))
  52. regB = op
  53. pokeb z, op
  54. case 9
  55. ' 009 RRC C
  56. op = rrc(peekb(z))
  57. regC = op
  58. pokeb z, op
  59. case 10
  60. ' 010 RRC D
  61. op = rrc(peekb(z))
  62. setD op
  63. pokeb z, op
  64. case 11
  65. ' 011 RRC E
  66. op = rrc(peekb(z))
  67. setE op
  68. pokeb z, op
  69. case 12
  70. ' 012 RRC H
  71. op = rrc(peekb(z))
  72. setH op
  73. pokeb z, op
  74. case 13
  75. ' 013 RRC L
  76. op = rrc(peekb(z))
  77. setL op
  78. pokeb z, op
  79. case 14
  80. ' 014 RRC (HL)
  81. pokeb z, rrc(peekb(z))
  82. case 15
  83. ' 015 RRC A
  84. op = rrc(peekb(z))
  85. regA = op
  86. pokeb z, op
  87. case 16 ' RL B
  88. op = rl(peekb(z))
  89. regB = op
  90. pokeb z, op
  91. Case 17 ' RL C
  92. op = rl(peekb(z))
  93. regC = op
  94. pokeb z, op
  95. Case 18 ' RL D
  96. op = rl(peekb(z))
  97. setD op
  98. pokeb z, op
  99. Case 19 ' RL E
  100. op = rl(peekb(z))
  101. setE op
  102. pokeb z, op
  103. Case 20 ' RL H
  104. op = rl(peekb(z))
  105. setH op
  106. pokeb z, op
  107. Case 21 ' RL L
  108. op = rl(peekb(z))
  109. setL op
  110. pokeb z, op
  111. Case 22 ' RL (HL)
  112. pokeb z, rl(peekb(z))
  113. Case 23 ' RL A
  114. op = rl(peekb(z))
  115. regA = op
  116. pokeb z, op
  117. Case 24 ' RR B
  118. op = rr(peekb(z))
  119. regB = op
  120. pokeb z, op
  121. Case 25 ' RR C
  122. op = rr(peekb(z))
  123. regC = op
  124. pokeb z, op
  125. Case 26 ' RR D
  126. op = rr(peekb(z))
  127. setD op
  128. pokeb z, op
  129. Case 27 ' RR E
  130. op = rr(peekb(z))
  131. setE op
  132. pokeb z, op
  133. Case 28 ' RR H
  134. op = rr(peekb(z))
  135. setH op
  136. pokeb z, op
  137. Case 29 ' RR L
  138. op = rr(peekb(z))
  139. setL op
  140. pokeb z, op
  141. Case 30 ' RR (HL)
  142. pokeb z, rr(peekb(z))
  143. Case 31 ' RR A
  144. op = rr(peekb(z))
  145. regA = op
  146. pokeb z, op
  147. Case 32 ' SLA B
  148. op = sla(peekb(z))
  149. regB = op
  150. pokeb z, op
  151. Case 33 ' SLA C
  152. op = sla(peekb(z))
  153. regC = op
  154. pokeb z, op
  155. Case 34 ' SLA D
  156. op = sla(peekb(z))
  157. setD op
  158. pokeb z, op
  159. Case 35 ' SLA E
  160. op = sla(peekb(z))
  161. setE op
  162. pokeb z, op
  163. Case 36 ' SLA H
  164. op = sla(peekb(z))
  165. setH op
  166. pokeb z, op
  167. Case 37 ' SLA L
  168. op = sla(peekb(z))
  169. setL op
  170. pokeb z, op
  171. Case 38 ' SLA (HL)
  172. pokeb z, sla(peekb(z))
  173. Case 39 ' SLA A
  174. op = sla(peekb(z))
  175. regA = op
  176. pokeb z, op
  177. Case 40 ' SRA B
  178. op = sra(peekb(z))
  179. regB = op
  180. pokeb z, op
  181. Case 41 ' SRA C
  182. op = sra(peekb(z))
  183. regC = op
  184. pokeb z, op
  185. Case 42 ' SRA D
  186. op = sra(peekb(z))
  187. setD op
  188. pokeb z, op
  189. Case 43 ' SRA E
  190. op = sra(peekb(z))
  191. setE op
  192. pokeb z, op
  193. Case 44 ' SRA H
  194. op = sra(peekb(z))
  195. setH op
  196. pokeb z, op
  197. Case 45 ' SRA L
  198. op = sra(peekb(z))
  199. setL op
  200. pokeb z, op
  201. Case 46 ' SRA (HL)
  202. pokeb z, sra(peekb(z))
  203. Case 47 ' SRA A
  204. op = sra(peekb(z))
  205. regA = op
  206. pokeb z, op
  207. Case 48 ' SLS B
  208. op = sls(peekb(z))
  209. regB = op
  210. pokeb z, op
  211. Case 49 ' SLS C
  212. op = sls(peekb(z))
  213. regC = op
  214. pokeb z, op
  215. Case 50 ' SLS D
  216. op = sls(peekb(z))
  217. setD op
  218. pokeb z, op
  219. Case 51 ' SLS E
  220. op = sls(peekb(z))
  221. setE op
  222. pokeb z, op
  223. Case 52 ' SLS H
  224. op = sls(peekb(z))
  225. setH op
  226. pokeb z, op
  227. Case 53 ' SLS L
  228. op = sls(peekb(z))
  229. setL op
  230. pokeb z, op
  231. Case 54 ' SLS (HL)
  232. pokeb z, sls(peekb(z))
  233. Case 55 ' SLS A
  234. op = sls(peekb(z))
  235. regA = op
  236. pokeb z, op
  237. Case 56 ' SRL B
  238. op = srl(peekb(z))
  239. regB = op
  240. pokeb z, op
  241. Case 57 ' SRL C
  242. op = srl(peekb(z))
  243. regC = op
  244. pokeb z, op
  245. Case 58 ' SRL D
  246. op = srl(peekb(z))
  247. setD op
  248. pokeb z, op
  249. Case 59 ' SRL E
  250. op = srl(peekb(z))
  251. setE op
  252. pokeb z, op
  253. Case 60 ' SRL H
  254. op = srl(peekb(z))
  255. setH op
  256. pokeb z, op
  257. Case 61 ' SRL L
  258. op = srl(peekb(z))
  259. setL op
  260. pokeb z, op
  261. Case 62 ' SRL (ID)
  262. pokeb z, srl(peekb(z))
  263. Case 63 ' SRL A
  264. op = srl(peekb(z))
  265. regA = op
  266. pokeb z, op
  267. case 64 to 71
  268. ' 064 to 071 BIT 0,B
  269. _bit( &H1&, peekb(z) )
  270. case 72 to 79
  271. ' 072 to 079 BIT 1,B
  272. _bit( &H2&, peekb(z) )
  273. case 80 to 87
  274. ' 080 To 087 BIT 2,B
  275. _bit &H4&, peekb(z)
  276. case 88 to 95
  277. ' 088 to 095 BIT 3,B
  278. _bit &H8&, peekb(z)
  279. case 96 to 103
  280. ' 096 to 103 BIT 4,B
  281. _bit &H10&, peekb(z)
  282. case 104 to 111
  283. ' 104 to 111 BIT 5,B
  284. _bit &H20&, peekb(z)
  285. case 112 to 119
  286. ' 112 To 119 BIT 6,B
  287. _bit &H40&, peekb(z)
  288. case 120 to 127
  289. ' 120 to 127 BIT 7,B
  290. _bit &H80&, peekb(z)
  291. Case 128 ' RES 0,(ID+y)->B
  292. regB = _bitres(1, peekb(z))
  293. pokeb z, regB
  294. Case 129 ' RES 0,(ID+y)->C
  295. regC = _bitres(1, peekb(z))
  296. pokeb z, regC
  297. Case 130 ' RES 0,(ID+y)->D
  298. setD _bitres(1, peekb(z))
  299. pokeb z, glMemAddrDiv256(regDE)
  300. Case 131 ' RES 0,(ID+y)->E
  301. setE _bitres(1, peekb(z))
  302. pokeb z, getE
  303. Case 132 ' RES 0,(ID+y)->H
  304. setH _bitres(1, peekb(z))
  305. pokeb z, glMemAddrDiv256(regHL)
  306. Case 133 ' RES 0,(ID+y)->L
  307. setL _bitres(1, peekb(z))
  308. pokeb z, regHL And &HFF&
  309. Case 134 ' RES 0,(HL)
  310. pokeb z, _bitres(&H1&, peekb(z))
  311. Case 135 ' RES 0,(ID+y)->A
  312. regA = _bitres(1, peekb(z))
  313. pokeb z, regA
  314. Case 136 ' RES 1,(ID+y)->B
  315. regB = _bitres(2, peekb(z))
  316. pokeb z, regB
  317. Case 137 ' RES 1,(ID+y)->C
  318. regC = _bitres(2, peekb(z))
  319. pokeb z, regC
  320. Case 138 ' RES 1,(ID+y)->D
  321. setD _bitres(2, peekb(z))
  322. pokeb z, glMemAddrDiv256(regDE)
  323. Case 139 ' RES 1,(ID+y)->E
  324. setE _bitres(2, peekb(z))
  325. pokeb z, getE
  326. Case 140 ' RES 1,(ID+y)->H
  327. setH _bitres(2, peekb(z))
  328. pokeb z, glMemAddrDiv256(regHL)
  329. Case 141 ' RES 1,(ID+y)->L
  330. setL _bitres(2, peekb(z))
  331. pokeb z, getL
  332. Case 142 ' RES 1,(HL)
  333. pokeb z, _bitres(&H2&, peekb(z))
  334. Case 143 ' RES 1,(ID+y)->A
  335. regA = _bitres(2, peekb(z))
  336. pokeb z, regA
  337. Case 144 ' RES 2,(ID+y)->B
  338. regB = _bitres(4, peekb(z))
  339. pokeb z, regB
  340. Case 145 ' RES 2,(ID+y)->C
  341. regC = _bitres(4, peekb(z))
  342. pokeb z, regC
  343. Case 146 ' RES 2,(ID+y)->D
  344. setD _bitres(4, peekb(z))
  345. pokeb z, glMemAddrDiv256(regDE)
  346. Case 147 ' RES 2,(ID+y)->E
  347. setE _bitres(4, peekb(z))
  348. pokeb z, getE
  349. Case 148 ' RES 2,(ID+y)->H
  350. setH _bitres(4, peekb(z))
  351. pokeb z, glMemAddrDiv256(regHL)
  352. Case 149 ' RES 2,(ID+y)->L
  353. setL _bitres(4, peekb(z))
  354. pokeb z, getL
  355. Case 150 ' RES 2,(HL)
  356. pokeb z, _bitres(&H4&, peekb(z))
  357. Case 151 ' RES 2,(ID+y)->A
  358. regA = _bitres(4, peekb(z))
  359. pokeb z, regA
  360. Case 152 ' RES 3,(ID+y)->B
  361. regB = _bitres(8, peekb(z))
  362. pokeb z, regB
  363. Case 153 ' RES 3,(ID+y)->C
  364. regC = _bitres(8, peekb(z))
  365. pokeb z, regC
  366. Case 154 ' RES 3,(ID+y)->D
  367. setD _bitres(8, peekb(z))
  368. pokeb z, glMemAddrDiv256(regDE)
  369. Case 155 ' RES 3,(ID+y)->E
  370. setE _bitres(8, peekb(z))
  371. pokeb z, getE
  372. Case 156 ' RES 3,(ID+y)->H
  373. setH _bitres(8, peekb(z))
  374. pokeb z, glMemAddrDiv256(regHL)
  375. Case 157 ' RES 3,(ID+y)->L
  376. setL _bitres(8, peekb(z))
  377. pokeb z, getL
  378. Case 158 ' RES 3,(HL)
  379. pokeb z, _bitres(&H8&, peekb(z))
  380. Case 159 ' RES 3,(ID+y)->A
  381. regA = _bitres(8, peekb(z))
  382. pokeb z, regA
  383. Case 160 ' RES 4,(ID+y)->B
  384. regB = _bitres(&H10&, peekb(z))
  385. pokeb z, regB
  386. Case 161 ' RES 4,(ID+y)->C
  387. regC = _bitres(&H10&, peekb(z))
  388. pokeb z, regC
  389. Case 162 ' RES 4,(ID+y)->D
  390. setD _bitres(&H10&, peekb(z))
  391. pokeb z, glMemAddrDiv256(regDE)
  392. Case 163 ' RES 4,(ID+y)->E
  393. setE _bitres(&H10&, peekb(z))
  394. pokeb z, getE
  395. Case 164 ' RES 4,(ID+y)->H
  396. setH _bitres(&H10&, peekb(z))
  397. pokeb z, glMemAddrDiv256(regHL)
  398. Case 165 ' RES 4,(ID+y)->L
  399. setL _bitres(&H10&, peekb(z))
  400. pokeb z, getL
  401. Case 166 ' RES 4,(HL)
  402. pokeb z, _bitres(&H10&, peekb(z))
  403. Case 167 ' RES 4,(ID+y)->A
  404. regA = _bitres(&H10&, peekb(z))
  405. pokeb z, regA
  406. Case 168 ' RES 5,(ID+y)->B
  407. regB = _bitres(&H20&, peekb(z))
  408. pokeb z, regB
  409. Case 169 ' RES 5,(ID+y)->C
  410. regC = _bitres(&H20&, peekb(z))
  411. pokeb z, regC
  412. Case 170 ' RES 5,(ID+y)->D
  413. setD _bitres(&H20&, peekb(z))
  414. pokeb z, glMemAddrDiv256(regDE)
  415. Case 171 ' RES 5,(ID+y)->E
  416. setE _bitres(&H20&, peekb(z))
  417. pokeb z, getE
  418. Case 172 ' RES 5,(ID+y)->H
  419. setH _bitres(&H20&, peekb(z))
  420. pokeb z, glMemAddrDiv256(regHL)
  421. Case 173 ' RES 5,(ID+y)->L
  422. setL _bitres(&H20&, peekb(z))
  423. pokeb z, getL
  424. Case 174 ' RES 5,(HL)
  425. pokeb z, _bitres(&H20&, peekb(z))
  426. Case 175 ' RES 5,(ID+y)->A
  427. regA = _bitres(&H20&, peekb(z))
  428. pokeb z, regA
  429. Case 176 ' RES 6,(ID+y)->B
  430. regB = _bitres(&H40&, peekb(z))
  431. pokeb z, regB
  432. Case 177 ' RES 6,(ID+y)->C
  433. regC = _bitres(&H40&, peekb(z))
  434. pokeb z, regC
  435. Case 178 ' RES 6,(ID+y)->D
  436. setD _bitres(&H40&, peekb(z))
  437. pokeb z, glMemAddrDiv256(regDE)
  438. Case 179 ' RES 6,(ID+y)->E
  439. setE _bitres(&H40&, peekb(z))
  440. pokeb z, getE
  441. Case 180 ' RES 6,(ID+y)->H
  442. setH _bitres(&H40&, peekb(z))
  443. pokeb z, glMemAddrDiv256(regHL)
  444. Case 181 ' RES 6,(ID+y)->L
  445. setL _bitres(&H40&, peekb(z))
  446. pokeb z, getL
  447. Case 182 ' RES 6,(HL)
  448. pokeb z, _bitres(&H40&, peekb(z))
  449. Case 183 ' RES 6,(ID+y)->A
  450. regA = _bitres(&H40&, peekb(z))
  451. pokeb z, regA
  452. Case 184 ' RES 6,(ID+y)->B
  453. regB = _bitres(&H80&, peekb(z))
  454. pokeb z, regB
  455. Case 185 ' RES 6,(ID+y)->C
  456. regC = _bitres(&H80&, peekb(z))
  457. pokeb z, regC
  458. Case 186 ' RES 6,(ID+y)->D
  459. setD _bitres(&H80&, peekb(z))
  460. pokeb z, glMemAddrDiv256(regDE)
  461. Case 187 ' RES 6,(ID+y)->E
  462. setE _bitres(&H80&, peekb(z))
  463. pokeb z, getE
  464. Case 188 ' RES 6,(ID+y)->H
  465. setH _bitres(&H80&, peekb(z))
  466. pokeb z, glMemAddrDiv256(regHL)
  467. Case 189 ' RES 6,(ID+y)->L
  468. setL _bitres(&H80&, peekb(z))
  469. pokeb z, getL
  470. Case 190 ' RES 7,(HL)
  471. pokeb z, _bitres(&H80&, peekb(z))
  472. Case 191 ' RES 7,(ID+y)->A
  473. regA = _bitres(&H80&, peekb(z))
  474. pokeb z, regA
  475. Case 192 ' SET 0,(ID+y)->B
  476. regB = _bitset(1, peekb(z))
  477. pokeb z, regB
  478. Case 193 ' SET 0,(ID+y)->C
  479. regC = _bitset(1, peekb(z))
  480. pokeb z, regC
  481. Case 194 ' SET 0,(ID+y)->D
  482. setD _bitset(1, peekb(z))
  483. pokeb z, glMemAddrDiv256(regDE)
  484. Case 195 ' SET 0,(ID+y)->E
  485. setE _bitset(1, peekb(z))
  486. pokeb z, getE
  487. Case 196 ' SET 0,(ID+y)->H
  488. setH _bitset(1, peekb(z))
  489. pokeb z, glMemAddrDiv256(regHL)
  490. Case 197 ' SET 0,(ID+y)->L
  491. setL _bitset(1, peekb(z))
  492. pokeb z, getL
  493. Case 198 ' SET 0,(HL)
  494. pokeb z, _bitset(&H1&, peekb(z))
  495. Case 199 ' SET 0,(ID+y)->A
  496. regA = _bitset(1, peekb(z))
  497. pokeb z, regA
  498. Case 200 ' SET 1,(ID+y)->B
  499. regB = _bitset(2, peekb(z))
  500. pokeb z, regB
  501. Case 201 ' SET 1,(ID+y)->C
  502. regC = _bitset(2, peekb(z))
  503. pokeb z, regC
  504. Case 202 ' SET 1,(ID+y)->D
  505. setD _bitset(2, peekb(z))
  506. pokeb z, glMemAddrDiv256(regDE)
  507. Case 203 ' SET 1,(ID+y)->E
  508. setE _bitset(2, peekb(z))
  509. pokeb z, getE
  510. Case 204 ' SET 1,(ID+y)->H
  511. setH _bitset(2, peekb(z))
  512. pokeb z, glMemAddrDiv256(regHL)
  513. Case 205 ' SET 1,(ID+y)->L
  514. setL _bitset(2, peekb(z))
  515. pokeb z, getL
  516. Case 206 ' SET 1,(HL)
  517. pokeb z, _bitset(&H2&, peekb(z))
  518. Case 207 ' SET 1,(ID+y)->A
  519. regA = _bitset(2, peekb(z))
  520. pokeb z, regA
  521. Case 208 ' SET 2,(ID+y)->B
  522. regB = _bitset(4, peekb(z))
  523. pokeb z, regB
  524. Case 209 ' SET 2,(ID+y)->C
  525. regC = _bitset(4, peekb(z))
  526. pokeb z, regC
  527. Case 210 ' SET 2,(ID+y)->D
  528. setD _bitset(4, peekb(z))
  529. pokeb z, glMemAddrDiv256(regDE)
  530. Case 211 ' SET 2,(ID+y)->E
  531. setE _bitset(4, peekb(z))
  532. pokeb z, getE
  533. Case 212 ' SET 2,(ID+y)->H
  534. setH _bitset(4, peekb(z))
  535. pokeb z, glMemAddrDiv256(regHL)
  536. Case 213 ' SET 2,(ID+y)->L
  537. setL _bitset(4, peekb(z))
  538. pokeb z, getL
  539. Case 214 ' SET 2,(HL)
  540. pokeb z, _bitset(&H4&, peekb(z))
  541. Case 215 ' SET 2,(ID+y)->A
  542. regA = _bitset(4, peekb(z))
  543. pokeb z, regA
  544. Case 216 ' SET 3,(ID+y)->B
  545. regB = _bitset(8, peekb(z))
  546. pokeb z, regB
  547. Case 217 ' SET 3,(ID+y)->C
  548. regC = _bitset(8, peekb(z))
  549. pokeb z, regC
  550. Case 218 ' SET 3,(ID+y)->D
  551. setD _bitset(8, peekb(z))
  552. pokeb z, glMemAddrDiv256(regDE)
  553. Case 219 ' SET 3,(ID+y)->E
  554. setE _bitset(8, peekb(z))
  555. pokeb z, getE
  556. Case 220 ' SET 3,(ID+y)->H
  557. setH _bitset(8, peekb(z))
  558. pokeb z, glMemAddrDiv256(regHL)
  559. Case 221 ' SET 3,(ID+y)->L
  560. setL _bitset(8, peekb(z))
  561. pokeb z, getL
  562. Case 222 ' SET 3,(HL)
  563. pokeb z, _bitset(&H8&, peekb(z))
  564. Case 223 ' SET 3,(ID+y)->A
  565. regA = _bitset(8, peekb(z))
  566. pokeb z, regA
  567. Case 224 ' SET 4,(ID+y)->B
  568. regB = _bitset(&H10&, peekb(z))
  569. pokeb z, regB
  570. Case 225 ' SET 4,(ID+y)->C
  571. regC = _bitset(&H10&, peekb(z))
  572. pokeb z, regC
  573. Case 226 ' SET 4,(ID+y)->D
  574. setD _bitset(&H10&, peekb(z))
  575. pokeb z, glMemAddrDiv256(regDE)
  576. Case 227 ' SET 4,(ID+y)->E
  577. setE _bitset(&H10&, peekb(z))
  578. pokeb z, getE
  579. Case 228 ' SET 4,(ID+y)->H
  580. setH _bitset(&H10&, peekb(z))
  581. pokeb z, glMemAddrDiv256(regHL)
  582. Case 229 ' SET 4,(ID+y)->L
  583. setL _bitset(&H10&, peekb(z))
  584. pokeb z, getL
  585. Case 230 ' SET 4,(HL)
  586. pokeb z, _bitset(&H10&, peekb(z))
  587. Case 231 ' SET 4,(ID+y)->A
  588. regA = _bitset(&H10&, peekb(z))
  589. pokeb z, regA
  590. Case 232 ' SET 5,(ID+y)->B
  591. regB = _bitset(&H20&, peekb(z))
  592. pokeb z, regB
  593. Case 233 ' SET 5,(ID+y)->C
  594. regC = _bitset(&H20&, peekb(z))
  595. pokeb z, regC
  596. Case 234 ' SET 5,(ID+y)->D
  597. setD _bitset(&H20&, peekb(z))
  598. pokeb z, glMemAddrDiv256(regDE)
  599. Case 235 ' SET 5,(ID+y)->E
  600. setE _bitset(&H20&, peekb(z))
  601. pokeb z, getE
  602. Case 236 ' SET 5,(ID+y)->H
  603. setH _bitset(&H20&, peekb(z))
  604. pokeb z, glMemAddrDiv256(regHL)
  605. Case 237 ' SET 5,(ID+y)->L
  606. setL _bitset(&H20&, peekb(z))
  607. pokeb z, getL
  608. Case 238 ' SET 5,(HL)
  609. pokeb z, _bitset(&H20&, peekb(z))
  610. Case 239 ' SET 5,(ID+y)->A
  611. regA = _bitset(&H20&, peekb(z))
  612. pokeb z, regA
  613. Case 240 ' SET 6,(ID+y)->B
  614. regB = _bitset(&H40&, peekb(z))
  615. pokeb z, regB
  616. Case 241 ' SET 6,(ID+y)->C
  617. regC = _bitset(&H40&, peekb(z))
  618. pokeb z, regC
  619. Case 242 ' SET 6,(ID+y)->D
  620. setD _bitset(&H40&, peekb(z))
  621. pokeb z, glMemAddrDiv256(regDE)
  622. Case 243 ' SET 6,(ID+y)->E
  623. setE _bitset(&H40&, peekb(z))
  624. pokeb z, getE
  625. Case 244 ' SET 6,(ID+y)->H
  626. setH _bitset(&H40&, peekb(z))
  627. pokeb z, glMemAddrDiv256(regHL)
  628. Case 245 ' SET 6,(ID+y)->L
  629. setL _bitset(&H40&, peekb(z))
  630. pokeb z, getL
  631. Case 246 ' SET 6,(HL)
  632. pokeb z, _bitset(&H40&, peekb(z))
  633. Case 247 ' SET 6,(ID+y)->A
  634. regA = _bitset(&H40&, peekb(z))
  635. pokeb z, regA
  636. Case 248 ' SET 7,(ID+y)->B
  637. regB = _bitset(&H80&, peekb(z))
  638. pokeb z, regB
  639. Case 249 ' SET 7,(ID+y)->C
  640. regC = _bitset(&H80&, peekb(z))
  641. pokeb z, regC
  642. Case 250 ' SET 7,(ID+y)->D
  643. setD _bitset(&H80&, peekb(z))
  644. pokeb z, glMemAddrDiv256(regDE)
  645. Case 251 ' SET 7,(ID+y)->E
  646. setE _bitset(&H80&, peekb(z))
  647. pokeb z, getE
  648. Case 252 ' SET 7,(ID+y)->H
  649. setH _bitset(&H80&, peekb(z))
  650. pokeb z, glMemAddrDiv256(regHL)
  651. Case 253 ' SET 7,(ID+y)->L
  652. setL _bitset(&H80&, peekb(z))
  653. pokeb z, getL
  654. Case 254 ' SET 7,(HL)
  655. pokeb z, _bitset(&H80&, peekb(z))
  656. Case 255 ' SET 7,A
  657. regA = _bitset(&H80&, peekb(z))
  658. pokeb z, regA
  659. case else
  660. debug_print( __FUNCTION__ & " unhanfled" )
  661. End Select
  662.  
  663. End Sub
Add Comment
Please, Sign In to add comment
Public Pastes
We use cookies for various purposes including analytics. By continuing to use Pastebin, you agree to our use of cookies as described in the Cookies Policy.  OK, I Understand
Not a member of Pastebin yet?
Sign Up, it unlocks many cool features!