windows Pico stuff wip
[picodrive.git] / cpu / mz80 / mz80.c
CommitLineData
cc68a136 1#include "driver.h"
2
3/* Multi-Z80 32 Bit emulator */
4
5/* Copyright 1996-2000 Neil Bradley, All rights reserved
6 *
7 * License agreement:
8 *
9 * (MZ80 Refers to both the assembly code emitted by makeZ80.c and makeZ80.c
10 * itself)
11 *
12 * MZ80 May be distributed in unmodified form to any medium.
13 *
14 * MZ80 May not be sold, or sold as a part of a commercial package without
15 * the express written permission of Neil Bradley (neil@synthcom.com). This
16 * includes shareware.
17 *
18 * Modified versions of MZ80 may not be publicly redistributed without author
19 * approval (neil@synthcom.com). This includes distributing via a publicly
20 * accessible LAN. You may make your own source modifications and distribute
21 * MZ80 in source or object form, but if you make modifications to MZ80
22 * then it should be noted in the top as a comment in makeZ80.c.
23 *
24 * MZ80 Licensing for commercial applications is available. Please email
25 * neil@synthcom.com for details.
26 *
27 * Synthcom Systems, Inc, and Neil Bradley will not be held responsible for
28 * any damage done by the use of MZ80. It is purely "as-is".
29 *
30 * If you use MZ80 in a freeware application, credit in the following text:
31 *
32 * "Multi-Z80 CPU emulator by Neil Bradley (neil@synthcom.com)"
33 *
34 * must accompany the freeware application within the application itself or
35 * in the documentation.
36 *
37 * Legal stuff aside:
38 *
39 * If you find problems with MZ80, please email the author so they can get
40 * resolved. If you find a bug and fix it, please also email the author so
41 * that those bug fixes can be propogated to the installed base of MZ80
42 * users. If you find performance improvements or problems with MZ80, please
43 * email the author with your changes/suggestions and they will be rolled in
44 * with subsequent releases of MZ80.
45 *
46 * The whole idea of this emulator is to have the fastest available 32 bit
47 * Multi-Z80 emulator for the PC, giving maximum performance.
48 */
49
50#include <stdio.h>
51#include <stdlib.h>
52#include <string.h>
53#include "mz80.h"
54UINT32 z80intAddr;
55UINT32 z80pc;
56
57
58/* Modular global variables go here*/
59
60static CONTEXTMZ80 cpu; /* CPU Context */
61static UINT8 *pbPC; /* Program counter normalized */
62static UINT8 *pbSP; /* Stack pointer normalized */
63static struct MemoryReadByte *psMemRead; /* Read memory structure */
64static struct MemoryWriteByte *psMemWrite; /* Write memory structure */
65static struct z80PortRead *psIoRead; /* Read I/O structure */
66static struct z80PortWrite *psIoWrite; /* Write memory structure */
67static INT32 sdwCyclesRemaining; /* Used as a countdown */
68static UINT32 dwReturnCode; /* Return code from exec() */
69static UINT32 dwOriginalCycles; /* How many cycles did we start with? */
70static UINT32 dwElapsedTicks; /* How many ticks did we elapse? */
71static INT32 sdwAddr; /* Temporary address storage */
72static UINT32 dwAddr; /* Temporary stack address */
73static UINT8 *pbAddAdcTable; /* Pointer to add/adc flag table */
74static UINT8 *pbSubSbcTable; /* Pointer to sub/sbc flag table */
75static UINT32 dwTemp; /* Temporary value */
76
77static UINT8 bTemp; /* Temporary value */
78
79static UINT8 bTemp2; /* Temporary value */
80
81/* Precomputed flag tables */
82
83static UINT8 bPostIncFlags[0x100] =
84{
85 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x10,
86 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x10,
87 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x10,
88 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x10,
89 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x10,
90 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x10,
91 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x10,
92 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x94,
93 0x80,0x80,0x80,0x80,0x80,0x80,0x80,0x80,0x80,0x80,0x80,0x80,0x80,0x80,0x80,0x90,
94 0x80,0x80,0x80,0x80,0x80,0x80,0x80,0x80,0x80,0x80,0x80,0x80,0x80,0x80,0x80,0x90,
95 0x80,0x80,0x80,0x80,0x80,0x80,0x80,0x80,0x80,0x80,0x80,0x80,0x80,0x80,0x80,0x90,
96 0x80,0x80,0x80,0x80,0x80,0x80,0x80,0x80,0x80,0x80,0x80,0x80,0x80,0x80,0x80,0x90,
97 0x80,0x80,0x80,0x80,0x80,0x80,0x80,0x80,0x80,0x80,0x80,0x80,0x80,0x80,0x80,0x90,
98 0x80,0x80,0x80,0x80,0x80,0x80,0x80,0x80,0x80,0x80,0x80,0x80,0x80,0x80,0x80,0x90,
99 0x80,0x80,0x80,0x80,0x80,0x80,0x80,0x80,0x80,0x80,0x80,0x80,0x80,0x80,0x80,0x90,
100 0x80,0x80,0x80,0x80,0x80,0x80,0x80,0x80,0x80,0x80,0x80,0x80,0x80,0x80,0x80,0x50
101};
102
103static UINT8 bPostDecFlags[0x100] =
104{
105 0x92,0x42,0x02,0x02,0x02,0x02,0x02,0x02,0x02,0x02,0x02,0x02,0x02,0x02,0x02,0x02,
106 0x12,0x02,0x02,0x02,0x02,0x02,0x02,0x02,0x02,0x02,0x02,0x02,0x02,0x02,0x02,0x02,
107 0x12,0x02,0x02,0x02,0x02,0x02,0x02,0x02,0x02,0x02,0x02,0x02,0x02,0x02,0x02,0x02,
108 0x12,0x02,0x02,0x02,0x02,0x02,0x02,0x02,0x02,0x02,0x02,0x02,0x02,0x02,0x02,0x02,
109 0x12,0x02,0x02,0x02,0x02,0x02,0x02,0x02,0x02,0x02,0x02,0x02,0x02,0x02,0x02,0x02,
110 0x12,0x02,0x02,0x02,0x02,0x02,0x02,0x02,0x02,0x02,0x02,0x02,0x02,0x02,0x02,0x02,
111 0x12,0x02,0x02,0x02,0x02,0x02,0x02,0x02,0x02,0x02,0x02,0x02,0x02,0x02,0x02,0x02,
112 0x12,0x02,0x02,0x02,0x02,0x02,0x02,0x02,0x02,0x02,0x02,0x02,0x02,0x02,0x02,0x02,
113 0x16,0x82,0x82,0x82,0x82,0x82,0x82,0x82,0x82,0x82,0x82,0x82,0x82,0x82,0x82,0x82,
114 0x92,0x82,0x82,0x82,0x82,0x82,0x82,0x82,0x82,0x82,0x82,0x82,0x82,0x82,0x82,0x82,
115 0x92,0x82,0x82,0x82,0x82,0x82,0x82,0x82,0x82,0x82,0x82,0x82,0x82,0x82,0x82,0x82,
116 0x92,0x82,0x82,0x82,0x82,0x82,0x82,0x82,0x82,0x82,0x82,0x82,0x82,0x82,0x82,0x82,
117 0x92,0x82,0x82,0x82,0x82,0x82,0x82,0x82,0x82,0x82,0x82,0x82,0x82,0x82,0x82,0x82,
118 0x92,0x82,0x82,0x82,0x82,0x82,0x82,0x82,0x82,0x82,0x82,0x82,0x82,0x82,0x82,0x82,
119 0x92,0x82,0x82,0x82,0x82,0x82,0x82,0x82,0x82,0x82,0x82,0x82,0x82,0x82,0x82,0x82,
120 0x92,0x82,0x82,0x82,0x82,0x82,0x82,0x82,0x82,0x82,0x82,0x82,0x82,0x82,0x82,0x82
121};
122
123static UINT8 bPostORFlags[0x100] =
124{
125 0x44,0x00,0x00,0x04,0x00,0x04,0x04,0x00,0x00,0x04,0x04,0x00,0x04,0x00,0x00,0x04,
126 0x00,0x04,0x04,0x00,0x04,0x00,0x00,0x04,0x04,0x00,0x00,0x04,0x00,0x04,0x04,0x00,
127 0x00,0x04,0x04,0x00,0x04,0x00,0x00,0x04,0x04,0x00,0x00,0x04,0x00,0x04,0x04,0x00,
128 0x04,0x00,0x00,0x04,0x00,0x04,0x04,0x00,0x00,0x04,0x04,0x00,0x04,0x00,0x00,0x04,
129 0x00,0x04,0x04,0x00,0x04,0x00,0x00,0x04,0x04,0x00,0x00,0x04,0x00,0x04,0x04,0x00,
130 0x04,0x00,0x00,0x04,0x00,0x04,0x04,0x00,0x00,0x04,0x04,0x00,0x04,0x00,0x00,0x04,
131 0x04,0x00,0x00,0x04,0x00,0x04,0x04,0x00,0x00,0x04,0x04,0x00,0x04,0x00,0x00,0x04,
132 0x00,0x04,0x04,0x00,0x04,0x00,0x00,0x04,0x04,0x00,0x00,0x04,0x00,0x04,0x04,0x00,
133 0x80,0x84,0x84,0x80,0x84,0x80,0x80,0x84,0x84,0x80,0x80,0x84,0x80,0x84,0x84,0x80,
134 0x84,0x80,0x80,0x84,0x80,0x84,0x84,0x80,0x80,0x84,0x84,0x80,0x84,0x80,0x80,0x84,
135 0x84,0x80,0x80,0x84,0x80,0x84,0x84,0x80,0x80,0x84,0x84,0x80,0x84,0x80,0x80,0x84,
136 0x80,0x84,0x84,0x80,0x84,0x80,0x80,0x84,0x84,0x80,0x80,0x84,0x80,0x84,0x84,0x80,
137 0x84,0x80,0x80,0x84,0x80,0x84,0x84,0x80,0x80,0x84,0x84,0x80,0x84,0x80,0x80,0x84,
138 0x80,0x84,0x84,0x80,0x84,0x80,0x80,0x84,0x84,0x80,0x80,0x84,0x80,0x84,0x84,0x80,
139 0x80,0x84,0x84,0x80,0x84,0x80,0x80,0x84,0x84,0x80,0x80,0x84,0x80,0x84,0x84,0x80,
140 0x84,0x80,0x80,0x84,0x80,0x84,0x84,0x80,0x80,0x84,0x84,0x80,0x84,0x80,0x80,0x84
141};
142
143static UINT8 bPostANDFlags[0x100] =
144{
145 0x54,0x10,0x10,0x14,0x10,0x14,0x14,0x10,0x10,0x14,0x14,0x10,0x14,0x10,0x10,0x14,
146 0x10,0x14,0x14,0x10,0x14,0x10,0x10,0x14,0x14,0x10,0x10,0x14,0x10,0x14,0x14,0x10,
147 0x10,0x14,0x14,0x10,0x14,0x10,0x10,0x14,0x14,0x10,0x10,0x14,0x10,0x14,0x14,0x10,
148 0x14,0x10,0x10,0x14,0x10,0x14,0x14,0x10,0x10,0x14,0x14,0x10,0x14,0x10,0x10,0x14,
149 0x10,0x14,0x14,0x10,0x14,0x10,0x10,0x14,0x14,0x10,0x10,0x14,0x10,0x14,0x14,0x10,
150 0x14,0x10,0x10,0x14,0x10,0x14,0x14,0x10,0x10,0x14,0x14,0x10,0x14,0x10,0x10,0x14,
151 0x14,0x10,0x10,0x14,0x10,0x14,0x14,0x10,0x10,0x14,0x14,0x10,0x14,0x10,0x10,0x14,
152 0x10,0x14,0x14,0x10,0x14,0x10,0x10,0x14,0x14,0x10,0x10,0x14,0x10,0x14,0x14,0x10,
153 0x90,0x94,0x94,0x90,0x94,0x90,0x90,0x94,0x94,0x90,0x90,0x94,0x90,0x94,0x94,0x90,
154 0x94,0x90,0x90,0x94,0x90,0x94,0x94,0x90,0x90,0x94,0x94,0x90,0x94,0x90,0x90,0x94,
155 0x94,0x90,0x90,0x94,0x90,0x94,0x94,0x90,0x90,0x94,0x94,0x90,0x94,0x90,0x90,0x94,
156 0x90,0x94,0x94,0x90,0x94,0x90,0x90,0x94,0x94,0x90,0x90,0x94,0x90,0x94,0x94,0x90,
157 0x94,0x90,0x90,0x94,0x90,0x94,0x94,0x90,0x90,0x94,0x94,0x90,0x94,0x90,0x90,0x94,
158 0x90,0x94,0x94,0x90,0x94,0x90,0x90,0x94,0x94,0x90,0x90,0x94,0x90,0x94,0x94,0x90,
159 0x90,0x94,0x94,0x90,0x94,0x90,0x90,0x94,0x94,0x90,0x90,0x94,0x90,0x94,0x94,0x90,
160 0x94,0x90,0x90,0x94,0x90,0x94,0x94,0x90,0x90,0x94,0x94,0x90,0x94,0x90,0x90,0x94
161};
162
163static UINT16 wDAATable[0x800] =
164{
165 0x5400,0x1001,0x1002,0x1403,0x1004,0x1405,0x1406,0x1007,
166 0x1008,0x1409,0x1010,0x1411,0x1412,0x1013,0x1414,0x1015,
167 0x1010,0x1411,0x1412,0x1013,0x1414,0x1015,0x1016,0x1417,
168 0x1418,0x1019,0x1020,0x1421,0x1422,0x1023,0x1424,0x1025,
169 0x1020,0x1421,0x1422,0x1023,0x1424,0x1025,0x1026,0x1427,
170 0x1428,0x1029,0x1430,0x1031,0x1032,0x1433,0x1034,0x1435,
171 0x1430,0x1031,0x1032,0x1433,0x1034,0x1435,0x1436,0x1037,
172 0x1038,0x1439,0x1040,0x1441,0x1442,0x1043,0x1444,0x1045,
173 0x1040,0x1441,0x1442,0x1043,0x1444,0x1045,0x1046,0x1447,
174 0x1448,0x1049,0x1450,0x1051,0x1052,0x1453,0x1054,0x1455,
175 0x1450,0x1051,0x1052,0x1453,0x1054,0x1455,0x1456,0x1057,
176 0x1058,0x1459,0x1460,0x1061,0x1062,0x1463,0x1064,0x1465,
177 0x1460,0x1061,0x1062,0x1463,0x1064,0x1465,0x1466,0x1067,
178 0x1068,0x1469,0x1070,0x1471,0x1472,0x1073,0x1474,0x1075,
179 0x1070,0x1471,0x1472,0x1073,0x1474,0x1075,0x1076,0x1477,
180 0x1478,0x1079,0x9080,0x9481,0x9482,0x9083,0x9484,0x9085,
181 0x9080,0x9481,0x9482,0x9083,0x9484,0x9085,0x9086,0x9487,
182 0x9488,0x9089,0x9490,0x9091,0x9092,0x9493,0x9094,0x9495,
183 0x9490,0x9091,0x9092,0x9493,0x9094,0x9495,0x9496,0x9097,
184 0x9098,0x9499,0x5500,0x1101,0x1102,0x1503,0x1104,0x1505,
185 0x5500,0x1101,0x1102,0x1503,0x1104,0x1505,0x1506,0x1107,
186 0x1108,0x1509,0x1110,0x1511,0x1512,0x1113,0x1514,0x1115,
187 0x1110,0x1511,0x1512,0x1113,0x1514,0x1115,0x1116,0x1517,
188 0x1518,0x1119,0x1120,0x1521,0x1522,0x1123,0x1524,0x1125,
189 0x1120,0x1521,0x1522,0x1123,0x1524,0x1125,0x1126,0x1527,
190 0x1528,0x1129,0x1530,0x1131,0x1132,0x1533,0x1134,0x1535,
191 0x1530,0x1131,0x1132,0x1533,0x1134,0x1535,0x1536,0x1137,
192 0x1138,0x1539,0x1140,0x1541,0x1542,0x1143,0x1544,0x1145,
193 0x1140,0x1541,0x1542,0x1143,0x1544,0x1145,0x1146,0x1547,
194 0x1548,0x1149,0x1550,0x1151,0x1152,0x1553,0x1154,0x1555,
195 0x1550,0x1151,0x1152,0x1553,0x1154,0x1555,0x1556,0x1157,
196 0x1158,0x1559,0x1560,0x1161,0x1162,0x1563,0x1164,0x1565,
197 0x1560,0x1161,0x1162,0x1563,0x1164,0x1565,0x1566,0x1167,
198 0x1168,0x1569,0x1170,0x1571,0x1572,0x1173,0x1574,0x1175,
199 0x1170,0x1571,0x1572,0x1173,0x1574,0x1175,0x1176,0x1577,
200 0x1578,0x1179,0x9180,0x9581,0x9582,0x9183,0x9584,0x9185,
201 0x9180,0x9581,0x9582,0x9183,0x9584,0x9185,0x9186,0x9587,
202 0x9588,0x9189,0x9590,0x9191,0x9192,0x9593,0x9194,0x9595,
203 0x9590,0x9191,0x9192,0x9593,0x9194,0x9595,0x9596,0x9197,
204 0x9198,0x9599,0x95a0,0x91a1,0x91a2,0x95a3,0x91a4,0x95a5,
205 0x95a0,0x91a1,0x91a2,0x95a3,0x91a4,0x95a5,0x95a6,0x91a7,
206 0x91a8,0x95a9,0x91b0,0x95b1,0x95b2,0x91b3,0x95b4,0x91b5,
207 0x91b0,0x95b1,0x95b2,0x91b3,0x95b4,0x91b5,0x91b6,0x95b7,
208 0x95b8,0x91b9,0x95c0,0x91c1,0x91c2,0x95c3,0x91c4,0x95c5,
209 0x95c0,0x91c1,0x91c2,0x95c3,0x91c4,0x95c5,0x95c6,0x91c7,
210 0x91c8,0x95c9,0x91d0,0x95d1,0x95d2,0x91d3,0x95d4,0x91d5,
211 0x91d0,0x95d1,0x95d2,0x91d3,0x95d4,0x91d5,0x91d6,0x95d7,
212 0x95d8,0x91d9,0x91e0,0x95e1,0x95e2,0x91e3,0x95e4,0x91e5,
213 0x91e0,0x95e1,0x95e2,0x91e3,0x95e4,0x91e5,0x91e6,0x95e7,
214 0x95e8,0x91e9,0x95f0,0x91f1,0x91f2,0x95f3,0x91f4,0x95f5,
215 0x95f0,0x91f1,0x91f2,0x95f3,0x91f4,0x95f5,0x95f6,0x91f7,
216 0x91f8,0x95f9,0x5500,0x1101,0x1102,0x1503,0x1104,0x1505,
217 0x5500,0x1101,0x1102,0x1503,0x1104,0x1505,0x1506,0x1107,
218 0x1108,0x1509,0x1110,0x1511,0x1512,0x1113,0x1514,0x1115,
219 0x1110,0x1511,0x1512,0x1113,0x1514,0x1115,0x1116,0x1517,
220 0x1518,0x1119,0x1120,0x1521,0x1522,0x1123,0x1524,0x1125,
221 0x1120,0x1521,0x1522,0x1123,0x1524,0x1125,0x1126,0x1527,
222 0x1528,0x1129,0x1530,0x1131,0x1132,0x1533,0x1134,0x1535,
223 0x1530,0x1131,0x1132,0x1533,0x1134,0x1535,0x1536,0x1137,
224 0x1138,0x1539,0x1140,0x1541,0x1542,0x1143,0x1544,0x1145,
225 0x1140,0x1541,0x1542,0x1143,0x1544,0x1145,0x1146,0x1547,
226 0x1548,0x1149,0x1550,0x1151,0x1152,0x1553,0x1154,0x1555,
227 0x1550,0x1151,0x1152,0x1553,0x1154,0x1555,0x1556,0x1157,
228 0x1158,0x1559,0x1560,0x1161,0x1162,0x1563,0x1164,0x1565,
229 0x1406,0x1007,0x1008,0x1409,0x140a,0x100b,0x140c,0x100d,
230 0x100e,0x140f,0x1010,0x1411,0x1412,0x1013,0x1414,0x1015,
231 0x1016,0x1417,0x1418,0x1019,0x101a,0x141b,0x101c,0x141d,
232 0x141e,0x101f,0x1020,0x1421,0x1422,0x1023,0x1424,0x1025,
233 0x1026,0x1427,0x1428,0x1029,0x102a,0x142b,0x102c,0x142d,
234 0x142e,0x102f,0x1430,0x1031,0x1032,0x1433,0x1034,0x1435,
235 0x1436,0x1037,0x1038,0x1439,0x143a,0x103b,0x143c,0x103d,
236 0x103e,0x143f,0x1040,0x1441,0x1442,0x1043,0x1444,0x1045,
237 0x1046,0x1447,0x1448,0x1049,0x104a,0x144b,0x104c,0x144d,
238 0x144e,0x104f,0x1450,0x1051,0x1052,0x1453,0x1054,0x1455,
239 0x1456,0x1057,0x1058,0x1459,0x145a,0x105b,0x145c,0x105d,
240 0x105e,0x145f,0x1460,0x1061,0x1062,0x1463,0x1064,0x1465,
241 0x1466,0x1067,0x1068,0x1469,0x146a,0x106b,0x146c,0x106d,
242 0x106e,0x146f,0x1070,0x1471,0x1472,0x1073,0x1474,0x1075,
243 0x1076,0x1477,0x1478,0x1079,0x107a,0x147b,0x107c,0x147d,
244 0x147e,0x107f,0x9080,0x9481,0x9482,0x9083,0x9484,0x9085,
245 0x9086,0x9487,0x9488,0x9089,0x908a,0x948b,0x908c,0x948d,
246 0x948e,0x908f,0x9490,0x9091,0x9092,0x9493,0x9094,0x9495,
247 0x9496,0x9097,0x9098,0x9499,0x949a,0x909b,0x949c,0x909d,
248 0x909e,0x949f,0x5500,0x1101,0x1102,0x1503,0x1104,0x1505,
249 0x1506,0x1107,0x1108,0x1509,0x150a,0x110b,0x150c,0x110d,
250 0x110e,0x150f,0x1110,0x1511,0x1512,0x1113,0x1514,0x1115,
251 0x1116,0x1517,0x1518,0x1119,0x111a,0x151b,0x111c,0x151d,
252 0x151e,0x111f,0x1120,0x1521,0x1522,0x1123,0x1524,0x1125,
253 0x1126,0x1527,0x1528,0x1129,0x112a,0x152b,0x112c,0x152d,
254 0x152e,0x112f,0x1530,0x1131,0x1132,0x1533,0x1134,0x1535,
255 0x1536,0x1137,0x1138,0x1539,0x153a,0x113b,0x153c,0x113d,
256 0x113e,0x153f,0x1140,0x1541,0x1542,0x1143,0x1544,0x1145,
257 0x1146,0x1547,0x1548,0x1149,0x114a,0x154b,0x114c,0x154d,
258 0x154e,0x114f,0x1550,0x1151,0x1152,0x1553,0x1154,0x1555,
259 0x1556,0x1157,0x1158,0x1559,0x155a,0x115b,0x155c,0x115d,
260 0x115e,0x155f,0x1560,0x1161,0x1162,0x1563,0x1164,0x1565,
261 0x1566,0x1167,0x1168,0x1569,0x156a,0x116b,0x156c,0x116d,
262 0x116e,0x156f,0x1170,0x1571,0x1572,0x1173,0x1574,0x1175,
263 0x1176,0x1577,0x1578,0x1179,0x117a,0x157b,0x117c,0x157d,
264 0x157e,0x117f,0x9180,0x9581,0x9582,0x9183,0x9584,0x9185,
265 0x9186,0x9587,0x9588,0x9189,0x918a,0x958b,0x918c,0x958d,
266 0x958e,0x918f,0x9590,0x9191,0x9192,0x9593,0x9194,0x9595,
267 0x9596,0x9197,0x9198,0x9599,0x959a,0x919b,0x959c,0x919d,
268 0x919e,0x959f,0x95a0,0x91a1,0x91a2,0x95a3,0x91a4,0x95a5,
269 0x95a6,0x91a7,0x91a8,0x95a9,0x95aa,0x91ab,0x95ac,0x91ad,
270 0x91ae,0x95af,0x91b0,0x95b1,0x95b2,0x91b3,0x95b4,0x91b5,
271 0x91b6,0x95b7,0x95b8,0x91b9,0x91ba,0x95bb,0x91bc,0x95bd,
272 0x95be,0x91bf,0x95c0,0x91c1,0x91c2,0x95c3,0x91c4,0x95c5,
273 0x95c6,0x91c7,0x91c8,0x95c9,0x95ca,0x91cb,0x95cc,0x91cd,
274 0x91ce,0x95cf,0x91d0,0x95d1,0x95d2,0x91d3,0x95d4,0x91d5,
275 0x91d6,0x95d7,0x95d8,0x91d9,0x91da,0x95db,0x91dc,0x95dd,
276 0x95de,0x91df,0x91e0,0x95e1,0x95e2,0x91e3,0x95e4,0x91e5,
277 0x91e6,0x95e7,0x95e8,0x91e9,0x91ea,0x95eb,0x91ec,0x95ed,
278 0x95ee,0x91ef,0x95f0,0x91f1,0x91f2,0x95f3,0x91f4,0x95f5,
279 0x95f6,0x91f7,0x91f8,0x95f9,0x95fa,0x91fb,0x95fc,0x91fd,
280 0x91fe,0x95ff,0x5500,0x1101,0x1102,0x1503,0x1104,0x1505,
281 0x1506,0x1107,0x1108,0x1509,0x150a,0x110b,0x150c,0x110d,
282 0x110e,0x150f,0x1110,0x1511,0x1512,0x1113,0x1514,0x1115,
283 0x1116,0x1517,0x1518,0x1119,0x111a,0x151b,0x111c,0x151d,
284 0x151e,0x111f,0x1120,0x1521,0x1522,0x1123,0x1524,0x1125,
285 0x1126,0x1527,0x1528,0x1129,0x112a,0x152b,0x112c,0x152d,
286 0x152e,0x112f,0x1530,0x1131,0x1132,0x1533,0x1134,0x1535,
287 0x1536,0x1137,0x1138,0x1539,0x153a,0x113b,0x153c,0x113d,
288 0x113e,0x153f,0x1140,0x1541,0x1542,0x1143,0x1544,0x1145,
289 0x1146,0x1547,0x1548,0x1149,0x114a,0x154b,0x114c,0x154d,
290 0x154e,0x114f,0x1550,0x1151,0x1152,0x1553,0x1154,0x1555,
291 0x1556,0x1157,0x1158,0x1559,0x155a,0x115b,0x155c,0x115d,
292 0x115e,0x155f,0x1560,0x1161,0x1162,0x1563,0x1164,0x1565,
293 0x5600,0x1201,0x1202,0x1603,0x1204,0x1605,0x1606,0x1207,
294 0x1208,0x1609,0x1204,0x1605,0x1606,0x1207,0x1208,0x1609,
295 0x1210,0x1611,0x1612,0x1213,0x1614,0x1215,0x1216,0x1617,
296 0x1618,0x1219,0x1614,0x1215,0x1216,0x1617,0x1618,0x1219,
297 0x1220,0x1621,0x1622,0x1223,0x1624,0x1225,0x1226,0x1627,
298 0x1628,0x1229,0x1624,0x1225,0x1226,0x1627,0x1628,0x1229,
299 0x1630,0x1231,0x1232,0x1633,0x1234,0x1635,0x1636,0x1237,
300 0x1238,0x1639,0x1234,0x1635,0x1636,0x1237,0x1238,0x1639,
301 0x1240,0x1641,0x1642,0x1243,0x1644,0x1245,0x1246,0x1647,
302 0x1648,0x1249,0x1644,0x1245,0x1246,0x1647,0x1648,0x1249,
303 0x1650,0x1251,0x1252,0x1653,0x1254,0x1655,0x1656,0x1257,
304 0x1258,0x1659,0x1254,0x1655,0x1656,0x1257,0x1258,0x1659,
305 0x1660,0x1261,0x1262,0x1663,0x1264,0x1665,0x1666,0x1267,
306 0x1268,0x1669,0x1264,0x1665,0x1666,0x1267,0x1268,0x1669,
307 0x1270,0x1671,0x1672,0x1273,0x1674,0x1275,0x1276,0x1677,
308 0x1678,0x1279,0x1674,0x1275,0x1276,0x1677,0x1678,0x1279,
309 0x9280,0x9681,0x9682,0x9283,0x9684,0x9285,0x9286,0x9687,
310 0x9688,0x9289,0x9684,0x9285,0x9286,0x9687,0x9688,0x9289,
311 0x9690,0x9291,0x9292,0x9693,0x9294,0x9695,0x9696,0x9297,
312 0x9298,0x9699,0x1334,0x1735,0x1736,0x1337,0x1338,0x1739,
313 0x1340,0x1741,0x1742,0x1343,0x1744,0x1345,0x1346,0x1747,
314 0x1748,0x1349,0x1744,0x1345,0x1346,0x1747,0x1748,0x1349,
315 0x1750,0x1351,0x1352,0x1753,0x1354,0x1755,0x1756,0x1357,
316 0x1358,0x1759,0x1354,0x1755,0x1756,0x1357,0x1358,0x1759,
317 0x1760,0x1361,0x1362,0x1763,0x1364,0x1765,0x1766,0x1367,
318 0x1368,0x1769,0x1364,0x1765,0x1766,0x1367,0x1368,0x1769,
319 0x1370,0x1771,0x1772,0x1373,0x1774,0x1375,0x1376,0x1777,
320 0x1778,0x1379,0x1774,0x1375,0x1376,0x1777,0x1778,0x1379,
321 0x9380,0x9781,0x9782,0x9383,0x9784,0x9385,0x9386,0x9787,
322 0x9788,0x9389,0x9784,0x9385,0x9386,0x9787,0x9788,0x9389,
323 0x9790,0x9391,0x9392,0x9793,0x9394,0x9795,0x9796,0x9397,
324 0x9398,0x9799,0x9394,0x9795,0x9796,0x9397,0x9398,0x9799,
325 0x97a0,0x93a1,0x93a2,0x97a3,0x93a4,0x97a5,0x97a6,0x93a7,
326 0x93a8,0x97a9,0x93a4,0x97a5,0x97a6,0x93a7,0x93a8,0x97a9,
327 0x93b0,0x97b1,0x97b2,0x93b3,0x97b4,0x93b5,0x93b6,0x97b7,
328 0x97b8,0x93b9,0x97b4,0x93b5,0x93b6,0x97b7,0x97b8,0x93b9,
329 0x97c0,0x93c1,0x93c2,0x97c3,0x93c4,0x97c5,0x97c6,0x93c7,
330 0x93c8,0x97c9,0x93c4,0x97c5,0x97c6,0x93c7,0x93c8,0x97c9,
331 0x93d0,0x97d1,0x97d2,0x93d3,0x97d4,0x93d5,0x93d6,0x97d7,
332 0x97d8,0x93d9,0x97d4,0x93d5,0x93d6,0x97d7,0x97d8,0x93d9,
333 0x93e0,0x97e1,0x97e2,0x93e3,0x97e4,0x93e5,0x93e6,0x97e7,
334 0x97e8,0x93e9,0x97e4,0x93e5,0x93e6,0x97e7,0x97e8,0x93e9,
335 0x97f0,0x93f1,0x93f2,0x97f3,0x93f4,0x97f5,0x97f6,0x93f7,
336 0x93f8,0x97f9,0x93f4,0x97f5,0x97f6,0x93f7,0x93f8,0x97f9,
337 0x5700,0x1301,0x1302,0x1703,0x1304,0x1705,0x1706,0x1307,
338 0x1308,0x1709,0x1304,0x1705,0x1706,0x1307,0x1308,0x1709,
339 0x1310,0x1711,0x1712,0x1313,0x1714,0x1315,0x1316,0x1717,
340 0x1718,0x1319,0x1714,0x1315,0x1316,0x1717,0x1718,0x1319,
341 0x1320,0x1721,0x1722,0x1323,0x1724,0x1325,0x1326,0x1727,
342 0x1728,0x1329,0x1724,0x1325,0x1326,0x1727,0x1728,0x1329,
343 0x1730,0x1331,0x1332,0x1733,0x1334,0x1735,0x1736,0x1337,
344 0x1338,0x1739,0x1334,0x1735,0x1736,0x1337,0x1338,0x1739,
345 0x1340,0x1741,0x1742,0x1343,0x1744,0x1345,0x1346,0x1747,
346 0x1748,0x1349,0x1744,0x1345,0x1346,0x1747,0x1748,0x1349,
347 0x1750,0x1351,0x1352,0x1753,0x1354,0x1755,0x1756,0x1357,
348 0x1358,0x1759,0x1354,0x1755,0x1756,0x1357,0x1358,0x1759,
349 0x1760,0x1361,0x1362,0x1763,0x1364,0x1765,0x1766,0x1367,
350 0x1368,0x1769,0x1364,0x1765,0x1766,0x1367,0x1368,0x1769,
351 0x1370,0x1771,0x1772,0x1373,0x1774,0x1375,0x1376,0x1777,
352 0x1778,0x1379,0x1774,0x1375,0x1376,0x1777,0x1778,0x1379,
353 0x9380,0x9781,0x9782,0x9383,0x9784,0x9385,0x9386,0x9787,
354 0x9788,0x9389,0x9784,0x9385,0x9386,0x9787,0x9788,0x9389,
355 0x9790,0x9391,0x9392,0x9793,0x9394,0x9795,0x9796,0x9397,
356 0x9398,0x9799,0x9394,0x9795,0x9796,0x9397,0x9398,0x9799,
357 0x97fa,0x93fb,0x97fc,0x93fd,0x93fe,0x97ff,0x5600,0x1201,
358 0x1202,0x1603,0x1204,0x1605,0x1606,0x1207,0x1208,0x1609,
359 0x160a,0x120b,0x160c,0x120d,0x120e,0x160f,0x1210,0x1611,
360 0x1612,0x1213,0x1614,0x1215,0x1216,0x1617,0x1618,0x1219,
361 0x121a,0x161b,0x121c,0x161d,0x161e,0x121f,0x1220,0x1621,
362 0x1622,0x1223,0x1624,0x1225,0x1226,0x1627,0x1628,0x1229,
363 0x122a,0x162b,0x122c,0x162d,0x162e,0x122f,0x1630,0x1231,
364 0x1232,0x1633,0x1234,0x1635,0x1636,0x1237,0x1238,0x1639,
365 0x163a,0x123b,0x163c,0x123d,0x123e,0x163f,0x1240,0x1641,
366 0x1642,0x1243,0x1644,0x1245,0x1246,0x1647,0x1648,0x1249,
367 0x124a,0x164b,0x124c,0x164d,0x164e,0x124f,0x1650,0x1251,
368 0x1252,0x1653,0x1254,0x1655,0x1656,0x1257,0x1258,0x1659,
369 0x165a,0x125b,0x165c,0x125d,0x125e,0x165f,0x1660,0x1261,
370 0x1262,0x1663,0x1264,0x1665,0x1666,0x1267,0x1268,0x1669,
371 0x166a,0x126b,0x166c,0x126d,0x126e,0x166f,0x1270,0x1671,
372 0x1672,0x1273,0x1674,0x1275,0x1276,0x1677,0x1678,0x1279,
373 0x127a,0x167b,0x127c,0x167d,0x167e,0x127f,0x9280,0x9681,
374 0x9682,0x9283,0x9684,0x9285,0x9286,0x9687,0x9688,0x9289,
375 0x928a,0x968b,0x928c,0x968d,0x968e,0x928f,0x9690,0x9291,
376 0x9292,0x9693,0x1334,0x1735,0x1736,0x1337,0x1338,0x1739,
377 0x173a,0x133b,0x173c,0x133d,0x133e,0x173f,0x1340,0x1741,
378 0x1742,0x1343,0x1744,0x1345,0x1346,0x1747,0x1748,0x1349,
379 0x134a,0x174b,0x134c,0x174d,0x174e,0x134f,0x1750,0x1351,
380 0x1352,0x1753,0x1354,0x1755,0x1756,0x1357,0x1358,0x1759,
381 0x175a,0x135b,0x175c,0x135d,0x135e,0x175f,0x1760,0x1361,
382 0x1362,0x1763,0x1364,0x1765,0x1766,0x1367,0x1368,0x1769,
383 0x176a,0x136b,0x176c,0x136d,0x136e,0x176f,0x1370,0x1771,
384 0x1772,0x1373,0x1774,0x1375,0x1376,0x1777,0x1778,0x1379,
385 0x137a,0x177b,0x137c,0x177d,0x177e,0x137f,0x9380,0x9781,
386 0x9782,0x9383,0x9784,0x9385,0x9386,0x9787,0x9788,0x9389,
387 0x938a,0x978b,0x938c,0x978d,0x978e,0x938f,0x9790,0x9391,
388 0x9392,0x9793,0x9394,0x9795,0x9796,0x9397,0x9398,0x9799,
389 0x979a,0x939b,0x979c,0x939d,0x939e,0x979f,0x97a0,0x93a1,
390 0x93a2,0x97a3,0x93a4,0x97a5,0x97a6,0x93a7,0x93a8,0x97a9,
391 0x97aa,0x93ab,0x97ac,0x93ad,0x93ae,0x97af,0x93b0,0x97b1,
392 0x97b2,0x93b3,0x97b4,0x93b5,0x93b6,0x97b7,0x97b8,0x93b9,
393 0x93ba,0x97bb,0x93bc,0x97bd,0x97be,0x93bf,0x97c0,0x93c1,
394 0x93c2,0x97c3,0x93c4,0x97c5,0x97c6,0x93c7,0x93c8,0x97c9,
395 0x97ca,0x93cb,0x97cc,0x93cd,0x93ce,0x97cf,0x93d0,0x97d1,
396 0x97d2,0x93d3,0x97d4,0x93d5,0x93d6,0x97d7,0x97d8,0x93d9,
397 0x93da,0x97db,0x93dc,0x97dd,0x97de,0x93df,0x93e0,0x97e1,
398 0x97e2,0x93e3,0x97e4,0x93e5,0x93e6,0x97e7,0x97e8,0x93e9,
399 0x93ea,0x97eb,0x93ec,0x97ed,0x97ee,0x93ef,0x97f0,0x93f1,
400 0x93f2,0x97f3,0x93f4,0x97f5,0x97f6,0x93f7,0x93f8,0x97f9,
401 0x97fa,0x93fb,0x97fc,0x93fd,0x93fe,0x97ff,0x5700,0x1301,
402 0x1302,0x1703,0x1304,0x1705,0x1706,0x1307,0x1308,0x1709,
403 0x170a,0x130b,0x170c,0x130d,0x130e,0x170f,0x1310,0x1711,
404 0x1712,0x1313,0x1714,0x1315,0x1316,0x1717,0x1718,0x1319,
405 0x131a,0x171b,0x131c,0x171d,0x171e,0x131f,0x1320,0x1721,
406 0x1722,0x1323,0x1724,0x1325,0x1326,0x1727,0x1728,0x1329,
407 0x132a,0x172b,0x132c,0x172d,0x172e,0x132f,0x1730,0x1331,
408 0x1332,0x1733,0x1334,0x1735,0x1736,0x1337,0x1338,0x1739,
409 0x173a,0x133b,0x173c,0x133d,0x133e,0x173f,0x1340,0x1741,
410 0x1742,0x1343,0x1744,0x1345,0x1346,0x1747,0x1748,0x1349,
411 0x134a,0x174b,0x134c,0x174d,0x174e,0x134f,0x1750,0x1351,
412 0x1352,0x1753,0x1354,0x1755,0x1756,0x1357,0x1358,0x1759,
413 0x175a,0x135b,0x175c,0x135d,0x135e,0x175f,0x1760,0x1361,
414 0x1362,0x1763,0x1364,0x1765,0x1766,0x1367,0x1368,0x1769,
415 0x176a,0x136b,0x176c,0x136d,0x136e,0x176f,0x1370,0x1771,
416 0x1772,0x1373,0x1774,0x1375,0x1376,0x1777,0x1778,0x1379,
417 0x137a,0x177b,0x137c,0x177d,0x177e,0x137f,0x9380,0x9781,
418 0x9782,0x9383,0x9784,0x9385,0x9386,0x9787,0x9788,0x9389,
419 0x938a,0x978b,0x938c,0x978d,0x978e,0x938f,0x9790,0x9391,
420 0x9392,0x9793,0x9394,0x9795,0x9796,0x9397,0x9398,0x9799
421};
422
423void DDFDCBHandler(UINT32 dwWhich);
424
425
426static void InvalidInstruction(UINT32 dwCount)
427{
428 pbPC -= dwCount; /* Invalid instruction - back up */
429 dwReturnCode = (UINT32) pbPC - (UINT32) cpu.z80Base;
430 dwOriginalCycles -= sdwCyclesRemaining;
431 sdwCyclesRemaining = 0;
432}
433
434void CBHandler(void)
435{
436 switch (*pbPC++)
437 {
438 case 0x00:
439 {
440 sdwCyclesRemaining -= 8;
441 cpu.z80F &= ~(Z80_FLAG_ZERO | Z80_FLAG_SIGN | Z80_FLAG_HALF_CARRY | Z80_FLAG_OVERFLOW_PARITY | Z80_FLAG_NEGATIVE | Z80_FLAG_CARRY);
442 bTemp2 = (cpu.z80B >> 7);
443 cpu.z80B = (cpu.z80B << 1) | bTemp2;
444 cpu.z80F |= bTemp2 | bPostORFlags[cpu.z80B];
445 break;
446 }
447 case 0x01:
448 {
449 sdwCyclesRemaining -= 8;
450 cpu.z80F &= ~(Z80_FLAG_ZERO | Z80_FLAG_SIGN | Z80_FLAG_HALF_CARRY | Z80_FLAG_OVERFLOW_PARITY | Z80_FLAG_NEGATIVE | Z80_FLAG_CARRY);
451 bTemp2 = (cpu.z80C >> 7);
452 cpu.z80C = (cpu.z80C << 1) | bTemp2;
453 cpu.z80F |= bTemp2 | bPostORFlags[cpu.z80C];
454 break;
455 }
456 case 0x02:
457 {
458 sdwCyclesRemaining -= 8;
459 cpu.z80F &= ~(Z80_FLAG_ZERO | Z80_FLAG_SIGN | Z80_FLAG_HALF_CARRY | Z80_FLAG_OVERFLOW_PARITY | Z80_FLAG_NEGATIVE | Z80_FLAG_CARRY);
460 bTemp2 = (cpu.z80D >> 7);
461 cpu.z80D = (cpu.z80D << 1) | bTemp2;
462 cpu.z80F |= bTemp2 | bPostORFlags[cpu.z80D];
463 break;
464 }
465 case 0x03:
466 {
467 sdwCyclesRemaining -= 8;
468 cpu.z80F &= ~(Z80_FLAG_ZERO | Z80_FLAG_SIGN | Z80_FLAG_HALF_CARRY | Z80_FLAG_OVERFLOW_PARITY | Z80_FLAG_NEGATIVE | Z80_FLAG_CARRY);
469 bTemp2 = (cpu.z80E >> 7);
470 cpu.z80E = (cpu.z80E << 1) | bTemp2;
471 cpu.z80F |= bTemp2 | bPostORFlags[cpu.z80E];
472 break;
473 }
474 case 0x04:
475 {
476 sdwCyclesRemaining -= 8;
477 cpu.z80F &= ~(Z80_FLAG_ZERO | Z80_FLAG_SIGN | Z80_FLAG_HALF_CARRY | Z80_FLAG_OVERFLOW_PARITY | Z80_FLAG_NEGATIVE | Z80_FLAG_CARRY);
478 bTemp2 = (cpu.z80H >> 7);
479 cpu.z80H = (cpu.z80H << 1) | bTemp2;
480 cpu.z80F |= bTemp2 | bPostORFlags[cpu.z80H];
481 break;
482 }
483 case 0x05:
484 {
485 sdwCyclesRemaining -= 8;
486 cpu.z80F &= ~(Z80_FLAG_ZERO | Z80_FLAG_SIGN | Z80_FLAG_HALF_CARRY | Z80_FLAG_OVERFLOW_PARITY | Z80_FLAG_NEGATIVE | Z80_FLAG_CARRY);
487 bTemp2 = (cpu.z80L >> 7);
488 cpu.z80L = (cpu.z80L << 1) | bTemp2;
489 cpu.z80F |= bTemp2 | bPostORFlags[cpu.z80L];
490 break;
491 }
492 case 0x06:
493 {
494 sdwCyclesRemaining -= 15;
495 psMemRead = cpu.z80MemRead; /* Beginning of our handler */
496 while (psMemRead->lowAddr != 0xffffffff)
497 {
498 if ((cpu.z80HL >= psMemRead->lowAddr) && (cpu.z80HL <= psMemRead->highAddr))
499 {
500 cpu.z80pc = (UINT32) pbPC - (UINT32) cpu.z80Base;
501 if (psMemRead->memoryCall)
502 {
503 bTemp = psMemRead->memoryCall(cpu.z80HL, psMemRead);
504 }
505 else
506 {
507 bTemp = *((UINT8 *) psMemRead->pUserArea + (cpu.z80HL - psMemRead->lowAddr));
508 }
509 psMemRead = NULL;
510 break;
511 }
512 ++psMemRead;
513 }
514
515 if (psMemRead)
516 {
517 bTemp = cpu.z80Base[cpu.z80HL];
518 }
519
520 cpu.z80F &= ~(Z80_FLAG_ZERO | Z80_FLAG_SIGN | Z80_FLAG_HALF_CARRY | Z80_FLAG_OVERFLOW_PARITY | Z80_FLAG_NEGATIVE | Z80_FLAG_CARRY);
521 bTemp2 = (bTemp >> 7);
522 bTemp = (bTemp << 1) | bTemp2;
523 cpu.z80F |= bTemp2 | bPostORFlags[bTemp];
524 psMemWrite = cpu.z80MemWrite; /* Beginning of our handler */
525 while (psMemWrite->lowAddr != 0xffffffff)
526 {
527 if ((cpu.z80HL >= psMemWrite->lowAddr) && (cpu.z80HL <= psMemWrite->highAddr))
528 {
529 cpu.z80pc = (UINT32) pbPC - (UINT32) cpu.z80Base;
530 if (psMemWrite->memoryCall)
531 {
532 psMemWrite->memoryCall(cpu.z80HL, bTemp, psMemWrite);
533 }
534 else
535 {
536 *((UINT8 *) psMemWrite->pUserArea + (cpu.z80HL - psMemWrite->lowAddr)) = bTemp;
537 }
538 psMemWrite = NULL;
539 break;
540 }
541 ++psMemWrite;
542 }
543
544 if (psMemWrite)
545 {
546 cpu.z80Base[cpu.z80HL] = (UINT8) bTemp;
547 }
548
549 break;
550 }
551 case 0x07:
552 {
553 sdwCyclesRemaining -= 8;
554 cpu.z80F &= ~(Z80_FLAG_ZERO | Z80_FLAG_SIGN | Z80_FLAG_HALF_CARRY | Z80_FLAG_OVERFLOW_PARITY | Z80_FLAG_NEGATIVE | Z80_FLAG_CARRY);
555 bTemp2 = (cpu.z80A >> 7);
556 cpu.z80A = (cpu.z80A << 1) | bTemp2;
557 cpu.z80F |= bTemp2 | bPostORFlags[cpu.z80A];
558 break;
559 }
560 case 0x08:
561 {
562 sdwCyclesRemaining -= 8;
563 cpu.z80F &= ~(Z80_FLAG_ZERO | Z80_FLAG_SIGN | Z80_FLAG_HALF_CARRY | Z80_FLAG_OVERFLOW_PARITY | Z80_FLAG_NEGATIVE | Z80_FLAG_CARRY);
564 cpu.z80F |= (cpu.z80B & Z80_FLAG_CARRY);
565 cpu.z80B = (cpu.z80B >> 1) | (cpu.z80B << 7);
566 cpu.z80F |= bPostORFlags[cpu.z80B];
567 break;
568 }
569 case 0x09:
570 {
571 sdwCyclesRemaining -= 8;
572 cpu.z80F &= ~(Z80_FLAG_ZERO | Z80_FLAG_SIGN | Z80_FLAG_HALF_CARRY | Z80_FLAG_OVERFLOW_PARITY | Z80_FLAG_NEGATIVE | Z80_FLAG_CARRY);
573 cpu.z80F |= (cpu.z80C & Z80_FLAG_CARRY);
574 cpu.z80C = (cpu.z80C >> 1) | (cpu.z80C << 7);
575 cpu.z80F |= bPostORFlags[cpu.z80C];
576 break;
577 }
578 case 0x0a:
579 {
580 sdwCyclesRemaining -= 8;
581 cpu.z80F &= ~(Z80_FLAG_ZERO | Z80_FLAG_SIGN | Z80_FLAG_HALF_CARRY | Z80_FLAG_OVERFLOW_PARITY | Z80_FLAG_NEGATIVE | Z80_FLAG_CARRY);
582 cpu.z80F |= (cpu.z80D & Z80_FLAG_CARRY);
583 cpu.z80D = (cpu.z80D >> 1) | (cpu.z80D << 7);
584 cpu.z80F |= bPostORFlags[cpu.z80D];
585 break;
586 }
587 case 0x0b:
588 {
589 sdwCyclesRemaining -= 8;
590 cpu.z80F &= ~(Z80_FLAG_ZERO | Z80_FLAG_SIGN | Z80_FLAG_HALF_CARRY | Z80_FLAG_OVERFLOW_PARITY | Z80_FLAG_NEGATIVE | Z80_FLAG_CARRY);
591 cpu.z80F |= (cpu.z80E & Z80_FLAG_CARRY);
592 cpu.z80E = (cpu.z80E >> 1) | (cpu.z80E << 7);
593 cpu.z80F |= bPostORFlags[cpu.z80E];
594 break;
595 }
596 case 0x0c:
597 {
598 sdwCyclesRemaining -= 8;
599 cpu.z80F &= ~(Z80_FLAG_ZERO | Z80_FLAG_SIGN | Z80_FLAG_HALF_CARRY | Z80_FLAG_OVERFLOW_PARITY | Z80_FLAG_NEGATIVE | Z80_FLAG_CARRY);
600 cpu.z80F |= (cpu.z80H & Z80_FLAG_CARRY);
601 cpu.z80H = (cpu.z80H >> 1) | (cpu.z80H << 7);
602 cpu.z80F |= bPostORFlags[cpu.z80H];
603 break;
604 }
605 case 0x0d:
606 {
607 sdwCyclesRemaining -= 8;
608 cpu.z80F &= ~(Z80_FLAG_ZERO | Z80_FLAG_SIGN | Z80_FLAG_HALF_CARRY | Z80_FLAG_OVERFLOW_PARITY | Z80_FLAG_NEGATIVE | Z80_FLAG_CARRY);
609 cpu.z80F |= (cpu.z80L & Z80_FLAG_CARRY);
610 cpu.z80L = (cpu.z80L >> 1) | (cpu.z80L << 7);
611 cpu.z80F |= bPostORFlags[cpu.z80L];
612 break;
613 }
614 case 0x0e:
615 {
616 sdwCyclesRemaining -= 15;
617 psMemRead = cpu.z80MemRead; /* Beginning of our handler */
618 while (psMemRead->lowAddr != 0xffffffff)
619 {
620 if ((cpu.z80HL >= psMemRead->lowAddr) && (cpu.z80HL <= psMemRead->highAddr))
621 {
622 cpu.z80pc = (UINT32) pbPC - (UINT32) cpu.z80Base;
623 if (psMemRead->memoryCall)
624 {
625 bTemp = psMemRead->memoryCall(cpu.z80HL, psMemRead);
626 }
627 else
628 {
629 bTemp = *((UINT8 *) psMemRead->pUserArea + (cpu.z80HL - psMemRead->lowAddr));
630 }
631 psMemRead = NULL;
632 break;
633 }
634 ++psMemRead;
635 }
636
637 if (psMemRead)
638 {
639 bTemp = cpu.z80Base[cpu.z80HL];
640 }
641
642 cpu.z80F &= ~(Z80_FLAG_ZERO | Z80_FLAG_SIGN | Z80_FLAG_HALF_CARRY | Z80_FLAG_OVERFLOW_PARITY | Z80_FLAG_NEGATIVE | Z80_FLAG_CARRY);
643 cpu.z80F |= (bTemp & Z80_FLAG_CARRY);
644 bTemp = (bTemp >> 1) | (bTemp << 7);
645 cpu.z80F |= bPostORFlags[bTemp];
646 psMemWrite = cpu.z80MemWrite; /* Beginning of our handler */
647 while (psMemWrite->lowAddr != 0xffffffff)
648 {
649 if ((cpu.z80HL >= psMemWrite->lowAddr) && (cpu.z80HL <= psMemWrite->highAddr))
650 {
651 cpu.z80pc = (UINT32) pbPC - (UINT32) cpu.z80Base;
652 if (psMemWrite->memoryCall)
653 {
654 psMemWrite->memoryCall(cpu.z80HL, bTemp, psMemWrite);
655 }
656 else
657 {
658 *((UINT8 *) psMemWrite->pUserArea + (cpu.z80HL - psMemWrite->lowAddr)) = bTemp;
659 }
660 psMemWrite = NULL;
661 break;
662 }
663 ++psMemWrite;
664 }
665
666 if (psMemWrite)
667 {
668 cpu.z80Base[cpu.z80HL] = (UINT8) bTemp;
669 }
670
671 break;
672 }
673 case 0x0f:
674 {
675 sdwCyclesRemaining -= 8;
676 cpu.z80F &= ~(Z80_FLAG_ZERO | Z80_FLAG_SIGN | Z80_FLAG_HALF_CARRY | Z80_FLAG_OVERFLOW_PARITY | Z80_FLAG_NEGATIVE | Z80_FLAG_CARRY);
677 cpu.z80F |= (cpu.z80A & Z80_FLAG_CARRY);
678 cpu.z80A = (cpu.z80A >> 1) | (cpu.z80A << 7);
679 cpu.z80F |= bPostORFlags[cpu.z80A];
680 break;
681 }
682 case 0x10:
683 {
684 sdwCyclesRemaining -= 8;
685 bTemp2 = cpu.z80F & Z80_FLAG_CARRY;
686 cpu.z80F &= ~(Z80_FLAG_ZERO | Z80_FLAG_SIGN | Z80_FLAG_HALF_CARRY | Z80_FLAG_OVERFLOW_PARITY | Z80_FLAG_NEGATIVE | Z80_FLAG_CARRY);
687 cpu.z80F |= (cpu.z80B >> 7);
688 cpu.z80B = (cpu.z80B << 1) | bTemp2;
689 cpu.z80F |= bPostORFlags[cpu.z80B];
690 break;
691 }
692 case 0x11:
693 {
694 sdwCyclesRemaining -= 8;
695 bTemp2 = cpu.z80F & Z80_FLAG_CARRY;
696 cpu.z80F &= ~(Z80_FLAG_ZERO | Z80_FLAG_SIGN | Z80_FLAG_HALF_CARRY | Z80_FLAG_OVERFLOW_PARITY | Z80_FLAG_NEGATIVE | Z80_FLAG_CARRY);
697 cpu.z80F |= (cpu.z80C >> 7);
698 cpu.z80C = (cpu.z80C << 1) | bTemp2;
699 cpu.z80F |= bPostORFlags[cpu.z80C];
700 break;
701 }
702 case 0x12:
703 {
704 sdwCyclesRemaining -= 8;
705 bTemp2 = cpu.z80F & Z80_FLAG_CARRY;
706 cpu.z80F &= ~(Z80_FLAG_ZERO | Z80_FLAG_SIGN | Z80_FLAG_HALF_CARRY | Z80_FLAG_OVERFLOW_PARITY | Z80_FLAG_NEGATIVE | Z80_FLAG_CARRY);
707 cpu.z80F |= (cpu.z80D >> 7);
708 cpu.z80D = (cpu.z80D << 1) | bTemp2;
709 cpu.z80F |= bPostORFlags[cpu.z80D];
710 break;
711 }
712 case 0x13:
713 {
714 sdwCyclesRemaining -= 8;
715 bTemp2 = cpu.z80F & Z80_FLAG_CARRY;
716 cpu.z80F &= ~(Z80_FLAG_ZERO | Z80_FLAG_SIGN | Z80_FLAG_HALF_CARRY | Z80_FLAG_OVERFLOW_PARITY | Z80_FLAG_NEGATIVE | Z80_FLAG_CARRY);
717 cpu.z80F |= (cpu.z80E >> 7);
718 cpu.z80E = (cpu.z80E << 1) | bTemp2;
719 cpu.z80F |= bPostORFlags[cpu.z80E];
720 break;
721 }
722 case 0x14:
723 {
724 sdwCyclesRemaining -= 8;
725 bTemp2 = cpu.z80F & Z80_FLAG_CARRY;
726 cpu.z80F &= ~(Z80_FLAG_ZERO | Z80_FLAG_SIGN | Z80_FLAG_HALF_CARRY | Z80_FLAG_OVERFLOW_PARITY | Z80_FLAG_NEGATIVE | Z80_FLAG_CARRY);
727 cpu.z80F |= (cpu.z80H >> 7);
728 cpu.z80H = (cpu.z80H << 1) | bTemp2;
729 cpu.z80F |= bPostORFlags[cpu.z80H];
730 break;
731 }
732 case 0x15:
733 {
734 sdwCyclesRemaining -= 8;
735 bTemp2 = cpu.z80F & Z80_FLAG_CARRY;
736 cpu.z80F &= ~(Z80_FLAG_ZERO | Z80_FLAG_SIGN | Z80_FLAG_HALF_CARRY | Z80_FLAG_OVERFLOW_PARITY | Z80_FLAG_NEGATIVE | Z80_FLAG_CARRY);
737 cpu.z80F |= (cpu.z80L >> 7);
738 cpu.z80L = (cpu.z80L << 1) | bTemp2;
739 cpu.z80F |= bPostORFlags[cpu.z80L];
740 break;
741 }
742 case 0x16:
743 {
744 sdwCyclesRemaining -= 15;
745 psMemRead = cpu.z80MemRead; /* Beginning of our handler */
746 while (psMemRead->lowAddr != 0xffffffff)
747 {
748 if ((cpu.z80HL >= psMemRead->lowAddr) && (cpu.z80HL <= psMemRead->highAddr))
749 {
750 cpu.z80pc = (UINT32) pbPC - (UINT32) cpu.z80Base;
751 if (psMemRead->memoryCall)
752 {
753 bTemp = psMemRead->memoryCall(cpu.z80HL, psMemRead);
754 }
755 else
756 {
757 bTemp = *((UINT8 *) psMemRead->pUserArea + (cpu.z80HL - psMemRead->lowAddr));
758 }
759 psMemRead = NULL;
760 break;
761 }
762 ++psMemRead;
763 }
764
765 if (psMemRead)
766 {
767 bTemp = cpu.z80Base[cpu.z80HL];
768 }
769
770 bTemp2 = cpu.z80F & Z80_FLAG_CARRY;
771 cpu.z80F &= ~(Z80_FLAG_ZERO | Z80_FLAG_SIGN | Z80_FLAG_HALF_CARRY | Z80_FLAG_OVERFLOW_PARITY | Z80_FLAG_NEGATIVE | Z80_FLAG_CARRY);
772 cpu.z80F |= (bTemp >> 7);
773 bTemp = (bTemp << 1) | bTemp2;
774 cpu.z80F |= bPostORFlags[bTemp];
775 psMemWrite = cpu.z80MemWrite; /* Beginning of our handler */
776 while (psMemWrite->lowAddr != 0xffffffff)
777 {
778 if ((cpu.z80HL >= psMemWrite->lowAddr) && (cpu.z80HL <= psMemWrite->highAddr))
779 {
780 cpu.z80pc = (UINT32) pbPC - (UINT32) cpu.z80Base;
781 if (psMemWrite->memoryCall)
782 {
783 psMemWrite->memoryCall(cpu.z80HL, bTemp, psMemWrite);
784 }
785 else
786 {
787 *((UINT8 *) psMemWrite->pUserArea + (cpu.z80HL - psMemWrite->lowAddr)) = bTemp;
788 }
789 psMemWrite = NULL;
790 break;
791 }
792 ++psMemWrite;
793 }
794
795 if (psMemWrite)
796 {
797 cpu.z80Base[cpu.z80HL] = (UINT8) bTemp;
798 }
799
800 break;
801 }
802 case 0x17:
803 {
804 sdwCyclesRemaining -= 8;
805 bTemp2 = cpu.z80F & Z80_FLAG_CARRY;
806 cpu.z80F &= ~(Z80_FLAG_ZERO | Z80_FLAG_SIGN | Z80_FLAG_HALF_CARRY | Z80_FLAG_OVERFLOW_PARITY | Z80_FLAG_NEGATIVE | Z80_FLAG_CARRY);
807 cpu.z80F |= (cpu.z80A >> 7);
808 cpu.z80A = (cpu.z80A << 1) | bTemp2;
809 cpu.z80F |= bPostORFlags[cpu.z80A];
810 break;
811 }
812 case 0x18:
813 {
814 sdwCyclesRemaining -= 8;
815 bTemp2 = (cpu.z80F & Z80_FLAG_CARRY) << 7;
816 cpu.z80F &= ~(Z80_FLAG_ZERO | Z80_FLAG_SIGN | Z80_FLAG_HALF_CARRY | Z80_FLAG_OVERFLOW_PARITY | Z80_FLAG_NEGATIVE | Z80_FLAG_CARRY);
817 cpu.z80F |= (cpu.z80B & Z80_FLAG_CARRY);
818 cpu.z80B = (cpu.z80B >> 1) | bTemp2;
819 cpu.z80F |= bPostORFlags[cpu.z80B];
820 break;
821 }
822 case 0x19:
823 {
824 sdwCyclesRemaining -= 8;
825 bTemp2 = (cpu.z80F & Z80_FLAG_CARRY) << 7;
826 cpu.z80F &= ~(Z80_FLAG_ZERO | Z80_FLAG_SIGN | Z80_FLAG_HALF_CARRY | Z80_FLAG_OVERFLOW_PARITY | Z80_FLAG_NEGATIVE | Z80_FLAG_CARRY);
827 cpu.z80F |= (cpu.z80C & Z80_FLAG_CARRY);
828 cpu.z80C = (cpu.z80C >> 1) | bTemp2;
829 cpu.z80F |= bPostORFlags[cpu.z80C];
830 break;
831 }
832 case 0x1a:
833 {
834 sdwCyclesRemaining -= 8;
835 bTemp2 = (cpu.z80F & Z80_FLAG_CARRY) << 7;
836 cpu.z80F &= ~(Z80_FLAG_ZERO | Z80_FLAG_SIGN | Z80_FLAG_HALF_CARRY | Z80_FLAG_OVERFLOW_PARITY | Z80_FLAG_NEGATIVE | Z80_FLAG_CARRY);
837 cpu.z80F |= (cpu.z80D & Z80_FLAG_CARRY);
838 cpu.z80D = (cpu.z80D >> 1) | bTemp2;
839 cpu.z80F |= bPostORFlags[cpu.z80D];
840 break;
841 }
842 case 0x1b:
843 {
844 sdwCyclesRemaining -= 8;
845 bTemp2 = (cpu.z80F & Z80_FLAG_CARRY) << 7;
846 cpu.z80F &= ~(Z80_FLAG_ZERO | Z80_FLAG_SIGN | Z80_FLAG_HALF_CARRY | Z80_FLAG_OVERFLOW_PARITY | Z80_FLAG_NEGATIVE | Z80_FLAG_CARRY);
847 cpu.z80F |= (cpu.z80E & Z80_FLAG_CARRY);
848 cpu.z80E = (cpu.z80E >> 1) | bTemp2;
849 cpu.z80F |= bPostORFlags[cpu.z80E];
850 break;
851 }
852 case 0x1c:
853 {
854 sdwCyclesRemaining -= 8;
855 bTemp2 = (cpu.z80F & Z80_FLAG_CARRY) << 7;
856 cpu.z80F &= ~(Z80_FLAG_ZERO | Z80_FLAG_SIGN | Z80_FLAG_HALF_CARRY | Z80_FLAG_OVERFLOW_PARITY | Z80_FLAG_NEGATIVE | Z80_FLAG_CARRY);
857 cpu.z80F |= (cpu.z80H & Z80_FLAG_CARRY);
858 cpu.z80H = (cpu.z80H >> 1) | bTemp2;
859 cpu.z80F |= bPostORFlags[cpu.z80H];
860 break;
861 }
862 case 0x1d:
863 {
864 sdwCyclesRemaining -= 8;
865 bTemp2 = (cpu.z80F & Z80_FLAG_CARRY) << 7;
866 cpu.z80F &= ~(Z80_FLAG_ZERO | Z80_FLAG_SIGN | Z80_FLAG_HALF_CARRY | Z80_FLAG_OVERFLOW_PARITY | Z80_FLAG_NEGATIVE | Z80_FLAG_CARRY);
867 cpu.z80F |= (cpu.z80L & Z80_FLAG_CARRY);
868 cpu.z80L = (cpu.z80L >> 1) | bTemp2;
869 cpu.z80F |= bPostORFlags[cpu.z80L];
870 break;
871 }
872 case 0x1e:
873 {
874 sdwCyclesRemaining -= 15;
875 psMemRead = cpu.z80MemRead; /* Beginning of our handler */
876 while (psMemRead->lowAddr != 0xffffffff)
877 {
878 if ((cpu.z80HL >= psMemRead->lowAddr) && (cpu.z80HL <= psMemRead->highAddr))
879 {
880 cpu.z80pc = (UINT32) pbPC - (UINT32) cpu.z80Base;
881 if (psMemRead->memoryCall)
882 {
883 bTemp = psMemRead->memoryCall(cpu.z80HL, psMemRead);
884 }
885 else
886 {
887 bTemp = *((UINT8 *) psMemRead->pUserArea + (cpu.z80HL - psMemRead->lowAddr));
888 }
889 psMemRead = NULL;
890 break;
891 }
892 ++psMemRead;
893 }
894
895 if (psMemRead)
896 {
897 bTemp = cpu.z80Base[cpu.z80HL];
898 }
899
900 bTemp2 = (cpu.z80F & Z80_FLAG_CARRY) << 7;
901 cpu.z80F &= ~(Z80_FLAG_ZERO | Z80_FLAG_SIGN | Z80_FLAG_HALF_CARRY | Z80_FLAG_OVERFLOW_PARITY | Z80_FLAG_NEGATIVE | Z80_FLAG_CARRY);
902 cpu.z80F |= (bTemp & Z80_FLAG_CARRY);
903 bTemp = (bTemp >> 1) | bTemp2;
904 cpu.z80F |= bPostORFlags[bTemp];
905 psMemWrite = cpu.z80MemWrite; /* Beginning of our handler */
906 while (psMemWrite->lowAddr != 0xffffffff)
907 {
908 if ((cpu.z80HL >= psMemWrite->lowAddr) && (cpu.z80HL <= psMemWrite->highAddr))
909 {
910 cpu.z80pc = (UINT32) pbPC - (UINT32) cpu.z80Base;
911 if (psMemWrite->memoryCall)
912 {
913 psMemWrite->memoryCall(cpu.z80HL, bTemp, psMemWrite);
914 }
915 else
916 {
917 *((UINT8 *) psMemWrite->pUserArea + (cpu.z80HL - psMemWrite->lowAddr)) = bTemp;
918 }
919 psMemWrite = NULL;
920 break;
921 }
922 ++psMemWrite;
923 }
924
925 if (psMemWrite)
926 {
927 cpu.z80Base[cpu.z80HL] = (UINT8) bTemp;
928 }
929
930 break;
931 }
932 case 0x1f:
933 {
934 sdwCyclesRemaining -= 8;
935 bTemp2 = (cpu.z80F & Z80_FLAG_CARRY) << 7;
936 cpu.z80F &= ~(Z80_FLAG_ZERO | Z80_FLAG_SIGN | Z80_FLAG_HALF_CARRY | Z80_FLAG_OVERFLOW_PARITY | Z80_FLAG_NEGATIVE | Z80_FLAG_CARRY);
937 cpu.z80F |= (cpu.z80A & Z80_FLAG_CARRY);
938 cpu.z80A = (cpu.z80A >> 1) | bTemp2;
939 cpu.z80F |= bPostORFlags[cpu.z80A];
940 break;
941 }
942 case 0x20:
943 {
944 sdwCyclesRemaining -= 8;
945 cpu.z80F &= ~(Z80_FLAG_ZERO | Z80_FLAG_SIGN | Z80_FLAG_HALF_CARRY | Z80_FLAG_OVERFLOW_PARITY | Z80_FLAG_NEGATIVE | Z80_FLAG_CARRY);
946 cpu.z80F |= (cpu.z80B >> 7);
947 cpu.z80B = (cpu.z80B << 1);
948 cpu.z80F |= bPostORFlags[cpu.z80B];
949 break;
950 }
951 case 0x21:
952 {
953 sdwCyclesRemaining -= 8;
954 cpu.z80F &= ~(Z80_FLAG_ZERO | Z80_FLAG_SIGN | Z80_FLAG_HALF_CARRY | Z80_FLAG_OVERFLOW_PARITY | Z80_FLAG_NEGATIVE | Z80_FLAG_CARRY);
955 cpu.z80F |= (cpu.z80C >> 7);
956 cpu.z80C = (cpu.z80C << 1);
957 cpu.z80F |= bPostORFlags[cpu.z80C];
958 break;
959 }
960 case 0x22:
961 {
962 sdwCyclesRemaining -= 8;
963 cpu.z80F &= ~(Z80_FLAG_ZERO | Z80_FLAG_SIGN | Z80_FLAG_HALF_CARRY | Z80_FLAG_OVERFLOW_PARITY | Z80_FLAG_NEGATIVE | Z80_FLAG_CARRY);
964 cpu.z80F |= (cpu.z80D >> 7);
965 cpu.z80D = (cpu.z80D << 1);
966 cpu.z80F |= bPostORFlags[cpu.z80D];
967 break;
968 }
969 case 0x23:
970 {
971 sdwCyclesRemaining -= 8;
972 cpu.z80F &= ~(Z80_FLAG_ZERO | Z80_FLAG_SIGN | Z80_FLAG_HALF_CARRY | Z80_FLAG_OVERFLOW_PARITY | Z80_FLAG_NEGATIVE | Z80_FLAG_CARRY);
973 cpu.z80F |= (cpu.z80E >> 7);
974 cpu.z80E = (cpu.z80E << 1);
975 cpu.z80F |= bPostORFlags[cpu.z80E];
976 break;
977 }
978 case 0x24:
979 {
980 sdwCyclesRemaining -= 8;
981 cpu.z80F &= ~(Z80_FLAG_ZERO | Z80_FLAG_SIGN | Z80_FLAG_HALF_CARRY | Z80_FLAG_OVERFLOW_PARITY | Z80_FLAG_NEGATIVE | Z80_FLAG_CARRY);
982 cpu.z80F |= (cpu.z80H >> 7);
983 cpu.z80H = (cpu.z80H << 1);
984 cpu.z80F |= bPostORFlags[cpu.z80H];
985 break;
986 }
987 case 0x25:
988 {
989 sdwCyclesRemaining -= 8;
990 cpu.z80F &= ~(Z80_FLAG_ZERO | Z80_FLAG_SIGN | Z80_FLAG_HALF_CARRY | Z80_FLAG_OVERFLOW_PARITY | Z80_FLAG_NEGATIVE | Z80_FLAG_CARRY);
991 cpu.z80F |= (cpu.z80L >> 7);
992 cpu.z80L = (cpu.z80L << 1);
993 cpu.z80F |= bPostORFlags[cpu.z80L];
994 break;
995 }
996 case 0x26:
997 {
998 sdwCyclesRemaining -= 15;
999 psMemRead = cpu.z80MemRead; /* Beginning of our handler */
1000 while (psMemRead->lowAddr != 0xffffffff)
1001 {
1002 if ((cpu.z80HL >= psMemRead->lowAddr) && (cpu.z80HL <= psMemRead->highAddr))
1003 {
1004 cpu.z80pc = (UINT32) pbPC - (UINT32) cpu.z80Base;
1005 if (psMemRead->memoryCall)
1006 {
1007 bTemp = psMemRead->memoryCall(cpu.z80HL, psMemRead);
1008 }
1009 else
1010 {
1011 bTemp = *((UINT8 *) psMemRead->pUserArea + (cpu.z80HL - psMemRead->lowAddr));
1012 }
1013 psMemRead = NULL;
1014 break;
1015 }
1016 ++psMemRead;
1017 }
1018
1019 if (psMemRead)
1020 {
1021 bTemp = cpu.z80Base[cpu.z80HL];
1022 }
1023
1024 cpu.z80F &= ~(Z80_FLAG_ZERO | Z80_FLAG_SIGN | Z80_FLAG_HALF_CARRY | Z80_FLAG_OVERFLOW_PARITY | Z80_FLAG_NEGATIVE | Z80_FLAG_CARRY);
1025 cpu.z80F |= (bTemp >> 7);
1026 bTemp = (bTemp << 1);
1027 cpu.z80F |= bPostORFlags[bTemp];
1028 psMemWrite = cpu.z80MemWrite; /* Beginning of our handler */
1029 while (psMemWrite->lowAddr != 0xffffffff)
1030 {
1031 if ((cpu.z80HL >= psMemWrite->lowAddr) && (cpu.z80HL <= psMemWrite->highAddr))
1032 {
1033 cpu.z80pc = (UINT32) pbPC - (UINT32) cpu.z80Base;
1034 if (psMemWrite->memoryCall)
1035 {
1036 psMemWrite->memoryCall(cpu.z80HL, bTemp, psMemWrite);
1037 }
1038 else
1039 {
1040 *((UINT8 *) psMemWrite->pUserArea + (cpu.z80HL - psMemWrite->lowAddr)) = bTemp;
1041 }
1042 psMemWrite = NULL;
1043 break;
1044 }
1045 ++psMemWrite;
1046 }
1047
1048 if (psMemWrite)
1049 {
1050 cpu.z80Base[cpu.z80HL] = (UINT8) bTemp;
1051 }
1052
1053 break;
1054 }
1055 case 0x27:
1056 {
1057 sdwCyclesRemaining -= 8;
1058 cpu.z80F &= ~(Z80_FLAG_ZERO | Z80_FLAG_SIGN | Z80_FLAG_HALF_CARRY | Z80_FLAG_OVERFLOW_PARITY | Z80_FLAG_NEGATIVE | Z80_FLAG_CARRY);
1059 cpu.z80F |= (cpu.z80A >> 7);
1060 cpu.z80A = (cpu.z80A << 1);
1061 cpu.z80F |= bPostORFlags[cpu.z80A];
1062 break;
1063 }
1064 case 0x28:
1065 {
1066 sdwCyclesRemaining -= 8;
1067 cpu.z80F &= ~(Z80_FLAG_ZERO | Z80_FLAG_SIGN | Z80_FLAG_HALF_CARRY | Z80_FLAG_OVERFLOW_PARITY | Z80_FLAG_NEGATIVE | Z80_FLAG_CARRY);
1068 cpu.z80F |= (cpu.z80B & Z80_FLAG_CARRY);
1069 cpu.z80B = (cpu.z80B >> 1) | (cpu.z80B & 0x80);
1070 cpu.z80F |= bPostORFlags[cpu.z80B];
1071 break;
1072 }
1073 case 0x29:
1074 {
1075 sdwCyclesRemaining -= 8;
1076 cpu.z80F &= ~(Z80_FLAG_ZERO | Z80_FLAG_SIGN | Z80_FLAG_HALF_CARRY | Z80_FLAG_OVERFLOW_PARITY | Z80_FLAG_NEGATIVE | Z80_FLAG_CARRY);
1077 cpu.z80F |= (cpu.z80C & Z80_FLAG_CARRY);
1078 cpu.z80C = (cpu.z80C >> 1) | (cpu.z80C & 0x80);
1079 cpu.z80F |= bPostORFlags[cpu.z80C];
1080 break;
1081 }
1082 case 0x2a:
1083 {
1084 sdwCyclesRemaining -= 8;
1085 cpu.z80F &= ~(Z80_FLAG_ZERO | Z80_FLAG_SIGN | Z80_FLAG_HALF_CARRY | Z80_FLAG_OVERFLOW_PARITY | Z80_FLAG_NEGATIVE | Z80_FLAG_CARRY);
1086 cpu.z80F |= (cpu.z80D & Z80_FLAG_CARRY);
1087 cpu.z80D = (cpu.z80D >> 1) | (cpu.z80D & 0x80);
1088 cpu.z80F |= bPostORFlags[cpu.z80D];
1089 break;
1090 }
1091 case 0x2b:
1092 {
1093 sdwCyclesRemaining -= 8;
1094 cpu.z80F &= ~(Z80_FLAG_ZERO | Z80_FLAG_SIGN | Z80_FLAG_HALF_CARRY | Z80_FLAG_OVERFLOW_PARITY | Z80_FLAG_NEGATIVE | Z80_FLAG_CARRY);
1095 cpu.z80F |= (cpu.z80E & Z80_FLAG_CARRY);
1096 cpu.z80E = (cpu.z80E >> 1) | (cpu.z80E & 0x80);
1097 cpu.z80F |= bPostORFlags[cpu.z80E];
1098 break;
1099 }
1100 case 0x2c:
1101 {
1102 sdwCyclesRemaining -= 8;
1103 cpu.z80F &= ~(Z80_FLAG_ZERO | Z80_FLAG_SIGN | Z80_FLAG_HALF_CARRY | Z80_FLAG_OVERFLOW_PARITY | Z80_FLAG_NEGATIVE | Z80_FLAG_CARRY);
1104 cpu.z80F |= (cpu.z80H & Z80_FLAG_CARRY);
1105 cpu.z80H = (cpu.z80H >> 1) | (cpu.z80H & 0x80);
1106 cpu.z80F |= bPostORFlags[cpu.z80H];
1107 break;
1108 }
1109 case 0x2d:
1110 {
1111 sdwCyclesRemaining -= 8;
1112 cpu.z80F &= ~(Z80_FLAG_ZERO | Z80_FLAG_SIGN | Z80_FLAG_HALF_CARRY | Z80_FLAG_OVERFLOW_PARITY | Z80_FLAG_NEGATIVE | Z80_FLAG_CARRY);
1113 cpu.z80F |= (cpu.z80L & Z80_FLAG_CARRY);
1114 cpu.z80L = (cpu.z80L >> 1) | (cpu.z80L & 0x80);
1115 cpu.z80F |= bPostORFlags[cpu.z80L];
1116 break;
1117 }
1118 case 0x2e:
1119 {
1120 sdwCyclesRemaining -= 15;
1121 psMemRead = cpu.z80MemRead; /* Beginning of our handler */
1122 while (psMemRead->lowAddr != 0xffffffff)
1123 {
1124 if ((cpu.z80HL >= psMemRead->lowAddr) && (cpu.z80HL <= psMemRead->highAddr))
1125 {
1126 cpu.z80pc = (UINT32) pbPC - (UINT32) cpu.z80Base;
1127 if (psMemRead->memoryCall)
1128 {
1129 bTemp = psMemRead->memoryCall(cpu.z80HL, psMemRead);
1130 }
1131 else
1132 {
1133 bTemp = *((UINT8 *) psMemRead->pUserArea + (cpu.z80HL - psMemRead->lowAddr));
1134 }
1135 psMemRead = NULL;
1136 break;
1137 }
1138 ++psMemRead;
1139 }
1140
1141 if (psMemRead)
1142 {
1143 bTemp = cpu.z80Base[cpu.z80HL];
1144 }
1145
1146 cpu.z80F &= ~(Z80_FLAG_ZERO | Z80_FLAG_SIGN | Z80_FLAG_HALF_CARRY | Z80_FLAG_OVERFLOW_PARITY | Z80_FLAG_NEGATIVE | Z80_FLAG_CARRY);
1147 cpu.z80F |= (bTemp & Z80_FLAG_CARRY);
1148 bTemp = (bTemp >> 1) | (bTemp & 0x80);
1149 cpu.z80F |= bPostORFlags[bTemp];
1150 psMemWrite = cpu.z80MemWrite; /* Beginning of our handler */
1151 while (psMemWrite->lowAddr != 0xffffffff)
1152 {
1153 if ((cpu.z80HL >= psMemWrite->lowAddr) && (cpu.z80HL <= psMemWrite->highAddr))
1154 {
1155 cpu.z80pc = (UINT32) pbPC - (UINT32) cpu.z80Base;
1156 if (psMemWrite->memoryCall)
1157 {
1158 psMemWrite->memoryCall(cpu.z80HL, bTemp, psMemWrite);
1159 }
1160 else
1161 {
1162 *((UINT8 *) psMemWrite->pUserArea + (cpu.z80HL - psMemWrite->lowAddr)) = bTemp;
1163 }
1164 psMemWrite = NULL;
1165 break;
1166 }
1167 ++psMemWrite;
1168 }
1169
1170 if (psMemWrite)
1171 {
1172 cpu.z80Base[cpu.z80HL] = (UINT8) bTemp;
1173 }
1174
1175 break;
1176 }
1177 case 0x2f:
1178 {
1179 sdwCyclesRemaining -= 8;
1180 cpu.z80F &= ~(Z80_FLAG_ZERO | Z80_FLAG_SIGN | Z80_FLAG_HALF_CARRY | Z80_FLAG_OVERFLOW_PARITY | Z80_FLAG_NEGATIVE | Z80_FLAG_CARRY);
1181 cpu.z80F |= (cpu.z80A & Z80_FLAG_CARRY);
1182 cpu.z80A = (cpu.z80A >> 1) | (cpu.z80A & 0x80);
1183 cpu.z80F |= bPostORFlags[cpu.z80A];
1184 break;
1185 }
1186 case 0x30:
1187 {
1188 sdwCyclesRemaining -= 8;
1189 cpu.z80F &= ~(Z80_FLAG_ZERO | Z80_FLAG_SIGN | Z80_FLAG_HALF_CARRY | Z80_FLAG_OVERFLOW_PARITY | Z80_FLAG_NEGATIVE | Z80_FLAG_CARRY);
1190 cpu.z80F |= (cpu.z80B >> 7);
1191 cpu.z80B = (cpu.z80B << 1);
1192 cpu.z80F |= bPostORFlags[cpu.z80B];
1193 break;
1194 }
1195 case 0x31:
1196 {
1197 sdwCyclesRemaining -= 8;
1198 cpu.z80F &= ~(Z80_FLAG_ZERO | Z80_FLAG_SIGN | Z80_FLAG_HALF_CARRY | Z80_FLAG_OVERFLOW_PARITY | Z80_FLAG_NEGATIVE | Z80_FLAG_CARRY);
1199 cpu.z80F |= (cpu.z80C >> 7);
1200 cpu.z80C = (cpu.z80C << 1);
1201 cpu.z80F |= bPostORFlags[cpu.z80C];
1202 break;
1203 }
1204 case 0x32:
1205 {
1206 sdwCyclesRemaining -= 8;
1207 cpu.z80F &= ~(Z80_FLAG_ZERO | Z80_FLAG_SIGN | Z80_FLAG_HALF_CARRY | Z80_FLAG_OVERFLOW_PARITY | Z80_FLAG_NEGATIVE | Z80_FLAG_CARRY);
1208 cpu.z80F |= (cpu.z80D >> 7);
1209 cpu.z80D = (cpu.z80D << 1);
1210 cpu.z80F |= bPostORFlags[cpu.z80D];
1211 break;
1212 }
1213 case 0x33:
1214 {
1215 sdwCyclesRemaining -= 8;
1216 cpu.z80F &= ~(Z80_FLAG_ZERO | Z80_FLAG_SIGN | Z80_FLAG_HALF_CARRY | Z80_FLAG_OVERFLOW_PARITY | Z80_FLAG_NEGATIVE | Z80_FLAG_CARRY);
1217 cpu.z80F |= (cpu.z80E >> 7);
1218 cpu.z80E = (cpu.z80E << 1);
1219 cpu.z80F |= bPostORFlags[cpu.z80E];
1220 break;
1221 }
1222 case 0x34:
1223 {
1224 sdwCyclesRemaining -= 8;
1225 cpu.z80F &= ~(Z80_FLAG_ZERO | Z80_FLAG_SIGN | Z80_FLAG_HALF_CARRY | Z80_FLAG_OVERFLOW_PARITY | Z80_FLAG_NEGATIVE | Z80_FLAG_CARRY);
1226 cpu.z80F |= (cpu.z80H >> 7);
1227 cpu.z80H = (cpu.z80H << 1);
1228 cpu.z80F |= bPostORFlags[cpu.z80H];
1229 break;
1230 }
1231 case 0x35:
1232 {
1233 sdwCyclesRemaining -= 8;
1234 cpu.z80F &= ~(Z80_FLAG_ZERO | Z80_FLAG_SIGN | Z80_FLAG_HALF_CARRY | Z80_FLAG_OVERFLOW_PARITY | Z80_FLAG_NEGATIVE | Z80_FLAG_CARRY);
1235 cpu.z80F |= (cpu.z80L >> 7);
1236 cpu.z80L = (cpu.z80L << 1);
1237 cpu.z80F |= bPostORFlags[cpu.z80L];
1238 break;
1239 }
1240 case 0x36:
1241 {
1242 sdwCyclesRemaining -= 15;
1243 psMemRead = cpu.z80MemRead; /* Beginning of our handler */
1244 while (psMemRead->lowAddr != 0xffffffff)
1245 {
1246 if ((cpu.z80HL >= psMemRead->lowAddr) && (cpu.z80HL <= psMemRead->highAddr))
1247 {
1248 cpu.z80pc = (UINT32) pbPC - (UINT32) cpu.z80Base;
1249 if (psMemRead->memoryCall)
1250 {
1251 bTemp = psMemRead->memoryCall(cpu.z80HL, psMemRead);
1252 }
1253 else
1254 {
1255 bTemp = *((UINT8 *) psMemRead->pUserArea + (cpu.z80HL - psMemRead->lowAddr));
1256 }
1257 psMemRead = NULL;
1258 break;
1259 }
1260 ++psMemRead;
1261 }
1262
1263 if (psMemRead)
1264 {
1265 bTemp = cpu.z80Base[cpu.z80HL];
1266 }
1267
1268 cpu.z80F &= ~(Z80_FLAG_ZERO | Z80_FLAG_SIGN | Z80_FLAG_HALF_CARRY | Z80_FLAG_OVERFLOW_PARITY | Z80_FLAG_NEGATIVE | Z80_FLAG_CARRY);
1269 cpu.z80F |= (bTemp >> 7);
1270 bTemp = (bTemp << 1);
1271 cpu.z80F |= bPostORFlags[bTemp];
1272 psMemWrite = cpu.z80MemWrite; /* Beginning of our handler */
1273 while (psMemWrite->lowAddr != 0xffffffff)
1274 {
1275 if ((cpu.z80HL >= psMemWrite->lowAddr) && (cpu.z80HL <= psMemWrite->highAddr))
1276 {
1277 cpu.z80pc = (UINT32) pbPC - (UINT32) cpu.z80Base;
1278 if (psMemWrite->memoryCall)
1279 {
1280 psMemWrite->memoryCall(cpu.z80HL, bTemp, psMemWrite);
1281 }
1282 else
1283 {
1284 *((UINT8 *) psMemWrite->pUserArea + (cpu.z80HL - psMemWrite->lowAddr)) = bTemp;
1285 }
1286 psMemWrite = NULL;
1287 break;
1288 }
1289 ++psMemWrite;
1290 }
1291
1292 if (psMemWrite)
1293 {
1294 cpu.z80Base[cpu.z80HL] = (UINT8) bTemp;
1295 }
1296
1297 break;
1298 }
1299 case 0x37:
1300 {
1301 sdwCyclesRemaining -= 8;
1302 cpu.z80F &= ~(Z80_FLAG_ZERO | Z80_FLAG_SIGN | Z80_FLAG_HALF_CARRY | Z80_FLAG_OVERFLOW_PARITY | Z80_FLAG_NEGATIVE | Z80_FLAG_CARRY);
1303 cpu.z80F |= (cpu.z80A >> 7);
1304 cpu.z80A = (cpu.z80A << 1);
1305 cpu.z80F |= bPostORFlags[cpu.z80A];
1306 break;
1307 }
1308 case 0x38:
1309 {
1310 sdwCyclesRemaining -= 8;
1311 cpu.z80F &= ~(Z80_FLAG_ZERO | Z80_FLAG_SIGN | Z80_FLAG_HALF_CARRY | Z80_FLAG_OVERFLOW_PARITY | Z80_FLAG_NEGATIVE | Z80_FLAG_CARRY);
1312 cpu.z80F |= (cpu.z80B & Z80_FLAG_CARRY);
1313 cpu.z80B = (cpu.z80B >> 1);
1314 cpu.z80F |= bPostORFlags[cpu.z80B];
1315 break;
1316 }
1317 case 0x39:
1318 {
1319 sdwCyclesRemaining -= 8;
1320 cpu.z80F &= ~(Z80_FLAG_ZERO | Z80_FLAG_SIGN | Z80_FLAG_HALF_CARRY | Z80_FLAG_OVERFLOW_PARITY | Z80_FLAG_NEGATIVE | Z80_FLAG_CARRY);
1321 cpu.z80F |= (cpu.z80C & Z80_FLAG_CARRY);
1322 cpu.z80C = (cpu.z80C >> 1);
1323 cpu.z80F |= bPostORFlags[cpu.z80C];
1324 break;
1325 }
1326 case 0x3a:
1327 {
1328 sdwCyclesRemaining -= 8;
1329 cpu.z80F &= ~(Z80_FLAG_ZERO | Z80_FLAG_SIGN | Z80_FLAG_HALF_CARRY | Z80_FLAG_OVERFLOW_PARITY | Z80_FLAG_NEGATIVE | Z80_FLAG_CARRY);
1330 cpu.z80F |= (cpu.z80D & Z80_FLAG_CARRY);
1331 cpu.z80D = (cpu.z80D >> 1);
1332 cpu.z80F |= bPostORFlags[cpu.z80D];
1333 break;
1334 }
1335 case 0x3b:
1336 {
1337 sdwCyclesRemaining -= 8;
1338 cpu.z80F &= ~(Z80_FLAG_ZERO | Z80_FLAG_SIGN | Z80_FLAG_HALF_CARRY | Z80_FLAG_OVERFLOW_PARITY | Z80_FLAG_NEGATIVE | Z80_FLAG_CARRY);
1339 cpu.z80F |= (cpu.z80E & Z80_FLAG_CARRY);
1340 cpu.z80E = (cpu.z80E >> 1);
1341 cpu.z80F |= bPostORFlags[cpu.z80E];
1342 break;
1343 }
1344 case 0x3c:
1345 {
1346 sdwCyclesRemaining -= 8;
1347 cpu.z80F &= ~(Z80_FLAG_ZERO | Z80_FLAG_SIGN | Z80_FLAG_HALF_CARRY | Z80_FLAG_OVERFLOW_PARITY | Z80_FLAG_NEGATIVE | Z80_FLAG_CARRY);
1348 cpu.z80F |= (cpu.z80H & Z80_FLAG_CARRY);
1349 cpu.z80H = (cpu.z80H >> 1);
1350 cpu.z80F |= bPostORFlags[cpu.z80H];
1351 break;
1352 }
1353 case 0x3d:
1354 {
1355 sdwCyclesRemaining -= 8;
1356 cpu.z80F &= ~(Z80_FLAG_ZERO | Z80_FLAG_SIGN | Z80_FLAG_HALF_CARRY | Z80_FLAG_OVERFLOW_PARITY | Z80_FLAG_NEGATIVE | Z80_FLAG_CARRY);
1357 cpu.z80F |= (cpu.z80L & Z80_FLAG_CARRY);
1358 cpu.z80L = (cpu.z80L >> 1);
1359 cpu.z80F |= bPostORFlags[cpu.z80L];
1360 break;
1361 }
1362 case 0x3e:
1363 {
1364 sdwCyclesRemaining -= 15;
1365 psMemRead = cpu.z80MemRead; /* Beginning of our handler */
1366 while (psMemRead->lowAddr != 0xffffffff)
1367 {
1368 if ((cpu.z80HL >= psMemRead->lowAddr) && (cpu.z80HL <= psMemRead->highAddr))
1369 {
1370 cpu.z80pc = (UINT32) pbPC - (UINT32) cpu.z80Base;
1371 if (psMemRead->memoryCall)
1372 {
1373 bTemp = psMemRead->memoryCall(cpu.z80HL, psMemRead);
1374 }
1375 else
1376 {
1377 bTemp = *((UINT8 *) psMemRead->pUserArea + (cpu.z80HL - psMemRead->lowAddr));
1378 }
1379 psMemRead = NULL;
1380 break;
1381 }
1382 ++psMemRead;
1383 }
1384
1385 if (psMemRead)
1386 {
1387 bTemp = cpu.z80Base[cpu.z80HL];
1388 }
1389
1390 cpu.z80F &= ~(Z80_FLAG_ZERO | Z80_FLAG_SIGN | Z80_FLAG_HALF_CARRY | Z80_FLAG_OVERFLOW_PARITY | Z80_FLAG_NEGATIVE | Z80_FLAG_CARRY);
1391 cpu.z80F |= (bTemp & Z80_FLAG_CARRY);
1392 bTemp = (bTemp >> 1);
1393 cpu.z80F |= bPostORFlags[bTemp];
1394 psMemWrite = cpu.z80MemWrite; /* Beginning of our handler */
1395 while (psMemWrite->lowAddr != 0xffffffff)
1396 {
1397 if ((cpu.z80HL >= psMemWrite->lowAddr) && (cpu.z80HL <= psMemWrite->highAddr))
1398 {
1399 cpu.z80pc = (UINT32) pbPC - (UINT32) cpu.z80Base;
1400 if (psMemWrite->memoryCall)
1401 {
1402 psMemWrite->memoryCall(cpu.z80HL, bTemp, psMemWrite);
1403 }
1404 else
1405 {
1406 *((UINT8 *) psMemWrite->pUserArea + (cpu.z80HL - psMemWrite->lowAddr)) = bTemp;
1407 }
1408 psMemWrite = NULL;
1409 break;
1410 }
1411 ++psMemWrite;
1412 }
1413
1414 if (psMemWrite)
1415 {
1416 cpu.z80Base[cpu.z80HL] = (UINT8) bTemp;
1417 }
1418
1419 break;
1420 }
1421 case 0x3f:
1422 {
1423 sdwCyclesRemaining -= 8;
1424 cpu.z80F &= ~(Z80_FLAG_ZERO | Z80_FLAG_SIGN | Z80_FLAG_HALF_CARRY | Z80_FLAG_OVERFLOW_PARITY | Z80_FLAG_NEGATIVE | Z80_FLAG_CARRY);
1425 cpu.z80F |= (cpu.z80A & Z80_FLAG_CARRY);
1426 cpu.z80A = (cpu.z80A >> 1);
1427 cpu.z80F |= bPostORFlags[cpu.z80A];
1428 break;
1429 }
1430 case 0x40:
1431 {
1432 sdwCyclesRemaining -= 8;
1433 cpu.z80F &= ~(Z80_FLAG_HALF_CARRY | Z80_FLAG_NEGATIVE | Z80_FLAG_ZERO);
1434 cpu.z80F |= (Z80_FLAG_HALF_CARRY);
1435 if (!(cpu.z80B & 0x01))
1436 {
1437 cpu.z80F |= Z80_FLAG_ZERO;
1438 }
1439 break;
1440 }
1441 case 0x41:
1442 {
1443 sdwCyclesRemaining -= 8;
1444 cpu.z80F &= ~(Z80_FLAG_HALF_CARRY | Z80_FLAG_NEGATIVE | Z80_FLAG_ZERO);
1445 cpu.z80F |= (Z80_FLAG_HALF_CARRY);
1446 if (!(cpu.z80C & 0x01))
1447 {
1448 cpu.z80F |= Z80_FLAG_ZERO;
1449 }
1450 break;
1451 }
1452 case 0x42:
1453 {
1454 sdwCyclesRemaining -= 8;
1455 cpu.z80F &= ~(Z80_FLAG_HALF_CARRY | Z80_FLAG_NEGATIVE | Z80_FLAG_ZERO);
1456 cpu.z80F |= (Z80_FLAG_HALF_CARRY);
1457 if (!(cpu.z80D & 0x01))
1458 {
1459 cpu.z80F |= Z80_FLAG_ZERO;
1460 }
1461 break;
1462 }
1463 case 0x43:
1464 {
1465 sdwCyclesRemaining -= 8;
1466 cpu.z80F &= ~(Z80_FLAG_HALF_CARRY | Z80_FLAG_NEGATIVE | Z80_FLAG_ZERO);
1467 cpu.z80F |= (Z80_FLAG_HALF_CARRY);
1468 if (!(cpu.z80E & 0x01))
1469 {
1470 cpu.z80F |= Z80_FLAG_ZERO;
1471 }
1472 break;
1473 }
1474 case 0x44:
1475 {
1476 sdwCyclesRemaining -= 8;
1477 cpu.z80F &= ~(Z80_FLAG_HALF_CARRY | Z80_FLAG_NEGATIVE | Z80_FLAG_ZERO);
1478 cpu.z80F |= (Z80_FLAG_HALF_CARRY);
1479 if (!(cpu.z80H & 0x01))
1480 {
1481 cpu.z80F |= Z80_FLAG_ZERO;
1482 }
1483 break;
1484 }
1485 case 0x45:
1486 {
1487 sdwCyclesRemaining -= 8;
1488 cpu.z80F &= ~(Z80_FLAG_HALF_CARRY | Z80_FLAG_NEGATIVE | Z80_FLAG_ZERO);
1489 cpu.z80F |= (Z80_FLAG_HALF_CARRY);
1490 if (!(cpu.z80L & 0x01))
1491 {
1492 cpu.z80F |= Z80_FLAG_ZERO;
1493 }
1494 break;
1495 }
1496 case 0x46:
1497 {
1498 sdwCyclesRemaining -= 12;
1499 psMemRead = cpu.z80MemRead; /* Beginning of our handler */
1500 while (psMemRead->lowAddr != 0xffffffff)
1501 {
1502 if ((cpu.z80HL >= psMemRead->lowAddr) && (cpu.z80HL <= psMemRead->highAddr))
1503 {
1504 cpu.z80pc = (UINT32) pbPC - (UINT32) cpu.z80Base;
1505 if (psMemRead->memoryCall)
1506 {
1507 bTemp = psMemRead->memoryCall(cpu.z80HL, psMemRead);
1508 }
1509 else
1510 {
1511 bTemp = *((UINT8 *) psMemRead->pUserArea + (cpu.z80HL - psMemRead->lowAddr));
1512 }
1513 psMemRead = NULL;
1514 break;
1515 }
1516 ++psMemRead;
1517 }
1518
1519 if (psMemRead)
1520 {
1521 bTemp = cpu.z80Base[cpu.z80HL];
1522 }
1523
1524 cpu.z80F &= ~(Z80_FLAG_HALF_CARRY | Z80_FLAG_NEGATIVE | Z80_FLAG_ZERO);
1525 cpu.z80F |= (Z80_FLAG_HALF_CARRY);
1526 if (!(bTemp & 0x01))
1527 {
1528 cpu.z80F |= Z80_FLAG_ZERO;
1529 }
1530 break;
1531 }
1532 case 0x47:
1533 {
1534 sdwCyclesRemaining -= 8;
1535 cpu.z80F &= ~(Z80_FLAG_HALF_CARRY | Z80_FLAG_NEGATIVE | Z80_FLAG_ZERO);
1536 cpu.z80F |= (Z80_FLAG_HALF_CARRY);
1537 if (!(cpu.z80A & 0x01))
1538 {
1539 cpu.z80F |= Z80_FLAG_ZERO;
1540 }
1541 break;
1542 }
1543 case 0x48:
1544 {
1545 sdwCyclesRemaining -= 8;
1546 cpu.z80F &= ~(Z80_FLAG_HALF_CARRY | Z80_FLAG_NEGATIVE | Z80_FLAG_ZERO);
1547 cpu.z80F |= (Z80_FLAG_HALF_CARRY);
1548 if (!(cpu.z80B & 0x02))
1549 {
1550 cpu.z80F |= Z80_FLAG_ZERO;
1551 }
1552 break;
1553 }
1554 case 0x49:
1555 {
1556 sdwCyclesRemaining -= 8;
1557 cpu.z80F &= ~(Z80_FLAG_HALF_CARRY | Z80_FLAG_NEGATIVE | Z80_FLAG_ZERO);
1558 cpu.z80F |= (Z80_FLAG_HALF_CARRY);
1559 if (!(cpu.z80C & 0x02))
1560 {
1561 cpu.z80F |= Z80_FLAG_ZERO;
1562 }
1563 break;
1564 }
1565 case 0x4a:
1566 {
1567 sdwCyclesRemaining -= 8;
1568 cpu.z80F &= ~(Z80_FLAG_HALF_CARRY | Z80_FLAG_NEGATIVE | Z80_FLAG_ZERO);
1569 cpu.z80F |= (Z80_FLAG_HALF_CARRY);
1570 if (!(cpu.z80D & 0x02))
1571 {
1572 cpu.z80F |= Z80_FLAG_ZERO;
1573 }
1574 break;
1575 }
1576 case 0x4b:
1577 {
1578 sdwCyclesRemaining -= 8;
1579 cpu.z80F &= ~(Z80_FLAG_HALF_CARRY | Z80_FLAG_NEGATIVE | Z80_FLAG_ZERO);
1580 cpu.z80F |= (Z80_FLAG_HALF_CARRY);
1581 if (!(cpu.z80E & 0x02))
1582 {
1583 cpu.z80F |= Z80_FLAG_ZERO;
1584 }
1585 break;
1586 }
1587 case 0x4c:
1588 {
1589 sdwCyclesRemaining -= 8;
1590 cpu.z80F &= ~(Z80_FLAG_HALF_CARRY | Z80_FLAG_NEGATIVE | Z80_FLAG_ZERO);
1591 cpu.z80F |= (Z80_FLAG_HALF_CARRY);
1592 if (!(cpu.z80H & 0x02))
1593 {
1594 cpu.z80F |= Z80_FLAG_ZERO;
1595 }
1596 break;
1597 }
1598 case 0x4d:
1599 {
1600 sdwCyclesRemaining -= 8;
1601 cpu.z80F &= ~(Z80_FLAG_HALF_CARRY | Z80_FLAG_NEGATIVE | Z80_FLAG_ZERO);
1602 cpu.z80F |= (Z80_FLAG_HALF_CARRY);
1603 if (!(cpu.z80L & 0x02))
1604 {
1605 cpu.z80F |= Z80_FLAG_ZERO;
1606 }
1607 break;
1608 }
1609 case 0x4e:
1610 {
1611 sdwCyclesRemaining -= 12;
1612 psMemRead = cpu.z80MemRead; /* Beginning of our handler */
1613 while (psMemRead->lowAddr != 0xffffffff)
1614 {
1615 if ((cpu.z80HL >= psMemRead->lowAddr) && (cpu.z80HL <= psMemRead->highAddr))
1616 {
1617 cpu.z80pc = (UINT32) pbPC - (UINT32) cpu.z80Base;
1618 if (psMemRead->memoryCall)
1619 {
1620 bTemp = psMemRead->memoryCall(cpu.z80HL, psMemRead);
1621 }
1622 else
1623 {
1624 bTemp = *((UINT8 *) psMemRead->pUserArea + (cpu.z80HL - psMemRead->lowAddr));
1625 }
1626 psMemRead = NULL;
1627 break;
1628 }
1629 ++psMemRead;
1630 }
1631
1632 if (psMemRead)
1633 {
1634 bTemp = cpu.z80Base[cpu.z80HL];
1635 }
1636
1637 cpu.z80F &= ~(Z80_FLAG_HALF_CARRY | Z80_FLAG_NEGATIVE | Z80_FLAG_ZERO);
1638 cpu.z80F |= (Z80_FLAG_HALF_CARRY);
1639 if (!(bTemp & 0x02))
1640 {
1641 cpu.z80F |= Z80_FLAG_ZERO;
1642 }
1643 break;
1644 }
1645 case 0x4f:
1646 {
1647 sdwCyclesRemaining -= 8;
1648 cpu.z80F &= ~(Z80_FLAG_HALF_CARRY | Z80_FLAG_NEGATIVE | Z80_FLAG_ZERO);
1649 cpu.z80F |= (Z80_FLAG_HALF_CARRY);
1650 if (!(cpu.z80A & 0x02))
1651 {
1652 cpu.z80F |= Z80_FLAG_ZERO;
1653 }
1654 break;
1655 }
1656 case 0x50:
1657 {
1658 sdwCyclesRemaining -= 8;
1659 cpu.z80F &= ~(Z80_FLAG_HALF_CARRY | Z80_FLAG_NEGATIVE | Z80_FLAG_ZERO);
1660 cpu.z80F |= (Z80_FLAG_HALF_CARRY);
1661 if (!(cpu.z80B & 0x04))
1662 {
1663 cpu.z80F |= Z80_FLAG_ZERO;
1664 }
1665 break;
1666 }
1667 case 0x51:
1668 {
1669 sdwCyclesRemaining -= 8;
1670 cpu.z80F &= ~(Z80_FLAG_HALF_CARRY | Z80_FLAG_NEGATIVE | Z80_FLAG_ZERO);
1671 cpu.z80F |= (Z80_FLAG_HALF_CARRY);
1672 if (!(cpu.z80C & 0x04))
1673 {
1674 cpu.z80F |= Z80_FLAG_ZERO;
1675 }
1676 break;
1677 }
1678 case 0x52:
1679 {
1680 sdwCyclesRemaining -= 8;
1681 cpu.z80F &= ~(Z80_FLAG_HALF_CARRY | Z80_FLAG_NEGATIVE | Z80_FLAG_ZERO);
1682 cpu.z80F |= (Z80_FLAG_HALF_CARRY);
1683 if (!(cpu.z80D & 0x04))
1684 {
1685 cpu.z80F |= Z80_FLAG_ZERO;
1686 }
1687 break;
1688 }
1689 case 0x53:
1690 {
1691 sdwCyclesRemaining -= 8;
1692 cpu.z80F &= ~(Z80_FLAG_HALF_CARRY | Z80_FLAG_NEGATIVE | Z80_FLAG_ZERO);
1693 cpu.z80F |= (Z80_FLAG_HALF_CARRY);
1694 if (!(cpu.z80E & 0x04))
1695 {
1696 cpu.z80F |= Z80_FLAG_ZERO;
1697 }
1698 break;
1699 }
1700 case 0x54:
1701 {
1702 sdwCyclesRemaining -= 8;
1703 cpu.z80F &= ~(Z80_FLAG_HALF_CARRY | Z80_FLAG_NEGATIVE | Z80_FLAG_ZERO);
1704 cpu.z80F |= (Z80_FLAG_HALF_CARRY);
1705 if (!(cpu.z80H & 0x04))
1706 {
1707 cpu.z80F |= Z80_FLAG_ZERO;
1708 }
1709 break;
1710 }
1711 case 0x55:
1712 {
1713 sdwCyclesRemaining -= 8;
1714 cpu.z80F &= ~(Z80_FLAG_HALF_CARRY | Z80_FLAG_NEGATIVE | Z80_FLAG_ZERO);
1715 cpu.z80F |= (Z80_FLAG_HALF_CARRY);
1716 if (!(cpu.z80L & 0x04))
1717 {
1718 cpu.z80F |= Z80_FLAG_ZERO;
1719 }
1720 break;
1721 }
1722 case 0x56:
1723 {
1724 sdwCyclesRemaining -= 12;
1725 psMemRead = cpu.z80MemRead; /* Beginning of our handler */
1726 while (psMemRead->lowAddr != 0xffffffff)
1727 {
1728 if ((cpu.z80HL >= psMemRead->lowAddr) && (cpu.z80HL <= psMemRead->highAddr))
1729 {
1730 cpu.z80pc = (UINT32) pbPC - (UINT32) cpu.z80Base;
1731 if (psMemRead->memoryCall)
1732 {
1733 bTemp = psMemRead->memoryCall(cpu.z80HL, psMemRead);
1734 }
1735 else
1736 {
1737 bTemp = *((UINT8 *) psMemRead->pUserArea + (cpu.z80HL - psMemRead->lowAddr));
1738 }
1739 psMemRead = NULL;
1740 break;
1741 }
1742 ++psMemRead;
1743 }
1744
1745 if (psMemRead)
1746 {
1747 bTemp = cpu.z80Base[cpu.z80HL];
1748 }
1749
1750 cpu.z80F &= ~(Z80_FLAG_HALF_CARRY | Z80_FLAG_NEGATIVE | Z80_FLAG_ZERO);
1751 cpu.z80F |= (Z80_FLAG_HALF_CARRY);
1752 if (!(bTemp & 0x04))
1753 {
1754 cpu.z80F |= Z80_FLAG_ZERO;
1755 }
1756 break;
1757 }
1758 case 0x57:
1759 {
1760 sdwCyclesRemaining -= 8;
1761 cpu.z80F &= ~(Z80_FLAG_HALF_CARRY | Z80_FLAG_NEGATIVE | Z80_FLAG_ZERO);
1762 cpu.z80F |= (Z80_FLAG_HALF_CARRY);
1763 if (!(cpu.z80A & 0x04))
1764 {
1765 cpu.z80F |= Z80_FLAG_ZERO;
1766 }
1767 break;
1768 }
1769 case 0x58:
1770 {
1771 sdwCyclesRemaining -= 8;
1772 cpu.z80F &= ~(Z80_FLAG_HALF_CARRY | Z80_FLAG_NEGATIVE | Z80_FLAG_ZERO);
1773 cpu.z80F |= (Z80_FLAG_HALF_CARRY);
1774 if (!(cpu.z80B & 0x08))
1775 {
1776 cpu.z80F |= Z80_FLAG_ZERO;
1777 }
1778 break;
1779 }
1780 case 0x59:
1781 {
1782 sdwCyclesRemaining -= 8;
1783 cpu.z80F &= ~(Z80_FLAG_HALF_CARRY | Z80_FLAG_NEGATIVE | Z80_FLAG_ZERO);
1784 cpu.z80F |= (Z80_FLAG_HALF_CARRY);
1785 if (!(cpu.z80C & 0x08))
1786 {
1787 cpu.z80F |= Z80_FLAG_ZERO;
1788 }
1789 break;
1790 }
1791 case 0x5a:
1792 {
1793 sdwCyclesRemaining -= 8;
1794 cpu.z80F &= ~(Z80_FLAG_HALF_CARRY | Z80_FLAG_NEGATIVE | Z80_FLAG_ZERO);
1795 cpu.z80F |= (Z80_FLAG_HALF_CARRY);
1796 if (!(cpu.z80D & 0x08))
1797 {
1798 cpu.z80F |= Z80_FLAG_ZERO;
1799 }
1800 break;
1801 }
1802 case 0x5b:
1803 {
1804 sdwCyclesRemaining -= 8;
1805 cpu.z80F &= ~(Z80_FLAG_HALF_CARRY | Z80_FLAG_NEGATIVE | Z80_FLAG_ZERO);
1806 cpu.z80F |= (Z80_FLAG_HALF_CARRY);
1807 if (!(cpu.z80E & 0x08))
1808 {
1809 cpu.z80F |= Z80_FLAG_ZERO;
1810 }
1811 break;
1812 }
1813 case 0x5c:
1814 {
1815 sdwCyclesRemaining -= 8;
1816 cpu.z80F &= ~(Z80_FLAG_HALF_CARRY | Z80_FLAG_NEGATIVE | Z80_FLAG_ZERO);
1817 cpu.z80F |= (Z80_FLAG_HALF_CARRY);
1818 if (!(cpu.z80H & 0x08))
1819 {
1820 cpu.z80F |= Z80_FLAG_ZERO;
1821 }
1822 break;
1823 }
1824 case 0x5d:
1825 {
1826 sdwCyclesRemaining -= 8;
1827 cpu.z80F &= ~(Z80_FLAG_HALF_CARRY | Z80_FLAG_NEGATIVE | Z80_FLAG_ZERO);
1828 cpu.z80F |= (Z80_FLAG_HALF_CARRY);
1829 if (!(cpu.z80L & 0x08))
1830 {
1831 cpu.z80F |= Z80_FLAG_ZERO;
1832 }
1833 break;
1834 }
1835 case 0x5e:
1836 {
1837 sdwCyclesRemaining -= 12;
1838 psMemRead = cpu.z80MemRead; /* Beginning of our handler */
1839 while (psMemRead->lowAddr != 0xffffffff)
1840 {
1841 if ((cpu.z80HL >= psMemRead->lowAddr) && (cpu.z80HL <= psMemRead->highAddr))
1842 {
1843 cpu.z80pc = (UINT32) pbPC - (UINT32) cpu.z80Base;
1844 if (psMemRead->memoryCall)
1845 {
1846 bTemp = psMemRead->memoryCall(cpu.z80HL, psMemRead);
1847 }
1848 else
1849 {
1850 bTemp = *((UINT8 *) psMemRead->pUserArea + (cpu.z80HL - psMemRead->lowAddr));
1851 }
1852 psMemRead = NULL;
1853 break;
1854 }
1855 ++psMemRead;
1856 }
1857
1858 if (psMemRead)
1859 {
1860 bTemp = cpu.z80Base[cpu.z80HL];
1861 }
1862
1863 cpu.z80F &= ~(Z80_FLAG_HALF_CARRY | Z80_FLAG_NEGATIVE | Z80_FLAG_ZERO);
1864 cpu.z80F |= (Z80_FLAG_HALF_CARRY);
1865 if (!(bTemp & 0x08))
1866 {
1867 cpu.z80F |= Z80_FLAG_ZERO;
1868 }
1869 break;
1870 }
1871 case 0x5f:
1872 {
1873 sdwCyclesRemaining -= 8;
1874 cpu.z80F &= ~(Z80_FLAG_HALF_CARRY | Z80_FLAG_NEGATIVE | Z80_FLAG_ZERO);
1875 cpu.z80F |= (Z80_FLAG_HALF_CARRY);
1876 if (!(cpu.z80A & 0x08))
1877 {
1878 cpu.z80F |= Z80_FLAG_ZERO;
1879 }
1880 break;
1881 }
1882 case 0x60:
1883 {
1884 sdwCyclesRemaining -= 8;
1885 cpu.z80F &= ~(Z80_FLAG_HALF_CARRY | Z80_FLAG_NEGATIVE | Z80_FLAG_ZERO);
1886 cpu.z80F |= (Z80_FLAG_HALF_CARRY);
1887 if (!(cpu.z80B & 0x10))
1888 {
1889 cpu.z80F |= Z80_FLAG_ZERO;
1890 }
1891 break;
1892 }
1893 case 0x61:
1894 {
1895 sdwCyclesRemaining -= 8;
1896 cpu.z80F &= ~(Z80_FLAG_HALF_CARRY | Z80_FLAG_NEGATIVE | Z80_FLAG_ZERO);
1897 cpu.z80F |= (Z80_FLAG_HALF_CARRY);
1898 if (!(cpu.z80C & 0x10))
1899 {
1900 cpu.z80F |= Z80_FLAG_ZERO;
1901 }
1902 break;
1903 }
1904 case 0x62:
1905 {
1906 sdwCyclesRemaining -= 8;
1907 cpu.z80F &= ~(Z80_FLAG_HALF_CARRY | Z80_FLAG_NEGATIVE | Z80_FLAG_ZERO);
1908 cpu.z80F |= (Z80_FLAG_HALF_CARRY);
1909 if (!(cpu.z80D & 0x10))
1910 {
1911 cpu.z80F |= Z80_FLAG_ZERO;
1912 }
1913 break;
1914 }
1915 case 0x63:
1916 {
1917 sdwCyclesRemaining -= 8;
1918 cpu.z80F &= ~(Z80_FLAG_HALF_CARRY | Z80_FLAG_NEGATIVE | Z80_FLAG_ZERO);
1919 cpu.z80F |= (Z80_FLAG_HALF_CARRY);
1920 if (!(cpu.z80E & 0x10))
1921 {
1922 cpu.z80F |= Z80_FLAG_ZERO;
1923 }
1924 break;
1925 }
1926 case 0x64:
1927 {
1928 sdwCyclesRemaining -= 8;
1929 cpu.z80F &= ~(Z80_FLAG_HALF_CARRY | Z80_FLAG_NEGATIVE | Z80_FLAG_ZERO);
1930 cpu.z80F |= (Z80_FLAG_HALF_CARRY);
1931 if (!(cpu.z80H & 0x10))
1932 {
1933 cpu.z80F |= Z80_FLAG_ZERO;
1934 }
1935 break;
1936 }
1937 case 0x65:
1938 {
1939 sdwCyclesRemaining -= 8;
1940 cpu.z80F &= ~(Z80_FLAG_HALF_CARRY | Z80_FLAG_NEGATIVE | Z80_FLAG_ZERO);
1941 cpu.z80F |= (Z80_FLAG_HALF_CARRY);
1942 if (!(cpu.z80L & 0x10))
1943 {
1944 cpu.z80F |= Z80_FLAG_ZERO;
1945 }
1946 break;
1947 }
1948 case 0x66:
1949 {
1950 sdwCyclesRemaining -= 12;
1951 psMemRead = cpu.z80MemRead; /* Beginning of our handler */
1952 while (psMemRead->lowAddr != 0xffffffff)
1953 {
1954 if ((cpu.z80HL >= psMemRead->lowAddr) && (cpu.z80HL <= psMemRead->highAddr))
1955 {
1956 cpu.z80pc = (UINT32) pbPC - (UINT32) cpu.z80Base;
1957 if (psMemRead->memoryCall)
1958 {
1959 bTemp = psMemRead->memoryCall(cpu.z80HL, psMemRead);
1960 }
1961 else
1962 {
1963 bTemp = *((UINT8 *) psMemRead->pUserArea + (cpu.z80HL - psMemRead->lowAddr));
1964 }
1965 psMemRead = NULL;
1966 break;
1967 }
1968 ++psMemRead;
1969 }
1970
1971 if (psMemRead)
1972 {
1973 bTemp = cpu.z80Base[cpu.z80HL];
1974 }
1975
1976 cpu.z80F &= ~(Z80_FLAG_HALF_CARRY | Z80_FLAG_NEGATIVE | Z80_FLAG_ZERO);
1977 cpu.z80F |= (Z80_FLAG_HALF_CARRY);
1978 if (!(bTemp & 0x10))
1979 {
1980 cpu.z80F |= Z80_FLAG_ZERO;
1981 }
1982 break;
1983 }
1984 case 0x67:
1985 {
1986 sdwCyclesRemaining -= 8;
1987 cpu.z80F &= ~(Z80_FLAG_HALF_CARRY | Z80_FLAG_NEGATIVE | Z80_FLAG_ZERO);
1988 cpu.z80F |= (Z80_FLAG_HALF_CARRY);
1989 if (!(cpu.z80A & 0x10))
1990 {
1991 cpu.z80F |= Z80_FLAG_ZERO;
1992 }
1993 break;
1994 }
1995 case 0x68:
1996 {
1997 sdwCyclesRemaining -= 8;
1998 cpu.z80F &= ~(Z80_FLAG_HALF_CARRY | Z80_FLAG_NEGATIVE | Z80_FLAG_ZERO);
1999 cpu.z80F |= (Z80_FLAG_HALF_CARRY);
2000 if (!(cpu.z80B & 0x20))
2001 {
2002 cpu.z80F |= Z80_FLAG_ZERO;
2003 }
2004 break;
2005 }
2006 case 0x69:
2007 {
2008 sdwCyclesRemaining -= 8;
2009 cpu.z80F &= ~(Z80_FLAG_HALF_CARRY | Z80_FLAG_NEGATIVE | Z80_FLAG_ZERO);
2010 cpu.z80F |= (Z80_FLAG_HALF_CARRY);
2011 if (!(cpu.z80C & 0x20))
2012 {
2013 cpu.z80F |= Z80_FLAG_ZERO;
2014 }
2015 break;
2016 }
2017 case 0x6a:
2018 {
2019 sdwCyclesRemaining -= 8;
2020 cpu.z80F &= ~(Z80_FLAG_HALF_CARRY | Z80_FLAG_NEGATIVE | Z80_FLAG_ZERO);
2021 cpu.z80F |= (Z80_FLAG_HALF_CARRY);
2022 if (!(cpu.z80D & 0x20))
2023 {
2024 cpu.z80F |= Z80_FLAG_ZERO;
2025 }
2026 break;
2027 }
2028 case 0x6b:
2029 {
2030 sdwCyclesRemaining -= 8;
2031 cpu.z80F &= ~(Z80_FLAG_HALF_CARRY | Z80_FLAG_NEGATIVE | Z80_FLAG_ZERO);
2032 cpu.z80F |= (Z80_FLAG_HALF_CARRY);
2033 if (!(cpu.z80E & 0x20))
2034 {
2035 cpu.z80F |= Z80_FLAG_ZERO;
2036 }
2037 break;
2038 }
2039 case 0x6c:
2040 {
2041 sdwCyclesRemaining -= 8;
2042 cpu.z80F &= ~(Z80_FLAG_HALF_CARRY | Z80_FLAG_NEGATIVE | Z80_FLAG_ZERO);
2043 cpu.z80F |= (Z80_FLAG_HALF_CARRY);
2044 if (!(cpu.z80H & 0x20))
2045 {
2046 cpu.z80F |= Z80_FLAG_ZERO;
2047 }
2048 break;
2049 }
2050 case 0x6d:
2051 {
2052 sdwCyclesRemaining -= 8;
2053 cpu.z80F &= ~(Z80_FLAG_HALF_CARRY | Z80_FLAG_NEGATIVE | Z80_FLAG_ZERO);
2054 cpu.z80F |= (Z80_FLAG_HALF_CARRY);
2055 if (!(cpu.z80L & 0x20))
2056 {
2057 cpu.z80F |= Z80_FLAG_ZERO;
2058 }
2059 break;
2060 }
2061 case 0x6e:
2062 {
2063 sdwCyclesRemaining -= 12;
2064 psMemRead = cpu.z80MemRead; /* Beginning of our handler */
2065 while (psMemRead->lowAddr != 0xffffffff)
2066 {
2067 if ((cpu.z80HL >= psMemRead->lowAddr) && (cpu.z80HL <= psMemRead->highAddr))
2068 {
2069 cpu.z80pc = (UINT32) pbPC - (UINT32) cpu.z80Base;
2070 if (psMemRead->memoryCall)
2071 {
2072 bTemp = psMemRead->memoryCall(cpu.z80HL, psMemRead);
2073 }
2074 else
2075 {
2076 bTemp = *((UINT8 *) psMemRead->pUserArea + (cpu.z80HL - psMemRead->lowAddr));
2077 }
2078 psMemRead = NULL;
2079 break;
2080 }
2081 ++psMemRead;
2082 }
2083
2084 if (psMemRead)
2085 {
2086 bTemp = cpu.z80Base[cpu.z80HL];
2087 }
2088
2089 cpu.z80F &= ~(Z80_FLAG_HALF_CARRY | Z80_FLAG_NEGATIVE | Z80_FLAG_ZERO);
2090 cpu.z80F |= (Z80_FLAG_HALF_CARRY);
2091 if (!(bTemp & 0x20))
2092 {
2093 cpu.z80F |= Z80_FLAG_ZERO;
2094 }
2095 break;
2096 }
2097 case 0x6f:
2098 {
2099 sdwCyclesRemaining -= 8;
2100 cpu.z80F &= ~(Z80_FLAG_HALF_CARRY | Z80_FLAG_NEGATIVE | Z80_FLAG_ZERO);
2101 cpu.z80F |= (Z80_FLAG_HALF_CARRY);
2102 if (!(cpu.z80A & 0x20))
2103 {
2104 cpu.z80F |= Z80_FLAG_ZERO;
2105 }
2106 break;
2107 }
2108 case 0x70:
2109 {
2110 sdwCyclesRemaining -= 8;
2111 cpu.z80F &= ~(Z80_FLAG_HALF_CARRY | Z80_FLAG_NEGATIVE | Z80_FLAG_ZERO);
2112 cpu.z80F |= (Z80_FLAG_HALF_CARRY);
2113 if (!(cpu.z80B & 0x40))
2114 {
2115 cpu.z80F |= Z80_FLAG_ZERO;
2116 }
2117 break;
2118 }
2119 case 0x71:
2120 {
2121 sdwCyclesRemaining -= 8;
2122 cpu.z80F &= ~(Z80_FLAG_HALF_CARRY | Z80_FLAG_NEGATIVE | Z80_FLAG_ZERO);
2123 cpu.z80F |= (Z80_FLAG_HALF_CARRY);
2124 if (!(cpu.z80C & 0x40))
2125 {
2126 cpu.z80F |= Z80_FLAG_ZERO;
2127 }
2128 break;
2129 }
2130 case 0x72:
2131 {
2132 sdwCyclesRemaining -= 8;
2133 cpu.z80F &= ~(Z80_FLAG_HALF_CARRY | Z80_FLAG_NEGATIVE | Z80_FLAG_ZERO);
2134 cpu.z80F |= (Z80_FLAG_HALF_CARRY);
2135 if (!(cpu.z80D & 0x40))
2136 {
2137 cpu.z80F |= Z80_FLAG_ZERO;
2138 }
2139 break;
2140 }
2141 case 0x73:
2142 {
2143 sdwCyclesRemaining -= 8;
2144 cpu.z80F &= ~(Z80_FLAG_HALF_CARRY | Z80_FLAG_NEGATIVE | Z80_FLAG_ZERO);
2145 cpu.z80F |= (Z80_FLAG_HALF_CARRY);
2146 if (!(cpu.z80E & 0x40))
2147 {
2148 cpu.z80F |= Z80_FLAG_ZERO;
2149 }
2150 break;
2151 }
2152 case 0x74:
2153 {
2154 sdwCyclesRemaining -= 8;
2155 cpu.z80F &= ~(Z80_FLAG_HALF_CARRY | Z80_FLAG_NEGATIVE | Z80_FLAG_ZERO);
2156 cpu.z80F |= (Z80_FLAG_HALF_CARRY);
2157 if (!(cpu.z80H & 0x40))
2158 {
2159 cpu.z80F |= Z80_FLAG_ZERO;
2160 }
2161 break;
2162 }
2163 case 0x75:
2164 {
2165 sdwCyclesRemaining -= 8;
2166 cpu.z80F &= ~(Z80_FLAG_HALF_CARRY | Z80_FLAG_NEGATIVE | Z80_FLAG_ZERO);
2167 cpu.z80F |= (Z80_FLAG_HALF_CARRY);
2168 if (!(cpu.z80L & 0x40))
2169 {
2170 cpu.z80F |= Z80_FLAG_ZERO;
2171 }
2172 break;
2173 }
2174 case 0x76:
2175 {
2176 sdwCyclesRemaining -= 12;
2177 psMemRead = cpu.z80MemRead; /* Beginning of our handler */
2178 while (psMemRead->lowAddr != 0xffffffff)
2179 {
2180 if ((cpu.z80HL >= psMemRead->lowAddr) && (cpu.z80HL <= psMemRead->highAddr))
2181 {
2182 cpu.z80pc = (UINT32) pbPC - (UINT32) cpu.z80Base;
2183 if (psMemRead->memoryCall)
2184 {
2185 bTemp = psMemRead->memoryCall(cpu.z80HL, psMemRead);
2186 }
2187 else
2188 {
2189 bTemp = *((UINT8 *) psMemRead->pUserArea + (cpu.z80HL - psMemRead->lowAddr));
2190 }
2191 psMemRead = NULL;
2192 break;
2193 }
2194 ++psMemRead;
2195 }
2196
2197 if (psMemRead)
2198 {
2199 bTemp = cpu.z80Base[cpu.z80HL];
2200 }
2201
2202 cpu.z80F &= ~(Z80_FLAG_HALF_CARRY | Z80_FLAG_NEGATIVE | Z80_FLAG_ZERO);
2203 cpu.z80F |= (Z80_FLAG_HALF_CARRY);
2204 if (!(bTemp & 0x40))
2205 {
2206 cpu.z80F |= Z80_FLAG_ZERO;
2207 }
2208 break;
2209 }
2210 case 0x77:
2211 {
2212 sdwCyclesRemaining -= 8;
2213 cpu.z80F &= ~(Z80_FLAG_HALF_CARRY | Z80_FLAG_NEGATIVE | Z80_FLAG_ZERO);
2214 cpu.z80F |= (Z80_FLAG_HALF_CARRY);
2215 if (!(cpu.z80A & 0x40))
2216 {
2217 cpu.z80F |= Z80_FLAG_ZERO;
2218 }
2219 break;
2220 }
2221 case 0x78:
2222 {
2223 sdwCyclesRemaining -= 8;
2224 cpu.z80F &= ~(Z80_FLAG_HALF_CARRY | Z80_FLAG_NEGATIVE | Z80_FLAG_ZERO);
2225 cpu.z80F |= (Z80_FLAG_HALF_CARRY);
2226 if (!(cpu.z80B & 0x80))
2227 {
2228 cpu.z80F |= Z80_FLAG_ZERO;
2229 }
2230 break;
2231 }
2232 case 0x79:
2233 {
2234 sdwCyclesRemaining -= 8;
2235 cpu.z80F &= ~(Z80_FLAG_HALF_CARRY | Z80_FLAG_NEGATIVE | Z80_FLAG_ZERO);
2236 cpu.z80F |= (Z80_FLAG_HALF_CARRY);
2237 if (!(cpu.z80C & 0x80))
2238 {
2239 cpu.z80F |= Z80_FLAG_ZERO;
2240 }
2241 break;
2242 }
2243 case 0x7a:
2244 {
2245 sdwCyclesRemaining -= 8;
2246 cpu.z80F &= ~(Z80_FLAG_HALF_CARRY | Z80_FLAG_NEGATIVE | Z80_FLAG_ZERO);
2247 cpu.z80F |= (Z80_FLAG_HALF_CARRY);
2248 if (!(cpu.z80D & 0x80))
2249 {
2250 cpu.z80F |= Z80_FLAG_ZERO;
2251 }
2252 break;
2253 }
2254 case 0x7b:
2255 {
2256 sdwCyclesRemaining -= 8;
2257 cpu.z80F &= ~(Z80_FLAG_HALF_CARRY | Z80_FLAG_NEGATIVE | Z80_FLAG_ZERO);
2258 cpu.z80F |= (Z80_FLAG_HALF_CARRY);
2259 if (!(cpu.z80E & 0x80))
2260 {
2261 cpu.z80F |= Z80_FLAG_ZERO;
2262 }
2263 break;
2264 }
2265 case 0x7c:
2266 {
2267 sdwCyclesRemaining -= 8;
2268 cpu.z80F &= ~(Z80_FLAG_HALF_CARRY | Z80_FLAG_NEGATIVE | Z80_FLAG_ZERO);
2269 cpu.z80F |= (Z80_FLAG_HALF_CARRY);
2270 if (!(cpu.z80H & 0x80))
2271 {
2272 cpu.z80F |= Z80_FLAG_ZERO;
2273 }
2274 break;
2275 }
2276 case 0x7d:
2277 {
2278 sdwCyclesRemaining -= 8;
2279 cpu.z80F &= ~(Z80_FLAG_HALF_CARRY | Z80_FLAG_NEGATIVE | Z80_FLAG_ZERO);
2280 cpu.z80F |= (Z80_FLAG_HALF_CARRY);
2281 if (!(cpu.z80L & 0x80))
2282 {
2283 cpu.z80F |= Z80_FLAG_ZERO;
2284 }
2285 break;
2286 }
2287 case 0x7e:
2288 {
2289 sdwCyclesRemaining -= 12;
2290 psMemRead = cpu.z80MemRead; /* Beginning of our handler */
2291 while (psMemRead->lowAddr != 0xffffffff)
2292 {
2293 if ((cpu.z80HL >= psMemRead->lowAddr) && (cpu.z80HL <= psMemRead->highAddr))
2294 {
2295 cpu.z80pc = (UINT32) pbPC - (UINT32) cpu.z80Base;
2296 if (psMemRead->memoryCall)
2297 {
2298 bTemp = psMemRead->memoryCall(cpu.z80HL, psMemRead);
2299 }
2300 else
2301 {
2302 bTemp = *((UINT8 *) psMemRead->pUserArea + (cpu.z80HL - psMemRead->lowAddr));
2303 }
2304 psMemRead = NULL;
2305 break;
2306 }
2307 ++psMemRead;
2308 }
2309
2310 if (psMemRead)
2311 {
2312 bTemp = cpu.z80Base[cpu.z80HL];
2313 }
2314
2315 cpu.z80F &= ~(Z80_FLAG_HALF_CARRY | Z80_FLAG_NEGATIVE | Z80_FLAG_ZERO);
2316 cpu.z80F |= (Z80_FLAG_HALF_CARRY);
2317 if (!(bTemp & 0x80))
2318 {
2319 cpu.z80F |= Z80_FLAG_ZERO;
2320 }
2321 break;
2322 }
2323 case 0x7f:
2324 {
2325 sdwCyclesRemaining -= 8;
2326 cpu.z80F &= ~(Z80_FLAG_HALF_CARRY | Z80_FLAG_NEGATIVE | Z80_FLAG_ZERO);
2327 cpu.z80F |= (Z80_FLAG_HALF_CARRY);
2328 if (!(cpu.z80A & 0x80))
2329 {
2330 cpu.z80F |= Z80_FLAG_ZERO;
2331 }
2332 break;
2333 }
2334 case 0x80:
2335 {
2336 sdwCyclesRemaining -= 8;
2337 cpu.z80B &= 0xfe;
2338 break;
2339 }
2340 case 0x81:
2341 {
2342 sdwCyclesRemaining -= 8;
2343 cpu.z80C &= 0xfe;
2344 break;
2345 }
2346 case 0x82:
2347 {
2348 sdwCyclesRemaining -= 8;
2349 cpu.z80D &= 0xfe;
2350 break;
2351 }
2352 case 0x83:
2353 {
2354 sdwCyclesRemaining -= 8;
2355 cpu.z80E &= 0xfe;
2356 break;
2357 }
2358 case 0x84:
2359 {
2360 sdwCyclesRemaining -= 8;
2361 cpu.z80H &= 0xfe;
2362 break;
2363 }
2364 case 0x85:
2365 {
2366 sdwCyclesRemaining -= 8;
2367 cpu.z80L &= 0xfe;
2368 break;
2369 }
2370 case 0x86:
2371 {
2372 sdwCyclesRemaining -= 15;
2373 psMemRead = cpu.z80MemRead; /* Beginning of our handler */
2374 while (psMemRead->lowAddr != 0xffffffff)
2375 {
2376 if ((cpu.z80HL >= psMemRead->lowAddr) && (cpu.z80HL <= psMemRead->highAddr))
2377 {
2378 cpu.z80pc = (UINT32) pbPC - (UINT32) cpu.z80Base;
2379 if (psMemRead->memoryCall)
2380 {
2381 bTemp = psMemRead->memoryCall(cpu.z80HL, psMemRead);
2382 }
2383 else
2384 {
2385 bTemp = *((UINT8 *) psMemRead->pUserArea + (cpu.z80HL - psMemRead->lowAddr));
2386 }
2387 psMemRead = NULL;
2388 break;
2389 }
2390 ++psMemRead;
2391 }
2392
2393 if (psMemRead)
2394 {
2395 bTemp = cpu.z80Base[cpu.z80HL];
2396 }
2397
2398 bTemp &= 0xfe;
2399 psMemWrite = cpu.z80MemWrite; /* Beginning of our handler */
2400 while (psMemWrite->lowAddr != 0xffffffff)
2401 {
2402 if ((cpu.z80HL >= psMemWrite->lowAddr) && (cpu.z80HL <= psMemWrite->highAddr))
2403 {
2404 cpu.z80pc = (UINT32) pbPC - (UINT32) cpu.z80Base;
2405 if (psMemWrite->memoryCall)
2406 {
2407 psMemWrite->memoryCall(cpu.z80HL, bTemp, psMemWrite);
2408 }
2409 else
2410 {
2411 *((UINT8 *) psMemWrite->pUserArea + (cpu.z80HL - psMemWrite->lowAddr)) = bTemp;
2412 }
2413 psMemWrite = NULL;
2414 break;
2415 }
2416 ++psMemWrite;
2417 }
2418
2419 if (psMemWrite)
2420 {
2421 cpu.z80Base[cpu.z80HL] = (UINT8) bTemp;
2422 }
2423
2424 break;
2425 }
2426 case 0x87:
2427 {
2428 sdwCyclesRemaining -= 8;
2429 cpu.z80A &= 0xfe;
2430 break;
2431 }
2432 case 0x88:
2433 {
2434 sdwCyclesRemaining -= 8;
2435 cpu.z80B &= 0xfd;
2436 break;
2437 }
2438 case 0x89:
2439 {
2440 sdwCyclesRemaining -= 8;
2441 cpu.z80C &= 0xfd;
2442 break;
2443 }
2444 case 0x8a:
2445 {
2446 sdwCyclesRemaining -= 8;
2447 cpu.z80D &= 0xfd;
2448 break;
2449 }
2450 case 0x8b:
2451 {
2452 sdwCyclesRemaining -= 8;
2453 cpu.z80E &= 0xfd;
2454 break;
2455 }
2456 case 0x8c:
2457 {
2458 sdwCyclesRemaining -= 8;
2459 cpu.z80H &= 0xfd;
2460 break;
2461 }
2462 case 0x8d:
2463 {
2464 sdwCyclesRemaining -= 8;
2465 cpu.z80L &= 0xfd;
2466 break;
2467 }
2468 case 0x8e:
2469 {
2470 sdwCyclesRemaining -= 15;
2471 psMemRead = cpu.z80MemRead; /* Beginning of our handler */
2472 while (psMemRead->lowAddr != 0xffffffff)
2473 {
2474 if ((cpu.z80HL >= psMemRead->lowAddr) && (cpu.z80HL <= psMemRead->highAddr))
2475 {
2476 cpu.z80pc = (UINT32) pbPC - (UINT32) cpu.z80Base;
2477 if (psMemRead->memoryCall)
2478 {
2479 bTemp = psMemRead->memoryCall(cpu.z80HL, psMemRead);
2480 }
2481 else
2482 {
2483 bTemp = *((UINT8 *) psMemRead->pUserArea + (cpu.z80HL - psMemRead->lowAddr));
2484 }
2485 psMemRead = NULL;
2486 break;
2487 }
2488 ++psMemRead;
2489 }
2490
2491 if (psMemRead)
2492 {
2493 bTemp = cpu.z80Base[cpu.z80HL];
2494 }
2495
2496 bTemp &= 0xfd;
2497 psMemWrite = cpu.z80MemWrite; /* Beginning of our handler */
2498 while (psMemWrite->lowAddr != 0xffffffff)
2499 {
2500 if ((cpu.z80HL >= psMemWrite->lowAddr) && (cpu.z80HL <= psMemWrite->highAddr))
2501 {
2502 cpu.z80pc = (UINT32) pbPC - (UINT32) cpu.z80Base;
2503 if (psMemWrite->memoryCall)
2504 {
2505 psMemWrite->memoryCall(cpu.z80HL, bTemp, psMemWrite);
2506 }
2507 else
2508 {
2509 *((UINT8 *) psMemWrite->pUserArea + (cpu.z80HL - psMemWrite->lowAddr)) = bTemp;
2510 }
2511 psMemWrite = NULL;
2512 break;
2513 }
2514 ++psMemWrite;
2515 }
2516
2517 if (psMemWrite)
2518 {
2519 cpu.z80Base[cpu.z80HL] = (UINT8) bTemp;
2520 }
2521
2522 break;
2523 }
2524 case 0x8f:
2525 {
2526 sdwCyclesRemaining -= 8;
2527 cpu.z80A &= 0xfd;
2528 break;
2529 }
2530 case 0x90:
2531 {
2532 sdwCyclesRemaining -= 8;
2533 cpu.z80B &= 0xfb;
2534 break;
2535 }
2536 case 0x91:
2537 {
2538 sdwCyclesRemaining -= 8;
2539 cpu.z80C &= 0xfb;
2540 break;
2541 }
2542 case 0x92:
2543 {
2544 sdwCyclesRemaining -= 8;
2545 cpu.z80D &= 0xfb;
2546 break;
2547 }
2548 case 0x93:
2549 {
2550 sdwCyclesRemaining -= 8;
2551 cpu.z80E &= 0xfb;
2552 break;
2553 }
2554 case 0x94:
2555 {
2556 sdwCyclesRemaining -= 8;
2557 cpu.z80H &= 0xfb;
2558 break;
2559 }
2560 case 0x95:
2561 {
2562 sdwCyclesRemaining -= 8;
2563 cpu.z80L &= 0xfb;
2564 break;
2565 }
2566 case 0x96:
2567 {
2568 sdwCyclesRemaining -= 15;
2569 psMemRead = cpu.z80MemRead; /* Beginning of our handler */
2570 while (psMemRead->lowAddr != 0xffffffff)
2571 {
2572 if ((cpu.z80HL >= psMemRead->lowAddr) && (cpu.z80HL <= psMemRead->highAddr))
2573 {
2574 cpu.z80pc = (UINT32) pbPC - (UINT32) cpu.z80Base;
2575 if (psMemRead->memoryCall)
2576 {
2577 bTemp = psMemRead->memoryCall(cpu.z80HL, psMemRead);
2578 }
2579 else
2580 {
2581 bTemp = *((UINT8 *) psMemRead->pUserArea + (cpu.z80HL - psMemRead->lowAddr));
2582 }
2583 psMemRead = NULL;
2584 break;
2585 }
2586 ++psMemRead;
2587 }
2588
2589 if (psMemRead)
2590 {
2591 bTemp = cpu.z80Base[cpu.z80HL];
2592 }
2593
2594 bTemp &= 0xfb;
2595 psMemWrite = cpu.z80MemWrite; /* Beginning of our handler */
2596 while (psMemWrite->lowAddr != 0xffffffff)
2597 {
2598 if ((cpu.z80HL >= psMemWrite->lowAddr) && (cpu.z80HL <= psMemWrite->highAddr))
2599 {
2600 cpu.z80pc = (UINT32) pbPC - (UINT32) cpu.z80Base;
2601 if (psMemWrite->memoryCall)
2602 {
2603 psMemWrite->memoryCall(cpu.z80HL, bTemp, psMemWrite);
2604 }
2605 else
2606 {
2607 *((UINT8 *) psMemWrite->pUserArea + (cpu.z80HL - psMemWrite->lowAddr)) = bTemp;
2608 }
2609 psMemWrite = NULL;
2610 break;
2611 }
2612 ++psMemWrite;
2613 }
2614
2615 if (psMemWrite)
2616 {
2617 cpu.z80Base[cpu.z80HL] = (UINT8) bTemp;
2618 }
2619
2620 break;
2621 }
2622 case 0x97:
2623 {
2624 sdwCyclesRemaining -= 8;
2625 cpu.z80A &= 0xfb;
2626 break;
2627 }
2628 case 0x98:
2629 {
2630 sdwCyclesRemaining -= 8;
2631 cpu.z80B &= 0xf7;
2632 break;
2633 }
2634 case 0x99:
2635 {
2636 sdwCyclesRemaining -= 8;
2637 cpu.z80C &= 0xf7;
2638 break;
2639 }
2640 case 0x9a:
2641 {
2642 sdwCyclesRemaining -= 8;
2643 cpu.z80D &= 0xf7;
2644 break;
2645 }
2646 case 0x9b:
2647 {
2648 sdwCyclesRemaining -= 8;
2649 cpu.z80E &= 0xf7;
2650 break;
2651 }
2652 case 0x9c:
2653 {
2654 sdwCyclesRemaining -= 8;
2655 cpu.z80H &= 0xf7;
2656 break;
2657 }
2658 case 0x9d:
2659 {
2660 sdwCyclesRemaining -= 8;
2661 cpu.z80L &= 0xf7;
2662 break;
2663 }
2664 case 0x9e:
2665 {
2666 sdwCyclesRemaining -= 15;
2667 psMemRead = cpu.z80MemRead; /* Beginning of our handler */
2668 while (psMemRead->lowAddr != 0xffffffff)
2669 {
2670 if ((cpu.z80HL >= psMemRead->lowAddr) && (cpu.z80HL <= psMemRead->highAddr))
2671 {
2672 cpu.z80pc = (UINT32) pbPC - (UINT32) cpu.z80Base;
2673 if (psMemRead->memoryCall)
2674 {
2675 bTemp = psMemRead->memoryCall(cpu.z80HL, psMemRead);
2676 }
2677 else
2678 {
2679 bTemp = *((UINT8 *) psMemRead->pUserArea + (cpu.z80HL - psMemRead->lowAddr));
2680 }
2681 psMemRead = NULL;
2682 break;
2683 }
2684 ++psMemRead;
2685 }
2686
2687 if (psMemRead)
2688 {
2689 bTemp = cpu.z80Base[cpu.z80HL];
2690 }
2691
2692 bTemp &= 0xf7;
2693 psMemWrite = cpu.z80MemWrite; /* Beginning of our handler */
2694 while (psMemWrite->lowAddr != 0xffffffff)
2695 {
2696 if ((cpu.z80HL >= psMemWrite->lowAddr) && (cpu.z80HL <= psMemWrite->highAddr))
2697 {
2698 cpu.z80pc = (UINT32) pbPC - (UINT32) cpu.z80Base;
2699 if (psMemWrite->memoryCall)
2700 {
2701 psMemWrite->memoryCall(cpu.z80HL, bTemp, psMemWrite);
2702 }
2703 else
2704 {
2705 *((UINT8 *) psMemWrite->pUserArea + (cpu.z80HL - psMemWrite->lowAddr)) = bTemp;
2706 }
2707 psMemWrite = NULL;
2708 break;
2709 }
2710 ++psMemWrite;
2711 }
2712
2713 if (psMemWrite)
2714 {
2715 cpu.z80Base[cpu.z80HL] = (UINT8) bTemp;
2716 }
2717
2718 break;
2719 }
2720 case 0x9f:
2721 {
2722 sdwCyclesRemaining -= 8;
2723 cpu.z80A &= 0xf7;
2724 break;
2725 }
2726 case 0xa0:
2727 {
2728 sdwCyclesRemaining -= 8;
2729 cpu.z80B &= 0xef;
2730 break;
2731 }
2732 case 0xa1:
2733 {
2734 sdwCyclesRemaining -= 8;
2735 cpu.z80C &= 0xef;
2736 break;
2737 }
2738 case 0xa2:
2739 {
2740 sdwCyclesRemaining -= 8;
2741 cpu.z80D &= 0xef;
2742 break;
2743 }
2744 case 0xa3:
2745 {
2746 sdwCyclesRemaining -= 8;
2747 cpu.z80E &= 0xef;
2748 break;
2749 }
2750 case 0xa4:
2751 {
2752 sdwCyclesRemaining -= 8;
2753 cpu.z80H &= 0xef;
2754 break;
2755 }
2756 case 0xa5:
2757 {
2758 sdwCyclesRemaining -= 8;
2759 cpu.z80L &= 0xef;
2760 break;
2761 }
2762 case 0xa6:
2763 {
2764 sdwCyclesRemaining -= 15;
2765 psMemRead = cpu.z80MemRead; /* Beginning of our handler */
2766 while (psMemRead->lowAddr != 0xffffffff)
2767 {
2768 if ((cpu.z80HL >= psMemRead->lowAddr) && (cpu.z80HL <= psMemRead->highAddr))
2769 {
2770 cpu.z80pc = (UINT32) pbPC - (UINT32) cpu.z80Base;
2771 if (psMemRead->memoryCall)
2772 {
2773 bTemp = psMemRead->memoryCall(cpu.z80HL, psMemRead);
2774 }
2775 else
2776 {
2777 bTemp = *((UINT8 *) psMemRead->pUserArea + (cpu.z80HL - psMemRead->lowAddr));
2778 }
2779 psMemRead = NULL;
2780 break;
2781 }
2782 ++psMemRead;
2783 }
2784
2785 if (psMemRead)
2786 {
2787 bTemp = cpu.z80Base[cpu.z80HL];
2788 }
2789
2790 bTemp &= 0xef;
2791 psMemWrite = cpu.z80MemWrite; /* Beginning of our handler */
2792 while (psMemWrite->lowAddr != 0xffffffff)
2793 {
2794 if ((cpu.z80HL >= psMemWrite->lowAddr) && (cpu.z80HL <= psMemWrite->highAddr))
2795 {
2796 cpu.z80pc = (UINT32) pbPC - (UINT32) cpu.z80Base;
2797 if (psMemWrite->memoryCall)
2798 {
2799 psMemWrite->memoryCall(cpu.z80HL, bTemp, psMemWrite);
2800 }
2801 else
2802 {
2803 *((UINT8 *) psMemWrite->pUserArea + (cpu.z80HL - psMemWrite->lowAddr)) = bTemp;
2804 }
2805 psMemWrite = NULL;
2806 break;
2807 }
2808 ++psMemWrite;
2809 }
2810
2811 if (psMemWrite)
2812 {
2813 cpu.z80Base[cpu.z80HL] = (UINT8) bTemp;
2814 }
2815
2816 break;
2817 }
2818 case 0xa7:
2819 {
2820 sdwCyclesRemaining -= 8;
2821 cpu.z80A &= 0xef;
2822 break;
2823 }
2824 case 0xa8:
2825 {
2826 sdwCyclesRemaining -= 8;
2827 cpu.z80B &= 0xdf;
2828 break;
2829 }
2830 case 0xa9:
2831 {
2832 sdwCyclesRemaining -= 8;
2833 cpu.z80C &= 0xdf;
2834 break;
2835 }
2836 case 0xaa:
2837 {
2838 sdwCyclesRemaining -= 8;
2839 cpu.z80D &= 0xdf;
2840 break;
2841 }
2842 case 0xab:
2843 {
2844 sdwCyclesRemaining -= 8;
2845 cpu.z80E &= 0xdf;
2846 break;
2847 }
2848 case 0xac:
2849 {
2850 sdwCyclesRemaining -= 8;
2851 cpu.z80H &= 0xdf;
2852 break;
2853 }
2854 case 0xad:
2855 {
2856 sdwCyclesRemaining -= 8;
2857 cpu.z80L &= 0xdf;
2858 break;
2859 }
2860 case 0xae:
2861 {
2862 sdwCyclesRemaining -= 15;
2863 psMemRead = cpu.z80MemRead; /* Beginning of our handler */
2864 while (psMemRead->lowAddr != 0xffffffff)
2865 {
2866 if ((cpu.z80HL >= psMemRead->lowAddr) && (cpu.z80HL <= psMemRead->highAddr))
2867 {
2868 cpu.z80pc = (UINT32) pbPC - (UINT32) cpu.z80Base;
2869 if (psMemRead->memoryCall)
2870 {
2871 bTemp = psMemRead->memoryCall(cpu.z80HL, psMemRead);
2872 }
2873 else
2874 {
2875 bTemp = *((UINT8 *) psMemRead->pUserArea + (cpu.z80HL - psMemRead->lowAddr));
2876 }
2877 psMemRead = NULL;
2878 break;
2879 }
2880 ++psMemRead;
2881 }
2882
2883 if (psMemRead)
2884 {
2885 bTemp = cpu.z80Base[cpu.z80HL];
2886 }
2887
2888 bTemp &= 0xdf;
2889 psMemWrite = cpu.z80MemWrite; /* Beginning of our handler */
2890 while (psMemWrite->lowAddr != 0xffffffff)
2891 {
2892 if ((cpu.z80HL >= psMemWrite->lowAddr) && (cpu.z80HL <= psMemWrite->highAddr))
2893 {
2894 cpu.z80pc = (UINT32) pbPC - (UINT32) cpu.z80Base;
2895 if (psMemWrite->memoryCall)
2896 {
2897 psMemWrite->memoryCall(cpu.z80HL, bTemp, psMemWrite);
2898 }
2899 else
2900 {
2901 *((UINT8 *) psMemWrite->pUserArea + (cpu.z80HL - psMemWrite->lowAddr)) = bTemp;
2902 }
2903 psMemWrite = NULL;
2904 break;
2905 }
2906 ++psMemWrite;
2907 }
2908
2909 if (psMemWrite)
2910 {
2911 cpu.z80Base[cpu.z80HL] = (UINT8) bTemp;
2912 }
2913
2914 break;
2915 }
2916 case 0xaf:
2917 {
2918 sdwCyclesRemaining -= 8;
2919 cpu.z80A &= 0xdf;
2920 break;
2921 }
2922 case 0xb0:
2923 {
2924 sdwCyclesRemaining -= 8;
2925 cpu.z80B &= 0xbf;
2926 break;
2927 }
2928 case 0xb1:
2929 {
2930 sdwCyclesRemaining -= 8;
2931 cpu.z80C &= 0xbf;
2932 break;
2933 }
2934 case 0xb2:
2935 {
2936 sdwCyclesRemaining -= 8;
2937 cpu.z80D &= 0xbf;
2938 break;
2939 }
2940 case 0xb3:
2941 {
2942 sdwCyclesRemaining -= 8;
2943 cpu.z80E &= 0xbf;
2944 break;
2945 }
2946 case 0xb4:
2947 {
2948 sdwCyclesRemaining -= 8;
2949 cpu.z80H &= 0xbf;
2950 break;
2951 }
2952 case 0xb5:
2953 {
2954 sdwCyclesRemaining -= 8;
2955 cpu.z80L &= 0xbf;
2956 break;
2957 }
2958 case 0xb6:
2959 {
2960 sdwCyclesRemaining -= 15;
2961 psMemRead = cpu.z80MemRead; /* Beginning of our handler */
2962 while (psMemRead->lowAddr != 0xffffffff)
2963 {
2964 if ((cpu.z80HL >= psMemRead->lowAddr) && (cpu.z80HL <= psMemRead->highAddr))
2965 {
2966 cpu.z80pc = (UINT32) pbPC - (UINT32) cpu.z80Base;
2967 if (psMemRead->memoryCall)
2968 {
2969 bTemp = psMemRead->memoryCall(cpu.z80HL, psMemRead);
2970 }
2971 else
2972 {
2973 bTemp = *((UINT8 *) psMemRead->pUserArea + (cpu.z80HL - psMemRead->lowAddr));
2974 }
2975 psMemRead = NULL;
2976 break;
2977 }
2978 ++psMemRead;
2979 }
2980
2981 if (psMemRead)
2982 {
2983 bTemp = cpu.z80Base[cpu.z80HL];
2984 }
2985
2986 bTemp &= 0xbf;
2987 psMemWrite = cpu.z80MemWrite; /* Beginning of our handler */
2988 while (psMemWrite->lowAddr != 0xffffffff)
2989 {
2990 if ((cpu.z80HL >= psMemWrite->lowAddr) && (cpu.z80HL <= psMemWrite->highAddr))
2991 {
2992 cpu.z80pc = (UINT32) pbPC - (UINT32) cpu.z80Base;
2993 if (psMemWrite->memoryCall)
2994 {
2995 psMemWrite->memoryCall(cpu.z80HL, bTemp, psMemWrite);
2996 }
2997 else
2998 {
2999 *((UINT8 *) psMemWrite->pUserArea + (cpu.z80HL - psMemWrite->lowAddr)) = bTemp;
3000 }
3001 psMemWrite = NULL;
3002 break;
3003 }
3004 ++psMemWrite;
3005 }
3006
3007 if (psMemWrite)
3008 {
3009 cpu.z80Base[cpu.z80HL] = (UINT8) bTemp;
3010 }
3011
3012 break;
3013 }
3014 case 0xb7:
3015 {
3016 sdwCyclesRemaining -= 8;
3017 cpu.z80A &= 0xbf;
3018 break;
3019 }
3020 case 0xb8:
3021 {
3022 sdwCyclesRemaining -= 8;
3023 cpu.z80B &= 0x7f;
3024 break;
3025 }
3026 case 0xb9:
3027 {
3028 sdwCyclesRemaining -= 8;
3029 cpu.z80C &= 0x7f;
3030 break;
3031 }
3032 case 0xba:
3033 {
3034 sdwCyclesRemaining -= 8;
3035 cpu.z80D &= 0x7f;
3036 break;
3037 }
3038 case 0xbb:
3039 {
3040 sdwCyclesRemaining -= 8;
3041 cpu.z80E &= 0x7f;
3042 break;
3043 }
3044 case 0xbc:
3045 {
3046 sdwCyclesRemaining -= 8;
3047 cpu.z80H &= 0x7f;
3048 break;
3049 }
3050 case 0xbd:
3051 {
3052 sdwCyclesRemaining -= 8;
3053 cpu.z80L &= 0x7f;
3054 break;
3055 }
3056 case 0xbe:
3057 {
3058 sdwCyclesRemaining -= 15;
3059 psMemRead = cpu.z80MemRead; /* Beginning of our handler */
3060 while (psMemRead->lowAddr != 0xffffffff)
3061 {
3062 if ((cpu.z80HL >= psMemRead->lowAddr) && (cpu.z80HL <= psMemRead->highAddr))
3063 {
3064 cpu.z80pc = (UINT32) pbPC - (UINT32) cpu.z80Base;
3065 if (psMemRead->memoryCall)
3066 {
3067 bTemp = psMemRead->memoryCall(cpu.z80HL, psMemRead);
3068 }
3069 else
3070 {
3071 bTemp = *((UINT8 *) psMemRead->pUserArea + (cpu.z80HL - psMemRead->lowAddr));
3072 }
3073 psMemRead = NULL;
3074 break;
3075 }
3076 ++psMemRead;
3077 }
3078
3079 if (psMemRead)
3080 {
3081 bTemp = cpu.z80Base[cpu.z80HL];
3082 }
3083
3084 bTemp &= 0x7f;
3085 psMemWrite = cpu.z80MemWrite; /* Beginning of our handler */
3086 while (psMemWrite->lowAddr != 0xffffffff)
3087 {
3088 if ((cpu.z80HL >= psMemWrite->lowAddr) && (cpu.z80HL <= psMemWrite->highAddr))
3089 {
3090 cpu.z80pc = (UINT32) pbPC - (UINT32) cpu.z80Base;
3091 if (psMemWrite->memoryCall)
3092 {
3093 psMemWrite->memoryCall(cpu.z80HL, bTemp, psMemWrite);
3094 }
3095 else
3096 {
3097 *((UINT8 *) psMemWrite->pUserArea + (cpu.z80HL - psMemWrite->lowAddr)) = bTemp;
3098 }
3099 psMemWrite = NULL;
3100 break;
3101 }
3102 ++psMemWrite;
3103 }
3104
3105 if (psMemWrite)
3106 {
3107 cpu.z80Base[cpu.z80HL] = (UINT8) bTemp;
3108 }
3109
3110 break;
3111 }
3112 case 0xbf:
3113 {
3114 sdwCyclesRemaining -= 8;
3115 cpu.z80A &= 0x7f;
3116 break;
3117 }
3118 case 0xc0:
3119 {
3120 sdwCyclesRemaining -= 8;
3121 cpu.z80B |= 0x01;
3122 break;
3123 }
3124 case 0xc1:
3125 {
3126 sdwCyclesRemaining -= 8;
3127 cpu.z80C |= 0x01;
3128 break;
3129 }
3130 case 0xc2:
3131 {
3132 sdwCyclesRemaining -= 8;
3133 cpu.z80D |= 0x01;
3134 break;
3135 }
3136 case 0xc3:
3137 {
3138 sdwCyclesRemaining -= 8;
3139 cpu.z80E |= 0x01;
3140 break;
3141 }
3142 case 0xc4:
3143 {
3144 sdwCyclesRemaining -= 8;
3145 cpu.z80H |= 0x01;
3146 break;
3147 }
3148 case 0xc5:
3149 {
3150 sdwCyclesRemaining -= 8;
3151 cpu.z80L |= 0x01;
3152 break;
3153 }
3154 case 0xc6:
3155 {
3156 sdwCyclesRemaining -= 15;
3157 psMemRead = cpu.z80MemRead; /* Beginning of our handler */
3158 while (psMemRead->lowAddr != 0xffffffff)
3159 {
3160 if ((cpu.z80HL >= psMemRead->lowAddr) && (cpu.z80HL <= psMemRead->highAddr))
3161 {
3162 cpu.z80pc = (UINT32) pbPC - (UINT32) cpu.z80Base;
3163 if (psMemRead->memoryCall)
3164 {
3165 bTemp = psMemRead->memoryCall(cpu.z80HL, psMemRead);
3166 }
3167 else
3168 {
3169 bTemp = *((UINT8 *) psMemRead->pUserArea + (cpu.z80HL - psMemRead->lowAddr));
3170 }
3171 psMemRead = NULL;
3172 break;
3173 }
3174 ++psMemRead;
3175 }
3176
3177 if (psMemRead)
3178 {
3179 bTemp = cpu.z80Base[cpu.z80HL];
3180 }
3181
3182 bTemp |= 0x01;
3183 psMemWrite = cpu.z80MemWrite; /* Beginning of our handler */
3184 while (psMemWrite->lowAddr != 0xffffffff)
3185 {
3186 if ((cpu.z80HL >= psMemWrite->lowAddr) && (cpu.z80HL <= psMemWrite->highAddr))
3187 {
3188 cpu.z80pc = (UINT32) pbPC - (UINT32) cpu.z80Base;
3189 if (psMemWrite->memoryCall)
3190 {
3191 psMemWrite->memoryCall(cpu.z80HL, bTemp, psMemWrite);
3192 }
3193 else
3194 {
3195 *((UINT8 *) psMemWrite->pUserArea + (cpu.z80HL - psMemWrite->lowAddr)) = bTemp;
3196 }
3197 psMemWrite = NULL;
3198 break;
3199 }
3200 ++psMemWrite;
3201 }
3202
3203 if (psMemWrite)
3204 {
3205 cpu.z80Base[cpu.z80HL] = (UINT8) bTemp;
3206 }
3207
3208 break;
3209 }
3210 case 0xc7:
3211 {
3212 sdwCyclesRemaining -= 8;
3213 cpu.z80A |= 0x01;
3214 break;
3215 }
3216 case 0xc8:
3217 {
3218 sdwCyclesRemaining -= 8;
3219 cpu.z80B |= 0x02;
3220 break;
3221 }
3222 case 0xc9:
3223 {
3224 sdwCyclesRemaining -= 8;
3225 cpu.z80C |= 0x02;
3226 break;
3227 }
3228 case 0xca:
3229 {
3230 sdwCyclesRemaining -= 8;
3231 cpu.z80D |= 0x02;
3232 break;
3233 }
3234 case 0xcb:
3235 {
3236 sdwCyclesRemaining -= 8;
3237 cpu.z80E |= 0x02;
3238 break;
3239 }
3240 case 0xcc:
3241 {
3242 sdwCyclesRemaining -= 8;
3243 cpu.z80H |= 0x02;
3244 break;
3245 }
3246 case 0xcd:
3247 {
3248 sdwCyclesRemaining -= 8;
3249 cpu.z80L |= 0x02;
3250 break;
3251 }
3252 case 0xce:
3253 {
3254 sdwCyclesRemaining -= 15;
3255 psMemRead = cpu.z80MemRead; /* Beginning of our handler */
3256 while (psMemRead->lowAddr != 0xffffffff)
3257 {
3258 if ((cpu.z80HL >= psMemRead->lowAddr) && (cpu.z80HL <= psMemRead->highAddr))
3259 {
3260 cpu.z80pc = (UINT32) pbPC - (UINT32) cpu.z80Base;
3261 if (psMemRead->memoryCall)
3262 {
3263 bTemp = psMemRead->memoryCall(cpu.z80HL, psMemRead);
3264 }
3265 else
3266 {
3267 bTemp = *((UINT8 *) psMemRead->pUserArea + (cpu.z80HL - psMemRead->lowAddr));
3268 }
3269 psMemRead = NULL;
3270 break;
3271 }
3272 ++psMemRead;
3273 }
3274
3275 if (psMemRead)
3276 {
3277 bTemp = cpu.z80Base[cpu.z80HL];
3278 }
3279
3280 bTemp |= 0x02;
3281 psMemWrite = cpu.z80MemWrite; /* Beginning of our handler */
3282 while (psMemWrite->lowAddr != 0xffffffff)
3283 {
3284 if ((cpu.z80HL >= psMemWrite->lowAddr) && (cpu.z80HL <= psMemWrite->highAddr))
3285 {
3286 cpu.z80pc = (UINT32) pbPC - (UINT32) cpu.z80Base;
3287 if (psMemWrite->memoryCall)
3288 {
3289 psMemWrite->memoryCall(cpu.z80HL, bTemp, psMemWrite);
3290 }
3291 else
3292 {
3293 *((UINT8 *) psMemWrite->pUserArea + (cpu.z80HL - psMemWrite->lowAddr)) = bTemp;
3294 }
3295 psMemWrite = NULL;
3296 break;
3297 }
3298 ++psMemWrite;
3299 }
3300
3301 if (psMemWrite)
3302 {
3303 cpu.z80Base[cpu.z80HL] = (UINT8) bTemp;
3304 }
3305
3306 break;
3307 }
3308 case 0xcf:
3309 {
3310 sdwCyclesRemaining -= 8;
3311 cpu.z80A |= 0x02;
3312 break;
3313 }
3314 case 0xd0:
3315 {
3316 sdwCyclesRemaining -= 8;
3317 cpu.z80B |= 0x04;
3318 break;
3319 }
3320 case 0xd1:
3321 {
3322 sdwCyclesRemaining -= 8;
3323 cpu.z80C |= 0x04;
3324 break;
3325 }
3326 case 0xd2:
3327 {
3328 sdwCyclesRemaining -= 8;
3329 cpu.z80D |= 0x04;
3330 break;
3331 }
3332 case 0xd3:
3333 {
3334 sdwCyclesRemaining -= 8;
3335 cpu.z80E |= 0x04;
3336 break;
3337 }
3338 case 0xd4:
3339 {
3340 sdwCyclesRemaining -= 8;
3341 cpu.z80H |= 0x04;
3342 break;
3343 }
3344 case 0xd5:
3345 {
3346 sdwCyclesRemaining -= 8;
3347 cpu.z80L |= 0x04;
3348 break;
3349 }
3350 case 0xd6:
3351 {
3352 sdwCyclesRemaining -= 15;
3353 psMemRead = cpu.z80MemRead; /* Beginning of our handler */
3354 while (psMemRead->lowAddr != 0xffffffff)
3355 {
3356 if ((cpu.z80HL >= psMemRead->lowAddr) && (cpu.z80HL <= psMemRead->highAddr))
3357 {
3358 cpu.z80pc = (UINT32) pbPC - (UINT32) cpu.z80Base;
3359 if (psMemRead->memoryCall)
3360 {
3361 bTemp = psMemRead->memoryCall(cpu.z80HL, psMemRead);
3362 }
3363 else
3364 {
3365 bTemp = *((UINT8 *) psMemRead->pUserArea + (cpu.z80HL - psMemRead->lowAddr));
3366 }
3367 psMemRead = NULL;
3368 break;
3369 }
3370 ++psMemRead;
3371 }
3372
3373 if (psMemRead)
3374 {
3375 bTemp = cpu.z80Base[cpu.z80HL];
3376 }
3377
3378 bTemp |= 0x04;
3379 psMemWrite = cpu.z80MemWrite; /* Beginning of our handler */
3380 while (psMemWrite->lowAddr != 0xffffffff)
3381 {
3382 if ((cpu.z80HL >= psMemWrite->lowAddr) && (cpu.z80HL <= psMemWrite->highAddr))
3383 {
3384 cpu.z80pc = (UINT32) pbPC - (UINT32) cpu.z80Base;
3385 if (psMemWrite->memoryCall)
3386 {
3387 psMemWrite->memoryCall(cpu.z80HL, bTemp, psMemWrite);
3388 }
3389 else
3390 {
3391 *((UINT8 *) psMemWrite->pUserArea + (cpu.z80HL - psMemWrite->lowAddr)) = bTemp;
3392 }
3393 psMemWrite = NULL;
3394 break;
3395 }
3396 ++psMemWrite;
3397 }
3398
3399 if (psMemWrite)
3400 {
3401 cpu.z80Base[cpu.z80HL] = (UINT8) bTemp;
3402 }
3403
3404 break;
3405 }
3406 case 0xd7:
3407 {
3408 sdwCyclesRemaining -= 8;
3409 cpu.z80A |= 0x04;
3410 break;
3411 }
3412 case 0xd8:
3413 {
3414 sdwCyclesRemaining -= 8;
3415 cpu.z80B |= 0x08;
3416 break;
3417 }
3418 case 0xd9:
3419 {
3420 sdwCyclesRemaining -= 8;
3421 cpu.z80C |= 0x08;
3422 break;
3423 }
3424 case 0xda:
3425 {
3426 sdwCyclesRemaining -= 8;
3427 cpu.z80D |= 0x08;
3428 break;
3429 }
3430 case 0xdb:
3431 {
3432 sdwCyclesRemaining -= 8;
3433 cpu.z80E |= 0x08;
3434 break;
3435 }
3436 case 0xdc:
3437 {
3438 sdwCyclesRemaining -= 8;
3439 cpu.z80H |= 0x08;
3440 break;
3441 }
3442 case 0xdd:
3443 {
3444 sdwCyclesRemaining -= 8;
3445 cpu.z80L |= 0x08;
3446 break;
3447 }
3448 case 0xde:
3449 {
3450 sdwCyclesRemaining -= 15;
3451 psMemRead = cpu.z80MemRead; /* Beginning of our handler */
3452 while (psMemRead->lowAddr != 0xffffffff)
3453 {
3454 if ((cpu.z80HL >= psMemRead->lowAddr) && (cpu.z80HL <= psMemRead->highAddr))
3455 {
3456 cpu.z80pc = (UINT32) pbPC - (UINT32) cpu.z80Base;
3457 if (psMemRead->memoryCall)
3458 {
3459 bTemp = psMemRead->memoryCall(cpu.z80HL, psMemRead);
3460 }
3461 else
3462 {
3463 bTemp = *((UINT8 *) psMemRead->pUserArea + (cpu.z80HL - psMemRead->lowAddr));
3464 }
3465 psMemRead = NULL;
3466 break;
3467 }
3468 ++psMemRead;
3469 }
3470
3471 if (psMemRead)
3472 {
3473 bTemp = cpu.z80Base[cpu.z80HL];
3474 }
3475
3476 bTemp |= 0x08;
3477 psMemWrite = cpu.z80MemWrite; /* Beginning of our handler */
3478 while (psMemWrite->lowAddr != 0xffffffff)
3479 {
3480 if ((cpu.z80HL >= psMemWrite->lowAddr) && (cpu.z80HL <= psMemWrite->highAddr))
3481 {
3482 cpu.z80pc = (UINT32) pbPC - (UINT32) cpu.z80Base;
3483 if (psMemWrite->memoryCall)
3484 {
3485 psMemWrite->memoryCall(cpu.z80HL, bTemp, psMemWrite);
3486 }
3487 else
3488 {
3489 *((UINT8 *) psMemWrite->pUserArea + (cpu.z80HL - psMemWrite->lowAddr)) = bTemp;
3490 }
3491 psMemWrite = NULL;
3492 break;
3493 }
3494 ++psMemWrite;
3495 }
3496
3497 if (psMemWrite)
3498 {
3499 cpu.z80Base[cpu.z80HL] = (UINT8) bTemp;
3500 }
3501
3502 break;
3503 }
3504 case 0xdf:
3505 {
3506 sdwCyclesRemaining -= 8;
3507 cpu.z80A |= 0x08;
3508 break;
3509 }
3510 case 0xe0:
3511 {
3512 sdwCyclesRemaining -= 8;
3513 cpu.z80B |= 0x10;
3514 break;
3515 }
3516 case 0xe1:
3517 {
3518 sdwCyclesRemaining -= 8;
3519 cpu.z80C |= 0x10;
3520 break;
3521 }
3522 case 0xe2:
3523 {
3524 sdwCyclesRemaining -= 8;
3525 cpu.z80D |= 0x10;
3526 break;
3527 }
3528 case 0xe3:
3529 {
3530 sdwCyclesRemaining -= 8;
3531 cpu.z80E |= 0x10;
3532 break;
3533 }
3534 case 0xe4:
3535 {
3536 sdwCyclesRemaining -= 8;
3537 cpu.z80H |= 0x10;
3538 break;
3539 }
3540 case 0xe5:
3541 {
3542 sdwCyclesRemaining -= 8;
3543 cpu.z80L |= 0x10;
3544 break;
3545 }
3546 case 0xe6:
3547 {
3548 sdwCyclesRemaining -= 15;
3549 psMemRead = cpu.z80MemRead; /* Beginning of our handler */
3550 while (psMemRead->lowAddr != 0xffffffff)
3551 {
3552 if ((cpu.z80HL >= psMemRead->lowAddr) && (cpu.z80HL <= psMemRead->highAddr))
3553 {
3554 cpu.z80pc = (UINT32) pbPC - (UINT32) cpu.z80Base;
3555 if (psMemRead->memoryCall)
3556 {
3557 bTemp = psMemRead->memoryCall(cpu.z80HL, psMemRead);
3558 }
3559 else
3560 {
3561 bTemp = *((UINT8 *) psMemRead->pUserArea + (cpu.z80HL - psMemRead->lowAddr));
3562 }
3563 psMemRead = NULL;
3564 break;
3565 }
3566 ++psMemRead;
3567 }
3568
3569 if (psMemRead)
3570 {
3571 bTemp = cpu.z80Base[cpu.z80HL];
3572 }
3573
3574 bTemp |= 0x10;
3575 psMemWrite = cpu.z80MemWrite; /* Beginning of our handler */
3576 while (psMemWrite->lowAddr != 0xffffffff)
3577 {
3578 if ((cpu.z80HL >= psMemWrite->lowAddr) && (cpu.z80HL <= psMemWrite->highAddr))
3579 {
3580 cpu.z80pc = (UINT32) pbPC - (UINT32) cpu.z80Base;
3581 if (psMemWrite->memoryCall)
3582 {
3583 psMemWrite->memoryCall(cpu.z80HL, bTemp, psMemWrite);
3584 }
3585 else
3586 {
3587 *((UINT8 *) psMemWrite->pUserArea + (cpu.z80HL - psMemWrite->lowAddr)) = bTemp;
3588 }
3589 psMemWrite = NULL;
3590 break;
3591 }
3592 ++psMemWrite;
3593 }
3594
3595 if (psMemWrite)
3596 {
3597 cpu.z80Base[cpu.z80HL] = (UINT8) bTemp;
3598 }
3599
3600 break;
3601 }
3602 case 0xe7:
3603 {
3604 sdwCyclesRemaining -= 8;
3605 cpu.z80A |= 0x10;
3606 break;
3607 }
3608 case 0xe8:
3609 {
3610 sdwCyclesRemaining -= 8;
3611 cpu.z80B |= 0x20;
3612 break;
3613 }
3614 case 0xe9:
3615 {
3616 sdwCyclesRemaining -= 8;
3617 cpu.z80C |= 0x20;
3618 break;
3619 }
3620 case 0xea:
3621 {
3622 sdwCyclesRemaining -= 8;
3623 cpu.z80D |= 0x20;
3624 break;
3625 }
3626 case 0xeb:
3627 {
3628 sdwCyclesRemaining -= 8;
3629 cpu.z80E |= 0x20;
3630 break;
3631 }
3632 case 0xec:
3633 {
3634 sdwCyclesRemaining -= 8;
3635 cpu.z80H |= 0x20;
3636 break;
3637 }
3638 case 0xed:
3639 {
3640 sdwCyclesRemaining -= 8;
3641 cpu.z80L |= 0x20;
3642 break;
3643 }
3644 case 0xee:
3645 {
3646 sdwCyclesRemaining -= 15;
3647 psMemRead = cpu.z80MemRead; /* Beginning of our handler */
3648 while (psMemRead->lowAddr != 0xffffffff)
3649 {
3650 if ((cpu.z80HL >= psMemRead->lowAddr) && (cpu.z80HL <= psMemRead->highAddr))
3651 {
3652 cpu.z80pc = (UINT32) pbPC - (UINT32) cpu.z80Base;
3653 if (psMemRead->memoryCall)
3654 {
3655 bTemp = psMemRead->memoryCall(cpu.z80HL, psMemRead);
3656 }
3657 else
3658 {
3659 bTemp = *((UINT8 *) psMemRead->pUserArea + (cpu.z80HL - psMemRead->lowAddr));
3660 }
3661 psMemRead = NULL;
3662 break;
3663 }
3664 ++psMemRead;
3665 }
3666
3667 if (psMemRead)
3668 {
3669 bTemp = cpu.z80Base[cpu.z80HL];
3670 }
3671
3672 bTemp |= 0x20;
3673 psMemWrite = cpu.z80MemWrite; /* Beginning of our handler */
3674 while (psMemWrite->lowAddr != 0xffffffff)
3675 {
3676 if ((cpu.z80HL >= psMemWrite->lowAddr) && (cpu.z80HL <= psMemWrite->highAddr))
3677 {
3678 cpu.z80pc = (UINT32) pbPC - (UINT32) cpu.z80Base;
3679 if (psMemWrite->memoryCall)
3680 {
3681 psMemWrite->memoryCall(cpu.z80HL, bTemp, psMemWrite);
3682 }
3683 else
3684 {
3685 *((UINT8 *) psMemWrite->pUserArea + (cpu.z80HL - psMemWrite->lowAddr)) = bTemp;
3686 }
3687 psMemWrite = NULL;
3688 break;
3689 }
3690 ++psMemWrite;
3691 }
3692
3693 if (psMemWrite)
3694 {
3695 cpu.z80Base[cpu.z80HL] = (UINT8) bTemp;
3696 }
3697
3698 break;
3699 }
3700 case 0xef:
3701 {
3702 sdwCyclesRemaining -= 8;
3703 cpu.z80A |= 0x20;
3704 break;
3705 }
3706 case 0xf0:
3707 {
3708 sdwCyclesRemaining -= 8;
3709 cpu.z80B |= 0x40;
3710 break;
3711 }
3712 case 0xf1:
3713 {
3714 sdwCyclesRemaining -= 8;
3715 cpu.z80C |= 0x40;
3716 break;
3717 }
3718 case 0xf2:
3719 {
3720 sdwCyclesRemaining -= 8;
3721 cpu.z80D |= 0x40;
3722 break;
3723 }
3724 case 0xf3:
3725 {
3726 sdwCyclesRemaining -= 8;
3727 cpu.z80E |= 0x40;
3728 break;
3729 }
3730 case 0xf4:
3731 {
3732 sdwCyclesRemaining -= 8;
3733 cpu.z80H |= 0x40;
3734 break;
3735 }
3736 case 0xf5:
3737 {
3738 sdwCyclesRemaining -= 8;
3739 cpu.z80L |= 0x40;
3740 break;
3741 }
3742 case 0xf6:
3743 {
3744 sdwCyclesRemaining -= 15;
3745 psMemRead = cpu.z80MemRead; /* Beginning of our handler */
3746 while (psMemRead->lowAddr != 0xffffffff)
3747 {
3748 if ((cpu.z80HL >= psMemRead->lowAddr) && (cpu.z80HL <= psMemRead->highAddr))
3749 {
3750 cpu.z80pc = (UINT32) pbPC - (UINT32) cpu.z80Base;
3751 if (psMemRead->memoryCall)
3752 {
3753 bTemp = psMemRead->memoryCall(cpu.z80HL, psMemRead);
3754 }
3755 else
3756 {
3757 bTemp = *((UINT8 *) psMemRead->pUserArea + (cpu.z80HL - psMemRead->lowAddr));
3758 }
3759 psMemRead = NULL;
3760 break;
3761 }
3762 ++psMemRead;
3763 }
3764
3765 if (psMemRead)
3766 {
3767 bTemp = cpu.z80Base[cpu.z80HL];
3768 }
3769
3770 bTemp |= 0x40;
3771 psMemWrite = cpu.z80MemWrite; /* Beginning of our handler */
3772 while (psMemWrite->lowAddr != 0xffffffff)
3773 {
3774 if ((cpu.z80HL >= psMemWrite->lowAddr) && (cpu.z80HL <= psMemWrite->highAddr))
3775 {
3776 cpu.z80pc = (UINT32) pbPC - (UINT32) cpu.z80Base;
3777 if (psMemWrite->memoryCall)
3778 {
3779 psMemWrite->memoryCall(cpu.z80HL, bTemp, psMemWrite);
3780 }
3781 else
3782 {
3783 *((UINT8 *) psMemWrite->pUserArea + (cpu.z80HL - psMemWrite->lowAddr)) = bTemp;
3784 }
3785 psMemWrite = NULL;
3786 break;
3787 }
3788 ++psMemWrite;
3789 }
3790
3791 if (psMemWrite)
3792 {
3793 cpu.z80Base[cpu.z80HL] = (UINT8) bTemp;
3794 }
3795
3796 break;
3797 }
3798 case 0xf7:
3799 {
3800 sdwCyclesRemaining -= 8;
3801 cpu.z80A |= 0x40;
3802 break;
3803 }
3804 case 0xf8:
3805 {
3806 sdwCyclesRemaining -= 8;
3807 cpu.z80B |= 0x80;
3808 break;
3809 }
3810 case 0xf9:
3811 {
3812 sdwCyclesRemaining -= 8;
3813 cpu.z80C |= 0x80;
3814 break;
3815 }
3816 case 0xfa:
3817 {
3818 sdwCyclesRemaining -= 8;
3819 cpu.z80D |= 0x80;
3820 break;
3821 }
3822 case 0xfb:
3823 {
3824 sdwCyclesRemaining -= 8;
3825 cpu.z80E |= 0x80;
3826 break;
3827 }
3828 case 0xfc:
3829 {
3830 sdwCyclesRemaining -= 8;
3831 cpu.z80H |= 0x80;
3832 break;
3833 }
3834 case 0xfd:
3835 {
3836 sdwCyclesRemaining -= 8;
3837 cpu.z80L |= 0x80;
3838 break;
3839 }
3840 case 0xfe:
3841 {
3842 sdwCyclesRemaining -= 15;
3843 psMemRead = cpu.z80MemRead; /* Beginning of our handler */
3844 while (psMemRead->lowAddr != 0xffffffff)
3845 {
3846 if ((cpu.z80HL >= psMemRead->lowAddr) && (cpu.z80HL <= psMemRead->highAddr))
3847 {
3848 cpu.z80pc = (UINT32) pbPC - (UINT32) cpu.z80Base;
3849 if (psMemRead->memoryCall)
3850 {
3851 bTemp = psMemRead->memoryCall(cpu.z80HL, psMemRead);
3852 }
3853 else
3854 {
3855 bTemp = *((UINT8 *) psMemRead->pUserArea + (cpu.z80HL - psMemRead->lowAddr));
3856 }
3857 psMemRead = NULL;
3858 break;
3859 }
3860 ++psMemRead;
3861 }
3862
3863 if (psMemRead)
3864 {
3865 bTemp = cpu.z80Base[cpu.z80HL];
3866 }
3867
3868 bTemp |= 0x80;
3869 psMemWrite = cpu.z80MemWrite; /* Beginning of our handler */
3870 while (psMemWrite->lowAddr != 0xffffffff)
3871 {
3872 if ((cpu.z80HL >= psMemWrite->lowAddr) && (cpu.z80HL <= psMemWrite->highAddr))
3873 {
3874 cpu.z80pc = (UINT32) pbPC - (UINT32) cpu.z80Base;
3875 if (psMemWrite->memoryCall)
3876 {
3877 psMemWrite->memoryCall(cpu.z80HL, bTemp, psMemWrite);
3878 }
3879 else
3880 {
3881 *((UINT8 *) psMemWrite->pUserArea + (cpu.z80HL - psMemWrite->lowAddr)) = bTemp;
3882 }
3883 psMemWrite = NULL;
3884 break;
3885 }
3886 ++psMemWrite;
3887 }
3888
3889 if (psMemWrite)
3890 {
3891 cpu.z80Base[cpu.z80HL] = (UINT8) bTemp;
3892 }
3893
3894 break;
3895 }
3896 case 0xff:
3897 {
3898 sdwCyclesRemaining -= 8;
3899 cpu.z80A |= 0x80;
3900 break;
3901 }
3902 }
3903}
3904void EDHandler(void)
3905{
3906 switch (*pbPC++)
3907 {
3908 case 0x00:
3909 {
3910 InvalidInstruction(2);
3911 break;
3912 }
3913 case 0x01:
3914 {
3915 InvalidInstruction(2);
3916 break;
3917 }
3918 case 0x02:
3919 {
3920 InvalidInstruction(2);
3921 break;
3922 }
3923 case 0x03:
3924 {
3925 InvalidInstruction(2);
3926 break;
3927 }
3928 case 0x04:
3929 {
3930 InvalidInstruction(2);
3931 break;
3932 }
3933 case 0x05:
3934 {
3935 InvalidInstruction(2);
3936 break;
3937 }
3938 case 0x06:
3939 {
3940 InvalidInstruction(2);
3941 break;
3942 }
3943 case 0x07:
3944 {
3945 InvalidInstruction(2);
3946 break;
3947 }
3948 case 0x08:
3949 {
3950 InvalidInstruction(2);
3951 break;
3952 }
3953 case 0x09:
3954 {
3955 InvalidInstruction(2);
3956 break;
3957 }
3958 case 0x0a:
3959 {
3960 InvalidInstruction(2);
3961 break;
3962 }
3963 case 0x0b:
3964 {
3965 InvalidInstruction(2);
3966 break;
3967 }
3968 case 0x0c:
3969 {
3970 InvalidInstruction(2);
3971 break;
3972 }
3973 case 0x0d:
3974 {
3975 InvalidInstruction(2);
3976 break;
3977 }
3978 case 0x0e:
3979 {
3980 InvalidInstruction(2);
3981 break;
3982 }
3983 case 0x0f:
3984 {
3985 InvalidInstruction(2);
3986 break;
3987 }
3988 case 0x10:
3989 {
3990 InvalidInstruction(2);
3991 break;
3992 }
3993 case 0x11:
3994 {
3995 InvalidInstruction(2);
3996 break;
3997 }
3998 case 0x12:
3999 {
4000 InvalidInstruction(2);
4001 break;
4002 }
4003 case 0x13:
4004 {
4005 InvalidInstruction(2);
4006 break;
4007 }
4008 case 0x14:
4009 {
4010 InvalidInstruction(2);
4011 break;
4012 }
4013 case 0x15:
4014 {
4015 InvalidInstruction(2);
4016 break;
4017 }
4018 case 0x16:
4019 {
4020 InvalidInstruction(2);
4021 break;
4022 }
4023 case 0x17:
4024 {
4025 InvalidInstruction(2);
4026 break;
4027 }
4028 case 0x18:
4029 {
4030 InvalidInstruction(2);
4031 break;
4032 }
4033 case 0x19:
4034 {
4035 InvalidInstruction(2);
4036 break;
4037 }
4038 case 0x1a:
4039 {
4040 InvalidInstruction(2);
4041 break;
4042 }
4043 case 0x1b:
4044 {
4045 InvalidInstruction(2);
4046 break;
4047 }
4048 case 0x1c:
4049 {
4050 InvalidInstruction(2);
4051 break;
4052 }
4053 case 0x1d:
4054 {
4055 InvalidInstruction(2);
4056 break;
4057 }
4058 case 0x1e:
4059 {
4060 InvalidInstruction(2);
4061 break;
4062 }
4063 case 0x1f:
4064 {
4065 InvalidInstruction(2);
4066 break;
4067 }
4068 case 0x20:
4069 {
4070 InvalidInstruction(2);
4071 break;
4072 }
4073 case 0x21:
4074 {
4075 InvalidInstruction(2);
4076 break;
4077 }
4078 case 0x22:
4079 {
4080 InvalidInstruction(2);
4081 break;
4082 }
4083 case 0x23:
4084 {
4085 InvalidInstruction(2);
4086 break;
4087 }
4088 case 0x24:
4089 {
4090 InvalidInstruction(2);
4091 break;
4092 }
4093 case 0x25:
4094 {
4095 InvalidInstruction(2);
4096 break;
4097 }
4098 case 0x26:
4099 {
4100 InvalidInstruction(2);
4101 break;
4102 }
4103 case 0x27:
4104 {
4105 InvalidInstruction(2);
4106 break;
4107 }
4108 case 0x28:
4109 {
4110 InvalidInstruction(2);
4111 break;
4112 }
4113 case 0x29:
4114 {
4115 InvalidInstruction(2);
4116 break;
4117 }
4118 case 0x2a:
4119 {
4120 InvalidInstruction(2);
4121 break;
4122 }
4123 case 0x2b:
4124 {
4125 InvalidInstruction(2);
4126 break;
4127 }
4128 case 0x2c:
4129 {
4130 InvalidInstruction(2);
4131 break;
4132 }
4133 case 0x2d:
4134 {
4135 InvalidInstruction(2);
4136 break;
4137 }
4138 case 0x2e:
4139 {
4140 InvalidInstruction(2);
4141 break;
4142 }
4143 case 0x2f:
4144 {
4145 InvalidInstruction(2);
4146 break;
4147 }
4148 case 0x30:
4149 {
4150 InvalidInstruction(2);
4151 break;
4152 }
4153 case 0x31:
4154 {
4155 InvalidInstruction(2);
4156 break;
4157 }
4158 case 0x32:
4159 {
4160 InvalidInstruction(2);
4161 break;
4162 }
4163 case 0x33:
4164 {
4165 InvalidInstruction(2);
4166 break;
4167 }
4168 case 0x34:
4169 {
4170 InvalidInstruction(2);
4171 break;
4172 }
4173 case 0x35:
4174 {
4175 InvalidInstruction(2);
4176 break;
4177 }
4178 case 0x36:
4179 {
4180 InvalidInstruction(2);
4181 break;
4182 }
4183 case 0x37:
4184 {
4185 InvalidInstruction(2);
4186 break;
4187 }
4188 case 0x38:
4189 {
4190 InvalidInstruction(2);
4191 break;
4192 }
4193 case 0x39:
4194 {
4195 InvalidInstruction(2);
4196 break;
4197 }
4198 case 0x3a:
4199 {
4200 InvalidInstruction(2);
4201 break;
4202 }
4203 case 0x3b:
4204 {
4205 InvalidInstruction(2);
4206 break;
4207 }
4208 case 0x3c:
4209 {
4210 InvalidInstruction(2);
4211 break;
4212 }
4213 case 0x3d:
4214 {
4215 InvalidInstruction(2);
4216 break;
4217 }
4218 case 0x3e:
4219 {
4220 InvalidInstruction(2);
4221 break;
4222 }
4223 case 0x3f:
4224 {
4225 InvalidInstruction(2);
4226 break;
4227 }
4228 case 0x40:
4229 {
4230 sdwCyclesRemaining -= 12;
4231 dwAddr = cpu.z80C;
4232 psIoRead = cpu.z80IoRead; /* Beginning of our handler */
4233 while (psIoRead->lowIoAddr != 0xffff)
4234 {
4235 if ((dwAddr >= psIoRead->lowIoAddr) && (dwAddr <= psIoRead->highIoAddr))
4236 {
4237 cpu.z80pc = (UINT32) pbPC - (UINT32) cpu.z80Base;
4238 cpu.z80B = psIoRead->IOCall(dwAddr, psIoRead);
4239 psIoRead = NULL;
4240 break;
4241 }
4242 ++psIoRead;
4243 }
4244
4245 if (psIoRead)
4246 {
4247 cpu.z80B = 0xff; /* Unclaimed I/O read */
4248 }
4249
4250 cpu.z80F &= ~(Z80_FLAG_SIGN | Z80_FLAG_ZERO | Z80_FLAG_HALF_CARRY | Z80_FLAG_OVERFLOW_PARITY | Z80_FLAG_NEGATIVE);
4251 cpu.z80F |= bPostORFlags[cpu.z80B];
4252 break;
4253 }
4254 case 0x41:
4255 {
4256 sdwCyclesRemaining -= 12;
4257 dwAddr = cpu.z80C;
4258 psIoWrite = cpu.z80IoWrite; /* Beginning of our handler */
4259 while (psIoWrite->lowIoAddr != 0xffff)
4260 {
4261 if ((dwAddr >= psIoWrite->lowIoAddr) && (dwAddr <= psIoWrite->highIoAddr))
4262 {
4263 cpu.z80pc = (UINT32) pbPC - (UINT32) cpu.z80Base;
4264 psIoWrite->IOCall(dwAddr, cpu.z80B, psIoWrite);
4265 psIoWrite = NULL;
4266 break;
4267 }
4268 ++psIoWrite;
4269 }
4270
4271 break;
4272 }
4273 case 0x42:
4274 {
4275 sdwCyclesRemaining -= 15;
4276 dwTemp = cpu.z80HL - cpu.z80BC - (cpu.z80F & Z80_FLAG_CARRY);
4277 cpu.z80F &= ~(Z80_FLAG_CARRY | Z80_FLAG_NEGATIVE | Z80_FLAG_OVERFLOW_PARITY | Z80_FLAG_HALF_CARRY | Z80_FLAG_ZERO | Z80_FLAG_SIGN);
4278 cpu.z80F |= ((dwTemp >> 8) & Z80_FLAG_SIGN);
4279 if (0 == (dwTemp & 0xffff))
4280 {
4281 cpu.z80F |= Z80_FLAG_ZERO;
4282 }
4283 cpu.z80F |= (((cpu.z80HL ^ dwTemp ^ cpu.z80BC) >> 8) & Z80_FLAG_HALF_CARRY);
4284 cpu.z80F |= ((((cpu.z80BC ^ cpu.z80HL) & (cpu.z80BC ^ dwTemp)) >> 13) & Z80_FLAG_OVERFLOW_PARITY);
4285 cpu.z80F |= ((dwTemp >> 16) & Z80_FLAG_CARRY);
4286 cpu.z80HL = dwTemp & 0xffff;
4287 break;
4288 }
4289 case 0x43:
4290 {
4291 sdwCyclesRemaining -= 20;
4292 dwTemp = *pbPC++;
4293 dwTemp |= ((UINT32) *pbPC++ << 8);
4294 psMemWrite = cpu.z80MemWrite; /* Beginning of our handler */
4295 while (psMemWrite->lowAddr != 0xffffffff)
4296 {
4297 if ((dwTemp >= psMemWrite->lowAddr) && (dwTemp <= psMemWrite->highAddr))
4298 {
4299 cpu.z80pc = (UINT32) pbPC - (UINT32) cpu.z80Base;
4300 if (psMemWrite->memoryCall)
4301 {
4302 psMemWrite->memoryCall(dwTemp, (cpu.z80BC & 0xff), psMemWrite);
4303 psMemWrite->memoryCall(dwTemp + 1, (cpu.z80BC >> 8), psMemWrite);
4304 }
4305 else
4306 {
4307 *((UINT8 *) psMemWrite->pUserArea + (dwTemp - psMemWrite->lowAddr)) = cpu.z80BC;
4308 *((UINT8 *) psMemWrite->pUserArea + (dwTemp - psMemWrite->lowAddr) + 1) = cpu.z80BC >> 8;
4309 }
4310 psMemWrite = NULL;
4311 break;
4312 }
4313 ++psMemWrite;
4314 }
4315
4316 if (psMemWrite)
4317 {
4318 cpu.z80Base[dwTemp] = (UINT8) cpu.z80BC;
4319 cpu.z80Base[dwTemp + 1] = (UINT8) ((UINT32) cpu.z80BC >> 8);
4320 }
4321
4322 break;
4323 }
4324 case 0x44:
4325 {
4326 sdwCyclesRemaining -= 8;
4327 cpu.z80F = (cpu.z80F & ~(Z80_FLAG_CARRY | Z80_FLAG_NEGATIVE | Z80_FLAG_OVERFLOW_PARITY |
4328 Z80_FLAG_HALF_CARRY | Z80_FLAG_ZERO | Z80_FLAG_SIGN)) |
4329 pbSubSbcTable[((UINT32) 0 << 8) | cpu.z80A];
4330 cpu.z80A = 0 - cpu.z80A;
4331 break;
4332 }
4333 case 0x45:
4334 {
4335 sdwCyclesRemaining -= 14;
4336 pbSP = cpu.z80Base + cpu.z80sp; /* Normalize our stack PTR */
4337 dwAddr = *pbSP++; /* Pop LSB */
4338 dwAddr |= ((UINT32) *pbSP << 8); /* Pop MSB */
4339 cpu.z80sp += 2; /* Pop the word off */
4340 pbPC = (cpu.z80Base + dwAddr); /* Point PC to our return address */
4341 cpu.z80iff &= ~(IFF1); /* Keep IFF2 around */
4342 cpu.z80iff |= ((cpu.z80iff >> 1) & IFF1); /* IFF2->IFF1 */
4343 break;
4344 }
4345 case 0x46:
4346 {
4347 sdwCyclesRemaining -= 8;
4348 cpu.z80interruptMode = 0;
4349 break;
4350 }
4351 case 0x47:
4352 {
4353 sdwCyclesRemaining -= 9;
4354 cpu.z80i = cpu.z80A;
4355 break;
4356 }
4357 case 0x48:
4358 {
4359 sdwCyclesRemaining -= 12;
4360 dwAddr = cpu.z80C;
4361 psIoRead = cpu.z80IoRead; /* Beginning of our handler */
4362 while (psIoRead->lowIoAddr != 0xffff)
4363 {
4364 if ((dwAddr >= psIoRead->lowIoAddr) && (dwAddr <= psIoRead->highIoAddr))
4365 {
4366 cpu.z80pc = (UINT32) pbPC - (UINT32) cpu.z80Base;
4367 cpu.z80C = psIoRead->IOCall(dwAddr, psIoRead);
4368 psIoRead = NULL;
4369 break;
4370 }
4371 ++psIoRead;
4372 }
4373
4374 if (psIoRead)
4375 {
4376 cpu.z80C = 0xff; /* Unclaimed I/O read */
4377 }
4378
4379 cpu.z80F &= ~(Z80_FLAG_SIGN | Z80_FLAG_ZERO | Z80_FLAG_HALF_CARRY | Z80_FLAG_OVERFLOW_PARITY | Z80_FLAG_NEGATIVE);
4380 cpu.z80F |= bPostORFlags[cpu.z80C];
4381 break;
4382 }
4383 case 0x49:
4384 {
4385 sdwCyclesRemaining -= 12;
4386 dwAddr = cpu.z80C;
4387 psIoWrite = cpu.z80IoWrite; /* Beginning of our handler */
4388 while (psIoWrite->lowIoAddr != 0xffff)
4389 {
4390 if ((dwAddr >= psIoWrite->lowIoAddr) && (dwAddr <= psIoWrite->highIoAddr))
4391 {
4392 cpu.z80pc = (UINT32) pbPC - (UINT32) cpu.z80Base;
4393 psIoWrite->IOCall(dwAddr, cpu.z80C, psIoWrite);
4394 psIoWrite = NULL;
4395 break;
4396 }
4397 ++psIoWrite;
4398 }
4399
4400 break;
4401 }
4402 case 0x4a:
4403 {
4404 sdwCyclesRemaining -= 15;
4405 dwTemp = cpu.z80HL + cpu.z80BC + (cpu.z80F & Z80_FLAG_CARRY);
4406 cpu.z80F &= ~(Z80_FLAG_CARRY | Z80_FLAG_NEGATIVE | Z80_FLAG_OVERFLOW_PARITY | Z80_FLAG_HALF_CARRY | Z80_FLAG_ZERO | Z80_FLAG_SIGN);
4407 cpu.z80F |= ((dwTemp >> 8) & Z80_FLAG_SIGN);
4408 if (0 == (dwTemp & 0xffff))
4409 {
4410 cpu.z80F |= Z80_FLAG_ZERO;
4411 }
4412 cpu.z80F |= (((cpu.z80HL ^ dwTemp ^ cpu.z80BC) >> 8) & Z80_FLAG_HALF_CARRY);
4413 cpu.z80F |= ((((cpu.z80BC ^ cpu.z80HL ^ 0x8000) & (cpu.z80BC ^ dwTemp)) >> 13) & Z80_FLAG_OVERFLOW_PARITY);
4414 cpu.z80F |= ((dwTemp >> 16) & Z80_FLAG_CARRY);
4415 cpu.z80HL = dwTemp & 0xffff;
4416 break;
4417 }
4418 case 0x4b:
4419 {
4420 sdwCyclesRemaining -= 20;
4421 dwTemp = *pbPC++;
4422 dwTemp |= ((UINT32) *pbPC++ << 8);
4423 psMemRead = cpu.z80MemRead; /* Beginning of our handler */
4424 while (psMemRead->lowAddr != 0xffffffff)
4425 {
4426 if ((dwTemp >= psMemRead->lowAddr) && (dwTemp <= psMemRead->highAddr))
4427 {
4428 cpu.z80pc = (UINT32) pbPC - (UINT32) cpu.z80Base;
4429 if (psMemRead->memoryCall)
4430 {
4431 cpu.z80BC = psMemRead->memoryCall(dwTemp, psMemRead);
4432 cpu.z80BC |= (UINT32) ((UINT32) psMemRead->memoryCall(dwTemp + 1, psMemRead) << 8);
4433 }
4434 else
4435 {
4436 cpu.z80BC = *((UINT8 *) psMemRead->pUserArea + (dwTemp - psMemRead->lowAddr));
4437 cpu.z80BC |= (UINT32) ((UINT32) *((UINT8 *) psMemRead->pUserArea + (dwTemp - psMemRead->lowAddr + 1)) << 8);
4438 }
4439 psMemRead = NULL;
4440 break;
4441 }
4442 ++psMemRead;
4443 }
4444
4445 if (psMemRead)
4446 {
4447 cpu.z80BC = cpu.z80Base[dwTemp];
4448 cpu.z80BC |= (UINT32) ((UINT32) cpu.z80Base[dwTemp + 1] << 8);
4449 }
4450
4451 break;
4452 }
4453 case 0x4c:
4454 {
4455 sdwCyclesRemaining -= 8;
4456 InvalidInstruction(2);
4457 break;
4458 }
4459 case 0x4d:
4460 {
4461 sdwCyclesRemaining -= 14;
4462 pbSP = cpu.z80Base + cpu.z80sp; /* Normalize our stack PTR */
4463 dwAddr = *pbSP++; /* Pop LSB */
4464 dwAddr |= ((UINT32) *pbSP << 8); /* Pop MSB */
4465 cpu.z80sp += 2; /* Pop the word off */
4466 pbPC = (cpu.z80Base + dwAddr); /* Point PC to our return address */
4467 break;
4468 }
4469 case 0x4e:
4470 {
4471 sdwCyclesRemaining -= 8;
4472 InvalidInstruction(2);
4473 break;
4474 }
4475 case 0x4f:
4476 {
4477 sdwCyclesRemaining -= 9;
4478 cpu.z80r = cpu.z80A;
4479 break;
4480 }
4481 case 0x50:
4482 {
4483 sdwCyclesRemaining -= 12;
4484 dwAddr = cpu.z80C;
4485 psIoRead = cpu.z80IoRead; /* Beginning of our handler */
4486 while (psIoRead->lowIoAddr != 0xffff)
4487 {
4488 if ((dwAddr >= psIoRead->lowIoAddr) && (dwAddr <= psIoRead->highIoAddr))
4489 {
4490 cpu.z80pc = (UINT32) pbPC - (UINT32) cpu.z80Base;
4491 cpu.z80D = psIoRead->IOCall(dwAddr, psIoRead);
4492 psIoRead = NULL;
4493 break;
4494 }
4495 ++psIoRead;
4496 }
4497
4498 if (psIoRead)
4499 {
4500 cpu.z80D = 0xff; /* Unclaimed I/O read */
4501 }
4502
4503 cpu.z80F &= ~(Z80_FLAG_SIGN | Z80_FLAG_ZERO | Z80_FLAG_HALF_CARRY | Z80_FLAG_OVERFLOW_PARITY | Z80_FLAG_NEGATIVE);
4504 cpu.z80F |= bPostORFlags[cpu.z80D];
4505 break;
4506 }
4507 case 0x51:
4508 {
4509 sdwCyclesRemaining -= 12;
4510 dwAddr = cpu.z80C;
4511 psIoWrite = cpu.z80IoWrite; /* Beginning of our handler */
4512 while (psIoWrite->lowIoAddr != 0xffff)
4513 {
4514 if ((dwAddr >= psIoWrite->lowIoAddr) && (dwAddr <= psIoWrite->highIoAddr))
4515 {
4516 cpu.z80pc = (UINT32) pbPC - (UINT32) cpu.z80Base;
4517 psIoWrite->IOCall(dwAddr, cpu.z80D, psIoWrite);
4518 psIoWrite = NULL;
4519 break;
4520 }
4521 ++psIoWrite;
4522 }
4523
4524 break;
4525 }
4526 case 0x52:
4527 {
4528 sdwCyclesRemaining -= 15;
4529 dwTemp = cpu.z80HL - cpu.z80DE - (cpu.z80F & Z80_FLAG_CARRY);
4530 cpu.z80F &= ~(Z80_FLAG_CARRY | Z80_FLAG_NEGATIVE | Z80_FLAG_OVERFLOW_PARITY | Z80_FLAG_HALF_CARRY | Z80_FLAG_ZERO | Z80_FLAG_SIGN);
4531 cpu.z80F |= ((dwTemp >> 8) & Z80_FLAG_SIGN);
4532 if (0 == (dwTemp & 0xffff))
4533 {
4534 cpu.z80F |= Z80_FLAG_ZERO;
4535 }
4536 cpu.z80F |= (((cpu.z80HL ^ dwTemp ^ cpu.z80DE) >> 8) & Z80_FLAG_HALF_CARRY);
4537 cpu.z80F |= ((((cpu.z80DE ^ cpu.z80HL) & (cpu.z80DE ^ dwTemp)) >> 13) & Z80_FLAG_OVERFLOW_PARITY);
4538 cpu.z80F |= ((dwTemp >> 16) & Z80_FLAG_CARRY);
4539 cpu.z80HL = dwTemp & 0xffff;
4540 break;
4541 }
4542 case 0x53:
4543 {
4544 sdwCyclesRemaining -= 20;
4545 dwTemp = *pbPC++;
4546 dwTemp |= ((UINT32) *pbPC++ << 8);
4547 psMemWrite = cpu.z80MemWrite; /* Beginning of our handler */
4548 while (psMemWrite->lowAddr != 0xffffffff)
4549 {
4550 if ((dwTemp >= psMemWrite->lowAddr) && (dwTemp <= psMemWrite->highAddr))
4551 {
4552 cpu.z80pc = (UINT32) pbPC - (UINT32) cpu.z80Base;
4553 if (psMemWrite->memoryCall)
4554 {
4555 psMemWrite->memoryCall(dwTemp, (cpu.z80DE & 0xff), psMemWrite);
4556 psMemWrite->memoryCall(dwTemp + 1, (cpu.z80DE >> 8), psMemWrite);
4557 }
4558 else
4559 {
4560 *((UINT8 *) psMemWrite->pUserArea + (dwTemp - psMemWrite->lowAddr)) = cpu.z80DE;
4561 *((UINT8 *) psMemWrite->pUserArea + (dwTemp - psMemWrite->lowAddr) + 1) = cpu.z80DE >> 8;
4562 }
4563 psMemWrite = NULL;
4564 break;
4565 }
4566 ++psMemWrite;
4567 }
4568
4569 if (psMemWrite)
4570 {
4571 cpu.z80Base[dwTemp] = (UINT8) cpu.z80DE;
4572 cpu.z80Base[dwTemp + 1] = (UINT8) ((UINT32) cpu.z80DE >> 8);
4573 }
4574
4575 break;
4576 }
4577 case 0x54:
4578 {
4579 sdwCyclesRemaining -= 8;
4580 InvalidInstruction(2);
4581 break;
4582 }
4583 case 0x55:
4584 {
4585 sdwCyclesRemaining -= 8;
4586 InvalidInstruction(2);
4587 break;
4588 }
4589 case 0x56:
4590 {
4591 sdwCyclesRemaining -= 8;
4592 cpu.z80interruptMode = 1;
4593 cpu.z80intAddr = 0x38;
4594 break;
4595 }
4596 case 0x57:
4597 {
4598 sdwCyclesRemaining -= 9;
4599 cpu.z80F &= ~(Z80_FLAG_HALF_CARRY | Z80_FLAG_OVERFLOW_PARITY | Z80_FLAG_NEGATIVE | Z80_FLAG_ZERO | Z80_FLAG_SIGN);
4600 cpu.z80F |= ((cpu.z80iff & IFF2) << 1);
4601 cpu.z80A = cpu.z80i;
4602 cpu.z80F |= bPostORFlags[cpu.z80A];
4603 break;
4604 }
4605 case 0x58:
4606 {
4607 sdwCyclesRemaining -= 12;
4608 dwAddr = cpu.z80C;
4609 psIoRead = cpu.z80IoRead; /* Beginning of our handler */
4610 while (psIoRead->lowIoAddr != 0xffff)
4611 {
4612 if ((dwAddr >= psIoRead->lowIoAddr) && (dwAddr <= psIoRead->highIoAddr))
4613 {
4614 cpu.z80pc = (UINT32) pbPC - (UINT32) cpu.z80Base;
4615 cpu.z80E = psIoRead->IOCall(dwAddr, psIoRead);
4616 psIoRead = NULL;
4617 break;
4618 }
4619 ++psIoRead;
4620 }
4621
4622 if (psIoRead)
4623 {
4624 cpu.z80E = 0xff; /* Unclaimed I/O read */
4625 }
4626
4627 cpu.z80F &= ~(Z80_FLAG_SIGN | Z80_FLAG_ZERO | Z80_FLAG_HALF_CARRY | Z80_FLAG_OVERFLOW_PARITY | Z80_FLAG_NEGATIVE);
4628 cpu.z80F |= bPostORFlags[cpu.z80E];
4629 break;
4630 }
4631 case 0x59:
4632 {
4633 sdwCyclesRemaining -= 12;
4634 dwAddr = cpu.z80C;
4635 psIoWrite = cpu.z80IoWrite; /* Beginning of our handler */
4636 while (psIoWrite->lowIoAddr != 0xffff)
4637 {
4638 if ((dwAddr >= psIoWrite->lowIoAddr) && (dwAddr <= psIoWrite->highIoAddr))
4639 {
4640 cpu.z80pc = (UINT32) pbPC - (UINT32) cpu.z80Base;
4641 psIoWrite->IOCall(dwAddr, cpu.z80E, psIoWrite);
4642 psIoWrite = NULL;
4643 break;
4644 }
4645 ++psIoWrite;
4646 }
4647
4648 break;
4649 }
4650 case 0x5a:
4651 {
4652 sdwCyclesRemaining -= 15;
4653 dwTemp = cpu.z80HL + cpu.z80DE + (cpu.z80F & Z80_FLAG_CARRY);
4654 cpu.z80F &= ~(Z80_FLAG_CARRY | Z80_FLAG_NEGATIVE | Z80_FLAG_OVERFLOW_PARITY | Z80_FLAG_HALF_CARRY | Z80_FLAG_ZERO | Z80_FLAG_SIGN);
4655 cpu.z80F |= ((dwTemp >> 8) & Z80_FLAG_SIGN);
4656 if (0 == (dwTemp & 0xffff))
4657 {
4658 cpu.z80F |= Z80_FLAG_ZERO;
4659 }
4660 cpu.z80F |= (((cpu.z80HL ^ dwTemp ^ cpu.z80DE) >> 8) & Z80_FLAG_HALF_CARRY);
4661 cpu.z80F |= ((((cpu.z80DE ^ cpu.z80HL ^ 0x8000) & (cpu.z80DE ^ dwTemp)) >> 13) & Z80_FLAG_OVERFLOW_PARITY);
4662 cpu.z80F |= ((dwTemp >> 16) & Z80_FLAG_CARRY);
4663 cpu.z80HL = dwTemp & 0xffff;
4664 break;
4665 }
4666 case 0x5b:
4667 {
4668 sdwCyclesRemaining -= 20;
4669 dwTemp = *pbPC++;
4670 dwTemp |= ((UINT32) *pbPC++ << 8);
4671 psMemRead = cpu.z80MemRead; /* Beginning of our handler */
4672 while (psMemRead->lowAddr != 0xffffffff)
4673 {
4674 if ((dwTemp >= psMemRead->lowAddr) && (dwTemp <= psMemRead->highAddr))
4675 {
4676 cpu.z80pc = (UINT32) pbPC - (UINT32) cpu.z80Base;
4677 if (psMemRead->memoryCall)
4678 {
4679 cpu.z80DE = psMemRead->memoryCall(dwTemp, psMemRead);
4680 cpu.z80DE |= (UINT32) ((UINT32) psMemRead->memoryCall(dwTemp + 1, psMemRead) << 8);
4681 }
4682 else
4683 {
4684 cpu.z80DE = *((UINT8 *) psMemRead->pUserArea + (dwTemp - psMemRead->lowAddr));
4685 cpu.z80DE |= (UINT32) ((UINT32) *((UINT8 *) psMemRead->pUserArea + (dwTemp - psMemRead->lowAddr + 1)) << 8);
4686 }
4687 psMemRead = NULL;
4688 break;
4689 }
4690 ++psMemRead;
4691 }
4692
4693 if (psMemRead)
4694 {
4695 cpu.z80DE = cpu.z80Base[dwTemp];
4696 cpu.z80DE |= (UINT32) ((UINT32) cpu.z80Base[dwTemp + 1] << 8);
4697 }
4698
4699 break;
4700 }
4701 case 0x5c:
4702 {
4703 sdwCyclesRemaining -= 8;
4704 InvalidInstruction(2);
4705 break;
4706 }
4707 case 0x5d:
4708 {
4709 sdwCyclesRemaining -= 8;
4710 InvalidInstruction(2);
4711 break;
4712 }
4713 case 0x5e:
4714 {
4715 sdwCyclesRemaining -= 8;
4716 cpu.z80interruptMode = 2;
4717 break;
4718 }
4719 case 0x5f:
4720 {
4721 sdwCyclesRemaining -= 9;
4722 cpu.z80F &= ~(Z80_FLAG_HALF_CARRY | Z80_FLAG_SIGN | Z80_FLAG_ZERO | Z80_FLAG_OVERFLOW_PARITY | Z80_FLAG_NEGATIVE);
4723 cpu.z80F |= bPostORFlags[cpu.z80r];
4724 cpu.z80F = (cpu.z80F & ~(Z80_FLAG_OVERFLOW_PARITY)) | ((cpu.z80iff & IFF2) << 1);
4725 cpu.z80A = cpu.z80r;
4726 bTemp = (cpu.z80r + (cpu.z80B + sdwCyclesRemaining + 1 + cpu.z80H)) ^ cpu.z80A;
4727 cpu.z80r = (cpu.z80r & 0x80) | (bTemp & 0x7f);
4728 break;
4729 }
4730 case 0x60:
4731 {
4732 sdwCyclesRemaining -= 12;
4733 dwAddr = cpu.z80C;
4734 psIoRead = cpu.z80IoRead; /* Beginning of our handler */
4735 while (psIoRead->lowIoAddr != 0xffff)
4736 {
4737 if ((dwAddr >= psIoRead->lowIoAddr) && (dwAddr <= psIoRead->highIoAddr))
4738 {
4739 cpu.z80pc = (UINT32) pbPC - (UINT32) cpu.z80Base;
4740 cpu.z80H = psIoRead->IOCall(dwAddr, psIoRead);
4741 psIoRead = NULL;
4742 break;
4743 }
4744 ++psIoRead;
4745 }
4746
4747 if (psIoRead)
4748 {
4749 cpu.z80H = 0xff; /* Unclaimed I/O read */
4750 }
4751
4752 cpu.z80F &= ~(Z80_FLAG_SIGN | Z80_FLAG_ZERO | Z80_FLAG_HALF_CARRY | Z80_FLAG_OVERFLOW_PARITY | Z80_FLAG_NEGATIVE);
4753 cpu.z80F |= bPostORFlags[cpu.z80H];
4754 break;
4755 }
4756 case 0x61:
4757 {
4758 sdwCyclesRemaining -= 12;
4759 dwAddr = cpu.z80C;
4760 psIoWrite = cpu.z80IoWrite; /* Beginning of our handler */
4761 while (psIoWrite->lowIoAddr != 0xffff)
4762 {
4763 if ((dwAddr >= psIoWrite->lowIoAddr) && (dwAddr <= psIoWrite->highIoAddr))
4764 {
4765 cpu.z80pc = (UINT32) pbPC - (UINT32) cpu.z80Base;
4766 psIoWrite->IOCall(dwAddr, cpu.z80H, psIoWrite);
4767 psIoWrite = NULL;
4768 break;
4769 }
4770 ++psIoWrite;
4771 }
4772
4773 break;
4774 }
4775 case 0x62:
4776 {
4777 sdwCyclesRemaining -= 15;
4778 dwTemp = cpu.z80HL - cpu.z80HL - (cpu.z80F & Z80_FLAG_CARRY);
4779 cpu.z80F &= ~(Z80_FLAG_CARRY | Z80_FLAG_NEGATIVE | Z80_FLAG_OVERFLOW_PARITY | Z80_FLAG_HALF_CARRY | Z80_FLAG_ZERO | Z80_FLAG_SIGN);
4780 cpu.z80F |= ((dwTemp >> 8) & Z80_FLAG_SIGN);
4781 if (0 == (dwTemp & 0xffff))
4782 {
4783 cpu.z80F |= Z80_FLAG_ZERO;
4784 }
4785 cpu.z80F |= (((cpu.z80HL ^ dwTemp ^ cpu.z80HL) >> 8) & Z80_FLAG_HALF_CARRY);
4786 cpu.z80F |= ((((cpu.z80HL ^ cpu.z80HL) & (cpu.z80HL ^ dwTemp)) >> 13) & Z80_FLAG_OVERFLOW_PARITY);
4787 cpu.z80F |= ((dwTemp >> 16) & Z80_FLAG_CARRY);
4788 cpu.z80HL = dwTemp & 0xffff;
4789 break;
4790 }
4791 case 0x63:
4792 {
4793 sdwCyclesRemaining -= 20;
4794 dwTemp = *pbPC++;
4795 dwTemp |= ((UINT32) *pbPC++ << 8);
4796 psMemWrite = cpu.z80MemWrite; /* Beginning of our handler */
4797 while (psMemWrite->lowAddr != 0xffffffff)
4798 {
4799 if ((dwTemp >= psMemWrite->lowAddr) && (dwTemp <= psMemWrite->highAddr))
4800 {
4801 cpu.z80pc = (UINT32) pbPC - (UINT32) cpu.z80Base;
4802 if (psMemWrite->memoryCall)
4803 {
4804 psMemWrite->memoryCall(dwTemp, (cpu.z80HL & 0xff), psMemWrite);
4805 psMemWrite->memoryCall(dwTemp + 1, (cpu.z80HL >> 8), psMemWrite);
4806 }
4807 else
4808 {
4809 *((UINT8 *) psMemWrite->pUserArea + (dwTemp - psMemWrite->lowAddr)) = cpu.z80HL;
4810 *((UINT8 *) psMemWrite->pUserArea + (dwTemp - psMemWrite->lowAddr) + 1) = cpu.z80HL >> 8;
4811 }
4812 psMemWrite = NULL;
4813 break;
4814 }
4815 ++psMemWrite;
4816 }
4817
4818 if (psMemWrite)
4819 {
4820 cpu.z80Base[dwTemp] = (UINT8) cpu.z80HL;
4821 cpu.z80Base[dwTemp + 1] = (UINT8) ((UINT32) cpu.z80HL >> 8);
4822 }
4823
4824 break;
4825 }
4826 case 0x64:
4827 {
4828 sdwCyclesRemaining -= 8;
4829 InvalidInstruction(2);
4830 break;
4831 }
4832 case 0x65:
4833 {
4834 sdwCyclesRemaining -= 8;
4835 InvalidInstruction(2);
4836 break;
4837 }
4838 case 0x66:
4839 {
4840 sdwCyclesRemaining -= 8;
4841 InvalidInstruction(2);
4842 break;
4843 }
4844 case 0x67:
4845 {
4846 sdwCyclesRemaining -= 18;
4847 psMemRead = cpu.z80MemRead; /* Beginning of our handler */
4848 while (psMemRead->lowAddr != 0xffffffff)
4849 {
4850 if ((cpu.z80HL >= psMemRead->lowAddr) && (cpu.z80HL <= psMemRead->highAddr))
4851 {
4852 cpu.z80pc = (UINT32) pbPC - (UINT32) cpu.z80Base;
4853 if (psMemRead->memoryCall)
4854 {
4855 bTemp = psMemRead->memoryCall(cpu.z80HL, psMemRead);
4856 }
4857 else
4858 {
4859 bTemp = *((UINT8 *) psMemRead->pUserArea + (cpu.z80HL - psMemRead->lowAddr));
4860 }
4861 psMemRead = NULL;
4862 break;
4863 }
4864 ++psMemRead;
4865 }
4866
4867 if (psMemRead)
4868 {
4869 bTemp = cpu.z80Base[cpu.z80HL];
4870 }
4871
4872 bTemp2 = (cpu.z80A & 0x0f) << 4;
4873 cpu.z80A = (cpu.z80A & 0xf0) | (bTemp & 0x0f);
4874 bTemp = (bTemp >> 4) | bTemp2;
4875 psMemWrite = cpu.z80MemWrite; /* Beginning of our handler */
4876 while (psMemWrite->lowAddr != 0xffffffff)
4877 {
4878 if ((cpu.z80HL >= psMemWrite->lowAddr) && (cpu.z80HL <= psMemWrite->highAddr))
4879 {
4880 cpu.z80pc = (UINT32) pbPC - (UINT32) cpu.z80Base;
4881 if (psMemWrite->memoryCall)
4882 {
4883 psMemWrite->memoryCall(cpu.z80HL, bTemp, psMemWrite);
4884 }
4885 else
4886 {
4887 *((UINT8 *) psMemWrite->pUserArea + (cpu.z80HL - psMemWrite->lowAddr)) = bTemp;
4888 }
4889 psMemWrite = NULL;
4890 break;
4891 }
4892 ++psMemWrite;
4893 }
4894
4895 if (psMemWrite)
4896 {
4897 cpu.z80Base[cpu.z80HL] = (UINT8) bTemp;
4898 }
4899
4900 cpu.z80F &= ~(Z80_FLAG_SIGN | Z80_FLAG_ZERO | Z80_FLAG_HALF_CARRY | Z80_FLAG_OVERFLOW_PARITY | Z80_FLAG_NEGATIVE);
4901 cpu.z80F |= bPostORFlags[cpu.z80A];
4902 break;
4903 }
4904 case 0x68:
4905 {
4906 sdwCyclesRemaining -= 12;
4907 dwAddr = cpu.z80C;
4908 psIoRead = cpu.z80IoRead; /* Beginning of our handler */
4909 while (psIoRead->lowIoAddr != 0xffff)
4910 {
4911 if ((dwAddr >= psIoRead->lowIoAddr) && (dwAddr <= psIoRead->highIoAddr))
4912 {
4913 cpu.z80pc = (UINT32) pbPC - (UINT32) cpu.z80Base;
4914 cpu.z80L = psIoRead->IOCall(dwAddr, psIoRead);
4915 psIoRead = NULL;
4916 break;
4917 }
4918 ++psIoRead;
4919 }
4920
4921 if (psIoRead)
4922 {
4923 cpu.z80L = 0xff; /* Unclaimed I/O read */
4924 }
4925
4926 cpu.z80F &= ~(Z80_FLAG_SIGN | Z80_FLAG_ZERO | Z80_FLAG_HALF_CARRY | Z80_FLAG_OVERFLOW_PARITY | Z80_FLAG_NEGATIVE);
4927 cpu.z80F |= bPostORFlags[cpu.z80L];
4928 break;
4929 }
4930 case 0x69:
4931 {
4932 sdwCyclesRemaining -= 12;
4933 dwAddr = cpu.z80C;
4934 psIoWrite = cpu.z80IoWrite; /* Beginning of our handler */
4935 while (psIoWrite->lowIoAddr != 0xffff)
4936 {
4937 if ((dwAddr >= psIoWrite->lowIoAddr) && (dwAddr <= psIoWrite->highIoAddr))
4938 {
4939 cpu.z80pc = (UINT32) pbPC - (UINT32) cpu.z80Base;
4940 psIoWrite->IOCall(dwAddr, cpu.z80L, psIoWrite);
4941 psIoWrite = NULL;
4942 break;
4943 }
4944 ++psIoWrite;
4945 }
4946
4947 break;
4948 }
4949 case 0x6a:
4950 {
4951 sdwCyclesRemaining -= 15;
4952 dwTemp = cpu.z80HL + cpu.z80HL + (cpu.z80F & Z80_FLAG_CARRY);
4953 cpu.z80F &= ~(Z80_FLAG_CARRY | Z80_FLAG_NEGATIVE | Z80_FLAG_OVERFLOW_PARITY | Z80_FLAG_HALF_CARRY | Z80_FLAG_ZERO | Z80_FLAG_SIGN);
4954 cpu.z80F |= ((dwTemp >> 8) & Z80_FLAG_SIGN);
4955 if (0 == (dwTemp & 0xffff))
4956 {
4957 cpu.z80F |= Z80_FLAG_ZERO;
4958 }
4959 cpu.z80F |= (((cpu.z80HL ^ dwTemp ^ cpu.z80HL) >> 8) & Z80_FLAG_HALF_CARRY);
4960 cpu.z80F |= ((((cpu.z80HL ^ cpu.z80HL ^ 0x8000) & (cpu.z80HL ^ dwTemp)) >> 13) & Z80_FLAG_OVERFLOW_PARITY);
4961 cpu.z80F |= ((dwTemp >> 16) & Z80_FLAG_CARRY);
4962 cpu.z80HL = dwTemp & 0xffff;
4963 break;
4964 }
4965 case 0x6b:
4966 {
4967 sdwCyclesRemaining -= 20;
4968 InvalidInstruction(2);
4969 break;
4970 }
4971 case 0x6c:
4972 {
4973 sdwCyclesRemaining -= 8;
4974 InvalidInstruction(2);
4975 break;
4976 }
4977 case 0x6d:
4978 {
4979 sdwCyclesRemaining -= 8;
4980 InvalidInstruction(2);
4981 break;
4982 }
4983 case 0x6e:
4984 {
4985 sdwCyclesRemaining -= 8;
4986 InvalidInstruction(2);
4987 break;
4988 }
4989 case 0x6f:
4990 {
4991 sdwCyclesRemaining -= 18;
4992 psMemRead = cpu.z80MemRead; /* Beginning of our handler */
4993 while (psMemRead->lowAddr != 0xffffffff)
4994 {
4995 if ((cpu.z80HL >= psMemRead->lowAddr) && (cpu.z80HL <= psMemRead->highAddr))
4996 {
4997 cpu.z80pc = (UINT32) pbPC - (UINT32) cpu.z80Base;
4998 if (psMemRead->memoryCall)
4999 {
5000 bTemp = psMemRead->memoryCall(cpu.z80HL, psMemRead);
5001 }
5002 else
5003 {
5004 bTemp = *((UINT8 *) psMemRead->pUserArea + (cpu.z80HL - psMemRead->lowAddr));
5005 }
5006 psMemRead = NULL;
5007 break;
5008 }
5009 ++psMemRead;
5010 }
5011
5012 if (psMemRead)
5013 {
5014 bTemp = cpu.z80Base[cpu.z80HL];
5015 }
5016
5017 bTemp2 = (cpu.z80A & 0x0f);
5018 cpu.z80A = (cpu.z80A & 0xf0) | (bTemp >> 4);
5019 bTemp = (bTemp << 4) | bTemp2;
5020 psMemWrite = cpu.z80MemWrite; /* Beginning of our handler */
5021 while (psMemWrite->lowAddr != 0xffffffff)
5022 {
5023 if ((cpu.z80HL >= psMemWrite->lowAddr) && (cpu.z80HL <= psMemWrite->highAddr))
5024 {
5025 cpu.z80pc = (UINT32) pbPC - (UINT32) cpu.z80Base;
5026 if (psMemWrite->memoryCall)
5027 {
5028 psMemWrite->memoryCall(cpu.z80HL, bTemp, psMemWrite);
5029 }
5030 else
5031 {
5032 *((UINT8 *) psMemWrite->pUserArea + (cpu.z80HL - psMemWrite->lowAddr)) = bTemp;
5033 }
5034 psMemWrite = NULL;
5035 break;
5036 }
5037 ++psMemWrite;
5038 }
5039
5040 if (psMemWrite)
5041 {
5042 cpu.z80Base[cpu.z80HL] = (UINT8) bTemp;
5043 }
5044
5045 cpu.z80F &= ~(Z80_FLAG_SIGN | Z80_FLAG_ZERO | Z80_FLAG_HALF_CARRY | Z80_FLAG_OVERFLOW_PARITY | Z80_FLAG_NEGATIVE);
5046 cpu.z80F |= bPostORFlags[cpu.z80A];
5047 break;
5048 }
5049 case 0x70:
5050 {
5051 sdwCyclesRemaining -= 12;
5052 InvalidInstruction(2);
5053 break;
5054 }
5055 case 0x71:
5056 {
5057 sdwCyclesRemaining -= 12;
5058 InvalidInstruction(2);
5059 break;
5060 }
5061 case 0x72:
5062 {
5063 sdwCyclesRemaining -= 15;
5064 dwTemp = cpu.z80HL - cpu.z80sp - (cpu.z80F & Z80_FLAG_CARRY);
5065 cpu.z80F &= ~(Z80_FLAG_CARRY | Z80_FLAG_NEGATIVE | Z80_FLAG_OVERFLOW_PARITY | Z80_FLAG_HALF_CARRY | Z80_FLAG_ZERO | Z80_FLAG_SIGN);
5066 cpu.z80F |= ((dwTemp >> 8) & Z80_FLAG_SIGN);
5067 if (0 == (dwTemp & 0xffff))
5068 {
5069 cpu.z80F |= Z80_FLAG_ZERO;
5070 }
5071 cpu.z80F |= (((cpu.z80HL ^ dwTemp ^ cpu.z80sp) >> 8) & Z80_FLAG_HALF_CARRY);
5072 cpu.z80F |= ((((cpu.z80sp ^ cpu.z80HL) & (cpu.z80sp ^ dwTemp)) >> 13) & Z80_FLAG_OVERFLOW_PARITY);
5073 cpu.z80F |= ((dwTemp >> 16) & Z80_FLAG_CARRY);
5074 cpu.z80HL = dwTemp & 0xffff;
5075 break;
5076 }
5077 case 0x73:
5078 {
5079 sdwCyclesRemaining -= 20;
5080 dwTemp = *pbPC++;
5081 dwTemp |= ((UINT32) *pbPC++ << 8);
5082 psMemWrite = cpu.z80MemWrite; /* Beginning of our handler */
5083 while (psMemWrite->lowAddr != 0xffffffff)
5084 {
5085 if ((dwTemp >= psMemWrite->lowAddr) && (dwTemp <= psMemWrite->highAddr))
5086 {
5087 cpu.z80pc = (UINT32) pbPC - (UINT32) cpu.z80Base;
5088 if (psMemWrite->memoryCall)
5089 {
5090 psMemWrite->memoryCall(dwTemp, (cpu.z80sp & 0xff), psMemWrite);
5091 psMemWrite->memoryCall(dwTemp + 1, (cpu.z80sp >> 8), psMemWrite);
5092 }
5093 else
5094 {
5095 *((UINT8 *) psMemWrite->pUserArea + (dwTemp - psMemWrite->lowAddr)) = cpu.z80sp;
5096 *((UINT8 *) psMemWrite->pUserArea + (dwTemp - psMemWrite->lowAddr) + 1) = cpu.z80sp >> 8;
5097 }
5098 psMemWrite = NULL;
5099 break;
5100 }
5101 ++psMemWrite;
5102 }
5103
5104 if (psMemWrite)
5105 {
5106 cpu.z80Base[dwTemp] = (UINT8) cpu.z80sp;
5107 cpu.z80Base[dwTemp + 1] = (UINT8) ((UINT32) cpu.z80sp >> 8);
5108 }
5109
5110 break;
5111 }
5112 case 0x74:
5113 {
5114 sdwCyclesRemaining -= 8;
5115 InvalidInstruction(2);
5116 break;
5117 }
5118 case 0x75:
5119 {
5120 sdwCyclesRemaining -= 8;
5121 InvalidInstruction(2);
5122 break;
5123 }
5124 case 0x76:
5125 {
5126 sdwCyclesRemaining -= 8;
5127 InvalidInstruction(2);
5128 break;
5129 }
5130 case 0x77:
5131 {
5132 InvalidInstruction(2);
5133 break;
5134 }
5135 case 0x78:
5136 {
5137 sdwCyclesRemaining -= 12;
5138 dwAddr = cpu.z80C;
5139 psIoRead = cpu.z80IoRead; /* Beginning of our handler */
5140 while (psIoRead->lowIoAddr != 0xffff)
5141 {
5142 if ((dwAddr >= psIoRead->lowIoAddr) && (dwAddr <= psIoRead->highIoAddr))
5143 {
5144 cpu.z80pc = (UINT32) pbPC - (UINT32) cpu.z80Base;
5145 cpu.z80A = psIoRead->IOCall(dwAddr, psIoRead);
5146 psIoRead = NULL;
5147 break;
5148 }
5149 ++psIoRead;
5150 }
5151
5152 if (psIoRead)
5153 {
5154 cpu.z80A = 0xff; /* Unclaimed I/O read */
5155 }
5156
5157 cpu.z80F &= ~(Z80_FLAG_SIGN | Z80_FLAG_ZERO | Z80_FLAG_HALF_CARRY | Z80_FLAG_OVERFLOW_PARITY | Z80_FLAG_NEGATIVE);
5158 cpu.z80F |= bPostORFlags[cpu.z80A];
5159 break;
5160 }
5161 case 0x79:
5162 {
5163 sdwCyclesRemaining -= 12;
5164 dwAddr = cpu.z80C;
5165 psIoWrite = cpu.z80IoWrite; /* Beginning of our handler */
5166 while (psIoWrite->lowIoAddr != 0xffff)
5167 {
5168 if ((dwAddr >= psIoWrite->lowIoAddr) && (dwAddr <= psIoWrite->highIoAddr))
5169 {
5170 cpu.z80pc = (UINT32) pbPC - (UINT32) cpu.z80Base;
5171 psIoWrite->IOCall(dwAddr, cpu.z80A, psIoWrite);
5172 psIoWrite = NULL;
5173 break;
5174 }
5175 ++psIoWrite;
5176 }
5177
5178 break;
5179 }
5180 case 0x7a:
5181 {
5182 sdwCyclesRemaining -= 15;
5183 dwTemp = cpu.z80HL + cpu.z80sp + (cpu.z80F & Z80_FLAG_CARRY);
5184 cpu.z80F &= ~(Z80_FLAG_CARRY | Z80_FLAG_NEGATIVE | Z80_FLAG_OVERFLOW_PARITY | Z80_FLAG_HALF_CARRY | Z80_FLAG_ZERO | Z80_FLAG_SIGN);
5185 cpu.z80F |= ((dwTemp >> 8) & Z80_FLAG_SIGN);
5186 if (0 == (dwTemp & 0xffff))
5187 {
5188 cpu.z80F |= Z80_FLAG_ZERO;
5189 }
5190 cpu.z80F |= (((cpu.z80HL ^ dwTemp ^ cpu.z80sp) >> 8) & Z80_FLAG_HALF_CARRY);
5191 cpu.z80F |= ((((cpu.z80sp ^ cpu.z80HL ^ 0x8000) & (cpu.z80sp ^ dwTemp)) >> 13) & Z80_FLAG_OVERFLOW_PARITY);
5192 cpu.z80F |= ((dwTemp >> 16) & Z80_FLAG_CARRY);
5193 cpu.z80HL = dwTemp & 0xffff;
5194 break;
5195 }
5196 case 0x7b:
5197 {
5198 sdwCyclesRemaining -= 20;
5199 dwTemp = *pbPC++;
5200 dwTemp |= ((UINT32) *pbPC++ << 8);
5201 psMemRead = cpu.z80MemRead; /* Beginning of our handler */
5202 while (psMemRead->lowAddr != 0xffffffff)
5203 {
5204 if ((dwTemp >= psMemRead->lowAddr) && (dwTemp <= psMemRead->highAddr))
5205 {
5206 cpu.z80pc = (UINT32) pbPC - (UINT32) cpu.z80Base;
5207 if (psMemRead->memoryCall)
5208 {
5209 cpu.z80sp = psMemRead->memoryCall(dwTemp, psMemRead);
5210 cpu.z80sp |= (UINT32) ((UINT32) psMemRead->memoryCall(dwTemp + 1, psMemRead) << 8);
5211 }
5212 else
5213 {
5214 cpu.z80sp = *((UINT8 *) psMemRead->pUserArea + (dwTemp - psMemRead->lowAddr));
5215 cpu.z80sp |= (UINT32) ((UINT32) *((UINT8 *) psMemRead->pUserArea + (dwTemp - psMemRead->lowAddr + 1)) << 8);
5216 }
5217 psMemRead = NULL;
5218 break;
5219 }
5220 ++psMemRead;
5221 }
5222
5223 if (psMemRead)
5224 {
5225 cpu.z80sp = cpu.z80Base[dwTemp];
5226 cpu.z80sp |= (UINT32) ((UINT32) cpu.z80Base[dwTemp + 1] << 8);
5227 }
5228
5229 break;
5230 }
5231 case 0x7c:
5232 {
5233 sdwCyclesRemaining -= 8;
5234 InvalidInstruction(2);
5235 break;
5236 }
5237 case 0x7d:
5238 {
5239 sdwCyclesRemaining -= 8;
5240 InvalidInstruction(2);
5241 break;
5242 }
5243 case 0x7e:
5244 {
5245 sdwCyclesRemaining -= 8;
5246 InvalidInstruction(2);
5247 break;
5248 }
5249 case 0x7f:
5250 {
5251 InvalidInstruction(2);
5252 break;
5253 }
5254 case 0x80:
5255 {
5256 InvalidInstruction(2);
5257 break;
5258 }
5259 case 0x81:
5260 {
5261 InvalidInstruction(2);
5262 break;
5263 }
5264 case 0x82:
5265 {
5266 InvalidInstruction(2);
5267 break;
5268 }
5269 case 0x83:
5270 {
5271 InvalidInstruction(2);
5272 break;
5273 }
5274 case 0x84:
5275 {
5276 InvalidInstruction(2);
5277 break;
5278 }
5279 case 0x85:
5280 {
5281 InvalidInstruction(2);
5282 break;
5283 }
5284 case 0x86:
5285 {
5286 InvalidInstruction(2);
5287 break;
5288 }
5289 case 0x87:
5290 {
5291 InvalidInstruction(2);
5292 break;
5293 }
5294 case 0x88:
5295 {
5296 InvalidInstruction(2);
5297 break;
5298 }
5299 case 0x89:
5300 {
5301 InvalidInstruction(2);
5302 break;
5303 }
5304 case 0x8a:
5305 {
5306 InvalidInstruction(2);
5307 break;
5308 }
5309 case 0x8b:
5310 {
5311 InvalidInstruction(2);
5312 break;
5313 }
5314 case 0x8c:
5315 {
5316 InvalidInstruction(2);
5317 break;
5318 }
5319 case 0x8d:
5320 {
5321 InvalidInstruction(2);
5322 break;
5323 }
5324 case 0x8e:
5325 {
5326 InvalidInstruction(2);
5327 break;
5328 }
5329 case 0x8f:
5330 {
5331 InvalidInstruction(2);
5332 break;
5333 }
5334 case 0x90:
5335 {
5336 InvalidInstruction(2);
5337 break;
5338 }
5339 case 0x91:
5340 {
5341 InvalidInstruction(2);
5342 break;
5343 }
5344 case 0x92:
5345 {
5346 InvalidInstruction(2);
5347 break;
5348 }
5349 case 0x93:
5350 {
5351 InvalidInstruction(2);
5352 break;
5353 }
5354 case 0x94:
5355 {
5356 InvalidInstruction(2);
5357 break;
5358 }
5359 case 0x95:
5360 {
5361 InvalidInstruction(2);
5362 break;
5363 }
5364 case 0x96:
5365 {
5366 InvalidInstruction(2);
5367 break;
5368 }
5369 case 0x97:
5370 {
5371 InvalidInstruction(2);
5372 break;
5373 }
5374 case 0x98:
5375 {
5376 InvalidInstruction(2);
5377 break;
5378 }
5379 case 0x99:
5380 {
5381 InvalidInstruction(2);
5382 break;
5383 }
5384 case 0x9a:
5385 {
5386 InvalidInstruction(2);
5387 break;
5388 }
5389 case 0x9b:
5390 {
5391 InvalidInstruction(2);
5392 break;
5393 }
5394 case 0x9c:
5395 {
5396 InvalidInstruction(2);
5397 break;
5398 }
5399 case 0x9d:
5400 {
5401 InvalidInstruction(2);
5402 break;
5403 }
5404 case 0x9e:
5405 {
5406 InvalidInstruction(2);
5407 break;
5408 }
5409 case 0x9f:
5410 {
5411 InvalidInstruction(2);
5412 break;
5413 }
5414 case 0xa0:
5415 {
5416 sdwCyclesRemaining -= 16;
5417 psMemRead = cpu.z80MemRead; /* Beginning of our handler */
5418 while (psMemRead->lowAddr != 0xffffffff)
5419 {
5420 if ((cpu.z80HL >= psMemRead->lowAddr) && (cpu.z80HL <= psMemRead->highAddr))
5421 {
5422 cpu.z80pc = (UINT32) pbPC - (UINT32) cpu.z80Base;
5423 if (psMemRead->memoryCall)
5424 {
5425 bTemp = psMemRead->memoryCall(cpu.z80HL, psMemRead);
5426 }
5427 else
5428 {
5429 bTemp = *((UINT8 *) psMemRead->pUserArea + (cpu.z80HL - psMemRead->lowAddr));
5430 }
5431 psMemRead = NULL;
5432 break;
5433 }
5434 ++psMemRead;
5435 }
5436
5437 if (psMemRead)
5438 {
5439 bTemp = cpu.z80Base[cpu.z80HL];
5440 }
5441
5442 psMemWrite = cpu.z80MemWrite; /* Beginning of our handler */
5443 while (psMemWrite->lowAddr != 0xffffffff)
5444 {
5445 if ((cpu.z80DE >= psMemWrite->lowAddr) && (cpu.z80DE <= psMemWrite->highAddr))
5446 {
5447 cpu.z80pc = (UINT32) pbPC - (UINT32) cpu.z80Base;
5448 if (psMemWrite->memoryCall)
5449 {
5450 psMemWrite->memoryCall(cpu.z80DE, bTemp, psMemWrite);
5451 }
5452 else
5453 {
5454 *((UINT8 *) psMemWrite->pUserArea + (cpu.z80DE - psMemWrite->lowAddr)) = bTemp;
5455 }
5456 psMemWrite = NULL;
5457 break;
5458 }
5459 ++psMemWrite;
5460 }
5461
5462 if (psMemWrite)
5463 {
5464 cpu.z80Base[cpu.z80DE] = (UINT8) bTemp;
5465 }
5466
5467 ++cpu.z80HL;
5468 ++cpu.z80DE;
5469 --cpu.z80BC;
5470 cpu.z80HL &= 0xffff;
5471 cpu.z80DE &= 0xffff;
5472 cpu.z80BC &= 0xffff;
5473 cpu.z80F &= ~(Z80_FLAG_HALF_CARRY | Z80_FLAG_NEGATIVE | Z80_FLAG_OVERFLOW_PARITY);
5474 if (cpu.z80BC)
5475 {
5476 cpu.z80F |= Z80_FLAG_OVERFLOW_PARITY;
5477 }
5478 break;
5479 }
5480 case 0xa1:
5481 {
5482 sdwCyclesRemaining -= 16;
5483 {
5484 psMemRead = cpu.z80MemRead; /* Beginning of our handler */
5485 while (psMemRead->lowAddr != 0xffffffff)
5486 {
5487 if ((cpu.z80HL >= psMemRead->lowAddr) && (cpu.z80HL <= psMemRead->highAddr))
5488 {
5489 cpu.z80pc = (UINT32) pbPC - (UINT32) cpu.z80Base;
5490 if (psMemRead->memoryCall)
5491 {
5492 bTemp = psMemRead->memoryCall(cpu.z80HL, psMemRead);
5493 }
5494 else
5495 {
5496 bTemp = *((UINT8 *) psMemRead->pUserArea + (cpu.z80HL - psMemRead->lowAddr));
5497 }
5498 psMemRead = NULL;
5499 break;
5500 }
5501 ++psMemRead;
5502 }
5503
5504 if (psMemRead)
5505 {
5506 bTemp = cpu.z80Base[cpu.z80HL];
5507 }
5508
5509 cpu.z80HL++;
5510 cpu.z80HL &= 0xffff;
5511 cpu.z80BC--;
5512 cpu.z80BC &= 0xffff;
5513 }
5514 cpu.z80F &= ~(Z80_FLAG_ZERO | Z80_FLAG_SIGN | Z80_FLAG_HALF_CARRY | Z80_FLAG_OVERFLOW_PARITY | Z80_FLAG_NEGATIVE);
5515 cpu.z80F |= (pbSubSbcTable[((UINT32) cpu.z80A << 8) | bTemp] & (Z80_FLAG_SIGN | Z80_FLAG_NEGATIVE | Z80_FLAG_ZERO));
5516 if (cpu.z80BC)
5517 {
5518 cpu.z80F |= Z80_FLAG_OVERFLOW_PARITY;
5519 }
5520 break;
5521 }
5522 case 0xa2:
5523 {
5524 sdwCyclesRemaining -= 16;
5525 {
5526 psIoRead = cpu.z80IoRead; /* Beginning of our handler */
5527 while (psIoRead->lowIoAddr != 0xffff)
5528 {
5529 if ((cpu.z80B >= psIoRead->lowIoAddr) && (cpu.z80B <= psIoRead->highIoAddr))
5530 {
5531 cpu.z80pc = (UINT32) pbPC - (UINT32) cpu.z80Base;
5532 bTemp = psIoRead->IOCall(cpu.z80B, psIoRead);
5533 psIoRead = NULL;
5534 break;
5535 }
5536 ++psIoRead;
5537 }
5538
5539 if (psIoRead)
5540 {
5541 bTemp = 0xff; /* Unclaimed I/O read */
5542 }
5543
5544 psMemWrite = cpu.z80MemWrite; /* Beginning of our handler */
5545 while (psMemWrite->lowAddr != 0xffffffff)
5546 {
5547 if ((cpu.z80HL >= psMemWrite->lowAddr) && (cpu.z80HL <= psMemWrite->highAddr))
5548 {
5549 cpu.z80pc = (UINT32) pbPC - (UINT32) cpu.z80Base;
5550 if (psMemWrite->memoryCall)
5551 {
5552 psMemWrite->memoryCall(cpu.z80HL, bTemp, psMemWrite);
5553 }
5554 else
5555 {
5556 *((UINT8 *) psMemWrite->pUserArea + (cpu.z80HL - psMemWrite->lowAddr)) = bTemp;
5557 }
5558 psMemWrite = NULL;
5559 break;
5560 }
5561 ++psMemWrite;
5562 }
5563
5564 if (psMemWrite)
5565 {
5566 cpu.z80Base[cpu.z80HL] = (UINT8) bTemp;
5567 }
5568
5569 cpu.z80HL++;
5570 cpu.z80HL &= 0xffff;
5571 sdwCyclesRemaining -= 16;
5572 cpu.z80B--;
5573 }
5574 cpu.z80F &= ~(Z80_FLAG_ZERO | Z80_FLAG_SIGN | Z80_FLAG_HALF_CARRY | Z80_FLAG_OVERFLOW_PARITY | Z80_FLAG_NEGATIVE);
5575 cpu.z80F |= (bPostORFlags[bTemp] & (Z80_FLAG_SIGN | Z80_FLAG_NEGATIVE | Z80_FLAG_HALF_CARRY | Z80_FLAG_OVERFLOW_PARITY));
5576 if (cpu.z80B)
5577 {
5578 cpu.z80F |= Z80_FLAG_OVERFLOW_PARITY;
5579 pbPC -= 2;
5580 }
5581 break;
5582 }
5583 case 0xa3:
5584 {
5585 sdwCyclesRemaining -= 16;
5586 {
5587 psMemRead = cpu.z80MemRead; /* Beginning of our handler */
5588 while (psMemRead->lowAddr != 0xffffffff)
5589 {
5590 if ((cpu.z80HL >= psMemRead->lowAddr) && (cpu.z80HL <= psMemRead->highAddr))
5591 {
5592 cpu.z80pc = (UINT32) pbPC - (UINT32) cpu.z80Base;
5593 if (psMemRead->memoryCall)
5594 {
5595 bTemp = psMemRead->memoryCall(cpu.z80HL, psMemRead);
5596 }
5597 else
5598 {
5599 bTemp = *((UINT8 *) psMemRead->pUserArea + (cpu.z80HL - psMemRead->lowAddr));
5600 }
5601 psMemRead = NULL;
5602 break;
5603 }
5604 ++psMemRead;
5605 }
5606
5607 if (psMemRead)
5608 {
5609 bTemp = cpu.z80Base[cpu.z80HL];
5610 }
5611
5612 psIoWrite = cpu.z80IoWrite; /* Beginning of our handler */
5613 while (psIoWrite->lowIoAddr != 0xffff)
5614 {
5615 if ((cpu.z80BC >= psIoWrite->lowIoAddr) && (cpu.z80BC <= psIoWrite->highIoAddr))
5616 {
5617 cpu.z80pc = (UINT32) pbPC - (UINT32) cpu.z80Base;
5618 psIoWrite->IOCall(cpu.z80BC, bTemp, psIoWrite);
5619 psIoWrite = NULL;
5620 break;
5621 }
5622 ++psIoWrite;
5623 }
5624
5625 cpu.z80HL++;
5626 cpu.z80HL &= 0xffff;
5627 sdwCyclesRemaining -= 16;
5628 cpu.z80B--;
5629 }
5630 cpu.z80F &= ~(Z80_FLAG_ZERO | Z80_FLAG_SIGN | Z80_FLAG_HALF_CARRY | Z80_FLAG_OVERFLOW_PARITY | Z80_FLAG_NEGATIVE);
5631 cpu.z80F |= (bPostORFlags[bTemp] & (Z80_FLAG_SIGN | Z80_FLAG_NEGATIVE | Z80_FLAG_HALF_CARRY | Z80_FLAG_OVERFLOW_PARITY));
5632 if (cpu.z80B)
5633 {
5634 cpu.z80F |= Z80_FLAG_OVERFLOW_PARITY;
5635 }
5636 break;
5637 }
5638 case 0xa4:
5639 {
5640 InvalidInstruction(2);
5641 break;
5642 }
5643 case 0xa5:
5644 {
5645 InvalidInstruction(2);
5646 break;
5647 }
5648 case 0xa6:
5649 {
5650 InvalidInstruction(2);
5651 break;
5652 }
5653 case 0xa7:
5654 {
5655 InvalidInstruction(2);
5656 break;
5657 }
5658 case 0xa8:
5659 {
5660 sdwCyclesRemaining -= 16;
5661 psMemRead = cpu.z80MemRead; /* Beginning of our handler */
5662 while (psMemRead->lowAddr != 0xffffffff)
5663 {
5664 if ((cpu.z80HL >= psMemRead->lowAddr) && (cpu.z80HL <= psMemRead->highAddr))
5665 {
5666 cpu.z80pc = (UINT32) pbPC - (UINT32) cpu.z80Base;
5667 if (psMemRead->memoryCall)
5668 {
5669 bTemp = psMemRead->memoryCall(cpu.z80HL, psMemRead);
5670 }
5671 else
5672 {
5673 bTemp = *((UINT8 *) psMemRead->pUserArea + (cpu.z80HL - psMemRead->lowAddr));
5674 }
5675 psMemRead = NULL;
5676 break;
5677 }
5678 ++psMemRead;
5679 }
5680
5681 if (psMemRead)
5682 {
5683 bTemp = cpu.z80Base[cpu.z80HL];
5684 }
5685
5686 psMemWrite = cpu.z80MemWrite; /* Beginning of our handler */
5687 while (psMemWrite->lowAddr != 0xffffffff)
5688 {
5689 if ((cpu.z80DE >= psMemWrite->lowAddr) && (cpu.z80DE <= psMemWrite->highAddr))
5690 {
5691 cpu.z80pc = (UINT32) pbPC - (UINT32) cpu.z80Base;
5692 if (psMemWrite->memoryCall)
5693 {
5694 psMemWrite->memoryCall(cpu.z80DE, bTemp, psMemWrite);
5695 }
5696 else
5697 {
5698 *((UINT8 *) psMemWrite->pUserArea + (cpu.z80DE - psMemWrite->lowAddr)) = bTemp;
5699 }
5700 psMemWrite = NULL;
5701 break;
5702 }
5703 ++psMemWrite;
5704 }
5705
5706 if (psMemWrite)
5707 {
5708 cpu.z80Base[cpu.z80DE] = (UINT8) bTemp;
5709 }
5710
5711 --cpu.z80HL;
5712 --cpu.z80DE;
5713 --cpu.z80BC;
5714 cpu.z80HL &= 0xffff;
5715 cpu.z80DE &= 0xffff;
5716 cpu.z80BC &= 0xffff;
5717 cpu.z80F &= ~(Z80_FLAG_HALF_CARRY | Z80_FLAG_NEGATIVE | Z80_FLAG_OVERFLOW_PARITY);
5718 if (cpu.z80BC)
5719 {
5720 cpu.z80F |= Z80_FLAG_OVERFLOW_PARITY;
5721 }
5722 break;
5723 }
5724 case 0xa9:
5725 {
5726 sdwCyclesRemaining -= 16;
5727 {
5728 psMemRead = cpu.z80MemRead; /* Beginning of our handler */
5729 while (psMemRead->lowAddr != 0xffffffff)
5730 {
5731 if ((cpu.z80HL >= psMemRead->lowAddr) && (cpu.z80HL <= psMemRead->highAddr))
5732 {
5733 cpu.z80pc = (UINT32) pbPC - (UINT32) cpu.z80Base;
5734 if (psMemRead->memoryCall)
5735 {
5736 bTemp = psMemRead->memoryCall(cpu.z80HL, psMemRead);
5737 }
5738 else
5739 {
5740 bTemp = *((UINT8 *) psMemRead->pUserArea + (cpu.z80HL - psMemRead->lowAddr));
5741 }
5742 psMemRead = NULL;
5743 break;
5744 }
5745 ++psMemRead;
5746 }
5747
5748 if (psMemRead)
5749 {
5750 bTemp = cpu.z80Base[cpu.z80HL];
5751 }
5752
5753 cpu.z80HL--;
5754 cpu.z80HL &= 0xffff;
5755 cpu.z80BC--;
5756 cpu.z80BC &= 0xffff;
5757 }
5758 cpu.z80F &= ~(Z80_FLAG_ZERO | Z80_FLAG_SIGN | Z80_FLAG_HALF_CARRY | Z80_FLAG_OVERFLOW_PARITY | Z80_FLAG_NEGATIVE);
5759 cpu.z80F |= (pbSubSbcTable[((UINT32) cpu.z80A << 8) | bTemp] & (Z80_FLAG_SIGN | Z80_FLAG_NEGATIVE | Z80_FLAG_ZERO));
5760 if (cpu.z80BC)
5761 {
5762 cpu.z80F |= Z80_FLAG_OVERFLOW_PARITY;
5763 }
5764 break;
5765 }
5766 case 0xaa:
5767 {
5768 sdwCyclesRemaining -= 16;
5769 {
5770 psIoRead = cpu.z80IoRead; /* Beginning of our handler */
5771 while (psIoRead->lowIoAddr != 0xffff)
5772 {
5773 if ((cpu.z80B >= psIoRead->lowIoAddr) && (cpu.z80B <= psIoRead->highIoAddr))
5774 {
5775 cpu.z80pc = (UINT32) pbPC - (UINT32) cpu.z80Base;
5776 bTemp = psIoRead->IOCall(cpu.z80B, psIoRead);
5777 psIoRead = NULL;
5778 break;
5779 }
5780 ++psIoRead;
5781 }
5782
5783 if (psIoRead)
5784 {
5785 bTemp = 0xff; /* Unclaimed I/O read */
5786 }
5787
5788 psMemWrite = cpu.z80MemWrite; /* Beginning of our handler */
5789 while (psMemWrite->lowAddr != 0xffffffff)
5790 {
5791 if ((cpu.z80HL >= psMemWrite->lowAddr) && (cpu.z80HL <= psMemWrite->highAddr))
5792 {
5793 cpu.z80pc = (UINT32) pbPC - (UINT32) cpu.z80Base;
5794 if (psMemWrite->memoryCall)
5795 {
5796 psMemWrite->memoryCall(cpu.z80HL, bTemp, psMemWrite);
5797 }
5798 else
5799 {
5800 *((UINT8 *) psMemWrite->pUserArea + (cpu.z80HL - psMemWrite->lowAddr)) = bTemp;
5801 }
5802 psMemWrite = NULL;
5803 break;
5804 }
5805 ++psMemWrite;
5806 }
5807
5808 if (psMemWrite)
5809 {
5810 cpu.z80Base[cpu.z80HL] = (UINT8) bTemp;
5811 }
5812
5813 cpu.z80HL--;
5814 cpu.z80HL &= 0xffff;
5815 sdwCyclesRemaining -= 16;
5816 cpu.z80B--;
5817 }
5818 cpu.z80F &= ~(Z80_FLAG_ZERO | Z80_FLAG_SIGN | Z80_FLAG_HALF_CARRY | Z80_FLAG_OVERFLOW_PARITY | Z80_FLAG_NEGATIVE);
5819 cpu.z80F |= (bPostORFlags[bTemp] & (Z80_FLAG_SIGN | Z80_FLAG_NEGATIVE | Z80_FLAG_HALF_CARRY | Z80_FLAG_OVERFLOW_PARITY));
5820 if (cpu.z80B)
5821 {
5822 cpu.z80F |= Z80_FLAG_OVERFLOW_PARITY;
5823 pbPC -= 2;
5824 }
5825 break;
5826 }
5827 case 0xab:
5828 {
5829 sdwCyclesRemaining -= 16;
5830 {
5831 psMemRead = cpu.z80MemRead; /* Beginning of our handler */
5832 while (psMemRead->lowAddr != 0xffffffff)
5833 {
5834 if ((cpu.z80HL >= psMemRead->lowAddr) && (cpu.z80HL <= psMemRead->highAddr))
5835 {
5836 cpu.z80pc = (UINT32) pbPC - (UINT32) cpu.z80Base;
5837 if (psMemRead->memoryCall)
5838 {
5839 bTemp = psMemRead->memoryCall(cpu.z80HL, psMemRead);
5840 }
5841 else
5842 {
5843 bTemp = *((UINT8 *) psMemRead->pUserArea + (cpu.z80HL - psMemRead->lowAddr));
5844 }
5845 psMemRead = NULL;
5846 break;
5847 }
5848 ++psMemRead;
5849 }
5850
5851 if (psMemRead)
5852 {
5853 bTemp = cpu.z80Base[cpu.z80HL];
5854 }
5855
5856 psIoWrite = cpu.z80IoWrite; /* Beginning of our handler */
5857 while (psIoWrite->lowIoAddr != 0xffff)
5858 {
5859 if ((cpu.z80BC >= psIoWrite->lowIoAddr) && (cpu.z80BC <= psIoWrite->highIoAddr))
5860 {
5861 cpu.z80pc = (UINT32) pbPC - (UINT32) cpu.z80Base;
5862 psIoWrite->IOCall(cpu.z80BC, bTemp, psIoWrite);
5863 psIoWrite = NULL;
5864 break;
5865 }
5866 ++psIoWrite;
5867 }
5868
5869 cpu.z80HL--;
5870 cpu.z80HL &= 0xffff;
5871 sdwCyclesRemaining -= 16;
5872 cpu.z80B--;
5873 }
5874 cpu.z80F &= ~(Z80_FLAG_ZERO | Z80_FLAG_SIGN | Z80_FLAG_HALF_CARRY | Z80_FLAG_OVERFLOW_PARITY | Z80_FLAG_NEGATIVE);
5875 cpu.z80F |= (bPostORFlags[bTemp] & (Z80_FLAG_SIGN | Z80_FLAG_NEGATIVE | Z80_FLAG_HALF_CARRY | Z80_FLAG_OVERFLOW_PARITY));
5876 if (cpu.z80B)
5877 {
5878 cpu.z80F |= Z80_FLAG_OVERFLOW_PARITY;
5879 }
5880 break;
5881 }
5882 case 0xac:
5883 {
5884 InvalidInstruction(2);
5885 break;
5886 }
5887 case 0xad:
5888 {
5889 InvalidInstruction(2);
5890 break;
5891 }
5892 case 0xae:
5893 {
5894 InvalidInstruction(2);
5895 break;
5896 }
5897 case 0xaf:
5898 {
5899 InvalidInstruction(2);
5900 break;
5901 }
5902 case 0xb0:
5903 {
5904 sdwCyclesRemaining -= 16;
5905 while ((sdwCyclesRemaining > 0) && (cpu.z80BC))
5906 {
5907 psMemRead = cpu.z80MemRead; /* Beginning of our handler */
5908 while (psMemRead->lowAddr != 0xffffffff)
5909 {
5910 if ((cpu.z80HL >= psMemRead->lowAddr) && (cpu.z80HL <= psMemRead->highAddr))
5911 {
5912 cpu.z80pc = (UINT32) pbPC - (UINT32) cpu.z80Base;
5913 if (psMemRead->memoryCall)
5914 {
5915 bTemp = psMemRead->memoryCall(cpu.z80HL, psMemRead);
5916 }
5917 else
5918 {
5919 bTemp = *((UINT8 *) psMemRead->pUserArea + (cpu.z80HL - psMemRead->lowAddr));
5920 }
5921 psMemRead = NULL;
5922 break;
5923 }
5924 ++psMemRead;
5925 }
5926
5927 if (psMemRead)
5928 {
5929 bTemp = cpu.z80Base[cpu.z80HL];
5930 }
5931
5932 psMemWrite = cpu.z80MemWrite; /* Beginning of our handler */
5933 while (psMemWrite->lowAddr != 0xffffffff)
5934 {
5935 if ((cpu.z80DE >= psMemWrite->lowAddr) && (cpu.z80DE <= psMemWrite->highAddr))
5936 {
5937 cpu.z80pc = (UINT32) pbPC - (UINT32) cpu.z80Base;
5938 if (psMemWrite->memoryCall)
5939 {
5940 psMemWrite->memoryCall(cpu.z80DE, bTemp, psMemWrite);
5941 }
5942 else
5943 {
5944 *((UINT8 *) psMemWrite->pUserArea + (cpu.z80DE - psMemWrite->lowAddr)) = bTemp;
5945 }
5946 psMemWrite = NULL;
5947 break;
5948 }
5949 ++psMemWrite;
5950 }
5951
5952 if (psMemWrite)
5953 {
5954 cpu.z80Base[cpu.z80DE] = (UINT8) bTemp;
5955 }
5956
5957 ++cpu.z80HL;
5958 ++cpu.z80DE;
5959 --cpu.z80BC;
5960 cpu.z80HL &= 0xffff;
5961 cpu.z80DE &= 0xffff;
5962 cpu.z80BC &= 0xffff;
5963 sdwCyclesRemaining -= 21;
5964 }
5965 cpu.z80F &= ~(Z80_FLAG_HALF_CARRY | Z80_FLAG_NEGATIVE | Z80_FLAG_OVERFLOW_PARITY);
5966 if (cpu.z80BC)
5967 {
5968 pbPC -= 2; /* Back up so we hit this instruction again */
5969 cpu.z80F |= Z80_FLAG_OVERFLOW_PARITY;
5970 }
5971 sdwCyclesRemaining -= 16;
5972 break;
5973 }
5974 case 0xb1:
5975 {
5976 sdwCyclesRemaining -= 16;
5977 while ((sdwCyclesRemaining >= 0) && (cpu.z80BC))
5978 {
5979 psMemRead = cpu.z80MemRead; /* Beginning of our handler */
5980 while (psMemRead->lowAddr != 0xffffffff)
5981 {
5982 if ((cpu.z80HL >= psMemRead->lowAddr) && (cpu.z80HL <= psMemRead->highAddr))
5983 {
5984 cpu.z80pc = (UINT32) pbPC - (UINT32) cpu.z80Base;
5985 if (psMemRead->memoryCall)
5986 {
5987 bTemp = psMemRead->memoryCall(cpu.z80HL, psMemRead);
5988 }
5989 else
5990 {
5991 bTemp = *((UINT8 *) psMemRead->pUserArea + (cpu.z80HL - psMemRead->lowAddr));
5992 }
5993 psMemRead = NULL;
5994 break;
5995 }
5996 ++psMemRead;
5997 }
5998
5999 if (psMemRead)
6000 {
6001 bTemp = cpu.z80Base[cpu.z80HL];
6002 }
6003
6004 cpu.z80HL++;
6005 cpu.z80HL &= 0xffff;
6006 cpu.z80BC--;
6007 cpu.z80BC &= 0xffff;
6008 sdwCyclesRemaining -= 16;
6009 if (cpu.z80A == bTemp)
6010 {
6011 break;
6012 }
6013 }
6014 cpu.z80F &= ~(Z80_FLAG_ZERO | Z80_FLAG_SIGN | Z80_FLAG_HALF_CARRY | Z80_FLAG_OVERFLOW_PARITY | Z80_FLAG_NEGATIVE);
6015 cpu.z80F |= (pbSubSbcTable[((UINT32) cpu.z80A << 8) | bTemp] & (Z80_FLAG_SIGN | Z80_FLAG_NEGATIVE | Z80_FLAG_ZERO));
6016 if (cpu.z80BC)
6017 {
6018 cpu.z80F |= Z80_FLAG_OVERFLOW_PARITY;
6019 }
6020 break;
6021 }
6022 case 0xb2:
6023 {
6024 sdwCyclesRemaining -= 16;
6025 while ((sdwCyclesRemaining > 0) && (cpu.z80B))
6026 {
6027 psIoRead = cpu.z80IoRead; /* Beginning of our handler */
6028 while (psIoRead->lowIoAddr != 0xffff)
6029 {
6030 if ((cpu.z80B >= psIoRead->lowIoAddr) && (cpu.z80B <= psIoRead->highIoAddr))
6031 {
6032 cpu.z80pc = (UINT32) pbPC - (UINT32) cpu.z80Base;
6033 bTemp = psIoRead->IOCall(cpu.z80B, psIoRead);
6034 psIoRead = NULL;
6035 break;
6036 }
6037 ++psIoRead;
6038 }
6039
6040 if (psIoRead)
6041 {
6042 bTemp = 0xff; /* Unclaimed I/O read */
6043 }
6044
6045 psMemWrite = cpu.z80MemWrite; /* Beginning of our handler */
6046 while (psMemWrite->lowAddr != 0xffffffff)
6047 {
6048 if ((cpu.z80HL >= psMemWrite->lowAddr) && (cpu.z80HL <= psMemWrite->highAddr))
6049 {
6050 cpu.z80pc = (UINT32) pbPC - (UINT32) cpu.z80Base;
6051 if (psMemWrite->memoryCall)
6052 {
6053 psMemWrite->memoryCall(cpu.z80HL, bTemp, psMemWrite);
6054 }
6055 else
6056 {
6057 *((UINT8 *) psMemWrite->pUserArea + (cpu.z80HL - psMemWrite->lowAddr)) = bTemp;
6058 }
6059 psMemWrite = NULL;
6060 break;
6061 }
6062 ++psMemWrite;
6063 }
6064
6065 if (psMemWrite)
6066 {
6067 cpu.z80Base[cpu.z80HL] = (UINT8) bTemp;
6068 }
6069
6070 cpu.z80HL++;
6071 cpu.z80HL &= 0xffff;
6072 sdwCyclesRemaining -= 16;
6073 cpu.z80B--;
6074 }
6075 cpu.z80F &= ~(Z80_FLAG_ZERO | Z80_FLAG_SIGN | Z80_FLAG_HALF_CARRY | Z80_FLAG_OVERFLOW_PARITY | Z80_FLAG_NEGATIVE);
6076 cpu.z80F |= (bPostORFlags[bTemp] & (Z80_FLAG_SIGN | Z80_FLAG_NEGATIVE | Z80_FLAG_HALF_CARRY | Z80_FLAG_OVERFLOW_PARITY));
6077 if (cpu.z80B)
6078 {
6079 cpu.z80F |= Z80_FLAG_OVERFLOW_PARITY;
6080 pbPC -= 2;
6081 }
6082 break;
6083 }
6084 case 0xb3:
6085 {
6086 sdwCyclesRemaining -= 16;
6087 while ((sdwCyclesRemaining > 0) && (cpu.z80B))
6088 {
6089 psMemRead = cpu.z80MemRead; /* Beginning of our handler */
6090 while (psMemRead->lowAddr != 0xffffffff)
6091 {
6092 if ((cpu.z80HL >= psMemRead->lowAddr) && (cpu.z80HL <= psMemRead->highAddr))
6093 {
6094 cpu.z80pc = (UINT32) pbPC - (UINT32) cpu.z80Base;
6095 if (psMemRead->memoryCall)
6096 {
6097 bTemp = psMemRead->memoryCall(cpu.z80HL, psMemRead);
6098 }
6099 else
6100 {
6101 bTemp = *((UINT8 *) psMemRead->pUserArea + (cpu.z80HL - psMemRead->lowAddr));
6102 }
6103 psMemRead = NULL;
6104 break;
6105 }
6106 ++psMemRead;
6107 }
6108
6109 if (psMemRead)
6110 {
6111 bTemp = cpu.z80Base[cpu.z80HL];
6112 }
6113
6114 psIoWrite = cpu.z80IoWrite; /* Beginning of our handler */
6115 while (psIoWrite->lowIoAddr != 0xffff)
6116 {
6117 if ((cpu.z80BC >= psIoWrite->lowIoAddr) && (cpu.z80BC <= psIoWrite->highIoAddr))
6118 {
6119 cpu.z80pc = (UINT32) pbPC - (UINT32) cpu.z80Base;
6120 psIoWrite->IOCall(cpu.z80BC, bTemp, psIoWrite);
6121 psIoWrite = NULL;
6122 break;
6123 }
6124 ++psIoWrite;
6125 }
6126
6127 cpu.z80HL++;
6128 cpu.z80HL &= 0xffff;
6129 sdwCyclesRemaining -= 16;
6130 cpu.z80B--;
6131 }
6132 cpu.z80F &= ~(Z80_FLAG_ZERO | Z80_FLAG_SIGN | Z80_FLAG_HALF_CARRY | Z80_FLAG_OVERFLOW_PARITY | Z80_FLAG_NEGATIVE);
6133 cpu.z80F |= (bPostORFlags[bTemp] & (Z80_FLAG_SIGN | Z80_FLAG_NEGATIVE | Z80_FLAG_HALF_CARRY | Z80_FLAG_OVERFLOW_PARITY));
6134 if (cpu.z80B)
6135 {
6136 cpu.z80F |= Z80_FLAG_OVERFLOW_PARITY;
6137 }
6138 break;
6139 }
6140 case 0xb4:
6141 {
6142 InvalidInstruction(2);
6143 break;
6144 }
6145 case 0xb5:
6146 {
6147 InvalidInstruction(2);
6148 break;
6149 }
6150 case 0xb6:
6151 {
6152 InvalidInstruction(2);
6153 break;
6154 }
6155 case 0xb7:
6156 {
6157 InvalidInstruction(2);
6158 break;
6159 }
6160 case 0xb8:
6161 {
6162 sdwCyclesRemaining -= 16;
6163 while ((sdwCyclesRemaining > 0) && (cpu.z80BC))
6164 {
6165 psMemRead = cpu.z80MemRead; /* Beginning of our handler */
6166 while (psMemRead->lowAddr != 0xffffffff)
6167 {
6168 if ((cpu.z80HL >= psMemRead->lowAddr) && (cpu.z80HL <= psMemRead->highAddr))
6169 {
6170 cpu.z80pc = (UINT32) pbPC - (UINT32) cpu.z80Base;
6171 if (psMemRead->memoryCall)
6172 {
6173 bTemp = psMemRead->memoryCall(cpu.z80HL, psMemRead);
6174 }
6175 else
6176 {
6177 bTemp = *((UINT8 *) psMemRead->pUserArea + (cpu.z80HL - psMemRead->lowAddr));
6178 }
6179 psMemRead = NULL;
6180 break;
6181 }
6182 ++psMemRead;
6183 }
6184
6185 if (psMemRead)
6186 {
6187 bTemp = cpu.z80Base[cpu.z80HL];
6188 }
6189
6190 psMemWrite = cpu.z80MemWrite; /* Beginning of our handler */
6191 while (psMemWrite->lowAddr != 0xffffffff)
6192 {
6193 if ((cpu.z80DE >= psMemWrite->lowAddr) && (cpu.z80DE <= psMemWrite->highAddr))
6194 {
6195 cpu.z80pc = (UINT32) pbPC - (UINT32) cpu.z80Base;
6196 if (psMemWrite->memoryCall)
6197 {
6198 psMemWrite->memoryCall(cpu.z80DE, bTemp, psMemWrite);
6199 }
6200 else
6201 {
6202 *((UINT8 *) psMemWrite->pUserArea + (cpu.z80DE - psMemWrite->lowAddr)) = bTemp;
6203 }
6204 psMemWrite = NULL;
6205 break;
6206 }
6207 ++psMemWrite;
6208 }
6209
6210 if (psMemWrite)
6211 {
6212 cpu.z80Base[cpu.z80DE] = (UINT8) bTemp;
6213 }
6214
6215 --cpu.z80HL;
6216 --cpu.z80DE;
6217 --cpu.z80BC;
6218 cpu.z80HL &= 0xffff;
6219 cpu.z80DE &= 0xffff;
6220 cpu.z80BC &= 0xffff;
6221 sdwCyclesRemaining -= 21;
6222 }
6223 cpu.z80F &= ~(Z80_FLAG_HALF_CARRY | Z80_FLAG_NEGATIVE | Z80_FLAG_OVERFLOW_PARITY);
6224 if (cpu.z80BC)
6225 {
6226 pbPC -= 2; /* Back up so we hit this instruction again */
6227 cpu.z80F |= Z80_FLAG_OVERFLOW_PARITY;
6228 }
6229 sdwCyclesRemaining -= 16;
6230 break;
6231 }
6232 case 0xb9:
6233 {
6234 sdwCyclesRemaining -= 16;
6235 while ((sdwCyclesRemaining >= 0) && (cpu.z80BC))
6236 {
6237 psMemRead = cpu.z80MemRead; /* Beginning of our handler */
6238 while (psMemRead->lowAddr != 0xffffffff)
6239 {
6240 if ((cpu.z80HL >= psMemRead->lowAddr) && (cpu.z80HL <= psMemRead->highAddr))
6241 {
6242 cpu.z80pc = (UINT32) pbPC - (UINT32) cpu.z80Base;
6243 if (psMemRead->memoryCall)
6244 {
6245 bTemp = psMemRead->memoryCall(cpu.z80HL, psMemRead);
6246 }
6247 else
6248 {
6249 bTemp = *((UINT8 *) psMemRead->pUserArea + (cpu.z80HL - psMemRead->lowAddr));
6250 }
6251 psMemRead = NULL;
6252 break;
6253 }
6254 ++psMemRead;
6255 }
6256
6257 if (psMemRead)
6258 {
6259 bTemp = cpu.z80Base[cpu.z80HL];
6260 }
6261
6262 cpu.z80HL--;
6263 cpu.z80HL &= 0xffff;
6264 cpu.z80BC--;
6265 cpu.z80BC &= 0xffff;
6266 sdwCyclesRemaining -= 16;
6267 if (cpu.z80A == bTemp)
6268 {
6269 break;
6270 }
6271 }
6272 cpu.z80F &= ~(Z80_FLAG_ZERO | Z80_FLAG_SIGN | Z80_FLAG_HALF_CARRY | Z80_FLAG_OVERFLOW_PARITY | Z80_FLAG_NEGATIVE);
6273 cpu.z80F |= (pbSubSbcTable[((UINT32) cpu.z80A << 8) | bTemp] & (Z80_FLAG_SIGN | Z80_FLAG_NEGATIVE | Z80_FLAG_ZERO));
6274 if (cpu.z80BC)
6275 {
6276 cpu.z80F |= Z80_FLAG_OVERFLOW_PARITY;
6277 }
6278 break;
6279 }
6280 case 0xba:
6281 {
6282 sdwCyclesRemaining -= 16;
6283 while ((sdwCyclesRemaining > 0) && (cpu.z80B))
6284 {
6285 psIoRead = cpu.z80IoRead; /* Beginning of our handler */
6286 while (psIoRead->lowIoAddr != 0xffff)
6287 {
6288 if ((cpu.z80B >= psIoRead->lowIoAddr) && (cpu.z80B <= psIoRead->highIoAddr))
6289 {
6290 cpu.z80pc = (UINT32) pbPC - (UINT32) cpu.z80Base;
6291 bTemp = psIoRead->IOCall(cpu.z80B, psIoRead);
6292 psIoRead = NULL;
6293 break;
6294 }
6295 ++psIoRead;
6296 }
6297
6298 if (psIoRead)
6299 {
6300 bTemp = 0xff; /* Unclaimed I/O read */
6301 }
6302
6303 psMemWrite = cpu.z80MemWrite; /* Beginning of our handler */
6304 while (psMemWrite->lowAddr != 0xffffffff)
6305 {
6306 if ((cpu.z80HL >= psMemWrite->lowAddr) && (cpu.z80HL <= psMemWrite->highAddr))
6307 {
6308 cpu.z80pc = (UINT32) pbPC - (UINT32) cpu.z80Base;
6309 if (psMemWrite->memoryCall)
6310 {
6311 psMemWrite->memoryCall(cpu.z80HL, bTemp, psMemWrite);
6312 }
6313 else
6314 {
6315 *((UINT8 *) psMemWrite->pUserArea + (cpu.z80HL - psMemWrite->lowAddr)) = bTemp;
6316 }
6317 psMemWrite = NULL;
6318 break;
6319 }
6320 ++psMemWrite;
6321 }
6322
6323 if (psMemWrite)
6324 {
6325 cpu.z80Base[cpu.z80HL] = (UINT8) bTemp;
6326 }
6327
6328 cpu.z80HL--;
6329 cpu.z80HL &= 0xffff;
6330 sdwCyclesRemaining -= 16;
6331 cpu.z80B--;
6332 }
6333 cpu.z80F &= ~(Z80_FLAG_ZERO | Z80_FLAG_SIGN | Z80_FLAG_HALF_CARRY | Z80_FLAG_OVERFLOW_PARITY | Z80_FLAG_NEGATIVE);
6334 cpu.z80F |= (bPostORFlags[bTemp] & (Z80_FLAG_SIGN | Z80_FLAG_NEGATIVE | Z80_FLAG_HALF_CARRY | Z80_FLAG_OVERFLOW_PARITY));
6335 if (cpu.z80B)
6336 {
6337 cpu.z80F |= Z80_FLAG_OVERFLOW_PARITY;
6338 pbPC -= 2;
6339 }
6340 break;
6341 }
6342 case 0xbb:
6343 {
6344 sdwCyclesRemaining -= 16;
6345 while ((sdwCyclesRemaining > 0) && (cpu.z80B))
6346 {
6347 psMemRead = cpu.z80MemRead; /* Beginning of our handler */
6348 while (psMemRead->lowAddr != 0xffffffff)
6349 {
6350 if ((cpu.z80HL >= psMemRead->lowAddr) && (cpu.z80HL <= psMemRead->highAddr))
6351 {
6352 cpu.z80pc = (UINT32) pbPC - (UINT32) cpu.z80Base;
6353 if (psMemRead->memoryCall)
6354 {
6355 bTemp = psMemRead->memoryCall(cpu.z80HL, psMemRead);
6356 }
6357 else
6358 {
6359 bTemp = *((UINT8 *) psMemRead->pUserArea + (cpu.z80HL - psMemRead->lowAddr));
6360 }
6361 psMemRead = NULL;
6362 break;
6363 }
6364 ++psMemRead;
6365 }
6366
6367 if (psMemRead)
6368 {
6369 bTemp = cpu.z80Base[cpu.z80HL];
6370 }
6371
6372 psIoWrite = cpu.z80IoWrite; /* Beginning of our handler */
6373 while (psIoWrite->lowIoAddr != 0xffff)
6374 {
6375 if ((cpu.z80BC >= psIoWrite->lowIoAddr) && (cpu.z80BC <= psIoWrite->highIoAddr))
6376 {
6377 cpu.z80pc = (UINT32) pbPC - (UINT32) cpu.z80Base;
6378 psIoWrite->IOCall(cpu.z80BC, bTemp, psIoWrite);
6379 psIoWrite = NULL;
6380 break;
6381 }
6382 ++psIoWrite;
6383 }
6384
6385 cpu.z80HL--;
6386 cpu.z80HL &= 0xffff;
6387 sdwCyclesRemaining -= 16;
6388 cpu.z80B--;
6389 }
6390 cpu.z80F &= ~(Z80_FLAG_ZERO | Z80_FLAG_SIGN | Z80_FLAG_HALF_CARRY | Z80_FLAG_OVERFLOW_PARITY | Z80_FLAG_NEGATIVE);
6391 cpu.z80F |= (bPostORFlags[bTemp] & (Z80_FLAG_SIGN | Z80_FLAG_NEGATIVE | Z80_FLAG_HALF_CARRY | Z80_FLAG_OVERFLOW_PARITY));
6392 if (cpu.z80B)
6393 {
6394 cpu.z80F |= Z80_FLAG_OVERFLOW_PARITY;
6395 }
6396 break;
6397 }
6398 case 0xbc:
6399 {
6400 InvalidInstruction(2);
6401 break;
6402 }
6403 case 0xbd:
6404 {
6405 InvalidInstruction(2);
6406 break;
6407 }
6408 case 0xbe:
6409 {
6410 InvalidInstruction(2);
6411 break;
6412 }
6413 case 0xbf:
6414 {
6415 InvalidInstruction(2);
6416 break;
6417 }
6418 case 0xc0:
6419 {
6420 InvalidInstruction(2);
6421 break;
6422 }
6423 case 0xc1:
6424 {
6425 InvalidInstruction(2);
6426 break;
6427 }
6428 case 0xc2:
6429 {
6430 InvalidInstruction(2);
6431 break;
6432 }
6433 case 0xc3:
6434 {
6435 InvalidInstruction(2);
6436 break;
6437 }
6438 case 0xc4:
6439 {
6440 InvalidInstruction(2);
6441 break;
6442 }
6443 case 0xc5:
6444 {
6445 InvalidInstruction(2);
6446 break;
6447 }
6448 case 0xc6:
6449 {
6450 InvalidInstruction(2);
6451 break;
6452 }
6453 case 0xc7:
6454 {
6455 InvalidInstruction(2);
6456 break;
6457 }
6458 case 0xc8:
6459 {
6460 InvalidInstruction(2);
6461 break;
6462 }
6463 case 0xc9:
6464 {
6465 InvalidInstruction(2);
6466 break;
6467 }
6468 case 0xca:
6469 {
6470 InvalidInstruction(2);
6471 break;
6472 }
6473 case 0xcb:
6474 {
6475 InvalidInstruction(2);
6476 break;
6477 }
6478 case 0xcc:
6479 {
6480 InvalidInstruction(2);
6481 break;
6482 }
6483 case 0xcd:
6484 {
6485 InvalidInstruction(2);
6486 break;
6487 }
6488 case 0xce:
6489 {
6490 InvalidInstruction(2);
6491 break;
6492 }
6493 case 0xcf:
6494 {
6495 InvalidInstruction(2);
6496 break;
6497 }
6498 case 0xd0:
6499 {
6500 InvalidInstruction(2);
6501 break;
6502 }
6503 case 0xd1:
6504 {
6505 InvalidInstruction(2);
6506 break;
6507 }
6508 case 0xd2:
6509 {
6510 InvalidInstruction(2);
6511 break;
6512 }
6513 case 0xd3:
6514 {
6515 InvalidInstruction(2);
6516 break;
6517 }
6518 case 0xd4:
6519 {
6520 InvalidInstruction(2);
6521 break;
6522 }
6523 case 0xd5:
6524 {
6525 InvalidInstruction(2);
6526 break;
6527 }
6528 case 0xd6:
6529 {
6530 InvalidInstruction(2);
6531 break;
6532 }
6533 case 0xd7:
6534 {
6535 InvalidInstruction(2);
6536 break;
6537 }
6538 case 0xd8:
6539 {
6540 InvalidInstruction(2);
6541 break;
6542 }
6543 case 0xd9:
6544 {
6545 InvalidInstruction(2);
6546 break;
6547 }
6548 case 0xda:
6549 {
6550 InvalidInstruction(2);
6551 break;
6552 }
6553 case 0xdb:
6554 {
6555 InvalidInstruction(2);
6556 break;
6557 }
6558 case 0xdc:
6559 {
6560 InvalidInstruction(2);
6561 break;
6562 }
6563 case 0xdd:
6564 {
6565 InvalidInstruction(2);
6566 break;
6567 }
6568 case 0xde:
6569 {
6570 InvalidInstruction(2);
6571 break;
6572 }
6573 case 0xdf:
6574 {
6575 InvalidInstruction(2);
6576 break;
6577 }
6578 case 0xe0:
6579 {
6580 InvalidInstruction(2);
6581 break;
6582 }
6583 case 0xe1:
6584 {
6585 InvalidInstruction(2);
6586 break;
6587 }
6588 case 0xe2:
6589 {
6590 InvalidInstruction(2);
6591 break;
6592 }
6593 case 0xe3:
6594 {
6595 InvalidInstruction(2);
6596 break;
6597 }
6598 case 0xe4:
6599 {
6600 InvalidInstruction(2);
6601 break;
6602 }
6603 case 0xe5:
6604 {
6605 InvalidInstruction(2);
6606 break;
6607 }
6608 case 0xe6:
6609 {
6610 InvalidInstruction(2);
6611 break;
6612 }
6613 case 0xe7:
6614 {
6615 InvalidInstruction(2);
6616 break;
6617 }
6618 case 0xe8:
6619 {
6620 InvalidInstruction(2);
6621 break;
6622 }
6623 case 0xe9:
6624 {
6625 InvalidInstruction(2);
6626 break;
6627 }
6628 case 0xea:
6629 {
6630 InvalidInstruction(2);
6631 break;
6632 }
6633 case 0xeb:
6634 {
6635 InvalidInstruction(2);
6636 break;
6637 }
6638 case 0xec:
6639 {
6640 InvalidInstruction(2);
6641 break;
6642 }
6643 case 0xed:
6644 {
6645 InvalidInstruction(2);
6646 break;
6647 }
6648 case 0xee:
6649 {
6650 InvalidInstruction(2);
6651 break;
6652 }
6653 case 0xef:
6654 {
6655 InvalidInstruction(2);
6656 break;
6657 }
6658 case 0xf0:
6659 {
6660 InvalidInstruction(2);
6661 break;
6662 }
6663 case 0xf1:
6664 {
6665 InvalidInstruction(2);
6666 break;
6667 }
6668 case 0xf2:
6669 {
6670 InvalidInstruction(2);
6671 break;
6672 }
6673 case 0xf3:
6674 {
6675 InvalidInstruction(2);
6676 break;
6677 }
6678 case 0xf4:
6679 {
6680 InvalidInstruction(2);
6681 break;
6682 }
6683 case 0xf5:
6684 {
6685 InvalidInstruction(2);
6686 break;
6687 }
6688 case 0xf6:
6689 {
6690 InvalidInstruction(2);
6691 break;
6692 }
6693 case 0xf7:
6694 {
6695 InvalidInstruction(2);
6696 break;
6697 }
6698 case 0xf8:
6699 {
6700 InvalidInstruction(2);
6701 break;
6702 }
6703 case 0xf9:
6704 {
6705 InvalidInstruction(2);
6706 break;
6707 }
6708 case 0xfa:
6709 {
6710 InvalidInstruction(2);
6711 break;
6712 }
6713 case 0xfb:
6714 {
6715 InvalidInstruction(2);
6716 break;
6717 }
6718 case 0xfc:
6719 {
6720 InvalidInstruction(2);
6721 break;
6722 }
6723 case 0xfd:
6724 {
6725 InvalidInstruction(2);
6726 break;
6727 }
6728 case 0xfe:
6729 {
6730 InvalidInstruction(2);
6731 break;
6732 }
6733 case 0xff:
6734 {
6735 InvalidInstruction(2);
6736 break;
6737 }
6738 }
6739}
6740
6741void DDHandler(void)
6742{
6743 switch (*pbPC++)
6744 {
6745 case 0x00:
6746 {
6747 InvalidInstruction(2);
6748 break;
6749 }
6750 case 0x01:
6751 {
6752 InvalidInstruction(2);
6753 break;
6754 }
6755 case 0x02:
6756 {
6757 InvalidInstruction(2);
6758 break;
6759 }
6760 case 0x03:
6761 {
6762 InvalidInstruction(2);
6763 break;
6764 }
6765 case 0x04:
6766 {
6767 InvalidInstruction(2);
6768 break;
6769 }
6770 case 0x05:
6771 {
6772 InvalidInstruction(2);
6773 break;
6774 }
6775 case 0x06:
6776 {
6777 InvalidInstruction(2);
6778 break;
6779 }
6780 case 0x07:
6781 {
6782 InvalidInstruction(2);
6783 break;
6784 }
6785 case 0x08:
6786 {
6787 InvalidInstruction(2);
6788 break;
6789 }
6790 case 0x09:
6791 {
6792 sdwCyclesRemaining -= 15;
6793 cpu.z80F &= ~(Z80_FLAG_CARRY | Z80_FLAG_NEGATIVE | Z80_FLAG_HALF_CARRY);
6794 dwTemp = cpu.z80IX + cpu.z80BC;
6795 cpu.z80F |= ((dwTemp >> 16) & Z80_FLAG_CARRY) | (((cpu.z80IX ^ dwTemp ^ cpu.z80BC) >> 8) & Z80_FLAG_HALF_CARRY);
6796 cpu.z80IX = dwTemp & 0xffff;
6797 break;
6798 }
6799 case 0x0a:
6800 {
6801 InvalidInstruction(2);
6802 break;
6803 }
6804 case 0x0b:
6805 {
6806 InvalidInstruction(2);
6807 break;
6808 }
6809 case 0x0c:
6810 {
6811 InvalidInstruction(2);
6812 break;
6813 }
6814 case 0x0d:
6815 {
6816 InvalidInstruction(2);
6817 break;
6818 }
6819 case 0x0e:
6820 {
6821 InvalidInstruction(2);
6822 break;
6823 }
6824 case 0x0f:
6825 {
6826 InvalidInstruction(2);
6827 break;
6828 }
6829 case 0x10:
6830 {
6831 InvalidInstruction(2);
6832 break;
6833 }
6834 case 0x11:
6835 {
6836 InvalidInstruction(2);
6837 break;
6838 }
6839 case 0x12:
6840 {
6841 InvalidInstruction(2);
6842 break;
6843 }
6844 case 0x13:
6845 {
6846 InvalidInstruction(2);
6847 break;
6848 }
6849 case 0x14:
6850 {
6851 InvalidInstruction(2);
6852 break;
6853 }
6854 case 0x15:
6855 {
6856 InvalidInstruction(2);
6857 break;
6858 }
6859 case 0x16:
6860 {
6861 InvalidInstruction(2);
6862 break;
6863 }
6864 case 0x17:
6865 {
6866 InvalidInstruction(2);
6867 break;
6868 }
6869 case 0x18:
6870 {
6871 InvalidInstruction(2);
6872 break;
6873 }
6874 case 0x19:
6875 {
6876 sdwCyclesRemaining -= 15;
6877 cpu.z80F &= ~(Z80_FLAG_CARRY | Z80_FLAG_NEGATIVE | Z80_FLAG_HALF_CARRY);
6878 dwTemp = cpu.z80IX + cpu.z80DE;
6879 cpu.z80F |= ((dwTemp >> 16) & Z80_FLAG_CARRY) | (((cpu.z80IX ^ dwTemp ^ cpu.z80DE) >> 8) & Z80_FLAG_HALF_CARRY);
6880 cpu.z80IX = dwTemp & 0xffff;
6881 break;
6882 }
6883 case 0x1a:
6884 {
6885 InvalidInstruction(2);
6886 break;
6887 }
6888 case 0x1b:
6889 {
6890 InvalidInstruction(2);
6891 break;
6892 }
6893 case 0x1c:
6894 {
6895 InvalidInstruction(2);
6896 break;
6897 }
6898 case 0x1d:
6899 {
6900 InvalidInstruction(2);
6901 break;
6902 }
6903 case 0x1e:
6904 {
6905 InvalidInstruction(2);
6906 break;
6907 }
6908 case 0x1f:
6909 {
6910 InvalidInstruction(2);
6911 break;
6912 }
6913 case 0x20:
6914 {
6915 InvalidInstruction(2);
6916 break;
6917 }
6918 case 0x21:
6919 {
6920 sdwCyclesRemaining -= 14;
6921 cpu.z80IX = *pbPC++;
6922 cpu.z80IX |= ((UINT32) *pbPC++ << 8);
6923 break;
6924 }
6925 case 0x22:
6926 {
6927 sdwCyclesRemaining -= 20;
6928 dwAddr = *pbPC++;
6929 dwAddr |= ((UINT32) *pbPC++ << 8);
6930 psMemWrite = cpu.z80MemWrite; /* Beginning of our handler */
6931 while (psMemWrite->lowAddr != 0xffffffff)
6932 {
6933 if ((dwAddr >= psMemWrite->lowAddr) && (dwAddr <= psMemWrite->highAddr))
6934 {
6935 cpu.z80pc = (UINT32) pbPC - (UINT32) cpu.z80Base;
6936 if (psMemWrite->memoryCall)
6937 {
6938 psMemWrite->memoryCall(dwAddr, (cpu.z80IX & 0xff), psMemWrite);
6939 psMemWrite->memoryCall(dwAddr + 1, (cpu.z80IX >> 8), psMemWrite);
6940 }
6941 else
6942 {
6943 *((UINT8 *) psMemWrite->pUserArea + (dwAddr - psMemWrite->lowAddr)) = cpu.z80IX;
6944 *((UINT8 *) psMemWrite->pUserArea + (dwAddr - psMemWrite->lowAddr) + 1) = cpu.z80IX >> 8;
6945 }
6946 psMemWrite = NULL;
6947 break;
6948 }
6949 ++psMemWrite;
6950 }
6951
6952 if (psMemWrite)
6953 {
6954 cpu.z80Base[dwAddr] = (UINT8) cpu.z80IX;
6955 cpu.z80Base[dwAddr + 1] = (UINT8) ((UINT32) cpu.z80IX >> 8);
6956 }
6957
6958 break;
6959 }
6960 case 0x23:
6961 {
6962 sdwCyclesRemaining -= 10;
6963 cpu.z80IX++;
6964 cpu.z80IX &= 0xffff;
6965 break;
6966 }
6967 case 0x24:
6968 {
6969 sdwCyclesRemaining -= 9;
6970 cpu.z80F &= ~(Z80_FLAG_SIGN | Z80_FLAG_ZERO | Z80_FLAG_HALF_CARRY | Z80_FLAG_OVERFLOW_PARITY | Z80_FLAG_NEGATIVE);
6971 cpu.z80F |= bPostIncFlags[cpu.z80XH++];
6972 break;
6973 }
6974 case 0x25:
6975 {
6976 sdwCyclesRemaining -= 9;
6977 cpu.z80F &= ~(Z80_FLAG_SIGN | Z80_FLAG_ZERO | Z80_FLAG_HALF_CARRY | Z80_FLAG_OVERFLOW_PARITY | Z80_FLAG_NEGATIVE);
6978 cpu.z80F |= bPostDecFlags[cpu.z80XH--];
6979 break;
6980 }
6981 case 0x26:
6982 {
6983 sdwCyclesRemaining -= 9;
6984 cpu.z80XH = *pbPC++;
6985 break;
6986 }
6987 case 0x27:
6988 {
6989 InvalidInstruction(2);
6990 break;
6991 }
6992 case 0x28:
6993 {
6994 InvalidInstruction(2);
6995 break;
6996 }
6997 case 0x29:
6998 {
6999 sdwCyclesRemaining -= 15;
7000 cpu.z80F &= ~(Z80_FLAG_CARRY | Z80_FLAG_NEGATIVE | Z80_FLAG_HALF_CARRY);
7001 dwTemp = cpu.z80IX + cpu.z80IX;
7002 cpu.z80F |= ((dwTemp >> 16) & Z80_FLAG_CARRY) | (((cpu.z80IX ^ dwTemp ^ cpu.z80HL) >> 8) & Z80_FLAG_HALF_CARRY);
7003 cpu.z80IX = dwTemp & 0xffff;
7004 break;
7005 }
7006 case 0x2a:
7007 {
7008 sdwCyclesRemaining -= 20;
7009 dwAddr = *pbPC++;
7010 dwAddr |= ((UINT32) *pbPC++ << 8);
7011 psMemRead = cpu.z80MemRead; /* Beginning of our handler */
7012 while (psMemRead->lowAddr != 0xffffffff)
7013 {
7014 if ((dwAddr >= psMemRead->lowAddr) && (dwAddr <= psMemRead->highAddr))
7015 {
7016 cpu.z80pc = (UINT32) pbPC - (UINT32) cpu.z80Base;
7017 if (psMemRead->memoryCall)
7018 {
7019 cpu.z80IX = psMemRead->memoryCall(dwAddr, psMemRead);
7020 cpu.z80IX |= (UINT32) ((UINT32) psMemRead->memoryCall(dwAddr + 1, psMemRead) << 8);
7021 }
7022 else
7023 {
7024 cpu.z80IX = *((UINT8 *) psMemRead->pUserArea + (dwAddr - psMemRead->lowAddr));
7025 cpu.z80IX |= (UINT32) ((UINT32) *((UINT8 *) psMemRead->pUserArea + (dwAddr - psMemRead->lowAddr + 1)) << 8);
7026 }
7027 psMemRead = NULL;
7028 break;
7029 }
7030 ++psMemRead;
7031 }
7032
7033 if (psMemRead)
7034 {
7035 cpu.z80IX = cpu.z80Base[dwAddr];
7036 cpu.z80IX |= (UINT32) ((UINT32) cpu.z80Base[dwAddr + 1] << 8);
7037 }
7038
7039 break;
7040 }
7041 case 0x2b:
7042 {
7043 sdwCyclesRemaining -= 10;
7044 cpu.z80IX--;
7045 cpu.z80IX &= 0xffff;
7046 break;
7047 }
7048 case 0x2c:
7049 {
7050 sdwCyclesRemaining -= 9;
7051 cpu.z80F &= ~(Z80_FLAG_SIGN | Z80_FLAG_ZERO | Z80_FLAG_HALF_CARRY | Z80_FLAG_OVERFLOW_PARITY | Z80_FLAG_NEGATIVE);
7052 cpu.z80F |= bPostIncFlags[cpu.z80XL++];
7053 break;
7054 }
7055 case 0x2d:
7056 {
7057 sdwCyclesRemaining -= 9;
7058 cpu.z80F &= ~(Z80_FLAG_SIGN | Z80_FLAG_ZERO | Z80_FLAG_HALF_CARRY | Z80_FLAG_OVERFLOW_PARITY | Z80_FLAG_NEGATIVE);
7059 cpu.z80F |= bPostDecFlags[cpu.z80XL--];
7060 break;
7061 }
7062 case 0x2e:
7063 {
7064 sdwCyclesRemaining -= 9;
7065 cpu.z80XL = *pbPC++;
7066 break;
7067 }
7068 case 0x2f:
7069 {
7070 InvalidInstruction(2);
7071 break;
7072 }
7073 case 0x30:
7074 {
7075 InvalidInstruction(2);
7076 break;
7077 }
7078 case 0x31:
7079 {
7080 InvalidInstruction(2);
7081 break;
7082 }
7083 case 0x32:
7084 {
7085 InvalidInstruction(2);
7086 break;
7087 }
7088 case 0x33:
7089 {
7090 InvalidInstruction(2);
7091 break;
7092 }
7093 case 0x34:
7094 {
7095 sdwCyclesRemaining -= 23;
7096 sdwAddr = (INT8) *pbPC++; /* Get LSB first */
7097 dwAddr = (sdwAddr + (INT32) cpu.z80IX) & 0xffff;
7098 psMemRead = cpu.z80MemRead; /* Beginning of our handler */
7099 while (psMemRead->lowAddr != 0xffffffff)
7100 {
7101 if ((dwAddr >= psMemRead->lowAddr) && (dwAddr <= psMemRead->highAddr))
7102 {
7103 cpu.z80pc = (UINT32) pbPC - (UINT32) cpu.z80Base;
7104 if (psMemRead->memoryCall)
7105 {
7106 bTemp = psMemRead->memoryCall(dwAddr, psMemRead);
7107 }
7108 else
7109 {
7110 bTemp = *((UINT8 *) psMemRead->pUserArea + (dwAddr - psMemRead->lowAddr));
7111 }
7112 psMemRead = NULL;
7113 break;
7114 }
7115 ++psMemRead;
7116 }
7117
7118 if (psMemRead)
7119 {
7120 bTemp = cpu.z80Base[dwAddr];
7121 }
7122
7123 cpu.z80F &= ~(Z80_FLAG_SIGN | Z80_FLAG_ZERO | Z80_FLAG_HALF_CARRY | Z80_FLAG_OVERFLOW_PARITY | Z80_FLAG_NEGATIVE);
7124 cpu.z80F |= bPostIncFlags[bTemp++];
7125 psMemWrite = cpu.z80MemWrite; /* Beginning of our handler */
7126 while (psMemWrite->lowAddr != 0xffffffff)
7127 {
7128 if ((dwAddr >= psMemWrite->lowAddr) && (dwAddr <= psMemWrite->highAddr))
7129 {
7130 cpu.z80pc = (UINT32) pbPC - (UINT32) cpu.z80Base;
7131 if (psMemWrite->memoryCall)
7132 {
7133 psMemWrite->memoryCall(dwAddr, bTemp, psMemWrite);
7134 }
7135 else
7136 {
7137 *((UINT8 *) psMemWrite->pUserArea + (dwAddr - psMemWrite->lowAddr)) = bTemp;
7138 }
7139 psMemWrite = NULL;
7140 break;
7141 }
7142 ++psMemWrite;
7143 }
7144
7145 if (psMemWrite)
7146 {
7147 cpu.z80Base[dwAddr] = (UINT8) bTemp;
7148 }
7149
7150 break;
7151 }
7152 case 0x35:
7153 {
7154 sdwCyclesRemaining -= 23;
7155 sdwAddr = (INT8) *pbPC++; /* Get LSB first */
7156 dwAddr = (sdwAddr + (INT32) cpu.z80IX) & 0xffff;
7157 psMemRead = cpu.z80MemRead; /* Beginning of our handler */
7158 while (psMemRead->lowAddr != 0xffffffff)
7159 {
7160 if ((dwAddr >= psMemRead->lowAddr) && (dwAddr <= psMemRead->highAddr))
7161 {
7162 cpu.z80pc = (UINT32) pbPC - (UINT32) cpu.z80Base;
7163 if (psMemRead->memoryCall)
7164 {
7165 bTemp = psMemRead->memoryCall(dwAddr, psMemRead);
7166 }
7167 else
7168 {
7169 bTemp = *((UINT8 *) psMemRead->pUserArea + (dwAddr - psMemRead->lowAddr));
7170 }
7171 psMemRead = NULL;
7172 break;
7173 }
7174 ++psMemRead;
7175 }
7176
7177 if (psMemRead)
7178 {
7179 bTemp = cpu.z80Base[dwAddr];
7180 }
7181
7182 cpu.z80F &= ~(Z80_FLAG_SIGN | Z80_FLAG_ZERO | Z80_FLAG_HALF_CARRY | Z80_FLAG_OVERFLOW_PARITY | Z80_FLAG_NEGATIVE);
7183 cpu.z80F |= bPostDecFlags[bTemp--];
7184 psMemWrite = cpu.z80MemWrite; /* Beginning of our handler */
7185 while (psMemWrite->lowAddr != 0xffffffff)
7186 {
7187 if ((dwAddr >= psMemWrite->lowAddr) && (dwAddr <= psMemWrite->highAddr))
7188 {
7189 cpu.z80pc = (UINT32) pbPC - (UINT32) cpu.z80Base;
7190 if (psMemWrite->memoryCall)
7191 {
7192 psMemWrite->memoryCall(dwAddr, bTemp, psMemWrite);
7193 }
7194 else
7195 {
7196 *((UINT8 *) psMemWrite->pUserArea + (dwAddr - psMemWrite->lowAddr)) = bTemp;
7197 }
7198 psMemWrite = NULL;
7199 break;
7200 }
7201 ++psMemWrite;
7202 }
7203
7204 if (psMemWrite)
7205 {
7206 cpu.z80Base[dwAddr] = (UINT8) bTemp;
7207 }
7208
7209 break;
7210 }
7211 case 0x36:
7212 {
7213 sdwCyclesRemaining -= 19;
7214 sdwAddr = (INT8) *pbPC++; // Get the offset
7215 sdwAddr = ((INT32) cpu.z80IX + sdwAddr) & 0xffff;
7216 psMemWrite = cpu.z80MemWrite; /* Beginning of our handler */
7217 while (psMemWrite->lowAddr != 0xffffffff)
7218 {
7219 if ((sdwAddr >= psMemWrite->lowAddr) && (sdwAddr <= psMemWrite->highAddr))
7220 {
7221 cpu.z80pc = (UINT32) pbPC - (UINT32) cpu.z80Base;
7222 if (psMemWrite->memoryCall)
7223 {
7224 psMemWrite->memoryCall(sdwAddr, *pbPC++, psMemWrite);
7225 }
7226 else
7227 {
7228 *((UINT8 *) psMemWrite->pUserArea + (sdwAddr - psMemWrite->lowAddr)) = *pbPC++;
7229 }
7230 psMemWrite = NULL;
7231 break;
7232 }
7233 ++psMemWrite;
7234 }
7235
7236 if (psMemWrite)
7237 {
7238 cpu.z80Base[sdwAddr] = (UINT8) *pbPC++;
7239 }
7240
7241 break;
7242 }
7243 case 0x37:
7244 {
7245 InvalidInstruction(2);
7246 break;
7247 }
7248 case 0x38:
7249 {
7250 InvalidInstruction(2);
7251 break;
7252 }
7253 case 0x39:
7254 {
7255 sdwCyclesRemaining -= 15;
7256 cpu.z80F &= ~(Z80_FLAG_CARRY | Z80_FLAG_NEGATIVE | Z80_FLAG_HALF_CARRY);
7257 dwTemp = cpu.z80IX + cpu.z80sp;
7258 cpu.z80F |= ((dwTemp >> 16) & Z80_FLAG_CARRY) | (((cpu.z80IX ^ dwTemp ^ cpu.z80sp) >> 8) & Z80_FLAG_HALF_CARRY);
7259 cpu.z80IX = dwTemp & 0xffff;
7260 break;
7261 }
7262 case 0x3a:
7263 {
7264 InvalidInstruction(2);
7265 break;
7266 }
7267 case 0x3b:
7268 {
7269 InvalidInstruction(2);
7270 break;
7271 }
7272 case 0x3c:
7273 {
7274 InvalidInstruction(2);
7275 break;
7276 }
7277 case 0x3d:
7278 {
7279 InvalidInstruction(2);
7280 break;
7281 }
7282 case 0x3e:
7283 {
7284 InvalidInstruction(2);
7285 break;
7286 }
7287 case 0x3f:
7288 {
7289 InvalidInstruction(2);
7290 break;
7291 }
7292 case 0x40:
7293 {
7294 InvalidInstruction(2);
7295 break;
7296 }
7297 case 0x41:
7298 {
7299 InvalidInstruction(2);
7300 break;
7301 }
7302 case 0x42:
7303 {
7304 InvalidInstruction(2);
7305 break;
7306 }
7307 case 0x43:
7308 {
7309 InvalidInstruction(2);
7310 break;
7311 }
7312 case 0x44:
7313 {
7314 sdwCyclesRemaining -= 9;
7315 cpu.z80B = cpu.z80XH;
7316 break;
7317 }
7318 case 0x45:
7319 {
7320 sdwCyclesRemaining -= 9;
7321 cpu.z80B = cpu.z80XL;
7322 break;
7323 }
7324 case 0x46:
7325 {
7326 sdwCyclesRemaining -= 19;
7327 sdwAddr = (INT8) *pbPC++; // Get the offset
7328 sdwAddr = ((INT32) cpu.z80IX + sdwAddr) & 0xffff;
7329 psMemRead = cpu.z80MemRead; /* Beginning of our handler */
7330 while (psMemRead->lowAddr != 0xffffffff)
7331 {
7332 if ((sdwAddr >= psMemRead->lowAddr) && (sdwAddr <= psMemRead->highAddr))
7333 {
7334 cpu.z80pc = (UINT32) pbPC - (UINT32) cpu.z80Base;
7335 if (psMemRead->memoryCall)
7336 {
7337 cpu.z80B = psMemRead->memoryCall(sdwAddr, psMemRead);
7338 }
7339 else
7340 {
7341 cpu.z80B = *((UINT8 *) psMemRead->pUserArea + (sdwAddr - psMemRead->lowAddr));
7342 }
7343 psMemRead = NULL;
7344 break;
7345 }
7346 ++psMemRead;
7347 }
7348
7349 if (psMemRead)
7350 {
7351 cpu.z80B = cpu.z80Base[sdwAddr];
7352 }
7353
7354 break;
7355 }
7356 case 0x47:
7357 {
7358 InvalidInstruction(2);
7359 break;
7360 }
7361 case 0x48:
7362 {
7363 InvalidInstruction(2);
7364 break;
7365 }
7366 case 0x49:
7367 {
7368 InvalidInstruction(2);
7369 break;
7370 }
7371 case 0x4a:
7372 {
7373 InvalidInstruction(2);
7374 break;
7375 }
7376 case 0x4b:
7377 {
7378 InvalidInstruction(2);
7379 break;
7380 }
7381 case 0x4c:
7382 {
7383 sdwCyclesRemaining -= 9;
7384 cpu.z80C = cpu.z80XH;
7385 break;
7386 }
7387 case 0x4d:
7388 {
7389 sdwCyclesRemaining -= 9;
7390 cpu.z80C = cpu.z80XL;
7391 break;
7392 }
7393 case 0x4e:
7394 {
7395 sdwCyclesRemaining -= 19;
7396 sdwAddr = (INT8) *pbPC++; // Get the offset
7397 sdwAddr = ((INT32) cpu.z80IX + sdwAddr) & 0xffff;
7398 psMemRead = cpu.z80MemRead; /* Beginning of our handler */
7399 while (psMemRead->lowAddr != 0xffffffff)
7400 {
7401 if ((sdwAddr >= psMemRead->lowAddr) && (sdwAddr <= psMemRead->highAddr))
7402 {
7403 cpu.z80pc = (UINT32) pbPC - (UINT32) cpu.z80Base;
7404 if (psMemRead->memoryCall)
7405 {
7406 cpu.z80C = psMemRead->memoryCall(sdwAddr, psMemRead);
7407 }
7408 else
7409 {
7410 cpu.z80C = *((UINT8 *) psMemRead->pUserArea + (sdwAddr - psMemRead->lowAddr));
7411 }
7412 psMemRead = NULL;
7413 break;
7414 }
7415 ++psMemRead;
7416 }
7417
7418 if (psMemRead)
7419 {
7420 cpu.z80C = cpu.z80Base[sdwAddr];
7421 }
7422
7423 break;
7424 }
7425 case 0x4f:
7426 {
7427 InvalidInstruction(2);
7428 break;
7429 }
7430 case 0x50:
7431 {
7432 InvalidInstruction(2);
7433 break;
7434 }
7435 case 0x51:
7436 {
7437 InvalidInstruction(2);
7438 break;
7439 }
7440 case 0x52:
7441 {
7442 InvalidInstruction(2);
7443 break;
7444 }
7445 case 0x53:
7446 {
7447 InvalidInstruction(2);
7448 break;
7449 }
7450 case 0x54:
7451 {
7452 sdwCyclesRemaining -= 9;
7453 cpu.z80D = cpu.z80XH;
7454 break;
7455 }
7456 case 0x55:
7457 {
7458 sdwCyclesRemaining -= 9;
7459 cpu.z80D = cpu.z80XL;
7460 break;
7461 }
7462 case 0x56:
7463 {
7464 sdwCyclesRemaining -= 19;
7465 sdwAddr = (INT8) *pbPC++; // Get the offset
7466 sdwAddr = ((INT32) cpu.z80IX + sdwAddr) & 0xffff;
7467 psMemRead = cpu.z80MemRead; /* Beginning of our handler */
7468 while (psMemRead->lowAddr != 0xffffffff)
7469 {
7470 if ((sdwAddr >= psMemRead->lowAddr) && (sdwAddr <= psMemRead->highAddr))
7471 {
7472 cpu.z80pc = (UINT32) pbPC - (UINT32) cpu.z80Base;
7473 if (psMemRead->memoryCall)
7474 {
7475 cpu.z80D = psMemRead->memoryCall(sdwAddr, psMemRead);
7476 }
7477 else
7478 {
7479 cpu.z80D = *((UINT8 *) psMemRead->pUserArea + (sdwAddr - psMemRead->lowAddr));
7480 }
7481 psMemRead = NULL;
7482 break;
7483 }
7484 ++psMemRead;
7485 }
7486
7487 if (psMemRead)
7488 {
7489 cpu.z80D = cpu.z80Base[sdwAddr];
7490 }
7491
7492 break;
7493 }
7494 case 0x57:
7495 {
7496 InvalidInstruction(2);
7497 break;
7498 }
7499 case 0x58:
7500 {
7501 InvalidInstruction(2);
7502 break;
7503 }
7504 case 0x59:
7505 {
7506 InvalidInstruction(2);
7507 break;
7508 }
7509 case 0x5a:
7510 {
7511 InvalidInstruction(2);
7512 break;
7513 }
7514 case 0x5b:
7515 {
7516 InvalidInstruction(2);
7517 break;
7518 }
7519 case 0x5c:
7520 {
7521 sdwCyclesRemaining -= 9;
7522 cpu.z80E = cpu.z80XH;
7523 break;
7524 }
7525 case 0x5d:
7526 {
7527 sdwCyclesRemaining -= 9;
7528 cpu.z80E = cpu.z80XL;
7529 break;
7530 }
7531 case 0x5e:
7532 {
7533 sdwCyclesRemaining -= 19;
7534 sdwAddr = (INT8) *pbPC++; // Get the offset
7535 sdwAddr = ((INT32) cpu.z80IX + sdwAddr) & 0xffff;
7536 psMemRead = cpu.z80MemRead; /* Beginning of our handler */
7537 while (psMemRead->lowAddr != 0xffffffff)
7538 {
7539 if ((sdwAddr >= psMemRead->lowAddr) && (sdwAddr <= psMemRead->highAddr))
7540 {
7541 cpu.z80pc = (UINT32) pbPC - (UINT32) cpu.z80Base;
7542 if (psMemRead->memoryCall)
7543 {
7544 cpu.z80E = psMemRead->memoryCall(sdwAddr, psMemRead);
7545 }
7546 else
7547 {
7548 cpu.z80E = *((UINT8 *) psMemRead->pUserArea + (sdwAddr - psMemRead->lowAddr));
7549 }
7550 psMemRead = NULL;
7551 break;
7552 }
7553 ++psMemRead;
7554 }
7555
7556 if (psMemRead)
7557 {
7558 cpu.z80E = cpu.z80Base[sdwAddr];
7559 }
7560
7561 break;
7562 }
7563 case 0x5f:
7564 {
7565 InvalidInstruction(2);
7566 break;
7567 }
7568 case 0x60:
7569 {
7570 sdwCyclesRemaining -= 9;
7571 cpu.z80XH = cpu.z80B;
7572 break;
7573 }
7574 case 0x61:
7575 {
7576 sdwCyclesRemaining -= 9;
7577 cpu.z80XH = cpu.z80C;
7578 break;
7579 }
7580 case 0x62:
7581 {
7582 sdwCyclesRemaining -= 9;
7583 cpu.z80XH = cpu.z80D;
7584 break;
7585 }
7586 case 0x63:
7587 {
7588 sdwCyclesRemaining -= 9;
7589 cpu.z80XH = cpu.z80E;
7590 break;
7591 }
7592 case 0x64:
7593 {
7594 sdwCyclesRemaining -= 9;
7595 break;
7596 }
7597 case 0x65:
7598 {
7599 sdwCyclesRemaining -= 9;
7600 cpu.z80XH = cpu.z80XL;
7601 break;
7602 }
7603 case 0x66:
7604 {
7605 sdwCyclesRemaining -= 19;
7606 sdwAddr = (INT8) *pbPC++; // Get the offset
7607 sdwAddr = ((INT32) cpu.z80IX + sdwAddr) & 0xffff;
7608 psMemRead = cpu.z80MemRead; /* Beginning of our handler */
7609 while (psMemRead->lowAddr != 0xffffffff)
7610 {
7611 if ((sdwAddr >= psMemRead->lowAddr) && (sdwAddr <= psMemRead->highAddr))
7612 {
7613 cpu.z80pc = (UINT32) pbPC - (UINT32) cpu.z80Base;
7614 if (psMemRead->memoryCall)
7615 {
7616 cpu.z80H = psMemRead->memoryCall(sdwAddr, psMemRead);
7617 }
7618 else
7619 {
7620 cpu.z80H = *((UINT8 *) psMemRead->pUserArea + (sdwAddr - psMemRead->lowAddr));
7621 }
7622 psMemRead = NULL;
7623 break;
7624 }
7625 ++psMemRead;
7626 }
7627
7628 if (psMemRead)
7629 {
7630 cpu.z80H = cpu.z80Base[sdwAddr];
7631 }
7632
7633 break;
7634 }
7635 case 0x67:
7636 {
7637 sdwCyclesRemaining -= 9;
7638 cpu.z80XH = cpu.z80A;
7639 break;
7640 }
7641 case 0x68:
7642 {
7643 sdwCyclesRemaining -= 9;
7644 cpu.z80XL = cpu.z80B;
7645 break;
7646 }
7647 case 0x69:
7648 {
7649 sdwCyclesRemaining -= 9;
7650 cpu.z80XL = cpu.z80C;
7651 break;
7652 }
7653 case 0x6a:
7654 {
7655 sdwCyclesRemaining -= 9;
7656 cpu.z80XL = cpu.z80D;
7657 break;
7658 }
7659 case 0x6b:
7660 {
7661 sdwCyclesRemaining -= 9;
7662 cpu.z80XL = cpu.z80E;
7663 break;
7664 }
7665 case 0x6c:
7666 {
7667 sdwCyclesRemaining -= 9;
7668 cpu.z80XL = cpu.z80XH;
7669 break;
7670 }
7671 case 0x6d:
7672 {
7673 sdwCyclesRemaining -= 9;
7674 break;
7675 }
7676 case 0x6e:
7677 {
7678 sdwCyclesRemaining -= 19;
7679 sdwAddr = (INT8) *pbPC++; // Get the offset
7680 sdwAddr = ((INT32) cpu.z80IX + sdwAddr) & 0xffff;
7681 psMemRead = cpu.z80MemRead; /* Beginning of our handler */
7682 while (psMemRead->lowAddr != 0xffffffff)
7683 {
7684 if ((sdwAddr >= psMemRead->lowAddr) && (sdwAddr <= psMemRead->highAddr))
7685 {
7686 cpu.z80pc = (UINT32) pbPC - (UINT32) cpu.z80Base;
7687 if (psMemRead->memoryCall)
7688 {
7689 cpu.z80L = psMemRead->memoryCall(sdwAddr, psMemRead);
7690 }
7691 else
7692 {
7693 cpu.z80L = *((UINT8 *) psMemRead->pUserArea + (sdwAddr - psMemRead->lowAddr));
7694 }
7695 psMemRead = NULL;
7696 break;
7697 }
7698 ++psMemRead;
7699 }
7700
7701 if (psMemRead)
7702 {
7703 cpu.z80L = cpu.z80Base[sdwAddr];
7704 }
7705
7706 break;
7707 }
7708 case 0x6f:
7709 {
7710 sdwCyclesRemaining -= 9;
7711 cpu.z80XL = cpu.z80A;
7712 break;
7713 }
7714 case 0x70:
7715 {
7716 sdwCyclesRemaining -= 19;
7717 sdwAddr = (INT8) *pbPC++; // Get the offset
7718 sdwAddr = ((INT32) cpu.z80IX + sdwAddr) & 0xffff;
7719 psMemWrite = cpu.z80MemWrite; /* Beginning of our handler */
7720 while (psMemWrite->lowAddr != 0xffffffff)
7721 {
7722 if ((sdwAddr >= psMemWrite->lowAddr) && (sdwAddr <= psMemWrite->highAddr))
7723 {
7724 cpu.z80pc = (UINT32) pbPC - (UINT32) cpu.z80Base;
7725 if (psMemWrite->memoryCall)
7726 {
7727 psMemWrite->memoryCall(sdwAddr, cpu.z80B, psMemWrite);
7728 }
7729 else
7730 {
7731 *((UINT8 *) psMemWrite->pUserArea + (sdwAddr - psMemWrite->lowAddr)) = cpu.z80B;
7732 }
7733 psMemWrite = NULL;
7734 break;
7735 }
7736 ++psMemWrite;
7737 }
7738
7739 if (psMemWrite)
7740 {
7741 cpu.z80Base[sdwAddr] = (UINT8) cpu.z80B;
7742 }
7743
7744 break;
7745 }
7746 case 0x71:
7747 {
7748 sdwCyclesRemaining -= 19;
7749 sdwAddr = (INT8) *pbPC++; // Get the offset
7750 sdwAddr = ((INT32) cpu.z80IX + sdwAddr) & 0xffff;
7751 psMemWrite = cpu.z80MemWrite; /* Beginning of our handler */
7752 while (psMemWrite->lowAddr != 0xffffffff)
7753 {
7754 if ((sdwAddr >= psMemWrite->lowAddr) && (sdwAddr <= psMemWrite->highAddr))
7755 {
7756 cpu.z80pc = (UINT32) pbPC - (UINT32) cpu.z80Base;
7757 if (psMemWrite->memoryCall)
7758 {
7759 psMemWrite->memoryCall(sdwAddr, cpu.z80C, psMemWrite);
7760 }
7761 else
7762 {
7763 *((UINT8 *) psMemWrite->pUserArea + (sdwAddr - psMemWrite->lowAddr)) = cpu.z80C;
7764 }
7765 psMemWrite = NULL;
7766 break;
7767 }
7768 ++psMemWrite;
7769 }
7770
7771 if (psMemWrite)
7772 {
7773 cpu.z80Base[sdwAddr] = (UINT8) cpu.z80C;
7774 }
7775
7776 break;
7777 }
7778 case 0x72:
7779 {
7780 sdwCyclesRemaining -= 19;
7781 sdwAddr = (INT8) *pbPC++; // Get the offset
7782 sdwAddr = ((INT32) cpu.z80IX + sdwAddr) & 0xffff;
7783 psMemWrite = cpu.z80MemWrite; /* Beginning of our handler */
7784 while (psMemWrite->lowAddr != 0xffffffff)
7785 {
7786 if ((sdwAddr >= psMemWrite->lowAddr) && (sdwAddr <= psMemWrite->highAddr))
7787 {
7788 cpu.z80pc = (UINT32) pbPC - (UINT32) cpu.z80Base;
7789 if (psMemWrite->memoryCall)
7790 {
7791 psMemWrite->memoryCall(sdwAddr, cpu.z80D, psMemWrite);
7792 }
7793 else
7794 {
7795 *((UINT8 *) psMemWrite->pUserArea + (sdwAddr - psMemWrite->lowAddr)) = cpu.z80D;
7796 }
7797 psMemWrite = NULL;
7798 break;
7799 }
7800 ++psMemWrite;
7801 }
7802
7803 if (psMemWrite)
7804 {
7805 cpu.z80Base[sdwAddr] = (UINT8) cpu.z80D;
7806 }
7807
7808 break;
7809 }
7810 case 0x73:
7811 {
7812 sdwCyclesRemaining -= 19;
7813 sdwAddr = (INT8) *pbPC++; // Get the offset
7814 sdwAddr = ((INT32) cpu.z80IX + sdwAddr) & 0xffff;
7815 psMemWrite = cpu.z80MemWrite; /* Beginning of our handler */
7816 while (psMemWrite->lowAddr != 0xffffffff)
7817 {
7818 if ((sdwAddr >= psMemWrite->lowAddr) && (sdwAddr <= psMemWrite->highAddr))
7819 {
7820 cpu.z80pc = (UINT32) pbPC - (UINT32) cpu.z80Base;
7821 if (psMemWrite->memoryCall)
7822 {
7823 psMemWrite->memoryCall(sdwAddr, cpu.z80E, psMemWrite);
7824 }
7825 else
7826 {
7827 *((UINT8 *) psMemWrite->pUserArea + (sdwAddr - psMemWrite->lowAddr)) = cpu.z80E;
7828 }
7829 psMemWrite = NULL;
7830 break;
7831 }
7832 ++psMemWrite;
7833 }
7834
7835 if (psMemWrite)
7836 {
7837 cpu.z80Base[sdwAddr] = (UINT8) cpu.z80E;
7838 }
7839
7840 break;
7841 }
7842 case 0x74:
7843 {
7844 sdwCyclesRemaining -= 19;
7845 sdwAddr = (INT8) *pbPC++; // Get the offset
7846 sdwAddr = ((INT32) cpu.z80IX + sdwAddr) & 0xffff;
7847 psMemWrite = cpu.z80MemWrite; /* Beginning of our handler */
7848 while (psMemWrite->lowAddr != 0xffffffff)
7849 {
7850 if ((sdwAddr >= psMemWrite->lowAddr) && (sdwAddr <= psMemWrite->highAddr))
7851 {
7852 cpu.z80pc = (UINT32) pbPC - (UINT32) cpu.z80Base;
7853 if (psMemWrite->memoryCall)
7854 {
7855 psMemWrite->memoryCall(sdwAddr, cpu.z80H, psMemWrite);
7856 }
7857 else
7858 {
7859 *((UINT8 *) psMemWrite->pUserArea + (sdwAddr - psMemWrite->lowAddr)) = cpu.z80H;
7860 }
7861 psMemWrite = NULL;
7862 break;
7863 }
7864 ++psMemWrite;
7865 }
7866
7867 if (psMemWrite)
7868 {
7869 cpu.z80Base[sdwAddr] = (UINT8) cpu.z80H;
7870 }
7871
7872 break;
7873 }
7874 case 0x75:
7875 {
7876 sdwCyclesRemaining -= 19;
7877 sdwAddr = (INT8) *pbPC++; // Get the offset
7878 sdwAddr = ((INT32) cpu.z80IX + sdwAddr) & 0xffff;
7879 psMemWrite = cpu.z80MemWrite; /* Beginning of our handler */
7880 while (psMemWrite->lowAddr != 0xffffffff)
7881 {
7882 if ((sdwAddr >= psMemWrite->lowAddr) && (sdwAddr <= psMemWrite->highAddr))
7883 {
7884 cpu.z80pc = (UINT32) pbPC - (UINT32) cpu.z80Base;
7885 if (psMemWrite->memoryCall)
7886 {
7887 psMemWrite->memoryCall(sdwAddr, cpu.z80L, psMemWrite);
7888 }
7889 else
7890 {
7891 *((UINT8 *) psMemWrite->pUserArea + (sdwAddr - psMemWrite->lowAddr)) = cpu.z80L;
7892 }
7893 psMemWrite = NULL;
7894 break;
7895 }
7896 ++psMemWrite;
7897 }
7898
7899 if (psMemWrite)
7900 {
7901 cpu.z80Base[sdwAddr] = (UINT8) cpu.z80L;
7902 }
7903
7904 break;
7905 }
7906 case 0x76:
7907 {
7908 sdwCyclesRemaining -= 19;
7909 InvalidInstruction(2);
7910 break;
7911 }
7912 case 0x77:
7913 {
7914 sdwCyclesRemaining -= 19;
7915 sdwAddr = (INT8) *pbPC++; // Get the offset
7916 sdwAddr = ((INT32) cpu.z80IX + sdwAddr) & 0xffff;
7917 psMemWrite = cpu.z80MemWrite; /* Beginning of our handler */
7918 while (psMemWrite->lowAddr != 0xffffffff)
7919 {
7920 if ((sdwAddr >= psMemWrite->lowAddr) && (sdwAddr <= psMemWrite->highAddr))
7921 {
7922 cpu.z80pc = (UINT32) pbPC - (UINT32) cpu.z80Base;
7923 if (psMemWrite->memoryCall)
7924 {
7925 psMemWrite->memoryCall(sdwAddr, cpu.z80A, psMemWrite);
7926 }
7927 else
7928 {
7929 *((UINT8 *) psMemWrite->pUserArea + (sdwAddr - psMemWrite->lowAddr)) = cpu.z80A;
7930 }
7931 psMemWrite = NULL;
7932 break;
7933 }
7934 ++psMemWrite;
7935 }
7936
7937 if (psMemWrite)
7938 {
7939 cpu.z80Base[sdwAddr] = (UINT8) cpu.z80A;
7940 }
7941
7942 break;
7943 }
7944 case 0x78:
7945 {
7946 InvalidInstruction(2);
7947 break;
7948 }
7949 case 0x79:
7950 {
7951 InvalidInstruction(2);
7952 break;
7953 }
7954 case 0x7a:
7955 {
7956 InvalidInstruction(2);
7957 break;
7958 }
7959 case 0x7b:
7960 {
7961 InvalidInstruction(2);
7962 break;
7963 }
7964 case 0x7c:
7965 {
7966 sdwCyclesRemaining -= 9;
7967 cpu.z80A = cpu.z80XH;
7968 break;
7969 }
7970 case 0x7d:
7971 {
7972 sdwCyclesRemaining -= 9;
7973 cpu.z80A = cpu.z80XL;
7974 break;
7975 }
7976 case 0x7e:
7977 {
7978 sdwCyclesRemaining -= 19;
7979 sdwAddr = (INT8) *pbPC++; // Get the offset
7980 sdwAddr = ((INT32) cpu.z80IX + sdwAddr) & 0xffff;
7981 psMemRead = cpu.z80MemRead; /* Beginning of our handler */
7982 while (psMemRead->lowAddr != 0xffffffff)
7983 {
7984 if ((sdwAddr >= psMemRead->lowAddr) && (sdwAddr <= psMemRead->highAddr))
7985 {
7986 cpu.z80pc = (UINT32) pbPC - (UINT32) cpu.z80Base;
7987 if (psMemRead->memoryCall)
7988 {
7989 cpu.z80A = psMemRead->memoryCall(sdwAddr, psMemRead);
7990 }
7991 else
7992 {
7993 cpu.z80A = *((UINT8 *) psMemRead->pUserArea + (sdwAddr - psMemRead->lowAddr));
7994 }
7995 psMemRead = NULL;
7996 break;
7997 }
7998 ++psMemRead;
7999 }
8000
8001 if (psMemRead)
8002 {
8003 cpu.z80A = cpu.z80Base[sdwAddr];
8004 }
8005
8006 break;
8007 }
8008 case 0x7f:
8009 {
8010 InvalidInstruction(2);
8011 break;
8012 }
8013 case 0x80:
8014 {
8015 InvalidInstruction(2);
8016 break;
8017 }
8018 case 0x81:
8019 {
8020 InvalidInstruction(2);
8021 break;
8022 }
8023 case 0x82:
8024 {
8025 InvalidInstruction(2);
8026 break;
8027 }
8028 case 0x83:
8029 {
8030 InvalidInstruction(2);
8031 break;
8032 }
8033 case 0x84:
8034 {
8035 sdwCyclesRemaining -= 9;
8036 bTemp2 = cpu.z80A + cpu.z80XH;
8037 cpu.z80F = (cpu.z80F & ~(Z80_FLAG_CARRY | Z80_FLAG_NEGATIVE | Z80_FLAG_OVERFLOW_PARITY |
8038 Z80_FLAG_HALF_CARRY | Z80_FLAG_ZERO | Z80_FLAG_SIGN)) |
8039 pbAddAdcTable[((UINT32) cpu.z80A << 8) | cpu.z80XH];
8040 InvalidInstruction(2);
8041 break;
8042 }
8043 case 0x85:
8044 {
8045 sdwCyclesRemaining -= 9;
8046 bTemp2 = cpu.z80A + cpu.z80XL;
8047 cpu.z80F = (cpu.z80F & ~(Z80_FLAG_CARRY | Z80_FLAG_NEGATIVE | Z80_FLAG_OVERFLOW_PARITY |
8048 Z80_FLAG_HALF_CARRY | Z80_FLAG_ZERO | Z80_FLAG_SIGN)) |
8049 pbAddAdcTable[((UINT32) cpu.z80A << 8) | cpu.z80XL];
8050 InvalidInstruction(2);
8051 break;
8052 }
8053 case 0x86:
8054 {
8055 sdwCyclesRemaining -= 19;
8056 sdwAddr = (INT8) *pbPC++; /* Get LSB first */
8057 dwAddr = (sdwAddr + (INT32) cpu.z80IX) & 0xffff;
8058 psMemRead = cpu.z80MemRead; /* Beginning of our handler */
8059 while (psMemRead->lowAddr != 0xffffffff)
8060 {
8061 if ((dwAddr >= psMemRead->lowAddr) && (dwAddr <= psMemRead->highAddr))
8062 {
8063 cpu.z80pc = (UINT32) pbPC - (UINT32) cpu.z80Base;
8064 if (psMemRead->memoryCall)
8065 {
8066 bTemp = psMemRead->memoryCall(dwAddr, psMemRead);
8067 }
8068 else
8069 {
8070 bTemp = *((UINT8 *) psMemRead->pUserArea + (dwAddr - psMemRead->lowAddr));
8071 }
8072 psMemRead = NULL;
8073 break;
8074 }
8075 ++psMemRead;
8076 }
8077
8078 if (psMemRead)
8079 {
8080 bTemp = cpu.z80Base[dwAddr];
8081 }
8082
8083 cpu.z80F = (cpu.z80F & ~(Z80_FLAG_CARRY | Z80_FLAG_NEGATIVE | Z80_FLAG_OVERFLOW_PARITY |
8084 Z80_FLAG_HALF_CARRY | Z80_FLAG_ZERO | Z80_FLAG_SIGN)) |
8085 pbAddAdcTable[((UINT32) cpu.z80A << 8) | bTemp];
8086 cpu.z80A += bTemp;
8087 break;
8088 }
8089 case 0x87:
8090 {
8091 InvalidInstruction(2);
8092 break;
8093 }
8094 case 0x88:
8095 {
8096 InvalidInstruction(2);
8097 break;
8098 }
8099 case 0x89:
8100 {
8101 InvalidInstruction(2);
8102 break;
8103 }
8104 case 0x8a:
8105 {
8106 InvalidInstruction(2);
8107 break;
8108 }
8109 case 0x8b:
8110 {
8111 InvalidInstruction(2);
8112 break;
8113 }
8114 case 0x8c:
8115 {
8116 sdwCyclesRemaining -= 9;
8117 bTemp2 = cpu.z80A + cpu.z80XH + (cpu.z80F & Z80_FLAG_CARRY);
8118 cpu.z80F = (cpu.z80F & ~(Z80_FLAG_CARRY | Z80_FLAG_NEGATIVE | Z80_FLAG_OVERFLOW_PARITY |
8119 Z80_FLAG_HALF_CARRY | Z80_FLAG_ZERO | Z80_FLAG_SIGN)) |
8120 pbAddAdcTable[((UINT32) cpu.z80A << 8) | cpu.z80XH | (((UINT32) cpu.z80F & Z80_FLAG_CARRY) << 16)];
8121 InvalidInstruction(2);
8122 break;
8123 }
8124 case 0x8d:
8125 {
8126 sdwCyclesRemaining -= 9;
8127 bTemp2 = cpu.z80A + cpu.z80XL + (cpu.z80F & Z80_FLAG_CARRY);
8128 cpu.z80F = (cpu.z80F & ~(Z80_FLAG_CARRY | Z80_FLAG_NEGATIVE | Z80_FLAG_OVERFLOW_PARITY |
8129 Z80_FLAG_HALF_CARRY | Z80_FLAG_ZERO | Z80_FLAG_SIGN)) |
8130 pbAddAdcTable[((UINT32) cpu.z80A << 8) | cpu.z80XL | (((UINT32) cpu.z80F & Z80_FLAG_CARRY) << 16)];
8131 InvalidInstruction(2);
8132 break;
8133 }
8134 case 0x8e:
8135 {
8136 sdwCyclesRemaining -= 19;
8137 sdwAddr = (INT8) *pbPC++; /* Get LSB first */
8138 dwAddr = (sdwAddr + (INT32) cpu.z80IX) & 0xffff;
8139 psMemRead = cpu.z80MemRead; /* Beginning of our handler */
8140 while (psMemRead->lowAddr != 0xffffffff)
8141 {
8142 if ((dwAddr >= psMemRead->lowAddr) && (dwAddr <= psMemRead->highAddr))
8143 {
8144 cpu.z80pc = (UINT32) pbPC - (UINT32) cpu.z80Base;
8145 if (psMemRead->memoryCall)
8146 {
8147 bTemp = psMemRead->memoryCall(dwAddr, psMemRead);
8148 }
8149 else
8150 {
8151 bTemp = *((UINT8 *) psMemRead->pUserArea + (dwAddr - psMemRead->lowAddr));
8152 }
8153 psMemRead = NULL;
8154 break;
8155 }
8156 ++psMemRead;
8157 }
8158
8159 if (psMemRead)
8160 {
8161 bTemp = cpu.z80Base[dwAddr];
8162 }
8163
8164 bTemp2 = (cpu.z80F & Z80_FLAG_CARRY);
8165 cpu.z80F = (cpu.z80F & ~(Z80_FLAG_CARRY | Z80_FLAG_NEGATIVE | Z80_FLAG_OVERFLOW_PARITY |
8166 Z80_FLAG_HALF_CARRY | Z80_FLAG_ZERO | Z80_FLAG_SIGN)) |
8167 pbAddAdcTable[((UINT32) cpu.z80A << 8) | bTemp | (((UINT32) cpu.z80F & Z80_FLAG_CARRY) << 16)];
8168 cpu.z80A += bTemp + bTemp2;
8169 break;
8170 }
8171 case 0x8f:
8172 {
8173 InvalidInstruction(2);
8174 break;
8175 }
8176 case 0x90:
8177 {
8178 InvalidInstruction(2);
8179 break;
8180 }
8181 case 0x91:
8182 {
8183 InvalidInstruction(2);
8184 break;
8185 }
8186 case 0x92:
8187 {
8188 InvalidInstruction(2);
8189 break;
8190 }
8191 case 0x93:
8192 {
8193 InvalidInstruction(2);
8194 break;
8195 }
8196 case 0x94:
8197 {
8198 sdwCyclesRemaining -= 9;
8199 bTemp2 = cpu.z80A - cpu.z80XH;
8200 cpu.z80F = (cpu.z80F & ~(Z80_FLAG_CARRY | Z80_FLAG_NEGATIVE | Z80_FLAG_OVERFLOW_PARITY |
8201 Z80_FLAG_HALF_CARRY | Z80_FLAG_ZERO | Z80_FLAG_SIGN)) |
8202 pbSubSbcTable[((UINT32) cpu.z80A << 8) | cpu.z80XH];
8203 InvalidInstruction(2);
8204 break;
8205 }
8206 case 0x95:
8207 {
8208 sdwCyclesRemaining -= 9;
8209 bTemp2 = cpu.z80A - cpu.z80XL;
8210 cpu.z80F = (cpu.z80F & ~(Z80_FLAG_CARRY | Z80_FLAG_NEGATIVE | Z80_FLAG_OVERFLOW_PARITY |
8211 Z80_FLAG_HALF_CARRY | Z80_FLAG_ZERO | Z80_FLAG_SIGN)) |
8212 pbSubSbcTable[((UINT32) cpu.z80A << 8) | cpu.z80XL];
8213 InvalidInstruction(2);
8214 break;
8215 }
8216 case 0x96:
8217 {
8218 sdwCyclesRemaining -= 19;
8219 sdwAddr = (INT8) *pbPC++; /* Get LSB first */
8220 dwAddr = (sdwAddr + (INT32) cpu.z80IX) & 0xffff;
8221 psMemRead = cpu.z80MemRead; /* Beginning of our handler */
8222 while (psMemRead->lowAddr != 0xffffffff)
8223 {
8224 if ((dwAddr >= psMemRead->lowAddr) && (dwAddr <= psMemRead->highAddr))
8225 {
8226 cpu.z80pc = (UINT32) pbPC - (UINT32) cpu.z80Base;
8227 if (psMemRead->memoryCall)
8228 {
8229 bTemp = psMemRead->memoryCall(dwAddr, psMemRead);
8230 }
8231 else
8232 {
8233 bTemp = *((UINT8 *) psMemRead->pUserArea + (dwAddr - psMemRead->lowAddr));
8234 }
8235 psMemRead = NULL;
8236 break;
8237 }
8238 ++psMemRead;
8239 }
8240
8241 if (psMemRead)
8242 {
8243 bTemp = cpu.z80Base[dwAddr];
8244 }
8245
8246 cpu.z80F = (cpu.z80F & ~(Z80_FLAG_CARRY | Z80_FLAG_NEGATIVE | Z80_FLAG_OVERFLOW_PARITY |
8247 Z80_FLAG_HALF_CARRY | Z80_FLAG_ZERO | Z80_FLAG_SIGN)) |
8248 pbSubSbcTable[((UINT32) cpu.z80A << 8) | bTemp];
8249 cpu.z80A -= bTemp;
8250 break;
8251 }
8252 case 0x97:
8253 {
8254 InvalidInstruction(2);
8255 break;
8256 }
8257 case 0x98:
8258 {
8259 InvalidInstruction(2);
8260 break;
8261 }
8262 case 0x99:
8263 {
8264 InvalidInstruction(2);
8265 break;
8266 }
8267 case 0x9a:
8268 {
8269 InvalidInstruction(2);
8270 break;
8271 }
8272 case 0x9b:
8273 {
8274 InvalidInstruction(2);
8275 break;
8276 }
8277 case 0x9c:
8278 {
8279 sdwCyclesRemaining -= 9;
8280 bTemp2 = cpu.z80A - cpu.z80XH - (cpu.z80F & Z80_FLAG_CARRY);
8281 cpu.z80F = (cpu.z80F & ~(Z80_FLAG_CARRY | Z80_FLAG_NEGATIVE | Z80_FLAG_OVERFLOW_PARITY |
8282 Z80_FLAG_HALF_CARRY | Z80_FLAG_ZERO | Z80_FLAG_SIGN)) |
8283 pbSubSbcTable[((UINT32) cpu.z80A << 8) | cpu.z80XH | (((UINT32) cpu.z80F & Z80_FLAG_CARRY) << 16)];
8284 InvalidInstruction(2);
8285 break;
8286 }
8287 case 0x9d:
8288 {
8289 sdwCyclesRemaining -= 9;
8290 bTemp2 = cpu.z80A - cpu.z80XL - (cpu.z80F & Z80_FLAG_CARRY);
8291 cpu.z80F = (cpu.z80F & ~(Z80_FLAG_CARRY | Z80_FLAG_NEGATIVE | Z80_FLAG_OVERFLOW_PARITY |
8292 Z80_FLAG_HALF_CARRY | Z80_FLAG_ZERO | Z80_FLAG_SIGN)) |
8293 pbSubSbcTable[((UINT32) cpu.z80A << 8) | cpu.z80XL | (((UINT32) cpu.z80F & Z80_FLAG_CARRY) << 16)];
8294 InvalidInstruction(2);
8295 break;
8296 }
8297 case 0x9e:
8298 {
8299 sdwCyclesRemaining -= 19;
8300 sdwAddr = (INT8) *pbPC++; /* Get LSB first */
8301 dwAddr = (sdwAddr + (INT32) cpu.z80IX) & 0xffff;
8302 psMemRead = cpu.z80MemRead; /* Beginning of our handler */
8303 while (psMemRead->lowAddr != 0xffffffff)
8304 {
8305 if ((dwAddr >= psMemRead->lowAddr) && (dwAddr <= psMemRead->highAddr))
8306 {
8307 cpu.z80pc = (UINT32) pbPC - (UINT32) cpu.z80Base;
8308 if (psMemRead->memoryCall)
8309 {
8310 bTemp = psMemRead->memoryCall(dwAddr, psMemRead);
8311 }
8312 else
8313 {
8314 bTemp = *((UINT8 *) psMemRead->pUserArea + (dwAddr - psMemRead->lowAddr));
8315 }
8316 psMemRead = NULL;
8317 break;
8318 }
8319 ++psMemRead;
8320 }
8321
8322 if (psMemRead)
8323 {
8324 bTemp = cpu.z80Base[dwAddr];
8325 }
8326
8327 bTemp2 = cpu.z80A;
8328 cpu.z80A = cpu.z80A - bTemp - (cpu.z80F & Z80_FLAG_CARRY);
8329 cpu.z80F = (cpu.z80F & ~(Z80_FLAG_CARRY | Z80_FLAG_NEGATIVE | Z80_FLAG_OVERFLOW_PARITY |
8330 Z80_FLAG_HALF_CARRY | Z80_FLAG_ZERO | Z80_FLAG_SIGN)) |
8331 pbSubSbcTable[((UINT32) bTemp2 << 8) | bTemp | (((UINT32) cpu.z80F & Z80_FLAG_CARRY) << 16)];
8332 break;
8333 }
8334 case 0x9f:
8335 {
8336 InvalidInstruction(2);
8337 break;
8338 }
8339 case 0xa0:
8340 {
8341 InvalidInstruction(2);
8342 break;
8343 }
8344 case 0xa1:
8345 {
8346 InvalidInstruction(2);
8347 break;
8348 }
8349 case 0xa2:
8350 {
8351 InvalidInstruction(2);
8352 break;
8353 }
8354 case 0xa3:
8355 {
8356 InvalidInstruction(2);
8357 break;
8358 }
8359 case 0xa4:
8360 {
8361 sdwCyclesRemaining -= 9;
8362 cpu.z80A &= cpu.z80XH;
8363 cpu.z80F &= ~(Z80_FLAG_CARRY | Z80_FLAG_NEGATIVE | Z80_FLAG_OVERFLOW_PARITY | Z80_FLAG_HALF_CARRY | Z80_FLAG_ZERO | Z80_FLAG_SIGN);
8364 cpu.z80F |= bPostANDFlags[cpu.z80A];
8365
8366 InvalidInstruction(2);
8367 break;
8368 }
8369 case 0xa5:
8370 {
8371 sdwCyclesRemaining -= 9;
8372 cpu.z80A &= cpu.z80XL;
8373 cpu.z80F &= ~(Z80_FLAG_CARRY | Z80_FLAG_NEGATIVE | Z80_FLAG_OVERFLOW_PARITY | Z80_FLAG_HALF_CARRY | Z80_FLAG_ZERO | Z80_FLAG_SIGN);
8374 cpu.z80F |= bPostANDFlags[cpu.z80A];
8375
8376 InvalidInstruction(2);
8377 break;
8378 }
8379 case 0xa6:
8380 {
8381 sdwCyclesRemaining -= 19;
8382 sdwAddr = (INT8) *pbPC++; /* Get LSB first */
8383 dwAddr = (sdwAddr + (INT32) cpu.z80IX) & 0xffff;
8384 psMemRead = cpu.z80MemRead; /* Beginning of our handler */
8385 while (psMemRead->lowAddr != 0xffffffff)
8386 {
8387 if ((dwAddr >= psMemRead->lowAddr) && (dwAddr <= psMemRead->highAddr))
8388 {
8389 cpu.z80pc = (UINT32) pbPC - (UINT32) cpu.z80Base;
8390 if (psMemRead->memoryCall)
8391 {
8392 bTemp = psMemRead->memoryCall(dwAddr, psMemRead);
8393 }
8394 else
8395 {
8396 bTemp = *((UINT8 *) psMemRead->pUserArea + (dwAddr - psMemRead->lowAddr));
8397 }
8398 psMemRead = NULL;
8399 break;
8400 }
8401 ++psMemRead;
8402 }
8403
8404 if (psMemRead)
8405 {
8406 bTemp = cpu.z80Base[dwAddr];
8407 }
8408
8409 cpu.z80A &= bTemp;
8410 cpu.z80F &= ~(Z80_FLAG_CARRY | Z80_FLAG_NEGATIVE | Z80_FLAG_OVERFLOW_PARITY | Z80_FLAG_HALF_CARRY | Z80_FLAG_ZERO | Z80_FLAG_SIGN);
8411 cpu.z80F |= bPostANDFlags[cpu.z80A];
8412
8413 break;
8414 }
8415 case 0xa7:
8416 {
8417 InvalidInstruction(2);
8418 break;
8419 }
8420 case 0xa8:
8421 {
8422 InvalidInstruction(2);
8423 break;
8424 }
8425 case 0xa9:
8426 {
8427 InvalidInstruction(2);
8428 break;
8429 }
8430 case 0xaa:
8431 {
8432 InvalidInstruction(2);
8433 break;
8434 }
8435 case 0xab:
8436 {
8437 InvalidInstruction(2);
8438 break;
8439 }
8440 case 0xac:
8441 {
8442 sdwCyclesRemaining -= 9;
8443 cpu.z80A ^= cpu.z80XH;
8444 cpu.z80F &= ~(Z80_FLAG_CARRY | Z80_FLAG_NEGATIVE | Z80_FLAG_OVERFLOW_PARITY | Z80_FLAG_HALF_CARRY | Z80_FLAG_ZERO | Z80_FLAG_SIGN);
8445 cpu.z80F |= bPostORFlags[cpu.z80A];
8446
8447 InvalidInstruction(2);
8448 break;
8449 }
8450 case 0xad:
8451 {
8452 sdwCyclesRemaining -= 9;
8453 cpu.z80A ^= cpu.z80XL;
8454 cpu.z80F &= ~(Z80_FLAG_CARRY | Z80_FLAG_NEGATIVE | Z80_FLAG_OVERFLOW_PARITY | Z80_FLAG_HALF_CARRY | Z80_FLAG_ZERO | Z80_FLAG_SIGN);
8455 cpu.z80F |= bPostORFlags[cpu.z80A];
8456
8457 InvalidInstruction(2);
8458 break;
8459 }
8460 case 0xae:
8461 {
8462 sdwCyclesRemaining -= 19;
8463 sdwAddr = (INT8) *pbPC++; /* Get LSB first */
8464 dwAddr = (sdwAddr + (INT32) cpu.z80IX) & 0xffff;
8465 psMemRead = cpu.z80MemRead; /* Beginning of our handler */
8466 while (psMemRead->lowAddr != 0xffffffff)
8467 {
8468 if ((dwAddr >= psMemRead->lowAddr) && (dwAddr <= psMemRead->highAddr))
8469 {
8470 cpu.z80pc = (UINT32) pbPC - (UINT32) cpu.z80Base;
8471 if (psMemRead->memoryCall)
8472 {
8473 bTemp = psMemRead->memoryCall(dwAddr, psMemRead);
8474 }
8475 else
8476 {
8477 bTemp = *((UINT8 *) psMemRead->pUserArea + (dwAddr - psMemRead->lowAddr));
8478 }
8479 psMemRead = NULL;
8480 break;
8481 }
8482 ++psMemRead;
8483 }
8484
8485 if (psMemRead)
8486 {
8487 bTemp = cpu.z80Base[dwAddr];
8488 }
8489
8490 cpu.z80A ^= bTemp;
8491 cpu.z80F &= ~(Z80_FLAG_CARRY | Z80_FLAG_NEGATIVE | Z80_FLAG_OVERFLOW_PARITY | Z80_FLAG_HALF_CARRY | Z80_FLAG_ZERO | Z80_FLAG_SIGN);
8492 cpu.z80F |= bPostORFlags[cpu.z80A];
8493
8494 break;
8495 }
8496 case 0xaf:
8497 {
8498 InvalidInstruction(2);
8499 break;
8500 }
8501 case 0xb0:
8502 {
8503 InvalidInstruction(2);
8504 break;
8505 }
8506 case 0xb1:
8507 {
8508 InvalidInstruction(2);
8509 break;
8510 }
8511 case 0xb2:
8512 {
8513 InvalidInstruction(2);
8514 break;
8515 }
8516 case 0xb3:
8517 {
8518 InvalidInstruction(2);
8519 break;
8520 }
8521 case 0xb4:
8522 {
8523 sdwCyclesRemaining -= 9;
8524 cpu.z80A |= cpu.z80XH;
8525 cpu.z80F &= ~(Z80_FLAG_CARRY | Z80_FLAG_NEGATIVE | Z80_FLAG_OVERFLOW_PARITY | Z80_FLAG_HALF_CARRY | Z80_FLAG_ZERO | Z80_FLAG_SIGN);
8526 cpu.z80F |= bPostORFlags[cpu.z80A];
8527
8528 InvalidInstruction(2);
8529 break;
8530 }
8531 case 0xb5:
8532 {
8533 sdwCyclesRemaining -= 9;
8534 cpu.z80A |= cpu.z80XL;
8535 cpu.z80F &= ~(Z80_FLAG_CARRY | Z80_FLAG_NEGATIVE | Z80_FLAG_OVERFLOW_PARITY | Z80_FLAG_HALF_CARRY | Z80_FLAG_ZERO | Z80_FLAG_SIGN);
8536 cpu.z80F |= bPostORFlags[cpu.z80A];
8537
8538 InvalidInstruction(2);
8539 break;
8540 }
8541 case 0xb6:
8542 {
8543 sdwCyclesRemaining -= 19;
8544 sdwAddr = (INT8) *pbPC++; /* Get LSB first */
8545 dwAddr = (sdwAddr + (INT32) cpu.z80IX) & 0xffff;
8546 psMemRead = cpu.z80MemRead; /* Beginning of our handler */
8547 while (psMemRead->lowAddr != 0xffffffff)
8548 {
8549 if ((dwAddr >= psMemRead->lowAddr) && (dwAddr <= psMemRead->highAddr))
8550 {
8551 cpu.z80pc = (UINT32) pbPC - (UINT32) cpu.z80Base;
8552 if (psMemRead->memoryCall)
8553 {
8554 bTemp = psMemRead->memoryCall(dwAddr, psMemRead);
8555 }
8556 else
8557 {
8558 bTemp = *((UINT8 *) psMemRead->pUserArea + (dwAddr - psMemRead->lowAddr));
8559 }
8560 psMemRead = NULL;
8561 break;
8562 }
8563 ++psMemRead;
8564 }
8565
8566 if (psMemRead)
8567 {
8568 bTemp = cpu.z80Base[dwAddr];
8569 }
8570
8571 cpu.z80A |= bTemp;
8572 cpu.z80F &= ~(Z80_FLAG_CARRY | Z80_FLAG_NEGATIVE | Z80_FLAG_OVERFLOW_PARITY | Z80_FLAG_HALF_CARRY | Z80_FLAG_ZERO | Z80_FLAG_SIGN);
8573 cpu.z80F |= bPostORFlags[cpu.z80A];
8574
8575 break;
8576 }
8577 case 0xb7:
8578 {
8579 InvalidInstruction(2);
8580 break;
8581 }
8582 case 0xb8:
8583 {
8584 InvalidInstruction(2);
8585 break;
8586 }
8587 case 0xb9:
8588 {
8589 InvalidInstruction(2);
8590 break;
8591 }
8592 case 0xba:
8593 {
8594 InvalidInstruction(2);
8595 break;
8596 }
8597 case 0xbb:
8598 {
8599 InvalidInstruction(2);
8600 break;
8601 }
8602 case 0xbc:
8603 {
8604 sdwCyclesRemaining -= 9;
8605 cpu.z80F &= ~(Z80_FLAG_CARRY | Z80_FLAG_NEGATIVE | Z80_FLAG_OVERFLOW_PARITY | Z80_FLAG_HALF_CARRY | Z80_FLAG_ZERO | Z80_FLAG_SIGN);
8606 cpu.z80F |= bPostORFlags[cpu.z80A];
8607
8608 InvalidInstruction(2);
8609 break;
8610 }
8611 case 0xbd:
8612 {
8613 sdwCyclesRemaining -= 9;
8614 cpu.z80F &= ~(Z80_FLAG_CARRY | Z80_FLAG_NEGATIVE | Z80_FLAG_OVERFLOW_PARITY | Z80_FLAG_HALF_CARRY | Z80_FLAG_ZERO | Z80_FLAG_SIGN);
8615 cpu.z80F |= bPostORFlags[cpu.z80A];
8616
8617 InvalidInstruction(2);
8618 break;
8619 }
8620 case 0xbe:
8621 {
8622 sdwCyclesRemaining -= 19;
8623 sdwAddr = (INT8) *pbPC++; /* Get LSB first */
8624 dwAddr = (sdwAddr + (INT32) cpu.z80IX) & 0xffff;
8625 psMemRead = cpu.z80MemRead; /* Beginning of our handler */
8626 while (psMemRead->lowAddr != 0xffffffff)
8627 {
8628 if ((dwAddr >= psMemRead->lowAddr) && (dwAddr <= psMemRead->highAddr))
8629 {
8630 cpu.z80pc = (UINT32) pbPC - (UINT32) cpu.z80Base;
8631 if (psMemRead->memoryCall)
8632 {
8633 bTemp = psMemRead->memoryCall(dwAddr, psMemRead);
8634 }
8635 else
8636 {
8637 bTemp = *((UINT8 *) psMemRead->pUserArea + (dwAddr - psMemRead->lowAddr));
8638 }
8639 psMemRead = NULL;
8640 break;
8641 }
8642 ++psMemRead;
8643 }
8644
8645 if (psMemRead)
8646 {
8647 bTemp = cpu.z80Base[dwAddr];
8648 }
8649
8650 cpu.z80F = (cpu.z80F & ~(Z80_FLAG_CARRY | Z80_FLAG_NEGATIVE | Z80_FLAG_OVERFLOW_PARITY |
8651 Z80_FLAG_HALF_CARRY | Z80_FLAG_ZERO | Z80_FLAG_SIGN)) |
8652 pbSubSbcTable[((UINT32) cpu.z80A << 8) | bTemp];
8653 break;
8654 }
8655 case 0xbf:
8656 {
8657 InvalidInstruction(2);
8658 break;
8659 }
8660 case 0xc0:
8661 {
8662 InvalidInstruction(2);
8663 break;
8664 }
8665 case 0xc1:
8666 {
8667 InvalidInstruction(2);
8668 break;
8669 }
8670 case 0xc2:
8671 {
8672 InvalidInstruction(2);
8673 break;
8674 }
8675 case 0xc3:
8676 {
8677 InvalidInstruction(2);
8678 break;
8679 }
8680 case 0xc4:
8681 {
8682 InvalidInstruction(2);
8683 break;
8684 }
8685 case 0xc5:
8686 {
8687 InvalidInstruction(2);
8688 break;
8689 }
8690 case 0xc6:
8691 {
8692 InvalidInstruction(2);
8693 break;
8694 }
8695 case 0xc7:
8696 {
8697 InvalidInstruction(2);
8698 break;
8699 }
8700 case 0xc8:
8701 {
8702 InvalidInstruction(2);
8703 break;
8704 }
8705 case 0xc9:
8706 {
8707 InvalidInstruction(2);
8708 break;
8709 }
8710 case 0xca:
8711 {
8712 InvalidInstruction(2);
8713 break;
8714 }
8715 case 0xcb:
8716 {
8717 DDFDCBHandler(0);
8718 break;
8719 }
8720 case 0xcc:
8721 {
8722 InvalidInstruction(2);
8723 break;
8724 }
8725 case 0xcd:
8726 {
8727 InvalidInstruction(2);
8728 break;
8729 }
8730 case 0xce:
8731 {
8732 InvalidInstruction(2);
8733 break;
8734 }
8735 case 0xcf:
8736 {
8737 InvalidInstruction(2);
8738 break;
8739 }
8740 case 0xd0:
8741 {
8742 InvalidInstruction(2);
8743 break;
8744 }
8745 case 0xd1:
8746 {
8747 InvalidInstruction(2);
8748 break;
8749 }
8750 case 0xd2:
8751 {
8752 InvalidInstruction(2);
8753 break;
8754 }
8755 case 0xd3:
8756 {
8757 InvalidInstruction(2);
8758 break;
8759 }
8760 case 0xd4:
8761 {
8762 InvalidInstruction(2);
8763 break;
8764 }
8765 case 0xd5:
8766 {
8767 InvalidInstruction(2);
8768 break;
8769 }
8770 case 0xd6:
8771 {
8772 InvalidInstruction(2);
8773 break;
8774 }
8775 case 0xd7:
8776 {
8777 InvalidInstruction(2);
8778 break;
8779 }
8780 case 0xd8:
8781 {
8782 InvalidInstruction(2);
8783 break;
8784 }
8785 case 0xd9:
8786 {
8787 InvalidInstruction(2);
8788 break;
8789 }
8790 case 0xda:
8791 {
8792 InvalidInstruction(2);
8793 break;
8794 }
8795 case 0xdb:
8796 {
8797 InvalidInstruction(2);
8798 break;
8799 }
8800 case 0xdc:
8801 {
8802 InvalidInstruction(2);
8803 break;
8804 }
8805 case 0xdd:
8806 {
8807 InvalidInstruction(2);
8808 break;
8809 }
8810 case 0xde:
8811 {
8812 InvalidInstruction(2);
8813 break;
8814 }
8815 case 0xdf:
8816 {
8817 InvalidInstruction(2);
8818 break;
8819 }
8820 case 0xe0:
8821 {
8822 InvalidInstruction(2);
8823 break;
8824 }
8825 case 0xe1:
8826 {
8827 sdwCyclesRemaining -= 14;
8828 psMemRead = cpu.z80MemRead; /* Beginning of our handler */
8829 while (psMemRead->lowAddr != 0xffffffff)
8830 {
8831 if ((cpu.z80sp >= psMemRead->lowAddr) && (cpu.z80sp <= psMemRead->highAddr))
8832 {
8833 cpu.z80pc = (UINT32) pbPC - (UINT32) cpu.z80Base;
8834 if (psMemRead->memoryCall)
8835 {
8836 cpu.z80IX = psMemRead->memoryCall(cpu.z80sp, psMemRead);
8837 cpu.z80IX |= (UINT32) ((UINT32) psMemRead->memoryCall(cpu.z80sp + 1, psMemRead) << 8);
8838 }
8839 else
8840 {
8841 cpu.z80IX = *((UINT8 *) psMemRead->pUserArea + (cpu.z80sp - psMemRead->lowAddr));
8842 cpu.z80IX |= (UINT32) ((UINT32) *((UINT8 *) psMemRead->pUserArea + (cpu.z80sp - psMemRead->lowAddr + 1)) << 8);
8843 }
8844 psMemRead = NULL;
8845 break;
8846 }
8847 ++psMemRead;
8848 }
8849
8850 if (psMemRead)
8851 {
8852 cpu.z80IX = cpu.z80Base[cpu.z80sp];
8853 cpu.z80IX |= (UINT32) ((UINT32) cpu.z80Base[cpu.z80sp + 1] << 8);
8854 }
8855
8856 cpu.z80sp += 2;
8857 pbSP = (cpu.z80Base + cpu.z80sp); /* Normalize the stack pointer */
8858 break;
8859 }
8860 case 0xe2:
8861 {
8862 InvalidInstruction(2);
8863 break;
8864 }
8865 case 0xe3:
8866 {
8867 sdwCyclesRemaining -= 23;
8868 psMemRead = cpu.z80MemRead; /* Beginning of our handler */
8869 while (psMemRead->lowAddr != 0xffffffff)
8870 {
8871 if ((cpu.z80sp >= psMemRead->lowAddr) && (cpu.z80sp <= psMemRead->highAddr))
8872 {
8873 cpu.z80pc = (UINT32) pbPC - (UINT32) cpu.z80Base;
8874 if (psMemRead->memoryCall)
8875 {
8876 dwAddr = psMemRead->memoryCall(cpu.z80sp, psMemRead);
8877 dwAddr |= (UINT32) ((UINT32) psMemRead->memoryCall(cpu.z80sp + 1, psMemRead) << 8);
8878 }
8879 else
8880 {
8881 dwAddr = *((UINT8 *) psMemRead->pUserArea + (cpu.z80sp - psMemRead->lowAddr));
8882 dwAddr |= (UINT32) ((UINT32) *((UINT8 *) psMemRead->pUserArea + (cpu.z80sp - psMemRead->lowAddr + 1)) << 8);
8883 }
8884 psMemRead = NULL;
8885 break;
8886 }
8887 ++psMemRead;
8888 }
8889
8890 if (psMemRead)
8891 {
8892 dwAddr = cpu.z80Base[cpu.z80sp];
8893 dwAddr |= (UINT32) ((UINT32) cpu.z80Base[cpu.z80sp + 1] << 8);
8894 }
8895
8896 psMemWrite = cpu.z80MemWrite; /* Beginning of our handler */
8897 while (psMemWrite->lowAddr != 0xffffffff)
8898 {
8899 if ((cpu.z80sp >= psMemWrite->lowAddr) && (cpu.z80sp <= psMemWrite->highAddr))
8900 {
8901 cpu.z80pc = (UINT32) pbPC - (UINT32) cpu.z80Base;
8902 if (psMemWrite->memoryCall)
8903 {
8904 psMemWrite->memoryCall(cpu.z80sp, (cpu.z80IX & 0xff), psMemWrite);
8905 psMemWrite->memoryCall(cpu.z80sp + 1, (cpu.z80IX >> 8), psMemWrite);
8906 }
8907 else
8908 {
8909 *((UINT8 *) psMemWrite->pUserArea + (cpu.z80sp - psMemWrite->lowAddr)) = cpu.z80IX;
8910 *((UINT8 *) psMemWrite->pUserArea + (cpu.z80sp - psMemWrite->lowAddr) + 1) = cpu.z80IX >> 8;
8911 }
8912 psMemWrite = NULL;
8913 break;
8914 }
8915 ++psMemWrite;
8916 }
8917
8918 if (psMemWrite)
8919 {
8920 cpu.z80Base[cpu.z80sp] = (UINT8) cpu.z80IX;
8921 cpu.z80Base[cpu.z80sp + 1] = (UINT8) ((UINT32) cpu.z80IX >> 8);
8922 }
8923
8924 cpu.z80IX = dwAddr;
8925 break;
8926 }
8927 case 0xe4:
8928 {
8929 InvalidInstruction(2);
8930 break;
8931 }
8932 case 0xe5:
8933 {
8934 sdwCyclesRemaining -= 15;
8935 cpu.z80sp -= 2;
8936 pbSP = (cpu.z80Base + cpu.z80sp); /* Normalize the stack pointer */
8937 psMemWrite = cpu.z80MemWrite; /* Beginning of our handler */
8938 while (psMemWrite->lowAddr != 0xffffffff)
8939 {
8940 if ((cpu.z80sp >= psMemWrite->lowAddr) && (cpu.z80sp <= psMemWrite->highAddr))
8941 {
8942 cpu.z80pc = (UINT32) pbPC - (UINT32) cpu.z80Base;
8943 if (psMemWrite->memoryCall)
8944 {
8945 psMemWrite->memoryCall(cpu.z80sp, (cpu.z80IX & 0xff), psMemWrite);
8946 psMemWrite->memoryCall(cpu.z80sp + 1, (cpu.z80IX >> 8), psMemWrite);
8947 }
8948 else
8949 {
8950 *((UINT8 *) psMemWrite->pUserArea + (cpu.z80sp - psMemWrite->lowAddr)) = cpu.z80IX;
8951 *((UINT8 *) psMemWrite->pUserArea + (cpu.z80sp - psMemWrite->lowAddr) + 1) = cpu.z80IX >> 8;
8952 }
8953 psMemWrite = NULL;
8954 break;
8955 }
8956 ++psMemWrite;
8957 }
8958
8959 if (psMemWrite)
8960 {
8961 cpu.z80Base[cpu.z80sp] = (UINT8) cpu.z80IX;
8962 cpu.z80Base[cpu.z80sp + 1] = (UINT8) ((UINT32) cpu.z80IX >> 8);
8963 }
8964
8965 break;
8966 }
8967 case 0xe6:
8968 {
8969 InvalidInstruction(2);
8970 break;
8971 }
8972 case 0xe7:
8973 {
8974 InvalidInstruction(2);
8975 break;
8976 }
8977 case 0xe8:
8978 {
8979 InvalidInstruction(2);
8980 break;
8981 }
8982 case 0xe9:
8983 {
8984 sdwCyclesRemaining -= 8;
8985 pbPC = cpu.z80Base + cpu.z80IX;
8986 break;
8987 }
8988 case 0xea:
8989 {
8990 InvalidInstruction(2);
8991 break;
8992 }
8993 case 0xeb:
8994 {
8995 InvalidInstruction(2);
8996 break;
8997 }
8998 case 0xec:
8999 {
9000 InvalidInstruction(2);
9001 break;
9002 }
9003 case 0xed:
9004 {
9005 InvalidInstruction(2);
9006 break;
9007 }
9008 case 0xee:
9009 {
9010 InvalidInstruction(2);
9011 break;
9012 }
9013 case 0xef:
9014 {
9015 InvalidInstruction(2);
9016 break;
9017 }
9018 case 0xf0:
9019 {
9020 InvalidInstruction(2);
9021 break;
9022 }
9023 case 0xf1:
9024 {
9025 InvalidInstruction(2);
9026 break;
9027 }
9028 case 0xf2:
9029 {
9030 InvalidInstruction(2);
9031 break;
9032 }
9033 case 0xf3:
9034 {
9035 InvalidInstruction(2);
9036 break;
9037 }
9038 case 0xf4:
9039 {
9040 InvalidInstruction(2);
9041 break;
9042 }
9043 case 0xf5:
9044 {
9045 InvalidInstruction(2);
9046 break;
9047 }
9048 case 0xf6:
9049 {
9050 InvalidInstruction(2);
9051 break;
9052 }
9053 case 0xf7:
9054 {
9055 InvalidInstruction(2);
9056 break;
9057 }
9058 case 0xf8:
9059 {
9060 InvalidInstruction(2);
9061 break;
9062 }
9063 case 0xf9:
9064 {
9065 sdwCyclesRemaining -= 10;
9066 cpu.z80sp = cpu.z80IX;
9067 break;
9068 }
9069 case 0xfa:
9070 {
9071 InvalidInstruction(2);
9072 break;
9073 }
9074 case 0xfb:
9075 {
9076 InvalidInstruction(2);
9077 break;
9078 }
9079 case 0xfc:
9080 {
9081 InvalidInstruction(2);
9082 break;
9083 }
9084 case 0xfd:
9085 {
9086 InvalidInstruction(2);
9087 break;
9088 }
9089 case 0xfe:
9090 {
9091 InvalidInstruction(2);
9092 break;
9093 }
9094 case 0xff:
9095 {
9096 InvalidInstruction(2);
9097 break;
9098 }
9099 }
9100}
9101void DDFDCBHandler(UINT32 dwWhich)
9102{
9103 if (dwWhich)
9104 {
9105 dwAddr = (UINT32) ((INT32) cpu.z80IY + ((INT32) *pbPC++)) & 0xffff;
9106 }
9107 else
9108 {
9109 dwAddr = (UINT32) ((INT32) cpu.z80IX + ((INT32) *pbPC++)) & 0xffff;
9110 }
9111
9112 psMemRead = cpu.z80MemRead; /* Beginning of our handler */
9113 while (psMemRead->lowAddr != 0xffffffff)
9114 {
9115 if ((dwAddr >= psMemRead->lowAddr) && (dwAddr <= psMemRead->highAddr))
9116 {
9117 cpu.z80pc = (UINT32) pbPC - (UINT32) cpu.z80Base;
9118 if (psMemRead->memoryCall)
9119 {
9120 bTemp = psMemRead->memoryCall(dwAddr, psMemRead);
9121 }
9122 else
9123 {
9124 bTemp = *((UINT8 *) psMemRead->pUserArea + (dwAddr - psMemRead->lowAddr));
9125 }
9126 psMemRead = NULL;
9127 break;
9128 }
9129 ++psMemRead;
9130 }
9131
9132 if (psMemRead)
9133 {
9134 bTemp = cpu.z80Base[dwAddr];
9135 }
9136
9137 switch (*pbPC++)
9138 {
9139 case 0x00:
9140 {
9141 InvalidInstruction(4);
9142 break;
9143 }
9144 case 0x01:
9145 {
9146 InvalidInstruction(4);
9147 break;
9148 }
9149 case 0x02:
9150 {
9151 InvalidInstruction(4);
9152 break;
9153 }
9154 case 0x03:
9155 {
9156 InvalidInstruction(4);
9157 break;
9158 }
9159 case 0x04:
9160 {
9161 InvalidInstruction(4);
9162 break;
9163 }
9164 case 0x05:
9165 {
9166 InvalidInstruction(4);
9167 break;
9168 }
9169 case 0x06:
9170 {
9171 sdwCyclesRemaining -= 23;
9172 cpu.z80F &= ~(Z80_FLAG_ZERO | Z80_FLAG_SIGN | Z80_FLAG_HALF_CARRY | Z80_FLAG_OVERFLOW_PARITY | Z80_FLAG_NEGATIVE | Z80_FLAG_CARRY);
9173 bTemp2 = (bTemp >> 7);
9174 bTemp = (bTemp << 1) | bTemp2;
9175 cpu.z80F |= bTemp2 | bPostORFlags[bTemp];
9176 psMemWrite = cpu.z80MemWrite; /* Beginning of our handler */
9177 while (psMemWrite->lowAddr != 0xffffffff)
9178 {
9179 if ((dwAddr >= psMemWrite->lowAddr) && (dwAddr <= psMemWrite->highAddr))
9180 {
9181 cpu.z80pc = (UINT32) pbPC - (UINT32) cpu.z80Base;
9182 if (psMemWrite->memoryCall)
9183 {
9184 psMemWrite->memoryCall(dwAddr, bTemp, psMemWrite);
9185 }
9186 else
9187 {
9188 *((UINT8 *) psMemWrite->pUserArea + (dwAddr - psMemWrite->lowAddr)) = bTemp;
9189 }
9190 psMemWrite = NULL;
9191 break;
9192 }
9193 ++psMemWrite;
9194 }
9195
9196 if (psMemWrite)
9197 {
9198 cpu.z80Base[dwAddr] = (UINT8) bTemp;
9199 }
9200
9201 break;
9202 }
9203 case 0x07:
9204 {
9205 InvalidInstruction(4);
9206 break;
9207 }
9208 case 0x08:
9209 {
9210 InvalidInstruction(4);
9211 break;
9212 }
9213 case 0x09:
9214 {
9215 InvalidInstruction(4);
9216 break;
9217 }
9218 case 0x0a:
9219 {
9220 InvalidInstruction(4);
9221 break;
9222 }
9223 case 0x0b:
9224 {
9225 InvalidInstruction(4);
9226 break;
9227 }
9228 case 0x0c:
9229 {
9230 InvalidInstruction(4);
9231 break;
9232 }
9233 case 0x0d:
9234 {
9235 InvalidInstruction(4);
9236 break;
9237 }
9238 case 0x0e:
9239 {
9240 sdwCyclesRemaining -= 23;
9241 cpu.z80F &= ~(Z80_FLAG_ZERO | Z80_FLAG_SIGN | Z80_FLAG_HALF_CARRY | Z80_FLAG_OVERFLOW_PARITY | Z80_FLAG_NEGATIVE | Z80_FLAG_CARRY);
9242 cpu.z80F |= (bTemp & Z80_FLAG_CARRY);
9243 bTemp = (bTemp >> 1) | (bTemp << 7);
9244 cpu.z80F |= bPostORFlags[bTemp];
9245 psMemWrite = cpu.z80MemWrite; /* Beginning of our handler */
9246 while (psMemWrite->lowAddr != 0xffffffff)
9247 {
9248 if ((dwAddr >= psMemWrite->lowAddr) && (dwAddr <= psMemWrite->highAddr))
9249 {
9250 cpu.z80pc = (UINT32) pbPC - (UINT32) cpu.z80Base;
9251 if (psMemWrite->memoryCall)
9252 {
9253 psMemWrite->memoryCall(dwAddr, bTemp, psMemWrite);
9254 }
9255 else
9256 {
9257 *((UINT8 *) psMemWrite->pUserArea + (dwAddr - psMemWrite->lowAddr)) = bTemp;
9258 }
9259 psMemWrite = NULL;
9260 break;
9261 }
9262 ++psMemWrite;
9263 }
9264
9265 if (psMemWrite)
9266 {
9267 cpu.z80Base[dwAddr] = (UINT8) bTemp;
9268 }
9269
9270 break;
9271 }
9272 case 0x0f:
9273 {
9274 InvalidInstruction(4);
9275 break;
9276 }
9277 case 0x10:
9278 {
9279 InvalidInstruction(4);
9280 break;
9281 }
9282 case 0x11:
9283 {
9284 InvalidInstruction(4);
9285 break;
9286 }
9287 case 0x12:
9288 {
9289 InvalidInstruction(4);
9290 break;
9291 }
9292 case 0x13:
9293 {
9294 InvalidInstruction(4);
9295 break;
9296 }
9297 case 0x14:
9298 {
9299 InvalidInstruction(4);
9300 break;
9301 }
9302 case 0x15:
9303 {
9304 InvalidInstruction(4);
9305 break;
9306 }
9307 case 0x16:
9308 {
9309 sdwCyclesRemaining -= 23;
9310 bTemp2 = cpu.z80F & Z80_FLAG_CARRY;
9311 cpu.z80F &= ~(Z80_FLAG_ZERO | Z80_FLAG_SIGN | Z80_FLAG_HALF_CARRY | Z80_FLAG_OVERFLOW_PARITY | Z80_FLAG_NEGATIVE | Z80_FLAG_CARRY);
9312 cpu.z80F |= (bTemp >> 7);
9313 bTemp = (bTemp << 1) | bTemp2;
9314 cpu.z80F |= bPostORFlags[bTemp];
9315 psMemWrite = cpu.z80MemWrite; /* Beginning of our handler */
9316 while (psMemWrite->lowAddr != 0xffffffff)
9317 {
9318 if ((dwAddr >= psMemWrite->lowAddr) && (dwAddr <= psMemWrite->highAddr))
9319 {
9320 cpu.z80pc = (UINT32) pbPC - (UINT32) cpu.z80Base;
9321 if (psMemWrite->memoryCall)
9322 {
9323 psMemWrite->memoryCall(dwAddr, bTemp, psMemWrite);
9324 }
9325 else
9326 {
9327 *((UINT8 *) psMemWrite->pUserArea + (dwAddr - psMemWrite->lowAddr)) = bTemp;
9328 }
9329 psMemWrite = NULL;
9330 break;
9331 }
9332 ++psMemWrite;
9333 }
9334
9335 if (psMemWrite)
9336 {
9337 cpu.z80Base[dwAddr] = (UINT8) bTemp;
9338 }
9339
9340 break;
9341 }
9342 case 0x17:
9343 {
9344 InvalidInstruction(4);
9345 break;
9346 }
9347 case 0x18:
9348 {
9349 InvalidInstruction(4);
9350 break;
9351 }
9352 case 0x19:
9353 {
9354 InvalidInstruction(4);
9355 break;
9356 }
9357 case 0x1a:
9358 {
9359 InvalidInstruction(4);
9360 break;
9361 }
9362 case 0x1b:
9363 {
9364 InvalidInstruction(4);
9365 break;
9366 }
9367 case 0x1c:
9368 {
9369 InvalidInstruction(4);
9370 break;
9371 }
9372 case 0x1d:
9373 {
9374 InvalidInstruction(4);
9375 break;
9376 }
9377 case 0x1e:
9378 {
9379 sdwCyclesRemaining -= 23;
9380 bTemp2 = (cpu.z80F & Z80_FLAG_CARRY) << 7;
9381 cpu.z80F &= ~(Z80_FLAG_ZERO | Z80_FLAG_SIGN | Z80_FLAG_HALF_CARRY | Z80_FLAG_OVERFLOW_PARITY | Z80_FLAG_NEGATIVE | Z80_FLAG_CARRY);
9382 cpu.z80F |= (bTemp & Z80_FLAG_CARRY);
9383 bTemp = (bTemp >> 1) | bTemp2;
9384 cpu.z80F |= bPostORFlags[bTemp];
9385 psMemWrite = cpu.z80MemWrite; /* Beginning of our handler */
9386 while (psMemWrite->lowAddr != 0xffffffff)
9387 {
9388 if ((dwAddr >= psMemWrite->lowAddr) && (dwAddr <= psMemWrite->highAddr))
9389 {
9390 cpu.z80pc = (UINT32) pbPC - (UINT32) cpu.z80Base;
9391 if (psMemWrite->memoryCall)
9392 {
9393 psMemWrite->memoryCall(dwAddr, bTemp, psMemWrite);
9394 }
9395 else
9396 {
9397 *((UINT8 *) psMemWrite->pUserArea + (dwAddr - psMemWrite->lowAddr)) = bTemp;
9398 }
9399 psMemWrite = NULL;
9400 break;
9401 }
9402 ++psMemWrite;
9403 }
9404
9405 if (psMemWrite)
9406 {
9407 cpu.z80Base[dwAddr] = (UINT8) bTemp;
9408 }
9409
9410 break;
9411 }
9412 case 0x1f:
9413 {
9414 InvalidInstruction(4);
9415 break;
9416 }
9417 case 0x20:
9418 {
9419 InvalidInstruction(4);
9420 break;
9421 }
9422 case 0x21:
9423 {
9424 InvalidInstruction(4);
9425 break;
9426 }
9427 case 0x22:
9428 {
9429 InvalidInstruction(4);
9430 break;
9431 }
9432 case 0x23:
9433 {
9434 InvalidInstruction(4);
9435 break;
9436 }
9437 case 0x24:
9438 {
9439 InvalidInstruction(4);
9440 break;
9441 }
9442 case 0x25:
9443 {
9444 InvalidInstruction(4);
9445 break;
9446 }
9447 case 0x26:
9448 {
9449 sdwCyclesRemaining -= 23;
9450 cpu.z80F &= ~(Z80_FLAG_ZERO | Z80_FLAG_SIGN | Z80_FLAG_HALF_CARRY | Z80_FLAG_OVERFLOW_PARITY | Z80_FLAG_NEGATIVE | Z80_FLAG_CARRY);
9451 cpu.z80F |= (bTemp >> 7);
9452 bTemp = (bTemp << 1);
9453 cpu.z80F |= bPostORFlags[bTemp];
9454 psMemWrite = cpu.z80MemWrite; /* Beginning of our handler */
9455 while (psMemWrite->lowAddr != 0xffffffff)
9456 {
9457 if ((dwAddr >= psMemWrite->lowAddr) && (dwAddr <= psMemWrite->highAddr))
9458 {
9459 cpu.z80pc = (UINT32) pbPC - (UINT32) cpu.z80Base;
9460 if (psMemWrite->memoryCall)
9461 {
9462 psMemWrite->memoryCall(dwAddr, bTemp, psMemWrite);
9463 }
9464 else
9465 {
9466 *((UINT8 *) psMemWrite->pUserArea + (dwAddr - psMemWrite->lowAddr)) = bTemp;
9467 }
9468 psMemWrite = NULL;
9469 break;
9470 }
9471 ++psMemWrite;
9472 }
9473
9474 if (psMemWrite)
9475 {
9476 cpu.z80Base[dwAddr] = (UINT8) bTemp;
9477 }
9478
9479 break;
9480 }
9481 case 0x27:
9482 {
9483 InvalidInstruction(4);
9484 break;
9485 }
9486 case 0x28:
9487 {
9488 InvalidInstruction(4);
9489 break;
9490 }
9491 case 0x29:
9492 {
9493 InvalidInstruction(4);
9494 break;
9495 }
9496 case 0x2a:
9497 {
9498 InvalidInstruction(4);
9499 break;
9500 }
9501 case 0x2b:
9502 {
9503 InvalidInstruction(4);
9504 break;
9505 }
9506 case 0x2c:
9507 {
9508 InvalidInstruction(4);
9509 break;
9510 }
9511 case 0x2d:
9512 {
9513 InvalidInstruction(4);
9514 break;
9515 }
9516 case 0x2e:
9517 {
9518 sdwCyclesRemaining -= 23;
9519 cpu.z80F &= ~(Z80_FLAG_ZERO | Z80_FLAG_SIGN | Z80_FLAG_HALF_CARRY | Z80_FLAG_OVERFLOW_PARITY | Z80_FLAG_NEGATIVE | Z80_FLAG_CARRY);
9520 cpu.z80F |= (bTemp & Z80_FLAG_CARRY);
9521 bTemp = (bTemp >> 1) | (bTemp & 0x80);
9522 cpu.z80F |= bPostORFlags[bTemp];
9523 psMemWrite = cpu.z80MemWrite; /* Beginning of our handler */
9524 while (psMemWrite->lowAddr != 0xffffffff)
9525 {
9526 if ((dwAddr >= psMemWrite->lowAddr) && (dwAddr <= psMemWrite->highAddr))
9527 {
9528 cpu.z80pc = (UINT32) pbPC - (UINT32) cpu.z80Base;
9529 if (psMemWrite->memoryCall)
9530 {
9531 psMemWrite->memoryCall(dwAddr, bTemp, psMemWrite);
9532 }
9533 else
9534 {
9535 *((UINT8 *) psMemWrite->pUserArea + (dwAddr - psMemWrite->lowAddr)) = bTemp;
9536 }
9537 psMemWrite = NULL;
9538 break;
9539 }
9540 ++psMemWrite;
9541 }
9542
9543 if (psMemWrite)
9544 {
9545 cpu.z80Base[dwAddr] = (UINT8) bTemp;
9546 }
9547
9548 break;
9549 }
9550 case 0x2f:
9551 {
9552 InvalidInstruction(4);
9553 break;
9554 }
9555 case 0x30:
9556 {
9557 InvalidInstruction(4);
9558 break;
9559 }
9560 case 0x31:
9561 {
9562 InvalidInstruction(4);
9563 break;
9564 }
9565 case 0x32:
9566 {
9567 InvalidInstruction(4);
9568 break;
9569 }
9570 case 0x33:
9571 {
9572 InvalidInstruction(4);
9573 break;
9574 }
9575 case 0x34:
9576 {
9577 InvalidInstruction(4);
9578 break;
9579 }
9580 case 0x35:
9581 {
9582 InvalidInstruction(4);
9583 break;
9584 }
9585 case 0x36:
9586 {
9587 sdwCyclesRemaining -= 23;
9588 InvalidInstruction(4);
9589 break;
9590 }
9591 case 0x37:
9592 {
9593 InvalidInstruction(4);
9594 break;
9595 }
9596 case 0x38:
9597 {
9598 InvalidInstruction(4);
9599 break;
9600 }
9601 case 0x39:
9602 {
9603 InvalidInstruction(4);
9604 break;
9605 }
9606 case 0x3a:
9607 {
9608 InvalidInstruction(4);
9609 break;
9610 }
9611 case 0x3b:
9612 {
9613 InvalidInstruction(4);
9614 break;
9615 }
9616 case 0x3c:
9617 {
9618 InvalidInstruction(4);
9619 break;
9620 }
9621 case 0x3d:
9622 {
9623 InvalidInstruction(4);
9624 break;
9625 }
9626 case 0x3e:
9627 {
9628 sdwCyclesRemaining -= 23;
9629 cpu.z80F &= ~(Z80_FLAG_ZERO | Z80_FLAG_SIGN | Z80_FLAG_HALF_CARRY | Z80_FLAG_OVERFLOW_PARITY | Z80_FLAG_NEGATIVE | Z80_FLAG_CARRY);
9630 cpu.z80F |= (bTemp & Z80_FLAG_CARRY);
9631 bTemp = (bTemp >> 1);
9632 cpu.z80F |= bPostORFlags[bTemp];
9633 psMemWrite = cpu.z80MemWrite; /* Beginning of our handler */
9634 while (psMemWrite->lowAddr != 0xffffffff)
9635 {
9636 if ((dwAddr >= psMemWrite->lowAddr) && (dwAddr <= psMemWrite->highAddr))
9637 {
9638 cpu.z80pc = (UINT32) pbPC - (UINT32) cpu.z80Base;
9639 if (psMemWrite->memoryCall)
9640 {
9641 psMemWrite->memoryCall(dwAddr, bTemp, psMemWrite);
9642 }
9643 else
9644 {
9645 *((UINT8 *) psMemWrite->pUserArea + (dwAddr - psMemWrite->lowAddr)) = bTemp;
9646 }
9647 psMemWrite = NULL;
9648 break;
9649 }
9650 ++psMemWrite;
9651 }
9652
9653 if (psMemWrite)
9654 {
9655 cpu.z80Base[dwAddr] = (UINT8) bTemp;
9656 }
9657
9658 break;
9659 }
9660 case 0x3f:
9661 {
9662 InvalidInstruction(4);
9663 break;
9664 }
9665 case 0x40:
9666 {
9667 sdwCyclesRemaining -= 20;
9668 InvalidInstruction(4);
9669 break;
9670 }
9671 case 0x41:
9672 {
9673 sdwCyclesRemaining -= 20;
9674 InvalidInstruction(4);
9675 break;
9676 }
9677 case 0x42:
9678 {
9679 sdwCyclesRemaining -= 20;
9680 InvalidInstruction(4);
9681 break;
9682 }
9683 case 0x43:
9684 {
9685 sdwCyclesRemaining -= 20;
9686 InvalidInstruction(4);
9687 break;
9688 }
9689 case 0x44:
9690 {
9691 sdwCyclesRemaining -= 20;
9692 InvalidInstruction(4);
9693 break;
9694 }
9695 case 0x45:
9696 {
9697 sdwCyclesRemaining -= 20;
9698 InvalidInstruction(4);
9699 break;
9700 }
9701 case 0x46:
9702 {
9703 sdwCyclesRemaining -= 20;
9704 cpu.z80F = (cpu.z80F & ~(Z80_FLAG_ZERO | Z80_FLAG_NEGATIVE)) | Z80_FLAG_HALF_CARRY;
9705 if (!(bTemp & 0x01))
9706 {
9707 cpu.z80F |= Z80_FLAG_ZERO;
9708 }
9709 break;
9710 }
9711 case 0x47:
9712 {
9713 sdwCyclesRemaining -= 20;
9714 InvalidInstruction(4);
9715 break;
9716 }
9717 case 0x48:
9718 {
9719 sdwCyclesRemaining -= 20;
9720 InvalidInstruction(4);
9721 break;
9722 }
9723 case 0x49:
9724 {
9725 sdwCyclesRemaining -= 20;
9726 InvalidInstruction(4);
9727 break;
9728 }
9729 case 0x4a:
9730 {
9731 sdwCyclesRemaining -= 20;
9732 InvalidInstruction(4);
9733 break;
9734 }
9735 case 0x4b:
9736 {
9737 sdwCyclesRemaining -= 20;
9738 InvalidInstruction(4);
9739 break;
9740 }
9741 case 0x4c:
9742 {
9743 sdwCyclesRemaining -= 20;
9744 InvalidInstruction(4);
9745 break;
9746 }
9747 case 0x4d:
9748 {
9749 sdwCyclesRemaining -= 20;
9750 InvalidInstruction(4);
9751 break;
9752 }
9753 case 0x4e:
9754 {
9755 sdwCyclesRemaining -= 20;
9756 cpu.z80F = (cpu.z80F & ~(Z80_FLAG_ZERO | Z80_FLAG_NEGATIVE)) | Z80_FLAG_HALF_CARRY;
9757 if (!(bTemp & 0x02))
9758 {
9759 cpu.z80F |= Z80_FLAG_ZERO;
9760 }
9761 break;
9762 }
9763 case 0x4f:
9764 {
9765 sdwCyclesRemaining -= 20;
9766 InvalidInstruction(4);
9767 break;
9768 }
9769 case 0x50:
9770 {
9771 sdwCyclesRemaining -= 20;
9772 InvalidInstruction(4);
9773 break;
9774 }
9775 case 0x51:
9776 {
9777 sdwCyclesRemaining -= 20;
9778 InvalidInstruction(4);
9779 break;
9780 }
9781 case 0x52:
9782 {
9783 sdwCyclesRemaining -= 20;
9784 InvalidInstruction(4);
9785 break;
9786 }
9787 case 0x53:
9788 {
9789 sdwCyclesRemaining -= 20;
9790 InvalidInstruction(4);
9791 break;
9792 }
9793 case 0x54:
9794 {
9795 sdwCyclesRemaining -= 20;
9796 InvalidInstruction(4);
9797 break;
9798 }
9799 case 0x55:
9800 {
9801 sdwCyclesRemaining -= 20;
9802 InvalidInstruction(4);
9803 break;
9804 }
9805 case 0x56:
9806 {
9807 sdwCyclesRemaining -= 20;
9808 cpu.z80F = (cpu.z80F & ~(Z80_FLAG_ZERO | Z80_FLAG_NEGATIVE)) | Z80_FLAG_HALF_CARRY;
9809 if (!(bTemp & 0x04))
9810 {
9811 cpu.z80F |= Z80_FLAG_ZERO;
9812 }
9813 break;
9814 }
9815 case 0x57:
9816 {
9817 sdwCyclesRemaining -= 20;
9818 InvalidInstruction(4);
9819 break;
9820 }
9821 case 0x58:
9822 {
9823 sdwCyclesRemaining -= 20;
9824 InvalidInstruction(4);
9825 break;
9826 }
9827 case 0x59:
9828 {
9829 sdwCyclesRemaining -= 20;
9830 InvalidInstruction(4);
9831 break;
9832 }
9833 case 0x5a:
9834 {
9835 sdwCyclesRemaining -= 20;
9836 InvalidInstruction(4);
9837 break;
9838 }
9839 case 0x5b:
9840 {
9841 sdwCyclesRemaining -= 20;
9842 InvalidInstruction(4);
9843 break;
9844 }
9845 case 0x5c:
9846 {
9847 sdwCyclesRemaining -= 20;
9848 InvalidInstruction(4);
9849 break;
9850 }
9851 case 0x5d:
9852 {
9853 sdwCyclesRemaining -= 20;
9854 InvalidInstruction(4);
9855 break;
9856 }
9857 case 0x5e:
9858 {
9859 sdwCyclesRemaining -= 20;
9860 cpu.z80F = (cpu.z80F & ~(Z80_FLAG_ZERO | Z80_FLAG_NEGATIVE)) | Z80_FLAG_HALF_CARRY;
9861 if (!(bTemp & 0x08))
9862 {
9863 cpu.z80F |= Z80_FLAG_ZERO;
9864 }
9865 break;
9866 }
9867 case 0x5f:
9868 {
9869 sdwCyclesRemaining -= 20;
9870 InvalidInstruction(4);
9871 break;
9872 }
9873 case 0x60:
9874 {
9875 sdwCyclesRemaining -= 20;
9876 InvalidInstruction(4);
9877 break;
9878 }
9879 case 0x61:
9880 {
9881 sdwCyclesRemaining -= 20;
9882 InvalidInstruction(4);
9883 break;
9884 }
9885 case 0x62:
9886 {
9887 sdwCyclesRemaining -= 20;
9888 InvalidInstruction(4);
9889 break;
9890 }
9891 case 0x63:
9892 {
9893 sdwCyclesRemaining -= 20;
9894 InvalidInstruction(4);
9895 break;
9896 }
9897 case 0x64:
9898 {
9899 sdwCyclesRemaining -= 20;
9900 InvalidInstruction(4);
9901 break;
9902 }
9903 case 0x65:
9904 {
9905 sdwCyclesRemaining -= 20;
9906 InvalidInstruction(4);
9907 break;
9908 }
9909 case 0x66:
9910 {
9911 sdwCyclesRemaining -= 20;
9912 cpu.z80F = (cpu.z80F & ~(Z80_FLAG_ZERO | Z80_FLAG_NEGATIVE)) | Z80_FLAG_HALF_CARRY;
9913 if (!(bTemp & 0x10))
9914 {
9915 cpu.z80F |= Z80_FLAG_ZERO;
9916 }
9917 break;
9918 }
9919 case 0x67:
9920 {
9921 sdwCyclesRemaining -= 20;
9922 InvalidInstruction(4);
9923 break;
9924 }
9925 case 0x68:
9926 {
9927 sdwCyclesRemaining -= 20;
9928 InvalidInstruction(4);
9929 break;
9930 }
9931 case 0x69:
9932 {
9933 sdwCyclesRemaining -= 20;
9934 InvalidInstruction(4);
9935 break;
9936 }
9937 case 0x6a:
9938 {
9939 sdwCyclesRemaining -= 20;
9940 InvalidInstruction(4);
9941 break;
9942 }
9943 case 0x6b:
9944 {
9945 sdwCyclesRemaining -= 20;
9946 InvalidInstruction(4);
9947 break;
9948 }
9949 case 0x6c:
9950 {
9951 sdwCyclesRemaining -= 20;
9952 InvalidInstruction(4);
9953 break;
9954 }
9955 case 0x6d:
9956 {
9957 sdwCyclesRemaining -= 20;
9958 InvalidInstruction(4);
9959 break;
9960 }
9961 case 0x6e:
9962 {
9963 sdwCyclesRemaining -= 20;
9964 cpu.z80F = (cpu.z80F & ~(Z80_FLAG_ZERO | Z80_FLAG_NEGATIVE)) | Z80_FLAG_HALF_CARRY;
9965 if (!(bTemp & 0x20))
9966 {
9967 cpu.z80F |= Z80_FLAG_ZERO;
9968 }
9969 break;
9970 }
9971 case 0x6f:
9972 {
9973 sdwCyclesRemaining -= 20;
9974 InvalidInstruction(4);
9975 break;
9976 }
9977 case 0x70:
9978 {
9979 sdwCyclesRemaining -= 20;
9980 InvalidInstruction(4);
9981 break;
9982 }
9983 case 0x71:
9984 {
9985 sdwCyclesRemaining -= 20;
9986 InvalidInstruction(4);
9987 break;
9988 }
9989 case 0x72:
9990 {
9991 sdwCyclesRemaining -= 20;
9992 InvalidInstruction(4);
9993 break;
9994 }
9995 case 0x73:
9996 {
9997 sdwCyclesRemaining -= 20;
9998 InvalidInstruction(4);
9999 break;
10000 }
10001 case 0x74:
10002 {
10003 sdwCyclesRemaining -= 20;
10004 InvalidInstruction(4);
10005 break;
10006 }
10007 case 0x75:
10008 {
10009 sdwCyclesRemaining -= 20;
10010 InvalidInstruction(4);
10011 break;
10012 }
10013 case 0x76:
10014 {
10015 sdwCyclesRemaining -= 20;
10016 cpu.z80F = (cpu.z80F & ~(Z80_FLAG_ZERO | Z80_FLAG_NEGATIVE)) | Z80_FLAG_HALF_CARRY;
10017 if (!(bTemp & 0x40))
10018 {
10019 cpu.z80F |= Z80_FLAG_ZERO;
10020 }
10021 break;
10022 }
10023 case 0x77:
10024 {
10025 sdwCyclesRemaining -= 20;
10026 InvalidInstruction(4);
10027 break;
10028 }
10029 case 0x78:
10030 {
10031 sdwCyclesRemaining -= 20;
10032 InvalidInstruction(4);
10033 break;
10034 }
10035 case 0x79:
10036 {
10037 sdwCyclesRemaining -= 20;
10038 InvalidInstruction(4);
10039 break;
10040 }
10041 case 0x7a:
10042 {
10043 sdwCyclesRemaining -= 20;
10044 InvalidInstruction(4);
10045 break;
10046 }
10047 case 0x7b:
10048 {
10049 sdwCyclesRemaining -= 20;
10050 InvalidInstruction(4);
10051 break;
10052 }
10053 case 0x7c:
10054 {
10055 sdwCyclesRemaining -= 20;
10056 InvalidInstruction(4);
10057 break;
10058 }
10059 case 0x7d:
10060 {
10061 sdwCyclesRemaining -= 20;
10062 InvalidInstruction(4);
10063 break;
10064 }
10065 case 0x7e:
10066 {
10067 sdwCyclesRemaining -= 20;
10068 cpu.z80F = (cpu.z80F & ~(Z80_FLAG_ZERO | Z80_FLAG_NEGATIVE)) | Z80_FLAG_HALF_CARRY;
10069 if (!(bTemp & 0x80))
10070 {
10071 cpu.z80F |= Z80_FLAG_ZERO;
10072 }
10073 break;
10074 }
10075 case 0x7f:
10076 {
10077 sdwCyclesRemaining -= 20;
10078 InvalidInstruction(4);
10079 break;
10080 }
10081 case 0x80:
10082 {
10083 InvalidInstruction(4);
10084 break;
10085 }
10086 case 0x81:
10087 {
10088 InvalidInstruction(4);
10089 break;
10090 }
10091 case 0x82:
10092 {
10093 InvalidInstruction(4);
10094 break;
10095 }
10096 case 0x83:
10097 {
10098 InvalidInstruction(4);
10099 break;
10100 }
10101 case 0x84:
10102 {
10103 InvalidInstruction(4);
10104 break;
10105 }
10106 case 0x85:
10107 {
10108 InvalidInstruction(4);
10109 break;
10110 }
10111 case 0x86:
10112 {
10113 sdwCyclesRemaining -= 23;
10114 bTemp &= 0xfe;
10115 psMemWrite = cpu.z80MemWrite; /* Beginning of our handler */
10116 while (psMemWrite->lowAddr != 0xffffffff)
10117 {
10118 if ((dwAddr >= psMemWrite->lowAddr) && (dwAddr <= psMemWrite->highAddr))
10119 {
10120 cpu.z80pc = (UINT32) pbPC - (UINT32) cpu.z80Base;
10121 if (psMemWrite->memoryCall)
10122 {
10123 psMemWrite->memoryCall(dwAddr, bTemp, psMemWrite);
10124 }
10125 else
10126 {
10127 *((UINT8 *) psMemWrite->pUserArea + (dwAddr - psMemWrite->lowAddr)) = bTemp;
10128 }
10129 psMemWrite = NULL;
10130 break;
10131 }
10132 ++psMemWrite;
10133 }
10134
10135 if (psMemWrite)
10136 {
10137 cpu.z80Base[dwAddr] = (UINT8) bTemp;
10138 }
10139
10140 break;
10141 }
10142 case 0x87:
10143 {
10144 InvalidInstruction(4);
10145 break;
10146 }
10147 case 0x88:
10148 {
10149 InvalidInstruction(4);
10150 break;
10151 }
10152 case 0x89:
10153 {
10154 InvalidInstruction(4);
10155 break;
10156 }
10157 case 0x8a:
10158 {
10159 InvalidInstruction(4);
10160 break;
10161 }
10162 case 0x8b:
10163 {
10164 InvalidInstruction(4);
10165 break;
10166 }
10167 case 0x8c:
10168 {
10169 InvalidInstruction(4);
10170 break;
10171 }
10172 case 0x8d:
10173 {
10174 InvalidInstruction(4);
10175 break;
10176 }
10177 case 0x8e:
10178 {
10179 sdwCyclesRemaining -= 23;
10180 bTemp &= 0xfd;
10181 psMemWrite = cpu.z80MemWrite; /* Beginning of our handler */
10182 while (psMemWrite->lowAddr != 0xffffffff)
10183 {
10184 if ((dwAddr >= psMemWrite->lowAddr) && (dwAddr <= psMemWrite->highAddr))
10185 {
10186 cpu.z80pc = (UINT32) pbPC - (UINT32) cpu.z80Base;
10187 if (psMemWrite->memoryCall)
10188 {
10189 psMemWrite->memoryCall(dwAddr, bTemp, psMemWrite);
10190 }
10191 else
10192 {
10193 *((UINT8 *) psMemWrite->pUserArea + (dwAddr - psMemWrite->lowAddr)) = bTemp;
10194 }
10195 psMemWrite = NULL;
10196 break;
10197 }
10198 ++psMemWrite;
10199 }
10200
10201 if (psMemWrite)
10202 {
10203 cpu.z80Base[dwAddr] = (UINT8) bTemp;
10204 }
10205
10206 break;
10207 }
10208 case 0x8f:
10209 {
10210 InvalidInstruction(4);
10211 break;
10212 }
10213 case 0x90:
10214 {
10215 InvalidInstruction(4);
10216 break;
10217 }
10218 case 0x91:
10219 {
10220 InvalidInstruction(4);
10221 break;
10222 }
10223 case 0x92:
10224 {
10225 InvalidInstruction(4);
10226 break;
10227 }
10228 case 0x93:
10229 {
10230 InvalidInstruction(4);
10231 break;
10232 }
10233 case 0x94:
10234 {
10235 InvalidInstruction(4);
10236 break;
10237 }
10238 case 0x95:
10239 {
10240 InvalidInstruction(4);
10241 break;
10242 }
10243 case 0x96:
10244 {
10245 sdwCyclesRemaining -= 23;
10246 bTemp &= 0xfb;
10247 psMemWrite = cpu.z80MemWrite; /* Beginning of our handler */
10248 while (psMemWrite->lowAddr != 0xffffffff)
10249 {
10250 if ((dwAddr >= psMemWrite->lowAddr) && (dwAddr <= psMemWrite->highAddr))
10251 {
10252 cpu.z80pc = (UINT32) pbPC - (UINT32) cpu.z80Base;
10253 if (psMemWrite->memoryCall)
10254 {
10255 psMemWrite->memoryCall(dwAddr, bTemp, psMemWrite);
10256 }
10257 else
10258 {
10259 *((UINT8 *) psMemWrite->pUserArea + (dwAddr - psMemWrite->lowAddr)) = bTemp;
10260 }
10261 psMemWrite = NULL;
10262 break;
10263 }
10264 ++psMemWrite;
10265 }
10266
10267 if (psMemWrite)
10268 {
10269 cpu.z80Base[dwAddr] = (UINT8) bTemp;
10270 }
10271
10272 break;
10273 }
10274 case 0x97:
10275 {
10276 InvalidInstruction(4);
10277 break;
10278 }
10279 case 0x98:
10280 {
10281 InvalidInstruction(4);
10282 break;
10283 }
10284 case 0x99:
10285 {
10286 InvalidInstruction(4);
10287 break;
10288 }
10289 case 0x9a:
10290 {
10291 InvalidInstruction(4);
10292 break;
10293 }
10294 case 0x9b:
10295 {
10296 InvalidInstruction(4);
10297 break;
10298 }
10299 case 0x9c:
10300 {
10301 InvalidInstruction(4);
10302 break;
10303 }
10304 case 0x9d:
10305 {
10306 InvalidInstruction(4);
10307 break;
10308 }
10309 case 0x9e:
10310 {
10311 sdwCyclesRemaining -= 23;
10312 bTemp &= 0xf7;
10313 psMemWrite = cpu.z80MemWrite; /* Beginning of our handler */
10314 while (psMemWrite->lowAddr != 0xffffffff)
10315 {
10316 if ((dwAddr >= psMemWrite->lowAddr) && (dwAddr <= psMemWrite->highAddr))
10317 {
10318 cpu.z80pc = (UINT32) pbPC - (UINT32) cpu.z80Base;
10319 if (psMemWrite->memoryCall)
10320 {
10321 psMemWrite->memoryCall(dwAddr, bTemp, psMemWrite);
10322 }
10323 else
10324 {
10325 *((UINT8 *) psMemWrite->pUserArea + (dwAddr - psMemWrite->lowAddr)) = bTemp;
10326 }
10327 psMemWrite = NULL;
10328 break;
10329 }
10330 ++psMemWrite;
10331 }
10332
10333 if (psMemWrite)
10334 {
10335 cpu.z80Base[dwAddr] = (UINT8) bTemp;
10336 }
10337
10338 break;
10339 }
10340 case 0x9f:
10341 {
10342 InvalidInstruction(4);
10343 break;
10344 }
10345 case 0xa0:
10346 {
10347 InvalidInstruction(4);
10348 break;
10349 }
10350 case 0xa1:
10351 {
10352 InvalidInstruction(4);
10353 break;
10354 }
10355 case 0xa2:
10356 {
10357 InvalidInstruction(4);
10358 break;
10359 }
10360 case 0xa3:
10361 {
10362 InvalidInstruction(4);
10363 break;
10364 }
10365 case 0xa4:
10366 {
10367 InvalidInstruction(4);
10368 break;
10369 }
10370 case 0xa5:
10371 {
10372 InvalidInstruction(4);
10373 break;
10374 }
10375 case 0xa6:
10376 {
10377 sdwCyclesRemaining -= 23;
10378 bTemp &= 0xef;
10379 psMemWrite = cpu.z80MemWrite; /* Beginning of our handler */
10380 while (psMemWrite->lowAddr != 0xffffffff)
10381 {
10382 if ((dwAddr >= psMemWrite->lowAddr) && (dwAddr <= psMemWrite->highAddr))
10383 {
10384 cpu.z80pc = (UINT32) pbPC - (UINT32) cpu.z80Base;
10385 if (psMemWrite->memoryCall)
10386 {
10387 psMemWrite->memoryCall(dwAddr, bTemp, psMemWrite);
10388 }
10389 else
10390 {
10391 *((UINT8 *) psMemWrite->pUserArea + (dwAddr - psMemWrite->lowAddr)) = bTemp;
10392 }
10393 psMemWrite = NULL;
10394 break;
10395 }
10396 ++psMemWrite;
10397 }
10398
10399 if (psMemWrite)
10400 {
10401 cpu.z80Base[dwAddr] = (UINT8) bTemp;
10402 }
10403
10404 break;
10405 }
10406 case 0xa7:
10407 {
10408 InvalidInstruction(4);
10409 break;
10410 }
10411 case 0xa8:
10412 {
10413 InvalidInstruction(4);
10414 break;
10415 }
10416 case 0xa9:
10417 {
10418 InvalidInstruction(4);
10419 break;
10420 }
10421 case 0xaa:
10422 {
10423 InvalidInstruction(4);
10424 break;
10425 }
10426 case 0xab:
10427 {
10428 InvalidInstruction(4);
10429 break;
10430 }
10431 case 0xac:
10432 {
10433 InvalidInstruction(4);
10434 break;
10435 }
10436 case 0xad:
10437 {
10438 InvalidInstruction(4);
10439 break;
10440 }
10441 case 0xae:
10442 {
10443 sdwCyclesRemaining -= 23;
10444 bTemp &= 0xdf;
10445 psMemWrite = cpu.z80MemWrite; /* Beginning of our handler */
10446 while (psMemWrite->lowAddr != 0xffffffff)
10447 {
10448 if ((dwAddr >= psMemWrite->lowAddr) && (dwAddr <= psMemWrite->highAddr))
10449 {
10450 cpu.z80pc = (UINT32) pbPC - (UINT32) cpu.z80Base;
10451 if (psMemWrite->memoryCall)
10452 {
10453 psMemWrite->memoryCall(dwAddr, bTemp, psMemWrite);
10454 }
10455 else
10456 {
10457 *((UINT8 *) psMemWrite->pUserArea + (dwAddr - psMemWrite->lowAddr)) = bTemp;
10458 }
10459 psMemWrite = NULL;
10460 break;
10461 }
10462 ++psMemWrite;
10463 }
10464
10465 if (psMemWrite)
10466 {
10467 cpu.z80Base[dwAddr] = (UINT8) bTemp;
10468 }
10469
10470 break;
10471 }
10472 case 0xaf:
10473 {
10474 InvalidInstruction(4);
10475 break;
10476 }
10477 case 0xb0:
10478 {
10479 InvalidInstruction(4);
10480 break;
10481 }
10482 case 0xb1:
10483 {
10484 InvalidInstruction(4);
10485 break;
10486 }
10487 case 0xb2:
10488 {
10489 InvalidInstruction(4);
10490 break;
10491 }
10492 case 0xb3:
10493 {
10494 InvalidInstruction(4);
10495 break;
10496 }
10497 case 0xb4:
10498 {
10499 InvalidInstruction(4);
10500 break;
10501 }
10502 case 0xb5:
10503 {
10504 InvalidInstruction(4);
10505 break;
10506 }
10507 case 0xb6:
10508 {
10509 sdwCyclesRemaining -= 23;
10510 bTemp &= 0xbf;
10511 psMemWrite = cpu.z80MemWrite; /* Beginning of our handler */
10512 while (psMemWrite->lowAddr != 0xffffffff)
10513 {
10514 if ((dwAddr >= psMemWrite->lowAddr) && (dwAddr <= psMemWrite->highAddr))
10515 {
10516 cpu.z80pc = (UINT32) pbPC - (UINT32) cpu.z80Base;
10517 if (psMemWrite->memoryCall)
10518 {
10519 psMemWrite->memoryCall(dwAddr, bTemp, psMemWrite);
10520 }
10521 else
10522 {
10523 *((UINT8 *) psMemWrite->pUserArea + (dwAddr - psMemWrite->lowAddr)) = bTemp;
10524 }
10525 psMemWrite = NULL;
10526 break;
10527 }
10528 ++psMemWrite;
10529 }
10530
10531 if (psMemWrite)
10532 {
10533 cpu.z80Base[dwAddr] = (UINT8) bTemp;
10534 }
10535
10536 break;
10537 }
10538 case 0xb7:
10539 {
10540 InvalidInstruction(4);
10541 break;
10542 }
10543 case 0xb8:
10544 {
10545 InvalidInstruction(4);
10546 break;
10547 }
10548 case 0xb9:
10549 {
10550 InvalidInstruction(4);
10551 break;
10552 }
10553 case 0xba:
10554 {
10555 InvalidInstruction(4);
10556 break;
10557 }
10558 case 0xbb:
10559 {
10560 InvalidInstruction(4);
10561 break;
10562 }
10563 case 0xbc:
10564 {
10565 InvalidInstruction(4);
10566 break;
10567 }
10568 case 0xbd:
10569 {
10570 InvalidInstruction(4);
10571 break;
10572 }
10573 case 0xbe:
10574 {
10575 sdwCyclesRemaining -= 23;
10576 bTemp &= 0x7f;
10577 psMemWrite = cpu.z80MemWrite; /* Beginning of our handler */
10578 while (psMemWrite->lowAddr != 0xffffffff)
10579 {
10580 if ((dwAddr >= psMemWrite->lowAddr) && (dwAddr <= psMemWrite->highAddr))
10581 {
10582 cpu.z80pc = (UINT32) pbPC - (UINT32) cpu.z80Base;
10583 if (psMemWrite->memoryCall)
10584 {
10585 psMemWrite->memoryCall(dwAddr, bTemp, psMemWrite);
10586 }
10587 else
10588 {
10589 *((UINT8 *) psMemWrite->pUserArea + (dwAddr - psMemWrite->lowAddr)) = bTemp;
10590 }
10591 psMemWrite = NULL;
10592 break;
10593 }
10594 ++psMemWrite;
10595 }
10596
10597 if (psMemWrite)
10598 {
10599 cpu.z80Base[dwAddr] = (UINT8) bTemp;
10600 }
10601
10602 break;
10603 }
10604 case 0xbf:
10605 {
10606 InvalidInstruction(4);
10607 break;
10608 }
10609 case 0xc0:
10610 {
10611 InvalidInstruction(4);
10612 break;
10613 }
10614 case 0xc1:
10615 {
10616 InvalidInstruction(4);
10617 break;
10618 }
10619 case 0xc2:
10620 {
10621 InvalidInstruction(4);
10622 break;
10623 }
10624 case 0xc3:
10625 {
10626 InvalidInstruction(4);
10627 break;
10628 }
10629 case 0xc4:
10630 {
10631 InvalidInstruction(4);
10632 break;
10633 }
10634 case 0xc5:
10635 {
10636 InvalidInstruction(4);
10637 break;
10638 }
10639 case 0xc6:
10640 {
10641 sdwCyclesRemaining -= 23;
10642 bTemp |= 0x01;
10643 psMemWrite = cpu.z80MemWrite; /* Beginning of our handler */
10644 while (psMemWrite->lowAddr != 0xffffffff)
10645 {
10646 if ((dwAddr >= psMemWrite->lowAddr) && (dwAddr <= psMemWrite->highAddr))
10647 {
10648 cpu.z80pc = (UINT32) pbPC - (UINT32) cpu.z80Base;
10649 if (psMemWrite->memoryCall)
10650 {
10651 psMemWrite->memoryCall(dwAddr, bTemp, psMemWrite);
10652 }
10653 else
10654 {
10655 *((UINT8 *) psMemWrite->pUserArea + (dwAddr - psMemWrite->lowAddr)) = bTemp;
10656 }
10657 psMemWrite = NULL;
10658 break;
10659 }
10660 ++psMemWrite;
10661 }
10662
10663 if (psMemWrite)
10664 {
10665 cpu.z80Base[dwAddr] = (UINT8) bTemp;
10666 }
10667
10668 break;
10669 }
10670 case 0xc7:
10671 {
10672 InvalidInstruction(4);
10673 break;
10674 }
10675 case 0xc8:
10676 {
10677 InvalidInstruction(4);
10678 break;
10679 }
10680 case 0xc9:
10681 {
10682 InvalidInstruction(4);
10683 break;
10684 }
10685 case 0xca:
10686 {
10687 InvalidInstruction(4);
10688 break;
10689 }
10690 case 0xcb:
10691 {
10692 InvalidInstruction(4);
10693 break;
10694 }
10695 case 0xcc:
10696 {
10697 InvalidInstruction(4);
10698 break;
10699 }
10700 case 0xcd:
10701 {
10702 InvalidInstruction(4);
10703 break;
10704 }
10705 case 0xce:
10706 {
10707 sdwCyclesRemaining -= 23;
10708 bTemp |= 0x02;
10709 psMemWrite = cpu.z80MemWrite; /* Beginning of our handler */
10710 while (psMemWrite->lowAddr != 0xffffffff)
10711 {
10712 if ((dwAddr >= psMemWrite->lowAddr) && (dwAddr <= psMemWrite->highAddr))
10713 {
10714 cpu.z80pc = (UINT32) pbPC - (UINT32) cpu.z80Base;
10715 if (psMemWrite->memoryCall)
10716 {
10717 psMemWrite->memoryCall(dwAddr, bTemp, psMemWrite);
10718 }
10719 else
10720 {
10721 *((UINT8 *) psMemWrite->pUserArea + (dwAddr - psMemWrite->lowAddr)) = bTemp;
10722 }
10723 psMemWrite = NULL;
10724 break;
10725 }
10726 ++psMemWrite;
10727 }
10728
10729 if (psMemWrite)
10730 {
10731 cpu.z80Base[dwAddr] = (UINT8) bTemp;
10732 }
10733
10734 break;
10735 }
10736 case 0xcf:
10737 {
10738 InvalidInstruction(4);
10739 break;
10740 }
10741 case 0xd0:
10742 {
10743 InvalidInstruction(4);
10744 break;
10745 }
10746 case 0xd1:
10747 {
10748 InvalidInstruction(4);
10749 break;
10750 }
10751 case 0xd2:
10752 {
10753 InvalidInstruction(4);
10754 break;
10755 }
10756 case 0xd3:
10757 {
10758 InvalidInstruction(4);
10759 break;
10760 }
10761 case 0xd4:
10762 {
10763 InvalidInstruction(4);
10764 break;
10765 }
10766 case 0xd5:
10767 {
10768 InvalidInstruction(4);
10769 break;
10770 }
10771 case 0xd6:
10772 {
10773 sdwCyclesRemaining -= 23;
10774 bTemp |= 0x04;
10775 psMemWrite = cpu.z80MemWrite; /* Beginning of our handler */
10776 while (psMemWrite->lowAddr != 0xffffffff)
10777 {
10778 if ((dwAddr >= psMemWrite->lowAddr) && (dwAddr <= psMemWrite->highAddr))
10779 {
10780 cpu.z80pc = (UINT32) pbPC - (UINT32) cpu.z80Base;
10781 if (psMemWrite->memoryCall)
10782 {
10783 psMemWrite->memoryCall(dwAddr, bTemp, psMemWrite);
10784 }
10785 else
10786 {
10787 *((UINT8 *) psMemWrite->pUserArea + (dwAddr - psMemWrite->lowAddr)) = bTemp;
10788 }
10789 psMemWrite = NULL;
10790 break;
10791 }
10792 ++psMemWrite;
10793 }
10794
10795 if (psMemWrite)
10796 {
10797 cpu.z80Base[dwAddr] = (UINT8) bTemp;
10798 }
10799
10800 break;
10801 }
10802 case 0xd7:
10803 {
10804 InvalidInstruction(4);
10805 break;
10806 }
10807 case 0xd8:
10808 {
10809 InvalidInstruction(4);
10810 break;
10811 }
10812 case 0xd9:
10813 {
10814 InvalidInstruction(4);
10815 break;
10816 }
10817 case 0xda:
10818 {
10819 InvalidInstruction(4);
10820 break;
10821 }
10822 case 0xdb:
10823 {
10824 InvalidInstruction(4);
10825 break;
10826 }
10827 case 0xdc:
10828 {
10829 InvalidInstruction(4);
10830 break;
10831 }
10832 case 0xdd:
10833 {
10834 InvalidInstruction(4);
10835 break;
10836 }
10837 case 0xde:
10838 {
10839 sdwCyclesRemaining -= 23;
10840 bTemp |= 0x08;
10841 psMemWrite = cpu.z80MemWrite; /* Beginning of our handler */
10842 while (psMemWrite->lowAddr != 0xffffffff)
10843 {
10844 if ((dwAddr >= psMemWrite->lowAddr) && (dwAddr <= psMemWrite->highAddr))
10845 {
10846 cpu.z80pc = (UINT32) pbPC - (UINT32) cpu.z80Base;
10847 if (psMemWrite->memoryCall)
10848 {
10849 psMemWrite->memoryCall(dwAddr, bTemp, psMemWrite);
10850 }
10851 else
10852 {
10853 *((UINT8 *) psMemWrite->pUserArea + (dwAddr - psMemWrite->lowAddr)) = bTemp;
10854 }
10855 psMemWrite = NULL;
10856 break;
10857 }
10858 ++psMemWrite;
10859 }
10860
10861 if (psMemWrite)
10862 {
10863 cpu.z80Base[dwAddr] = (UINT8) bTemp;
10864 }
10865
10866 break;
10867 }
10868 case 0xdf:
10869 {
10870 InvalidInstruction(4);
10871 break;
10872 }
10873 case 0xe0:
10874 {
10875 InvalidInstruction(4);
10876 break;
10877 }
10878 case 0xe1:
10879 {
10880 InvalidInstruction(4);
10881 break;
10882 }
10883 case 0xe2:
10884 {
10885 InvalidInstruction(4);
10886 break;
10887 }
10888 case 0xe3:
10889 {
10890 InvalidInstruction(4);
10891 break;
10892 }
10893 case 0xe4:
10894 {
10895 InvalidInstruction(4);
10896 break;
10897 }
10898 case 0xe5:
10899 {
10900 InvalidInstruction(4);
10901 break;
10902 }
10903 case 0xe6:
10904 {
10905 sdwCyclesRemaining -= 23;
10906 bTemp |= 0x10;
10907 psMemWrite = cpu.z80MemWrite; /* Beginning of our handler */
10908 while (psMemWrite->lowAddr != 0xffffffff)
10909 {
10910 if ((dwAddr >= psMemWrite->lowAddr) && (dwAddr <= psMemWrite->highAddr))
10911 {
10912 cpu.z80pc = (UINT32) pbPC - (UINT32) cpu.z80Base;
10913 if (psMemWrite->memoryCall)
10914 {
10915 psMemWrite->memoryCall(dwAddr, bTemp, psMemWrite);
10916 }
10917 else
10918 {
10919 *((UINT8 *) psMemWrite->pUserArea + (dwAddr - psMemWrite->lowAddr)) = bTemp;
10920 }
10921 psMemWrite = NULL;
10922 break;
10923 }
10924 ++psMemWrite;
10925 }
10926
10927 if (psMemWrite)
10928 {
10929 cpu.z80Base[dwAddr] = (UINT8) bTemp;
10930 }
10931
10932 break;
10933 }
10934 case 0xe7:
10935 {
10936 InvalidInstruction(4);
10937 break;
10938 }
10939 case 0xe8:
10940 {
10941 InvalidInstruction(4);
10942 break;
10943 }
10944 case 0xe9:
10945 {
10946 InvalidInstruction(4);
10947 break;
10948 }
10949 case 0xea:
10950 {
10951 InvalidInstruction(4);
10952 break;
10953 }
10954 case 0xeb:
10955 {
10956 InvalidInstruction(4);
10957 break;
10958 }
10959 case 0xec:
10960 {
10961 InvalidInstruction(4);
10962 break;
10963 }
10964 case 0xed:
10965 {
10966 InvalidInstruction(4);
10967 break;
10968 }
10969 case 0xee:
10970 {
10971 sdwCyclesRemaining -= 23;
10972 bTemp |= 0x20;
10973 psMemWrite = cpu.z80MemWrite; /* Beginning of our handler */
10974 while (psMemWrite->lowAddr != 0xffffffff)
10975 {
10976 if ((dwAddr >= psMemWrite->lowAddr) && (dwAddr <= psMemWrite->highAddr))
10977 {
10978 cpu.z80pc = (UINT32) pbPC - (UINT32) cpu.z80Base;
10979 if (psMemWrite->memoryCall)
10980 {
10981 psMemWrite->memoryCall(dwAddr, bTemp, psMemWrite);
10982 }
10983 else
10984 {
10985 *((UINT8 *) psMemWrite->pUserArea + (dwAddr - psMemWrite->lowAddr)) = bTemp;
10986 }
10987 psMemWrite = NULL;
10988 break;
10989 }
10990 ++psMemWrite;
10991 }
10992
10993 if (psMemWrite)
10994 {
10995 cpu.z80Base[dwAddr] = (UINT8) bTemp;
10996 }
10997
10998 break;
10999 }
11000 case 0xef:
11001 {
11002 InvalidInstruction(4);
11003 break;
11004 }
11005 case 0xf0:
11006 {
11007 InvalidInstruction(4);
11008 break;
11009 }
11010 case 0xf1:
11011 {
11012 InvalidInstruction(4);
11013 break;
11014 }
11015 case 0xf2:
11016 {
11017 InvalidInstruction(4);
11018 break;
11019 }
11020 case 0xf3:
11021 {
11022 InvalidInstruction(4);
11023 break;
11024 }
11025 case 0xf4:
11026 {
11027 InvalidInstruction(4);
11028 break;
11029 }
11030 case 0xf5:
11031 {
11032 InvalidInstruction(4);
11033 break;
11034 }
11035 case 0xf6:
11036 {
11037 sdwCyclesRemaining -= 23;
11038 bTemp |= 0x40;
11039 psMemWrite = cpu.z80MemWrite; /* Beginning of our handler */
11040 while (psMemWrite->lowAddr != 0xffffffff)
11041 {
11042 if ((dwAddr >= psMemWrite->lowAddr) && (dwAddr <= psMemWrite->highAddr))
11043 {
11044 cpu.z80pc = (UINT32) pbPC - (UINT32) cpu.z80Base;
11045 if (psMemWrite->memoryCall)
11046 {
11047 psMemWrite->memoryCall(dwAddr, bTemp, psMemWrite);
11048 }
11049 else
11050 {
11051 *((UINT8 *) psMemWrite->pUserArea + (dwAddr - psMemWrite->lowAddr)) = bTemp;
11052 }
11053 psMemWrite = NULL;
11054 break;
11055 }
11056 ++psMemWrite;
11057 }
11058
11059 if (psMemWrite)
11060 {
11061 cpu.z80Base[dwAddr] = (UINT8) bTemp;
11062 }
11063
11064 break;
11065 }
11066 case 0xf7:
11067 {
11068 InvalidInstruction(4);
11069 break;
11070 }
11071 case 0xf8:
11072 {
11073 InvalidInstruction(4);
11074 break;
11075 }
11076 case 0xf9:
11077 {
11078 InvalidInstruction(4);
11079 break;
11080 }
11081 case 0xfa:
11082 {
11083 InvalidInstruction(4);
11084 break;
11085 }
11086 case 0xfb:
11087 {
11088 InvalidInstruction(4);
11089 break;
11090 }
11091 case 0xfc:
11092 {
11093 InvalidInstruction(4);
11094 break;
11095 }
11096 case 0xfd:
11097 {
11098 InvalidInstruction(4);
11099 break;
11100 }
11101 case 0xfe:
11102 {
11103 sdwCyclesRemaining -= 23;
11104 bTemp |= 0x80;
11105 psMemWrite = cpu.z80MemWrite; /* Beginning of our handler */
11106 while (psMemWrite->lowAddr != 0xffffffff)
11107 {
11108 if ((dwAddr >= psMemWrite->lowAddr) && (dwAddr <= psMemWrite->highAddr))
11109 {
11110 cpu.z80pc = (UINT32) pbPC - (UINT32) cpu.z80Base;
11111 if (psMemWrite->memoryCall)
11112 {
11113 psMemWrite->memoryCall(dwAddr, bTemp, psMemWrite);
11114 }
11115 else
11116 {
11117 *((UINT8 *) psMemWrite->pUserArea + (dwAddr - psMemWrite->lowAddr)) = bTemp;
11118 }
11119 psMemWrite = NULL;
11120 break;
11121 }
11122 ++psMemWrite;
11123 }
11124
11125 if (psMemWrite)
11126 {
11127 cpu.z80Base[dwAddr] = (UINT8) bTemp;
11128 }
11129
11130 break;
11131 }
11132 case 0xff:
11133 {
11134 InvalidInstruction(4);
11135 break;
11136 }
11137 }
11138}
11139void FDHandler(void)
11140{
11141 switch (*pbPC++)
11142 {
11143 case 0x00:
11144 {
11145 InvalidInstruction(2);
11146 break;
11147 }
11148 case 0x01:
11149 {
11150 InvalidInstruction(2);
11151 break;
11152 }
11153 case 0x02:
11154 {
11155 InvalidInstruction(2);
11156 break;
11157 }
11158 case 0x03:
11159 {
11160 InvalidInstruction(2);
11161 break;
11162 }
11163 case 0x04:
11164 {
11165 InvalidInstruction(2);
11166 break;
11167 }
11168 case 0x05:
11169 {
11170 InvalidInstruction(2);
11171 break;
11172 }
11173 case 0x06:
11174 {
11175 InvalidInstruction(2);
11176 break;
11177 }
11178 case 0x07:
11179 {
11180 InvalidInstruction(2);
11181 break;
11182 }
11183 case 0x08:
11184 {
11185 InvalidInstruction(2);
11186 break;
11187 }
11188 case 0x09:
11189 {
11190 sdwCyclesRemaining -= 15;
11191 cpu.z80F &= ~(Z80_FLAG_CARRY | Z80_FLAG_NEGATIVE | Z80_FLAG_HALF_CARRY);
11192 dwTemp = cpu.z80IY + cpu.z80BC;
11193 cpu.z80F |= ((dwTemp >> 16) & Z80_FLAG_CARRY) | (((cpu.z80IY ^ dwTemp ^ cpu.z80BC) >> 8) & Z80_FLAG_HALF_CARRY);
11194 cpu.z80IY = dwTemp & 0xffff;
11195 break;
11196 }
11197 case 0x0a:
11198 {
11199 InvalidInstruction(2);
11200 break;
11201 }
11202 case 0x0b:
11203 {
11204 InvalidInstruction(2);
11205 break;
11206 }
11207 case 0x0c:
11208 {
11209 InvalidInstruction(2);
11210 break;
11211 }
11212 case 0x0d:
11213 {
11214 InvalidInstruction(2);
11215 break;
11216 }
11217 case 0x0e:
11218 {
11219 InvalidInstruction(2);
11220 break;
11221 }
11222 case 0x0f:
11223 {
11224 InvalidInstruction(2);
11225 break;
11226 }
11227 case 0x10:
11228 {
11229 InvalidInstruction(2);
11230 break;
11231 }
11232 case 0x11:
11233 {
11234 InvalidInstruction(2);
11235 break;
11236 }
11237 case 0x12:
11238 {
11239 InvalidInstruction(2);
11240 break;
11241 }
11242 case 0x13:
11243 {
11244 InvalidInstruction(2);
11245 break;
11246 }
11247 case 0x14:
11248 {
11249 InvalidInstruction(2);
11250 break;
11251 }
11252 case 0x15:
11253 {
11254 InvalidInstruction(2);
11255 break;
11256 }
11257 case 0x16:
11258 {
11259 InvalidInstruction(2);
11260 break;
11261 }
11262 case 0x17:
11263 {
11264 InvalidInstruction(2);
11265 break;
11266 }
11267 case 0x18:
11268 {
11269 InvalidInstruction(2);
11270 break;
11271 }
11272 case 0x19:
11273 {
11274 sdwCyclesRemaining -= 15;
11275 cpu.z80F &= ~(Z80_FLAG_CARRY | Z80_FLAG_NEGATIVE | Z80_FLAG_HALF_CARRY);
11276 dwTemp = cpu.z80IY + cpu.z80DE;
11277 cpu.z80F |= ((dwTemp >> 16) & Z80_FLAG_CARRY) | (((cpu.z80IY ^ dwTemp ^ cpu.z80DE) >> 8) & Z80_FLAG_HALF_CARRY);
11278 cpu.z80IY = dwTemp & 0xffff;
11279 break;
11280 }
11281 case 0x1a:
11282 {
11283 InvalidInstruction(2);
11284 break;
11285 }
11286 case 0x1b:
11287 {
11288 InvalidInstruction(2);
11289 break;
11290 }
11291 case 0x1c:
11292 {
11293 InvalidInstruction(2);
11294 break;
11295 }
11296 case 0x1d:
11297 {
11298 InvalidInstruction(2);
11299 break;
11300 }
11301 case 0x1e:
11302 {
11303 InvalidInstruction(2);
11304 break;
11305 }
11306 case 0x1f:
11307 {
11308 InvalidInstruction(2);
11309 break;
11310 }
11311 case 0x20:
11312 {
11313 InvalidInstruction(2);
11314 break;
11315 }
11316 case 0x21:
11317 {
11318 sdwCyclesRemaining -= 14;
11319 cpu.z80IY = *pbPC++;
11320 cpu.z80IY |= ((UINT32) *pbPC++ << 8);
11321 break;
11322 }
11323 case 0x22:
11324 {
11325 sdwCyclesRemaining -= 20;
11326 dwAddr = *pbPC++;
11327 dwAddr |= ((UINT32) *pbPC++ << 8);
11328 psMemWrite = cpu.z80MemWrite; /* Beginning of our handler */
11329 while (psMemWrite->lowAddr != 0xffffffff)
11330 {
11331 if ((dwAddr >= psMemWrite->lowAddr) && (dwAddr <= psMemWrite->highAddr))
11332 {
11333 cpu.z80pc = (UINT32) pbPC - (UINT32) cpu.z80Base;
11334 if (psMemWrite->memoryCall)
11335 {
11336 psMemWrite->memoryCall(dwAddr, (cpu.z80IY & 0xff), psMemWrite);
11337 psMemWrite->memoryCall(dwAddr + 1, (cpu.z80IY >> 8), psMemWrite);
11338 }
11339 else
11340 {
11341 *((UINT8 *) psMemWrite->pUserArea + (dwAddr - psMemWrite->lowAddr)) = cpu.z80IY;
11342 *((UINT8 *) psMemWrite->pUserArea + (dwAddr - psMemWrite->lowAddr) + 1) = cpu.z80IY >> 8;
11343 }
11344 psMemWrite = NULL;
11345 break;
11346 }
11347 ++psMemWrite;
11348 }
11349
11350 if (psMemWrite)
11351 {
11352 cpu.z80Base[dwAddr] = (UINT8) cpu.z80IY;
11353 cpu.z80Base[dwAddr + 1] = (UINT8) ((UINT32) cpu.z80IY >> 8);
11354 }
11355
11356 break;
11357 }
11358 case 0x23:
11359 {
11360 sdwCyclesRemaining -= 10;
11361 cpu.z80IY++;
11362 cpu.z80IY &= 0xffff;
11363 break;
11364 }
11365 case 0x24:
11366 {
11367 sdwCyclesRemaining -= 9;
11368 cpu.z80F &= ~(Z80_FLAG_SIGN | Z80_FLAG_ZERO | Z80_FLAG_HALF_CARRY | Z80_FLAG_OVERFLOW_PARITY | Z80_FLAG_NEGATIVE);
11369 cpu.z80F |= bPostIncFlags[cpu.z80YH++];
11370 break;
11371 }
11372 case 0x25:
11373 {
11374 sdwCyclesRemaining -= 9;
11375 cpu.z80F &= ~(Z80_FLAG_SIGN | Z80_FLAG_ZERO | Z80_FLAG_HALF_CARRY | Z80_FLAG_OVERFLOW_PARITY | Z80_FLAG_NEGATIVE);
11376 cpu.z80F |= bPostDecFlags[cpu.z80YH--];
11377 break;
11378 }
11379 case 0x26:
11380 {
11381 sdwCyclesRemaining -= 9;
11382 cpu.z80YH = *pbPC++;
11383 break;
11384 }
11385 case 0x27:
11386 {
11387 InvalidInstruction(2);
11388 break;
11389 }
11390 case 0x28:
11391 {
11392 InvalidInstruction(2);
11393 break;
11394 }
11395 case 0x29:
11396 {
11397 sdwCyclesRemaining -= 15;
11398 cpu.z80F &= ~(Z80_FLAG_CARRY | Z80_FLAG_NEGATIVE | Z80_FLAG_HALF_CARRY);
11399 dwTemp = cpu.z80IY + cpu.z80IY;
11400 cpu.z80F |= ((dwTemp >> 16) & Z80_FLAG_CARRY) | (((cpu.z80IY ^ dwTemp ^ cpu.z80HL) >> 8) & Z80_FLAG_HALF_CARRY);
11401 cpu.z80IY = dwTemp & 0xffff;
11402 break;
11403 }
11404 case 0x2a:
11405 {
11406 sdwCyclesRemaining -= 20;
11407 dwAddr = *pbPC++;
11408 dwAddr |= ((UINT32) *pbPC++ << 8);
11409 psMemRead = cpu.z80MemRead; /* Beginning of our handler */
11410 while (psMemRead->lowAddr != 0xffffffff)
11411 {
11412 if ((dwAddr >= psMemRead->lowAddr) && (dwAddr <= psMemRead->highAddr))
11413 {
11414 cpu.z80pc = (UINT32) pbPC - (UINT32) cpu.z80Base;
11415 if (psMemRead->memoryCall)
11416 {
11417 cpu.z80IY = psMemRead->memoryCall(dwAddr, psMemRead);
11418 cpu.z80IY |= (UINT32) ((UINT32) psMemRead->memoryCall(dwAddr + 1, psMemRead) << 8);
11419 }
11420 else
11421 {
11422 cpu.z80IY = *((UINT8 *) psMemRead->pUserArea + (dwAddr - psMemRead->lowAddr));
11423 cpu.z80IY |= (UINT32) ((UINT32) *((UINT8 *) psMemRead->pUserArea + (dwAddr - psMemRead->lowAddr + 1)) << 8);
11424 }
11425 psMemRead = NULL;
11426 break;
11427 }
11428 ++psMemRead;
11429 }
11430
11431 if (psMemRead)
11432 {
11433 cpu.z80IY = cpu.z80Base[dwAddr];
11434 cpu.z80IY |= (UINT32) ((UINT32) cpu.z80Base[dwAddr + 1] << 8);
11435 }
11436
11437 break;
11438 }
11439 case 0x2b:
11440 {
11441 sdwCyclesRemaining -= 10;
11442 cpu.z80IY--;
11443 cpu.z80IY &= 0xffff;
11444 break;
11445 }
11446 case 0x2c:
11447 {
11448 sdwCyclesRemaining -= 9;
11449 cpu.z80F &= ~(Z80_FLAG_SIGN | Z80_FLAG_ZERO | Z80_FLAG_HALF_CARRY | Z80_FLAG_OVERFLOW_PARITY | Z80_FLAG_NEGATIVE);
11450 cpu.z80F |= bPostIncFlags[cpu.z80YL++];
11451 break;
11452 }
11453 case 0x2d:
11454 {
11455 sdwCyclesRemaining -= 9;
11456 cpu.z80F &= ~(Z80_FLAG_SIGN | Z80_FLAG_ZERO | Z80_FLAG_HALF_CARRY | Z80_FLAG_OVERFLOW_PARITY | Z80_FLAG_NEGATIVE);
11457 cpu.z80F |= bPostDecFlags[cpu.z80YL--];
11458 break;
11459 }
11460 case 0x2e:
11461 {
11462 sdwCyclesRemaining -= 9;
11463 cpu.z80YL = *pbPC++;
11464 break;
11465 }
11466 case 0x2f:
11467 {
11468 InvalidInstruction(2);
11469 break;
11470 }
11471 case 0x30:
11472 {
11473 InvalidInstruction(2);
11474 break;
11475 }
11476 case 0x31:
11477 {
11478 InvalidInstruction(2);
11479 break;
11480 }
11481 case 0x32:
11482 {
11483 InvalidInstruction(2);
11484 break;
11485 }
11486 case 0x33:
11487 {
11488 InvalidInstruction(2);
11489 break;
11490 }
11491 case 0x34:
11492 {
11493 sdwCyclesRemaining -= 23;
11494 sdwAddr = (INT8) *pbPC++; /* Get LSB first */
11495 dwAddr = (sdwAddr + (INT32) cpu.z80IY) & 0xffff;
11496 psMemRead = cpu.z80MemRead; /* Beginning of our handler */
11497 while (psMemRead->lowAddr != 0xffffffff)
11498 {
11499 if ((dwAddr >= psMemRead->lowAddr) && (dwAddr <= psMemRead->highAddr))
11500 {
11501 cpu.z80pc = (UINT32) pbPC - (UINT32) cpu.z80Base;
11502 if (psMemRead->memoryCall)
11503 {
11504 bTemp = psMemRead->memoryCall(dwAddr, psMemRead);
11505 }
11506 else
11507 {
11508 bTemp = *((UINT8 *) psMemRead->pUserArea + (dwAddr - psMemRead->lowAddr));
11509 }
11510 psMemRead = NULL;
11511 break;
11512 }
11513 ++psMemRead;
11514 }
11515
11516 if (psMemRead)
11517 {
11518 bTemp = cpu.z80Base[dwAddr];
11519 }
11520
11521 cpu.z80F &= ~(Z80_FLAG_SIGN | Z80_FLAG_ZERO | Z80_FLAG_HALF_CARRY | Z80_FLAG_OVERFLOW_PARITY | Z80_FLAG_NEGATIVE);
11522 cpu.z80F |= bPostIncFlags[bTemp++];
11523 psMemWrite = cpu.z80MemWrite; /* Beginning of our handler */
11524 while (psMemWrite->lowAddr != 0xffffffff)
11525 {
11526 if ((dwAddr >= psMemWrite->lowAddr) && (dwAddr <= psMemWrite->highAddr))
11527 {
11528 cpu.z80pc = (UINT32) pbPC - (UINT32) cpu.z80Base;
11529 if (psMemWrite->memoryCall)
11530 {
11531 psMemWrite->memoryCall(dwAddr, bTemp, psMemWrite);
11532 }
11533 else
11534 {
11535 *((UINT8 *) psMemWrite->pUserArea + (dwAddr - psMemWrite->lowAddr)) = bTemp;
11536 }
11537 psMemWrite = NULL;
11538 break;
11539 }
11540 ++psMemWrite;
11541 }
11542
11543 if (psMemWrite)
11544 {
11545 cpu.z80Base[dwAddr] = (UINT8) bTemp;
11546 }
11547
11548 break;
11549 }
11550 case 0x35:
11551 {
11552 sdwCyclesRemaining -= 23;
11553 sdwAddr = (INT8) *pbPC++; /* Get LSB first */
11554 dwAddr = (sdwAddr + (INT32) cpu.z80IY) & 0xffff;
11555 psMemRead = cpu.z80MemRead; /* Beginning of our handler */
11556 while (psMemRead->lowAddr != 0xffffffff)
11557 {
11558 if ((dwAddr >= psMemRead->lowAddr) && (dwAddr <= psMemRead->highAddr))
11559 {
11560 cpu.z80pc = (UINT32) pbPC - (UINT32) cpu.z80Base;
11561 if (psMemRead->memoryCall)
11562 {
11563 bTemp = psMemRead->memoryCall(dwAddr, psMemRead);
11564 }
11565 else
11566 {
11567 bTemp = *((UINT8 *) psMemRead->pUserArea + (dwAddr - psMemRead->lowAddr));
11568 }
11569 psMemRead = NULL;
11570 break;
11571 }
11572 ++psMemRead;
11573 }
11574
11575 if (psMemRead)
11576 {
11577 bTemp = cpu.z80Base[dwAddr];
11578 }
11579
11580 cpu.z80F &= ~(Z80_FLAG_SIGN | Z80_FLAG_ZERO | Z80_FLAG_HALF_CARRY | Z80_FLAG_OVERFLOW_PARITY | Z80_FLAG_NEGATIVE);
11581 cpu.z80F |= bPostDecFlags[bTemp--];
11582 psMemWrite = cpu.z80MemWrite; /* Beginning of our handler */
11583 while (psMemWrite->lowAddr != 0xffffffff)
11584 {
11585 if ((dwAddr >= psMemWrite->lowAddr) && (dwAddr <= psMemWrite->highAddr))
11586 {
11587 cpu.z80pc = (UINT32) pbPC - (UINT32) cpu.z80Base;
11588 if (psMemWrite->memoryCall)
11589 {
11590 psMemWrite->memoryCall(dwAddr, bTemp, psMemWrite);
11591 }
11592 else
11593 {
11594 *((UINT8 *) psMemWrite->pUserArea + (dwAddr - psMemWrite->lowAddr)) = bTemp;
11595 }
11596 psMemWrite = NULL;
11597 break;
11598 }
11599 ++psMemWrite;
11600 }
11601
11602 if (psMemWrite)
11603 {
11604 cpu.z80Base[dwAddr] = (UINT8) bTemp;
11605 }
11606
11607 break;
11608 }
11609 case 0x36:
11610 {
11611 sdwCyclesRemaining -= 19;
11612 sdwAddr = (INT8) *pbPC++; // Get the offset
11613 sdwAddr = ((INT32) cpu.z80IY + sdwAddr) & 0xffff;
11614 psMemWrite = cpu.z80MemWrite; /* Beginning of our handler */
11615 while (psMemWrite->lowAddr != 0xffffffff)
11616 {
11617 if ((sdwAddr >= psMemWrite->lowAddr) && (sdwAddr <= psMemWrite->highAddr))
11618 {
11619 cpu.z80pc = (UINT32) pbPC - (UINT32) cpu.z80Base;
11620 if (psMemWrite->memoryCall)
11621 {
11622 psMemWrite->memoryCall(sdwAddr, *pbPC++, psMemWrite);
11623 }
11624 else
11625 {
11626 *((UINT8 *) psMemWrite->pUserArea + (sdwAddr - psMemWrite->lowAddr)) = *pbPC++;
11627 }
11628 psMemWrite = NULL;
11629 break;
11630 }
11631 ++psMemWrite;
11632 }
11633
11634 if (psMemWrite)
11635 {
11636 cpu.z80Base[sdwAddr] = (UINT8) *pbPC++;
11637 }
11638
11639 break;
11640 }
11641 case 0x37:
11642 {
11643 InvalidInstruction(2);
11644 break;
11645 }
11646 case 0x38:
11647 {
11648 InvalidInstruction(2);
11649 break;
11650 }
11651 case 0x39:
11652 {
11653 sdwCyclesRemaining -= 15;
11654 cpu.z80F &= ~(Z80_FLAG_CARRY | Z80_FLAG_NEGATIVE | Z80_FLAG_HALF_CARRY);
11655 dwTemp = cpu.z80IY + cpu.z80sp;
11656 cpu.z80F |= ((dwTemp >> 16) & Z80_FLAG_CARRY) | (((cpu.z80IY ^ dwTemp ^ cpu.z80sp) >> 8) & Z80_FLAG_HALF_CARRY);
11657 cpu.z80IY = dwTemp & 0xffff;
11658 break;
11659 }
11660 case 0x3a:
11661 {
11662 InvalidInstruction(2);
11663 break;
11664 }
11665 case 0x3b:
11666 {
11667 InvalidInstruction(2);
11668 break;
11669 }
11670 case 0x3c:
11671 {
11672 InvalidInstruction(2);
11673 break;
11674 }
11675 case 0x3d:
11676 {
11677 InvalidInstruction(2);
11678 break;
11679 }
11680 case 0x3e:
11681 {
11682 InvalidInstruction(2);
11683 break;
11684 }
11685 case 0x3f:
11686 {
11687 InvalidInstruction(2);
11688 break;
11689 }
11690 case 0x40:
11691 {
11692 InvalidInstruction(2);
11693 break;
11694 }
11695 case 0x41:
11696 {
11697 InvalidInstruction(2);
11698 break;
11699 }
11700 case 0x42:
11701 {
11702 InvalidInstruction(2);
11703 break;
11704 }
11705 case 0x43:
11706 {
11707 InvalidInstruction(2);
11708 break;
11709 }
11710 case 0x44:
11711 {
11712 sdwCyclesRemaining -= 9;
11713 cpu.z80B = cpu.z80YH;
11714 break;
11715 }
11716 case 0x45:
11717 {
11718 sdwCyclesRemaining -= 9;
11719 cpu.z80B = cpu.z80YL;
11720 break;
11721 }
11722 case 0x46:
11723 {
11724 sdwCyclesRemaining -= 19;
11725 sdwAddr = (INT8) *pbPC++; // Get the offset
11726 sdwAddr = ((INT32) cpu.z80IY + sdwAddr) & 0xffff;
11727 psMemRead = cpu.z80MemRead; /* Beginning of our handler */
11728 while (psMemRead->lowAddr != 0xffffffff)
11729 {
11730 if ((sdwAddr >= psMemRead->lowAddr) && (sdwAddr <= psMemRead->highAddr))
11731 {
11732 cpu.z80pc = (UINT32) pbPC - (UINT32) cpu.z80Base;
11733 if (psMemRead->memoryCall)
11734 {
11735 cpu.z80B = psMemRead->memoryCall(sdwAddr, psMemRead);
11736 }
11737 else
11738 {
11739 cpu.z80B = *((UINT8 *) psMemRead->pUserArea + (sdwAddr - psMemRead->lowAddr));
11740 }
11741 psMemRead = NULL;
11742 break;
11743 }
11744 ++psMemRead;
11745 }
11746
11747 if (psMemRead)
11748 {
11749 cpu.z80B = cpu.z80Base[sdwAddr];
11750 }
11751
11752 break;
11753 }
11754 case 0x47:
11755 {
11756 InvalidInstruction(2);
11757 break;
11758 }
11759 case 0x48:
11760 {
11761 InvalidInstruction(2);
11762 break;
11763 }
11764 case 0x49:
11765 {
11766 InvalidInstruction(2);
11767 break;
11768 }
11769 case 0x4a:
11770 {
11771 InvalidInstruction(2);
11772 break;
11773 }
11774 case 0x4b:
11775 {
11776 InvalidInstruction(2);
11777 break;
11778 }
11779 case 0x4c:
11780 {
11781 sdwCyclesRemaining -= 9;
11782 cpu.z80C = cpu.z80YH;
11783 break;
11784 }
11785 case 0x4d:
11786 {
11787 sdwCyclesRemaining -= 9;
11788 cpu.z80C = cpu.z80YL;
11789 break;
11790 }
11791 case 0x4e:
11792 {
11793 sdwCyclesRemaining -= 19;
11794 sdwAddr = (INT8) *pbPC++; // Get the offset
11795 sdwAddr = ((INT32) cpu.z80IY + sdwAddr) & 0xffff;
11796 psMemRead = cpu.z80MemRead; /* Beginning of our handler */
11797 while (psMemRead->lowAddr != 0xffffffff)
11798 {
11799 if ((sdwAddr >= psMemRead->lowAddr) && (sdwAddr <= psMemRead->highAddr))
11800 {
11801 cpu.z80pc = (UINT32) pbPC - (UINT32) cpu.z80Base;
11802 if (psMemRead->memoryCall)
11803 {
11804 cpu.z80C = psMemRead->memoryCall(sdwAddr, psMemRead);
11805 }
11806 else
11807 {
11808 cpu.z80C = *((UINT8 *) psMemRead->pUserArea + (sdwAddr - psMemRead->lowAddr));
11809 }
11810 psMemRead = NULL;
11811 break;
11812 }
11813 ++psMemRead;
11814 }
11815
11816 if (psMemRead)
11817 {
11818 cpu.z80C = cpu.z80Base[sdwAddr];
11819 }
11820
11821 break;
11822 }
11823 case 0x4f:
11824 {
11825 InvalidInstruction(2);
11826 break;
11827 }
11828 case 0x50:
11829 {
11830 InvalidInstruction(2);
11831 break;
11832 }
11833 case 0x51:
11834 {
11835 InvalidInstruction(2);
11836 break;
11837 }
11838 case 0x52:
11839 {
11840 InvalidInstruction(2);
11841 break;
11842 }
11843 case 0x53:
11844 {
11845 InvalidInstruction(2);
11846 break;
11847 }
11848 case 0x54:
11849 {
11850 sdwCyclesRemaining -= 9;
11851 cpu.z80D = cpu.z80YH;
11852 break;
11853 }
11854 case 0x55:
11855 {
11856 sdwCyclesRemaining -= 9;
11857 cpu.z80D = cpu.z80YL;
11858 break;
11859 }
11860 case 0x56:
11861 {
11862 sdwCyclesRemaining -= 19;
11863 sdwAddr = (INT8) *pbPC++; // Get the offset
11864 sdwAddr = ((INT32) cpu.z80IY + sdwAddr) & 0xffff;
11865 psMemRead = cpu.z80MemRead; /* Beginning of our handler */
11866 while (psMemRead->lowAddr != 0xffffffff)
11867 {
11868 if ((sdwAddr >= psMemRead->lowAddr) && (sdwAddr <= psMemRead->highAddr))
11869 {
11870 cpu.z80pc = (UINT32) pbPC - (UINT32) cpu.z80Base;
11871 if (psMemRead->memoryCall)
11872 {
11873 cpu.z80D = psMemRead->memoryCall(sdwAddr, psMemRead);
11874 }
11875 else
11876 {
11877 cpu.z80D = *((UINT8 *) psMemRead->pUserArea + (sdwAddr - psMemRead->lowAddr));
11878 }
11879 psMemRead = NULL;
11880 break;
11881 }
11882 ++psMemRead;
11883 }
11884
11885 if (psMemRead)
11886 {
11887 cpu.z80D = cpu.z80Base[sdwAddr];
11888 }
11889
11890 break;
11891 }
11892 case 0x57:
11893 {
11894 InvalidInstruction(2);
11895 break;
11896 }
11897 case 0x58:
11898 {
11899 InvalidInstruction(2);
11900 break;
11901 }
11902 case 0x59:
11903 {
11904 InvalidInstruction(2);
11905 break;
11906 }
11907 case 0x5a:
11908 {
11909 InvalidInstruction(2);
11910 break;
11911 }
11912 case 0x5b:
11913 {
11914 InvalidInstruction(2);
11915 break;
11916 }
11917 case 0x5c:
11918 {
11919 sdwCyclesRemaining -= 9;
11920 cpu.z80E = cpu.z80YH;
11921 break;
11922 }
11923 case 0x5d:
11924 {
11925 sdwCyclesRemaining -= 9;
11926 cpu.z80E = cpu.z80YL;
11927 break;
11928 }
11929 case 0x5e:
11930 {
11931 sdwCyclesRemaining -= 19;
11932 sdwAddr = (INT8) *pbPC++; // Get the offset
11933 sdwAddr = ((INT32) cpu.z80IY + sdwAddr) & 0xffff;
11934 psMemRead = cpu.z80MemRead; /* Beginning of our handler */
11935 while (psMemRead->lowAddr != 0xffffffff)
11936 {
11937 if ((sdwAddr >= psMemRead->lowAddr) && (sdwAddr <= psMemRead->highAddr))
11938 {
11939 cpu.z80pc = (UINT32) pbPC - (UINT32) cpu.z80Base;
11940 if (psMemRead->memoryCall)
11941 {
11942 cpu.z80E = psMemRead->memoryCall(sdwAddr, psMemRead);
11943 }
11944 else
11945 {
11946 cpu.z80E = *((UINT8 *) psMemRead->pUserArea + (sdwAddr - psMemRead->lowAddr));
11947 }
11948 psMemRead = NULL;
11949 break;
11950 }
11951 ++psMemRead;
11952 }
11953
11954 if (psMemRead)
11955 {
11956 cpu.z80E = cpu.z80Base[sdwAddr];
11957 }
11958
11959 break;
11960 }
11961 case 0x5f:
11962 {
11963 InvalidInstruction(2);
11964 break;
11965 }
11966 case 0x60:
11967 {
11968 sdwCyclesRemaining -= 9;
11969 cpu.z80YH = cpu.z80B;
11970 break;
11971 }
11972 case 0x61:
11973 {
11974 sdwCyclesRemaining -= 9;
11975 cpu.z80YH = cpu.z80C;
11976 break;
11977 }
11978 case 0x62:
11979 {
11980 sdwCyclesRemaining -= 9;
11981 cpu.z80YH = cpu.z80D;
11982 break;
11983 }
11984 case 0x63:
11985 {
11986 sdwCyclesRemaining -= 9;
11987 cpu.z80YH = cpu.z80E;
11988 break;
11989 }
11990 case 0x64:
11991 {
11992 sdwCyclesRemaining -= 9;
11993 break;
11994 }
11995 case 0x65:
11996 {
11997 sdwCyclesRemaining -= 9;
11998 cpu.z80YH = cpu.z80YL;
11999 break;
12000 }
12001 case 0x66:
12002 {
12003 sdwCyclesRemaining -= 19;
12004 sdwAddr = (INT8) *pbPC++; // Get the offset
12005 sdwAddr = ((INT32) cpu.z80IY + sdwAddr) & 0xffff;
12006 psMemRead = cpu.z80MemRead; /* Beginning of our handler */
12007 while (psMemRead->lowAddr != 0xffffffff)
12008 {
12009 if ((sdwAddr >= psMemRead->lowAddr) && (sdwAddr <= psMemRead->highAddr))
12010 {
12011 cpu.z80pc = (UINT32) pbPC - (UINT32) cpu.z80Base;
12012 if (psMemRead->memoryCall)
12013 {
12014 cpu.z80H = psMemRead->memoryCall(sdwAddr, psMemRead);
12015 }
12016 else
12017 {
12018 cpu.z80H = *((UINT8 *) psMemRead->pUserArea + (sdwAddr - psMemRead->lowAddr));
12019 }
12020 psMemRead = NULL;
12021 break;
12022 }
12023 ++psMemRead;
12024 }
12025
12026 if (psMemRead)
12027 {
12028 cpu.z80H = cpu.z80Base[sdwAddr];
12029 }
12030
12031 break;
12032 }
12033 case 0x67:
12034 {
12035 sdwCyclesRemaining -= 9;
12036 cpu.z80YH = cpu.z80A;
12037 break;
12038 }
12039 case 0x68:
12040 {
12041 sdwCyclesRemaining -= 9;
12042 cpu.z80YL = cpu.z80B;
12043 break;
12044 }
12045 case 0x69:
12046 {
12047 sdwCyclesRemaining -= 9;
12048 cpu.z80YL = cpu.z80C;
12049 break;
12050 }
12051 case 0x6a:
12052 {
12053 sdwCyclesRemaining -= 9;
12054 cpu.z80YL = cpu.z80D;
12055 break;
12056 }
12057 case 0x6b:
12058 {
12059 sdwCyclesRemaining -= 9;
12060 cpu.z80YL = cpu.z80E;
12061 break;
12062 }
12063 case 0x6c:
12064 {
12065 sdwCyclesRemaining -= 9;
12066 cpu.z80YL = cpu.z80YH;
12067 break;
12068 }
12069 case 0x6d:
12070 {
12071 sdwCyclesRemaining -= 9;
12072 break;
12073 }
12074 case 0x6e:
12075 {
12076 sdwCyclesRemaining -= 19;
12077 sdwAddr = (INT8) *pbPC++; // Get the offset
12078 sdwAddr = ((INT32) cpu.z80IY + sdwAddr) & 0xffff;
12079 psMemRead = cpu.z80MemRead; /* Beginning of our handler */
12080 while (psMemRead->lowAddr != 0xffffffff)
12081 {
12082 if ((sdwAddr >= psMemRead->lowAddr) && (sdwAddr <= psMemRead->highAddr))
12083 {
12084 cpu.z80pc = (UINT32) pbPC - (UINT32) cpu.z80Base;
12085 if (psMemRead->memoryCall)
12086 {
12087 cpu.z80L = psMemRead->memoryCall(sdwAddr, psMemRead);
12088 }
12089 else
12090 {
12091 cpu.z80L = *((UINT8 *) psMemRead->pUserArea + (sdwAddr - psMemRead->lowAddr));
12092 }
12093 psMemRead = NULL;
12094 break;
12095 }
12096 ++psMemRead;
12097 }
12098
12099 if (psMemRead)
12100 {
12101 cpu.z80L = cpu.z80Base[sdwAddr];
12102 }
12103
12104 break;
12105 }
12106 case 0x6f:
12107 {
12108 sdwCyclesRemaining -= 9;
12109 cpu.z80YL = cpu.z80A;
12110 break;
12111 }
12112 case 0x70:
12113 {
12114 sdwCyclesRemaining -= 19;
12115 sdwAddr = (INT8) *pbPC++; // Get the offset
12116 sdwAddr = ((INT32) cpu.z80IY + sdwAddr) & 0xffff;
12117 psMemWrite = cpu.z80MemWrite; /* Beginning of our handler */
12118 while (psMemWrite->lowAddr != 0xffffffff)
12119 {
12120 if ((sdwAddr >= psMemWrite->lowAddr) && (sdwAddr <= psMemWrite->highAddr))
12121 {
12122 cpu.z80pc = (UINT32) pbPC - (UINT32) cpu.z80Base;
12123 if (psMemWrite->memoryCall)
12124 {
12125 psMemWrite->memoryCall(sdwAddr, cpu.z80B, psMemWrite);
12126 }
12127 else
12128 {
12129 *((UINT8 *) psMemWrite->pUserArea + (sdwAddr - psMemWrite->lowAddr)) = cpu.z80B;
12130 }
12131 psMemWrite = NULL;
12132 break;
12133 }
12134 ++psMemWrite;
12135 }
12136
12137 if (psMemWrite)
12138 {
12139 cpu.z80Base[sdwAddr] = (UINT8) cpu.z80B;
12140 }
12141
12142 break;
12143 }
12144 case 0x71:
12145 {
12146 sdwCyclesRemaining -= 19;
12147 sdwAddr = (INT8) *pbPC++; // Get the offset
12148 sdwAddr = ((INT32) cpu.z80IY + sdwAddr) & 0xffff;
12149 psMemWrite = cpu.z80MemWrite; /* Beginning of our handler */
12150 while (psMemWrite->lowAddr != 0xffffffff)
12151 {
12152 if ((sdwAddr >= psMemWrite->lowAddr) && (sdwAddr <= psMemWrite->highAddr))
12153 {
12154 cpu.z80pc = (UINT32) pbPC - (UINT32) cpu.z80Base;
12155 if (psMemWrite->memoryCall)
12156 {
12157 psMemWrite->memoryCall(sdwAddr, cpu.z80C, psMemWrite);
12158 }
12159 else
12160 {
12161 *((UINT8 *) psMemWrite->pUserArea + (sdwAddr - psMemWrite->lowAddr)) = cpu.z80C;
12162 }
12163 psMemWrite = NULL;
12164 break;
12165 }
12166 ++psMemWrite;
12167 }
12168
12169 if (psMemWrite)
12170 {
12171 cpu.z80Base[sdwAddr] = (UINT8) cpu.z80C;
12172 }
12173
12174 break;
12175 }
12176 case 0x72:
12177 {
12178 sdwCyclesRemaining -= 19;
12179 sdwAddr = (INT8) *pbPC++; // Get the offset
12180 sdwAddr = ((INT32) cpu.z80IY + sdwAddr) & 0xffff;
12181 psMemWrite = cpu.z80MemWrite; /* Beginning of our handler */
12182 while (psMemWrite->lowAddr != 0xffffffff)
12183 {
12184 if ((sdwAddr >= psMemWrite->lowAddr) && (sdwAddr <= psMemWrite->highAddr))
12185 {
12186 cpu.z80pc = (UINT32) pbPC - (UINT32) cpu.z80Base;
12187 if (psMemWrite->memoryCall)
12188 {
12189 psMemWrite->memoryCall(sdwAddr, cpu.z80D, psMemWrite);
12190 }
12191 else
12192 {
12193 *((UINT8 *) psMemWrite->pUserArea + (sdwAddr - psMemWrite->lowAddr)) = cpu.z80D;
12194 }
12195 psMemWrite = NULL;
12196 break;
12197 }
12198 ++psMemWrite;
12199 }
12200
12201 if (psMemWrite)
12202 {
12203 cpu.z80Base[sdwAddr] = (UINT8) cpu.z80D;
12204 }
12205
12206 break;
12207 }
12208 case 0x73:
12209 {
12210 sdwCyclesRemaining -= 19;
12211 sdwAddr = (INT8) *pbPC++; // Get the offset
12212 sdwAddr = ((INT32) cpu.z80IY + sdwAddr) & 0xffff;
12213 psMemWrite = cpu.z80MemWrite; /* Beginning of our handler */
12214 while (psMemWrite->lowAddr != 0xffffffff)
12215 {
12216 if ((sdwAddr >= psMemWrite->lowAddr) && (sdwAddr <= psMemWrite->highAddr))
12217 {
12218 cpu.z80pc = (UINT32) pbPC - (UINT32) cpu.z80Base;
12219 if (psMemWrite->memoryCall)
12220 {
12221 psMemWrite->memoryCall(sdwAddr, cpu.z80E, psMemWrite);
12222 }
12223 else
12224 {
12225 *((UINT8 *) psMemWrite->pUserArea + (sdwAddr - psMemWrite->lowAddr)) = cpu.z80E;
12226 }
12227 psMemWrite = NULL;
12228 break;
12229 }
12230 ++psMemWrite;
12231 }
12232
12233 if (psMemWrite)
12234 {
12235 cpu.z80Base[sdwAddr] = (UINT8) cpu.z80E;
12236 }
12237
12238 break;
12239 }
12240 case 0x74:
12241 {
12242 sdwCyclesRemaining -= 19;
12243 sdwAddr = (INT8) *pbPC++; // Get the offset
12244 sdwAddr = ((INT32) cpu.z80IY + sdwAddr) & 0xffff;
12245 psMemWrite = cpu.z80MemWrite; /* Beginning of our handler */
12246 while (psMemWrite->lowAddr != 0xffffffff)
12247 {
12248 if ((sdwAddr >= psMemWrite->lowAddr) && (sdwAddr <= psMemWrite->highAddr))
12249 {
12250 cpu.z80pc = (UINT32) pbPC - (UINT32) cpu.z80Base;
12251 if (psMemWrite->memoryCall)
12252 {
12253 psMemWrite->memoryCall(sdwAddr, cpu.z80H, psMemWrite);
12254 }
12255 else
12256 {
12257 *((UINT8 *) psMemWrite->pUserArea + (sdwAddr - psMemWrite->lowAddr)) = cpu.z80H;
12258 }
12259 psMemWrite = NULL;
12260 break;
12261 }
12262 ++psMemWrite;
12263 }
12264
12265 if (psMemWrite)
12266 {
12267 cpu.z80Base[sdwAddr] = (UINT8) cpu.z80H;
12268 }
12269
12270 break;
12271 }
12272 case 0x75:
12273 {
12274 sdwCyclesRemaining -= 19;
12275 sdwAddr = (INT8) *pbPC++; // Get the offset
12276 sdwAddr = ((INT32) cpu.z80IY + sdwAddr) & 0xffff;
12277 psMemWrite = cpu.z80MemWrite; /* Beginning of our handler */
12278 while (psMemWrite->lowAddr != 0xffffffff)
12279 {
12280 if ((sdwAddr >= psMemWrite->lowAddr) && (sdwAddr <= psMemWrite->highAddr))
12281 {
12282 cpu.z80pc = (UINT32) pbPC - (UINT32) cpu.z80Base;
12283 if (psMemWrite->memoryCall)
12284 {
12285 psMemWrite->memoryCall(sdwAddr, cpu.z80L, psMemWrite);
12286 }
12287 else
12288 {
12289 *((UINT8 *) psMemWrite->pUserArea + (sdwAddr - psMemWrite->lowAddr)) = cpu.z80L;
12290 }
12291 psMemWrite = NULL;
12292 break;
12293 }
12294 ++psMemWrite;
12295 }
12296
12297 if (psMemWrite)
12298 {
12299 cpu.z80Base[sdwAddr] = (UINT8) cpu.z80L;
12300 }
12301
12302 break;
12303 }
12304 case 0x76:
12305 {
12306 sdwCyclesRemaining -= 19;
12307 InvalidInstruction(2);
12308 break;
12309 }
12310 case 0x77:
12311 {
12312 sdwCyclesRemaining -= 19;
12313 sdwAddr = (INT8) *pbPC++; // Get the offset
12314 sdwAddr = ((INT32) cpu.z80IY + sdwAddr) & 0xffff;
12315 psMemWrite = cpu.z80MemWrite; /* Beginning of our handler */
12316 while (psMemWrite->lowAddr != 0xffffffff)
12317 {
12318 if ((sdwAddr >= psMemWrite->lowAddr) && (sdwAddr <= psMemWrite->highAddr))
12319 {
12320 cpu.z80pc = (UINT32) pbPC - (UINT32) cpu.z80Base;
12321 if (psMemWrite->memoryCall)
12322 {
12323 psMemWrite->memoryCall(sdwAddr, cpu.z80A, psMemWrite);
12324 }
12325 else
12326 {
12327 *((UINT8 *) psMemWrite->pUserArea + (sdwAddr - psMemWrite->lowAddr)) = cpu.z80A;
12328 }
12329 psMemWrite = NULL;
12330 break;
12331 }
12332 ++psMemWrite;
12333 }
12334
12335 if (psMemWrite)
12336 {
12337 cpu.z80Base[sdwAddr] = (UINT8) cpu.z80A;
12338 }
12339
12340 break;
12341 }
12342 case 0x78:
12343 {
12344 InvalidInstruction(2);
12345 break;
12346 }
12347 case 0x79:
12348 {
12349 InvalidInstruction(2);
12350 break;
12351 }
12352 case 0x7a:
12353 {
12354 InvalidInstruction(2);
12355 break;
12356 }
12357 case 0x7b:
12358 {
12359 InvalidInstruction(2);
12360 break;
12361 }
12362 case 0x7c:
12363 {
12364 sdwCyclesRemaining -= 9;
12365 cpu.z80A = cpu.z80YH;
12366 break;
12367 }
12368 case 0x7d:
12369 {
12370 sdwCyclesRemaining -= 9;
12371 cpu.z80A = cpu.z80YL;
12372 break;
12373 }
12374 case 0x7e:
12375 {
12376 sdwCyclesRemaining -= 19;
12377 sdwAddr = (INT8) *pbPC++; // Get the offset
12378 sdwAddr = ((INT32) cpu.z80IY + sdwAddr) & 0xffff;
12379 psMemRead = cpu.z80MemRead; /* Beginning of our handler */
12380 while (psMemRead->lowAddr != 0xffffffff)
12381 {
12382 if ((sdwAddr >= psMemRead->lowAddr) && (sdwAddr <= psMemRead->highAddr))
12383 {
12384 cpu.z80pc = (UINT32) pbPC - (UINT32) cpu.z80Base;
12385 if (psMemRead->memoryCall)
12386 {
12387 cpu.z80A = psMemRead->memoryCall(sdwAddr, psMemRead);
12388 }
12389 else
12390 {
12391 cpu.z80A = *((UINT8 *) psMemRead->pUserArea + (sdwAddr - psMemRead->lowAddr));
12392 }
12393 psMemRead = NULL;
12394 break;
12395 }
12396 ++psMemRead;
12397 }
12398
12399 if (psMemRead)
12400 {
12401 cpu.z80A = cpu.z80Base[sdwAddr];
12402 }
12403
12404 break;
12405 }
12406 case 0x7f:
12407 {
12408 InvalidInstruction(2);
12409 break;
12410 }
12411 case 0x80:
12412 {
12413 InvalidInstruction(2);
12414 break;
12415 }
12416 case 0x81:
12417 {
12418 InvalidInstruction(2);
12419 break;
12420 }
12421 case 0x82:
12422 {
12423 InvalidInstruction(2);
12424 break;
12425 }
12426 case 0x83:
12427 {
12428 InvalidInstruction(2);
12429 break;
12430 }
12431 case 0x84:
12432 {
12433 sdwCyclesRemaining -= 9;
12434 bTemp2 = cpu.z80A + cpu.z80YH;
12435 cpu.z80F = (cpu.z80F & ~(Z80_FLAG_CARRY | Z80_FLAG_NEGATIVE | Z80_FLAG_OVERFLOW_PARITY |
12436 Z80_FLAG_HALF_CARRY | Z80_FLAG_ZERO | Z80_FLAG_SIGN)) |
12437 pbAddAdcTable[((UINT32) cpu.z80A << 8) | cpu.z80YH];
12438 InvalidInstruction(2);
12439 break;
12440 }
12441 case 0x85:
12442 {
12443 sdwCyclesRemaining -= 9;
12444 bTemp2 = cpu.z80A + cpu.z80YL;
12445 cpu.z80F = (cpu.z80F & ~(Z80_FLAG_CARRY | Z80_FLAG_NEGATIVE | Z80_FLAG_OVERFLOW_PARITY |
12446 Z80_FLAG_HALF_CARRY | Z80_FLAG_ZERO | Z80_FLAG_SIGN)) |
12447 pbAddAdcTable[((UINT32) cpu.z80A << 8) | cpu.z80YL];
12448 InvalidInstruction(2);
12449 break;
12450 }
12451 case 0x86:
12452 {
12453 sdwCyclesRemaining -= 19;
12454 sdwAddr = (INT8) *pbPC++; /* Get LSB first */
12455 dwAddr = (sdwAddr + (INT32) cpu.z80IY) & 0xffff;
12456 psMemRead = cpu.z80MemRead; /* Beginning of our handler */
12457 while (psMemRead->lowAddr != 0xffffffff)
12458 {
12459 if ((dwAddr >= psMemRead->lowAddr) && (dwAddr <= psMemRead->highAddr))
12460 {
12461 cpu.z80pc = (UINT32) pbPC - (UINT32) cpu.z80Base;
12462 if (psMemRead->memoryCall)
12463 {
12464 bTemp = psMemRead->memoryCall(dwAddr, psMemRead);
12465 }
12466 else
12467 {
12468 bTemp = *((UINT8 *) psMemRead->pUserArea + (dwAddr - psMemRead->lowAddr));
12469 }
12470 psMemRead = NULL;
12471 break;
12472 }
12473 ++psMemRead;
12474 }
12475
12476 if (psMemRead)
12477 {
12478 bTemp = cpu.z80Base[dwAddr];
12479 }
12480
12481 cpu.z80F = (cpu.z80F & ~(Z80_FLAG_CARRY | Z80_FLAG_NEGATIVE | Z80_FLAG_OVERFLOW_PARITY |
12482 Z80_FLAG_HALF_CARRY | Z80_FLAG_ZERO | Z80_FLAG_SIGN)) |
12483 pbAddAdcTable[((UINT32) cpu.z80A << 8) | bTemp];
12484 cpu.z80A += bTemp;
12485 break;
12486 }
12487 case 0x87:
12488 {
12489 InvalidInstruction(2);
12490 break;
12491 }
12492 case 0x88:
12493 {
12494 InvalidInstruction(2);
12495 break;
12496 }
12497 case 0x89:
12498 {
12499 InvalidInstruction(2);
12500 break;
12501 }
12502 case 0x8a:
12503 {
12504 InvalidInstruction(2);
12505 break;
12506 }
12507 case 0x8b:
12508 {
12509 InvalidInstruction(2);
12510 break;
12511 }
12512 case 0x8c:
12513 {
12514 sdwCyclesRemaining -= 9;
12515 bTemp2 = cpu.z80A + cpu.z80YH + (cpu.z80F & Z80_FLAG_CARRY);
12516 cpu.z80F = (cpu.z80F & ~(Z80_FLAG_CARRY | Z80_FLAG_NEGATIVE | Z80_FLAG_OVERFLOW_PARITY |
12517 Z80_FLAG_HALF_CARRY | Z80_FLAG_ZERO | Z80_FLAG_SIGN)) |
12518 pbAddAdcTable[((UINT32) cpu.z80A << 8) | cpu.z80YH | (((UINT32) cpu.z80F & Z80_FLAG_CARRY) << 16)];
12519 InvalidInstruction(2);
12520 break;
12521 }
12522 case 0x8d:
12523 {
12524 sdwCyclesRemaining -= 9;
12525 bTemp2 = cpu.z80A + cpu.z80YL + (cpu.z80F & Z80_FLAG_CARRY);
12526 cpu.z80F = (cpu.z80F & ~(Z80_FLAG_CARRY | Z80_FLAG_NEGATIVE | Z80_FLAG_OVERFLOW_PARITY |
12527 Z80_FLAG_HALF_CARRY | Z80_FLAG_ZERO | Z80_FLAG_SIGN)) |
12528 pbAddAdcTable[((UINT32) cpu.z80A << 8) | cpu.z80YL | (((UINT32) cpu.z80F & Z80_FLAG_CARRY) << 16)];
12529 InvalidInstruction(2);
12530 break;
12531 }
12532 case 0x8e:
12533 {
12534 sdwCyclesRemaining -= 19;
12535 sdwAddr = (INT8) *pbPC++; /* Get LSB first */
12536 dwAddr = (sdwAddr + (INT32) cpu.z80IY) & 0xffff;
12537 psMemRead = cpu.z80MemRead; /* Beginning of our handler */
12538 while (psMemRead->lowAddr != 0xffffffff)
12539 {
12540 if ((dwAddr >= psMemRead->lowAddr) && (dwAddr <= psMemRead->highAddr))
12541 {
12542 cpu.z80pc = (UINT32) pbPC - (UINT32) cpu.z80Base;
12543 if (psMemRead->memoryCall)
12544 {
12545 bTemp = psMemRead->memoryCall(dwAddr, psMemRead);
12546 }
12547 else
12548 {
12549 bTemp = *((UINT8 *) psMemRead->pUserArea + (dwAddr - psMemRead->lowAddr));
12550 }
12551 psMemRead = NULL;
12552 break;
12553 }
12554 ++psMemRead;
12555 }
12556
12557 if (psMemRead)
12558 {
12559 bTemp = cpu.z80Base[dwAddr];
12560 }
12561
12562 bTemp2 = (cpu.z80F & Z80_FLAG_CARRY);
12563 cpu.z80F = (cpu.z80F & ~(Z80_FLAG_CARRY | Z80_FLAG_NEGATIVE | Z80_FLAG_OVERFLOW_PARITY |
12564 Z80_FLAG_HALF_CARRY | Z80_FLAG_ZERO | Z80_FLAG_SIGN)) |
12565 pbAddAdcTable[((UINT32) cpu.z80A << 8) | bTemp | (((UINT32) cpu.z80F & Z80_FLAG_CARRY) << 16)];
12566 cpu.z80A += bTemp + bTemp2;
12567 break;
12568 }
12569 case 0x8f:
12570 {
12571 InvalidInstruction(2);
12572 break;
12573 }
12574 case 0x90:
12575 {
12576 InvalidInstruction(2);
12577 break;
12578 }
12579 case 0x91:
12580 {
12581 InvalidInstruction(2);
12582 break;
12583 }
12584 case 0x92:
12585 {
12586 InvalidInstruction(2);
12587 break;
12588 }
12589 case 0x93:
12590 {
12591 InvalidInstruction(2);
12592 break;
12593 }
12594 case 0x94:
12595 {
12596 sdwCyclesRemaining -= 9;
12597 bTemp2 = cpu.z80A - cpu.z80YH;
12598 cpu.z80F = (cpu.z80F & ~(Z80_FLAG_CARRY | Z80_FLAG_NEGATIVE | Z80_FLAG_OVERFLOW_PARITY |
12599 Z80_FLAG_HALF_CARRY | Z80_FLAG_ZERO | Z80_FLAG_SIGN)) |
12600 pbSubSbcTable[((UINT32) cpu.z80A << 8) | cpu.z80YH];
12601 InvalidInstruction(2);
12602 break;
12603 }
12604 case 0x95:
12605 {
12606 sdwCyclesRemaining -= 9;
12607 bTemp2 = cpu.z80A - cpu.z80YL;
12608 cpu.z80F = (cpu.z80F & ~(Z80_FLAG_CARRY | Z80_FLAG_NEGATIVE | Z80_FLAG_OVERFLOW_PARITY |
12609 Z80_FLAG_HALF_CARRY | Z80_FLAG_ZERO | Z80_FLAG_SIGN)) |
12610 pbSubSbcTable[((UINT32) cpu.z80A << 8) | cpu.z80YL];
12611 InvalidInstruction(2);
12612 break;
12613 }
12614 case 0x96:
12615 {
12616 sdwCyclesRemaining -= 19;
12617 sdwAddr = (INT8) *pbPC++; /* Get LSB first */
12618 dwAddr = (sdwAddr + (INT32) cpu.z80IY) & 0xffff;
12619 psMemRead = cpu.z80MemRead; /* Beginning of our handler */
12620 while (psMemRead->lowAddr != 0xffffffff)
12621 {
12622 if ((dwAddr >= psMemRead->lowAddr) && (dwAddr <= psMemRead->highAddr))
12623 {
12624 cpu.z80pc = (UINT32) pbPC - (UINT32) cpu.z80Base;
12625 if (psMemRead->memoryCall)
12626 {
12627 bTemp = psMemRead->memoryCall(dwAddr, psMemRead);
12628 }
12629 else
12630 {
12631 bTemp = *((UINT8 *) psMemRead->pUserArea + (dwAddr - psMemRead->lowAddr));
12632 }
12633 psMemRead = NULL;
12634 break;
12635 }
12636 ++psMemRead;
12637 }
12638
12639 if (psMemRead)
12640 {
12641 bTemp = cpu.z80Base[dwAddr];
12642 }
12643
12644 cpu.z80F = (cpu.z80F & ~(Z80_FLAG_CARRY | Z80_FLAG_NEGATIVE | Z80_FLAG_OVERFLOW_PARITY |
12645 Z80_FLAG_HALF_CARRY | Z80_FLAG_ZERO | Z80_FLAG_SIGN)) |
12646 pbSubSbcTable[((UINT32) cpu.z80A << 8) | bTemp];
12647 cpu.z80A -= bTemp;
12648 break;
12649 }
12650 case 0x97:
12651 {
12652 InvalidInstruction(2);
12653 break;
12654 }
12655 case 0x98:
12656 {
12657 InvalidInstruction(2);
12658 break;
12659 }
12660 case 0x99:
12661 {
12662 InvalidInstruction(2);
12663 break;
12664 }
12665 case 0x9a:
12666 {
12667 InvalidInstruction(2);
12668 break;
12669 }
12670 case 0x9b:
12671 {
12672 InvalidInstruction(2);
12673 break;
12674 }
12675 case 0x9c:
12676 {
12677 sdwCyclesRemaining -= 9;
12678 bTemp2 = cpu.z80A - cpu.z80YH - (cpu.z80F & Z80_FLAG_CARRY);
12679 cpu.z80F = (cpu.z80F & ~(Z80_FLAG_CARRY | Z80_FLAG_NEGATIVE | Z80_FLAG_OVERFLOW_PARITY |
12680 Z80_FLAG_HALF_CARRY | Z80_FLAG_ZERO | Z80_FLAG_SIGN)) |
12681 pbSubSbcTable[((UINT32) cpu.z80A << 8) | cpu.z80YH | (((UINT32) cpu.z80F & Z80_FLAG_CARRY) << 16)];
12682 InvalidInstruction(2);
12683 break;
12684 }
12685 case 0x9d:
12686 {
12687 sdwCyclesRemaining -= 9;
12688 bTemp2 = cpu.z80A - cpu.z80YL - (cpu.z80F & Z80_FLAG_CARRY);
12689 cpu.z80F = (cpu.z80F & ~(Z80_FLAG_CARRY | Z80_FLAG_NEGATIVE | Z80_FLAG_OVERFLOW_PARITY |
12690 Z80_FLAG_HALF_CARRY | Z80_FLAG_ZERO | Z80_FLAG_SIGN)) |
12691 pbSubSbcTable[((UINT32) cpu.z80A << 8) | cpu.z80YL | (((UINT32) cpu.z80F & Z80_FLAG_CARRY) << 16)];
12692 InvalidInstruction(2);
12693 break;
12694 }
12695 case 0x9e:
12696 {
12697 sdwCyclesRemaining -= 19;
12698 sdwAddr = (INT8) *pbPC++; /* Get LSB first */
12699 dwAddr = (sdwAddr + (INT32) cpu.z80IY) & 0xffff;
12700 psMemRead = cpu.z80MemRead; /* Beginning of our handler */
12701 while (psMemRead->lowAddr != 0xffffffff)
12702 {
12703 if ((dwAddr >= psMemRead->lowAddr) && (dwAddr <= psMemRead->highAddr))
12704 {
12705 cpu.z80pc = (UINT32) pbPC - (UINT32) cpu.z80Base;
12706 if (psMemRead->memoryCall)
12707 {
12708 bTemp = psMemRead->memoryCall(dwAddr, psMemRead);
12709 }
12710 else
12711 {
12712 bTemp = *((UINT8 *) psMemRead->pUserArea + (dwAddr - psMemRead->lowAddr));
12713 }
12714 psMemRead = NULL;
12715 break;
12716 }
12717 ++psMemRead;
12718 }
12719
12720 if (psMemRead)
12721 {
12722 bTemp = cpu.z80Base[dwAddr];
12723 }
12724
12725 bTemp2 = cpu.z80A;
12726 cpu.z80A = cpu.z80A - bTemp - (cpu.z80F & Z80_FLAG_CARRY);
12727 cpu.z80F = (cpu.z80F & ~(Z80_FLAG_CARRY | Z80_FLAG_NEGATIVE | Z80_FLAG_OVERFLOW_PARITY |
12728 Z80_FLAG_HALF_CARRY | Z80_FLAG_ZERO | Z80_FLAG_SIGN)) |
12729 pbSubSbcTable[((UINT32) bTemp2 << 8) | bTemp | (((UINT32) cpu.z80F & Z80_FLAG_CARRY) << 16)];
12730 break;
12731 }
12732 case 0x9f:
12733 {
12734 InvalidInstruction(2);
12735 break;
12736 }
12737 case 0xa0:
12738 {
12739 InvalidInstruction(2);
12740 break;
12741 }
12742 case 0xa1:
12743 {
12744 InvalidInstruction(2);
12745 break;
12746 }
12747 case 0xa2:
12748 {
12749 InvalidInstruction(2);
12750 break;
12751 }
12752 case 0xa3:
12753 {
12754 InvalidInstruction(2);
12755 break;
12756 }
12757 case 0xa4:
12758 {
12759 sdwCyclesRemaining -= 9;
12760 cpu.z80A &= cpu.z80YH;
12761 cpu.z80F &= ~(Z80_FLAG_CARRY | Z80_FLAG_NEGATIVE | Z80_FLAG_OVERFLOW_PARITY | Z80_FLAG_HALF_CARRY | Z80_FLAG_ZERO | Z80_FLAG_SIGN);
12762 cpu.z80F |= bPostANDFlags[cpu.z80A];
12763
12764 InvalidInstruction(2);
12765 break;
12766 }
12767 case 0xa5:
12768 {
12769 sdwCyclesRemaining -= 9;
12770 cpu.z80A &= cpu.z80YL;
12771 cpu.z80F &= ~(Z80_FLAG_CARRY | Z80_FLAG_NEGATIVE | Z80_FLAG_OVERFLOW_PARITY | Z80_FLAG_HALF_CARRY | Z80_FLAG_ZERO | Z80_FLAG_SIGN);
12772 cpu.z80F |= bPostANDFlags[cpu.z80A];
12773
12774 InvalidInstruction(2);
12775 break;
12776 }
12777 case 0xa6:
12778 {
12779 sdwCyclesRemaining -= 19;
12780 sdwAddr = (INT8) *pbPC++; /* Get LSB first */
12781 dwAddr = (sdwAddr + (INT32) cpu.z80IY) & 0xffff;
12782 psMemRead = cpu.z80MemRead; /* Beginning of our handler */
12783 while (psMemRead->lowAddr != 0xffffffff)
12784 {
12785 if ((dwAddr >= psMemRead->lowAddr) && (dwAddr <= psMemRead->highAddr))
12786 {
12787 cpu.z80pc = (UINT32) pbPC - (UINT32) cpu.z80Base;
12788 if (psMemRead->memoryCall)
12789 {
12790 bTemp = psMemRead->memoryCall(dwAddr, psMemRead);
12791 }
12792 else
12793 {
12794 bTemp = *((UINT8 *) psMemRead->pUserArea + (dwAddr - psMemRead->lowAddr));
12795 }
12796 psMemRead = NULL;
12797 break;
12798 }
12799 ++psMemRead;
12800 }
12801
12802 if (psMemRead)
12803 {
12804 bTemp = cpu.z80Base[dwAddr];
12805 }
12806
12807 cpu.z80A &= bTemp;
12808 cpu.z80F &= ~(Z80_FLAG_CARRY | Z80_FLAG_NEGATIVE | Z80_FLAG_OVERFLOW_PARITY | Z80_FLAG_HALF_CARRY | Z80_FLAG_ZERO | Z80_FLAG_SIGN);
12809 cpu.z80F |= bPostANDFlags[cpu.z80A];
12810
12811 break;
12812 }
12813 case 0xa7:
12814 {
12815 InvalidInstruction(2);
12816 break;
12817 }
12818 case 0xa8:
12819 {
12820 InvalidInstruction(2);
12821 break;
12822 }
12823 case 0xa9:
12824 {
12825 InvalidInstruction(2);
12826 break;
12827 }
12828 case 0xaa:
12829 {
12830 InvalidInstruction(2);
12831 break;
12832 }
12833 case 0xab:
12834 {
12835 InvalidInstruction(2);
12836 break;
12837 }
12838 case 0xac:
12839 {
12840 sdwCyclesRemaining -= 9;
12841 cpu.z80A ^= cpu.z80YH;
12842 cpu.z80F &= ~(Z80_FLAG_CARRY | Z80_FLAG_NEGATIVE | Z80_FLAG_OVERFLOW_PARITY | Z80_FLAG_HALF_CARRY | Z80_FLAG_ZERO | Z80_FLAG_SIGN);
12843 cpu.z80F |= bPostORFlags[cpu.z80A];
12844
12845 InvalidInstruction(2);
12846 break;
12847 }
12848 case 0xad:
12849 {
12850 sdwCyclesRemaining -= 9;
12851 cpu.z80A ^= cpu.z80YL;
12852 cpu.z80F &= ~(Z80_FLAG_CARRY | Z80_FLAG_NEGATIVE | Z80_FLAG_OVERFLOW_PARITY | Z80_FLAG_HALF_CARRY | Z80_FLAG_ZERO | Z80_FLAG_SIGN);
12853 cpu.z80F |= bPostORFlags[cpu.z80A];
12854
12855 InvalidInstruction(2);
12856 break;
12857 }
12858 case 0xae:
12859 {
12860 sdwCyclesRemaining -= 19;
12861 sdwAddr = (INT8) *pbPC++; /* Get LSB first */
12862 dwAddr = (sdwAddr + (INT32) cpu.z80IY) & 0xffff;
12863 psMemRead = cpu.z80MemRead; /* Beginning of our handler */
12864 while (psMemRead->lowAddr != 0xffffffff)
12865 {
12866 if ((dwAddr >= psMemRead->lowAddr) && (dwAddr <= psMemRead->highAddr))
12867 {
12868 cpu.z80pc = (UINT32) pbPC - (UINT32) cpu.z80Base;
12869 if (psMemRead->memoryCall)
12870 {
12871 bTemp = psMemRead->memoryCall(dwAddr, psMemRead);
12872 }
12873 else
12874 {
12875 bTemp = *((UINT8 *) psMemRead->pUserArea + (dwAddr - psMemRead->lowAddr));
12876 }
12877 psMemRead = NULL;
12878 break;
12879 }
12880 ++psMemRead;
12881 }
12882
12883 if (psMemRead)
12884 {
12885 bTemp = cpu.z80Base[dwAddr];
12886 }
12887
12888 cpu.z80A ^= bTemp;
12889 cpu.z80F &= ~(Z80_FLAG_CARRY | Z80_FLAG_NEGATIVE | Z80_FLAG_OVERFLOW_PARITY | Z80_FLAG_HALF_CARRY | Z80_FLAG_ZERO | Z80_FLAG_SIGN);
12890 cpu.z80F |= bPostORFlags[cpu.z80A];
12891
12892 break;
12893 }
12894 case 0xaf:
12895 {
12896 InvalidInstruction(2);
12897 break;
12898 }
12899 case 0xb0:
12900 {
12901 InvalidInstruction(2);
12902 break;
12903 }
12904 case 0xb1:
12905 {
12906 InvalidInstruction(2);
12907 break;
12908 }
12909 case 0xb2:
12910 {
12911 InvalidInstruction(2);
12912 break;
12913 }
12914 case 0xb3:
12915 {
12916 InvalidInstruction(2);
12917 break;
12918 }
12919 case 0xb4:
12920 {
12921 sdwCyclesRemaining -= 9;
12922 cpu.z80A |= cpu.z80YH;
12923 cpu.z80F &= ~(Z80_FLAG_CARRY | Z80_FLAG_NEGATIVE | Z80_FLAG_OVERFLOW_PARITY | Z80_FLAG_HALF_CARRY | Z80_FLAG_ZERO | Z80_FLAG_SIGN);
12924 cpu.z80F |= bPostORFlags[cpu.z80A];
12925
12926 InvalidInstruction(2);
12927 break;
12928 }
12929 case 0xb5:
12930 {
12931 sdwCyclesRemaining -= 9;
12932 cpu.z80A |= cpu.z80YL;
12933 cpu.z80F &= ~(Z80_FLAG_CARRY | Z80_FLAG_NEGATIVE | Z80_FLAG_OVERFLOW_PARITY | Z80_FLAG_HALF_CARRY | Z80_FLAG_ZERO | Z80_FLAG_SIGN);
12934 cpu.z80F |= bPostORFlags[cpu.z80A];
12935
12936 InvalidInstruction(2);
12937 break;
12938 }
12939 case 0xb6:
12940 {
12941 sdwCyclesRemaining -= 19;
12942 sdwAddr = (INT8) *pbPC++; /* Get LSB first */
12943 dwAddr = (sdwAddr + (INT32) cpu.z80IY) & 0xffff;
12944 psMemRead = cpu.z80MemRead; /* Beginning of our handler */
12945 while (psMemRead->lowAddr != 0xffffffff)
12946 {
12947 if ((dwAddr >= psMemRead->lowAddr) && (dwAddr <= psMemRead->highAddr))
12948 {
12949 cpu.z80pc = (UINT32) pbPC - (UINT32) cpu.z80Base;
12950 if (psMemRead->memoryCall)
12951 {
12952 bTemp = psMemRead->memoryCall(dwAddr, psMemRead);
12953 }
12954 else
12955 {
12956 bTemp = *((UINT8 *) psMemRead->pUserArea + (dwAddr - psMemRead->lowAddr));
12957 }
12958 psMemRead = NULL;
12959 break;
12960 }
12961 ++psMemRead;
12962 }
12963
12964 if (psMemRead)
12965 {
12966 bTemp = cpu.z80Base[dwAddr];
12967 }
12968
12969 cpu.z80A |= bTemp;
12970 cpu.z80F &= ~(Z80_FLAG_CARRY | Z80_FLAG_NEGATIVE | Z80_FLAG_OVERFLOW_PARITY | Z80_FLAG_HALF_CARRY | Z80_FLAG_ZERO | Z80_FLAG_SIGN);
12971 cpu.z80F |= bPostORFlags[cpu.z80A];
12972
12973 break;
12974 }
12975 case 0xb7:
12976 {
12977 InvalidInstruction(2);
12978 break;
12979 }
12980 case 0xb8:
12981 {
12982 InvalidInstruction(2);
12983 break;
12984 }
12985 case 0xb9:
12986 {
12987 InvalidInstruction(2);
12988 break;
12989 }
12990 case 0xba:
12991 {
12992 InvalidInstruction(2);
12993 break;
12994 }
12995 case 0xbb:
12996 {
12997 InvalidInstruction(2);
12998 break;
12999 }
13000 case 0xbc:
13001 {
13002 sdwCyclesRemaining -= 9;
13003 cpu.z80F &= ~(Z80_FLAG_CARRY | Z80_FLAG_NEGATIVE | Z80_FLAG_OVERFLOW_PARITY | Z80_FLAG_HALF_CARRY | Z80_FLAG_ZERO | Z80_FLAG_SIGN);
13004 cpu.z80F |= bPostORFlags[cpu.z80A];
13005
13006 InvalidInstruction(2);
13007 break;
13008 }
13009 case 0xbd:
13010 {
13011 sdwCyclesRemaining -= 9;
13012 cpu.z80F &= ~(Z80_FLAG_CARRY | Z80_FLAG_NEGATIVE | Z80_FLAG_OVERFLOW_PARITY | Z80_FLAG_HALF_CARRY | Z80_FLAG_ZERO | Z80_FLAG_SIGN);
13013 cpu.z80F |= bPostORFlags[cpu.z80A];
13014
13015 InvalidInstruction(2);
13016 break;
13017 }
13018 case 0xbe:
13019 {
13020 sdwCyclesRemaining -= 19;
13021 sdwAddr = (INT8) *pbPC++; /* Get LSB first */
13022 dwAddr = (sdwAddr + (INT32) cpu.z80IY) & 0xffff;
13023 psMemRead = cpu.z80MemRead; /* Beginning of our handler */
13024 while (psMemRead->lowAddr != 0xffffffff)
13025 {
13026 if ((dwAddr >= psMemRead->lowAddr) && (dwAddr <= psMemRead->highAddr))
13027 {
13028 cpu.z80pc = (UINT32) pbPC - (UINT32) cpu.z80Base;
13029 if (psMemRead->memoryCall)
13030 {
13031 bTemp = psMemRead->memoryCall(dwAddr, psMemRead);
13032 }
13033 else
13034 {
13035 bTemp = *((UINT8 *) psMemRead->pUserArea + (dwAddr - psMemRead->lowAddr));
13036 }
13037 psMemRead = NULL;
13038 break;
13039 }
13040 ++psMemRead;
13041 }
13042
13043 if (psMemRead)
13044 {
13045 bTemp = cpu.z80Base[dwAddr];
13046 }
13047
13048 cpu.z80F = (cpu.z80F & ~(Z80_FLAG_CARRY | Z80_FLAG_NEGATIVE | Z80_FLAG_OVERFLOW_PARITY |
13049 Z80_FLAG_HALF_CARRY | Z80_FLAG_ZERO | Z80_FLAG_SIGN)) |
13050 pbSubSbcTable[((UINT32) cpu.z80A << 8) | bTemp];
13051 break;
13052 }
13053 case 0xbf:
13054 {
13055 InvalidInstruction(2);
13056 break;
13057 }
13058 case 0xc0:
13059 {
13060 InvalidInstruction(2);
13061 break;
13062 }
13063 case 0xc1:
13064 {
13065 InvalidInstruction(2);
13066 break;
13067 }
13068 case 0xc2:
13069 {
13070 InvalidInstruction(2);
13071 break;
13072 }
13073 case 0xc3:
13074 {
13075 InvalidInstruction(2);
13076 break;
13077 }
13078 case 0xc4:
13079 {
13080 InvalidInstruction(2);
13081 break;
13082 }
13083 case 0xc5:
13084 {
13085 InvalidInstruction(2);
13086 break;
13087 }
13088 case 0xc6:
13089 {
13090 InvalidInstruction(2);
13091 break;
13092 }
13093 case 0xc7:
13094 {
13095 InvalidInstruction(2);
13096 break;
13097 }
13098 case 0xc8:
13099 {
13100 InvalidInstruction(2);
13101 break;
13102 }
13103 case 0xc9:
13104 {
13105 InvalidInstruction(2);
13106 break;
13107 }
13108 case 0xca:
13109 {
13110 InvalidInstruction(2);
13111 break;
13112 }
13113 case 0xcb:
13114 {
13115 DDFDCBHandler(1);
13116 break;
13117 }
13118 case 0xcc:
13119 {
13120 InvalidInstruction(2);
13121 break;
13122 }
13123 case 0xcd:
13124 {
13125 InvalidInstruction(2);
13126 break;
13127 }
13128 case 0xce:
13129 {
13130 InvalidInstruction(2);
13131 break;
13132 }
13133 case 0xcf:
13134 {
13135 InvalidInstruction(2);
13136 break;
13137 }
13138 case 0xd0:
13139 {
13140 InvalidInstruction(2);
13141 break;
13142 }
13143 case 0xd1:
13144 {
13145 InvalidInstruction(2);
13146 break;
13147 }
13148 case 0xd2:
13149 {
13150 InvalidInstruction(2);
13151 break;
13152 }
13153 case 0xd3:
13154 {
13155 InvalidInstruction(2);
13156 break;
13157 }
13158 case 0xd4:
13159 {
13160 InvalidInstruction(2);
13161 break;
13162 }
13163 case 0xd5:
13164 {
13165 InvalidInstruction(2);
13166 break;
13167 }
13168 case 0xd6:
13169 {
13170 InvalidInstruction(2);
13171 break;
13172 }
13173 case 0xd7:
13174 {
13175 InvalidInstruction(2);
13176 break;
13177 }
13178 case 0xd8:
13179 {
13180 InvalidInstruction(2);
13181 break;
13182 }
13183 case 0xd9:
13184 {
13185 InvalidInstruction(2);
13186 break;
13187 }
13188 case 0xda:
13189 {
13190 InvalidInstruction(2);
13191 break;
13192 }
13193 case 0xdb:
13194 {
13195 InvalidInstruction(2);
13196 break;
13197 }
13198 case 0xdc:
13199 {
13200 InvalidInstruction(2);
13201 break;
13202 }
13203 case 0xdd:
13204 {
13205 InvalidInstruction(2);
13206 break;
13207 }
13208 case 0xde:
13209 {
13210 InvalidInstruction(2);
13211 break;
13212 }
13213 case 0xdf:
13214 {
13215 InvalidInstruction(2);
13216 break;
13217 }
13218 case 0xe0:
13219 {
13220 InvalidInstruction(2);
13221 break;
13222 }
13223 case 0xe1:
13224 {
13225 sdwCyclesRemaining -= 14;
13226 psMemRead = cpu.z80MemRead; /* Beginning of our handler */
13227 while (psMemRead->lowAddr != 0xffffffff)
13228 {
13229 if ((cpu.z80sp >= psMemRead->lowAddr) && (cpu.z80sp <= psMemRead->highAddr))
13230 {
13231 cpu.z80pc = (UINT32) pbPC - (UINT32) cpu.z80Base;
13232 if (psMemRead->memoryCall)
13233 {
13234 cpu.z80IY = psMemRead->memoryCall(cpu.z80sp, psMemRead);
13235 cpu.z80IY |= (UINT32) ((UINT32) psMemRead->memoryCall(cpu.z80sp + 1, psMemRead) << 8);
13236 }
13237 else
13238 {
13239 cpu.z80IY = *((UINT8 *) psMemRead->pUserArea + (cpu.z80sp - psMemRead->lowAddr));
13240 cpu.z80IY |= (UINT32) ((UINT32) *((UINT8 *) psMemRead->pUserArea + (cpu.z80sp - psMemRead->lowAddr + 1)) << 8);
13241 }
13242 psMemRead = NULL;
13243 break;
13244 }
13245 ++psMemRead;
13246 }
13247
13248 if (psMemRead)
13249 {
13250 cpu.z80IY = cpu.z80Base[cpu.z80sp];
13251 cpu.z80IY |= (UINT32) ((UINT32) cpu.z80Base[cpu.z80sp + 1] << 8);
13252 }
13253
13254 cpu.z80sp += 2;
13255 pbSP = (cpu.z80Base + cpu.z80sp); /* Normalize the stack pointer */
13256 break;
13257 }
13258 case 0xe2:
13259 {
13260 InvalidInstruction(2);
13261 break;
13262 }
13263 case 0xe3:
13264 {
13265 sdwCyclesRemaining -= 23;
13266 psMemRead = cpu.z80MemRead; /* Beginning of our handler */
13267 while (psMemRead->lowAddr != 0xffffffff)
13268 {
13269 if ((cpu.z80sp >= psMemRead->lowAddr) && (cpu.z80sp <= psMemRead->highAddr))
13270 {
13271 cpu.z80pc = (UINT32) pbPC - (UINT32) cpu.z80Base;
13272 if (psMemRead->memoryCall)
13273 {
13274 dwAddr = psMemRead->memoryCall(cpu.z80sp, psMemRead);
13275 dwAddr |= (UINT32) ((UINT32) psMemRead->memoryCall(cpu.z80sp + 1, psMemRead) << 8);
13276 }
13277 else
13278 {
13279 dwAddr = *((UINT8 *) psMemRead->pUserArea + (cpu.z80sp - psMemRead->lowAddr));
13280 dwAddr |= (UINT32) ((UINT32) *((UINT8 *) psMemRead->pUserArea + (cpu.z80sp - psMemRead->lowAddr + 1)) << 8);
13281 }
13282 psMemRead = NULL;
13283 break;
13284 }
13285 ++psMemRead;
13286 }
13287
13288 if (psMemRead)
13289 {
13290 dwAddr = cpu.z80Base[cpu.z80sp];
13291 dwAddr |= (UINT32) ((UINT32) cpu.z80Base[cpu.z80sp + 1] << 8);
13292 }
13293
13294 psMemWrite = cpu.z80MemWrite; /* Beginning of our handler */
13295 while (psMemWrite->lowAddr != 0xffffffff)
13296 {
13297 if ((cpu.z80sp >= psMemWrite->lowAddr) && (cpu.z80sp <= psMemWrite->highAddr))
13298 {
13299 cpu.z80pc = (UINT32) pbPC - (UINT32) cpu.z80Base;
13300 if (psMemWrite->memoryCall)
13301 {
13302 psMemWrite->memoryCall(cpu.z80sp, (cpu.z80IY & 0xff), psMemWrite);
13303 psMemWrite->memoryCall(cpu.z80sp + 1, (cpu.z80IY >> 8), psMemWrite);
13304 }
13305 else
13306 {
13307 *((UINT8 *) psMemWrite->pUserArea + (cpu.z80sp - psMemWrite->lowAddr)) = cpu.z80IY;
13308 *((UINT8 *) psMemWrite->pUserArea + (cpu.z80sp - psMemWrite->lowAddr) + 1) = cpu.z80IY >> 8;
13309 }
13310 psMemWrite = NULL;
13311 break;
13312 }
13313 ++psMemWrite;
13314 }
13315
13316 if (psMemWrite)
13317 {
13318 cpu.z80Base[cpu.z80sp] = (UINT8) cpu.z80IY;
13319 cpu.z80Base[cpu.z80sp + 1] = (UINT8) ((UINT32) cpu.z80IY >> 8);
13320 }
13321
13322 cpu.z80IY = dwAddr;
13323 break;
13324 }
13325 case 0xe4:
13326 {
13327 InvalidInstruction(2);
13328 break;
13329 }
13330 case 0xe5:
13331 {
13332 sdwCyclesRemaining -= 15;
13333 cpu.z80sp -= 2;
13334 pbSP = (cpu.z80Base + cpu.z80sp); /* Normalize the stack pointer */
13335 psMemWrite = cpu.z80MemWrite; /* Beginning of our handler */
13336 while (psMemWrite->lowAddr != 0xffffffff)
13337 {
13338 if ((cpu.z80sp >= psMemWrite->lowAddr) && (cpu.z80sp <= psMemWrite->highAddr))
13339 {
13340 cpu.z80pc = (UINT32) pbPC - (UINT32) cpu.z80Base;
13341 if (psMemWrite->memoryCall)
13342 {
13343 psMemWrite->memoryCall(cpu.z80sp, (cpu.z80IY & 0xff), psMemWrite);
13344 psMemWrite->memoryCall(cpu.z80sp + 1, (cpu.z80IY >> 8), psMemWrite);
13345 }
13346 else
13347 {
13348 *((UINT8 *) psMemWrite->pUserArea + (cpu.z80sp - psMemWrite->lowAddr)) = cpu.z80IY;
13349 *((UINT8 *) psMemWrite->pUserArea + (cpu.z80sp - psMemWrite->lowAddr) + 1) = cpu.z80IY >> 8;
13350 }
13351 psMemWrite = NULL;
13352 break;
13353 }
13354 ++psMemWrite;
13355 }
13356
13357 if (psMemWrite)
13358 {
13359 cpu.z80Base[cpu.z80sp] = (UINT8) cpu.z80IY;
13360 cpu.z80Base[cpu.z80sp + 1] = (UINT8) ((UINT32) cpu.z80IY >> 8);
13361 }
13362
13363 break;
13364 }
13365 case 0xe6:
13366 {
13367 InvalidInstruction(2);
13368 break;
13369 }
13370 case 0xe7:
13371 {
13372 InvalidInstruction(2);
13373 break;
13374 }
13375 case 0xe8:
13376 {
13377 InvalidInstruction(2);
13378 break;
13379 }
13380 case 0xe9:
13381 {
13382 sdwCyclesRemaining -= 8;
13383 pbPC = cpu.z80Base + cpu.z80IY;
13384 break;
13385 }
13386 case 0xea:
13387 {
13388 InvalidInstruction(2);
13389 break;
13390 }
13391 case 0xeb:
13392 {
13393 InvalidInstruction(2);
13394 break;
13395 }
13396 case 0xec:
13397 {
13398 InvalidInstruction(2);
13399 break;
13400 }
13401 case 0xed:
13402 {
13403 InvalidInstruction(2);
13404 break;
13405 }
13406 case 0xee:
13407 {
13408 InvalidInstruction(2);
13409 break;
13410 }
13411 case 0xef:
13412 {
13413 InvalidInstruction(2);
13414 break;
13415 }
13416 case 0xf0:
13417 {
13418 InvalidInstruction(2);
13419 break;
13420 }
13421 case 0xf1:
13422 {
13423 InvalidInstruction(2);
13424 break;
13425 }
13426 case 0xf2:
13427 {
13428 InvalidInstruction(2);
13429 break;
13430 }
13431 case 0xf3:
13432 {
13433 InvalidInstruction(2);
13434 break;
13435 }
13436 case 0xf4:
13437 {
13438 InvalidInstruction(2);
13439 break;
13440 }
13441 case 0xf5:
13442 {
13443 InvalidInstruction(2);
13444 break;
13445 }
13446 case 0xf6:
13447 {
13448 InvalidInstruction(2);
13449 break;
13450 }
13451 case 0xf7:
13452 {
13453 InvalidInstruction(2);
13454 break;
13455 }
13456 case 0xf8:
13457 {
13458 InvalidInstruction(2);
13459 break;
13460 }
13461 case 0xf9:
13462 {
13463 sdwCyclesRemaining -= 10;
13464 cpu.z80sp = cpu.z80IY;
13465 break;
13466 }
13467 case 0xfa:
13468 {
13469 InvalidInstruction(2);
13470 break;
13471 }
13472 case 0xfb:
13473 {
13474 InvalidInstruction(2);
13475 break;
13476 }
13477 case 0xfc:
13478 {
13479 InvalidInstruction(2);
13480 break;
13481 }
13482 case 0xfd:
13483 {
13484 InvalidInstruction(2);
13485 break;
13486 }
13487 case 0xfe:
13488 {
13489 InvalidInstruction(2);
13490 break;
13491 }
13492 case 0xff:
13493 {
13494 InvalidInstruction(2);
13495 break;
13496 }
13497 }
13498}
13499/* Main execution entry point */
13500
13501UINT32 mz80exec(UINT32 dwCycles)
13502{
13503 UINT8 bOpcode;
13504
13505 dwReturnCode = 0x80000000; /* Assume it'll work */
13506 sdwCyclesRemaining = dwCycles;
13507 dwOriginalCycles = dwCycles;
13508 if (cpu.z80halted)
13509 {
13510 dwElapsedTicks += dwCycles;
13511 return(0x80000000);
13512 }
13513
13514 pbPC = cpu.z80Base + cpu.z80pc;
13515
13516 while (sdwCyclesRemaining > 0)
13517 {
13518 bOpcode = *pbPC++;
13519 switch (bOpcode)
13520 {
13521 case 0x00:
13522 {
13523 sdwCyclesRemaining -= 4;
13524 /* Intentionally not doing anything - NOP! */
13525 break;
13526 }
13527 case 0x01:
13528 {
13529 sdwCyclesRemaining -= 10;
13530 cpu.z80BC = *pbPC++; /* LSB First */
13531 cpu.z80BC |= (((UINT32) *pbPC++ << 8)); /* Now the MSB */
13532 break;
13533 }
13534 case 0x02:
13535 {
13536 sdwCyclesRemaining -= 7;
13537 psMemWrite = cpu.z80MemWrite; /* Beginning of our handler */
13538 while (psMemWrite->lowAddr != 0xffffffff)
13539 {
13540 if ((cpu.z80BC >= psMemWrite->lowAddr) && (cpu.z80BC <= psMemWrite->highAddr))
13541 {
13542 cpu.z80pc = (UINT32) pbPC - (UINT32) cpu.z80Base;
13543 if (psMemWrite->memoryCall)
13544 {
13545 psMemWrite->memoryCall(cpu.z80BC, cpu.z80A, psMemWrite);
13546 }
13547 else
13548 {
13549 *((UINT8 *) psMemWrite->pUserArea + (cpu.z80BC - psMemWrite->lowAddr)) = cpu.z80A;
13550 }
13551 psMemWrite = NULL;
13552 break;
13553 }
13554 ++psMemWrite;
13555 }
13556
13557 if (psMemWrite)
13558 {
13559 cpu.z80Base[cpu.z80BC] = (UINT8) cpu.z80A;
13560 }
13561
13562 break;
13563 }
13564 case 0x03:
13565 {
13566 sdwCyclesRemaining -= 6;
13567 cpu.z80BC++;
13568 cpu.z80BC &= 0xffff;
13569 break;
13570 }
13571 case 0x04:
13572 {
13573 sdwCyclesRemaining -= 4;
13574 cpu.z80F &= ~(Z80_FLAG_SIGN | Z80_FLAG_ZERO | Z80_FLAG_HALF_CARRY | Z80_FLAG_OVERFLOW_PARITY | Z80_FLAG_NEGATIVE);
13575 cpu.z80F |= bPostIncFlags[cpu.z80B++];
13576 break;
13577 }
13578 case 0x05:
13579 {
13580 sdwCyclesRemaining -= 4;
13581 cpu.z80F &= ~(Z80_FLAG_SIGN | Z80_FLAG_ZERO | Z80_FLAG_HALF_CARRY | Z80_FLAG_OVERFLOW_PARITY);
13582 cpu.z80F |= bPostDecFlags[cpu.z80B--];
13583 break;
13584 }
13585 case 0x06:
13586 {
13587 sdwCyclesRemaining -= 7;
13588 cpu.z80B = *pbPC++; /* Get immediate byte into register */
13589 break;
13590 }
13591 case 0x07:
13592 {
13593 sdwCyclesRemaining -= 4;
13594 cpu.z80F &= ~(Z80_FLAG_CARRY | Z80_FLAG_NEGATIVE | Z80_FLAG_HALF_CARRY);
13595 cpu.z80F |= (cpu.z80A >> 7);
13596 cpu.z80A = (cpu.z80A << 1) | (cpu.z80A >> 7);
13597 break;
13598 }
13599 case 0x08:
13600 {
13601 sdwCyclesRemaining -= 4;
13602 dwAddr = (UINT32) cpu.z80AF;
13603 cpu.z80AF = cpu.z80afprime;
13604 cpu.z80afprime = dwAddr;
13605 break;
13606 }
13607 case 0x09:
13608 {
13609 sdwCyclesRemaining -= 11;
13610 cpu.z80F &= ~(Z80_FLAG_CARRY | Z80_FLAG_NEGATIVE | Z80_FLAG_HALF_CARRY);
13611 dwTemp = cpu.z80HL + cpu.z80BC;
13612 cpu.z80F |= ((dwTemp >> 16) & Z80_FLAG_CARRY) | (((cpu.z80HL ^ dwTemp ^ cpu.z80BC) >> 8) & Z80_FLAG_HALF_CARRY);
13613 cpu.z80HL = dwTemp & 0xffff;
13614 break;
13615 }
13616 case 0x0a:
13617 {
13618 sdwCyclesRemaining -= 7;
13619 psMemRead = cpu.z80MemRead; /* Beginning of our handler */
13620 while (psMemRead->lowAddr != 0xffffffff)
13621 {
13622 if ((cpu.z80BC >= psMemRead->lowAddr) && (cpu.z80BC <= psMemRead->highAddr))
13623 {
13624 cpu.z80pc = (UINT32) pbPC - (UINT32) cpu.z80Base;
13625 if (psMemRead->memoryCall)
13626 {
13627 cpu.z80A = psMemRead->memoryCall(cpu.z80BC, psMemRead);
13628 }
13629 else
13630 {
13631 cpu.z80A = *((UINT8 *) psMemRead->pUserArea + (cpu.z80BC - psMemRead->lowAddr));
13632 }
13633 psMemRead = NULL;
13634 break;
13635 }
13636 ++psMemRead;
13637 }
13638
13639 if (psMemRead)
13640 {
13641 cpu.z80A = cpu.z80Base[cpu.z80BC];
13642 }
13643
13644 break;
13645 }
13646 case 0x0b:
13647 {
13648 sdwCyclesRemaining -= 6;
13649 cpu.z80BC--;
13650 cpu.z80BC &= 0xffff;
13651 break;
13652 }
13653 case 0x0c:
13654 {
13655 sdwCyclesRemaining -= 4;
13656 cpu.z80F &= ~(Z80_FLAG_SIGN | Z80_FLAG_ZERO | Z80_FLAG_HALF_CARRY | Z80_FLAG_OVERFLOW_PARITY | Z80_FLAG_NEGATIVE);
13657 cpu.z80F |= bPostIncFlags[cpu.z80C++];
13658 break;
13659 }
13660 case 0x0d:
13661 {
13662 sdwCyclesRemaining -= 4;
13663 cpu.z80F &= ~(Z80_FLAG_SIGN | Z80_FLAG_ZERO | Z80_FLAG_HALF_CARRY | Z80_FLAG_OVERFLOW_PARITY);
13664 cpu.z80F |= bPostDecFlags[cpu.z80C--];
13665 break;
13666 }
13667 case 0x0e:
13668 {
13669 sdwCyclesRemaining -= 7;
13670 cpu.z80C = *pbPC++; /* Get immediate byte into register */
13671 break;
13672 }
13673 case 0x0f:
13674 {
13675 sdwCyclesRemaining -= 4;
13676 cpu.z80F &= ~(Z80_FLAG_CARRY | Z80_FLAG_NEGATIVE | Z80_FLAG_HALF_CARRY);
13677 cpu.z80F |= (cpu.z80A & Z80_FLAG_CARRY);
13678 cpu.z80A = (cpu.z80A >> 1) | (cpu.z80A << 7);
13679 break;
13680 }
13681 case 0x10:
13682 {
13683 sdwCyclesRemaining -= 8;
13684 sdwAddr = (INT8) *pbPC++; /* Get LSB first */
13685 if (--cpu.z80B)
13686 {
13687 dwElapsedTicks += 5; /* 5 More for jump taken */
13688 cpu.z80pc = (UINT32) pbPC - (UINT32) cpu.z80Base;
13689 sdwAddr = (sdwAddr + (INT32) cpu.z80pc) & 0xffff;
13690 pbPC = cpu.z80Base + sdwAddr; /* Normalize the address */
13691 }
13692 break;
13693 }
13694 case 0x11:
13695 {
13696 sdwCyclesRemaining -= 10;
13697 cpu.z80DE = *pbPC++; /* LSB First */
13698 cpu.z80DE |= (((UINT32) *pbPC++ << 8)); /* Now the MSB */
13699 break;
13700 }
13701 case 0x12:
13702 {
13703 sdwCyclesRemaining -= 7;
13704 psMemWrite = cpu.z80MemWrite; /* Beginning of our handler */
13705 while (psMemWrite->lowAddr != 0xffffffff)
13706 {
13707 if ((cpu.z80DE >= psMemWrite->lowAddr) && (cpu.z80DE <= psMemWrite->highAddr))
13708 {
13709 cpu.z80pc = (UINT32) pbPC - (UINT32) cpu.z80Base;
13710 if (psMemWrite->memoryCall)
13711 {
13712 psMemWrite->memoryCall(cpu.z80DE, cpu.z80A, psMemWrite);
13713 }
13714 else
13715 {
13716 *((UINT8 *) psMemWrite->pUserArea + (cpu.z80DE - psMemWrite->lowAddr)) = cpu.z80A;
13717 }
13718 psMemWrite = NULL;
13719 break;
13720 }
13721 ++psMemWrite;
13722 }
13723
13724 if (psMemWrite)
13725 {
13726 cpu.z80Base[cpu.z80DE] = (UINT8) cpu.z80A;
13727 }
13728
13729 break;
13730 }
13731 case 0x13:
13732 {
13733 sdwCyclesRemaining -= 6;
13734 cpu.z80DE++;
13735 cpu.z80DE &= 0xffff;
13736 break;
13737 }
13738 case 0x14:
13739 {
13740 sdwCyclesRemaining -= 4;
13741 cpu.z80F &= ~(Z80_FLAG_SIGN | Z80_FLAG_ZERO | Z80_FLAG_HALF_CARRY | Z80_FLAG_OVERFLOW_PARITY | Z80_FLAG_NEGATIVE);
13742 cpu.z80F |= bPostIncFlags[cpu.z80D++];
13743 break;
13744 }
13745 case 0x15:
13746 {
13747 sdwCyclesRemaining -= 4;
13748 cpu.z80F &= ~(Z80_FLAG_SIGN | Z80_FLAG_ZERO | Z80_FLAG_HALF_CARRY | Z80_FLAG_OVERFLOW_PARITY);
13749 cpu.z80F |= bPostDecFlags[cpu.z80D--];
13750 break;
13751 }
13752 case 0x16:
13753 {
13754 sdwCyclesRemaining -= 7;
13755 cpu.z80D = *pbPC++; /* Get immediate byte into register */
13756 break;
13757 }
13758 case 0x17:
13759 {
13760 sdwCyclesRemaining -= 4;
13761 bTemp = cpu.z80A >> 7;
13762 cpu.z80A = (cpu.z80A << 1) | (cpu.z80F & Z80_FLAG_CARRY);
13763 cpu.z80F = (cpu.z80F & ~(Z80_FLAG_CARRY | Z80_FLAG_NEGATIVE | Z80_FLAG_HALF_CARRY)) | bTemp;
13764 break;
13765 }
13766 case 0x18:
13767 {
13768 sdwCyclesRemaining -= 12;
13769 sdwAddr = (INT8) *pbPC++; /* Get LSB first */
13770 cpu.z80pc = (UINT32) pbPC - (UINT32) cpu.z80Base;
13771 sdwAddr = (sdwAddr + (INT32) cpu.z80pc) & 0xffff;
13772 {
13773 sdwCyclesRemaining -= 5;
13774 pbPC = cpu.z80Base + sdwAddr; /* Normalize the address */
13775 }
13776 break;
13777 }
13778 case 0x19:
13779 {
13780 sdwCyclesRemaining -= 11;
13781 cpu.z80F &= ~(Z80_FLAG_CARRY | Z80_FLAG_NEGATIVE | Z80_FLAG_HALF_CARRY);
13782 dwTemp = cpu.z80HL + cpu.z80DE;
13783 cpu.z80F |= ((dwTemp >> 16) & Z80_FLAG_CARRY) | (((cpu.z80HL ^ dwTemp ^ cpu.z80DE) >> 8) & Z80_FLAG_HALF_CARRY);
13784 cpu.z80HL = dwTemp & 0xffff;
13785 break;
13786 }
13787 case 0x1a:
13788 {
13789 sdwCyclesRemaining -= 7;
13790 psMemRead = cpu.z80MemRead; /* Beginning of our handler */
13791 while (psMemRead->lowAddr != 0xffffffff)
13792 {
13793 if ((cpu.z80DE >= psMemRead->lowAddr) && (cpu.z80DE <= psMemRead->highAddr))
13794 {
13795 cpu.z80pc = (UINT32) pbPC - (UINT32) cpu.z80Base;
13796 if (psMemRead->memoryCall)
13797 {
13798 cpu.z80A = psMemRead->memoryCall(cpu.z80DE, psMemRead);
13799 }
13800 else
13801 {
13802 cpu.z80A = *((UINT8 *) psMemRead->pUserArea + (cpu.z80DE - psMemRead->lowAddr));
13803 }
13804 psMemRead = NULL;
13805 break;
13806 }
13807 ++psMemRead;
13808 }
13809
13810 if (psMemRead)
13811 {
13812 cpu.z80A = cpu.z80Base[cpu.z80DE];
13813 }
13814
13815 break;
13816 }
13817 case 0x1b:
13818 {
13819 sdwCyclesRemaining -= 6;
13820 cpu.z80DE--;
13821 cpu.z80DE &= 0xffff;
13822 break;
13823 }
13824 case 0x1c:
13825 {
13826 sdwCyclesRemaining -= 4;
13827 cpu.z80F &= ~(Z80_FLAG_SIGN | Z80_FLAG_ZERO | Z80_FLAG_HALF_CARRY | Z80_FLAG_OVERFLOW_PARITY | Z80_FLAG_NEGATIVE);
13828 cpu.z80F |= bPostIncFlags[cpu.z80E++];
13829 break;
13830 }
13831 case 0x1d:
13832 {
13833 sdwCyclesRemaining -= 4;
13834 cpu.z80F &= ~(Z80_FLAG_SIGN | Z80_FLAG_ZERO | Z80_FLAG_HALF_CARRY | Z80_FLAG_OVERFLOW_PARITY);
13835 cpu.z80F |= bPostDecFlags[cpu.z80E--];
13836 break;
13837 }
13838 case 0x1e:
13839 {
13840 sdwCyclesRemaining -= 7;
13841 cpu.z80E = *pbPC++; /* Get immediate byte into register */
13842 break;
13843 }
13844 case 0x1f:
13845 {
13846 sdwCyclesRemaining -= 4;
13847 bTemp = (cpu.z80F & Z80_FLAG_CARRY) << 7;
13848 cpu.z80F = (cpu.z80F & ~(Z80_FLAG_CARRY | Z80_FLAG_NEGATIVE | Z80_FLAG_HALF_CARRY)) | (cpu.z80A & Z80_FLAG_CARRY);
13849 cpu.z80A = ((cpu.z80A >> 1) | bTemp);
13850 break;
13851 }
13852 case 0x20:
13853 {
13854 sdwCyclesRemaining -= 7;
13855 sdwAddr = (INT8) *pbPC++; /* Get LSB first */
13856 cpu.z80pc = (UINT32) pbPC - (UINT32) cpu.z80Base;
13857 sdwAddr = (sdwAddr + (INT32) cpu.z80pc) & 0xffff;
13858 if (!(cpu.z80F & Z80_FLAG_ZERO))
13859 {
13860 sdwCyclesRemaining -= 5;
13861 pbPC = cpu.z80Base + sdwAddr; /* Normalize the address */
13862 }
13863 break;
13864 }
13865 case 0x21:
13866 {
13867 sdwCyclesRemaining -= 10;
13868 cpu.z80HL = *pbPC++; /* LSB First */
13869 cpu.z80HL |= (((UINT32) *pbPC++ << 8)); /* Now the MSB */
13870 break;
13871 }
13872 case 0x22:
13873 {
13874 sdwCyclesRemaining -= 16;
13875 dwTemp = *pbPC++;
13876 dwTemp |= ((UINT32) *pbPC++ << 8);
13877 psMemWrite = cpu.z80MemWrite; /* Beginning of our handler */
13878 while (psMemWrite->lowAddr != 0xffffffff)
13879 {
13880 if ((dwTemp >= psMemWrite->lowAddr) && (dwTemp <= psMemWrite->highAddr))
13881 {
13882 cpu.z80pc = (UINT32) pbPC - (UINT32) cpu.z80Base;
13883 if (psMemWrite->memoryCall)
13884 {
13885 psMemWrite->memoryCall(dwTemp, (cpu.z80HL & 0xff), psMemWrite);
13886 psMemWrite->memoryCall(dwTemp + 1, (cpu.z80HL >> 8), psMemWrite);
13887 }
13888 else
13889 {
13890 *((UINT8 *) psMemWrite->pUserArea + (dwTemp - psMemWrite->lowAddr)) = cpu.z80HL;
13891 *((UINT8 *) psMemWrite->pUserArea + (dwTemp - psMemWrite->lowAddr) + 1) = cpu.z80HL >> 8;
13892 }
13893 psMemWrite = NULL;
13894 break;
13895 }
13896 ++psMemWrite;
13897 }
13898
13899 if (psMemWrite)
13900 {
13901 cpu.z80Base[dwTemp] = (UINT8) cpu.z80HL;
13902 cpu.z80Base[dwTemp + 1] = (UINT8) ((UINT32) cpu.z80HL >> 8);
13903 }
13904
13905 break;
13906 }
13907 case 0x23:
13908 {
13909 sdwCyclesRemaining -= 6;
13910 cpu.z80HL++;
13911 cpu.z80HL &= 0xffff;
13912 break;
13913 }
13914 case 0x24:
13915 {
13916 sdwCyclesRemaining -= 4;
13917 cpu.z80F &= ~(Z80_FLAG_SIGN | Z80_FLAG_ZERO | Z80_FLAG_HALF_CARRY | Z80_FLAG_OVERFLOW_PARITY | Z80_FLAG_NEGATIVE);
13918 cpu.z80F |= bPostIncFlags[cpu.z80H++];
13919 break;
13920 }
13921 case 0x25:
13922 {
13923 sdwCyclesRemaining -= 4;
13924 cpu.z80F &= ~(Z80_FLAG_SIGN | Z80_FLAG_ZERO | Z80_FLAG_HALF_CARRY | Z80_FLAG_OVERFLOW_PARITY);
13925 cpu.z80F |= bPostDecFlags[cpu.z80H--];
13926 break;
13927 }
13928 case 0x26:
13929 {
13930 sdwCyclesRemaining -= 7;
13931 cpu.z80H = *pbPC++; /* Get immediate byte into register */
13932 break;
13933 }
13934 case 0x27:
13935 {
13936 sdwCyclesRemaining -= 4;
13937 dwAddr = (((cpu.z80F & Z80_FLAG_CARRY) |
13938 ((cpu.z80F & Z80_FLAG_HALF_CARRY) >> 3) |
13939 ((cpu.z80F & Z80_FLAG_NEGATIVE) << 1)) << 8) | cpu.z80A;
13940 cpu.z80F &= ~(Z80_FLAG_CARRY | Z80_FLAG_OVERFLOW_PARITY | Z80_FLAG_HALF_CARRY | Z80_FLAG_ZERO | Z80_FLAG_SIGN);
13941 cpu.z80F |= (wDAATable[dwAddr] >> 8);
13942 cpu.z80A = wDAATable[dwAddr] & 0xff;
13943 break;
13944 }
13945 case 0x28:
13946 {
13947 sdwCyclesRemaining -= 7;
13948 sdwAddr = (INT8) *pbPC++; /* Get LSB first */
13949 cpu.z80pc = (UINT32) pbPC - (UINT32) cpu.z80Base;
13950 sdwAddr = (sdwAddr + (INT32) cpu.z80pc) & 0xffff;
13951 if (cpu.z80F & Z80_FLAG_ZERO)
13952 {
13953 sdwCyclesRemaining -= 5;
13954 pbPC = cpu.z80Base + sdwAddr; /* Normalize the address */
13955 }
13956 break;
13957 }
13958 case 0x29:
13959 {
13960 sdwCyclesRemaining -= 11;
13961 cpu.z80F &= ~(Z80_FLAG_CARRY | Z80_FLAG_NEGATIVE | Z80_FLAG_HALF_CARRY);
13962 dwTemp = cpu.z80HL + cpu.z80HL;
13963 cpu.z80F |= ((dwTemp >> 16) & Z80_FLAG_CARRY) | (((cpu.z80HL ^ dwTemp ^ cpu.z80HL) >> 8) & Z80_FLAG_HALF_CARRY);
13964 cpu.z80HL = dwTemp & 0xffff;
13965 break;
13966 }
13967 case 0x2a:
13968 {
13969 sdwCyclesRemaining -= 16;
13970 dwAddr = *pbPC++;
13971 dwAddr |= ((UINT32) *pbPC++ << 8);
13972 psMemRead = cpu.z80MemRead; /* Beginning of our handler */
13973 while (psMemRead->lowAddr != 0xffffffff)
13974 {
13975 if ((dwAddr >= psMemRead->lowAddr) && (dwAddr <= psMemRead->highAddr))
13976 {
13977 cpu.z80pc = (UINT32) pbPC - (UINT32) cpu.z80Base;
13978 if (psMemRead->memoryCall)
13979 {
13980 cpu.z80HL = psMemRead->memoryCall(dwAddr, psMemRead);
13981 cpu.z80HL |= (UINT32) ((UINT32) psMemRead->memoryCall(dwAddr + 1, psMemRead) << 8);
13982 }
13983 else
13984 {
13985 cpu.z80HL = *((UINT8 *) psMemRead->pUserArea + (dwAddr - psMemRead->lowAddr));
13986 cpu.z80HL |= (UINT32) ((UINT32) *((UINT8 *) psMemRead->pUserArea + (dwAddr - psMemRead->lowAddr + 1)) << 8);
13987 }
13988 psMemRead = NULL;
13989 break;
13990 }
13991 ++psMemRead;
13992 }
13993
13994 if (psMemRead)
13995 {
13996 cpu.z80HL = cpu.z80Base[dwAddr];
13997 cpu.z80HL |= (UINT32) ((UINT32) cpu.z80Base[dwAddr + 1] << 8);
13998 }
13999
14000 break;
14001 }
14002 case 0x2b:
14003 {
14004 sdwCyclesRemaining -= 6;
14005 cpu.z80HL--;
14006 cpu.z80HL &= 0xffff;
14007 break;
14008 }
14009 case 0x2c:
14010 {
14011 sdwCyclesRemaining -= 4;
14012 cpu.z80F &= ~(Z80_FLAG_SIGN | Z80_FLAG_ZERO | Z80_FLAG_HALF_CARRY | Z80_FLAG_OVERFLOW_PARITY | Z80_FLAG_NEGATIVE);
14013 cpu.z80F |= bPostIncFlags[cpu.z80L++];
14014 break;
14015 }
14016 case 0x2d:
14017 {
14018 sdwCyclesRemaining -= 4;
14019 cpu.z80F &= ~(Z80_FLAG_SIGN | Z80_FLAG_ZERO | Z80_FLAG_HALF_CARRY | Z80_FLAG_OVERFLOW_PARITY);
14020 cpu.z80F |= bPostDecFlags[cpu.z80L--];
14021 break;
14022 }
14023 case 0x2e:
14024 {
14025 sdwCyclesRemaining -= 7;
14026 cpu.z80L = *pbPC++; /* Get immediate byte into register */
14027 break;
14028 }
14029 case 0x2f:
14030 {
14031 sdwCyclesRemaining -= 4;
14032 cpu.z80A ^= 0xff;
14033 cpu.z80F |= (Z80_FLAG_NEGATIVE | Z80_FLAG_HALF_CARRY);
14034 break;
14035 }
14036 case 0x30:
14037 {
14038 sdwCyclesRemaining -= 7;
14039 sdwAddr = (INT8) *pbPC++; /* Get LSB first */
14040 cpu.z80pc = (UINT32) pbPC - (UINT32) cpu.z80Base;
14041 sdwAddr = (sdwAddr + (INT32) cpu.z80pc) & 0xffff;
14042 if (!(cpu.z80F & Z80_FLAG_CARRY))
14043 {
14044 sdwCyclesRemaining -= 5;
14045 pbPC = cpu.z80Base + sdwAddr; /* Normalize the address */
14046 }
14047 break;
14048 }
14049 case 0x31:
14050 {
14051 sdwCyclesRemaining -= 10;
14052 cpu.z80sp = *pbPC++; /* LSB First */
14053 cpu.z80sp |= (((UINT32) *pbPC++ << 8)); /* Now the MSB */
14054 break;
14055 }
14056 case 0x32:
14057 {
14058 sdwCyclesRemaining -= 13;
14059 dwTemp = *pbPC++;
14060 dwTemp |= ((UINT32) *pbPC++ << 8);
14061 psMemWrite = cpu.z80MemWrite; /* Beginning of our handler */
14062 while (psMemWrite->lowAddr != 0xffffffff)
14063 {
14064 if ((dwTemp >= psMemWrite->lowAddr) && (dwTemp <= psMemWrite->highAddr))
14065 {
14066 cpu.z80pc = (UINT32) pbPC - (UINT32) cpu.z80Base;
14067 if (psMemWrite->memoryCall)
14068 {
14069 psMemWrite->memoryCall(dwTemp, cpu.z80A, psMemWrite);
14070 }
14071 else
14072 {
14073 *((UINT8 *) psMemWrite->pUserArea + (dwTemp - psMemWrite->lowAddr)) = cpu.z80A;
14074 }
14075 psMemWrite = NULL;
14076 break;
14077 }
14078 ++psMemWrite;
14079 }
14080
14081 if (psMemWrite)
14082 {
14083 cpu.z80Base[dwTemp] = (UINT8) cpu.z80A;
14084 }
14085
14086 break;
14087 }
14088 case 0x33:
14089 {
14090 sdwCyclesRemaining -= 6;
14091 cpu.z80sp++;
14092 cpu.z80sp &= 0xffff;
14093 break;
14094 }
14095 case 0x34:
14096 {
14097 sdwCyclesRemaining -= 11;
14098 psMemRead = cpu.z80MemRead; /* Beginning of our handler */
14099 while (psMemRead->lowAddr != 0xffffffff)
14100 {
14101 if ((cpu.z80HL >= psMemRead->lowAddr) && (cpu.z80HL <= psMemRead->highAddr))
14102 {
14103 cpu.z80pc = (UINT32) pbPC - (UINT32) cpu.z80Base;
14104 if (psMemRead->memoryCall)
14105 {
14106 bTemp = psMemRead->memoryCall(cpu.z80HL, psMemRead);
14107 }
14108 else
14109 {
14110 bTemp = *((UINT8 *) psMemRead->pUserArea + (cpu.z80HL - psMemRead->lowAddr));
14111 }
14112 psMemRead = NULL;
14113 break;
14114 }
14115 ++psMemRead;
14116 }
14117
14118 if (psMemRead)
14119 {
14120 bTemp = cpu.z80Base[cpu.z80HL];
14121 }
14122
14123 cpu.z80F &= ~(Z80_FLAG_SIGN | Z80_FLAG_ZERO | Z80_FLAG_HALF_CARRY | Z80_FLAG_OVERFLOW_PARITY | Z80_FLAG_NEGATIVE);
14124 cpu.z80F |= bPostIncFlags[bTemp];
14125 bTemp++;
14126 psMemWrite = cpu.z80MemWrite; /* Beginning of our handler */
14127 while (psMemWrite->lowAddr != 0xffffffff)
14128 {
14129 if ((cpu.z80HL >= psMemWrite->lowAddr) && (cpu.z80HL <= psMemWrite->highAddr))
14130 {
14131 cpu.z80pc = (UINT32) pbPC - (UINT32) cpu.z80Base;
14132 if (psMemWrite->memoryCall)
14133 {
14134 psMemWrite->memoryCall(cpu.z80HL, bTemp, psMemWrite);
14135 }
14136 else
14137 {
14138 *((UINT8 *) psMemWrite->pUserArea + (cpu.z80HL - psMemWrite->lowAddr)) = bTemp;
14139 }
14140 psMemWrite = NULL;
14141 break;
14142 }
14143 ++psMemWrite;
14144 }
14145
14146 if (psMemWrite)
14147 {
14148 cpu.z80Base[cpu.z80HL] = (UINT8) bTemp;
14149 }
14150
14151 break;
14152 }
14153 case 0x35:
14154 {
14155 sdwCyclesRemaining -= 11;
14156 psMemRead = cpu.z80MemRead; /* Beginning of our handler */
14157 while (psMemRead->lowAddr != 0xffffffff)
14158 {
14159 if ((cpu.z80HL >= psMemRead->lowAddr) && (cpu.z80HL <= psMemRead->highAddr))
14160 {
14161 cpu.z80pc = (UINT32) pbPC - (UINT32) cpu.z80Base;
14162 if (psMemRead->memoryCall)
14163 {
14164 bTemp = psMemRead->memoryCall(cpu.z80HL, psMemRead);
14165 }
14166 else
14167 {
14168 bTemp = *((UINT8 *) psMemRead->pUserArea + (cpu.z80HL - psMemRead->lowAddr));
14169 }
14170 psMemRead = NULL;
14171 break;
14172 }
14173 ++psMemRead;
14174 }
14175
14176 if (psMemRead)
14177 {
14178 bTemp = cpu.z80Base[cpu.z80HL];
14179 }
14180
14181 cpu.z80F &= ~(Z80_FLAG_SIGN | Z80_FLAG_ZERO | Z80_FLAG_HALF_CARRY | Z80_FLAG_OVERFLOW_PARITY | Z80_FLAG_NEGATIVE);
14182 cpu.z80F |= bPostDecFlags[bTemp];
14183 bTemp--;
14184 psMemWrite = cpu.z80MemWrite; /* Beginning of our handler */
14185 while (psMemWrite->lowAddr != 0xffffffff)
14186 {
14187 if ((cpu.z80HL >= psMemWrite->lowAddr) && (cpu.z80HL <= psMemWrite->highAddr))
14188 {
14189 cpu.z80pc = (UINT32) pbPC - (UINT32) cpu.z80Base;
14190 if (psMemWrite->memoryCall)
14191 {
14192 psMemWrite->memoryCall(cpu.z80HL, bTemp, psMemWrite);
14193 }
14194 else
14195 {
14196 *((UINT8 *) psMemWrite->pUserArea + (cpu.z80HL - psMemWrite->lowAddr)) = bTemp;
14197 }
14198 psMemWrite = NULL;
14199 break;
14200 }
14201 ++psMemWrite;
14202 }
14203
14204 if (psMemWrite)
14205 {
14206 cpu.z80Base[cpu.z80HL] = (UINT8) bTemp;
14207 }
14208
14209 break;
14210 }
14211 case 0x36:
14212 {
14213 sdwCyclesRemaining -= 10;
14214 psMemWrite = cpu.z80MemWrite; /* Beginning of our handler */
14215 while (psMemWrite->lowAddr != 0xffffffff)
14216 {
14217 if ((cpu.z80HL >= psMemWrite->lowAddr) && (cpu.z80HL <= psMemWrite->highAddr))
14218 {
14219 cpu.z80pc = (UINT32) pbPC - (UINT32) cpu.z80Base;
14220 if (psMemWrite->memoryCall)
14221 {
14222 psMemWrite->memoryCall(cpu.z80HL, *pbPC++, psMemWrite);
14223 }
14224 else
14225 {
14226 *((UINT8 *) psMemWrite->pUserArea + (cpu.z80HL - psMemWrite->lowAddr)) = *pbPC++;
14227 }
14228 psMemWrite = NULL;
14229 break;
14230 }
14231 ++psMemWrite;
14232 }
14233
14234 if (psMemWrite)
14235 {
14236 cpu.z80Base[cpu.z80HL] = (UINT8) *pbPC++;
14237 }
14238
14239 break;
14240 }
14241 case 0x37:
14242 {
14243 sdwCyclesRemaining -= 4;
14244 cpu.z80F &= ~(Z80_FLAG_HALF_CARRY | Z80_FLAG_NEGATIVE);
14245 cpu.z80F |= Z80_FLAG_CARRY;
14246 break;
14247 }
14248 case 0x38:
14249 {
14250 sdwCyclesRemaining -= 7;
14251 sdwAddr = (INT8) *pbPC++; /* Get LSB first */
14252 cpu.z80pc = (UINT32) pbPC - (UINT32) cpu.z80Base;
14253 sdwAddr = (sdwAddr + (INT32) cpu.z80pc) & 0xffff;
14254 if (cpu.z80F & Z80_FLAG_CARRY)
14255 {
14256 sdwCyclesRemaining -= 5;
14257 pbPC = cpu.z80Base + sdwAddr; /* Normalize the address */
14258 }
14259 break;
14260 }
14261 case 0x39:
14262 {
14263 sdwCyclesRemaining -= 11;
14264 cpu.z80F &= ~(Z80_FLAG_CARRY | Z80_FLAG_NEGATIVE | Z80_FLAG_HALF_CARRY);
14265 dwTemp = cpu.z80HL + cpu.z80sp;
14266 cpu.z80F |= ((dwTemp >> 16) & Z80_FLAG_CARRY) | (((cpu.z80HL ^ dwTemp ^ cpu.z80sp) >> 8) & Z80_FLAG_HALF_CARRY);
14267 cpu.z80HL = dwTemp & 0xffff;
14268 break;
14269 }
14270 case 0x3a:
14271 {
14272 sdwCyclesRemaining -= 13;
14273 dwTemp = *pbPC++;
14274 dwTemp |= (((UINT32) *pbPC++) << 8);
14275 psMemRead = cpu.z80MemRead; /* Beginning of our handler */
14276 while (psMemRead->lowAddr != 0xffffffff)
14277 {
14278 if ((dwTemp >= psMemRead->lowAddr) && (dwTemp <= psMemRead->highAddr))
14279 {
14280 cpu.z80pc = (UINT32) pbPC - (UINT32) cpu.z80Base;
14281 if (psMemRead->memoryCall)
14282 {
14283 cpu.z80A = psMemRead->memoryCall(dwTemp, psMemRead);
14284 }
14285 else
14286 {
14287 cpu.z80A = *((UINT8 *) psMemRead->pUserArea + (dwTemp - psMemRead->lowAddr));
14288 }
14289 psMemRead = NULL;
14290 break;
14291 }
14292 ++psMemRead;
14293 }
14294
14295 if (psMemRead)
14296 {
14297 cpu.z80A = cpu.z80Base[dwTemp];
14298 }
14299
14300 break;
14301 }
14302 case 0x3b:
14303 {
14304 sdwCyclesRemaining -= 6;
14305 cpu.z80sp--;
14306 cpu.z80sp &= 0xffff;
14307 break;
14308 }
14309 case 0x3c:
14310 {
14311 sdwCyclesRemaining -= 4;
14312 cpu.z80F &= ~(Z80_FLAG_SIGN | Z80_FLAG_ZERO | Z80_FLAG_HALF_CARRY | Z80_FLAG_OVERFLOW_PARITY | Z80_FLAG_NEGATIVE);
14313 cpu.z80F |= bPostIncFlags[cpu.z80A++];
14314 break;
14315 }
14316 case 0x3d:
14317 {
14318 sdwCyclesRemaining -= 4;
14319 cpu.z80F &= ~(Z80_FLAG_SIGN | Z80_FLAG_ZERO | Z80_FLAG_HALF_CARRY | Z80_FLAG_OVERFLOW_PARITY);
14320 cpu.z80F |= bPostDecFlags[cpu.z80A--];
14321 break;
14322 }
14323 case 0x3e:
14324 {
14325 sdwCyclesRemaining -= 7;
14326 cpu.z80A = *pbPC++; /* Get immediate byte into register */
14327 break;
14328 }
14329 case 0x3f:
14330 {
14331 sdwCyclesRemaining -= 4;
14332 bTemp = (cpu.z80F & Z80_FLAG_CARRY) << 4;
14333 cpu.z80F &= ~(Z80_FLAG_HALF_CARRY | Z80_FLAG_NEGATIVE);
14334 cpu.z80F ^= Z80_FLAG_CARRY;
14335 break;
14336 }
14337 case 0x40:
14338 {
14339 sdwCyclesRemaining -= 4;
14340 break;
14341 }
14342 case 0x41:
14343 {
14344 sdwCyclesRemaining -= 4;
14345 cpu.z80B = cpu.z80C;
14346 break;
14347 }
14348 case 0x42:
14349 {
14350 sdwCyclesRemaining -= 4;
14351 cpu.z80B = cpu.z80D;
14352 break;
14353 }
14354 case 0x43:
14355 {
14356 sdwCyclesRemaining -= 4;
14357 cpu.z80B = cpu.z80E;
14358 break;
14359 }
14360 case 0x44:
14361 {
14362 sdwCyclesRemaining -= 4;
14363 cpu.z80B = cpu.z80H;
14364 break;
14365 }
14366 case 0x45:
14367 {
14368 sdwCyclesRemaining -= 4;
14369 cpu.z80B = cpu.z80L;
14370 break;
14371 }
14372 case 0x46:
14373 {
14374 sdwCyclesRemaining -= 7;
14375 psMemRead = cpu.z80MemRead; /* Beginning of our handler */
14376 while (psMemRead->lowAddr != 0xffffffff)
14377 {
14378 if ((cpu.z80HL >= psMemRead->lowAddr) && (cpu.z80HL <= psMemRead->highAddr))
14379 {
14380 cpu.z80pc = (UINT32) pbPC - (UINT32) cpu.z80Base;
14381 if (psMemRead->memoryCall)
14382 {
14383 cpu.z80B = psMemRead->memoryCall(cpu.z80HL, psMemRead);
14384 }
14385 else
14386 {
14387 cpu.z80B = *((UINT8 *) psMemRead->pUserArea + (cpu.z80HL - psMemRead->lowAddr));
14388 }
14389 psMemRead = NULL;
14390 break;
14391 }
14392 ++psMemRead;
14393 }
14394
14395 if (psMemRead)
14396 {
14397 cpu.z80B = cpu.z80Base[cpu.z80HL];
14398 }
14399
14400 break;
14401 }
14402 case 0x47:
14403 {
14404 sdwCyclesRemaining -= 4;
14405 cpu.z80B = cpu.z80A;
14406 break;
14407 }
14408 case 0x48:
14409 {
14410 sdwCyclesRemaining -= 4;
14411 cpu.z80C = cpu.z80B;
14412 break;
14413 }
14414 case 0x49:
14415 {
14416 sdwCyclesRemaining -= 4;
14417 break;
14418 }
14419 case 0x4a:
14420 {
14421 sdwCyclesRemaining -= 4;
14422 cpu.z80C = cpu.z80D;
14423 break;
14424 }
14425 case 0x4b:
14426 {
14427 sdwCyclesRemaining -= 4;
14428 cpu.z80C = cpu.z80E;
14429 break;
14430 }
14431 case 0x4c:
14432 {
14433 sdwCyclesRemaining -= 4;
14434 cpu.z80C = cpu.z80H;
14435 break;
14436 }
14437 case 0x4d:
14438 {
14439 sdwCyclesRemaining -= 4;
14440 cpu.z80C = cpu.z80L;
14441 break;
14442 }
14443 case 0x4e:
14444 {
14445 sdwCyclesRemaining -= 7;
14446 psMemRead = cpu.z80MemRead; /* Beginning of our handler */
14447 while (psMemRead->lowAddr != 0xffffffff)
14448 {
14449 if ((cpu.z80HL >= psMemRead->lowAddr) && (cpu.z80HL <= psMemRead->highAddr))
14450 {
14451 cpu.z80pc = (UINT32) pbPC - (UINT32) cpu.z80Base;
14452 if (psMemRead->memoryCall)
14453 {
14454 cpu.z80C = psMemRead->memoryCall(cpu.z80HL, psMemRead);
14455 }
14456 else
14457 {
14458 cpu.z80C = *((UINT8 *) psMemRead->pUserArea + (cpu.z80HL - psMemRead->lowAddr));
14459 }
14460 psMemRead = NULL;
14461 break;
14462 }
14463 ++psMemRead;
14464 }
14465
14466 if (psMemRead)
14467 {
14468 cpu.z80C = cpu.z80Base[cpu.z80HL];
14469 }
14470
14471 break;
14472 }
14473 case 0x4f:
14474 {
14475 sdwCyclesRemaining -= 4;
14476 cpu.z80C = cpu.z80A;
14477 break;
14478 }
14479 case 0x50:
14480 {
14481 sdwCyclesRemaining -= 4;
14482 cpu.z80D = cpu.z80B;
14483 break;
14484 }
14485 case 0x51:
14486 {
14487 sdwCyclesRemaining -= 4;
14488 cpu.z80D = cpu.z80C;
14489 break;
14490 }
14491 case 0x52:
14492 {
14493 sdwCyclesRemaining -= 4;
14494 break;
14495 }
14496 case 0x53:
14497 {
14498 sdwCyclesRemaining -= 4;
14499 cpu.z80D = cpu.z80E;
14500 break;
14501 }
14502 case 0x54:
14503 {
14504 sdwCyclesRemaining -= 4;
14505 cpu.z80D = cpu.z80H;
14506 break;
14507 }
14508 case 0x55:
14509 {
14510 sdwCyclesRemaining -= 4;
14511 cpu.z80D = cpu.z80L;
14512 break;
14513 }
14514 case 0x56:
14515 {
14516 sdwCyclesRemaining -= 7;
14517 psMemRead = cpu.z80MemRead; /* Beginning of our handler */
14518 while (psMemRead->lowAddr != 0xffffffff)
14519 {
14520 if ((cpu.z80HL >= psMemRead->lowAddr) && (cpu.z80HL <= psMemRead->highAddr))
14521 {
14522 cpu.z80pc = (UINT32) pbPC - (UINT32) cpu.z80Base;
14523 if (psMemRead->memoryCall)
14524 {
14525 cpu.z80D = psMemRead->memoryCall(cpu.z80HL, psMemRead);
14526 }
14527 else
14528 {
14529 cpu.z80D = *((UINT8 *) psMemRead->pUserArea + (cpu.z80HL - psMemRead->lowAddr));
14530 }
14531 psMemRead = NULL;
14532 break;
14533 }
14534 ++psMemRead;
14535 }
14536
14537 if (psMemRead)
14538 {
14539 cpu.z80D = cpu.z80Base[cpu.z80HL];
14540 }
14541
14542 break;
14543 }
14544 case 0x57:
14545 {
14546 sdwCyclesRemaining -= 4;
14547 cpu.z80D = cpu.z80A;
14548 break;
14549 }
14550 case 0x58:
14551 {
14552 sdwCyclesRemaining -= 4;
14553 cpu.z80E = cpu.z80B;
14554 break;
14555 }
14556 case 0x59:
14557 {
14558 sdwCyclesRemaining -= 4;
14559 cpu.z80E = cpu.z80C;
14560 break;
14561 }
14562 case 0x5a:
14563 {
14564 sdwCyclesRemaining -= 4;
14565 cpu.z80E = cpu.z80D;
14566 break;
14567 }
14568 case 0x5b:
14569 {
14570 sdwCyclesRemaining -= 4;
14571 break;
14572 }
14573 case 0x5c:
14574 {
14575 sdwCyclesRemaining -= 4;
14576 cpu.z80E = cpu.z80H;
14577 break;
14578 }
14579 case 0x5d:
14580 {
14581 sdwCyclesRemaining -= 4;
14582 cpu.z80E = cpu.z80L;
14583 break;
14584 }
14585 case 0x5e:
14586 {
14587 sdwCyclesRemaining -= 7;
14588 psMemRead = cpu.z80MemRead; /* Beginning of our handler */
14589 while (psMemRead->lowAddr != 0xffffffff)
14590 {
14591 if ((cpu.z80HL >= psMemRead->lowAddr) && (cpu.z80HL <= psMemRead->highAddr))
14592 {
14593 cpu.z80pc = (UINT32) pbPC - (UINT32) cpu.z80Base;
14594 if (psMemRead->memoryCall)
14595 {
14596 cpu.z80E = psMemRead->memoryCall(cpu.z80HL, psMemRead);
14597 }
14598 else
14599 {
14600 cpu.z80E = *((UINT8 *) psMemRead->pUserArea + (cpu.z80HL - psMemRead->lowAddr));
14601 }
14602 psMemRead = NULL;
14603 break;
14604 }
14605 ++psMemRead;
14606 }
14607
14608 if (psMemRead)
14609 {
14610 cpu.z80E = cpu.z80Base[cpu.z80HL];
14611 }
14612
14613 break;
14614 }
14615 case 0x5f:
14616 {
14617 sdwCyclesRemaining -= 4;
14618 cpu.z80E = cpu.z80A;
14619 break;
14620 }
14621 case 0x60:
14622 {
14623 sdwCyclesRemaining -= 4;
14624 cpu.z80H = cpu.z80B;
14625 break;
14626 }
14627 case 0x61:
14628 {
14629 sdwCyclesRemaining -= 4;
14630 cpu.z80H = cpu.z80C;
14631 break;
14632 }
14633 case 0x62:
14634 {
14635 sdwCyclesRemaining -= 4;
14636 cpu.z80H = cpu.z80D;
14637 break;
14638 }
14639 case 0x63:
14640 {
14641 sdwCyclesRemaining -= 4;
14642 cpu.z80H = cpu.z80E;
14643 break;
14644 }
14645 case 0x64:
14646 {
14647 sdwCyclesRemaining -= 4;
14648 break;
14649 }
14650 case 0x65:
14651 {
14652 sdwCyclesRemaining -= 4;
14653 cpu.z80H = cpu.z80L;
14654 break;
14655 }
14656 case 0x66:
14657 {
14658 sdwCyclesRemaining -= 7;
14659 psMemRead = cpu.z80MemRead; /* Beginning of our handler */
14660 while (psMemRead->lowAddr != 0xffffffff)
14661 {
14662 if ((cpu.z80HL >= psMemRead->lowAddr) && (cpu.z80HL <= psMemRead->highAddr))
14663 {
14664 cpu.z80pc = (UINT32) pbPC - (UINT32) cpu.z80Base;
14665 if (psMemRead->memoryCall)
14666 {
14667 cpu.z80H = psMemRead->memoryCall(cpu.z80HL, psMemRead);
14668 }
14669 else
14670 {
14671 cpu.z80H = *((UINT8 *) psMemRead->pUserArea + (cpu.z80HL - psMemRead->lowAddr));
14672 }
14673 psMemRead = NULL;
14674 break;
14675 }
14676 ++psMemRead;
14677 }
14678
14679 if (psMemRead)
14680 {
14681 cpu.z80H = cpu.z80Base[cpu.z80HL];
14682 }
14683
14684 break;
14685 }
14686 case 0x67:
14687 {
14688 sdwCyclesRemaining -= 4;
14689 cpu.z80H = cpu.z80A;
14690 break;
14691 }
14692 case 0x68:
14693 {
14694 sdwCyclesRemaining -= 4;
14695 cpu.z80L = cpu.z80B;
14696 break;
14697 }
14698 case 0x69:
14699 {
14700 sdwCyclesRemaining -= 4;
14701 cpu.z80L = cpu.z80C;
14702 break;
14703 }
14704 case 0x6a:
14705 {
14706 sdwCyclesRemaining -= 4;
14707 cpu.z80L = cpu.z80D;
14708 break;
14709 }
14710 case 0x6b:
14711 {
14712 sdwCyclesRemaining -= 4;
14713 cpu.z80L = cpu.z80E;
14714 break;
14715 }
14716 case 0x6c:
14717 {
14718 sdwCyclesRemaining -= 4;
14719 cpu.z80L = cpu.z80H;
14720 break;
14721 }
14722 case 0x6d:
14723 {
14724 sdwCyclesRemaining -= 4;
14725 break;
14726 }
14727 case 0x6e:
14728 {
14729 sdwCyclesRemaining -= 7;
14730 psMemRead = cpu.z80MemRead; /* Beginning of our handler */
14731 while (psMemRead->lowAddr != 0xffffffff)
14732 {
14733 if ((cpu.z80HL >= psMemRead->lowAddr) && (cpu.z80HL <= psMemRead->highAddr))
14734 {
14735 cpu.z80pc = (UINT32) pbPC - (UINT32) cpu.z80Base;
14736 if (psMemRead->memoryCall)
14737 {
14738 cpu.z80L = psMemRead->memoryCall(cpu.z80HL, psMemRead);
14739 }
14740 else
14741 {
14742 cpu.z80L = *((UINT8 *) psMemRead->pUserArea + (cpu.z80HL - psMemRead->lowAddr));
14743 }
14744 psMemRead = NULL;
14745 break;
14746 }
14747 ++psMemRead;
14748 }
14749
14750 if (psMemRead)
14751 {
14752 cpu.z80L = cpu.z80Base[cpu.z80HL];
14753 }
14754
14755 break;
14756 }
14757 case 0x6f:
14758 {
14759 sdwCyclesRemaining -= 4;
14760 cpu.z80L = cpu.z80A;
14761 break;
14762 }
14763 case 0x70:
14764 {
14765 sdwCyclesRemaining -= 7;
14766 psMemWrite = cpu.z80MemWrite; /* Beginning of our handler */
14767 while (psMemWrite->lowAddr != 0xffffffff)
14768 {
14769 if ((cpu.z80HL >= psMemWrite->lowAddr) && (cpu.z80HL <= psMemWrite->highAddr))
14770 {
14771 cpu.z80pc = (UINT32) pbPC - (UINT32) cpu.z80Base;
14772 if (psMemWrite->memoryCall)
14773 {
14774 psMemWrite->memoryCall(cpu.z80HL, cpu.z80B, psMemWrite);
14775 }
14776 else
14777 {
14778 *((UINT8 *) psMemWrite->pUserArea + (cpu.z80HL - psMemWrite->lowAddr)) = cpu.z80B;
14779 }
14780 psMemWrite = NULL;
14781 break;
14782 }
14783 ++psMemWrite;
14784 }
14785
14786 if (psMemWrite)
14787 {
14788 cpu.z80Base[cpu.z80HL] = (UINT8) cpu.z80B;
14789 }
14790
14791 break;
14792 }
14793 case 0x71:
14794 {
14795 sdwCyclesRemaining -= 7;
14796 psMemWrite = cpu.z80MemWrite; /* Beginning of our handler */
14797 while (psMemWrite->lowAddr != 0xffffffff)
14798 {
14799 if ((cpu.z80HL >= psMemWrite->lowAddr) && (cpu.z80HL <= psMemWrite->highAddr))
14800 {
14801 cpu.z80pc = (UINT32) pbPC - (UINT32) cpu.z80Base;
14802 if (psMemWrite->memoryCall)
14803 {
14804 psMemWrite->memoryCall(cpu.z80HL, cpu.z80C, psMemWrite);
14805 }
14806 else
14807 {
14808 *((UINT8 *) psMemWrite->pUserArea + (cpu.z80HL - psMemWrite->lowAddr)) = cpu.z80C;
14809 }
14810 psMemWrite = NULL;
14811 break;
14812 }
14813 ++psMemWrite;
14814 }
14815
14816 if (psMemWrite)
14817 {
14818 cpu.z80Base[cpu.z80HL] = (UINT8) cpu.z80C;
14819 }
14820
14821 break;
14822 }
14823 case 0x72:
14824 {
14825 sdwCyclesRemaining -= 7;
14826 psMemWrite = cpu.z80MemWrite; /* Beginning of our handler */
14827 while (psMemWrite->lowAddr != 0xffffffff)
14828 {
14829 if ((cpu.z80HL >= psMemWrite->lowAddr) && (cpu.z80HL <= psMemWrite->highAddr))
14830 {
14831 cpu.z80pc = (UINT32) pbPC - (UINT32) cpu.z80Base;
14832 if (psMemWrite->memoryCall)
14833 {
14834 psMemWrite->memoryCall(cpu.z80HL, cpu.z80D, psMemWrite);
14835 }
14836 else
14837 {
14838 *((UINT8 *) psMemWrite->pUserArea + (cpu.z80HL - psMemWrite->lowAddr)) = cpu.z80D;
14839 }
14840 psMemWrite = NULL;
14841 break;
14842 }
14843 ++psMemWrite;
14844 }
14845
14846 if (psMemWrite)
14847 {
14848 cpu.z80Base[cpu.z80HL] = (UINT8) cpu.z80D;
14849 }
14850
14851 break;
14852 }
14853 case 0x73:
14854 {
14855 sdwCyclesRemaining -= 7;
14856 psMemWrite = cpu.z80MemWrite; /* Beginning of our handler */
14857 while (psMemWrite->lowAddr != 0xffffffff)
14858 {
14859 if ((cpu.z80HL >= psMemWrite->lowAddr) && (cpu.z80HL <= psMemWrite->highAddr))
14860 {
14861 cpu.z80pc = (UINT32) pbPC - (UINT32) cpu.z80Base;
14862 if (psMemWrite->memoryCall)
14863 {
14864 psMemWrite->memoryCall(cpu.z80HL, cpu.z80E, psMemWrite);
14865 }
14866 else
14867 {
14868 *((UINT8 *) psMemWrite->pUserArea + (cpu.z80HL - psMemWrite->lowAddr)) = cpu.z80E;
14869 }
14870 psMemWrite = NULL;
14871 break;
14872 }
14873 ++psMemWrite;
14874 }
14875
14876 if (psMemWrite)
14877 {
14878 cpu.z80Base[cpu.z80HL] = (UINT8) cpu.z80E;
14879 }
14880
14881 break;
14882 }
14883 case 0x74:
14884 {
14885 sdwCyclesRemaining -= 7;
14886 psMemWrite = cpu.z80MemWrite; /* Beginning of our handler */
14887 while (psMemWrite->lowAddr != 0xffffffff)
14888 {
14889 if ((cpu.z80HL >= psMemWrite->lowAddr) && (cpu.z80HL <= psMemWrite->highAddr))
14890 {
14891 cpu.z80pc = (UINT32) pbPC - (UINT32) cpu.z80Base;
14892 if (psMemWrite->memoryCall)
14893 {
14894 psMemWrite->memoryCall(cpu.z80HL, cpu.z80H, psMemWrite);
14895 }
14896 else
14897 {
14898 *((UINT8 *) psMemWrite->pUserArea + (cpu.z80HL - psMemWrite->lowAddr)) = cpu.z80H;
14899 }
14900 psMemWrite = NULL;
14901 break;
14902 }
14903 ++psMemWrite;
14904 }
14905
14906 if (psMemWrite)
14907 {
14908 cpu.z80Base[cpu.z80HL] = (UINT8) cpu.z80H;
14909 }
14910
14911 break;
14912 }
14913 case 0x75:
14914 {
14915 sdwCyclesRemaining -= 7;
14916 psMemWrite = cpu.z80MemWrite; /* Beginning of our handler */
14917 while (psMemWrite->lowAddr != 0xffffffff)
14918 {
14919 if ((cpu.z80HL >= psMemWrite->lowAddr) && (cpu.z80HL <= psMemWrite->highAddr))
14920 {
14921 cpu.z80pc = (UINT32) pbPC - (UINT32) cpu.z80Base;
14922 if (psMemWrite->memoryCall)
14923 {
14924 psMemWrite->memoryCall(cpu.z80HL, cpu.z80L, psMemWrite);
14925 }
14926 else
14927 {
14928 *((UINT8 *) psMemWrite->pUserArea + (cpu.z80HL - psMemWrite->lowAddr)) = cpu.z80L;
14929 }
14930 psMemWrite = NULL;
14931 break;
14932 }
14933 ++psMemWrite;
14934 }
14935
14936 if (psMemWrite)
14937 {
14938 cpu.z80Base[cpu.z80HL] = (UINT8) cpu.z80L;
14939 }
14940
14941 break;
14942 }
14943 case 0x76:
14944 {
14945 sdwCyclesRemaining -= 4;
14946 cpu.z80halted = 1;
14947 dwElapsedTicks += sdwCyclesRemaining;
14948 sdwCyclesRemaining = 0;
14949 break;
14950 }
14951 case 0x77:
14952 {
14953 sdwCyclesRemaining -= 7;
14954 psMemWrite = cpu.z80MemWrite; /* Beginning of our handler */
14955 while (psMemWrite->lowAddr != 0xffffffff)
14956 {
14957 if ((cpu.z80HL >= psMemWrite->lowAddr) && (cpu.z80HL <= psMemWrite->highAddr))
14958 {
14959 cpu.z80pc = (UINT32) pbPC - (UINT32) cpu.z80Base;
14960 if (psMemWrite->memoryCall)
14961 {
14962 psMemWrite->memoryCall(cpu.z80HL, cpu.z80A, psMemWrite);
14963 }
14964 else
14965 {
14966 *((UINT8 *) psMemWrite->pUserArea + (cpu.z80HL - psMemWrite->lowAddr)) = cpu.z80A;
14967 }
14968 psMemWrite = NULL;
14969 break;
14970 }
14971 ++psMemWrite;
14972 }
14973
14974 if (psMemWrite)
14975 {
14976 cpu.z80Base[cpu.z80HL] = (UINT8) cpu.z80A;
14977 }
14978
14979 break;
14980 }
14981 case 0x78:
14982 {
14983 sdwCyclesRemaining -= 4;
14984 cpu.z80A = cpu.z80B;
14985 break;
14986 }
14987 case 0x79:
14988 {
14989 sdwCyclesRemaining -= 4;
14990 cpu.z80A = cpu.z80C;
14991 break;
14992 }
14993 case 0x7a:
14994 {
14995 sdwCyclesRemaining -= 4;
14996 cpu.z80A = cpu.z80D;
14997 break;
14998 }
14999 case 0x7b:
15000 {
15001 sdwCyclesRemaining -= 4;
15002 cpu.z80A = cpu.z80E;
15003 break;
15004 }
15005 case 0x7c:
15006 {
15007 sdwCyclesRemaining -= 4;
15008 cpu.z80A = cpu.z80H;
15009 break;
15010 }
15011 case 0x7d:
15012 {
15013 sdwCyclesRemaining -= 4;
15014 cpu.z80A = cpu.z80L;
15015 break;
15016 }
15017 case 0x7e:
15018 {
15019 sdwCyclesRemaining -= 7;
15020 psMemRead = cpu.z80MemRead; /* Beginning of our handler */
15021 while (psMemRead->lowAddr != 0xffffffff)
15022 {
15023 if ((cpu.z80HL >= psMemRead->lowAddr) && (cpu.z80HL <= psMemRead->highAddr))
15024 {
15025 cpu.z80pc = (UINT32) pbPC - (UINT32) cpu.z80Base;
15026 if (psMemRead->memoryCall)
15027 {
15028 cpu.z80A = psMemRead->memoryCall(cpu.z80HL, psMemRead);
15029 }
15030 else
15031 {
15032 cpu.z80A = *((UINT8 *) psMemRead->pUserArea + (cpu.z80HL - psMemRead->lowAddr));
15033 }
15034 psMemRead = NULL;
15035 break;
15036 }
15037 ++psMemRead;
15038 }
15039
15040 if (psMemRead)
15041 {
15042 cpu.z80A = cpu.z80Base[cpu.z80HL];
15043 }
15044
15045 break;
15046 }
15047 case 0x7f:
15048 {
15049 sdwCyclesRemaining -= 4;
15050 break;
15051 }
15052 case 0x80:
15053 {
15054 sdwCyclesRemaining -= 4;
15055 bTemp2 = cpu.z80A + cpu.z80B;
15056 cpu.z80F = (cpu.z80F & ~(Z80_FLAG_CARRY | Z80_FLAG_NEGATIVE | Z80_FLAG_OVERFLOW_PARITY |
15057 Z80_FLAG_HALF_CARRY | Z80_FLAG_ZERO | Z80_FLAG_SIGN)) |
15058 pbAddAdcTable[((UINT32) cpu.z80A << 8) | cpu.z80B];
15059 cpu.z80A = bTemp2;
15060 break;
15061 }
15062 case 0x81:
15063 {
15064 sdwCyclesRemaining -= 4;
15065 bTemp2 = cpu.z80A + cpu.z80C;
15066 cpu.z80F = (cpu.z80F & ~(Z80_FLAG_CARRY | Z80_FLAG_NEGATIVE | Z80_FLAG_OVERFLOW_PARITY |
15067 Z80_FLAG_HALF_CARRY | Z80_FLAG_ZERO | Z80_FLAG_SIGN)) |
15068 pbAddAdcTable[((UINT32) cpu.z80A << 8) | cpu.z80C];
15069 cpu.z80A = bTemp2;
15070 break;
15071 }
15072 case 0x82:
15073 {
15074 sdwCyclesRemaining -= 4;
15075 bTemp2 = cpu.z80A + cpu.z80D;
15076 cpu.z80F = (cpu.z80F & ~(Z80_FLAG_CARRY | Z80_FLAG_NEGATIVE | Z80_FLAG_OVERFLOW_PARITY |
15077 Z80_FLAG_HALF_CARRY | Z80_FLAG_ZERO | Z80_FLAG_SIGN)) |
15078 pbAddAdcTable[((UINT32) cpu.z80A << 8) | cpu.z80D];
15079 cpu.z80A = bTemp2;
15080 break;
15081 }
15082 case 0x83:
15083 {
15084 sdwCyclesRemaining -= 4;
15085 bTemp2 = cpu.z80A + cpu.z80E;
15086 cpu.z80F = (cpu.z80F & ~(Z80_FLAG_CARRY | Z80_FLAG_NEGATIVE | Z80_FLAG_OVERFLOW_PARITY |
15087 Z80_FLAG_HALF_CARRY | Z80_FLAG_ZERO | Z80_FLAG_SIGN)) |
15088 pbAddAdcTable[((UINT32) cpu.z80A << 8) | cpu.z80E];
15089 cpu.z80A = bTemp2;
15090 break;
15091 }
15092 case 0x84:
15093 {
15094 sdwCyclesRemaining -= 4;
15095 bTemp2 = cpu.z80A + cpu.z80H;
15096 cpu.z80F = (cpu.z80F & ~(Z80_FLAG_CARRY | Z80_FLAG_NEGATIVE | Z80_FLAG_OVERFLOW_PARITY |
15097 Z80_FLAG_HALF_CARRY | Z80_FLAG_ZERO | Z80_FLAG_SIGN)) |
15098 pbAddAdcTable[((UINT32) cpu.z80A << 8) | cpu.z80H];
15099 cpu.z80A = bTemp2;
15100 break;
15101 }
15102 case 0x85:
15103 {
15104 sdwCyclesRemaining -= 4;
15105 bTemp2 = cpu.z80A + cpu.z80L;
15106 cpu.z80F = (cpu.z80F & ~(Z80_FLAG_CARRY | Z80_FLAG_NEGATIVE | Z80_FLAG_OVERFLOW_PARITY |
15107 Z80_FLAG_HALF_CARRY | Z80_FLAG_ZERO | Z80_FLAG_SIGN)) |
15108 pbAddAdcTable[((UINT32) cpu.z80A << 8) | cpu.z80L];
15109 cpu.z80A = bTemp2;
15110 break;
15111 }
15112 case 0x86:
15113 {
15114 sdwCyclesRemaining -= 7;
15115 psMemRead = cpu.z80MemRead; /* Beginning of our handler */
15116 while (psMemRead->lowAddr != 0xffffffff)
15117 {
15118 if ((cpu.z80HL >= psMemRead->lowAddr) && (cpu.z80HL <= psMemRead->highAddr))
15119 {
15120 cpu.z80pc = (UINT32) pbPC - (UINT32) cpu.z80Base;
15121 if (psMemRead->memoryCall)
15122 {
15123 bTemp = psMemRead->memoryCall(cpu.z80HL, psMemRead);
15124 }
15125 else
15126 {
15127 bTemp = *((UINT8 *) psMemRead->pUserArea + (cpu.z80HL - psMemRead->lowAddr));
15128 }
15129 psMemRead = NULL;
15130 break;
15131 }
15132 ++psMemRead;
15133 }
15134
15135 if (psMemRead)
15136 {
15137 bTemp = cpu.z80Base[cpu.z80HL];
15138 }
15139
15140 bTemp2 = cpu.z80A + bTemp;
15141 cpu.z80F = (cpu.z80F & ~(Z80_FLAG_CARRY | Z80_FLAG_NEGATIVE | Z80_FLAG_OVERFLOW_PARITY |
15142 Z80_FLAG_HALF_CARRY | Z80_FLAG_ZERO | Z80_FLAG_SIGN)) |
15143 pbAddAdcTable[((UINT32) cpu.z80A << 8) | bTemp];
15144 cpu.z80A = bTemp2;
15145 break;
15146 }
15147 case 0x87:
15148 {
15149 sdwCyclesRemaining -= 4;
15150 bTemp2 = cpu.z80A + cpu.z80A;
15151 cpu.z80F = (cpu.z80F & ~(Z80_FLAG_CARRY | Z80_FLAG_NEGATIVE | Z80_FLAG_OVERFLOW_PARITY |
15152 Z80_FLAG_HALF_CARRY | Z80_FLAG_ZERO | Z80_FLAG_SIGN)) |
15153 pbAddAdcTable[((UINT32) cpu.z80A << 8) | cpu.z80A];
15154 cpu.z80A = bTemp2;
15155 break;
15156 }
15157 case 0x88:
15158 {
15159 sdwCyclesRemaining -= 4;
15160 bTemp2 = cpu.z80A + cpu.z80B + (cpu.z80F & Z80_FLAG_CARRY);
15161 cpu.z80F = (cpu.z80F & ~(Z80_FLAG_CARRY | Z80_FLAG_NEGATIVE | Z80_FLAG_OVERFLOW_PARITY |
15162 Z80_FLAG_HALF_CARRY | Z80_FLAG_ZERO | Z80_FLAG_SIGN)) |
15163 pbAddAdcTable[((UINT32) cpu.z80A << 8) | cpu.z80B | (((UINT32) cpu.z80F & Z80_FLAG_CARRY) << 16)];
15164 cpu.z80A = bTemp2;
15165 break;
15166 }
15167 case 0x89:
15168 {
15169 sdwCyclesRemaining -= 4;
15170 bTemp2 = cpu.z80A + cpu.z80C + (cpu.z80F & Z80_FLAG_CARRY);
15171 cpu.z80F = (cpu.z80F & ~(Z80_FLAG_CARRY | Z80_FLAG_NEGATIVE | Z80_FLAG_OVERFLOW_PARITY |
15172 Z80_FLAG_HALF_CARRY | Z80_FLAG_ZERO | Z80_FLAG_SIGN)) |
15173 pbAddAdcTable[((UINT32) cpu.z80A << 8) | cpu.z80C | (((UINT32) cpu.z80F & Z80_FLAG_CARRY) << 16)];
15174 cpu.z80A = bTemp2;
15175 break;
15176 }
15177 case 0x8a:
15178 {
15179 sdwCyclesRemaining -= 4;
15180 bTemp2 = cpu.z80A + cpu.z80D + (cpu.z80F & Z80_FLAG_CARRY);
15181 cpu.z80F = (cpu.z80F & ~(Z80_FLAG_CARRY | Z80_FLAG_NEGATIVE | Z80_FLAG_OVERFLOW_PARITY |
15182 Z80_FLAG_HALF_CARRY | Z80_FLAG_ZERO | Z80_FLAG_SIGN)) |
15183 pbAddAdcTable[((UINT32) cpu.z80A << 8) | cpu.z80D | (((UINT32) cpu.z80F & Z80_FLAG_CARRY) << 16)];
15184 cpu.z80A = bTemp2;
15185 break;
15186 }
15187 case 0x8b:
15188 {
15189 sdwCyclesRemaining -= 4;
15190 bTemp2 = cpu.z80A + cpu.z80E + (cpu.z80F & Z80_FLAG_CARRY);
15191 cpu.z80F = (cpu.z80F & ~(Z80_FLAG_CARRY | Z80_FLAG_NEGATIVE | Z80_FLAG_OVERFLOW_PARITY |
15192 Z80_FLAG_HALF_CARRY | Z80_FLAG_ZERO | Z80_FLAG_SIGN)) |
15193 pbAddAdcTable[((UINT32) cpu.z80A << 8) | cpu.z80E | (((UINT32) cpu.z80F & Z80_FLAG_CARRY) << 16)];
15194 cpu.z80A = bTemp2;
15195 break;
15196 }
15197 case 0x8c:
15198 {
15199 sdwCyclesRemaining -= 4;
15200 bTemp2 = cpu.z80A + cpu.z80H + (cpu.z80F & Z80_FLAG_CARRY);
15201 cpu.z80F = (cpu.z80F & ~(Z80_FLAG_CARRY | Z80_FLAG_NEGATIVE | Z80_FLAG_OVERFLOW_PARITY |
15202 Z80_FLAG_HALF_CARRY | Z80_FLAG_ZERO | Z80_FLAG_SIGN)) |
15203 pbAddAdcTable[((UINT32) cpu.z80A << 8) | cpu.z80H | (((UINT32) cpu.z80F & Z80_FLAG_CARRY) << 16)];
15204 cpu.z80A = bTemp2;
15205 break;
15206 }
15207 case 0x8d:
15208 {
15209 sdwCyclesRemaining -= 4;
15210 bTemp2 = cpu.z80A + cpu.z80L + (cpu.z80F & Z80_FLAG_CARRY);
15211 cpu.z80F = (cpu.z80F & ~(Z80_FLAG_CARRY | Z80_FLAG_NEGATIVE | Z80_FLAG_OVERFLOW_PARITY |
15212 Z80_FLAG_HALF_CARRY | Z80_FLAG_ZERO | Z80_FLAG_SIGN)) |
15213 pbAddAdcTable[((UINT32) cpu.z80A << 8) | cpu.z80L | (((UINT32) cpu.z80F & Z80_FLAG_CARRY) << 16)];
15214 cpu.z80A = bTemp2;
15215 break;
15216 }
15217 case 0x8e:
15218 {
15219 sdwCyclesRemaining -= 7;
15220 psMemRead = cpu.z80MemRead; /* Beginning of our handler */
15221 while (psMemRead->lowAddr != 0xffffffff)
15222 {
15223 if ((cpu.z80HL >= psMemRead->lowAddr) && (cpu.z80HL <= psMemRead->highAddr))
15224 {
15225 cpu.z80pc = (UINT32) pbPC - (UINT32) cpu.z80Base;
15226 if (psMemRead->memoryCall)
15227 {
15228 bTemp = psMemRead->memoryCall(cpu.z80HL, psMemRead);
15229 }
15230 else
15231 {
15232 bTemp = *((UINT8 *) psMemRead->pUserArea + (cpu.z80HL - psMemRead->lowAddr));
15233 }
15234 psMemRead = NULL;
15235 break;
15236 }
15237 ++psMemRead;
15238 }
15239
15240 if (psMemRead)
15241 {
15242 bTemp = cpu.z80Base[cpu.z80HL];
15243 }
15244
15245 bTemp2 = cpu.z80A + bTemp + (cpu.z80F & Z80_FLAG_CARRY);
15246 cpu.z80F = (cpu.z80F & ~(Z80_FLAG_CARRY | Z80_FLAG_NEGATIVE | Z80_FLAG_OVERFLOW_PARITY |
15247 Z80_FLAG_HALF_CARRY | Z80_FLAG_ZERO | Z80_FLAG_SIGN)) |
15248 pbAddAdcTable[((UINT32) cpu.z80A << 8) | bTemp | (((UINT32) cpu.z80F & Z80_FLAG_CARRY) << 16)];
15249 cpu.z80A = bTemp2;
15250 break;
15251 }
15252 case 0x8f:
15253 {
15254 sdwCyclesRemaining -= 4;
15255 bTemp2 = cpu.z80A + cpu.z80A + (cpu.z80F & Z80_FLAG_CARRY);
15256 cpu.z80F = (cpu.z80F & ~(Z80_FLAG_CARRY | Z80_FLAG_NEGATIVE | Z80_FLAG_OVERFLOW_PARITY |
15257 Z80_FLAG_HALF_CARRY | Z80_FLAG_ZERO | Z80_FLAG_SIGN)) |
15258 pbAddAdcTable[((UINT32) cpu.z80A << 8) | cpu.z80A | (((UINT32) cpu.z80F & Z80_FLAG_CARRY) << 16)];
15259 cpu.z80A = bTemp2;
15260 break;
15261 }
15262 case 0x90:
15263 {
15264 sdwCyclesRemaining -= 4;
15265 bTemp2 = cpu.z80A - cpu.z80B;
15266 cpu.z80F = (cpu.z80F & ~(Z80_FLAG_CARRY | Z80_FLAG_NEGATIVE | Z80_FLAG_OVERFLOW_PARITY |
15267 Z80_FLAG_HALF_CARRY | Z80_FLAG_ZERO | Z80_FLAG_SIGN)) |
15268 pbSubSbcTable[((UINT32) cpu.z80A << 8) | cpu.z80B];
15269 cpu.z80A = bTemp2;
15270 break;
15271 }
15272 case 0x91:
15273 {
15274 sdwCyclesRemaining -= 4;
15275 bTemp2 = cpu.z80A - cpu.z80C;
15276 cpu.z80F = (cpu.z80F & ~(Z80_FLAG_CARRY | Z80_FLAG_NEGATIVE | Z80_FLAG_OVERFLOW_PARITY |
15277 Z80_FLAG_HALF_CARRY | Z80_FLAG_ZERO | Z80_FLAG_SIGN)) |
15278 pbSubSbcTable[((UINT32) cpu.z80A << 8) | cpu.z80C];
15279 cpu.z80A = bTemp2;
15280 break;
15281 }
15282 case 0x92:
15283 {
15284 sdwCyclesRemaining -= 4;
15285 bTemp2 = cpu.z80A - cpu.z80D;
15286 cpu.z80F = (cpu.z80F & ~(Z80_FLAG_CARRY | Z80_FLAG_NEGATIVE | Z80_FLAG_OVERFLOW_PARITY |
15287 Z80_FLAG_HALF_CARRY | Z80_FLAG_ZERO | Z80_FLAG_SIGN)) |
15288 pbSubSbcTable[((UINT32) cpu.z80A << 8) | cpu.z80D];
15289 cpu.z80A = bTemp2;
15290 break;
15291 }
15292 case 0x93:
15293 {
15294 sdwCyclesRemaining -= 4;
15295 bTemp2 = cpu.z80A - cpu.z80E;
15296 cpu.z80F = (cpu.z80F & ~(Z80_FLAG_CARRY | Z80_FLAG_NEGATIVE | Z80_FLAG_OVERFLOW_PARITY |
15297 Z80_FLAG_HALF_CARRY | Z80_FLAG_ZERO | Z80_FLAG_SIGN)) |
15298 pbSubSbcTable[((UINT32) cpu.z80A << 8) | cpu.z80E];
15299 cpu.z80A = bTemp2;
15300 break;
15301 }
15302 case 0x94:
15303 {
15304 sdwCyclesRemaining -= 4;
15305 bTemp2 = cpu.z80A - cpu.z80H;
15306 cpu.z80F = (cpu.z80F & ~(Z80_FLAG_CARRY | Z80_FLAG_NEGATIVE | Z80_FLAG_OVERFLOW_PARITY |
15307 Z80_FLAG_HALF_CARRY | Z80_FLAG_ZERO | Z80_FLAG_SIGN)) |
15308 pbSubSbcTable[((UINT32) cpu.z80A << 8) | cpu.z80H];
15309 cpu.z80A = bTemp2;
15310 break;
15311 }
15312 case 0x95:
15313 {
15314 sdwCyclesRemaining -= 4;
15315 bTemp2 = cpu.z80A - cpu.z80L;
15316 cpu.z80F = (cpu.z80F & ~(Z80_FLAG_CARRY | Z80_FLAG_NEGATIVE | Z80_FLAG_OVERFLOW_PARITY |
15317 Z80_FLAG_HALF_CARRY | Z80_FLAG_ZERO | Z80_FLAG_SIGN)) |
15318 pbSubSbcTable[((UINT32) cpu.z80A << 8) | cpu.z80L];
15319 cpu.z80A = bTemp2;
15320 break;
15321 }
15322 case 0x96:
15323 {
15324 sdwCyclesRemaining -= 7;
15325 psMemRead = cpu.z80MemRead; /* Beginning of our handler */
15326 while (psMemRead->lowAddr != 0xffffffff)
15327 {
15328 if ((cpu.z80HL >= psMemRead->lowAddr) && (cpu.z80HL <= psMemRead->highAddr))
15329 {
15330 cpu.z80pc = (UINT32) pbPC - (UINT32) cpu.z80Base;
15331 if (psMemRead->memoryCall)
15332 {
15333 bTemp = psMemRead->memoryCall(cpu.z80HL, psMemRead);
15334 }
15335 else
15336 {
15337 bTemp = *((UINT8 *) psMemRead->pUserArea + (cpu.z80HL - psMemRead->lowAddr));
15338 }
15339 psMemRead = NULL;
15340 break;
15341 }
15342 ++psMemRead;
15343 }
15344
15345 if (psMemRead)
15346 {
15347 bTemp = cpu.z80Base[cpu.z80HL];
15348 }
15349
15350 bTemp2 = cpu.z80A - bTemp;
15351 cpu.z80F = (cpu.z80F & ~(Z80_FLAG_CARRY | Z80_FLAG_NEGATIVE | Z80_FLAG_OVERFLOW_PARITY |
15352 Z80_FLAG_HALF_CARRY | Z80_FLAG_ZERO | Z80_FLAG_SIGN)) |
15353 pbSubSbcTable[((UINT32) cpu.z80A << 8) | bTemp];
15354 cpu.z80A = bTemp2;
15355 break;
15356 }
15357 case 0x97:
15358 {
15359 sdwCyclesRemaining -= 4;
15360 bTemp2 = cpu.z80A - cpu.z80A;
15361 cpu.z80F = (cpu.z80F & ~(Z80_FLAG_CARRY | Z80_FLAG_NEGATIVE | Z80_FLAG_OVERFLOW_PARITY |
15362 Z80_FLAG_HALF_CARRY | Z80_FLAG_ZERO | Z80_FLAG_SIGN)) |
15363 pbSubSbcTable[((UINT32) cpu.z80A << 8) | cpu.z80A];
15364 cpu.z80A = bTemp2;
15365 break;
15366 }
15367 case 0x98:
15368 {
15369 sdwCyclesRemaining -= 4;
15370 bTemp2 = cpu.z80A - cpu.z80B - (cpu.z80F & Z80_FLAG_CARRY);
15371 cpu.z80F = (cpu.z80F & ~(Z80_FLAG_CARRY | Z80_FLAG_NEGATIVE | Z80_FLAG_OVERFLOW_PARITY |
15372 Z80_FLAG_HALF_CARRY | Z80_FLAG_ZERO | Z80_FLAG_SIGN)) |
15373 pbSubSbcTable[((UINT32) cpu.z80A << 8) | cpu.z80B | (((UINT32) cpu.z80F & Z80_FLAG_CARRY) << 16)];
15374 cpu.z80A = bTemp2;
15375 break;
15376 }
15377 case 0x99:
15378 {
15379 sdwCyclesRemaining -= 4;
15380 bTemp2 = cpu.z80A - cpu.z80C - (cpu.z80F & Z80_FLAG_CARRY);
15381 cpu.z80F = (cpu.z80F & ~(Z80_FLAG_CARRY | Z80_FLAG_NEGATIVE | Z80_FLAG_OVERFLOW_PARITY |
15382 Z80_FLAG_HALF_CARRY | Z80_FLAG_ZERO | Z80_FLAG_SIGN)) |
15383 pbSubSbcTable[((UINT32) cpu.z80A << 8) | cpu.z80C | (((UINT32) cpu.z80F & Z80_FLAG_CARRY) << 16)];
15384 cpu.z80A = bTemp2;
15385 break;
15386 }
15387 case 0x9a:
15388 {
15389 sdwCyclesRemaining -= 4;
15390 bTemp2 = cpu.z80A - cpu.z80D - (cpu.z80F & Z80_FLAG_CARRY);
15391 cpu.z80F = (cpu.z80F & ~(Z80_FLAG_CARRY | Z80_FLAG_NEGATIVE | Z80_FLAG_OVERFLOW_PARITY |
15392 Z80_FLAG_HALF_CARRY | Z80_FLAG_ZERO | Z80_FLAG_SIGN)) |
15393 pbSubSbcTable[((UINT32) cpu.z80A << 8) | cpu.z80D | (((UINT32) cpu.z80F & Z80_FLAG_CARRY) << 16)];
15394 cpu.z80A = bTemp2;
15395 break;
15396 }
15397 case 0x9b:
15398 {
15399 sdwCyclesRemaining -= 4;
15400 bTemp2 = cpu.z80A - cpu.z80E - (cpu.z80F & Z80_FLAG_CARRY);
15401 cpu.z80F = (cpu.z80F & ~(Z80_FLAG_CARRY | Z80_FLAG_NEGATIVE | Z80_FLAG_OVERFLOW_PARITY |
15402 Z80_FLAG_HALF_CARRY | Z80_FLAG_ZERO | Z80_FLAG_SIGN)) |
15403 pbSubSbcTable[((UINT32) cpu.z80A << 8) | cpu.z80E | (((UINT32) cpu.z80F & Z80_FLAG_CARRY) << 16)];
15404 cpu.z80A = bTemp2;
15405 break;
15406 }
15407 case 0x9c:
15408 {
15409 sdwCyclesRemaining -= 4;
15410 bTemp2 = cpu.z80A - cpu.z80H - (cpu.z80F & Z80_FLAG_CARRY);
15411 cpu.z80F = (cpu.z80F & ~(Z80_FLAG_CARRY | Z80_FLAG_NEGATIVE | Z80_FLAG_OVERFLOW_PARITY |
15412 Z80_FLAG_HALF_CARRY | Z80_FLAG_ZERO | Z80_FLAG_SIGN)) |
15413 pbSubSbcTable[((UINT32) cpu.z80A << 8) | cpu.z80H | (((UINT32) cpu.z80F & Z80_FLAG_CARRY) << 16)];
15414 cpu.z80A = bTemp2;
15415 break;
15416 }
15417 case 0x9d:
15418 {
15419 sdwCyclesRemaining -= 4;
15420 bTemp2 = cpu.z80A - cpu.z80L - (cpu.z80F & Z80_FLAG_CARRY);
15421 cpu.z80F = (cpu.z80F & ~(Z80_FLAG_CARRY | Z80_FLAG_NEGATIVE | Z80_FLAG_OVERFLOW_PARITY |
15422 Z80_FLAG_HALF_CARRY | Z80_FLAG_ZERO | Z80_FLAG_SIGN)) |
15423 pbSubSbcTable[((UINT32) cpu.z80A << 8) | cpu.z80L | (((UINT32) cpu.z80F & Z80_FLAG_CARRY) << 16)];
15424 cpu.z80A = bTemp2;
15425 break;
15426 }
15427 case 0x9e:
15428 {
15429 sdwCyclesRemaining -= 7;
15430 psMemRead = cpu.z80MemRead; /* Beginning of our handler */
15431 while (psMemRead->lowAddr != 0xffffffff)
15432 {
15433 if ((cpu.z80HL >= psMemRead->lowAddr) && (cpu.z80HL <= psMemRead->highAddr))
15434 {
15435 cpu.z80pc = (UINT32) pbPC - (UINT32) cpu.z80Base;
15436 if (psMemRead->memoryCall)
15437 {
15438 bTemp = psMemRead->memoryCall(cpu.z80HL, psMemRead);
15439 }
15440 else
15441 {
15442 bTemp = *((UINT8 *) psMemRead->pUserArea + (cpu.z80HL - psMemRead->lowAddr));
15443 }
15444 psMemRead = NULL;
15445 break;
15446 }
15447 ++psMemRead;
15448 }
15449
15450 if (psMemRead)
15451 {
15452 bTemp = cpu.z80Base[cpu.z80HL];
15453 }
15454
15455 bTemp2 = cpu.z80A - bTemp - (cpu.z80F & Z80_FLAG_CARRY);
15456 cpu.z80F = (cpu.z80F & ~(Z80_FLAG_CARRY | Z80_FLAG_NEGATIVE | Z80_FLAG_OVERFLOW_PARITY |
15457 Z80_FLAG_HALF_CARRY | Z80_FLAG_ZERO | Z80_FLAG_SIGN)) |
15458 pbSubSbcTable[((UINT32) cpu.z80A << 8) | bTemp | (((UINT32) cpu.z80F & Z80_FLAG_CARRY) << 16)];
15459 cpu.z80A = bTemp2;
15460 break;
15461 }
15462 case 0x9f:
15463 {
15464 sdwCyclesRemaining -= 4;
15465 bTemp2 = cpu.z80A - cpu.z80A - (cpu.z80F & Z80_FLAG_CARRY);
15466 cpu.z80F = (cpu.z80F & ~(Z80_FLAG_CARRY | Z80_FLAG_NEGATIVE | Z80_FLAG_OVERFLOW_PARITY |
15467 Z80_FLAG_HALF_CARRY | Z80_FLAG_ZERO | Z80_FLAG_SIGN)) |
15468 pbSubSbcTable[((UINT32) cpu.z80A << 8) | cpu.z80A | (((UINT32) cpu.z80F & Z80_FLAG_CARRY) << 16)];
15469 cpu.z80A = bTemp2;
15470 break;
15471 }
15472 case 0xa0:
15473 {
15474 sdwCyclesRemaining -= 4;
15475 cpu.z80A &= cpu.z80B;
15476 cpu.z80F &= ~(Z80_FLAG_CARRY | Z80_FLAG_NEGATIVE | Z80_FLAG_OVERFLOW_PARITY | Z80_FLAG_HALF_CARRY | Z80_FLAG_ZERO | Z80_FLAG_SIGN);
15477 cpu.z80F |= bPostANDFlags[cpu.z80A];
15478
15479 break;
15480 }
15481 case 0xa1:
15482 {
15483 sdwCyclesRemaining -= 4;
15484 cpu.z80A &= cpu.z80C;
15485 cpu.z80F &= ~(Z80_FLAG_CARRY | Z80_FLAG_NEGATIVE | Z80_FLAG_OVERFLOW_PARITY | Z80_FLAG_HALF_CARRY | Z80_FLAG_ZERO | Z80_FLAG_SIGN);
15486 cpu.z80F |= bPostANDFlags[cpu.z80A];
15487
15488 break;
15489 }
15490 case 0xa2:
15491 {
15492 sdwCyclesRemaining -= 4;
15493 cpu.z80A &= cpu.z80D;
15494 cpu.z80F &= ~(Z80_FLAG_CARRY | Z80_FLAG_NEGATIVE | Z80_FLAG_OVERFLOW_PARITY | Z80_FLAG_HALF_CARRY | Z80_FLAG_ZERO | Z80_FLAG_SIGN);
15495 cpu.z80F |= bPostANDFlags[cpu.z80A];
15496
15497 break;
15498 }
15499 case 0xa3:
15500 {
15501 sdwCyclesRemaining -= 4;
15502 cpu.z80A &= cpu.z80E;
15503 cpu.z80F &= ~(Z80_FLAG_CARRY | Z80_FLAG_NEGATIVE | Z80_FLAG_OVERFLOW_PARITY | Z80_FLAG_HALF_CARRY | Z80_FLAG_ZERO | Z80_FLAG_SIGN);
15504 cpu.z80F |= bPostANDFlags[cpu.z80A];
15505
15506 break;
15507 }
15508 case 0xa4:
15509 {
15510 sdwCyclesRemaining -= 4;
15511 cpu.z80A &= cpu.z80H;
15512 cpu.z80F &= ~(Z80_FLAG_CARRY | Z80_FLAG_NEGATIVE | Z80_FLAG_OVERFLOW_PARITY | Z80_FLAG_HALF_CARRY | Z80_FLAG_ZERO | Z80_FLAG_SIGN);
15513 cpu.z80F |= bPostANDFlags[cpu.z80A];
15514
15515 break;
15516 }
15517 case 0xa5:
15518 {
15519 sdwCyclesRemaining -= 4;
15520 cpu.z80A &= cpu.z80L;
15521 cpu.z80F &= ~(Z80_FLAG_CARRY | Z80_FLAG_NEGATIVE | Z80_FLAG_OVERFLOW_PARITY | Z80_FLAG_HALF_CARRY | Z80_FLAG_ZERO | Z80_FLAG_SIGN);
15522 cpu.z80F |= bPostANDFlags[cpu.z80A];
15523
15524 break;
15525 }
15526 case 0xa6:
15527 {
15528 sdwCyclesRemaining -= 7;
15529 psMemRead = cpu.z80MemRead; /* Beginning of our handler */
15530 while (psMemRead->lowAddr != 0xffffffff)
15531 {
15532 if ((cpu.z80HL >= psMemRead->lowAddr) && (cpu.z80HL <= psMemRead->highAddr))
15533 {
15534 cpu.z80pc = (UINT32) pbPC - (UINT32) cpu.z80Base;
15535 if (psMemRead->memoryCall)
15536 {
15537 bTemp = psMemRead->memoryCall(cpu.z80HL, psMemRead);
15538 }
15539 else
15540 {
15541 bTemp = *((UINT8 *) psMemRead->pUserArea + (cpu.z80HL - psMemRead->lowAddr));
15542 }
15543 psMemRead = NULL;
15544 break;
15545 }
15546 ++psMemRead;
15547 }
15548
15549 if (psMemRead)
15550 {
15551 bTemp = cpu.z80Base[cpu.z80HL];
15552 }
15553
15554 cpu.z80A &= bTemp;
15555 cpu.z80F &= ~(Z80_FLAG_CARRY | Z80_FLAG_NEGATIVE | Z80_FLAG_OVERFLOW_PARITY | Z80_FLAG_HALF_CARRY | Z80_FLAG_ZERO | Z80_FLAG_SIGN);
15556 cpu.z80F |= bPostANDFlags[cpu.z80A];
15557
15558 break;
15559 }
15560 case 0xa7:
15561 {
15562 sdwCyclesRemaining -= 4;
15563 cpu.z80A &= cpu.z80A;
15564 cpu.z80F &= ~(Z80_FLAG_CARRY | Z80_FLAG_NEGATIVE | Z80_FLAG_OVERFLOW_PARITY | Z80_FLAG_HALF_CARRY | Z80_FLAG_ZERO | Z80_FLAG_SIGN);
15565 cpu.z80F |= bPostANDFlags[cpu.z80A];
15566
15567 break;
15568 }
15569 case 0xa8:
15570 {
15571 sdwCyclesRemaining -= 4;
15572 cpu.z80A ^= cpu.z80B;
15573 cpu.z80F &= ~(Z80_FLAG_CARRY | Z80_FLAG_NEGATIVE | Z80_FLAG_OVERFLOW_PARITY | Z80_FLAG_HALF_CARRY | Z80_FLAG_ZERO | Z80_FLAG_SIGN);
15574 cpu.z80F |= bPostORFlags[cpu.z80A];
15575
15576 break;
15577 }
15578 case 0xa9:
15579 {
15580 sdwCyclesRemaining -= 4;
15581 cpu.z80A ^= cpu.z80C;
15582 cpu.z80F &= ~(Z80_FLAG_CARRY | Z80_FLAG_NEGATIVE | Z80_FLAG_OVERFLOW_PARITY | Z80_FLAG_HALF_CARRY | Z80_FLAG_ZERO | Z80_FLAG_SIGN);
15583 cpu.z80F |= bPostORFlags[cpu.z80A];
15584
15585 break;
15586 }
15587 case 0xaa:
15588 {
15589 sdwCyclesRemaining -= 4;
15590 cpu.z80A ^= cpu.z80D;
15591 cpu.z80F &= ~(Z80_FLAG_CARRY | Z80_FLAG_NEGATIVE | Z80_FLAG_OVERFLOW_PARITY | Z80_FLAG_HALF_CARRY | Z80_FLAG_ZERO | Z80_FLAG_SIGN);
15592 cpu.z80F |= bPostORFlags[cpu.z80A];
15593
15594 break;
15595 }
15596 case 0xab:
15597 {
15598 sdwCyclesRemaining -= 4;
15599 cpu.z80A ^= cpu.z80E;
15600 cpu.z80F &= ~(Z80_FLAG_CARRY | Z80_FLAG_NEGATIVE | Z80_FLAG_OVERFLOW_PARITY | Z80_FLAG_HALF_CARRY | Z80_FLAG_ZERO | Z80_FLAG_SIGN);
15601 cpu.z80F |= bPostORFlags[cpu.z80A];
15602
15603 break;
15604 }
15605 case 0xac:
15606 {
15607 sdwCyclesRemaining -= 4;
15608 cpu.z80A ^= cpu.z80H;
15609 cpu.z80F &= ~(Z80_FLAG_CARRY | Z80_FLAG_NEGATIVE | Z80_FLAG_OVERFLOW_PARITY | Z80_FLAG_HALF_CARRY | Z80_FLAG_ZERO | Z80_FLAG_SIGN);
15610 cpu.z80F |= bPostORFlags[cpu.z80A];
15611
15612 break;
15613 }
15614 case 0xad:
15615 {
15616 sdwCyclesRemaining -= 4;
15617 cpu.z80A ^= cpu.z80L;
15618 cpu.z80F &= ~(Z80_FLAG_CARRY | Z80_FLAG_NEGATIVE | Z80_FLAG_OVERFLOW_PARITY | Z80_FLAG_HALF_CARRY | Z80_FLAG_ZERO | Z80_FLAG_SIGN);
15619 cpu.z80F |= bPostORFlags[cpu.z80A];
15620
15621 break;
15622 }
15623 case 0xae:
15624 {
15625 sdwCyclesRemaining -= 7;
15626 psMemRead = cpu.z80MemRead; /* Beginning of our handler */
15627 while (psMemRead->lowAddr != 0xffffffff)
15628 {
15629 if ((cpu.z80HL >= psMemRead->lowAddr) && (cpu.z80HL <= psMemRead->highAddr))
15630 {
15631 cpu.z80pc = (UINT32) pbPC - (UINT32) cpu.z80Base;
15632 if (psMemRead->memoryCall)
15633 {
15634 bTemp = psMemRead->memoryCall(cpu.z80HL, psMemRead);
15635 }
15636 else
15637 {
15638 bTemp = *((UINT8 *) psMemRead->pUserArea + (cpu.z80HL - psMemRead->lowAddr));
15639 }
15640 psMemRead = NULL;
15641 break;
15642 }
15643 ++psMemRead;
15644 }
15645
15646 if (psMemRead)
15647 {
15648 bTemp = cpu.z80Base[cpu.z80HL];
15649 }
15650
15651 cpu.z80A ^= bTemp;
15652 cpu.z80F &= ~(Z80_FLAG_CARRY | Z80_FLAG_NEGATIVE | Z80_FLAG_OVERFLOW_PARITY | Z80_FLAG_HALF_CARRY | Z80_FLAG_ZERO | Z80_FLAG_SIGN);
15653 cpu.z80F |= bPostORFlags[cpu.z80A];
15654
15655 break;
15656 }
15657 case 0xaf:
15658 {
15659 sdwCyclesRemaining -= 4;
15660 cpu.z80A ^= cpu.z80A;
15661 cpu.z80F &= ~(Z80_FLAG_CARRY | Z80_FLAG_NEGATIVE | Z80_FLAG_OVERFLOW_PARITY | Z80_FLAG_HALF_CARRY | Z80_FLAG_ZERO | Z80_FLAG_SIGN);
15662 cpu.z80F |= bPostORFlags[cpu.z80A];
15663
15664 break;
15665 }
15666 case 0xb0:
15667 {
15668 sdwCyclesRemaining -= 4;
15669 cpu.z80A |= cpu.z80B;
15670 cpu.z80F &= ~(Z80_FLAG_CARRY | Z80_FLAG_NEGATIVE | Z80_FLAG_OVERFLOW_PARITY | Z80_FLAG_HALF_CARRY | Z80_FLAG_ZERO | Z80_FLAG_SIGN);
15671 cpu.z80F |= bPostORFlags[cpu.z80A];
15672
15673 break;
15674 }
15675 case 0xb1:
15676 {
15677 sdwCyclesRemaining -= 4;
15678 cpu.z80A |= cpu.z80C;
15679 cpu.z80F &= ~(Z80_FLAG_CARRY | Z80_FLAG_NEGATIVE | Z80_FLAG_OVERFLOW_PARITY | Z80_FLAG_HALF_CARRY | Z80_FLAG_ZERO | Z80_FLAG_SIGN);
15680 cpu.z80F |= bPostORFlags[cpu.z80A];
15681
15682 break;
15683 }
15684 case 0xb2:
15685 {
15686 sdwCyclesRemaining -= 4;
15687 cpu.z80A |= cpu.z80D;
15688 cpu.z80F &= ~(Z80_FLAG_CARRY | Z80_FLAG_NEGATIVE | Z80_FLAG_OVERFLOW_PARITY | Z80_FLAG_HALF_CARRY | Z80_FLAG_ZERO | Z80_FLAG_SIGN);
15689 cpu.z80F |= bPostORFlags[cpu.z80A];
15690
15691 break;
15692 }
15693 case 0xb3:
15694 {
15695 sdwCyclesRemaining -= 4;
15696 cpu.z80A |= cpu.z80E;
15697 cpu.z80F &= ~(Z80_FLAG_CARRY | Z80_FLAG_NEGATIVE | Z80_FLAG_OVERFLOW_PARITY | Z80_FLAG_HALF_CARRY | Z80_FLAG_ZERO | Z80_FLAG_SIGN);
15698 cpu.z80F |= bPostORFlags[cpu.z80A];
15699
15700 break;
15701 }
15702 case 0xb4:
15703 {
15704 sdwCyclesRemaining -= 4;
15705 cpu.z80A |= cpu.z80H;
15706 cpu.z80F &= ~(Z80_FLAG_CARRY | Z80_FLAG_NEGATIVE | Z80_FLAG_OVERFLOW_PARITY | Z80_FLAG_HALF_CARRY | Z80_FLAG_ZERO | Z80_FLAG_SIGN);
15707 cpu.z80F |= bPostORFlags[cpu.z80A];
15708
15709 break;
15710 }
15711 case 0xb5:
15712 {
15713 sdwCyclesRemaining -= 4;
15714 cpu.z80A |= cpu.z80L;
15715 cpu.z80F &= ~(Z80_FLAG_CARRY | Z80_FLAG_NEGATIVE | Z80_FLAG_OVERFLOW_PARITY | Z80_FLAG_HALF_CARRY | Z80_FLAG_ZERO | Z80_FLAG_SIGN);
15716 cpu.z80F |= bPostORFlags[cpu.z80A];
15717
15718 break;
15719 }
15720 case 0xb6:
15721 {
15722 sdwCyclesRemaining -= 7;
15723 psMemRead = cpu.z80MemRead; /* Beginning of our handler */
15724 while (psMemRead->lowAddr != 0xffffffff)
15725 {
15726 if ((cpu.z80HL >= psMemRead->lowAddr) && (cpu.z80HL <= psMemRead->highAddr))
15727 {
15728 cpu.z80pc = (UINT32) pbPC - (UINT32) cpu.z80Base;
15729 if (psMemRead->memoryCall)
15730 {
15731 bTemp = psMemRead->memoryCall(cpu.z80HL, psMemRead);
15732 }
15733 else
15734 {
15735 bTemp = *((UINT8 *) psMemRead->pUserArea + (cpu.z80HL - psMemRead->lowAddr));
15736 }
15737 psMemRead = NULL;
15738 break;
15739 }
15740 ++psMemRead;
15741 }
15742
15743 if (psMemRead)
15744 {
15745 bTemp = cpu.z80Base[cpu.z80HL];
15746 }
15747
15748 cpu.z80A |= bTemp;
15749 cpu.z80F &= ~(Z80_FLAG_CARRY | Z80_FLAG_NEGATIVE | Z80_FLAG_OVERFLOW_PARITY | Z80_FLAG_HALF_CARRY | Z80_FLAG_ZERO | Z80_FLAG_SIGN);
15750 cpu.z80F |= bPostORFlags[cpu.z80A];
15751
15752 break;
15753 }
15754 case 0xb7:
15755 {
15756 sdwCyclesRemaining -= 4;
15757 cpu.z80A |= cpu.z80A;
15758 cpu.z80F &= ~(Z80_FLAG_CARRY | Z80_FLAG_NEGATIVE | Z80_FLAG_OVERFLOW_PARITY | Z80_FLAG_HALF_CARRY | Z80_FLAG_ZERO | Z80_FLAG_SIGN);
15759 cpu.z80F |= bPostORFlags[cpu.z80A];
15760
15761 break;
15762 }
15763 case 0xb8:
15764 {
15765 sdwCyclesRemaining -= 4;
15766 cpu.z80F = (cpu.z80F & ~(Z80_FLAG_CARRY | Z80_FLAG_NEGATIVE | Z80_FLAG_OVERFLOW_PARITY |
15767 Z80_FLAG_HALF_CARRY | Z80_FLAG_ZERO | Z80_FLAG_SIGN)) |
15768 pbSubSbcTable[((UINT32) cpu.z80A << 8) | cpu.z80B];
15769 break;
15770 }
15771 case 0xb9:
15772 {
15773 sdwCyclesRemaining -= 4;
15774 cpu.z80F = (cpu.z80F & ~(Z80_FLAG_CARRY | Z80_FLAG_NEGATIVE | Z80_FLAG_OVERFLOW_PARITY |
15775 Z80_FLAG_HALF_CARRY | Z80_FLAG_ZERO | Z80_FLAG_SIGN)) |
15776 pbSubSbcTable[((UINT32) cpu.z80A << 8) | cpu.z80C];
15777 break;
15778 }
15779 case 0xba:
15780 {
15781 sdwCyclesRemaining -= 4;
15782 cpu.z80F = (cpu.z80F & ~(Z80_FLAG_CARRY | Z80_FLAG_NEGATIVE | Z80_FLAG_OVERFLOW_PARITY |
15783 Z80_FLAG_HALF_CARRY | Z80_FLAG_ZERO | Z80_FLAG_SIGN)) |
15784 pbSubSbcTable[((UINT32) cpu.z80A << 8) | cpu.z80D];
15785 break;
15786 }
15787 case 0xbb:
15788 {
15789 sdwCyclesRemaining -= 4;
15790 cpu.z80F = (cpu.z80F & ~(Z80_FLAG_CARRY | Z80_FLAG_NEGATIVE | Z80_FLAG_OVERFLOW_PARITY |
15791 Z80_FLAG_HALF_CARRY | Z80_FLAG_ZERO | Z80_FLAG_SIGN)) |
15792 pbSubSbcTable[((UINT32) cpu.z80A << 8) | cpu.z80E];
15793 break;
15794 }
15795 case 0xbc:
15796 {
15797 sdwCyclesRemaining -= 4;
15798 cpu.z80F = (cpu.z80F & ~(Z80_FLAG_CARRY | Z80_FLAG_NEGATIVE | Z80_FLAG_OVERFLOW_PARITY |
15799 Z80_FLAG_HALF_CARRY | Z80_FLAG_ZERO | Z80_FLAG_SIGN)) |
15800 pbSubSbcTable[((UINT32) cpu.z80A << 8) | cpu.z80H];
15801 break;
15802 }
15803 case 0xbd:
15804 {
15805 sdwCyclesRemaining -= 4;
15806 cpu.z80F = (cpu.z80F & ~(Z80_FLAG_CARRY | Z80_FLAG_NEGATIVE | Z80_FLAG_OVERFLOW_PARITY |
15807 Z80_FLAG_HALF_CARRY | Z80_FLAG_ZERO | Z80_FLAG_SIGN)) |
15808 pbSubSbcTable[((UINT32) cpu.z80A << 8) | cpu.z80L];
15809 break;
15810 }
15811 case 0xbe:
15812 {
15813 sdwCyclesRemaining -= 7;
15814 psMemRead = cpu.z80MemRead; /* Beginning of our handler */
15815 while (psMemRead->lowAddr != 0xffffffff)
15816 {
15817 if ((cpu.z80HL >= psMemRead->lowAddr) && (cpu.z80HL <= psMemRead->highAddr))
15818 {
15819 cpu.z80pc = (UINT32) pbPC - (UINT32) cpu.z80Base;
15820 if (psMemRead->memoryCall)
15821 {
15822 bTemp = psMemRead->memoryCall(cpu.z80HL, psMemRead);
15823 }
15824 else
15825 {
15826 bTemp = *((UINT8 *) psMemRead->pUserArea + (cpu.z80HL - psMemRead->lowAddr));
15827 }
15828 psMemRead = NULL;
15829 break;
15830 }
15831 ++psMemRead;
15832 }
15833
15834 if (psMemRead)
15835 {
15836 bTemp = cpu.z80Base[cpu.z80HL];
15837 }
15838
15839 cpu.z80F = (cpu.z80F & ~(Z80_FLAG_CARRY | Z80_FLAG_NEGATIVE | Z80_FLAG_OVERFLOW_PARITY |
15840 Z80_FLAG_HALF_CARRY | Z80_FLAG_ZERO | Z80_FLAG_SIGN)) |
15841 pbSubSbcTable[((UINT32) cpu.z80A << 8) | bTemp];
15842 break;
15843 }
15844 case 0xbf:
15845 {
15846 sdwCyclesRemaining -= 4;
15847 cpu.z80F = (cpu.z80F & ~(Z80_FLAG_CARRY | Z80_FLAG_NEGATIVE | Z80_FLAG_OVERFLOW_PARITY |
15848 Z80_FLAG_HALF_CARRY | Z80_FLAG_ZERO | Z80_FLAG_SIGN)) |
15849 pbSubSbcTable[((UINT32) cpu.z80A << 8) | cpu.z80A];
15850 break;
15851 }
15852 case 0xc0:
15853 {
15854 sdwCyclesRemaining -= 5;
15855 if (!(cpu.z80F & Z80_FLAG_ZERO))
15856 {
15857 dwElapsedTicks += 6;
15858 pbSP = cpu.z80Base + cpu.z80sp; /* Normalize our stack PTR */
15859 dwAddr = *pbSP++; /* Pop LSB */
15860 dwAddr |= ((UINT32) *pbSP << 8); /* Pop MSB */
15861 cpu.z80sp += 2; /* Pop the word off */
15862 pbPC = (cpu.z80Base + dwAddr); /* Point PC to our return address */
15863 }
15864 break;
15865 }
15866 case 0xc1:
15867 {
15868 sdwCyclesRemaining -= 10;
15869 psMemRead = cpu.z80MemRead; /* Beginning of our handler */
15870 while (psMemRead->lowAddr != 0xffffffff)
15871 {
15872 if ((cpu.z80sp >= psMemRead->lowAddr) && (cpu.z80sp <= psMemRead->highAddr))
15873 {
15874 cpu.z80pc = (UINT32) pbPC - (UINT32) cpu.z80Base;
15875 if (psMemRead->memoryCall)
15876 {
15877 cpu.z80BC = psMemRead->memoryCall(cpu.z80sp, psMemRead);
15878 cpu.z80BC |= (UINT32) ((UINT32) psMemRead->memoryCall(cpu.z80sp + 1, psMemRead) << 8);
15879 }
15880 else
15881 {
15882 cpu.z80BC = *((UINT8 *) psMemRead->pUserArea + (cpu.z80sp - psMemRead->lowAddr));
15883 cpu.z80BC |= (UINT32) ((UINT32) *((UINT8 *) psMemRead->pUserArea + (cpu.z80sp - psMemRead->lowAddr + 1)) << 8);
15884 }
15885 psMemRead = NULL;
15886 break;
15887 }
15888 ++psMemRead;
15889 }
15890
15891 if (psMemRead)
15892 {
15893 cpu.z80BC = cpu.z80Base[cpu.z80sp];
15894 cpu.z80BC |= (UINT32) ((UINT32) cpu.z80Base[cpu.z80sp + 1] << 8);
15895 }
15896
15897 cpu.z80sp += 2;
15898 pbSP = (cpu.z80Base + cpu.z80sp); /* Normalize the stack pointer */
15899 break;
15900 }
15901 case 0xc2:
15902 {
15903 sdwCyclesRemaining -= 10;
15904 dwAddr = *pbPC++; /* Get LSB first */
15905 dwAddr |= ((UINT32) *pbPC++ << 8); /* Get MSB last */
15906 if (!(cpu.z80F & Z80_FLAG_ZERO))
15907 {
15908 pbPC = cpu.z80Base + dwAddr; /* Normalize the address */
15909 }
15910 break;
15911 }
15912 case 0xc3:
15913 {
15914 sdwCyclesRemaining -= 10;
15915 dwAddr = *pbPC++; /* Get LSB first */
15916 dwAddr |= ((UINT32) *pbPC++ << 8); /* Get MSB last */
15917 pbPC = cpu.z80Base + dwAddr; /* Normalize the address */
15918 break;
15919 }
15920 case 0xc4:
15921 {
15922 sdwCyclesRemaining -= 10;
15923 dwAddr = *pbPC++; /* Get LSB first */
15924 dwAddr |= ((UINT32) *pbPC++ << 8); /* Get MSB last */
15925 if (!(cpu.z80F & Z80_FLAG_ZERO))
15926 {
15927 cpu.z80pc = (UINT32) pbPC - (UINT32) cpu.z80Base;
15928 pbSP = (cpu.z80Base + cpu.z80sp - 1); /* Normalize the stack pointer */
15929 *pbSP-- = cpu.z80pc >> 8; /* MSB */
15930 *pbSP = (UINT8) cpu.z80pc; /* LSB */
15931 cpu.z80sp -= 2; /* Back our stack up */
15932 pbPC = cpu.z80Base + dwAddr; /* Normalize the address */
15933 }
15934 break;
15935 }
15936 case 0xc5:
15937 {
15938 sdwCyclesRemaining -= 11;
15939 cpu.z80sp -= 2;
15940 pbSP = (cpu.z80Base + cpu.z80sp); /* Normalize the stack pointer */
15941 psMemWrite = cpu.z80MemWrite; /* Beginning of our handler */
15942 while (psMemWrite->lowAddr != 0xffffffff)
15943 {
15944 if ((cpu.z80sp >= psMemWrite->lowAddr) && (cpu.z80sp <= psMemWrite->highAddr))
15945 {
15946 cpu.z80pc = (UINT32) pbPC - (UINT32) cpu.z80Base;
15947 if (psMemWrite->memoryCall)
15948 {
15949 psMemWrite->memoryCall(cpu.z80sp, (cpu.z80BC & 0xff), psMemWrite);
15950 psMemWrite->memoryCall(cpu.z80sp + 1, (cpu.z80BC >> 8), psMemWrite);
15951 }
15952 else
15953 {
15954 *((UINT8 *) psMemWrite->pUserArea + (cpu.z80sp - psMemWrite->lowAddr)) = cpu.z80BC;
15955 *((UINT8 *) psMemWrite->pUserArea + (cpu.z80sp - psMemWrite->lowAddr) + 1) = cpu.z80BC >> 8;
15956 }
15957 psMemWrite = NULL;
15958 break;
15959 }
15960 ++psMemWrite;
15961 }
15962
15963 if (psMemWrite)
15964 {
15965 cpu.z80Base[cpu.z80sp] = (UINT8) cpu.z80BC;
15966 cpu.z80Base[cpu.z80sp + 1] = (UINT8) ((UINT32) cpu.z80BC >> 8);
15967 }
15968
15969 break;
15970 }
15971 case 0xc6:
15972 {
15973 sdwCyclesRemaining -= 7;
15974 bTemp = *pbPC++;
15975 cpu.z80F = (cpu.z80F & ~(Z80_FLAG_CARRY | Z80_FLAG_NEGATIVE | Z80_FLAG_OVERFLOW_PARITY |
15976 Z80_FLAG_HALF_CARRY | Z80_FLAG_ZERO | Z80_FLAG_SIGN)) |
15977 pbAddAdcTable[((UINT32) cpu.z80A << 8) | bTemp];
15978 cpu.z80A += bTemp;
15979 break;
15980 }
15981 case 0xc7:
15982 {
15983 sdwCyclesRemaining -= 11;
15984 cpu.z80pc = (UINT32) pbPC - (UINT32) cpu.z80Base;
15985 pbSP = (cpu.z80Base + cpu.z80sp - 1); /* Normalize the stack pointer */
15986 *pbSP-- = cpu.z80pc >> 8; /* LSB */
15987 *pbSP = (UINT8) cpu.z80pc; /* MSB */
15988 cpu.z80sp -= 2; /* Back our stack up */
15989 pbPC = cpu.z80Base + 0x00; /* Normalize the address */
15990 break;
15991 }
15992 case 0xc8:
15993 {
15994 sdwCyclesRemaining -= 5;
15995 if (cpu.z80F & Z80_FLAG_ZERO)
15996 {
15997 dwElapsedTicks += 6;
15998 pbSP = cpu.z80Base + cpu.z80sp; /* Normalize our stack PTR */
15999 dwAddr = *pbSP++; /* Pop LSB */
16000 dwAddr |= ((UINT32) *pbSP << 8); /* Pop MSB */
16001 cpu.z80sp += 2; /* Pop the word off */
16002 pbPC = (cpu.z80Base + dwAddr); /* Point PC to our return address */
16003 }
16004 break;
16005 }
16006 case 0xc9:
16007 {
16008 sdwCyclesRemaining -= 10;
16009 pbSP = cpu.z80Base + cpu.z80sp; /* Normalize our stack PTR */
16010 dwAddr = *pbSP++; /* Pop LSB */
16011 dwAddr |= ((UINT32) *pbSP << 8); /* Pop MSB */
16012 cpu.z80sp += 2; /* Pop the word off */
16013 pbPC = (cpu.z80Base + dwAddr); /* Point PC to our return address */
16014 break;
16015 }
16016 case 0xca:
16017 {
16018 sdwCyclesRemaining -= 10;
16019 dwAddr = *pbPC++; /* Get LSB first */
16020 dwAddr |= ((UINT32) *pbPC++ << 8); /* Get MSB last */
16021 if (cpu.z80F & Z80_FLAG_ZERO)
16022 {
16023 pbPC = cpu.z80Base + dwAddr; /* Normalize the address */
16024 }
16025 break;
16026 }
16027 case 0xcb:
16028 {
16029 CBHandler();
16030 break;
16031 }
16032 case 0xcc:
16033 {
16034 sdwCyclesRemaining -= 10;
16035 dwAddr = *pbPC++; /* Get LSB first */
16036 dwAddr |= ((UINT32) *pbPC++ << 8); /* Get MSB last */
16037 if (cpu.z80F & Z80_FLAG_ZERO)
16038 {
16039 cpu.z80pc = (UINT32) pbPC - (UINT32) cpu.z80Base;
16040 pbSP = (cpu.z80Base + cpu.z80sp - 1); /* Normalize the stack pointer */
16041 *pbSP-- = cpu.z80pc >> 8; /* MSB */
16042 *pbSP = (UINT8) cpu.z80pc; /* LSB */
16043 cpu.z80sp -= 2; /* Back our stack up */
16044 pbPC = cpu.z80Base + dwAddr; /* Normalize the address */
16045 }
16046 break;
16047 }
16048 case 0xcd:
16049 {
16050 sdwCyclesRemaining -= 17;
16051 dwAddr = *pbPC++; /* Get LSB first */
16052 dwAddr |= ((UINT32) *pbPC++ << 8); /* Get MSB last */
16053 cpu.z80pc = (UINT32) pbPC - (UINT32) cpu.z80Base;
16054 pbSP = (cpu.z80Base + cpu.z80sp - 1); /* Normalize the stack pointer */
16055 *pbSP-- = cpu.z80pc >> 8; /* LSB */
16056 *pbSP = (UINT8) cpu.z80pc; /* MSB */
16057 cpu.z80sp -= 2; /* Back our stack up */
16058 pbPC = cpu.z80Base + dwAddr; /* Normalize the address */
16059 break;
16060 }
16061 case 0xce:
16062 {
16063 sdwCyclesRemaining -= 7;
16064 bTemp = *pbPC++ + (cpu.z80F & Z80_FLAG_CARRY);
16065 cpu.z80F = (cpu.z80F & ~(Z80_FLAG_CARRY | Z80_FLAG_NEGATIVE | Z80_FLAG_OVERFLOW_PARITY |
16066 Z80_FLAG_HALF_CARRY | Z80_FLAG_ZERO | Z80_FLAG_SIGN)) |
16067 pbAddAdcTable[((UINT32) cpu.z80A << 8) | bTemp | (((UINT32) cpu.z80F & Z80_FLAG_CARRY) << 16)];
16068 cpu.z80A += bTemp;
16069 break;
16070 }
16071 case 0xcf:
16072 {
16073 sdwCyclesRemaining -= 11;
16074 cpu.z80pc = (UINT32) pbPC - (UINT32) cpu.z80Base;
16075 pbSP = (cpu.z80Base + cpu.z80sp - 1); /* Normalize the stack pointer */
16076 *pbSP-- = cpu.z80pc >> 8; /* LSB */
16077 *pbSP = (UINT8) cpu.z80pc; /* MSB */
16078 cpu.z80sp -= 2; /* Back our stack up */
16079 pbPC = cpu.z80Base + 0x08; /* Normalize the address */
16080 break;
16081 }
16082 case 0xd0:
16083 {
16084 sdwCyclesRemaining -= 5;
16085 if (!(cpu.z80F & Z80_FLAG_CARRY))
16086 {
16087 dwElapsedTicks += 6;
16088 pbSP = cpu.z80Base + cpu.z80sp; /* Normalize our stack PTR */
16089 dwAddr = *pbSP++; /* Pop LSB */
16090 dwAddr |= ((UINT32) *pbSP << 8); /* Pop MSB */
16091 cpu.z80sp += 2; /* Pop the word off */
16092 pbPC = (cpu.z80Base + dwAddr); /* Point PC to our return address */
16093 }
16094 break;
16095 }
16096 case 0xd1:
16097 {
16098 sdwCyclesRemaining -= 10;
16099 psMemRead = cpu.z80MemRead; /* Beginning of our handler */
16100 while (psMemRead->lowAddr != 0xffffffff)
16101 {
16102 if ((cpu.z80sp >= psMemRead->lowAddr) && (cpu.z80sp <= psMemRead->highAddr))
16103 {
16104 cpu.z80pc = (UINT32) pbPC - (UINT32) cpu.z80Base;
16105 if (psMemRead->memoryCall)
16106 {
16107 cpu.z80DE = psMemRead->memoryCall(cpu.z80sp, psMemRead);
16108 cpu.z80DE |= (UINT32) ((UINT32) psMemRead->memoryCall(cpu.z80sp + 1, psMemRead) << 8);
16109 }
16110 else
16111 {
16112 cpu.z80DE = *((UINT8 *) psMemRead->pUserArea + (cpu.z80sp - psMemRead->lowAddr));
16113 cpu.z80DE |= (UINT32) ((UINT32) *((UINT8 *) psMemRead->pUserArea + (cpu.z80sp - psMemRead->lowAddr + 1)) << 8);
16114 }
16115 psMemRead = NULL;
16116 break;
16117 }
16118 ++psMemRead;
16119 }
16120
16121 if (psMemRead)
16122 {
16123 cpu.z80DE = cpu.z80Base[cpu.z80sp];
16124 cpu.z80DE |= (UINT32) ((UINT32) cpu.z80Base[cpu.z80sp + 1] << 8);
16125 }
16126
16127 cpu.z80sp += 2;
16128 pbSP = (cpu.z80Base + cpu.z80sp); /* Normalize the stack pointer */
16129 break;
16130 }
16131 case 0xd2:
16132 {
16133 sdwCyclesRemaining -= 10;
16134 dwAddr = *pbPC++; /* Get LSB first */
16135 dwAddr |= ((UINT32) *pbPC++ << 8); /* Get MSB last */
16136 if (!(cpu.z80F & Z80_FLAG_CARRY))
16137 {
16138 pbPC = cpu.z80Base + dwAddr; /* Normalize the address */
16139 }
16140 break;
16141 }
16142 case 0xd3:
16143 {
16144 sdwCyclesRemaining -= 11;
16145 dwTemp = *pbPC++;
16146 psIoWrite = cpu.z80IoWrite; /* Beginning of our handler */
16147 while (psIoWrite->lowIoAddr != 0xffff)
16148 {
16149 if ((dwTemp >= psIoWrite->lowIoAddr) && (dwTemp <= psIoWrite->highIoAddr))
16150 {
16151 cpu.z80pc = (UINT32) pbPC - (UINT32) cpu.z80Base;
16152 psIoWrite->IOCall(dwTemp, cpu.z80A, psIoWrite);
16153 psIoWrite = NULL;
16154 break;
16155 }
16156 ++psIoWrite;
16157 }
16158
16159 break;
16160 }
16161 case 0xd4:
16162 {
16163 sdwCyclesRemaining -= 10;
16164 dwAddr = *pbPC++; /* Get LSB first */
16165 dwAddr |= ((UINT32) *pbPC++ << 8); /* Get MSB last */
16166 if (!(cpu.z80F & Z80_FLAG_CARRY))
16167 {
16168 cpu.z80pc = (UINT32) pbPC - (UINT32) cpu.z80Base;
16169 pbSP = (cpu.z80Base + cpu.z80sp - 1); /* Normalize the stack pointer */
16170 *pbSP-- = cpu.z80pc >> 8; /* MSB */
16171 *pbSP = (UINT8) cpu.z80pc; /* LSB */
16172 cpu.z80sp -= 2; /* Back our stack up */
16173 pbPC = cpu.z80Base + dwAddr; /* Normalize the address */
16174 }
16175 break;
16176 }
16177 case 0xd5:
16178 {
16179 sdwCyclesRemaining -= 11;
16180 cpu.z80sp -= 2;
16181 pbSP = (cpu.z80Base + cpu.z80sp); /* Normalize the stack pointer */
16182 psMemWrite = cpu.z80MemWrite; /* Beginning of our handler */
16183 while (psMemWrite->lowAddr != 0xffffffff)
16184 {
16185 if ((cpu.z80sp >= psMemWrite->lowAddr) && (cpu.z80sp <= psMemWrite->highAddr))
16186 {
16187 cpu.z80pc = (UINT32) pbPC - (UINT32) cpu.z80Base;
16188 if (psMemWrite->memoryCall)
16189 {
16190 psMemWrite->memoryCall(cpu.z80sp, (cpu.z80DE & 0xff), psMemWrite);
16191 psMemWrite->memoryCall(cpu.z80sp + 1, (cpu.z80DE >> 8), psMemWrite);
16192 }
16193 else
16194 {
16195 *((UINT8 *) psMemWrite->pUserArea + (cpu.z80sp - psMemWrite->lowAddr)) = cpu.z80DE;
16196 *((UINT8 *) psMemWrite->pUserArea + (cpu.z80sp - psMemWrite->lowAddr) + 1) = cpu.z80DE >> 8;
16197 }
16198 psMemWrite = NULL;
16199 break;
16200 }
16201 ++psMemWrite;
16202 }
16203
16204 if (psMemWrite)
16205 {
16206 cpu.z80Base[cpu.z80sp] = (UINT8) cpu.z80DE;
16207 cpu.z80Base[cpu.z80sp + 1] = (UINT8) ((UINT32) cpu.z80DE >> 8);
16208 }
16209
16210 break;
16211 }
16212 case 0xd6:
16213 {
16214 sdwCyclesRemaining -= 7;
16215 bTemp = *pbPC++;
16216 cpu.z80F = (cpu.z80F & ~(Z80_FLAG_CARRY | Z80_FLAG_NEGATIVE | Z80_FLAG_OVERFLOW_PARITY |
16217 Z80_FLAG_HALF_CARRY | Z80_FLAG_ZERO | Z80_FLAG_SIGN)) |
16218 pbSubSbcTable[((UINT32) cpu.z80A << 8) | bTemp];
16219 cpu.z80A -= bTemp;
16220 break;
16221 }
16222 case 0xd7:
16223 {
16224 sdwCyclesRemaining -= 11;
16225 cpu.z80pc = (UINT32) pbPC - (UINT32) cpu.z80Base;
16226 pbSP = (cpu.z80Base + cpu.z80sp - 1); /* Normalize the stack pointer */
16227 *pbSP-- = cpu.z80pc >> 8; /* LSB */
16228 *pbSP = (UINT8) cpu.z80pc; /* MSB */
16229 cpu.z80sp -= 2; /* Back our stack up */
16230 pbPC = cpu.z80Base + 0x10; /* Normalize the address */
16231 break;
16232 }
16233 case 0xd8:
16234 {
16235 sdwCyclesRemaining -= 5;
16236 if (cpu.z80F & Z80_FLAG_CARRY)
16237 {
16238 dwElapsedTicks += 6;
16239 pbSP = cpu.z80Base + cpu.z80sp; /* Normalize our stack PTR */
16240 dwAddr = *pbSP++; /* Pop LSB */
16241 dwAddr |= ((UINT32) *pbSP << 8); /* Pop MSB */
16242 cpu.z80sp += 2; /* Pop the word off */
16243 pbPC = (cpu.z80Base + dwAddr); /* Point PC to our return address */
16244 }
16245 break;
16246 }
16247 case 0xd9:
16248 {
16249 sdwCyclesRemaining -= 4;
16250 dwTemp = cpu.z80DE;
16251 cpu.z80DE = cpu.z80deprime;
16252 cpu.z80deprime = dwTemp;
16253 dwTemp = cpu.z80BC;
16254 cpu.z80BC = cpu.z80bcprime;
16255 cpu.z80bcprime = dwTemp;
16256 dwTemp = cpu.z80HL;
16257 cpu.z80HL = cpu.z80hlprime;
16258 cpu.z80hlprime = dwTemp;
16259 break;
16260 }
16261 case 0xda:
16262 {
16263 sdwCyclesRemaining -= 10;
16264 dwAddr = *pbPC++; /* Get LSB first */
16265 dwAddr |= ((UINT32) *pbPC++ << 8); /* Get MSB last */
16266 if (cpu.z80F & Z80_FLAG_CARRY)
16267 {
16268 pbPC = cpu.z80Base + dwAddr; /* Normalize the address */
16269 }
16270 break;
16271 }
16272 case 0xdb:
16273 {
16274 sdwCyclesRemaining -= 11;
16275 dwTemp = *pbPC++;
16276 psIoRead = cpu.z80IoRead; /* Beginning of our handler */
16277 while (psIoRead->lowIoAddr != 0xffff)
16278 {
16279 if ((dwTemp >= psIoRead->lowIoAddr) && (dwTemp <= psIoRead->highIoAddr))
16280 {
16281 cpu.z80pc = (UINT32) pbPC - (UINT32) cpu.z80Base;
16282 cpu.z80A = psIoRead->IOCall(dwTemp, psIoRead);
16283 psIoRead = NULL;
16284 break;
16285 }
16286 ++psIoRead;
16287 }
16288
16289 if (psIoRead)
16290 {
16291 cpu.z80A = 0xff; /* Unclaimed I/O read */
16292 }
16293
16294 break;
16295 }
16296 case 0xdc:
16297 {
16298 sdwCyclesRemaining -= 10;
16299 dwAddr = *pbPC++; /* Get LSB first */
16300 dwAddr |= ((UINT32) *pbPC++ << 8); /* Get MSB last */
16301 if (cpu.z80F & Z80_FLAG_CARRY)
16302 {
16303 cpu.z80pc = (UINT32) pbPC - (UINT32) cpu.z80Base;
16304 pbSP = (cpu.z80Base + cpu.z80sp - 1); /* Normalize the stack pointer */
16305 *pbSP-- = cpu.z80pc >> 8; /* MSB */
16306 *pbSP = (UINT8) cpu.z80pc; /* LSB */
16307 cpu.z80sp -= 2; /* Back our stack up */
16308 pbPC = cpu.z80Base + dwAddr; /* Normalize the address */
16309 }
16310 break;
16311 }
16312 case 0xdd:
16313 {
16314 DDHandler();
16315 break;
16316 }
16317 case 0xde:
16318 {
16319 sdwCyclesRemaining -= 7;
16320 bTemp = *pbPC++ + (cpu.z80F & Z80_FLAG_CARRY);
16321 cpu.z80F = (cpu.z80F & ~(Z80_FLAG_CARRY | Z80_FLAG_NEGATIVE | Z80_FLAG_OVERFLOW_PARITY |
16322 Z80_FLAG_HALF_CARRY | Z80_FLAG_ZERO | Z80_FLAG_SIGN)) |
16323 pbSubSbcTable[((UINT32) cpu.z80A << 8) | bTemp | (((UINT32) cpu.z80F & Z80_FLAG_CARRY) << 16)];
16324 cpu.z80A = cpu.z80A - bTemp;
16325 break;
16326 }
16327 case 0xdf:
16328 {
16329 sdwCyclesRemaining -= 11;
16330 cpu.z80pc = (UINT32) pbPC - (UINT32) cpu.z80Base;
16331 pbSP = (cpu.z80Base + cpu.z80sp - 1); /* Normalize the stack pointer */
16332 *pbSP-- = cpu.z80pc >> 8; /* LSB */
16333 *pbSP = (UINT8) cpu.z80pc; /* MSB */
16334 cpu.z80sp -= 2; /* Back our stack up */
16335 pbPC = cpu.z80Base + 0x18; /* Normalize the address */
16336 break;
16337 }
16338 case 0xe0:
16339 {
16340 sdwCyclesRemaining -= 5;
16341 if (!(cpu.z80F & Z80_FLAG_OVERFLOW_PARITY))
16342 {
16343 dwElapsedTicks += 6;
16344 pbSP = cpu.z80Base + cpu.z80sp; /* Normalize our stack PTR */
16345 dwAddr = *pbSP++; /* Pop LSB */
16346 dwAddr |= ((UINT32) *pbSP << 8); /* Pop MSB */
16347 cpu.z80sp += 2; /* Pop the word off */
16348 pbPC = (cpu.z80Base + dwAddr); /* Point PC to our return address */
16349 }
16350 break;
16351 }
16352 case 0xe1:
16353 {
16354 sdwCyclesRemaining -= 10;
16355 psMemRead = cpu.z80MemRead; /* Beginning of our handler */
16356 while (psMemRead->lowAddr != 0xffffffff)
16357 {
16358 if ((cpu.z80sp >= psMemRead->lowAddr) && (cpu.z80sp <= psMemRead->highAddr))
16359 {
16360 cpu.z80pc = (UINT32) pbPC - (UINT32) cpu.z80Base;
16361 if (psMemRead->memoryCall)
16362 {
16363 cpu.z80HL = psMemRead->memoryCall(cpu.z80sp, psMemRead);
16364 cpu.z80HL |= (UINT32) ((UINT32) psMemRead->memoryCall(cpu.z80sp + 1, psMemRead) << 8);
16365 }
16366 else
16367 {
16368 cpu.z80HL = *((UINT8 *) psMemRead->pUserArea + (cpu.z80sp - psMemRead->lowAddr));
16369 cpu.z80HL |= (UINT32) ((UINT32) *((UINT8 *) psMemRead->pUserArea + (cpu.z80sp - psMemRead->lowAddr + 1)) << 8);
16370 }
16371 psMemRead = NULL;
16372 break;
16373 }
16374 ++psMemRead;
16375 }
16376
16377 if (psMemRead)
16378 {
16379 cpu.z80HL = cpu.z80Base[cpu.z80sp];
16380 cpu.z80HL |= (UINT32) ((UINT32) cpu.z80Base[cpu.z80sp + 1] << 8);
16381 }
16382
16383 cpu.z80sp += 2;
16384 pbSP = (cpu.z80Base + cpu.z80sp); /* Normalize the stack pointer */
16385 break;
16386 }
16387 case 0xe2:
16388 {
16389 sdwCyclesRemaining -= 10;
16390 dwAddr = *pbPC++; /* Get LSB first */
16391 dwAddr |= ((UINT32) *pbPC++ << 8); /* Get MSB last */
16392 if (!(cpu.z80F & Z80_FLAG_OVERFLOW_PARITY))
16393 {
16394 pbPC = cpu.z80Base + dwAddr; /* Normalize the address */
16395 }
16396 break;
16397 }
16398 case 0xe3:
16399 {
16400 sdwCyclesRemaining -= 19;
16401 psMemRead = cpu.z80MemRead; /* Beginning of our handler */
16402 while (psMemRead->lowAddr != 0xffffffff)
16403 {
16404 if ((cpu.z80sp >= psMemRead->lowAddr) && (cpu.z80sp <= psMemRead->highAddr))
16405 {
16406 cpu.z80pc = (UINT32) pbPC - (UINT32) cpu.z80Base;
16407 if (psMemRead->memoryCall)
16408 {
16409 dwAddr = psMemRead->memoryCall(cpu.z80sp, psMemRead);
16410 dwAddr |= (UINT32) ((UINT32) psMemRead->memoryCall(cpu.z80sp + 1, psMemRead) << 8);
16411 }
16412 else
16413 {
16414 dwAddr = *((UINT8 *) psMemRead->pUserArea + (cpu.z80sp - psMemRead->lowAddr));
16415 dwAddr |= (UINT32) ((UINT32) *((UINT8 *) psMemRead->pUserArea + (cpu.z80sp - psMemRead->lowAddr + 1)) << 8);
16416 }
16417 psMemRead = NULL;
16418 break;
16419 }
16420 ++psMemRead;
16421 }
16422
16423 if (psMemRead)
16424 {
16425 dwAddr = cpu.z80Base[cpu.z80sp];
16426 dwAddr |= (UINT32) ((UINT32) cpu.z80Base[cpu.z80sp + 1] << 8);
16427 }
16428
16429 psMemWrite = cpu.z80MemWrite; /* Beginning of our handler */
16430 while (psMemWrite->lowAddr != 0xffffffff)
16431 {
16432 if ((cpu.z80sp >= psMemWrite->lowAddr) && (cpu.z80sp <= psMemWrite->highAddr))
16433 {
16434 cpu.z80pc = (UINT32) pbPC - (UINT32) cpu.z80Base;
16435 if (psMemWrite->memoryCall)
16436 {
16437 psMemWrite->memoryCall(cpu.z80sp, (cpu.z80HL & 0xff), psMemWrite);
16438 psMemWrite->memoryCall(cpu.z80sp + 1, (cpu.z80HL >> 8), psMemWrite);
16439 }
16440 else
16441 {
16442 *((UINT8 *) psMemWrite->pUserArea + (cpu.z80sp - psMemWrite->lowAddr)) = cpu.z80HL;
16443 *((UINT8 *) psMemWrite->pUserArea + (cpu.z80sp - psMemWrite->lowAddr) + 1) = cpu.z80HL >> 8;
16444 }
16445 psMemWrite = NULL;
16446 break;
16447 }
16448 ++psMemWrite;
16449 }
16450
16451 if (psMemWrite)
16452 {
16453 cpu.z80Base[cpu.z80sp] = (UINT8) cpu.z80HL;
16454 cpu.z80Base[cpu.z80sp + 1] = (UINT8) ((UINT32) cpu.z80HL >> 8);
16455 }
16456
16457 cpu.z80HL = dwAddr;
16458 break;
16459 }
16460 case 0xe4:
16461 {
16462 sdwCyclesRemaining -= 10;
16463 dwAddr = *pbPC++; /* Get LSB first */
16464 dwAddr |= ((UINT32) *pbPC++ << 8); /* Get MSB last */
16465 if (!(cpu.z80F & Z80_FLAG_OVERFLOW_PARITY))
16466 {
16467 cpu.z80pc = (UINT32) pbPC - (UINT32) cpu.z80Base;
16468 pbSP = (cpu.z80Base + cpu.z80sp - 1); /* Normalize the stack pointer */
16469 *pbSP-- = cpu.z80pc >> 8; /* MSB */
16470 *pbSP = (UINT8) cpu.z80pc; /* LSB */
16471 cpu.z80sp -= 2; /* Back our stack up */
16472 pbPC = cpu.z80Base + dwAddr; /* Normalize the address */
16473 }
16474 break;
16475 }
16476 case 0xe5:
16477 {
16478 sdwCyclesRemaining -= 11;
16479 cpu.z80sp -= 2;
16480 pbSP = (cpu.z80Base + cpu.z80sp); /* Normalize the stack pointer */
16481 psMemWrite = cpu.z80MemWrite; /* Beginning of our handler */
16482 while (psMemWrite->lowAddr != 0xffffffff)
16483 {
16484 if ((cpu.z80sp >= psMemWrite->lowAddr) && (cpu.z80sp <= psMemWrite->highAddr))
16485 {
16486 cpu.z80pc = (UINT32) pbPC - (UINT32) cpu.z80Base;
16487 if (psMemWrite->memoryCall)
16488 {
16489 psMemWrite->memoryCall(cpu.z80sp, (cpu.z80HL & 0xff), psMemWrite);
16490 psMemWrite->memoryCall(cpu.z80sp + 1, (cpu.z80HL >> 8), psMemWrite);
16491 }
16492 else
16493 {
16494 *((UINT8 *) psMemWrite->pUserArea + (cpu.z80sp - psMemWrite->lowAddr)) = cpu.z80HL;
16495 *((UINT8 *) psMemWrite->pUserArea + (cpu.z80sp - psMemWrite->lowAddr) + 1) = cpu.z80HL >> 8;
16496 }
16497 psMemWrite = NULL;
16498 break;
16499 }
16500 ++psMemWrite;
16501 }
16502
16503 if (psMemWrite)
16504 {
16505 cpu.z80Base[cpu.z80sp] = (UINT8) cpu.z80HL;
16506 cpu.z80Base[cpu.z80sp + 1] = (UINT8) ((UINT32) cpu.z80HL >> 8);
16507 }
16508
16509 break;
16510 }
16511 case 0xe6:
16512 {
16513 sdwCyclesRemaining -= 7;
16514 cpu.z80A &= *pbPC++;
16515 cpu.z80F &= ~(Z80_FLAG_CARRY | Z80_FLAG_NEGATIVE | Z80_FLAG_OVERFLOW_PARITY | Z80_FLAG_HALF_CARRY | Z80_FLAG_ZERO | Z80_FLAG_SIGN);
16516 cpu.z80F |= bPostANDFlags[cpu.z80A];
16517
16518 break;
16519 }
16520 case 0xe7:
16521 {
16522 sdwCyclesRemaining -= 11;
16523 cpu.z80pc = (UINT32) pbPC - (UINT32) cpu.z80Base;
16524 pbSP = (cpu.z80Base + cpu.z80sp - 1); /* Normalize the stack pointer */
16525 *pbSP-- = cpu.z80pc >> 8; /* LSB */
16526 *pbSP = (UINT8) cpu.z80pc; /* MSB */
16527 cpu.z80sp -= 2; /* Back our stack up */
16528 pbPC = cpu.z80Base + 0x20; /* Normalize the address */
16529 break;
16530 }
16531 case 0xe8:
16532 {
16533 sdwCyclesRemaining -= 5;
16534 if (cpu.z80F & Z80_FLAG_OVERFLOW_PARITY)
16535 {
16536 dwElapsedTicks += 6;
16537 pbSP = cpu.z80Base + cpu.z80sp; /* Normalize our stack PTR */
16538 dwAddr = *pbSP++; /* Pop LSB */
16539 dwAddr |= ((UINT32) *pbSP << 8); /* Pop MSB */
16540 cpu.z80sp += 2; /* Pop the word off */
16541 pbPC = (cpu.z80Base + dwAddr); /* Point PC to our return address */
16542 }
16543 break;
16544 }
16545 case 0xe9:
16546 {
16547 sdwCyclesRemaining -= 4;
16548 pbPC = cpu.z80Base + cpu.z80HL;
16549 break;
16550 }
16551 case 0xea:
16552 {
16553 sdwCyclesRemaining -= 10;
16554 dwAddr = *pbPC++; /* Get LSB first */
16555 dwAddr |= ((UINT32) *pbPC++ << 8); /* Get MSB last */
16556 if (cpu.z80F & Z80_FLAG_OVERFLOW_PARITY)
16557 {
16558 pbPC = cpu.z80Base + dwAddr; /* Normalize the address */
16559 }
16560 break;
16561 }
16562 case 0xeb:
16563 {
16564 sdwCyclesRemaining -= 4;
16565 dwAddr = cpu.z80DE;
16566 cpu.z80DE = cpu.z80HL;
16567 cpu.z80HL = dwAddr;
16568 break;
16569 }
16570 case 0xec:
16571 {
16572 sdwCyclesRemaining -= 10;
16573 dwAddr = *pbPC++; /* Get LSB first */
16574 dwAddr |= ((UINT32) *pbPC++ << 8); /* Get MSB last */
16575 if (cpu.z80F & Z80_FLAG_OVERFLOW_PARITY)
16576 {
16577 cpu.z80pc = (UINT32) pbPC - (UINT32) cpu.z80Base;
16578 pbSP = (cpu.z80Base + cpu.z80sp - 1); /* Normalize the stack pointer */
16579 *pbSP-- = cpu.z80pc >> 8; /* MSB */
16580 *pbSP = (UINT8) cpu.z80pc; /* LSB */
16581 cpu.z80sp -= 2; /* Back our stack up */
16582 pbPC = cpu.z80Base + dwAddr; /* Normalize the address */
16583 }
16584 break;
16585 }
16586 case 0xed:
16587 {
16588 EDHandler();
16589 break;
16590 }
16591 case 0xee:
16592 {
16593 sdwCyclesRemaining -= 7;
16594 cpu.z80A ^= *pbPC++;
16595 cpu.z80F &= ~(Z80_FLAG_CARRY | Z80_FLAG_NEGATIVE | Z80_FLAG_OVERFLOW_PARITY | Z80_FLAG_HALF_CARRY | Z80_FLAG_ZERO | Z80_FLAG_SIGN);
16596 cpu.z80F |= bPostORFlags[cpu.z80A];
16597
16598 break;
16599 }
16600 case 0xef:
16601 {
16602 sdwCyclesRemaining -= 11;
16603 cpu.z80pc = (UINT32) pbPC - (UINT32) cpu.z80Base;
16604 pbSP = (cpu.z80Base + cpu.z80sp - 1); /* Normalize the stack pointer */
16605 *pbSP-- = cpu.z80pc >> 8; /* LSB */
16606 *pbSP = (UINT8) cpu.z80pc; /* MSB */
16607 cpu.z80sp -= 2; /* Back our stack up */
16608 pbPC = cpu.z80Base + 0x28; /* Normalize the address */
16609 break;
16610 }
16611 case 0xf0:
16612 {
16613 sdwCyclesRemaining -= 5;
16614 if (!(cpu.z80F & Z80_FLAG_SIGN))
16615 {
16616 dwElapsedTicks += 6;
16617 pbSP = cpu.z80Base + cpu.z80sp; /* Normalize our stack PTR */
16618 dwAddr = *pbSP++; /* Pop LSB */
16619 dwAddr |= ((UINT32) *pbSP << 8); /* Pop MSB */
16620 cpu.z80sp += 2; /* Pop the word off */
16621 pbPC = (cpu.z80Base + dwAddr); /* Point PC to our return address */
16622 }
16623 break;
16624 }
16625 case 0xf1:
16626 {
16627 sdwCyclesRemaining -= 10;
16628 psMemRead = cpu.z80MemRead; /* Beginning of our handler */
16629 while (psMemRead->lowAddr != 0xffffffff)
16630 {
16631 if ((cpu.z80sp >= psMemRead->lowAddr) && (cpu.z80sp <= psMemRead->highAddr))
16632 {
16633 cpu.z80pc = (UINT32) pbPC - (UINT32) cpu.z80Base;
16634 if (psMemRead->memoryCall)
16635 {
16636 cpu.z80AF = psMemRead->memoryCall(cpu.z80sp, psMemRead);
16637 cpu.z80AF |= (UINT32) ((UINT32) psMemRead->memoryCall(cpu.z80sp + 1, psMemRead) << 8);
16638 }
16639 else
16640 {
16641 cpu.z80AF = *((UINT8 *) psMemRead->pUserArea + (cpu.z80sp - psMemRead->lowAddr));
16642 cpu.z80AF |= (UINT32) ((UINT32) *((UINT8 *) psMemRead->pUserArea + (cpu.z80sp - psMemRead->lowAddr + 1)) << 8);
16643 }
16644 psMemRead = NULL;
16645 break;
16646 }
16647 ++psMemRead;
16648 }
16649
16650 if (psMemRead)
16651 {
16652 cpu.z80AF = cpu.z80Base[cpu.z80sp];
16653 cpu.z80AF |= (UINT32) ((UINT32) cpu.z80Base[cpu.z80sp + 1] << 8);
16654 }
16655
16656 cpu.z80sp += 2;
16657 pbSP = (cpu.z80Base + cpu.z80sp); /* Normalize the stack pointer */
16658 break;
16659 }
16660 case 0xf2:
16661 {
16662 sdwCyclesRemaining -= 10;
16663 dwAddr = *pbPC++; /* Get LSB first */
16664 dwAddr |= ((UINT32) *pbPC++ << 8); /* Get MSB last */
16665 if (!(cpu.z80F & Z80_FLAG_SIGN))
16666 {
16667 pbPC = cpu.z80Base + dwAddr; /* Normalize the address */
16668 }
16669 break;
16670 }
16671 case 0xf3:
16672 {
16673 sdwCyclesRemaining -= 4;
16674 cpu.z80iff &= (~IFF1);
16675 break;
16676 }
16677 case 0xf4:
16678 {
16679 sdwCyclesRemaining -= 10;
16680 dwAddr = *pbPC++; /* Get LSB first */
16681 dwAddr |= ((UINT32) *pbPC++ << 8); /* Get MSB last */
16682 if (!(cpu.z80F & Z80_FLAG_SIGN))
16683 {
16684 cpu.z80pc = (UINT32) pbPC - (UINT32) cpu.z80Base;
16685 pbSP = (cpu.z80Base + cpu.z80sp - 1); /* Normalize the stack pointer */
16686 *pbSP-- = cpu.z80pc >> 8; /* MSB */
16687 *pbSP = (UINT8) cpu.z80pc; /* LSB */
16688 cpu.z80sp -= 2; /* Back our stack up */
16689 pbPC = cpu.z80Base + dwAddr; /* Normalize the address */
16690 }
16691 break;
16692 }
16693 case 0xf5:
16694 {
16695 sdwCyclesRemaining -= 11;
16696 cpu.z80sp -= 2;
16697 pbSP = (cpu.z80Base + cpu.z80sp); /* Normalize the stack pointer */
16698 psMemWrite = cpu.z80MemWrite; /* Beginning of our handler */
16699 while (psMemWrite->lowAddr != 0xffffffff)
16700 {
16701 if ((cpu.z80sp >= psMemWrite->lowAddr) && (cpu.z80sp <= psMemWrite->highAddr))
16702 {
16703 cpu.z80pc = (UINT32) pbPC - (UINT32) cpu.z80Base;
16704 if (psMemWrite->memoryCall)
16705 {
16706 psMemWrite->memoryCall(cpu.z80sp, (cpu.z80AF & 0xff), psMemWrite);
16707 psMemWrite->memoryCall(cpu.z80sp + 1, (cpu.z80AF >> 8), psMemWrite);
16708 }
16709 else
16710 {
16711 *((UINT8 *) psMemWrite->pUserArea + (cpu.z80sp - psMemWrite->lowAddr)) = cpu.z80AF;
16712 *((UINT8 *) psMemWrite->pUserArea + (cpu.z80sp - psMemWrite->lowAddr) + 1) = cpu.z80AF >> 8;
16713 }
16714 psMemWrite = NULL;
16715 break;
16716 }
16717 ++psMemWrite;
16718 }
16719
16720 if (psMemWrite)
16721 {
16722 cpu.z80Base[cpu.z80sp] = (UINT8) cpu.z80AF;
16723 cpu.z80Base[cpu.z80sp + 1] = (UINT8) ((UINT32) cpu.z80AF >> 8);
16724 }
16725
16726 break;
16727 }
16728 case 0xf6:
16729 {
16730 sdwCyclesRemaining -= 7;
16731 cpu.z80A |= *pbPC++;
16732 cpu.z80F &= ~(Z80_FLAG_CARRY | Z80_FLAG_NEGATIVE | Z80_FLAG_OVERFLOW_PARITY | Z80_FLAG_HALF_CARRY | Z80_FLAG_ZERO | Z80_FLAG_SIGN);
16733 cpu.z80F |= bPostORFlags[cpu.z80A];
16734
16735 break;
16736 }
16737 case 0xf7:
16738 {
16739 sdwCyclesRemaining -= 11;
16740 cpu.z80pc = (UINT32) pbPC - (UINT32) cpu.z80Base;
16741 pbSP = (cpu.z80Base + cpu.z80sp - 1); /* Normalize the stack pointer */
16742 *pbSP-- = cpu.z80pc >> 8; /* LSB */
16743 *pbSP = (UINT8) cpu.z80pc; /* MSB */
16744 cpu.z80sp -= 2; /* Back our stack up */
16745 pbPC = cpu.z80Base + 0x30; /* Normalize the address */
16746 break;
16747 }
16748 case 0xf8:
16749 {
16750 sdwCyclesRemaining -= 5;
16751 if (cpu.z80F & Z80_FLAG_SIGN)
16752 {
16753 dwElapsedTicks += 6;
16754 pbSP = cpu.z80Base + cpu.z80sp; /* Normalize our stack PTR */
16755 dwAddr = *pbSP++; /* Pop LSB */
16756 dwAddr |= ((UINT32) *pbSP << 8); /* Pop MSB */
16757 cpu.z80sp += 2; /* Pop the word off */
16758 pbPC = (cpu.z80Base + dwAddr); /* Point PC to our return address */
16759 }
16760 break;
16761 }
16762 case 0xf9:
16763 {
16764 sdwCyclesRemaining -= 6;
16765 cpu.z80sp = cpu.z80HL;
16766 break;
16767 }
16768 case 0xfa:
16769 {
16770 sdwCyclesRemaining -= 10;
16771 dwAddr = *pbPC++; /* Get LSB first */
16772 dwAddr |= ((UINT32) *pbPC++ << 8); /* Get MSB last */
16773 if (cpu.z80F & Z80_FLAG_SIGN)
16774 {
16775 pbPC = cpu.z80Base + dwAddr; /* Normalize the address */
16776 }
16777 break;
16778 }
16779 case 0xfb:
16780 {
16781 sdwCyclesRemaining -= 4;
16782 cpu.z80iff |= IFF1;
16783 break;
16784 }
16785 case 0xfc:
16786 {
16787 sdwCyclesRemaining -= 10;
16788 dwAddr = *pbPC++; /* Get LSB first */
16789 dwAddr |= ((UINT32) *pbPC++ << 8); /* Get MSB last */
16790 if (cpu.z80F & Z80_FLAG_SIGN)
16791 {
16792 cpu.z80pc = (UINT32) pbPC - (UINT32) cpu.z80Base;
16793 pbSP = (cpu.z80Base + cpu.z80sp - 1); /* Normalize the stack pointer */
16794 *pbSP-- = cpu.z80pc >> 8; /* MSB */
16795 *pbSP = (UINT8) cpu.z80pc; /* LSB */
16796 cpu.z80sp -= 2; /* Back our stack up */
16797 pbPC = cpu.z80Base + dwAddr; /* Normalize the address */
16798 }
16799 break;
16800 }
16801 case 0xfd:
16802 {
16803 FDHandler();
16804 break;
16805 }
16806 case 0xfe:
16807 {
16808 sdwCyclesRemaining -= 7;
16809 cpu.z80F = (cpu.z80F & ~(Z80_FLAG_CARRY | Z80_FLAG_NEGATIVE | Z80_FLAG_OVERFLOW_PARITY |
16810 Z80_FLAG_HALF_CARRY | Z80_FLAG_ZERO | Z80_FLAG_SIGN)) |
16811 pbSubSbcTable[((UINT32) cpu.z80A << 8) | *pbPC++];
16812 break;
16813 }
16814 case 0xff:
16815 {
16816 sdwCyclesRemaining -= 11;
16817 cpu.z80pc = (UINT32) pbPC - (UINT32) cpu.z80Base;
16818 pbSP = (cpu.z80Base + cpu.z80sp - 1); /* Normalize the stack pointer */
16819 *pbSP-- = cpu.z80pc >> 8; /* LSB */
16820 *pbSP = (UINT8) cpu.z80pc; /* MSB */
16821 cpu.z80sp -= 2; /* Back our stack up */
16822 pbPC = cpu.z80Base + 0x38; /* Normalize the address */
16823 break;
16824 }
16825 }
16826 }
16827
16828 dwElapsedTicks += (dwOriginalCycles - sdwCyclesRemaining);
16829
16830 cpu.z80pc = (UINT32) pbPC - (UINT32) cpu.z80Base;
16831 return(dwReturnCode); /* Indicate success */
16832}
16833
16834/* Get mz80's context */
16835
16836void mz80GetContext(void *pData)
16837{
16838 memcpy(pData, &cpu, sizeof(CONTEXTMZ80));
16839}
16840
16841/* Set mz80's context */
16842
16843void mz80SetContext(void *pData)
16844{
16845 memcpy(&cpu, pData, sizeof(CONTEXTMZ80));
16846}
16847
16848/* Get mz80's context size */
16849
16850UINT32 mz80GetContextSize(void)
16851{
16852 return(sizeof(CONTEXTMZ80));
16853}
16854
16855/* This will return the elapsed ticks */
16856
16857UINT32 mz80GetElapsedTicks(UINT32 dwClear)
16858{
16859 UINT32 dwTemp = dwElapsedTicks;
16860
16861 if (dwClear)
16862 {
16863 dwElapsedTicks = 0;
16864 }
16865
16866 return(dwTemp);
16867}
16868
16869/* Releases mz80 from its current timeslice */
16870
16871void mz80ReleaseTimeslice(void)
16872{
16873 dwOriginalCycles -= sdwCyclesRemaining;
16874 sdwCyclesRemaining = 0;
16875}
16876
16877/* This routine is mz80's reset handler */
16878
16879void mz80reset(void)
16880{
16881 cpu.z80halted = 0;
16882 cpu.z80AF = 0;
16883 cpu.z80F = Z80_FLAG_ZERO;
16884 cpu.z80BC = 0;
16885 cpu.z80DE = 0;
16886 cpu.z80HL = 0;
16887 cpu.z80afprime = 0;
16888 cpu.z80bcprime = 0;
16889 cpu.z80deprime = 0;
16890 cpu.z80hlprime = 0;
16891 cpu.z80i = 0;
16892 cpu.z80r = 0;
16893 cpu.z80IX = 0xffff; /* Yes, this is intentional */
16894 cpu.z80IY = 0xffff; /* Yes, this is intentional */
16895 cpu.z80pc = 0;
16896 cpu.z80sp = 0;
16897 cpu.z80interruptMode = 0;
16898 cpu.z80intAddr = 0x38;
16899 cpu.z80nmiAddr = 0x66;
16900}
16901
16902/* Interrupt handler */
16903
16904UINT32 mz80int(UINT32 dwLowAddr)
16905{
16906 cpu.z80halted = 0;
16907 if (0 == (cpu.z80iff & IFF1))
16908 return(0xffffffff);
16909 cpu.z80iff &= ~(IFF1 | IFF2);
16910 pbSP = (cpu.z80Base + cpu.z80sp - 1); /* Normalize the stack pointer */
16911 *pbSP-- = cpu.z80pc >> 8; /* LSB */
16912 *pbSP = (UINT8) cpu.z80pc; /* MSB */
16913 cpu.z80sp -= 2; /* Back our stack up */
16914 if (2 == cpu.z80interruptMode)
16915 {
16916 cpu.z80pc = ((UINT16) cpu.z80i << 8) | (dwLowAddr & 0xff);
16917 cpu.z80pc = ((UINT16) cpu.z80Base[cpu.z80pc + 1] << 8) | (cpu.z80Base[cpu.z80pc]);
16918 }
16919 else
16920 {
16921 cpu.z80pc = cpu.z80intAddr;
16922 }
16923 pbPC = cpu.z80Base + cpu.z80pc; /* Normalize the address */
16924 return(0);
16925}
16926
16927/* NMI Handler */
16928
16929UINT32 mz80nmi(void)
16930{
16931 cpu.z80halted = 0;
16932 pbSP = (cpu.z80Base + cpu.z80sp - 1); /* Normalize the stack pointer */
16933 *pbSP-- = cpu.z80pc >> 8; /* LSB */
16934 *pbSP = (UINT8) cpu.z80pc; /* MSB */
16935 cpu.z80sp -= 2; /* Back our stack up */
16936 cpu.z80pc = cpu.z80nmiAddr; /* Our NMI */
16937 return(0);
16938}
16939
16940/* Initialize MZ80 for action */
16941
16942void mz80init(void)
16943{
16944 UINT32 dwLoop;
16945 UINT8 *pbTempPtr;
16946 UINT8 *pbTempPtr2;
16947 UINT8 bNewAdd;
16948 UINT8 bNewSub;
16949 UINT8 bFlag;
16950 UINT8 bLow;
16951 UINT8 bHigh;
16952 UINT8 bCarry;
16953
16954 if (NULL == pbAddAdcTable)
16955 {
16956 pbAddAdcTable = malloc(256*256*2);
16957
16958 if (NULL == pbAddAdcTable)
16959 {
16960 return;
16961 }
16962
16963 pbTempPtr = pbAddAdcTable;
16964
16965 pbSubSbcTable = malloc(256*256*2);
16966
16967 if (NULL == pbSubSbcTable)
16968 {
16969 return;
16970 }
16971
16972 pbTempPtr2 = pbSubSbcTable;
16973
16974 for (dwLoop = 0; dwLoop < (256*256*2); dwLoop++)
16975 {
16976 bLow = dwLoop & 0xff;
16977 bHigh = (dwLoop >> 8) & 0xff;
16978 bCarry = (dwLoop >> 16);
16979
16980 bFlag = 0;
16981 bNewAdd = bHigh + bLow + bCarry;
16982
16983 if (0 == bNewAdd)
16984 {
16985 bFlag |= Z80_FLAG_ZERO;
16986 }
16987 else
16988 {
16989 bFlag = bNewAdd & 0x80; /* Sign flag */
16990 }
16991
16992 if (((UINT32) bLow + (UINT32) bHigh + (UINT32) bCarry) >= 0x100)
16993 {
16994 bFlag |= Z80_FLAG_CARRY;
16995 }
16996
16997 if ( ((bLow ^ bHigh ^ 0x80) & (bLow ^ (bNewAdd & 0x80))) & 0x80)
16998 {
16999 bFlag |= Z80_FLAG_OVERFLOW_PARITY;
17000 }
17001
17002 if (((bLow & 0x0f) + (bHigh & 0x0f) + bCarry) >= 0x10)
17003 {
17004 bFlag |= Z80_FLAG_HALF_CARRY;
17005 }
17006
17007 *pbTempPtr++ = bFlag; /* Store our new flag */
17008
17009 // Now do subtract - Zero
17010
17011 bFlag = Z80_FLAG_NEGATIVE;
17012 bNewSub = bHigh - bLow - bCarry;
17013
17014 if (0 == bNewSub)
17015 {
17016 bFlag |= Z80_FLAG_ZERO;
17017 }
17018 else
17019 {
17020 bFlag |= bNewSub & 0x80; /* Sign flag */
17021 }
17022
17023 if ( ((INT32) bHigh - (INT32) bLow - (INT32) bCarry) < 0)
17024 {
17025 bFlag |= Z80_FLAG_CARRY;
17026 }
17027
17028 if ( ((INT32) (bHigh & 0xf) - (INT32) (bLow & 0x0f) - (INT32) bCarry) < 0)
17029 {
17030 bFlag |= Z80_FLAG_HALF_CARRY;
17031 }
17032
17033 if ( ((bLow ^ bHigh) & (bHigh ^ bNewSub) & 0x80) )
17034 {
17035 bFlag |= Z80_FLAG_OVERFLOW_PARITY;
17036 }
17037
17038 *pbTempPtr2++ = bFlag; /* Store our sub flag */
17039
17040 }
17041 }
17042}
17043/* Shut down MZ80 */
17044
17045void mz80shutdown(void)
17046{
17047 // notaz: why weren't these here?
17048 free(pbAddAdcTable);
17049 pbAddAdcTable = 0;
17050 free(pbSubSbcTable);
17051 pbSubSbcTable = 0;
17052}
17053