1 /* 2 * libtilemcore - Graphing calculator emulation library 3 * 4 * Copyright (C) 2009 Benjamin Moody 5 * 6 * This library is free software; you can redistribute it and/or 7 * modify it under the terms of the GNU Lesser General Public License 8 * as published by the Free Software Foundation; either version 2.1 of 9 * the License, or (at your option) any later version. 10 * 11 * This library is distributed in the hope that it will be useful, but 12 * WITHOUT ANY WARRANTY; without even the implied warranty of 13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU 14 * Lesser General Public License for more details. 15 * 16 * You should have received a copy of the GNU Lesser General Public 17 * License along with this library; if not, see 18 * <http://www.gnu.org/licenses/>. 19 */ 20 21 switch (op) { 22 case 0x00: /* NOP */ 23 delay(4); 24 break; 25 case 0x01: /* LD BC, nn */ 26 BC = readw(PC); 27 PC += 2; 28 delay(10); 29 break; 30 case 0x02: /* LD (BC), A */ 31 W = A; 32 writeb(BC, A); 33 delay(7); 34 break; 35 case 0x03: /* INC BC */ 36 BC++; 37 delay(6); 38 break; 39 case 0x04: /* INC B */ 40 inc(B); 41 delay(4); 42 break; 43 case 0x05: /* DEC B */ 44 dec(B); 45 delay(4); 46 break; 47 case 0x06: /* LD B, n */ 48 B = readb(PC++); 49 delay(7); 50 break; 51 case 0x07: /* RLCA */ 52 rlca; 53 delay(4); 54 break; 55 56 case 0x08: /* EX AF, AF' */ 57 ex(AF, AF2); 58 delay(4); 59 break; 60 case 0x09: /* ADD HL, BC */ 61 WZ = HL + 1; 62 add16(HLw, BCw); 63 delay(11); 64 break; 65 case 0x0A: /* LD A, (BC) */ 66 WZ = BC; 67 A = readb(WZ++); 68 delay(7); 69 break; 70 case 0x0B: /* DEC BC */ 71 BC--; 72 delay(6); 73 break; 74 case 0x0C: /* INC C */ 75 inc(C); 76 delay(4); 77 break; 78 case 0x0D: /* DEC C */ 79 dec(C); 80 delay(4); 81 break; 82 case 0x0E: /* LD C, n */ 83 C = readb(PC++); 84 delay(7); 85 break; 86 case 0x0F: /* RRCA */ 87 rrca; 88 delay(4); 89 break; 90 91 case 0x10: /* DJNZ $+n */ 92 offs = (int) (signed char) readb(PC++); 93 B--; 94 if (B) { 95 WZ = PC + offs; 96 PC = WZ; 97 delay(13); 98 } 99 else 100 delay(8); 101 break; 102 case 0x11: /* LD DE, nn */ 103 DE = readw(PC); 104 PC += 2; 105 delay(10); 106 break; 107 case 0x12: /* LD (DE), A */ 108 W = A; 109 writeb(DE, A); 110 delay(7); 111 break; 112 case 0x13: /* INC DE */ 113 DE++; 114 delay(6); 115 break; 116 case 0x14: /* INC D */ 117 inc(D); 118 delay(4); 119 break; 120 case 0x15: /* DEC D */ 121 dec(D); 122 delay(4); 123 break; 124 case 0x16: /* LD D, n */ 125 D = readb(PC++); 126 delay(7); 127 break; 128 case 0x17: /* RLA */ 129 rla; 130 delay(4); 131 break; 132 133 case 0x18: /* JR $+n */ 134 offs = (int) (signed char) readb(PC++); 135 WZ = PC + offs; 136 PC = WZ; 137 delay(12); 138 break; 139 case 0x19: /* ADD HL, DE */ 140 WZ = HL + 1; 141 add16(HLw, DEw); 142 delay(11); 143 break; 144 case 0x1A: /* LD A, (DE) */ 145 WZ = DE; 146 A = readb(WZ++); 147 delay(7); 148 break; 149 case 0x1B: /* DEC DE */ 150 DE--; 151 delay(6); 152 break; 153 case 0x1C: /* INC E */ 154 inc(E); 155 delay(4); 156 break; 157 case 0x1D: /* DEC E */ 158 dec(E); 159 delay(4); 160 break; 161 case 0x1E: /* LD E, n */ 162 E = readb(PC++); 163 delay(7); 164 break; 165 case 0x1F: /* RRA */ 166 rra; 167 delay(4); 168 break; 169 170 case 0x20: /* JR NZ, $+n */ 171 offs = (int) (signed char) readb(PC++); 172 if (!(F & FLAG_Z)) { 173 WZ = PC + offs; 174 PC = WZ; 175 delay(12); 176 } 177 else 178 delay(7); 179 break; 180 case 0x21: /* LD HL, nn */ 181 HL = readw(PC); 182 PC += 2; 183 delay(10); 184 break; 185 case 0x22: /* LD (nn), HL */ 186 WZ = readw(PC); 187 PC += 2; 188 writew(WZ++, HL); 189 delay(16); 190 break; 191 case 0x23: /* INC HL */ 192 HL++; 193 delay(6); 194 break; 195 case 0x24: /* INC H */ 196 inc(H); 197 delay(4); 198 break; 199 case 0x25: /* DEC H */ 200 dec(H); 201 delay(4); 202 break; 203 case 0x26: /* LD H, n */ 204 H = readb(PC++); 205 delay(7); 206 break; 207 case 0x27: /* DAA */ 208 daa; 209 delay(4); 210 break; 211 212 case 0x28: /* JR Z, $+n */ 213 offs = (int) (signed char) readb(PC++); 214 if (F & FLAG_Z) { 215 WZ = PC + offs; 216 PC = WZ; 217 delay(12); 218 } 219 else 220 delay(7); 221 break; 222 case 0x29: /* ADD HL, HL */ 223 WZ = HL + 1; 224 add16(HLw, HLw); 225 delay(11); 226 break; 227 case 0x2A: /* LD HL, (nn) */ 228 WZ = readw(PC); 229 PC += 2; 230 HL = readw(WZ++); 231 delay(16); 232 break; 233 case 0x2B: /* DEC HL */ 234 HL--; 235 delay(6); 236 break; 237 case 0x2C: /* INC L */ 238 inc(L); 239 delay(4); 240 break; 241 case 0x2D: /* DEC L */ 242 dec(L); 243 delay(4); 244 break; 245 case 0x2E: /* LD L,n */ 246 L = readb(PC++); 247 delay(7); 248 break; 249 case 0x2F: /* CPL */ 250 cpl(A); 251 delay(4); 252 break; 253 254 case 0x30: /* JR NC, $+n */ 255 offs = (int) (signed char) readb(PC++); 256 if (!(F & FLAG_C)) { 257 WZ = PC + offs; 258 PC = WZ; 259 delay(12); 260 } 261 else 262 delay(7); 263 break; 264 case 0x31: /* LD SP, nn */ 265 SP = readw(PC); 266 PC += 2; 267 delay(10); 268 break; 269 case 0x32: /* LD (nn), A */ 270 tmp2 = readw(PC); 271 PC += 2; 272 writeb(tmp2, A); 273 W = A; /* is this really correct?! */ 274 delay(13); 275 break; 276 case 0x33: /* INC SP */ 277 SP++; 278 delay(6); 279 break; 280 case 0x34: /* INC (HL) */ 281 tmp1 = readb(HL); 282 inc(tmp1); 283 writeb(HL, tmp1); 284 delay(11); 285 break; 286 case 0x35: /* DEC (HL) */ 287 tmp1 = readb(HL); 288 dec(tmp1); 289 writeb(HL, tmp1); 290 delay(11); 291 break; 292 case 0x36: /* LD (HL), n */ 293 tmp1 = readb(PC++); 294 writeb(HL, tmp1); 295 delay(10); 296 break; 297 case 0x37: /* SCF */ 298 F |= FLAG_C; 299 delay(4); 300 break; 301 case 0x38: /* JR C, $+n */ 302 offs = (int) (signed char) readb(PC++); 303 if (F & FLAG_C) { 304 WZ = PC + offs; 305 PC = WZ; 306 delay(12); 307 } 308 else 309 delay(7); 310 break; 311 case 0x39: /* ADD HL, SP */ 312 WZ = HL + 1; 313 add16(HLw, SPw); 314 delay(11); 315 break; 316 case 0x3A: /* LD A, (nn) */ 317 WZ = readw(PC); 318 PC += 2; 319 A = readb(WZ++); 320 delay(13); 321 break; 322 case 0x3B: /* DEC SP */ 323 SP--; 324 delay(6); 325 break; 326 case 0x3C: /* INC A */ 327 inc(A); 328 delay(4); 329 break; 330 case 0x3D: /* DEC A */ 331 dec(A); 332 delay(4); 333 break; 334 case 0x3E: /* LD A, n */ 335 A = readb(PC++); 336 delay(7); 337 break; 338 case 0x3F: /* CCF */ 339 F ^= FLAG_C; 340 delay(4); 341 break; 342 343 case 0x40: B = B; delay(4); break; 344 case 0x41: B = C; delay(4); break; 345 case 0x42: B = D; delay(4); break; 346 case 0x43: B = E; delay(4); break; 347 case 0x44: B = H; delay(4); break; 348 case 0x45: B = L; delay(4); break; 349 case 0x46: B = readb(HL); delay(7); break; 350 case 0x47: B = A; delay(4); break; 351 case 0x48: C = B; delay(4); break; 352 case 0x49: C = C; delay(4); break; 353 case 0x4A: C = D; delay(4); break; 354 case 0x4B: C = E; delay(4); break; 355 case 0x4C: C = H; delay(4); break; 356 case 0x4D: C = L; delay(4); break; 357 case 0x4E: C = readb(HL); delay(7); break; 358 case 0x4F: C = A; delay(4); break; 359 case 0x50: D = B; delay(4); break; 360 case 0x51: D = C; delay(4); break; 361 case 0x52: D = D; delay(4); break; 362 case 0x53: D = E; delay(4); break; 363 case 0x54: D = H; delay(4); break; 364 case 0x55: D = L; delay(4); break; 365 case 0x56: D = readb(HL); delay(7); break; 366 case 0x57: D = A; delay(4); break; 367 case 0x58: E = B; delay(4); break; 368 case 0x59: E = C; delay(4); break; 369 case 0x5A: E = D; delay(4); break; 370 case 0x5B: E = E; delay(4); break; 371 case 0x5C: E = H; delay(4); break; 372 case 0x5D: E = L; delay(4); break; 373 case 0x5E: E = readb(HL); delay(7); break; 374 case 0x5F: E = A; delay(4); break; 375 case 0x60: H = B; delay(4); break; 376 case 0x61: H = C; delay(4); break; 377 case 0x62: H = D; delay(4); break; 378 case 0x63: H = E; delay(4); break; 379 case 0x64: H = H; delay(4); break; 380 case 0x65: H = L; delay(4); break; 381 case 0x66: H = readb(HL); delay(7); break; 382 case 0x67: H = A; delay(4); break; 383 case 0x68: L = B; delay(4); break; 384 case 0x69: L = C; delay(4); break; 385 case 0x6A: L = D; delay(4); break; 386 case 0x6B: L = E; delay(4); break; 387 case 0x6C: L = H; delay(4); break; 388 case 0x6D: L = L; delay(4); break; 389 case 0x6E: L = readb(HL); delay(7); break; 390 case 0x6F: L = A; delay(4); break; 391 case 0x70: writeb(HL, B); delay(7); break; 392 case 0x71: writeb(HL, C); delay(7); break; 393 case 0x72: writeb(HL, D); delay(7); break; 394 case 0x73: writeb(HL, E); delay(7); break; 395 case 0x74: writeb(HL, H); delay(7); break; 396 case 0x75: writeb(HL, L); delay(7); break; 397 case 0x76: delay(4); break; 398 case 0x77: writeb(HL, A); delay(7); break; 399 case 0x78: A = B; delay(4); break; 400 case 0x79: A = C; delay(4); break; 401 case 0x7A: A = D; delay(4); break; 402 case 0x7B: A = E; delay(4); break; 403 case 0x7C: A = H; delay(4); break; 404 case 0x7D: A = L; delay(4); break; 405 case 0x7E: A = readb(HL); delay(7); break; 406 case 0x7F: A = A; delay(4); break; 407 408 case 0x80: add8(A, B); delay(4); break; 409 case 0x81: add8(A, C); delay(4); break; 410 case 0x82: add8(A, D); delay(4); break; 411 case 0x83: add8(A, E); delay(4); break; 412 case 0x84: add8(A, H); delay(4); break; 413 case 0x85: add8(A, L); delay(4); break; 414 case 0x86: add8(A, readb(HL)); delay(7); break; 415 case 0x87: add8(A, A); delay(4); break; 416 case 0x88: adc8(A, B); delay(4); break; 417 case 0x89: adc8(A, C); delay(4); break; 418 case 0x8A: adc8(A, D); delay(4); break; 419 case 0x8B: adc8(A, E); delay(4); break; 420 case 0x8C: adc8(A, H); delay(4); break; 421 case 0x8D: adc8(A, L); delay(4); break; 422 case 0x8E: adc8(A, readb(HL)); delay(7); break; 423 case 0x8F: adc8(A, A); delay(4); break; 424 case 0x90: sub8(A, B); delay(4); break; 425 case 0x91: sub8(A, C); delay(4); break; 426 case 0x92: sub8(A, D); delay(4); break; 427 case 0x93: sub8(A, E); delay(4); break; 428 case 0x94: sub8(A, H); delay(4); break; 429 case 0x95: sub8(A, L); delay(4); break; 430 case 0x96: sub8(A, readb(HL)); delay(7); break; 431 case 0x97: sub8(A, A); delay(4); break; 432 case 0x98: sbc8(A, B); delay(4); break; 433 case 0x99: sbc8(A, C); delay(4); break; 434 case 0x9A: sbc8(A, D); delay(4); break; 435 case 0x9B: sbc8(A, E); delay(4); break; 436 case 0x9C: sbc8(A, H); delay(4); break; 437 case 0x9D: sbc8(A, L); delay(4); break; 438 case 0x9E: sbc8(A, readb(HL)); delay(7); break; 439 case 0x9F: sbc8(A, A); delay(4); break; 440 case 0xA0: and(A, B); delay(4); break; 441 case 0xA1: and(A, C); delay(4); break; 442 case 0xA2: and(A, D); delay(4); break; 443 case 0xA3: and(A, E); delay(4); break; 444 case 0xA4: and(A, H); delay(4); break; 445 case 0xA5: and(A, L); delay(4); break; 446 case 0xA6: and(A, readb(HL)); delay(7); break; 447 case 0xA7: and(A, A); delay(4); break; 448 case 0xA8: xor(A, B); delay(4); break; 449 case 0xA9: xor(A, C); delay(4); break; 450 case 0xAA: xor(A, D); delay(4); break; 451 case 0xAB: xor(A, E); delay(4); break; 452 case 0xAC: xor(A, H); delay(4); break; 453 case 0xAD: xor(A, L); delay(4); break; 454 case 0xAE: xor(A, readb(HL)); delay(7); break; 455 case 0xAF: xor(A, A); delay(4); break; 456 case 0xB0: or(A, B); delay(4); break; 457 case 0xB1: or(A, C); delay(4); break; 458 case 0xB2: or(A, D); delay(4); break; 459 case 0xB3: or(A, E); delay(4); break; 460 case 0xB4: or(A, H); delay(4); break; 461 case 0xB5: or(A, L); delay(4); break; 462 case 0xB6: or(A, readb(HL)); delay(7); break; 463 case 0xB7: or(A, A); delay(4); break; 464 case 0xB8: cp(A, B); delay(4); break; 465 case 0xB9: cp(A, C); delay(4); break; 466 case 0xBA: cp(A, D); delay(4); break; 467 case 0xBB: cp(A, E); delay(4); break; 468 case 0xBC: cp(A, H); delay(4); break; 469 case 0xBD: cp(A, L); delay(4); break; 470 case 0xBE: cp(A, readb(HL)); delay(7); break; 471 case 0xBF: cp(A, A); delay(4); break; 472 473 case 0xC0: /* RET NZ */ 474 if (!(F & FLAG_Z)) { 475 pop(WZ); 476 PC = WZ; 477 delay(11); 478 } 479 else 480 delay(5); 481 break; 482 case 0xC1: /* POP BC */ 483 pop(BC); 484 delay(10); 485 break; 486 case 0xC2: /* JP NZ, nn */ 487 WZ = readw(PC); 488 if (!(F & FLAG_Z)) 489 PC = WZ; 490 else 491 PC += 2; 492 delay(10); 493 break; 494 case 0xC3: /* JP nn */ 495 WZ = readw(PC); 496 PC = WZ; 497 delay(10); 498 break; 499 case 0xC4: /* CALL NZ, nn */ 500 WZ = readw(PC); 501 PC += 2; 502 if (!(F & FLAG_Z)) { 503 push(PC); 504 PC = WZ; 505 delay(17); 506 } 507 else 508 delay(10); 509 break; 510 case 0xC5: /* PUSH BC */ 511 push(BC); 512 delay(11); 513 break; 514 case 0xC6: /* ADD A, n */ 515 add8(A, readb(PC++)); 516 delay(7); 517 break; 518 case 0xC7: /* RST 00h */ 519 /* FIXME: I have not tested whether RST affects WZ */ 520 push(PC); 521 PC = 0x0000; 522 delay(11); 523 break; 524 525 case 0xC8: /* RET Z */ 526 if (F & FLAG_Z) { 527 pop(WZ); 528 PC = WZ; 529 delay(11); 530 } 531 else 532 delay(5); 533 break; 534 case 0xC9: /* RET */ 535 pop(WZ); 536 PC = WZ; 537 delay(10); 538 break; 539 case 0xCA: /* JP Z, nn */ 540 WZ = readw(PC); 541 if (F & FLAG_Z) 542 PC = WZ; 543 else 544 PC += 2; 545 delay(10); 546 break; 547 548 case 0xCB: 549 op = readb_m1(PC++); 550 goto opcode_cb; 551 552 case 0xCC: /* CALL Z, nn */ 553 WZ = readw(PC); 554 PC += 2; 555 if (F & FLAG_Z) { 556 push(PC); 557 PC = WZ; 558 delay(17); 559 } 560 else 561 delay(10); 562 break; 563 case 0xCD: /* CALL nn */ 564 WZ = readw(PC); 565 PC += 2; 566 push(PC); 567 PC = WZ; 568 delay(17); 569 break; 570 case 0xCE: /* ADC A, n */ 571 adc8(A, readb(PC++)); 572 delay(7); 573 break; 574 case 0xCF: /* RST 08h */ 575 push(PC); 576 PC = 0x0008; 577 delay(11); 578 break; 579 580 case 0xD0: /* RET NC */ 581 if (!(F & FLAG_C)) { 582 pop(WZ); 583 PC = WZ; 584 delay(11); 585 } 586 else 587 delay(5); 588 break; 589 case 0xD1: /* POP DE */ 590 pop(DE); 591 delay(10); 592 break; 593 case 0xD2: /* JP NC, nn */ 594 WZ = readw(PC); 595 if (!(F & FLAG_C)) 596 PC = WZ; 597 else 598 PC += 2; 599 delay(10); 600 break; 601 case 0xD3: /* OUT (n), A */ 602 W = A; 603 Z = readb(PC++); 604 delay(11); 605 output(WZ, A); 606 break; 607 case 0xD4: /* CALL NC, nn */ 608 WZ = readw(PC); 609 PC += 2; 610 if (!(F & FLAG_C)) { 611 push(PC); 612 PC = WZ; 613 delay(17); 614 } 615 else 616 delay(10); 617 break; 618 case 0xD5: /* PUSH DE */ 619 push(DE); 620 delay(11); 621 break; 622 case 0xD6: /* SUB n */ 623 sub8(A, readb(PC++)); 624 delay(7); 625 break; 626 case 0xD7: /* RST 10h */ 627 push(PC); 628 PC = 0x0010; 629 delay(11); 630 break; 631 632 case 0xD8: /* RET C */ 633 if (F & FLAG_C) { 634 pop(WZ); 635 PC = WZ; 636 delay(11); 637 } 638 else 639 delay(5); 640 break; 641 case 0xD9: /* EXX */ 642 ex(BC, BC2); 643 ex(DE, DE2); 644 ex(HL, HL2); 645 ex(WZ, WZ2); 646 delay(4); 647 break; 648 case 0xDA: /* JP C, nn */ 649 WZ = readw(PC); 650 if (F & FLAG_C) 651 PC = WZ; 652 else 653 PC += 2; 654 delay(10); 655 break; 656 case 0xDB: /* IN A, (n) */ 657 W = A; 658 Z = readb(PC++); 659 delay(11); 660 A = input(WZ); 661 break; 662 case 0xDC: /* CALL C, nn */ 663 WZ = readw(PC); 664 PC += 2; 665 if (F & FLAG_C) { 666 push(PC); 667 PC = WZ; 668 delay(17); 669 } 670 else 671 delay(10); 672 break; 673 674 case 0xDD: 675 op = readb_m1(PC++); 676 delay(4); 677 goto opcode_dd; 678 679 case 0xDE: /* SBC A, n */ 680 sbc8(A, readb(PC++)); 681 delay(7); 682 break; 683 case 0xDF: /* RST 18h */ 684 push(PC); 685 PC = 0x0018; 686 delay(11); 687 break; 688 689 case 0xE0: /* RET PO */ 690 if (!(F & FLAG_P)) { 691 pop(WZ); 692 PC = WZ; 693 delay(11); 694 } 695 else 696 delay(5); 697 break; 698 case 0xE1: /* POP HL */ 699 pop(HL); 700 delay(10); 701 break; 702 case 0xE2: /* JP PO, nn */ 703 WZ = readw(PC); 704 if (!(F & FLAG_P)) 705 PC = WZ; 706 else 707 PC += 2; 708 delay(10); 709 break; 710 case 0xE3: /* EX (SP), HL */ 711 WZ = readw(SP); 712 writew(SP, HL); 713 HL = WZ; 714 delay(19); 715 break; 716 case 0xE4: /* CALL PO, nn */ 717 WZ = readw(PC); 718 PC += 2; 719 if (!(F & FLAG_P)) { 720 push(PC); 721 PC = WZ; 722 delay(17); 723 } 724 else 725 delay(10); 726 break; 727 case 0xE5: /* PUSH HL */ 728 push(HL); 729 delay(11); 730 break; 731 case 0xE6: /* AND n */ 732 and(A, readb(PC++)); 733 delay(7); 734 break; 735 case 0xE7: /* RST 20h */ 736 push(PC); 737 PC = 0x0020; 738 delay(11); 739 break; 740 741 case 0xE8: /* RET PE */ 742 if (F & FLAG_P) { 743 pop(WZ); 744 PC = WZ; 745 delay(11); 746 } 747 else 748 delay(5); 749 break; 750 case 0xE9: /* JP HL */ 751 PC = HL; 752 delay(4); 753 break; 754 case 0xEA: /* JP PE, nn */ 755 WZ = readw(PC); 756 if (F & FLAG_P) 757 PC = WZ; 758 else 759 PC += 2; 760 delay(10); 761 break; 762 case 0xEB: /* EX DE,HL */ 763 ex(DE, HL); 764 delay(4); 765 break; 766 case 0xEC: /* CALL PE, nn */ 767 WZ = readw(PC); 768 PC += 2; 769 if (F & FLAG_P) { 770 push(PC); 771 PC = WZ; 772 delay(17); 773 } 774 else 775 delay(10); 776 break; 777 778 case 0xED: 779 op = readb_m1(PC++); 780 goto opcode_ed; 781 782 case 0xEE: /* XOR n */ 783 xor(A, readb(PC++)); 784 delay(7); 785 break; 786 case 0xEF: /* RST 28h */ 787 push(PC); 788 PC = 0x0028; 789 delay(11); 790 break; 791 792 case 0xF0: /* RET P */ 793 if (!(F & FLAG_S)) { 794 pop(WZ); 795 PC = WZ; 796 delay(11); 797 } 798 else 799 delay(5); 800 break; 801 case 0xF1: /* POP AF */ 802 pop(AF); 803 delay(10); 804 break; 805 case 0xF2: /* JP P, nn */ 806 WZ = readw(PC); 807 if (!(F & FLAG_S)) 808 PC = WZ; 809 else 810 PC += 2; 811 delay(10); 812 break; 813 case 0xF3: /* DI */ 814 IFF1 = IFF2 = 0; 815 delay(4); 816 break; 817 case 0xF4: /* CALL P, nn */ 818 WZ = readw(PC); 819 PC += 2; 820 if (!(F & FLAG_S)) { 821 push(PC); 822 PC = WZ; 823 delay(17); 824 } 825 else 826 delay(10); 827 break; 828 case 0xF5: /* PUSH AF */ 829 push(AF); 830 delay(11); 831 break; 832 case 0xF6: /* OR n */ 833 or(A, readb(PC++)); 834 delay(7); 835 break; 836 case 0xF7: /* RST 30h */ 837 push(PC); 838 PC = 0x0030; 839 delay(11); 840 break; 841 842 case 0xF8: /* RET M */ 843 if (F & FLAG_S) { 844 pop(WZ); 845 PC = WZ; 846 delay(11); 847 } 848 else 849 delay(5); 850 break; 851 case 0xF9: /* LD SP, HL */ 852 SP = HL; 853 delay(4); 854 break; 855 case 0xFA: /* JP M, nn */ 856 WZ = readw(PC); 857 if (F & FLAG_S) 858 PC = WZ; 859 else 860 PC += 2; 861 delay(10); 862 break; 863 case 0xFB: /* EI */ 864 IFF1 = IFF2 = 1; 865 delay(4); 866 break; 867 case 0xFC: /* CALL M, nn */ 868 WZ = readw(PC); 869 PC += 2; 870 if (F & FLAG_S) { 871 push(PC); 872 PC = WZ; 873 delay(17); 874 } 875 else 876 delay(10); 877 break; 878 879 case 0xFD: 880 op = readb_m1(PC++); 881 delay(4); 882 goto opcode_fd; 883 884 case 0xFE: /* CP n */ 885 cp(A, readb(PC++)); 886 delay(7); 887 break; 888 case 0xFF: /* RST 38h */ 889 push(PC); 890 PC = 0x0038; 891 delay(11); 892 break; 893 } 894