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