Subversion Repositories Kolibri OS

Rev

Blame | Last modification | View Log | Download | RSS feed

  1. /*====================================================================/*
  2.   opcodes_cb.c -> This file executes the CB PREFIX opcodes.
  3.  
  4.   When you find the CB opcode, it means that you must fetch another
  5.   byte from memory and treat it as a new opcode with different
  6.   meaning than the single-byte opcodes. This is a common way to extend
  7.   the number of opcodes (8 bits of instruction word = just 256 opcodes)
  8.   and it's called an OPCODE PREFIX (now we have another 256 new opcodes
  9.   by using this trick).
  10.  
  11.  This program is free software; you can redistribute it and/or modify
  12.  it under the terms of the GNU General Public License as published by
  13.  the Free Software Foundation; either version 2 of the License, or
  14.  (at your option) any later version.
  15.  
  16.  This program is distributed in the hope that it will be useful,
  17.  but WITHOUT ANY WARRANTY; without even the implied warranty of
  18.  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  19.  GNU General Public License for more details.
  20.  
  21.  You should have received a copy of the GNU General Public License
  22.  along with this program; if not, write to the Free Software
  23.  Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  24.  
  25.  Copyright (c) 2000 Santiago Romero Iglesias.
  26.  Email: sromero@escomposlinux.org
  27.  =====================================================================*/
  28.  
  29. /* 8 clock cycles minimum = CB opcode = 4+4 */
  30.  
  31. opcode = Z80ReadMem( r_PC );
  32. r_PC++;
  33.  
  34. switch(opcode)
  35. {
  36.  
  37.   case  RLC_B     :  RLC(r_B); AddCycles( 4+4 ); break;
  38.   case  RLC_C     :  RLC(r_C); AddCycles( 4+4 ); break;
  39.   case  RLC_D     :  RLC(r_D); AddCycles( 4+4 ); break;
  40.   case  RLC_E     :  RLC(r_E); AddCycles( 4+4 ); break;
  41.   case  RLC_H     :  RLC(r_H); AddCycles( 4+4 ); break;
  42.   case  RLC_L     :  RLC(r_L); AddCycles( 4+4 ); break;
  43.   case  RLC_xHL   :  r_meml = Z80ReadMem( r_HL );
  44.                      RLC(r_meml);
  45.                      Z80WriteMem( r_HL, r_meml, regs );
  46.                      AddCycles( 4+4+3+3+1 ); break;
  47.   case  RLC_A     :  RLC(r_A); AddCycles( 4+4 ); break;
  48.  
  49.   case  RRC_B     :  RRC(r_B); AddCycles( 4+4 ); break;
  50.   case  RRC_C     :  RRC(r_C); AddCycles( 4+4 ); break;
  51.   case  RRC_D     :  RRC(r_D); AddCycles( 4+4 ); break;
  52.   case  RRC_E     :  RRC(r_E); AddCycles( 4+4 ); break;
  53.   case  RRC_H     :  RRC(r_H); AddCycles( 4+4 ); break;
  54.   case  RRC_L     :  RRC(r_L); AddCycles( 4+4 ); break;
  55.   case  RRC_xHL   :  r_meml = Z80ReadMem( r_HL );
  56.                      RRC(r_meml);
  57.                      Z80WriteMem( r_HL, r_meml, regs );
  58.                      AddCycles( 4+4+3+3+1 ); break;
  59.   case  RRC_A     :  RRC(r_A); AddCycles( 4+4 ); break;
  60.  
  61.   case  RL_B      :  RL(r_B); AddCycles( 4+4 ); break;
  62.   case  RL_C      :  RL(r_C); AddCycles( 4+4 ); break;
  63.   case  RL_D      :  RL(r_D); AddCycles( 4+4 ); break;
  64.   case  RL_E      :  RL(r_E); AddCycles( 4+4 ); break;
  65.   case  RL_H      :  RL(r_H); AddCycles( 4+4 ); break;
  66.   case  RL_L      :  RL(r_L); AddCycles( 4+4 ); break;
  67.   case  RL_xHL    :  r_meml = Z80ReadMem( r_HL );
  68.                      RL(r_meml);
  69.                      Z80WriteMem( r_HL, r_meml, regs );
  70.                      AddCycles( 4+4+3+3+1 ); break;
  71.   case  RL_A      :  RL(r_A); AddCycles( 4+4 ); break;
  72.  
  73.   case  RR_B      :  RR(r_B); AddCycles( 4+4 ); break;
  74.   case  RR_C      :  RR(r_C); AddCycles( 4+4 ); break;
  75.   case  RR_D      :  RR(r_D); AddCycles( 4+4 ); break;
  76.   case  RR_E      :  RR(r_E); AddCycles( 4+4 ); break;
  77.   case  RR_H      :  RR(r_H); AddCycles( 4+4 ); break;
  78.   case  RR_L      :  RR(r_L); AddCycles( 4+4 ); break;
  79.   case  RR_xHL    :  r_meml = Z80ReadMem( r_HL );
  80.                      RR(r_meml);
  81.                      Z80WriteMem( r_HL, r_meml, regs );
  82.                      AddCycles( 4+4+3+3+1 ); break;
  83.   case  RR_A      :  RR(r_A); AddCycles( 4+4 ); break;
  84.  
  85.   case  SLA_B     :  SLA(r_B); AddCycles( 4+4 ); break;
  86.   case  SLA_C     :  SLA(r_C); AddCycles( 4+4 ); break;
  87.   case  SLA_D     :  SLA(r_D); AddCycles( 4+4 ); break;
  88.   case  SLA_E     :  SLA(r_E); AddCycles( 4+4 ); break;
  89.   case  SLA_H     :  SLA(r_H); AddCycles( 4+4 ); break;
  90.   case  SLA_L     :  SLA(r_L); AddCycles( 4+4 ); break;
  91.   case  SLA_xHL   :  r_meml = Z80ReadMem( r_HL );
  92.                      SLA(r_meml);
  93.                      Z80WriteMem( r_HL, r_meml, regs );
  94.                      AddCycles( 4+4+3+3+1 ); break;
  95.   case  SLA_A     :  SLA(r_A); AddCycles( 4+4 ); break;
  96.  
  97.   case  SRA_B     :  SRA(r_B); AddCycles( 4+4 ); break;
  98.   case  SRA_C     :  SRA(r_C); AddCycles( 4+4 ); break;
  99.   case  SRA_D     :  SRA(r_D); AddCycles( 4+4 ); break;
  100.   case  SRA_E     :  SRA(r_E); AddCycles( 4+4 ); break;
  101.   case  SRA_H     :  SRA(r_H); AddCycles( 4+4 ); break;
  102.   case  SRA_L     :  SRA(r_L); AddCycles( 4+4 ); break;
  103.   case  SRA_xHL   :  r_meml = Z80ReadMem( r_HL );
  104.                      SRA(r_meml);
  105.                      Z80WriteMem( r_HL, r_meml, regs );
  106.                      AddCycles( 4+4+3+3+1 ); break;
  107.   case  SRA_A     :  SRA(r_A); AddCycles( 4+4 ); break;
  108.  
  109.   case  SLL_B     :  SLL(r_B); AddCycles( 4+4 ); break;
  110.   case  SLL_C     :  SLL(r_C); AddCycles( 4+4 ); break;
  111.   case  SLL_D     :  SLL(r_D); AddCycles( 4+4 ); break;
  112.   case  SLL_E     :  SLL(r_E); AddCycles( 4+4 ); break;
  113.   case  SLL_H     :  SLL(r_H); AddCycles( 4+4 ); break;
  114.   case  SLL_L     :  SLL(r_L); AddCycles( 4+4 ); break;
  115.   case  SLL_xHL   :  r_meml = Z80ReadMem( r_HL );
  116.                      SLL(r_meml);
  117.                      Z80WriteMem( r_HL, r_meml, regs );
  118.                      AddCycles( 4+4+3+3+1 ); break;
  119.   case  SLL_A     :  SLL(r_A); AddCycles( 4+4 ); break;
  120.  
  121.   case  SRL_B     :  SRL(r_B); AddCycles( 4+4 ); break;
  122.   case  SRL_C     :  SRL(r_C); AddCycles( 4+4 ); break;
  123.   case  SRL_D     :  SRL(r_D); AddCycles( 4+4 ); break;
  124.   case  SRL_E     :  SRL(r_E); AddCycles( 4+4 ); break;
  125.   case  SRL_H     :  SRL(r_H); AddCycles( 4+4 ); break;
  126.   case  SRL_L     :  SRL(r_L); AddCycles( 4+4 ); break;
  127.   case  SRL_xHL   :  r_meml = Z80ReadMem( r_HL );
  128.                      SRL(r_meml);
  129.                      Z80WriteMem( r_HL, r_meml, regs );
  130.                      AddCycles( 4+4+3+3+1 ); break;
  131.   case  SRL_A     :  SRL(r_A); AddCycles( 4+4 ); break;
  132.  
  133.   case  BIT_0_B   :  BIT_BIT(0, r_B); AddCycles( 4+4 ); break;
  134.   case  BIT_0_C   :  BIT_BIT(0, r_C); AddCycles( 4+4 ); break;
  135.   case  BIT_0_D   :  BIT_BIT(0, r_D); AddCycles( 4+4 ); break;
  136.   case  BIT_0_E   :  BIT_BIT(0, r_E); AddCycles( 4+4 ); break;
  137.   case  BIT_0_H   :  BIT_BIT(0, r_H); AddCycles( 4+4 ); break;
  138.   case  BIT_0_L   :  BIT_BIT(0, r_L); AddCycles( 4+4 ); break;
  139.   case  BIT_0_xHL :  BIT_mem_BIT(0, r_HL); AddCycles( 12 ); break;
  140.   case  BIT_0_A   :  BIT_BIT(0, r_A); AddCycles( 4+4 ); break;
  141.  
  142.   case  BIT_1_B   :  BIT_BIT(1, r_B); AddCycles( 4+4 ); break;
  143.   case  BIT_1_C   :  BIT_BIT(1, r_C); AddCycles( 4+4 ); break;
  144.   case  BIT_1_D   :  BIT_BIT(1, r_D); AddCycles( 4+4 ); break;
  145.   case  BIT_1_E   :  BIT_BIT(1, r_E); AddCycles( 4+4 ); break;
  146.   case  BIT_1_H   :  BIT_BIT(1, r_H); AddCycles( 4+4 ); break;
  147.   case  BIT_1_L   :  BIT_BIT(1, r_L); AddCycles( 4+4 ); break;
  148.   case  BIT_1_xHL :  BIT_mem_BIT(1, r_HL); AddCycles( 12 ); break;
  149.   case  BIT_1_A   :  BIT_BIT(1, r_A); AddCycles( 4+4 ); break;
  150.  
  151.   case  BIT_2_B   :  BIT_BIT(2, r_B); AddCycles( 4+4 ); break;
  152.   case  BIT_2_C   :  BIT_BIT(2, r_C); AddCycles( 4+4 ); break;
  153.   case  BIT_2_D   :  BIT_BIT(2, r_D); AddCycles( 4+4 ); break;
  154.   case  BIT_2_E   :  BIT_BIT(2, r_E); AddCycles( 4+4 ); break;
  155.   case  BIT_2_H   :  BIT_BIT(2, r_H); AddCycles( 4+4 ); break;
  156.   case  BIT_2_L   :  BIT_BIT(2, r_L); AddCycles( 4+4 ); break;
  157.   case  BIT_2_xHL :  BIT_mem_BIT(2, r_HL); AddCycles( 12 ); break;
  158.   case  BIT_2_A   :  BIT_BIT(2, r_A); AddCycles( 4+4 ); break;
  159.  
  160.   case  BIT_3_B   :  BIT_BIT(3, r_B); AddCycles( 4+4 ); break;
  161.   case  BIT_3_C   :  BIT_BIT(3, r_C); AddCycles( 4+4 ); break;
  162.   case  BIT_3_D   :  BIT_BIT(3, r_D); AddCycles( 4+4 ); break;
  163.   case  BIT_3_E   :  BIT_BIT(3, r_E); AddCycles( 4+4 ); break;
  164.   case  BIT_3_H   :  BIT_BIT(3, r_H); AddCycles( 4+4 ); break;
  165.   case  BIT_3_L   :  BIT_BIT(3, r_L); AddCycles( 4+4 ); break;
  166.   case  BIT_3_xHL :  BIT_mem_BIT(3, r_HL); AddCycles( 12 ); break;
  167.   case  BIT_3_A   :  BIT_BIT(3, r_A); AddCycles( 4+4 ); break;
  168.  
  169.   case  BIT_4_B   :  BIT_BIT(4, r_B); AddCycles( 4+4 ); break;
  170.   case  BIT_4_C   :  BIT_BIT(4, r_C); AddCycles( 4+4 ); break;
  171.   case  BIT_4_D   :  BIT_BIT(4, r_D); AddCycles( 4+4 ); break;
  172.   case  BIT_4_E   :  BIT_BIT(4, r_E); AddCycles( 4+4 ); break;
  173.   case  BIT_4_H   :  BIT_BIT(4, r_H); AddCycles( 4+4 ); break;
  174.   case  BIT_4_L   :  BIT_BIT(4, r_L); AddCycles( 4+4 ); break;
  175.   case  BIT_4_xHL :  BIT_mem_BIT(4, r_HL); AddCycles( 12 ); break;
  176.   case  BIT_4_A   :  BIT_BIT(4, r_A); AddCycles( 4+4 ); break;
  177.  
  178.   case  BIT_5_B   :  BIT_BIT(5, r_B); AddCycles( 4+4 ); break;
  179.   case  BIT_5_C   :  BIT_BIT(5, r_C); AddCycles( 4+4 ); break;
  180.   case  BIT_5_D   :  BIT_BIT(5, r_D); AddCycles( 4+4 ); break;
  181.   case  BIT_5_E   :  BIT_BIT(5, r_E); AddCycles( 4+4 ); break;
  182.   case  BIT_5_H   :  BIT_BIT(5, r_H); AddCycles( 4+4 ); break;
  183.   case  BIT_5_L   :  BIT_BIT(5, r_L); AddCycles( 4+4 ); break;
  184.   case  BIT_5_xHL :  BIT_mem_BIT(5, r_HL); AddCycles( 12 ); break;
  185.   case  BIT_5_A   :  BIT_BIT(5, r_A); AddCycles( 4+4 ); break;
  186.  
  187.   case  BIT_6_B   :  BIT_BIT(6, r_B); AddCycles( 4+4 ); break;
  188.   case  BIT_6_C   :  BIT_BIT(6, r_C); AddCycles( 4+4 ); break;
  189.   case  BIT_6_D   :  BIT_BIT(6, r_D); AddCycles( 4+4 ); break;
  190.   case  BIT_6_E   :  BIT_BIT(6, r_E); AddCycles( 4+4 ); break;
  191.   case  BIT_6_H   :  BIT_BIT(6, r_H); AddCycles( 4+4 ); break;
  192.   case  BIT_6_L   :  BIT_BIT(6, r_L); AddCycles( 4+4 ); break;
  193.   case  BIT_6_xHL :  BIT_mem_BIT(6, r_HL); AddCycles( 12 ); break;
  194.   case  BIT_6_A   :  BIT_BIT(6, r_A); AddCycles( 4+4 ); break;
  195.  
  196.   case  BIT_7_B   :  BIT_BIT7(r_B); AddCycles( 4+4 ); break;
  197.   case  BIT_7_C   :  BIT_BIT7(r_C); AddCycles( 4+4 ); break;
  198.   case  BIT_7_D   :  BIT_BIT7(r_D); AddCycles( 4+4 ); break;
  199.   case  BIT_7_E   :  BIT_BIT7(r_E); AddCycles( 4+4 ); break;
  200.   case  BIT_7_H   :  BIT_BIT7(r_H); AddCycles( 4+4 ); break;
  201.   case  BIT_7_L   :  BIT_BIT7(r_L); AddCycles( 4+4 ); break;
  202.   case  BIT_7_xHL :  BIT_mem_BIT7(r_HL); AddCycles( 12 ); break;
  203.   case  BIT_7_A   :  BIT_BIT7(r_A); AddCycles( 4+4 ); break;
  204.  
  205.   case  RES_0_B   :  BIT_RES(0, r_B); AddCycles( 4+4 ); break;
  206.   case  RES_0_C   :  BIT_RES(0, r_C); AddCycles( 4+4 ); break;
  207.   case  RES_0_D   :  BIT_RES(0, r_D); AddCycles( 4+4 ); break;
  208.   case  RES_0_E   :  BIT_RES(0, r_E); AddCycles( 4+4 ); break;
  209.   case  RES_0_H   :  BIT_RES(0, r_H); AddCycles( 4+4 ); break;
  210.   case  RES_0_L   :  BIT_RES(0, r_L); AddCycles( 4+4 ); break;
  211.   case  RES_0_xHL :  BIT_mem_RES(0, r_HL); AddCycles( 4+4+7 ); break;
  212.   case  RES_0_A   :  BIT_RES(0, r_A); AddCycles( 4+4 ); break;
  213.  
  214.   case  RES_1_B   :  BIT_RES(1, r_B); AddCycles( 4+4 ); break;
  215.   case  RES_1_C   :  BIT_RES(1, r_C); AddCycles( 4+4 ); break;
  216.   case  RES_1_D   :  BIT_RES(1, r_D); AddCycles( 4+4 ); break;
  217.   case  RES_1_E   :  BIT_RES(1, r_E); AddCycles( 4+4 ); break;
  218.   case  RES_1_H   :  BIT_RES(1, r_H); AddCycles( 4+4 ); break;
  219.   case  RES_1_L   :  BIT_RES(1, r_L); AddCycles( 4+4 ); break;
  220.   case  RES_1_xHL :  BIT_mem_RES(1, r_HL); AddCycles( 4+4+7 ); break;
  221.   case  RES_1_A   :  BIT_RES(1, r_A); AddCycles( 4+4 ); break;
  222.  
  223.   case  RES_2_B   :  BIT_RES(2, r_B); AddCycles( 4+4 ); break;
  224.   case  RES_2_C   :  BIT_RES(2, r_C); AddCycles( 4+4 ); break;
  225.   case  RES_2_D   :  BIT_RES(2, r_D); AddCycles( 4+4 ); break;
  226.   case  RES_2_E   :  BIT_RES(2, r_E); AddCycles( 4+4 ); break;
  227.   case  RES_2_H   :  BIT_RES(2, r_H); AddCycles( 4+4 ); break;
  228.   case  RES_2_L   :  BIT_RES(2, r_L); AddCycles( 4+4 ); break;
  229.   case  RES_2_xHL :  BIT_mem_RES(2, r_HL); AddCycles( 4+4+7 ); break;
  230.   case  RES_2_A   :  BIT_RES(2, r_A); AddCycles( 4+4 ); break;
  231.  
  232.   case  RES_3_B   :  BIT_RES(3, r_B); AddCycles( 4+4 ); break;
  233.   case  RES_3_C   :  BIT_RES(3, r_C); AddCycles( 4+4 ); break;
  234.   case  RES_3_D   :  BIT_RES(3, r_D); AddCycles( 4+4 ); break;
  235.   case  RES_3_E   :  BIT_RES(3, r_E); AddCycles( 4+4 ); break;
  236.   case  RES_3_H   :  BIT_RES(3, r_H); AddCycles( 4+4 ); break;
  237.   case  RES_3_L   :  BIT_RES(3, r_L); AddCycles( 4+4 ); break;
  238.   case  RES_3_xHL :  BIT_mem_RES(3, r_HL); AddCycles( 4+4+7 ); break;
  239.   case  RES_3_A   :  BIT_RES(3, r_A); AddCycles( 4+4 ); break;
  240.  
  241.   case  RES_4_B   :  BIT_RES(4, r_B); AddCycles( 4+4 ); break;
  242.   case  RES_4_C   :  BIT_RES(4, r_C); AddCycles( 4+4 ); break;
  243.   case  RES_4_D   :  BIT_RES(4, r_D); AddCycles( 4+4 ); break;
  244.   case  RES_4_E   :  BIT_RES(4, r_E); AddCycles( 4+4 ); break;
  245.   case  RES_4_H   :  BIT_RES(4, r_H); AddCycles( 4+4 ); break;
  246.   case  RES_4_L   :  BIT_RES(4, r_L); AddCycles( 4+4 ); break;
  247.   case  RES_4_xHL :  BIT_mem_RES(4, r_HL); AddCycles( 4+4+7 ); break;
  248.   case  RES_4_A   :  BIT_RES(4, r_A); AddCycles( 4+4 ); break;
  249.  
  250.   case  RES_5_B   :  BIT_RES(5, r_B); AddCycles( 4+4 ); break;
  251.   case  RES_5_C   :  BIT_RES(5, r_C); AddCycles( 4+4 ); break;
  252.   case  RES_5_D   :  BIT_RES(5, r_D); AddCycles( 4+4 ); break;
  253.   case  RES_5_E   :  BIT_RES(5, r_E); AddCycles( 4+4 ); break;
  254.   case  RES_5_H   :  BIT_RES(5, r_H); AddCycles( 4+4 ); break;
  255.   case  RES_5_L   :  BIT_RES(5, r_L); AddCycles( 4+4 ); break;
  256.   case  RES_5_xHL :  BIT_mem_RES(5, r_HL); AddCycles( 4+4+7 ); break;
  257.   case  RES_5_A   :  BIT_RES(5, r_A); AddCycles( 4+4 ); break;
  258.  
  259.   case  RES_6_B   :  BIT_RES(6, r_B); AddCycles( 4+4 ); break;
  260.   case  RES_6_C   :  BIT_RES(6, r_C); AddCycles( 4+4 ); break;
  261.   case  RES_6_D   :  BIT_RES(6, r_D); AddCycles( 4+4 ); break;
  262.   case  RES_6_E   :  BIT_RES(6, r_E); AddCycles( 4+4 ); break;
  263.   case  RES_6_H   :  BIT_RES(6, r_H); AddCycles( 4+4 ); break;
  264.   case  RES_6_L   :  BIT_RES(6, r_L); AddCycles( 4+4 ); break;
  265.   case  RES_6_xHL :  BIT_mem_RES(6, r_HL); AddCycles( 4+4+7 ); break;
  266.   case  RES_6_A   :  BIT_RES(6, r_A); AddCycles( 4+4 ); break;
  267.  
  268.   case  RES_7_B   :  BIT_RES(7, r_B); AddCycles( 4+4 ); break;
  269.   case  RES_7_C   :  BIT_RES(7, r_C); AddCycles( 4+4 ); break;
  270.   case  RES_7_D   :  BIT_RES(7, r_D); AddCycles( 4+4 ); break;
  271.   case  RES_7_E   :  BIT_RES(7, r_E); AddCycles( 4+4 ); break;
  272.   case  RES_7_H   :  BIT_RES(7, r_H); AddCycles( 4+4 ); break;
  273.   case  RES_7_L   :  BIT_RES(7, r_L); AddCycles( 4+4 ); break;
  274.   case  RES_7_xHL :  BIT_mem_RES(7, r_HL); AddCycles( 4+4+7 ); break;
  275.   case  RES_7_A   :  BIT_RES(7, r_A); AddCycles( 4+4 ); break;
  276.  
  277.   case  SET_0_B   :  BIT_SET(0, r_B); AddCycles( 4+4 ); break;
  278.   case  SET_0_C   :  BIT_SET(0, r_C); AddCycles( 4+4 ); break;
  279.   case  SET_0_D   :  BIT_SET(0, r_D); AddCycles( 4+4 ); break;
  280.   case  SET_0_E   :  BIT_SET(0, r_E); AddCycles( 4+4 ); break;
  281.   case  SET_0_H   :  BIT_SET(0, r_H); AddCycles( 4+4 ); break;
  282.   case  SET_0_L   :  BIT_SET(0, r_L); AddCycles( 4+4 ); break;
  283.   case  SET_0_xHL :  BIT_mem_SET(0, r_HL); AddCycles( 4+4+7 ); break;
  284.   case  SET_0_A   :  BIT_SET(0, r_A); AddCycles( 4+4 ); break;
  285.  
  286.   case  SET_1_B   :  BIT_SET(1, r_B); AddCycles( 4+4 ); break;
  287.   case  SET_1_C   :  BIT_SET(1, r_C); AddCycles( 4+4 ); break;
  288.   case  SET_1_D   :  BIT_SET(1, r_D); AddCycles( 4+4 ); break;
  289.   case  SET_1_E   :  BIT_SET(1, r_E); AddCycles( 4+4 ); break;
  290.   case  SET_1_H   :  BIT_SET(1, r_H); AddCycles( 4+4 ); break;
  291.   case  SET_1_L   :  BIT_SET(1, r_L); AddCycles( 4+4 ); break;
  292.   case  SET_1_xHL :  BIT_mem_SET(1, r_HL); AddCycles( 4+4+7 ); break;
  293.   case  SET_1_A   :  BIT_SET(1, r_A); AddCycles( 4+4 ); break;
  294.  
  295.   case  SET_2_B   :  BIT_SET(2, r_B); AddCycles( 4+4 ); break;
  296.   case  SET_2_C   :  BIT_SET(2, r_C); AddCycles( 4+4 ); break;
  297.   case  SET_2_D   :  BIT_SET(2, r_D); AddCycles( 4+4 ); break;
  298.   case  SET_2_E   :  BIT_SET(2, r_E); AddCycles( 4+4 ); break;
  299.   case  SET_2_H   :  BIT_SET(2, r_H); AddCycles( 4+4 ); break;
  300.   case  SET_2_L   :  BIT_SET(2, r_L); AddCycles( 4+4 ); break;
  301.   case  SET_2_xHL :  BIT_mem_SET(2, r_HL); AddCycles( 4+4+7 ); break;
  302.   case  SET_2_A   :  BIT_SET(2, r_A); AddCycles( 4+4 ); break;
  303.  
  304.   case  SET_3_B   :  BIT_SET(3, r_B); AddCycles( 4+4 ); break;
  305.   case  SET_3_C   :  BIT_SET(3, r_C); AddCycles( 4+4 ); break;
  306.   case  SET_3_D   :  BIT_SET(3, r_D); AddCycles( 4+4 ); break;
  307.   case  SET_3_E   :  BIT_SET(3, r_E); AddCycles( 4+4 ); break;
  308.   case  SET_3_H   :  BIT_SET(3, r_H); AddCycles( 4+4 ); break;
  309.   case  SET_3_L   :  BIT_SET(3, r_L); AddCycles( 4+4 ); break;
  310.   case  SET_3_xHL :  BIT_mem_SET(3, r_HL); AddCycles( 4+4+7 ); break;
  311.   case  SET_3_A   :  BIT_SET(3, r_A); AddCycles( 4+4 ); break;
  312.  
  313.   case  SET_4_B   :  BIT_SET(4, r_B); AddCycles( 4+4 ); break;
  314.   case  SET_4_C   :  BIT_SET(4, r_C); AddCycles( 4+4 ); break;
  315.   case  SET_4_D   :  BIT_SET(4, r_D); AddCycles( 4+4 ); break;
  316.   case  SET_4_E   :  BIT_SET(4, r_E); AddCycles( 4+4 ); break;
  317.   case  SET_4_H   :  BIT_SET(4, r_H); AddCycles( 4+4 ); break;
  318.   case  SET_4_L   :  BIT_SET(4, r_L); AddCycles( 4+4 ); break;
  319.   case  SET_4_xHL :  BIT_mem_SET(4, r_HL); AddCycles( 4+4+7 ); break;
  320.   case  SET_4_A   :  BIT_SET(4, r_A); AddCycles( 4+4 ); break;
  321.  
  322.   case  SET_5_B   :  BIT_SET(5, r_B); AddCycles( 4+4 ); break;
  323.   case  SET_5_C   :  BIT_SET(5, r_C); AddCycles( 4+4 ); break;
  324.   case  SET_5_D   :  BIT_SET(5, r_D); AddCycles( 4+4 ); break;
  325.   case  SET_5_E   :  BIT_SET(5, r_E); AddCycles( 4+4 ); break;
  326.   case  SET_5_H   :  BIT_SET(5, r_H); AddCycles( 4+4 ); break;
  327.   case  SET_5_L   :  BIT_SET(5, r_L); AddCycles( 4+4 ); break;
  328.   case  SET_5_xHL :  BIT_mem_SET(5, r_HL); AddCycles( 4+4+7 ); break;
  329.   case  SET_5_A   :  BIT_SET(5, r_A); AddCycles( 4+4 ); break;
  330.  
  331.   case  SET_6_B   :  BIT_SET(6, r_B); AddCycles( 4+4 ); break;
  332.   case  SET_6_C   :  BIT_SET(6, r_C); AddCycles( 4+4 ); break;
  333.   case  SET_6_D   :  BIT_SET(6, r_D); AddCycles( 4+4 ); break;
  334.   case  SET_6_E   :  BIT_SET(6, r_E); AddCycles( 4+4 ); break;
  335.   case  SET_6_H   :  BIT_SET(6, r_H); AddCycles( 4+4 ); break;
  336.   case  SET_6_L   :  BIT_SET(6, r_L); AddCycles( 4+4 ); break;
  337.   case  SET_6_xHL :  BIT_mem_SET(6, r_HL); AddCycles( 4+4+7 ); break;
  338.   case  SET_6_A   :  BIT_SET(6, r_A); AddCycles( 4+4 ); break;
  339.  
  340.   case  SET_7_B   :  BIT_SET(7, r_B); AddCycles( 4+4 ); break;
  341.   case  SET_7_C   :  BIT_SET(7, r_C); AddCycles( 4+4 ); break;
  342.   case  SET_7_D   :  BIT_SET(7, r_D); AddCycles( 4+4 ); break;
  343.   case  SET_7_E   :  BIT_SET(7, r_E); AddCycles( 4+4 ); break;
  344.   case  SET_7_H   :  BIT_SET(7, r_H); AddCycles( 4+4 ); break;
  345.   case  SET_7_L   :  BIT_SET(7, r_L); AddCycles( 4+4 ); break;
  346.   case  SET_7_xHL :  BIT_mem_SET(7, r_HL); AddCycles( 4+4+7 ); break;
  347.   case  SET_7_A   :  BIT_SET(7, r_A); AddCycles( 4+4 ); break;
  348.  
  349.   default:
  350. //    exit(1);
  351. ///!!!   if( regs->DecodingErrors )
  352. ///!!!    printf("z80 core: Unknown instruction: CB %02Xh at PC=%04Xh.\n",
  353. ///!!!            Z80ReadMem(r_PC-1), r_PC-2 );
  354.     break;
  355. }
  356.  
  357.