[BACK]Return to z80c_cb.c CVS log [TXT] [DIR] Up to [RetroPC.NET] / xmil / z80c

Diff for /xmil/z80c/z80c_cb.c between versions 1.1 and 1.7

version 1.1, 2004/08/01 05:31:32 version 1.7, 2008/06/02 20:07:32
Line 1 Line 1
 //----------------------------------------------------------------------------  /* -----------------------------------------------------------------------
 //   *
 //  Z80C : Z80 Engine - GENERIC   * Z80C : Z80 Engine - GENERIC
 //   *
 //                                  Copyright by Studio Milmake 1999-2000,2004   *                              Copyright by Studio Milmake 1999-2000,2004
 //   *
 //----------------------------------------------------------------------------   *------------------------------------------------------------------------ */
   
   
 #include        "compiler.h"  #include        "compiler.h"
 #include        "z80core.h"  #include        "z80core.h"
 #include        "z80c.h"  #include        "z80c.h"
 #include        "x1_io.h"  
 #include        "z80c.mcr"  #include        "z80c.mcr"
   
   
 static BYTE CPUCALL _cb_rlc(BYTE v) {  static REG8 CPUCALL _cb_rlc(REG8 v) {
   
         BYTE    ret;          REG8    ret;
   
         R_Z80F = v >> 7;          R_Z80F = v >> 7;
         ret = (v << 1) | R_Z80F;          ret = (v << 1) | R_Z80F;
         R_Z80F |= ZSPtable[ret];          R_Z80F |= z80szp_flag[(UINT8)ret];
         return(ret);          return(ret);
 }  }
   
 static BYTE CPUCALL _cb_rrc(BYTE v) {  static REG8 CPUCALL _cb_rrc(REG8 v) {
   
         BYTE    ret;          REG8    ret;
   
         R_Z80F = v & 1;          R_Z80F = v & 1;
         ret = (v >> 1) | (R_Z80F << 7);          ret = (v >> 1) | (R_Z80F << 7);
         R_Z80F |= ZSPtable[ret];          R_Z80F |= z80szp_flag[(UINT8)ret];
         return(ret);          return(ret);
 }  }
   
 static BYTE CPUCALL _cb_rl(BYTE v) {  static REG8 CPUCALL _cb_rl(REG8 v) {
   
         BYTE    ret;          REG8    ret;
   
         ret = (v << 1) | (R_Z80F & 1);          ret = (v << 1) | (R_Z80F & 1);
         R_Z80F = ZSPtable[ret] | (v >> 7);          R_Z80F = z80szp_flag[(UINT8)ret] | (v >> 7);
         return(ret);          return(ret);
 }  }
   
 static BYTE CPUCALL _cb_rr(BYTE v) {  static REG8 CPUCALL _cb_rr(REG8 v) {
   
         BYTE    ret;          REG8    ret;
   
         ret = (v >> 1) | (R_Z80F << 7);          ret = (v >> 1) | (R_Z80F << 7);
         R_Z80F = ZSPtable[ret] | (v & 1);          R_Z80F = z80szp_flag[(UINT8)ret] | (v & 1);
         return(ret);          return(ret);
 }  }
   
 static BYTE CPUCALL _cb_sla(BYTE v) {  static REG8 CPUCALL _cb_sla(REG8 v) {
   
         BYTE    ret;          REG8    ret;
   
         ret = (v << 1);          ret = (v << 1);
         R_Z80F = ZSPtable[ret] | (v >> 7);          R_Z80F = z80szp_flag[(UINT8)ret] | (v >> 7);
         return(ret);          return(ret);
 }  }
   
 static BYTE CPUCALL _cb_sra(BYTE v) {  static REG8 CPUCALL _cb_sra(REG8 v) {
   
         BYTE    ret;          REG8    ret;
   
         ret = (((char)v) / 2);          ret = (((SINT8)v) >> 1);
         R_Z80F = ZSPtable[ret] | (v & 1);          R_Z80F = z80szp_flag[(UINT8)ret] | (v & 1);
         return(ret);          return(ret);
 }  }
   
 static BYTE CPUCALL _cb_sll(BYTE v) {  static REG8 CPUCALL _cb_sll(REG8 v) {
   
         BYTE    ret;          REG8    ret;
   
         ret = (v << 1) | 1;          ret = (v << 1) | 1;
         R_Z80F = ZSPtable[ret] | (v >> 7);          R_Z80F = z80szp_flag[(UINT8)ret] | (v >> 7);
         return(ret);          return(ret);
 }  }
   
 static BYTE CPUCALL _cb_srl(BYTE v) {  static REG8 CPUCALL _cb_srl(REG8 v) {
   
         BYTE    ret;          REG8    ret;
   
         ret = v >> 1;          ret = v >> 1;
         R_Z80F = ZSPtable[ret] | (v & 1);          R_Z80F = z80szp_flag[ret] | (v & 1);
         return(ret);          return(ret);
 }  }
   
   
 static BYTE (CPUCALL * rolsft_proc[8])(BYTE value) = {  static REG8 (CPUCALL * rolsft_proc[8])(REG8 value) = {
                 _cb_rlc,        _cb_rrc,        _cb_rl,         _cb_rr,                  _cb_rlc,        _cb_rrc,        _cb_rl,         _cb_rr,
                 _cb_sla,        _cb_sra,        _cb_sll,        _cb_srl};                  _cb_sla,        _cb_sra,        _cb_sll,        _cb_srl};
   
 static BYTE *cb_reg[8] = {  static UINT8 *cb_reg[8] = {
                 &R_Z80B,        &R_Z80C,        &R_Z80D,        &R_Z80E,                  &R_Z80B,        &R_Z80C,        &R_Z80D,        &R_Z80E,
                 &R_Z80H,        &R_Z80L,        NULL,           &R_Z80A};                  &R_Z80H,        &R_Z80L,        NULL,           &R_Z80A};
   
   
 void z80c_cb(void) {  void z80c_cb(void) {
   
         BYTE    op;          UINT    op;
         BYTE    *reg;          UINT8   *reg;
         BYTE    xhl;          REG8    xhl;
         int             bit;          UINT    bit;
   
         R_Z80R++;          R_Z80R++;
         GET_PC_BYTE(op);          GET_PC_BYTE(op);
Line 117  void z80c_cb(void) { Line 115  void z80c_cb(void) {
                                 *reg = rolsft_proc[bit](*reg);                                  *reg = rolsft_proc[bit](*reg);
                                 break;                                  break;
   
                         case 0x40:                                                                              // bit                          case 0x40:                                                                              /* bit */
                                 R_Z80F &= C_FLAG;                                  R_Z80F &= C_FLAG;
                                 if ((*reg) & (1 << bit)) {                                  if ((*reg) & (1 << bit)) {
                                         if (bit != 7) {                                          if (bit != 7) {
Line 132  void z80c_cb(void) { Line 130  void z80c_cb(void) {
                                 }                                  }
                                 break;                                  break;
   
                         case 0x80:                                                                              // reset                          case 0x80:                                                                              /* reset */
                                 (*reg) &= ~(1 << bit);                                  (*reg) &= ~(1 << bit);
                                 break;                                  break;
   
                         case 0xc0:                                                                              // set                          case 0xc0:                                                                              /* set */
                                 (*reg) |= 1 << bit;                                  (*reg) |= 1 << bit;
                                 break;                                  break;
                 }                  }
         }          }
         else {          else {
                 xhl = Z80_RDMEM(R_Z80HL);                  xhl = mem_read8(R_Z80HL);
                 switch(op & 0xc0) {                  switch(op & 0xc0) {
                         case 0x00:                          case 0x00:
                                 Z80_COUNT(15);                                  Z80_COUNT(15);
                                 xhl = rolsft_proc[bit](xhl);                                  xhl = rolsft_proc[bit](xhl);
                                 break;                                  break;
   
                         case 0x40:                                                                              // bit                          case 0x40:                                                                              /* bit */
                                 Z80_COUNT(12);                                  Z80_COUNT(12);
                                 R_Z80F &= C_FLAG;                                  R_Z80F &= C_FLAG;
                                 if (xhl & (1 << bit)) {                                  if (xhl & (1 << bit)) {
Line 165  void z80c_cb(void) { Line 163  void z80c_cb(void) {
                                 }                                  }
                                 return;                                  return;
   
                         case 0x80:                                                                              // reset                          case 0x80:                                                                              /* reset */
                                 Z80_COUNT(15);                                  Z80_COUNT(15);
                                 xhl &= ~(1 << bit);                                  xhl &= ~(1 << bit);
                                 break;                                  break;
   
                         case 0xc0:                                                                              // set                          case 0xc0:                                                                              /* set */
                                 Z80_COUNT(15);                                  Z80_COUNT(15);
                                 xhl |= 1 << bit;                                  xhl |= 1 << bit;
                                 break;                                  break;
                 }                  }
                 Z80_WRMEM(R_Z80HL, xhl);                  mem_write8(R_Z80HL, xhl);
         }          }
 }  }
   
 void z80c_ixcb(void) {  void z80c_ixcb(void) {
   
         BYTE    op;          UINT    op;
         WORD    adrs;          UINT    adrs;
         BYTE    xi;          REG8    xi;
         int             bit;          UINT    bit;
   
         R_Z80R++;          R_Z80R++;
         adrs = __CBW(Z80_RDMEM(R_Z80PC++)) + R_Z80IX;          adrs = LOW16(mem_read8s(R_Z80PC++) + R_Z80IX);
         xi = Z80_RDMEM(adrs);          xi = mem_read8(adrs);
         GET_PC_BYTE(op);          GET_PC_BYTE(op);
         bit = (op >> 3) & 7;          bit = (op >> 3) & 7;
         switch(op & 0xc0) {          switch(op & 0xc0) {
Line 197  void z80c_ixcb(void) { Line 195  void z80c_ixcb(void) {
                         xi = rolsft_proc[bit](xi);                          xi = rolsft_proc[bit](xi);
                         break;                          break;
   
                 case 0x40:                                                                              // bit                  case 0x40:                                                                              /* bit */
                         Z80_COUNT(20);                          Z80_COUNT(20);
                         R_Z80F &= C_FLAG;                          R_Z80F &= C_FLAG;
                         if (xi & (1 << bit)) {                          if (xi & (1 << bit)) {
Line 213  void z80c_ixcb(void) { Line 211  void z80c_ixcb(void) {
                         }                          }
                         return;                          return;
   
                 case 0x80:                                                                              // reset                  case 0x80:                                                                              /* reset */
                         Z80_COUNT(23);                          Z80_COUNT(23);
                         xi &= ~(1 << bit);                          xi &= ~(1 << bit);
                         break;                          break;
   
                 case 0xc0:                                                                              // set                  case 0xc0:                                                                              /* set */
                         Z80_COUNT(23);                          Z80_COUNT(23);
                         xi |= 1 << bit;                          xi |= 1 << bit;
                         break;                          break;
         }          }
         Z80_WRMEM(adrs, xi);          mem_write8(adrs, xi);
 }  }
   
 void z80c_iycb(void) {  void z80c_iycb(void) {
   
         BYTE    op;          UINT    op;
         WORD    adrs;          UINT    adrs;
         BYTE    xi;          REG8    xi;
         int             bit;          UINT    bit;
   
         R_Z80R++;          R_Z80R++;
         adrs = __CBW(Z80_RDMEM(R_Z80PC++)) + R_Z80IY;          adrs = LOW16(mem_read8s(R_Z80PC++) + R_Z80IY);
         xi = Z80_RDMEM(adrs);          xi = mem_read8(adrs);
         GET_PC_BYTE(op);          GET_PC_BYTE(op);
         bit = (op >> 3) & 7;          bit = (op >> 3) & 7;
         switch(op & 0xc0) {          switch(op & 0xc0) {
Line 244  void z80c_iycb(void) { Line 242  void z80c_iycb(void) {
                         xi = rolsft_proc[bit](xi);                          xi = rolsft_proc[bit](xi);
                         break;                          break;
   
                 case 0x40:                                                                              // bit                  case 0x40:                                                                              /* bit */
                         Z80_COUNT(20);                          Z80_COUNT(20);
                         R_Z80F &= C_FLAG;                          R_Z80F &= C_FLAG;
                         if (xi & (1 << bit)) {                          if (xi & (1 << bit)) {
Line 260  void z80c_iycb(void) { Line 258  void z80c_iycb(void) {
                         }                          }
                         return;                          return;
   
                 case 0x80:                                                                              // reset                  case 0x80:                                                                              /* reset */
                         Z80_COUNT(23);                          Z80_COUNT(23);
                         xi &= ~(1 << bit);                          xi &= ~(1 << bit);
                         break;                          break;
   
                 case 0xc0:                                                                              // set                  case 0xc0:                                                                              /* set */
                         Z80_COUNT(23);                          Z80_COUNT(23);
                         xi |= 1 << bit;                          xi |= 1 << bit;
                         break;                          break;
         }          }
         Z80_WRMEM(adrs, xi);          mem_write8(adrs, xi);
 }  }
   
Removed from v.1.1  
changed lines
  Added in v.1.7

RetroPC.NET-CVS <cvs@retropc.net>