API tools faq
paste
Guest User

Untitled

a guest
May 8th, 2018
178
0
Never
Add comment
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
text 171.50 KB | None | 0 0
raw download clone embed print report
  1. package z80
  2.  
  3. import (
  4. "container/vector"
  5. "fmt"
  6. )
  7.  
  8. /* The flags */
  9.  
  10. const FLAG_C = 0x01
  11. const FLAG_N = 0x02
  12. const FLAG_P = 0x04
  13. const FLAG_V = FLAG_P
  14. const FLAG_3 = 0x08
  15. const FLAG_H = 0x10
  16. const FLAG_5 = 0x20
  17. const FLAG_Z = 0x40
  18. const FLAG_S = 0x80
  19.  
  20. type Z80 struct {
  21. a, f, b, c, d, e, h, l byte
  22. a_, f_, b_, c_, d_, e_, h_, l_ byte
  23. ixh, ixl, iyh, iyl byte
  24.  
  25. sp, i, r, r7, pc, iff1, iff2, im uint16
  26.  
  27. sz53Table, sz53pTable, parityTable [0x100]byte
  28.  
  29. halted byte
  30.  
  31. tstates uint16
  32.  
  33. LogEvents bool
  34. }
  35.  
  36. var memory, initialMemory [0x10000]byte
  37. var events *vector.StringVector
  38. var event_next_event uint16
  39.  
  40. func NewZ80() *Z80 {
  41. z80 := new(Z80)
  42. z80.initTables()
  43.  
  44. events = new(vector.StringVector)
  45. return z80
  46. }
  47.  
  48. func (z80 *Z80) DumpRegisters(out *vector.StringVector) {
  49. out.Push(fmt.Sprintf("%02x%02x %02x%02x %02x%02x %02x%02x %02x%02x %02x%02x %02x%02x %02x%02x %02x%02x %02x%02x %04x %04x\n",
  50. z80.a, z80.f, z80.b, z80.c, z80.d, z80.e, z80.h, z80.l, z80.a_, z80.f_, z80.b_, z80.c_, z80.d_, z80.e_, z80.h_, z80.l_, z80.ixh, z80.ixl, z80.iyh, z80.iyl, z80.sp, z80.pc))
  51. out.Push(fmt.Sprintf("%02x %02x %d %d %d %d %d\n", z80.i, (z80.r7&0x80)|(z80.r&0x7f),
  52. z80.iff1, z80.iff2, z80.im, z80.halted, z80.tstates))
  53. }
  54.  
  55. func (z80 *Z80) DumpMemory(out *vector.StringVector) {
  56.  
  57. for i, _ := range memory {
  58. if memory[i] == initialMemory[i] {
  59. continue
  60. }
  61.  
  62. line := fmt.Sprintf("%04x ", i)
  63.  
  64. for i < 0x10000 && memory[i] != initialMemory[i] {
  65. line += fmt.Sprintf("%02x ", memory[i])
  66. i++
  67. }
  68.  
  69. line += fmt.Sprintf("-1\n")
  70.  
  71. out.Push(line)
  72. }
  73. }
  74.  
  75. func (z80 *Z80) Reset() {
  76. z80.a, z80.f, z80.b, z80.c, z80.d, z80.e, z80.h, z80.l = 0, 0, 0, 0, 0, 0, 0, 0
  77. z80.a_, z80.f_, z80.b_, z80.c_, z80.d_, z80.e_, z80.h_, z80.l_ = 0, 0, 0, 0, 0, 0, 0, 0
  78. z80.ixh, z80.ixl, z80.iyh, z80.iyl = 0, 0, 0, 0
  79.  
  80. z80.sp, z80.i, z80.r, z80.r7, z80.pc, z80.iff1, z80.iff2, z80.im = 0, 0, 0, 0, 0, 0, 0, 0
  81.  
  82. z80.halted = 0
  83.  
  84. z80.tstates = 0
  85.  
  86. for i, _ := range memory {
  87. memory[i] = 0
  88. }
  89. }
  90.  
  91. func ternOpB(cond bool, ret1, ret2 byte) byte {
  92. if cond {
  93. return ret1
  94. }
  95. return ret2
  96. }
  97.  
  98. func (z80 *Z80) initTables() {
  99.  
  100. var i int16
  101. var j, k byte
  102. var parity byte
  103.  
  104. for i = 0; i < 0x100; i++ {
  105. z80.sz53Table[i] = byte(i) & (0x08 | 0x20 | 0x80)
  106. j = byte(i)
  107. parity = 0
  108. for k = 0; k < 8; k++ {
  109. parity ^= j & 1
  110. j >>= 1
  111. }
  112. z80.parityTable[i] = ternOpB(parity == 1, 0, 0x04)
  113. z80.sz53pTable[i] = z80.sz53Table[i] | z80.parityTable[i]
  114. }
  115.  
  116. z80.sz53Table[0] |= 0x40
  117. z80.sz53pTable[0] |= 0x40
  118.  
  119. }
  120.  
  121. func (z80 *Z80) incA() {
  122. z80.a++
  123. z80.f = (z80.f & FLAG_C) | (ternOpB(z80.a == 0x80, FLAG_V, 0)) | (ternOpB((z80.a&0x0f) == 1, 0, FLAG_H)) | z80.sz53Table[z80.a]
  124. }
  125.  
  126. func (z80 *Z80) decA() {
  127. z80.f = (z80.f & FLAG_C) | (ternOpB(z80.a&0x0f == 1, 0, FLAG_H)) | FLAG_N
  128. z80.a--
  129. z80.f |= (ternOpB(z80.a == 0x7f, FLAG_V, 0)) | z80.sz53Table[z80.a]
  130.  
  131. }
  132.  
  133. func (z80 *Z80) incB() {
  134. z80.b++
  135. z80.f = (z80.f & FLAG_C) | (ternOpB(z80.b == 0x80, FLAG_V, 0)) | (ternOpB((z80.b&0x0f) == 1, 0, FLAG_H)) | z80.sz53Table[z80.b]
  136. }
  137.  
  138. func (z80 *Z80) decB() {
  139. z80.f = (z80.f & FLAG_C) | (ternOpB(z80.b&0x0f == 1, 0, FLAG_H)) | FLAG_N
  140. z80.b--
  141. z80.f |= (ternOpB(z80.b == 0x7f, FLAG_V, 0)) | z80.sz53Table[z80.b]
  142.  
  143. }
  144.  
  145. func (z80 *Z80) incC() {
  146. z80.c++
  147. z80.f = (z80.f & FLAG_C) | (ternOpB(z80.c == 0x80, FLAG_V, 0)) | (ternOpB((z80.c&0x0f) == 1, 0, FLAG_H)) | z80.sz53Table[z80.c]
  148. }
  149.  
  150. func (z80 *Z80) decC() {
  151. z80.f = (z80.f & FLAG_C) | (ternOpB(z80.c&0x0f == 1, 0, FLAG_H)) | FLAG_N
  152. z80.c--
  153. z80.f |= (ternOpB(z80.c == 0x7f, FLAG_V, 0)) | z80.sz53Table[z80.c]
  154.  
  155. }
  156.  
  157. func (z80 *Z80) incD() {
  158. z80.d++
  159. z80.f = (z80.f & FLAG_C) | (ternOpB(z80.d == 0x80, FLAG_V, 0)) | (ternOpB((z80.d&0x0f) == 1, 0, FLAG_H)) | z80.sz53Table[z80.d]
  160. }
  161.  
  162. func (z80 *Z80) decD() {
  163. z80.f = (z80.f & FLAG_C) | (ternOpB(z80.d&0x0f == 1, 0, FLAG_H)) | FLAG_N
  164. z80.d--
  165. z80.f |= (ternOpB(z80.d == 0x7f, FLAG_V, 0)) | z80.sz53Table[z80.d]
  166.  
  167. }
  168.  
  169. func (z80 *Z80) incE() {
  170. z80.e++
  171. z80.f = (z80.f & FLAG_C) | (ternOpB(z80.e == 0x80, FLAG_V, 0)) | (ternOpB((z80.e&0x0f) == 1, 0, FLAG_H)) | z80.sz53Table[z80.e]
  172. }
  173.  
  174. func (z80 *Z80) decE() {
  175. z80.f = (z80.f & FLAG_C) | (ternOpB(z80.e&0x0f == 1, 0, FLAG_H)) | FLAG_N
  176. z80.e--
  177. z80.f |= (ternOpB(z80.e == 0x7f, FLAG_V, 0)) | z80.sz53Table[z80.e]
  178.  
  179. }
  180.  
  181. func (z80 *Z80) incH() {
  182. z80.h++
  183. z80.f = (z80.f & FLAG_C) | (ternOpB(z80.h == 0x80, FLAG_V, 0)) | (ternOpB((z80.h&0x0f) == 1, 0, FLAG_H)) | z80.sz53Table[z80.h]
  184. }
  185.  
  186. func (z80 *Z80) decH() {
  187. z80.f = (z80.f & FLAG_C) | (ternOpB(z80.h&0x0f == 1, 0, FLAG_H)) | FLAG_N
  188. z80.h--
  189. z80.f |= (ternOpB(z80.h == 0x7f, FLAG_V, 0)) | z80.sz53Table[z80.h]
  190.  
  191. }
  192.  
  193. func (z80 *Z80) incL() {
  194. z80.l++
  195. z80.f = (z80.f & FLAG_C) | (ternOpB(z80.l == 0x80, FLAG_V, 0)) | (ternOpB((z80.l&0x0f) == 1, 0, FLAG_H)) | z80.sz53Table[z80.l]
  196. }
  197.  
  198. func (z80 *Z80) decL() {
  199. z80.f = (z80.f & FLAG_C) | (ternOpB(z80.l&0x0f == 1, 0, FLAG_H)) | FLAG_N
  200. z80.l--
  201. z80.f |= (ternOpB(z80.l == 0x7f, FLAG_V, 0)) | z80.sz53Table[z80.l]
  202.  
  203. }
  204.  
  205. func (z80 *Z80) BC() uint16 {
  206. return uint16(z80.c) | (uint16(z80.b) << 8)
  207. }
  208.  
  209. func (z80 *Z80) incBC() {
  210. temp := z80.BC() + 1
  211. z80.b = byte(temp >> 8)
  212. z80.c = byte(temp & 0xff)
  213. }
  214.  
  215.  
  216. func (z80 *Z80) HL() uint16 {
  217. return uint16(z80.l) | (uint16(z80.h) << 8)
  218. }
  219.  
  220. func (z80 *Z80) IR() uint16 {
  221. return uint16((z80.i)<<8 | (z80.r7 & 0x80) | (z80.r & 0x7f))
  222. }
  223.  
  224. func (z80 *Z80) readByteInternal(addr uint16) byte {
  225. events.Push(fmt.Sprintf("%5d MR %04x %02x\n", z80.tstates, addr, memory[addr]))
  226. return memory[addr]
  227. }
  228.  
  229. func (z80 *Z80) readByte(addr uint16) byte {
  230. events.Push(fmt.Sprintf("%5d MC %04x\n", z80.tstates, addr))
  231. z80.tstates += 3
  232. return z80.readByteInternal(addr)
  233. }
  234.  
  235. func (z80 *Z80) writeByte(address uint16, b byte) {
  236. events.Push(fmt.Sprintf("%5d MC %04x\n", z80.tstates, address))
  237. z80.tstates += 3
  238. z80.writebyteInternal(address, b)
  239. }
  240.  
  241. func (z80 *Z80) writebyteInternal(address uint16, b byte) {
  242. events.Push(fmt.Sprintf("%5d MW %04x %02x\n", z80.tstates, address, b))
  243. memory[address] = b
  244. }
  245.  
  246. func (z80 *Z80) contendRead(addr, time uint16) {
  247. events.Push(fmt.Sprintf("%5d MC %04x\n", z80.tstates, addr))
  248. z80.tstates += time
  249. }
  250.  
  251. func (z80 *Z80) contendReadNoMreq(address, time uint16) {
  252. z80.contendRead(address, time)
  253. }
  254.  
  255. func (z80 *Z80) contendWriteNoMreq(address, time uint16) {
  256. events.Push(fmt.Sprintf("%5d MC %04x\n", z80.tstates, address))
  257. z80.tstates += time
  258. }
  259.  
  260. func (z80 *Z80) doOpcodes() {
  261. for z80.tstates < event_next_event {
  262.  
  263. z80.r = (z80.r + 1) & 0x7f
  264.  
  265. z80.contendRead(z80.pc, 4)
  266.  
  267. opcode := z80.readByteInternal(z80.pc)
  268. z80.pc++
  269.  
  270. switch opcode {
  271.  
  272. /* opcodes_base.c: unshifted Z80 opcodes
  273. Copyright (c) 1999-2003 Philip Kendall
  274.  
  275. This program is free software; you can redistribute it and/or modify
  276. it under the terms of the GNU General Public License as published by
  277. the Free Software Foundation; either version 2 of the License, or
  278. (at your option) any later version.
  279.  
  280. This program is distributed in the hope that it will be useful,
  281. but WITHOUT ANY WARRANTY; without even the implied warranty of
  282. MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
  283. GNU General Public License for more details.
  284.  
  285. You should have received a copy of the GNU General Public License along
  286. with this program; if not, write to the Free Software Foundation, Inc.,
  287. 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
  288.  
  289. Author contact information:
  290.  
  291. E-mail: philip-fuse@shadowmagic.org.uk
  292.  
  293. */
  294.  
  295. /* NB: this file is autogenerated by './z80.pl' from 'opcodes_base.dat',
  296. and included in 'z80_ops.c' */
  297.  
  298. case 0x00: /* NOP */
  299. break
  300. case 0x01: /* LD BC,nnnn */
  301. C = z80.readByte(z80.pc)
  302. z80.pc++
  303. B = z80.readByte(z80.pc)
  304. z80.pc++
  305. break
  306. case 0x02: /* LD (BC),A */
  307. z80.writeByte(BC, A)
  308. break
  309. case 0x03: /* INC BC */
  310. z80.contendReadNoMReq(z80.IR(), 1)
  311. z80.contendReadNoMReq(z80.IR(), 1)
  312. z80.incBC()
  313. break
  314. case 0x04: /* INC B */
  315. z80.incB()
  316. break
  317. case 0x05: /* DEC B */
  318. z80.decB()
  319. break
  320. case 0x06: /* LD B,nn */
  321. B = z80.readByte(z80.pc)
  322. z80.pc++
  323. break
  324. case 0x07: /* RLCA */
  325. z80.a = (z80.a << 1) | (z80.a >> 7)
  326. z80.f = (z80.f & (FLAG_P | FLAG_Z | FLAG_S)) |
  327. (z80.a & (FLAG_C | FLAG_3 | FLAG_5))
  328. break
  329. case 0x08: /* EX AF,AF' */
  330. /* Tape saving trap: note this traps the EX AF,AF' at #04d0, not
  331. #04d1 as PC has already been incremented */
  332. /* 0x76 - Timex 2068 save routine in EXROM */
  333. if z80.pc == 0x04d1 || z80.pc == 0x0077 {
  334. if tape_save_trap() == 0 {
  335. break
  336. }
  337. }
  338.  
  339. var wordtemp uint16 = z80.AF()
  340. z80.setAF(z80.AF_())
  341. z80.setAF_(wordtemp)
  342. break
  343. case 0x09: /* ADD HL,BC */
  344. z80.contendReadNoMReq(z80.IR(), 1)
  345. z80.contendReadNoMReq(z80.IR(), 1)
  346. z80.contendReadNoMReq(z80.IR(), 1)
  347. z80.contendReadNoMReq(z80.IR(), 1)
  348. z80.contendReadNoMReq(z80.IR(), 1)
  349. z80.contendReadNoMReq(z80.IR(), 1)
  350. z80.contendReadNoMReq(z80.IR(), 1)
  351. ADD16(HL, BC)
  352. break
  353. case 0x0a: /* LD A,(BC) */
  354. A = z80.readByte(BC)
  355. break
  356. case 0x0b: /* DEC BC */
  357. z80.contendReadNoMReq(z80.IR(), 1)
  358. z80.contendReadNoMReq(z80.IR(), 1)
  359. z80.decBC()
  360. break
  361. case 0x0c: /* INC C */
  362. z80.incC()
  363. break
  364. case 0x0d: /* DEC C */
  365. z80.decC()
  366. break
  367. case 0x0e: /* LD C,nn */
  368. C = z80.readByte(z80.pc)
  369. z80.pc++
  370. break
  371. case 0x0f: /* RRCA */
  372. z80.f = (z80.f & (FLAG_P | FLAG_Z | FLAG_S)) | (z80.a & FLAG_C)
  373. z80.a = (z80.a >> 1) | (z80.a << 7)
  374. z80.f |= (z80.a & (FLAG_3 | FLAG_5))
  375. break
  376. case 0x10: /* DJNZ offset */
  377. z80.contendReadNoMReq(z80.IR(), 1)
  378. z80.b--
  379. if B {
  380. JR()
  381. } else {
  382. z80.contendRead(z80.pc, 3)
  383. }
  384. z80.pc++
  385. break
  386. case 0x11: /* LD DE,nnnn */
  387. E = z80.readByte(z80.pc)
  388. z80.pc++
  389. D = z80.readByte(z80.pc)
  390. z80.pc++
  391. break
  392. case 0x12: /* LD (DE),A */
  393. z80.writeByte(DE, A)
  394. break
  395. case 0x13: /* INC DE */
  396. z80.contendReadNoMReq(z80.IR(), 1)
  397. z80.contendReadNoMReq(z80.IR(), 1)
  398. z80.incDE()
  399. break
  400. case 0x14: /* INC D */
  401. z80.incD()
  402. break
  403. case 0x15: /* DEC D */
  404. z80.decD()
  405. break
  406. case 0x16: /* LD D,nn */
  407. D = z80.readByte(z80.pc)
  408. z80.pc++
  409. break
  410. case 0x17: /* RLA */
  411. var bytetemp byte = z80.a
  412. z80.a = (z80.a << 1) | (z80.f & FLAG_C)
  413. z80.f = (z80.f & (FLAG_P | FLAG_Z | FLAG_S)) | (z80.a & (FLAG_3 | FLAG_5)) | (bytetemp >> 7)
  414. break
  415. case 0x18: /* JR offset */
  416. JR()
  417. z80.pc++
  418. break
  419. case 0x19: /* ADD HL,DE */
  420. z80.contendReadNoMReq(z80.IR(), 1)
  421. z80.contendReadNoMReq(z80.IR(), 1)
  422. z80.contendReadNoMReq(z80.IR(), 1)
  423. z80.contendReadNoMReq(z80.IR(), 1)
  424. z80.contendReadNoMReq(z80.IR(), 1)
  425. z80.contendReadNoMReq(z80.IR(), 1)
  426. z80.contendReadNoMReq(z80.IR(), 1)
  427. ADD16(HL, DE)
  428. break
  429. case 0x1a: /* LD A,(DE) */
  430. A = z80.readByte(DE)
  431. break
  432. case 0x1b: /* DEC DE */
  433. z80.contendReadNoMReq(z80.IR(), 1)
  434. z80.contendReadNoMReq(z80.IR(), 1)
  435. z80.decDE()
  436. break
  437. case 0x1c: /* INC E */
  438. z80.incE()
  439. break
  440. case 0x1d: /* DEC E */
  441. z80.decE()
  442. break
  443. case 0x1e: /* LD E,nn */
  444. E = z80.readByte(z80.pc)
  445. z80.pc++
  446. break
  447. case 0x1f: /* RRA */
  448. var bytetemp byte = z80.a
  449. z80.a = (z80.a >> 1) | (z80.f << 7)
  450. z80.f = (z80.f & (FLAG_P | FLAG_Z | FLAG_S)) | (z80.a & (FLAG_3 | FLAG_5)) | (bytetemp & FLAG_C)
  451. break
  452. case 0x20: /* JR NZ,offset */
  453. if !(F & FLAG_Z) {
  454. JR()
  455. } else {
  456. z80.contendRead(z80.pc, 3)
  457. }
  458. z80.pc++
  459. break
  460. case 0x21: /* LD HL,nnnn */
  461. L = z80.readByte(z80.pc)
  462. z80.pc++
  463. H = z80.readByte(z80.pc)
  464. z80.pc++
  465. break
  466. case 0x22: /* LD (nnnn),HL */
  467. LD16_NNRR(L, H)
  468. break
  469. case 0x23: /* INC HL */
  470. z80.contendReadNoMReq(z80.IR(), 1)
  471. z80.contendReadNoMReq(z80.IR(), 1)
  472. z80.incHL()
  473. break
  474. case 0x24: /* INC H */
  475. z80.incH()
  476. break
  477. case 0x25: /* DEC H */
  478. z80.decH()
  479. break
  480. case 0x26: /* LD H,nn */
  481. H = z80.readByte(z80.pc)
  482. z80.pc++
  483. break
  484. case 0x27: /* DAA */
  485. var add, carry byte = 0, (z80.f & FLAG_C)
  486. if (z80.f & FLAG_H) || ((z80.a & 0x0f) > 9) {
  487. add = 6
  488. }
  489. if carry || (z80.a > 0x99) {
  490. add |= 0x60
  491. }
  492. if z80.a > 0x99 {
  493. carry = FLAG_C
  494. }
  495. if z80.f & FLAG_N {
  496. SUB(add)
  497. } else {
  498. ADD(add)
  499. }
  500. z80.f = (z80.f & ^(FLAG_C | FLAG_P)) | carry | z80.parityTable[z80.a]
  501. break
  502. case 0x28: /* JR Z,offset */
  503. if F & FLAG_Z {
  504. JR()
  505. } else {
  506. z80.contendRead(z80.pc, 3)
  507. }
  508. z80.pc++
  509. break
  510. case 0x29: /* ADD HL,HL */
  511. z80.contendReadNoMReq(z80.IR(), 1)
  512. z80.contendReadNoMReq(z80.IR(), 1)
  513. z80.contendReadNoMReq(z80.IR(), 1)
  514. z80.contendReadNoMReq(z80.IR(), 1)
  515. z80.contendReadNoMReq(z80.IR(), 1)
  516. z80.contendReadNoMReq(z80.IR(), 1)
  517. z80.contendReadNoMReq(z80.IR(), 1)
  518. ADD16(HL, HL)
  519. break
  520. case 0x2a: /* LD HL,(nnnn) */
  521. LD16_RRNN(L, H)
  522. break
  523. case 0x2b: /* DEC HL */
  524. z80.contendReadNoMReq(z80.IR(), 1)
  525. z80.contendReadNoMReq(z80.IR(), 1)
  526. z80.decHL()
  527. break
  528. case 0x2c: /* INC L */
  529. z80.incL()
  530. break
  531. case 0x2d: /* DEC L */
  532. z80.decL()
  533. break
  534. case 0x2e: /* LD L,nn */
  535. L = z80.readByte(z80.pc)
  536. z80.pc++
  537. break
  538. case 0x2f: /* CPL */
  539. z80.a ^= 0xff
  540. z80.f = (z80.f & (FLAG_C | FLAG_P | FLAG_Z | FLAG_S)) |
  541. (z80.a & (FLAG_3 | FLAG_5)) | (FLAG_N | FLAG_H)
  542. break
  543. case 0x30: /* JR NC,offset */
  544. if !(F & FLAG_C) {
  545. JR()
  546. } else {
  547. z80.contendRead(z80.pc, 3)
  548. }
  549. z80.pc++
  550. break
  551. case 0x31: /* LD SP,nnnn */
  552. SPL = z80.readByte(z80.pc)
  553. z80.pc++
  554. SPH = z80.readByte(z80.pc)
  555. z80.pc++
  556. break
  557. case 0x32: /* LD (nnnn),A */
  558. var wordtemp uint16 = z80.readByte(z80.pc)
  559. z80.pc++
  560. wordtemp |= z80.readByte(z80.pc) << 8
  561. z80.pc++
  562. z80.writeByte(wordtemp, z80.a)
  563. break
  564. case 0x33: /* INC SP */
  565. z80.contendReadNoMReq(z80.IR(), 1)
  566. z80.contendReadNoMReq(z80.IR(), 1)
  567. z80.incSP()
  568. break
  569. case 0x34: /* INC (HL) */
  570. {
  571. var bytetemp byte = z80.readByte(z80.HL())
  572. z80.contendReadNoMReq(z80.HL(), 1)
  573. INC(bytetemp)
  574. z80.writeByte(z80.HL(), bytetemp)
  575. }
  576. break
  577. case 0x35: /* DEC (HL) */
  578. {
  579. var bytetemp byte = z80.readByte(z80.HL())
  580. z80.contendReadNoMReq(z80.HL(), 1)
  581. DEC(bytetemp)
  582. z80.writeByte(z80.HL(), bytetemp)
  583. }
  584. break
  585. case 0x36: /* LD (HL),nn */
  586. z80.writeByte(HL, z80.readByte(z80.pc))
  587. z80.pc++
  588. break
  589. case 0x37: /* SCF */
  590. z80.f = (z80.f & (FLAG_P | FLAG_Z | FLAG_S)) |
  591. (z80.a & (FLAG_3 | FLAG_5)) |
  592. FLAG_C
  593. break
  594. case 0x38: /* JR C,offset */
  595. if F & FLAG_C {
  596. JR()
  597. } else {
  598. z80.contendRead(z80.pc, 3)
  599. }
  600. z80.pc++
  601. break
  602. case 0x39: /* ADD HL,SP */
  603. z80.contendReadNoMReq(z80.IR(), 1)
  604. z80.contendReadNoMReq(z80.IR(), 1)
  605. z80.contendReadNoMReq(z80.IR(), 1)
  606. z80.contendReadNoMReq(z80.IR(), 1)
  607. z80.contendReadNoMReq(z80.IR(), 1)
  608. z80.contendReadNoMReq(z80.IR(), 1)
  609. z80.contendReadNoMReq(z80.IR(), 1)
  610. ADD16(HL, SP)
  611. break
  612. case 0x3a: /* LD A,(nnnn) */
  613. var wordtemp uint16
  614. wordtemp = z80.readByte(z80.pc)
  615. z80.pc++
  616. wordtemp |= (z80.readByte(z80.pc) << 8)
  617. z80.pc++
  618. z80.a = z80.readByte(wordtemp)
  619. break
  620. case 0x3b: /* DEC SP */
  621. z80.contendReadNoMReq(z80.IR(), 1)
  622. z80.contendReadNoMReq(z80.IR(), 1)
  623. z80.decSP()
  624. break
  625. case 0x3c: /* INC A */
  626. z80.incA()
  627. break
  628. case 0x3d: /* DEC A */
  629. z80.decA()
  630. break
  631. case 0x3e: /* LD A,nn */
  632. A = z80.readByte(z80.pc)
  633. z80.pc++
  634. break
  635. case 0x3f: /* CCF */
  636. z80.f = (z80.f & (FLAG_P | FLAG_Z | FLAG_S)) |
  637. ternOpB((z80.f&FLAG_C) == 1, FLAG_H, FLAG_C) | (z80.a & (FLAG_3 | FLAG_5))
  638. break
  639. case 0x40: /* LD B,B */
  640. break
  641. case 0x41: /* LD B,C */
  642. B = C
  643. break
  644. case 0x42: /* LD B,D */
  645. B = D
  646. break
  647. case 0x43: /* LD B,E */
  648. B = E
  649. break
  650. case 0x44: /* LD B,H */
  651. B = H
  652. break
  653. case 0x45: /* LD B,L */
  654. B = L
  655. break
  656. case 0x46: /* LD B,(HL) */
  657. B = z80.readByte(HL)
  658. break
  659. case 0x47: /* LD B,A */
  660. B = A
  661. break
  662. case 0x48: /* LD C,B */
  663. C = B
  664. break
  665. case 0x49: /* LD C,C */
  666. break
  667. case 0x4a: /* LD C,D */
  668. C = D
  669. break
  670. case 0x4b: /* LD C,E */
  671. C = E
  672. break
  673. case 0x4c: /* LD C,H */
  674. C = H
  675. break
  676. case 0x4d: /* LD C,L */
  677. C = L
  678. break
  679. case 0x4e: /* LD C,(HL) */
  680. C = z80.readByte(HL)
  681. break
  682. case 0x4f: /* LD C,A */
  683. C = A
  684. break
  685. case 0x50: /* LD D,B */
  686. D = B
  687. break
  688. case 0x51: /* LD D,C */
  689. D = C
  690. break
  691. case 0x52: /* LD D,D */
  692. break
  693. case 0x53: /* LD D,E */
  694. D = E
  695. break
  696. case 0x54: /* LD D,H */
  697. D = H
  698. break
  699. case 0x55: /* LD D,L */
  700. D = L
  701. break
  702. case 0x56: /* LD D,(HL) */
  703. D = z80.readByte(HL)
  704. break
  705. case 0x57: /* LD D,A */
  706. D = A
  707. break
  708. case 0x58: /* LD E,B */
  709. E = B
  710. break
  711. case 0x59: /* LD E,C */
  712. E = C
  713. break
  714. case 0x5a: /* LD E,D */
  715. E = D
  716. break
  717. case 0x5b: /* LD E,E */
  718. break
  719. case 0x5c: /* LD E,H */
  720. E = H
  721. break
  722. case 0x5d: /* LD E,L */
  723. E = L
  724. break
  725. case 0x5e: /* LD E,(HL) */
  726. E = z80.readByte(HL)
  727. break
  728. case 0x5f: /* LD E,A */
  729. E = A
  730. break
  731. case 0x60: /* LD H,B */
  732. H = B
  733. break
  734. case 0x61: /* LD H,C */
  735. H = C
  736. break
  737. case 0x62: /* LD H,D */
  738. H = D
  739. break
  740. case 0x63: /* LD H,E */
  741. H = E
  742. break
  743. case 0x64: /* LD H,H */
  744. break
  745. case 0x65: /* LD H,L */
  746. H = L
  747. break
  748. case 0x66: /* LD H,(HL) */
  749. H = z80.readByte(HL)
  750. break
  751. case 0x67: /* LD H,A */
  752. H = A
  753. break
  754. case 0x68: /* LD L,B */
  755. L = B
  756. break
  757. case 0x69: /* LD L,C */
  758. L = C
  759. break
  760. case 0x6a: /* LD L,D */
  761. L = D
  762. break
  763. case 0x6b: /* LD L,E */
  764. L = E
  765. break
  766. case 0x6c: /* LD L,H */
  767. L = H
  768. break
  769. case 0x6d: /* LD L,L */
  770. break
  771. case 0x6e: /* LD L,(HL) */
  772. L = z80.readByte(HL)
  773. break
  774. case 0x6f: /* LD L,A */
  775. L = A
  776. break
  777. case 0x70: /* LD (HL),B */
  778. z80.writeByte(HL, B)
  779. break
  780. case 0x71: /* LD (HL),C */
  781. z80.writeByte(HL, C)
  782. break
  783. case 0x72: /* LD (HL),D */
  784. z80.writeByte(HL, D)
  785. break
  786. case 0x73: /* LD (HL),E */
  787. z80.writeByte(HL, E)
  788. break
  789. case 0x74: /* LD (HL),H */
  790. z80.writeByte(HL, H)
  791. break
  792. case 0x75: /* LD (HL),L */
  793. z80.writeByte(HL, L)
  794. break
  795. case 0x76: /* HALT */
  796. z80.halted = 1
  797. z80.pc--
  798. break
  799. case 0x77: /* LD (HL),A */
  800. z80.writeByte(HL, A)
  801. break
  802. case 0x78: /* LD A,B */
  803. A = B
  804. break
  805. case 0x79: /* LD A,C */
  806. A = C
  807. break
  808. case 0x7a: /* LD A,D */
  809. A = D
  810. break
  811. case 0x7b: /* LD A,E */
  812. A = E
  813. break
  814. case 0x7c: /* LD A,H */
  815. A = H
  816. break
  817. case 0x7d: /* LD A,L */
  818. A = L
  819. break
  820. case 0x7e: /* LD A,(HL) */
  821. A = z80.readByte(HL)
  822. break
  823. case 0x7f: /* LD A,A */
  824. break
  825. case 0x80: /* ADD A,B */
  826. ADD(B)
  827. break
  828. case 0x81: /* ADD A,C */
  829. ADD(C)
  830. break
  831. case 0x82: /* ADD A,D */
  832. ADD(D)
  833. break
  834. case 0x83: /* ADD A,E */
  835. ADD(E)
  836. break
  837. case 0x84: /* ADD A,H */
  838. ADD(H)
  839. break
  840. case 0x85: /* ADD A,L */
  841. ADD(L)
  842. break
  843. case 0x86: /* ADD A,(HL) */
  844. {
  845. var bytetemp byte = z80.readByte(HL)
  846.  
  847. ADD(bytetemp)
  848. }
  849. break
  850. case 0x87: /* ADD A,A */
  851. ADD(A)
  852. break
  853. case 0x88: /* ADC A,B */
  854. ADC(B)
  855. break
  856. case 0x89: /* ADC A,C */
  857. ADC(C)
  858. break
  859. case 0x8a: /* ADC A,D */
  860. ADC(D)
  861. break
  862. case 0x8b: /* ADC A,E */
  863. ADC(E)
  864. break
  865. case 0x8c: /* ADC A,H */
  866. ADC(H)
  867. break
  868. case 0x8d: /* ADC A,L */
  869. ADC(L)
  870. break
  871. case 0x8e: /* ADC A,(HL) */
  872. {
  873. var bytetemp byte = z80.readByte(HL)
  874.  
  875. ADC(bytetemp)
  876. }
  877. break
  878. case 0x8f: /* ADC A,A */
  879. ADC(A)
  880. break
  881. case 0x90: /* SUB A,B */
  882. SUB(B)
  883. break
  884. case 0x91: /* SUB A,C */
  885. SUB(C)
  886. break
  887. case 0x92: /* SUB A,D */
  888. SUB(D)
  889. break
  890. case 0x93: /* SUB A,E */
  891. SUB(E)
  892. break
  893. case 0x94: /* SUB A,H */
  894. SUB(H)
  895. break
  896. case 0x95: /* SUB A,L */
  897. SUB(L)
  898. break
  899. case 0x96: /* SUB A,(HL) */
  900. {
  901. var bytetemp byte = z80.readByte(HL)
  902.  
  903. SUB(bytetemp)
  904. }
  905. break
  906. case 0x97: /* SUB A,A */
  907. SUB(A)
  908. break
  909. case 0x98: /* SBC A,B */
  910. SBC(B)
  911. break
  912. case 0x99: /* SBC A,C */
  913. SBC(C)
  914. break
  915. case 0x9a: /* SBC A,D */
  916. SBC(D)
  917. break
  918. case 0x9b: /* SBC A,E */
  919. SBC(E)
  920. break
  921. case 0x9c: /* SBC A,H */
  922. SBC(H)
  923. break
  924. case 0x9d: /* SBC A,L */
  925. SBC(L)
  926. break
  927. case 0x9e: /* SBC A,(HL) */
  928. {
  929. var bytetemp byte = z80.readByte(HL)
  930.  
  931. SBC(bytetemp)
  932. }
  933. break
  934. case 0x9f: /* SBC A,A */
  935. SBC(A)
  936. break
  937. case 0xa0: /* AND A,B */
  938. AND(B)
  939. break
  940. case 0xa1: /* AND A,C */
  941. AND(C)
  942. break
  943. case 0xa2: /* AND A,D */
  944. AND(D)
  945. break
  946. case 0xa3: /* AND A,E */
  947. AND(E)
  948. break
  949. case 0xa4: /* AND A,H */
  950. AND(H)
  951. break
  952. case 0xa5: /* AND A,L */
  953. AND(L)
  954. break
  955. case 0xa6: /* AND A,(HL) */
  956. {
  957. var bytetemp byte = z80.readByte(HL)
  958.  
  959. AND(bytetemp)
  960. }
  961. break
  962. case 0xa7: /* AND A,A */
  963. AND(A)
  964. break
  965. case 0xa8: /* XOR A,B */
  966. XOR(B)
  967. break
  968. case 0xa9: /* XOR A,C */
  969. XOR(C)
  970. break
  971. case 0xaa: /* XOR A,D */
  972. XOR(D)
  973. break
  974. case 0xab: /* XOR A,E */
  975. XOR(E)
  976. break
  977. case 0xac: /* XOR A,H */
  978. XOR(H)
  979. break
  980. case 0xad: /* XOR A,L */
  981. XOR(L)
  982. break
  983. case 0xae: /* XOR A,(HL) */
  984. {
  985. var bytetemp byte = z80.readByte(HL)
  986.  
  987. XOR(bytetemp)
  988. }
  989. break
  990. case 0xaf: /* XOR A,A */
  991. XOR(A)
  992. break
  993. case 0xb0: /* OR A,B */
  994. OR(B)
  995. break
  996. case 0xb1: /* OR A,C */
  997. OR(C)
  998. break
  999. case 0xb2: /* OR A,D */
  1000. OR(D)
  1001. break
  1002. case 0xb3: /* OR A,E */
  1003. OR(E)
  1004. break
  1005. case 0xb4: /* OR A,H */
  1006. OR(H)
  1007. break
  1008. case 0xb5: /* OR A,L */
  1009. OR(L)
  1010. break
  1011. case 0xb6: /* OR A,(HL) */
  1012. {
  1013. var bytetemp byte = z80.readByte(HL)
  1014.  
  1015. OR(bytetemp)
  1016. }
  1017. break
  1018. case 0xb7: /* OR A,A */
  1019. OR(A)
  1020. break
  1021. case 0xb8: /* CP B */
  1022. CP(B)
  1023. break
  1024. case 0xb9: /* CP C */
  1025. CP(C)
  1026. break
  1027. case 0xba: /* CP D */
  1028. CP(D)
  1029. break
  1030. case 0xbb: /* CP E */
  1031. CP(E)
  1032. break
  1033. case 0xbc: /* CP H */
  1034. CP(H)
  1035. break
  1036. case 0xbd: /* CP L */
  1037. CP(L)
  1038. break
  1039. case 0xbe: /* CP (HL) */
  1040. {
  1041. var bytetemp byte = z80.readByte(HL)
  1042.  
  1043. CP(bytetemp)
  1044. }
  1045. break
  1046. case 0xbf: /* CP A */
  1047. CP(A)
  1048. break
  1049. case 0xc0: /* RET NZ */
  1050. z80.contendReadNoMReq(z80.IR(), 1)
  1051. if z80.pc == 0x056c || z80.pc == 0x0112 {
  1052. if tape_load_trap() == 0 {
  1053. break
  1054. }
  1055. }
  1056. if !(z80.f & FLAG_Z) {
  1057. RET()
  1058. }
  1059. break
  1060. case 0xc1: /* POP BC */
  1061. POP16(C, B)
  1062. break
  1063. case 0xc2: /* JP NZ,nnnn */
  1064. if !(z80.f & FLAG_Z) {
  1065. JP()
  1066. } else {
  1067. z80.contendRead(z80.pc, 3)
  1068. z80.contendRead(z80.pc+1, 3)
  1069. z80.pc += 2
  1070. }
  1071. break
  1072. case 0xc3: /* JP nnnn */
  1073. JP()
  1074. break
  1075. case 0xc4: /* CALL NZ,nnnn */
  1076. if !(z80.f & FLAG_Z) {
  1077. CALL()
  1078. } else {
  1079. z80.contendRead(z80.pc, 3)
  1080. z80.contendRead(z80.pc+1, 3)
  1081. z80.pc += 2
  1082. }
  1083. break
  1084. case 0xc5: /* PUSH BC */
  1085. z80.contendReadNoMReq(z80.IR(), 1)
  1086. PUSH16(C, B)
  1087. break
  1088. case 0xc6: /* ADD A,nn */
  1089. {
  1090. var bytetemp byte = z80.readByte(PC)
  1091. z80.pc++
  1092. ADD(bytetemp)
  1093. }
  1094. break
  1095. case 0xc7: /* RST 00 */
  1096. z80.contendReadNoMReq(z80.IR(), 1)
  1097. RST(0x00)
  1098. break
  1099. case 0xc8: /* RET Z */
  1100. z80.contendReadNoMReq(z80.IR(), 1)
  1101. if z80.f & FLAG_Z {
  1102. RET()
  1103. }
  1104. break
  1105. case 0xc9: /* RET */
  1106. RET()
  1107. break
  1108. case 0xca: /* JP Z,nnnn */
  1109. if z80.f & FLAG_Z {
  1110. JP()
  1111. } else {
  1112. z80.contendRead(z80.pc, 3)
  1113. z80.contendRead(z80.pc+1, 3)
  1114. z80.pc += 2
  1115. }
  1116. break
  1117. case 0xcb: /* shift CB */
  1118. {
  1119. var opcode2 byte
  1120. z80.contendRead(z80.pc, 4)
  1121. opcode2 = z80.readByteInternal(z80.pc)
  1122. z80.pc++
  1123. z80.r++
  1124.  
  1125. switch opcode2 {
  1126. /* z80_cb.c: Z80 CBxx opcodes
  1127. Copyright (c) 1999-2003 Philip Kendall
  1128.  
  1129. This program is free software; you can redistribute it and/or modify
  1130. it under the terms of the GNU General Public License as published by
  1131. the Free Software Foundation; either version 2 of the License, or
  1132. (at your option) any later version.
  1133.  
  1134. This program is distributed in the hope that it will be useful,
  1135. but WITHOUT ANY WARRANTY; without even the implied warranty of
  1136. MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
  1137. GNU General Public License for more details.
  1138.  
  1139. You should have received a copy of the GNU General Public License along
  1140. with this program; if not, write to the Free Software Foundation, Inc.,
  1141. 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
  1142.  
  1143. Author contact information:
  1144.  
  1145. E-mail: philip-fuse@shadowmagic.org.uk
  1146.  
  1147. */
  1148.  
  1149. /* NB: this file is autogenerated by './z80.pl' from 'opcodes_cb.dat',
  1150. and included in 'z80_ops.c' */
  1151.  
  1152. case 0x00: /* RLC B */
  1153. RLC(B)
  1154. break
  1155. case 0x01: /* RLC C */
  1156. RLC(C)
  1157. break
  1158. case 0x02: /* RLC D */
  1159. RLC(D)
  1160. break
  1161. case 0x03: /* RLC E */
  1162. RLC(E)
  1163. break
  1164. case 0x04: /* RLC H */
  1165. RLC(H)
  1166. break
  1167. case 0x05: /* RLC L */
  1168. RLC(L)
  1169. break
  1170. case 0x06: /* RLC (HL) */
  1171. var bytetemp byte = z80.readByte(z80.HL())
  1172. z80.contendReadNoMReq(z80.HL(), 1)
  1173. RLC(bytetemp)
  1174. z80.writeByte(z80.HL(), bytetemp)
  1175. break
  1176. case 0x07: /* RLC A */
  1177. RLC(A)
  1178. break
  1179. case 0x08: /* RRC B */
  1180. RRC(B)
  1181. break
  1182. case 0x09: /* RRC C */
  1183. RRC(C)
  1184. break
  1185. case 0x0a: /* RRC D */
  1186. RRC(D)
  1187. break
  1188. case 0x0b: /* RRC E */
  1189. RRC(E)
  1190. break
  1191. case 0x0c: /* RRC H */
  1192. RRC(H)
  1193. break
  1194. case 0x0d: /* RRC L */
  1195. RRC(L)
  1196. break
  1197. case 0x0e: /* RRC (HL) */
  1198. var bytetemp byte = z80.readByte(z80.HL())
  1199. z80.contendReadNoMReq(z80.HL(), 1)
  1200. RRC(bytetemp)
  1201. z80.writeByte(z80.HL(), bytetemp)
  1202. break
  1203. case 0x0f: /* RRC A */
  1204. RRC(A)
  1205. break
  1206. case 0x10: /* RL B */
  1207. RL(B)
  1208. break
  1209. case 0x11: /* RL C */
  1210. RL(C)
  1211. break
  1212. case 0x12: /* RL D */
  1213. RL(D)
  1214. break
  1215. case 0x13: /* RL E */
  1216. RL(E)
  1217. break
  1218. case 0x14: /* RL H */
  1219. RL(H)
  1220. break
  1221. case 0x15: /* RL L */
  1222. RL(L)
  1223. break
  1224. case 0x16: /* RL (HL) */
  1225. var bytetemp byte = z80.readByte(z80.HL())
  1226. z80.contendReadNoMReq(z80.HL(), 1)
  1227. RL(bytetemp)
  1228. z80.writeByte(z80.HL(), bytetemp)
  1229. break
  1230. case 0x17: /* RL A */
  1231. RL(A)
  1232. break
  1233. case 0x18: /* RR B */
  1234. RR(B)
  1235. break
  1236. case 0x19: /* RR C */
  1237. RR(C)
  1238. break
  1239. case 0x1a: /* RR D */
  1240. RR(D)
  1241. break
  1242. case 0x1b: /* RR E */
  1243. RR(E)
  1244. break
  1245. case 0x1c: /* RR H */
  1246. RR(H)
  1247. break
  1248. case 0x1d: /* RR L */
  1249. RR(L)
  1250. break
  1251. case 0x1e: /* RR (HL) */
  1252. var bytetemp byte = z80.readByte(z80.HL())
  1253. z80.contendReadNoMReq(z80.HL(), 1)
  1254. RR(bytetemp)
  1255. z80.writeByte(z80.HL(), bytetemp)
  1256. break
  1257. case 0x1f: /* RR A */
  1258. RR(A)
  1259. break
  1260. case 0x20: /* SLA B */
  1261. SLA(B)
  1262. break
  1263. case 0x21: /* SLA C */
  1264. SLA(C)
  1265. break
  1266. case 0x22: /* SLA D */
  1267. SLA(D)
  1268. break
  1269. case 0x23: /* SLA E */
  1270. SLA(E)
  1271. break
  1272. case 0x24: /* SLA H */
  1273. SLA(H)
  1274. break
  1275. case 0x25: /* SLA L */
  1276. SLA(L)
  1277. break
  1278. case 0x26: /* SLA (HL) */
  1279. var bytetemp byte = z80.readByte(z80.HL())
  1280. z80.contendReadNoMReq(z80.HL(), 1)
  1281. SLA(bytetemp)
  1282. z80.writeByte(z80.HL(), bytetemp)
  1283. break
  1284. case 0x27: /* SLA A */
  1285. SLA(A)
  1286. break
  1287. case 0x28: /* SRA B */
  1288. SRA(B)
  1289. break
  1290. case 0x29: /* SRA C */
  1291. SRA(C)
  1292. break
  1293. case 0x2a: /* SRA D */
  1294. SRA(D)
  1295. break
  1296. case 0x2b: /* SRA E */
  1297. SRA(E)
  1298. break
  1299. case 0x2c: /* SRA H */
  1300. SRA(H)
  1301. break
  1302. case 0x2d: /* SRA L */
  1303. SRA(L)
  1304. break
  1305. case 0x2e: /* SRA (HL) */
  1306. var bytetemp byte = z80.readByte(z80.HL())
  1307. z80.contendReadNoMReq(z80.HL(), 1)
  1308. SRA(bytetemp)
  1309. z80.writeByte(z80.HL(), bytetemp)
  1310. break
  1311. case 0x2f: /* SRA A */
  1312. SRA(A)
  1313. break
  1314. case 0x30: /* SLL B */
  1315. SLL(B)
  1316. break
  1317. case 0x31: /* SLL C */
  1318. SLL(C)
  1319. break
  1320. case 0x32: /* SLL D */
  1321. SLL(D)
  1322. break
  1323. case 0x33: /* SLL E */
  1324. SLL(E)
  1325. break
  1326. case 0x34: /* SLL H */
  1327. SLL(H)
  1328. break
  1329. case 0x35: /* SLL L */
  1330. SLL(L)
  1331. break
  1332. case 0x36: /* SLL (HL) */
  1333. var bytetemp byte = z80.readByte(z80.HL())
  1334. z80.contendReadNoMReq(z80.HL(), 1)
  1335. SLL(bytetemp)
  1336. z80.writeByte(z80.HL(), bytetemp)
  1337. break
  1338. case 0x37: /* SLL A */
  1339. SLL(A)
  1340. break
  1341. case 0x38: /* SRL B */
  1342. SRL(B)
  1343. break
  1344. case 0x39: /* SRL C */
  1345. SRL(C)
  1346. break
  1347. case 0x3a: /* SRL D */
  1348. SRL(D)
  1349. break
  1350. case 0x3b: /* SRL E */
  1351. SRL(E)
  1352. break
  1353. case 0x3c: /* SRL H */
  1354. SRL(H)
  1355. break
  1356. case 0x3d: /* SRL L */
  1357. SRL(L)
  1358. break
  1359. case 0x3e: /* SRL (HL) */
  1360. var bytetemp byte = z80.readByte(z80.HL())
  1361. z80.contendReadNoMReq(z80.HL(), 1)
  1362. SRL(bytetemp)
  1363. z80.writeByte(z80.HL(), bytetemp)
  1364. break
  1365. case 0x3f: /* SRL A */
  1366. SRL(A)
  1367. break
  1368. case 0x40: /* BIT 0,B */
  1369. BIT(0, B)
  1370. break
  1371. case 0x41: /* BIT 0,C */
  1372. BIT(0, C)
  1373. break
  1374. case 0x42: /* BIT 0,D */
  1375. BIT(0, D)
  1376. break
  1377. case 0x43: /* BIT 0,E */
  1378. BIT(0, E)
  1379. break
  1380. case 0x44: /* BIT 0,H */
  1381. BIT(0, H)
  1382. break
  1383. case 0x45: /* BIT 0,L */
  1384. BIT(0, L)
  1385. break
  1386. case 0x46: /* BIT 0,(HL) */
  1387. bytetemp := z80.readByte(z80.HL())
  1388. z80.contendReadNoMReq(z80.HL(), 1)
  1389. BIT(0, bytetemp)
  1390. break
  1391. case 0x47: /* BIT 0,A */
  1392. BIT(0, A)
  1393. break
  1394. case 0x48: /* BIT 1,B */
  1395. BIT(1, B)
  1396. break
  1397. case 0x49: /* BIT 1,C */
  1398. BIT(1, C)
  1399. break
  1400. case 0x4a: /* BIT 1,D */
  1401. BIT(1, D)
  1402. break
  1403. case 0x4b: /* BIT 1,E */
  1404. BIT(1, E)
  1405. break
  1406. case 0x4c: /* BIT 1,H */
  1407. BIT(1, H)
  1408. break
  1409. case 0x4d: /* BIT 1,L */
  1410. BIT(1, L)
  1411. break
  1412. case 0x4e: /* BIT 1,(HL) */
  1413. bytetemp := z80.readByte(z80.HL())
  1414. z80.contendReadNoMReq(z80.HL(), 1)
  1415. BIT(1, bytetemp)
  1416. break
  1417. case 0x4f: /* BIT 1,A */
  1418. BIT(1, A)
  1419. break
  1420. case 0x50: /* BIT 2,B */
  1421. BIT(2, B)
  1422. break
  1423. case 0x51: /* BIT 2,C */
  1424. BIT(2, C)
  1425. break
  1426. case 0x52: /* BIT 2,D */
  1427. BIT(2, D)
  1428. break
  1429. case 0x53: /* BIT 2,E */
  1430. BIT(2, E)
  1431. break
  1432. case 0x54: /* BIT 2,H */
  1433. BIT(2, H)
  1434. break
  1435. case 0x55: /* BIT 2,L */
  1436. BIT(2, L)
  1437. break
  1438. case 0x56: /* BIT 2,(HL) */
  1439. bytetemp := z80.readByte(z80.HL())
  1440. z80.contendReadNoMReq(z80.HL(), 1)
  1441. BIT(2, bytetemp)
  1442. break
  1443. case 0x57: /* BIT 2,A */
  1444. BIT(2, A)
  1445. break
  1446. case 0x58: /* BIT 3,B */
  1447. BIT(3, B)
  1448. break
  1449. case 0x59: /* BIT 3,C */
  1450. BIT(3, C)
  1451. break
  1452. case 0x5a: /* BIT 3,D */
  1453. BIT(3, D)
  1454. break
  1455. case 0x5b: /* BIT 3,E */
  1456. BIT(3, E)
  1457. break
  1458. case 0x5c: /* BIT 3,H */
  1459. BIT(3, H)
  1460. break
  1461. case 0x5d: /* BIT 3,L */
  1462. BIT(3, L)
  1463. break
  1464. case 0x5e: /* BIT 3,(HL) */
  1465. bytetemp := z80.readByte(z80.HL())
  1466. z80.contendReadNoMReq(z80.HL(), 1)
  1467. BIT(3, bytetemp)
  1468. break
  1469. case 0x5f: /* BIT 3,A */
  1470. BIT(3, A)
  1471. break
  1472. case 0x60: /* BIT 4,B */
  1473. BIT(4, B)
  1474. break
  1475. case 0x61: /* BIT 4,C */
  1476. BIT(4, C)
  1477. break
  1478. case 0x62: /* BIT 4,D */
  1479. BIT(4, D)
  1480. break
  1481. case 0x63: /* BIT 4,E */
  1482. BIT(4, E)
  1483. break
  1484. case 0x64: /* BIT 4,H */
  1485. BIT(4, H)
  1486. break
  1487. case 0x65: /* BIT 4,L */
  1488. BIT(4, L)
  1489. break
  1490. case 0x66: /* BIT 4,(HL) */
  1491. bytetemp := z80.readByte(z80.HL())
  1492. z80.contendReadNoMReq(z80.HL(), 1)
  1493. BIT(4, bytetemp)
  1494. break
  1495. case 0x67: /* BIT 4,A */
  1496. BIT(4, A)
  1497. break
  1498. case 0x68: /* BIT 5,B */
  1499. BIT(5, B)
  1500. break
  1501. case 0x69: /* BIT 5,C */
  1502. BIT(5, C)
  1503. break
  1504. case 0x6a: /* BIT 5,D */
  1505. BIT(5, D)
  1506. break
  1507. case 0x6b: /* BIT 5,E */
  1508. BIT(5, E)
  1509. break
  1510. case 0x6c: /* BIT 5,H */
  1511. BIT(5, H)
  1512. break
  1513. case 0x6d: /* BIT 5,L */
  1514. BIT(5, L)
  1515. break
  1516. case 0x6e: /* BIT 5,(HL) */
  1517. bytetemp := z80.readByte(z80.HL())
  1518. z80.contendReadNoMReq(z80.HL(), 1)
  1519. BIT(5, bytetemp)
  1520. break
  1521. case 0x6f: /* BIT 5,A */
  1522. BIT(5, A)
  1523. break
  1524. case 0x70: /* BIT 6,B */
  1525. BIT(6, B)
  1526. break
  1527. case 0x71: /* BIT 6,C */
  1528. BIT(6, C)
  1529. break
  1530. case 0x72: /* BIT 6,D */
  1531. BIT(6, D)
  1532. break
  1533. case 0x73: /* BIT 6,E */
  1534. BIT(6, E)
  1535. break
  1536. case 0x74: /* BIT 6,H */
  1537. BIT(6, H)
  1538. break
  1539. case 0x75: /* BIT 6,L */
  1540. BIT(6, L)
  1541. break
  1542. case 0x76: /* BIT 6,(HL) */
  1543. bytetemp := z80.readByte(z80.HL())
  1544. z80.contendReadNoMReq(z80.HL(), 1)
  1545. BIT(6, bytetemp)
  1546. break
  1547. case 0x77: /* BIT 6,A */
  1548. BIT(6, A)
  1549. break
  1550. case 0x78: /* BIT 7,B */
  1551. BIT(7, B)
  1552. break
  1553. case 0x79: /* BIT 7,C */
  1554. BIT(7, C)
  1555. break
  1556. case 0x7a: /* BIT 7,D */
  1557. BIT(7, D)
  1558. break
  1559. case 0x7b: /* BIT 7,E */
  1560. BIT(7, E)
  1561. break
  1562. case 0x7c: /* BIT 7,H */
  1563. BIT(7, H)
  1564. break
  1565. case 0x7d: /* BIT 7,L */
  1566. BIT(7, L)
  1567. break
  1568. case 0x7e: /* BIT 7,(HL) */
  1569. bytetemp := z80.readByte(z80.HL())
  1570. z80.contendReadNoMReq(z80.HL(), 1)
  1571. BIT(7, bytetemp)
  1572. break
  1573. case 0x7f: /* BIT 7,A */
  1574. BIT(7, A)
  1575. break
  1576. case 0x80: /* RES 0,B */
  1577. B &= 0xfe
  1578. break
  1579. case 0x81: /* RES 0,C */
  1580. C &= 0xfe
  1581. break
  1582. case 0x82: /* RES 0,D */
  1583. D &= 0xfe
  1584. break
  1585. case 0x83: /* RES 0,E */
  1586. E &= 0xfe
  1587. break
  1588. case 0x84: /* RES 0,H */
  1589. H &= 0xfe
  1590. break
  1591. case 0x85: /* RES 0,L */
  1592. L &= 0xfe
  1593. break
  1594. case 0x86: /* RES 0,(HL) */
  1595. var bytetemp byte = z80.readByte(z80.HL())
  1596. z80.contendReadNoMReq(z80.HL(), 1)
  1597. z80.writeByte(z80.HL(), bytetemp&0xfe)
  1598. break
  1599. case 0x87: /* RES 0,A */
  1600. A &= 0xfe
  1601. break
  1602. case 0x88: /* RES 1,B */
  1603. B &= 0xfd
  1604. break
  1605. case 0x89: /* RES 1,C */
  1606. C &= 0xfd
  1607. break
  1608. case 0x8a: /* RES 1,D */
  1609. D &= 0xfd
  1610. break
  1611. case 0x8b: /* RES 1,E */
  1612. E &= 0xfd
  1613. break
  1614. case 0x8c: /* RES 1,H */
  1615. H &= 0xfd
  1616. break
  1617. case 0x8d: /* RES 1,L */
  1618. L &= 0xfd
  1619. break
  1620. case 0x8e: /* RES 1,(HL) */
  1621. var bytetemp byte = z80.readByte(z80.HL())
  1622. z80.contendReadNoMReq(z80.HL(), 1)
  1623. z80.writeByte(z80.HL(), bytetemp&0xfd)
  1624. break
  1625. case 0x8f: /* RES 1,A */
  1626. A &= 0xfd
  1627. break
  1628. case 0x90: /* RES 2,B */
  1629. B &= 0xfb
  1630. break
  1631. case 0x91: /* RES 2,C */
  1632. C &= 0xfb
  1633. break
  1634. case 0x92: /* RES 2,D */
  1635. D &= 0xfb
  1636. break
  1637. case 0x93: /* RES 2,E */
  1638. E &= 0xfb
  1639. break
  1640. case 0x94: /* RES 2,H */
  1641. H &= 0xfb
  1642. break
  1643. case 0x95: /* RES 2,L */
  1644. L &= 0xfb
  1645. break
  1646. case 0x96: /* RES 2,(HL) */
  1647. var bytetemp byte = z80.readByte(z80.HL())
  1648. z80.contendReadNoMReq(z80.HL(), 1)
  1649. z80.writeByte(z80.HL(), bytetemp&0xfb)
  1650. break
  1651. case 0x97: /* RES 2,A */
  1652. A &= 0xfb
  1653. break
  1654. case 0x98: /* RES 3,B */
  1655. B &= 0xf7
  1656. break
  1657. case 0x99: /* RES 3,C */
  1658. C &= 0xf7
  1659. break
  1660. case 0x9a: /* RES 3,D */
  1661. D &= 0xf7
  1662. break
  1663. case 0x9b: /* RES 3,E */
  1664. E &= 0xf7
  1665. break
  1666. case 0x9c: /* RES 3,H */
  1667. H &= 0xf7
  1668. break
  1669. case 0x9d: /* RES 3,L */
  1670. L &= 0xf7
  1671. break
  1672. case 0x9e: /* RES 3,(HL) */
  1673. var bytetemp byte = z80.readByte(z80.HL())
  1674. z80.contendReadNoMReq(z80.HL(), 1)
  1675. z80.writeByte(z80.HL(), bytetemp&0xf7)
  1676. break
  1677. case 0x9f: /* RES 3,A */
  1678. A &= 0xf7
  1679. break
  1680. case 0xa0: /* RES 4,B */
  1681. B &= 0xef
  1682. break
  1683. case 0xa1: /* RES 4,C */
  1684. C &= 0xef
  1685. break
  1686. case 0xa2: /* RES 4,D */
  1687. D &= 0xef
  1688. break
  1689. case 0xa3: /* RES 4,E */
  1690. E &= 0xef
  1691. break
  1692. case 0xa4: /* RES 4,H */
  1693. H &= 0xef
  1694. break
  1695. case 0xa5: /* RES 4,L */
  1696. L &= 0xef
  1697. break
  1698. case 0xa6: /* RES 4,(HL) */
  1699. var bytetemp byte = z80.readByte(z80.HL())
  1700. z80.contendReadNoMReq(z80.HL(), 1)
  1701. z80.writeByte(z80.HL(), bytetemp&0xef)
  1702. break
  1703. case 0xa7: /* RES 4,A */
  1704. A &= 0xef
  1705. break
  1706. case 0xa8: /* RES 5,B */
  1707. B &= 0xdf
  1708. break
  1709. case 0xa9: /* RES 5,C */
  1710. C &= 0xdf
  1711. break
  1712. case 0xaa: /* RES 5,D */
  1713. D &= 0xdf
  1714. break
  1715. case 0xab: /* RES 5,E */
  1716. E &= 0xdf
  1717. break
  1718. case 0xac: /* RES 5,H */
  1719. H &= 0xdf
  1720. break
  1721. case 0xad: /* RES 5,L */
  1722. L &= 0xdf
  1723. break
  1724. case 0xae: /* RES 5,(HL) */
  1725. var bytetemp byte = z80.readByte(z80.HL())
  1726. z80.contendReadNoMReq(z80.HL(), 1)
  1727. z80.writeByte(z80.HL(), bytetemp&0xdf)
  1728. break
  1729. case 0xaf: /* RES 5,A */
  1730. A &= 0xdf
  1731. break
  1732. case 0xb0: /* RES 6,B */
  1733. B &= 0xbf
  1734. break
  1735. case 0xb1: /* RES 6,C */
  1736. C &= 0xbf
  1737. break
  1738. case 0xb2: /* RES 6,D */
  1739. D &= 0xbf
  1740. break
  1741. case 0xb3: /* RES 6,E */
  1742. E &= 0xbf
  1743. break
  1744. case 0xb4: /* RES 6,H */
  1745. H &= 0xbf
  1746. break
  1747. case 0xb5: /* RES 6,L */
  1748. L &= 0xbf
  1749. break
  1750. case 0xb6: /* RES 6,(HL) */
  1751. var bytetemp byte = z80.readByte(z80.HL())
  1752. z80.contendReadNoMReq(z80.HL(), 1)
  1753. z80.writeByte(z80.HL(), bytetemp&0xbf)
  1754. break
  1755. case 0xb7: /* RES 6,A */
  1756. A &= 0xbf
  1757. break
  1758. case 0xb8: /* RES 7,B */
  1759. B &= 0x7f
  1760. break
  1761. case 0xb9: /* RES 7,C */
  1762. C &= 0x7f
  1763. break
  1764. case 0xba: /* RES 7,D */
  1765. D &= 0x7f
  1766. break
  1767. case 0xbb: /* RES 7,E */
  1768. E &= 0x7f
  1769. break
  1770. case 0xbc: /* RES 7,H */
  1771. H &= 0x7f
  1772. break
  1773. case 0xbd: /* RES 7,L */
  1774. L &= 0x7f
  1775. break
  1776. case 0xbe: /* RES 7,(HL) */
  1777. var bytetemp byte = z80.readByte(z80.HL())
  1778. z80.contendReadNoMReq(z80.HL(), 1)
  1779. z80.writeByte(z80.HL(), bytetemp&0x7f)
  1780. break
  1781. case 0xbf: /* RES 7,A */
  1782. A &= 0x7f
  1783. break
  1784. case 0xc0: /* SET 0,B */
  1785. B |= 0x01
  1786. break
  1787. case 0xc1: /* SET 0,C */
  1788. C |= 0x01
  1789. break
  1790. case 0xc2: /* SET 0,D */
  1791. D |= 0x01
  1792. break
  1793. case 0xc3: /* SET 0,E */
  1794. E |= 0x01
  1795. break
  1796. case 0xc4: /* SET 0,H */
  1797. H |= 0x01
  1798. break
  1799. case 0xc5: /* SET 0,L */
  1800. L |= 0x01
  1801. break
  1802. case 0xc6: /* SET 0,(HL) */
  1803. var bytetemp byte = z80.readByte(z80.HL())
  1804. z80.contendReadNoMReq(z80.HL(), 1)
  1805. z80.writeByte(z80.HL(), bytetemp|0x01)
  1806. break
  1807. case 0xc7: /* SET 0,A */
  1808. A |= 0x01
  1809. break
  1810. case 0xc8: /* SET 1,B */
  1811. B |= 0x02
  1812. break
  1813. case 0xc9: /* SET 1,C */
  1814. C |= 0x02
  1815. break
  1816. case 0xca: /* SET 1,D */
  1817. D |= 0x02
  1818. break
  1819. case 0xcb: /* SET 1,E */
  1820. E |= 0x02
  1821. break
  1822. case 0xcc: /* SET 1,H */
  1823. H |= 0x02
  1824. break
  1825. case 0xcd: /* SET 1,L */
  1826. L |= 0x02
  1827. break
  1828. case 0xce: /* SET 1,(HL) */
  1829. var bytetemp byte = z80.readByte(z80.HL())
  1830. z80.contendReadNoMReq(z80.HL(), 1)
  1831. z80.writeByte(z80.HL(), bytetemp|0x02)
  1832. break
  1833. case 0xcf: /* SET 1,A */
  1834. A |= 0x02
  1835. break
  1836. case 0xd0: /* SET 2,B */
  1837. B |= 0x04
  1838. break
  1839. case 0xd1: /* SET 2,C */
  1840. C |= 0x04
  1841. break
  1842. case 0xd2: /* SET 2,D */
  1843. D |= 0x04
  1844. break
  1845. case 0xd3: /* SET 2,E */
  1846. E |= 0x04
  1847. break
  1848. case 0xd4: /* SET 2,H */
  1849. H |= 0x04
  1850. break
  1851. case 0xd5: /* SET 2,L */
  1852. L |= 0x04
  1853. break
  1854. case 0xd6: /* SET 2,(HL) */
  1855. var bytetemp byte = z80.readByte(z80.HL())
  1856. z80.contendReadNoMReq(z80.HL(), 1)
  1857. z80.writeByte(z80.HL(), bytetemp|0x04)
  1858. break
  1859. case 0xd7: /* SET 2,A */
  1860. A |= 0x04
  1861. break
  1862. case 0xd8: /* SET 3,B */
  1863. B |= 0x08
  1864. break
  1865. case 0xd9: /* SET 3,C */
  1866. C |= 0x08
  1867. break
  1868. case 0xda: /* SET 3,D */
  1869. D |= 0x08
  1870. break
  1871. case 0xdb: /* SET 3,E */
  1872. E |= 0x08
  1873. break
  1874. case 0xdc: /* SET 3,H */
  1875. H |= 0x08
  1876. break
  1877. case 0xdd: /* SET 3,L */
  1878. L |= 0x08
  1879. break
  1880. case 0xde: /* SET 3,(HL) */
  1881. var bytetemp byte = z80.readByte(z80.HL())
  1882. z80.contendReadNoMReq(z80.HL(), 1)
  1883. z80.writeByte(z80.HL(), bytetemp|0x08)
  1884. break
  1885. case 0xdf: /* SET 3,A */
  1886. A |= 0x08
  1887. break
  1888. case 0xe0: /* SET 4,B */
  1889. B |= 0x10
  1890. break
  1891. case 0xe1: /* SET 4,C */
  1892. C |= 0x10
  1893. break
  1894. case 0xe2: /* SET 4,D */
  1895. D |= 0x10
  1896. break
  1897. case 0xe3: /* SET 4,E */
  1898. E |= 0x10
  1899. break
  1900. case 0xe4: /* SET 4,H */
  1901. H |= 0x10
  1902. break
  1903. case 0xe5: /* SET 4,L */
  1904. L |= 0x10
  1905. break
  1906. case 0xe6: /* SET 4,(HL) */
  1907. var bytetemp byte = z80.readByte(z80.HL())
  1908. z80.contendReadNoMReq(z80.HL(), 1)
  1909. z80.writeByte(z80.HL(), bytetemp|0x10)
  1910. break
  1911. case 0xe7: /* SET 4,A */
  1912. A |= 0x10
  1913. break
  1914. case 0xe8: /* SET 5,B */
  1915. B |= 0x20
  1916. break
  1917. case 0xe9: /* SET 5,C */
  1918. C |= 0x20
  1919. break
  1920. case 0xea: /* SET 5,D */
  1921. D |= 0x20
  1922. break
  1923. case 0xeb: /* SET 5,E */
  1924. E |= 0x20
  1925. break
  1926. case 0xec: /* SET 5,H */
  1927. H |= 0x20
  1928. break
  1929. case 0xed: /* SET 5,L */
  1930. L |= 0x20
  1931. break
  1932. case 0xee: /* SET 5,(HL) */
  1933. var bytetemp byte = z80.readByte(z80.HL())
  1934. z80.contendReadNoMReq(z80.HL(), 1)
  1935. z80.writeByte(z80.HL(), bytetemp|0x20)
  1936. break
  1937. case 0xef: /* SET 5,A */
  1938. A |= 0x20
  1939. break
  1940. case 0xf0: /* SET 6,B */
  1941. B |= 0x40
  1942. break
  1943. case 0xf1: /* SET 6,C */
  1944. C |= 0x40
  1945. break
  1946. case 0xf2: /* SET 6,D */
  1947. D |= 0x40
  1948. break
  1949. case 0xf3: /* SET 6,E */
  1950. E |= 0x40
  1951. break
  1952. case 0xf4: /* SET 6,H */
  1953. H |= 0x40
  1954. break
  1955. case 0xf5: /* SET 6,L */
  1956. L |= 0x40
  1957. break
  1958. case 0xf6: /* SET 6,(HL) */
  1959. var bytetemp byte = z80.readByte(z80.HL())
  1960. z80.contendReadNoMReq(z80.HL(), 1)
  1961. z80.writeByte(z80.HL(), bytetemp|0x40)
  1962. break
  1963. case 0xf7: /* SET 6,A */
  1964. A |= 0x40
  1965. break
  1966. case 0xf8: /* SET 7,B */
  1967. B |= 0x80
  1968. break
  1969. case 0xf9: /* SET 7,C */
  1970. C |= 0x80
  1971. break
  1972. case 0xfa: /* SET 7,D */
  1973. D |= 0x80
  1974. break
  1975. case 0xfb: /* SET 7,E */
  1976. E |= 0x80
  1977. break
  1978. case 0xfc: /* SET 7,H */
  1979. H |= 0x80
  1980. break
  1981. case 0xfd: /* SET 7,L */
  1982. L |= 0x80
  1983. break
  1984. case 0xfe: /* SET 7,(HL) */
  1985. var bytetemp byte = z80.readByte(z80.HL())
  1986. z80.contendReadNoMReq(z80.HL(), 1)
  1987. z80.writeByte(z80.HL(), bytetemp|0x80)
  1988. break
  1989. case 0xff: /* SET 7,A */
  1990. A |= 0x80
  1991. break
  1992.  
  1993. }
  1994. }
  1995. break
  1996. case 0xcc: /* CALL Z,nnnn */
  1997. if z80.f & FLAG_Z {
  1998. CALL()
  1999. } else {
  2000. z80.contendRead(z80.pc, 3)
  2001. z80.contendRead(z80.pc+1, 3)
  2002. z80.pc += 2
  2003. }
  2004. break
  2005. case 0xcd: /* CALL nnnn */
  2006. CALL()
  2007. break
  2008. case 0xce: /* ADC A,nn */
  2009. {
  2010. var bytetemp byte = z80.readByte(PC)
  2011. z80.pc++
  2012. ADC(bytetemp)
  2013. }
  2014. break
  2015. case 0xcf: /* RST 8 */
  2016. z80.contendReadNoMReq(z80.IR(), 1)
  2017. RST(0x08)
  2018. break
  2019. case 0xd0: /* RET NC */
  2020. z80.contendReadNoMReq(z80.IR(), 1)
  2021. if !(z80.f & FLAG_C) {
  2022. RET()
  2023. }
  2024. break
  2025. case 0xd1: /* POP DE */
  2026. POP16(E, D)
  2027. break
  2028. case 0xd2: /* JP NC,nnnn */
  2029. if !(z80.f & FLAG_C) {
  2030. JP()
  2031. } else {
  2032. z80.contendRead(z80.pc, 3)
  2033. z80.contendRead(z80.pc+1, 3)
  2034. z80.pc += 2
  2035. }
  2036. break
  2037. case 0xd3: /* OUT (nn),A */
  2038. var outtemp uint16
  2039. outtemp = z80.readByte(z80.pc) + (z80.a << 8)
  2040. z80.pc++
  2041. writeport(outtemp, z80.a)
  2042. break
  2043. case 0xd4: /* CALL NC,nnnn */
  2044. if !(z80.f & FLAG_C) {
  2045. CALL()
  2046. } else {
  2047. z80.contendRead(z80.pc, 3)
  2048. z80.contendRead(z80.pc+1, 3)
  2049. z80.pc += 2
  2050. }
  2051. break
  2052. case 0xd5: /* PUSH DE */
  2053. z80.contendReadNoMReq(z80.IR(), 1)
  2054. PUSH16(E, D)
  2055. break
  2056. case 0xd6: /* SUB nn */
  2057. {
  2058. var bytetemp byte = z80.readByte(PC)
  2059. z80.pc++
  2060. SUB(bytetemp)
  2061. }
  2062. break
  2063. case 0xd7: /* RST 10 */
  2064. z80.contendReadNoMReq(z80.IR(), 1)
  2065. RST(0x10)
  2066. break
  2067. case 0xd8: /* RET C */
  2068. z80.contendReadNoMReq(z80.IR(), 1)
  2069. if z80.f & FLAG_C {
  2070. RET()
  2071. }
  2072. break
  2073. case 0xd9: /* EXX */
  2074. var wordtemp uint16
  2075. wordtemp = BC
  2076. BC = BC_
  2077. BC_ = wordtemp
  2078. wordtemp = DE
  2079. DE = DE_
  2080. DE_ = wordtemp
  2081. wordtemp = z80.HL()
  2082. HL = HL_
  2083. HL_ = wordtemp
  2084. break
  2085. case 0xda: /* JP C,nnnn */
  2086. if z80.f & FLAG_C {
  2087. JP()
  2088. } else {
  2089. z80.contendRead(z80.pc, 3)
  2090. z80.contendRead(z80.pc+1, 3)
  2091. z80.pc += 2
  2092. }
  2093. break
  2094. case 0xdb: /* IN A,(nn) */
  2095. var intemp uint16
  2096. intemp = z80.readByte(z80.pc) + (z80.a << 8)
  2097. z80.pc++
  2098. z80.a = readport(intemp)
  2099. break
  2100. case 0xdc: /* CALL C,nnnn */
  2101. if z80.f & FLAG_C {
  2102. CALL()
  2103. } else {
  2104. z80.contendRead(z80.pc, 3)
  2105. z80.contendRead(z80.pc+1, 3)
  2106. z80.pc += 2
  2107. }
  2108. break
  2109. case 0xdd: /* shift DD */
  2110. {
  2111. var opcode2 byte
  2112. z80.contendRead(z80.pc, 4)
  2113. opcode2 = z80.readByteInternal(z80.pc)
  2114. z80.pc++
  2115. z80.r++
  2116.  
  2117. switch opcode2 {
  2118. /* z80_ddfd.c Z80 {DD,FD}xx opcodes
  2119. Copyright (c) 1999-2003 Philip Kendall
  2120.  
  2121. This program is free software; you can redistribute it and/or modify
  2122. it under the terms of the GNU General Public License as published by
  2123. the Free Software Foundation; either version 2 of the License, or
  2124. (at your option) any later version.
  2125.  
  2126. This program is distributed in the hope that it will be useful,
  2127. but WITHOUT ANY WARRANTY; without even the implied warranty of
  2128. MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
  2129. GNU General Public License for more details.
  2130.  
  2131. You should have received a copy of the GNU General Public License along
  2132. with this program; if not, write to the Free Software Foundation, Inc.,
  2133. 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
  2134.  
  2135. Author contact information:
  2136.  
  2137. E-mail: philip-fuse@shadowmagic.org.uk
  2138.  
  2139. */
  2140.  
  2141. /* NB: this file is autogenerated by './z80.pl' from 'opcodes_ddfd.dat',
  2142. and included in 'z80_ops.c' */
  2143.  
  2144. case 0x09: /* ADD REGISTER,BC */
  2145. z80.contendReadNoMReq(z80.IR(), 1)
  2146. z80.contendReadNoMReq(z80.IR(), 1)
  2147. z80.contendReadNoMReq(z80.IR(), 1)
  2148. z80.contendReadNoMReq(z80.IR(), 1)
  2149. z80.contendReadNoMReq(z80.IR(), 1)
  2150. z80.contendReadNoMReq(z80.IR(), 1)
  2151. z80.contendReadNoMReq(z80.IR(), 1)
  2152. ADD16(REGISTER, BC)
  2153. break
  2154. case 0x19: /* ADD REGISTER,DE */
  2155. z80.contendReadNoMReq(z80.IR(), 1)
  2156. z80.contendReadNoMReq(z80.IR(), 1)
  2157. z80.contendReadNoMReq(z80.IR(), 1)
  2158. z80.contendReadNoMReq(z80.IR(), 1)
  2159. z80.contendReadNoMReq(z80.IR(), 1)
  2160. z80.contendReadNoMReq(z80.IR(), 1)
  2161. z80.contendReadNoMReq(z80.IR(), 1)
  2162. ADD16(REGISTER, DE)
  2163. break
  2164. case 0x21: /* LD REGISTER,nnnn */
  2165. REGISTERL = z80.readByte(z80.pc)
  2166. z80.pc++
  2167. REGISTERH = z80.readByte(z80.pc)
  2168. z80.pc++
  2169. break
  2170. case 0x22: /* LD (nnnn),REGISTER */
  2171. LD16_NNRR(REGISTERL, REGISTERH)
  2172. break
  2173. case 0x23: /* INC REGISTER */
  2174. z80.contendReadNoMReq(z80.IR(), 1)
  2175. z80.contendReadNoMReq(z80.IR(), 1)
  2176. z80.incREGISTER()
  2177. break
  2178. case 0x24: /* INC REGISTERH */
  2179. z80.incREGISTERH()
  2180. break
  2181. case 0x25: /* DEC REGISTERH */
  2182. z80.decREGISTERH()
  2183. break
  2184. case 0x26: /* LD REGISTERH,nn */
  2185. REGISTERH = z80.readByte(z80.pc)
  2186. z80.pc++
  2187. break
  2188. case 0x29: /* ADD REGISTER,REGISTER */
  2189. z80.contendReadNoMReq(z80.IR(), 1)
  2190. z80.contendReadNoMReq(z80.IR(), 1)
  2191. z80.contendReadNoMReq(z80.IR(), 1)
  2192. z80.contendReadNoMReq(z80.IR(), 1)
  2193. z80.contendReadNoMReq(z80.IR(), 1)
  2194. z80.contendReadNoMReq(z80.IR(), 1)
  2195. z80.contendReadNoMReq(z80.IR(), 1)
  2196. ADD16(REGISTER, REGISTER)
  2197. break
  2198. case 0x2a: /* LD REGISTER,(nnnn) */
  2199. LD16_RRNN(REGISTERL, REGISTERH)
  2200. break
  2201. case 0x2b: /* DEC REGISTER */
  2202. z80.contendReadNoMReq(z80.IR(), 1)
  2203. z80.contendReadNoMReq(z80.IR(), 1)
  2204. z80.decREGISTER()
  2205. break
  2206. case 0x2c: /* INC REGISTERL */
  2207. z80.incREGISTERL()
  2208. break
  2209. case 0x2d: /* DEC REGISTERL */
  2210. z80.decREGISTERL()
  2211. break
  2212. case 0x2e: /* LD REGISTERL,nn */
  2213. REGISTERL = z80.readByte(z80.pc)
  2214. z80.pc++
  2215. break
  2216. case 0x34: /* INC (REGISTER+dd) */
  2217. var offset, bytetemp byte
  2218. var wordtemp uint16
  2219. offset = z80.readByte(z80.pc)
  2220. z80.contendReadNoMReq(z80.pc, 1)
  2221. z80.contendReadNoMReq(z80.pc, 1)
  2222. z80.contendReadNoMReq(z80.pc, 1)
  2223. z80.contendReadNoMReq(z80.pc, 1)
  2224. z80.contendReadNoMReq(z80.pc, 1)
  2225. z80.pc++
  2226. wordtemp = REGISTER + signExtend(offset)
  2227. bytetemp = z80.readByte(wordtemp)
  2228. z80.contendReadNoMReq(wordtemp, 1)
  2229. INC(bytetemp)
  2230. z80.writeByte(wordtemp, bytetemp)
  2231. break
  2232. case 0x35: /* DEC (REGISTER+dd) */
  2233. var offset, bytetemp byte
  2234. var wordtemp uint16
  2235. offset = z80.readByte(z80.pc)
  2236. z80.contendReadNoMReq(z80.pc, 1)
  2237. z80.contendReadNoMReq(z80.pc, 1)
  2238. z80.contendReadNoMReq(z80.pc, 1)
  2239. z80.contendReadNoMReq(z80.pc, 1)
  2240. z80.contendReadNoMReq(z80.pc, 1)
  2241. z80.pc++
  2242. wordtemp = REGISTER + signExtend(offset)
  2243. bytetemp = z80.readByte(wordtemp)
  2244. z80.contendReadNoMReq(wordtemp, 1)
  2245. DEC(bytetemp)
  2246. z80.writeByte(wordtemp, bytetemp)
  2247. break
  2248. case 0x36: /* LD (REGISTER+dd),nn */
  2249. offset := z80.readByte(z80.pc)
  2250. z80.pc++
  2251. value := z80.readByte(z80.pc)
  2252. z80.contendReadNoMReq(z80.pc, 1)
  2253. z80.contendReadNoMReq(z80.pc, 1)
  2254. z80.pc++
  2255. z80.writeByte(REGISTER+signExtend(offset), value)
  2256. break
  2257. case 0x39: /* ADD REGISTER,SP */
  2258. z80.contendReadNoMReq(z80.IR(), 1)
  2259. z80.contendReadNoMReq(z80.IR(), 1)
  2260. z80.contendReadNoMReq(z80.IR(), 1)
  2261. z80.contendReadNoMReq(z80.IR(), 1)
  2262. z80.contendReadNoMReq(z80.IR(), 1)
  2263. z80.contendReadNoMReq(z80.IR(), 1)
  2264. z80.contendReadNoMReq(z80.IR(), 1)
  2265. ADD16(REGISTER, SP)
  2266. break
  2267. case 0x44: /* LD B,REGISTERH */
  2268. B = REGISTERH
  2269. break
  2270. case 0x45: /* LD B,REGISTERL */
  2271. B = REGISTERL
  2272. break
  2273. case 0x46: /* LD B,(REGISTER+dd) */
  2274. var offset byte
  2275. offset = z80.readByte(z80.pc)
  2276. z80.contendReadNoMReq(z80.pc, 1)
  2277. z80.contendReadNoMReq(z80.pc, 1)
  2278. z80.contendReadNoMReq(z80.pc, 1)
  2279. z80.contendReadNoMReq(z80.pc, 1)
  2280. z80.contendReadNoMReq(z80.pc, 1)
  2281. z80.pc++
  2282. B = z80.readByte(REGISTER + signExtend(offset))
  2283. break
  2284. case 0x4c: /* LD C,REGISTERH */
  2285. C = REGISTERH
  2286. break
  2287. case 0x4d: /* LD C,REGISTERL */
  2288. C = REGISTERL
  2289. break
  2290. case 0x4e: /* LD C,(REGISTER+dd) */
  2291. var offset byte
  2292. offset = z80.readByte(z80.pc)
  2293. z80.contendReadNoMReq(z80.pc, 1)
  2294. z80.contendReadNoMReq(z80.pc, 1)
  2295. z80.contendReadNoMReq(z80.pc, 1)
  2296. z80.contendReadNoMReq(z80.pc, 1)
  2297. z80.contendReadNoMReq(z80.pc, 1)
  2298. z80.pc++
  2299. C = z80.readByte(REGISTER + signExtend(offset))
  2300. break
  2301. case 0x54: /* LD D,REGISTERH */
  2302. D = REGISTERH
  2303. break
  2304. case 0x55: /* LD D,REGISTERL */
  2305. D = REGISTERL
  2306. break
  2307. case 0x56: /* LD D,(REGISTER+dd) */
  2308. var offset byte
  2309. offset = z80.readByte(z80.pc)
  2310. z80.contendReadNoMReq(z80.pc, 1)
  2311. z80.contendReadNoMReq(z80.pc, 1)
  2312. z80.contendReadNoMReq(z80.pc, 1)
  2313. z80.contendReadNoMReq(z80.pc, 1)
  2314. z80.contendReadNoMReq(z80.pc, 1)
  2315. z80.pc++
  2316. D = z80.readByte(REGISTER + signExtend(offset))
  2317. break
  2318. case 0x5c: /* LD E,REGISTERH */
  2319. E = REGISTERH
  2320. break
  2321. case 0x5d: /* LD E,REGISTERL */
  2322. E = REGISTERL
  2323. break
  2324. case 0x5e: /* LD E,(REGISTER+dd) */
  2325. var offset byte
  2326. offset = z80.readByte(z80.pc)
  2327. z80.contendReadNoMReq(z80.pc, 1)
  2328. z80.contendReadNoMReq(z80.pc, 1)
  2329. z80.contendReadNoMReq(z80.pc, 1)
  2330. z80.contendReadNoMReq(z80.pc, 1)
  2331. z80.contendReadNoMReq(z80.pc, 1)
  2332. z80.pc++
  2333. E = z80.readByte(REGISTER + signExtend(offset))
  2334. break
  2335. case 0x60: /* LD REGISTERH,B */
  2336. REGISTERH = B
  2337. break
  2338. case 0x61: /* LD REGISTERH,C */
  2339. REGISTERH = C
  2340. break
  2341. case 0x62: /* LD REGISTERH,D */
  2342. REGISTERH = D
  2343. break
  2344. case 0x63: /* LD REGISTERH,E */
  2345. REGISTERH = E
  2346. break
  2347. case 0x64: /* LD REGISTERH,REGISTERH */
  2348. break
  2349. case 0x65: /* LD REGISTERH,REGISTERL */
  2350. REGISTERH = REGISTERL
  2351. break
  2352. case 0x66: /* LD H,(REGISTER+dd) */
  2353. var offset byte
  2354. offset = z80.readByte(z80.pc)
  2355. z80.contendReadNoMReq(z80.pc, 1)
  2356. z80.contendReadNoMReq(z80.pc, 1)
  2357. z80.contendReadNoMReq(z80.pc, 1)
  2358. z80.contendReadNoMReq(z80.pc, 1)
  2359. z80.contendReadNoMReq(z80.pc, 1)
  2360. z80.pc++
  2361. H = z80.readByte(REGISTER + signExtend(offset))
  2362. break
  2363. case 0x67: /* LD REGISTERH,A */
  2364. REGISTERH = A
  2365. break
  2366. case 0x68: /* LD REGISTERL,B */
  2367. REGISTERL = B
  2368. break
  2369. case 0x69: /* LD REGISTERL,C */
  2370. REGISTERL = C
  2371. break
  2372. case 0x6a: /* LD REGISTERL,D */
  2373. REGISTERL = D
  2374. break
  2375. case 0x6b: /* LD REGISTERL,E */
  2376. REGISTERL = E
  2377. break
  2378. case 0x6c: /* LD REGISTERL,REGISTERH */
  2379. REGISTERL = REGISTERH
  2380. break
  2381. case 0x6d: /* LD REGISTERL,REGISTERL */
  2382. break
  2383. case 0x6e: /* LD L,(REGISTER+dd) */
  2384. var offset byte
  2385. offset = z80.readByte(z80.pc)
  2386. z80.contendReadNoMReq(z80.pc, 1)
  2387. z80.contendReadNoMReq(z80.pc, 1)
  2388. z80.contendReadNoMReq(z80.pc, 1)
  2389. z80.contendReadNoMReq(z80.pc, 1)
  2390. z80.contendReadNoMReq(z80.pc, 1)
  2391. z80.pc++
  2392. L = z80.readByte(REGISTER + signExtend(offset))
  2393. break
  2394. case 0x6f: /* LD REGISTERL,A */
  2395. REGISTERL = A
  2396. break
  2397. case 0x70: /* LD (REGISTER+dd),B */
  2398. offset := z80.readByte(z80.pc)
  2399. z80.contendReadNoMReq(z80.pc, 1)
  2400. z80.contendReadNoMReq(z80.pc, 1)
  2401. z80.contendReadNoMReq(z80.pc, 1)
  2402. z80.contendReadNoMReq(z80.pc, 1)
  2403. z80.contendReadNoMReq(z80.pc, 1)
  2404. z80.pc++
  2405. z80.writeByte(REGISTER+signExtend(offset), B)
  2406. break
  2407. case 0x71: /* LD (REGISTER+dd),C */
  2408. offset := z80.readByte(z80.pc)
  2409. z80.contendReadNoMReq(z80.pc, 1)
  2410. z80.contendReadNoMReq(z80.pc, 1)
  2411. z80.contendReadNoMReq(z80.pc, 1)
  2412. z80.contendReadNoMReq(z80.pc, 1)
  2413. z80.contendReadNoMReq(z80.pc, 1)
  2414. z80.pc++
  2415. z80.writeByte(REGISTER+signExtend(offset), C)
  2416. break
  2417. case 0x72: /* LD (REGISTER+dd),D */
  2418. offset := z80.readByte(z80.pc)
  2419. z80.contendReadNoMReq(z80.pc, 1)
  2420. z80.contendReadNoMReq(z80.pc, 1)
  2421. z80.contendReadNoMReq(z80.pc, 1)
  2422. z80.contendReadNoMReq(z80.pc, 1)
  2423. z80.contendReadNoMReq(z80.pc, 1)
  2424. z80.pc++
  2425. z80.writeByte(REGISTER+signExtend(offset), D)
  2426. break
  2427. case 0x73: /* LD (REGISTER+dd),E */
  2428. offset := z80.readByte(z80.pc)
  2429. z80.contendReadNoMReq(z80.pc, 1)
  2430. z80.contendReadNoMReq(z80.pc, 1)
  2431. z80.contendReadNoMReq(z80.pc, 1)
  2432. z80.contendReadNoMReq(z80.pc, 1)
  2433. z80.contendReadNoMReq(z80.pc, 1)
  2434. z80.pc++
  2435. z80.writeByte(REGISTER+signExtend(offset), E)
  2436. break
  2437. case 0x74: /* LD (REGISTER+dd),H */
  2438. offset := z80.readByte(z80.pc)
  2439. z80.contendReadNoMReq(z80.pc, 1)
  2440. z80.contendReadNoMReq(z80.pc, 1)
  2441. z80.contendReadNoMReq(z80.pc, 1)
  2442. z80.contendReadNoMReq(z80.pc, 1)
  2443. z80.contendReadNoMReq(z80.pc, 1)
  2444. z80.pc++
  2445. z80.writeByte(REGISTER+signExtend(offset), H)
  2446. break
  2447. case 0x75: /* LD (REGISTER+dd),L */
  2448. offset := z80.readByte(z80.pc)
  2449. z80.contendReadNoMReq(z80.pc, 1)
  2450. z80.contendReadNoMReq(z80.pc, 1)
  2451. z80.contendReadNoMReq(z80.pc, 1)
  2452. z80.contendReadNoMReq(z80.pc, 1)
  2453. z80.contendReadNoMReq(z80.pc, 1)
  2454. z80.pc++
  2455. z80.writeByte(REGISTER+signExtend(offset), L)
  2456. break
  2457. case 0x77: /* LD (REGISTER+dd),A */
  2458. offset := z80.readByte(z80.pc)
  2459. z80.contendReadNoMReq(z80.pc, 1)
  2460. z80.contendReadNoMReq(z80.pc, 1)
  2461. z80.contendReadNoMReq(z80.pc, 1)
  2462. z80.contendReadNoMReq(z80.pc, 1)
  2463. z80.contendReadNoMReq(z80.pc, 1)
  2464. z80.pc++
  2465. z80.writeByte(REGISTER+signExtend(offset), A)
  2466. break
  2467. case 0x7c: /* LD A,REGISTERH */
  2468. A = REGISTERH
  2469. break
  2470. case 0x7d: /* LD A,REGISTERL */
  2471. A = REGISTERL
  2472. break
  2473. case 0x7e: /* LD A,(REGISTER+dd) */
  2474. var offset byte
  2475. offset = z80.readByte(z80.pc)
  2476. z80.contendReadNoMReq(z80.pc, 1)
  2477. z80.contendReadNoMReq(z80.pc, 1)
  2478. z80.contendReadNoMReq(z80.pc, 1)
  2479. z80.contendReadNoMReq(z80.pc, 1)
  2480. z80.contendReadNoMReq(z80.pc, 1)
  2481. z80.pc++
  2482. A = z80.readByte(REGISTER + signExtend(offset))
  2483. break
  2484. case 0x84: /* ADD A,REGISTERH */
  2485. ADD(REGISTERH)
  2486. break
  2487. case 0x85: /* ADD A,REGISTERL */
  2488. ADD(REGISTERL)
  2489. break
  2490. case 0x86: /* ADD A,(REGISTER+dd) */
  2491.  
  2492. var offset, bytetemp byte
  2493. offset = z80.readByte(z80.pc)
  2494. z80.contendReadNoMReq(z80.pc, 1)
  2495. z80.contendReadNoMReq(z80.pc, 1)
  2496. z80.contendReadNoMReq(z80.pc, 1)
  2497. z80.contendReadNoMReq(z80.pc, 1)
  2498. z80.contendReadNoMReq(z80.pc, 1)
  2499. z80.pc++
  2500. bytetemp = z80.readByte(REGISTER + signExtend(offset))
  2501. ADD(bytetemp)
  2502.  
  2503. break
  2504. case 0x8c: /* ADC A,REGISTERH */
  2505. ADC(REGISTERH)
  2506. break
  2507. case 0x8d: /* ADC A,REGISTERL */
  2508. ADC(REGISTERL)
  2509. break
  2510. case 0x8e: /* ADC A,(REGISTER+dd) */
  2511.  
  2512. var offset, bytetemp byte
  2513. offset = z80.readByte(z80.pc)
  2514. z80.contendReadNoMReq(z80.pc, 1)
  2515. z80.contendReadNoMReq(z80.pc, 1)
  2516. z80.contendReadNoMReq(z80.pc, 1)
  2517. z80.contendReadNoMReq(z80.pc, 1)
  2518. z80.contendReadNoMReq(z80.pc, 1)
  2519. z80.pc++
  2520. bytetemp = z80.readByte(REGISTER + signExtend(offset))
  2521. ADC(bytetemp)
  2522.  
  2523. break
  2524. case 0x94: /* SUB A,REGISTERH */
  2525. SUB(REGISTERH)
  2526. break
  2527. case 0x95: /* SUB A,REGISTERL */
  2528. SUB(REGISTERL)
  2529. break
  2530. case 0x96: /* SUB A,(REGISTER+dd) */
  2531.  
  2532. var offset, bytetemp byte
  2533. offset = z80.readByte(z80.pc)
  2534. z80.contendReadNoMReq(z80.pc, 1)
  2535. z80.contendReadNoMReq(z80.pc, 1)
  2536. z80.contendReadNoMReq(z80.pc, 1)
  2537. z80.contendReadNoMReq(z80.pc, 1)
  2538. z80.contendReadNoMReq(z80.pc, 1)
  2539. z80.pc++
  2540. bytetemp = z80.readByte(REGISTER + signExtend(offset))
  2541. SUB(bytetemp)
  2542.  
  2543. break
  2544. case 0x9c: /* SBC A,REGISTERH */
  2545. SBC(REGISTERH)
  2546. break
  2547. case 0x9d: /* SBC A,REGISTERL */
  2548. SBC(REGISTERL)
  2549. break
  2550. case 0x9e: /* SBC A,(REGISTER+dd) */
  2551.  
  2552. var offset, bytetemp byte
  2553. offset = z80.readByte(z80.pc)
  2554. z80.contendReadNoMReq(z80.pc, 1)
  2555. z80.contendReadNoMReq(z80.pc, 1)
  2556. z80.contendReadNoMReq(z80.pc, 1)
  2557. z80.contendReadNoMReq(z80.pc, 1)
  2558. z80.contendReadNoMReq(z80.pc, 1)
  2559. z80.pc++
  2560. bytetemp = z80.readByte(REGISTER + signExtend(offset))
  2561. SBC(bytetemp)
  2562.  
  2563. break
  2564. case 0xa4: /* AND A,REGISTERH */
  2565. AND(REGISTERH)
  2566. break
  2567. case 0xa5: /* AND A,REGISTERL */
  2568. AND(REGISTERL)
  2569. break
  2570. case 0xa6: /* AND A,(REGISTER+dd) */
  2571.  
  2572. var offset, bytetemp byte
  2573. offset = z80.readByte(z80.pc)
  2574. z80.contendReadNoMReq(z80.pc, 1)
  2575. z80.contendReadNoMReq(z80.pc, 1)
  2576. z80.contendReadNoMReq(z80.pc, 1)
  2577. z80.contendReadNoMReq(z80.pc, 1)
  2578. z80.contendReadNoMReq(z80.pc, 1)
  2579. z80.pc++
  2580. bytetemp = z80.readByte(REGISTER + signExtend(offset))
  2581. AND(bytetemp)
  2582.  
  2583. break
  2584. case 0xac: /* XOR A,REGISTERH */
  2585. XOR(REGISTERH)
  2586. break
  2587. case 0xad: /* XOR A,REGISTERL */
  2588. XOR(REGISTERL)
  2589. break
  2590. case 0xae: /* XOR A,(REGISTER+dd) */
  2591.  
  2592. var offset, bytetemp byte
  2593. offset = z80.readByte(z80.pc)
  2594. z80.contendReadNoMReq(z80.pc, 1)
  2595. z80.contendReadNoMReq(z80.pc, 1)
  2596. z80.contendReadNoMReq(z80.pc, 1)
  2597. z80.contendReadNoMReq(z80.pc, 1)
  2598. z80.contendReadNoMReq(z80.pc, 1)
  2599. z80.pc++
  2600. bytetemp = z80.readByte(REGISTER + signExtend(offset))
  2601. XOR(bytetemp)
  2602.  
  2603. break
  2604. case 0xb4: /* OR A,REGISTERH */
  2605. OR(REGISTERH)
  2606. break
  2607. case 0xb5: /* OR A,REGISTERL */
  2608. OR(REGISTERL)
  2609. break
  2610. case 0xb6: /* OR A,(REGISTER+dd) */
  2611.  
  2612. var offset, bytetemp byte
  2613. offset = z80.readByte(z80.pc)
  2614. z80.contendReadNoMReq(z80.pc, 1)
  2615. z80.contendReadNoMReq(z80.pc, 1)
  2616. z80.contendReadNoMReq(z80.pc, 1)
  2617. z80.contendReadNoMReq(z80.pc, 1)
  2618. z80.contendReadNoMReq(z80.pc, 1)
  2619. z80.pc++
  2620. bytetemp = z80.readByte(REGISTER + signExtend(offset))
  2621. OR(bytetemp)
  2622.  
  2623. break
  2624. case 0xbc: /* CP A,REGISTERH */
  2625. CP(REGISTERH)
  2626. break
  2627. case 0xbd: /* CP A,REGISTERL */
  2628. CP(REGISTERL)
  2629. break
  2630. case 0xbe: /* CP A,(REGISTER+dd) */
  2631.  
  2632. var offset, bytetemp byte
  2633. offset = z80.readByte(z80.pc)
  2634. z80.contendReadNoMReq(z80.pc, 1)
  2635. z80.contendReadNoMReq(z80.pc, 1)
  2636. z80.contendReadNoMReq(z80.pc, 1)
  2637. z80.contendReadNoMReq(z80.pc, 1)
  2638. z80.contendReadNoMReq(z80.pc, 1)
  2639. z80.pc++
  2640. bytetemp = z80.readByte(REGISTER + signExtend(offset))
  2641. CP(bytetemp)
  2642.  
  2643. break
  2644. case 0xcb: /* shift DDFDCB */
  2645.  
  2646. var tempaddr uint16
  2647. var opcode3 byte
  2648. z80.contendRead(z80.pc, 3)
  2649. tempaddr = REGISTER + signExtend(z80.readByteInternal(z80.pc))
  2650. z80.pc++
  2651. z80.contendRead(z80.pc, 3)
  2652. opcode3 = z80.readByteInternal(z80.pc)
  2653. z80.contendReadNoMReq(z80.pc, 1)
  2654. z80.contendReadNoMReq(z80.pc, 1)
  2655. z80.pc++
  2656.  
  2657. switch opcode3 {
  2658. /* z80_ddfdcb.c Z80 {DD,FD}CBxx opcodes
  2659. Copyright (c) 1999-2003 Philip Kendall
  2660.  
  2661. This program is free software; you can redistribute it and/or modify
  2662. it under the terms of the GNU General Public License as published by
  2663. the Free Software Foundation; either version 2 of the License, or
  2664. (at your option) any later version.
  2665.  
  2666. This program is distributed in the hope that it will be useful,
  2667. but WITHOUT ANY WARRANTY; without even the implied warranty of
  2668. MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
  2669. GNU General Public License for more details.
  2670.  
  2671. You should have received a copy of the GNU General Public License along
  2672. with this program; if not, write to the Free Software Foundation, Inc.,
  2673. 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
  2674.  
  2675. Author contact information:
  2676.  
  2677. E-mail: philip-fuse@shadowmagic.org.uk
  2678.  
  2679. */
  2680.  
  2681. /* NB: this file is autogenerated by './z80.pl' from 'opcodes_ddfdcb.dat',
  2682. and included in 'z80_ops.c' */
  2683.  
  2684. case 0x00: /* LD B,RLC (REGISTER+dd) */
  2685. B = z80.readByte(tempaddr)
  2686. z80.contendReadNoMReq(tempaddr, 1)
  2687. RLC(B)
  2688. z80.writeByte(tempaddr, B)
  2689. break
  2690. case 0x01: /* LD C,RLC (REGISTER+dd) */
  2691. C = z80.readByte(tempaddr)
  2692. z80.contendReadNoMReq(tempaddr, 1)
  2693. RLC(C)
  2694. z80.writeByte(tempaddr, C)
  2695. break
  2696. case 0x02: /* LD D,RLC (REGISTER+dd) */
  2697. D = z80.readByte(tempaddr)
  2698. z80.contendReadNoMReq(tempaddr, 1)
  2699. RLC(D)
  2700. z80.writeByte(tempaddr, D)
  2701. break
  2702. case 0x03: /* LD E,RLC (REGISTER+dd) */
  2703. E = z80.readByte(tempaddr)
  2704. z80.contendReadNoMReq(tempaddr, 1)
  2705. RLC(E)
  2706. z80.writeByte(tempaddr, E)
  2707. break
  2708. case 0x04: /* LD H,RLC (REGISTER+dd) */
  2709. H = z80.readByte(tempaddr)
  2710. z80.contendReadNoMReq(tempaddr, 1)
  2711. RLC(H)
  2712. z80.writeByte(tempaddr, H)
  2713. break
  2714. case 0x05: /* LD L,RLC (REGISTER+dd) */
  2715. L = z80.readByte(tempaddr)
  2716. z80.contendReadNoMReq(tempaddr, 1)
  2717. RLC(L)
  2718. z80.writeByte(tempaddr, L)
  2719. break
  2720. case 0x06: /* RLC (REGISTER+dd) */
  2721. var bytetemp byte = z80.readByte(tempaddr)
  2722. z80.contendReadNoMReq(tempaddr, 1)
  2723. RLC(bytetemp)
  2724. z80.writeByte(tempaddr, bytetemp)
  2725. break
  2726. case 0x07: /* LD A,RLC (REGISTER+dd) */
  2727. A = z80.readByte(tempaddr)
  2728. z80.contendReadNoMReq(tempaddr, 1)
  2729. RLC(A)
  2730. z80.writeByte(tempaddr, A)
  2731. break
  2732. case 0x08: /* LD B,RRC (REGISTER+dd) */
  2733. B = z80.readByte(tempaddr)
  2734. z80.contendReadNoMReq(tempaddr, 1)
  2735. RRC(B)
  2736. z80.writeByte(tempaddr, B)
  2737. break
  2738. case 0x09: /* LD C,RRC (REGISTER+dd) */
  2739. C = z80.readByte(tempaddr)
  2740. z80.contendReadNoMReq(tempaddr, 1)
  2741. RRC(C)
  2742. z80.writeByte(tempaddr, C)
  2743. break
  2744. case 0x0a: /* LD D,RRC (REGISTER+dd) */
  2745. D = z80.readByte(tempaddr)
  2746. z80.contendReadNoMReq(tempaddr, 1)
  2747. RRC(D)
  2748. z80.writeByte(tempaddr, D)
  2749. break
  2750. case 0x0b: /* LD E,RRC (REGISTER+dd) */
  2751. E = z80.readByte(tempaddr)
  2752. z80.contendReadNoMReq(tempaddr, 1)
  2753. RRC(E)
  2754. z80.writeByte(tempaddr, E)
  2755. break
  2756. case 0x0c: /* LD H,RRC (REGISTER+dd) */
  2757. H = z80.readByte(tempaddr)
  2758. z80.contendReadNoMReq(tempaddr, 1)
  2759. RRC(H)
  2760. z80.writeByte(tempaddr, H)
  2761. break
  2762. case 0x0d: /* LD L,RRC (REGISTER+dd) */
  2763. L = z80.readByte(tempaddr)
  2764. z80.contendReadNoMReq(tempaddr, 1)
  2765. RRC(L)
  2766. z80.writeByte(tempaddr, L)
  2767. break
  2768. case 0x0e: /* RRC (REGISTER+dd) */
  2769. var bytetemp byte = z80.readByte(tempaddr)
  2770. z80.contendReadNoMReq(tempaddr, 1)
  2771. RRC(bytetemp)
  2772. z80.writeByte(tempaddr, bytetemp)
  2773. break
  2774. case 0x0f: /* LD A,RRC (REGISTER+dd) */
  2775. A = z80.readByte(tempaddr)
  2776. z80.contendReadNoMReq(tempaddr, 1)
  2777. RRC(A)
  2778. z80.writeByte(tempaddr, A)
  2779. break
  2780. case 0x10: /* LD B,RL (REGISTER+dd) */
  2781. B = z80.readByte(tempaddr)
  2782. z80.contendReadNoMReq(tempaddr, 1)
  2783. RL(B)
  2784. z80.writeByte(tempaddr, B)
  2785. break
  2786. case 0x11: /* LD C,RL (REGISTER+dd) */
  2787. C = z80.readByte(tempaddr)
  2788. z80.contendReadNoMReq(tempaddr, 1)
  2789. RL(C)
  2790. z80.writeByte(tempaddr, C)
  2791. break
  2792. case 0x12: /* LD D,RL (REGISTER+dd) */
  2793. D = z80.readByte(tempaddr)
  2794. z80.contendReadNoMReq(tempaddr, 1)
  2795. RL(D)
  2796. z80.writeByte(tempaddr, D)
  2797. break
  2798. case 0x13: /* LD E,RL (REGISTER+dd) */
  2799. E = z80.readByte(tempaddr)
  2800. z80.contendReadNoMReq(tempaddr, 1)
  2801. RL(E)
  2802. z80.writeByte(tempaddr, E)
  2803. break
  2804. case 0x14: /* LD H,RL (REGISTER+dd) */
  2805. H = z80.readByte(tempaddr)
  2806. z80.contendReadNoMReq(tempaddr, 1)
  2807. RL(H)
  2808. z80.writeByte(tempaddr, H)
  2809. break
  2810. case 0x15: /* LD L,RL (REGISTER+dd) */
  2811. L = z80.readByte(tempaddr)
  2812. z80.contendReadNoMReq(tempaddr, 1)
  2813. RL(L)
  2814. z80.writeByte(tempaddr, L)
  2815. break
  2816. case 0x16: /* RL (REGISTER+dd) */
  2817. var bytetemp byte = z80.readByte(tempaddr)
  2818. z80.contendReadNoMReq(tempaddr, 1)
  2819. RL(bytetemp)
  2820. z80.writeByte(tempaddr, bytetemp)
  2821. break
  2822. case 0x17: /* LD A,RL (REGISTER+dd) */
  2823. A = z80.readByte(tempaddr)
  2824. z80.contendReadNoMReq(tempaddr, 1)
  2825. RL(A)
  2826. z80.writeByte(tempaddr, A)
  2827. break
  2828. case 0x18: /* LD B,RR (REGISTER+dd) */
  2829. B = z80.readByte(tempaddr)
  2830. z80.contendReadNoMReq(tempaddr, 1)
  2831. RR(B)
  2832. z80.writeByte(tempaddr, B)
  2833. break
  2834. case 0x19: /* LD C,RR (REGISTER+dd) */
  2835. C = z80.readByte(tempaddr)
  2836. z80.contendReadNoMReq(tempaddr, 1)
  2837. RR(C)
  2838. z80.writeByte(tempaddr, C)
  2839. break
  2840. case 0x1a: /* LD D,RR (REGISTER+dd) */
  2841. D = z80.readByte(tempaddr)
  2842. z80.contendReadNoMReq(tempaddr, 1)
  2843. RR(D)
  2844. z80.writeByte(tempaddr, D)
  2845. break
  2846. case 0x1b: /* LD E,RR (REGISTER+dd) */
  2847. E = z80.readByte(tempaddr)
  2848. z80.contendReadNoMReq(tempaddr, 1)
  2849. RR(E)
  2850. z80.writeByte(tempaddr, E)
  2851. break
  2852. case 0x1c: /* LD H,RR (REGISTER+dd) */
  2853. H = z80.readByte(tempaddr)
  2854. z80.contendReadNoMReq(tempaddr, 1)
  2855. RR(H)
  2856. z80.writeByte(tempaddr, H)
  2857. break
  2858. case 0x1d: /* LD L,RR (REGISTER+dd) */
  2859. L = z80.readByte(tempaddr)
  2860. z80.contendReadNoMReq(tempaddr, 1)
  2861. RR(L)
  2862. z80.writeByte(tempaddr, L)
  2863. break
  2864. case 0x1e: /* RR (REGISTER+dd) */
  2865. var bytetemp byte = z80.readByte(tempaddr)
  2866. z80.contendReadNoMReq(tempaddr, 1)
  2867. RR(bytetemp)
  2868. z80.writeByte(tempaddr, bytetemp)
  2869. break
  2870. case 0x1f: /* LD A,RR (REGISTER+dd) */
  2871. A = z80.readByte(tempaddr)
  2872. z80.contendReadNoMReq(tempaddr, 1)
  2873. RR(A)
  2874. z80.writeByte(tempaddr, A)
  2875. break
  2876. case 0x20: /* LD B,SLA (REGISTER+dd) */
  2877. B = z80.readByte(tempaddr)
  2878. z80.contendReadNoMReq(tempaddr, 1)
  2879. SLA(B)
  2880. z80.writeByte(tempaddr, B)
  2881. break
  2882. case 0x21: /* LD C,SLA (REGISTER+dd) */
  2883. C = z80.readByte(tempaddr)
  2884. z80.contendReadNoMReq(tempaddr, 1)
  2885. SLA(C)
  2886. z80.writeByte(tempaddr, C)
  2887. break
  2888. case 0x22: /* LD D,SLA (REGISTER+dd) */
  2889. D = z80.readByte(tempaddr)
  2890. z80.contendReadNoMReq(tempaddr, 1)
  2891. SLA(D)
  2892. z80.writeByte(tempaddr, D)
  2893. break
  2894. case 0x23: /* LD E,SLA (REGISTER+dd) */
  2895. E = z80.readByte(tempaddr)
  2896. z80.contendReadNoMReq(tempaddr, 1)
  2897. SLA(E)
  2898. z80.writeByte(tempaddr, E)
  2899. break
  2900. case 0x24: /* LD H,SLA (REGISTER+dd) */
  2901. H = z80.readByte(tempaddr)
  2902. z80.contendReadNoMReq(tempaddr, 1)
  2903. SLA(H)
  2904. z80.writeByte(tempaddr, H)
  2905. break
  2906. case 0x25: /* LD L,SLA (REGISTER+dd) */
  2907. L = z80.readByte(tempaddr)
  2908. z80.contendReadNoMReq(tempaddr, 1)
  2909. SLA(L)
  2910. z80.writeByte(tempaddr, L)
  2911. break
  2912. case 0x26: /* SLA (REGISTER+dd) */
  2913. var bytetemp byte = z80.readByte(tempaddr)
  2914. z80.contendReadNoMReq(tempaddr, 1)
  2915. SLA(bytetemp)
  2916. z80.writeByte(tempaddr, bytetemp)
  2917. break
  2918. case 0x27: /* LD A,SLA (REGISTER+dd) */
  2919. A = z80.readByte(tempaddr)
  2920. z80.contendReadNoMReq(tempaddr, 1)
  2921. SLA(A)
  2922. z80.writeByte(tempaddr, A)
  2923. break
  2924. case 0x28: /* LD B,SRA (REGISTER+dd) */
  2925. B = z80.readByte(tempaddr)
  2926. z80.contendReadNoMReq(tempaddr, 1)
  2927. SRA(B)
  2928. z80.writeByte(tempaddr, B)
  2929. break
  2930. case 0x29: /* LD C,SRA (REGISTER+dd) */
  2931. C = z80.readByte(tempaddr)
  2932. z80.contendReadNoMReq(tempaddr, 1)
  2933. SRA(C)
  2934. z80.writeByte(tempaddr, C)
  2935. break
  2936. case 0x2a: /* LD D,SRA (REGISTER+dd) */
  2937. D = z80.readByte(tempaddr)
  2938. z80.contendReadNoMReq(tempaddr, 1)
  2939. SRA(D)
  2940. z80.writeByte(tempaddr, D)
  2941. break
  2942. case 0x2b: /* LD E,SRA (REGISTER+dd) */
  2943. E = z80.readByte(tempaddr)
  2944. z80.contendReadNoMReq(tempaddr, 1)
  2945. SRA(E)
  2946. z80.writeByte(tempaddr, E)
  2947. break
  2948. case 0x2c: /* LD H,SRA (REGISTER+dd) */
  2949. H = z80.readByte(tempaddr)
  2950. z80.contendReadNoMReq(tempaddr, 1)
  2951. SRA(H)
  2952. z80.writeByte(tempaddr, H)
  2953. break
  2954. case 0x2d: /* LD L,SRA (REGISTER+dd) */
  2955. L = z80.readByte(tempaddr)
  2956. z80.contendReadNoMReq(tempaddr, 1)
  2957. SRA(L)
  2958. z80.writeByte(tempaddr, L)
  2959. break
  2960. case 0x2e: /* SRA (REGISTER+dd) */
  2961. var bytetemp byte = z80.readByte(tempaddr)
  2962. z80.contendReadNoMReq(tempaddr, 1)
  2963. SRA(bytetemp)
  2964. z80.writeByte(tempaddr, bytetemp)
  2965. break
  2966. case 0x2f: /* LD A,SRA (REGISTER+dd) */
  2967. A = z80.readByte(tempaddr)
  2968. z80.contendReadNoMReq(tempaddr, 1)
  2969. SRA(A)
  2970. z80.writeByte(tempaddr, A)
  2971. break
  2972. case 0x30: /* LD B,SLL (REGISTER+dd) */
  2973. B = z80.readByte(tempaddr)
  2974. z80.contendReadNoMReq(tempaddr, 1)
  2975. SLL(B)
  2976. z80.writeByte(tempaddr, B)
  2977. break
  2978. case 0x31: /* LD C,SLL (REGISTER+dd) */
  2979. C = z80.readByte(tempaddr)
  2980. z80.contendReadNoMReq(tempaddr, 1)
  2981. SLL(C)
  2982. z80.writeByte(tempaddr, C)
  2983. break
  2984. case 0x32: /* LD D,SLL (REGISTER+dd) */
  2985. D = z80.readByte(tempaddr)
  2986. z80.contendReadNoMReq(tempaddr, 1)
  2987. SLL(D)
  2988. z80.writeByte(tempaddr, D)
  2989. break
  2990. case 0x33: /* LD E,SLL (REGISTER+dd) */
  2991. E = z80.readByte(tempaddr)
  2992. z80.contendReadNoMReq(tempaddr, 1)
  2993. SLL(E)
  2994. z80.writeByte(tempaddr, E)
  2995. break
  2996. case 0x34: /* LD H,SLL (REGISTER+dd) */
  2997. H = z80.readByte(tempaddr)
  2998. z80.contendReadNoMReq(tempaddr, 1)
  2999. SLL(H)
  3000. z80.writeByte(tempaddr, H)
  3001. break
  3002. case 0x35: /* LD L,SLL (REGISTER+dd) */
  3003. L = z80.readByte(tempaddr)
  3004. z80.contendReadNoMReq(tempaddr, 1)
  3005. SLL(L)
  3006. z80.writeByte(tempaddr, L)
  3007. break
  3008. case 0x36: /* SLL (REGISTER+dd) */
  3009. var bytetemp byte = z80.readByte(tempaddr)
  3010. z80.contendReadNoMReq(tempaddr, 1)
  3011. SLL(bytetemp)
  3012. z80.writeByte(tempaddr, bytetemp)
  3013. break
  3014. case 0x37: /* LD A,SLL (REGISTER+dd) */
  3015. A = z80.readByte(tempaddr)
  3016. z80.contendReadNoMReq(tempaddr, 1)
  3017. SLL(A)
  3018. z80.writeByte(tempaddr, A)
  3019. break
  3020. case 0x38: /* LD B,SRL (REGISTER+dd) */
  3021. B = z80.readByte(tempaddr)
  3022. z80.contendReadNoMReq(tempaddr, 1)
  3023. SRL(B)
  3024. z80.writeByte(tempaddr, B)
  3025. break
  3026. case 0x39: /* LD C,SRL (REGISTER+dd) */
  3027. C = z80.readByte(tempaddr)
  3028. z80.contendReadNoMReq(tempaddr, 1)
  3029. SRL(C)
  3030. z80.writeByte(tempaddr, C)
  3031. break
  3032. case 0x3a: /* LD D,SRL (REGISTER+dd) */
  3033. D = z80.readByte(tempaddr)
  3034. z80.contendReadNoMReq(tempaddr, 1)
  3035. SRL(D)
  3036. z80.writeByte(tempaddr, D)
  3037. break
  3038. case 0x3b: /* LD E,SRL (REGISTER+dd) */
  3039. E = z80.readByte(tempaddr)
  3040. z80.contendReadNoMReq(tempaddr, 1)
  3041. SRL(E)
  3042. z80.writeByte(tempaddr, E)
  3043. break
  3044. case 0x3c: /* LD H,SRL (REGISTER+dd) */
  3045. H = z80.readByte(tempaddr)
  3046. z80.contendReadNoMReq(tempaddr, 1)
  3047. SRL(H)
  3048. z80.writeByte(tempaddr, H)
  3049. break
  3050. case 0x3d: /* LD L,SRL (REGISTER+dd) */
  3051. L = z80.readByte(tempaddr)
  3052. z80.contendReadNoMReq(tempaddr, 1)
  3053. SRL(L)
  3054. z80.writeByte(tempaddr, L)
  3055. break
  3056. case 0x3e: /* SRL (REGISTER+dd) */
  3057. var bytetemp byte = z80.readByte(tempaddr)
  3058. z80.contendReadNoMReq(tempaddr, 1)
  3059. SRL(bytetemp)
  3060. z80.writeByte(tempaddr, bytetemp)
  3061. break
  3062. case 0x3f: /* LD A,SRL (REGISTER+dd) */
  3063. A = z80.readByte(tempaddr)
  3064. z80.contendReadNoMReq(tempaddr, 1)
  3065. SRL(A)
  3066. z80.writeByte(tempaddr, A)
  3067. break
  3068. case 0x40:
  3069. case 0x41:
  3070. case 0x42:
  3071. case 0x43:
  3072. case 0x44:
  3073. case 0x45:
  3074. case 0x46:
  3075. case 0x47: /* BIT 0,(REGISTER+dd) */
  3076. bytetemp := z80.readByte(tempaddr)
  3077. z80.contendReadNoMReq(tempaddr, 1)
  3078. BIT_I(0, bytetemp, tempaddr)
  3079. break
  3080. case 0x48:
  3081. case 0x49:
  3082. case 0x4a:
  3083. case 0x4b:
  3084. case 0x4c:
  3085. case 0x4d:
  3086. case 0x4e:
  3087. case 0x4f: /* BIT 1,(REGISTER+dd) */
  3088. bytetemp := z80.readByte(tempaddr)
  3089. z80.contendReadNoMReq(tempaddr, 1)
  3090. BIT_I(1, bytetemp, tempaddr)
  3091. break
  3092. case 0x50:
  3093. case 0x51:
  3094. case 0x52:
  3095. case 0x53:
  3096. case 0x54:
  3097. case 0x55:
  3098. case 0x56:
  3099. case 0x57: /* BIT 2,(REGISTER+dd) */
  3100. bytetemp := z80.readByte(tempaddr)
  3101. z80.contendReadNoMReq(tempaddr, 1)
  3102. BIT_I(2, bytetemp, tempaddr)
  3103. break
  3104. case 0x58:
  3105. case 0x59:
  3106. case 0x5a:
  3107. case 0x5b:
  3108. case 0x5c:
  3109. case 0x5d:
  3110. case 0x5e:
  3111. case 0x5f: /* BIT 3,(REGISTER+dd) */
  3112. bytetemp := z80.readByte(tempaddr)
  3113. z80.contendReadNoMReq(tempaddr, 1)
  3114. BIT_I(3, bytetemp, tempaddr)
  3115. break
  3116. case 0x60:
  3117. case 0x61:
  3118. case 0x62:
  3119. case 0x63:
  3120. case 0x64:
  3121. case 0x65:
  3122. case 0x66:
  3123. case 0x67: /* BIT 4,(REGISTER+dd) */
  3124. bytetemp := z80.readByte(tempaddr)
  3125. z80.contendReadNoMReq(tempaddr, 1)
  3126. BIT_I(4, bytetemp, tempaddr)
  3127. break
  3128. case 0x68:
  3129. case 0x69:
  3130. case 0x6a:
  3131. case 0x6b:
  3132. case 0x6c:
  3133. case 0x6d:
  3134. case 0x6e:
  3135. case 0x6f: /* BIT 5,(REGISTER+dd) */
  3136. bytetemp := z80.readByte(tempaddr)
  3137. z80.contendReadNoMReq(tempaddr, 1)
  3138. BIT_I(5, bytetemp, tempaddr)
  3139. break
  3140. case 0x70:
  3141. case 0x71:
  3142. case 0x72:
  3143. case 0x73:
  3144. case 0x74:
  3145. case 0x75:
  3146. case 0x76:
  3147. case 0x77: /* BIT 6,(REGISTER+dd) */
  3148. bytetemp := z80.readByte(tempaddr)
  3149. z80.contendReadNoMReq(tempaddr, 1)
  3150. BIT_I(6, bytetemp, tempaddr)
  3151. break
  3152. case 0x78:
  3153. case 0x79:
  3154. case 0x7a:
  3155. case 0x7b:
  3156. case 0x7c:
  3157. case 0x7d:
  3158. case 0x7e:
  3159. case 0x7f: /* BIT 7,(REGISTER+dd) */
  3160. bytetemp := z80.readByte(tempaddr)
  3161. z80.contendReadNoMReq(tempaddr, 1)
  3162. BIT_I(7, bytetemp, tempaddr)
  3163. break
  3164. case 0x80: /* LD B,RES 0,(REGISTER+dd) */
  3165. B = z80.readByte(tempaddr) & 0xfe
  3166. z80.contendReadNoMReq(tempaddr, 1)
  3167. z80.writeByte(tempaddr, B)
  3168. break
  3169. case 0x81: /* LD C,RES 0,(REGISTER+dd) */
  3170. C = z80.readByte(tempaddr) & 0xfe
  3171. z80.contendReadNoMReq(tempaddr, 1)
  3172. z80.writeByte(tempaddr, C)
  3173. break
  3174. case 0x82: /* LD D,RES 0,(REGISTER+dd) */
  3175. D = z80.readByte(tempaddr) & 0xfe
  3176. z80.contendReadNoMReq(tempaddr, 1)
  3177. z80.writeByte(tempaddr, D)
  3178. break
  3179. case 0x83: /* LD E,RES 0,(REGISTER+dd) */
  3180. E = z80.readByte(tempaddr) & 0xfe
  3181. z80.contendReadNoMReq(tempaddr, 1)
  3182. z80.writeByte(tempaddr, E)
  3183. break
  3184. case 0x84: /* LD H,RES 0,(REGISTER+dd) */
  3185. H = z80.readByte(tempaddr) & 0xfe
  3186. z80.contendReadNoMReq(tempaddr, 1)
  3187. z80.writeByte(tempaddr, H)
  3188. break
  3189. case 0x85: /* LD L,RES 0,(REGISTER+dd) */
  3190. L = z80.readByte(tempaddr) & 0xfe
  3191. z80.contendReadNoMReq(tempaddr, 1)
  3192. z80.writeByte(tempaddr, L)
  3193. break
  3194. case 0x86: /* RES 0,(REGISTER+dd) */
  3195.  
  3196. var bytetemp byte
  3197. bytetemp = z80.readByte(tempaddr)
  3198. z80.contendReadNoMReq(tempaddr, 1)
  3199. z80.writeByte(tempaddr, bytetemp&0xfe)
  3200.  
  3201. break
  3202. case 0x87: /* LD A,RES 0,(REGISTER+dd) */
  3203. A = z80.readByte(tempaddr) & 0xfe
  3204. z80.contendReadNoMReq(tempaddr, 1)
  3205. z80.writeByte(tempaddr, A)
  3206. break
  3207. case 0x88: /* LD B,RES 1,(REGISTER+dd) */
  3208. B = z80.readByte(tempaddr) & 0xfd
  3209. z80.contendReadNoMReq(tempaddr, 1)
  3210. z80.writeByte(tempaddr, B)
  3211. break
  3212. case 0x89: /* LD C,RES 1,(REGISTER+dd) */
  3213. C = z80.readByte(tempaddr) & 0xfd
  3214. z80.contendReadNoMReq(tempaddr, 1)
  3215. z80.writeByte(tempaddr, C)
  3216. break
  3217. case 0x8a: /* LD D,RES 1,(REGISTER+dd) */
  3218. D = z80.readByte(tempaddr) & 0xfd
  3219. z80.contendReadNoMReq(tempaddr, 1)
  3220. z80.writeByte(tempaddr, D)
  3221. break
  3222. case 0x8b: /* LD E,RES 1,(REGISTER+dd) */
  3223. E = z80.readByte(tempaddr) & 0xfd
  3224. z80.contendReadNoMReq(tempaddr, 1)
  3225. z80.writeByte(tempaddr, E)
  3226. break
  3227. case 0x8c: /* LD H,RES 1,(REGISTER+dd) */
  3228. H = z80.readByte(tempaddr) & 0xfd
  3229. z80.contendReadNoMReq(tempaddr, 1)
  3230. z80.writeByte(tempaddr, H)
  3231. break
  3232. case 0x8d: /* LD L,RES 1,(REGISTER+dd) */
  3233. L = z80.readByte(tempaddr) & 0xfd
  3234. z80.contendReadNoMReq(tempaddr, 1)
  3235. z80.writeByte(tempaddr, L)
  3236. break
  3237. case 0x8e: /* RES 1,(REGISTER+dd) */
  3238.  
  3239. var bytetemp byte
  3240. bytetemp = z80.readByte(tempaddr)
  3241. z80.contendReadNoMReq(tempaddr, 1)
  3242. z80.writeByte(tempaddr, bytetemp&0xfd)
  3243.  
  3244. break
  3245. case 0x8f: /* LD A,RES 1,(REGISTER+dd) */
  3246. A = z80.readByte(tempaddr) & 0xfd
  3247. z80.contendReadNoMReq(tempaddr, 1)
  3248. z80.writeByte(tempaddr, A)
  3249. break
  3250. case 0x90: /* LD B,RES 2,(REGISTER+dd) */
  3251. B = z80.readByte(tempaddr) & 0xfb
  3252. z80.contendReadNoMReq(tempaddr, 1)
  3253. z80.writeByte(tempaddr, B)
  3254. break
  3255. case 0x91: /* LD C,RES 2,(REGISTER+dd) */
  3256. C = z80.readByte(tempaddr) & 0xfb
  3257. z80.contendReadNoMReq(tempaddr, 1)
  3258. z80.writeByte(tempaddr, C)
  3259. break
  3260. case 0x92: /* LD D,RES 2,(REGISTER+dd) */
  3261. D = z80.readByte(tempaddr) & 0xfb
  3262. z80.contendReadNoMReq(tempaddr, 1)
  3263. z80.writeByte(tempaddr, D)
  3264. break
  3265. case 0x93: /* LD E,RES 2,(REGISTER+dd) */
  3266. E = z80.readByte(tempaddr) & 0xfb
  3267. z80.contendReadNoMReq(tempaddr, 1)
  3268. z80.writeByte(tempaddr, E)
  3269. break
  3270. case 0x94: /* LD H,RES 2,(REGISTER+dd) */
  3271. H = z80.readByte(tempaddr) & 0xfb
  3272. z80.contendReadNoMReq(tempaddr, 1)
  3273. z80.writeByte(tempaddr, H)
  3274. break
  3275. case 0x95: /* LD L,RES 2,(REGISTER+dd) */
  3276. L = z80.readByte(tempaddr) & 0xfb
  3277. z80.contendReadNoMReq(tempaddr, 1)
  3278. z80.writeByte(tempaddr, L)
  3279. break
  3280. case 0x96: /* RES 2,(REGISTER+dd) */
  3281.  
  3282. var bytetemp byte
  3283. bytetemp = z80.readByte(tempaddr)
  3284. z80.contendReadNoMReq(tempaddr, 1)
  3285. z80.writeByte(tempaddr, bytetemp&0xfb)
  3286.  
  3287. break
  3288. case 0x97: /* LD A,RES 2,(REGISTER+dd) */
  3289. A = z80.readByte(tempaddr) & 0xfb
  3290. z80.contendReadNoMReq(tempaddr, 1)
  3291. z80.writeByte(tempaddr, A)
  3292. break
  3293. case 0x98: /* LD B,RES 3,(REGISTER+dd) */
  3294. B = z80.readByte(tempaddr) & 0xf7
  3295. z80.contendReadNoMReq(tempaddr, 1)
  3296. z80.writeByte(tempaddr, B)
  3297. break
  3298. case 0x99: /* LD C,RES 3,(REGISTER+dd) */
  3299. C = z80.readByte(tempaddr) & 0xf7
  3300. z80.contendReadNoMReq(tempaddr, 1)
  3301. z80.writeByte(tempaddr, C)
  3302. break
  3303. case 0x9a: /* LD D,RES 3,(REGISTER+dd) */
  3304. D = z80.readByte(tempaddr) & 0xf7
  3305. z80.contendReadNoMReq(tempaddr, 1)
  3306. z80.writeByte(tempaddr, D)
  3307. break
  3308. case 0x9b: /* LD E,RES 3,(REGISTER+dd) */
  3309. E = z80.readByte(tempaddr) & 0xf7
  3310. z80.contendReadNoMReq(tempaddr, 1)
  3311. z80.writeByte(tempaddr, E)
  3312. break
  3313. case 0x9c: /* LD H,RES 3,(REGISTER+dd) */
  3314. H = z80.readByte(tempaddr) & 0xf7
  3315. z80.contendReadNoMReq(tempaddr, 1)
  3316. z80.writeByte(tempaddr, H)
  3317. break
  3318. case 0x9d: /* LD L,RES 3,(REGISTER+dd) */
  3319. L = z80.readByte(tempaddr) & 0xf7
  3320. z80.contendReadNoMReq(tempaddr, 1)
  3321. z80.writeByte(tempaddr, L)
  3322. break
  3323. case 0x9e: /* RES 3,(REGISTER+dd) */
  3324.  
  3325. var bytetemp byte
  3326. bytetemp = z80.readByte(tempaddr)
  3327. z80.contendReadNoMReq(tempaddr, 1)
  3328. z80.writeByte(tempaddr, bytetemp&0xf7)
  3329.  
  3330. break
  3331. case 0x9f: /* LD A,RES 3,(REGISTER+dd) */
  3332. A = z80.readByte(tempaddr) & 0xf7
  3333. z80.contendReadNoMReq(tempaddr, 1)
  3334. z80.writeByte(tempaddr, A)
  3335. break
  3336. case 0xa0: /* LD B,RES 4,(REGISTER+dd) */
  3337. B = z80.readByte(tempaddr) & 0xef
  3338. z80.contendReadNoMReq(tempaddr, 1)
  3339. z80.writeByte(tempaddr, B)
  3340. break
  3341. case 0xa1: /* LD C,RES 4,(REGISTER+dd) */
  3342. C = z80.readByte(tempaddr) & 0xef
  3343. z80.contendReadNoMReq(tempaddr, 1)
  3344. z80.writeByte(tempaddr, C)
  3345. break
  3346. case 0xa2: /* LD D,RES 4,(REGISTER+dd) */
  3347. D = z80.readByte(tempaddr) & 0xef
  3348. z80.contendReadNoMReq(tempaddr, 1)
  3349. z80.writeByte(tempaddr, D)
  3350. break
  3351. case 0xa3: /* LD E,RES 4,(REGISTER+dd) */
  3352. E = z80.readByte(tempaddr) & 0xef
  3353. z80.contendReadNoMReq(tempaddr, 1)
  3354. z80.writeByte(tempaddr, E)
  3355. break
  3356. case 0xa4: /* LD H,RES 4,(REGISTER+dd) */
  3357. H = z80.readByte(tempaddr) & 0xef
  3358. z80.contendReadNoMReq(tempaddr, 1)
  3359. z80.writeByte(tempaddr, H)
  3360. break
  3361. case 0xa5: /* LD L,RES 4,(REGISTER+dd) */
  3362. L = z80.readByte(tempaddr) & 0xef
  3363. z80.contendReadNoMReq(tempaddr, 1)
  3364. z80.writeByte(tempaddr, L)
  3365. break
  3366. case 0xa6: /* RES 4,(REGISTER+dd) */
  3367.  
  3368. var bytetemp byte
  3369. bytetemp = z80.readByte(tempaddr)
  3370. z80.contendReadNoMReq(tempaddr, 1)
  3371. z80.writeByte(tempaddr, bytetemp&0xef)
  3372.  
  3373. break
  3374. case 0xa7: /* LD A,RES 4,(REGISTER+dd) */
  3375. A = z80.readByte(tempaddr) & 0xef
  3376. z80.contendReadNoMReq(tempaddr, 1)
  3377. z80.writeByte(tempaddr, A)
  3378. break
  3379. case 0xa8: /* LD B,RES 5,(REGISTER+dd) */
  3380. B = z80.readByte(tempaddr) & 0xdf
  3381. z80.contendReadNoMReq(tempaddr, 1)
  3382. z80.writeByte(tempaddr, B)
  3383. break
  3384. case 0xa9: /* LD C,RES 5,(REGISTER+dd) */
  3385. C = z80.readByte(tempaddr) & 0xdf
  3386. z80.contendReadNoMReq(tempaddr, 1)
  3387. z80.writeByte(tempaddr, C)
  3388. break
  3389. case 0xaa: /* LD D,RES 5,(REGISTER+dd) */
  3390. D = z80.readByte(tempaddr) & 0xdf
  3391. z80.contendReadNoMReq(tempaddr, 1)
  3392. z80.writeByte(tempaddr, D)
  3393. break
  3394. case 0xab: /* LD E,RES 5,(REGISTER+dd) */
  3395. E = z80.readByte(tempaddr) & 0xdf
  3396. z80.contendReadNoMReq(tempaddr, 1)
  3397. z80.writeByte(tempaddr, E)
  3398. break
  3399. case 0xac: /* LD H,RES 5,(REGISTER+dd) */
  3400. H = z80.readByte(tempaddr) & 0xdf
  3401. z80.contendReadNoMReq(tempaddr, 1)
  3402. z80.writeByte(tempaddr, H)
  3403. break
  3404. case 0xad: /* LD L,RES 5,(REGISTER+dd) */
  3405. L = z80.readByte(tempaddr) & 0xdf
  3406. z80.contendReadNoMReq(tempaddr, 1)
  3407. z80.writeByte(tempaddr, L)
  3408. break
  3409. case 0xae: /* RES 5,(REGISTER+dd) */
  3410.  
  3411. var bytetemp byte
  3412. bytetemp = z80.readByte(tempaddr)
  3413. z80.contendReadNoMReq(tempaddr, 1)
  3414. z80.writeByte(tempaddr, bytetemp&0xdf)
  3415.  
  3416. break
  3417. case 0xaf: /* LD A,RES 5,(REGISTER+dd) */
  3418. A = z80.readByte(tempaddr) & 0xdf
  3419. z80.contendReadNoMReq(tempaddr, 1)
  3420. z80.writeByte(tempaddr, A)
  3421. break
  3422. case 0xb0: /* LD B,RES 6,(REGISTER+dd) */
  3423. B = z80.readByte(tempaddr) & 0xbf
  3424. z80.contendReadNoMReq(tempaddr, 1)
  3425. z80.writeByte(tempaddr, B)
  3426. break
  3427. case 0xb1: /* LD C,RES 6,(REGISTER+dd) */
  3428. C = z80.readByte(tempaddr) & 0xbf
  3429. z80.contendReadNoMReq(tempaddr, 1)
  3430. z80.writeByte(tempaddr, C)
  3431. break
  3432. case 0xb2: /* LD D,RES 6,(REGISTER+dd) */
  3433. D = z80.readByte(tempaddr) & 0xbf
  3434. z80.contendReadNoMReq(tempaddr, 1)
  3435. z80.writeByte(tempaddr, D)
  3436. break
  3437. case 0xb3: /* LD E,RES 6,(REGISTER+dd) */
  3438. E = z80.readByte(tempaddr) & 0xbf
  3439. z80.contendReadNoMReq(tempaddr, 1)
  3440. z80.writeByte(tempaddr, E)
  3441. break
  3442. case 0xb4: /* LD H,RES 6,(REGISTER+dd) */
  3443. H = z80.readByte(tempaddr) & 0xbf
  3444. z80.contendReadNoMReq(tempaddr, 1)
  3445. z80.writeByte(tempaddr, H)
  3446. break
  3447. case 0xb5: /* LD L,RES 6,(REGISTER+dd) */
  3448. L = z80.readByte(tempaddr) & 0xbf
  3449. z80.contendReadNoMReq(tempaddr, 1)
  3450. z80.writeByte(tempaddr, L)
  3451. break
  3452. case 0xb6: /* RES 6,(REGISTER+dd) */
  3453.  
  3454. var bytetemp byte
  3455. bytetemp = z80.readByte(tempaddr)
  3456. z80.contendReadNoMReq(tempaddr, 1)
  3457. z80.writeByte(tempaddr, bytetemp&0xbf)
  3458.  
  3459. break
  3460. case 0xb7: /* LD A,RES 6,(REGISTER+dd) */
  3461. A = z80.readByte(tempaddr) & 0xbf
  3462. z80.contendReadNoMReq(tempaddr, 1)
  3463. z80.writeByte(tempaddr, A)
  3464. break
  3465. case 0xb8: /* LD B,RES 7,(REGISTER+dd) */
  3466. B = z80.readByte(tempaddr) & 0x7f
  3467. z80.contendReadNoMReq(tempaddr, 1)
  3468. z80.writeByte(tempaddr, B)
  3469. break
  3470. case 0xb9: /* LD C,RES 7,(REGISTER+dd) */
  3471. C = z80.readByte(tempaddr) & 0x7f
  3472. z80.contendReadNoMReq(tempaddr, 1)
  3473. z80.writeByte(tempaddr, C)
  3474. break
  3475. case 0xba: /* LD D,RES 7,(REGISTER+dd) */
  3476. D = z80.readByte(tempaddr) & 0x7f
  3477. z80.contendReadNoMReq(tempaddr, 1)
  3478. z80.writeByte(tempaddr, D)
  3479. break
  3480. case 0xbb: /* LD E,RES 7,(REGISTER+dd) */
  3481. E = z80.readByte(tempaddr) & 0x7f
  3482. z80.contendReadNoMReq(tempaddr, 1)
  3483. z80.writeByte(tempaddr, E)
  3484. break
  3485. case 0xbc: /* LD H,RES 7,(REGISTER+dd) */
  3486. H = z80.readByte(tempaddr) & 0x7f
  3487. z80.contendReadNoMReq(tempaddr, 1)
  3488. z80.writeByte(tempaddr, H)
  3489. break
  3490. case 0xbd: /* LD L,RES 7,(REGISTER+dd) */
  3491. L = z80.readByte(tempaddr) & 0x7f
  3492. z80.contendReadNoMReq(tempaddr, 1)
  3493. z80.writeByte(tempaddr, L)
  3494. break
  3495. case 0xbe: /* RES 7,(REGISTER+dd) */
  3496.  
  3497. var bytetemp byte
  3498. bytetemp = z80.readByte(tempaddr)
  3499. z80.contendReadNoMReq(tempaddr, 1)
  3500. z80.writeByte(tempaddr, bytetemp&0x7f)
  3501.  
  3502. break
  3503. case 0xbf: /* LD A,RES 7,(REGISTER+dd) */
  3504. A = z80.readByte(tempaddr) & 0x7f
  3505. z80.contendReadNoMReq(tempaddr, 1)
  3506. z80.writeByte(tempaddr, A)
  3507. break
  3508. case 0xc0: /* LD B,SET 0,(REGISTER+dd) */
  3509. B = z80.readByte(tempaddr) | 0x01
  3510. z80.contendReadNoMReq(tempaddr, 1)
  3511. z80.writeByte(tempaddr, B)
  3512. break
  3513. case 0xc1: /* LD C,SET 0,(REGISTER+dd) */
  3514. C = z80.readByte(tempaddr) | 0x01
  3515. z80.contendReadNoMReq(tempaddr, 1)
  3516. z80.writeByte(tempaddr, C)
  3517. break
  3518. case 0xc2: /* LD D,SET 0,(REGISTER+dd) */
  3519. D = z80.readByte(tempaddr) | 0x01
  3520. z80.contendReadNoMReq(tempaddr, 1)
  3521. z80.writeByte(tempaddr, D)
  3522. break
  3523. case 0xc3: /* LD E,SET 0,(REGISTER+dd) */
  3524. E = z80.readByte(tempaddr) | 0x01
  3525. z80.contendReadNoMReq(tempaddr, 1)
  3526. z80.writeByte(tempaddr, E)
  3527. break
  3528. case 0xc4: /* LD H,SET 0,(REGISTER+dd) */
  3529. H = z80.readByte(tempaddr) | 0x01
  3530. z80.contendReadNoMReq(tempaddr, 1)
  3531. z80.writeByte(tempaddr, H)
  3532. break
  3533. case 0xc5: /* LD L,SET 0,(REGISTER+dd) */
  3534. L = z80.readByte(tempaddr) | 0x01
  3535. z80.contendReadNoMReq(tempaddr, 1)
  3536. z80.writeByte(tempaddr, L)
  3537. break
  3538. case 0xc6: /* SET 0,(REGISTER+dd) */
  3539.  
  3540. var bytetemp byte
  3541. bytetemp = z80.readByte(tempaddr)
  3542. z80.contendReadNoMReq(tempaddr, 1)
  3543. z80.writeByte(tempaddr, bytetemp|0x01)
  3544.  
  3545. break
  3546. case 0xc7: /* LD A,SET 0,(REGISTER+dd) */
  3547. A = z80.readByte(tempaddr) | 0x01
  3548. z80.contendReadNoMReq(tempaddr, 1)
  3549. z80.writeByte(tempaddr, A)
  3550. break
  3551. case 0xc8: /* LD B,SET 1,(REGISTER+dd) */
  3552. B = z80.readByte(tempaddr) | 0x02
  3553. z80.contendReadNoMReq(tempaddr, 1)
  3554. z80.writeByte(tempaddr, B)
  3555. break
  3556. case 0xc9: /* LD C,SET 1,(REGISTER+dd) */
  3557. C = z80.readByte(tempaddr) | 0x02
  3558. z80.contendReadNoMReq(tempaddr, 1)
  3559. z80.writeByte(tempaddr, C)
  3560. break
  3561. case 0xca: /* LD D,SET 1,(REGISTER+dd) */
  3562. D = z80.readByte(tempaddr) | 0x02
  3563. z80.contendReadNoMReq(tempaddr, 1)
  3564. z80.writeByte(tempaddr, D)
  3565. break
  3566. case 0xcb: /* LD E,SET 1,(REGISTER+dd) */
  3567. E = z80.readByte(tempaddr) | 0x02
  3568. z80.contendReadNoMReq(tempaddr, 1)
  3569. z80.writeByte(tempaddr, E)
  3570. break
  3571. case 0xcc: /* LD H,SET 1,(REGISTER+dd) */
  3572. H = z80.readByte(tempaddr) | 0x02
  3573. z80.contendReadNoMReq(tempaddr, 1)
  3574. z80.writeByte(tempaddr, H)
  3575. break
  3576. case 0xcd: /* LD L,SET 1,(REGISTER+dd) */
  3577. L = z80.readByte(tempaddr) | 0x02
  3578. z80.contendReadNoMReq(tempaddr, 1)
  3579. z80.writeByte(tempaddr, L)
  3580. break
  3581. case 0xce: /* SET 1,(REGISTER+dd) */
  3582.  
  3583. var bytetemp byte
  3584. bytetemp = z80.readByte(tempaddr)
  3585. z80.contendReadNoMReq(tempaddr, 1)
  3586. z80.writeByte(tempaddr, bytetemp|0x02)
  3587.  
  3588. break
  3589. case 0xcf: /* LD A,SET 1,(REGISTER+dd) */
  3590. A = z80.readByte(tempaddr) | 0x02
  3591. z80.contendReadNoMReq(tempaddr, 1)
  3592. z80.writeByte(tempaddr, A)
  3593. break
  3594. case 0xd0: /* LD B,SET 2,(REGISTER+dd) */
  3595. B = z80.readByte(tempaddr) | 0x04
  3596. z80.contendReadNoMReq(tempaddr, 1)
  3597. z80.writeByte(tempaddr, B)
  3598. break
  3599. case 0xd1: /* LD C,SET 2,(REGISTER+dd) */
  3600. C = z80.readByte(tempaddr) | 0x04
  3601. z80.contendReadNoMReq(tempaddr, 1)
  3602. z80.writeByte(tempaddr, C)
  3603. break
  3604. case 0xd2: /* LD D,SET 2,(REGISTER+dd) */
  3605. D = z80.readByte(tempaddr) | 0x04
  3606. z80.contendReadNoMReq(tempaddr, 1)
  3607. z80.writeByte(tempaddr, D)
  3608. break
  3609. case 0xd3: /* LD E,SET 2,(REGISTER+dd) */
  3610. E = z80.readByte(tempaddr) | 0x04
  3611. z80.contendReadNoMReq(tempaddr, 1)
  3612. z80.writeByte(tempaddr, E)
  3613. break
  3614. case 0xd4: /* LD H,SET 2,(REGISTER+dd) */
  3615. H = z80.readByte(tempaddr) | 0x04
  3616. z80.contendReadNoMReq(tempaddr, 1)
  3617. z80.writeByte(tempaddr, H)
  3618. break
  3619. case 0xd5: /* LD L,SET 2,(REGISTER+dd) */
  3620. L = z80.readByte(tempaddr) | 0x04
  3621. z80.contendReadNoMReq(tempaddr, 1)
  3622. z80.writeByte(tempaddr, L)
  3623. break
  3624. case 0xd6: /* SET 2,(REGISTER+dd) */
  3625.  
  3626. var bytetemp byte
  3627. bytetemp = z80.readByte(tempaddr)
  3628. z80.contendReadNoMReq(tempaddr, 1)
  3629. z80.writeByte(tempaddr, bytetemp|0x04)
  3630.  
  3631. break
  3632. case 0xd7: /* LD A,SET 2,(REGISTER+dd) */
  3633. A = z80.readByte(tempaddr) | 0x04
  3634. z80.contendReadNoMReq(tempaddr, 1)
  3635. z80.writeByte(tempaddr, A)
  3636. break
  3637. case 0xd8: /* LD B,SET 3,(REGISTER+dd) */
  3638. B = z80.readByte(tempaddr) | 0x08
  3639. z80.contendReadNoMReq(tempaddr, 1)
  3640. z80.writeByte(tempaddr, B)
  3641. break
  3642. case 0xd9: /* LD C,SET 3,(REGISTER+dd) */
  3643. C = z80.readByte(tempaddr) | 0x08
  3644. z80.contendReadNoMReq(tempaddr, 1)
  3645. z80.writeByte(tempaddr, C)
  3646. break
  3647. case 0xda: /* LD D,SET 3,(REGISTER+dd) */
  3648. D = z80.readByte(tempaddr) | 0x08
  3649. z80.contendReadNoMReq(tempaddr, 1)
  3650. z80.writeByte(tempaddr, D)
  3651. break
  3652. case 0xdb: /* LD E,SET 3,(REGISTER+dd) */
  3653. E = z80.readByte(tempaddr) | 0x08
  3654. z80.contendReadNoMReq(tempaddr, 1)
  3655. z80.writeByte(tempaddr, E)
  3656. break
  3657. case 0xdc: /* LD H,SET 3,(REGISTER+dd) */
  3658. H = z80.readByte(tempaddr) | 0x08
  3659. z80.contendReadNoMReq(tempaddr, 1)
  3660. z80.writeByte(tempaddr, H)
  3661. break
  3662. case 0xdd: /* LD L,SET 3,(REGISTER+dd) */
  3663. L = z80.readByte(tempaddr) | 0x08
  3664. z80.contendReadNoMReq(tempaddr, 1)
  3665. z80.writeByte(tempaddr, L)
  3666. break
  3667. case 0xde: /* SET 3,(REGISTER+dd) */
  3668.  
  3669. var bytetemp byte
  3670. bytetemp = z80.readByte(tempaddr)
  3671. z80.contendReadNoMReq(tempaddr, 1)
  3672. z80.writeByte(tempaddr, bytetemp|0x08)
  3673.  
  3674. break
  3675. case 0xdf: /* LD A,SET 3,(REGISTER+dd) */
  3676. A = z80.readByte(tempaddr) | 0x08
  3677. z80.contendReadNoMReq(tempaddr, 1)
  3678. z80.writeByte(tempaddr, A)
  3679. break
  3680. case 0xe0: /* LD B,SET 4,(REGISTER+dd) */
  3681. B = z80.readByte(tempaddr) | 0x10
  3682. z80.contendReadNoMReq(tempaddr, 1)
  3683. z80.writeByte(tempaddr, B)
  3684. break
  3685. case 0xe1: /* LD C,SET 4,(REGISTER+dd) */
  3686. C = z80.readByte(tempaddr) | 0x10
  3687. z80.contendReadNoMReq(tempaddr, 1)
  3688. z80.writeByte(tempaddr, C)
  3689. break
  3690. case 0xe2: /* LD D,SET 4,(REGISTER+dd) */
  3691. D = z80.readByte(tempaddr) | 0x10
  3692. z80.contendReadNoMReq(tempaddr, 1)
  3693. z80.writeByte(tempaddr, D)
  3694. break
  3695. case 0xe3: /* LD E,SET 4,(REGISTER+dd) */
  3696. E = z80.readByte(tempaddr) | 0x10
  3697. z80.contendReadNoMReq(tempaddr, 1)
  3698. z80.writeByte(tempaddr, E)
  3699. break
  3700. case 0xe4: /* LD H,SET 4,(REGISTER+dd) */
  3701. H = z80.readByte(tempaddr) | 0x10
  3702. z80.contendReadNoMReq(tempaddr, 1)
  3703. z80.writeByte(tempaddr, H)
  3704. break
  3705. case 0xe5: /* LD L,SET 4,(REGISTER+dd) */
  3706. L = z80.readByte(tempaddr) | 0x10
  3707. z80.contendReadNoMReq(tempaddr, 1)
  3708. z80.writeByte(tempaddr, L)
  3709. break
  3710. case 0xe6: /* SET 4,(REGISTER+dd) */
  3711.  
  3712. var bytetemp byte
  3713. bytetemp = z80.readByte(tempaddr)
  3714. z80.contendReadNoMReq(tempaddr, 1)
  3715. z80.writeByte(tempaddr, bytetemp|0x10)
  3716.  
  3717. break
  3718. case 0xe7: /* LD A,SET 4,(REGISTER+dd) */
  3719. A = z80.readByte(tempaddr) | 0x10
  3720. z80.contendReadNoMReq(tempaddr, 1)
  3721. z80.writeByte(tempaddr, A)
  3722. break
  3723. case 0xe8: /* LD B,SET 5,(REGISTER+dd) */
  3724. B = z80.readByte(tempaddr) | 0x20
  3725. z80.contendReadNoMReq(tempaddr, 1)
  3726. z80.writeByte(tempaddr, B)
  3727. break
  3728. case 0xe9: /* LD C,SET 5,(REGISTER+dd) */
  3729. C = z80.readByte(tempaddr) | 0x20
  3730. z80.contendReadNoMReq(tempaddr, 1)
  3731. z80.writeByte(tempaddr, C)
  3732. break
  3733. case 0xea: /* LD D,SET 5,(REGISTER+dd) */
  3734. D = z80.readByte(tempaddr) | 0x20
  3735. z80.contendReadNoMReq(tempaddr, 1)
  3736. z80.writeByte(tempaddr, D)
  3737. break
  3738. case 0xeb: /* LD E,SET 5,(REGISTER+dd) */
  3739. E = z80.readByte(tempaddr) | 0x20
  3740. z80.contendReadNoMReq(tempaddr, 1)
  3741. z80.writeByte(tempaddr, E)
  3742. break
  3743. case 0xec: /* LD H,SET 5,(REGISTER+dd) */
  3744. H = z80.readByte(tempaddr) | 0x20
  3745. z80.contendReadNoMReq(tempaddr, 1)
  3746. z80.writeByte(tempaddr, H)
  3747. break
  3748. case 0xed: /* LD L,SET 5,(REGISTER+dd) */
  3749. L = z80.readByte(tempaddr) | 0x20
  3750. z80.contendReadNoMReq(tempaddr, 1)
  3751. z80.writeByte(tempaddr, L)
  3752. break
  3753. case 0xee: /* SET 5,(REGISTER+dd) */
  3754.  
  3755. var bytetemp byte
  3756. bytetemp = z80.readByte(tempaddr)
  3757. z80.contendReadNoMReq(tempaddr, 1)
  3758. z80.writeByte(tempaddr, bytetemp|0x20)
  3759.  
  3760. break
  3761. case 0xef: /* LD A,SET 5,(REGISTER+dd) */
  3762. A = z80.readByte(tempaddr) | 0x20
  3763. z80.contendReadNoMReq(tempaddr, 1)
  3764. z80.writeByte(tempaddr, A)
  3765. break
  3766. case 0xf0: /* LD B,SET 6,(REGISTER+dd) */
  3767. B = z80.readByte(tempaddr) | 0x40
  3768. z80.contendReadNoMReq(tempaddr, 1)
  3769. z80.writeByte(tempaddr, B)
  3770. break
  3771. case 0xf1: /* LD C,SET 6,(REGISTER+dd) */
  3772. C = z80.readByte(tempaddr) | 0x40
  3773. z80.contendReadNoMReq(tempaddr, 1)
  3774. z80.writeByte(tempaddr, C)
  3775. break
  3776. case 0xf2: /* LD D,SET 6,(REGISTER+dd) */
  3777. D = z80.readByte(tempaddr) | 0x40
  3778. z80.contendReadNoMReq(tempaddr, 1)
  3779. z80.writeByte(tempaddr, D)
  3780. break
  3781. case 0xf3: /* LD E,SET 6,(REGISTER+dd) */
  3782. E = z80.readByte(tempaddr) | 0x40
  3783. z80.contendReadNoMReq(tempaddr, 1)
  3784. z80.writeByte(tempaddr, E)
  3785. break
  3786. case 0xf4: /* LD H,SET 6,(REGISTER+dd) */
  3787. H = z80.readByte(tempaddr) | 0x40
  3788. z80.contendReadNoMReq(tempaddr, 1)
  3789. z80.writeByte(tempaddr, H)
  3790. break
  3791. case 0xf5: /* LD L,SET 6,(REGISTER+dd) */
  3792. L = z80.readByte(tempaddr) | 0x40
  3793. z80.contendReadNoMReq(tempaddr, 1)
  3794. z80.writeByte(tempaddr, L)
  3795. break
  3796. case 0xf6: /* SET 6,(REGISTER+dd) */
  3797.  
  3798. var bytetemp byte
  3799. bytetemp = z80.readByte(tempaddr)
  3800. z80.contendReadNoMReq(tempaddr, 1)
  3801. z80.writeByte(tempaddr, bytetemp|0x40)
  3802.  
  3803. break
  3804. case 0xf7: /* LD A,SET 6,(REGISTER+dd) */
  3805. A = z80.readByte(tempaddr) | 0x40
  3806. z80.contendReadNoMReq(tempaddr, 1)
  3807. z80.writeByte(tempaddr, A)
  3808. break
  3809. case 0xf8: /* LD B,SET 7,(REGISTER+dd) */
  3810. B = z80.readByte(tempaddr) | 0x80
  3811. z80.contendReadNoMReq(tempaddr, 1)
  3812. z80.writeByte(tempaddr, B)
  3813. break
  3814. case 0xf9: /* LD C,SET 7,(REGISTER+dd) */
  3815. C = z80.readByte(tempaddr) | 0x80
  3816. z80.contendReadNoMReq(tempaddr, 1)
  3817. z80.writeByte(tempaddr, C)
  3818. break
  3819. case 0xfa: /* LD D,SET 7,(REGISTER+dd) */
  3820. D = z80.readByte(tempaddr) | 0x80
  3821. z80.contendReadNoMReq(tempaddr, 1)
  3822. z80.writeByte(tempaddr, D)
  3823. break
  3824. case 0xfb: /* LD E,SET 7,(REGISTER+dd) */
  3825. E = z80.readByte(tempaddr) | 0x80
  3826. z80.contendReadNoMReq(tempaddr, 1)
  3827. z80.writeByte(tempaddr, E)
  3828. break
  3829. case 0xfc: /* LD H,SET 7,(REGISTER+dd) */
  3830. H = z80.readByte(tempaddr) | 0x80
  3831. z80.contendReadNoMReq(tempaddr, 1)
  3832. z80.writeByte(tempaddr, H)
  3833. break
  3834. case 0xfd: /* LD L,SET 7,(REGISTER+dd) */
  3835. L = z80.readByte(tempaddr) | 0x80
  3836. z80.contendReadNoMReq(tempaddr, 1)
  3837. z80.writeByte(tempaddr, L)
  3838. break
  3839. case 0xfe: /* SET 7,(REGISTER+dd) */
  3840.  
  3841. var bytetemp byte
  3842. bytetemp = z80.readByte(tempaddr)
  3843. z80.contendReadNoMReq(tempaddr, 1)
  3844. z80.writeByte(tempaddr, bytetemp|0x80)
  3845.  
  3846. break
  3847. case 0xff: /* LD A,SET 7,(REGISTER+dd) */
  3848. A = z80.readByte(tempaddr) | 0x80
  3849. z80.contendReadNoMReq(tempaddr, 1)
  3850. z80.writeByte(tempaddr, A)
  3851. break
  3852.  
  3853. }
  3854.  
  3855. break
  3856. case 0xe1: /* POP REGISTER */
  3857. POP16(REGISTERL, REGISTERH)
  3858. break
  3859. case 0xe3: /* EX (SP),REGISTER */
  3860. var bytetempl, bytetemph byte
  3861. bytetempl = z80.readByte(z80.SP())
  3862. bytetemph = z80.readByte(z80.SP() + 1)
  3863. z80.contendReadNoMReq(z80.SP()+1, 1)
  3864. z80.writeByte(z80.SP()+1, REGISTERH)
  3865. z80.writeByte(z80, SP(), REGISTERL)
  3866. z80.contendWriteNoMReq(z80.SP(), 1)
  3867. z80.contendWriteNoMreq(z80.SP(), 1)
  3868. REGISTERL = bytetempl
  3869. REGISTERH = bytetemph
  3870. break
  3871. case 0xe5: /* PUSH REGISTER */
  3872. z80.contendReadNoMReq(z80.IR(), 1)
  3873. PUSH16(REGISTERL, REGISTERH)
  3874. break
  3875. case 0xe9: /* JP REGISTER */
  3876. z80.pc = REGISTER /* NB: NOT INDIRECT! */
  3877. break
  3878. case 0xf9: /* LD SP,REGISTER */
  3879. z80.contendReadNoMReq(z80.IR(), 1)
  3880. z80.contendReadNoMReq(z80.IR(), 1)
  3881. SP = REGISTER
  3882. break
  3883. default: /* Instruction did not involve H or L, so backtrack
  3884. one instruction and parse again */
  3885. z80.pc--
  3886. z80.r--
  3887. opcode = opcode2
  3888.  
  3889. goto end_opcode
  3890.  
  3891. }
  3892. }
  3893. break
  3894. case 0xde: /* SBC A,nn */
  3895. {
  3896. var bytetemp byte = z80.readByte(PC)
  3897. z80.pc++
  3898. SBC(bytetemp)
  3899. }
  3900. break
  3901. case 0xdf: /* RST 18 */
  3902. z80.contendReadNoMReq(z80.IR(), 1)
  3903. RST(0x18)
  3904. break
  3905. case 0xe0: /* RET PO */
  3906. z80.contendReadNoMReq(z80.IR(), 1)
  3907. if !(z80.f & FLAG_P) {
  3908. RET()
  3909. }
  3910. break
  3911. case 0xe1: /* POP HL */
  3912. POP16(L, H)
  3913. break
  3914. case 0xe2: /* JP PO,nnnn */
  3915. if !(z80.f & FLAG_P) {
  3916. JP()
  3917. } else {
  3918. z80.contendRead(z80.pc, 3)
  3919. z80.contendRead(z80.pc+1, 3)
  3920. z80.pc += 2
  3921. }
  3922. break
  3923. case 0xe3: /* EX (SP),HL */
  3924. var bytetempl, bytetemph byte
  3925. bytetempl = z80.readByte(z80.SP())
  3926. bytetemph = z80.readByte(z80.SP() + 1)
  3927. z80.contendReadNoMReq(z80.SP()+1, 1)
  3928. z80.writeByte(z80.SP()+1, H)
  3929. z80.writeByte(z80, SP(), L)
  3930. z80.contendWriteNoMReq(z80.SP(), 1)
  3931. z80.contendWriteNoMreq(z80.SP(), 1)
  3932. L = bytetempl
  3933. H = bytetemph
  3934. break
  3935. case 0xe4: /* CALL PO,nnnn */
  3936. if !(z80.f & FLAG_P) {
  3937. CALL()
  3938. } else {
  3939. z80.contendRead(z80.pc, 3)
  3940. z80.contendRead(z80.pc+1, 3)
  3941. z80.pc += 2
  3942. }
  3943. break
  3944. case 0xe5: /* PUSH HL */
  3945. z80.contendReadNoMReq(z80.IR(), 1)
  3946. PUSH16(L, H)
  3947. break
  3948. case 0xe6: /* AND nn */
  3949. {
  3950. var bytetemp byte = z80.readByte(PC)
  3951. z80.pc++
  3952. AND(bytetemp)
  3953. }
  3954. break
  3955. case 0xe7: /* RST 20 */
  3956. z80.contendReadNoMReq(z80.IR(), 1)
  3957. RST(0x20)
  3958. break
  3959. case 0xe8: /* RET PE */
  3960. z80.contendReadNoMReq(z80.IR(), 1)
  3961. if z80.f & FLAG_P {
  3962. RET()
  3963. }
  3964. break
  3965. case 0xe9: /* JP HL */
  3966. z80.pc = HL /* NB: NOT INDIRECT! */
  3967. break
  3968. case 0xea: /* JP PE,nnnn */
  3969. if z80.f & FLAG_P {
  3970. JP()
  3971. } else {
  3972. z80.contendRead(z80.pc, 3)
  3973. z80.contendRead(z80.pc+1, 3)
  3974. z80.pc += 2
  3975. }
  3976. break
  3977. case 0xeb: /* EX DE,HL */
  3978. var wordtemp uint16 = z80.DE()
  3979. z80.setDE(z80.HL())
  3980. z80.setHL(wordtemp)
  3981. break
  3982. case 0xec: /* CALL PE,nnnn */
  3983. if z80.f & FLAG_P {
  3984. CALL()
  3985. } else {
  3986. z80.contendRead(z80.pc, 3)
  3987. z80.contendRead(z80.pc+1, 3)
  3988. z80.pc += 2
  3989. }
  3990. break
  3991. case 0xed: /* shift ED */
  3992. {
  3993. var opcode2 byte
  3994. z80.contendRead(z80.pc, 4)
  3995. opcode2 = z80.readByteInternal(z80.pc)
  3996. z80.pc++
  3997. z80.r++
  3998.  
  3999. switch opcode2 {
  4000. /* z80_ed.c: Z80 CBxx opcodes
  4001. Copyright (c) 1999-2003 Philip Kendall
  4002.  
  4003. This program is free software; you can redistribute it and/or modify
  4004. it under the terms of the GNU General Public License as published by
  4005. the Free Software Foundation; either version 2 of the License, or
  4006. (at your option) any later version.
  4007.  
  4008. This program is distributed in the hope that it will be useful,
  4009. but WITHOUT ANY WARRANTY; without even the implied warranty of
  4010. MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
  4011. GNU General Public License for more details.
  4012.  
  4013. You should have received a copy of the GNU General Public License along
  4014. with this program; if not, write to the Free Software Foundation, Inc.,
  4015. 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
  4016.  
  4017. Author contact information:
  4018.  
  4019. E-mail: philip-fuse@shadowmagic.org.uk
  4020.  
  4021. */
  4022.  
  4023. /* NB: this file is autogenerated by './z80.pl' from 'opcodes_ed.dat',
  4024. and included in 'z80_ops.c' */
  4025.  
  4026. case 0x40: /* IN B,(C) */
  4027. Z80_IN(B, BC)
  4028. break
  4029. case 0x41: /* OUT (C),B */
  4030. writeport(BC, B)
  4031. break
  4032. case 0x42: /* SBC HL,BC */
  4033. z80.contendReadNoMReq(z80.IR(), 1)
  4034. z80.contendReadNoMReq(z80.IR(), 1)
  4035. z80.contendReadNoMReq(z80.IR(), 1)
  4036. z80.contendReadNoMReq(z80.IR(), 1)
  4037. z80.contendReadNoMReq(z80.IR(), 1)
  4038. z80.contendReadNoMReq(z80.IR(), 1)
  4039. z80.contendReadNoMReq(z80.IR(), 1)
  4040. SBC16(BC)
  4041. break
  4042. case 0x43: /* LD (nnnn),BC */
  4043. LD16_NNRR(C, B)
  4044. break
  4045. case 0x44:
  4046. case 0x4c:
  4047. case 0x54:
  4048. case 0x5c:
  4049. case 0x64:
  4050. case 0x6c:
  4051. case 0x74:
  4052. case 0x7c: /* NEG */
  4053. bytetemp := z80.a
  4054. z80.a = 0
  4055. SUB(bytetemp)
  4056. break
  4057. case 0x45:
  4058. case 0x4d:
  4059. case 0x55:
  4060. case 0x5d:
  4061. case 0x65:
  4062. case 0x6d:
  4063. case 0x75:
  4064. case 0x7d: /* RETN */
  4065. z80.iff1, z80.iff2 = 0, 0
  4066. RET()
  4067. break
  4068. case 0x46:
  4069. case 0x4e:
  4070. case 0x66:
  4071. case 0x6e: /* IM 0 */
  4072. IM = 0
  4073. break
  4074. case 0x47: /* LD I,A */
  4075. z80.contendReadNoMReq(z80.IR(), 1)
  4076. I = A
  4077. break
  4078. case 0x48: /* IN C,(C) */
  4079. Z80_IN(C, BC)
  4080. break
  4081. case 0x49: /* OUT (C),C */
  4082. writeport(BC, C)
  4083. break
  4084. case 0x4a: /* ADC HL,BC */
  4085. z80.contendReadNoMReq(z80.IR(), 1)
  4086. z80.contendReadNoMReq(z80.IR(), 1)
  4087. z80.contendReadNoMReq(z80.IR(), 1)
  4088. z80.contendReadNoMReq(z80.IR(), 1)
  4089. z80.contendReadNoMReq(z80.IR(), 1)
  4090. z80.contendReadNoMReq(z80.IR(), 1)
  4091. z80.contendReadNoMReq(z80.IR(), 1)
  4092. ADC16(BC)
  4093. break
  4094. case 0x4b: /* LD BC,(nnnn) */
  4095. LD16_RRNN(C, B)
  4096. break
  4097. case 0x4f: /* LD R,A */
  4098. z80.contendReadNoMReq(z80.IR(), 1)
  4099. /* Keep the RZX instruction counter right */
  4100. rzx_instructions_offset += (R - z80.a)
  4101. z80.r, z80.r7 = z80.a, z80.a
  4102. break
  4103. case 0x50: /* IN D,(C) */
  4104. Z80_IN(D, BC)
  4105. break
  4106. case 0x51: /* OUT (C),D */
  4107. writeport(BC, D)
  4108. break
  4109. case 0x52: /* SBC HL,DE */
  4110. z80.contendReadNoMReq(z80.IR(), 1)
  4111. z80.contendReadNoMReq(z80.IR(), 1)
  4112. z80.contendReadNoMReq(z80.IR(), 1)
  4113. z80.contendReadNoMReq(z80.IR(), 1)
  4114. z80.contendReadNoMReq(z80.IR(), 1)
  4115. z80.contendReadNoMReq(z80.IR(), 1)
  4116. z80.contendReadNoMReq(z80.IR(), 1)
  4117. SBC16(DE)
  4118. break
  4119. case 0x53: /* LD (nnnn),DE */
  4120. LD16_NNRR(E, D)
  4121. break
  4122. case 0x56:
  4123. case 0x76: /* IM 1 */
  4124. IM = 1
  4125. break
  4126. case 0x57: /* LD A,I */
  4127. z80.contendReadNoMReq(z80.IR(), 1)
  4128. A = I
  4129. z80.f = (z80.f & FLAG_C) | z80.sz53Table[z80.a] | ternOpB(IFF2 == 1, FLAG_V, 0)
  4130. break
  4131. case 0x58: /* IN E,(C) */
  4132. Z80_IN(E, BC)
  4133. break
  4134. case 0x59: /* OUT (C),E */
  4135. writeport(BC, E)
  4136. break
  4137. case 0x5a: /* ADC HL,DE */
  4138. z80.contendReadNoMReq(z80.IR(), 1)
  4139. z80.contendReadNoMReq(z80.IR(), 1)
  4140. z80.contendReadNoMReq(z80.IR(), 1)
  4141. z80.contendReadNoMReq(z80.IR(), 1)
  4142. z80.contendReadNoMReq(z80.IR(), 1)
  4143. z80.contendReadNoMReq(z80.IR(), 1)
  4144. z80.contendReadNoMReq(z80.IR(), 1)
  4145. ADC16(DE)
  4146. break
  4147. case 0x5b: /* LD DE,(nnnn) */
  4148. LD16_RRNN(E, D)
  4149. break
  4150. case 0x5e:
  4151. case 0x7e: /* IM 2 */
  4152. IM = 2
  4153. break
  4154. case 0x5f: /* LD A,R */
  4155. z80.contendReadNoMReq(z80.IR(), 1)
  4156. z80.a = (R & 0x7f) | (R7 & 0x80)
  4157. z80.f = (z80.f & FLAG_C) | z80.sz53Table[z80.a] | ternOpB(IFF2 == 1, FLAG_V, 0)
  4158. break
  4159. case 0x60: /* IN H,(C) */
  4160. Z80_IN(H, BC)
  4161. break
  4162. case 0x61: /* OUT (C),H */
  4163. writeport(BC, H)
  4164. break
  4165. case 0x62: /* SBC HL,HL */
  4166. z80.contendReadNoMReq(z80.IR(), 1)
  4167. z80.contendReadNoMReq(z80.IR(), 1)
  4168. z80.contendReadNoMReq(z80.IR(), 1)
  4169. z80.contendReadNoMReq(z80.IR(), 1)
  4170. z80.contendReadNoMReq(z80.IR(), 1)
  4171. z80.contendReadNoMReq(z80.IR(), 1)
  4172. z80.contendReadNoMReq(z80.IR(), 1)
  4173. SBC16(HL)
  4174. break
  4175. case 0x63: /* LD (nnnn),HL */
  4176. LD16_NNRR(L, H)
  4177. break
  4178. case 0x67: /* RRD */
  4179. var bytetemp byte = z80.readByte(z80.HL())
  4180. z80.contendReadNoMReq(z80.HL(), 1)
  4181. z80.contendReadNoMReq(z80.HL(), 1)
  4182. z80.contendReadNoMReq(z80.HL(), 1)
  4183. z80.contendReadNoMReq(z80.HL(), 1)
  4184. z80.writeByte(z80.HL(), (z80.a<<4)|(bytetemp>>4))
  4185. z80.a = (z80.a & 0xf0) | (bytetemp & 0x0f)
  4186. z80.f = (z80.f & FLAG_C) | z80.sz53pTable[z80.a]
  4187. break
  4188. case 0x68: /* IN L,(C) */
  4189. Z80_IN(L, BC)
  4190. break
  4191. case 0x69: /* OUT (C),L */
  4192. writeport(BC, L)
  4193. break
  4194. case 0x6a: /* ADC HL,HL */
  4195. z80.contendReadNoMReq(z80.IR(), 1)
  4196. z80.contendReadNoMReq(z80.IR(), 1)
  4197. z80.contendReadNoMReq(z80.IR(), 1)
  4198. z80.contendReadNoMReq(z80.IR(), 1)
  4199. z80.contendReadNoMReq(z80.IR(), 1)
  4200. z80.contendReadNoMReq(z80.IR(), 1)
  4201. z80.contendReadNoMReq(z80.IR(), 1)
  4202. ADC16(HL)
  4203. break
  4204. case 0x6b: /* LD HL,(nnnn) */
  4205. LD16_RRNN(L, H)
  4206. break
  4207. case 0x6f: /* RLD */
  4208. var bytetemp byte = z80.readByte(z80.HL())
  4209. z80.contendReadNoMReq(z80.HL(), 1)
  4210. z80.contendReadNoMReq(z80.HL(), 1)
  4211. z80.contendReadNoMReq(z80.HL(), 1)
  4212. z80.contendReadNoMReq(z80.HL(), 1)
  4213. z80.writeByte(z80.HL(), (bytetemp<<4)|(z80.a&0x0f))
  4214. z80.a = (z80.a & 0xf0) | (bytetemp >> 4)
  4215. z80.f = (z80.f & FLAG_C) | z80.sz53pTable[z80.a]
  4216. break
  4217. case 0x70: /* IN F,(C) */
  4218. var bytetemp byte
  4219. Z80_IN(bytetemp, BC)
  4220. break
  4221. case 0x71: /* OUT (C),0 */
  4222. writeport(BC, 0)
  4223. break
  4224. case 0x72: /* SBC HL,SP */
  4225. z80.contendReadNoMReq(z80.IR(), 1)
  4226. z80.contendReadNoMReq(z80.IR(), 1)
  4227. z80.contendReadNoMReq(z80.IR(), 1)
  4228. z80.contendReadNoMReq(z80.IR(), 1)
  4229. z80.contendReadNoMReq(z80.IR(), 1)
  4230. z80.contendReadNoMReq(z80.IR(), 1)
  4231. z80.contendReadNoMReq(z80.IR(), 1)
  4232. SBC16(SP)
  4233. break
  4234. case 0x73: /* LD (nnnn),SP */
  4235. LD16_NNRR(SPL, SPH)
  4236. break
  4237. case 0x78: /* IN A,(C) */
  4238. Z80_IN(A, BC)
  4239. break
  4240. case 0x79: /* OUT (C),A */
  4241. writeport(BC, A)
  4242. break
  4243. case 0x7a: /* ADC HL,SP */
  4244. z80.contendReadNoMReq(z80.IR(), 1)
  4245. z80.contendReadNoMReq(z80.IR(), 1)
  4246. z80.contendReadNoMReq(z80.IR(), 1)
  4247. z80.contendReadNoMReq(z80.IR(), 1)
  4248. z80.contendReadNoMReq(z80.IR(), 1)
  4249. z80.contendReadNoMReq(z80.IR(), 1)
  4250. z80.contendReadNoMReq(z80.IR(), 1)
  4251. ADC16(SP)
  4252. break
  4253. case 0x7b: /* LD SP,(nnnn) */
  4254. LD16_RRNN(SPL, SPH)
  4255. break
  4256. case 0xa0: /* LDI */
  4257. var bytetemp byte = z80.readByte(z80.HL())
  4258. BC--
  4259. z80.writeByte(DE, bytetemp)
  4260. contend_write_no_mreq(DE, 1)
  4261. contend_write_no_mreq(DE, 1)
  4262. DE++
  4263. HL++
  4264. bytetemp += z80.a
  4265. z80.f = (z80.f & (FLAG_C | FLAG_Z | FLAG_S)) | ternOpB(BC == 1, FLAG_V, 0) |
  4266. (bytetemp & FLAG_3) | ternOpB((bytetemp&0x02) == 1, FLAG_5, 0)
  4267. break
  4268. case 0xa1: /* CPI */
  4269.  
  4270. var value, bytetemp, lookup byte = z80.readByte(z80.HL()), z80.a - value, ((z80.a & 0x08) >> 3) | (((value) & 0x08) >> 2) | ((bytetemp & 0x08) >> 1)
  4271. z80.contendReadNoMReq(z80.HL(), 1)
  4272. z80.contendReadNoMReq(z80.HL(), 1)
  4273. z80.contendReadNoMReq(z80.HL(), 1)
  4274. z80.contendReadNoMReq(z80.HL(), 1)
  4275. z80.contendReadNoMReq(z80.HL(), 1)
  4276. HL++
  4277. BC--
  4278. z80.f = (z80.f & FLAG_C) | ternOpB(BC == 1, FLAG_V|FLAG_N, FLAG_N) | z80.halfCarrySubTable[lookup] | ternOpB(bytetemp == 1, 0, FLAG_Z) | (bytetemp & FLAG_S)
  4279. if z80.f & FLAG_H {
  4280. bytetemp--
  4281. }
  4282. z80.f |= (bytetemp & FLAG_3) | ternOpB((bytetemp&0x02) == 1, FLAG_5, 0)
  4283.  
  4284. break
  4285. case 0xa2: /* INI */
  4286. var initemp, initemp2 byte
  4287.  
  4288. z80.contendReadNoMReq(z80.IR(), 1)
  4289. initemp = readport(BC)
  4290. z80.writeByte(z80.HL(), initemp)
  4291.  
  4292. z80.b--
  4293. HL++
  4294. initemp2 = initemp + C + 1
  4295. z80.f = ternOpB((initemp&0x80) == 1, FLAG_N, 0) | ternOpB(initemp2 < initemp, FLAG_H|FLAG_C, 0) | ternOpB(z80.parityTable[(initemp2&0x07)^B] == 1, FLAG_P, 0) | z80.sz53Table[B]
  4296. break
  4297. case 0xa3: /* OUTI */
  4298. var outitemp, outitemp2 byte
  4299.  
  4300. z80.contendReadNoMReq(z80.IR(), 1)
  4301. outitemp = z80.readByte(z80.HL())
  4302. z80.b-- /* This does happen first, despite what the specs say */
  4303. writeport(BC, outitemp)
  4304.  
  4305. HL++
  4306. outitemp2 = outitemp + L
  4307. z80.f = ternOpB((outitemp&0x80) == 1, FLAG_N, 0) |
  4308. ternOpB(outitemp2 < outitemp, FLAG_H|FLAG_C, 0) |
  4309. ternopB(z80.parityTable[(outitemp2&0x07)^B] == 1, FLAG_P, 0) |
  4310. z80.sz53Table[B]
  4311. break
  4312. case 0xa8: /* LDD */
  4313. var bytetemp byte = z80.readByte(z80.HL())
  4314. BC--
  4315. z80.writeByte(DE, bytetemp)
  4316. contend_write_no_mreq(DE, 1)
  4317. contend_write_no_mreq(DE, 1)
  4318. DE--
  4319. HL--
  4320. bytetemp += z80.a
  4321. z80.f = (z80.f & (FLAG_C | FLAG_Z | FLAG_S)) | ternOpB(BC == 1, FLAG_V, 0) |
  4322. (bytetemp & FLAG_3) | ternOpB((bytetemp&0x02) == 1, FLAG_5, 0)
  4323. break
  4324. case 0xa9: /* CPD */
  4325.  
  4326. var value, bytetemp, lookup byte = z80.readByte(z80.HL()), z80.a - value, ((z80.a & 0x08) >> 3) | (((value) & 0x08) >> 2) | ((bytetemp & 0x08) >> 1)
  4327. z80.contendReadNoMReq(z80.HL(), 1)
  4328. z80.contendReadNoMReq(z80.HL(), 1)
  4329. z80.contendReadNoMReq(z80.HL(), 1)
  4330. z80.contendReadNoMReq(z80.HL(), 1)
  4331. z80.contendReadNoMReq(z80.HL(), 1)
  4332. HL--
  4333. BC--
  4334. z80.f = (z80.f & FLAG_C) | ternOpB(BC == 1, FLAG_V|FLAG_N, FLAG_N) | z80.halfCarrySubTable[lookup] | ternOpB(bytetemp == 1, 0, FLAG_Z) | (bytetemp & FLAG_S)
  4335. if z80.f & FLAG_H {
  4336. bytetemp--
  4337. }
  4338. z80.f |= (bytetemp & FLAG_3) | ternOpB((bytetemp&0x02) == 1, FLAG_5, 0)
  4339.  
  4340. break
  4341. case 0xaa: /* IND */
  4342. var initemp, initemp2 byte
  4343.  
  4344. z80.contendReadNoMReq(z80.IR(), 1)
  4345. initemp = readport(BC)
  4346. z80.writeByte(z80.HL(), initemp)
  4347.  
  4348. z80.b--
  4349. HL--
  4350. initemp2 = initemp + C - 1
  4351. z80.f = ternOpB((initemp&0x80) == 1, FLAG_N, 0) | ternOpB(initemp2 < initemp, FLAG_H|FLAG_C, 0) | ternOpB(z80.parityTable[(initemp2&0x07)^B] == 1, FLAG_P, 0) | z80.sz53Table[B]
  4352. break
  4353. case 0xab: /* OUTD */
  4354. var outitemp, outitemp2 byte
  4355.  
  4356. z80.contendReadNoMReq(z80.IR(), 1)
  4357. outitemp = z80.readByte(z80.HL())
  4358. z80.b-- /* This does happen first, despite what the specs say */
  4359. writeport(BC, outitemp)
  4360.  
  4361. HL--
  4362. outitemp2 = outitemp + L
  4363. z80.f = ternOpB((outitemp&0x80) == 1, FLAG_N, 0) |
  4364. ternOpB(outitemp2 < outitemp, FLAG_H|FLAG_C, 0) |
  4365. ternopB(z80.parityTable[(outitemp2&0x07)^B] == 1, FLAG_P, 0) |
  4366. z80.sz53Table[B]
  4367. break
  4368. case 0xb0: /* LDIR */
  4369. var bytetemp byte = z80.readByte(z80.HL())
  4370. z80.writeByte(DE, bytetemp)
  4371. contend_write_no_mreq(DE, 1)
  4372. contend_write_no_mreq(DE, 1)
  4373. BC--
  4374. bytetemp += z80.a
  4375. z80.f = (z80.f & (FLAG_C | FLAG_Z | FLAG_S)) | ternOp(BC == 1, FLAG_V, 0) | (bytetemp & FLAG_3) | ternOp((bytetemp&0x02 == 1), FLAG_5, 0)
  4376. if BC {
  4377. contend_write_no_mreq(DE, 1)
  4378. contend_write_no_mreq(DE, 1)
  4379. contend_write_no_mreq(DE, 1)
  4380. contend_write_no_mreq(DE, 1)
  4381. contend_write_no_mreq(DE, 1)
  4382. z80.pc -= 2
  4383. }
  4384. HL++
  4385. DE++
  4386. break
  4387. case 0xb1: /* CPIR */
  4388. var value, bytetemp, lookup byte = z80.readByte(z80.HL()), z80.a - value, ((z80.a & 0x08) >> 3) | (((value) & 0x08) >> 2) | ((bytetemp & 0x08) >> 1)
  4389. z80.contendReadNoMReq(z80.HL(), 1)
  4390. z80.contendReadNoMReq(z80.HL(), 1)
  4391. z80.contendReadNoMReq(z80.HL(), 1)
  4392. z80.contendReadNoMReq(z80.HL(), 1)
  4393. z80.contendReadNoMReq(z80.HL(), 1)
  4394. z80.decBC()
  4395. z80.f = (z80.f & FLAG_C) | (ternOpB(BC == 1, (FLAG_V | FLAG_N), FLAG_N)) | z80.halfCarrySubTable[lookup] | (ternOpB(bytetemp == 1, 0, FLAG_Z)) | (bytetemp & FLAG_S)
  4396. if z80.f & FLAG_H {
  4397. bytetemp--
  4398. }
  4399. z80.f |= (bytetemp & FLAG_3) | ternOpB((bytetemp&0x02) == 1, FLAG_5, 0)
  4400. if (z80.f & (FLAG_V | FLAG_Z)) == FLAG_V {
  4401. z80.contendReadNoMReq(z80.HL(), 1)
  4402. z80.contendReadNoMReq(z80.HL(), 1)
  4403. z80.contendReadNoMReq(z80.HL(), 1)
  4404. z80.contendReadNoMReq(z80.HL(), 1)
  4405. z80.contendReadNoMReq(z80.HL(), 1)
  4406. z80.pc -= 2
  4407. }
  4408. HL++
  4409. break
  4410. case 0xb2: /* INIR */
  4411. var initemp, initemp2 byte
  4412.  
  4413. z80.contendReadNoMReq(z80.IR(), 1)
  4414. initemp = readport(BC)
  4415. z80.writeByte(z80.HL(), initemp)
  4416.  
  4417. z80.b--
  4418. initemp2 = initemp + C + 1
  4419. z80.f = ternOpB(initemp&0x80 == 1, FLAG_N, 0) |
  4420. ternOpB(initemp2 < initemp, FLAG_H|FLAG_C, 0) |
  4421. ternOpB(z80.parityTable[(initemp2&0x07)^B] == 1, FLAG_P, 0) |
  4422. z80.sz53Table[B]
  4423.  
  4424. if B {
  4425. z80.contendWriteNoMReq(z80.HL(), 1)
  4426. z80.contendWriteNoMReq(z80.HL(), 1)
  4427. z80.contendWriteNoMReq(z80.HL(), 1)
  4428. z80.contendWriteNoMReq(z80.HL(), 1)
  4429. z80.contendWriteNoMReq(z80.HL(), 1)
  4430. z80.pc -= 2
  4431. }
  4432. HL++
  4433. break
  4434. case 0xb3: /* OTIR */
  4435. var outitemp, outitemp2 byte
  4436.  
  4437. z80.contendReadNoMReq(z80.IR(), 1)
  4438. outitemp = z80.readByte(z80.HL())
  4439. z80.b-- /* This does happen first, despite what the specs say */
  4440. writeport(BC, outitemp)
  4441.  
  4442. HL++
  4443. outitemp2 = outitemp + L
  4444. z80.f = ternOpB((outitemp&0x80) == 1, FLAG_N, 0) |
  4445. ternOpB(outitemp2 < outitemp, FLAG_H|FLAG_C, 0) |
  4446. ternOpB(z80.parityTable[(outitemp2&0x07)^B] == 1, FLAG_P, 0) |
  4447. z80.sz53Table[B]
  4448.  
  4449. if B {
  4450. z80.contendReadNoMReq(BC, 1)
  4451. z80.contendReadNoMReq(BC, 1)
  4452. z80.contendReadNoMReq(BC, 1)
  4453. z80.contendReadNoMReq(BC, 1)
  4454. z80.contendReadNoMReq(BC, 1)
  4455. z80.pc -= 2
  4456. }
  4457. break
  4458. case 0xb8: /* LDDR */
  4459. var bytetemp byte = z80.readByte(z80.HL())
  4460. z80.writeByte(DE, bytetemp)
  4461. contend_write_no_mreq(DE, 1)
  4462. contend_write_no_mreq(DE, 1)
  4463. BC--
  4464. bytetemp += z80.a
  4465. z80.f = (z80.f & (FLAG_C | FLAG_Z | FLAG_S)) | ternOp(BC == 1, FLAG_V, 0) | (bytetemp & FLAG_3) | ternOp((bytetemp&0x02 == 1), FLAG_5, 0)
  4466. if BC {
  4467. contend_write_no_mreq(DE, 1)
  4468. contend_write_no_mreq(DE, 1)
  4469. contend_write_no_mreq(DE, 1)
  4470. contend_write_no_mreq(DE, 1)
  4471. contend_write_no_mreq(DE, 1)
  4472. z80.pc -= 2
  4473. }
  4474. HL--
  4475. DE--
  4476. break
  4477. case 0xb9: /* CPDR */
  4478. var value, bytetemp, lookup byte = z80.readByte(z80.HL()), z80.a - value, ((z80.a & 0x08) >> 3) | (((value) & 0x08) >> 2) | ((bytetemp & 0x08) >> 1)
  4479. z80.contendReadNoMReq(z80.HL(), 1)
  4480. z80.contendReadNoMReq(z80.HL(), 1)
  4481. z80.contendReadNoMReq(z80.HL(), 1)
  4482. z80.contendReadNoMReq(z80.HL(), 1)
  4483. z80.contendReadNoMReq(z80.HL(), 1)
  4484. z80.decBC()
  4485. z80.f = (z80.f & FLAG_C) | (ternOpB(BC == 1, (FLAG_V | FLAG_N), FLAG_N)) | z80.halfCarrySubTable[lookup] | (ternOpB(bytetemp == 1, 0, FLAG_Z)) | (bytetemp & FLAG_S)
  4486. if z80.f & FLAG_H {
  4487. bytetemp--
  4488. }
  4489. z80.f |= (bytetemp & FLAG_3) | ternOpB((bytetemp&0x02) == 1, FLAG_5, 0)
  4490. if (z80.f & (FLAG_V | FLAG_Z)) == FLAG_V {
  4491. z80.contendReadNoMReq(z80.HL(), 1)
  4492. z80.contendReadNoMReq(z80.HL(), 1)
  4493. z80.contendReadNoMReq(z80.HL(), 1)
  4494. z80.contendReadNoMReq(z80.HL(), 1)
  4495. z80.contendReadNoMReq(z80.HL(), 1)
  4496. z80.pc -= 2
  4497. }
  4498. HL--
  4499. break
  4500. case 0xba: /* INDR */
  4501. var initemp, initemp2 byte
  4502.  
  4503. z80.contendReadNoMReq(z80.IR(), 1)
  4504. initemp = readport(BC)
  4505. z80.writeByte(z80.HL(), initemp)
  4506.  
  4507. z80.b--
  4508. initemp2 = initemp + C - 1
  4509. z80.f = ternOpB(initemp&0x80 == 1, FLAG_N, 0) |
  4510. ternOpB(initemp2 < initemp, FLAG_H|FLAG_C, 0) |
  4511. ternOpB(z80.parityTable[(initemp2&0x07)^B] == 1, FLAG_P, 0) |
  4512. z80.sz53Table[B]
  4513.  
  4514. if B {
  4515. z80.contendWriteNoMReq(z80.HL(), 1)
  4516. z80.contendWriteNoMReq(z80.HL(), 1)
  4517. z80.contendWriteNoMReq(z80.HL(), 1)
  4518. z80.contendWriteNoMReq(z80.HL(), 1)
  4519. z80.contendWriteNoMReq(z80.HL(), 1)
  4520. z80.pc -= 2
  4521. }
  4522. HL--
  4523. break
  4524. case 0xbb: /* OTDR */
  4525. var outitemp, outitemp2 byte
  4526.  
  4527. z80.contendReadNoMReq(z80.IR(), 1)
  4528. outitemp = z80.readByte(z80.HL())
  4529. z80.b-- /* This does happen first, despite what the specs say */
  4530. writeport(BC, outitemp)
  4531.  
  4532. HL--
  4533. outitemp2 = outitemp + L
  4534. z80.f = ternOpB((outitemp&0x80) == 1, FLAG_N, 0) |
  4535. ternOpB(outitemp2 < outitemp, FLAG_H|FLAG_C, 0) |
  4536. ternOpB(z80.parityTable[(outitemp2&0x07)^B] == 1, FLAG_P, 0) |
  4537. z80.sz53Table[B]
  4538.  
  4539. if B {
  4540. z80.contendReadNoMReq(BC, 1)
  4541. z80.contendReadNoMReq(BC, 1)
  4542. z80.contendReadNoMReq(BC, 1)
  4543. z80.contendReadNoMReq(BC, 1)
  4544. z80.contendReadNoMReq(BC, 1)
  4545. z80.pc -= 2
  4546. }
  4547. break
  4548. case 0xfb: /* slttrap */
  4549. slt_trap(z80.HL(), A)
  4550. break
  4551. default: /* All other opcodes are NOPD */
  4552. break
  4553.  
  4554. }
  4555. }
  4556. break
  4557. case 0xee: /* XOR A,nn */
  4558. {
  4559. var bytetemp byte = z80.readByte(PC)
  4560. z80.pc++
  4561. XOR(bytetemp)
  4562. }
  4563. break
  4564. case 0xef: /* RST 28 */
  4565. z80.contendReadNoMReq(z80.IR(), 1)
  4566. RST(0x28)
  4567. break
  4568. case 0xf0: /* RET P */
  4569. z80.contendReadNoMReq(z80.IR(), 1)
  4570. if !(z80.f & FLAG_S) {
  4571. RET()
  4572. }
  4573. break
  4574. case 0xf1: /* POP AF */
  4575. POP16(F, A)
  4576. break
  4577. case 0xf2: /* JP P,nnnn */
  4578. if !(z80.f & FLAG_S) {
  4579. JP()
  4580. } else {
  4581. z80.contendRead(z80.pc, 3)
  4582. z80.contendRead(z80.pc+1, 3)
  4583. z80.pc += 2
  4584. }
  4585. break
  4586. case 0xf3: /* DI */
  4587. z80.iff1, z80.iff2 = 0, 0
  4588. break
  4589. case 0xf4: /* CALL P,nnnn */
  4590. if !(z80.f & FLAG_S) {
  4591. CALL()
  4592. } else {
  4593. z80.contendRead(z80.pc, 3)
  4594. z80.contendRead(z80.pc+1, 3)
  4595. z80.pc += 2
  4596. }
  4597. break
  4598. case 0xf5: /* PUSH AF */
  4599. z80.contendReadNoMReq(z80.IR(), 1)
  4600. PUSH16(F, A)
  4601. break
  4602. case 0xf6: /* OR nn */
  4603. {
  4604. var bytetemp byte = z80.readByte(PC)
  4605. z80.pc++
  4606. OR(bytetemp)
  4607. }
  4608. break
  4609. case 0xf7: /* RST 30 */
  4610. z80.contendReadNoMReq(z80.IR(), 1)
  4611. RST(0x30)
  4612. break
  4613. case 0xf8: /* RET M */
  4614. z80.contendReadNoMReq(z80.IR(), 1)
  4615. if z80.f & FLAG_S {
  4616. RET()
  4617. }
  4618. break
  4619. case 0xf9: /* LD SP,HL */
  4620. z80.contendReadNoMReq(z80.IR(), 1)
  4621. z80.contendReadNoMReq(z80.IR(), 1)
  4622. SP = HL
  4623. break
  4624. case 0xfa: /* JP M,nnnn */
  4625. if z80.f & FLAG_S {
  4626. JP()
  4627. } else {
  4628. z80.contendRead(z80.pc, 3)
  4629. z80.contendRead(z80.pc+1, 3)
  4630. z80.pc += 2
  4631. }
  4632. break
  4633. case 0xfb: /* EI */
  4634. /* Interrupts are not accepted immediately after an EI, but are
  4635. accepted after the next instruction */
  4636. z80.iff1, z80.iff2 = 0, 0
  4637. z80.interrupts_enabled_at = tstates
  4638. event_add(tstates+1, z80_interrupt_event)
  4639. break
  4640. case 0xfc: /* CALL M,nnnn */
  4641. if z80.f & FLAG_S {
  4642. CALL()
  4643. } else {
  4644. z80.contendRead(z80.pc, 3)
  4645. z80.contendRead(z80.pc+1, 3)
  4646. z80.pc += 2
  4647. }
  4648. break
  4649. case 0xfd: /* shift FD */
  4650. {
  4651. var opcode2 byte
  4652. z80.contendRead(z80.pc, 4)
  4653. opcode2 = z80.readByteInternal(z80.pc)
  4654. z80.pc++
  4655. z80.r++
  4656.  
  4657. switch opcode2 {
  4658. /* z80_ddfd.c Z80 {DD,FD}xx opcodes
  4659. Copyright (c) 1999-2003 Philip Kendall
  4660.  
  4661. This program is free software; you can redistribute it and/or modify
  4662. it under the terms of the GNU General Public License as published by
  4663. the Free Software Foundation; either version 2 of the License, or
  4664. (at your option) any later version.
  4665.  
  4666. This program is distributed in the hope that it will be useful,
  4667. but WITHOUT ANY WARRANTY; without even the implied warranty of
  4668. MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
  4669. GNU General Public License for more details.
  4670.  
  4671. You should have received a copy of the GNU General Public License along
  4672. with this program; if not, write to the Free Software Foundation, Inc.,
  4673. 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
  4674.  
  4675. Author contact information:
  4676.  
  4677. E-mail: philip-fuse@shadowmagic.org.uk
  4678.  
  4679. */
  4680.  
  4681. /* NB: this file is autogenerated by './z80.pl' from 'opcodes_ddfd.dat',
  4682. and included in 'z80_ops.c' */
  4683.  
  4684. case 0x09: /* ADD REGISTER,BC */
  4685. z80.contendReadNoMReq(z80.IR(), 1)
  4686. z80.contendReadNoMReq(z80.IR(), 1)
  4687. z80.contendReadNoMReq(z80.IR(), 1)
  4688. z80.contendReadNoMReq(z80.IR(), 1)
  4689. z80.contendReadNoMReq(z80.IR(), 1)
  4690. z80.contendReadNoMReq(z80.IR(), 1)
  4691. z80.contendReadNoMReq(z80.IR(), 1)
  4692. ADD16(REGISTER, BC)
  4693. break
  4694. case 0x19: /* ADD REGISTER,DE */
  4695. z80.contendReadNoMReq(z80.IR(), 1)
  4696. z80.contendReadNoMReq(z80.IR(), 1)
  4697. z80.contendReadNoMReq(z80.IR(), 1)
  4698. z80.contendReadNoMReq(z80.IR(), 1)
  4699. z80.contendReadNoMReq(z80.IR(), 1)
  4700. z80.contendReadNoMReq(z80.IR(), 1)
  4701. z80.contendReadNoMReq(z80.IR(), 1)
  4702. ADD16(REGISTER, DE)
  4703. break
  4704. case 0x21: /* LD REGISTER,nnnn */
  4705. REGISTERL = z80.readByte(z80.pc)
  4706. z80.pc++
  4707. REGISTERH = z80.readByte(z80.pc)
  4708. z80.pc++
  4709. break
  4710. case 0x22: /* LD (nnnn),REGISTER */
  4711. LD16_NNRR(REGISTERL, REGISTERH)
  4712. break
  4713. case 0x23: /* INC REGISTER */
  4714. z80.contendReadNoMReq(z80.IR(), 1)
  4715. z80.contendReadNoMReq(z80.IR(), 1)
  4716. z80.incREGISTER()
  4717. break
  4718. case 0x24: /* INC REGISTERH */
  4719. z80.incREGISTERH()
  4720. break
  4721. case 0x25: /* DEC REGISTERH */
  4722. z80.decREGISTERH()
  4723. break
  4724. case 0x26: /* LD REGISTERH,nn */
  4725. REGISTERH = z80.readByte(z80.pc)
  4726. z80.pc++
  4727. break
  4728. case 0x29: /* ADD REGISTER,REGISTER */
  4729. z80.contendReadNoMReq(z80.IR(), 1)
  4730. z80.contendReadNoMReq(z80.IR(), 1)
  4731. z80.contendReadNoMReq(z80.IR(), 1)
  4732. z80.contendReadNoMReq(z80.IR(), 1)
  4733. z80.contendReadNoMReq(z80.IR(), 1)
  4734. z80.contendReadNoMReq(z80.IR(), 1)
  4735. z80.contendReadNoMReq(z80.IR(), 1)
  4736. ADD16(REGISTER, REGISTER)
  4737. break
  4738. case 0x2a: /* LD REGISTER,(nnnn) */
  4739. LD16_RRNN(REGISTERL, REGISTERH)
  4740. break
  4741. case 0x2b: /* DEC REGISTER */
  4742. z80.contendReadNoMReq(z80.IR(), 1)
  4743. z80.contendReadNoMReq(z80.IR(), 1)
  4744. z80.decREGISTER()
  4745. break
  4746. case 0x2c: /* INC REGISTERL */
  4747. z80.incREGISTERL()
  4748. break
  4749. case 0x2d: /* DEC REGISTERL */
  4750. z80.decREGISTERL()
  4751. break
  4752. case 0x2e: /* LD REGISTERL,nn */
  4753. REGISTERL = z80.readByte(z80.pc)
  4754. z80.pc++
  4755. break
  4756. case 0x34: /* INC (REGISTER+dd) */
  4757. var offset, bytetemp byte
  4758. var wordtemp uint16
  4759. offset = z80.readByte(z80.pc)
  4760. z80.contendReadNoMReq(z80.pc, 1)
  4761. z80.contendReadNoMReq(z80.pc, 1)
  4762. z80.contendReadNoMReq(z80.pc, 1)
  4763. z80.contendReadNoMReq(z80.pc, 1)
  4764. z80.contendReadNoMReq(z80.pc, 1)
  4765. z80.pc++
  4766. wordtemp = REGISTER + signExtend(offset)
  4767. bytetemp = z80.readByte(wordtemp)
  4768. z80.contendReadNoMReq(wordtemp, 1)
  4769. INC(bytetemp)
  4770. z80.writeByte(wordtemp, bytetemp)
  4771. break
  4772. case 0x35: /* DEC (REGISTER+dd) */
  4773. var offset, bytetemp byte
  4774. var wordtemp uint16
  4775. offset = z80.readByte(z80.pc)
  4776. z80.contendReadNoMReq(z80.pc, 1)
  4777. z80.contendReadNoMReq(z80.pc, 1)
  4778. z80.contendReadNoMReq(z80.pc, 1)
  4779. z80.contendReadNoMReq(z80.pc, 1)
  4780. z80.contendReadNoMReq(z80.pc, 1)
  4781. z80.pc++
  4782. wordtemp = REGISTER + signExtend(offset)
  4783. bytetemp = z80.readByte(wordtemp)
  4784. z80.contendReadNoMReq(wordtemp, 1)
  4785. DEC(bytetemp)
  4786. z80.writeByte(wordtemp, bytetemp)
  4787. break
  4788. case 0x36: /* LD (REGISTER+dd),nn */
  4789. offset := z80.readByte(z80.pc)
  4790. z80.pc++
  4791. value := z80.readByte(z80.pc)
  4792. z80.contendReadNoMReq(z80.pc, 1)
  4793. z80.contendReadNoMReq(z80.pc, 1)
  4794. z80.pc++
  4795. z80.writeByte(REGISTER+signExtend(offset), value)
  4796. break
  4797. case 0x39: /* ADD REGISTER,SP */
  4798. z80.contendReadNoMReq(z80.IR(), 1)
  4799. z80.contendReadNoMReq(z80.IR(), 1)
  4800. z80.contendReadNoMReq(z80.IR(), 1)
  4801. z80.contendReadNoMReq(z80.IR(), 1)
  4802. z80.contendReadNoMReq(z80.IR(), 1)
  4803. z80.contendReadNoMReq(z80.IR(), 1)
  4804. z80.contendReadNoMReq(z80.IR(), 1)
  4805. ADD16(REGISTER, SP)
  4806. break
  4807. case 0x44: /* LD B,REGISTERH */
  4808. B = REGISTERH
  4809. break
  4810. case 0x45: /* LD B,REGISTERL */
  4811. B = REGISTERL
  4812. break
  4813. case 0x46: /* LD B,(REGISTER+dd) */
  4814. var offset byte
  4815. offset = z80.readByte(z80.pc)
  4816. z80.contendReadNoMReq(z80.pc, 1)
  4817. z80.contendReadNoMReq(z80.pc, 1)
  4818. z80.contendReadNoMReq(z80.pc, 1)
  4819. z80.contendReadNoMReq(z80.pc, 1)
  4820. z80.contendReadNoMReq(z80.pc, 1)
  4821. z80.pc++
  4822. B = z80.readByte(REGISTER + signExtend(offset))
  4823. break
  4824. case 0x4c: /* LD C,REGISTERH */
  4825. C = REGISTERH
  4826. break
  4827. case 0x4d: /* LD C,REGISTERL */
  4828. C = REGISTERL
  4829. break
  4830. case 0x4e: /* LD C,(REGISTER+dd) */
  4831. var offset byte
  4832. offset = z80.readByte(z80.pc)
  4833. z80.contendReadNoMReq(z80.pc, 1)
  4834. z80.contendReadNoMReq(z80.pc, 1)
  4835. z80.contendReadNoMReq(z80.pc, 1)
  4836. z80.contendReadNoMReq(z80.pc, 1)
  4837. z80.contendReadNoMReq(z80.pc, 1)
  4838. z80.pc++
  4839. C = z80.readByte(REGISTER + signExtend(offset))
  4840. break
  4841. case 0x54: /* LD D,REGISTERH */
  4842. D = REGISTERH
  4843. break
  4844. case 0x55: /* LD D,REGISTERL */
  4845. D = REGISTERL
  4846. break
  4847. case 0x56: /* LD D,(REGISTER+dd) */
  4848. var offset byte
  4849. offset = z80.readByte(z80.pc)
  4850. z80.contendReadNoMReq(z80.pc, 1)
  4851. z80.contendReadNoMReq(z80.pc, 1)
  4852. z80.contendReadNoMReq(z80.pc, 1)
  4853. z80.contendReadNoMReq(z80.pc, 1)
  4854. z80.contendReadNoMReq(z80.pc, 1)
  4855. z80.pc++
  4856. D = z80.readByte(REGISTER + signExtend(offset))
  4857. break
  4858. case 0x5c: /* LD E,REGISTERH */
  4859. E = REGISTERH
  4860. break
  4861. case 0x5d: /* LD E,REGISTERL */
  4862. E = REGISTERL
  4863. break
  4864. case 0x5e: /* LD E,(REGISTER+dd) */
  4865. var offset byte
  4866. offset = z80.readByte(z80.pc)
  4867. z80.contendReadNoMReq(z80.pc, 1)
  4868. z80.contendReadNoMReq(z80.pc, 1)
  4869. z80.contendReadNoMReq(z80.pc, 1)
  4870. z80.contendReadNoMReq(z80.pc, 1)
  4871. z80.contendReadNoMReq(z80.pc, 1)
  4872. z80.pc++
  4873. E = z80.readByte(REGISTER + signExtend(offset))
  4874. break
  4875. case 0x60: /* LD REGISTERH,B */
  4876. REGISTERH = B
  4877. break
  4878. case 0x61: /* LD REGISTERH,C */
  4879. REGISTERH = C
  4880. break
  4881. case 0x62: /* LD REGISTERH,D */
  4882. REGISTERH = D
  4883. break
  4884. case 0x63: /* LD REGISTERH,E */
  4885. REGISTERH = E
  4886. break
  4887. case 0x64: /* LD REGISTERH,REGISTERH */
  4888. break
  4889. case 0x65: /* LD REGISTERH,REGISTERL */
  4890. REGISTERH = REGISTERL
  4891. break
  4892. case 0x66: /* LD H,(REGISTER+dd) */
  4893. var offset byte
  4894. offset = z80.readByte(z80.pc)
  4895. z80.contendReadNoMReq(z80.pc, 1)
  4896. z80.contendReadNoMReq(z80.pc, 1)
  4897. z80.contendReadNoMReq(z80.pc, 1)
  4898. z80.contendReadNoMReq(z80.pc, 1)
  4899. z80.contendReadNoMReq(z80.pc, 1)
  4900. z80.pc++
  4901. H = z80.readByte(REGISTER + signExtend(offset))
  4902. break
  4903. case 0x67: /* LD REGISTERH,A */
  4904. REGISTERH = A
  4905. break
  4906. case 0x68: /* LD REGISTERL,B */
  4907. REGISTERL = B
  4908. break
  4909. case 0x69: /* LD REGISTERL,C */
  4910. REGISTERL = C
  4911. break
  4912. case 0x6a: /* LD REGISTERL,D */
  4913. REGISTERL = D
  4914. break
  4915. case 0x6b: /* LD REGISTERL,E */
  4916. REGISTERL = E
  4917. break
  4918. case 0x6c: /* LD REGISTERL,REGISTERH */
  4919. REGISTERL = REGISTERH
  4920. break
  4921. case 0x6d: /* LD REGISTERL,REGISTERL */
  4922. break
  4923. case 0x6e: /* LD L,(REGISTER+dd) */
  4924. var offset byte
  4925. offset = z80.readByte(z80.pc)
  4926. z80.contendReadNoMReq(z80.pc, 1)
  4927. z80.contendReadNoMReq(z80.pc, 1)
  4928. z80.contendReadNoMReq(z80.pc, 1)
  4929. z80.contendReadNoMReq(z80.pc, 1)
  4930. z80.contendReadNoMReq(z80.pc, 1)
  4931. z80.pc++
  4932. L = z80.readByte(REGISTER + signExtend(offset))
  4933. break
  4934. case 0x6f: /* LD REGISTERL,A */
  4935. REGISTERL = A
  4936. break
  4937. case 0x70: /* LD (REGISTER+dd),B */
  4938. offset := z80.readByte(z80.pc)
  4939. z80.contendReadNoMReq(z80.pc, 1)
  4940. z80.contendReadNoMReq(z80.pc, 1)
  4941. z80.contendReadNoMReq(z80.pc, 1)
  4942. z80.contendReadNoMReq(z80.pc, 1)
  4943. z80.contendReadNoMReq(z80.pc, 1)
  4944. z80.pc++
  4945. z80.writeByte(REGISTER+signExtend(offset), B)
  4946. break
  4947. case 0x71: /* LD (REGISTER+dd),C */
  4948. offset := z80.readByte(z80.pc)
  4949. z80.contendReadNoMReq(z80.pc, 1)
  4950. z80.contendReadNoMReq(z80.pc, 1)
  4951. z80.contendReadNoMReq(z80.pc, 1)
  4952. z80.contendReadNoMReq(z80.pc, 1)
  4953. z80.contendReadNoMReq(z80.pc, 1)
  4954. z80.pc++
  4955. z80.writeByte(REGISTER+signExtend(offset), C)
  4956. break
  4957. case 0x72: /* LD (REGISTER+dd),D */
  4958. offset := z80.readByte(z80.pc)
  4959. z80.contendReadNoMReq(z80.pc, 1)
  4960. z80.contendReadNoMReq(z80.pc, 1)
  4961. z80.contendReadNoMReq(z80.pc, 1)
  4962. z80.contendReadNoMReq(z80.pc, 1)
  4963. z80.contendReadNoMReq(z80.pc, 1)
  4964. z80.pc++
  4965. z80.writeByte(REGISTER+signExtend(offset), D)
  4966. break
  4967. case 0x73: /* LD (REGISTER+dd),E */
  4968. offset := z80.readByte(z80.pc)
  4969. z80.contendReadNoMReq(z80.pc, 1)
  4970. z80.contendReadNoMReq(z80.pc, 1)
  4971. z80.contendReadNoMReq(z80.pc, 1)
  4972. z80.contendReadNoMReq(z80.pc, 1)
  4973. z80.contendReadNoMReq(z80.pc, 1)
  4974. z80.pc++
  4975. z80.writeByte(REGISTER+signExtend(offset), E)
  4976. break
  4977. case 0x74: /* LD (REGISTER+dd),H */
  4978. offset := z80.readByte(z80.pc)
  4979. z80.contendReadNoMReq(z80.pc, 1)
  4980. z80.contendReadNoMReq(z80.pc, 1)
  4981. z80.contendReadNoMReq(z80.pc, 1)
  4982. z80.contendReadNoMReq(z80.pc, 1)
  4983. z80.contendReadNoMReq(z80.pc, 1)
  4984. z80.pc++
  4985. z80.writeByte(REGISTER+signExtend(offset), H)
  4986. break
  4987. case 0x75: /* LD (REGISTER+dd),L */
  4988. offset := z80.readByte(z80.pc)
  4989. z80.contendReadNoMReq(z80.pc, 1)
  4990. z80.contendReadNoMReq(z80.pc, 1)
  4991. z80.contendReadNoMReq(z80.pc, 1)
  4992. z80.contendReadNoMReq(z80.pc, 1)
  4993. z80.contendReadNoMReq(z80.pc, 1)
  4994. z80.pc++
  4995. z80.writeByte(REGISTER+signExtend(offset), L)
  4996. break
  4997. case 0x77: /* LD (REGISTER+dd),A */
  4998. offset := z80.readByte(z80.pc)
  4999. z80.contendReadNoMReq(z80.pc, 1)
  5000. z80.contendReadNoMReq(z80.pc, 1)
  5001. z80.contendReadNoMReq(z80.pc, 1)
  5002. z80.contendReadNoMReq(z80.pc, 1)
  5003. z80.contendReadNoMReq(z80.pc, 1)
  5004. z80.pc++
  5005. z80.writeByte(REGISTER+signExtend(offset), A)
  5006. break
  5007. case 0x7c: /* LD A,REGISTERH */
  5008. A = REGISTERH
  5009. break
  5010. case 0x7d: /* LD A,REGISTERL */
  5011. A = REGISTERL
  5012. break
  5013. case 0x7e: /* LD A,(REGISTER+dd) */
  5014. var offset byte
  5015. offset = z80.readByte(z80.pc)
  5016. z80.contendReadNoMReq(z80.pc, 1)
  5017. z80.contendReadNoMReq(z80.pc, 1)
  5018. z80.contendReadNoMReq(z80.pc, 1)
  5019. z80.contendReadNoMReq(z80.pc, 1)
  5020. z80.contendReadNoMReq(z80.pc, 1)
  5021. z80.pc++
  5022. A = z80.readByte(REGISTER + signExtend(offset))
  5023. break
  5024. case 0x84: /* ADD A,REGISTERH */
  5025. ADD(REGISTERH)
  5026. break
  5027. case 0x85: /* ADD A,REGISTERL */
  5028. ADD(REGISTERL)
  5029. break
  5030. case 0x86: /* ADD A,(REGISTER+dd) */
  5031.  
  5032. var offset, bytetemp byte
  5033. offset = z80.readByte(z80.pc)
  5034. z80.contendReadNoMReq(z80.pc, 1)
  5035. z80.contendReadNoMReq(z80.pc, 1)
  5036. z80.contendReadNoMReq(z80.pc, 1)
  5037. z80.contendReadNoMReq(z80.pc, 1)
  5038. z80.contendReadNoMReq(z80.pc, 1)
  5039. z80.pc++
  5040. bytetemp = z80.readByte(REGISTER + signExtend(offset))
  5041. ADD(bytetemp)
  5042.  
  5043. break
  5044. case 0x8c: /* ADC A,REGISTERH */
  5045. ADC(REGISTERH)
  5046. break
  5047. case 0x8d: /* ADC A,REGISTERL */
  5048. ADC(REGISTERL)
  5049. break
  5050. case 0x8e: /* ADC A,(REGISTER+dd) */
  5051.  
  5052. var offset, bytetemp byte
  5053. offset = z80.readByte(z80.pc)
  5054. z80.contendReadNoMReq(z80.pc, 1)
  5055. z80.contendReadNoMReq(z80.pc, 1)
  5056. z80.contendReadNoMReq(z80.pc, 1)
  5057. z80.contendReadNoMReq(z80.pc, 1)
  5058. z80.contendReadNoMReq(z80.pc, 1)
  5059. z80.pc++
  5060. bytetemp = z80.readByte(REGISTER + signExtend(offset))
  5061. ADC(bytetemp)
  5062.  
  5063. break
  5064. case 0x94: /* SUB A,REGISTERH */
  5065. SUB(REGISTERH)
  5066. break
  5067. case 0x95: /* SUB A,REGISTERL */
  5068. SUB(REGISTERL)
  5069. break
  5070. case 0x96: /* SUB A,(REGISTER+dd) */
  5071.  
  5072. var offset, bytetemp byte
  5073. offset = z80.readByte(z80.pc)
  5074. z80.contendReadNoMReq(z80.pc, 1)
  5075. z80.contendReadNoMReq(z80.pc, 1)
  5076. z80.contendReadNoMReq(z80.pc, 1)
  5077. z80.contendReadNoMReq(z80.pc, 1)
  5078. z80.contendReadNoMReq(z80.pc, 1)
  5079. z80.pc++
  5080. bytetemp = z80.readByte(REGISTER + signExtend(offset))
  5081. SUB(bytetemp)
  5082.  
  5083. break
  5084. case 0x9c: /* SBC A,REGISTERH */
  5085. SBC(REGISTERH)
  5086. break
  5087. case 0x9d: /* SBC A,REGISTERL */
  5088. SBC(REGISTERL)
  5089. break
  5090. case 0x9e: /* SBC A,(REGISTER+dd) */
  5091.  
  5092. var offset, bytetemp byte
  5093. offset = z80.readByte(z80.pc)
  5094. z80.contendReadNoMReq(z80.pc, 1)
  5095. z80.contendReadNoMReq(z80.pc, 1)
  5096. z80.contendReadNoMReq(z80.pc, 1)
  5097. z80.contendReadNoMReq(z80.pc, 1)
  5098. z80.contendReadNoMReq(z80.pc, 1)
  5099. z80.pc++
  5100. bytetemp = z80.readByte(REGISTER + signExtend(offset))
  5101. SBC(bytetemp)
  5102.  
  5103. break
  5104. case 0xa4: /* AND A,REGISTERH */
  5105. AND(REGISTERH)
  5106. break
  5107. case 0xa5: /* AND A,REGISTERL */
  5108. AND(REGISTERL)
  5109. break
  5110. case 0xa6: /* AND A,(REGISTER+dd) */
  5111.  
  5112. var offset, bytetemp byte
  5113. offset = z80.readByte(z80.pc)
  5114. z80.contendReadNoMReq(z80.pc, 1)
  5115. z80.contendReadNoMReq(z80.pc, 1)
  5116. z80.contendReadNoMReq(z80.pc, 1)
  5117. z80.contendReadNoMReq(z80.pc, 1)
  5118. z80.contendReadNoMReq(z80.pc, 1)
  5119. z80.pc++
  5120. bytetemp = z80.readByte(REGISTER + signExtend(offset))
  5121. AND(bytetemp)
  5122.  
  5123. break
  5124. case 0xac: /* XOR A,REGISTERH */
  5125. XOR(REGISTERH)
  5126. break
  5127. case 0xad: /* XOR A,REGISTERL */
  5128. XOR(REGISTERL)
  5129. break
  5130. case 0xae: /* XOR A,(REGISTER+dd) */
  5131.  
  5132. var offset, bytetemp byte
  5133. offset = z80.readByte(z80.pc)
  5134. z80.contendReadNoMReq(z80.pc, 1)
  5135. z80.contendReadNoMReq(z80.pc, 1)
  5136. z80.contendReadNoMReq(z80.pc, 1)
  5137. z80.contendReadNoMReq(z80.pc, 1)
  5138. z80.contendReadNoMReq(z80.pc, 1)
  5139. z80.pc++
  5140. bytetemp = z80.readByte(REGISTER + signExtend(offset))
  5141. XOR(bytetemp)
  5142.  
  5143. break
  5144. case 0xb4: /* OR A,REGISTERH */
  5145. OR(REGISTERH)
  5146. break
  5147. case 0xb5: /* OR A,REGISTERL */
  5148. OR(REGISTERL)
  5149. break
  5150. case 0xb6: /* OR A,(REGISTER+dd) */
  5151.  
  5152. var offset, bytetemp byte
  5153. offset = z80.readByte(z80.pc)
  5154. z80.contendReadNoMReq(z80.pc, 1)
  5155. z80.contendReadNoMReq(z80.pc, 1)
  5156. z80.contendReadNoMReq(z80.pc, 1)
  5157. z80.contendReadNoMReq(z80.pc, 1)
  5158. z80.contendReadNoMReq(z80.pc, 1)
  5159. z80.pc++
  5160. bytetemp = z80.readByte(REGISTER + signExtend(offset))
  5161. OR(bytetemp)
  5162.  
  5163. break
  5164. case 0xbc: /* CP A,REGISTERH */
  5165. CP(REGISTERH)
  5166. break
  5167. case 0xbd: /* CP A,REGISTERL */
  5168. CP(REGISTERL)
  5169. break
  5170. case 0xbe: /* CP A,(REGISTER+dd) */
  5171.  
  5172. var offset, bytetemp byte
  5173. offset = z80.readByte(z80.pc)
  5174. z80.contendReadNoMReq(z80.pc, 1)
  5175. z80.contendReadNoMReq(z80.pc, 1)
  5176. z80.contendReadNoMReq(z80.pc, 1)
  5177. z80.contendReadNoMReq(z80.pc, 1)
  5178. z80.contendReadNoMReq(z80.pc, 1)
  5179. z80.pc++
  5180. bytetemp = z80.readByte(REGISTER + signExtend(offset))
  5181. CP(bytetemp)
  5182.  
  5183. break
  5184. case 0xcb: /* shift DDFDCB */
  5185.  
  5186. var tempaddr uint16
  5187. var opcode3 byte
  5188. z80.contendRead(z80.pc, 3)
  5189. tempaddr = REGISTER + signExtend(z80.readByteInternal(z80.pc))
  5190. z80.pc++
  5191. z80.contendRead(z80.pc, 3)
  5192. opcode3 = z80.readByteInternal(z80.pc)
  5193. z80.contendReadNoMReq(z80.pc, 1)
  5194. z80.contendReadNoMReq(z80.pc, 1)
  5195. z80.pc++
  5196.  
  5197. switch opcode3 {
  5198. /* z80_ddfdcb.c Z80 {DD,FD}CBxx opcodes
  5199. Copyright (c) 1999-2003 Philip Kendall
  5200.  
  5201. This program is free software; you can redistribute it and/or modify
  5202. it under the terms of the GNU General Public License as published by
  5203. the Free Software Foundation; either version 2 of the License, or
  5204. (at your option) any later version.
  5205.  
  5206. This program is distributed in the hope that it will be useful,
  5207. but WITHOUT ANY WARRANTY; without even the implied warranty of
  5208. MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
  5209. GNU General Public License for more details.
  5210.  
  5211. You should have received a copy of the GNU General Public License along
  5212. with this program; if not, write to the Free Software Foundation, Inc.,
  5213. 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
  5214.  
  5215. Author contact information:
  5216.  
  5217. E-mail: philip-fuse@shadowmagic.org.uk
  5218.  
  5219. */
  5220.  
  5221. /* NB: this file is autogenerated by './z80.pl' from 'opcodes_ddfdcb.dat',
  5222. and included in 'z80_ops.c' */
  5223.  
  5224. case 0x00: /* LD B,RLC (REGISTER+dd) */
  5225. B = z80.readByte(tempaddr)
  5226. z80.contendReadNoMReq(tempaddr, 1)
  5227. RLC(B)
  5228. z80.writeByte(tempaddr, B)
  5229. break
  5230. case 0x01: /* LD C,RLC (REGISTER+dd) */
  5231. C = z80.readByte(tempaddr)
  5232. z80.contendReadNoMReq(tempaddr, 1)
  5233. RLC(C)
  5234. z80.writeByte(tempaddr, C)
  5235. break
  5236. case 0x02: /* LD D,RLC (REGISTER+dd) */
  5237. D = z80.readByte(tempaddr)
  5238. z80.contendReadNoMReq(tempaddr, 1)
  5239. RLC(D)
  5240. z80.writeByte(tempaddr, D)
  5241. break
  5242. case 0x03: /* LD E,RLC (REGISTER+dd) */
  5243. E = z80.readByte(tempaddr)
  5244. z80.contendReadNoMReq(tempaddr, 1)
  5245. RLC(E)
  5246. z80.writeByte(tempaddr, E)
  5247. break
  5248. case 0x04: /* LD H,RLC (REGISTER+dd) */
  5249. H = z80.readByte(tempaddr)
  5250. z80.contendReadNoMReq(tempaddr, 1)
  5251. RLC(H)
  5252. z80.writeByte(tempaddr, H)
  5253. break
  5254. case 0x05: /* LD L,RLC (REGISTER+dd) */
  5255. L = z80.readByte(tempaddr)
  5256. z80.contendReadNoMReq(tempaddr, 1)
  5257. RLC(L)
  5258. z80.writeByte(tempaddr, L)
  5259. break
  5260. case 0x06: /* RLC (REGISTER+dd) */
  5261. var bytetemp byte = z80.readByte(tempaddr)
  5262. z80.contendReadNoMReq(tempaddr, 1)
  5263. RLC(bytetemp)
  5264. z80.writeByte(tempaddr, bytetemp)
  5265. break
  5266. case 0x07: /* LD A,RLC (REGISTER+dd) */
  5267. A = z80.readByte(tempaddr)
  5268. z80.contendReadNoMReq(tempaddr, 1)
  5269. RLC(A)
  5270. z80.writeByte(tempaddr, A)
  5271. break
  5272. case 0x08: /* LD B,RRC (REGISTER+dd) */
  5273. B = z80.readByte(tempaddr)
  5274. z80.contendReadNoMReq(tempaddr, 1)
  5275. RRC(B)
  5276. z80.writeByte(tempaddr, B)
  5277. break
  5278. case 0x09: /* LD C,RRC (REGISTER+dd) */
  5279. C = z80.readByte(tempaddr)
  5280. z80.contendReadNoMReq(tempaddr, 1)
  5281. RRC(C)
  5282. z80.writeByte(tempaddr, C)
  5283. break
  5284. case 0x0a: /* LD D,RRC (REGISTER+dd) */
  5285. D = z80.readByte(tempaddr)
  5286. z80.contendReadNoMReq(tempaddr, 1)
  5287. RRC(D)
  5288. z80.writeByte(tempaddr, D)
  5289. break
  5290. case 0x0b: /* LD E,RRC (REGISTER+dd) */
  5291. E = z80.readByte(tempaddr)
  5292. z80.contendReadNoMReq(tempaddr, 1)
  5293. RRC(E)
  5294. z80.writeByte(tempaddr, E)
  5295. break
  5296. case 0x0c: /* LD H,RRC (REGISTER+dd) */
  5297. H = z80.readByte(tempaddr)
  5298. z80.contendReadNoMReq(tempaddr, 1)
  5299. RRC(H)
  5300. z80.writeByte(tempaddr, H)
  5301. break
  5302. case 0x0d: /* LD L,RRC (REGISTER+dd) */
  5303. L = z80.readByte(tempaddr)
  5304. z80.contendReadNoMReq(tempaddr, 1)
  5305. RRC(L)
  5306. z80.writeByte(tempaddr, L)
  5307. break
  5308. case 0x0e: /* RRC (REGISTER+dd) */
  5309. var bytetemp byte = z80.readByte(tempaddr)
  5310. z80.contendReadNoMReq(tempaddr, 1)
  5311. RRC(bytetemp)
  5312. z80.writeByte(tempaddr, bytetemp)
  5313. break
  5314. case 0x0f: /* LD A,RRC (REGISTER+dd) */
  5315. A = z80.readByte(tempaddr)
  5316. z80.contendReadNoMReq(tempaddr, 1)
  5317. RRC(A)
  5318. z80.writeByte(tempaddr, A)
  5319. break
  5320. case 0x10: /* LD B,RL (REGISTER+dd) */
  5321. B = z80.readByte(tempaddr)
  5322. z80.contendReadNoMReq(tempaddr, 1)
  5323. RL(B)
  5324. z80.writeByte(tempaddr, B)
  5325. break
  5326. case 0x11: /* LD C,RL (REGISTER+dd) */
  5327. C = z80.readByte(tempaddr)
  5328. z80.contendReadNoMReq(tempaddr, 1)
  5329. RL(C)
  5330. z80.writeByte(tempaddr, C)
  5331. break
  5332. case 0x12: /* LD D,RL (REGISTER+dd) */
  5333. D = z80.readByte(tempaddr)
  5334. z80.contendReadNoMReq(tempaddr, 1)
  5335. RL(D)
  5336. z80.writeByte(tempaddr, D)
  5337. break
  5338. case 0x13: /* LD E,RL (REGISTER+dd) */
  5339. E = z80.readByte(tempaddr)
  5340. z80.contendReadNoMReq(tempaddr, 1)
  5341. RL(E)
  5342. z80.writeByte(tempaddr, E)
  5343. break
  5344. case 0x14: /* LD H,RL (REGISTER+dd) */
  5345. H = z80.readByte(tempaddr)
  5346. z80.contendReadNoMReq(tempaddr, 1)
  5347. RL(H)
  5348. z80.writeByte(tempaddr, H)
  5349. break
  5350. case 0x15: /* LD L,RL (REGISTER+dd) */
  5351. L = z80.readByte(tempaddr)
  5352. z80.contendReadNoMReq(tempaddr, 1)
  5353. RL(L)
  5354. z80.writeByte(tempaddr, L)
  5355. break
  5356. case 0x16: /* RL (REGISTER+dd) */
  5357. var bytetemp byte = z80.readByte(tempaddr)
  5358. z80.contendReadNoMReq(tempaddr, 1)
  5359. RL(bytetemp)
  5360. z80.writeByte(tempaddr, bytetemp)
  5361. break
  5362. case 0x17: /* LD A,RL (REGISTER+dd) */
  5363. A = z80.readByte(tempaddr)
  5364. z80.contendReadNoMReq(tempaddr, 1)
  5365. RL(A)
  5366. z80.writeByte(tempaddr, A)
  5367. break
  5368. case 0x18: /* LD B,RR (REGISTER+dd) */
  5369. B = z80.readByte(tempaddr)
  5370. z80.contendReadNoMReq(tempaddr, 1)
  5371. RR(B)
  5372. z80.writeByte(tempaddr, B)
  5373. break
  5374. case 0x19: /* LD C,RR (REGISTER+dd) */
  5375. C = z80.readByte(tempaddr)
  5376. z80.contendReadNoMReq(tempaddr, 1)
  5377. RR(C)
  5378. z80.writeByte(tempaddr, C)
  5379. break
  5380. case 0x1a: /* LD D,RR (REGISTER+dd) */
  5381. D = z80.readByte(tempaddr)
  5382. z80.contendReadNoMReq(tempaddr, 1)
  5383. RR(D)
  5384. z80.writeByte(tempaddr, D)
  5385. break
  5386. case 0x1b: /* LD E,RR (REGISTER+dd) */
  5387. E = z80.readByte(tempaddr)
  5388. z80.contendReadNoMReq(tempaddr, 1)
  5389. RR(E)
  5390. z80.writeByte(tempaddr, E)
  5391. break
  5392. case 0x1c: /* LD H,RR (REGISTER+dd) */
  5393. H = z80.readByte(tempaddr)
  5394. z80.contendReadNoMReq(tempaddr, 1)
  5395. RR(H)
  5396. z80.writeByte(tempaddr, H)
  5397. break
  5398. case 0x1d: /* LD L,RR (REGISTER+dd) */
  5399. L = z80.readByte(tempaddr)
  5400. z80.contendReadNoMReq(tempaddr, 1)
  5401. RR(L)
  5402. z80.writeByte(tempaddr, L)
  5403. break
  5404. case 0x1e: /* RR (REGISTER+dd) */
  5405. var bytetemp byte = z80.readByte(tempaddr)
  5406. z80.contendReadNoMReq(tempaddr, 1)
  5407. RR(bytetemp)
  5408. z80.writeByte(tempaddr, bytetemp)
  5409. break
  5410. case 0x1f: /* LD A,RR (REGISTER+dd) */
  5411. A = z80.readByte(tempaddr)
  5412. z80.contendReadNoMReq(tempaddr, 1)
  5413. RR(A)
  5414. z80.writeByte(tempaddr, A)
  5415. break
  5416. case 0x20: /* LD B,SLA (REGISTER+dd) */
  5417. B = z80.readByte(tempaddr)
  5418. z80.contendReadNoMReq(tempaddr, 1)
  5419. SLA(B)
  5420. z80.writeByte(tempaddr, B)
  5421. break
  5422. case 0x21: /* LD C,SLA (REGISTER+dd) */
  5423. C = z80.readByte(tempaddr)
  5424. z80.contendReadNoMReq(tempaddr, 1)
  5425. SLA(C)
  5426. z80.writeByte(tempaddr, C)
  5427. break
  5428. case 0x22: /* LD D,SLA (REGISTER+dd) */
  5429. D = z80.readByte(tempaddr)
  5430. z80.contendReadNoMReq(tempaddr, 1)
  5431. SLA(D)
  5432. z80.writeByte(tempaddr, D)
  5433. break
  5434. case 0x23: /* LD E,SLA (REGISTER+dd) */
  5435. E = z80.readByte(tempaddr)
  5436. z80.contendReadNoMReq(tempaddr, 1)
  5437. SLA(E)
  5438. z80.writeByte(tempaddr, E)
  5439. break
  5440. case 0x24: /* LD H,SLA (REGISTER+dd) */
  5441. H = z80.readByte(tempaddr)
  5442. z80.contendReadNoMReq(tempaddr, 1)
  5443. SLA(H)
  5444. z80.writeByte(tempaddr, H)
  5445. break
  5446. case 0x25: /* LD L,SLA (REGISTER+dd) */
  5447. L = z80.readByte(tempaddr)
  5448. z80.contendReadNoMReq(tempaddr, 1)
  5449. SLA(L)
  5450. z80.writeByte(tempaddr, L)
  5451. break
  5452. case 0x26: /* SLA (REGISTER+dd) */
  5453. var bytetemp byte = z80.readByte(tempaddr)
  5454. z80.contendReadNoMReq(tempaddr, 1)
  5455. SLA(bytetemp)
  5456. z80.writeByte(tempaddr, bytetemp)
  5457. break
  5458. case 0x27: /* LD A,SLA (REGISTER+dd) */
  5459. A = z80.readByte(tempaddr)
  5460. z80.contendReadNoMReq(tempaddr, 1)
  5461. SLA(A)
  5462. z80.writeByte(tempaddr, A)
  5463. break
  5464. case 0x28: /* LD B,SRA (REGISTER+dd) */
  5465. B = z80.readByte(tempaddr)
  5466. z80.contendReadNoMReq(tempaddr, 1)
  5467. SRA(B)
  5468. z80.writeByte(tempaddr, B)
  5469. break
  5470. case 0x29: /* LD C,SRA (REGISTER+dd) */
  5471. C = z80.readByte(tempaddr)
  5472. z80.contendReadNoMReq(tempaddr, 1)
  5473. SRA(C)
  5474. z80.writeByte(tempaddr, C)
  5475. break
  5476. case 0x2a: /* LD D,SRA (REGISTER+dd) */
  5477. D = z80.readByte(tempaddr)
  5478. z80.contendReadNoMReq(tempaddr, 1)
  5479. SRA(D)
  5480. z80.writeByte(tempaddr, D)
  5481. break
  5482. case 0x2b: /* LD E,SRA (REGISTER+dd) */
  5483. E = z80.readByte(tempaddr)
  5484. z80.contendReadNoMReq(tempaddr, 1)
  5485. SRA(E)
  5486. z80.writeByte(tempaddr, E)
  5487. break
  5488. case 0x2c: /* LD H,SRA (REGISTER+dd) */
  5489. H = z80.readByte(tempaddr)
  5490. z80.contendReadNoMReq(tempaddr, 1)
  5491. SRA(H)
  5492. z80.writeByte(tempaddr, H)
  5493. break
  5494. case 0x2d: /* LD L,SRA (REGISTER+dd) */
  5495. L = z80.readByte(tempaddr)
  5496. z80.contendReadNoMReq(tempaddr, 1)
  5497. SRA(L)
  5498. z80.writeByte(tempaddr, L)
  5499. break
  5500. case 0x2e: /* SRA (REGISTER+dd) */
  5501. var bytetemp byte = z80.readByte(tempaddr)
  5502. z80.contendReadNoMReq(tempaddr, 1)
  5503. SRA(bytetemp)
  5504. z80.writeByte(tempaddr, bytetemp)
  5505. break
  5506. case 0x2f: /* LD A,SRA (REGISTER+dd) */
  5507. A = z80.readByte(tempaddr)
  5508. z80.contendReadNoMReq(tempaddr, 1)
  5509. SRA(A)
  5510. z80.writeByte(tempaddr, A)
  5511. break
  5512. case 0x30: /* LD B,SLL (REGISTER+dd) */
  5513. B = z80.readByte(tempaddr)
  5514. z80.contendReadNoMReq(tempaddr, 1)
  5515. SLL(B)
  5516. z80.writeByte(tempaddr, B)
  5517. break
  5518. case 0x31: /* LD C,SLL (REGISTER+dd) */
  5519. C = z80.readByte(tempaddr)
  5520. z80.contendReadNoMReq(tempaddr, 1)
  5521. SLL(C)
  5522. z80.writeByte(tempaddr, C)
  5523. break
  5524. case 0x32: /* LD D,SLL (REGISTER+dd) */
  5525. D = z80.readByte(tempaddr)
  5526. z80.contendReadNoMReq(tempaddr, 1)
  5527. SLL(D)
  5528. z80.writeByte(tempaddr, D)
  5529. break
  5530. case 0x33: /* LD E,SLL (REGISTER+dd) */
  5531. E = z80.readByte(tempaddr)
  5532. z80.contendReadNoMReq(tempaddr, 1)
  5533. SLL(E)
  5534. z80.writeByte(tempaddr, E)
  5535. break
  5536. case 0x34: /* LD H,SLL (REGISTER+dd) */
  5537. H = z80.readByte(tempaddr)
  5538. z80.contendReadNoMReq(tempaddr, 1)
  5539. SLL(H)
  5540. z80.writeByte(tempaddr, H)
  5541. break
  5542. case 0x35: /* LD L,SLL (REGISTER+dd) */
  5543. L = z80.readByte(tempaddr)
  5544. z80.contendReadNoMReq(tempaddr, 1)
  5545. SLL(L)
  5546. z80.writeByte(tempaddr, L)
  5547. break
  5548. case 0x36: /* SLL (REGISTER+dd) */
  5549. var bytetemp byte = z80.readByte(tempaddr)
  5550. z80.contendReadNoMReq(tempaddr, 1)
  5551. SLL(bytetemp)
  5552. z80.writeByte(tempaddr, bytetemp)
  5553. break
  5554. case 0x37: /* LD A,SLL (REGISTER+dd) */
  5555. A = z80.readByte(tempaddr)
  5556. z80.contendReadNoMReq(tempaddr, 1)
  5557. SLL(A)
  5558. z80.writeByte(tempaddr, A)
  5559. break
  5560. case 0x38: /* LD B,SRL (REGISTER+dd) */
  5561. B = z80.readByte(tempaddr)
  5562. z80.contendReadNoMReq(tempaddr, 1)
  5563. SRL(B)
  5564. z80.writeByte(tempaddr, B)
  5565. break
  5566. case 0x39: /* LD C,SRL (REGISTER+dd) */
  5567. C = z80.readByte(tempaddr)
  5568. z80.contendReadNoMReq(tempaddr, 1)
  5569. SRL(C)
  5570. z80.writeByte(tempaddr, C)
  5571. break
  5572. case 0x3a: /* LD D,SRL (REGISTER+dd) */
  5573. D = z80.readByte(tempaddr)
  5574. z80.contendReadNoMReq(tempaddr, 1)
  5575. SRL(D)
  5576. z80.writeByte(tempaddr, D)
  5577. break
  5578. case 0x3b: /* LD E,SRL (REGISTER+dd) */
  5579. E = z80.readByte(tempaddr)
  5580. z80.contendReadNoMReq(tempaddr, 1)
  5581. SRL(E)
  5582. z80.writeByte(tempaddr, E)
  5583. break
  5584. case 0x3c: /* LD H,SRL (REGISTER+dd) */
  5585. H = z80.readByte(tempaddr)
  5586. z80.contendReadNoMReq(tempaddr, 1)
  5587. SRL(H)
  5588. z80.writeByte(tempaddr, H)
  5589. break
  5590. case 0x3d: /* LD L,SRL (REGISTER+dd) */
  5591. L = z80.readByte(tempaddr)
  5592. z80.contendReadNoMReq(tempaddr, 1)
  5593. SRL(L)
  5594. z80.writeByte(tempaddr, L)
  5595. break
  5596. case 0x3e: /* SRL (REGISTER+dd) */
  5597. var bytetemp byte = z80.readByte(tempaddr)
  5598. z80.contendReadNoMReq(tempaddr, 1)
  5599. SRL(bytetemp)
  5600. z80.writeByte(tempaddr, bytetemp)
  5601. break
  5602. case 0x3f: /* LD A,SRL (REGISTER+dd) */
  5603. A = z80.readByte(tempaddr)
  5604. z80.contendReadNoMReq(tempaddr, 1)
  5605. SRL(A)
  5606. z80.writeByte(tempaddr, A)
  5607. break
  5608. case 0x40:
  5609. case 0x41:
  5610. case 0x42:
  5611. case 0x43:
  5612. case 0x44:
  5613. case 0x45:
  5614. case 0x46:
  5615. case 0x47: /* BIT 0,(REGISTER+dd) */
  5616. bytetemp := z80.readByte(tempaddr)
  5617. z80.contendReadNoMReq(tempaddr, 1)
  5618. BIT_I(0, bytetemp, tempaddr)
  5619. break
  5620. case 0x48:
  5621. case 0x49:
  5622. case 0x4a:
  5623. case 0x4b:
  5624. case 0x4c:
  5625. case 0x4d:
  5626. case 0x4e:
  5627. case 0x4f: /* BIT 1,(REGISTER+dd) */
  5628. bytetemp := z80.readByte(tempaddr)
  5629. z80.contendReadNoMReq(tempaddr, 1)
  5630. BIT_I(1, bytetemp, tempaddr)
  5631. break
  5632. case 0x50:
  5633. case 0x51:
  5634. case 0x52:
  5635. case 0x53:
  5636. case 0x54:
  5637. case 0x55:
  5638. case 0x56:
  5639. case 0x57: /* BIT 2,(REGISTER+dd) */
  5640. bytetemp := z80.readByte(tempaddr)
  5641. z80.contendReadNoMReq(tempaddr, 1)
  5642. BIT_I(2, bytetemp, tempaddr)
  5643. break
  5644. case 0x58:
  5645. case 0x59:
  5646. case 0x5a:
  5647. case 0x5b:
  5648. case 0x5c:
  5649. case 0x5d:
  5650. case 0x5e:
  5651. case 0x5f: /* BIT 3,(REGISTER+dd) */
  5652. bytetemp := z80.readByte(tempaddr)
  5653. z80.contendReadNoMReq(tempaddr, 1)
  5654. BIT_I(3, bytetemp, tempaddr)
  5655. break
  5656. case 0x60:
  5657. case 0x61:
  5658. case 0x62:
  5659. case 0x63:
  5660. case 0x64:
  5661. case 0x65:
  5662. case 0x66:
  5663. case 0x67: /* BIT 4,(REGISTER+dd) */
  5664. bytetemp := z80.readByte(tempaddr)
  5665. z80.contendReadNoMReq(tempaddr, 1)
  5666. BIT_I(4, bytetemp, tempaddr)
  5667. break
  5668. case 0x68:
  5669. case 0x69:
  5670. case 0x6a:
  5671. case 0x6b:
  5672. case 0x6c:
  5673. case 0x6d:
  5674. case 0x6e:
  5675. case 0x6f: /* BIT 5,(REGISTER+dd) */
  5676. bytetemp := z80.readByte(tempaddr)
  5677. z80.contendReadNoMReq(tempaddr, 1)
  5678. BIT_I(5, bytetemp, tempaddr)
  5679. break
  5680. case 0x70:
  5681. case 0x71:
  5682. case 0x72:
  5683. case 0x73:
  5684. case 0x74:
  5685. case 0x75:
  5686. case 0x76:
  5687. case 0x77: /* BIT 6,(REGISTER+dd) */
  5688. bytetemp := z80.readByte(tempaddr)
  5689. z80.contendReadNoMReq(tempaddr, 1)
  5690. BIT_I(6, bytetemp, tempaddr)
  5691. break
  5692. case 0x78:
  5693. case 0x79:
  5694. case 0x7a:
  5695. case 0x7b:
  5696. case 0x7c:
  5697. case 0x7d:
  5698. case 0x7e:
  5699. case 0x7f: /* BIT 7,(REGISTER+dd) */
  5700. bytetemp := z80.readByte(tempaddr)
  5701. z80.contendReadNoMReq(tempaddr, 1)
  5702. BIT_I(7, bytetemp, tempaddr)
  5703. break
  5704. case 0x80: /* LD B,RES 0,(REGISTER+dd) */
  5705. B = z80.readByte(tempaddr) & 0xfe
  5706. z80.contendReadNoMReq(tempaddr, 1)
  5707. z80.writeByte(tempaddr, B)
  5708. break
  5709. case 0x81: /* LD C,RES 0,(REGISTER+dd) */
  5710. C = z80.readByte(tempaddr) & 0xfe
  5711. z80.contendReadNoMReq(tempaddr, 1)
  5712. z80.writeByte(tempaddr, C)
  5713. break
  5714. case 0x82: /* LD D,RES 0,(REGISTER+dd) */
  5715. D = z80.readByte(tempaddr) & 0xfe
  5716. z80.contendReadNoMReq(tempaddr, 1)
  5717. z80.writeByte(tempaddr, D)
  5718. break
  5719. case 0x83: /* LD E,RES 0,(REGISTER+dd) */
  5720. E = z80.readByte(tempaddr) & 0xfe
  5721. z80.contendReadNoMReq(tempaddr, 1)
  5722. z80.writeByte(tempaddr, E)
  5723. break
  5724. case 0x84: /* LD H,RES 0,(REGISTER+dd) */
  5725. H = z80.readByte(tempaddr) & 0xfe
  5726. z80.contendReadNoMReq(tempaddr, 1)
  5727. z80.writeByte(tempaddr, H)
  5728. break
  5729. case 0x85: /* LD L,RES 0,(REGISTER+dd) */
  5730. L = z80.readByte(tempaddr) & 0xfe
  5731. z80.contendReadNoMReq(tempaddr, 1)
  5732. z80.writeByte(tempaddr, L)
  5733. break
  5734. case 0x86: /* RES 0,(REGISTER+dd) */
  5735.  
  5736. var bytetemp byte
  5737. bytetemp = z80.readByte(tempaddr)
  5738. z80.contendReadNoMReq(tempaddr, 1)
  5739. z80.writeByte(tempaddr, bytetemp&0xfe)
  5740.  
  5741. break
  5742. case 0x87: /* LD A,RES 0,(REGISTER+dd) */
  5743. A = z80.readByte(tempaddr) & 0xfe
  5744. z80.contendReadNoMReq(tempaddr, 1)
  5745. z80.writeByte(tempaddr, A)
  5746. break
  5747. case 0x88: /* LD B,RES 1,(REGISTER+dd) */
  5748. B = z80.readByte(tempaddr) & 0xfd
  5749. z80.contendReadNoMReq(tempaddr, 1)
  5750. z80.writeByte(tempaddr, B)
  5751. break
  5752. case 0x89: /* LD C,RES 1,(REGISTER+dd) */
  5753. C = z80.readByte(tempaddr) & 0xfd
  5754. z80.contendReadNoMReq(tempaddr, 1)
  5755. z80.writeByte(tempaddr, C)
  5756. break
  5757. case 0x8a: /* LD D,RES 1,(REGISTER+dd) */
  5758. D = z80.readByte(tempaddr) & 0xfd
  5759. z80.contendReadNoMReq(tempaddr, 1)
  5760. z80.writeByte(tempaddr, D)
  5761. break
  5762. case 0x8b: /* LD E,RES 1,(REGISTER+dd) */
  5763. E = z80.readByte(tempaddr) & 0xfd
  5764. z80.contendReadNoMReq(tempaddr, 1)
  5765. z80.writeByte(tempaddr, E)
  5766. break
  5767. case 0x8c: /* LD H,RES 1,(REGISTER+dd) */
  5768. H = z80.readByte(tempaddr) & 0xfd
  5769. z80.contendReadNoMReq(tempaddr, 1)
  5770. z80.writeByte(tempaddr, H)
  5771. break
  5772. case 0x8d: /* LD L,RES 1,(REGISTER+dd) */
  5773. L = z80.readByte(tempaddr) & 0xfd
  5774. z80.contendReadNoMReq(tempaddr, 1)
  5775. z80.writeByte(tempaddr, L)
  5776. break
  5777. case 0x8e: /* RES 1,(REGISTER+dd) */
  5778.  
  5779. var bytetemp byte
  5780. bytetemp = z80.readByte(tempaddr)
  5781. z80.contendReadNoMReq(tempaddr, 1)
  5782. z80.writeByte(tempaddr, bytetemp&0xfd)
  5783.  
  5784. break
  5785. case 0x8f: /* LD A,RES 1,(REGISTER+dd) */
  5786. A = z80.readByte(tempaddr) & 0xfd
  5787. z80.contendReadNoMReq(tempaddr, 1)
  5788. z80.writeByte(tempaddr, A)
  5789. break
  5790. case 0x90: /* LD B,RES 2,(REGISTER+dd) */
  5791. B = z80.readByte(tempaddr) & 0xfb
  5792. z80.contendReadNoMReq(tempaddr, 1)
  5793. z80.writeByte(tempaddr, B)
  5794. break
  5795. case 0x91: /* LD C,RES 2,(REGISTER+dd) */
  5796. C = z80.readByte(tempaddr) & 0xfb
  5797. z80.contendReadNoMReq(tempaddr, 1)
  5798. z80.writeByte(tempaddr, C)
  5799. break
  5800. case 0x92: /* LD D,RES 2,(REGISTER+dd) */
  5801. D = z80.readByte(tempaddr) & 0xfb
  5802. z80.contendReadNoMReq(tempaddr, 1)
  5803. z80.writeByte(tempaddr, D)
  5804. break
  5805. case 0x93: /* LD E,RES 2,(REGISTER+dd) */
  5806. E = z80.readByte(tempaddr) & 0xfb
  5807. z80.contendReadNoMReq(tempaddr, 1)
  5808. z80.writeByte(tempaddr, E)
  5809. break
  5810. case 0x94: /* LD H,RES 2,(REGISTER+dd) */
  5811. H = z80.readByte(tempaddr) & 0xfb
  5812. z80.contendReadNoMReq(tempaddr, 1)
  5813. z80.writeByte(tempaddr, H)
  5814. break
  5815. case 0x95: /* LD L,RES 2,(REGISTER+dd) */
  5816. L = z80.readByte(tempaddr) & 0xfb
  5817. z80.contendReadNoMReq(tempaddr, 1)
  5818. z80.writeByte(tempaddr, L)
  5819. break
  5820. case 0x96: /* RES 2,(REGISTER+dd) */
  5821.  
  5822. var bytetemp byte
  5823. bytetemp = z80.readByte(tempaddr)
  5824. z80.contendReadNoMReq(tempaddr, 1)
  5825. z80.writeByte(tempaddr, bytetemp&0xfb)
  5826.  
  5827. break
  5828. case 0x97: /* LD A,RES 2,(REGISTER+dd) */
  5829. A = z80.readByte(tempaddr) & 0xfb
  5830. z80.contendReadNoMReq(tempaddr, 1)
  5831. z80.writeByte(tempaddr, A)
  5832. break
  5833. case 0x98: /* LD B,RES 3,(REGISTER+dd) */
  5834. B = z80.readByte(tempaddr) & 0xf7
  5835. z80.contendReadNoMReq(tempaddr, 1)
  5836. z80.writeByte(tempaddr, B)
  5837. break
  5838. case 0x99: /* LD C,RES 3,(REGISTER+dd) */
  5839. C = z80.readByte(tempaddr) & 0xf7
  5840. z80.contendReadNoMReq(tempaddr, 1)
  5841. z80.writeByte(tempaddr, C)
  5842. break
  5843. case 0x9a: /* LD D,RES 3,(REGISTER+dd) */
  5844. D = z80.readByte(tempaddr) & 0xf7
  5845. z80.contendReadNoMReq(tempaddr, 1)
  5846. z80.writeByte(tempaddr, D)
  5847. break
  5848. case 0x9b: /* LD E,RES 3,(REGISTER+dd) */
  5849. E = z80.readByte(tempaddr) & 0xf7
  5850. z80.contendReadNoMReq(tempaddr, 1)
  5851. z80.writeByte(tempaddr, E)
  5852. break
  5853. case 0x9c: /* LD H,RES 3,(REGISTER+dd) */
  5854. H = z80.readByte(tempaddr) & 0xf7
  5855. z80.contendReadNoMReq(tempaddr, 1)
  5856. z80.writeByte(tempaddr, H)
  5857. break
  5858. case 0x9d: /* LD L,RES 3,(REGISTER+dd) */
  5859. L = z80.readByte(tempaddr) & 0xf7
  5860. z80.contendReadNoMReq(tempaddr, 1)
  5861. z80.writeByte(tempaddr, L)
  5862. break
  5863. case 0x9e: /* RES 3,(REGISTER+dd) */
  5864.  
  5865. var bytetemp byte
  5866. bytetemp = z80.readByte(tempaddr)
  5867. z80.contendReadNoMReq(tempaddr, 1)
  5868. z80.writeByte(tempaddr, bytetemp&0xf7)
  5869.  
  5870. break
  5871. case 0x9f: /* LD A,RES 3,(REGISTER+dd) */
  5872. A = z80.readByte(tempaddr) & 0xf7
  5873. z80.contendReadNoMReq(tempaddr, 1)
  5874. z80.writeByte(tempaddr, A)
  5875. break
  5876. case 0xa0: /* LD B,RES 4,(REGISTER+dd) */
  5877. B = z80.readByte(tempaddr) & 0xef
  5878. z80.contendReadNoMReq(tempaddr, 1)
  5879. z80.writeByte(tempaddr, B)
  5880. break
  5881. case 0xa1: /* LD C,RES 4,(REGISTER+dd) */
  5882. C = z80.readByte(tempaddr) & 0xef
  5883. z80.contendReadNoMReq(tempaddr, 1)
  5884. z80.writeByte(tempaddr, C)
  5885. break
  5886. case 0xa2: /* LD D,RES 4,(REGISTER+dd) */
  5887. D = z80.readByte(tempaddr) & 0xef
  5888. z80.contendReadNoMReq(tempaddr, 1)
  5889. z80.writeByte(tempaddr, D)
  5890. break
  5891. case 0xa3: /* LD E,RES 4,(REGISTER+dd) */
  5892. E = z80.readByte(tempaddr) & 0xef
  5893. z80.contendReadNoMReq(tempaddr, 1)
  5894. z80.writeByte(tempaddr, E)
  5895. break
  5896. case 0xa4: /* LD H,RES 4,(REGISTER+dd) */
  5897. H = z80.readByte(tempaddr) & 0xef
  5898. z80.contendReadNoMReq(tempaddr, 1)
  5899. z80.writeByte(tempaddr, H)
  5900. break
  5901. case 0xa5: /* LD L,RES 4,(REGISTER+dd) */
  5902. L = z80.readByte(tempaddr) & 0xef
  5903. z80.contendReadNoMReq(tempaddr, 1)
  5904. z80.writeByte(tempaddr, L)
  5905. break
  5906. case 0xa6: /* RES 4,(REGISTER+dd) */
  5907.  
  5908. var bytetemp byte
  5909. bytetemp = z80.readByte(tempaddr)
  5910. z80.contendReadNoMReq(tempaddr, 1)
  5911. z80.writeByte(tempaddr, bytetemp&0xef)
  5912.  
  5913. break
  5914. case 0xa7: /* LD A,RES 4,(REGISTER+dd) */
  5915. A = z80.readByte(tempaddr) & 0xef
  5916. z80.contendReadNoMReq(tempaddr, 1)
  5917. z80.writeByte(tempaddr, A)
  5918. break
  5919. case 0xa8: /* LD B,RES 5,(REGISTER+dd) */
  5920. B = z80.readByte(tempaddr) & 0xdf
  5921. z80.contendReadNoMReq(tempaddr, 1)
  5922. z80.writeByte(tempaddr, B)
  5923. break
  5924. case 0xa9: /* LD C,RES 5,(REGISTER+dd) */
  5925. C = z80.readByte(tempaddr) & 0xdf
  5926. z80.contendReadNoMReq(tempaddr, 1)
  5927. z80.writeByte(tempaddr, C)
  5928. break
  5929. case 0xaa: /* LD D,RES 5,(REGISTER+dd) */
  5930. D = z80.readByte(tempaddr) & 0xdf
  5931. z80.contendReadNoMReq(tempaddr, 1)
  5932. z80.writeByte(tempaddr, D)
  5933. break
  5934. case 0xab: /* LD E,RES 5,(REGISTER+dd) */
  5935. E = z80.readByte(tempaddr) & 0xdf
  5936. z80.contendReadNoMReq(tempaddr, 1)
  5937. z80.writeByte(tempaddr, E)
  5938. break
  5939. case 0xac: /* LD H,RES 5,(REGISTER+dd) */
  5940. H = z80.readByte(tempaddr) & 0xdf
  5941. z80.contendReadNoMReq(tempaddr, 1)
  5942. z80.writeByte(tempaddr, H)
  5943. break
  5944. case 0xad: /* LD L,RES 5,(REGISTER+dd) */
  5945. L = z80.readByte(tempaddr) & 0xdf
  5946. z80.contendReadNoMReq(tempaddr, 1)
  5947. z80.writeByte(tempaddr, L)
  5948. break
  5949. case 0xae: /* RES 5,(REGISTER+dd) */
  5950.  
  5951. var bytetemp byte
  5952. bytetemp = z80.readByte(tempaddr)
  5953. z80.contendReadNoMReq(tempaddr, 1)
  5954. z80.writeByte(tempaddr, bytetemp&0xdf)
  5955.  
  5956. break
  5957. case 0xaf: /* LD A,RES 5,(REGISTER+dd) */
  5958. A = z80.readByte(tempaddr) & 0xdf
  5959. z80.contendReadNoMReq(tempaddr, 1)
  5960. z80.writeByte(tempaddr, A)
  5961. break
  5962. case 0xb0: /* LD B,RES 6,(REGISTER+dd) */
  5963. B = z80.readByte(tempaddr) & 0xbf
  5964. z80.contendReadNoMReq(tempaddr, 1)
  5965. z80.writeByte(tempaddr, B)
  5966. break
  5967. case 0xb1: /* LD C,RES 6,(REGISTER+dd) */
  5968. C = z80.readByte(tempaddr) & 0xbf
  5969. z80.contendReadNoMReq(tempaddr, 1)
  5970. z80.writeByte(tempaddr, C)
  5971. break
  5972. case 0xb2: /* LD D,RES 6,(REGISTER+dd) */
  5973. D = z80.readByte(tempaddr) & 0xbf
  5974. z80.contendReadNoMReq(tempaddr, 1)
  5975. z80.writeByte(tempaddr, D)
  5976. break
  5977. case 0xb3: /* LD E,RES 6,(REGISTER+dd) */
  5978. E = z80.readByte(tempaddr) & 0xbf
  5979. z80.contendReadNoMReq(tempaddr, 1)
  5980. z80.writeByte(tempaddr, E)
  5981. break
  5982. case 0xb4: /* LD H,RES 6,(REGISTER+dd) */
  5983. H = z80.readByte(tempaddr) & 0xbf
  5984. z80.contendReadNoMReq(tempaddr, 1)
  5985. z80.writeByte(tempaddr, H)
  5986. break
  5987. case 0xb5: /* LD L,RES 6,(REGISTER+dd) */
  5988. L = z80.readByte(tempaddr) & 0xbf
  5989. z80.contendReadNoMReq(tempaddr, 1)
  5990. z80.writeByte(tempaddr, L)
  5991. break
  5992. case 0xb6: /* RES 6,(REGISTER+dd) */
  5993.  
  5994. var bytetemp byte
  5995. bytetemp = z80.readByte(tempaddr)
  5996. z80.contendReadNoMReq(tempaddr, 1)
  5997. z80.writeByte(tempaddr, bytetemp&0xbf)
  5998.  
  5999. break
  6000. case 0xb7: /* LD A,RES 6,(REGISTER+dd) */
  6001. A = z80.readByte(tempaddr) & 0xbf
  6002. z80.contendReadNoMReq(tempaddr, 1)
  6003. z80.writeByte(tempaddr, A)
  6004. break
  6005. case 0xb8: /* LD B,RES 7,(REGISTER+dd) */
  6006. B = z80.readByte(tempaddr) & 0x7f
  6007. z80.contendReadNoMReq(tempaddr, 1)
  6008. z80.writeByte(tempaddr, B)
  6009. break
  6010. case 0xb9: /* LD C,RES 7,(REGISTER+dd) */
  6011. C = z80.readByte(tempaddr) & 0x7f
  6012. z80.contendReadNoMReq(tempaddr, 1)
  6013. z80.writeByte(tempaddr, C)
  6014. break
  6015. case 0xba: /* LD D,RES 7,(REGISTER+dd) */
  6016. D = z80.readByte(tempaddr) & 0x7f
  6017. z80.contendReadNoMReq(tempaddr, 1)
  6018. z80.writeByte(tempaddr, D)
  6019. break
  6020. case 0xbb: /* LD E,RES 7,(REGISTER+dd) */
  6021. E = z80.readByte(tempaddr) & 0x7f
  6022. z80.contendReadNoMReq(tempaddr, 1)
  6023. z80.writeByte(tempaddr, E)
  6024. break
  6025. case 0xbc: /* LD H,RES 7,(REGISTER+dd) */
  6026. H = z80.readByte(tempaddr) & 0x7f
  6027. z80.contendReadNoMReq(tempaddr, 1)
  6028. z80.writeByte(tempaddr, H)
  6029. break
  6030. case 0xbd: /* LD L,RES 7,(REGISTER+dd) */
  6031. L = z80.readByte(tempaddr) & 0x7f
  6032. z80.contendReadNoMReq(tempaddr, 1)
  6033. z80.writeByte(tempaddr, L)
  6034. break
  6035. case 0xbe: /* RES 7,(REGISTER+dd) */
  6036.  
  6037. var bytetemp byte
  6038. bytetemp = z80.readByte(tempaddr)
  6039. z80.contendReadNoMReq(tempaddr, 1)
  6040. z80.writeByte(tempaddr, bytetemp&0x7f)
  6041.  
  6042. break
  6043. case 0xbf: /* LD A,RES 7,(REGISTER+dd) */
  6044. A = z80.readByte(tempaddr) & 0x7f
  6045. z80.contendReadNoMReq(tempaddr, 1)
  6046. z80.writeByte(tempaddr, A)
  6047. break
  6048. case 0xc0: /* LD B,SET 0,(REGISTER+dd) */
  6049. B = z80.readByte(tempaddr) | 0x01
  6050. z80.contendReadNoMReq(tempaddr, 1)
  6051. z80.writeByte(tempaddr, B)
  6052. break
  6053. case 0xc1: /* LD C,SET 0,(REGISTER+dd) */
  6054. C = z80.readByte(tempaddr) | 0x01
  6055. z80.contendReadNoMReq(tempaddr, 1)
  6056. z80.writeByte(tempaddr, C)
  6057. break
  6058. case 0xc2: /* LD D,SET 0,(REGISTER+dd) */
  6059. D = z80.readByte(tempaddr) | 0x01
  6060. z80.contendReadNoMReq(tempaddr, 1)
  6061. z80.writeByte(tempaddr, D)
  6062. break
  6063. case 0xc3: /* LD E,SET 0,(REGISTER+dd) */
  6064. E = z80.readByte(tempaddr) | 0x01
  6065. z80.contendReadNoMReq(tempaddr, 1)
  6066. z80.writeByte(tempaddr, E)
  6067. break
  6068. case 0xc4: /* LD H,SET 0,(REGISTER+dd) */
  6069. H = z80.readByte(tempaddr) | 0x01
  6070. z80.contendReadNoMReq(tempaddr, 1)
  6071. z80.writeByte(tempaddr, H)
  6072. break
  6073. case 0xc5: /* LD L,SET 0,(REGISTER+dd) */
  6074. L = z80.readByte(tempaddr) | 0x01
  6075. z80.contendReadNoMReq(tempaddr, 1)
  6076. z80.writeByte(tempaddr, L)
  6077. break
  6078. case 0xc6: /* SET 0,(REGISTER+dd) */
  6079.  
  6080. var bytetemp byte
  6081. bytetemp = z80.readByte(tempaddr)
  6082. z80.contendReadNoMReq(tempaddr, 1)
  6083. z80.writeByte(tempaddr, bytetemp|0x01)
  6084.  
  6085. break
  6086. case 0xc7: /* LD A,SET 0,(REGISTER+dd) */
  6087. A = z80.readByte(tempaddr) | 0x01
  6088. z80.contendReadNoMReq(tempaddr, 1)
  6089. z80.writeByte(tempaddr, A)
  6090. break
  6091. case 0xc8: /* LD B,SET 1,(REGISTER+dd) */
  6092. B = z80.readByte(tempaddr) | 0x02
  6093. z80.contendReadNoMReq(tempaddr, 1)
  6094. z80.writeByte(tempaddr, B)
  6095. break
  6096. case 0xc9: /* LD C,SET 1,(REGISTER+dd) */
  6097. C = z80.readByte(tempaddr) | 0x02
  6098. z80.contendReadNoMReq(tempaddr, 1)
  6099. z80.writeByte(tempaddr, C)
  6100. break
  6101. case 0xca: /* LD D,SET 1,(REGISTER+dd) */
  6102. D = z80.readByte(tempaddr) | 0x02
  6103. z80.contendReadNoMReq(tempaddr, 1)
  6104. z80.writeByte(tempaddr, D)
  6105. break
  6106. case 0xcb: /* LD E,SET 1,(REGISTER+dd) */
  6107. E = z80.readByte(tempaddr) | 0x02
  6108. z80.contendReadNoMReq(tempaddr, 1)
  6109. z80.writeByte(tempaddr, E)
  6110. break
  6111. case 0xcc: /* LD H,SET 1,(REGISTER+dd) */
  6112. H = z80.readByte(tempaddr) | 0x02
  6113. z80.contendReadNoMReq(tempaddr, 1)
  6114. z80.writeByte(tempaddr, H)
  6115. break
  6116. case 0xcd: /* LD L,SET 1,(REGISTER+dd) */
  6117. L = z80.readByte(tempaddr) | 0x02
  6118. z80.contendReadNoMReq(tempaddr, 1)
  6119. z80.writeByte(tempaddr, L)
  6120. break
  6121. case 0xce: /* SET 1,(REGISTER+dd) */
  6122.  
  6123. var bytetemp byte
  6124. bytetemp = z80.readByte(tempaddr)
  6125. z80.contendReadNoMReq(tempaddr, 1)
  6126. z80.writeByte(tempaddr, bytetemp|0x02)
  6127.  
  6128. break
  6129. case 0xcf: /* LD A,SET 1,(REGISTER+dd) */
  6130. A = z80.readByte(tempaddr) | 0x02
  6131. z80.contendReadNoMReq(tempaddr, 1)
  6132. z80.writeByte(tempaddr, A)
  6133. break
  6134. case 0xd0: /* LD B,SET 2,(REGISTER+dd) */
  6135. B = z80.readByte(tempaddr) | 0x04
  6136. z80.contendReadNoMReq(tempaddr, 1)
  6137. z80.writeByte(tempaddr, B)
  6138. break
  6139. case 0xd1: /* LD C,SET 2,(REGISTER+dd) */
  6140. C = z80.readByte(tempaddr) | 0x04
  6141. z80.contendReadNoMReq(tempaddr, 1)
  6142. z80.writeByte(tempaddr, C)
  6143. break
  6144. case 0xd2: /* LD D,SET 2,(REGISTER+dd) */
  6145. D = z80.readByte(tempaddr) | 0x04
  6146. z80.contendReadNoMReq(tempaddr, 1)
  6147. z80.writeByte(tempaddr, D)
  6148. break
  6149. case 0xd3: /* LD E,SET 2,(REGISTER+dd) */
  6150. E = z80.readByte(tempaddr) | 0x04
  6151. z80.contendReadNoMReq(tempaddr, 1)
  6152. z80.writeByte(tempaddr, E)
  6153. break
  6154. case 0xd4: /* LD H,SET 2,(REGISTER+dd) */
  6155. H = z80.readByte(tempaddr) | 0x04
  6156. z80.contendReadNoMReq(tempaddr, 1)
  6157. z80.writeByte(tempaddr, H)
  6158. break
  6159. case 0xd5: /* LD L,SET 2,(REGISTER+dd) */
  6160. L = z80.readByte(tempaddr) | 0x04
  6161. z80.contendReadNoMReq(tempaddr, 1)
  6162. z80.writeByte(tempaddr, L)
  6163. break
  6164. case 0xd6: /* SET 2,(REGISTER+dd) */
  6165.  
  6166. var bytetemp byte
  6167. bytetemp = z80.readByte(tempaddr)
  6168. z80.contendReadNoMReq(tempaddr, 1)
  6169. z80.writeByte(tempaddr, bytetemp|0x04)
  6170.  
  6171. break
  6172. case 0xd7: /* LD A,SET 2,(REGISTER+dd) */
  6173. A = z80.readByte(tempaddr) | 0x04
  6174. z80.contendReadNoMReq(tempaddr, 1)
  6175. z80.writeByte(tempaddr, A)
  6176. break
  6177. case 0xd8: /* LD B,SET 3,(REGISTER+dd) */
  6178. B = z80.readByte(tempaddr) | 0x08
  6179. z80.contendReadNoMReq(tempaddr, 1)
  6180. z80.writeByte(tempaddr, B)
  6181. break
  6182. case 0xd9: /* LD C,SET 3,(REGISTER+dd) */
  6183. C = z80.readByte(tempaddr) | 0x08
  6184. z80.contendReadNoMReq(tempaddr, 1)
  6185. z80.writeByte(tempaddr, C)
  6186. break
  6187. case 0xda: /* LD D,SET 3,(REGISTER+dd) */
  6188. D = z80.readByte(tempaddr) | 0x08
  6189. z80.contendReadNoMReq(tempaddr, 1)
  6190. z80.writeByte(tempaddr, D)
  6191. break
  6192. case 0xdb: /* LD E,SET 3,(REGISTER+dd) */
  6193. E = z80.readByte(tempaddr) | 0x08
  6194. z80.contendReadNoMReq(tempaddr, 1)
  6195. z80.writeByte(tempaddr, E)
  6196. break
  6197. case 0xdc: /* LD H,SET 3,(REGISTER+dd) */
  6198. H = z80.readByte(tempaddr) | 0x08
  6199. z80.contendReadNoMReq(tempaddr, 1)
  6200. z80.writeByte(tempaddr, H)
  6201. break
  6202. case 0xdd: /* LD L,SET 3,(REGISTER+dd) */
  6203. L = z80.readByte(tempaddr) | 0x08
  6204. z80.contendReadNoMReq(tempaddr, 1)
  6205. z80.writeByte(tempaddr, L)
  6206. break
  6207. case 0xde: /* SET 3,(REGISTER+dd) */
  6208.  
  6209. var bytetemp byte
  6210. bytetemp = z80.readByte(tempaddr)
  6211. z80.contendReadNoMReq(tempaddr, 1)
  6212. z80.writeByte(tempaddr, bytetemp|0x08)
  6213.  
  6214. break
  6215. case 0xdf: /* LD A,SET 3,(REGISTER+dd) */
  6216. A = z80.readByte(tempaddr) | 0x08
  6217. z80.contendReadNoMReq(tempaddr, 1)
  6218. z80.writeByte(tempaddr, A)
  6219. break
  6220. case 0xe0: /* LD B,SET 4,(REGISTER+dd) */
  6221. B = z80.readByte(tempaddr) | 0x10
  6222. z80.contendReadNoMReq(tempaddr, 1)
  6223. z80.writeByte(tempaddr, B)
  6224. break
  6225. case 0xe1: /* LD C,SET 4,(REGISTER+dd) */
  6226. C = z80.readByte(tempaddr) | 0x10
  6227. z80.contendReadNoMReq(tempaddr, 1)
  6228. z80.writeByte(tempaddr, C)
  6229. break
  6230. case 0xe2: /* LD D,SET 4,(REGISTER+dd) */
  6231. D = z80.readByte(tempaddr) | 0x10
  6232. z80.contendReadNoMReq(tempaddr, 1)
  6233. z80.writeByte(tempaddr, D)
  6234. break
  6235. case 0xe3: /* LD E,SET 4,(REGISTER+dd) */
  6236. E = z80.readByte(tempaddr) | 0x10
  6237. z80.contendReadNoMReq(tempaddr, 1)
  6238. z80.writeByte(tempaddr, E)
  6239. break
  6240. case 0xe4: /* LD H,SET 4,(REGISTER+dd) */
  6241. H = z80.readByte(tempaddr) | 0x10
  6242. z80.contendReadNoMReq(tempaddr, 1)
  6243. z80.writeByte(tempaddr, H)
  6244. break
  6245. case 0xe5: /* LD L,SET 4,(REGISTER+dd) */
  6246. L = z80.readByte(tempaddr) | 0x10
  6247. z80.contendReadNoMReq(tempaddr, 1)
  6248. z80.writeByte(tempaddr, L)
  6249. break
  6250. case 0xe6: /* SET 4,(REGISTER+dd) */
  6251.  
  6252. var bytetemp byte
  6253. bytetemp = z80.readByte(tempaddr)
  6254. z80.contendReadNoMReq(tempaddr, 1)
  6255. z80.writeByte(tempaddr, bytetemp|0x10)
  6256.  
  6257. break
  6258. case 0xe7: /* LD A,SET 4,(REGISTER+dd) */
  6259. A = z80.readByte(tempaddr) | 0x10
  6260. z80.contendReadNoMReq(tempaddr, 1)
  6261. z80.writeByte(tempaddr, A)
  6262. break
  6263. case 0xe8: /* LD B,SET 5,(REGISTER+dd) */
  6264. B = z80.readByte(tempaddr) | 0x20
  6265. z80.contendReadNoMReq(tempaddr, 1)
  6266. z80.writeByte(tempaddr, B)
  6267. break
  6268. case 0xe9: /* LD C,SET 5,(REGISTER+dd) */
  6269. C = z80.readByte(tempaddr) | 0x20
  6270. z80.contendReadNoMReq(tempaddr, 1)
  6271. z80.writeByte(tempaddr, C)
  6272. break
  6273. case 0xea: /* LD D,SET 5,(REGISTER+dd) */
  6274. D = z80.readByte(tempaddr) | 0x20
  6275. z80.contendReadNoMReq(tempaddr, 1)
  6276. z80.writeByte(tempaddr, D)
  6277. break
  6278. case 0xeb: /* LD E,SET 5,(REGISTER+dd) */
  6279. E = z80.readByte(tempaddr) | 0x20
  6280. z80.contendReadNoMReq(tempaddr, 1)
  6281. z80.writeByte(tempaddr, E)
  6282. break
  6283. case 0xec: /* LD H,SET 5,(REGISTER+dd) */
  6284. H = z80.readByte(tempaddr) | 0x20
  6285. z80.contendReadNoMReq(tempaddr, 1)
  6286. z80.writeByte(tempaddr, H)
  6287. break
  6288. case 0xed: /* LD L,SET 5,(REGISTER+dd) */
  6289. L = z80.readByte(tempaddr) | 0x20
  6290. z80.contendReadNoMReq(tempaddr, 1)
  6291. z80.writeByte(tempaddr, L)
  6292. break
  6293. case 0xee: /* SET 5,(REGISTER+dd) */
  6294.  
  6295. var bytetemp byte
  6296. bytetemp = z80.readByte(tempaddr)
  6297. z80.contendReadNoMReq(tempaddr, 1)
  6298. z80.writeByte(tempaddr, bytetemp|0x20)
  6299.  
  6300. break
  6301. case 0xef: /* LD A,SET 5,(REGISTER+dd) */
  6302. A = z80.readByte(tempaddr) | 0x20
  6303. z80.contendReadNoMReq(tempaddr, 1)
  6304. z80.writeByte(tempaddr, A)
  6305. break
  6306. case 0xf0: /* LD B,SET 6,(REGISTER+dd) */
  6307. B = z80.readByte(tempaddr) | 0x40
  6308. z80.contendReadNoMReq(tempaddr, 1)
  6309. z80.writeByte(tempaddr, B)
  6310. break
  6311. case 0xf1: /* LD C,SET 6,(REGISTER+dd) */
  6312. C = z80.readByte(tempaddr) | 0x40
  6313. z80.contendReadNoMReq(tempaddr, 1)
  6314. z80.writeByte(tempaddr, C)
  6315. break
  6316. case 0xf2: /* LD D,SET 6,(REGISTER+dd) */
  6317. D = z80.readByte(tempaddr) | 0x40
  6318. z80.contendReadNoMReq(tempaddr, 1)
  6319. z80.writeByte(tempaddr, D)
  6320. break
  6321. case 0xf3: /* LD E,SET 6,(REGISTER+dd) */
  6322. E = z80.readByte(tempaddr) | 0x40
  6323. z80.contendReadNoMReq(tempaddr, 1)
  6324. z80.writeByte(tempaddr, E)
  6325. break
  6326. case 0xf4: /* LD H,SET 6,(REGISTER+dd) */
  6327. H = z80.readByte(tempaddr) | 0x40
  6328. z80.contendReadNoMReq(tempaddr, 1)
  6329. z80.writeByte(tempaddr, H)
  6330. break
  6331. case 0xf5: /* LD L,SET 6,(REGISTER+dd) */
  6332. L = z80.readByte(tempaddr) | 0x40
  6333. z80.contendReadNoMReq(tempaddr, 1)
  6334. z80.writeByte(tempaddr, L)
  6335. break
  6336. case 0xf6: /* SET 6,(REGISTER+dd) */
  6337.  
  6338. var bytetemp byte
  6339. bytetemp = z80.readByte(tempaddr)
  6340. z80.contendReadNoMReq(tempaddr, 1)
  6341. z80.writeByte(tempaddr, bytetemp|0x40)
  6342.  
  6343. break
  6344. case 0xf7: /* LD A,SET 6,(REGISTER+dd) */
  6345. A = z80.readByte(tempaddr) | 0x40
  6346. z80.contendReadNoMReq(tempaddr, 1)
  6347. z80.writeByte(tempaddr, A)
  6348. break
  6349. case 0xf8: /* LD B,SET 7,(REGISTER+dd) */
  6350. B = z80.readByte(tempaddr) | 0x80
  6351. z80.contendReadNoMReq(tempaddr, 1)
  6352. z80.writeByte(tempaddr, B)
  6353. break
  6354. case 0xf9: /* LD C,SET 7,(REGISTER+dd) */
  6355. C = z80.readByte(tempaddr) | 0x80
  6356. z80.contendReadNoMReq(tempaddr, 1)
  6357. z80.writeByte(tempaddr, C)
  6358. break
  6359. case 0xfa: /* LD D,SET 7,(REGISTER+dd) */
  6360. D = z80.readByte(tempaddr) | 0x80
  6361. z80.contendReadNoMReq(tempaddr, 1)
  6362. z80.writeByte(tempaddr, D)
  6363. break
  6364. case 0xfb: /* LD E,SET 7,(REGISTER+dd) */
  6365. E = z80.readByte(tempaddr) | 0x80
  6366. z80.contendReadNoMReq(tempaddr, 1)
  6367. z80.writeByte(tempaddr, E)
  6368. break
  6369. case 0xfc: /* LD H,SET 7,(REGISTER+dd) */
  6370. H = z80.readByte(tempaddr) | 0x80
  6371. z80.contendReadNoMReq(tempaddr, 1)
  6372. z80.writeByte(tempaddr, H)
  6373. break
  6374. case 0xfd: /* LD L,SET 7,(REGISTER+dd) */
  6375. L = z80.readByte(tempaddr) | 0x80
  6376. z80.contendReadNoMReq(tempaddr, 1)
  6377. z80.writeByte(tempaddr, L)
  6378. break
  6379. case 0xfe: /* SET 7,(REGISTER+dd) */
  6380.  
  6381. var bytetemp byte
  6382. bytetemp = z80.readByte(tempaddr)
  6383. z80.contendReadNoMReq(tempaddr, 1)
  6384. z80.writeByte(tempaddr, bytetemp|0x80)
  6385.  
  6386. break
  6387. case 0xff: /* LD A,SET 7,(REGISTER+dd) */
  6388. A = z80.readByte(tempaddr) | 0x80
  6389. z80.contendReadNoMReq(tempaddr, 1)
  6390. z80.writeByte(tempaddr, A)
  6391. break
  6392.  
  6393. }
  6394.  
  6395. break
  6396. case 0xe1: /* POP REGISTER */
  6397. POP16(REGISTERL, REGISTERH)
  6398. break
  6399. case 0xe3: /* EX (SP),REGISTER */
  6400. var bytetempl, bytetemph byte
  6401. bytetempl = z80.readByte(z80.SP())
  6402. bytetemph = z80.readByte(z80.SP() + 1)
  6403. z80.contendReadNoMReq(z80.SP()+1, 1)
  6404. z80.writeByte(z80.SP()+1, REGISTERH)
  6405. z80.writeByte(z80, SP(), REGISTERL)
  6406. z80.contendWriteNoMReq(z80.SP(), 1)
  6407. z80.contendWriteNoMreq(z80.SP(), 1)
  6408. REGISTERL = bytetempl
  6409. REGISTERH = bytetemph
  6410. break
  6411. case 0xe5: /* PUSH REGISTER */
  6412. z80.contendReadNoMReq(z80.IR(), 1)
  6413. PUSH16(REGISTERL, REGISTERH)
  6414. break
  6415. case 0xe9: /* JP REGISTER */
  6416. z80.pc = REGISTER /* NB: NOT INDIRECT! */
  6417. break
  6418. case 0xf9: /* LD SP,REGISTER */
  6419. z80.contendReadNoMReq(z80.IR(), 1)
  6420. z80.contendReadNoMReq(z80.IR(), 1)
  6421. SP = REGISTER
  6422. break
  6423. default: /* Instruction did not involve H or L, so backtrack
  6424. one instruction and parse again */
  6425. z80.pc--
  6426. z80.r--
  6427. opcode = opcode2
  6428.  
  6429. goto end_opcode
  6430.  
  6431. }
  6432. }
  6433. break
  6434. case 0xfe: /* CP nn */
  6435. {
  6436. var bytetemp byte = z80.readByte(PC)
  6437. z80.pc++
  6438. CP(bytetemp)
  6439. }
  6440. break
  6441. case 0xff: /* RST 38 */
  6442. z80.contendReadNoMReq(z80.IR(), 1)
  6443. RST(0x38)
  6444. break
  6445.  
  6446. }
  6447. }
  6448. }
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!