git.gag.com Git - fw/sdcc/blob - sim/ucsim/z80.src/inst.cc

   1 /*
   2  * Simulator of microcontrollers (inst.cc)
   3  *
   4  * some z80 code base from Karl Bongers karl@turbobit.com
   5  *
   6  * Copyright (C) 1999,99 Drotos Daniel, Talker Bt.
   7  *
   8  * To contact author send email to drdani@mazsola.iit.uni-miskolc.hu
   9  *
  10  */
  11
  12 /* This file is part of microcontroller simulator: ucsim.
  13
  14 UCSIM is free software; you can redistribute it and/or modify
  15 it under the terms of the GNU General Public License as published by
  16 the Free Software Foundation; either version 2 of the License, or
  17 (at your option) any later version.
  18
  19 UCSIM is distributed in the hope that it will be useful,
  20 but WITHOUT ANY WARRANTY; without even the implied warranty of
  21 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  22 GNU General Public License for more details.
  23
  24 You should have received a copy of the GNU General Public License
  25 along with UCSIM; see the file COPYING.  If not, write to the Free
  26 Software Foundation, 59 Temple Place - Suite 330, Boston, MA
  27 02111-1307, USA. */
  28 /*@1@*/
  29
  30 #include "ddconfig.h"
  31
  32 // local
  33 #include "z80cl.h"
  34 #include "regsz80.h"
  35 #include "z80mac.h"
  36
  37
  38 /*
  39  * No Instruction
  40  * NOP
  41  * 0000 0000 0000 0000
  42  *----------------------------------------------------------------------------
  43  */
  44
  45 int
  46 cl_z80::inst_nop(t_mem code)
  47 {
  48   return(resGO);
  49 }
  50
  51 /*
  52  * Load Instruction
  53  * LD
  54  *
  55  *----------------------------------------------------------------------------
  56  */
  57
  58 int
  59 cl_z80::inst_ld(t_mem code)
  60 {
  61   switch(code) {
  62     case 1:  // LD BC,nnnn
  63       regs.BC = fetch2();
  64     break;
  65     case 2: // LD (BC),A
  66       store1(regs.BC, regs.A);
  67     break;
  68     case 6: // LD B,nn
  69       regs.bc.h = fetch();
  70     break;
  71     case 0xa: // LD A,(BC)
  72       regs.A = get1(regs.BC);
  73     break;
  74     case 0x0e: // LD C,nn
  75       regs.bc.l = fetch();
  76     break;
  77     case 0x11: // LD DE,nnnn
  78       regs.DE = fetch2();
  79     break;
  80     case 0x12: // LD (DE),A
  81       store1(regs.DE, regs.A);
  82     break;
  83     case 0x16: // LD D,nn
  84       regs.de.h = fetch();
  85     break;
  86     case 0x1A: // LD A,(DE)
  87       regs.A = get1(regs.DE);
  88     break;
  89     case 0x1E: // LD E,nn
  90       regs.de.l = fetch();
  91     break;
  92     case 0x21: // LD HL,nnnn
  93         regs.HL = fetch2();
  94     break;
  95     case 0x22: // LD (nnnn),HL
  96       {
  97          unsigned short tw;
  98          tw = fetch2();
  99          store2(tw, regs.HL);
 100       }
 101     break;
 102     case 0x26: // LD H,nn
 103       regs.hl.h = fetch();
 104     break;
 105     case 0x2A: // LD HL,(nnnn)
 106       {
 107          unsigned short tw;
 108          tw = fetch2();
 109          regs.HL = get2(tw);
 110       }
 111     break;
 112     case 0x2E: // LD L,nn
 113       regs.hl.l = fetch();
 114     break;
 115     case 0x31: // LD SP,nnnn
 116       regs.SP = fetch2();
 117     break;
 118     case 0x32: // LD (nnnn),A
 119       {
 120          unsigned short tw;
 121          tw = fetch2();
 122          store1(tw, regs.A);
 123       }
 124     break;
 125     case 0x36: // LD (HL),nn
 126       store1(regs.HL, fetch());
 127     break;
 128     case 0x3A: // LD A,(nnnn)
 129       regs.A = get1(fetch2());
 130     break;
 131     case 0x3E: // LD A,nn
 132       regs.A = fetch();
 133     break;
 134     case 0x40: // LD B,B
 135     break;
 136     case 0x41: // LD B,C
 137       regs.bc.h = regs.bc.l;
 138     break;
 139     case 0x42: // LD B,D
 140       regs.bc.h = regs.de.h;
 141     break;
 142     case 0x43: // LD B,E
 143       regs.bc.h = regs.de.l;
 144     break;
 145     case 0x44: // LD B,H
 146       regs.bc.h = regs.hl.h;
 147     break;
 148     case 0x45: // LD B,L
 149       regs.bc.h = regs.hl.l;
 150     break;
 151     case 0x46: // LD B,(HL)
 152       regs.bc.h = get1(regs.HL);
 153     break;
 154     case 0x47: // LD B,A
 155       regs.bc.h = regs.A;
 156     break;
 157     case 0x48: // LD C,B
 158       regs.bc.l = regs.bc.h;
 159     break;
 160     case 0x49: // LD C,C
 161     break;
 162     case 0x4A: // LD C,D
 163       regs.bc.l = regs.de.h;
 164     break;
 165     case 0x4B: // LD C,E
 166       regs.bc.l = regs.de.l;
 167     break;
 168     case 0x4C: // LD C,H
 169       regs.bc.l = regs.hl.h;
 170     break;
 171     case 0x4D: // LD C,L
 172       regs.bc.l = regs.hl.l;
 173     break;
 174     case 0x4E: // LD C,(HL)
 175       regs.bc.l = get1(regs.HL);
 176     break;
 177     case 0x4F: // LD C,A
 178       regs.bc.l = regs.A;
 179     break;
 180     case 0x50: // LD D,B
 181       regs.de.h = regs.bc.h;
 182     break;
 183     case 0x51: // LD D,C
 184       regs.de.h = regs.bc.l;
 185     break;
 186     case 0x52: // LD D,D
 187     break;
 188     case 0x53: // LD D,E
 189       regs.de.h = regs.de.l;
 190     break;
 191     case 0x54: // LD D,H
 192       regs.de.h = regs.hl.h;
 193     break;
 194     case 0x55: // LD D,L
 195       regs.de.h = regs.hl.l;
 196     break;
 197     case 0x56: // LD D,(HL)
 198       regs.de.h = get1(regs.HL);
 199     break;
 200     case 0x57: // LD D,A
 201       regs.de.h = regs.A;
 202     break;
 203     case 0x58: // LD E,B
 204       regs.de.l = regs.bc.h;
 205     break;
 206     case 0x59: // LD E,C
 207       regs.de.l = regs.bc.l;
 208     break;
 209     case 0x5A: // LD E,D
 210       regs.de.l = regs.de.h;
 211     break;
 212     case 0x5B: // LD E,E
 213     break;
 214     case 0x5C: // LD E,H
 215       regs.de.l = regs.hl.h;
 216     break;
 217     case 0x5D: // LD E,L
 218       regs.de.l = regs.hl.l;
 219     break;
 220     case 0x5E: // LD E,(HL)
 221       regs.de.l = get1(regs.HL);
 222     break;
 223     case 0x5F: // LD E,A
 224       regs.de.l = regs.A;
 225     break;
 226     case 0x60: // LD H,B
 227       regs.hl.h = regs.bc.h;
 228     break;
 229     case 0x61: // LD H,C
 230       regs.hl.h = regs.bc.l;
 231     break;
 232     case 0x62: // LD H,D
 233       regs.hl.h = regs.de.h;
 234     break;
 235     case 0x63: // LD H,E
 236       regs.hl.h = regs.de.l;
 237     break;
 238     case 0x64: // LD H,H
 239       regs.hl.h = regs.hl.h;
 240     break;
 241     case 0x65: // LD H,L
 242       regs.hl.h = regs.hl.l;
 243     break;
 244     case 0x66: // LD H,(HL)
 245       regs.hl.h = get1(regs.HL);
 246     break;
 247     case 0x67: // LD H,A
 248       regs.hl.h = regs.A;
 249     break;
 250     case 0x68: // LD L,B
 251       regs.hl.l = regs.bc.h;
 252     break;
 253     case 0x69: // LD L,C
 254       regs.hl.l = regs.bc.l;
 255     break;
 256     case 0x6A: // LD L,D
 257       regs.hl.l = regs.de.h;
 258     break;
 259     case 0x6B: // LD L,E
 260       regs.hl.l = regs.de.l;
 261     break;
 262     case 0x6C: // LD L,H
 263       regs.hl.l = regs.hl.h;
 264     break;
 265     case 0x6D: // LD L,L
 266     break;
 267     case 0x6E: // LD L,(HL)
 268       regs.hl.l = get1(regs.HL);
 269     break;
 270     case 0x6F: // LD L,A
 271       regs.hl.l = regs.A;
 272     break;
 273     case 0x70: // LD (HL),B
 274       store1(regs.HL, regs.bc.h);
 275     break;
 276     case 0x71: // LD (HL),C
 277       store1(regs.HL, regs.bc.l);
 278     break;
 279     case 0x72: // LD (HL),D
 280       store1(regs.HL, regs.de.h);
 281     break;
 282     case 0x73: // LD (HL),E
 283       store1(regs.HL, regs.de.l);
 284     break;
 285     case 0x74: // LD (HL),H
 286       store1(regs.HL, regs.hl.h);
 287     break;
 288     case 0x75: // LD (HL),L
 289       store1(regs.HL, regs.hl.l);
 290     break;
 291     case 0x76: // HALT
 292     return(resHALT);
 293
 294     case 0x77: // LD (HL),A
 295       store1(regs.HL, regs.A);
 296     break;
 297     case 0x78: // LD A,B
 298       regs.A = regs.bc.h;
 299     break;
 300     case 0x79: // LD A,C
 301       regs.A = regs.bc.l;
 302     break;
 303     case 0x7A: // LD A,D
 304       regs.A = regs.de.h;
 305     break;
 306     case 0x7B: // LD A,E
 307       regs.A = regs.de.l;
 308     break;
 309     case 0x7C: // LD A,H
 310       regs.A = regs.hl.h;
 311     break;
 312     case 0x7D: // LD A,L
 313       regs.A = regs.hl.l;
 314     break;
 315     case 0x7E: // LD A,(HL)
 316       regs.A = get1(regs.HL);
 317     break;
 318     case 0x7F: // LD A,A
 319     break;
 320     case 0xF9: // LD SP,HL
 321       regs.SP = regs.HL;
 322     break;
 323     default:
 324       return(resINV_INST);
 325     break;
 326   }
 327   return(resGO);
 328 }
 329
 330 int
 331 cl_z80::inst_inc(t_mem code)
 332 {
 333   switch(code) {
 334     case 0x03: // INC BC
 335       ++regs.BC;
 336     break;
 337     case 0x04: // INC B
 338       inc(regs.bc.h);
 339     break;
 340     case 0x0C: // INC C
 341       inc(regs.bc.l);
 342     break;
 343     case 0x13: // INC DE
 344       ++regs.DE;
 345     break;
 346     case 0x14: // INC D
 347       inc(regs.de.h);
 348     break;
 349     case 0x1C: // INC E
 350       inc(regs.de.l);
 351     break;
 352     case 0x23: // INC HL
 353       ++regs.HL;
 354     break;
 355     case 0x24: // INC H
 356       inc(regs.hl.h);
 357     break;
 358     case 0x2C: // INC L
 359       inc(regs.hl.l);
 360     break;
 361     case 0x33: // INC SP
 362       ++regs.SP;
 363     break;
 364     case 0x34: // INC (HL)
 365       {unsigned char t=get1(regs.HL);
 366          inc(t);
 367          store1(regs.HL, t);
 368       }
 369     break;
 370     case 0x3C: // INC A
 371       inc(regs.A);
 372     break;
 373     default:
 374       return(resINV_INST);
 375     break;
 376   }
 377   return(resGO);
 378 }
 379
 380 int
 381 cl_z80::inst_dec(t_mem code)
 382 {
 383   switch(code) {
 384     case 0x05: // DEC B
 385       dec(regs.bc.h);
 386     break;
 387     case 0x0B: // DEC BC
 388       --regs.BC;
 389     break;
 390     case 0x0D: // DEC C
 391       dec(regs.bc.l);
 392     break;
 393     case 0x15: // DEC D
 394       dec(regs.de.h);
 395     break;
 396     case 0x1B: // DEC DE
 397       --regs.DE;
 398     break;
 399     case 0x1D: // DEC E
 400       dec(regs.de.l);
 401     break;
 402     case 0x25: // DEC H
 403       dec(regs.hl.h);
 404     break;
 405     case 0x2B: // DEC HL
 406       --regs.HL;
 407     break;
 408     case 0x2D: // DEC L
 409       dec(regs.hl.l);
 410     break;
 411     case 0x35: // DEC (HL)
 412       {unsigned char t=get1(regs.HL);
 413          dec(t);
 414          store1(regs.HL, t);
 415       }
 416     break;
 417     case 0x3B: // DEC SP
 418       --regs.SP;
 419     break;
 420     case 0x3D: // DEC A
 421       dec(regs.A);
 422     break;
 423     default:
 424       return(resINV_INST);
 425     break;
 426   }
 427   return(resGO);
 428 }
 429
 430 int
 431 cl_z80::inst_rlca(t_mem code)
 432 {
 433   rlc_byte(regs.A);
 434
 435   return(resGO);
 436 }
 437
 438 int
 439 cl_z80::inst_rrca(t_mem code)
 440 {
 441   rrc_byte(regs.A);
 442   return(resGO);
 443 }
 444
 445 int
 446 cl_z80::inst_ex(t_mem code)
 447 {
 448   /* 0x08 // EX AF,AF' */
 449   unsigned char tmp;
 450   TYPE_UWORD tempw;
 451
 452   switch (code) {
 453     case 0x08: // EX AF,AF'
 454       tmp = regs.aA;
 455       regs.aA = regs.A;
 456       regs.A = tmp;
 457
 458       tmp = regs.aF;
 459       regs.aF = regs.F;
 460       regs.F = tmp;
 461     break;
 462
 463     case 0xE3: // EX (SP),HL
 464       tempw = regs.HL;
 465       regs.HL = get2(regs.SP);
 466       store2(regs.SP, tempw);
 467     break;
 468
 469     case 0xEB: // EX DE,HL
 470       tempw = regs.DE;
 471       regs.DE = regs.HL;
 472       regs.HL = tempw;
 473     break;
 474
 475     default:
 476       return(resINV_INST);
 477     break;
 478   }
 479
 480   return(resGO);
 481 }
 482
 483 int
 484 cl_z80::inst_add(t_mem code)
 485 {
 486 #define add_HL_Word(wr) { \
 487       unsigned int tmp; \
 488       regs.F &= ~(BIT_ALL);  /* clear these */ \
 489       tmp = (unsigned int)regs.HL + (unsigned int)(wr); \
 490       if (tmp > 0xffff) regs.F |= BIT_C; \
 491       regs.HL = (unsigned short) tmp; }
 492
 493   switch(code) {
 494     case 0x09: // ADD HL,BC
 495       add_HL_Word(regs.BC);
 496     break;
 497     case 0x19: // ADD HL,DE
 498       add_HL_Word(regs.DE);
 499     break;
 500     case 0x29: // ADD HL,HL
 501       add_HL_Word(regs.HL);
 502     break;
 503     case 0x39: // ADD HL,SP
 504       add_HL_Word(regs.SP);
 505     break;
 506
 507     case 0x80: // ADD A,B
 508       add_A_bytereg(regs.bc.h);
 509     break;
 510     case 0x81: // ADD A,C
 511       add_A_bytereg(regs.bc.l);
 512     break;
 513     case 0x82: // ADD A,D
 514       add_A_bytereg(regs.de.h);
 515     break;
 516     case 0x83: // ADD A,E
 517       add_A_bytereg(regs.de.l);
 518     break;
 519     case 0x84: // ADD A,H
 520       add_A_bytereg(regs.hl.h);
 521     break;
 522     case 0x85: // ADD A,L
 523       add_A_bytereg(regs.hl.l);
 524     break;
 525
 526     case 0x86: // ADD A,(HL)
 527       { unsigned char utmp;
 528         utmp = get1(regs.HL);
 529         add_A_bytereg(utmp);
 530       }
 531     break;
 532
 533     case 0x87: // ADD A,A
 534       add_A_bytereg(regs.A);
 535     break;
 536
 537     case 0xC6: // ADD A,nn
 538       {
 539         unsigned char utmp1;
 540         utmp1 = fetch();
 541         add_A_bytereg(utmp1);
 542       }
 543     break;
 544
 545     default:
 546       return(resINV_INST);
 547     break;
 548   }
 549
 550   return(resGO);
 551 }
 552
 553 int
 554 cl_z80::inst_djnz(t_mem code)
 555 {
 556   signed char j;
 557
 558   // 0x10: DJNZ dd
 559
 560   j = fetch1();
 561   if ((--regs.bc.h != 0)) {
 562     PC += j;
 563   } else {
 564   }
 565   return(resGO);
 566 }
 567
 568 int
 569 cl_z80::inst_rra(t_mem code)
 570 {
 571   rr_byte(regs.A);
 572   return(resGO);
 573 }
 574
 575 int
 576 cl_z80::inst_rla(t_mem code)
 577 {
 578   rl_byte(regs.A);
 579   return(resGO);
 580 }
 581
 582 int
 583 cl_z80::inst_jr(t_mem code)
 584 {
 585   signed char j;
 586
 587   j = fetch1();
 588   switch(code) {
 589     case 0x18: // JR dd
 590       PC += j;
 591     break;
 592     case 0x20: // JR NZ,dd
 593       if (!(regs.F & BIT_Z)) {
 594         PC += j;
 595       }
 596     break;
 597     case 0x28: // JR Z,dd
 598       if ((regs.F & BIT_Z)) {
 599         PC += j;
 600       }
 601     break;
 602     case 0x30: // JR NC,dd
 603       if (!(regs.F & BIT_C)) {
 604         PC += j;
 605       }
 606     break;
 607     case 0x38: // JR C,dd
 608       if ((regs.F & BIT_C)) {
 609         PC += j;
 610       }
 611     break;
 612     default:
 613       return(resINV_INST);
 614     break;
 615   }
 616   return(resGO);
 617 }
 618
 619 int
 620 cl_z80::inst_daa(t_mem code)
 621 {
 622   /************* from MH's z80ops.c:
 623       unsigned char incr=0, carry=cy;
 624       if((f&0x10) || (a&0x0f)>9) incr=6;
 625       if((f&1) || (a>>4)>9) incr|=0x60;
 626       if(f&2)suba(incr,0);
 627       else {
 628          if(a>0x90 && (a&15)>9)incr|=0x60;
 629          adda(incr,0);
 630       }
 631       f=((f|carry)&0xfb);
 632    ********/
 633   /* I have not tried to understand this archaic bit of BCD logic(kpb),
 634      taking the lazy way out for now and just transcribing MH's code.
 635    */
 636   unsigned char incr;
 637   if ((regs.F & BIT_A) || ((regs.A & 0x0f) > 9))
 638        incr = 6;
 639   else incr = 0;
 640
 641   if ((regs.F & BIT_C) || ((regs.A & 0xf0) > 0x90))
 642     incr |= 0x60;
 643
 644   if (regs.F & BIT_N) {  /* not addition */
 645     sub_A_bytereg(incr);
 646   } else {
 647      if ((regs.A > 0x90) && ((regs.A & 0x0f) >9)) incr |= 0x60;
 648      add_A_bytereg(incr);
 649   }
 650
 651   return(resGO);
 652 }
 653
 654 int
 655 cl_z80::inst_cpl(t_mem code)
 656 {
 657   regs.F |= (BIT_A | BIT_N);
 658   regs.A = ~regs.A;
 659   return(resGO);
 660 }
 661
 662 int
 663 cl_z80::inst_scf(t_mem code)
 664 {
 665   /* Set Carry Flag */
 666   regs.F |= BIT_C;
 667   return(resGO);
 668 }
 669
 670 int
 671 cl_z80::inst_ccf(t_mem code)
 672 {
 673   /* Compliment Carry Flag */
 674   regs.F ^= BIT_C;
 675   return(resGO);
 676 }
 677
 678 int
 679 cl_z80::inst_halt(t_mem code)
 680 {
 681   return(resHALT);
 682 }
 683
 684 int
 685 cl_z80::inst_adc(t_mem code)
 686 {
 687   switch(code) {
 688     case 0x88: // ADC A,B
 689       adc_A_bytereg(regs.bc.h);
 690     break;
 691     case 0x89: // ADC A,C
 692       adc_A_bytereg(regs.bc.l);
 693     break;
 694     case 0x8A: // ADC A,D
 695       adc_A_bytereg(regs.de.h);
 696     break;
 697     case 0x8B: // ADC A,E
 698       adc_A_bytereg(regs.de.l);
 699     break;
 700     case 0x8C: // ADC A,H
 701       adc_A_bytereg(regs.hl.h);
 702     break;
 703     case 0x8D: // ADC A,L
 704       adc_A_bytereg(regs.hl.l);
 705     break;
 706     case 0x8E: // ADC A,(HL)
 707       { unsigned char utmp;
 708         utmp = get1(regs.HL);
 709         adc_A_bytereg(utmp);
 710       }
 711     break;
 712     case 0x8F: // ADC A,A
 713       adc_A_bytereg(regs.A);
 714     break;
 715
 716     case 0xCE: // ADC A,nn
 717       { unsigned char utmp;
 718         utmp = fetch();
 719         adc_A_bytereg(utmp);
 720       }
 721     break;
 722
 723     default:
 724       return(resINV_INST);
 725     break;
 726   }
 727   return(resGO);
 728 }
 729
 730 int
 731 cl_z80::inst_sbc(t_mem code)
 732 {
 733   switch(code) {
 734     case 0x98: // SBC A,B
 735       sbc_A_bytereg(regs.bc.h);
 736     break;
 737     case 0x99: // SBC A,C
 738       sbc_A_bytereg(regs.bc.l);
 739     break;
 740     case 0x9A: // SBC A,D
 741       sbc_A_bytereg(regs.de.h);
 742     break;
 743     case 0x9B: // SBC A,E
 744       sbc_A_bytereg(regs.de.l);
 745     break;
 746     case 0x9C: // SBC A,H
 747       sbc_A_bytereg(regs.hl.h);
 748     break;
 749     case 0x9D: // SBC A,L
 750       sbc_A_bytereg(regs.hl.l);
 751     break;
 752     case 0x9E: // SBC A,(HL)
 753       { unsigned char utmp;
 754         utmp = get1(regs.HL);
 755         sbc_A_bytereg(utmp);
 756       }
 757     break;
 758     case 0x9F: // SBC A,A
 759       sbc_A_bytereg(regs.A);
 760     break;
 761     case 0xDE: // SBC A,nn
 762       { unsigned char utmp;
 763         utmp = fetch();
 764         sbc_A_bytereg(utmp);
 765       }
 766     break;
 767     default:
 768       return(resINV_INST);
 769     break;
 770   }
 771   return(resGO);
 772 }
 773
 774 int
 775 cl_z80::inst_and(t_mem code)
 776 {
 777   switch(code) {
 778     case 0xA0: // AND B
 779       and_A_bytereg(regs.bc.h);
 780     break;
 781     case 0xA1: // AND C
 782       and_A_bytereg(regs.bc.l);
 783     break;
 784     case 0xA2: // AND D
 785       and_A_bytereg(regs.de.h);
 786     break;
 787     case 0xA3: // AND E
 788       and_A_bytereg(regs.de.l);
 789     break;
 790     case 0xA4: // AND H
 791       and_A_bytereg(regs.hl.h);
 792     break;
 793     case 0xA5: // AND L
 794       and_A_bytereg(regs.hl.l);
 795     break;
 796     case 0xA6: // AND (HL)
 797       { unsigned char utmp;
 798         utmp = get1(regs.HL);
 799         and_A_bytereg(utmp);
 800       }
 801     break;
 802     case 0xA7: // AND A
 803       and_A_bytereg(regs.A);
 804     break;
 805     case 0xE6: // AND nn
 806       and_A_bytereg(fetch());
 807     break;
 808
 809     default:
 810       return(resINV_INST);
 811     break;
 812   }
 813   return(resGO);
 814 }
 815
 816 int
 817 cl_z80::inst_xor(t_mem code)
 818 {
 819   switch(code) {
 820     case 0xA8: // XOR B
 821       xor_A_bytereg(regs.bc.h);
 822     break;
 823     case 0xA9: // XOR C
 824       xor_A_bytereg(regs.bc.l);
 825     break;
 826     case 0xAA: // XOR D
 827       xor_A_bytereg(regs.de.h);
 828     break;
 829     case 0xAB: // XOR E
 830       xor_A_bytereg(regs.de.l);
 831     break;
 832     case 0xAC: // XOR H
 833       xor_A_bytereg(regs.hl.h);
 834     break;
 835     case 0xAD: // XOR L
 836       xor_A_bytereg(regs.hl.l);
 837     break;
 838     case 0xAE: // XOR (HL)
 839       { unsigned char utmp;
 840         utmp = get1(regs.HL);
 841         xor_A_bytereg(utmp);
 842       }
 843     break;
 844     case 0xAF: // XOR A
 845       xor_A_bytereg(regs.A);
 846     break;
 847     case 0xEE: // XOR nn
 848       xor_A_bytereg(fetch());
 849     break;
 850
 851     default:
 852       return(resINV_INST);
 853     break;
 854   }
 855   return(resGO);
 856 }
 857
 858 int
 859 cl_z80::inst_or(t_mem code)
 860 {
 861   switch(code) {
 862     case 0xB0: // OR B
 863       or_A_bytereg(regs.bc.h);
 864     break;
 865     case 0xB1: // OR C
 866       or_A_bytereg(regs.bc.l);
 867     break;
 868     case 0xB2: // OR D
 869       or_A_bytereg(regs.de.h);
 870     break;
 871     case 0xB3: // OR E
 872       or_A_bytereg(regs.de.l);
 873     break;
 874     case 0xB4: // OR H
 875       or_A_bytereg(regs.hl.h);
 876     break;
 877     case 0xB5: // OR L
 878       or_A_bytereg(regs.hl.l);
 879     break;
 880     case 0xB6: // OR (HL)
 881       { unsigned char utmp;
 882         utmp = get1(regs.HL);
 883         or_A_bytereg(utmp);
 884       }
 885     break;
 886     case 0xB7: // OR A
 887       or_A_bytereg(regs.A);
 888     break;
 889     case 0xF6: // OR nn
 890       or_A_bytereg(fetch());
 891     break;
 892     default:
 893       return(resINV_INST);
 894     break;
 895   }
 896   return(resGO);
 897 }
 898
 899 int
 900 cl_z80::inst_cp(t_mem code)
 901 {
 902   /* Compare with Accumulator - subtract and test, leave A unchanged */
 903   switch(code) {
 904     case 0xB8: // CP B
 905       cp_bytereg(regs.bc.h);
 906     break;
 907     case 0xB9: // CP C
 908       cp_bytereg(regs.bc.l);
 909     break;
 910     case 0xBA: // CP D
 911       cp_bytereg(regs.de.h);
 912     break;
 913     case 0xBB: // CP E
 914       cp_bytereg(regs.de.l);
 915     break;
 916     case 0xBC: // CP H
 917       cp_bytereg(regs.hl.h);
 918     break;
 919     case 0xBD: // CP L
 920       cp_bytereg(regs.hl.l);
 921     break;
 922     case 0xBE: // CP (HL)
 923       { unsigned char utmp;
 924         utmp = get1(regs.HL);
 925         cp_bytereg(utmp);
 926       }
 927     break;
 928     case 0xBF: // CP A
 929       cp_bytereg(regs.A);
 930     break;
 931     case 0xFE: // CP nn
 932       { unsigned char utmp;
 933         utmp = fetch();
 934         cp_bytereg(utmp);
 935       }
 936     break;
 937     default:
 938       return(resINV_INST);
 939     break;
 940   }
 941   return(resGO);
 942 }
 943
 944 int
 945 cl_z80::inst_rst(t_mem code)
 946 {
 947   switch(code) {
 948     case 0xC7: // RST 0
 949       push2(PC+2);
 950       PC = 0x0;
 951     break;
 952     case 0xCF: // RST 8
 953       //PC = 0x08;
 954       switch (regs.A) {
 955         case 0:
 956           ::exit(0);
 957         break;
 958
 959         case 1:
 960           //printf("PUTCHAR-----> %xH\n", regs.hl.l);
 961           putchar(regs.hl.l);
 962           fflush(stdout);
 963         break;
 964       }
 965     break;
 966     case 0xD7: // RST 10H
 967       push2(PC+2);
 968       PC = 0x10;
 969     break;
 970     case 0xDF: // RST 18H
 971       push2(PC+2);
 972       PC = 0x18;
 973     break;
 974     case 0xE7: // RST 20H
 975       push2(PC+2);
 976       PC = 0x20;
 977     break;
 978     case 0xEF: // RST 28H
 979       push2(PC+2);
 980       PC = 0x28;
 981     break;
 982     case 0xF7: // RST 30H
 983       push2(PC+2);
 984       PC = 0x30;
 985     break;
 986     case 0xFF: // RST 38H
 987       push2(PC+2);
 988       PC = 0x38;
 989     break;
 990     default:
 991       return(resINV_INST);
 992     break;
 993   }
 994   return(resGO);
 995 }
 996
 997 int
 998 cl_z80::inst_ret(t_mem code)
 999 {
1000   switch(code) {
1001     case 0xC0: // RET NZ
1002       if (!(regs.F & BIT_Z)) {
1003         pop2(PC);
1004       }
1005     break;
1006     case 0xC8: // RET Z
1007       if ((regs.F & BIT_Z)) {
1008         pop2(PC);
1009       }
1010     break;
1011     case 0xC9: // RET
1012       pop2(PC);
1013     break;
1014     case 0xD0: // RET NC
1015       if (!(regs.F & BIT_C)) {
1016         pop2(PC);
1017       }
1018     break;
1019     case 0xD8: // RET C
1020       if ((regs.F & BIT_C)) {
1021         pop2(PC);
1022       }
1023     break;
1024     case 0xE0: // RET PO
1025       if (!(regs.F & BIT_P)) {
1026         pop2(PC);
1027       }
1028     break;
1029     case 0xE8: // RET PE
1030       if ((regs.F & BIT_P)) {
1031         pop2(PC);
1032       }
1033     break;
1034     case 0xF0: // RET P
1035       if (!(regs.F & BIT_S)) {
1036         pop2(PC);
1037       }
1038     break;
1039     case 0xF8: // RET M
1040       if ((regs.F & BIT_S)) {
1041         pop2(PC);
1042       }
1043     break;
1044     default:
1045       return(resINV_INST);
1046     break;
1047   }
1048   return(resGO);
1049 }
1050
1051 int
1052 cl_z80::inst_call(t_mem code)
1053 {
1054   int jnk;
1055
1056   switch(code) {
1057     case 0xC4: // CALL NZ,nnnn
1058       if (!(regs.F & BIT_Z)) {
1059         push2(PC+2);
1060         PC = fetch2();
1061       } else {
1062         jnk = fetch2();
1063       }
1064     break;
1065     case 0xCC: // CALL Z,nnnn
1066       if (regs.F & BIT_Z) {
1067         push2(PC+2);
1068         PC = fetch2();
1069       } else {
1070         jnk = fetch2();
1071       }
1072     break;
1073     case 0xCD: // CALL nnnn
1074       push2(PC+2);
1075       PC = fetch2();
1076     break;
1077     case 0xD4: // CALL NC,nnnn
1078       if (!(regs.F & BIT_C)) {
1079         push2(PC+2);
1080         PC = fetch2();
1081       } else {
1082         jnk = fetch2();
1083       }
1084     break;
1085     case 0xDC: // CALL C,nnnn
1086       if (regs.F & BIT_C) {
1087         push2(PC+2);
1088         PC = fetch2();
1089       } else {
1090         jnk = fetch2();
1091       }
1092     break;
1093     case 0xE4: // CALL PO,nnnn
1094       if (!(regs.F & BIT_P)) {
1095         push2(PC+2);
1096         PC = fetch2();
1097       } else {
1098         jnk = fetch2();
1099       }
1100     break;
1101     case 0xEC: // CALL PE,nnnn
1102       if (regs.F & BIT_P) {
1103         push2(PC+2);
1104         PC = fetch2();
1105       } else {
1106         jnk = fetch2();
1107       }
1108     break;
1109     case 0xF4: // CALL P,nnnn
1110       if (!(regs.F & BIT_S)) {
1111         push2(PC+2);
1112         PC = fetch2();
1113       } else {
1114         jnk = fetch2();
1115       }
1116     break;
1117     case 0xFC: // CALL M,nnnn
1118       if (regs.F & BIT_S) {
1119         push2(PC+2);
1120         PC = fetch2();
1121       } else {
1122         jnk = fetch2();
1123       }
1124     break;
1125     default:
1126       return(resINV_INST);
1127     break;
1128   }
1129
1130   return(resGO);
1131 }
1132
1133 int
1134 cl_z80::inst_out(t_mem code)
1135 {
1136   return(resGO);
1137 }
1138
1139 int
1140 cl_z80::inst_push(t_mem code)
1141 {
1142   switch(code) {
1143     case 0xC5: // PUSH BC
1144       push2(regs.BC);
1145     break;
1146     case 0xD5: // PUSH DE
1147       push2(regs.DE);
1148     break;
1149     case 0xE5: // PUSH HL
1150       push2(regs.HL);
1151     break;
1152     case 0xF5: // PUSH AF
1153       push1(regs.A);
1154       push1(regs.F);
1155     break;
1156     default:
1157       return(resINV_INST);
1158     break;
1159   }
1160   return(resGO);
1161 }
1162
1163 int
1164 cl_z80::inst_exx(t_mem code)
1165 {
1166   /* case 0xD9: // EXX - swap BC,DE,HL with alternates */
1167   TYPE_UWORD tempw;
1168
1169   tempw = regs.aBC;
1170   regs.BC = regs.aBC;
1171   regs.aBC = tempw;
1172
1173   tempw = regs.aDE;
1174   regs.DE = regs.aDE;
1175   regs.aDE = tempw;
1176
1177   tempw = regs.aDE;
1178   regs.DE = regs.aDE;
1179   regs.aDE = tempw;
1180
1181   return(resGO);
1182 }
1183
1184 int
1185 cl_z80::inst_in(t_mem code)
1186 {
1187   return(resGO);
1188 }
1189
1190 int
1191 cl_z80::inst_sub(t_mem code)
1192 {
1193   switch(code) {
1194     case 0x90: // SUB B
1195       sub_A_bytereg(regs.bc.h);
1196     break;
1197     case 0x91: // SUB C
1198       sub_A_bytereg(regs.bc.l);
1199     break;
1200     case 0x92: // SUB D
1201       sub_A_bytereg(regs.de.h);
1202     break;
1203     case 0x93: // SUB E
1204       sub_A_bytereg(regs.de.l);
1205     break;
1206     case 0x94: // SUB H
1207       sub_A_bytereg(regs.hl.h);
1208     break;
1209     case 0x95: // SUB L
1210       sub_A_bytereg(regs.hl.l);
1211     break;
1212     case 0x96: // SUB (HL)
1213       { unsigned char tmp1;
1214         tmp1 = get1(regs.HL);
1215         sub_A_bytereg(tmp1);
1216       }
1217     break;
1218     case 0x97: // SUB A
1219       regs.A = 0;
1220     break;
1221     case 0xD6: // SUB nn
1222       { unsigned char tmp1;
1223         tmp1 = fetch();
1224         sub_A_bytereg(tmp1);
1225       }
1226     break;
1227     default:
1228       return(resINV_INST);
1229     break;
1230   }
1231   return(resGO);
1232 }
1233
1234 int
1235 cl_z80::inst_pop(t_mem code)
1236 {
1237   switch (code) {
1238     case 0xC1: // POP BC
1239       regs.BC = get2(regs.SP);
1240       regs.SP+=2;
1241     break;
1242     case 0xD1: // POP DE
1243       regs.DE = get2(regs.SP);
1244       regs.SP+=2;
1245     break;
1246     case 0xE1: // POP HL
1247       regs.HL = get2(regs.SP);
1248       regs.SP+=2;
1249     break;
1250     case 0xF1: // POP AF
1251       regs.F = get1(regs.SP++);
1252       regs.A = get1(regs.SP++);
1253     break;
1254     default:
1255       return(resINV_INST);
1256     break;
1257   }
1258   return(resGO);
1259 }
1260
1261 int
1262 cl_z80::inst_jp(t_mem code)
1263 {
1264   int jnk;
1265
1266   switch (code) {
1267     case 0xC2: // JP NZ,nnnn
1268       if (!(regs.F & BIT_Z)) {
1269         PC = fetch2();
1270       } else {
1271         jnk = fetch2();
1272       }
1273     break;
1274
1275     case 0xC3: // JP nnnn
1276       PC = fetch2();
1277     break;
1278
1279     case 0xCA: // JP Z,nnnn
1280       if (regs.F & BIT_Z) {
1281         PC = fetch2();
1282       } else {
1283         jnk = fetch2();
1284       }
1285     break;
1286
1287     case 0xD2: // JP NC,nnnn
1288       if (!(regs.F & BIT_C)) {
1289         PC = fetch2();
1290       } else {
1291         jnk = fetch2();
1292       }
1293     break;
1294
1295     case 0xDA: // JP C,nnnn
1296       if (regs.F & BIT_C) {
1297         PC = fetch2();
1298       } else {
1299         jnk = fetch2();
1300       }
1301     break;
1302
1303     case 0xE2: // JP PO,nnnn
1304       if (regs.F & BIT_P) {
1305         PC = fetch2();
1306       } else {
1307         jnk = fetch2();
1308       }
1309     break;
1310
1311     case 0xE9: // JP (HL)
1312       PC = regs.HL;
1313     break;
1314
1315     case 0xea: // JP PO,nnnn
1316       if (!(regs.F & BIT_P)) {
1317         PC = fetch2();
1318       } else {
1319         jnk = fetch2();
1320       }
1321     break;
1322
1323     case 0xF2: // JP P,nnnn (positive)
1324       if (!(regs.F & BIT_S)) {
1325         PC = fetch2();
1326       } else {
1327         jnk = fetch2();
1328       }
1329     break;
1330
1331     case 0xfa: // JP M,nnnn (sign negative)
1332       if (regs.F & BIT_S) {
1333         PC = fetch2();
1334       } else {
1335         jnk = fetch2();
1336       }
1337     break;
1338     default:
1339       return(resINV_INST);
1340     break;
1341   }
1342   return(resGO);
1343 }
1344
1345 int
1346 cl_z80::inst_di(t_mem code)
1347 {
1348   /* disable interrupts */
1349   return(resGO);
1350 }
1351
1352 int
1353 cl_z80::inst_ei(t_mem code)
1354 {
1355   /* enable interrupts */
1356   return(resGO);
1357 }
1358
1359 /* End of z80.src/inst.cc */