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           ::exit(0);
 959         break;
 960
 961         case 1:
 962           //printf("PUTCHAR-----> %xH\n", regs.hl.l);
 963           putchar(regs.hl.l);
 964           fflush(stdout);
 965         break;
 966       }
 967     break;
 968     case 0xD7: // RST 10H
 969       push2(PC+2);
 970       PC = 0x10;
 971     break;
 972     case 0xDF: // RST 18H
 973       push2(PC+2);
 974       PC = 0x18;
 975     break;
 976     case 0xE7: // RST 20H
 977       push2(PC+2);
 978       PC = 0x20;
 979     break;
 980     case 0xEF: // RST 28H
 981       push2(PC+2);
 982       PC = 0x28;
 983     break;
 984     case 0xF7: // RST 30H
 985       push2(PC+2);
 986       PC = 0x30;
 987     break;
 988     case 0xFF: // RST 38H
 989       push2(PC+2);
 990       PC = 0x38;
 991     break;
 992     default:
 993       return(resINV_INST);
 994     break;
 995   }
 996   return(resGO);
 997 }
 998
 999 int
1000 cl_z80::inst_ret(t_mem code)
1001 {
1002   switch(code) {
1003     case 0xC0: // RET NZ
1004       if (!(regs.F & BIT_Z)) {
1005         pop2(PC);
1006       }
1007     break;
1008     case 0xC8: // RET Z
1009       if ((regs.F & BIT_Z)) {
1010         pop2(PC);
1011       }
1012     break;
1013     case 0xC9: // RET
1014       pop2(PC);
1015     break;
1016     case 0xD0: // RET NC
1017       if (!(regs.F & BIT_C)) {
1018         pop2(PC);
1019       }
1020     break;
1021     case 0xD8: // RET C
1022       if ((regs.F & BIT_C)) {
1023         pop2(PC);
1024       }
1025     break;
1026     case 0xE0: // RET PO
1027       if (!(regs.F & BIT_P)) {
1028         pop2(PC);
1029       }
1030     break;
1031     case 0xE8: // RET PE
1032       if ((regs.F & BIT_P)) {
1033         pop2(PC);
1034       }
1035     break;
1036     case 0xF0: // RET P
1037       if (!(regs.F & BIT_S)) {
1038         pop2(PC);
1039       }
1040     break;
1041     case 0xF8: // RET M
1042       if ((regs.F & BIT_S)) {
1043         pop2(PC);
1044       }
1045     break;
1046     default:
1047       return(resINV_INST);
1048     break;
1049   }
1050   return(resGO);
1051 }
1052
1053 int
1054 cl_z80::inst_call(t_mem code)
1055 {
1056   int jnk;
1057
1058   switch(code) {
1059     case 0xC4: // CALL NZ,nnnn
1060       if (!(regs.F & BIT_Z)) {
1061         push2(PC+2);
1062         PC = fetch2();
1063       } else {
1064         jnk = fetch2();
1065       }
1066     break;
1067     case 0xCC: // CALL Z,nnnn
1068       if (regs.F & BIT_Z) {
1069         push2(PC+2);
1070         PC = fetch2();
1071       } else {
1072         jnk = fetch2();
1073       }
1074     break;
1075     case 0xCD: // CALL nnnn
1076       push2(PC+2);
1077       PC = fetch2();
1078     break;
1079     case 0xD4: // CALL NC,nnnn
1080       if (!(regs.F & BIT_C)) {
1081         push2(PC+2);
1082         PC = fetch2();
1083       } else {
1084         jnk = fetch2();
1085       }
1086     break;
1087     case 0xDC: // CALL C,nnnn
1088       if (regs.F & BIT_C) {
1089         push2(PC+2);
1090         PC = fetch2();
1091       } else {
1092         jnk = fetch2();
1093       }
1094     break;
1095     case 0xE4: // CALL PO,nnnn
1096       if (!(regs.F & BIT_P)) {
1097         push2(PC+2);
1098         PC = fetch2();
1099       } else {
1100         jnk = fetch2();
1101       }
1102     break;
1103     case 0xEC: // CALL PE,nnnn
1104       if (regs.F & BIT_P) {
1105         push2(PC+2);
1106         PC = fetch2();
1107       } else {
1108         jnk = fetch2();
1109       }
1110     break;
1111     case 0xF4: // CALL P,nnnn
1112       if (!(regs.F & BIT_S)) {
1113         push2(PC+2);
1114         PC = fetch2();
1115       } else {
1116         jnk = fetch2();
1117       }
1118     break;
1119     case 0xFC: // CALL M,nnnn
1120       if (regs.F & BIT_S) {
1121         push2(PC+2);
1122         PC = fetch2();
1123       } else {
1124         jnk = fetch2();
1125       }
1126     break;
1127     default:
1128       return(resINV_INST);
1129     break;
1130   }
1131
1132   return(resGO);
1133 }
1134
1135 int
1136 cl_z80::inst_out(t_mem code)
1137 {
1138   return(resGO);
1139 }
1140
1141 int
1142 cl_z80::inst_push(t_mem code)
1143 {
1144   switch(code) {
1145     case 0xC5: // PUSH BC
1146       push2(regs.BC);
1147     break;
1148     case 0xD5: // PUSH DE
1149       push2(regs.DE);
1150     break;
1151     case 0xE5: // PUSH HL
1152       push2(regs.HL);
1153     break;
1154     case 0xF5: // PUSH AF
1155       push1(regs.A);
1156       push1(regs.F);
1157     break;
1158     default:
1159       return(resINV_INST);
1160     break;
1161   }
1162   return(resGO);
1163 }
1164
1165 int
1166 cl_z80::inst_exx(t_mem code)
1167 {
1168   /* case 0xD9: // EXX - swap BC,DE,HL with alternates */
1169   TYPE_UWORD tempw;
1170
1171   tempw = regs.aBC;
1172   regs.BC = regs.aBC;
1173   regs.aBC = tempw;
1174
1175   tempw = regs.aDE;
1176   regs.DE = regs.aDE;
1177   regs.aDE = tempw;
1178
1179   tempw = regs.aDE;
1180   regs.DE = regs.aDE;
1181   regs.aDE = tempw;
1182
1183   return(resGO);
1184 }
1185
1186 int
1187 cl_z80::inst_in(t_mem code)
1188 {
1189   return(resGO);
1190 }
1191
1192 int
1193 cl_z80::inst_sub(t_mem code)
1194 {
1195   switch(code) {
1196     case 0x90: // SUB B
1197       sub_A_bytereg(regs.bc.h);
1198     break;
1199     case 0x91: // SUB C
1200       sub_A_bytereg(regs.bc.l);
1201     break;
1202     case 0x92: // SUB D
1203       sub_A_bytereg(regs.de.h);
1204     break;
1205     case 0x93: // SUB E
1206       sub_A_bytereg(regs.de.l);
1207     break;
1208     case 0x94: // SUB H
1209       sub_A_bytereg(regs.hl.h);
1210     break;
1211     case 0x95: // SUB L
1212       sub_A_bytereg(regs.hl.l);
1213     break;
1214     case 0x96: // SUB (HL)
1215       { unsigned char tmp1;
1216         tmp1 = get1(regs.HL);
1217         sub_A_bytereg(tmp1);
1218       }
1219     break;
1220     case 0x97: // SUB A
1221       regs.A = 0;
1222     break;
1223     case 0xD6: // SUB nn
1224       { unsigned char tmp1;
1225         tmp1 = fetch();
1226         sub_A_bytereg(tmp1);
1227       }
1228     break;
1229     default:
1230       return(resINV_INST);
1231     break;
1232   }
1233   return(resGO);
1234 }
1235
1236 int
1237 cl_z80::inst_pop(t_mem code)
1238 {
1239   switch (code) {
1240     case 0xC1: // POP BC
1241       regs.BC = get2(regs.SP);
1242       regs.SP+=2;
1243     break;
1244     case 0xD1: // POP DE
1245       regs.DE = get2(regs.SP);
1246       regs.SP+=2;
1247     break;
1248     case 0xE1: // POP HL
1249       regs.HL = get2(regs.SP);
1250       regs.SP+=2;
1251     break;
1252     case 0xF1: // POP AF
1253       regs.F = get1(regs.SP++);
1254       regs.A = get1(regs.SP++);
1255     break;
1256     default:
1257       return(resINV_INST);
1258     break;
1259   }
1260   return(resGO);
1261 }
1262
1263 int
1264 cl_z80::inst_jp(t_mem code)
1265 {
1266   int jnk;
1267
1268   switch (code) {
1269     case 0xC2: // JP NZ,nnnn
1270       if (!(regs.F & BIT_Z)) {
1271         PC = fetch2();
1272       } else {
1273         jnk = fetch2();
1274       }
1275     break;
1276
1277     case 0xC3: // JP nnnn
1278       PC = fetch2();
1279     break;
1280
1281     case 0xCA: // JP Z,nnnn
1282       if (regs.F & BIT_Z) {
1283         PC = fetch2();
1284       } else {
1285         jnk = fetch2();
1286       }
1287     break;
1288
1289     case 0xD2: // JP NC,nnnn
1290       if (!(regs.F & BIT_C)) {
1291         PC = fetch2();
1292       } else {
1293         jnk = fetch2();
1294       }
1295     break;
1296
1297     case 0xDA: // JP C,nnnn
1298       if (regs.F & BIT_C) {
1299         PC = fetch2();
1300       } else {
1301         jnk = fetch2();
1302       }
1303     break;
1304
1305     case 0xE2: // JP PO,nnnn
1306       if (regs.F & BIT_P) {
1307         PC = fetch2();
1308       } else {
1309         jnk = fetch2();
1310       }
1311     break;
1312
1313     case 0xE9: // JP (HL)
1314       PC = regs.HL;
1315     break;
1316
1317     case 0xea: // JP PO,nnnn
1318       if (!(regs.F & BIT_P)) {
1319         PC = fetch2();
1320       } else {
1321         jnk = fetch2();
1322       }
1323     break;
1324
1325     case 0xF2: // JP P,nnnn (positive)
1326       if (!(regs.F & BIT_S)) {
1327         PC = fetch2();
1328       } else {
1329         jnk = fetch2();
1330       }
1331     break;
1332
1333     case 0xfa: // JP M,nnnn (sign negative)
1334       if (regs.F & BIT_S) {
1335         PC = fetch2();
1336       } else {
1337         jnk = fetch2();
1338       }
1339     break;
1340     default:
1341       return(resINV_INST);
1342     break;
1343   }
1344   return(resGO);
1345 }
1346
1347 int
1348 cl_z80::inst_di(t_mem code)
1349 {
1350   /* disable interrupts */
1351   return(resGO);
1352 }
1353
1354 int
1355 cl_z80::inst_ei(t_mem code)
1356 {
1357   /* enable interrupts */
1358   return(resGO);
1359 }
1360
1361 /* End of z80.src/inst.cc */