1 /*
2 * Z80SIM - a Z80-CPU simulator
3 *
4 * Copyright (C) 1987-2021 by Udo Munk
5 *
6 * History:
7 * 28-SEP-87 Development on TARGON/35 with AT&T Unix System V.3
8 * 11-JAN-89 Release 1.1
9 * 08-FEB-89 Release 1.2
10 * 13-MAR-89 Release 1.3
11 * 09-FEB-90 Release 1.4 Ported to TARGON/31 M10/30
12 * 20-DEC-90 Release 1.5 Ported to COHERENT 3.0
13 * 10-JUN-92 Release 1.6 long casting problem solved with COHERENT 3.2
14 * and some optimisation
15 * 25-JUN-92 Release 1.7 comments in english and ported to COHERENT 4.0
16 * 02-OCT-06 Release 1.8 modified to compile on modern POSIX OS's
17 * 18-NOV-06 Release 1.9 modified to work with CP/M sources
18 * 08-DEC-06 Release 1.10 modified MMU for working with CP/NET
19 * 17-DEC-06 Release 1.11 TCP/IP sockets for CP/NET
20 * 25-DEC-06 Release 1.12 CPU speed option
21 * 19-FEB-07 Release 1.13 various improvements
22 * 06-OCT-07 Release 1.14 bug fixes and improvements
23 * 06-AUG-08 Release 1.15 many improvements and Windows support via Cygwin
24 * 25-AUG-08 Release 1.16 console status I/O loop detection and line discipline
25 * 20-OCT-08 Release 1.17 frontpanel integrated and Altair/IMSAI emulations
26 * 24-JAN-14 Release 1.18 bug fixes and improvements
27 * 02-MAR-14 Release 1.19 source cleanup and improvements
28 * 14-MAR-14 Release 1.20 added Tarbell SD FDC and printer port to Altair
29 * 29-MAR-14 Release 1.21 many improvements
30 * 29-MAY-14 Release 1.22 improved networking and bugfixes
31 * 04-JUN-14 Release 1.23 added 8080 emulation
32 * 06-SEP-14 Release 1.24 bugfixes and improvements
33 * 18-FEB-15 Release 1.25 bugfixes, improvements, added Cromemco Z-1
34 * 18-APR-15 Release 1.26 bugfixes and improvements
35 * 18-JAN-16 Release 1.27 bugfixes and improvements
36 * 05-MAY-16 Release 1.28 improved usability
37 * 20-NOV-16 Release 1.29 bugfixes and improvements
38 * 15-DEC-16 Release 1.30 improved memory management, machine cycle correct CPUs
39 * 28-DEC-16 Release 1.31 improved memory management, reimplemented MMUs
40 * 12-JAN-17 Release 1.32 improved configurations, front panel, added IMSAI VIO
41 * 07-FEB-17 Release 1.33 bugfixes, improvements, better front panels
42 * 16-MAR-17 Release 1.34 improvements, added ProcTec VDM-1
43 * 03-AUG-17 Release 1.35 added UNIX sockets, bugfixes, improvements
44 * 21-DEC-17 Release 1.36 bugfixes and improvements
45 * 06-JAN-21 Release 1.37 bugfixes and improvements
46 */
47
48 /*
49 * Like the function "cpu_z80()" this one emulates multi byte opcodes
50 * starting with 0xcb
51 */
52
53 #include "sim.h"
54 #include "simglb.h"
55 #include "config.h"
56 #ifdef FRONTPANEL
57 #include "../../frontpanel/frontpanel.h"
58 #endif
59 #include "memory.h"
60
61 #ifdef Z80_UNDOC
62 #define UNDOC(f) f
63 #else
64 #define UNDOC(f) trap_cb
65 #endif
66
67 static int trap_cb(void);
68 static int op_srla(void), op_srlb(void), op_srlc(void);
69 static int op_srld(void), op_srle(void);
70 static int op_srlh(void), op_srll(void), op_srlhl(void);
71 static int op_slaa(void), op_slab(void), op_slac(void);
72 static int op_slad(void), op_slae(void);
73 static int op_slah(void), op_slal(void), op_slahl(void);
74 static int op_rlra(void), op_rlb(void), op_rlc(void);
75 static int op_rld(void), op_rle(void);
76 static int op_rlh(void), op_rll(void), op_rlhl(void);
77 static int op_rrra(void), op_rrb(void), op_rrc(void);
78 static int op_rrd(void), op_rre(void);
79 static int op_rrh(void), op_rrl(void), op_rrhl(void);
80 static int op_rrcra(void), op_rrcb(void), op_rrcc(void);
81 static int op_rrcd(void), op_rrce(void);
82 static int op_rrch(void), op_rrcl(void), op_rrchl(void);
83 static int op_rlcra(void), op_rlcb(void), op_rlcc(void);
84 static int op_rlcd(void), op_rlce(void);
85 static int op_rlch(void), op_rlcl(void), op_rlchl(void);
86 static int op_sraa(void), op_srab(void), op_srac(void);
87 static int op_srad(void), op_srae(void);
88 static int op_srah(void), op_sral(void), op_srahl(void);
89 static int op_sb0a(void), op_sb1a(void), op_sb2a(void), op_sb3a(void);
90 static int op_sb4a(void), op_sb5a(void), op_sb6a(void), op_sb7a(void);
91 static int op_sb0b(void), op_sb1b(void), op_sb2b(void), op_sb3b(void);
92 static int op_sb4b(void), op_sb5b(void), op_sb6b(void), op_sb7b(void);
93 static int op_sb0c(void), op_sb1c(void), op_sb2c(void), op_sb3c(void);
94 static int op_sb4c(void), op_sb5c(void), op_sb6c(void), op_sb7c(void);
95 static int op_sb0d(void), op_sb1d(void), op_sb2d(void), op_sb3d(void);
96 static int op_sb4d(void), op_sb5d(void), op_sb6d(void), op_sb7d(void);
97 static int op_sb0e(void), op_sb1e(void), op_sb2e(void), op_sb3e(void);
98 static int op_sb4e(void), op_sb5e(void), op_sb6e(void), op_sb7e(void);
99 static int op_sb0h(void), op_sb1h(void), op_sb2h(void), op_sb3h(void);
100 static int op_sb4h(void), op_sb5h(void), op_sb6h(void), op_sb7h(void);
101 static int op_sb0l(void), op_sb1l(void), op_sb2l(void), op_sb3l(void);
102 static int op_sb4l(void), op_sb5l(void), op_sb6l(void), op_sb7l(void);
103 static int op_sb0hl(void), op_sb1hl(void), op_sb2hl(void), op_sb3hl(void);
104 static int op_sb4hl(void), op_sb5hl(void), op_sb6hl(void), op_sb7hl(void);
105 static int op_rb0a(void), op_rb1a(void), op_rb2a(void), op_rb3a(void);
106 static int op_rb4a(void), op_rb5a(void), op_rb6a(void), op_rb7a(void);
107 static int op_rb0b(void), op_rb1b(void), op_rb2b(void), op_rb3b(void);
108 static int op_rb4b(void), op_rb5b(void), op_rb6b(void), op_rb7b(void);
109 static int op_rb0c(void), op_rb1c(void), op_rb2c(void), op_rb3c(void);
110 static int op_rb4c(void), op_rb5c(void), op_rb6c(void), op_rb7c(void);
111 static int op_rb0d(void), op_rb1d(void), op_rb2d(void), op_rb3d(void);
112 static int op_rb4d(void), op_rb5d(void), op_rb6d(void), op_rb7d(void);
113 static int op_rb0e(void), op_rb1e(void), op_rb2e(void), op_rb3e(void);
114 static int op_rb4e(void), op_rb5e(void), op_rb6e(void), op_rb7e(void);
115 static int op_rb0h(void), op_rb1h(void), op_rb2h(void), op_rb3h(void);
116 static int op_rb4h(void), op_rb5h(void), op_rb6h(void), op_rb7h(void);
117 static int op_rb0l(void), op_rb1l(void), op_rb2l(void), op_rb3l(void);
118 static int op_rb4l(void), op_rb5l(void), op_rb6l(void), op_rb7l(void);
119 static int op_rb0hl(void), op_rb1hl(void), op_rb2hl(void), op_rb3hl(void);
120 static int op_rb4hl(void), op_rb5hl(void), op_rb6hl(void), op_rb7hl(void);
121 static int op_tb0a(void), op_tb1a(void), op_tb2a(void), op_tb3a(void);
122 static int op_tb4a(void), op_tb5a(void), op_tb6a(void), op_tb7a(void);
123 static int op_tb0b(void), op_tb1b(void), op_tb2b(void), op_tb3b(void);
124 static int op_tb4b(void), op_tb5b(void), op_tb6b(void), op_tb7b(void);
125 static int op_tb0c(void), op_tb1c(void), op_tb2c(void), op_tb3c(void);
126 static int op_tb4c(void), op_tb5c(void), op_tb6c(void), op_tb7c(void);
127 static int op_tb0d(void), op_tb1d(void), op_tb2d(void), op_tb3d(void);
128 static int op_tb4d(void), op_tb5d(void), op_tb6d(void), op_tb7d(void);
129 static int op_tb0e(void), op_tb1e(void), op_tb2e(void), op_tb3e(void);
130 static int op_tb4e(void), op_tb5e(void), op_tb6e(void), op_tb7e(void);
131 static int op_tb0h(void), op_tb1h(void), op_tb2h(void), op_tb3h(void);
132 static int op_tb4h(void), op_tb5h(void), op_tb6h(void), op_tb7h(void);
133 static int op_tb0l(void), op_tb1l(void), op_tb2l(void), op_tb3l(void);
134 static int op_tb4l(void), op_tb5l(void), op_tb6l(void), op_tb7l(void);
135 static int op_tb0hl(void), op_tb1hl(void), op_tb2hl(void), op_tb3hl(void);
136 static int op_tb4hl(void), op_tb5hl(void), op_tb6hl(void), op_tb7hl(void);
137
138 #ifdef Z80_UNDOC
139 static int op_undoc_slla(void), op_undoc_sllb(void), op_undoc_sllc(void);
140 static int op_undoc_slld(void), op_undoc_slle(void);
141 static int op_undoc_sllh(void), op_undoc_slll(void), op_undoc_sllhl(void);
142 #endif
143
op_cb_handel(void)144 int op_cb_handel(void)
145 {
146 register int t;
147
148 static int (*op_cb[256]) (void) = {
149 op_rlcb, /* 0x00 */
150 op_rlcc, /* 0x01 */
151 op_rlcd, /* 0x02 */
152 op_rlce, /* 0x03 */
153 op_rlch, /* 0x04 */
154 op_rlcl, /* 0x05 */
155 op_rlchl, /* 0x06 */
156 op_rlcra, /* 0x07 */
157 op_rrcb, /* 0x08 */
158 op_rrcc, /* 0x09 */
159 op_rrcd, /* 0x0a */
160 op_rrce, /* 0x0b */
161 op_rrch, /* 0x0c */
162 op_rrcl, /* 0x0d */
163 op_rrchl, /* 0x0e */
164 op_rrcra, /* 0x0f */
165 op_rlb, /* 0x10 */
166 op_rlc, /* 0x11 */
167 op_rld, /* 0x12 */
168 op_rle, /* 0x13 */
169 op_rlh, /* 0x14 */
170 op_rll, /* 0x15 */
171 op_rlhl, /* 0x16 */
172 op_rlra, /* 0x17 */
173 op_rrb, /* 0x18 */
174 op_rrc, /* 0x19 */
175 op_rrd, /* 0x1a */
176 op_rre, /* 0x1b */
177 op_rrh, /* 0x1c */
178 op_rrl, /* 0x1d */
179 op_rrhl, /* 0x1e */
180 op_rrra, /* 0x1f */
181 op_slab, /* 0x20 */
182 op_slac, /* 0x21 */
183 op_slad, /* 0x22 */
184 op_slae, /* 0x23 */
185 op_slah, /* 0x24 */
186 op_slal, /* 0x25 */
187 op_slahl, /* 0x26 */
188 op_slaa, /* 0x27 */
189 op_srab, /* 0x28 */
190 op_srac, /* 0x29 */
191 op_srad, /* 0x2a */
192 op_srae, /* 0x2b */
193 op_srah, /* 0x2c */
194 op_sral, /* 0x2d */
195 op_srahl, /* 0x2e */
196 op_sraa, /* 0x2f */
197 UNDOC(op_undoc_sllb), /* 0x30 */
198 UNDOC(op_undoc_sllc), /* 0x31 */
199 UNDOC(op_undoc_slld), /* 0x32 */
200 UNDOC(op_undoc_slle), /* 0x33 */
201 UNDOC(op_undoc_sllh), /* 0x34 */
202 UNDOC(op_undoc_slll), /* 0x35 */
203 UNDOC(op_undoc_sllhl), /* 0x36 */
204 op_undoc_slla, /* 0x37 */
205 op_srlb, /* 0x38 */
206 op_srlc, /* 0x39 */
207 op_srld, /* 0x3a */
208 op_srle, /* 0x3b */
209 op_srlh, /* 0x3c */
210 op_srll, /* 0x3d */
211 op_srlhl, /* 0x3e */
212 op_srla, /* 0x3f */
213 op_tb0b, /* 0x40 */
214 op_tb0c, /* 0x41 */
215 op_tb0d, /* 0x42 */
216 op_tb0e, /* 0x43 */
217 op_tb0h, /* 0x44 */
218 op_tb0l, /* 0x45 */
219 op_tb0hl, /* 0x46 */
220 op_tb0a, /* 0x47 */
221 op_tb1b, /* 0x48 */
222 op_tb1c, /* 0x49 */
223 op_tb1d, /* 0x4a */
224 op_tb1e, /* 0x4b */
225 op_tb1h, /* 0x4c */
226 op_tb1l, /* 0x4d */
227 op_tb1hl, /* 0x4e */
228 op_tb1a, /* 0x4f */
229 op_tb2b, /* 0x50 */
230 op_tb2c, /* 0x51 */
231 op_tb2d, /* 0x52 */
232 op_tb2e, /* 0x53 */
233 op_tb2h, /* 0x54 */
234 op_tb2l, /* 0x55 */
235 op_tb2hl, /* 0x56 */
236 op_tb2a, /* 0x57 */
237 op_tb3b, /* 0x58 */
238 op_tb3c, /* 0x59 */
239 op_tb3d, /* 0x5a */
240 op_tb3e, /* 0x5b */
241 op_tb3h, /* 0x5c */
242 op_tb3l, /* 0x5d */
243 op_tb3hl, /* 0x5e */
244 op_tb3a, /* 0x5f */
245 op_tb4b, /* 0x60 */
246 op_tb4c, /* 0x61 */
247 op_tb4d, /* 0x62 */
248 op_tb4e, /* 0x63 */
249 op_tb4h, /* 0x64 */
250 op_tb4l, /* 0x65 */
251 op_tb4hl, /* 0x66 */
252 op_tb4a, /* 0x67 */
253 op_tb5b, /* 0x68 */
254 op_tb5c, /* 0x69 */
255 op_tb5d, /* 0x6a */
256 op_tb5e, /* 0x6b */
257 op_tb5h, /* 0x6c */
258 op_tb5l, /* 0x6d */
259 op_tb5hl, /* 0x6e */
260 op_tb5a, /* 0x6f */
261 op_tb6b, /* 0x70 */
262 op_tb6c, /* 0x71 */
263 op_tb6d, /* 0x72 */
264 op_tb6e, /* 0x73 */
265 op_tb6h, /* 0x74 */
266 op_tb6l, /* 0x75 */
267 op_tb6hl, /* 0x76 */
268 op_tb6a, /* 0x77 */
269 op_tb7b, /* 0x78 */
270 op_tb7c, /* 0x79 */
271 op_tb7d, /* 0x7a */
272 op_tb7e, /* 0x7b */
273 op_tb7h, /* 0x7c */
274 op_tb7l, /* 0x7d */
275 op_tb7hl, /* 0x7e */
276 op_tb7a, /* 0x7f */
277 op_rb0b, /* 0x80 */
278 op_rb0c, /* 0x81 */
279 op_rb0d, /* 0x82 */
280 op_rb0e, /* 0x83 */
281 op_rb0h, /* 0x84 */
282 op_rb0l, /* 0x85 */
283 op_rb0hl, /* 0x86 */
284 op_rb0a, /* 0x87 */
285 op_rb1b, /* 0x88 */
286 op_rb1c, /* 0x89 */
287 op_rb1d, /* 0x8a */
288 op_rb1e, /* 0x8b */
289 op_rb1h, /* 0x8c */
290 op_rb1l, /* 0x8d */
291 op_rb1hl, /* 0x8e */
292 op_rb1a, /* 0x8f */
293 op_rb2b, /* 0x90 */
294 op_rb2c, /* 0x91 */
295 op_rb2d, /* 0x92 */
296 op_rb2e, /* 0x93 */
297 op_rb2h, /* 0x94 */
298 op_rb2l, /* 0x95 */
299 op_rb2hl, /* 0x96 */
300 op_rb2a, /* 0x97 */
301 op_rb3b, /* 0x98 */
302 op_rb3c, /* 0x99 */
303 op_rb3d, /* 0x9a */
304 op_rb3e, /* 0x9b */
305 op_rb3h, /* 0x9c */
306 op_rb3l, /* 0x9d */
307 op_rb3hl, /* 0x9e */
308 op_rb3a, /* 0x9f */
309 op_rb4b, /* 0xa0 */
310 op_rb4c, /* 0xa1 */
311 op_rb4d, /* 0xa2 */
312 op_rb4e, /* 0xa3 */
313 op_rb4h, /* 0xa4 */
314 op_rb4l, /* 0xa5 */
315 op_rb4hl, /* 0xa6 */
316 op_rb4a, /* 0xa7 */
317 op_rb5b, /* 0xa8 */
318 op_rb5c, /* 0xa9 */
319 op_rb5d, /* 0xaa */
320 op_rb5e, /* 0xab */
321 op_rb5h, /* 0xac */
322 op_rb5l, /* 0xad */
323 op_rb5hl, /* 0xae */
324 op_rb5a, /* 0xaf */
325 op_rb6b, /* 0xb0 */
326 op_rb6c, /* 0xb1 */
327 op_rb6d, /* 0xb2 */
328 op_rb6e, /* 0xb3 */
329 op_rb6h, /* 0xb4 */
330 op_rb6l, /* 0xb5 */
331 op_rb6hl, /* 0xb6 */
332 op_rb6a, /* 0xb7 */
333 op_rb7b, /* 0xb8 */
334 op_rb7c, /* 0xb9 */
335 op_rb7d, /* 0xba */
336 op_rb7e, /* 0xbb */
337 op_rb7h, /* 0xbc */
338 op_rb7l, /* 0xbd */
339 op_rb7hl, /* 0xbe */
340 op_rb7a, /* 0xbf */
341 op_sb0b, /* 0xc0 */
342 op_sb0c, /* 0xc1 */
343 op_sb0d, /* 0xc2 */
344 op_sb0e, /* 0xc3 */
345 op_sb0h, /* 0xc4 */
346 op_sb0l, /* 0xc5 */
347 op_sb0hl, /* 0xc6 */
348 op_sb0a, /* 0xc7 */
349 op_sb1b, /* 0xc8 */
350 op_sb1c, /* 0xc9 */
351 op_sb1d, /* 0xca */
352 op_sb1e, /* 0xcb */
353 op_sb1h, /* 0xcc */
354 op_sb1l, /* 0xcd */
355 op_sb1hl, /* 0xce */
356 op_sb1a, /* 0xcf */
357 op_sb2b, /* 0xd0 */
358 op_sb2c, /* 0xd1 */
359 op_sb2d, /* 0xd2 */
360 op_sb2e, /* 0xd3 */
361 op_sb2h, /* 0xd4 */
362 op_sb2l, /* 0xd5 */
363 op_sb2hl, /* 0xd6 */
364 op_sb2a, /* 0xd7 */
365 op_sb3b, /* 0xd8 */
366 op_sb3c, /* 0xd9 */
367 op_sb3d, /* 0xda */
368 op_sb3e, /* 0xdb */
369 op_sb3h, /* 0xdc */
370 op_sb3l, /* 0xdd */
371 op_sb3hl, /* 0xde */
372 op_sb3a, /* 0xdf */
373 op_sb4b, /* 0xe0 */
374 op_sb4c, /* 0xe1 */
375 op_sb4d, /* 0xe2 */
376 op_sb4e, /* 0xe3 */
377 op_sb4h, /* 0xe4 */
378 op_sb4l, /* 0xe5 */
379 op_sb4hl, /* 0xe6 */
380 op_sb4a, /* 0xe7 */
381 op_sb5b, /* 0xe8 */
382 op_sb5c, /* 0xe9 */
383 op_sb5d, /* 0xea */
384 op_sb5e, /* 0xeb */
385 op_sb5h, /* 0xec */
386 op_sb5l, /* 0xed */
387 op_sb5hl, /* 0xee */
388 op_sb5a, /* 0xef */
389 op_sb6b, /* 0xf0 */
390 op_sb6c, /* 0xf1 */
391 op_sb6d, /* 0xf2 */
392 op_sb6e, /* 0xf3 */
393 op_sb6h, /* 0xf4 */
394 op_sb6l, /* 0xf5 */
395 op_sb6hl, /* 0xf6 */
396 op_sb6a, /* 0xf7 */
397 op_sb7b, /* 0xf8 */
398 op_sb7c, /* 0xf9 */
399 op_sb7d, /* 0xfa */
400 op_sb7e, /* 0xfb */
401 op_sb7h, /* 0xfc */
402 op_sb7l, /* 0xfd */
403 op_sb7hl, /* 0xfe */
404 op_sb7a /* 0xff */
405 };
406
407 #ifdef BUS_8080
408 /* M1 opcode fetch */
409 cpu_bus = CPU_WO | CPU_M1 | CPU_MEMR;
410 m1_step = 1;
411 #endif
412 #ifdef FRONTPANEL
413 /* update frontpanel */
414 fp_clock++;
415 fp_sampleLightGroup(0, 0);
416 #endif
417
418 t = (*op_cb[memrdr(PC++)]) (); /* execute next opcode */
419
420 return(t);
421 }
422
423 /*
424 * This function traps undocumented opcodes following the
425 * initial 0xcb of a multi byte opcode.
426 */
trap_cb(void)427 static int trap_cb(void)
428 {
429 cpu_error = OPTRAP2;
430 cpu_state = STOPPED;
431 return(0);
432 }
433
op_srla(void)434 static int op_srla(void) /* SRL A */
435 {
436 (A & 1) ? (F |= C_FLAG) : (F &= ~C_FLAG);
437 A >>= 1;
438 F &= ~(H_FLAG | N_FLAG);
439 (A) ? (F &= ~Z_FLAG) : (F |= Z_FLAG);
440 (A & 128) ? (F |= S_FLAG) : (F &= ~S_FLAG);
441 (parity[A]) ? (F &= ~P_FLAG) : (F |= P_FLAG);
442 return(8);
443 }
444
op_srlb(void)445 static int op_srlb(void) /* SRL B */
446 {
447 (B & 1) ? (F |= C_FLAG) : (F &= ~C_FLAG);
448 B >>= 1;
449 F &= ~(H_FLAG | N_FLAG);
450 (B) ? (F &= ~Z_FLAG) : (F |= Z_FLAG);
451 (B & 128) ? (F |= S_FLAG) : (F &= ~S_FLAG);
452 (parity[B]) ? (F &= ~P_FLAG) : (F |= P_FLAG);
453 return(8);
454 }
455
op_srlc(void)456 static int op_srlc(void) /* SRL C */
457 {
458 (C & 1) ? (F |= C_FLAG) : (F &= ~C_FLAG);
459 C >>= 1;
460 F &= ~(H_FLAG | N_FLAG);
461 (C) ? (F &= ~Z_FLAG) : (F |= Z_FLAG);
462 (C & 128) ? (F |= S_FLAG) : (F &= ~S_FLAG);
463 (parity[C]) ? (F &= ~P_FLAG) : (F |= P_FLAG);
464 return(8);
465 }
466
op_srld(void)467 static int op_srld(void) /* SRL D */
468 {
469 (D & 1) ? (F |= C_FLAG) : (F &= ~C_FLAG);
470 D >>= 1;
471 F &= ~(H_FLAG | N_FLAG);
472 (D) ? (F &= ~Z_FLAG) : (F |= Z_FLAG);
473 (D & 128) ? (F |= S_FLAG) : (F &= ~S_FLAG);
474 (parity[D]) ? (F &= ~P_FLAG) : (F |= P_FLAG);
475 return(8);
476 }
477
op_srle(void)478 static int op_srle(void) /* SRL E */
479 {
480 (E & 1) ? (F |= C_FLAG) : (F &= ~C_FLAG);
481 E >>= 1;
482 F &= ~(H_FLAG | N_FLAG);
483 (E) ? (F &= ~Z_FLAG) : (F |= Z_FLAG);
484 (E & 128) ? (F |= S_FLAG) : (F &= ~S_FLAG);
485 (parity[E]) ? (F &= ~P_FLAG) :(F |= P_FLAG);
486 return(8);
487 }
488
op_srlh(void)489 static int op_srlh(void) /* SRL H */
490 {
491 (H & 1) ? (F |= C_FLAG) : (F &= ~C_FLAG);
492 H >>= 1;
493 F &= ~(H_FLAG | N_FLAG);
494 (H) ? (F &= ~Z_FLAG) : (F |= Z_FLAG);
495 (H & 128) ? (F |= S_FLAG) : (F &= ~S_FLAG);
496 (parity[H]) ? (F &= ~P_FLAG) : (F |= P_FLAG);
497 return(8);
498 }
499
op_srll(void)500 static int op_srll(void) /* SRL L */
501 {
502 (L & 1) ? (F |= C_FLAG) : (F &= ~C_FLAG);
503 L >>= 1;
504 F &= ~(H_FLAG | N_FLAG);
505 (L) ? (F &= ~Z_FLAG) : (F |= Z_FLAG);
506 (L & 128) ? (F |= S_FLAG) : (F &= ~S_FLAG);
507 (parity[L]) ? (F &= ~P_FLAG) : (F |= P_FLAG);
508 return(8);
509 }
510
op_srlhl(void)511 static int op_srlhl(void) /* SRL (HL) */
512 {
513 register BYTE P;
514 WORD addr;
515
516 addr = (H << 8) + L;
517 P = memrdr(addr);
518 (P & 1) ? (F |= C_FLAG) : (F &= ~C_FLAG);
519 P >>= 1;
520 memwrt(addr, P);
521 F &= ~(H_FLAG | N_FLAG);
522 (P) ? (F &= ~Z_FLAG) : (F |= Z_FLAG);
523 (P & 128) ? (F |= S_FLAG) : (F &= ~S_FLAG);
524 (parity[P]) ? (F &= ~P_FLAG) : (F |= P_FLAG);
525 return(15);
526 }
527
op_slaa(void)528 static int op_slaa(void) /* SLA A */
529 {
530 (A & 128) ? (F |= C_FLAG) : (F &= ~C_FLAG);
531 A <<= 1;
532 F &= ~(H_FLAG | N_FLAG);
533 (A) ? (F &= ~Z_FLAG) : (F |= Z_FLAG);
534 (A & 128) ? (F |= S_FLAG) : (F &= ~S_FLAG);
535 (parity[A]) ? (F &= ~P_FLAG) : (F |= P_FLAG);
536 return(8);
537 }
538
op_slab(void)539 static int op_slab(void) /* SLA B */
540 {
541 (B & 128) ? (F |= C_FLAG) : (F &= ~C_FLAG);
542 B <<= 1;
543 F &= ~(H_FLAG | N_FLAG);
544 (B) ? (F &= ~Z_FLAG) : (F |= Z_FLAG);
545 (B & 128) ? (F |= S_FLAG) : (F &= ~S_FLAG);
546 (parity[B]) ? (F &= ~P_FLAG) : (F |= P_FLAG);
547 return(8);
548 }
549
op_slac(void)550 static int op_slac(void) /* SLA C */
551 {
552 (C & 128) ? (F |= C_FLAG) : (F &= ~C_FLAG);
553 C <<= 1;
554 F &= ~(H_FLAG | N_FLAG);
555 (C) ? (F &= ~Z_FLAG) : (F |= Z_FLAG);
556 (C & 128) ? (F |= S_FLAG) : (F &= ~S_FLAG);
557 (parity[C]) ? (F &= ~P_FLAG) : (F |= P_FLAG);
558 return(8);
559 }
560
op_slad(void)561 static int op_slad(void) /* SLA D */
562 {
563 (D & 128) ? (F |= C_FLAG) : (F &= ~C_FLAG);
564 D <<= 1;
565 F &= ~(H_FLAG | N_FLAG);
566 (D) ? (F &= ~Z_FLAG) : (F |= Z_FLAG);
567 (D & 128) ? (F |= S_FLAG) : (F &= ~S_FLAG);
568 (parity[D]) ? (F &= ~P_FLAG) : (F |= P_FLAG);
569 return(8);
570 }
571
op_slae(void)572 static int op_slae(void) /* SLA E */
573 {
574 (E & 128) ? (F |= C_FLAG) : (F &= ~C_FLAG);
575 E <<= 1;
576 F &= ~(H_FLAG | N_FLAG);
577 (E) ? (F &= ~Z_FLAG) : (F |= Z_FLAG);
578 (E & 128) ? (F |= S_FLAG) : (F &= ~S_FLAG);
579 (parity[E]) ? (F &= ~P_FLAG) : (F |= P_FLAG);
580 return(8);
581 }
582
op_slah(void)583 static int op_slah(void) /* SLA H */
584 {
585 (H & 128) ? (F |= C_FLAG) : (F &= ~C_FLAG);
586 H <<= 1;
587 F &= ~(H_FLAG | N_FLAG);
588 (H) ? (F &= ~Z_FLAG) : (F |= Z_FLAG);
589 (H & 128) ? (F |= S_FLAG) : (F &= ~S_FLAG);
590 (parity[H]) ? (F &= ~P_FLAG) : (F |= P_FLAG);
591 return(8);
592 }
593
op_slal(void)594 static int op_slal(void) /* SLA L */
595 {
596 (L & 128) ? (F |= C_FLAG) : (F &= ~C_FLAG);
597 L <<= 1;
598 F &= ~(H_FLAG | N_FLAG);
599 (L) ? (F &= ~Z_FLAG) : (F |= Z_FLAG);
600 (L & 128) ? (F |= S_FLAG) : (F &= ~S_FLAG);
601 (parity[L]) ? (F &= ~P_FLAG) : (F |= P_FLAG);
602 return(8);
603 }
604
op_slahl(void)605 static int op_slahl(void) /* SLA (HL) */
606 {
607 register BYTE P;
608 WORD addr;
609
610 addr = (H << 8) + L;
611 P = memrdr(addr);
612 (P & 128) ? (F |= C_FLAG) : (F &= ~C_FLAG);
613 P <<= 1;
614 memwrt(addr, P);
615 F &= ~(H_FLAG | N_FLAG);
616 (P) ? (F &= ~Z_FLAG) : (F |= Z_FLAG);
617 (P & 128) ? (F |= S_FLAG) : (F &= ~S_FLAG);
618 (parity[P]) ? (F &= ~P_FLAG) : (F |= P_FLAG);
619 return(15);
620 }
621
op_rlra(void)622 static int op_rlra(void) /* RL A */
623 {
624 register int old_c_flag;
625
626 old_c_flag = F & C_FLAG;
627 (A & 128) ? (F |= C_FLAG) : (F &= ~C_FLAG);
628 A <<= 1;
629 if (old_c_flag) A |= 1;
630 F &= ~(H_FLAG | N_FLAG);
631 (A) ? (F &= ~Z_FLAG) : (F |= Z_FLAG);
632 (A & 128) ? (F |= S_FLAG) : (F &= ~S_FLAG);
633 (parity[A]) ? (F &= ~P_FLAG) : (F |= P_FLAG);
634 return(8);
635 }
636
op_rlb(void)637 static int op_rlb(void) /* RL B */
638 {
639 register int old_c_flag;
640
641 old_c_flag = F & C_FLAG;
642 (B & 128) ? (F |= C_FLAG) : (F &= ~C_FLAG);
643 B <<= 1;
644 if (old_c_flag) B |= 1;
645 F &= ~(H_FLAG | N_FLAG);
646 (B) ? (F &= ~Z_FLAG) : (F |= Z_FLAG);
647 (B & 128) ? (F |= S_FLAG) : (F &= ~S_FLAG);
648 (parity[B]) ? (F &= ~P_FLAG) : (F |= P_FLAG);
649 return(8);
650 }
651
op_rlc(void)652 static int op_rlc(void) /* RL C */
653 {
654 register int old_c_flag;
655
656 old_c_flag = F & C_FLAG;
657 (C & 128) ? (F |= C_FLAG) : (F &= ~C_FLAG);
658 C <<= 1;
659 if (old_c_flag) C |= 1;
660 F &= ~(H_FLAG | N_FLAG);
661 (C) ? (F &= ~Z_FLAG) : (F |= Z_FLAG);
662 (C & 128) ? (F |= S_FLAG) : (F &= ~S_FLAG);
663 (parity[C]) ? (F &= ~P_FLAG) : (F |= P_FLAG);
664 return(8);
665 }
666
op_rld(void)667 static int op_rld(void) /* RL D */
668 {
669 register int old_c_flag;
670
671 old_c_flag = F & C_FLAG;
672 (D & 128) ? (F |= C_FLAG) : (F &= ~C_FLAG);
673 D <<= 1;
674 if (old_c_flag) D |= 1;
675 F &= ~(H_FLAG | N_FLAG);
676 (D) ? (F &= ~Z_FLAG) : (F |= Z_FLAG);
677 (D & 128) ? (F |= S_FLAG) : (F &= ~S_FLAG);
678 (parity[D]) ? (F &= ~P_FLAG) : (F |= P_FLAG);
679 return(8);
680 }
681
op_rle(void)682 static int op_rle(void) /* RL E */
683 {
684 register int old_c_flag;
685
686 old_c_flag = F & C_FLAG;
687 (E & 128) ? (F |= C_FLAG) : (F &= ~C_FLAG);
688 E <<= 1;
689 if (old_c_flag) E |= 1;
690 F &= ~(H_FLAG | N_FLAG);
691 (E) ? (F &= ~Z_FLAG) : (F |= Z_FLAG);
692 (E & 128) ? (F |= S_FLAG) : (F &= ~S_FLAG);
693 (parity[E]) ? (F &= ~P_FLAG) : (F |= P_FLAG);
694 return(8);
695 }
696
op_rlh(void)697 static int op_rlh(void) /* RL H */
698 {
699 register int old_c_flag;
700
701 old_c_flag = F & C_FLAG;
702 (H & 128) ? (F |= C_FLAG) : (F &= ~C_FLAG);
703 H <<= 1;
704 if (old_c_flag) H |= 1;
705 F &= ~(H_FLAG | N_FLAG);
706 (H) ? (F &= ~Z_FLAG) : (F |= Z_FLAG);
707 (H & 128) ? (F |= S_FLAG) : (F &= ~S_FLAG);
708 (parity[H]) ? (F &= ~P_FLAG) :(F |= P_FLAG);
709 return(8);
710 }
711
op_rll(void)712 static int op_rll(void) /* RL L */
713 {
714 register int old_c_flag;
715
716 old_c_flag = F & C_FLAG;
717 (L & 128) ? (F |= C_FLAG) : (F &= ~C_FLAG);
718 L <<= 1;
719 if (old_c_flag) L |= 1;
720 F &= ~(H_FLAG | N_FLAG);
721 (L) ? (F &= ~Z_FLAG) : (F |= Z_FLAG);
722 (L & 128) ? (F |= S_FLAG) : (F &= ~S_FLAG);
723 (parity[L]) ? (F &= ~P_FLAG) : (F |= P_FLAG);
724 return(8);
725 }
726
op_rlhl(void)727 static int op_rlhl(void) /* RL (HL) */
728 {
729 register BYTE P;
730 WORD addr;
731 int old_c_flag;
732
733 addr = (H << 8) + L;
734 P = memrdr(addr);
735 old_c_flag = F & C_FLAG;
736 (P & 128) ? (F |= C_FLAG) : (F &= ~C_FLAG);
737 P <<= 1;
738 if (old_c_flag) P |= 1;
739 memwrt(addr, P);
740 F &= ~(H_FLAG | N_FLAG);
741 (P) ? (F &= ~Z_FLAG) : (F |= Z_FLAG);
742 (P & 128) ? (F |= S_FLAG) : (F &= ~S_FLAG);
743 (parity[P]) ? (F &= ~P_FLAG) : (F |= P_FLAG);
744 return(15);
745 }
746
op_rrra(void)747 static int op_rrra(void) /* RR A */
748 {
749 register int old_c_flag;
750
751 old_c_flag = F & C_FLAG;
752 (A & 1) ? (F |= C_FLAG) : (F &= ~C_FLAG);
753 A >>= 1;
754 if (old_c_flag) A |= 128;
755 F &= ~(H_FLAG | N_FLAG);
756 (A) ? (F &= ~Z_FLAG) : (F |= Z_FLAG);
757 (A & 128) ? (F |= S_FLAG) : (F &= ~S_FLAG);
758 (parity[A]) ? (F &= ~P_FLAG) : (F |= P_FLAG);
759 return(8);
760 }
761
op_rrb(void)762 static int op_rrb(void) /* RR B */
763 {
764 register int old_c_flag;
765
766 old_c_flag = F & C_FLAG;
767 (B & 1) ? (F |= C_FLAG) : (F &= ~C_FLAG);
768 B >>= 1;
769 if (old_c_flag) B |= 128;
770 F &= ~(H_FLAG | N_FLAG);
771 (B) ? (F &= ~Z_FLAG) : (F |= Z_FLAG);
772 (B & 128) ? (F |= S_FLAG) : (F &= ~S_FLAG);
773 (parity[B]) ? (F &= ~P_FLAG) : (F |= P_FLAG);
774 return(8);
775 }
776
op_rrc(void)777 static int op_rrc(void) /* RR C */
778 {
779 register int old_c_flag;
780
781 old_c_flag = F & C_FLAG;
782 (C & 1) ? (F |= C_FLAG) : (F &= ~C_FLAG);
783 C >>= 1;
784 if (old_c_flag) C |= 128;
785 F &= ~(H_FLAG | N_FLAG);
786 (C) ? (F &= ~Z_FLAG) : (F |= Z_FLAG);
787 (C & 128) ? (F |= S_FLAG) : (F &= ~S_FLAG);
788 (parity[C]) ? (F &= ~P_FLAG) : (F |= P_FLAG);
789 return(8);
790 }
791
op_rrd(void)792 static int op_rrd(void) /* RR D */
793 {
794 register int old_c_flag;
795
796 old_c_flag = F & C_FLAG;
797 (D & 1) ? (F |= C_FLAG) : (F &= ~C_FLAG);
798 D >>= 1;
799 if (old_c_flag) D |= 128;
800 F &= ~(H_FLAG | N_FLAG);
801 (D) ? (F &= ~Z_FLAG) : (F |= Z_FLAG);
802 (D & 128) ? (F |= S_FLAG) : (F &= ~S_FLAG);
803 (parity[D]) ? (F &= ~P_FLAG) : (F |= P_FLAG);
804 return(8);
805 }
806
op_rre(void)807 static int op_rre(void) /* RR E */
808 {
809 register int old_c_flag;
810
811 old_c_flag = F & C_FLAG;
812 (E & 1) ? (F |= C_FLAG) : (F &= ~C_FLAG);
813 E >>= 1;
814 if (old_c_flag) E |= 128;
815 F &= ~(H_FLAG | N_FLAG);
816 (E) ? (F &= ~Z_FLAG) : (F |= Z_FLAG);
817 (E & 128) ? (F |= S_FLAG) : (F &= ~S_FLAG);
818 (parity[E]) ? (F &= ~P_FLAG) : (F |= P_FLAG);
819 return(8);
820 }
821
op_rrh(void)822 static int op_rrh(void) /* RR H */
823 {
824 register int old_c_flag;
825
826 old_c_flag = F & C_FLAG;
827 (H & 1) ? (F |= C_FLAG) : (F &= ~C_FLAG);
828 H >>= 1;
829 if (old_c_flag) H |= 128;
830 F &= ~(H_FLAG | N_FLAG);
831 (H) ? (F &= ~Z_FLAG) : (F |= Z_FLAG);
832 (H & 128) ? (F |= S_FLAG) : (F &= ~S_FLAG);
833 (parity[H]) ? (F &= ~P_FLAG) : (F |= P_FLAG);
834 return(8);
835 }
836
op_rrl(void)837 static int op_rrl(void) /* RR L */
838 {
839 register int old_c_flag;
840
841 old_c_flag = F & C_FLAG;
842 (L & 1) ? (F |= C_FLAG) : (F &= ~C_FLAG);
843 L >>= 1;
844 if (old_c_flag) L |= 128;
845 F &= ~(H_FLAG | N_FLAG);
846 (L) ? (F &= ~Z_FLAG) : (F |= Z_FLAG);
847 (L & 128) ? (F |= S_FLAG) : (F &= ~S_FLAG);
848 (parity[L]) ? (F &= ~P_FLAG) : (F |= P_FLAG);
849 return(8);
850 }
851
op_rrhl(void)852 static int op_rrhl(void) /* RR (HL) */
853 {
854 register BYTE P;
855 WORD addr;
856 int old_c_flag;
857
858 addr = (H << 8) + L;
859 P = memrdr(addr);
860 old_c_flag = F & C_FLAG;
861 (P & 1) ? (F |= C_FLAG) : (F &= ~C_FLAG);
862 P >>= 1;
863 if (old_c_flag) P |= 128;
864 memwrt(addr, P);
865 F &= ~(H_FLAG | N_FLAG);
866 (P) ? (F &= ~Z_FLAG) : (F |= Z_FLAG);
867 (P & 128) ? (F |= S_FLAG) : (F &= ~S_FLAG);
868 (parity[P]) ? (F &= ~P_FLAG) : (F |= P_FLAG);
869 return(15);
870 }
871
op_rrcra(void)872 static int op_rrcra(void) /* RRC A */
873 {
874 register int i;
875
876 i = A & 1;
877 (i) ? (F |= C_FLAG) : (F &= ~C_FLAG);
878 F &= ~(H_FLAG | N_FLAG);
879 A >>= 1;
880 if (i) A |= 128;
881 (A) ? (F &= ~Z_FLAG) : (F |= Z_FLAG);
882 (A & 128) ? (F |= S_FLAG) : (F &= ~S_FLAG);
883 (parity[A]) ? (F &= ~P_FLAG) : (F |= P_FLAG);
884 return(8);
885 }
886
op_rrcb(void)887 static int op_rrcb(void) /* RRC B */
888 {
889 register int i;
890
891 i = B & 1;
892 (i) ? (F |= C_FLAG) : (F &= ~C_FLAG);
893 F &= ~(H_FLAG | N_FLAG);
894 B >>= 1;
895 if (i) B |= 128;
896 (B) ? (F &= ~Z_FLAG) : (F |= Z_FLAG);
897 (B & 128) ? (F |= S_FLAG) : (F &= ~S_FLAG);
898 (parity[B]) ? (F &= ~P_FLAG) : (F |= P_FLAG);
899 return(8);
900 }
901
op_rrcc(void)902 static int op_rrcc(void) /* RRC C */
903 {
904 register int i;
905
906 i = C & 1;
907 (i) ? (F |= C_FLAG) : (F &= ~C_FLAG);
908 F &= ~(H_FLAG | N_FLAG);
909 C >>= 1;
910 if (i) C |= 128;
911 (C) ? (F &= ~Z_FLAG) : (F |= Z_FLAG);
912 (C & 128) ? (F |= S_FLAG) : (F &= ~S_FLAG);
913 (parity[C]) ? (F &= ~P_FLAG) : (F |= P_FLAG);
914 return(8);
915 }
916
op_rrcd(void)917 static int op_rrcd(void) /* RRC D */
918 {
919 register int i;
920
921 i = D & 1;
922 (i) ? (F |= C_FLAG) : (F &= ~C_FLAG);
923 F &= ~(H_FLAG | N_FLAG);
924 D >>= 1;
925 if (i) D |= 128;
926 (D) ? (F &= ~Z_FLAG) : (F |= Z_FLAG);
927 (D & 128) ? (F |= S_FLAG) : (F &= ~S_FLAG);
928 (parity[D]) ? (F &= ~P_FLAG) : (F |= P_FLAG);
929 return(8);
930 }
931
op_rrce(void)932 static int op_rrce(void) /* RRC E */
933 {
934 register int i;
935
936 i = E & 1;
937 (i) ? (F |= C_FLAG) : (F &= ~C_FLAG);
938 F &= ~(H_FLAG | N_FLAG);
939 E >>= 1;
940 if (i) E |= 128;
941 (E) ? (F &= ~Z_FLAG) : (F |= Z_FLAG);
942 (E & 128) ? (F |= S_FLAG) : (F &= ~S_FLAG);
943 (parity[E]) ? (F &= ~P_FLAG) : (F |= P_FLAG);
944 return(8);
945 }
946
op_rrch(void)947 static int op_rrch(void) /* RRC H */
948 {
949 register int i;
950
951 i = H & 1;
952 (i) ? (F |= C_FLAG) : (F &= ~C_FLAG);
953 F &= ~(H_FLAG | N_FLAG);
954 H >>= 1;
955 if (i) H |= 128;
956 (H) ? (F &= ~Z_FLAG) : (F |= Z_FLAG);
957 (H & 128) ? (F |= S_FLAG) : (F &= ~S_FLAG);
958 (parity[H]) ? (F &= ~P_FLAG) : (F |= P_FLAG);
959 return(8);
960 }
961
op_rrcl(void)962 static int op_rrcl(void) /* RRC L */
963 {
964 register int i;
965
966 i = L & 1;
967 (i) ? (F |= C_FLAG) : (F &= ~C_FLAG);
968 F &= ~(H_FLAG | N_FLAG);
969 L >>= 1;
970 if (i) L |= 128;
971 (L) ? (F &= ~Z_FLAG) : (F |= Z_FLAG);
972 (L & 128) ? (F |= S_FLAG) : (F &= ~S_FLAG);
973 (parity[L]) ? (F &= ~P_FLAG) : (F |= P_FLAG);
974 return(8);
975 }
976
op_rrchl(void)977 static int op_rrchl(void) /* RRC (HL) */
978 {
979 register BYTE P;
980 WORD addr;
981 int i;
982
983 addr = (H << 8) + L;
984 P = memrdr(addr);
985 i = P & 1;
986 (i) ? (F |= C_FLAG) : (F &= ~C_FLAG);
987 P >>= 1;
988 if (i) P |= 128;
989 memwrt(addr, P);
990 F &= ~(H_FLAG | N_FLAG);
991 (P) ? (F &= ~Z_FLAG) : (F |= Z_FLAG);
992 (P & 128) ? (F |= S_FLAG) : (F &= ~S_FLAG);
993 (parity[P]) ? (F &= ~P_FLAG) : (F |= P_FLAG);
994 return(15);
995 }
996
op_rlcra(void)997 static int op_rlcra(void) /* RLC A */
998 {
999 register int i;
1000
1001 i = A & 128;
1002 (i) ? (F |= C_FLAG) : (F &= ~C_FLAG);
1003 F &= ~(H_FLAG | N_FLAG);
1004 A <<= 1;
1005 if (i) A |= 1;
1006 (A) ? (F &= ~Z_FLAG) : (F |= Z_FLAG);
1007 (A & 128) ? (F |= S_FLAG) : (F &= ~S_FLAG);
1008 (parity[A]) ? (F &= ~P_FLAG) : (F |= P_FLAG);
1009 return(8);
1010 }
1011
op_rlcb(void)1012 static int op_rlcb(void) /* RLC B */
1013 {
1014 register int i;
1015
1016 i = B & 128;
1017 (i) ? (F |= C_FLAG) : (F &= ~C_FLAG);
1018 F &= ~(H_FLAG | N_FLAG);
1019 B <<= 1;
1020 if (i) B |= 1;
1021 (B) ? (F &= ~Z_FLAG) : (F |= Z_FLAG);
1022 (B & 128) ? (F |= S_FLAG) : (F &= ~S_FLAG);
1023 (parity[B]) ? (F &= ~P_FLAG) : (F |= P_FLAG);
1024 return(8);
1025 }
1026
op_rlcc(void)1027 static int op_rlcc(void) /* RLC C */
1028 {
1029 register int i;
1030
1031 i = C & 128;
1032 (i) ? (F |= C_FLAG) : (F &= ~C_FLAG);
1033 F &= ~(H_FLAG | N_FLAG);
1034 C <<= 1;
1035 if (i) C |= 1;
1036 (C) ? (F &= ~Z_FLAG) : (F |= Z_FLAG);
1037 (C & 128) ? (F |= S_FLAG) : (F &= ~S_FLAG);
1038 (parity[C]) ? (F &= ~P_FLAG) : (F |= P_FLAG);
1039 return(8);
1040 }
1041
op_rlcd(void)1042 static int op_rlcd(void) /* RLC D */
1043 {
1044 register int i;
1045
1046 i = D & 128;
1047 (i) ? (F |= C_FLAG) : (F &= ~C_FLAG);
1048 F &= ~(H_FLAG | N_FLAG);
1049 D <<= 1;
1050 if (i) D |= 1;
1051 (D) ? (F &= ~Z_FLAG) : (F |= Z_FLAG);
1052 (D & 128) ? (F |= S_FLAG) : (F &= ~S_FLAG);
1053 (parity[D]) ? (F &= ~P_FLAG) : (F |= P_FLAG);
1054 return(8);
1055 }
1056
op_rlce(void)1057 static int op_rlce(void) /* RLC E */
1058 {
1059 register int i;
1060
1061 i = E & 128;
1062 (i) ? (F |= C_FLAG) : (F &= ~C_FLAG);
1063 F &= ~(H_FLAG | N_FLAG);
1064 E <<= 1;
1065 if (i) E |= 1;
1066 (E) ? (F &= ~Z_FLAG) : (F |= Z_FLAG);
1067 (E & 128) ? (F |= S_FLAG) : (F &= ~S_FLAG);
1068 (parity[E]) ? (F &= ~P_FLAG) : (F |= P_FLAG);
1069 return(8);
1070 }
1071
op_rlch(void)1072 static int op_rlch(void) /* RLC H */
1073 {
1074 register int i;
1075
1076 i = H & 128;
1077 (i) ? (F |= C_FLAG) : (F &= ~C_FLAG);
1078 F &= ~(H_FLAG | N_FLAG);
1079 H <<= 1;
1080 if (i) H |= 1;
1081 (H) ? (F &= ~Z_FLAG) : (F |= Z_FLAG);
1082 (H & 128) ? (F |= S_FLAG) : (F &= ~S_FLAG);
1083 (parity[H]) ? (F &= ~P_FLAG) : (F |= P_FLAG);
1084 return(8);
1085 }
1086
op_rlcl(void)1087 static int op_rlcl(void) /* RLC L */
1088 {
1089 register int i;
1090
1091 i = L & 128;
1092 (i) ? (F |= C_FLAG) : (F &= ~C_FLAG);
1093 F &= ~(H_FLAG | N_FLAG);
1094 L <<= 1;
1095 if (i) L |= 1;
1096 (L) ? (F &= ~Z_FLAG) : (F |= Z_FLAG);
1097 (L & 128) ? (F |= S_FLAG) : (F &= ~S_FLAG);
1098 (parity[L]) ? (F &= ~P_FLAG) : (F |= P_FLAG);
1099 return(8);
1100 }
1101
op_rlchl(void)1102 static int op_rlchl(void) /* RLC (HL) */
1103 {
1104 register BYTE P;
1105 WORD addr;
1106 int i;
1107
1108 addr = (H << 8) + L;
1109 P = memrdr(addr);
1110 i = P & 128;
1111 (i) ? (F |= C_FLAG) : (F &= ~C_FLAG);
1112 P <<= 1;
1113 if (i) P |= 1;
1114 memwrt(addr, P);
1115 F &= ~(H_FLAG | N_FLAG);
1116 (P) ? (F &= ~Z_FLAG) : (F |= Z_FLAG);
1117 (P & 128) ? (F |= S_FLAG) : (F &= ~S_FLAG);
1118 (parity[P]) ? (F &= ~P_FLAG) : (F |= P_FLAG);
1119 return(15);
1120 }
1121
op_sraa(void)1122 static int op_sraa(void) /* SRA A */
1123 {
1124 register int i;
1125
1126 i = A & 128;
1127 (A & 1) ? (F |= C_FLAG) : (F &= ~C_FLAG);
1128 A >>= 1;
1129 A |= i;
1130 F &= ~(H_FLAG | N_FLAG);
1131 (A) ? (F &= ~Z_FLAG) : (F |= Z_FLAG);
1132 (A & 128) ? (F |= S_FLAG) : (F &= ~S_FLAG);
1133 (parity[A]) ? (F &= ~P_FLAG) : (F |= P_FLAG);
1134 return(8);
1135 }
1136
op_srab(void)1137 static int op_srab(void) /* SRA B */
1138 {
1139 register int i;
1140
1141 i = B & 128;
1142 (B & 1) ? (F |= C_FLAG) : (F &= ~C_FLAG);
1143 B >>= 1;
1144 B |= i;
1145 F &= ~(H_FLAG | N_FLAG);
1146 (B) ? (F &= ~Z_FLAG) : (F |= Z_FLAG);
1147 (B & 128) ? (F |= S_FLAG) : (F &= ~S_FLAG);
1148 (parity[B]) ? (F &= ~P_FLAG) : (F |= P_FLAG);
1149 return(8);
1150 }
1151
op_srac(void)1152 static int op_srac(void) /* SRA C */
1153 {
1154 register int i;
1155
1156 i = C & 128;
1157 (C & 1) ? (F |= C_FLAG) : (F &= ~C_FLAG);
1158 C >>= 1;
1159 C |= i;
1160 F &= ~(H_FLAG | N_FLAG);
1161 (C) ? (F &= ~Z_FLAG) : (F |= Z_FLAG);
1162 (C & 128) ? (F |= S_FLAG) : (F &= ~S_FLAG);
1163 (parity[C]) ? (F &= ~P_FLAG) : (F |= P_FLAG);
1164 return(8);
1165 }
1166
op_srad(void)1167 static int op_srad(void) /* SRA D */
1168 {
1169 register int i;
1170
1171 i = D & 128;
1172 (D & 1) ? (F |= C_FLAG) : (F &= ~C_FLAG);
1173 D >>= 1;
1174 D |= i;
1175 F &= ~(H_FLAG | N_FLAG);
1176 (D) ? (F &= ~Z_FLAG) : (F |= Z_FLAG);
1177 (D & 128) ? (F |= S_FLAG) : (F &= ~S_FLAG);
1178 (parity[D]) ? (F &= ~P_FLAG) : (F |= P_FLAG);
1179 return(8);
1180 }
1181
op_srae(void)1182 static int op_srae(void) /* SRA E */
1183 {
1184 register int i;
1185
1186 i = E & 128;
1187 (E & 1) ? (F |= C_FLAG) : (F &= ~C_FLAG);
1188 E >>= 1;
1189 E |= i;
1190 F &= ~(H_FLAG | N_FLAG);
1191 (E) ? (F &= ~Z_FLAG) : (F |= Z_FLAG);
1192 (E & 128) ? (F |= S_FLAG) : (F &= ~S_FLAG);
1193 (parity[E]) ? (F &= ~P_FLAG) : (F |= P_FLAG);
1194 return(8);
1195 }
1196
op_srah(void)1197 static int op_srah(void) /* SRA H */
1198 {
1199 register int i;
1200
1201 i = H & 128;
1202 (H & 1) ? (F |= C_FLAG) : (F &= ~C_FLAG);
1203 H >>= 1;
1204 H |= i;
1205 F &= ~(H_FLAG | N_FLAG);
1206 (H) ? (F &= ~Z_FLAG) : (F |= Z_FLAG);
1207 (H & 128) ? (F |= S_FLAG) : (F &= ~S_FLAG);
1208 (parity[H]) ? (F &= ~P_FLAG) : (F |= P_FLAG);
1209 return(8);
1210 }
1211
op_sral(void)1212 static int op_sral(void) /* SRA L */
1213 {
1214 register int i;
1215
1216 i = L & 128;
1217 (L & 1) ? (F |= C_FLAG) : (F &= ~C_FLAG);
1218 L >>= 1;
1219 L |= i;
1220 F &= ~(H_FLAG | N_FLAG);
1221 (L) ? (F &= ~Z_FLAG) : (F |= Z_FLAG);
1222 (L & 128) ? (F |= S_FLAG) : (F &= ~S_FLAG);
1223 (parity[L]) ? (F &= ~P_FLAG) : (F |= P_FLAG);
1224 return(8);
1225 }
1226
op_srahl(void)1227 static int op_srahl(void) /* SRA (HL) */
1228 {
1229 register BYTE P;
1230 WORD addr;
1231 int i;
1232
1233 addr = (H << 8) + L;
1234 P = memrdr(addr);
1235 i = P & 128;
1236 (P & 1) ? (F |= C_FLAG) : (F &= ~C_FLAG);
1237 P = (P >> 1) | i;
1238 memwrt(addr, P);
1239 F &= ~(H_FLAG | N_FLAG);
1240 (P) ? (F &= ~Z_FLAG) : (F |= Z_FLAG);
1241 (P & 128) ? (F |= S_FLAG) : (F &= ~S_FLAG);
1242 (parity[P]) ? (F &= ~P_FLAG) : (F |= P_FLAG);
1243 return(15);
1244 }
1245
op_sb0a(void)1246 static int op_sb0a(void) /* SET 0,A */
1247 {
1248 A |= 1;
1249 return(8);
1250 }
1251
op_sb1a(void)1252 static int op_sb1a(void) /* SET 1,A */
1253 {
1254 A |= 2;
1255 return(8);
1256 }
1257
op_sb2a(void)1258 static int op_sb2a(void) /* SET 2,A */
1259 {
1260 A |= 4;
1261 return(8);
1262 }
1263
op_sb3a(void)1264 static int op_sb3a(void) /* SET 3,A */
1265 {
1266 A |= 8;
1267 return(8);
1268 }
1269
op_sb4a(void)1270 static int op_sb4a(void) /* SET 4,A */
1271 {
1272 A |= 16;
1273 return(8);
1274 }
1275
op_sb5a(void)1276 static int op_sb5a(void) /* SET 5,A */
1277 {
1278 A |= 32;
1279 return(8);
1280 }
1281
op_sb6a(void)1282 static int op_sb6a(void) /* SET 6,A */
1283 {
1284 A |= 64;
1285 return(8);
1286 }
1287
op_sb7a(void)1288 static int op_sb7a(void) /* SET 7,A */
1289 {
1290 A |= 128;
1291 return(8);
1292 }
1293
op_sb0b(void)1294 static int op_sb0b(void) /* SET 0,B */
1295 {
1296 B |= 1;
1297 return(8);
1298 }
1299
op_sb1b(void)1300 static int op_sb1b(void) /* SET 1,B */
1301 {
1302 B |= 2;
1303 return(8);
1304 }
1305
op_sb2b(void)1306 static int op_sb2b(void) /* SET 2,B */
1307 {
1308 B |= 4;
1309 return(8);
1310 }
1311
op_sb3b(void)1312 static int op_sb3b(void) /* SET 3,B */
1313 {
1314 B |= 8;
1315 return(8);
1316 }
1317
op_sb4b(void)1318 static int op_sb4b(void) /* SET 4,B */
1319 {
1320 B |= 16;
1321 return(8);
1322 }
1323
op_sb5b(void)1324 static int op_sb5b(void) /* SET 5,B */
1325 {
1326 B |= 32;
1327 return(8);
1328 }
1329
op_sb6b(void)1330 static int op_sb6b(void) /* SET 6,B */
1331 {
1332 B |= 64;
1333 return(8);
1334 }
1335
op_sb7b(void)1336 static int op_sb7b(void) /* SET 7,B */
1337 {
1338 B |= 128;
1339 return(8);
1340 }
1341
op_sb0c(void)1342 static int op_sb0c(void) /* SET 0,C */
1343 {
1344 C |= 1;
1345 return(8);
1346 }
1347
op_sb1c(void)1348 static int op_sb1c(void) /* SET 1,C */
1349 {
1350 C |= 2;
1351 return(8);
1352 }
1353
op_sb2c(void)1354 static int op_sb2c(void) /* SET 2,C */
1355 {
1356 C |= 4;
1357 return(8);
1358 }
1359
op_sb3c(void)1360 static int op_sb3c(void) /* SET 3,C */
1361 {
1362 C |= 8;
1363 return(8);
1364 }
1365
op_sb4c(void)1366 static int op_sb4c(void) /* SET 4,C */
1367 {
1368 C |= 16;
1369 return(8);
1370 }
1371
op_sb5c(void)1372 static int op_sb5c(void) /* SET 5,C */
1373 {
1374 C |= 32;
1375 return(8);
1376 }
1377
op_sb6c(void)1378 static int op_sb6c(void) /* SET 6,C */
1379 {
1380 C |= 64;
1381 return(8);
1382 }
1383
op_sb7c(void)1384 static int op_sb7c(void) /* SET 7,C */
1385 {
1386 C |= 128;
1387 return(8);
1388 }
1389
op_sb0d(void)1390 static int op_sb0d(void) /* SET 0,D */
1391 {
1392 D |= 1;
1393 return(8);
1394 }
1395
op_sb1d(void)1396 static int op_sb1d(void) /* SET 1,D */
1397 {
1398 D |= 2;
1399 return(8);
1400 }
1401
op_sb2d(void)1402 static int op_sb2d(void) /* SET 2,D */
1403 {
1404 D |= 4;
1405 return(8);
1406 }
1407
op_sb3d(void)1408 static int op_sb3d(void) /* SET 3,D */
1409 {
1410 D |= 8;
1411 return(8);
1412 }
1413
op_sb4d(void)1414 static int op_sb4d(void) /* SET 4,D */
1415 {
1416 D |= 16;
1417 return(8);
1418 }
1419
op_sb5d(void)1420 static int op_sb5d(void) /* SET 5,D */
1421 {
1422 D |= 32;
1423 return(8);
1424 }
1425
op_sb6d(void)1426 static int op_sb6d(void) /* SET 6,D */
1427 {
1428 D |= 64;
1429 return(8);
1430 }
1431
op_sb7d(void)1432 static int op_sb7d(void) /* SET 7,D */
1433 {
1434 D |= 128;
1435 return(8);
1436 }
1437
op_sb0e(void)1438 static int op_sb0e(void) /* SET 0,E */
1439 {
1440 E |= 1;
1441 return(8);
1442 }
1443
op_sb1e(void)1444 static int op_sb1e(void) /* SET 1,E */
1445 {
1446 E |= 2;
1447 return(8);
1448 }
1449
op_sb2e(void)1450 static int op_sb2e(void) /* SET 2,E */
1451 {
1452 E |= 4;
1453 return(8);
1454 }
1455
op_sb3e(void)1456 static int op_sb3e(void) /* SET 3,E */
1457 {
1458 E |= 8;
1459 return(8);
1460 }
1461
op_sb4e(void)1462 static int op_sb4e(void) /* SET 4,E */
1463 {
1464 E |= 16;
1465 return(8);
1466 }
1467
op_sb5e(void)1468 static int op_sb5e(void) /* SET 5,E */
1469 {
1470 E |= 32;
1471 return(8);
1472 }
1473
op_sb6e(void)1474 static int op_sb6e(void) /* SET 6,E */
1475 {
1476 E |= 64;
1477 return(8);
1478 }
1479
op_sb7e(void)1480 static int op_sb7e(void) /* SET 7,E */
1481 {
1482 E |= 128;
1483 return(8);
1484 }
1485
op_sb0h(void)1486 static int op_sb0h(void) /* SET 0,H */
1487 {
1488 H |= 1;
1489 return(8);
1490 }
1491
op_sb1h(void)1492 static int op_sb1h(void) /* SET 1,H */
1493 {
1494 H |= 2;
1495 return(8);
1496 }
1497
op_sb2h(void)1498 static int op_sb2h(void) /* SET 2,H */
1499 {
1500 H |= 4;
1501 return(8);
1502 }
1503
op_sb3h(void)1504 static int op_sb3h(void) /* SET 3,H */
1505 {
1506 H |= 8;
1507 return(8);
1508 }
1509
op_sb4h(void)1510 static int op_sb4h(void) /* SET 4,H */
1511 {
1512 H |= 16;
1513 return(8);
1514 }
1515
op_sb5h(void)1516 static int op_sb5h(void) /* SET 5,H */
1517 {
1518 H |= 32;
1519 return(8);
1520 }
1521
op_sb6h(void)1522 static int op_sb6h(void) /* SET 6,H */
1523 {
1524 H |= 64;
1525 return(8);
1526 }
1527
op_sb7h(void)1528 static int op_sb7h(void) /* SET 7,H */
1529 {
1530 H |= 128;
1531 return(8);
1532 }
1533
op_sb0l(void)1534 static int op_sb0l(void) /* SET 0,L */
1535 {
1536 L |= 1;
1537 return(8);
1538 }
1539
op_sb1l(void)1540 static int op_sb1l(void) /* SET 1,L */
1541 {
1542 L |= 2;
1543 return(8);
1544 }
1545
op_sb2l(void)1546 static int op_sb2l(void) /* SET 2,L */
1547 {
1548 L |= 4;
1549 return(8);
1550 }
1551
op_sb3l(void)1552 static int op_sb3l(void) /* SET 3,L */
1553 {
1554 L |= 8;
1555 return(8);
1556 }
1557
op_sb4l(void)1558 static int op_sb4l(void) /* SET 4,L */
1559 {
1560 L |= 16;
1561 return(8);
1562 }
1563
op_sb5l(void)1564 static int op_sb5l(void) /* SET 5,L */
1565 {
1566 L |= 32;
1567 return(8);
1568 }
1569
op_sb6l(void)1570 static int op_sb6l(void) /* SET 6,L */
1571 {
1572 L |= 64;
1573 return(8);
1574 }
1575
op_sb7l(void)1576 static int op_sb7l(void) /* SET 7,L */
1577 {
1578 L |= 128;
1579 return(8);
1580 }
1581
op_sb0hl(void)1582 static int op_sb0hl(void) /* SET 0,(HL) */
1583 {
1584 memwrt((H << 8) + L, memrdr((H << 8) + L) | 1);
1585 return(15);
1586 }
1587
op_sb1hl(void)1588 static int op_sb1hl(void) /* SET 1,(HL) */
1589 {
1590 memwrt((H << 8) + L, memrdr((H << 8) + L) | 2);
1591 return(15);
1592 }
1593
op_sb2hl(void)1594 static int op_sb2hl(void) /* SET 2,(HL) */
1595 {
1596 memwrt((H << 8) + L, memrdr((H << 8) + L) | 4);
1597 return(15);
1598 }
1599
op_sb3hl(void)1600 static int op_sb3hl(void) /* SET 3,(HL) */
1601 {
1602 memwrt((H << 8) + L, memrdr((H << 8) + L) | 8);
1603 return(15);
1604 }
1605
op_sb4hl(void)1606 static int op_sb4hl(void) /* SET 4,(HL) */
1607 {
1608 memwrt((H << 8) + L, memrdr((H << 8) + L) | 16);
1609 return(15);
1610 }
1611
op_sb5hl(void)1612 static int op_sb5hl(void) /* SET 5,(HL) */
1613 {
1614 memwrt((H << 8) + L, memrdr((H << 8) + L) | 32);
1615 return(15);
1616 }
1617
op_sb6hl(void)1618 static int op_sb6hl(void) /* SET 6,(HL) */
1619 {
1620 memwrt((H << 8) + L, memrdr((H << 8) + L) | 64);
1621 return(15);
1622 }
1623
op_sb7hl(void)1624 static int op_sb7hl(void) /* SET 7,(HL) */
1625 {
1626 memwrt((H << 8) + L, memrdr((H << 8) + L) | 128);
1627 return(15);
1628 }
1629
op_rb0a(void)1630 static int op_rb0a(void) /* RES 0,A */
1631 {
1632 A &= ~1;
1633 return(8);
1634 }
1635
op_rb1a(void)1636 static int op_rb1a(void) /* RES 1,A */
1637 {
1638 A &= ~2;
1639 return(8);
1640 }
1641
op_rb2a(void)1642 static int op_rb2a(void) /* RES 2,A */
1643 {
1644 A &= ~4;
1645 return(8);
1646 }
1647
op_rb3a(void)1648 static int op_rb3a(void) /* RES 3,A */
1649 {
1650 A &= ~8;
1651 return(8);
1652 }
1653
op_rb4a(void)1654 static int op_rb4a(void) /* RES 4,A */
1655 {
1656 A &= ~16;
1657 return(8);
1658 }
1659
op_rb5a(void)1660 static int op_rb5a(void) /* RES 5,A */
1661 {
1662 A &= ~32;
1663 return(8);
1664 }
1665
op_rb6a(void)1666 static int op_rb6a(void) /* RES 6,A */
1667 {
1668 A &= ~64;
1669 return(8);
1670 }
1671
op_rb7a(void)1672 static int op_rb7a(void) /* RES 7,A */
1673 {
1674 A &= ~128;
1675 return(8);
1676 }
1677
op_rb0b(void)1678 static int op_rb0b(void) /* RES 0,B */
1679 {
1680 B &= ~1;
1681 return(8);
1682 }
1683
op_rb1b(void)1684 static int op_rb1b(void) /* RES 1,B */
1685 {
1686 B &= ~2;
1687 return(8);
1688 }
1689
op_rb2b(void)1690 static int op_rb2b(void) /* RES 2,B */
1691 {
1692 B &= ~4;
1693 return(8);
1694 }
1695
op_rb3b(void)1696 static int op_rb3b(void) /* RES 3,B */
1697 {
1698 B &= ~8;
1699 return(8);
1700 }
1701
op_rb4b(void)1702 static int op_rb4b(void) /* RES 4,B */
1703 {
1704 B &= ~16;
1705 return(8);
1706 }
1707
op_rb5b(void)1708 static int op_rb5b(void) /* RES 5,B */
1709 {
1710 B &= ~32;
1711 return(8);
1712 }
1713
op_rb6b(void)1714 static int op_rb6b(void) /* RES 6,B */
1715 {
1716 B &= ~64;
1717 return(8);
1718 }
1719
op_rb7b(void)1720 static int op_rb7b(void) /* RES 7,B */
1721 {
1722 B &= ~128;
1723 return(8);
1724 }
1725
op_rb0c(void)1726 static int op_rb0c(void) /* RES 0,C */
1727 {
1728 C &= ~1;
1729 return(8);
1730 }
1731
op_rb1c(void)1732 static int op_rb1c(void) /* RES 1,C */
1733 {
1734 C &= ~2;
1735 return(8);
1736 }
1737
op_rb2c(void)1738 static int op_rb2c(void) /* RES 2,C */
1739 {
1740 C &= ~4;
1741 return(8);
1742 }
1743
op_rb3c(void)1744 static int op_rb3c(void) /* RES 3,C */
1745 {
1746 C &= ~8;
1747 return(8);
1748 }
1749
op_rb4c(void)1750 static int op_rb4c(void) /* RES 4,C */
1751 {
1752 C &= ~16;
1753 return(8);
1754 }
1755
op_rb5c(void)1756 static int op_rb5c(void) /* RES 5,C */
1757 {
1758 C &= ~32;
1759 return(8);
1760 }
1761
op_rb6c(void)1762 static int op_rb6c(void) /* RES 6,C */
1763 {
1764 C &= ~64;
1765 return(8);
1766 }
1767
op_rb7c(void)1768 static int op_rb7c(void) /* RES 7,C */
1769 {
1770 C &= ~128;
1771 return(8);
1772 }
1773
op_rb0d(void)1774 static int op_rb0d(void) /* RES 0,D */
1775 {
1776 D &= ~1;
1777 return(8);
1778 }
1779
op_rb1d(void)1780 static int op_rb1d(void) /* RES 1,D */
1781 {
1782 D &= ~2;
1783 return(8);
1784 }
1785
op_rb2d(void)1786 static int op_rb2d(void) /* RES 2,D */
1787 {
1788 D &= ~4;
1789 return(8);
1790 }
1791
op_rb3d(void)1792 static int op_rb3d(void) /* RES 3,D */
1793 {
1794 D &= ~8;
1795 return(8);
1796 }
1797
op_rb4d(void)1798 static int op_rb4d(void) /* RES 4,D */
1799 {
1800 D &= ~16;
1801 return(8);
1802 }
1803
op_rb5d(void)1804 static int op_rb5d(void) /* RES 5,D */
1805 {
1806 D &= ~32;
1807 return(8);
1808 }
1809
op_rb6d(void)1810 static int op_rb6d(void) /* RES 6,D */
1811 {
1812 D &= ~64;
1813 return(8);
1814 }
1815
op_rb7d(void)1816 static int op_rb7d(void) /* RES 7,D */
1817 {
1818 D &= ~128;
1819 return(8);
1820 }
1821
op_rb0e(void)1822 static int op_rb0e(void) /* RES 0,E */
1823 {
1824 E &= ~1;
1825 return(8);
1826 }
1827
op_rb1e(void)1828 static int op_rb1e(void) /* RES 1,E */
1829 {
1830 E &= ~2;
1831 return(8);
1832 }
1833
op_rb2e(void)1834 static int op_rb2e(void) /* RES 2,E */
1835 {
1836 E &= ~4;
1837 return(8);
1838 }
1839
op_rb3e(void)1840 static int op_rb3e(void) /* RES 3,E */
1841 {
1842 E &= ~8;
1843 return(8);
1844 }
1845
op_rb4e(void)1846 static int op_rb4e(void) /* RES 4,E */
1847 {
1848 E &= ~16;
1849 return(8);
1850 }
1851
op_rb5e(void)1852 static int op_rb5e(void) /* RES 5,E */
1853 {
1854 E &= ~32;
1855 return(8);
1856 }
1857
op_rb6e(void)1858 static int op_rb6e(void) /* RES 6,E */
1859 {
1860 E &= ~64;
1861 return(8);
1862 }
1863
op_rb7e(void)1864 static int op_rb7e(void) /* RES 7,E */
1865 {
1866 E &= ~128;
1867 return(8);
1868 }
1869
op_rb0h(void)1870 static int op_rb0h(void) /* RES 0,H */
1871 {
1872 H &= ~1;
1873 return(8);
1874 }
1875
op_rb1h(void)1876 static int op_rb1h(void) /* RES 1,H */
1877 {
1878 H &= ~2;
1879 return(8);
1880 }
1881
op_rb2h(void)1882 static int op_rb2h(void) /* RES 2,H */
1883 {
1884 H &= ~4;
1885 return(8);
1886 }
1887
op_rb3h(void)1888 static int op_rb3h(void) /* RES 3,H */
1889 {
1890 H &= ~8;
1891 return(8);
1892 }
1893
op_rb4h(void)1894 static int op_rb4h(void) /* RES 4,H */
1895 {
1896 H &= ~16;
1897 return(8);
1898 }
1899
op_rb5h(void)1900 static int op_rb5h(void) /* RES 5,H */
1901 {
1902 H &= ~32;
1903 return(8);
1904 }
1905
op_rb6h(void)1906 static int op_rb6h(void) /* RES 6,H */
1907 {
1908 H &= ~64;
1909 return(8);
1910 }
1911
op_rb7h(void)1912 static int op_rb7h(void) /* RES 7,H */
1913 {
1914 H &= ~128;
1915 return(8);
1916 }
1917
op_rb0l(void)1918 static int op_rb0l(void) /* RES 0,L */
1919 {
1920 L &= ~1;
1921 return(8);
1922 }
1923
op_rb1l(void)1924 static int op_rb1l(void) /* RES 1,L */
1925 {
1926 L &= ~2;
1927 return(8);
1928 }
1929
op_rb2l(void)1930 static int op_rb2l(void) /* RES 2,L */
1931 {
1932 L &= ~4;
1933 return(8);
1934 }
1935
op_rb3l(void)1936 static int op_rb3l(void) /* RES 3,L */
1937 {
1938 L &= ~8;
1939 return(8);
1940 }
1941
op_rb4l(void)1942 static int op_rb4l(void) /* RES 4,L */
1943 {
1944 L &= ~16;
1945 return(8);
1946 }
1947
op_rb5l(void)1948 static int op_rb5l(void) /* RES 5,L */
1949 {
1950 L &= ~32;
1951 return(8);
1952 }
1953
op_rb6l(void)1954 static int op_rb6l(void) /* RES 6,L */
1955 {
1956 L &= ~64;
1957 return(8);
1958 }
1959
op_rb7l(void)1960 static int op_rb7l(void) /* RES 7,L */
1961 {
1962 L &= ~128;
1963 return(8);
1964 }
1965
op_rb0hl(void)1966 static int op_rb0hl(void) /* RES 0,(HL) */
1967 {
1968 memwrt((H << 8) + L, memrdr((H << 8) + L) & ~1);
1969 return(15);
1970 }
1971
op_rb1hl(void)1972 static int op_rb1hl(void) /* RES 1,(HL) */
1973 {
1974 memwrt((H << 8) + L, memrdr((H << 8) + L) & ~2);
1975 return(15);
1976 }
1977
op_rb2hl(void)1978 static int op_rb2hl(void) /* RES 2,(HL) */
1979 {
1980 memwrt((H << 8) + L, memrdr((H << 8) + L) & ~4);
1981 return(15);
1982 }
1983
op_rb3hl(void)1984 static int op_rb3hl(void) /* RES 3,(HL) */
1985 {
1986 memwrt((H << 8) + L, memrdr((H << 8) + L) & ~8);
1987 return(15);
1988 }
1989
op_rb4hl(void)1990 static int op_rb4hl(void) /* RES 4,(HL) */
1991 {
1992 memwrt((H << 8) + L, memrdr((H << 8) + L) & ~16);
1993 return(15);
1994 }
1995
op_rb5hl(void)1996 static int op_rb5hl(void) /* RES 5,(HL) */
1997 {
1998 memwrt((H << 8) + L, memrdr((H << 8) + L) & ~32);
1999 return(15);
2000 }
2001
op_rb6hl(void)2002 static int op_rb6hl(void) /* RES 6,(HL) */
2003 {
2004 memwrt((H << 8) + L, memrdr((H << 8) + L) & ~64);
2005 return(15);
2006 }
2007
op_rb7hl(void)2008 static int op_rb7hl(void) /* RES 7,(HL) */
2009 {
2010 memwrt((H << 8) + L, memrdr((H << 8) + L) & ~128);
2011 return(15);
2012 }
2013
op_tb0a(void)2014 static int op_tb0a(void) /* BIT 0,A */
2015 {
2016 F &= ~(N_FLAG | S_FLAG);
2017 F |= H_FLAG;
2018 (A & 1) ? (F &= ~(Z_FLAG | P_FLAG)) : (F |= (Z_FLAG | P_FLAG));
2019 return(8);
2020 }
2021
op_tb1a(void)2022 static int op_tb1a(void) /* BIT 1,A */
2023 {
2024 F &= ~(N_FLAG | S_FLAG);
2025 F |= H_FLAG;
2026 (A & 2) ? (F &= ~(Z_FLAG | P_FLAG)) : (F |= (Z_FLAG | P_FLAG));
2027 return(8);
2028 }
2029
op_tb2a(void)2030 static int op_tb2a(void) /* BIT 2,A */
2031 {
2032 F &= ~(N_FLAG | S_FLAG);
2033 F |= H_FLAG;
2034 (A & 4) ? (F &= ~(Z_FLAG | P_FLAG)) : (F |= (Z_FLAG | P_FLAG));
2035 return(8);
2036 }
2037
op_tb3a(void)2038 static int op_tb3a(void) /* BIT 3,A */
2039 {
2040 F &= ~(N_FLAG | S_FLAG);
2041 F |= H_FLAG;
2042 (A & 8) ? (F &= ~(Z_FLAG | P_FLAG)) : (F |= (Z_FLAG | P_FLAG));
2043 return(8);
2044 }
2045
op_tb4a(void)2046 static int op_tb4a(void) /* BIT 4,A */
2047 {
2048 F &= ~(N_FLAG | S_FLAG);
2049 F |= H_FLAG;
2050 (A & 16) ? (F &= ~(Z_FLAG | P_FLAG)) : (F |= (Z_FLAG | P_FLAG));
2051 return(8);
2052 }
2053
op_tb5a(void)2054 static int op_tb5a(void) /* BIT 5,A */
2055 {
2056 F &= ~(N_FLAG | S_FLAG);
2057 F |= H_FLAG;
2058 (A & 32) ? (F &= ~(Z_FLAG | P_FLAG)) : (F |= (Z_FLAG | P_FLAG));
2059 return(8);
2060 }
2061
op_tb6a(void)2062 static int op_tb6a(void) /* BIT 6,A */
2063 {
2064 F &= ~(N_FLAG | S_FLAG);
2065 F |= H_FLAG;
2066 (A & 64) ? (F &= ~(Z_FLAG | P_FLAG)) : (F |= (Z_FLAG | P_FLAG));
2067 return(8);
2068 }
2069
op_tb7a(void)2070 static int op_tb7a(void) /* BIT 7,A */
2071 {
2072 F &= ~N_FLAG;
2073 F |= H_FLAG;
2074 if (A & 128) {
2075 F &= ~(Z_FLAG | P_FLAG);
2076 F |= S_FLAG;
2077 } else {
2078 F |= (Z_FLAG | P_FLAG);
2079 F &= ~S_FLAG;
2080 }
2081 return(8);
2082 }
2083
op_tb0b(void)2084 static int op_tb0b(void) /* BIT 0,B */
2085 {
2086 F &= ~(N_FLAG | S_FLAG);
2087 F |= H_FLAG;
2088 (B & 1) ? (F &= ~(Z_FLAG | P_FLAG)) : (F |= (Z_FLAG | P_FLAG));
2089 return(8);
2090 }
2091
op_tb1b(void)2092 static int op_tb1b(void) /* BIT 1,B */
2093 {
2094 F &= ~(N_FLAG | S_FLAG);
2095 F |= H_FLAG;
2096 (B & 2) ? (F &= ~(Z_FLAG | P_FLAG)) : (F |= (Z_FLAG | P_FLAG));
2097 return(8);
2098 }
2099
op_tb2b(void)2100 static int op_tb2b(void) /* BIT 2,B */
2101 {
2102 F &= ~(N_FLAG | S_FLAG);
2103 F |= H_FLAG;
2104 (B & 4) ? (F &= ~(Z_FLAG | P_FLAG)) : (F |= (Z_FLAG | P_FLAG));
2105 return(8);
2106 }
2107
op_tb3b(void)2108 static int op_tb3b(void) /* BIT 3,B */
2109 {
2110 F &= ~(N_FLAG | S_FLAG);
2111 F |= H_FLAG;
2112 (B & 8) ? (F &= ~(Z_FLAG | P_FLAG)) : (F |= (Z_FLAG | P_FLAG));
2113 return(8);
2114 }
2115
op_tb4b(void)2116 static int op_tb4b(void) /* BIT 4,B */
2117 {
2118 F &= ~(N_FLAG | S_FLAG);
2119 F |= H_FLAG;
2120 (B & 16) ? (F &= ~(Z_FLAG | P_FLAG)) : (F |= (Z_FLAG | P_FLAG));
2121 return(8);
2122 }
2123
op_tb5b(void)2124 static int op_tb5b(void) /* BIT 5,B */
2125 {
2126 F &= ~(N_FLAG | S_FLAG);
2127 F |= H_FLAG;
2128 (B & 32) ? (F &= ~(Z_FLAG | P_FLAG)) : (F |= (Z_FLAG | P_FLAG));
2129 return(8);
2130 }
2131
op_tb6b(void)2132 static int op_tb6b(void) /* BIT 6,B */
2133 {
2134 F &= ~(N_FLAG | S_FLAG);
2135 F |= H_FLAG;
2136 (B & 64) ? (F &= ~(Z_FLAG | P_FLAG)) : (F |= (Z_FLAG | P_FLAG));
2137 return(8);
2138 }
2139
op_tb7b(void)2140 static int op_tb7b(void) /* BIT 7,B */
2141 {
2142 F &= ~N_FLAG;
2143 F |= H_FLAG;
2144 if (B & 128) {
2145 F &= ~(Z_FLAG | P_FLAG);
2146 F |= S_FLAG;
2147 } else {
2148 F |= (Z_FLAG | P_FLAG);
2149 F &= ~S_FLAG;
2150 }
2151 return(8);
2152 }
2153
op_tb0c(void)2154 static int op_tb0c(void) /* BIT 0,C */
2155 {
2156 F &= ~(N_FLAG | S_FLAG);
2157 F |= H_FLAG;
2158 (C & 1) ? (F &= ~(Z_FLAG | P_FLAG)) : (F |= (Z_FLAG | P_FLAG));
2159 return(8);
2160 }
2161
op_tb1c(void)2162 static int op_tb1c(void) /* BIT 1,C */
2163 {
2164 F &= ~(N_FLAG | S_FLAG);
2165 F |= H_FLAG;
2166 (C & 2) ? (F &= ~(Z_FLAG | P_FLAG)) : (F |= (Z_FLAG | P_FLAG));
2167 return(8);
2168 }
2169
op_tb2c(void)2170 static int op_tb2c(void) /* BIT 2,C */
2171 {
2172 F &= ~(N_FLAG | S_FLAG);
2173 F |= H_FLAG;
2174 (C & 4) ? (F &= ~(Z_FLAG | P_FLAG)) : (F |= (Z_FLAG | P_FLAG));
2175 return(8);
2176 }
2177
op_tb3c(void)2178 static int op_tb3c(void) /* BIT 3,C */
2179 {
2180 F &= ~(N_FLAG | S_FLAG);
2181 F |= H_FLAG;
2182 (C & 8) ? (F &= ~(Z_FLAG | P_FLAG)) : (F |= (Z_FLAG | P_FLAG));
2183 return(8);
2184 }
2185
op_tb4c(void)2186 static int op_tb4c(void) /* BIT 4,C */
2187 {
2188 F &= ~(N_FLAG | S_FLAG);
2189 F |= H_FLAG;
2190 (C & 16) ? (F &= ~(Z_FLAG | P_FLAG)) : (F |= (Z_FLAG | P_FLAG));
2191 return(8);
2192 }
2193
op_tb5c(void)2194 static int op_tb5c(void) /* BIT 5,C */
2195 {
2196 F &= ~(N_FLAG | S_FLAG);
2197 F |= H_FLAG;
2198 (C & 32) ? (F &= ~(Z_FLAG | P_FLAG)) : (F |= (Z_FLAG | P_FLAG));
2199 return(8);
2200 }
2201
op_tb6c(void)2202 static int op_tb6c(void) /* BIT 6,C */
2203 {
2204 F &= ~(N_FLAG | S_FLAG);
2205 F |= H_FLAG;
2206 (C & 64) ? (F &= ~(Z_FLAG | P_FLAG)) : (F |= (Z_FLAG | P_FLAG));
2207 return(8);
2208 }
2209
op_tb7c(void)2210 static int op_tb7c(void) /* BIT 7,C */
2211 {
2212 F &= ~N_FLAG;
2213 F |= H_FLAG;
2214 if (C & 128) {
2215 F &= ~(Z_FLAG | P_FLAG);
2216 F |= S_FLAG;
2217 } else {
2218 F |= (Z_FLAG | P_FLAG);
2219 F &= ~S_FLAG;
2220 }
2221 return(8);
2222 }
2223
op_tb0d(void)2224 static int op_tb0d(void) /* BIT 0,D */
2225 {
2226 F &= ~(N_FLAG | S_FLAG);
2227 F |= H_FLAG;
2228 (D & 1) ? (F &= ~(Z_FLAG | P_FLAG)) : (F |= (Z_FLAG | P_FLAG));
2229 return(8);
2230 }
2231
op_tb1d(void)2232 static int op_tb1d(void) /* BIT 1,D */
2233 {
2234 F &= ~(N_FLAG | S_FLAG);
2235 F |= H_FLAG;
2236 (D & 2) ? (F &= ~(Z_FLAG | P_FLAG)) : (F |= (Z_FLAG | P_FLAG));
2237 return(8);
2238 }
2239
op_tb2d(void)2240 static int op_tb2d(void) /* BIT 2,D */
2241 {
2242 F &= ~(N_FLAG | S_FLAG);
2243 F |= H_FLAG;
2244 (D & 4) ? (F &= ~(Z_FLAG | P_FLAG)) : (F |= (Z_FLAG | P_FLAG));
2245 return(8);
2246 }
2247
op_tb3d(void)2248 static int op_tb3d(void) /* BIT 3,D */
2249 {
2250 F &= ~(N_FLAG | S_FLAG);
2251 F |= H_FLAG;
2252 (D & 8) ? (F &= ~(Z_FLAG | P_FLAG)) : (F |= (Z_FLAG | P_FLAG));
2253 return(8);
2254 }
2255
op_tb4d(void)2256 static int op_tb4d(void) /* BIT 4,D */
2257 {
2258 F &= ~(N_FLAG | S_FLAG);
2259 F |= H_FLAG;
2260 (D & 16) ? (F &= ~(Z_FLAG | P_FLAG)) : (F |= (Z_FLAG | P_FLAG));
2261 return(8);
2262 }
2263
op_tb5d(void)2264 static int op_tb5d(void) /* BIT 5,D */
2265 {
2266 F &= ~(N_FLAG | S_FLAG);
2267 F |= H_FLAG;
2268 (D & 32) ? (F &= ~(Z_FLAG | P_FLAG)) : (F |= (Z_FLAG | P_FLAG));
2269 return(8);
2270 }
2271
op_tb6d(void)2272 static int op_tb6d(void) /* BIT 6,D */
2273 {
2274 F &= ~(N_FLAG | S_FLAG);
2275 F |= H_FLAG;
2276 (D & 64) ? (F &= ~(Z_FLAG | P_FLAG)) : (F |= (Z_FLAG | P_FLAG));
2277 return(8);
2278 }
2279
op_tb7d(void)2280 static int op_tb7d(void) /* BIT 7,D */
2281 {
2282 F &= ~N_FLAG;
2283 F |= H_FLAG;
2284 if (D & 128) {
2285 F &= ~(Z_FLAG | P_FLAG);
2286 F |= S_FLAG;
2287 } else {
2288 F |= (Z_FLAG | P_FLAG);
2289 F &= ~S_FLAG;
2290 }
2291 return(8);
2292 }
2293
op_tb0e(void)2294 static int op_tb0e(void) /* BIT 0,E */
2295 {
2296 F &= ~(N_FLAG | S_FLAG);
2297 F |= H_FLAG;
2298 (E & 1) ? (F &= ~(Z_FLAG | P_FLAG)) : (F |= (Z_FLAG | P_FLAG));
2299 return(8);
2300 }
2301
op_tb1e(void)2302 static int op_tb1e(void) /* BIT 1,E */
2303 {
2304 F &= ~(N_FLAG | S_FLAG);
2305 F |= H_FLAG;
2306 (E & 2) ? (F &= ~(Z_FLAG | P_FLAG)) : (F |= (Z_FLAG | P_FLAG));
2307 return(8);
2308 }
2309
op_tb2e(void)2310 static int op_tb2e(void) /* BIT 2,E */
2311 {
2312 F &= ~(N_FLAG | S_FLAG);
2313 F |= H_FLAG;
2314 (E & 4) ? (F &= ~(Z_FLAG | P_FLAG)) : (F |= (Z_FLAG | P_FLAG));
2315 return(8);
2316 }
2317
op_tb3e(void)2318 static int op_tb3e(void) /* BIT 3,E */
2319 {
2320 F &= ~(N_FLAG | S_FLAG);
2321 F |= H_FLAG;
2322 (E & 8) ? (F &= ~(Z_FLAG | P_FLAG)) : (F |= (Z_FLAG | P_FLAG));
2323 return(8);
2324 }
2325
op_tb4e(void)2326 static int op_tb4e(void) /* BIT 4,E */
2327 {
2328 F &= ~(N_FLAG | S_FLAG);
2329 F |= H_FLAG;
2330 (E & 16) ? (F &= ~(Z_FLAG | P_FLAG)) : (F |= (Z_FLAG | P_FLAG));
2331 return(8);
2332 }
2333
op_tb5e(void)2334 static int op_tb5e(void) /* BIT 5,E */
2335 {
2336 F &= ~(N_FLAG | S_FLAG);
2337 F |= H_FLAG;
2338 (E & 32) ? (F &= ~(Z_FLAG | P_FLAG)) : (F |= (Z_FLAG | P_FLAG));
2339 return(8);
2340 }
2341
op_tb6e(void)2342 static int op_tb6e(void) /* BIT 6,E */
2343 {
2344 F &= ~(N_FLAG | S_FLAG);
2345 F |= H_FLAG;
2346 (E & 64) ? (F &= ~(Z_FLAG | P_FLAG)) : (F |= (Z_FLAG | P_FLAG));
2347 return(8);
2348 }
2349
op_tb7e(void)2350 static int op_tb7e(void) /* BIT 7,E */
2351 {
2352 F &= ~N_FLAG;
2353 F |= H_FLAG;
2354 if (E & 128) {
2355 F &= ~(Z_FLAG | P_FLAG);
2356 F |= S_FLAG;
2357 } else {
2358 F |= (Z_FLAG | P_FLAG);
2359 F &= ~S_FLAG;
2360 }
2361 return(8);
2362 }
2363
op_tb0h(void)2364 static int op_tb0h(void) /* BIT 0,H */
2365 {
2366 F &= ~(N_FLAG | S_FLAG);
2367 F |= H_FLAG;
2368 (H & 1) ? (F &= ~(Z_FLAG | P_FLAG)) : (F |= (Z_FLAG | P_FLAG));
2369 return(8);
2370 }
2371
op_tb1h(void)2372 static int op_tb1h(void) /* BIT 1,H */
2373 {
2374 F &= ~(N_FLAG | S_FLAG);
2375 F |= H_FLAG;
2376 (H & 2) ? (F &= ~(Z_FLAG | P_FLAG)) : (F |= (Z_FLAG | P_FLAG));
2377 return(8);
2378 }
2379
op_tb2h(void)2380 static int op_tb2h(void) /* BIT 2,H */
2381 {
2382 F &= ~(N_FLAG | S_FLAG);
2383 F |= H_FLAG;
2384 (H & 4) ? (F &= ~(Z_FLAG | P_FLAG)) : (F |= (Z_FLAG | P_FLAG));
2385 return(8);
2386 }
2387
op_tb3h(void)2388 static int op_tb3h(void) /* BIT 3,H */
2389 {
2390 F &= ~(N_FLAG | S_FLAG);
2391 F |= H_FLAG;
2392 (H & 8) ? (F &= ~(Z_FLAG | P_FLAG)) : (F |= (Z_FLAG | P_FLAG));
2393 return(8);
2394 }
2395
op_tb4h(void)2396 static int op_tb4h(void) /* BIT 4,H */
2397 {
2398 F &= ~(N_FLAG | S_FLAG);
2399 F |= H_FLAG;
2400 (H & 16) ? (F &= ~(Z_FLAG | P_FLAG)) : (F |= (Z_FLAG | P_FLAG));
2401 return(8);
2402 }
2403
op_tb5h(void)2404 static int op_tb5h(void) /* BIT 5,H */
2405 {
2406 F &= ~(N_FLAG | S_FLAG);
2407 F |= H_FLAG;
2408 (H & 32) ? (F &= ~(Z_FLAG | P_FLAG)) : (F |= (Z_FLAG | P_FLAG));
2409 return(8);
2410 }
2411
op_tb6h(void)2412 static int op_tb6h(void) /* BIT 6,H */
2413 {
2414 F &= ~(N_FLAG | S_FLAG);
2415 F |= H_FLAG;
2416 (H & 64) ? (F &= ~(Z_FLAG | P_FLAG)) : (F |= (Z_FLAG | P_FLAG));
2417 return(8);
2418 }
2419
op_tb7h(void)2420 static int op_tb7h(void) /* BIT 7,H */
2421 {
2422 F &= ~N_FLAG;
2423 F |= H_FLAG;
2424 if (H & 128) {
2425 F &= ~(Z_FLAG | P_FLAG);
2426 F |= S_FLAG;
2427 } else {
2428 F |= (Z_FLAG | P_FLAG);
2429 F &= ~S_FLAG;
2430 }
2431 return(8);
2432 }
2433
op_tb0l(void)2434 static int op_tb0l(void) /* BIT 0,L */
2435 {
2436 F &= ~(N_FLAG | S_FLAG);
2437 F |= H_FLAG;
2438 (L & 1) ? (F &= ~(Z_FLAG | P_FLAG)) : (F |= (Z_FLAG | P_FLAG));
2439 return(8);
2440 }
2441
op_tb1l(void)2442 static int op_tb1l(void) /* BIT 1,L */
2443 {
2444 F &= ~(N_FLAG | S_FLAG);
2445 F |= H_FLAG;
2446 (L & 2) ? (F &= ~(Z_FLAG | P_FLAG)) : (F |= (Z_FLAG | P_FLAG));
2447 return(8);
2448 }
2449
op_tb2l(void)2450 static int op_tb2l(void) /* BIT 2,L */
2451 {
2452 F &= ~(N_FLAG | S_FLAG);
2453 F |= H_FLAG;
2454 (L & 4) ? (F &= ~(Z_FLAG | P_FLAG)) : (F |= (Z_FLAG | P_FLAG));
2455 return(8);
2456 }
2457
op_tb3l(void)2458 static int op_tb3l(void) /* BIT 3,L */
2459 {
2460 F &= ~(N_FLAG | S_FLAG);
2461 F |= H_FLAG;
2462 (L & 8) ? (F &= ~(Z_FLAG | P_FLAG)) : (F |= (Z_FLAG | P_FLAG));
2463 return(8);
2464 }
2465
op_tb4l(void)2466 static int op_tb4l(void) /* BIT 4,L */
2467 {
2468 F &= ~(N_FLAG | S_FLAG);
2469 F |= H_FLAG;
2470 (L & 16) ? (F &= ~(Z_FLAG | P_FLAG)) : (F |= (Z_FLAG | P_FLAG));
2471 return(8);
2472 }
2473
op_tb5l(void)2474 static int op_tb5l(void) /* BIT 5,L */
2475 {
2476 F &= ~(N_FLAG | S_FLAG);
2477 F |= H_FLAG;
2478 (L & 32) ? (F &= ~(Z_FLAG | P_FLAG)) : (F |= (Z_FLAG | P_FLAG));
2479 return(8);
2480 }
2481
op_tb6l(void)2482 static int op_tb6l(void) /* BIT 6,L */
2483 {
2484 F &= ~(N_FLAG | S_FLAG);
2485 F |= H_FLAG;
2486 (L & 64) ? (F &= ~(Z_FLAG | P_FLAG)) : (F |= (Z_FLAG | P_FLAG));
2487 return(8);
2488 }
2489
op_tb7l(void)2490 static int op_tb7l(void) /* BIT 7,L */
2491 {
2492 F &= ~N_FLAG;
2493 F |= H_FLAG;
2494 if (L & 128) {
2495 F &= ~(Z_FLAG | P_FLAG);
2496 F |= S_FLAG;
2497 } else {
2498 F |= (Z_FLAG | P_FLAG);
2499 F &= ~S_FLAG;
2500 }
2501 return(8);
2502 }
2503
op_tb0hl(void)2504 static int op_tb0hl(void) /* BIT 0,(HL) */
2505 {
2506 F &= ~(N_FLAG | S_FLAG);
2507 F |= H_FLAG;
2508 (memrdr((H << 8) + L) & 1) ? (F &= ~(Z_FLAG | P_FLAG))
2509 : (F |= (Z_FLAG | P_FLAG));
2510 return(12);
2511 }
2512
op_tb1hl(void)2513 static int op_tb1hl(void) /* BIT 1,(HL) */
2514 {
2515 F &= ~(N_FLAG | S_FLAG);
2516 F |= H_FLAG;
2517 (memrdr((H << 8) + L) & 2) ? (F &= ~(Z_FLAG | P_FLAG))
2518 : (F |= (Z_FLAG | P_FLAG));
2519 return(12);
2520 }
2521
op_tb2hl(void)2522 static int op_tb2hl(void) /* BIT 2,(HL) */
2523 {
2524 F &= ~(N_FLAG | S_FLAG);
2525 F |= H_FLAG;
2526 (memrdr((H << 8) + L) & 4) ? (F &= ~(Z_FLAG | P_FLAG))
2527 : (F |= (Z_FLAG | P_FLAG));
2528 return(12);
2529 }
2530
op_tb3hl(void)2531 static int op_tb3hl(void) /* BIT 3,(HL) */
2532 {
2533 F &= ~(N_FLAG | S_FLAG);
2534 F |= H_FLAG;
2535 (memrdr((H << 8) + L) & 8) ? (F &= ~(Z_FLAG | P_FLAG))
2536 : (F |= (Z_FLAG | P_FLAG));
2537 return(12);
2538 }
2539
op_tb4hl(void)2540 static int op_tb4hl(void) /* BIT 4,(HL) */
2541 {
2542 F &= ~(N_FLAG | S_FLAG);
2543 F |= H_FLAG;
2544 (memrdr((H << 8) + L) & 16) ? (F &= ~(Z_FLAG | P_FLAG))
2545 : (F |= (Z_FLAG | P_FLAG));
2546 return(12);
2547 }
2548
op_tb5hl(void)2549 static int op_tb5hl(void) /* BIT 5,(HL) */
2550 {
2551 F &= ~(N_FLAG | S_FLAG);
2552 F |= H_FLAG;
2553 (memrdr((H << 8) + L) & 32) ? (F &= ~(Z_FLAG | P_FLAG))
2554 : (F |= (Z_FLAG | P_FLAG));
2555 return(12);
2556 }
2557
op_tb6hl(void)2558 static int op_tb6hl(void) /* BIT 6,(HL) */
2559 {
2560 F &= ~(N_FLAG | S_FLAG);
2561 F |= H_FLAG;
2562 (memrdr((H << 8) + L) & 64) ? (F &= ~(Z_FLAG | P_FLAG))
2563 : (F |= (Z_FLAG | P_FLAG));
2564 return(12);
2565 }
2566
op_tb7hl(void)2567 static int op_tb7hl(void) /* BIT 7,(HL) */
2568 {
2569 F &= ~N_FLAG;
2570 F |= H_FLAG;
2571 if (memrdr((H << 8) + L) & 128) {
2572 F &= ~(Z_FLAG | P_FLAG);
2573 F |= S_FLAG;
2574 } else {
2575 F |= (Z_FLAG | P_FLAG);
2576 F &= ~S_FLAG;
2577 }
2578 return(12);
2579 }
2580
2581 /**********************************************************************/
2582 /**********************************************************************/
2583 /********* UNDOCUMENTED Z80 INSTRUCTIONS, BEWARE! **********/
2584 /**********************************************************************/
2585 /**********************************************************************/
2586
2587 /*
2588 * While the instructions is not documented in the Z80
2589 * documentation, it is in the Z280 one, including an
2590 * example to tell Z80 and Z280 apart.
2591 */
op_undoc_slla(void)2592 static int op_undoc_slla(void) /* SLL A */
2593 {
2594 (A & 128) ? (F |= C_FLAG) : (F &= ~C_FLAG);
2595 A = A << 1 | 1;
2596 F &= ~(H_FLAG | N_FLAG);
2597 (A) ? (F &= ~Z_FLAG) : (F |= Z_FLAG);
2598 (A & 128) ? (F |= S_FLAG) : (F &= ~S_FLAG);
2599 (parity[A]) ? (F &= ~P_FLAG) : (F |= P_FLAG);
2600 return(8);
2601 }
2602
2603 #ifdef Z80_UNDOC
2604
op_undoc_sllb(void)2605 static int op_undoc_sllb(void) /* SLL B */
2606 {
2607 if (u_flag) {
2608 trap_cb();
2609 return(0);
2610 }
2611
2612 (B & 128) ? (F |= C_FLAG) : (F &= ~C_FLAG);
2613 B = B << 1 | 1;
2614 F &= ~(H_FLAG | N_FLAG);
2615 (B) ? (F &= ~Z_FLAG) : (F |= Z_FLAG);
2616 (B & 128) ? (F |= S_FLAG) : (F &= ~S_FLAG);
2617 (parity[B]) ? (F &= ~P_FLAG) : (F |= P_FLAG);
2618 return(8);
2619 }
2620
op_undoc_sllc(void)2621 static int op_undoc_sllc(void) /* SLL C */
2622 {
2623 if (u_flag) {
2624 trap_cb();
2625 return(0);
2626 }
2627
2628 (C & 128) ? (F |= C_FLAG) : (F &= ~C_FLAG);
2629 C = C << 1 | 1;
2630 F &= ~(H_FLAG | N_FLAG);
2631 (C) ? (F &= ~Z_FLAG) : (F |= Z_FLAG);
2632 (C & 128) ? (F |= S_FLAG) : (F &= ~S_FLAG);
2633 (parity[C]) ? (F &= ~P_FLAG) : (F |= P_FLAG);
2634 return(8);
2635 }
2636
op_undoc_slld(void)2637 static int op_undoc_slld(void) /* SLL D */
2638 {
2639 if (u_flag) {
2640 trap_cb();
2641 return(0);
2642 }
2643
2644 (D & 128) ? (F |= C_FLAG) : (F &= ~C_FLAG);
2645 D = D << 1 | 1;
2646 F &= ~(H_FLAG | N_FLAG);
2647 (D) ? (F &= ~Z_FLAG) : (F |= Z_FLAG);
2648 (D & 128) ? (F |= S_FLAG) : (F &= ~S_FLAG);
2649 (parity[D]) ? (F &= ~P_FLAG) : (F |= P_FLAG);
2650 return(8);
2651 }
2652
op_undoc_slle(void)2653 static int op_undoc_slle(void) /* SLL E */
2654 {
2655 if (u_flag) {
2656 trap_cb();
2657 return(0);
2658 }
2659
2660 (E & 128) ? (F |= C_FLAG) : (F &= ~C_FLAG);
2661 E = E << 1 | 1;
2662 F &= ~(H_FLAG | N_FLAG);
2663 (E) ? (F &= ~Z_FLAG) : (F |= Z_FLAG);
2664 (E & 128) ? (F |= S_FLAG) : (F &= ~S_FLAG);
2665 (parity[E]) ? (F &= ~P_FLAG) : (F |= P_FLAG);
2666 return(8);
2667 }
2668
op_undoc_sllh(void)2669 static int op_undoc_sllh(void) /* SLL H */
2670 {
2671 if (u_flag) {
2672 trap_cb();
2673 return(0);
2674 }
2675
2676 (H & 128) ? (F |= C_FLAG) : (F &= ~C_FLAG);
2677 H = H << 1 | 1;
2678 F &= ~(H_FLAG | N_FLAG);
2679 (H) ? (F &= ~Z_FLAG) : (F |= Z_FLAG);
2680 (H & 128) ? (F |= S_FLAG) : (F &= ~S_FLAG);
2681 (parity[H]) ? (F &= ~P_FLAG) : (F |= P_FLAG);
2682 return(8);
2683 }
2684
op_undoc_slll(void)2685 static int op_undoc_slll(void) /* SLL L */
2686 {
2687 if (u_flag) {
2688 trap_cb();
2689 return(0);
2690 }
2691
2692 (L & 128) ? (F |= C_FLAG) : (F &= ~C_FLAG);
2693 L = L << 1 | 1;
2694 F &= ~(H_FLAG | N_FLAG);
2695 (L) ? (F &= ~Z_FLAG) : (F |= Z_FLAG);
2696 (L & 128) ? (F |= S_FLAG) : (F &= ~S_FLAG);
2697 (parity[L]) ? (F &= ~P_FLAG) : (F |= P_FLAG);
2698 return(8);
2699 }
2700
op_undoc_sllhl(void)2701 static int op_undoc_sllhl(void) /* SLL (HL) */
2702 {
2703 register BYTE P;
2704 WORD addr;
2705
2706 if (u_flag) {
2707 trap_cb();
2708 return(0);
2709 }
2710
2711 addr = (H << 8) + L;
2712 P = memrdr(addr);
2713 (P & 128) ? (F |= C_FLAG) : (F &= ~C_FLAG);
2714 P = (P << 1) | 1;
2715 memwrt(addr, P);
2716 F &= ~(H_FLAG | N_FLAG);
2717 (P) ? (F &= ~Z_FLAG) : (F |= Z_FLAG);
2718 (P & 128) ? (F |= S_FLAG) : (F &= ~S_FLAG);
2719 (parity[P]) ? (F &= ~P_FLAG) : (F |= P_FLAG);
2720 return(15);
2721 }
2722
2723 #endif
2724