home *** CD-ROM | disk | FTP | other *** search
/ PC Shareware 1996 December / PC_Shareware-1996-12.iso / windows / spectrum / sources / z80 / ld8bits.c < prev    next >
Encoding:
C/C++ Source or Header  |  1996-05-21  |  11.4 KB  |  339 lines
  1. /* Ld8Bits.c: Z80 8 bit load instructions.
  2.  *
  3.  * Copyright 1996 Rui Fernando Ferreira Ribeiro.
  4.  *
  5.  * This program is free software; you can redistribute it and/or modify
  6.  * it under the terms of the GNU General Public License as published by
  7.  * the Free Software Foundation; either version 2 of the License, or
  8.  * (at your option) any later version.
  9.  *
  10.  * This program is distributed in the hope that it will be useful,
  11.  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  12.  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  13.  * GNU General Public License for more details.
  14.  *
  15.  * You should have received a copy of the GNU General Public License
  16.  * along with this program; if not, write to the Free Software
  17.  * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  18.  */
  19.  
  20. /*
  21.  * History: 4th April 96
  22.  *                    . Modified ld_a_r() and ld_r_a() for a new handling of
  23.  *                R register. see also [kernel.c] and
  24.  *        5th April
  25.  *            . Modified FD/DD logic
  26.  */
  27.  
  28. #include "env.h"
  29.  
  30. /*=========================================================================*
  31.  *                            ld_r_s                                       *
  32.  *=========================================================================*/
  33. #define ld_r_s(r,s,TS) { T(TS); (r)=(s); }
  34.  
  35. void ld_b_b()  { T(4); }
  36. void ld_b_c()  ld_r_s(B, C, 4);
  37. void ld_b_d()  ld_r_s(B, D, 4);
  38. void ld_b_e()  ld_r_s(B, E, 4);
  39. void ld_b_h()  ld_r_s(B, H, 4);
  40. void ld_b_Ix() ld_r_s(B, HX, 8);
  41. void ld_b_Iy() ld_r_s(B, HY, 8);
  42. void ld_b_l()  ld_r_s(B, L, 4);
  43. void ld_b_iX() ld_r_s(B, LX, 8);
  44. void ld_b_iY() ld_r_s(B, LY, 8);
  45. void ld_b_a()  ld_r_s(B, A, 4);
  46. void ld_c_b()  ld_r_s(C, B, 4);
  47. void ld_c_c()  { T(4); }
  48. void ld_c_d()  ld_r_s(C, D, 4);
  49. void ld_c_e()  ld_r_s(C, E, 4);
  50. void ld_c_h()  ld_r_s(C, H, 4);
  51. void ld_c_Ix() ld_r_s(C, HX, 8);
  52. void ld_c_Iy() ld_r_s(C, HY, 8);
  53. void ld_c_l()  ld_r_s(C, L, 4);
  54. void ld_c_iX() ld_r_s(C, LX, 8);
  55. void ld_c_iY() ld_r_s(C, LY, 8);
  56. void ld_c_a()  ld_r_s(C, A, 4);
  57. void ld_d_b()  ld_r_s(D, B, 4);
  58. void ld_d_c()  ld_r_s(D, C, 4);
  59. void ld_d_d()  { T(4); }
  60. void ld_d_e()  ld_r_s(D, E, 4);
  61. void ld_d_h()  ld_r_s(D, H, 4);
  62. void ld_d_Ix() ld_r_s(D, HX, 8);
  63. void ld_d_Iy() ld_r_s(D, HY, 8);
  64. void ld_d_l()  ld_r_s(D, L, 4);
  65. void ld_d_iX() ld_r_s(D, LX, 8);
  66. void ld_d_iY() ld_r_s(D, LY, 8);
  67. void ld_d_a()  ld_r_s(D, A, 4);
  68. void ld_e_b()  ld_r_s(E, B, 4);
  69. void ld_e_c()  ld_r_s(E, C, 4);
  70. void ld_e_d()  ld_r_s(E, D, 4);
  71. void ld_e_e()  { T(4); }
  72. void ld_e_h()  ld_r_s(E, H, 4);
  73. void ld_e_Ix() ld_r_s(E, HX, 8);
  74. void ld_e_Iy() ld_r_s(E, HY, 8);
  75. void ld_e_l()  ld_r_s(E, L, 4);
  76. void ld_e_iX() ld_r_s(E, LX, 8);
  77. void ld_e_iY() ld_r_s(E, LY, 8);
  78. void ld_e_a()  ld_r_s(E, A, 4);
  79. void ld_h_b()  ld_r_s(H, B, 4);
  80. void ld_h_c()  ld_r_s(H, C, 4);
  81. void ld_h_d()  ld_r_s(H, D, 4);
  82. void ld_h_e()  ld_r_s(H, E, 4);
  83. void ld_h_h()  { T(4); }
  84. void ld_h_l()  ld_r_s(H, L, 4);
  85. void ld_h_a()  ld_r_s(H, A, 4);
  86. void ld_Ix_b() ld_r_s(HX, B, 8);
  87. void ld_Ix_c() ld_r_s(HX, C, 8);
  88. void ld_Ix_d() ld_r_s(HX, D, 8);
  89. void ld_Ix_e() ld_r_s(HX, E, 8);
  90. void ld_Ix_Ix(){ T(8); }
  91. void ld_Ix_iX()ld_r_s(HX, LX, 8);
  92. void ld_Ix_a() ld_r_s(HX, A, 8);
  93. void ld_Iy_b() ld_r_s(HY, B, 8);
  94. void ld_Iy_c() ld_r_s(HY, C, 8);
  95. void ld_Iy_d() ld_r_s(HY, D, 8);
  96. void ld_Iy_e() ld_r_s(HY, E, 8);
  97. void ld_Iy_Iy(){ T(8); }
  98. void ld_Iy_iY()ld_r_s(HY, LY, 8);
  99. void ld_Iy_a() ld_r_s(HY, A, 8);
  100. void ld_l_b()  ld_r_s(L, B, 4);
  101. void ld_l_c()  ld_r_s(L, C, 4);
  102. void ld_l_d()  ld_r_s(L, D, 4);
  103. void ld_l_e()  ld_r_s(L, E, 4);
  104. void ld_l_h()  ld_r_s(L, H, 4);
  105. void ld_l_l()  { T(4); }
  106. void ld_l_a()  ld_r_s(L, A, 4);
  107. void ld_iX_b() ld_r_s(LX, B, 8);
  108. void ld_iX_c() ld_r_s(LX, C, 8);
  109. void ld_iX_d() ld_r_s(LX, D, 8);
  110. void ld_iX_e() ld_r_s(LX, E, 8);
  111. void ld_iX_iX(){ T(8); }
  112. void ld_iX_Ix()ld_r_s(LX, HX, 8);
  113. void ld_iX_a() ld_r_s(LX, A, 8);
  114. void ld_iY_b() ld_r_s(LY, B, 8);
  115. void ld_iY_c() ld_r_s(LY, C, 8);
  116. void ld_iY_d() ld_r_s(LY, D, 8);
  117. void ld_iY_e() ld_r_s(LY, E, 8);
  118. void ld_iY_iY(){ T(8); }
  119. void ld_iY_Iy()ld_r_s(LY, HY, 8);
  120. void ld_iY_a() ld_r_s(LY, A, 8);
  121. void ld_a_b()  ld_r_s(A, B, 4);
  122. void ld_a_c()  ld_r_s(A, C, 4);
  123. void ld_a_d()  ld_r_s(A, D, 4);
  124. void ld_a_e()  ld_r_s(A, E, 4);
  125. void ld_a_h()  ld_r_s(A, H, 4);
  126. void ld_a_Ix() ld_r_s(A, HX, 8);
  127. void ld_a_Iy() ld_r_s(A, HY, 8);
  128. void ld_a_l()  ld_r_s(A, L, 4);
  129. void ld_a_iX() ld_r_s(A, LX, 8);
  130. void ld_a_iY() ld_r_s(A, LY, 8);
  131. void ld_a_a()  { T(4); }
  132.  
  133. #undef ld_r_s
  134.  
  135. /*=========================================================================*
  136.  *                            ld_r_n                                       *
  137.  *=========================================================================*/
  138.  
  139. #define ld_r_n(r, TS) { T(TS); r = Getnextbyte(); }
  140.  
  141. void ld_b_n()  ld_r_n(B, 7);
  142. void ld_c_n()  ld_r_n(C, 7);
  143. void ld_d_n()  ld_r_n(D, 7);
  144. void ld_e_n()  ld_r_n(E, 7);
  145. void ld_h_n()  ld_r_n(H, 7);
  146. void ld_Ix_n() ld_r_n(HX, 11);
  147. void ld_Iy_n() ld_r_n(HY, 11);
  148. void ld_l_n()  ld_r_n(L, 7);
  149. void ld_iX_n() ld_r_n(LX, 7);
  150. void ld_iY_n() ld_r_n(LY, 7);
  151. void ld_a_n()  ld_r_n(A, 7);
  152.  
  153. #undef ld_r_n
  154.  
  155. /*=========================================================================*
  156.  *                            ld_r_phl                                     *
  157.  *=========================================================================*/
  158.  
  159. #define ld_r_phl(r,expr,TS) { T(TS); (r) = readbyte(expr); }
  160.  
  161. void ld_b_phl() ld_r_phl(B, HL , 7);
  162. void ld_c_phl() ld_r_phl(C, HL , 7);
  163. void ld_d_phl() ld_r_phl(D, HL , 7);
  164. void ld_e_phl() ld_r_phl(E, HL , 7);
  165. void ld_h_phl() ld_r_phl(H, HL , 7);
  166. void ld_l_phl() ld_r_phl(L, HL , 7);
  167. void ld_a_phl() ld_r_phl(A, HL , 7);
  168. void ld_b_pix() ld_r_phl(B, pIX, 19);
  169. void ld_c_pix() ld_r_phl(C, pIX, 19);
  170. void ld_d_pix() ld_r_phl(D, pIX, 19);
  171. void ld_e_pix() ld_r_phl(E, pIX, 19);
  172. void ld_h_pix() ld_r_phl(H, pIX, 19);
  173. void ld_l_pix() ld_r_phl(L, pIX, 19);
  174. void ld_a_pix() ld_r_phl(A, pIX, 19);
  175. void ld_b_piy() ld_r_phl(B, pIY, 19);
  176. void ld_c_piy() ld_r_phl(C, pIY, 19);
  177. void ld_d_piy() ld_r_phl(D, pIY, 19);
  178. void ld_e_piy() ld_r_phl(E, pIY, 19);
  179. void ld_h_piy() ld_r_phl(H, pIY, 19);
  180. void ld_l_piy() ld_r_phl(L, pIY, 19);
  181. void ld_a_piy() ld_r_phl(A, pIY, 19);
  182.  
  183. #undef ld_r_phl
  184.  
  185. /*=========================================================================*
  186.  *                            ld_phl_r                                     *
  187.  *=========================================================================*/
  188.  
  189. #define ld_phl_r(r,expr,TS) { T(TS); writebyte(expr, r); }
  190.  
  191. void ld_phl_b() ld_phl_r(B, HL, 7);
  192. void ld_phl_c() ld_phl_r(C, HL, 7);
  193. void ld_phl_d() ld_phl_r(D, HL, 7);
  194. void ld_phl_e() ld_phl_r(E, HL, 7);
  195. void ld_phl_h() ld_phl_r(H, HL, 7);
  196. void ld_phl_l() ld_phl_r(L, HL, 7);
  197. void ld_phl_a() ld_phl_r(A, HL, 7);
  198. void ld_pix_b() ld_phl_r(B, pIX, 19);
  199. void ld_pix_c() ld_phl_r(C, pIX, 19);
  200. void ld_pix_d() ld_phl_r(D, pIX, 19);
  201. void ld_pix_e() ld_phl_r(E, pIX, 19);
  202. void ld_pix_h() ld_phl_r(H, pIX, 19);
  203. void ld_pix_l() ld_phl_r(L, pIX, 19);
  204. void ld_pix_a() ld_phl_r(A, pIX, 19);
  205. void ld_piy_b() ld_phl_r(B, pIY, 19);
  206. void ld_piy_c() ld_phl_r(C, pIY, 19);
  207. void ld_piy_d() ld_phl_r(D, pIY, 19);
  208. void ld_piy_e() ld_phl_r(E, pIY, 19);
  209. void ld_piy_h() ld_phl_r(H, pIY, 19);
  210. void ld_piy_l() ld_phl_r(L, pIY, 19);
  211. void ld_piy_a() ld_phl_r(A, pIY, 19);
  212.  
  213. #undef ld_phl_r
  214.  
  215. /*=========================================================================*
  216.  *                            ld_phl_n                                     *
  217.  *=========================================================================*/
  218. void ld_phl_n() { T(10); writebyte(HL, Getnextbyte() ); }
  219. /* The next two instructions will be a possible source of problems with a
  220.     optimizing compiler -- if tmp was cutted we will have a problem in
  221.     writebyte()
  222.  */
  223. static USHORT tmp;
  224. void ld_pix_n() { /*USHORT tmp;*/ T(19); tmp=pIX;
  225.              writebyte(tmp,    Getnextbyte() ); }
  226. void ld_piy_n() { /*USHORT tmp;*/ T(19); tmp=pIY;
  227.              writebyte(tmp,    Getnextbyte() ); }
  228.  
  229. /*=========================================================================*
  230.  *                            ld_a_pbc                                     *
  231.  *=========================================================================*/
  232. void ld_a_pbc()
  233. {
  234.     T(7);
  235.     A = readbyte(BC);
  236. }
  237.  
  238. /*=========================================================================*
  239.  *                            ld_a_pde                                     *
  240.  *=========================================================================*/
  241. void ld_a_pde()
  242. {
  243.     T(7);
  244.     A = readbyte(DE);
  245. }
  246.  
  247. /*=========================================================================*
  248.  *                            ld_a_pnn                                     *
  249.  *=========================================================================*/
  250. void ld_a_pnn()
  251. {
  252.     T(13);
  253.     A = readbyte(Getnextword());
  254. }
  255.  
  256. /*=========================================================================*
  257.  *                            ld_pbc_a                                     *
  258.  *=========================================================================*/
  259. void ld_pbc_a()
  260. {
  261.     T(7);
  262.     writebyte(BC, A);
  263. }
  264.  
  265. /*=========================================================================*
  266.  *                            ld_pde_a                                     *
  267.  *=========================================================================*/
  268. void ld_pde_a()
  269. {
  270.     T(7);
  271.     writebyte(DE, A);
  272. }
  273.  
  274. /*=========================================================================*
  275.  *                            ld_pnn_a                                     *
  276.  *=========================================================================*/
  277. void ld_pnn_a()
  278. {
  279.     T(13);
  280.     writebyte(Getnextword(), A);
  281. }
  282.  
  283. /*=========================================================================*
  284.  *                            ld_a_i                                       *
  285.  *=========================================================================*/
  286. void ld_a_i()
  287. {
  288.     T(9);
  289.     A = I;
  290.     flags._P = IFF2;
  291.     /* IFF2 got IFF1 copy, so this instruction can be used in Z80 programming
  292.       to know the former state of interrupts in the middle of a NMI interrupt
  293.     */
  294.     flags._S = (A & BIT_7);
  295.     flags._Z = !A;
  296.     flags._H = flags._N = 0;
  297.     flags._X = A & (UCHAR)BIT_5;
  298.     flags._Y = A & (UCHAR)BIT_3;
  299. }
  300.  
  301. /*=========================================================================*
  302.  *                            ld_a_r                                       *
  303.  *=========================================================================*/
  304. void ld_a_r()
  305. {
  306.     T(9);
  307.     A = (R & ~BIT_7) | R_BIT7;
  308.     flags._P = IFF2;
  309.     /* IFF2 got IFF1 copy, so this instruction can be used in Z80 programming
  310.       to know the former state of interrupts in the middle of a NMI interrupt
  311.     */
  312.     flags._S = (A & BIT_7);
  313.     flags._Z = !A;
  314.     flags._H = flags._N = 0;
  315.     flags._X = A & (UCHAR)BIT_5;
  316.     flags._Y = A & (UCHAR)BIT_3;
  317. }
  318.  
  319. /*=========================================================================*
  320.  *                            ld_i_a                                       *
  321.  *=========================================================================*/
  322. void ld_i_a()
  323. {
  324.     T(9);
  325.     I = A;
  326. }
  327.  
  328. /*=========================================================================*
  329.  *                            ld_r_a                                       *
  330.  *=========================================================================*/
  331. void ld_r_a()
  332. {
  333.     T(9);
  334.     R = A;
  335.     R_BIT7 = (A & BIT_7);
  336. }
  337.  
  338. /* EOF : Ld8Bits.c */
  339.