Subversion Repositories Kolibri OS

Rev

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

  1. /*====================================================================/*
  2.   opcodes.c -> This file executes the single-byte Z80 opcodes.
  3.  
  4.   The CPU fetchs the byte pointed by the PC register (Program Counter)
  5.   into de IR (Instruction Register) and decodes it. The value of this
  6.   fetched byte (opcode) determines what operation the CPU must do.
  7.   On Z80 (which uses 8 bit for the IW register) this means that we
  8.   can have 256 (2^8) different opcodes. The z80 uses a simple trick
  9.   called PREFIXES to obtain more opcodes by using more than one byte
  10.   in the decoding (see opcodes_cb.c to know how it does it).
  11.  
  12.   This file executes the whole list of single-byte opcodes.
  13.  
  14.  This program 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.  This program 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 this program; if not, write to the Free Software
  26.  Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  27.  
  28.  Copyright (c) 2000 Santiago Romero Iglesias.
  29.  Email: sromero@escomposlinux.org
  30.  =====================================================================*/
  31.  
  32. /* About the AddCycles(4) -> Remember that reading from memory
  33.                              takes 3 cycles plus 1 of the decoding.
  34.                              Add 3 cycles for each operand fetch, and
  35.                              3 more for each memory write/read. */
  36.  
  37.  
  38. case  NOP       :  AddCycles( 4 ); break;
  39. case  LD_BC_NN  :  LD_rr_nn(r_BC); AddCycles( 4+3+3 ); break;
  40. case  LD_xBC_A  :  STORE_r(r_BC, r_A); AddCycles( 4+3 ); break;
  41. case  INC_BC    :  r_BC++; AddCycles( 4+2 ); break;
  42.  
  43. case  INC_B     :  INC(r_B); AddCycles( 4 ); break;
  44. case  DEC_B     :  DEC(r_B); AddCycles( 4 ); break;
  45.  
  46. case  LD_B_N    :  LD_r_n(r_B);
  47.                    AddCycles( 4+3 );
  48.                    break;
  49.  
  50. case  EX_AF_AF  :  EX_WORD(r_AF, r_AFs);
  51.                    AddCycles( 4 );
  52.                    break;
  53.  
  54. case  LD_A_xBC  :  LOAD_r(r_A, r_BC);
  55.                    AddCycles( 4+3 );
  56.                    break;
  57.  
  58. case  DEC_BC    :  r_BC--;
  59.                    AddCycles( 4+2 );
  60.                    break;
  61.  
  62. case  INC_C     :  INC(r_C);
  63.                    AddCycles( 4 );
  64.                    break;
  65.  
  66. case  DEC_C     :  DEC(r_C);
  67.                    AddCycles( 4 );
  68.                    break;
  69.  
  70. case  LD_C_N    :  LD_r_n(r_C);
  71.                    AddCycles( 4+3 );
  72.                    break;
  73.  
  74. case  LD_DE_NN  :  LD_rr_nn(r_DE);
  75.                    AddCycles( 4+3+3 );
  76.                    break;
  77.  
  78. case  LD_xDE_A  :  STORE_r(r_DE, r_A);
  79.                    AddCycles( 4+3 );
  80.                    break;
  81.  
  82. case  INC_DE    :  r_DE++;
  83.                    AddCycles( 4+2 );
  84.                    break;
  85.  
  86. case  INC_D     :  INC(r_D);
  87.                    AddCycles( 4 );
  88.                    break;
  89.  
  90. case  DEC_D     :  DEC(r_D);
  91.                    AddCycles( 4 );
  92.                    break;
  93.  
  94. case  LD_D_N    :  LD_r_n(r_D);
  95.                    AddCycles( 4+3 );
  96.                    break;
  97.  
  98. case  ADD_HL_BC :  ADD_WORD(r_HL, r_BC); AddCycles( 4+3+3+1 ); break;
  99. case  ADD_HL_DE :  ADD_WORD(r_HL, r_DE); AddCycles( 4+3+3+1 ); break;
  100. case  ADD_HL_HL :  ADD_WORD(r_HL, r_HL); AddCycles( 4+3+3+1 ); break;
  101. case  ADD_HL_SP :  ADD_WORD(r_HL, r_SP); AddCycles( 4+3+3+1 ); break;
  102.  
  103. case  LD_A_xDE  :  LOAD_r(r_A, r_DE);
  104.                    AddCycles( 4+3 );
  105.                    break;
  106.  
  107. case  DEC_DE    :  r_DE--;
  108.                    AddCycles( 4+2 );
  109.                    break;
  110.  
  111. case  INC_E     :  INC(r_E);
  112.                    AddCycles( 4 );
  113.                    break;
  114.  
  115. case  DEC_E     :  DEC(r_E);
  116.                    AddCycles( 4 );
  117.                    break;
  118.  
  119. case  LD_E_N    :  LD_r_n(r_E);
  120.                    AddCycles( 4+3 );
  121.                    break;
  122.  
  123. case  LD_HL_NN  :  LD_rr_nn(r_HL);
  124.                    AddCycles( 4+3+3 );
  125.                    break;
  126.  
  127. case  LD_xNN_HL :  STORE_nn_rr(r_HL);
  128.                    AddCycles( 4+3+3+3+3 );
  129.                    break;
  130.  
  131. case  INC_HL    :  r_HL++;
  132.                    AddCycles( 4+2 );
  133.                    break;
  134.  
  135. case  INC_H     :  INC(r_H);
  136.                    AddCycles( 4 );
  137.                    break;
  138.  
  139. case  DEC_H     :  DEC(r_H);
  140.                    AddCycles( 4 );
  141.                    break;
  142.  
  143. case  LD_H_N    :  LD_r_n(r_H);
  144.                    AddCycles( 4+3 );
  145.                    break;
  146.  
  147. case  LD_HL_xNN :  LOAD_rr_nn(r_HL);
  148.                    AddCycles( 4+3+3+3+3 );
  149.                    break;
  150.  
  151. case  DEC_HL    :  r_HL--;
  152.                    AddCycles( 4+2 );
  153.                    break;
  154.  
  155. case  INC_L     :  INC(r_L);
  156.                    AddCycles( 4 );
  157.                    break;
  158.  
  159. case  DEC_L     :  DEC(r_L);
  160.                    AddCycles( 4 );
  161.                    break;
  162.  
  163. case  LD_L_N    :  LD_r_n(r_L);
  164.                    AddCycles( 4+3 );
  165.                    break;
  166.  
  167. case  LD_SP_NN  :  LD_rr_nn(r_SP);
  168.                    AddCycles( 10 );
  169.                    break;
  170.  
  171. case  LD_xNN_A  :  STORE_nn_r(r_A);
  172.                    AddCycles( 13 );
  173.                    break;
  174.  
  175. case  INC_SP    :  r_SP++;
  176.                    AddCycles( 6 );
  177.                    break;
  178.  
  179. case  LD_xHL_N  :  r_meml = Z80ReadMem(r_PC); r_PC++;
  180.                    STORE_r( r_HL, r_meml );
  181.                    AddCycles( 10 );
  182.                    break;
  183.  
  184. case  LD_A_xNN  :  LOAD_r_nn( r_A );
  185.                    AddCycles( 13 );
  186.                    break;
  187.  
  188. case  DEC_SP    :  r_SP--;
  189.                    AddCycles( 6 );
  190.                    break;
  191.  
  192. case  INC_A     :  INC(r_A);
  193.                    AddCycles( 4 );
  194.                    break;
  195.  
  196. case  DEC_A     :  DEC(r_A);
  197.                    AddCycles( 4 );
  198.                    break;
  199.  
  200. case  LD_A_N    :  LD_r_n(r_A);
  201.                    AddCycles( 4+3 );
  202.                    break;
  203.  
  204. case  LD_B_B    :  LD_r_r( r_B, r_B );
  205.                    AddCycles( 4 );
  206.                    break;
  207.  
  208. case  LD_B_C    :  LD_r_r( r_B, r_C );
  209.                    AddCycles( 4 );
  210.                    break;
  211.  
  212. case  LD_B_D    :  LD_r_r( r_B, r_D );
  213.                    AddCycles( 4 );
  214.                    break;
  215.  
  216. case  LD_B_E    :  LD_r_r( r_B, r_E );
  217.                    AddCycles( 4 );
  218.                    break;
  219.  
  220. case  LD_B_H    :  LD_r_r( r_B, r_H );
  221.                    AddCycles( 4 );
  222.                    break;
  223.  
  224. case  LD_B_L    :  LD_r_r( r_B, r_L );
  225.                    AddCycles( 4 );
  226.                    break;
  227.  
  228. case  LD_B_xHL  :  LOAD_r(r_B, r_HL);
  229.                    AddCycles( 4+3 );
  230.                    break;
  231.  
  232. case  LD_B_A    :  LD_r_r( r_B, r_A );
  233.                    AddCycles( 4 );
  234.                    break;
  235.  
  236. case  LD_C_B    :  LD_r_r( r_C, r_B );
  237.                    AddCycles( 4 );
  238.                    break;
  239.  
  240. case  LD_C_C    :  LD_r_r( r_C, r_C );
  241.                    AddCycles( 4 );
  242.                    break;
  243.  
  244. case  LD_C_D    :  LD_r_r( r_C, r_D );
  245.                    AddCycles( 4 );
  246.                    break;
  247.  
  248. case  LD_C_E    :  LD_r_r( r_C, r_E );
  249.                    AddCycles( 4 );
  250.                    break;
  251. case  LD_C_H    :  LD_r_r( r_C, r_H );
  252.                    AddCycles( 4 );
  253.                    break;
  254.  
  255. case  LD_C_L    :  LD_r_r( r_C, r_L );
  256.                    AddCycles( 4 );
  257.                    break;
  258.  
  259. case  LD_C_xHL  :  LOAD_r(r_C, r_HL);
  260.                    AddCycles( 4+3 );
  261.                    break;
  262.  
  263. case  LD_C_A    :  LD_r_r( r_C, r_A );
  264.                    AddCycles( 4 );
  265.                    break;
  266.  
  267. case  LD_D_B    :  LD_r_r( r_D, r_B );
  268.                    AddCycles( 4 );
  269.                    break;
  270.  
  271. case  LD_D_C    :  LD_r_r( r_D, r_C );
  272.                    AddCycles( 4 );
  273.                    break;
  274.  
  275. case  LD_D_D    :  LD_r_r( r_D, r_D );
  276.                    AddCycles( 4 );
  277.                    break;
  278.  
  279. case  LD_D_E    :  LD_r_r( r_D, r_E );
  280.                    AddCycles( 4 );
  281.                    break;
  282.  
  283. case  LD_D_H    :  LD_r_r( r_D, r_H );
  284.                    AddCycles( 4 );
  285.                    break;
  286.  
  287. case  LD_D_L    :  LD_r_r( r_D, r_L );
  288.                    AddCycles( 4 );
  289.                    break;
  290.  
  291. case  LD_D_xHL  :  LOAD_r(r_D, r_HL);
  292.                    AddCycles( 4+3 );
  293.                    break;
  294.  
  295. case  LD_D_A    :  LD_r_r( r_D, r_A );
  296.                    AddCycles( 4 );
  297.                    break;
  298.  
  299. case  LD_E_B    :  LD_r_r( r_E, r_B );
  300.                    AddCycles( 4 );
  301.                    break;
  302.  
  303. case  LD_E_C    :  LD_r_r( r_E, r_C );
  304.                    AddCycles( 4 );
  305.                    break;
  306.  
  307. case  LD_E_D    :  LD_r_r( r_E, r_D );
  308.                    AddCycles( 4 );
  309.                    break;
  310.  
  311. case  LD_E_E    :  LD_r_r( r_E, r_E );
  312.                    AddCycles( 4 );
  313.                    break;
  314.  
  315. case  LD_E_H    :  LD_r_r( r_E, r_H );
  316.                    AddCycles( 4 );
  317.                    break;
  318.  
  319. case  LD_E_L    :  LD_r_r( r_E, r_L );
  320.                    AddCycles( 4 );
  321.                    break;
  322.  
  323. case  LD_E_xHL  :  LOAD_r(r_E, r_HL);
  324.                    AddCycles( 4+3 );
  325.                    break;
  326.  
  327. case  LD_E_A    :  LD_r_r( r_E, r_A );
  328.                    AddCycles( 4 );
  329.                    break;
  330.  
  331. case  LD_H_B    :  LD_r_r( r_H, r_B );
  332.                    AddCycles( 4 );
  333.                    break;
  334.  
  335. case  LD_H_C    :  LD_r_r( r_H, r_C );
  336.                    AddCycles( 4 );
  337.                    break;
  338.  
  339. case  LD_H_D    :  LD_r_r( r_H, r_D );
  340.                    AddCycles( 4 );
  341.                    break;
  342.  
  343. case  LD_H_E    :  LD_r_r( r_H, r_E );
  344.                    AddCycles( 4 );
  345.                    break;
  346.  
  347. case  LD_H_H    :  LD_r_r( r_H, r_H );
  348.                    AddCycles( 4 );
  349.                    break;
  350.  
  351. case  LD_H_L    :  LD_r_r( r_H, r_L );
  352.                    AddCycles( 4 );
  353.                    break;
  354.  
  355. case  LD_H_xHL  :  LOAD_r(r_H, r_HL);
  356.                    AddCycles( 4+3 );
  357.                    break;
  358.  
  359. case  LD_H_A    :  LD_r_r( r_H, r_A );
  360.                    AddCycles( 4 );
  361.                    break;
  362.  
  363. case  LD_L_B    :  LD_r_r( r_L, r_B );
  364.                    AddCycles( 4 );
  365.                    break;
  366.  
  367. case  LD_L_C    :  LD_r_r( r_L, r_C );
  368.                    AddCycles( 4 );
  369.                    break;
  370.  
  371. case  LD_L_D    :  LD_r_r( r_L, r_D );
  372.                    AddCycles( 4 );
  373.                    break;
  374.  
  375. case  LD_L_E    :  LD_r_r( r_L, r_E );
  376.                    AddCycles( 4 );
  377.                    break;
  378.  
  379. case  LD_L_H    :  LD_r_r( r_L, r_H );
  380.                    AddCycles( 4 );
  381.                    break;
  382.  
  383. case  LD_L_L    :  LD_r_r( r_L, r_L );
  384.                    AddCycles( 4 );
  385.                    break;
  386.  
  387. case  LD_L_xHL  :  LOAD_r(r_L, r_HL);
  388.                    AddCycles( 7 );
  389.                    break;
  390.  
  391. case  LD_L_A    :  LD_r_r( r_L, r_A );
  392.                    AddCycles( 4 );
  393.                    break;
  394.  
  395. case  LD_xHL_B  :  STORE_r( r_HL, r_B );
  396.                    AddCycles( 4+3 );
  397.                    break;
  398.  
  399. case  LD_xHL_C  :  STORE_r( r_HL, r_C );
  400.                    AddCycles( 4+3 );
  401.                    break;
  402.  
  403. case  LD_xHL_D  :  STORE_r( r_HL, r_D );
  404.                    AddCycles( 4+3 );
  405.                    break;
  406.  
  407. case  LD_xHL_E  :  STORE_r( r_HL, r_E );
  408.                    AddCycles( 4+3 );
  409.                    break;
  410.  
  411. case  LD_xHL_H  :  STORE_r( r_HL, r_H );
  412.                    AddCycles( 4+3 );
  413.                    break;
  414.  
  415. case  LD_xHL_L  :  STORE_r( r_HL, r_L );
  416.                    AddCycles( 4+3 );
  417.                    break;
  418.  
  419. case  LD_xHL_A  :  STORE_r(r_HL, r_A );
  420.                    AddCycles( 4+3 );
  421.                    break;
  422.  
  423. case  LD_A_B    :  LD_r_r( r_A, r_B );
  424.                    AddCycles( 4 );
  425.                    break;
  426.  
  427. case  LD_A_C    :  LD_r_r( r_A, r_C );
  428.                    AddCycles( 4 );
  429.                    break;
  430.  
  431. case  LD_A_D    :  LD_r_r( r_A, r_D );
  432.                    AddCycles( 4 );
  433.                    break;
  434.  
  435. case  LD_A_E    :  LD_r_r( r_A, r_E );
  436.                    AddCycles( 4 );
  437.                    break;
  438.  
  439. case  LD_A_H    :  LD_r_r( r_A, r_H );
  440.                    AddCycles( 4 );
  441.                    break;
  442.  
  443. case  LD_A_L    :  LD_r_r( r_A, r_L );
  444.                    AddCycles( 4 );
  445.                    break;
  446.  
  447. case  LD_A_xHL  :  LOAD_r( r_A, r_HL);
  448.                    AddCycles( 4+3 );
  449.                    break;
  450.  
  451. case  LD_A_A    :  LD_r_r( r_A, r_A );
  452.                    AddCycles( 4 );
  453.                    break;
  454.  
  455. case  LD_SP_HL  :  LD_r_r( r_SP, r_HL );
  456.                    AddCycles( 6 ); break;
  457.  
  458. case  ADD_B     :  ADD(r_B); AddCycles( 4 ); break;
  459. case  ADD_C     :  ADD(r_C); AddCycles( 4 ); break;
  460. case  ADD_D     :  ADD(r_D); AddCycles( 4 ); break;
  461. case  ADD_E     :  ADD(r_E); AddCycles( 4 ); break;
  462. case  ADD_H     :  ADD(r_H); AddCycles( 4 ); break;
  463. case  ADD_L     :  ADD(r_L); AddCycles( 4 ); break;
  464. case  ADD_xHL   :  r_meml = Z80ReadMem(r_HL);
  465.                    ADD(r_meml);
  466.                    AddCycles( 4+3 );
  467.                    break;
  468. case  ADD_A     :  ADD(r_A); AddCycles( 4 ); break;
  469. case  ADC_B     :  ADC(r_B); AddCycles( 4 ); break;
  470. case  ADC_C     :  ADC(r_C); AddCycles( 4 ); break;
  471. case  ADC_D     :  ADC(r_D); AddCycles( 4 ); break;
  472. case  ADC_E     :  ADC(r_E); AddCycles( 4 ); break;
  473. case  ADC_H     :  ADC(r_H); AddCycles( 4 ); break;
  474. case  ADC_L     :  ADC(r_L); AddCycles( 4 ); break;
  475. case  ADC_xHL   :  r_meml = Z80ReadMem(r_HL);
  476.                    ADC(r_meml);
  477.                    AddCycles( 4+3 );
  478.                    break;
  479. case  ADC_A     :  ADC(r_A); AddCycles( 4 ); break;
  480. case  ADC_N     :  r_meml = Z80ReadMem(r_PC); r_PC++;
  481.                    ADC(r_meml);
  482.                    AddCycles( 4+3 );
  483.                    break;
  484.  
  485. case  SUB_A     :  SUB(r_A); AddCycles( 4 ); break;
  486. case  SUB_B     :  SUB(r_B); AddCycles( 4 ); break;
  487. case  SUB_C     :  SUB(r_C); AddCycles( 4 ); break;
  488. case  SUB_D     :  SUB(r_D); AddCycles( 4 ); break;
  489. case  SUB_E     :  SUB(r_E); AddCycles( 4 ); break;
  490. case  SUB_H     :  SUB(r_H); AddCycles( 4 ); break;
  491. case  SUB_L     :  SUB(r_L); AddCycles( 4 ); break;
  492. case  SUB_xHL   :  r_meml = Z80ReadMem(r_HL);
  493.                    SUB(r_meml);
  494.                    AddCycles( 4+3 );
  495.                    break;
  496. case  SUB_N     :  r_meml = Z80ReadMem(r_PC); r_PC++;
  497.                    SUB(r_meml);
  498.                    AddCycles( 4+3 );
  499.                    break;
  500.  
  501. case  SBC_A     :  SBC(r_A); AddCycles( 4 ); break;
  502. case  SBC_B     :  SBC(r_B); AddCycles( 4 ); break;
  503. case  SBC_C     :  SBC(r_C); AddCycles( 4 ); break;
  504. case  SBC_D     :  SBC(r_D); AddCycles( 4 ); break;
  505. case  SBC_E     :  SBC(r_E); AddCycles( 4 ); break;
  506. case  SBC_H     :  SBC(r_H); AddCycles( 4 ); break;
  507. case  SBC_L     :  SBC(r_L); AddCycles( 4 ); break;
  508. case  SBC_xHL   :  r_meml = Z80ReadMem(r_HL);
  509.                    SBC(r_meml);
  510.                    AddCycles( 4+3 );
  511.                    break;
  512. case  SBC_N     :  r_meml = Z80ReadMem(r_PC); r_PC++;
  513.                    SBC(r_meml);
  514.                    AddCycles( 4 );
  515.                    break;
  516.  
  517. case  AND_B     :  AND( r_B ); AddCycles( 4 ); break;
  518. case  AND_C     :  AND( r_C ); AddCycles( 4 ); break;
  519. case  AND_D     :  AND( r_D ); AddCycles( 4 ); break;
  520. case  AND_E     :  AND( r_E ); AddCycles( 4 ); break;
  521. case  AND_H     :  AND( r_H ); AddCycles( 4 ); break;
  522. case  AND_L     :  AND( r_L ); AddCycles( 4 ); break;
  523. case  AND_xHL   :  AND_mem( r_HL ); AddCycles( 4+3 ); break;
  524. case  AND_A     :  AND( r_A ); AddCycles( 4 ); break;
  525. case  XOR_B     :  XOR( r_B ); AddCycles( 4 ); break;
  526. case  XOR_C     :  XOR( r_C ); AddCycles( 4 ); break;
  527. case  XOR_D     :  XOR( r_D ); AddCycles( 4 ); break;
  528. case  XOR_E     :  XOR( r_E ); AddCycles( 4 ); break;
  529. case  XOR_H     :  XOR( r_H ); AddCycles( 4 ); break;
  530. case  XOR_L     :  XOR( r_L ); AddCycles( 4 ); break;
  531. case  XOR_xHL   :  XOR_mem( r_HL ); AddCycles( 4+3 ); break;
  532. case  XOR_A     :  XOR( r_A ); AddCycles( 4 ); break;
  533. case  OR_B      :  OR( r_B ); AddCycles( 4 ); break;
  534. case  OR_C      :  OR( r_C ); AddCycles( 4 ); break;
  535. case  OR_D      :  OR( r_D ); AddCycles( 4 ); break;
  536. case  OR_E      :  OR( r_E ); AddCycles( 4 ); break;
  537. case  OR_H      :  OR( r_H ); AddCycles( 4 ); break;
  538. case  OR_L      :  OR( r_L ); AddCycles( 4 ); break;
  539. case  OR_xHL    :  OR_mem( r_HL ); AddCycles( 4+3 ); break;
  540. case  OR_A      :  OR( r_A ); AddCycles( 4 ); break;
  541. case  CP_A      :  CP(r_A); AddCycles( 4 ); break;
  542. case  CP_B      :  CP(r_B); AddCycles( 4 ); break;
  543. case  CP_C      :  CP(r_C); AddCycles( 4 ); break;
  544. case  CP_D      :  CP(r_D); AddCycles( 4 ); break;
  545. case  CP_E      :  CP(r_E); AddCycles( 4 ); break;
  546. case  CP_H      :  CP(r_H); AddCycles( 4 ); break;
  547. case  CP_L      :  CP(r_L); AddCycles( 4 ); break;
  548. case  CP_xHL    :  r_meml = Z80ReadMem( r_HL );
  549.                    CP(r_meml); AddCycles( 4+3 ); break;
  550. case  CP_N      :  r_meml = Z80ReadMem(r_PC); r_PC++;
  551.                    CP(r_meml);
  552.                    AddCycles( 4+3);
  553.                    break;
  554.  
  555. case  RET_Z     :  if( TEST_FLAG(Z_FLAG) )
  556.                    { RET_nn(); AddCycles( 4+1+3+3 ); }
  557.                    else { AddCycles( 4+1 ); }
  558.                    break;
  559.  
  560. case  RET_C     :  if( TEST_FLAG(C_FLAG) )
  561.                    { RET_nn(); AddCycles( 4+1+3+3 ); }
  562.                    else { AddCycles( 4+1 ); }
  563.                    break;
  564.  
  565. case  RET_M     :  if( TEST_FLAG(S_FLAG) )
  566.                    { RET_nn(); AddCycles( 4+1+3+3 ); }
  567.                    else { AddCycles( 4+1 ); }
  568.                    break;
  569.  
  570. case  RET_PE    :  if( TEST_FLAG(P_FLAG) )
  571.                    { RET_nn(); AddCycles( 4+1+3+3 ); }
  572.                    else { AddCycles( 4+1 ); }
  573.                    break;
  574.  
  575. case  RET_PO    :  if( TEST_FLAG(P_FLAG) )
  576.                    { AddCycles( 4+1 ); }
  577.                    else { RET_nn(); AddCycles( 4+1+3+3 ); }
  578.                    break;
  579.  
  580. case  RET_P     :  if( TEST_FLAG(S_FLAG) )
  581.                    { AddCycles( 4+1 ); }
  582.                    else { RET_nn(); AddCycles( 4+1+3+3 ); }
  583.                    break;
  584.  
  585. case  RET       :  RET_nn();
  586.                    AddCycles( 4+3+3 );
  587.                    break;
  588.  
  589. case  RET_NZ    :  if( TEST_FLAG(Z_FLAG) )
  590.                    { AddCycles( 4+1 ); }
  591.                    else { RET_nn(); AddCycles( 4+1+3+3 ); }
  592.                    break;
  593.  
  594. case  RET_NC    :  if( TEST_FLAG(C_FLAG) )
  595.                    { AddCycles( 4+1 ); }
  596.                    else { RET_nn(); AddCycles( 4+1+3+3 ); }
  597.                    break;
  598.  
  599. case  ADD_N     :  r_meml = Z80ReadMem(r_PC); r_PC++;
  600.                    ADD(r_meml);
  601.                    AddCycles( 4+3 );
  602.                    break;
  603.  
  604. case  JR        :  JR_n();
  605.                    AddCycles( 4+3+3+2 );
  606.                    break;
  607.  
  608. case  JR_NZ     :  if( TEST_FLAG(Z_FLAG) )
  609.                    { r_PC++;  AddCycles( 4+3 ); }
  610.                    else
  611.                    { JR_n();  AddCycles( 4+8 ); }
  612.                    break;
  613.  
  614. case  JR_Z      :  if( TEST_FLAG(Z_FLAG) )
  615.                    { JR_n();  AddCycles( 4+8 ); }
  616.                    else
  617.                    { r_PC++;  AddCycles( 4+3 ); }
  618.                    break;
  619.  
  620. case  JR_NC     :  if( TEST_FLAG(C_FLAG) )
  621.                    { r_PC++;  AddCycles( 4+3 ); }
  622.                    else
  623.                    { JR_n();  AddCycles( 4+8 ); }
  624.                    break;
  625.  
  626. case  JR_C      :  if( TEST_FLAG(C_FLAG) )
  627.                    { JR_n();  AddCycles( 4+8 ); }
  628.                    else
  629.                    { r_PC++;  AddCycles( 4+3 ); }
  630.                    break;
  631.  
  632. case  JP_NZ     :  if( TEST_FLAG(Z_FLAG) ) { r_PC += 2; }
  633.                    else                    { JP_nn();   }
  634.                    AddCycles( 4+3+3 );
  635.                    break;
  636.  
  637. case  JP        :  JP_nn();
  638.                    AddCycles( 4+3+3 );
  639.                    break;
  640.  
  641. case  JP_Z      :  if( TEST_FLAG(Z_FLAG) ) { JP_nn();   }
  642.                    else                    { r_PC += 2; }
  643.                    AddCycles( 4+3+3 );
  644.                    break;
  645.  
  646. case  JP_NC     :  if( TEST_FLAG(C_FLAG) ) { r_PC += 2; }
  647.                    else                    { JP_nn();   }
  648.                    AddCycles( 4+3+3 );
  649.                    break;
  650.  
  651. case  JP_C      :  if( TEST_FLAG(C_FLAG) ) { JP_nn();   }
  652.                    else                    { r_PC += 2; }
  653.                    AddCycles( 4+3+3 );
  654.                    break;
  655.  
  656. case  JP_PO     :  if( TEST_FLAG(P_FLAG) ) { r_PC += 2; }
  657.                    else                    { JP_nn();   }
  658.                    AddCycles( 4+3+3 );
  659.                    break;
  660.  
  661. case  JP_PE     :  if( TEST_FLAG(P_FLAG) ) { JP_nn();   }
  662.                    else                    { r_PC += 2; }
  663.                    AddCycles( 4+3+3 );
  664.                    break;
  665.  
  666. case  JP_P      :  if( TEST_FLAG(S_FLAG) ) { r_PC += 2; }
  667.                    else                    { JP_nn();   }
  668.                    AddCycles( 4+3+3 );
  669.                    break;
  670.  
  671.  
  672. case  JP_M      :  if( TEST_FLAG(S_FLAG) ) { JP_nn();   }
  673.                    else                    { r_PC += 2; }
  674.                    AddCycles( 4+3+3 );
  675.                    break;
  676.  
  677. case  JP_xHL    :  r_PC = r_HL; AddCycles( 4 ); break;
  678.  
  679. case  CPL       :  r_A ^= 0xFF;
  680.                    r_F = ( r_F & (FLAG_C|FLAG_P|FLAG_Z|FLAG_S)) |
  681.                          ( r_A & (FLAG_3|FLAG_5))|(FLAG_N|FLAG_H);
  682.                    AddCycles( 4 ); break;
  683.  
  684. case  INC_xHL   :  r_meml = Z80ReadMem( r_HL );
  685.                    INC(r_meml);
  686.                    Z80WriteMem( r_HL, r_meml, regs );
  687.                    AddCycles( 4+3+3+1 ); break;
  688.  
  689. case  DEC_xHL   :  r_meml = Z80ReadMem( r_HL );
  690.                    DEC(r_meml);
  691.                    Z80WriteMem( r_HL, r_meml, regs );
  692.                    AddCycles( 4+3+3+1 ); break;
  693.  
  694. case  SCF       :  r_F = r_F | FLAG_C;
  695.                    r_F &= FLAG_Z | FLAG_S | FLAG_P;
  696.                    if(r_F & FLAG_H) r_F ^= FLAG_H;
  697.                    r_F |= FLAG_C;
  698.                    AddCycles( 4 ); break;
  699.  
  700. case  CCF       :  r_F = (r_F & (FLAG_P|FLAG_Z|FLAG_S) )    |
  701.                          ((r_F & FLAG_C) ? FLAG_H : FLAG_C) |
  702.                          ( r_A & (FLAG_3 | FLAG_5) );
  703.                    AddCycles( 4 ); break;
  704.  
  705. case HALT       : regs->halted = 1;
  706.                   AddCycles(4);
  707.                   break;
  708.  
  709. case  POP_BC    :  POP(BC);  AddCycles( 10 ); break;
  710. case  PUSH_BC   :  PUSH(BC); AddCycles( 11 ); break;
  711. case  POP_HL    :  POP(HL);  AddCycles( 10 ); break;
  712. case  PUSH_HL   :  PUSH(HL); AddCycles( 11 ); break;
  713. case  POP_AF    :  POP(AF);  AddCycles( 10 ); break;
  714. case  PUSH_AF   :  PUSH(AF); AddCycles( 11 ); break;
  715. case  POP_DE    :  POP(DE);  AddCycles( 10 ); break;
  716. case  PUSH_DE   :  PUSH(DE); AddCycles( 11 ); break;
  717.  
  718. case  RLCA      :  r_A = (r_A << 1) | (r_A >> 7);
  719.                    r_F = ( r_F & (FLAG_P|FLAG_Z|FLAG_S)) |
  720.                          ( r_A & (FLAG_C|FLAG_3|FLAG_5) );
  721.                    AddCycles( 4 ); break;
  722.  
  723. case  RRCA      :  r_F = ( r_F & (FLAG_P|FLAG_Z|FLAG_S)) |
  724.                          ( r_A & FLAG_C );
  725.                    r_A = ( r_A >> 1) | ( r_A << 7 );
  726.                    r_F |= ( r_A & ( FLAG_3 | FLAG_5 ) );
  727.                    AddCycles( 4 ); break;
  728.  
  729. case  DJNZ      :  r_B--;
  730.                    if( r_B )   { JR_n();  AddCycles(13); }
  731.                    else        { r_PC++ ; AddCycles(8);  }
  732.                    break;
  733.  
  734. case  RLA       :  r_meml = r_A;
  735.                    r_A = ( r_A << 1 ) | ( r_F & FLAG_C );
  736.                    r_F = ( r_F & ( FLAG_P | FLAG_Z | FLAG_S ) ) |
  737.                    (r_A & ( FLAG_3 | FLAG_5 ) ) | ( r_meml >> 7);
  738.                    AddCycles( 4 ); break;
  739.  
  740. case  RRA       :  r_meml = r_A;
  741.                    r_A = ( r_A >> 1 ) | ( r_F << 7 );
  742.                    r_F = ( r_F & ( FLAG_P | FLAG_Z | FLAG_S ) ) |
  743.                    ( r_A & ( FLAG_3 | FLAG_5 ) ) | ( r_meml & FLAG_C );
  744.                    AddCycles( 4 ); break;
  745.  
  746. case  DAA       :  r_meml = 0;
  747.                    r_memh = ( r_F & FLAG_C );
  748.                    if( ( r_F & FLAG_H ) || ( (r_A & 0x0f)>9 ) ) r_meml=6;
  749.                    if( r_memh || (r_A > 0x9f ) ) r_meml |= 0x60;
  750.                    if( r_A > 0x99 ) r_memh=1;
  751.                    if ( r_F & FLAG_N ) { SUB(r_meml); }
  752.                    else
  753.                    {
  754.                        if( (r_A>0x90) && ( (r_A & 0x0f)>9) ) r_meml|=0x60;
  755.                        ADD(r_meml);
  756.                    }
  757.                    r_F = ( r_F & ~( FLAG_C | FLAG_P) ) | r_memh |
  758.                    parity_table[r_A];
  759.                    AddCycles( 4 ); break;
  760.  
  761. case  OUT_N_A   :  Z80OutPort( regs, Z80ReadMem( r_PC ), r_A ); r_PC++;
  762.                    AddCycles( 11 ); break;
  763.  
  764. case  IN_A_N    :  r_A = Z80InPort( Z80ReadMem( r_PC ) + (r_A << 8));
  765.                    r_PC++; AddCycles( 11 ); break;
  766.  
  767. case  EX_HL_xSP :  r_meml = Z80ReadMem(r_SP);
  768.                    r_memh = Z80ReadMem(r_SP+1);
  769.                    Z80WriteMem(r_SP, r_L, regs);
  770.                    Z80WriteMem(r_SP+1, r_H, regs);
  771.                    r_L = r_meml;
  772.                    r_H = r_memh;
  773.                    AddCycles( 19 ); break;
  774.  
  775. case  EXX       :  EX_WORD(r_BC, r_BCs); EX_WORD(r_DE, r_DEs);
  776.                    EX_WORD(r_HL, r_HLs);
  777.                    AddCycles( 4 ); break;
  778.  
  779. case  EX_DE_HL  :  EX_WORD( r_DE, r_HL );
  780.                    AddCycles( 4 );
  781.                    break;
  782.  
  783. case  AND_N     :  AND_mem( r_PC );
  784.                    r_PC++;
  785.                    AddCycles( 4+3 );
  786.                    break;
  787.  
  788. case  XOR_N     :  XOR_mem( r_PC );
  789.                    r_PC++;
  790.                    AddCycles( 4+3 );
  791.                    break;
  792.  
  793. case  OR_N      :  OR_mem( r_PC );
  794.                    r_PC++;
  795.                    AddCycles( 4+3 );
  796.                    break;
  797.  
  798. case  DI        :  r_IFF1 = r_IFF2 = 0;
  799.                    AddCycles( 4 );
  800.                    break;
  801.  
  802. case  CALL      :
  803.                    CALL_nn();
  804.                    AddCycles( 4+3+3+3+3+1 );
  805.                    break;
  806.  
  807. case  CALL_NZ   :  if( TEST_FLAG(Z_FLAG) )
  808.                     { r_PC += 2; AddCycles( 4+3+3 ); }
  809.                    else
  810.                     {
  811.                       CALL_nn();
  812.                       AddCycles( 4+3+3+3+3+1 );
  813.                     }
  814.                    break;
  815.  
  816. case  CALL_NC   :  if( TEST_FLAG(C_FLAG) )
  817.                     { r_PC += 2; AddCycles( 4+3+3 ); }
  818.                    else
  819.                     { CALL_nn();
  820.                       AddCycles( 4+3+3+3+3+1 );
  821.                     }
  822.                    break;
  823.  
  824. case  CALL_PO   :  if( TEST_FLAG(P_FLAG) )
  825.                     { r_PC += 2; AddCycles( 4+3+3 ); }
  826.                    else
  827.                     { CALL_nn();
  828.                       AddCycles( 4+3+3+ 3+3+1 );
  829.                    }
  830.                    break;
  831.  
  832. case  CALL_P    :  if( TEST_FLAG(S_FLAG) )
  833.                     { r_PC += 2; AddCycles( 4+3+3 ); }
  834.                    else
  835.                     { CALL_nn();
  836.                       AddCycles( 4+3+3+3+3+1 );
  837.                     }
  838.                    break;
  839.  
  840.  
  841. case  CALL_Z    :  if( TEST_FLAG(Z_FLAG) )
  842.                    { CALL_nn();
  843.                       AddCycles( 4+3+3+3+3+1 );
  844.                    }
  845.                    else
  846.                    {  r_PC += 2; AddCycles( 4+3+3 ); }
  847.                    break;
  848.  
  849. case  CALL_C    :  if( TEST_FLAG(C_FLAG) )
  850.                    { CALL_nn();
  851.                       AddCycles( 4+3+3+ 3+3+4 );
  852.                    }
  853.                    else
  854.                    { r_PC += 2; AddCycles( 4+3+3 ); }
  855.                    break;
  856.  
  857. case  CALL_PE   :  if( TEST_FLAG(P_FLAG) )
  858.                     { CALL_nn();
  859.                       AddCycles( 4+3+3+3+3+1 );
  860.                     }
  861.                    else
  862.                     { r_PC += 2; AddCycles( 4+3+3 ); }
  863.                    break;
  864.  
  865. case  CALL_M    :  if( TEST_FLAG(S_FLAG) )
  866.                     { CALL_nn();
  867.                       AddCycles( 4+3+3+3+3+1 );
  868.                    }
  869.                    else
  870.                     { r_PC += 2; AddCycles( 4+3+3 ); }
  871.                    break;
  872.  
  873. case  EI        :   r_IFF1 = r_IFF2 = 1;
  874.                     /*
  875.                     Why Marat Fayzullin does this? ->
  876.  
  877.                     regs->IFF2 |= 0x01;
  878.                     if( regs->IRequest != INT_NOINT )
  879.                     {
  880.                        regs->IBackup = regs->ICount;
  881.                        regs->ICount = 0x1;
  882.                        r_IFF |= 0x20;
  883.                     }*/
  884.                    AddCycles( 4 );
  885.                    break;
  886.  
  887. case  RST_00    :  RST(0x00); AddCycles( 11 ); break;
  888. case  RST_08    :  RST(0x08); AddCycles( 11 ); break;
  889. case  RST_10    :  RST(0x10); AddCycles( 11 ); break;
  890. case  RST_18    :  RST(0x18); AddCycles( 11 ); break;
  891. case  RST_20    :  RST(0x20); AddCycles( 11 ); break;
  892. case  RST_28    :  RST(0x28); AddCycles( 11 ); break;
  893. case  RST_30    :  RST(0x30); AddCycles( 11 ); break;
  894. case  RST_38    :  RST(0x38); AddCycles( 11 ); break;
  895.  
  896. default:
  897. //    exit(1);
  898. ///!!!    if( regs->DecodingErrors )
  899. ///!!!    printf("z80 core: Unknown instruction: %02Xh at PC=%04Xh.\n",
  900. ///!!!            Z80ReadMem(r_PC-1), r_PC-1 );
  901.     break;
  902.