1 /* altairz80_cpu_opt.c: MITS Altair CPU (8080 and Z80)
3 Copyright (c) 2002-2008, Peter Schorn
5 Permission is hereby granted, free of charge, to any person obtaining a
6 copy of this software and associated documentation files (the "Software"),
7 to deal in the Software without restriction, including without limitation
8 the rights to use, copy, modify, merge, publish, distribute, sublicense,
9 and/or sell copies of the Software, and to permit persons to whom the
10 Software is furnished to do so, subject to the following conditions:
12 The above copyright notice and this permission notice shall be included in
13 all copies or substantial portions of the Software.
15 THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
16 IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
17 FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
18 PETER SCHORN BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
19 IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
20 CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
22 Except as contained in this notice, the name of Peter Schorn shall not
23 be used in advertising or otherwise to promote the sale, use or other dealings
24 in this Software without prior written authorization from Peter Schorn.
26 Based on work by Charles E Owen (c) 1997
27 Code for Z80 CPU from Frank D. Cringle ((c) 1995 under GNU license)
30 #include "altairz80_defs.h"
39 #define SETFLAG(f,c) AF = (c) ? AF | FLAG_ ## f : AF & ~FLAG_ ## f
40 #define TSTFLAG(f) ((AF & FLAG_ ## f) != 0)
42 #define LOW_DIGIT(x) ((x) & 0xf)
43 #define HIGH_DIGIT(x) (((x) >> 4) & 0xf)
44 #define LOW_REGISTER(x) ((x) & 0xff)
45 #define HIGH_REGISTER(x) (((x) >> 8) & 0xff)
47 #define SET_LOW_REGISTER(x, v) x = (((x) & 0xff00) | ((v) & 0xff))
48 #define SET_HIGH_REGISTER(x, v) x = (((x) & 0xff) | (((v) & 0xff) << 8))
50 #define PARITY(x) parityTable[(x) & 0xff]
51 /* SET_PV and SET_PV2 are used to provide correct PARITY flag semantics for the 8080 in cases
52 where the Z80 uses the overflow flag
54 #define SET_PVS(s) ((chiptype == CHIP_TYPE_Z80) ? (((cbits >> 6) ^ (cbits >> 5)) & 4) : (PARITY(s)))
55 #define SET_PV (SET_PVS(sum))
56 #define SET_PV2(x) ((chiptype == CHIP_TYPE_Z80) ? (((temp == (x)) << 2)) : (PARITY(temp)))
58 /* CHECK_CPU_8080 must be invoked whenever a Z80 only instruction is executed
59 In case a Z80 instruction is executed on an 8080 the following two cases exist:
60 1) Trapping is enabled: execution stops
61 2) Trapping is not enabled: decoding continues with the next byte
63 #define CHECK_CPU_8080 \
64 if (chiptype == CHIP_TYPE_8080) { \
65 if (cpu_unit.flags & UNIT_CPU_OPSTOP) { \
66 reason = STOP_OPCODE; \
72 /* CHECK_CPU_Z80 must be invoked whenever a non Z80 instruction is executed */
73 #define CHECK_CPU_Z80 \
74 if (cpu_unit.flags & UNIT_CPU_OPSTOP) { \
75 reason = STOP_OPCODE; \
80 register uint32 y = RAM_PP(SP); \
81 x = y + (RAM_PP(SP) << 8); \
93 #define CALLC(cond) { \
95 register uint32 adrr = GET_WORD(PC); \
104 /* function prototypes */
105 t_stat
sim_instr_nommu(void);
107 extern void out(const uint32 Port
, const uint32 Value
);
108 extern uint32
in(const uint32 Port
);
109 extern UNIT cpu_unit
;
110 extern uint32 PCX
; /* external view of PC */
111 extern int32 AF_S
; /* AF register */
112 extern int32 BC_S
; /* BC register */
113 extern int32 DE_S
; /* DE register */
114 extern int32 HL_S
; /* HL register */
115 extern int32 IX_S
; /* IX register */
116 extern int32 IY_S
; /* IY register */
117 extern int32 PC_S
; /* program counter */
118 extern int32 SP_S
; /* SP register */
119 extern int32 AF1_S
; /* alternate AF register */
120 extern int32 BC1_S
; /* alternate BC register */
121 extern int32 DE1_S
; /* alternate DE register */
122 extern int32 HL1_S
; /* alternate HL register */
123 extern int32 IFF_S
; /* Interrupt Flip Flop */
124 extern int32 IR_S
; /* Interrupt (upper) / Refresh (lower) register */
125 extern int32 chiptype
;
127 /* the following tables precompute some common subexpressions
128 parityTable[i] 0..255 (number of 1's in i is odd) ? 0 : 4
129 incTable[i] 0..256! (i & 0xa8) | (((i & 0xff) == 0) << 6) | (((i & 0xf) == 0) << 4)
130 decTable[i] 0..255 (i & 0xa8) | (((i & 0xff) == 0) << 6) | (((i & 0xf) == 0xf) << 4) | 2
131 cbitsTable[i] 0..511 (i & 0x10) | ((i >> 8) & 1)
132 cbitsDup8Table[i] 0..511 (i & 0x10) | ((i >> 8) & 1) | ((i & 0xff) << 8) | (i & 0xa8) |
133 (((i & 0xff) == 0) << 6)
134 cbitsDup16Table[i] 0..511 (i & 0x10) | ((i >> 8) & 1) | (i & 0x28)
135 cbits2Table[i] 0..511 (i & 0x10) | ((i >> 8) & 1) | 2
136 rrcaTable[i] 0..255 ((i & 1) << 15) | ((i >> 1) << 8) | ((i >> 1) & 0x28) | (i & 1)
137 rraTable[i] 0..255 ((i >> 1) << 8) | ((i >> 1) & 0x28) | (i & 1)
138 addTable[i] 0..511 ((i & 0xff) << 8) | (i & 0xa8) | (((i & 0xff) == 0) << 6)
139 subTable[i] 0..255 ((i & 0xff) << 8) | (i & 0xa8) | (((i & 0xff) == 0) << 6) | 2
140 andTable[i] 0..255 (i << 8) | (i & 0xa8) | ((i == 0) << 6) | 0x10 | parityTable[i]
141 xororTable[i] 0..255 (i << 8) | (i & 0xa8) | ((i == 0) << 6) | parityTable[i]
142 rotateShiftTable[i] 0..255 (i & 0xa8) | (((i & 0xff) == 0) << 6) | parityTable[i & 0xff]
143 incZ80Table[i] 0..256! (i & 0xa8) | (((i & 0xff) == 0) << 6) |
144 (((i & 0xf) == 0) << 4) | ((i == 0x80) << 2)
145 decZ80Table[i] 0..255 (i & 0xa8) | (((i & 0xff) == 0) << 6) |
146 (((i & 0xf) == 0xf) << 4) | ((i == 0x7f) << 2) | 2
147 cbitsZ80Table[i] 0..511 (i & 0x10) | (((i >> 6) ^ (i >> 5)) & 4) | ((i >> 8) & 1)
148 cbitsZ80DupTable[i] 0..511 (i & 0x10) | (((i >> 6) ^ (i >> 5)) & 4) |
149 ((i >> 8) & 1) | (i & 0xa8)
150 cbits2Z80Table[i] 0..511 (i & 0x10) | (((i >> 6) ^ (i >> 5)) & 4) | ((i >> 8) & 1) | 2
151 cbits2Z80DupTable[i] 0..511 (i & 0x10) | (((i >> 6) ^ (i >> 5)) & 4) | ((i >> 8) & 1) | 2 |
153 negTable[i] 0..255 (((i & 0x0f) != 0) << 4) | ((i == 0x80) << 2) | 2 | (i != 0)
154 rrdrldTable[i] 0..255 (i << 8) | (i & 0xa8) | (((i & 0xff) == 0) << 6) | parityTable[i]
155 cpTable[i] 0..255 (i & 0x80) | (((i & 0xff) == 0) << 6)
158 /* parityTable[i] = (number of 1's in i is odd) ? 0 : 4, i = 0..255 */
159 static const uint8 parityTable
[256] = {
160 4,0,0,4,0,4,4,0,0,4,4,0,4,0,0,4,
161 0,4,4,0,4,0,0,4,4,0,0,4,0,4,4,0,
162 0,4,4,0,4,0,0,4,4,0,0,4,0,4,4,0,
163 4,0,0,4,0,4,4,0,0,4,4,0,4,0,0,4,
164 0,4,4,0,4,0,0,4,4,0,0,4,0,4,4,0,
165 4,0,0,4,0,4,4,0,0,4,4,0,4,0,0,4,
166 4,0,0,4,0,4,4,0,0,4,4,0,4,0,0,4,
167 0,4,4,0,4,0,0,4,4,0,0,4,0,4,4,0,
168 0,4,4,0,4,0,0,4,4,0,0,4,0,4,4,0,
169 4,0,0,4,0,4,4,0,0,4,4,0,4,0,0,4,
170 4,0,0,4,0,4,4,0,0,4,4,0,4,0,0,4,
171 0,4,4,0,4,0,0,4,4,0,0,4,0,4,4,0,
172 4,0,0,4,0,4,4,0,0,4,4,0,4,0,0,4,
173 0,4,4,0,4,0,0,4,4,0,0,4,0,4,4,0,
174 0,4,4,0,4,0,0,4,4,0,0,4,0,4,4,0,
175 4,0,0,4,0,4,4,0,0,4,4,0,4,0,0,4,
178 /* incTable[i] = (i & 0xa8) | (((i & 0xff) == 0) << 6) | (((i & 0xf) == 0) << 4), i = 0..256 */
179 static const uint8 incTable
[257] = {
180 80, 0, 0, 0, 0, 0, 0, 0, 8, 8, 8, 8, 8, 8, 8, 8,
181 16, 0, 0, 0, 0, 0, 0, 0, 8, 8, 8, 8, 8, 8, 8, 8,
182 48, 32, 32, 32, 32, 32, 32, 32, 40, 40, 40, 40, 40, 40, 40, 40,
183 48, 32, 32, 32, 32, 32, 32, 32, 40, 40, 40, 40, 40, 40, 40, 40,
184 16, 0, 0, 0, 0, 0, 0, 0, 8, 8, 8, 8, 8, 8, 8, 8,
185 16, 0, 0, 0, 0, 0, 0, 0, 8, 8, 8, 8, 8, 8, 8, 8,
186 48, 32, 32, 32, 32, 32, 32, 32, 40, 40, 40, 40, 40, 40, 40, 40,
187 48, 32, 32, 32, 32, 32, 32, 32, 40, 40, 40, 40, 40, 40, 40, 40,
188 144,128,128,128,128,128,128,128,136,136,136,136,136,136,136,136,
189 144,128,128,128,128,128,128,128,136,136,136,136,136,136,136,136,
190 176,160,160,160,160,160,160,160,168,168,168,168,168,168,168,168,
191 176,160,160,160,160,160,160,160,168,168,168,168,168,168,168,168,
192 144,128,128,128,128,128,128,128,136,136,136,136,136,136,136,136,
193 144,128,128,128,128,128,128,128,136,136,136,136,136,136,136,136,
194 176,160,160,160,160,160,160,160,168,168,168,168,168,168,168,168,
195 176,160,160,160,160,160,160,160,168,168,168,168,168,168,168,168, 80
198 /* decTable[i] = (i & 0xa8) | (((i & 0xff) == 0) << 6) | (((i & 0xf) == 0xf) << 4) | 2, i = 0..255 */
199 static const uint8 decTable
[256] = {
200 66, 2, 2, 2, 2, 2, 2, 2, 10, 10, 10, 10, 10, 10, 10, 26,
201 2, 2, 2, 2, 2, 2, 2, 2, 10, 10, 10, 10, 10, 10, 10, 26,
202 34, 34, 34, 34, 34, 34, 34, 34, 42, 42, 42, 42, 42, 42, 42, 58,
203 34, 34, 34, 34, 34, 34, 34, 34, 42, 42, 42, 42, 42, 42, 42, 58,
204 2, 2, 2, 2, 2, 2, 2, 2, 10, 10, 10, 10, 10, 10, 10, 26,
205 2, 2, 2, 2, 2, 2, 2, 2, 10, 10, 10, 10, 10, 10, 10, 26,
206 34, 34, 34, 34, 34, 34, 34, 34, 42, 42, 42, 42, 42, 42, 42, 58,
207 34, 34, 34, 34, 34, 34, 34, 34, 42, 42, 42, 42, 42, 42, 42, 58,
208 130,130,130,130,130,130,130,130,138,138,138,138,138,138,138,154,
209 130,130,130,130,130,130,130,130,138,138,138,138,138,138,138,154,
210 162,162,162,162,162,162,162,162,170,170,170,170,170,170,170,186,
211 162,162,162,162,162,162,162,162,170,170,170,170,170,170,170,186,
212 130,130,130,130,130,130,130,130,138,138,138,138,138,138,138,154,
213 130,130,130,130,130,130,130,130,138,138,138,138,138,138,138,154,
214 162,162,162,162,162,162,162,162,170,170,170,170,170,170,170,186,
215 162,162,162,162,162,162,162,162,170,170,170,170,170,170,170,186,
218 /* cbitsTable[i] = (i & 0x10) | ((i >> 8) & 1), i = 0..511 */
219 static const uint8 cbitsTable
[512] = {
220 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
221 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,
222 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
223 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,
224 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
225 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,
226 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
227 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,
228 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
229 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,
230 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
231 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,
232 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
233 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,
234 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
235 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,
236 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
237 17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,
238 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
239 17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,
240 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
241 17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,
242 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
243 17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,
244 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
245 17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,
246 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
247 17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,
248 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
249 17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,
250 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
251 17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,
254 /* cbitsDup8Table[i] = (i & 0x10) | ((i >> 8) & 1) | ((i & 0xff) << 8) | (i & 0xa8) |
255 (((i & 0xff) == 0) << 6), i = 0..511 */
256 static const uint16 cbitsDup8Table
[512] = {
257 0x0040,0x0100,0x0200,0x0300,0x0400,0x0500,0x0600,0x0700,
258 0x0808,0x0908,0x0a08,0x0b08,0x0c08,0x0d08,0x0e08,0x0f08,
259 0x1010,0x1110,0x1210,0x1310,0x1410,0x1510,0x1610,0x1710,
260 0x1818,0x1918,0x1a18,0x1b18,0x1c18,0x1d18,0x1e18,0x1f18,
261 0x2020,0x2120,0x2220,0x2320,0x2420,0x2520,0x2620,0x2720,
262 0x2828,0x2928,0x2a28,0x2b28,0x2c28,0x2d28,0x2e28,0x2f28,
263 0x3030,0x3130,0x3230,0x3330,0x3430,0x3530,0x3630,0x3730,
264 0x3838,0x3938,0x3a38,0x3b38,0x3c38,0x3d38,0x3e38,0x3f38,
265 0x4000,0x4100,0x4200,0x4300,0x4400,0x4500,0x4600,0x4700,
266 0x4808,0x4908,0x4a08,0x4b08,0x4c08,0x4d08,0x4e08,0x4f08,
267 0x5010,0x5110,0x5210,0x5310,0x5410,0x5510,0x5610,0x5710,
268 0x5818,0x5918,0x5a18,0x5b18,0x5c18,0x5d18,0x5e18,0x5f18,
269 0x6020,0x6120,0x6220,0x6320,0x6420,0x6520,0x6620,0x6720,
270 0x6828,0x6928,0x6a28,0x6b28,0x6c28,0x6d28,0x6e28,0x6f28,
271 0x7030,0x7130,0x7230,0x7330,0x7430,0x7530,0x7630,0x7730,
272 0x7838,0x7938,0x7a38,0x7b38,0x7c38,0x7d38,0x7e38,0x7f38,
273 0x8080,0x8180,0x8280,0x8380,0x8480,0x8580,0x8680,0x8780,
274 0x8888,0x8988,0x8a88,0x8b88,0x8c88,0x8d88,0x8e88,0x8f88,
275 0x9090,0x9190,0x9290,0x9390,0x9490,0x9590,0x9690,0x9790,
276 0x9898,0x9998,0x9a98,0x9b98,0x9c98,0x9d98,0x9e98,0x9f98,
277 0xa0a0,0xa1a0,0xa2a0,0xa3a0,0xa4a0,0xa5a0,0xa6a0,0xa7a0,
278 0xa8a8,0xa9a8,0xaaa8,0xaba8,0xaca8,0xada8,0xaea8,0xafa8,
279 0xb0b0,0xb1b0,0xb2b0,0xb3b0,0xb4b0,0xb5b0,0xb6b0,0xb7b0,
280 0xb8b8,0xb9b8,0xbab8,0xbbb8,0xbcb8,0xbdb8,0xbeb8,0xbfb8,
281 0xc080,0xc180,0xc280,0xc380,0xc480,0xc580,0xc680,0xc780,
282 0xc888,0xc988,0xca88,0xcb88,0xcc88,0xcd88,0xce88,0xcf88,
283 0xd090,0xd190,0xd290,0xd390,0xd490,0xd590,0xd690,0xd790,
284 0xd898,0xd998,0xda98,0xdb98,0xdc98,0xdd98,0xde98,0xdf98,
285 0xe0a0,0xe1a0,0xe2a0,0xe3a0,0xe4a0,0xe5a0,0xe6a0,0xe7a0,
286 0xe8a8,0xe9a8,0xeaa8,0xeba8,0xeca8,0xeda8,0xeea8,0xefa8,
287 0xf0b0,0xf1b0,0xf2b0,0xf3b0,0xf4b0,0xf5b0,0xf6b0,0xf7b0,
288 0xf8b8,0xf9b8,0xfab8,0xfbb8,0xfcb8,0xfdb8,0xfeb8,0xffb8,
289 0x0041,0x0101,0x0201,0x0301,0x0401,0x0501,0x0601,0x0701,
290 0x0809,0x0909,0x0a09,0x0b09,0x0c09,0x0d09,0x0e09,0x0f09,
291 0x1011,0x1111,0x1211,0x1311,0x1411,0x1511,0x1611,0x1711,
292 0x1819,0x1919,0x1a19,0x1b19,0x1c19,0x1d19,0x1e19,0x1f19,
293 0x2021,0x2121,0x2221,0x2321,0x2421,0x2521,0x2621,0x2721,
294 0x2829,0x2929,0x2a29,0x2b29,0x2c29,0x2d29,0x2e29,0x2f29,
295 0x3031,0x3131,0x3231,0x3331,0x3431,0x3531,0x3631,0x3731,
296 0x3839,0x3939,0x3a39,0x3b39,0x3c39,0x3d39,0x3e39,0x3f39,
297 0x4001,0x4101,0x4201,0x4301,0x4401,0x4501,0x4601,0x4701,
298 0x4809,0x4909,0x4a09,0x4b09,0x4c09,0x4d09,0x4e09,0x4f09,
299 0x5011,0x5111,0x5211,0x5311,0x5411,0x5511,0x5611,0x5711,
300 0x5819,0x5919,0x5a19,0x5b19,0x5c19,0x5d19,0x5e19,0x5f19,
301 0x6021,0x6121,0x6221,0x6321,0x6421,0x6521,0x6621,0x6721,
302 0x6829,0x6929,0x6a29,0x6b29,0x6c29,0x6d29,0x6e29,0x6f29,
303 0x7031,0x7131,0x7231,0x7331,0x7431,0x7531,0x7631,0x7731,
304 0x7839,0x7939,0x7a39,0x7b39,0x7c39,0x7d39,0x7e39,0x7f39,
305 0x8081,0x8181,0x8281,0x8381,0x8481,0x8581,0x8681,0x8781,
306 0x8889,0x8989,0x8a89,0x8b89,0x8c89,0x8d89,0x8e89,0x8f89,
307 0x9091,0x9191,0x9291,0x9391,0x9491,0x9591,0x9691,0x9791,
308 0x9899,0x9999,0x9a99,0x9b99,0x9c99,0x9d99,0x9e99,0x9f99,
309 0xa0a1,0xa1a1,0xa2a1,0xa3a1,0xa4a1,0xa5a1,0xa6a1,0xa7a1,
310 0xa8a9,0xa9a9,0xaaa9,0xaba9,0xaca9,0xada9,0xaea9,0xafa9,
311 0xb0b1,0xb1b1,0xb2b1,0xb3b1,0xb4b1,0xb5b1,0xb6b1,0xb7b1,
312 0xb8b9,0xb9b9,0xbab9,0xbbb9,0xbcb9,0xbdb9,0xbeb9,0xbfb9,
313 0xc081,0xc181,0xc281,0xc381,0xc481,0xc581,0xc681,0xc781,
314 0xc889,0xc989,0xca89,0xcb89,0xcc89,0xcd89,0xce89,0xcf89,
315 0xd091,0xd191,0xd291,0xd391,0xd491,0xd591,0xd691,0xd791,
316 0xd899,0xd999,0xda99,0xdb99,0xdc99,0xdd99,0xde99,0xdf99,
317 0xe0a1,0xe1a1,0xe2a1,0xe3a1,0xe4a1,0xe5a1,0xe6a1,0xe7a1,
318 0xe8a9,0xe9a9,0xeaa9,0xeba9,0xeca9,0xeda9,0xeea9,0xefa9,
319 0xf0b1,0xf1b1,0xf2b1,0xf3b1,0xf4b1,0xf5b1,0xf6b1,0xf7b1,
320 0xf8b9,0xf9b9,0xfab9,0xfbb9,0xfcb9,0xfdb9,0xfeb9,0xffb9,
323 /* cbitsDup16Table[i] = (i & 0x10) | ((i >> 8) & 1) | (i & 0x28), i = 0..511 */
324 static const uint8 cbitsDup16Table
[512] = {
325 0, 0, 0, 0, 0, 0, 0, 0, 8, 8, 8, 8, 8, 8, 8, 8,
326 16,16,16,16,16,16,16,16,24,24,24,24,24,24,24,24,
327 32,32,32,32,32,32,32,32,40,40,40,40,40,40,40,40,
328 48,48,48,48,48,48,48,48,56,56,56,56,56,56,56,56,
329 0, 0, 0, 0, 0, 0, 0, 0, 8, 8, 8, 8, 8, 8, 8, 8,
330 16,16,16,16,16,16,16,16,24,24,24,24,24,24,24,24,
331 32,32,32,32,32,32,32,32,40,40,40,40,40,40,40,40,
332 48,48,48,48,48,48,48,48,56,56,56,56,56,56,56,56,
333 0, 0, 0, 0, 0, 0, 0, 0, 8, 8, 8, 8, 8, 8, 8, 8,
334 16,16,16,16,16,16,16,16,24,24,24,24,24,24,24,24,
335 32,32,32,32,32,32,32,32,40,40,40,40,40,40,40,40,
336 48,48,48,48,48,48,48,48,56,56,56,56,56,56,56,56,
337 0, 0, 0, 0, 0, 0, 0, 0, 8, 8, 8, 8, 8, 8, 8, 8,
338 16,16,16,16,16,16,16,16,24,24,24,24,24,24,24,24,
339 32,32,32,32,32,32,32,32,40,40,40,40,40,40,40,40,
340 48,48,48,48,48,48,48,48,56,56,56,56,56,56,56,56,
341 1, 1, 1, 1, 1, 1, 1, 1, 9, 9, 9, 9, 9, 9, 9, 9,
342 17,17,17,17,17,17,17,17,25,25,25,25,25,25,25,25,
343 33,33,33,33,33,33,33,33,41,41,41,41,41,41,41,41,
344 49,49,49,49,49,49,49,49,57,57,57,57,57,57,57,57,
345 1, 1, 1, 1, 1, 1, 1, 1, 9, 9, 9, 9, 9, 9, 9, 9,
346 17,17,17,17,17,17,17,17,25,25,25,25,25,25,25,25,
347 33,33,33,33,33,33,33,33,41,41,41,41,41,41,41,41,
348 49,49,49,49,49,49,49,49,57,57,57,57,57,57,57,57,
349 1, 1, 1, 1, 1, 1, 1, 1, 9, 9, 9, 9, 9, 9, 9, 9,
350 17,17,17,17,17,17,17,17,25,25,25,25,25,25,25,25,
351 33,33,33,33,33,33,33,33,41,41,41,41,41,41,41,41,
352 49,49,49,49,49,49,49,49,57,57,57,57,57,57,57,57,
353 1, 1, 1, 1, 1, 1, 1, 1, 9, 9, 9, 9, 9, 9, 9, 9,
354 17,17,17,17,17,17,17,17,25,25,25,25,25,25,25,25,
355 33,33,33,33,33,33,33,33,41,41,41,41,41,41,41,41,
356 49,49,49,49,49,49,49,49,57,57,57,57,57,57,57,57,
359 /* cbits2Table[i] = (i & 0x10) | ((i >> 8) & 1) | 2, i = 0..511 */
360 static const uint8 cbits2Table
[512] = {
361 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
362 18,18,18,18,18,18,18,18,18,18,18,18,18,18,18,18,
363 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
364 18,18,18,18,18,18,18,18,18,18,18,18,18,18,18,18,
365 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
366 18,18,18,18,18,18,18,18,18,18,18,18,18,18,18,18,
367 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
368 18,18,18,18,18,18,18,18,18,18,18,18,18,18,18,18,
369 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
370 18,18,18,18,18,18,18,18,18,18,18,18,18,18,18,18,
371 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
372 18,18,18,18,18,18,18,18,18,18,18,18,18,18,18,18,
373 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
374 18,18,18,18,18,18,18,18,18,18,18,18,18,18,18,18,
375 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
376 18,18,18,18,18,18,18,18,18,18,18,18,18,18,18,18,
377 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
378 19,19,19,19,19,19,19,19,19,19,19,19,19,19,19,19,
379 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
380 19,19,19,19,19,19,19,19,19,19,19,19,19,19,19,19,
381 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
382 19,19,19,19,19,19,19,19,19,19,19,19,19,19,19,19,
383 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
384 19,19,19,19,19,19,19,19,19,19,19,19,19,19,19,19,
385 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
386 19,19,19,19,19,19,19,19,19,19,19,19,19,19,19,19,
387 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
388 19,19,19,19,19,19,19,19,19,19,19,19,19,19,19,19,
389 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
390 19,19,19,19,19,19,19,19,19,19,19,19,19,19,19,19,
391 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
392 19,19,19,19,19,19,19,19,19,19,19,19,19,19,19,19,
395 /* rrcaTable[i] = ((i & 1) << 15) | ((i >> 1) << 8) | ((i >> 1) & 0x28) | (i & 1), i = 0..255 */
396 static const uint16 rrcaTable
[256] = {
397 0x0000,0x8001,0x0100,0x8101,0x0200,0x8201,0x0300,0x8301,
398 0x0400,0x8401,0x0500,0x8501,0x0600,0x8601,0x0700,0x8701,
399 0x0808,0x8809,0x0908,0x8909,0x0a08,0x8a09,0x0b08,0x8b09,
400 0x0c08,0x8c09,0x0d08,0x8d09,0x0e08,0x8e09,0x0f08,0x8f09,
401 0x1000,0x9001,0x1100,0x9101,0x1200,0x9201,0x1300,0x9301,
402 0x1400,0x9401,0x1500,0x9501,0x1600,0x9601,0x1700,0x9701,
403 0x1808,0x9809,0x1908,0x9909,0x1a08,0x9a09,0x1b08,0x9b09,
404 0x1c08,0x9c09,0x1d08,0x9d09,0x1e08,0x9e09,0x1f08,0x9f09,
405 0x2020,0xa021,0x2120,0xa121,0x2220,0xa221,0x2320,0xa321,
406 0x2420,0xa421,0x2520,0xa521,0x2620,0xa621,0x2720,0xa721,
407 0x2828,0xa829,0x2928,0xa929,0x2a28,0xaa29,0x2b28,0xab29,
408 0x2c28,0xac29,0x2d28,0xad29,0x2e28,0xae29,0x2f28,0xaf29,
409 0x3020,0xb021,0x3120,0xb121,0x3220,0xb221,0x3320,0xb321,
410 0x3420,0xb421,0x3520,0xb521,0x3620,0xb621,0x3720,0xb721,
411 0x3828,0xb829,0x3928,0xb929,0x3a28,0xba29,0x3b28,0xbb29,
412 0x3c28,0xbc29,0x3d28,0xbd29,0x3e28,0xbe29,0x3f28,0xbf29,
413 0x4000,0xc001,0x4100,0xc101,0x4200,0xc201,0x4300,0xc301,
414 0x4400,0xc401,0x4500,0xc501,0x4600,0xc601,0x4700,0xc701,
415 0x4808,0xc809,0x4908,0xc909,0x4a08,0xca09,0x4b08,0xcb09,
416 0x4c08,0xcc09,0x4d08,0xcd09,0x4e08,0xce09,0x4f08,0xcf09,
417 0x5000,0xd001,0x5100,0xd101,0x5200,0xd201,0x5300,0xd301,
418 0x5400,0xd401,0x5500,0xd501,0x5600,0xd601,0x5700,0xd701,
419 0x5808,0xd809,0x5908,0xd909,0x5a08,0xda09,0x5b08,0xdb09,
420 0x5c08,0xdc09,0x5d08,0xdd09,0x5e08,0xde09,0x5f08,0xdf09,
421 0x6020,0xe021,0x6120,0xe121,0x6220,0xe221,0x6320,0xe321,
422 0x6420,0xe421,0x6520,0xe521,0x6620,0xe621,0x6720,0xe721,
423 0x6828,0xe829,0x6928,0xe929,0x6a28,0xea29,0x6b28,0xeb29,
424 0x6c28,0xec29,0x6d28,0xed29,0x6e28,0xee29,0x6f28,0xef29,
425 0x7020,0xf021,0x7120,0xf121,0x7220,0xf221,0x7320,0xf321,
426 0x7420,0xf421,0x7520,0xf521,0x7620,0xf621,0x7720,0xf721,
427 0x7828,0xf829,0x7928,0xf929,0x7a28,0xfa29,0x7b28,0xfb29,
428 0x7c28,0xfc29,0x7d28,0xfd29,0x7e28,0xfe29,0x7f28,0xff29,
431 /* rraTable[i] = ((i >> 1) << 8) | ((i >> 1) & 0x28) | (i & 1), i = 0..255 */
432 static const uint16 rraTable
[256] = {
433 0x0000,0x0001,0x0100,0x0101,0x0200,0x0201,0x0300,0x0301,
434 0x0400,0x0401,0x0500,0x0501,0x0600,0x0601,0x0700,0x0701,
435 0x0808,0x0809,0x0908,0x0909,0x0a08,0x0a09,0x0b08,0x0b09,
436 0x0c08,0x0c09,0x0d08,0x0d09,0x0e08,0x0e09,0x0f08,0x0f09,
437 0x1000,0x1001,0x1100,0x1101,0x1200,0x1201,0x1300,0x1301,
438 0x1400,0x1401,0x1500,0x1501,0x1600,0x1601,0x1700,0x1701,
439 0x1808,0x1809,0x1908,0x1909,0x1a08,0x1a09,0x1b08,0x1b09,
440 0x1c08,0x1c09,0x1d08,0x1d09,0x1e08,0x1e09,0x1f08,0x1f09,
441 0x2020,0x2021,0x2120,0x2121,0x2220,0x2221,0x2320,0x2321,
442 0x2420,0x2421,0x2520,0x2521,0x2620,0x2621,0x2720,0x2721,
443 0x2828,0x2829,0x2928,0x2929,0x2a28,0x2a29,0x2b28,0x2b29,
444 0x2c28,0x2c29,0x2d28,0x2d29,0x2e28,0x2e29,0x2f28,0x2f29,
445 0x3020,0x3021,0x3120,0x3121,0x3220,0x3221,0x3320,0x3321,
446 0x3420,0x3421,0x3520,0x3521,0x3620,0x3621,0x3720,0x3721,
447 0x3828,0x3829,0x3928,0x3929,0x3a28,0x3a29,0x3b28,0x3b29,
448 0x3c28,0x3c29,0x3d28,0x3d29,0x3e28,0x3e29,0x3f28,0x3f29,
449 0x4000,0x4001,0x4100,0x4101,0x4200,0x4201,0x4300,0x4301,
450 0x4400,0x4401,0x4500,0x4501,0x4600,0x4601,0x4700,0x4701,
451 0x4808,0x4809,0x4908,0x4909,0x4a08,0x4a09,0x4b08,0x4b09,
452 0x4c08,0x4c09,0x4d08,0x4d09,0x4e08,0x4e09,0x4f08,0x4f09,
453 0x5000,0x5001,0x5100,0x5101,0x5200,0x5201,0x5300,0x5301,
454 0x5400,0x5401,0x5500,0x5501,0x5600,0x5601,0x5700,0x5701,
455 0x5808,0x5809,0x5908,0x5909,0x5a08,0x5a09,0x5b08,0x5b09,
456 0x5c08,0x5c09,0x5d08,0x5d09,0x5e08,0x5e09,0x5f08,0x5f09,
457 0x6020,0x6021,0x6120,0x6121,0x6220,0x6221,0x6320,0x6321,
458 0x6420,0x6421,0x6520,0x6521,0x6620,0x6621,0x6720,0x6721,
459 0x6828,0x6829,0x6928,0x6929,0x6a28,0x6a29,0x6b28,0x6b29,
460 0x6c28,0x6c29,0x6d28,0x6d29,0x6e28,0x6e29,0x6f28,0x6f29,
461 0x7020,0x7021,0x7120,0x7121,0x7220,0x7221,0x7320,0x7321,
462 0x7420,0x7421,0x7520,0x7521,0x7620,0x7621,0x7720,0x7721,
463 0x7828,0x7829,0x7928,0x7929,0x7a28,0x7a29,0x7b28,0x7b29,
464 0x7c28,0x7c29,0x7d28,0x7d29,0x7e28,0x7e29,0x7f28,0x7f29,
467 /* addTable[i] = ((i & 0xff) << 8) | (i & 0xa8) | (((i & 0xff) == 0) << 6), i = 0..511 */
468 static const uint16 addTable
[512] = {
469 0x0040,0x0100,0x0200,0x0300,0x0400,0x0500,0x0600,0x0700,
470 0x0808,0x0908,0x0a08,0x0b08,0x0c08,0x0d08,0x0e08,0x0f08,
471 0x1000,0x1100,0x1200,0x1300,0x1400,0x1500,0x1600,0x1700,
472 0x1808,0x1908,0x1a08,0x1b08,0x1c08,0x1d08,0x1e08,0x1f08,
473 0x2020,0x2120,0x2220,0x2320,0x2420,0x2520,0x2620,0x2720,
474 0x2828,0x2928,0x2a28,0x2b28,0x2c28,0x2d28,0x2e28,0x2f28,
475 0x3020,0x3120,0x3220,0x3320,0x3420,0x3520,0x3620,0x3720,
476 0x3828,0x3928,0x3a28,0x3b28,0x3c28,0x3d28,0x3e28,0x3f28,
477 0x4000,0x4100,0x4200,0x4300,0x4400,0x4500,0x4600,0x4700,
478 0x4808,0x4908,0x4a08,0x4b08,0x4c08,0x4d08,0x4e08,0x4f08,
479 0x5000,0x5100,0x5200,0x5300,0x5400,0x5500,0x5600,0x5700,
480 0x5808,0x5908,0x5a08,0x5b08,0x5c08,0x5d08,0x5e08,0x5f08,
481 0x6020,0x6120,0x6220,0x6320,0x6420,0x6520,0x6620,0x6720,
482 0x6828,0x6928,0x6a28,0x6b28,0x6c28,0x6d28,0x6e28,0x6f28,
483 0x7020,0x7120,0x7220,0x7320,0x7420,0x7520,0x7620,0x7720,
484 0x7828,0x7928,0x7a28,0x7b28,0x7c28,0x7d28,0x7e28,0x7f28,
485 0x8080,0x8180,0x8280,0x8380,0x8480,0x8580,0x8680,0x8780,
486 0x8888,0x8988,0x8a88,0x8b88,0x8c88,0x8d88,0x8e88,0x8f88,
487 0x9080,0x9180,0x9280,0x9380,0x9480,0x9580,0x9680,0x9780,
488 0x9888,0x9988,0x9a88,0x9b88,0x9c88,0x9d88,0x9e88,0x9f88,
489 0xa0a0,0xa1a0,0xa2a0,0xa3a0,0xa4a0,0xa5a0,0xa6a0,0xa7a0,
490 0xa8a8,0xa9a8,0xaaa8,0xaba8,0xaca8,0xada8,0xaea8,0xafa8,
491 0xb0a0,0xb1a0,0xb2a0,0xb3a0,0xb4a0,0xb5a0,0xb6a0,0xb7a0,
492 0xb8a8,0xb9a8,0xbaa8,0xbba8,0xbca8,0xbda8,0xbea8,0xbfa8,
493 0xc080,0xc180,0xc280,0xc380,0xc480,0xc580,0xc680,0xc780,
494 0xc888,0xc988,0xca88,0xcb88,0xcc88,0xcd88,0xce88,0xcf88,
495 0xd080,0xd180,0xd280,0xd380,0xd480,0xd580,0xd680,0xd780,
496 0xd888,0xd988,0xda88,0xdb88,0xdc88,0xdd88,0xde88,0xdf88,
497 0xe0a0,0xe1a0,0xe2a0,0xe3a0,0xe4a0,0xe5a0,0xe6a0,0xe7a0,
498 0xe8a8,0xe9a8,0xeaa8,0xeba8,0xeca8,0xeda8,0xeea8,0xefa8,
499 0xf0a0,0xf1a0,0xf2a0,0xf3a0,0xf4a0,0xf5a0,0xf6a0,0xf7a0,
500 0xf8a8,0xf9a8,0xfaa8,0xfba8,0xfca8,0xfda8,0xfea8,0xffa8,
501 0x0040,0x0100,0x0200,0x0300,0x0400,0x0500,0x0600,0x0700,
502 0x0808,0x0908,0x0a08,0x0b08,0x0c08,0x0d08,0x0e08,0x0f08,
503 0x1000,0x1100,0x1200,0x1300,0x1400,0x1500,0x1600,0x1700,
504 0x1808,0x1908,0x1a08,0x1b08,0x1c08,0x1d08,0x1e08,0x1f08,
505 0x2020,0x2120,0x2220,0x2320,0x2420,0x2520,0x2620,0x2720,
506 0x2828,0x2928,0x2a28,0x2b28,0x2c28,0x2d28,0x2e28,0x2f28,
507 0x3020,0x3120,0x3220,0x3320,0x3420,0x3520,0x3620,0x3720,
508 0x3828,0x3928,0x3a28,0x3b28,0x3c28,0x3d28,0x3e28,0x3f28,
509 0x4000,0x4100,0x4200,0x4300,0x4400,0x4500,0x4600,0x4700,
510 0x4808,0x4908,0x4a08,0x4b08,0x4c08,0x4d08,0x4e08,0x4f08,
511 0x5000,0x5100,0x5200,0x5300,0x5400,0x5500,0x5600,0x5700,
512 0x5808,0x5908,0x5a08,0x5b08,0x5c08,0x5d08,0x5e08,0x5f08,
513 0x6020,0x6120,0x6220,0x6320,0x6420,0x6520,0x6620,0x6720,
514 0x6828,0x6928,0x6a28,0x6b28,0x6c28,0x6d28,0x6e28,0x6f28,
515 0x7020,0x7120,0x7220,0x7320,0x7420,0x7520,0x7620,0x7720,
516 0x7828,0x7928,0x7a28,0x7b28,0x7c28,0x7d28,0x7e28,0x7f28,
517 0x8080,0x8180,0x8280,0x8380,0x8480,0x8580,0x8680,0x8780,
518 0x8888,0x8988,0x8a88,0x8b88,0x8c88,0x8d88,0x8e88,0x8f88,
519 0x9080,0x9180,0x9280,0x9380,0x9480,0x9580,0x9680,0x9780,
520 0x9888,0x9988,0x9a88,0x9b88,0x9c88,0x9d88,0x9e88,0x9f88,
521 0xa0a0,0xa1a0,0xa2a0,0xa3a0,0xa4a0,0xa5a0,0xa6a0,0xa7a0,
522 0xa8a8,0xa9a8,0xaaa8,0xaba8,0xaca8,0xada8,0xaea8,0xafa8,
523 0xb0a0,0xb1a0,0xb2a0,0xb3a0,0xb4a0,0xb5a0,0xb6a0,0xb7a0,
524 0xb8a8,0xb9a8,0xbaa8,0xbba8,0xbca8,0xbda8,0xbea8,0xbfa8,
525 0xc080,0xc180,0xc280,0xc380,0xc480,0xc580,0xc680,0xc780,
526 0xc888,0xc988,0xca88,0xcb88,0xcc88,0xcd88,0xce88,0xcf88,
527 0xd080,0xd180,0xd280,0xd380,0xd480,0xd580,0xd680,0xd780,
528 0xd888,0xd988,0xda88,0xdb88,0xdc88,0xdd88,0xde88,0xdf88,
529 0xe0a0,0xe1a0,0xe2a0,0xe3a0,0xe4a0,0xe5a0,0xe6a0,0xe7a0,
530 0xe8a8,0xe9a8,0xeaa8,0xeba8,0xeca8,0xeda8,0xeea8,0xefa8,
531 0xf0a0,0xf1a0,0xf2a0,0xf3a0,0xf4a0,0xf5a0,0xf6a0,0xf7a0,
532 0xf8a8,0xf9a8,0xfaa8,0xfba8,0xfca8,0xfda8,0xfea8,0xffa8,
535 /* subTable[i] = ((i & 0xff) << 8) | (i & 0xa8) | (((i & 0xff) == 0) << 6) | 2, i = 0..255 */
536 static const uint16 subTable
[256] = {
537 0x0042,0x0102,0x0202,0x0302,0x0402,0x0502,0x0602,0x0702,
538 0x080a,0x090a,0x0a0a,0x0b0a,0x0c0a,0x0d0a,0x0e0a,0x0f0a,
539 0x1002,0x1102,0x1202,0x1302,0x1402,0x1502,0x1602,0x1702,
540 0x180a,0x190a,0x1a0a,0x1b0a,0x1c0a,0x1d0a,0x1e0a,0x1f0a,
541 0x2022,0x2122,0x2222,0x2322,0x2422,0x2522,0x2622,0x2722,
542 0x282a,0x292a,0x2a2a,0x2b2a,0x2c2a,0x2d2a,0x2e2a,0x2f2a,
543 0x3022,0x3122,0x3222,0x3322,0x3422,0x3522,0x3622,0x3722,
544 0x382a,0x392a,0x3a2a,0x3b2a,0x3c2a,0x3d2a,0x3e2a,0x3f2a,
545 0x4002,0x4102,0x4202,0x4302,0x4402,0x4502,0x4602,0x4702,
546 0x480a,0x490a,0x4a0a,0x4b0a,0x4c0a,0x4d0a,0x4e0a,0x4f0a,
547 0x5002,0x5102,0x5202,0x5302,0x5402,0x5502,0x5602,0x5702,
548 0x580a,0x590a,0x5a0a,0x5b0a,0x5c0a,0x5d0a,0x5e0a,0x5f0a,
549 0x6022,0x6122,0x6222,0x6322,0x6422,0x6522,0x6622,0x6722,
550 0x682a,0x692a,0x6a2a,0x6b2a,0x6c2a,0x6d2a,0x6e2a,0x6f2a,
551 0x7022,0x7122,0x7222,0x7322,0x7422,0x7522,0x7622,0x7722,
552 0x782a,0x792a,0x7a2a,0x7b2a,0x7c2a,0x7d2a,0x7e2a,0x7f2a,
553 0x8082,0x8182,0x8282,0x8382,0x8482,0x8582,0x8682,0x8782,
554 0x888a,0x898a,0x8a8a,0x8b8a,0x8c8a,0x8d8a,0x8e8a,0x8f8a,
555 0x9082,0x9182,0x9282,0x9382,0x9482,0x9582,0x9682,0x9782,
556 0x988a,0x998a,0x9a8a,0x9b8a,0x9c8a,0x9d8a,0x9e8a,0x9f8a,
557 0xa0a2,0xa1a2,0xa2a2,0xa3a2,0xa4a2,0xa5a2,0xa6a2,0xa7a2,
558 0xa8aa,0xa9aa,0xaaaa,0xabaa,0xacaa,0xadaa,0xaeaa,0xafaa,
559 0xb0a2,0xb1a2,0xb2a2,0xb3a2,0xb4a2,0xb5a2,0xb6a2,0xb7a2,
560 0xb8aa,0xb9aa,0xbaaa,0xbbaa,0xbcaa,0xbdaa,0xbeaa,0xbfaa,
561 0xc082,0xc182,0xc282,0xc382,0xc482,0xc582,0xc682,0xc782,
562 0xc88a,0xc98a,0xca8a,0xcb8a,0xcc8a,0xcd8a,0xce8a,0xcf8a,
563 0xd082,0xd182,0xd282,0xd382,0xd482,0xd582,0xd682,0xd782,
564 0xd88a,0xd98a,0xda8a,0xdb8a,0xdc8a,0xdd8a,0xde8a,0xdf8a,
565 0xe0a2,0xe1a2,0xe2a2,0xe3a2,0xe4a2,0xe5a2,0xe6a2,0xe7a2,
566 0xe8aa,0xe9aa,0xeaaa,0xebaa,0xecaa,0xedaa,0xeeaa,0xefaa,
567 0xf0a2,0xf1a2,0xf2a2,0xf3a2,0xf4a2,0xf5a2,0xf6a2,0xf7a2,
568 0xf8aa,0xf9aa,0xfaaa,0xfbaa,0xfcaa,0xfdaa,0xfeaa,0xffaa,
571 /* andTable[i] = (i << 8) | (i & 0xa8) | ((i == 0) << 6) | 0x10 | parityTable[i], i = 0..255 */
572 static const uint16 andTable
[256] = {
573 0x0054,0x0110,0x0210,0x0314,0x0410,0x0514,0x0614,0x0710,
574 0x0818,0x091c,0x0a1c,0x0b18,0x0c1c,0x0d18,0x0e18,0x0f1c,
575 0x1010,0x1114,0x1214,0x1310,0x1414,0x1510,0x1610,0x1714,
576 0x181c,0x1918,0x1a18,0x1b1c,0x1c18,0x1d1c,0x1e1c,0x1f18,
577 0x2030,0x2134,0x2234,0x2330,0x2434,0x2530,0x2630,0x2734,
578 0x283c,0x2938,0x2a38,0x2b3c,0x2c38,0x2d3c,0x2e3c,0x2f38,
579 0x3034,0x3130,0x3230,0x3334,0x3430,0x3534,0x3634,0x3730,
580 0x3838,0x393c,0x3a3c,0x3b38,0x3c3c,0x3d38,0x3e38,0x3f3c,
581 0x4010,0x4114,0x4214,0x4310,0x4414,0x4510,0x4610,0x4714,
582 0x481c,0x4918,0x4a18,0x4b1c,0x4c18,0x4d1c,0x4e1c,0x4f18,
583 0x5014,0x5110,0x5210,0x5314,0x5410,0x5514,0x5614,0x5710,
584 0x5818,0x591c,0x5a1c,0x5b18,0x5c1c,0x5d18,0x5e18,0x5f1c,
585 0x6034,0x6130,0x6230,0x6334,0x6430,0x6534,0x6634,0x6730,
586 0x6838,0x693c,0x6a3c,0x6b38,0x6c3c,0x6d38,0x6e38,0x6f3c,
587 0x7030,0x7134,0x7234,0x7330,0x7434,0x7530,0x7630,0x7734,
588 0x783c,0x7938,0x7a38,0x7b3c,0x7c38,0x7d3c,0x7e3c,0x7f38,
589 0x8090,0x8194,0x8294,0x8390,0x8494,0x8590,0x8690,0x8794,
590 0x889c,0x8998,0x8a98,0x8b9c,0x8c98,0x8d9c,0x8e9c,0x8f98,
591 0x9094,0x9190,0x9290,0x9394,0x9490,0x9594,0x9694,0x9790,
592 0x9898,0x999c,0x9a9c,0x9b98,0x9c9c,0x9d98,0x9e98,0x9f9c,
593 0xa0b4,0xa1b0,0xa2b0,0xa3b4,0xa4b0,0xa5b4,0xa6b4,0xa7b0,
594 0xa8b8,0xa9bc,0xaabc,0xabb8,0xacbc,0xadb8,0xaeb8,0xafbc,
595 0xb0b0,0xb1b4,0xb2b4,0xb3b0,0xb4b4,0xb5b0,0xb6b0,0xb7b4,
596 0xb8bc,0xb9b8,0xbab8,0xbbbc,0xbcb8,0xbdbc,0xbebc,0xbfb8,
597 0xc094,0xc190,0xc290,0xc394,0xc490,0xc594,0xc694,0xc790,
598 0xc898,0xc99c,0xca9c,0xcb98,0xcc9c,0xcd98,0xce98,0xcf9c,
599 0xd090,0xd194,0xd294,0xd390,0xd494,0xd590,0xd690,0xd794,
600 0xd89c,0xd998,0xda98,0xdb9c,0xdc98,0xdd9c,0xde9c,0xdf98,
601 0xe0b0,0xe1b4,0xe2b4,0xe3b0,0xe4b4,0xe5b0,0xe6b0,0xe7b4,
602 0xe8bc,0xe9b8,0xeab8,0xebbc,0xecb8,0xedbc,0xeebc,0xefb8,
603 0xf0b4,0xf1b0,0xf2b0,0xf3b4,0xf4b0,0xf5b4,0xf6b4,0xf7b0,
604 0xf8b8,0xf9bc,0xfabc,0xfbb8,0xfcbc,0xfdb8,0xfeb8,0xffbc,
607 /* xororTable[i] = (i << 8) | (i & 0xa8) | ((i == 0) << 6) | parityTable[i], i = 0..255 */
608 static const uint16 xororTable
[256] = {
609 0x0044,0x0100,0x0200,0x0304,0x0400,0x0504,0x0604,0x0700,
610 0x0808,0x090c,0x0a0c,0x0b08,0x0c0c,0x0d08,0x0e08,0x0f0c,
611 0x1000,0x1104,0x1204,0x1300,0x1404,0x1500,0x1600,0x1704,
612 0x180c,0x1908,0x1a08,0x1b0c,0x1c08,0x1d0c,0x1e0c,0x1f08,
613 0x2020,0x2124,0x2224,0x2320,0x2424,0x2520,0x2620,0x2724,
614 0x282c,0x2928,0x2a28,0x2b2c,0x2c28,0x2d2c,0x2e2c,0x2f28,
615 0x3024,0x3120,0x3220,0x3324,0x3420,0x3524,0x3624,0x3720,
616 0x3828,0x392c,0x3a2c,0x3b28,0x3c2c,0x3d28,0x3e28,0x3f2c,
617 0x4000,0x4104,0x4204,0x4300,0x4404,0x4500,0x4600,0x4704,
618 0x480c,0x4908,0x4a08,0x4b0c,0x4c08,0x4d0c,0x4e0c,0x4f08,
619 0x5004,0x5100,0x5200,0x5304,0x5400,0x5504,0x5604,0x5700,
620 0x5808,0x590c,0x5a0c,0x5b08,0x5c0c,0x5d08,0x5e08,0x5f0c,
621 0x6024,0x6120,0x6220,0x6324,0x6420,0x6524,0x6624,0x6720,
622 0x6828,0x692c,0x6a2c,0x6b28,0x6c2c,0x6d28,0x6e28,0x6f2c,
623 0x7020,0x7124,0x7224,0x7320,0x7424,0x7520,0x7620,0x7724,
624 0x782c,0x7928,0x7a28,0x7b2c,0x7c28,0x7d2c,0x7e2c,0x7f28,
625 0x8080,0x8184,0x8284,0x8380,0x8484,0x8580,0x8680,0x8784,
626 0x888c,0x8988,0x8a88,0x8b8c,0x8c88,0x8d8c,0x8e8c,0x8f88,
627 0x9084,0x9180,0x9280,0x9384,0x9480,0x9584,0x9684,0x9780,
628 0x9888,0x998c,0x9a8c,0x9b88,0x9c8c,0x9d88,0x9e88,0x9f8c,
629 0xa0a4,0xa1a0,0xa2a0,0xa3a4,0xa4a0,0xa5a4,0xa6a4,0xa7a0,
630 0xa8a8,0xa9ac,0xaaac,0xaba8,0xacac,0xada8,0xaea8,0xafac,
631 0xb0a0,0xb1a4,0xb2a4,0xb3a0,0xb4a4,0xb5a0,0xb6a0,0xb7a4,
632 0xb8ac,0xb9a8,0xbaa8,0xbbac,0xbca8,0xbdac,0xbeac,0xbfa8,
633 0xc084,0xc180,0xc280,0xc384,0xc480,0xc584,0xc684,0xc780,
634 0xc888,0xc98c,0xca8c,0xcb88,0xcc8c,0xcd88,0xce88,0xcf8c,
635 0xd080,0xd184,0xd284,0xd380,0xd484,0xd580,0xd680,0xd784,
636 0xd88c,0xd988,0xda88,0xdb8c,0xdc88,0xdd8c,0xde8c,0xdf88,
637 0xe0a0,0xe1a4,0xe2a4,0xe3a0,0xe4a4,0xe5a0,0xe6a0,0xe7a4,
638 0xe8ac,0xe9a8,0xeaa8,0xebac,0xeca8,0xedac,0xeeac,0xefa8,
639 0xf0a4,0xf1a0,0xf2a0,0xf3a4,0xf4a0,0xf5a4,0xf6a4,0xf7a0,
640 0xf8a8,0xf9ac,0xfaac,0xfba8,0xfcac,0xfda8,0xfea8,0xffac,
643 /* rotateShiftTable[i] = (i & 0xa8) | (((i & 0xff) == 0) << 6) | parityTable[i & 0xff], i = 0..255 */
644 static const uint8 rotateShiftTable
[256] = {
645 68, 0, 0, 4, 0, 4, 4, 0, 8, 12, 12, 8, 12, 8, 8, 12,
646 0, 4, 4, 0, 4, 0, 0, 4, 12, 8, 8, 12, 8, 12, 12, 8,
647 32, 36, 36, 32, 36, 32, 32, 36, 44, 40, 40, 44, 40, 44, 44, 40,
648 36, 32, 32, 36, 32, 36, 36, 32, 40, 44, 44, 40, 44, 40, 40, 44,
649 0, 4, 4, 0, 4, 0, 0, 4, 12, 8, 8, 12, 8, 12, 12, 8,
650 4, 0, 0, 4, 0, 4, 4, 0, 8, 12, 12, 8, 12, 8, 8, 12,
651 36, 32, 32, 36, 32, 36, 36, 32, 40, 44, 44, 40, 44, 40, 40, 44,
652 32, 36, 36, 32, 36, 32, 32, 36, 44, 40, 40, 44, 40, 44, 44, 40,
653 128,132,132,128,132,128,128,132,140,136,136,140,136,140,140,136,
654 132,128,128,132,128,132,132,128,136,140,140,136,140,136,136,140,
655 164,160,160,164,160,164,164,160,168,172,172,168,172,168,168,172,
656 160,164,164,160,164,160,160,164,172,168,168,172,168,172,172,168,
657 132,128,128,132,128,132,132,128,136,140,140,136,140,136,136,140,
658 128,132,132,128,132,128,128,132,140,136,136,140,136,140,140,136,
659 160,164,164,160,164,160,160,164,172,168,168,172,168,172,172,168,
660 164,160,160,164,160,164,164,160,168,172,172,168,172,168,168,172,
663 /* incZ80Table[i] = (i & 0xa8) | (((i & 0xff) == 0) << 6) |
664 (((i & 0xf) == 0) << 4) | ((i == 0x80) << 2), i = 0..256 */
665 static const uint8 incZ80Table
[257] = {
666 80, 0, 0, 0, 0, 0, 0, 0, 8, 8, 8, 8, 8, 8, 8, 8,
667 16, 0, 0, 0, 0, 0, 0, 0, 8, 8, 8, 8, 8, 8, 8, 8,
668 48, 32, 32, 32, 32, 32, 32, 32, 40, 40, 40, 40, 40, 40, 40, 40,
669 48, 32, 32, 32, 32, 32, 32, 32, 40, 40, 40, 40, 40, 40, 40, 40,
670 16, 0, 0, 0, 0, 0, 0, 0, 8, 8, 8, 8, 8, 8, 8, 8,
671 16, 0, 0, 0, 0, 0, 0, 0, 8, 8, 8, 8, 8, 8, 8, 8,
672 48, 32, 32, 32, 32, 32, 32, 32, 40, 40, 40, 40, 40, 40, 40, 40,
673 48, 32, 32, 32, 32, 32, 32, 32, 40, 40, 40, 40, 40, 40, 40, 40,
674 148,128,128,128,128,128,128,128,136,136,136,136,136,136,136,136,
675 144,128,128,128,128,128,128,128,136,136,136,136,136,136,136,136,
676 176,160,160,160,160,160,160,160,168,168,168,168,168,168,168,168,
677 176,160,160,160,160,160,160,160,168,168,168,168,168,168,168,168,
678 144,128,128,128,128,128,128,128,136,136,136,136,136,136,136,136,
679 144,128,128,128,128,128,128,128,136,136,136,136,136,136,136,136,
680 176,160,160,160,160,160,160,160,168,168,168,168,168,168,168,168,
681 176,160,160,160,160,160,160,160,168,168,168,168,168,168,168,168, 80,
684 /* decZ80Table[i] = (i & 0xa8) | (((i & 0xff) == 0) << 6) |
685 (((i & 0xf) == 0xf) << 4) | ((i == 0x7f) << 2) | 2, i = 0..255 */
686 static const uint8 decZ80Table
[256] = {
687 66, 2, 2, 2, 2, 2, 2, 2, 10, 10, 10, 10, 10, 10, 10, 26,
688 2, 2, 2, 2, 2, 2, 2, 2, 10, 10, 10, 10, 10, 10, 10, 26,
689 34, 34, 34, 34, 34, 34, 34, 34, 42, 42, 42, 42, 42, 42, 42, 58,
690 34, 34, 34, 34, 34, 34, 34, 34, 42, 42, 42, 42, 42, 42, 42, 58,
691 2, 2, 2, 2, 2, 2, 2, 2, 10, 10, 10, 10, 10, 10, 10, 26,
692 2, 2, 2, 2, 2, 2, 2, 2, 10, 10, 10, 10, 10, 10, 10, 26,
693 34, 34, 34, 34, 34, 34, 34, 34, 42, 42, 42, 42, 42, 42, 42, 58,
694 34, 34, 34, 34, 34, 34, 34, 34, 42, 42, 42, 42, 42, 42, 42, 62,
695 130,130,130,130,130,130,130,130,138,138,138,138,138,138,138,154,
696 130,130,130,130,130,130,130,130,138,138,138,138,138,138,138,154,
697 162,162,162,162,162,162,162,162,170,170,170,170,170,170,170,186,
698 162,162,162,162,162,162,162,162,170,170,170,170,170,170,170,186,
699 130,130,130,130,130,130,130,130,138,138,138,138,138,138,138,154,
700 130,130,130,130,130,130,130,130,138,138,138,138,138,138,138,154,
701 162,162,162,162,162,162,162,162,170,170,170,170,170,170,170,186,
702 162,162,162,162,162,162,162,162,170,170,170,170,170,170,170,186,
705 /* cbitsZ80Table[i] = (i & 0x10) | (((i >> 6) ^ (i >> 5)) & 4) | ((i >> 8) & 1), i = 0..511 */
706 static const uint8 cbitsZ80Table
[512] = {
707 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
708 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,
709 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
710 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,
711 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
712 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,
713 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
714 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,
715 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
716 20,20,20,20,20,20,20,20,20,20,20,20,20,20,20,20,
717 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
718 20,20,20,20,20,20,20,20,20,20,20,20,20,20,20,20,
719 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
720 20,20,20,20,20,20,20,20,20,20,20,20,20,20,20,20,
721 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
722 20,20,20,20,20,20,20,20,20,20,20,20,20,20,20,20,
723 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
724 21,21,21,21,21,21,21,21,21,21,21,21,21,21,21,21,
725 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
726 21,21,21,21,21,21,21,21,21,21,21,21,21,21,21,21,
727 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
728 21,21,21,21,21,21,21,21,21,21,21,21,21,21,21,21,
729 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
730 21,21,21,21,21,21,21,21,21,21,21,21,21,21,21,21,
731 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
732 17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,
733 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
734 17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,
735 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
736 17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,
737 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
738 17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,
741 /* cbitsZ80DupTable[i] = (i & 0x10) | (((i >> 6) ^ (i >> 5)) & 4) |
742 ((i >> 8) & 1) | (i & 0xa8), i = 0..511 */
743 static const uint8 cbitsZ80DupTable
[512] = {
744 0, 0, 0, 0, 0, 0, 0, 0, 8, 8, 8, 8, 8, 8, 8, 8,
745 16, 16, 16, 16, 16, 16, 16, 16, 24, 24, 24, 24, 24, 24, 24, 24,
746 32, 32, 32, 32, 32, 32, 32, 32, 40, 40, 40, 40, 40, 40, 40, 40,
747 48, 48, 48, 48, 48, 48, 48, 48, 56, 56, 56, 56, 56, 56, 56, 56,
748 0, 0, 0, 0, 0, 0, 0, 0, 8, 8, 8, 8, 8, 8, 8, 8,
749 16, 16, 16, 16, 16, 16, 16, 16, 24, 24, 24, 24, 24, 24, 24, 24,
750 32, 32, 32, 32, 32, 32, 32, 32, 40, 40, 40, 40, 40, 40, 40, 40,
751 48, 48, 48, 48, 48, 48, 48, 48, 56, 56, 56, 56, 56, 56, 56, 56,
752 132,132,132,132,132,132,132,132,140,140,140,140,140,140,140,140,
753 148,148,148,148,148,148,148,148,156,156,156,156,156,156,156,156,
754 164,164,164,164,164,164,164,164,172,172,172,172,172,172,172,172,
755 180,180,180,180,180,180,180,180,188,188,188,188,188,188,188,188,
756 132,132,132,132,132,132,132,132,140,140,140,140,140,140,140,140,
757 148,148,148,148,148,148,148,148,156,156,156,156,156,156,156,156,
758 164,164,164,164,164,164,164,164,172,172,172,172,172,172,172,172,
759 180,180,180,180,180,180,180,180,188,188,188,188,188,188,188,188,
760 5, 5, 5, 5, 5, 5, 5, 5, 13, 13, 13, 13, 13, 13, 13, 13,
761 21, 21, 21, 21, 21, 21, 21, 21, 29, 29, 29, 29, 29, 29, 29, 29,
762 37, 37, 37, 37, 37, 37, 37, 37, 45, 45, 45, 45, 45, 45, 45, 45,
763 53, 53, 53, 53, 53, 53, 53, 53, 61, 61, 61, 61, 61, 61, 61, 61,
764 5, 5, 5, 5, 5, 5, 5, 5, 13, 13, 13, 13, 13, 13, 13, 13,
765 21, 21, 21, 21, 21, 21, 21, 21, 29, 29, 29, 29, 29, 29, 29, 29,
766 37, 37, 37, 37, 37, 37, 37, 37, 45, 45, 45, 45, 45, 45, 45, 45,
767 53, 53, 53, 53, 53, 53, 53, 53, 61, 61, 61, 61, 61, 61, 61, 61,
768 129,129,129,129,129,129,129,129,137,137,137,137,137,137,137,137,
769 145,145,145,145,145,145,145,145,153,153,153,153,153,153,153,153,
770 161,161,161,161,161,161,161,161,169,169,169,169,169,169,169,169,
771 177,177,177,177,177,177,177,177,185,185,185,185,185,185,185,185,
772 129,129,129,129,129,129,129,129,137,137,137,137,137,137,137,137,
773 145,145,145,145,145,145,145,145,153,153,153,153,153,153,153,153,
774 161,161,161,161,161,161,161,161,169,169,169,169,169,169,169,169,
775 177,177,177,177,177,177,177,177,185,185,185,185,185,185,185,185,
778 /* cbits2Z80Table[i] = (i & 0x10) | (((i >> 6) ^ (i >> 5)) & 4) | ((i >> 8) & 1) | 2, i = 0..511 */
779 static const uint8 cbits2Z80Table
[512] = {
780 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
781 18,18,18,18,18,18,18,18,18,18,18,18,18,18,18,18,
782 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
783 18,18,18,18,18,18,18,18,18,18,18,18,18,18,18,18,
784 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
785 18,18,18,18,18,18,18,18,18,18,18,18,18,18,18,18,
786 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
787 18,18,18,18,18,18,18,18,18,18,18,18,18,18,18,18,
788 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6,
789 22,22,22,22,22,22,22,22,22,22,22,22,22,22,22,22,
790 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6,
791 22,22,22,22,22,22,22,22,22,22,22,22,22,22,22,22,
792 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6,
793 22,22,22,22,22,22,22,22,22,22,22,22,22,22,22,22,
794 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6,
795 22,22,22,22,22,22,22,22,22,22,22,22,22,22,22,22,
796 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7,
797 23,23,23,23,23,23,23,23,23,23,23,23,23,23,23,23,
798 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7,
799 23,23,23,23,23,23,23,23,23,23,23,23,23,23,23,23,
800 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7,
801 23,23,23,23,23,23,23,23,23,23,23,23,23,23,23,23,
802 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7,
803 23,23,23,23,23,23,23,23,23,23,23,23,23,23,23,23,
804 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
805 19,19,19,19,19,19,19,19,19,19,19,19,19,19,19,19,
806 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
807 19,19,19,19,19,19,19,19,19,19,19,19,19,19,19,19,
808 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
809 19,19,19,19,19,19,19,19,19,19,19,19,19,19,19,19,
810 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
811 19,19,19,19,19,19,19,19,19,19,19,19,19,19,19,19,
814 /* cbits2Z80DupTable[i] = (i & 0x10) | (((i >> 6) ^ (i >> 5)) & 4) | ((i >> 8) & 1) | 2 |
815 (i & 0xa8), i = 0..511 */
816 static const uint8 cbits2Z80DupTable
[512] = {
817 2, 2, 2, 2, 2, 2, 2, 2, 10, 10, 10, 10, 10, 10, 10, 10,
818 18, 18, 18, 18, 18, 18, 18, 18, 26, 26, 26, 26, 26, 26, 26, 26,
819 34, 34, 34, 34, 34, 34, 34, 34, 42, 42, 42, 42, 42, 42, 42, 42,
820 50, 50, 50, 50, 50, 50, 50, 50, 58, 58, 58, 58, 58, 58, 58, 58,
821 2, 2, 2, 2, 2, 2, 2, 2, 10, 10, 10, 10, 10, 10, 10, 10,
822 18, 18, 18, 18, 18, 18, 18, 18, 26, 26, 26, 26, 26, 26, 26, 26,
823 34, 34, 34, 34, 34, 34, 34, 34, 42, 42, 42, 42, 42, 42, 42, 42,
824 50, 50, 50, 50, 50, 50, 50, 50, 58, 58, 58, 58, 58, 58, 58, 58,
825 134,134,134,134,134,134,134,134,142,142,142,142,142,142,142,142,
826 150,150,150,150,150,150,150,150,158,158,158,158,158,158,158,158,
827 166,166,166,166,166,166,166,166,174,174,174,174,174,174,174,174,
828 182,182,182,182,182,182,182,182,190,190,190,190,190,190,190,190,
829 134,134,134,134,134,134,134,134,142,142,142,142,142,142,142,142,
830 150,150,150,150,150,150,150,150,158,158,158,158,158,158,158,158,
831 166,166,166,166,166,166,166,166,174,174,174,174,174,174,174,174,
832 182,182,182,182,182,182,182,182,190,190,190,190,190,190,190,190,
833 7, 7, 7, 7, 7, 7, 7, 7, 15, 15, 15, 15, 15, 15, 15, 15,
834 23, 23, 23, 23, 23, 23, 23, 23, 31, 31, 31, 31, 31, 31, 31, 31,
835 39, 39, 39, 39, 39, 39, 39, 39, 47, 47, 47, 47, 47, 47, 47, 47,
836 55, 55, 55, 55, 55, 55, 55, 55, 63, 63, 63, 63, 63, 63, 63, 63,
837 7, 7, 7, 7, 7, 7, 7, 7, 15, 15, 15, 15, 15, 15, 15, 15,
838 23, 23, 23, 23, 23, 23, 23, 23, 31, 31, 31, 31, 31, 31, 31, 31,
839 39, 39, 39, 39, 39, 39, 39, 39, 47, 47, 47, 47, 47, 47, 47, 47,
840 55, 55, 55, 55, 55, 55, 55, 55, 63, 63, 63, 63, 63, 63, 63, 63,
841 131,131,131,131,131,131,131,131,139,139,139,139,139,139,139,139,
842 147,147,147,147,147,147,147,147,155,155,155,155,155,155,155,155,
843 163,163,163,163,163,163,163,163,171,171,171,171,171,171,171,171,
844 179,179,179,179,179,179,179,179,187,187,187,187,187,187,187,187,
845 131,131,131,131,131,131,131,131,139,139,139,139,139,139,139,139,
846 147,147,147,147,147,147,147,147,155,155,155,155,155,155,155,155,
847 163,163,163,163,163,163,163,163,171,171,171,171,171,171,171,171,
848 179,179,179,179,179,179,179,179,187,187,187,187,187,187,187,187,
851 /* negTable[i] = (((i & 0x0f) != 0) << 4) | ((i == 0x80) << 2) | 2 | (i != 0), i = 0..255 */
852 static const uint8 negTable
[256] = {
853 2,19,19,19,19,19,19,19,19,19,19,19,19,19,19,19,
854 3,19,19,19,19,19,19,19,19,19,19,19,19,19,19,19,
855 3,19,19,19,19,19,19,19,19,19,19,19,19,19,19,19,
856 3,19,19,19,19,19,19,19,19,19,19,19,19,19,19,19,
857 3,19,19,19,19,19,19,19,19,19,19,19,19,19,19,19,
858 3,19,19,19,19,19,19,19,19,19,19,19,19,19,19,19,
859 3,19,19,19,19,19,19,19,19,19,19,19,19,19,19,19,
860 3,19,19,19,19,19,19,19,19,19,19,19,19,19,19,19,
861 7,19,19,19,19,19,19,19,19,19,19,19,19,19,19,19,
862 3,19,19,19,19,19,19,19,19,19,19,19,19,19,19,19,
863 3,19,19,19,19,19,19,19,19,19,19,19,19,19,19,19,
864 3,19,19,19,19,19,19,19,19,19,19,19,19,19,19,19,
865 3,19,19,19,19,19,19,19,19,19,19,19,19,19,19,19,
866 3,19,19,19,19,19,19,19,19,19,19,19,19,19,19,19,
867 3,19,19,19,19,19,19,19,19,19,19,19,19,19,19,19,
868 3,19,19,19,19,19,19,19,19,19,19,19,19,19,19,19,
871 /* rrdrldTable[i] = (i << 8) | (i & 0xa8) | (((i & 0xff) == 0) << 6) | parityTable[i], i = 0..255 */
872 static const uint16 rrdrldTable
[256] = {
873 0x0044,0x0100,0x0200,0x0304,0x0400,0x0504,0x0604,0x0700,
874 0x0808,0x090c,0x0a0c,0x0b08,0x0c0c,0x0d08,0x0e08,0x0f0c,
875 0x1000,0x1104,0x1204,0x1300,0x1404,0x1500,0x1600,0x1704,
876 0x180c,0x1908,0x1a08,0x1b0c,0x1c08,0x1d0c,0x1e0c,0x1f08,
877 0x2020,0x2124,0x2224,0x2320,0x2424,0x2520,0x2620,0x2724,
878 0x282c,0x2928,0x2a28,0x2b2c,0x2c28,0x2d2c,0x2e2c,0x2f28,
879 0x3024,0x3120,0x3220,0x3324,0x3420,0x3524,0x3624,0x3720,
880 0x3828,0x392c,0x3a2c,0x3b28,0x3c2c,0x3d28,0x3e28,0x3f2c,
881 0x4000,0x4104,0x4204,0x4300,0x4404,0x4500,0x4600,0x4704,
882 0x480c,0x4908,0x4a08,0x4b0c,0x4c08,0x4d0c,0x4e0c,0x4f08,
883 0x5004,0x5100,0x5200,0x5304,0x5400,0x5504,0x5604,0x5700,
884 0x5808,0x590c,0x5a0c,0x5b08,0x5c0c,0x5d08,0x5e08,0x5f0c,
885 0x6024,0x6120,0x6220,0x6324,0x6420,0x6524,0x6624,0x6720,
886 0x6828,0x692c,0x6a2c,0x6b28,0x6c2c,0x6d28,0x6e28,0x6f2c,
887 0x7020,0x7124,0x7224,0x7320,0x7424,0x7520,0x7620,0x7724,
888 0x782c,0x7928,0x7a28,0x7b2c,0x7c28,0x7d2c,0x7e2c,0x7f28,
889 0x8080,0x8184,0x8284,0x8380,0x8484,0x8580,0x8680,0x8784,
890 0x888c,0x8988,0x8a88,0x8b8c,0x8c88,0x8d8c,0x8e8c,0x8f88,
891 0x9084,0x9180,0x9280,0x9384,0x9480,0x9584,0x9684,0x9780,
892 0x9888,0x998c,0x9a8c,0x9b88,0x9c8c,0x9d88,0x9e88,0x9f8c,
893 0xa0a4,0xa1a0,0xa2a0,0xa3a4,0xa4a0,0xa5a4,0xa6a4,0xa7a0,
894 0xa8a8,0xa9ac,0xaaac,0xaba8,0xacac,0xada8,0xaea8,0xafac,
895 0xb0a0,0xb1a4,0xb2a4,0xb3a0,0xb4a4,0xb5a0,0xb6a0,0xb7a4,
896 0xb8ac,0xb9a8,0xbaa8,0xbbac,0xbca8,0xbdac,0xbeac,0xbfa8,
897 0xc084,0xc180,0xc280,0xc384,0xc480,0xc584,0xc684,0xc780,
898 0xc888,0xc98c,0xca8c,0xcb88,0xcc8c,0xcd88,0xce88,0xcf8c,
899 0xd080,0xd184,0xd284,0xd380,0xd484,0xd580,0xd680,0xd784,
900 0xd88c,0xd988,0xda88,0xdb8c,0xdc88,0xdd8c,0xde8c,0xdf88,
901 0xe0a0,0xe1a4,0xe2a4,0xe3a0,0xe4a4,0xe5a0,0xe6a0,0xe7a4,
902 0xe8ac,0xe9a8,0xeaa8,0xebac,0xeca8,0xedac,0xeeac,0xefa8,
903 0xf0a4,0xf1a0,0xf2a0,0xf3a4,0xf4a0,0xf5a4,0xf6a4,0xf7a0,
904 0xf8a8,0xf9ac,0xfaac,0xfba8,0xfcac,0xfda8,0xfea8,0xffac,
907 /* cpTable[i] = (i & 0x80) | (((i & 0xff) == 0) << 6), i = 0..255 */
908 static const uint8 cpTable
[256] = {
909 64, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
910 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
911 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
912 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
913 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
914 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
915 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
916 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
917 128,128,128,128,128,128,128,128,128,128,128,128,128,128,128,128,
918 128,128,128,128,128,128,128,128,128,128,128,128,128,128,128,128,
919 128,128,128,128,128,128,128,128,128,128,128,128,128,128,128,128,
920 128,128,128,128,128,128,128,128,128,128,128,128,128,128,128,128,
921 128,128,128,128,128,128,128,128,128,128,128,128,128,128,128,128,
922 128,128,128,128,128,128,128,128,128,128,128,128,128,128,128,128,
923 128,128,128,128,128,128,128,128,128,128,128,128,128,128,128,128,
924 128,128,128,128,128,128,128,128,128,128,128,128,128,128,128,128,
927 /* Memory management */
929 uint8 MOPT
[MAXBANKSIZE
]; /* RAM which is present */
931 static uint8
GET_BYTE(register uint32 Addr
) {
932 return MOPT
[Addr
& ADDRMASK
];
935 static void PUT_BYTE(register uint32 Addr
, register uint32 Value
) {
936 MOPT
[Addr
& ADDRMASK
] = Value
;
939 static void PUT_WORD(register uint32 Addr
, register uint32 Value
) {
940 MOPT
[Addr
& ADDRMASK
] = Value
;
941 MOPT
[(Addr
+ 1) & ADDRMASK
] = Value
>> 8;
944 static uint16
GET_WORD(register uint32 a
) {
945 return GET_BYTE(a
) | (GET_BYTE(a
+ 1) << 8);
948 #define RAM_MM(a) GET_BYTE(a--)
949 #define RAM_PP(a) GET_BYTE(a++)
951 #define PUT_BYTE_PP(a,v) PUT_BYTE(a++, v)
952 #define PUT_BYTE_MM(a,v) PUT_BYTE(a--, v)
953 #define MM_PUT_BYTE(a,v) PUT_BYTE(--a, v)
955 #define PUSH(x) do { \
956 MM_PUT_BYTE(SP, (x) >> 8); \
957 MM_PUT_BYTE(SP, x); \
960 /* Macros for the IN/OUT instructions INI/INIR/IND/INDR/OUTI/OTIR/OUTD/OTDR
963 temp == value of register B at entry of the instruction
964 acu == value of transferred byte (IN or OUT)
968 Use INOUTFLAGS_ZERO(x) for INIR/INDR/OTIR/OTDR where
969 x == (C + 1) & 0xff for INIR
970 x == L for OTIR and OTDR
971 x == (C - 1) & 0xff for INDR
972 Use INOUTFLAGS_NONZERO(x) for INI/IND/OUTI/OUTD where
973 x == (C + 1) & 0xff for INI
974 x == L for OUTI and OUTD
975 x == (C - 1) & 0xff for IND
977 #define INOUTFLAGS(syxz, x) \
978 AF = (AF & 0xff00) | (syxz) | /* SF, YF, XF, ZF */ \
979 ((acu & 0x80) >> 6) | /* NF */ \
980 ((acu + (x)) > 0xff ? (FLAG_C | FLAG_H) : 0) | /* CF, HF */ \
981 parityTable[((acu + (x)) & 7) ^ temp] /* PF */
983 #define INOUTFLAGS_ZERO(x) INOUTFLAGS(FLAG_Z, x)
984 #define INOUTFLAGS_NONZERO(x) \
985 INOUTFLAGS((HIGH_REGISTER(BC) & 0xa8) | ((HIGH_REGISTER(BC) == 0) << 6), x)
987 t_stat
sim_instr_nommu(void) {
988 extern int32 sim_interval
;
989 extern uint32 sim_brk_summ
;
999 register uint32 temp
= 0;
1000 register uint32 acu
= 0;
1001 register uint32 sum
;
1002 register uint32 cbits
;
1004 register uint32 adr
;
1005 register int32 l_sim_brk_summ
;
1011 PC
= PC_S
& ADDRMASK
;
1015 l_sim_brk_summ
= sim_brk_summ
;
1017 /* main instruction fetch/decode loop */
1018 while (TRUE
) { /* loop until halted */
1019 if (sim_interval
<= 0) { /* check clock queue */
1021 if ((reason
= sim_poll_kbd()) == SCPE_STOP
) break; /* poll on platforms without reliable signalling */
1023 if ((reason
= sim_process_event())) break;
1026 if (l_sim_brk_summ
&& sim_brk_test(PC
, SWMASK('E'))) {/* breakpoint? */
1027 reason
= STOP_IBKPT
; /* stop simulation */
1034 switch(RAM_PP(PC
)) {
1036 case 0x00: /* NOP */
1039 case 0x01: /* LD BC,nnnn */
1044 case 0x02: /* LD (BC),A */
1045 PUT_BYTE(BC
, HIGH_REGISTER(AF
));
1048 case 0x03: /* INC BC */
1052 case 0x04: /* INC B */
1054 temp
= HIGH_REGISTER(BC
);
1055 AF
= (AF
& ~0xfe) | incTable
[temp
] | SET_PV2(0x80); /* SET_PV2 uses temp */
1058 case 0x05: /* DEC B */
1060 temp
= HIGH_REGISTER(BC
);
1061 AF
= (AF
& ~0xfe) | decTable
[temp
] | SET_PV2(0x7f); /* SET_PV2 uses temp */
1064 case 0x06: /* LD B,nn */
1065 SET_HIGH_REGISTER(BC
, RAM_PP(PC
));
1068 case 0x07: /* RLCA */
1069 AF
= ((AF
>> 7) & 0x0128) | ((AF
<< 1) & ~0x1ff) |
1070 (AF
& 0xc4) | ((AF
>> 15) & 1);
1073 case 0x08: /* EX AF,AF' */
1080 case 0x09: /* ADD HL,BC */
1084 AF
= (AF
& ~0x3b) | ((sum
>> 8) & 0x28) | cbitsTable
[(HL
^ BC
^ sum
) >> 8];
1088 case 0x0a: /* LD A,(BC) */
1089 SET_HIGH_REGISTER(AF
, GET_BYTE(BC
));
1092 case 0x0b: /* DEC BC */
1096 case 0x0c: /* INC C */
1097 temp
= LOW_REGISTER(BC
) + 1;
1098 SET_LOW_REGISTER(BC
, temp
);
1099 AF
= (AF
& ~0xfe) | incTable
[temp
] | SET_PV2(0x80);
1102 case 0x0d: /* DEC C */
1103 temp
= LOW_REGISTER(BC
) - 1;
1104 SET_LOW_REGISTER(BC
, temp
);
1105 AF
= (AF
& ~0xfe) | decTable
[temp
& 0xff] | SET_PV2(0x7f);
1108 case 0x0e: /* LD C,nn */
1109 SET_LOW_REGISTER(BC
, RAM_PP(PC
));
1112 case 0x0f: /* RRCA */
1113 AF
= (AF
& 0xc4) | rrcaTable
[HIGH_REGISTER(AF
)];
1116 case 0x10: /* DJNZ dd */
1118 if ((BC
-= 0x100) & 0xff00) PC
+= (int8
) GET_BYTE(PC
) + 1;
1122 case 0x11: /* LD DE,nnnn */
1127 case 0x12: /* LD (DE),A */
1128 PUT_BYTE(DE
, HIGH_REGISTER(AF
));
1131 case 0x13: /* INC DE */
1135 case 0x14: /* INC D */
1137 temp
= HIGH_REGISTER(DE
);
1138 AF
= (AF
& ~0xfe) | incTable
[temp
] | SET_PV2(0x80); /* SET_PV2 uses temp */
1141 case 0x15: /* DEC D */
1143 temp
= HIGH_REGISTER(DE
);
1144 AF
= (AF
& ~0xfe) | decTable
[temp
] | SET_PV2(0x7f); /* SET_PV2 uses temp */
1147 case 0x16: /* LD D,nn */
1148 SET_HIGH_REGISTER(DE
, RAM_PP(PC
));
1151 case 0x17: /* RLA */
1152 AF
= ((AF
<< 8) & 0x0100) | ((AF
>> 7) & 0x28) | ((AF
<< 1) & ~0x01ff) |
1153 (AF
& 0xc4) | ((AF
>> 15) & 1);
1156 case 0x18: /* JR dd */
1158 PC
+= (int8
) GET_BYTE(PC
) + 1;
1161 case 0x19: /* ADD HL,DE */
1165 AF
= (AF
& ~0x3b) | ((sum
>> 8) & 0x28) | cbitsTable
[(HL
^ DE
^ sum
) >> 8];
1169 case 0x1a: /* LD A,(DE) */
1170 SET_HIGH_REGISTER(AF
, GET_BYTE(DE
));
1173 case 0x1b: /* DEC DE */
1177 case 0x1c: /* INC E */
1178 temp
= LOW_REGISTER(DE
) + 1;
1179 SET_LOW_REGISTER(DE
, temp
);
1180 AF
= (AF
& ~0xfe) | incTable
[temp
] | SET_PV2(0x80);
1183 case 0x1d: /* DEC E */
1184 temp
= LOW_REGISTER(DE
) - 1;
1185 SET_LOW_REGISTER(DE
, temp
);
1186 AF
= (AF
& ~0xfe) | decTable
[temp
& 0xff] | SET_PV2(0x7f);
1189 case 0x1e: /* LD E,nn */
1190 SET_LOW_REGISTER(DE
, RAM_PP(PC
));
1193 case 0x1f: /* RRA */
1194 AF
= ((AF
& 1) << 15) | (AF
& 0xc4) | rraTable
[HIGH_REGISTER(AF
)];
1197 case 0x20: /* JR NZ,dd */
1199 if (TSTFLAG(Z
)) PC
++;
1200 else PC
+= (int8
) GET_BYTE(PC
) + 1;
1203 case 0x21: /* LD HL,nnnn */
1208 case 0x22: /* LD (nnnn),HL */
1209 temp
= GET_WORD(PC
);
1214 case 0x23: /* INC HL */
1218 case 0x24: /* INC H */
1220 temp
= HIGH_REGISTER(HL
);
1221 AF
= (AF
& ~0xfe) | incTable
[temp
] | SET_PV2(0x80); /* SET_PV2 uses temp */
1224 case 0x25: /* DEC H */
1226 temp
= HIGH_REGISTER(HL
);
1227 AF
= (AF
& ~0xfe) | decTable
[temp
] | SET_PV2(0x7f); /* SET_PV2 uses temp */
1230 case 0x26: /* LD H,nn */
1231 SET_HIGH_REGISTER(HL
, RAM_PP(PC
));
1234 case 0x27: /* DAA */
1235 acu
= HIGH_REGISTER(AF
);
1236 temp
= LOW_DIGIT(acu
);
1238 if (TSTFLAG(N
)) { /* last operation was a subtract */
1239 int hd
= cbits
|| acu
> 0x99;
1240 if (TSTFLAG(H
) || (temp
> 9)) { /* adjust low digit */
1241 if (temp
> 5) SETFLAG(H
, 0);
1245 if (hd
) acu
-= 0x160; /* adjust high digit */
1247 else { /* last operation was an add */
1248 if (TSTFLAG(H
) || (temp
> 9)) { /* adjust low digit */
1249 SETFLAG(H
, (temp
> 9));
1252 if (cbits
|| ((acu
& 0x1f0) > 0x90)) acu
+= 0x60; /* adjust high digit */
1254 AF
= (AF
& 0x12) | rrdrldTable
[acu
& 0xff] | ((acu
>> 8) & 1) | cbits
;
1257 case 0x28: /* JR Z,dd */
1259 if (TSTFLAG(Z
)) PC
+= (int8
) GET_BYTE(PC
) + 1;
1263 case 0x29: /* ADD HL,HL */
1266 AF
= (AF
& ~0x3b) | cbitsDup16Table
[sum
>> 8];
1270 case 0x2a: /* LD HL,(nnnn) */
1271 temp
= GET_WORD(PC
);
1272 HL
= GET_WORD(temp
);
1276 case 0x2b: /* DEC HL */
1280 case 0x2c: /* INC L */
1281 temp
= LOW_REGISTER(HL
) + 1;
1282 SET_LOW_REGISTER(HL
, temp
);
1283 AF
= (AF
& ~0xfe) | incTable
[temp
] | SET_PV2(0x80);
1286 case 0x2d: /* DEC L */
1287 temp
= LOW_REGISTER(HL
) - 1;
1288 SET_LOW_REGISTER(HL
, temp
);
1289 AF
= (AF
& ~0xfe) | decTable
[temp
& 0xff] | SET_PV2(0x7f);
1292 case 0x2e: /* LD L,nn */
1293 SET_LOW_REGISTER(HL
, RAM_PP(PC
));
1296 case 0x2f: /* CPL */
1297 AF
= (~AF
& ~0xff) | (AF
& 0xc5) | ((~AF
>> 8) & 0x28) | 0x12;
1300 case 0x30: /* JR NC,dd */
1302 if (TSTFLAG(C
)) PC
++;
1303 else PC
+= (int8
) GET_BYTE(PC
) + 1;
1306 case 0x31: /* LD SP,nnnn */
1311 case 0x32: /* LD (nnnn),A */
1312 temp
= GET_WORD(PC
);
1313 PUT_BYTE(temp
, HIGH_REGISTER(AF
));
1317 case 0x33: /* INC SP */
1321 case 0x34: /* INC (HL) */
1322 temp
= GET_BYTE(HL
) + 1;
1324 AF
= (AF
& ~0xfe) | incTable
[temp
] | SET_PV2(0x80);
1327 case 0x35: /* DEC (HL) */
1328 temp
= GET_BYTE(HL
) - 1;
1330 AF
= (AF
& ~0xfe) | decTable
[temp
& 0xff] | SET_PV2(0x7f);
1333 case 0x36: /* LD (HL),nn */
1334 PUT_BYTE(HL
, RAM_PP(PC
));
1337 case 0x37: /* SCF */
1338 AF
= (AF
& ~0x3b) | ((AF
>> 8) & 0x28) | 1;
1341 case 0x38: /* JR C,dd */
1343 if (TSTFLAG(C
)) PC
+= (int8
) GET_BYTE(PC
) + 1;
1347 case 0x39: /* ADD HL,SP */
1351 AF
= (AF
& ~0x3b) | ((sum
>> 8) & 0x28) | cbitsTable
[(HL
^ SP
^ sum
) >> 8];
1355 case 0x3a: /* LD A,(nnnn) */
1356 temp
= GET_WORD(PC
);
1357 SET_HIGH_REGISTER(AF
, GET_BYTE(temp
));
1361 case 0x3b: /* DEC SP */
1365 case 0x3c: /* INC A */
1367 temp
= HIGH_REGISTER(AF
);
1368 AF
= (AF
& ~0xfe) | incTable
[temp
] | SET_PV2(0x80); /* SET_PV2 uses temp */
1371 case 0x3d: /* DEC A */
1373 temp
= HIGH_REGISTER(AF
);
1374 AF
= (AF
& ~0xfe) | decTable
[temp
] | SET_PV2(0x7f); /* SET_PV2 uses temp */
1377 case 0x3e: /* LD A,nn */
1378 SET_HIGH_REGISTER(AF
, RAM_PP(PC
));
1381 case 0x3f: /* CCF */
1382 AF
= (AF
& ~0x3b) | ((AF
>> 8) & 0x28) | ((AF
& 1) << 4) | (~AF
& 1);
1385 case 0x40: /* LD B,B */
1388 case 0x41: /* LD B,C */
1389 BC
= (BC
& 0xff) | ((BC
& 0xff) << 8);
1392 case 0x42: /* LD B,D */
1393 BC
= (BC
& 0xff) | (DE
& ~0xff);
1396 case 0x43: /* LD B,E */
1397 BC
= (BC
& 0xff) | ((DE
& 0xff) << 8);
1400 case 0x44: /* LD B,H */
1401 BC
= (BC
& 0xff) | (HL
& ~0xff);
1404 case 0x45: /* LD B,L */
1405 BC
= (BC
& 0xff) | ((HL
& 0xff) << 8);
1408 case 0x46: /* LD B,(HL) */
1409 SET_HIGH_REGISTER(BC
, GET_BYTE(HL
));
1412 case 0x47: /* LD B,A */
1413 BC
= (BC
& 0xff) | (AF
& ~0xff);
1416 case 0x48: /* LD C,B */
1417 BC
= (BC
& ~0xff) | ((BC
>> 8) & 0xff);
1420 case 0x49: /* LD C,C */
1423 case 0x4a: /* LD C,D */
1424 BC
= (BC
& ~0xff) | ((DE
>> 8) & 0xff);
1427 case 0x4b: /* LD C,E */
1428 BC
= (BC
& ~0xff) | (DE
& 0xff);
1431 case 0x4c: /* LD C,H */
1432 BC
= (BC
& ~0xff) | ((HL
>> 8) & 0xff);
1435 case 0x4d: /* LD C,L */
1436 BC
= (BC
& ~0xff) | (HL
& 0xff);
1439 case 0x4e: /* LD C,(HL) */
1440 SET_LOW_REGISTER(BC
, GET_BYTE(HL
));
1443 case 0x4f: /* LD C,A */
1444 BC
= (BC
& ~0xff) | ((AF
>> 8) & 0xff);
1447 case 0x50: /* LD D,B */
1448 DE
= (DE
& 0xff) | (BC
& ~0xff);
1451 case 0x51: /* LD D,C */
1452 DE
= (DE
& 0xff) | ((BC
& 0xff) << 8);
1455 case 0x52: /* LD D,D */
1458 case 0x53: /* LD D,E */
1459 DE
= (DE
& 0xff) | ((DE
& 0xff) << 8);
1462 case 0x54: /* LD D,H */
1463 DE
= (DE
& 0xff) | (HL
& ~0xff);
1466 case 0x55: /* LD D,L */
1467 DE
= (DE
& 0xff) | ((HL
& 0xff) << 8);
1470 case 0x56: /* LD D,(HL) */
1471 SET_HIGH_REGISTER(DE
, GET_BYTE(HL
));
1474 case 0x57: /* LD D,A */
1475 DE
= (DE
& 0xff) | (AF
& ~0xff);
1478 case 0x58: /* LD E,B */
1479 DE
= (DE
& ~0xff) | ((BC
>> 8) & 0xff);
1482 case 0x59: /* LD E,C */
1483 DE
= (DE
& ~0xff) | (BC
& 0xff);
1486 case 0x5a: /* LD E,D */
1487 DE
= (DE
& ~0xff) | ((DE
>> 8) & 0xff);
1490 case 0x5b: /* LD E,E */
1493 case 0x5c: /* LD E,H */
1494 DE
= (DE
& ~0xff) | ((HL
>> 8) & 0xff);
1497 case 0x5d: /* LD E,L */
1498 DE
= (DE
& ~0xff) | (HL
& 0xff);
1501 case 0x5e: /* LD E,(HL) */
1502 SET_LOW_REGISTER(DE
, GET_BYTE(HL
));
1505 case 0x5f: /* LD E,A */
1506 DE
= (DE
& ~0xff) | ((AF
>> 8) & 0xff);
1509 case 0x60: /* LD H,B */
1510 HL
= (HL
& 0xff) | (BC
& ~0xff);
1513 case 0x61: /* LD H,C */
1514 HL
= (HL
& 0xff) | ((BC
& 0xff) << 8);
1517 case 0x62: /* LD H,D */
1518 HL
= (HL
& 0xff) | (DE
& ~0xff);
1521 case 0x63: /* LD H,E */
1522 HL
= (HL
& 0xff) | ((DE
& 0xff) << 8);
1525 case 0x64: /* LD H,H */
1528 case 0x65: /* LD H,L */
1529 HL
= (HL
& 0xff) | ((HL
& 0xff) << 8);
1532 case 0x66: /* LD H,(HL) */
1533 SET_HIGH_REGISTER(HL
, GET_BYTE(HL
));
1536 case 0x67: /* LD H,A */
1537 HL
= (HL
& 0xff) | (AF
& ~0xff);
1540 case 0x68: /* LD L,B */
1541 HL
= (HL
& ~0xff) | ((BC
>> 8) & 0xff);
1544 case 0x69: /* LD L,C */
1545 HL
= (HL
& ~0xff) | (BC
& 0xff);
1548 case 0x6a: /* LD L,D */
1549 HL
= (HL
& ~0xff) | ((DE
>> 8) & 0xff);
1552 case 0x6b: /* LD L,E */
1553 HL
= (HL
& ~0xff) | (DE
& 0xff);
1556 case 0x6c: /* LD L,H */
1557 HL
= (HL
& ~0xff) | ((HL
>> 8) & 0xff);
1560 case 0x6d: /* LD L,L */
1563 case 0x6e: /* LD L,(HL) */
1564 SET_LOW_REGISTER(HL
, GET_BYTE(HL
));
1567 case 0x6f: /* LD L,A */
1568 HL
= (HL
& ~0xff) | ((AF
>> 8) & 0xff);
1571 case 0x70: /* LD (HL),B */
1572 PUT_BYTE(HL
, HIGH_REGISTER(BC
));
1575 case 0x71: /* LD (HL),C */
1576 PUT_BYTE(HL
, LOW_REGISTER(BC
));
1579 case 0x72: /* LD (HL),D */
1580 PUT_BYTE(HL
, HIGH_REGISTER(DE
));
1583 case 0x73: /* LD (HL),E */
1584 PUT_BYTE(HL
, LOW_REGISTER(DE
));
1587 case 0x74: /* LD (HL),H */
1588 PUT_BYTE(HL
, HIGH_REGISTER(HL
));
1591 case 0x75: /* LD (HL),L */
1592 PUT_BYTE(HL
, LOW_REGISTER(HL
));
1595 case 0x76: /* HALT */
1597 if (cpu_unit
.flags
& UNIT_CPU_STOPONHALT
) {
1604 case 0x77: /* LD (HL),A */
1605 PUT_BYTE(HL
, HIGH_REGISTER(AF
));
1608 case 0x78: /* LD A,B */
1609 AF
= (AF
& 0xff) | (BC
& ~0xff);
1612 case 0x79: /* LD A,C */
1613 AF
= (AF
& 0xff) | ((BC
& 0xff) << 8);
1616 case 0x7a: /* LD A,D */
1617 AF
= (AF
& 0xff) | (DE
& ~0xff);
1620 case 0x7b: /* LD A,E */
1621 AF
= (AF
& 0xff) | ((DE
& 0xff) << 8);
1624 case 0x7c: /* LD A,H */
1625 AF
= (AF
& 0xff) | (HL
& ~0xff);
1628 case 0x7d: /* LD A,L */
1629 AF
= (AF
& 0xff) | ((HL
& 0xff) << 8);
1632 case 0x7e: /* LD A,(HL) */
1633 SET_HIGH_REGISTER(AF
, GET_BYTE(HL
));
1636 case 0x7f: /* LD A,A */
1639 case 0x80: /* ADD A,B */
1640 temp
= HIGH_REGISTER(BC
);
1641 acu
= HIGH_REGISTER(AF
);
1643 cbits
= acu
^ temp
^ sum
;
1644 AF
= addTable
[sum
] | cbitsTable
[cbits
] | (SET_PV
);
1647 case 0x81: /* ADD A,C */
1648 temp
= LOW_REGISTER(BC
);
1649 acu
= HIGH_REGISTER(AF
);
1651 cbits
= acu
^ temp
^ sum
;
1652 AF
= addTable
[sum
] | cbitsTable
[cbits
] | (SET_PV
);
1655 case 0x82: /* ADD A,D */
1656 temp
= HIGH_REGISTER(DE
);
1657 acu
= HIGH_REGISTER(AF
);
1659 cbits
= acu
^ temp
^ sum
;
1660 AF
= addTable
[sum
] | cbitsTable
[cbits
] | (SET_PV
);
1663 case 0x83: /* ADD A,E */
1664 temp
= LOW_REGISTER(DE
);
1665 acu
= HIGH_REGISTER(AF
);
1667 cbits
= acu
^ temp
^ sum
;
1668 AF
= addTable
[sum
] | cbitsTable
[cbits
] | (SET_PV
);
1671 case 0x84: /* ADD A,H */
1672 temp
= HIGH_REGISTER(HL
);
1673 acu
= HIGH_REGISTER(AF
);
1675 cbits
= acu
^ temp
^ sum
;
1676 AF
= addTable
[sum
] | cbitsTable
[cbits
] | (SET_PV
);
1679 case 0x85: /* ADD A,L */
1680 temp
= LOW_REGISTER(HL
);
1681 acu
= HIGH_REGISTER(AF
);
1683 cbits
= acu
^ temp
^ sum
;
1684 AF
= addTable
[sum
] | cbitsTable
[cbits
] | (SET_PV
);
1687 case 0x86: /* ADD A,(HL) */
1688 temp
= GET_BYTE(HL
);
1689 acu
= HIGH_REGISTER(AF
);
1691 cbits
= acu
^ temp
^ sum
;
1692 AF
= addTable
[sum
] | cbitsTable
[cbits
] | (SET_PV
);
1695 case 0x87: /* ADD A,A */
1696 cbits
= 2 * HIGH_REGISTER(AF
);
1697 AF
= cbitsDup8Table
[cbits
] | (SET_PVS(cbits
));
1700 case 0x88: /* ADC A,B */
1701 temp
= HIGH_REGISTER(BC
);
1702 acu
= HIGH_REGISTER(AF
);
1703 sum
= acu
+ temp
+ TSTFLAG(C
);
1704 cbits
= acu
^ temp
^ sum
;
1705 AF
= addTable
[sum
] | cbitsTable
[cbits
] | (SET_PV
);
1708 case 0x89: /* ADC A,C */
1709 temp
= LOW_REGISTER(BC
);
1710 acu
= HIGH_REGISTER(AF
);
1711 sum
= acu
+ temp
+ TSTFLAG(C
);
1712 cbits
= acu
^ temp
^ sum
;
1713 AF
= addTable
[sum
] | cbitsTable
[cbits
] | (SET_PV
);
1716 case 0x8a: /* ADC A,D */
1717 temp
= HIGH_REGISTER(DE
);
1718 acu
= HIGH_REGISTER(AF
);
1719 sum
= acu
+ temp
+ TSTFLAG(C
);
1720 cbits
= acu
^ temp
^ sum
;
1721 AF
= addTable
[sum
] | cbitsTable
[cbits
] | (SET_PV
);
1724 case 0x8b: /* ADC A,E */
1725 temp
= LOW_REGISTER(DE
);
1726 acu
= HIGH_REGISTER(AF
);
1727 sum
= acu
+ temp
+ TSTFLAG(C
);
1728 cbits
= acu
^ temp
^ sum
;
1729 AF
= addTable
[sum
] | cbitsTable
[cbits
] | (SET_PV
);
1732 case 0x8c: /* ADC A,H */
1733 temp
= HIGH_REGISTER(HL
);
1734 acu
= HIGH_REGISTER(AF
);
1735 sum
= acu
+ temp
+ TSTFLAG(C
);
1736 cbits
= acu
^ temp
^ sum
;
1737 AF
= addTable
[sum
] | cbitsTable
[cbits
] | (SET_PV
);
1740 case 0x8d: /* ADC A,L */
1741 temp
= LOW_REGISTER(HL
);
1742 acu
= HIGH_REGISTER(AF
);
1743 sum
= acu
+ temp
+ TSTFLAG(C
);
1744 cbits
= acu
^ temp
^ sum
;
1745 AF
= addTable
[sum
] | cbitsTable
[cbits
] | (SET_PV
);
1748 case 0x8e: /* ADC A,(HL) */
1749 temp
= GET_BYTE(HL
);
1750 acu
= HIGH_REGISTER(AF
);
1751 sum
= acu
+ temp
+ TSTFLAG(C
);
1752 cbits
= acu
^ temp
^ sum
;
1753 AF
= addTable
[sum
] | cbitsTable
[cbits
] | (SET_PV
);
1756 case 0x8f: /* ADC A,A */
1757 cbits
= 2 * HIGH_REGISTER(AF
) + TSTFLAG(C
);
1758 AF
= cbitsDup8Table
[cbits
] | (SET_PVS(cbits
));
1761 case 0x90: /* SUB B */
1762 temp
= HIGH_REGISTER(BC
);
1763 acu
= HIGH_REGISTER(AF
);
1765 cbits
= acu
^ temp
^ sum
;
1766 AF
= subTable
[sum
& 0xff] | cbitsTable
[cbits
& 0x1ff] | (SET_PV
);
1769 case 0x91: /* SUB C */
1770 temp
= LOW_REGISTER(BC
);
1771 acu
= HIGH_REGISTER(AF
);
1773 cbits
= acu
^ temp
^ sum
;
1774 AF
= subTable
[sum
& 0xff] | cbitsTable
[cbits
& 0x1ff] | (SET_PV
);
1777 case 0x92: /* SUB D */
1778 temp
= HIGH_REGISTER(DE
);
1779 acu
= HIGH_REGISTER(AF
);
1781 cbits
= acu
^ temp
^ sum
;
1782 AF
= subTable
[sum
& 0xff] | cbitsTable
[cbits
& 0x1ff] | (SET_PV
);
1785 case 0x93: /* SUB E */
1786 temp
= LOW_REGISTER(DE
);
1787 acu
= HIGH_REGISTER(AF
);
1789 cbits
= acu
^ temp
^ sum
;
1790 AF
= subTable
[sum
& 0xff] | cbitsTable
[cbits
& 0x1ff] | (SET_PV
);
1793 case 0x94: /* SUB H */
1794 temp
= HIGH_REGISTER(HL
);
1795 acu
= HIGH_REGISTER(AF
);
1797 cbits
= acu
^ temp
^ sum
;
1798 AF
= subTable
[sum
& 0xff] | cbitsTable
[cbits
& 0x1ff] | (SET_PV
);
1801 case 0x95: /* SUB L */
1802 temp
= LOW_REGISTER(HL
);
1803 acu
= HIGH_REGISTER(AF
);
1805 cbits
= acu
^ temp
^ sum
;
1806 AF
= subTable
[sum
& 0xff] | cbitsTable
[cbits
& 0x1ff] | (SET_PV
);
1809 case 0x96: /* SUB (HL) */
1810 temp
= GET_BYTE(HL
);
1811 acu
= HIGH_REGISTER(AF
);
1813 cbits
= acu
^ temp
^ sum
;
1814 AF
= subTable
[sum
& 0xff] | cbitsTable
[cbits
& 0x1ff] | (SET_PV
);
1817 case 0x97: /* SUB A */
1818 AF
= (chiptype
== CHIP_TYPE_Z80
) ? 0x42 : 0x46;
1821 case 0x98: /* SBC A,B */
1822 temp
= HIGH_REGISTER(BC
);
1823 acu
= HIGH_REGISTER(AF
);
1824 sum
= acu
- temp
- TSTFLAG(C
);
1825 cbits
= acu
^ temp
^ sum
;
1826 AF
= subTable
[sum
& 0xff] | cbitsTable
[cbits
& 0x1ff] | (SET_PV
);
1829 case 0x99: /* SBC A,C */
1830 temp
= LOW_REGISTER(BC
);
1831 acu
= HIGH_REGISTER(AF
);
1832 sum
= acu
- temp
- TSTFLAG(C
);
1833 cbits
= acu
^ temp
^ sum
;
1834 AF
= subTable
[sum
& 0xff] | cbitsTable
[cbits
& 0x1ff] | (SET_PV
);
1837 case 0x9a: /* SBC A,D */
1838 temp
= HIGH_REGISTER(DE
);
1839 acu
= HIGH_REGISTER(AF
);
1840 sum
= acu
- temp
- TSTFLAG(C
);
1841 cbits
= acu
^ temp
^ sum
;
1842 AF
= subTable
[sum
& 0xff] | cbitsTable
[cbits
& 0x1ff] | (SET_PV
);
1845 case 0x9b: /* SBC A,E */
1846 temp
= LOW_REGISTER(DE
);
1847 acu
= HIGH_REGISTER(AF
);
1848 sum
= acu
- temp
- TSTFLAG(C
);
1849 cbits
= acu
^ temp
^ sum
;
1850 AF
= subTable
[sum
& 0xff] | cbitsTable
[cbits
& 0x1ff] | (SET_PV
);
1853 case 0x9c: /* SBC A,H */
1854 temp
= HIGH_REGISTER(HL
);
1855 acu
= HIGH_REGISTER(AF
);
1856 sum
= acu
- temp
- TSTFLAG(C
);
1857 cbits
= acu
^ temp
^ sum
;
1858 AF
= subTable
[sum
& 0xff] | cbitsTable
[cbits
& 0x1ff] | (SET_PV
);
1861 case 0x9d: /* SBC A,L */
1862 temp
= LOW_REGISTER(HL
);
1863 acu
= HIGH_REGISTER(AF
);
1864 sum
= acu
- temp
- TSTFLAG(C
);
1865 cbits
= acu
^ temp
^ sum
;
1866 AF
= subTable
[sum
& 0xff] | cbitsTable
[cbits
& 0x1ff] | (SET_PV
);
1869 case 0x9e: /* SBC A,(HL) */
1870 temp
= GET_BYTE(HL
);
1871 acu
= HIGH_REGISTER(AF
);
1872 sum
= acu
- temp
- TSTFLAG(C
);
1873 cbits
= acu
^ temp
^ sum
;
1874 AF
= subTable
[sum
& 0xff] | cbitsTable
[cbits
& 0x1ff] | (SET_PV
);
1877 case 0x9f: /* SBC A,A */
1878 cbits
= -TSTFLAG(C
);
1879 AF
= subTable
[cbits
& 0xff] | cbitsTable
[cbits
& 0x1ff] | (SET_PVS(cbits
));
1882 case 0xa0: /* AND B */
1883 AF
= andTable
[((AF
& BC
) >> 8) & 0xff];
1886 case 0xa1: /* AND C */
1887 AF
= andTable
[((AF
>> 8) & BC
) & 0xff];
1890 case 0xa2: /* AND D */
1891 AF
= andTable
[((AF
& DE
) >> 8) & 0xff];
1894 case 0xa3: /* AND E */
1895 AF
= andTable
[((AF
>> 8) & DE
) & 0xff];
1898 case 0xa4: /* AND H */
1899 AF
= andTable
[((AF
& HL
) >> 8) & 0xff];
1902 case 0xa5: /* AND L */
1903 AF
= andTable
[((AF
>> 8) & HL
) & 0xff];
1906 case 0xa6: /* AND (HL) */
1907 AF
= andTable
[((AF
>> 8) & GET_BYTE(HL
)) & 0xff];
1910 case 0xa7: /* AND A */
1911 AF
= andTable
[(AF
>> 8) & 0xff];
1914 case 0xa8: /* XOR B */
1915 AF
= xororTable
[((AF
^ BC
) >> 8) & 0xff];
1918 case 0xa9: /* XOR C */
1919 AF
= xororTable
[((AF
>> 8) ^ BC
) & 0xff];
1922 case 0xaa: /* XOR D */
1923 AF
= xororTable
[((AF
^ DE
) >> 8) & 0xff];
1926 case 0xab: /* XOR E */
1927 AF
= xororTable
[((AF
>> 8) ^ DE
) & 0xff];
1930 case 0xac: /* XOR H */
1931 AF
= xororTable
[((AF
^ HL
) >> 8) & 0xff];
1934 case 0xad: /* XOR L */
1935 AF
= xororTable
[((AF
>> 8) ^ HL
) & 0xff];
1938 case 0xae: /* XOR (HL) */
1939 AF
= xororTable
[((AF
>> 8) ^ GET_BYTE(HL
)) & 0xff];
1942 case 0xaf: /* XOR A */
1946 case 0xb0: /* OR B */
1947 AF
= xororTable
[((AF
| BC
) >> 8) & 0xff];
1950 case 0xb1: /* OR C */
1951 AF
= xororTable
[((AF
>> 8) | BC
) & 0xff];
1954 case 0xb2: /* OR D */
1955 AF
= xororTable
[((AF
| DE
) >> 8) & 0xff];
1958 case 0xb3: /* OR E */
1959 AF
= xororTable
[((AF
>> 8) | DE
) & 0xff];
1962 case 0xb4: /* OR H */
1963 AF
= xororTable
[((AF
| HL
) >> 8) & 0xff];
1966 case 0xb5: /* OR L */
1967 AF
= xororTable
[((AF
>> 8) | HL
) & 0xff];
1970 case 0xb6: /* OR (HL) */
1971 AF
= xororTable
[((AF
>> 8) | GET_BYTE(HL
)) & 0xff];
1974 case 0xb7: /* OR A */
1975 AF
= xororTable
[(AF
>> 8) & 0xff];
1978 case 0xb8: /* CP B */
1979 temp
= HIGH_REGISTER(BC
);
1980 AF
= (AF
& ~0x28) | (temp
& 0x28);
1981 acu
= HIGH_REGISTER(AF
);
1983 cbits
= acu
^ temp
^ sum
;
1984 AF
= (AF
& ~0xff) | cpTable
[sum
& 0xff] | (temp
& 0x28) |
1985 (SET_PV
) | cbits2Table
[cbits
& 0x1ff];
1988 case 0xb9: /* CP C */
1989 temp
= LOW_REGISTER(BC
);
1990 AF
= (AF
& ~0x28) | (temp
& 0x28);
1991 acu
= HIGH_REGISTER(AF
);
1993 cbits
= acu
^ temp
^ sum
;
1994 AF
= (AF
& ~0xff) | cpTable
[sum
& 0xff] | (temp
& 0x28) |
1995 (SET_PV
) | cbits2Table
[cbits
& 0x1ff];
1998 case 0xba: /* CP D */
1999 temp
= HIGH_REGISTER(DE
);
2000 AF
= (AF
& ~0x28) | (temp
& 0x28);
2001 acu
= HIGH_REGISTER(AF
);
2003 cbits
= acu
^ temp
^ sum
;
2004 AF
= (AF
& ~0xff) | cpTable
[sum
& 0xff] | (temp
& 0x28) |
2005 (SET_PV
) | cbits2Table
[cbits
& 0x1ff];
2008 case 0xbb: /* CP E */
2009 temp
= LOW_REGISTER(DE
);
2010 AF
= (AF
& ~0x28) | (temp
& 0x28);
2011 acu
= HIGH_REGISTER(AF
);
2013 cbits
= acu
^ temp
^ sum
;
2014 AF
= (AF
& ~0xff) | cpTable
[sum
& 0xff] | (temp
& 0x28) |
2015 (SET_PV
) | cbits2Table
[cbits
& 0x1ff];
2018 case 0xbc: /* CP H */
2019 temp
= HIGH_REGISTER(HL
);
2020 AF
= (AF
& ~0x28) | (temp
& 0x28);
2021 acu
= HIGH_REGISTER(AF
);
2023 cbits
= acu
^ temp
^ sum
;
2024 AF
= (AF
& ~0xff) | cpTable
[sum
& 0xff] | (temp
& 0x28) |
2025 (SET_PV
) | cbits2Table
[cbits
& 0x1ff];
2028 case 0xbd: /* CP L */
2029 temp
= LOW_REGISTER(HL
);
2030 AF
= (AF
& ~0x28) | (temp
& 0x28);
2031 acu
= HIGH_REGISTER(AF
);
2033 cbits
= acu
^ temp
^ sum
;
2034 AF
= (AF
& ~0xff) | cpTable
[sum
& 0xff] | (temp
& 0x28) |
2035 (SET_PV
) | cbits2Table
[cbits
& 0x1ff];
2038 case 0xbe: /* CP (HL) */
2039 temp
= GET_BYTE(HL
);
2040 AF
= (AF
& ~0x28) | (temp
& 0x28);
2041 acu
= HIGH_REGISTER(AF
);
2043 cbits
= acu
^ temp
^ sum
;
2044 AF
= (AF
& ~0xff) | cpTable
[sum
& 0xff] | (temp
& 0x28) |
2045 (SET_PV
) | cbits2Table
[cbits
& 0x1ff];
2048 case 0xbf: /* CP A */
2049 SET_LOW_REGISTER(AF
, (HIGH_REGISTER(AF
) & 0x28) | (chiptype
== CHIP_TYPE_Z80
? 0x42 : 0x46));
2052 case 0xc0: /* RET NZ */
2053 if (!(TSTFLAG(Z
))) POP(PC
);
2056 case 0xc1: /* POP BC */
2060 case 0xc2: /* JP NZ,nnnn */
2064 case 0xc3: /* JP nnnn */
2068 case 0xc4: /* CALL NZ,nnnn */
2072 case 0xc5: /* PUSH BC */
2076 case 0xc6: /* ADD A,nn */
2078 acu
= HIGH_REGISTER(AF
);
2080 cbits
= acu
^ temp
^ sum
;
2081 AF
= addTable
[sum
] | cbitsTable
[cbits
] | (SET_PV
);
2084 case 0xc7: /* RST 0 */
2089 case 0xc8: /* RET Z */
2090 if (TSTFLAG(Z
)) POP(PC
);
2093 case 0xc9: /* RET */
2097 case 0xca: /* JP Z,nnnn */
2101 case 0xcb: /* CB prefix */
2104 switch ((op
= GET_BYTE(PC
)) & 7) {
2108 acu
= HIGH_REGISTER(BC
);
2113 acu
= LOW_REGISTER(BC
);
2118 acu
= HIGH_REGISTER(DE
);
2123 acu
= LOW_REGISTER(DE
);
2128 acu
= HIGH_REGISTER(HL
);
2133 acu
= LOW_REGISTER(HL
);
2138 acu
= GET_BYTE(adr
);
2143 acu
= HIGH_REGISTER(AF
);
2146 switch (op
& 0xc0) {
2148 case 0x00: /* shift/rotate */
2149 switch (op
& 0x38) {
2152 temp
= (acu
<< 1) | (acu
>> 7);
2157 temp
= (acu
>> 1) | (acu
<< 7);
2158 cbits
= temp
& 0x80;
2162 temp
= (acu
<< 1) | TSTFLAG(C
);
2167 temp
= (acu
>> 1) | (TSTFLAG(C
) << 7);
2177 temp
= (acu
>> 1) | (acu
& 0x80);
2181 case 0x30:/* SLIA */
2182 temp
= (acu
<< 1) | 1;
2190 AF
= (AF
& ~0xff) | rotateShiftTable
[temp
& 0xff] | !!cbits
;
2194 case 0x40: /* BIT */
2195 if (acu
& (1 << ((op
>> 3) & 7)))
2196 AF
= (AF
& ~0xfe) | 0x10 | (((op
& 0x38) == 0x38) << 7);
2197 else AF
= (AF
& ~0xfe) | 0x54;
2198 if ((op
& 7) != 6) AF
|= (acu
& 0x28);
2202 case 0x80: /* RES */
2203 temp
= acu
& ~(1 << ((op
>> 3) & 7));
2206 case 0xc0: /* SET */
2207 temp
= acu
| (1 << ((op
>> 3) & 7));
2213 SET_HIGH_REGISTER(BC
, temp
);
2217 SET_LOW_REGISTER(BC
, temp
);
2221 SET_HIGH_REGISTER(DE
, temp
);
2225 SET_LOW_REGISTER(DE
, temp
);
2229 SET_HIGH_REGISTER(HL
, temp
);
2233 SET_LOW_REGISTER(HL
, temp
);
2237 PUT_BYTE(adr
, temp
);
2241 SET_HIGH_REGISTER(AF
, temp
);
2246 case 0xcc: /* CALL Z,nnnn */
2250 case 0xcd: /* CALL nnnn */
2254 case 0xce: /* ADC A,nn */
2256 acu
= HIGH_REGISTER(AF
);
2257 sum
= acu
+ temp
+ TSTFLAG(C
);
2258 cbits
= acu
^ temp
^ sum
;
2259 AF
= addTable
[sum
] | cbitsTable
[cbits
] | (SET_PV
);
2262 case 0xcf: /* RST 8 */
2267 case 0xd0: /* RET NC */
2268 if (!(TSTFLAG(C
))) POP(PC
);
2271 case 0xd1: /* POP DE */
2275 case 0xd2: /* JP NC,nnnn */
2279 case 0xd3: /* OUT (nn),A */
2280 out(RAM_PP(PC
), HIGH_REGISTER(AF
));
2283 case 0xd4: /* CALL NC,nnnn */
2287 case 0xd5: /* PUSH DE */
2291 case 0xd6: /* SUB nn */
2293 acu
= HIGH_REGISTER(AF
);
2295 cbits
= acu
^ temp
^ sum
;
2296 AF
= subTable
[sum
& 0xff] | cbitsTable
[cbits
& 0x1ff] | (SET_PV
);
2299 case 0xd7: /* RST 10H */
2304 case 0xd8: /* RET C */
2305 if (TSTFLAG(C
)) POP(PC
);
2308 case 0xd9: /* EXX */
2321 case 0xda: /* JP C,nnnn */
2325 case 0xdb: /* IN A,(nn) */
2326 SET_HIGH_REGISTER(AF
, in(RAM_PP(PC
)));
2329 case 0xdc: /* CALL C,nnnn */
2333 case 0xdd: /* DD prefix */
2335 switch (op
= RAM_PP(PC
)) {
2337 case 0x09: /* ADD IX,BC */
2341 AF
= (AF
& ~0x3b) | ((sum
>> 8) & 0x28) | cbitsTable
[(IX
^ BC
^ sum
) >> 8];
2345 case 0x19: /* ADD IX,DE */
2349 AF
= (AF
& ~0x3b) | ((sum
>> 8) & 0x28) | cbitsTable
[(IX
^ DE
^ sum
) >> 8];
2353 case 0x21: /* LD IX,nnnn */
2358 case 0x22: /* LD (nnnn),IX */
2359 temp
= GET_WORD(PC
);
2364 case 0x23: /* INC IX */
2368 case 0x24: /* INC IXH */
2370 AF
= (AF
& ~0xfe) | incZ80Table
[HIGH_REGISTER(IX
)];
2373 case 0x25: /* DEC IXH */
2375 AF
= (AF
& ~0xfe) | decZ80Table
[HIGH_REGISTER(IX
)];
2378 case 0x26: /* LD IXH,nn */
2379 SET_HIGH_REGISTER(IX
, RAM_PP(PC
));
2382 case 0x29: /* ADD IX,IX */
2385 AF
= (AF
& ~0x3b) | cbitsDup16Table
[sum
>> 8];
2389 case 0x2a: /* LD IX,(nnnn) */
2390 temp
= GET_WORD(PC
);
2391 IX
= GET_WORD(temp
);
2395 case 0x2b: /* DEC IX */
2399 case 0x2c: /* INC IXL */
2400 temp
= LOW_REGISTER(IX
) + 1;
2401 SET_LOW_REGISTER(IX
, temp
);
2402 AF
= (AF
& ~0xfe) | incZ80Table
[temp
];
2405 case 0x2d: /* DEC IXL */
2406 temp
= LOW_REGISTER(IX
) - 1;
2407 SET_LOW_REGISTER(IX
, temp
);
2408 AF
= (AF
& ~0xfe) | decZ80Table
[temp
& 0xff];
2411 case 0x2e: /* LD IXL,nn */
2412 SET_LOW_REGISTER(IX
, RAM_PP(PC
));
2415 case 0x34: /* INC (IX+dd) */
2416 adr
= IX
+ (int8
) RAM_PP(PC
);
2417 temp
= GET_BYTE(adr
) + 1;
2418 PUT_BYTE(adr
, temp
);
2419 AF
= (AF
& ~0xfe) | incZ80Table
[temp
];
2422 case 0x35: /* DEC (IX+dd) */
2423 adr
= IX
+ (int8
) RAM_PP(PC
);
2424 temp
= GET_BYTE(adr
) - 1;
2425 PUT_BYTE(adr
, temp
);
2426 AF
= (AF
& ~0xfe) | decZ80Table
[temp
& 0xff];
2429 case 0x36: /* LD (IX+dd),nn */
2430 adr
= IX
+ (int8
) RAM_PP(PC
);
2431 PUT_BYTE(adr
, RAM_PP(PC
));
2434 case 0x39: /* ADD IX,SP */
2438 AF
= (AF
& ~0x3b) | ((sum
>> 8) & 0x28) | cbitsTable
[(IX
^ SP
^ sum
) >> 8];
2442 case 0x44: /* LD B,IXH */
2443 SET_HIGH_REGISTER(BC
, HIGH_REGISTER(IX
));
2446 case 0x45: /* LD B,IXL */
2447 SET_HIGH_REGISTER(BC
, LOW_REGISTER(IX
));
2450 case 0x46: /* LD B,(IX+dd) */
2451 adr
= IX
+ (int8
) RAM_PP(PC
);
2452 SET_HIGH_REGISTER(BC
, GET_BYTE(adr
));
2455 case 0x4c: /* LD C,IXH */
2456 SET_LOW_REGISTER(BC
, HIGH_REGISTER(IX
));
2459 case 0x4d: /* LD C,IXL */
2460 SET_LOW_REGISTER(BC
, LOW_REGISTER(IX
));
2463 case 0x4e: /* LD C,(IX+dd) */
2464 adr
= IX
+ (int8
) RAM_PP(PC
);
2465 SET_LOW_REGISTER(BC
, GET_BYTE(adr
));
2468 case 0x54: /* LD D,IXH */
2469 SET_HIGH_REGISTER(DE
, HIGH_REGISTER(IX
));
2472 case 0x55: /* LD D,IXL */
2473 SET_HIGH_REGISTER(DE
, LOW_REGISTER(IX
));
2476 case 0x56: /* LD D,(IX+dd) */
2477 adr
= IX
+ (int8
) RAM_PP(PC
);
2478 SET_HIGH_REGISTER(DE
, GET_BYTE(adr
));
2481 case 0x5c: /* LD E,IXH */
2482 SET_LOW_REGISTER(DE
, HIGH_REGISTER(IX
));
2485 case 0x5d: /* LD E,IXL */
2486 SET_LOW_REGISTER(DE
, LOW_REGISTER(IX
));
2489 case 0x5e: /* LD E,(IX+dd) */
2490 adr
= IX
+ (int8
) RAM_PP(PC
);
2491 SET_LOW_REGISTER(DE
, GET_BYTE(adr
));
2494 case 0x60: /* LD IXH,B */
2495 SET_HIGH_REGISTER(IX
, HIGH_REGISTER(BC
));
2498 case 0x61: /* LD IXH,C */
2499 SET_HIGH_REGISTER(IX
, LOW_REGISTER(BC
));
2502 case 0x62: /* LD IXH,D */
2503 SET_HIGH_REGISTER(IX
, HIGH_REGISTER(DE
));
2506 case 0x63: /* LD IXH,E */
2507 SET_HIGH_REGISTER(IX
, LOW_REGISTER(DE
));
2510 case 0x64: /* LD IXH,IXH */
2513 case 0x65: /* LD IXH,IXL */
2514 SET_HIGH_REGISTER(IX
, LOW_REGISTER(IX
));
2517 case 0x66: /* LD H,(IX+dd) */
2518 adr
= IX
+ (int8
) RAM_PP(PC
);
2519 SET_HIGH_REGISTER(HL
, GET_BYTE(adr
));
2522 case 0x67: /* LD IXH,A */
2523 SET_HIGH_REGISTER(IX
, HIGH_REGISTER(AF
));
2526 case 0x68: /* LD IXL,B */
2527 SET_LOW_REGISTER(IX
, HIGH_REGISTER(BC
));
2530 case 0x69: /* LD IXL,C */
2531 SET_LOW_REGISTER(IX
, LOW_REGISTER(BC
));
2534 case 0x6a: /* LD IXL,D */
2535 SET_LOW_REGISTER(IX
, HIGH_REGISTER(DE
));
2538 case 0x6b: /* LD IXL,E */
2539 SET_LOW_REGISTER(IX
, LOW_REGISTER(DE
));
2542 case 0x6c: /* LD IXL,IXH */
2543 SET_LOW_REGISTER(IX
, HIGH_REGISTER(IX
));
2546 case 0x6d: /* LD IXL,IXL */
2549 case 0x6e: /* LD L,(IX+dd) */
2550 adr
= IX
+ (int8
) RAM_PP(PC
);
2551 SET_LOW_REGISTER(HL
, GET_BYTE(adr
));
2554 case 0x6f: /* LD IXL,A */
2555 SET_LOW_REGISTER(IX
, HIGH_REGISTER(AF
));
2558 case 0x70: /* LD (IX+dd),B */
2559 adr
= IX
+ (int8
) RAM_PP(PC
);
2560 PUT_BYTE(adr
, HIGH_REGISTER(BC
));
2563 case 0x71: /* LD (IX+dd),C */
2564 adr
= IX
+ (int8
) RAM_PP(PC
);
2565 PUT_BYTE(adr
, LOW_REGISTER(BC
));
2568 case 0x72: /* LD (IX+dd),D */
2569 adr
= IX
+ (int8
) RAM_PP(PC
);
2570 PUT_BYTE(adr
, HIGH_REGISTER(DE
));
2573 case 0x73: /* LD (IX+dd),E */
2574 adr
= IX
+ (int8
) RAM_PP(PC
);
2575 PUT_BYTE(adr
, LOW_REGISTER(DE
));
2578 case 0x74: /* LD (IX+dd),H */
2579 adr
= IX
+ (int8
) RAM_PP(PC
);
2580 PUT_BYTE(adr
, HIGH_REGISTER(HL
));
2583 case 0x75: /* LD (IX+dd),L */
2584 adr
= IX
+ (int8
) RAM_PP(PC
);
2585 PUT_BYTE(adr
, LOW_REGISTER(HL
));
2588 case 0x77: /* LD (IX+dd),A */
2589 adr
= IX
+ (int8
) RAM_PP(PC
);
2590 PUT_BYTE(adr
, HIGH_REGISTER(AF
));
2593 case 0x7c: /* LD A,IXH */
2594 SET_HIGH_REGISTER(AF
, HIGH_REGISTER(IX
));
2597 case 0x7d: /* LD A,IXL */
2598 SET_HIGH_REGISTER(AF
, LOW_REGISTER(IX
));
2601 case 0x7e: /* LD A,(IX+dd) */
2602 adr
= IX
+ (int8
) RAM_PP(PC
);
2603 SET_HIGH_REGISTER(AF
, GET_BYTE(adr
));
2606 case 0x84: /* ADD A,IXH */
2607 temp
= HIGH_REGISTER(IX
);
2608 acu
= HIGH_REGISTER(AF
);
2610 AF
= addTable
[sum
] | cbitsZ80Table
[acu
^ temp
^ sum
];
2613 case 0x85: /* ADD A,IXL */
2614 temp
= LOW_REGISTER(IX
);
2615 acu
= HIGH_REGISTER(AF
);
2617 AF
= addTable
[sum
] | cbitsZ80Table
[acu
^ temp
^ sum
];
2620 case 0x86: /* ADD A,(IX+dd) */
2621 adr
= IX
+ (int8
) RAM_PP(PC
);
2622 temp
= GET_BYTE(adr
);
2623 acu
= HIGH_REGISTER(AF
);
2625 AF
= addTable
[sum
] | cbitsZ80Table
[acu
^ temp
^ sum
];
2628 case 0x8c: /* ADC A,IXH */
2629 temp
= HIGH_REGISTER(IX
);
2630 acu
= HIGH_REGISTER(AF
);
2631 sum
= acu
+ temp
+ TSTFLAG(C
);
2632 AF
= addTable
[sum
] | cbitsZ80Table
[acu
^ temp
^ sum
];
2635 case 0x8d: /* ADC A,IXL */
2636 temp
= LOW_REGISTER(IX
);
2637 acu
= HIGH_REGISTER(AF
);
2638 sum
= acu
+ temp
+ TSTFLAG(C
);
2639 AF
= addTable
[sum
] | cbitsZ80Table
[acu
^ temp
^ sum
];
2642 case 0x8e: /* ADC A,(IX+dd) */
2643 adr
= IX
+ (int8
) RAM_PP(PC
);
2644 temp
= GET_BYTE(adr
);
2645 acu
= HIGH_REGISTER(AF
);
2646 sum
= acu
+ temp
+ TSTFLAG(C
);
2647 AF
= addTable
[sum
] | cbitsZ80Table
[acu
^ temp
^ sum
];
2650 case 0x96: /* SUB (IX+dd) */
2651 adr
= IX
+ (int8
) RAM_PP(PC
);
2652 temp
= GET_BYTE(adr
);
2653 acu
= HIGH_REGISTER(AF
);
2655 AF
= addTable
[sum
& 0xff] | cbits2Z80Table
[(acu
^ temp
^ sum
) & 0x1ff];
2658 case 0x94: /* SUB IXH */
2659 SETFLAG(C
, 0);/* fall through, a bit less efficient but smaller code */
2661 case 0x9c: /* SBC A,IXH */
2662 temp
= HIGH_REGISTER(IX
);
2663 acu
= HIGH_REGISTER(AF
);
2664 sum
= acu
- temp
- TSTFLAG(C
);
2665 AF
= addTable
[sum
& 0xff] | cbits2Z80Table
[(acu
^ temp
^ sum
) & 0x1ff];
2668 case 0x95: /* SUB IXL */
2669 SETFLAG(C
, 0);/* fall through, a bit less efficient but smaller code */
2671 case 0x9d: /* SBC A,IXL */
2672 temp
= LOW_REGISTER(IX
);
2673 acu
= HIGH_REGISTER(AF
);
2674 sum
= acu
- temp
- TSTFLAG(C
);
2675 AF
= addTable
[sum
& 0xff] | cbits2Z80Table
[(acu
^ temp
^ sum
) & 0x1ff];
2678 case 0x9e: /* SBC A,(IX+dd) */
2679 adr
= IX
+ (int8
) RAM_PP(PC
);
2680 temp
= GET_BYTE(adr
);
2681 acu
= HIGH_REGISTER(AF
);
2682 sum
= acu
- temp
- TSTFLAG(C
);
2683 AF
= addTable
[sum
& 0xff] | cbits2Z80Table
[(acu
^ temp
^ sum
) & 0x1ff];
2686 case 0xa4: /* AND IXH */
2687 AF
= andTable
[((AF
& IX
) >> 8) & 0xff];
2690 case 0xa5: /* AND IXL */
2691 AF
= andTable
[((AF
>> 8) & IX
) & 0xff];
2694 case 0xa6: /* AND (IX+dd) */
2695 adr
= IX
+ (int8
) RAM_PP(PC
);
2696 AF
= andTable
[((AF
>> 8) & GET_BYTE(adr
)) & 0xff];
2699 case 0xac: /* XOR IXH */
2700 AF
= xororTable
[((AF
^ IX
) >> 8) & 0xff];
2703 case 0xad: /* XOR IXL */
2704 AF
= xororTable
[((AF
>> 8) ^ IX
) & 0xff];
2707 case 0xae: /* XOR (IX+dd) */
2708 adr
= IX
+ (int8
) RAM_PP(PC
);
2709 AF
= xororTable
[((AF
>> 8) ^ GET_BYTE(adr
)) & 0xff];
2712 case 0xb4: /* OR IXH */
2713 AF
= xororTable
[((AF
| IX
) >> 8) & 0xff];
2716 case 0xb5: /* OR IXL */
2717 AF
= xororTable
[((AF
>> 8) | IX
) & 0xff];
2720 case 0xb6: /* OR (IX+dd) */
2721 adr
= IX
+ (int8
) RAM_PP(PC
);
2722 AF
= xororTable
[((AF
>> 8) | GET_BYTE(adr
)) & 0xff];
2725 case 0xbc: /* CP IXH */
2726 temp
= HIGH_REGISTER(IX
);
2727 AF
= (AF
& ~0x28) | (temp
& 0x28);
2728 acu
= HIGH_REGISTER(AF
);
2730 AF
= (AF
& ~0xff) | cpTable
[sum
& 0xff] | (temp
& 0x28) |
2731 cbits2Z80Table
[(acu
^ temp
^ sum
) & 0x1ff];
2734 case 0xbd: /* CP IXL */
2735 temp
= LOW_REGISTER(IX
);
2736 AF
= (AF
& ~0x28) | (temp
& 0x28);
2737 acu
= HIGH_REGISTER(AF
);
2739 AF
= (AF
& ~0xff) | cpTable
[sum
& 0xff] | (temp
& 0x28) |
2740 cbits2Z80Table
[(acu
^ temp
^ sum
) & 0x1ff];
2743 case 0xbe: /* CP (IX+dd) */
2744 adr
= IX
+ (int8
) RAM_PP(PC
);
2745 temp
= GET_BYTE(adr
);
2746 AF
= (AF
& ~0x28) | (temp
& 0x28);
2747 acu
= HIGH_REGISTER(AF
);
2749 AF
= (AF
& ~0xff) | cpTable
[sum
& 0xff] | (temp
& 0x28) |
2750 cbits2Z80Table
[(acu
^ temp
^ sum
) & 0x1ff];
2753 case 0xcb: /* CB prefix */
2754 adr
= IX
+ (int8
) RAM_PP(PC
);
2755 switch ((op
= GET_BYTE(PC
)) & 7) {
2759 acu
= HIGH_REGISTER(BC
);
2764 acu
= LOW_REGISTER(BC
);
2769 acu
= HIGH_REGISTER(DE
);
2774 acu
= LOW_REGISTER(DE
);
2779 acu
= HIGH_REGISTER(HL
);
2784 acu
= LOW_REGISTER(HL
);
2789 acu
= GET_BYTE(adr
);
2794 acu
= HIGH_REGISTER(AF
);
2797 switch (op
& 0xc0) {
2799 case 0x00: /* shift/rotate */
2800 switch (op
& 0x38) {
2803 temp
= (acu
<< 1) | (acu
>> 7);
2808 temp
= (acu
>> 1) | (acu
<< 7);
2809 cbits
= temp
& 0x80;
2813 temp
= (acu
<< 1) | TSTFLAG(C
);
2818 temp
= (acu
>> 1) | (TSTFLAG(C
) << 7);
2828 temp
= (acu
>> 1) | (acu
& 0x80);
2832 case 0x30:/* SLIA */
2833 temp
= (acu
<< 1) | 1;
2841 AF
= (AF
& ~0xff) | rotateShiftTable
[temp
& 0xff] | !!cbits
;
2845 case 0x40: /* BIT */
2846 if (acu
& (1 << ((op
>> 3) & 7)))
2847 AF
= (AF
& ~0xfe) | 0x10 | (((op
& 0x38) == 0x38) << 7);
2848 else AF
= (AF
& ~0xfe) | 0x54;
2849 if ((op
& 7) != 6) AF
|= (acu
& 0x28);
2853 case 0x80: /* RES */
2854 temp
= acu
& ~(1 << ((op
>> 3) & 7));
2857 case 0xc0: /* SET */
2858 temp
= acu
| (1 << ((op
>> 3) & 7));
2864 SET_HIGH_REGISTER(BC
, temp
);
2868 SET_LOW_REGISTER(BC
, temp
);
2872 SET_HIGH_REGISTER(DE
, temp
);
2876 SET_LOW_REGISTER(DE
, temp
);
2880 SET_HIGH_REGISTER(HL
, temp
);
2884 SET_LOW_REGISTER(HL
, temp
);
2888 PUT_BYTE(adr
, temp
);
2892 SET_HIGH_REGISTER(AF
, temp
);
2897 case 0xe1: /* POP IX */
2901 case 0xe3: /* EX (SP),IX */
2907 case 0xe5: /* PUSH IX */
2911 case 0xe9: /* JP (IX) */
2915 case 0xf9: /* LD SP,IX */
2919 default: /* ignore DD */
2925 case 0xde: /* SBC A,nn */
2927 acu
= HIGH_REGISTER(AF
);
2928 sum
= acu
- temp
- TSTFLAG(C
);
2929 cbits
= acu
^ temp
^ sum
;
2930 AF
= subTable
[sum
& 0xff] | cbitsTable
[cbits
& 0x1ff] | (SET_PV
);
2933 case 0xdf: /* RST 18H */
2938 case 0xe0: /* RET PO */
2939 if (!(TSTFLAG(P
))) POP(PC
);
2942 case 0xe1: /* POP HL */
2946 case 0xe2: /* JP PO,nnnn */
2950 case 0xe3: /* EX (SP),HL */
2956 case 0xe4: /* CALL PO,nnnn */
2960 case 0xe5: /* PUSH HL */
2964 case 0xe6: /* AND nn */
2965 AF
= andTable
[((AF
>> 8) & RAM_PP(PC
)) & 0xff];
2968 case 0xe7: /* RST 20H */
2973 case 0xe8: /* RET PE */
2974 if (TSTFLAG(P
)) POP(PC
);
2977 case 0xe9: /* JP (HL) */
2981 case 0xea: /* JP PE,nnnn */
2985 case 0xeb: /* EX DE,HL */
2991 case 0xec: /* CALL PE,nnnn */
2995 case 0xed: /* ED prefix */
2997 switch (op
= RAM_PP(PC
)) {
2999 case 0x40: /* IN B,(C) */
3000 temp
= in(LOW_REGISTER(BC
));
3001 SET_HIGH_REGISTER(BC
, temp
);
3002 AF
= (AF
& ~0xfe) | rotateShiftTable
[temp
& 0xff];
3005 case 0x41: /* OUT (C),B */
3006 out(LOW_REGISTER(BC
), HIGH_REGISTER(BC
));
3009 case 0x42: /* SBC HL,BC */
3012 sum
= HL
- BC
- TSTFLAG(C
);
3013 AF
= (AF
& ~0xff) | ((sum
>> 8) & 0xa8) | (((sum
& ADDRMASK
) == 0) << 6) |
3014 cbits2Z80Table
[((HL
^ BC
^ sum
) >> 8) & 0x1ff];
3018 case 0x43: /* LD (nnnn),BC */
3019 temp
= GET_WORD(PC
);
3024 case 0x44: /* NEG */
3026 case 0x4C: /* NEG, unofficial */
3028 case 0x54: /* NEG, unofficial */
3030 case 0x5C: /* NEG, unofficial */
3032 case 0x64: /* NEG, unofficial */
3034 case 0x6C: /* NEG, unofficial */
3036 case 0x74: /* NEG, unofficial */
3038 case 0x7C: /* NEG, unofficial */
3039 temp
= HIGH_REGISTER(AF
);
3040 AF
= ((~(AF
& 0xff00) + 1) & 0xff00); /* AF = (-(AF & 0xff00) & 0xff00); */
3041 AF
|= ((AF
>> 8) & 0xa8) | (((AF
& 0xff00) == 0) << 6) | negTable
[temp
];
3044 case 0x45: /* RETN */
3046 case 0x55: /* RETN, unofficial */
3048 case 0x5D: /* RETN, unofficial */
3050 case 0x65: /* RETN, unofficial */
3052 case 0x6D: /* RETN, unofficial */
3054 case 0x75: /* RETN, unofficial */
3056 case 0x7D: /* RETN, unofficial */
3057 IFF_S
|= IFF_S
>> 1;
3061 case 0x46: /* IM 0 */
3062 /* interrupt mode 0 */
3065 case 0x47: /* LD I,A */
3066 IR_S
= (IR_S
& 0xff) | (AF
& ~0xff);
3069 case 0x48: /* IN C,(C) */
3070 temp
= in(LOW_REGISTER(BC
));
3071 SET_LOW_REGISTER(BC
, temp
);
3072 AF
= (AF
& ~0xfe) | rotateShiftTable
[temp
& 0xff];
3075 case 0x49: /* OUT (C),C */
3076 out(LOW_REGISTER(BC
), LOW_REGISTER(BC
));
3079 case 0x4a: /* ADC HL,BC */
3082 sum
= HL
+ BC
+ TSTFLAG(C
);
3083 AF
= (AF
& ~0xff) | ((sum
>> 8) & 0xa8) | (((sum
& ADDRMASK
) == 0) << 6) |
3084 cbitsZ80Table
[(HL
^ BC
^ sum
) >> 8];
3088 case 0x4b: /* LD BC,(nnnn) */
3089 temp
= GET_WORD(PC
);
3090 BC
= GET_WORD(temp
);
3094 case 0x4d: /* RETI */
3095 IFF_S
|= IFF_S
>> 1;
3099 case 0x4f: /* LD R,A */
3100 IR_S
= (IR_S
& ~0xff) | ((AF
>> 8) & 0xff);
3103 case 0x50: /* IN D,(C) */
3104 temp
= in(LOW_REGISTER(BC
));
3105 SET_HIGH_REGISTER(DE
, temp
);
3106 AF
= (AF
& ~0xfe) | rotateShiftTable
[temp
& 0xff];
3109 case 0x51: /* OUT (C),D */
3110 out(LOW_REGISTER(BC
), HIGH_REGISTER(DE
));
3113 case 0x52: /* SBC HL,DE */
3116 sum
= HL
- DE
- TSTFLAG(C
);
3117 AF
= (AF
& ~0xff) | ((sum
>> 8) & 0xa8) | (((sum
& ADDRMASK
) == 0) << 6) |
3118 cbits2Z80Table
[((HL
^ DE
^ sum
) >> 8) & 0x1ff];
3122 case 0x53: /* LD (nnnn),DE */
3123 temp
= GET_WORD(PC
);
3128 case 0x56: /* IM 1 */
3129 /* interrupt mode 1 */
3132 case 0x57: /* LD A,I */
3133 AF
= (AF
& 0x29) | (IR_S
& ~0xff) | ((IR_S
>> 8) & 0x80) | (((IR_S
& ~0xff) == 0) << 6) | ((IFF_S
& 2) << 1);
3136 case 0x58: /* IN E,(C) */
3137 temp
= in(LOW_REGISTER(BC
));
3138 SET_LOW_REGISTER(DE
, temp
);
3139 AF
= (AF
& ~0xfe) | rotateShiftTable
[temp
& 0xff];
3142 case 0x59: /* OUT (C),E */
3143 out(LOW_REGISTER(BC
), LOW_REGISTER(DE
));
3146 case 0x5a: /* ADC HL,DE */
3149 sum
= HL
+ DE
+ TSTFLAG(C
);
3150 AF
= (AF
& ~0xff) | ((sum
>> 8) & 0xa8) | (((sum
& ADDRMASK
) == 0) << 6) |
3151 cbitsZ80Table
[(HL
^ DE
^ sum
) >> 8];
3155 case 0x5b: /* LD DE,(nnnn) */
3156 temp
= GET_WORD(PC
);
3157 DE
= GET_WORD(temp
);
3161 case 0x5e: /* IM 2 */
3162 /* interrupt mode 2 */
3165 case 0x5f: /* LD A,R */
3166 AF
= (AF
& 0x29) | ((IR_S
& 0xff) << 8) | (IR_S
& 0x80) |
3167 (((IR_S
& 0xff) == 0) << 6) | ((IFF_S
& 2) << 1);
3170 case 0x60: /* IN H,(C) */
3171 temp
= in(LOW_REGISTER(BC
));
3172 SET_HIGH_REGISTER(HL
, temp
);
3173 AF
= (AF
& ~0xfe) | rotateShiftTable
[temp
& 0xff];
3176 case 0x61: /* OUT (C),H */
3177 out(LOW_REGISTER(BC
), HIGH_REGISTER(HL
));
3180 case 0x62: /* SBC HL,HL */
3182 sum
= HL
- HL
- TSTFLAG(C
);
3183 AF
= (AF
& ~0xff) | (((sum
& ADDRMASK
) == 0) << 6) |
3184 cbits2Z80DupTable
[(sum
>> 8) & 0x1ff];
3188 case 0x63: /* LD (nnnn),HL */
3189 temp
= GET_WORD(PC
);
3194 case 0x67: /* RRD */
3195 temp
= GET_BYTE(HL
);
3196 acu
= HIGH_REGISTER(AF
);
3197 PUT_BYTE(HL
, HIGH_DIGIT(temp
) | (LOW_DIGIT(acu
) << 4));
3198 AF
= rrdrldTable
[(acu
& 0xf0) | LOW_DIGIT(temp
)] | (AF
& 1);
3201 case 0x68: /* IN L,(C) */
3202 temp
= in(LOW_REGISTER(BC
));
3203 SET_LOW_REGISTER(HL
, temp
);
3204 AF
= (AF
& ~0xfe) | rotateShiftTable
[temp
& 0xff];
3207 case 0x69: /* OUT (C),L */
3208 out(LOW_REGISTER(BC
), LOW_REGISTER(HL
));
3211 case 0x6a: /* ADC HL,HL */
3213 sum
= HL
+ HL
+ TSTFLAG(C
);
3214 AF
= (AF
& ~0xff) | (((sum
& ADDRMASK
) == 0) << 6) |
3215 cbitsZ80DupTable
[sum
>> 8];
3219 case 0x6b: /* LD HL,(nnnn) */
3220 temp
= GET_WORD(PC
);
3221 HL
= GET_WORD(temp
);
3225 case 0x6f: /* RLD */
3226 temp
= GET_BYTE(HL
);
3227 acu
= HIGH_REGISTER(AF
);
3228 PUT_BYTE(HL
, (LOW_DIGIT(temp
) << 4) | LOW_DIGIT(acu
));
3229 AF
= rrdrldTable
[(acu
& 0xf0) | HIGH_DIGIT(temp
)] | (AF
& 1);
3232 case 0x70: /* IN (C) */
3233 temp
= in(LOW_REGISTER(BC
));
3234 SET_LOW_REGISTER(temp
, temp
);
3235 AF
= (AF
& ~0xfe) | rotateShiftTable
[temp
& 0xff];
3238 case 0x71: /* OUT (C),0 */
3239 out(LOW_REGISTER(BC
), 0);
3242 case 0x72: /* SBC HL,SP */
3245 sum
= HL
- SP
- TSTFLAG(C
);
3246 AF
= (AF
& ~0xff) | ((sum
>> 8) & 0xa8) | (((sum
& ADDRMASK
) == 0) << 6) |
3247 cbits2Z80Table
[((HL
^ SP
^ sum
) >> 8) & 0x1ff];
3251 case 0x73: /* LD (nnnn),SP */
3252 temp
= GET_WORD(PC
);
3257 case 0x78: /* IN A,(C) */
3258 temp
= in(LOW_REGISTER(BC
));
3259 SET_HIGH_REGISTER(AF
, temp
);
3260 AF
= (AF
& ~0xfe) | rotateShiftTable
[temp
& 0xff];
3263 case 0x79: /* OUT (C),A */
3264 out(LOW_REGISTER(BC
), HIGH_REGISTER(AF
));
3267 case 0x7a: /* ADC HL,SP */
3270 sum
= HL
+ SP
+ TSTFLAG(C
);
3271 AF
= (AF
& ~0xff) | ((sum
>> 8) & 0xa8) | (((sum
& ADDRMASK
) == 0) << 6) |
3272 cbitsZ80Table
[(HL
^ SP
^ sum
) >> 8];
3276 case 0x7b: /* LD SP,(nnnn) */
3277 temp
= GET_WORD(PC
);
3278 SP
= GET_WORD(temp
);
3282 case 0xa0: /* LDI */
3284 PUT_BYTE_PP(DE
, acu
);
3285 acu
+= HIGH_REGISTER(AF
);
3286 AF
= (AF
& ~0x3e) | (acu
& 8) | ((acu
& 2) << 4) |
3287 (((--BC
& ADDRMASK
) != 0) << 2);
3290 case 0xa1: /* CPI */
3291 acu
= HIGH_REGISTER(AF
);
3294 cbits
= acu
^ temp
^ sum
;
3295 AF
= (AF
& ~0xfe) | (sum
& 0x80) | (!(sum
& 0xff) << 6) |
3296 (((sum
- ((cbits
& 16) >> 4)) & 2) << 4) | (cbits
& 16) |
3297 ((sum
- ((cbits
>> 4) & 1)) & 8) |
3298 ((--BC
& ADDRMASK
) != 0) << 2 | 2;
3299 if ((sum
& 15) == 8 && (cbits
& 16) != 0) AF
&= ~8;
3302 /* SF, ZF, YF, XF flags are affected by decreasing register B, as in DEC B.
3303 NF flag A is copy of bit 7 of the value read from or written to an I/O port.
3304 INI/INIR/IND/INDR use the C flag in stead of the L register. There is a
3305 catch though, because not the value of C is used, but C + 1 if it's INI/INIR or
3306 C - 1 if it's IND/INDR. So, first of all INI/INIR:
3307 HF and CF Both set if ((HL) + ((C + 1) & 255) > 255)
3308 PF The parity of (((HL) + ((C + 1) & 255)) & 7) xor B) */
3309 case 0xa2: /* INI */
3310 acu
= in(LOW_REGISTER(BC
));
3313 temp
= HIGH_REGISTER(BC
);
3315 INOUTFLAGS_NONZERO((LOW_REGISTER(BC
) + 1) & 0xff);
3318 /* SF, ZF, YF, XF flags are affected by decreasing register B, as in DEC B.
3319 NF flag A is copy of bit 7 of the value read from or written to an I/O port.
3320 And now the for OUTI/OTIR/OUTD/OTDR instructions. Take state of the L
3321 after the increment or decrement of HL; add the value written to the I/O port
3322 to; call that k for now. If k > 255, then the CF and HF flags are set. The PF
3323 flags is set like the parity of k bitwise and'ed with 7, bitwise xor'ed with B.
3324 HF and CF Both set if ((HL) + L > 255)
3325 PF The parity of ((((HL) + L) & 7) xor B) */
3326 case 0xa3: /* OUTI */
3328 out(LOW_REGISTER(BC
), acu
);
3330 temp
= HIGH_REGISTER(BC
);
3332 INOUTFLAGS_NONZERO(LOW_REGISTER(HL
));
3335 case 0xa8: /* LDD */
3337 PUT_BYTE_MM(DE
, acu
);
3338 acu
+= HIGH_REGISTER(AF
);
3339 AF
= (AF
& ~0x3e) | (acu
& 8) | ((acu
& 2) << 4) |
3340 (((--BC
& ADDRMASK
) != 0) << 2);
3343 case 0xa9: /* CPD */
3344 acu
= HIGH_REGISTER(AF
);
3347 cbits
= acu
^ temp
^ sum
;
3348 AF
= (AF
& ~0xfe) | (sum
& 0x80) | (!(sum
& 0xff) << 6) |
3349 (((sum
- ((cbits
& 16) >> 4)) & 2) << 4) | (cbits
& 16) |
3350 ((sum
- ((cbits
>> 4) & 1)) & 8) |
3351 ((--BC
& ADDRMASK
) != 0) << 2 | 2;
3352 if ((sum
& 15) == 8 && (cbits
& 16) != 0) AF
&= ~8;
3355 /* SF, ZF, YF, XF flags are affected by decreasing register B, as in DEC B.
3356 NF flag A is copy of bit 7 of the value read from or written to an I/O port.
3357 INI/INIR/IND/INDR use the C flag in stead of the L register. There is a
3358 catch though, because not the value of C is used, but C + 1 if it's INI/INIR or
3359 C - 1 if it's IND/INDR. And last IND/INDR:
3360 HF and CF Both set if ((HL) + ((C - 1) & 255) > 255)
3361 PF The parity of (((HL) + ((C - 1) & 255)) & 7) xor B) */
3362 case 0xaa: /* IND */
3363 acu
= in(LOW_REGISTER(BC
));
3366 temp
= HIGH_REGISTER(BC
);
3368 INOUTFLAGS_NONZERO((LOW_REGISTER(BC
) - 1) & 0xff);
3371 case 0xab: /* OUTD */
3373 out(LOW_REGISTER(BC
), acu
);
3375 temp
= HIGH_REGISTER(BC
);
3377 INOUTFLAGS_NONZERO(LOW_REGISTER(HL
));
3380 case 0xb0: /* LDIR */
3381 acu
= HIGH_REGISTER(AF
);
3383 if (BC
== 0) BC
= 0x10000;
3386 PUT_BYTE_PP(DE
, acu
);
3388 acu
+= HIGH_REGISTER(AF
);
3389 AF
= (AF
& ~0x3e) | (acu
& 8) | ((acu
& 2) << 4);
3392 case 0xb1: /* CPIR */
3393 acu
= HIGH_REGISTER(AF
);
3395 if (BC
== 0) BC
= 0x10000;
3400 } while (op
&& sum
!= 0);
3401 cbits
= acu
^ temp
^ sum
;
3402 AF
= (AF
& ~0xfe) | (sum
& 0x80) | (!(sum
& 0xff) << 6) |
3403 (((sum
- ((cbits
& 16) >> 4)) & 2) << 4) |
3404 (cbits
& 16) | ((sum
- ((cbits
>> 4) & 1)) & 8) |
3406 if ((sum
& 15) == 8 && (cbits
& 16) != 0) AF
&= ~8;
3409 case 0xb2: /* INIR */
3410 temp
= HIGH_REGISTER(BC
);
3411 if (temp
== 0) temp
= 0x100;
3413 acu
= in(LOW_REGISTER(BC
));
3417 temp
= HIGH_REGISTER(BC
);
3418 SET_HIGH_REGISTER(BC
, 0);
3419 INOUTFLAGS_ZERO((LOW_REGISTER(BC
) + 1) & 0xff);
3422 case 0xb3: /* OTIR */
3423 temp
= HIGH_REGISTER(BC
);
3424 if (temp
== 0) temp
= 0x100;
3427 out(LOW_REGISTER(BC
), acu
);
3430 temp
= HIGH_REGISTER(BC
);
3431 SET_HIGH_REGISTER(BC
, 0);
3432 INOUTFLAGS_ZERO(LOW_REGISTER(HL
));
3435 case 0xb8: /* LDDR */
3437 if (BC
== 0) BC
= 0x10000;
3440 PUT_BYTE_MM(DE
, acu
);
3442 acu
+= HIGH_REGISTER(AF
);
3443 AF
= (AF
& ~0x3e) | (acu
& 8) | ((acu
& 2) << 4);
3446 case 0xb9: /* CPDR */
3447 acu
= HIGH_REGISTER(AF
);
3449 if (BC
== 0) BC
= 0x10000;
3454 } while (op
&& sum
!= 0);
3455 cbits
= acu
^ temp
^ sum
;
3456 AF
= (AF
& ~0xfe) | (sum
& 0x80) | (!(sum
& 0xff) << 6) |
3457 (((sum
- ((cbits
& 16) >> 4)) & 2) << 4) |
3458 (cbits
& 16) | ((sum
- ((cbits
>> 4) & 1)) & 8) |
3460 if ((sum
& 15) == 8 && (cbits
& 16) != 0) AF
&= ~8;
3463 case 0xba: /* INDR */
3464 temp
= HIGH_REGISTER(BC
);
3465 if (temp
== 0) temp
= 0x100;
3467 acu
= in(LOW_REGISTER(BC
));
3471 temp
= HIGH_REGISTER(BC
);
3472 SET_HIGH_REGISTER(BC
, 0);
3473 INOUTFLAGS_ZERO((LOW_REGISTER(BC
) - 1) & 0xff);
3476 case 0xbb: /* OTDR */
3477 temp
= HIGH_REGISTER(BC
);
3478 if (temp
== 0) temp
= 0x100;
3481 out(LOW_REGISTER(BC
), acu
);
3484 temp
= HIGH_REGISTER(BC
);
3485 SET_HIGH_REGISTER(BC
, 0);
3486 INOUTFLAGS_ZERO(LOW_REGISTER(HL
));
3489 default: /* ignore ED and following byte */
3494 case 0xee: /* XOR nn */
3495 AF
= xororTable
[((AF
>> 8) ^ RAM_PP(PC
)) & 0xff];
3498 case 0xef: /* RST 28H */
3503 case 0xf0: /* RET P */
3504 if (!(TSTFLAG(S
))) POP(PC
);
3507 case 0xf1: /* POP AF */
3511 case 0xf2: /* JP P,nnnn */
3519 case 0xf4: /* CALL P,nnnn */
3523 case 0xf5: /* PUSH AF */
3527 case 0xf6: /* OR nn */
3528 AF
= xororTable
[((AF
>> 8) | RAM_PP(PC
)) & 0xff];
3531 case 0xf7: /* RST 30H */
3536 case 0xf8: /* RET M */
3537 if (TSTFLAG(S
)) POP(PC
);
3540 case 0xf9: /* LD SP,HL */
3544 case 0xfa: /* JP M,nnnn */
3552 case 0xfc: /* CALL M,nnnn */
3556 case 0xfd: /* FD prefix */
3558 switch (op
= RAM_PP(PC
)) {
3560 case 0x09: /* ADD IY,BC */
3564 AF
= (AF
& ~0x3b) | ((sum
>> 8) & 0x28) | cbitsTable
[(IY
^ BC
^ sum
) >> 8];
3568 case 0x19: /* ADD IY,DE */
3572 AF
= (AF
& ~0x3b) | ((sum
>> 8) & 0x28) | cbitsTable
[(IY
^ DE
^ sum
) >> 8];
3576 case 0x21: /* LD IY,nnnn */
3581 case 0x22: /* LD (nnnn),IY */
3582 temp
= GET_WORD(PC
);
3587 case 0x23: /* INC IY */
3591 case 0x24: /* INC IYH */
3593 AF
= (AF
& ~0xfe) | incZ80Table
[HIGH_REGISTER(IY
)];
3596 case 0x25: /* DEC IYH */
3598 AF
= (AF
& ~0xfe) | decZ80Table
[HIGH_REGISTER(IY
)];
3601 case 0x26: /* LD IYH,nn */
3602 SET_HIGH_REGISTER(IY
, RAM_PP(PC
));
3605 case 0x29: /* ADD IY,IY */
3608 AF
= (AF
& ~0x3b) | cbitsDup16Table
[sum
>> 8];
3612 case 0x2a: /* LD IY,(nnnn) */
3613 temp
= GET_WORD(PC
);
3614 IY
= GET_WORD(temp
);
3618 case 0x2b: /* DEC IY */
3622 case 0x2c: /* INC IYL */
3623 temp
= LOW_REGISTER(IY
) + 1;
3624 SET_LOW_REGISTER(IY
, temp
);
3625 AF
= (AF
& ~0xfe) | incZ80Table
[temp
];
3628 case 0x2d: /* DEC IYL */
3629 temp
= LOW_REGISTER(IY
) - 1;
3630 SET_LOW_REGISTER(IY
, temp
);
3631 AF
= (AF
& ~0xfe) | decZ80Table
[temp
& 0xff];
3634 case 0x2e: /* LD IYL,nn */
3635 SET_LOW_REGISTER(IY
, RAM_PP(PC
));
3638 case 0x34: /* INC (IY+dd) */
3639 adr
= IY
+ (int8
) RAM_PP(PC
);
3640 temp
= GET_BYTE(adr
) + 1;
3641 PUT_BYTE(adr
, temp
);
3642 AF
= (AF
& ~0xfe) | incZ80Table
[temp
];
3645 case 0x35: /* DEC (IY+dd) */
3646 adr
= IY
+ (int8
) RAM_PP(PC
);
3647 temp
= GET_BYTE(adr
) - 1;
3648 PUT_BYTE(adr
, temp
);
3649 AF
= (AF
& ~0xfe) | decZ80Table
[temp
& 0xff];
3652 case 0x36: /* LD (IY+dd),nn */
3653 adr
= IY
+ (int8
) RAM_PP(PC
);
3654 PUT_BYTE(adr
, RAM_PP(PC
));
3657 case 0x39: /* ADD IY,SP */
3661 AF
= (AF
& ~0x3b) | ((sum
>> 8) & 0x28) | cbitsTable
[(IY
^ SP
^ sum
) >> 8];
3665 case 0x44: /* LD B,IYH */
3666 SET_HIGH_REGISTER(BC
, HIGH_REGISTER(IY
));
3669 case 0x45: /* LD B,IYL */
3670 SET_HIGH_REGISTER(BC
, LOW_REGISTER(IY
));
3673 case 0x46: /* LD B,(IY+dd) */
3674 adr
= IY
+ (int8
) RAM_PP(PC
);
3675 SET_HIGH_REGISTER(BC
, GET_BYTE(adr
));
3678 case 0x4c: /* LD C,IYH */
3679 SET_LOW_REGISTER(BC
, HIGH_REGISTER(IY
));
3682 case 0x4d: /* LD C,IYL */
3683 SET_LOW_REGISTER(BC
, LOW_REGISTER(IY
));
3686 case 0x4e: /* LD C,(IY+dd) */
3687 adr
= IY
+ (int8
) RAM_PP(PC
);
3688 SET_LOW_REGISTER(BC
, GET_BYTE(adr
));
3691 case 0x54: /* LD D,IYH */
3692 SET_HIGH_REGISTER(DE
, HIGH_REGISTER(IY
));
3695 case 0x55: /* LD D,IYL */
3696 SET_HIGH_REGISTER(DE
, LOW_REGISTER(IY
));
3699 case 0x56: /* LD D,(IY+dd) */
3700 adr
= IY
+ (int8
) RAM_PP(PC
);
3701 SET_HIGH_REGISTER(DE
, GET_BYTE(adr
));
3704 case 0x5c: /* LD E,IYH */
3705 SET_LOW_REGISTER(DE
, HIGH_REGISTER(IY
));
3708 case 0x5d: /* LD E,IYL */
3709 SET_LOW_REGISTER(DE
, LOW_REGISTER(IY
));
3712 case 0x5e: /* LD E,(IY+dd) */
3713 adr
= IY
+ (int8
) RAM_PP(PC
);
3714 SET_LOW_REGISTER(DE
, GET_BYTE(adr
));
3717 case 0x60: /* LD IYH,B */
3718 SET_HIGH_REGISTER(IY
, HIGH_REGISTER(BC
));
3721 case 0x61: /* LD IYH,C */
3722 SET_HIGH_REGISTER(IY
, LOW_REGISTER(BC
));
3725 case 0x62: /* LD IYH,D */
3726 SET_HIGH_REGISTER(IY
, HIGH_REGISTER(DE
));
3729 case 0x63: /* LD IYH,E */
3730 SET_HIGH_REGISTER(IY
, LOW_REGISTER(DE
));
3733 case 0x64: /* LD IYH,IYH */
3736 case 0x65: /* LD IYH,IYL */
3737 SET_HIGH_REGISTER(IY
, LOW_REGISTER(IY
));
3740 case 0x66: /* LD H,(IY+dd) */
3741 adr
= IY
+ (int8
) RAM_PP(PC
);
3742 SET_HIGH_REGISTER(HL
, GET_BYTE(adr
));
3745 case 0x67: /* LD IYH,A */
3746 SET_HIGH_REGISTER(IY
, HIGH_REGISTER(AF
));
3749 case 0x68: /* LD IYL,B */
3750 SET_LOW_REGISTER(IY
, HIGH_REGISTER(BC
));
3753 case 0x69: /* LD IYL,C */
3754 SET_LOW_REGISTER(IY
, LOW_REGISTER(BC
));
3757 case 0x6a: /* LD IYL,D */
3758 SET_LOW_REGISTER(IY
, HIGH_REGISTER(DE
));
3761 case 0x6b: /* LD IYL,E */
3762 SET_LOW_REGISTER(IY
, LOW_REGISTER(DE
));
3765 case 0x6c: /* LD IYL,IYH */
3766 SET_LOW_REGISTER(IY
, HIGH_REGISTER(IY
));
3769 case 0x6d: /* LD IYL,IYL */
3772 case 0x6e: /* LD L,(IY+dd) */
3773 adr
= IY
+ (int8
) RAM_PP(PC
);
3774 SET_LOW_REGISTER(HL
, GET_BYTE(adr
));
3777 case 0x6f: /* LD IYL,A */
3778 SET_LOW_REGISTER(IY
, HIGH_REGISTER(AF
));
3781 case 0x70: /* LD (IY+dd),B */
3782 adr
= IY
+ (int8
) RAM_PP(PC
);
3783 PUT_BYTE(adr
, HIGH_REGISTER(BC
));
3786 case 0x71: /* LD (IY+dd),C */
3787 adr
= IY
+ (int8
) RAM_PP(PC
);
3788 PUT_BYTE(adr
, LOW_REGISTER(BC
));
3791 case 0x72: /* LD (IY+dd),D */
3792 adr
= IY
+ (int8
) RAM_PP(PC
);
3793 PUT_BYTE(adr
, HIGH_REGISTER(DE
));
3796 case 0x73: /* LD (IY+dd),E */
3797 adr
= IY
+ (int8
) RAM_PP(PC
);
3798 PUT_BYTE(adr
, LOW_REGISTER(DE
));
3801 case 0x74: /* LD (IY+dd),H */
3802 adr
= IY
+ (int8
) RAM_PP(PC
);
3803 PUT_BYTE(adr
, HIGH_REGISTER(HL
));
3806 case 0x75: /* LD (IY+dd),L */
3807 adr
= IY
+ (int8
) RAM_PP(PC
);
3808 PUT_BYTE(adr
, LOW_REGISTER(HL
));
3811 case 0x77: /* LD (IY+dd),A */
3812 adr
= IY
+ (int8
) RAM_PP(PC
);
3813 PUT_BYTE(adr
, HIGH_REGISTER(AF
));
3816 case 0x7c: /* LD A,IYH */
3817 SET_HIGH_REGISTER(AF
, HIGH_REGISTER(IY
));
3820 case 0x7d: /* LD A,IYL */
3821 SET_HIGH_REGISTER(AF
, LOW_REGISTER(IY
));
3824 case 0x7e: /* LD A,(IY+dd) */
3825 adr
= IY
+ (int8
) RAM_PP(PC
);
3826 SET_HIGH_REGISTER(AF
, GET_BYTE(adr
));
3829 case 0x84: /* ADD A,IYH */
3830 temp
= HIGH_REGISTER(IY
);
3831 acu
= HIGH_REGISTER(AF
);
3833 AF
= addTable
[sum
] | cbitsZ80Table
[acu
^ temp
^ sum
];
3836 case 0x85: /* ADD A,IYL */
3837 temp
= LOW_REGISTER(IY
);
3838 acu
= HIGH_REGISTER(AF
);
3840 AF
= addTable
[sum
] | cbitsZ80Table
[acu
^ temp
^ sum
];
3843 case 0x86: /* ADD A,(IY+dd) */
3844 adr
= IY
+ (int8
) RAM_PP(PC
);
3845 temp
= GET_BYTE(adr
);
3846 acu
= HIGH_REGISTER(AF
);
3848 AF
= addTable
[sum
] | cbitsZ80Table
[acu
^ temp
^ sum
];
3851 case 0x8c: /* ADC A,IYH */
3852 temp
= HIGH_REGISTER(IY
);
3853 acu
= HIGH_REGISTER(AF
);
3854 sum
= acu
+ temp
+ TSTFLAG(C
);
3855 AF
= addTable
[sum
] | cbitsZ80Table
[acu
^ temp
^ sum
];
3858 case 0x8d: /* ADC A,IYL */
3859 temp
= LOW_REGISTER(IY
);
3860 acu
= HIGH_REGISTER(AF
);
3861 sum
= acu
+ temp
+ TSTFLAG(C
);
3862 AF
= addTable
[sum
] | cbitsZ80Table
[acu
^ temp
^ sum
];
3865 case 0x8e: /* ADC A,(IY+dd) */
3866 adr
= IY
+ (int8
) RAM_PP(PC
);
3867 temp
= GET_BYTE(adr
);
3868 acu
= HIGH_REGISTER(AF
);
3869 sum
= acu
+ temp
+ TSTFLAG(C
);
3870 AF
= addTable
[sum
] | cbitsZ80Table
[acu
^ temp
^ sum
];
3873 case 0x96: /* SUB (IY+dd) */
3874 adr
= IY
+ (int8
) RAM_PP(PC
);
3875 temp
= GET_BYTE(adr
);
3876 acu
= HIGH_REGISTER(AF
);
3878 AF
= addTable
[sum
& 0xff] | cbits2Z80Table
[(acu
^ temp
^ sum
) & 0x1ff];
3881 case 0x94: /* SUB IYH */
3882 SETFLAG(C
, 0);/* fall through, a bit less efficient but smaller code */
3884 case 0x9c: /* SBC A,IYH */
3885 temp
= HIGH_REGISTER(IY
);
3886 acu
= HIGH_REGISTER(AF
);
3887 sum
= acu
- temp
- TSTFLAG(C
);
3888 AF
= addTable
[sum
& 0xff] | cbits2Z80Table
[(acu
^ temp
^ sum
) & 0x1ff];
3891 case 0x95: /* SUB IYL */
3892 SETFLAG(C
, 0);/* fall through, a bit less efficient but smaller code */
3894 case 0x9d: /* SBC A,IYL */
3895 temp
= LOW_REGISTER(IY
);
3896 acu
= HIGH_REGISTER(AF
);
3897 sum
= acu
- temp
- TSTFLAG(C
);
3898 AF
= addTable
[sum
& 0xff] | cbits2Z80Table
[(acu
^ temp
^ sum
) & 0x1ff];
3901 case 0x9e: /* SBC A,(IY+dd) */
3902 adr
= IY
+ (int8
) RAM_PP(PC
);
3903 temp
= GET_BYTE(adr
);
3904 acu
= HIGH_REGISTER(AF
);
3905 sum
= acu
- temp
- TSTFLAG(C
);
3906 AF
= addTable
[sum
& 0xff] | cbits2Z80Table
[(acu
^ temp
^ sum
) & 0x1ff];
3909 case 0xa4: /* AND IYH */
3910 AF
= andTable
[((AF
& IY
) >> 8) & 0xff];
3913 case 0xa5: /* AND IYL */
3914 AF
= andTable
[((AF
>> 8) & IY
) & 0xff];
3917 case 0xa6: /* AND (IY+dd) */
3918 adr
= IY
+ (int8
) RAM_PP(PC
);
3919 AF
= andTable
[((AF
>> 8) & GET_BYTE(adr
)) & 0xff];
3922 case 0xac: /* XOR IYH */
3923 AF
= xororTable
[((AF
^ IY
) >> 8) & 0xff];
3926 case 0xad: /* XOR IYL */
3927 AF
= xororTable
[((AF
>> 8) ^ IY
) & 0xff];
3930 case 0xae: /* XOR (IY+dd) */
3931 adr
= IY
+ (int8
) RAM_PP(PC
);
3932 AF
= xororTable
[((AF
>> 8) ^ GET_BYTE(adr
)) & 0xff];
3935 case 0xb4: /* OR IYH */
3936 AF
= xororTable
[((AF
| IY
) >> 8) & 0xff];
3939 case 0xb5: /* OR IYL */
3940 AF
= xororTable
[((AF
>> 8) | IY
) & 0xff];
3943 case 0xb6: /* OR (IY+dd) */
3944 adr
= IY
+ (int8
) RAM_PP(PC
);
3945 AF
= xororTable
[((AF
>> 8) | GET_BYTE(adr
)) & 0xff];
3948 case 0xbc: /* CP IYH */
3949 temp
= HIGH_REGISTER(IY
);
3950 AF
= (AF
& ~0x28) | (temp
& 0x28);
3951 acu
= HIGH_REGISTER(AF
);
3953 AF
= (AF
& ~0xff) | cpTable
[sum
& 0xff] | (temp
& 0x28) |
3954 cbits2Z80Table
[(acu
^ temp
^ sum
) & 0x1ff];
3957 case 0xbd: /* CP IYL */
3958 temp
= LOW_REGISTER(IY
);
3959 AF
= (AF
& ~0x28) | (temp
& 0x28);
3960 acu
= HIGH_REGISTER(AF
);
3962 AF
= (AF
& ~0xff) | cpTable
[sum
& 0xff] | (temp
& 0x28) |
3963 cbits2Z80Table
[(acu
^ temp
^ sum
) & 0x1ff];
3966 case 0xbe: /* CP (IY+dd) */
3967 adr
= IY
+ (int8
) RAM_PP(PC
);
3968 temp
= GET_BYTE(adr
);
3969 AF
= (AF
& ~0x28) | (temp
& 0x28);
3970 acu
= HIGH_REGISTER(AF
);
3972 AF
= (AF
& ~0xff) | cpTable
[sum
& 0xff] | (temp
& 0x28) |
3973 cbits2Z80Table
[(acu
^ temp
^ sum
) & 0x1ff];
3976 case 0xcb: /* CB prefix */
3977 adr
= IY
+ (int8
) RAM_PP(PC
);
3978 switch ((op
= GET_BYTE(PC
)) & 7) {
3982 acu
= HIGH_REGISTER(BC
);
3987 acu
= LOW_REGISTER(BC
);
3992 acu
= HIGH_REGISTER(DE
);
3997 acu
= LOW_REGISTER(DE
);
4002 acu
= HIGH_REGISTER(HL
);
4007 acu
= LOW_REGISTER(HL
);
4012 acu
= GET_BYTE(adr
);
4017 acu
= HIGH_REGISTER(AF
);
4020 switch (op
& 0xc0) {
4022 case 0x00: /* shift/rotate */
4023 switch (op
& 0x38) {
4026 temp
= (acu
<< 1) | (acu
>> 7);
4031 temp
= (acu
>> 1) | (acu
<< 7);
4032 cbits
= temp
& 0x80;
4036 temp
= (acu
<< 1) | TSTFLAG(C
);
4041 temp
= (acu
>> 1) | (TSTFLAG(C
) << 7);
4051 temp
= (acu
>> 1) | (acu
& 0x80);
4055 case 0x30:/* SLIA */
4056 temp
= (acu
<< 1) | 1;
4064 AF
= (AF
& ~0xff) | rotateShiftTable
[temp
& 0xff] | !!cbits
;
4068 case 0x40: /* BIT */
4069 if (acu
& (1 << ((op
>> 3) & 7)))
4070 AF
= (AF
& ~0xfe) | 0x10 | (((op
& 0x38) == 0x38) << 7);
4071 else AF
= (AF
& ~0xfe) | 0x54;
4072 if ((op
& 7) != 6) AF
|= (acu
& 0x28);
4076 case 0x80: /* RES */
4077 temp
= acu
& ~(1 << ((op
>> 3) & 7));
4080 case 0xc0: /* SET */
4081 temp
= acu
| (1 << ((op
>> 3) & 7));
4087 SET_HIGH_REGISTER(BC
, temp
);
4091 SET_LOW_REGISTER(BC
, temp
);
4095 SET_HIGH_REGISTER(DE
, temp
);
4099 SET_LOW_REGISTER(DE
, temp
);
4103 SET_HIGH_REGISTER(HL
, temp
);
4107 SET_LOW_REGISTER(HL
, temp
);
4111 PUT_BYTE(adr
, temp
);
4115 SET_HIGH_REGISTER(AF
, temp
);
4120 case 0xe1: /* POP IY */
4124 case 0xe3: /* EX (SP),IY */
4130 case 0xe5: /* PUSH IY */
4134 case 0xe9: /* JP (IY) */
4138 case 0xf9: /* LD SP,IY */
4142 default: /* ignore FD */
4148 case 0xfe: /* CP nn */
4150 AF
= (AF
& ~0x28) | (temp
& 0x28);
4151 acu
= HIGH_REGISTER(AF
);
4153 cbits
= acu
^ temp
^ sum
;
4154 AF
= (AF
& ~0xff) | cpTable
[sum
& 0xff] | (temp
& 0x28) |
4155 (SET_PV
) | cbits2Table
[cbits
& 0x1ff];
4158 case 0xff: /* RST 38H */
4165 /* simulation halted */
4166 PC_S
= (reason
== STOP_OPCODE
) ? PCX
: PC
;