![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to z80.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Generator SEGA Genesis emulator] / generator / extra / z80-mz80-c|
Return to z80.c CVS log | Up to [Generator SEGA Genesis emulator] / generator / extra / z80-mz80-c |
1.1 ! root 1: /* Multi-Z80 32 Bit emulator */ ! 2: ! 3: /* Copyright 1996-2000 Neil Bradley, All rights reserved ! 4: * ! 5: * License agreement: ! 6: * ! 7: * (MZ80 Refers to both the assembly code emitted by makeZ80.c and makeZ80.c ! 8: * itself) ! 9: * ! 10: * MZ80 May be distributed in unmodified form to any medium. ! 11: * ! 12: * MZ80 May not be sold, or sold as a part of a commercial package without ! 13: * the express written permission of Neil Bradley ([email protected]). This ! 14: * includes shareware. ! 15: * ! 16: * Modified versions of MZ80 may not be publicly redistributed without author ! 17: * approval ([email protected]). This includes distributing via a publicly ! 18: * accessible LAN. You may make your own source modifications and distribute ! 19: * MZ80 in source or object form, but if you make modifications to MZ80 ! 20: * then it should be noted in the top as a comment in makeZ80.c. ! 21: * ! 22: * MZ80 Licensing for commercial applications is available. Please email ! 23: * [email protected] for details. ! 24: * ! 25: * Synthcom Systems, Inc, and Neil Bradley will not be held responsible for ! 26: * any damage done by the use of MZ80. It is purely "as-is". ! 27: * ! 28: * If you use MZ80 in a freeware application, credit in the following text: ! 29: * ! 30: * "Multi-Z80 CPU emulator by Neil Bradley ([email protected])" ! 31: * ! 32: * must accompany the freeware application within the application itself or ! 33: * in the documentation. ! 34: * ! 35: * Legal stuff aside: ! 36: * ! 37: * If you find problems with MZ80, please email the author so they can get ! 38: * resolved. If you find a bug and fix it, please also email the author so ! 39: * that those bug fixes can be propogated to the installed base of MZ80 ! 40: * users. If you find performance improvements or problems with MZ80, please ! 41: * email the author with your changes/suggestions and they will be rolled in ! 42: * with subsequent releases of MZ80. ! 43: * ! 44: * The whole idea of this emulator is to have the fastest available 32 bit ! 45: * Multi-Z80 emulator for the PC, giving maximum performance. ! 46: */ ! 47: ! 48: #include <stdio.h> ! 49: #include <stdlib.h> ! 50: #include <string.h> ! 51: #include "mz80.h" ! 52: UINT32 z80intAddr; ! 53: UINT32 z80pc; ! 54: ! 55: ! 56: /* Modular global variables go here*/ ! 57: ! 58: static CONTEXTMZ80 cpu; /* CPU Context */ ! 59: static UINT8 *pbPC; /* Program counter normalized */ ! 60: static UINT8 *pbSP; /* Stack pointer normalized */ ! 61: static struct MemoryReadByte *psMemRead; /* Read memory structure */ ! 62: static struct MemoryWriteByte *psMemWrite; /* Write memory structure */ ! 63: static struct z80PortRead *psIoRead; /* Read I/O structure */ ! 64: static struct z80PortWrite *psIoWrite; /* Write memory structure */ ! 65: static INT32 sdwCyclesRemaining; /* Used as a countdown */ ! 66: static UINT32 dwReturnCode; /* Return code from exec() */ ! 67: static UINT32 dwOriginalCycles; /* How many cycles did we start with? */ ! 68: static UINT32 dwElapsedTicks; /* How many ticks did we elapse? */ ! 69: static INT32 sdwAddr; /* Temporary address storage */ ! 70: static UINT32 dwAddr; /* Temporary stack address */ ! 71: static UINT8 *pbAddAdcTable; /* Pointer to add/adc flag table */ ! 72: static UINT8 *pbSubSbcTable; /* Pointer to sub/sbc flag table */ ! 73: static UINT32 dwTemp; /* Temporary value */ ! 74: ! 75: static UINT8 bTemp; /* Temporary value */ ! 76: ! 77: static UINT8 bTemp2; /* Temporary value */ ! 78: ! 79: /* Precomputed flag tables */ ! 80: ! 81: static UINT8 bPostIncFlags[0x100] = ! 82: { ! 83: 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x10, ! 84: 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x10, ! 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,0x94, ! 91: 0x80,0x80,0x80,0x80,0x80,0x80,0x80,0x80,0x80,0x80,0x80,0x80,0x80,0x80,0x80,0x90, ! 92: 0x80,0x80,0x80,0x80,0x80,0x80,0x80,0x80,0x80,0x80,0x80,0x80,0x80,0x80,0x80,0x90, ! 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,0x50 ! 99: }; ! 100: ! 101: static UINT8 bPostDecFlags[0x100] = ! 102: { ! 103: 0x92,0x42,0x02,0x02,0x02,0x02,0x02,0x02,0x02,0x02,0x02,0x02,0x02,0x02,0x02,0x02, ! 104: 0x12,0x02,0x02,0x02,0x02,0x02,0x02,0x02,0x02,0x02,0x02,0x02,0x02,0x02,0x02,0x02, ! 105: 0x12,0x02,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: 0x16,0x82,0x82,0x82,0x82,0x82,0x82,0x82,0x82,0x82,0x82,0x82,0x82,0x82,0x82,0x82, ! 112: 0x92,0x82,0x82,0x82,0x82,0x82,0x82,0x82,0x82,0x82,0x82,0x82,0x82,0x82,0x82,0x82, ! 113: 0x92,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: }; ! 120: ! 121: static UINT8 bPostORFlags[0x100] = ! 122: { ! 123: 0x44,0x00,0x00,0x04,0x00,0x04,0x04,0x00,0x00,0x04,0x04,0x00,0x04,0x00,0x00,0x04, ! 124: 0x00,0x04,0x04,0x00,0x04,0x00,0x00,0x04,0x04,0x00,0x00,0x04,0x00,0x04,0x04,0x00, ! 125: 0x00,0x04,0x04,0x00,0x04,0x00,0x00,0x04,0x04,0x00,0x00,0x04,0x00,0x04,0x04,0x00, ! 126: 0x04,0x00,0x00,0x04,0x00,0x04,0x04,0x00,0x00,0x04,0x04,0x00,0x04,0x00,0x00,0x04, ! 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: 0x04,0x00,0x00,0x04,0x00,0x04,0x04,0x00,0x00,0x04,0x04,0x00,0x04,0x00,0x00,0x04, ! 130: 0x00,0x04,0x04,0x00,0x04,0x00,0x00,0x04,0x04,0x00,0x00,0x04,0x00,0x04,0x04,0x00, ! 131: 0x80,0x84,0x84,0x80,0x84,0x80,0x80,0x84,0x84,0x80,0x80,0x84,0x80,0x84,0x84,0x80, ! 132: 0x84,0x80,0x80,0x84,0x80,0x84,0x84,0x80,0x80,0x84,0x84,0x80,0x84,0x80,0x80,0x84, ! 133: 0x84,0x80,0x80,0x84,0x80,0x84,0x84,0x80,0x80,0x84,0x84,0x80,0x84,0x80,0x80,0x84, ! 134: 0x80,0x84,0x84,0x80,0x84,0x80,0x80,0x84,0x84,0x80,0x80,0x84,0x80,0x84,0x84,0x80, ! 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: 0x80,0x84,0x84,0x80,0x84,0x80,0x80,0x84,0x84,0x80,0x80,0x84,0x80,0x84,0x84,0x80, ! 138: 0x84,0x80,0x80,0x84,0x80,0x84,0x84,0x80,0x80,0x84,0x84,0x80,0x84,0x80,0x80,0x84 ! 139: }; ! 140: ! 141: static UINT8 bPostANDFlags[0x100] = ! 142: { ! 143: 0x54,0x10,0x10,0x14,0x10,0x14,0x14,0x10,0x10,0x14,0x14,0x10,0x14,0x10,0x10,0x14, ! 144: 0x10,0x14,0x14,0x10,0x14,0x10,0x10,0x14,0x14,0x10,0x10,0x14,0x10,0x14,0x14,0x10, ! 145: 0x10,0x14,0x14,0x10,0x14,0x10,0x10,0x14,0x14,0x10,0x10,0x14,0x10,0x14,0x14,0x10, ! 146: 0x14,0x10,0x10,0x14,0x10,0x14,0x14,0x10,0x10,0x14,0x14,0x10,0x14,0x10,0x10,0x14, ! 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: 0x14,0x10,0x10,0x14,0x10,0x14,0x14,0x10,0x10,0x14,0x14,0x10,0x14,0x10,0x10,0x14, ! 150: 0x10,0x14,0x14,0x10,0x14,0x10,0x10,0x14,0x14,0x10,0x10,0x14,0x10,0x14,0x14,0x10, ! 151: 0x90,0x94,0x94,0x90,0x94,0x90,0x90,0x94,0x94,0x90,0x90,0x94,0x90,0x94,0x94,0x90, ! 152: 0x94,0x90,0x90,0x94,0x90,0x94,0x94,0x90,0x90,0x94,0x94,0x90,0x94,0x90,0x90,0x94, ! 153: 0x94,0x90,0x90,0x94,0x90,0x94,0x94,0x90,0x90,0x94,0x94,0x90,0x94,0x90,0x90,0x94, ! 154: 0x90,0x94,0x94,0x90,0x94,0x90,0x90,0x94,0x94,0x90,0x90,0x94,0x90,0x94,0x94,0x90, ! 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: 0x90,0x94,0x94,0x90,0x94,0x90,0x90,0x94,0x94,0x90,0x90,0x94,0x90,0x94,0x94,0x90, ! 158: 0x94,0x90,0x90,0x94,0x90,0x94,0x94,0x90,0x90,0x94,0x94,0x90,0x94,0x90,0x90,0x94 ! 159: }; ! 160: ! 161: static UINT16 wDAATable[0x800] = ! 162: { ! 163: 0x5400,0x1001,0x1002,0x1403,0x1004,0x1405,0x1406,0x1007, ! 164: 0x1008,0x1409,0x1010,0x1411,0x1412,0x1013,0x1414,0x1015, ! 165: 0x1010,0x1411,0x1412,0x1013,0x1414,0x1015,0x1016,0x1417, ! 166: 0x1418,0x1019,0x1020,0x1421,0x1422,0x1023,0x1424,0x1025, ! 167: 0x1020,0x1421,0x1422,0x1023,0x1424,0x1025,0x1026,0x1427, ! 168: 0x1428,0x1029,0x1430,0x1031,0x1032,0x1433,0x1034,0x1435, ! 169: 0x1430,0x1031,0x1032,0x1433,0x1034,0x1435,0x1436,0x1037, ! 170: 0x1038,0x1439,0x1040,0x1441,0x1442,0x1043,0x1444,0x1045, ! 171: 0x1040,0x1441,0x1442,0x1043,0x1444,0x1045,0x1046,0x1447, ! 172: 0x1448,0x1049,0x1450,0x1051,0x1052,0x1453,0x1054,0x1455, ! 173: 0x1450,0x1051,0x1052,0x1453,0x1054,0x1455,0x1456,0x1057, ! 174: 0x1058,0x1459,0x1460,0x1061,0x1062,0x1463,0x1064,0x1465, ! 175: 0x1460,0x1061,0x1062,0x1463,0x1064,0x1465,0x1466,0x1067, ! 176: 0x1068,0x1469,0x1070,0x1471,0x1472,0x1073,0x1474,0x1075, ! 177: 0x1070,0x1471,0x1472,0x1073,0x1474,0x1075,0x1076,0x1477, ! 178: 0x1478,0x1079,0x9080,0x9481,0x9482,0x9083,0x9484,0x9085, ! 179: 0x9080,0x9481,0x9482,0x9083,0x9484,0x9085,0x9086,0x9487, ! 180: 0x9488,0x9089,0x9490,0x9091,0x9092,0x9493,0x9094,0x9495, ! 181: 0x9490,0x9091,0x9092,0x9493,0x9094,0x9495,0x9496,0x9097, ! 182: 0x9098,0x9499,0x5500,0x1101,0x1102,0x1503,0x1104,0x1505, ! 183: 0x5500,0x1101,0x1102,0x1503,0x1104,0x1505,0x1506,0x1107, ! 184: 0x1108,0x1509,0x1110,0x1511,0x1512,0x1113,0x1514,0x1115, ! 185: 0x1110,0x1511,0x1512,0x1113,0x1514,0x1115,0x1116,0x1517, ! 186: 0x1518,0x1119,0x1120,0x1521,0x1522,0x1123,0x1524,0x1125, ! 187: 0x1120,0x1521,0x1522,0x1123,0x1524,0x1125,0x1126,0x1527, ! 188: 0x1528,0x1129,0x1530,0x1131,0x1132,0x1533,0x1134,0x1535, ! 189: 0x1530,0x1131,0x1132,0x1533,0x1134,0x1535,0x1536,0x1137, ! 190: 0x1138,0x1539,0x1140,0x1541,0x1542,0x1143,0x1544,0x1145, ! 191: 0x1140,0x1541,0x1542,0x1143,0x1544,0x1145,0x1146,0x1547, ! 192: 0x1548,0x1149,0x1550,0x1151,0x1152,0x1553,0x1154,0x1555, ! 193: 0x1550,0x1151,0x1152,0x1553,0x1154,0x1555,0x1556,0x1157, ! 194: 0x1158,0x1559,0x1560,0x1161,0x1162,0x1563,0x1164,0x1565, ! 195: 0x1560,0x1161,0x1162,0x1563,0x1164,0x1565,0x1566,0x1167, ! 196: 0x1168,0x1569,0x1170,0x1571,0x1572,0x1173,0x1574,0x1175, ! 197: 0x1170,0x1571,0x1572,0x1173,0x1574,0x1175,0x1176,0x1577, ! 198: 0x1578,0x1179,0x9180,0x9581,0x9582,0x9183,0x9584,0x9185, ! 199: 0x9180,0x9581,0x9582,0x9183,0x9584,0x9185,0x9186,0x9587, ! 200: 0x9588,0x9189,0x9590,0x9191,0x9192,0x9593,0x9194,0x9595, ! 201: 0x9590,0x9191,0x9192,0x9593,0x9194,0x9595,0x9596,0x9197, ! 202: 0x9198,0x9599,0x95a0,0x91a1,0x91a2,0x95a3,0x91a4,0x95a5, ! 203: 0x95a0,0x91a1,0x91a2,0x95a3,0x91a4,0x95a5,0x95a6,0x91a7, ! 204: 0x91a8,0x95a9,0x91b0,0x95b1,0x95b2,0x91b3,0x95b4,0x91b5, ! 205: 0x91b0,0x95b1,0x95b2,0x91b3,0x95b4,0x91b5,0x91b6,0x95b7, ! 206: 0x95b8,0x91b9,0x95c0,0x91c1,0x91c2,0x95c3,0x91c4,0x95c5, ! 207: 0x95c0,0x91c1,0x91c2,0x95c3,0x91c4,0x95c5,0x95c6,0x91c7, ! 208: 0x91c8,0x95c9,0x91d0,0x95d1,0x95d2,0x91d3,0x95d4,0x91d5, ! 209: 0x91d0,0x95d1,0x95d2,0x91d3,0x95d4,0x91d5,0x91d6,0x95d7, ! 210: 0x95d8,0x91d9,0x91e0,0x95e1,0x95e2,0x91e3,0x95e4,0x91e5, ! 211: 0x91e0,0x95e1,0x95e2,0x91e3,0x95e4,0x91e5,0x91e6,0x95e7, ! 212: 0x95e8,0x91e9,0x95f0,0x91f1,0x91f2,0x95f3,0x91f4,0x95f5, ! 213: 0x95f0,0x91f1,0x91f2,0x95f3,0x91f4,0x95f5,0x95f6,0x91f7, ! 214: 0x91f8,0x95f9,0x5500,0x1101,0x1102,0x1503,0x1104,0x1505, ! 215: 0x5500,0x1101,0x1102,0x1503,0x1104,0x1505,0x1506,0x1107, ! 216: 0x1108,0x1509,0x1110,0x1511,0x1512,0x1113,0x1514,0x1115, ! 217: 0x1110,0x1511,0x1512,0x1113,0x1514,0x1115,0x1116,0x1517, ! 218: 0x1518,0x1119,0x1120,0x1521,0x1522,0x1123,0x1524,0x1125, ! 219: 0x1120,0x1521,0x1522,0x1123,0x1524,0x1125,0x1126,0x1527, ! 220: 0x1528,0x1129,0x1530,0x1131,0x1132,0x1533,0x1134,0x1535, ! 221: 0x1530,0x1131,0x1132,0x1533,0x1134,0x1535,0x1536,0x1137, ! 222: 0x1138,0x1539,0x1140,0x1541,0x1542,0x1143,0x1544,0x1145, ! 223: 0x1140,0x1541,0x1542,0x1143,0x1544,0x1145,0x1146,0x1547, ! 224: 0x1548,0x1149,0x1550,0x1151,0x1152,0x1553,0x1154,0x1555, ! 225: 0x1550,0x1151,0x1152,0x1553,0x1154,0x1555,0x1556,0x1157, ! 226: 0x1158,0x1559,0x1560,0x1161,0x1162,0x1563,0x1164,0x1565, ! 227: 0x1406,0x1007,0x1008,0x1409,0x140a,0x100b,0x140c,0x100d, ! 228: 0x100e,0x140f,0x1010,0x1411,0x1412,0x1013,0x1414,0x1015, ! 229: 0x1016,0x1417,0x1418,0x1019,0x101a,0x141b,0x101c,0x141d, ! 230: 0x141e,0x101f,0x1020,0x1421,0x1422,0x1023,0x1424,0x1025, ! 231: 0x1026,0x1427,0x1428,0x1029,0x102a,0x142b,0x102c,0x142d, ! 232: 0x142e,0x102f,0x1430,0x1031,0x1032,0x1433,0x1034,0x1435, ! 233: 0x1436,0x1037,0x1038,0x1439,0x143a,0x103b,0x143c,0x103d, ! 234: 0x103e,0x143f,0x1040,0x1441,0x1442,0x1043,0x1444,0x1045, ! 235: 0x1046,0x1447,0x1448,0x1049,0x104a,0x144b,0x104c,0x144d, ! 236: 0x144e,0x104f,0x1450,0x1051,0x1052,0x1453,0x1054,0x1455, ! 237: 0x1456,0x1057,0x1058,0x1459,0x145a,0x105b,0x145c,0x105d, ! 238: 0x105e,0x145f,0x1460,0x1061,0x1062,0x1463,0x1064,0x1465, ! 239: 0x1466,0x1067,0x1068,0x1469,0x146a,0x106b,0x146c,0x106d, ! 240: 0x106e,0x146f,0x1070,0x1471,0x1472,0x1073,0x1474,0x1075, ! 241: 0x1076,0x1477,0x1478,0x1079,0x107a,0x147b,0x107c,0x147d, ! 242: 0x147e,0x107f,0x9080,0x9481,0x9482,0x9083,0x9484,0x9085, ! 243: 0x9086,0x9487,0x9488,0x9089,0x908a,0x948b,0x908c,0x948d, ! 244: 0x948e,0x908f,0x9490,0x9091,0x9092,0x9493,0x9094,0x9495, ! 245: 0x9496,0x9097,0x9098,0x9499,0x949a,0x909b,0x949c,0x909d, ! 246: 0x909e,0x949f,0x5500,0x1101,0x1102,0x1503,0x1104,0x1505, ! 247: 0x1506,0x1107,0x1108,0x1509,0x150a,0x110b,0x150c,0x110d, ! 248: 0x110e,0x150f,0x1110,0x1511,0x1512,0x1113,0x1514,0x1115, ! 249: 0x1116,0x1517,0x1518,0x1119,0x111a,0x151b,0x111c,0x151d, ! 250: 0x151e,0x111f,0x1120,0x1521,0x1522,0x1123,0x1524,0x1125, ! 251: 0x1126,0x1527,0x1528,0x1129,0x112a,0x152b,0x112c,0x152d, ! 252: 0x152e,0x112f,0x1530,0x1131,0x1132,0x1533,0x1134,0x1535, ! 253: 0x1536,0x1137,0x1138,0x1539,0x153a,0x113b,0x153c,0x113d, ! 254: 0x113e,0x153f,0x1140,0x1541,0x1542,0x1143,0x1544,0x1145, ! 255: 0x1146,0x1547,0x1548,0x1149,0x114a,0x154b,0x114c,0x154d, ! 256: 0x154e,0x114f,0x1550,0x1151,0x1152,0x1553,0x1154,0x1555, ! 257: 0x1556,0x1157,0x1158,0x1559,0x155a,0x115b,0x155c,0x115d, ! 258: 0x115e,0x155f,0x1560,0x1161,0x1162,0x1563,0x1164,0x1565, ! 259: 0x1566,0x1167,0x1168,0x1569,0x156a,0x116b,0x156c,0x116d, ! 260: 0x116e,0x156f,0x1170,0x1571,0x1572,0x1173,0x1574,0x1175, ! 261: 0x1176,0x1577,0x1578,0x1179,0x117a,0x157b,0x117c,0x157d, ! 262: 0x157e,0x117f,0x9180,0x9581,0x9582,0x9183,0x9584,0x9185, ! 263: 0x9186,0x9587,0x9588,0x9189,0x918a,0x958b,0x918c,0x958d, ! 264: 0x958e,0x918f,0x9590,0x9191,0x9192,0x9593,0x9194,0x9595, ! 265: 0x9596,0x9197,0x9198,0x9599,0x959a,0x919b,0x959c,0x919d, ! 266: 0x919e,0x959f,0x95a0,0x91a1,0x91a2,0x95a3,0x91a4,0x95a5, ! 267: 0x95a6,0x91a7,0x91a8,0x95a9,0x95aa,0x91ab,0x95ac,0x91ad, ! 268: 0x91ae,0x95af,0x91b0,0x95b1,0x95b2,0x91b3,0x95b4,0x91b5, ! 269: 0x91b6,0x95b7,0x95b8,0x91b9,0x91ba,0x95bb,0x91bc,0x95bd, ! 270: 0x95be,0x91bf,0x95c0,0x91c1,0x91c2,0x95c3,0x91c4,0x95c5, ! 271: 0x95c6,0x91c7,0x91c8,0x95c9,0x95ca,0x91cb,0x95cc,0x91cd, ! 272: 0x91ce,0x95cf,0x91d0,0x95d1,0x95d2,0x91d3,0x95d4,0x91d5, ! 273: 0x91d6,0x95d7,0x95d8,0x91d9,0x91da,0x95db,0x91dc,0x95dd, ! 274: 0x95de,0x91df,0x91e0,0x95e1,0x95e2,0x91e3,0x95e4,0x91e5, ! 275: 0x91e6,0x95e7,0x95e8,0x91e9,0x91ea,0x95eb,0x91ec,0x95ed, ! 276: 0x95ee,0x91ef,0x95f0,0x91f1,0x91f2,0x95f3,0x91f4,0x95f5, ! 277: 0x95f6,0x91f7,0x91f8,0x95f9,0x95fa,0x91fb,0x95fc,0x91fd, ! 278: 0x91fe,0x95ff,0x5500,0x1101,0x1102,0x1503,0x1104,0x1505, ! 279: 0x1506,0x1107,0x1108,0x1509,0x150a,0x110b,0x150c,0x110d, ! 280: 0x110e,0x150f,0x1110,0x1511,0x1512,0x1113,0x1514,0x1115, ! 281: 0x1116,0x1517,0x1518,0x1119,0x111a,0x151b,0x111c,0x151d, ! 282: 0x151e,0x111f,0x1120,0x1521,0x1522,0x1123,0x1524,0x1125, ! 283: 0x1126,0x1527,0x1528,0x1129,0x112a,0x152b,0x112c,0x152d, ! 284: 0x152e,0x112f,0x1530,0x1131,0x1132,0x1533,0x1134,0x1535, ! 285: 0x1536,0x1137,0x1138,0x1539,0x153a,0x113b,0x153c,0x113d, ! 286: 0x113e,0x153f,0x1140,0x1541,0x1542,0x1143,0x1544,0x1145, ! 287: 0x1146,0x1547,0x1548,0x1149,0x114a,0x154b,0x114c,0x154d, ! 288: 0x154e,0x114f,0x1550,0x1151,0x1152,0x1553,0x1154,0x1555, ! 289: 0x1556,0x1157,0x1158,0x1559,0x155a,0x115b,0x155c,0x115d, ! 290: 0x115e,0x155f,0x1560,0x1161,0x1162,0x1563,0x1164,0x1565, ! 291: 0x5600,0x1201,0x1202,0x1603,0x1204,0x1605,0x1606,0x1207, ! 292: 0x1208,0x1609,0x1204,0x1605,0x1606,0x1207,0x1208,0x1609, ! 293: 0x1210,0x1611,0x1612,0x1213,0x1614,0x1215,0x1216,0x1617, ! 294: 0x1618,0x1219,0x1614,0x1215,0x1216,0x1617,0x1618,0x1219, ! 295: 0x1220,0x1621,0x1622,0x1223,0x1624,0x1225,0x1226,0x1627, ! 296: 0x1628,0x1229,0x1624,0x1225,0x1226,0x1627,0x1628,0x1229, ! 297: 0x1630,0x1231,0x1232,0x1633,0x1234,0x1635,0x1636,0x1237, ! 298: 0x1238,0x1639,0x1234,0x1635,0x1636,0x1237,0x1238,0x1639, ! 299: 0x1240,0x1641,0x1642,0x1243,0x1644,0x1245,0x1246,0x1647, ! 300: 0x1648,0x1249,0x1644,0x1245,0x1246,0x1647,0x1648,0x1249, ! 301: 0x1650,0x1251,0x1252,0x1653,0x1254,0x1655,0x1656,0x1257, ! 302: 0x1258,0x1659,0x1254,0x1655,0x1656,0x1257,0x1258,0x1659, ! 303: 0x1660,0x1261,0x1262,0x1663,0x1264,0x1665,0x1666,0x1267, ! 304: 0x1268,0x1669,0x1264,0x1665,0x1666,0x1267,0x1268,0x1669, ! 305: 0x1270,0x1671,0x1672,0x1273,0x1674,0x1275,0x1276,0x1677, ! 306: 0x1678,0x1279,0x1674,0x1275,0x1276,0x1677,0x1678,0x1279, ! 307: 0x9280,0x9681,0x9682,0x9283,0x9684,0x9285,0x9286,0x9687, ! 308: 0x9688,0x9289,0x9684,0x9285,0x9286,0x9687,0x9688,0x9289, ! 309: 0x9690,0x9291,0x9292,0x9693,0x9294,0x9695,0x9696,0x9297, ! 310: 0x9298,0x9699,0x1334,0x1735,0x1736,0x1337,0x1338,0x1739, ! 311: 0x1340,0x1741,0x1742,0x1343,0x1744,0x1345,0x1346,0x1747, ! 312: 0x1748,0x1349,0x1744,0x1345,0x1346,0x1747,0x1748,0x1349, ! 313: 0x1750,0x1351,0x1352,0x1753,0x1354,0x1755,0x1756,0x1357, ! 314: 0x1358,0x1759,0x1354,0x1755,0x1756,0x1357,0x1358,0x1759, ! 315: 0x1760,0x1361,0x1362,0x1763,0x1364,0x1765,0x1766,0x1367, ! 316: 0x1368,0x1769,0x1364,0x1765,0x1766,0x1367,0x1368,0x1769, ! 317: 0x1370,0x1771,0x1772,0x1373,0x1774,0x1375,0x1376,0x1777, ! 318: 0x1778,0x1379,0x1774,0x1375,0x1376,0x1777,0x1778,0x1379, ! 319: 0x9380,0x9781,0x9782,0x9383,0x9784,0x9385,0x9386,0x9787, ! 320: 0x9788,0x9389,0x9784,0x9385,0x9386,0x9787,0x9788,0x9389, ! 321: 0x9790,0x9391,0x9392,0x9793,0x9394,0x9795,0x9796,0x9397, ! 322: 0x9398,0x9799,0x9394,0x9795,0x9796,0x9397,0x9398,0x9799, ! 323: 0x97a0,0x93a1,0x93a2,0x97a3,0x93a4,0x97a5,0x97a6,0x93a7, ! 324: 0x93a8,0x97a9,0x93a4,0x97a5,0x97a6,0x93a7,0x93a8,0x97a9, ! 325: 0x93b0,0x97b1,0x97b2,0x93b3,0x97b4,0x93b5,0x93b6,0x97b7, ! 326: 0x97b8,0x93b9,0x97b4,0x93b5,0x93b6,0x97b7,0x97b8,0x93b9, ! 327: 0x97c0,0x93c1,0x93c2,0x97c3,0x93c4,0x97c5,0x97c6,0x93c7, ! 328: 0x93c8,0x97c9,0x93c4,0x97c5,0x97c6,0x93c7,0x93c8,0x97c9, ! 329: 0x93d0,0x97d1,0x97d2,0x93d3,0x97d4,0x93d5,0x93d6,0x97d7, ! 330: 0x97d8,0x93d9,0x97d4,0x93d5,0x93d6,0x97d7,0x97d8,0x93d9, ! 331: 0x93e0,0x97e1,0x97e2,0x93e3,0x97e4,0x93e5,0x93e6,0x97e7, ! 332: 0x97e8,0x93e9,0x97e4,0x93e5,0x93e6,0x97e7,0x97e8,0x93e9, ! 333: 0x97f0,0x93f1,0x93f2,0x97f3,0x93f4,0x97f5,0x97f6,0x93f7, ! 334: 0x93f8,0x97f9,0x93f4,0x97f5,0x97f6,0x93f7,0x93f8,0x97f9, ! 335: 0x5700,0x1301,0x1302,0x1703,0x1304,0x1705,0x1706,0x1307, ! 336: 0x1308,0x1709,0x1304,0x1705,0x1706,0x1307,0x1308,0x1709, ! 337: 0x1310,0x1711,0x1712,0x1313,0x1714,0x1315,0x1316,0x1717, ! 338: 0x1718,0x1319,0x1714,0x1315,0x1316,0x1717,0x1718,0x1319, ! 339: 0x1320,0x1721,0x1722,0x1323,0x1724,0x1325,0x1326,0x1727, ! 340: 0x1728,0x1329,0x1724,0x1325,0x1326,0x1727,0x1728,0x1329, ! 341: 0x1730,0x1331,0x1332,0x1733,0x1334,0x1735,0x1736,0x1337, ! 342: 0x1338,0x1739,0x1334,0x1735,0x1736,0x1337,0x1338,0x1739, ! 343: 0x1340,0x1741,0x1742,0x1343,0x1744,0x1345,0x1346,0x1747, ! 344: 0x1748,0x1349,0x1744,0x1345,0x1346,0x1747,0x1748,0x1349, ! 345: 0x1750,0x1351,0x1352,0x1753,0x1354,0x1755,0x1756,0x1357, ! 346: 0x1358,0x1759,0x1354,0x1755,0x1756,0x1357,0x1358,0x1759, ! 347: 0x1760,0x1361,0x1362,0x1763,0x1364,0x1765,0x1766,0x1367, ! 348: 0x1368,0x1769,0x1364,0x1765,0x1766,0x1367,0x1368,0x1769, ! 349: 0x1370,0x1771,0x1772,0x1373,0x1774,0x1375,0x1376,0x1777, ! 350: 0x1778,0x1379,0x1774,0x1375,0x1376,0x1777,0x1778,0x1379, ! 351: 0x9380,0x9781,0x9782,0x9383,0x9784,0x9385,0x9386,0x9787, ! 352: 0x9788,0x9389,0x9784,0x9385,0x9386,0x9787,0x9788,0x9389, ! 353: 0x9790,0x9391,0x9392,0x9793,0x9394,0x9795,0x9796,0x9397, ! 354: 0x9398,0x9799,0x9394,0x9795,0x9796,0x9397,0x9398,0x9799, ! 355: 0x97fa,0x93fb,0x97fc,0x93fd,0x93fe,0x97ff,0x5600,0x1201, ! 356: 0x1202,0x1603,0x1204,0x1605,0x1606,0x1207,0x1208,0x1609, ! 357: 0x160a,0x120b,0x160c,0x120d,0x120e,0x160f,0x1210,0x1611, ! 358: 0x1612,0x1213,0x1614,0x1215,0x1216,0x1617,0x1618,0x1219, ! 359: 0x121a,0x161b,0x121c,0x161d,0x161e,0x121f,0x1220,0x1621, ! 360: 0x1622,0x1223,0x1624,0x1225,0x1226,0x1627,0x1628,0x1229, ! 361: 0x122a,0x162b,0x122c,0x162d,0x162e,0x122f,0x1630,0x1231, ! 362: 0x1232,0x1633,0x1234,0x1635,0x1636,0x1237,0x1238,0x1639, ! 363: 0x163a,0x123b,0x163c,0x123d,0x123e,0x163f,0x1240,0x1641, ! 364: 0x1642,0x1243,0x1644,0x1245,0x1246,0x1647,0x1648,0x1249, ! 365: 0x124a,0x164b,0x124c,0x164d,0x164e,0x124f,0x1650,0x1251, ! 366: 0x1252,0x1653,0x1254,0x1655,0x1656,0x1257,0x1258,0x1659, ! 367: 0x165a,0x125b,0x165c,0x125d,0x125e,0x165f,0x1660,0x1261, ! 368: 0x1262,0x1663,0x1264,0x1665,0x1666,0x1267,0x1268,0x1669, ! 369: 0x166a,0x126b,0x166c,0x126d,0x126e,0x166f,0x1270,0x1671, ! 370: 0x1672,0x1273,0x1674,0x1275,0x1276,0x1677,0x1678,0x1279, ! 371: 0x127a,0x167b,0x127c,0x167d,0x167e,0x127f,0x9280,0x9681, ! 372: 0x9682,0x9283,0x9684,0x9285,0x9286,0x9687,0x9688,0x9289, ! 373: 0x928a,0x968b,0x928c,0x968d,0x968e,0x928f,0x9690,0x9291, ! 374: 0x9292,0x9693,0x1334,0x1735,0x1736,0x1337,0x1338,0x1739, ! 375: 0x173a,0x133b,0x173c,0x133d,0x133e,0x173f,0x1340,0x1741, ! 376: 0x1742,0x1343,0x1744,0x1345,0x1346,0x1747,0x1748,0x1349, ! 377: 0x134a,0x174b,0x134c,0x174d,0x174e,0x134f,0x1750,0x1351, ! 378: 0x1352,0x1753,0x1354,0x1755,0x1756,0x1357,0x1358,0x1759, ! 379: 0x175a,0x135b,0x175c,0x135d,0x135e,0x175f,0x1760,0x1361, ! 380: 0x1362,0x1763,0x1364,0x1765,0x1766,0x1367,0x1368,0x1769, ! 381: 0x176a,0x136b,0x176c,0x136d,0x136e,0x176f,0x1370,0x1771, ! 382: 0x1772,0x1373,0x1774,0x1375,0x1376,0x1777,0x1778,0x1379, ! 383: 0x137a,0x177b,0x137c,0x177d,0x177e,0x137f,0x9380,0x9781, ! 384: 0x9782,0x9383,0x9784,0x9385,0x9386,0x9787,0x9788,0x9389, ! 385: 0x938a,0x978b,0x938c,0x978d,0x978e,0x938f,0x9790,0x9391, ! 386: 0x9392,0x9793,0x9394,0x9795,0x9796,0x9397,0x9398,0x9799, ! 387: 0x979a,0x939b,0x979c,0x939d,0x939e,0x979f,0x97a0,0x93a1, ! 388: 0x93a2,0x97a3,0x93a4,0x97a5,0x97a6,0x93a7,0x93a8,0x97a9, ! 389: 0x97aa,0x93ab,0x97ac,0x93ad,0x93ae,0x97af,0x93b0,0x97b1, ! 390: 0x97b2,0x93b3,0x97b4,0x93b5,0x93b6,0x97b7,0x97b8,0x93b9, ! 391: 0x93ba,0x97bb,0x93bc,0x97bd,0x97be,0x93bf,0x97c0,0x93c1, ! 392: 0x93c2,0x97c3,0x93c4,0x97c5,0x97c6,0x93c7,0x93c8,0x97c9, ! 393: 0x97ca,0x93cb,0x97cc,0x93cd,0x93ce,0x97cf,0x93d0,0x97d1, ! 394: 0x97d2,0x93d3,0x97d4,0x93d5,0x93d6,0x97d7,0x97d8,0x93d9, ! 395: 0x93da,0x97db,0x93dc,0x97dd,0x97de,0x93df,0x93e0,0x97e1, ! 396: 0x97e2,0x93e3,0x97e4,0x93e5,0x93e6,0x97e7,0x97e8,0x93e9, ! 397: 0x93ea,0x97eb,0x93ec,0x97ed,0x97ee,0x93ef,0x97f0,0x93f1, ! 398: 0x93f2,0x97f3,0x93f4,0x97f5,0x97f6,0x93f7,0x93f8,0x97f9, ! 399: 0x97fa,0x93fb,0x97fc,0x93fd,0x93fe,0x97ff,0x5700,0x1301, ! 400: 0x1302,0x1703,0x1304,0x1705,0x1706,0x1307,0x1308,0x1709, ! 401: 0x170a,0x130b,0x170c,0x130d,0x130e,0x170f,0x1310,0x1711, ! 402: 0x1712,0x1313,0x1714,0x1315,0x1316,0x1717,0x1718,0x1319, ! 403: 0x131a,0x171b,0x131c,0x171d,0x171e,0x131f,0x1320,0x1721, ! 404: 0x1722,0x1323,0x1724,0x1325,0x1326,0x1727,0x1728,0x1329, ! 405: 0x132a,0x172b,0x132c,0x172d,0x172e,0x132f,0x1730,0x1331, ! 406: 0x1332,0x1733,0x1334,0x1735,0x1736,0x1337,0x1338,0x1739, ! 407: 0x173a,0x133b,0x173c,0x133d,0x133e,0x173f,0x1340,0x1741, ! 408: 0x1742,0x1343,0x1744,0x1345,0x1346,0x1747,0x1748,0x1349, ! 409: 0x134a,0x174b,0x134c,0x174d,0x174e,0x134f,0x1750,0x1351, ! 410: 0x1352,0x1753,0x1354,0x1755,0x1756,0x1357,0x1358,0x1759, ! 411: 0x175a,0x135b,0x175c,0x135d,0x135e,0x175f,0x1760,0x1361, ! 412: 0x1362,0x1763,0x1364,0x1765,0x1766,0x1367,0x1368,0x1769, ! 413: 0x176a,0x136b,0x176c,0x136d,0x136e,0x176f,0x1370,0x1771, ! 414: 0x1772,0x1373,0x1774,0x1375,0x1376,0x1777,0x1778,0x1379, ! 415: 0x137a,0x177b,0x137c,0x177d,0x177e,0x137f,0x9380,0x9781, ! 416: 0x9782,0x9383,0x9784,0x9385,0x9386,0x9787,0x9788,0x9389, ! 417: 0x938a,0x978b,0x938c,0x978d,0x978e,0x938f,0x9790,0x9391, ! 418: 0x9392,0x9793,0x9394,0x9795,0x9796,0x9397,0x9398,0x9799 ! 419: }; ! 420: ! 421: void DDFDCBHandler(UINT32 dwWhich); ! 422: ! 423: ! 424: static void InvalidInstruction(UINT32 dwCount) ! 425: { ! 426: pbPC -= dwCount; /* Invalid instruction - back up */ ! 427: dwReturnCode = (UINT32) pbPC - (UINT32) cpu.z80Base; ! 428: dwOriginalCycles -= sdwCyclesRemaining; ! 429: sdwCyclesRemaining = 0; ! 430: } ! 431: ! 432: void CBHandler(void) ! 433: { ! 434: switch (*pbPC++) ! 435: { ! 436: case 0x00: ! 437: { ! 438: sdwCyclesRemaining -= 8; ! 439: cpu.z80F &= ~(Z80_FLAG_ZERO | Z80_FLAG_SIGN | Z80_FLAG_HALF_CARRY | Z80_FLAG_OVERFLOW_PARITY | Z80_FLAG_NEGATIVE | Z80_FLAG_CARRY); ! 440: bTemp2 = (cpu.z80B >> 7); ! 441: cpu.z80B = (cpu.z80B << 1) | bTemp2; ! 442: cpu.z80F |= bTemp2 | bPostORFlags[cpu.z80B]; ! 443: break; ! 444: } ! 445: case 0x01: ! 446: { ! 447: sdwCyclesRemaining -= 8; ! 448: cpu.z80F &= ~(Z80_FLAG_ZERO | Z80_FLAG_SIGN | Z80_FLAG_HALF_CARRY | Z80_FLAG_OVERFLOW_PARITY | Z80_FLAG_NEGATIVE | Z80_FLAG_CARRY); ! 449: bTemp2 = (cpu.z80C >> 7); ! 450: cpu.z80C = (cpu.z80C << 1) | bTemp2; ! 451: cpu.z80F |= bTemp2 | bPostORFlags[cpu.z80C]; ! 452: break; ! 453: } ! 454: case 0x02: ! 455: { ! 456: sdwCyclesRemaining -= 8; ! 457: cpu.z80F &= ~(Z80_FLAG_ZERO | Z80_FLAG_SIGN | Z80_FLAG_HALF_CARRY | Z80_FLAG_OVERFLOW_PARITY | Z80_FLAG_NEGATIVE | Z80_FLAG_CARRY); ! 458: bTemp2 = (cpu.z80D >> 7); ! 459: cpu.z80D = (cpu.z80D << 1) | bTemp2; ! 460: cpu.z80F |= bTemp2 | bPostORFlags[cpu.z80D]; ! 461: break; ! 462: } ! 463: case 0x03: ! 464: { ! 465: sdwCyclesRemaining -= 8; ! 466: cpu.z80F &= ~(Z80_FLAG_ZERO | Z80_FLAG_SIGN | Z80_FLAG_HALF_CARRY | Z80_FLAG_OVERFLOW_PARITY | Z80_FLAG_NEGATIVE | Z80_FLAG_CARRY); ! 467: bTemp2 = (cpu.z80E >> 7); ! 468: cpu.z80E = (cpu.z80E << 1) | bTemp2; ! 469: cpu.z80F |= bTemp2 | bPostORFlags[cpu.z80E]; ! 470: break; ! 471: } ! 472: case 0x04: ! 473: { ! 474: sdwCyclesRemaining -= 8; ! 475: cpu.z80F &= ~(Z80_FLAG_ZERO | Z80_FLAG_SIGN | Z80_FLAG_HALF_CARRY | Z80_FLAG_OVERFLOW_PARITY | Z80_FLAG_NEGATIVE | Z80_FLAG_CARRY); ! 476: bTemp2 = (cpu.z80H >> 7); ! 477: cpu.z80H = (cpu.z80H << 1) | bTemp2; ! 478: cpu.z80F |= bTemp2 | bPostORFlags[cpu.z80H]; ! 479: break; ! 480: } ! 481: case 0x05: ! 482: { ! 483: sdwCyclesRemaining -= 8; ! 484: cpu.z80F &= ~(Z80_FLAG_ZERO | Z80_FLAG_SIGN | Z80_FLAG_HALF_CARRY | Z80_FLAG_OVERFLOW_PARITY | Z80_FLAG_NEGATIVE | Z80_FLAG_CARRY); ! 485: bTemp2 = (cpu.z80L >> 7); ! 486: cpu.z80L = (cpu.z80L << 1) | bTemp2; ! 487: cpu.z80F |= bTemp2 | bPostORFlags[cpu.z80L]; ! 488: break; ! 489: } ! 490: case 0x06: ! 491: { ! 492: sdwCyclesRemaining -= 15; ! 493: psMemRead = cpu.z80MemRead; /* Beginning of our handler */ ! 494: while (psMemRead->lowAddr != 0xffffffff) ! 495: { ! 496: if ((cpu.z80HL >= psMemRead->lowAddr) && (cpu.z80HL <= psMemRead->highAddr)) ! 497: { ! 498: cpu.z80pc = (UINT32) pbPC - (UINT32) cpu.z80Base; ! 499: if (psMemRead->memoryCall) ! 500: { ! 501: bTemp = psMemRead->memoryCall(cpu.z80HL, psMemRead); ! 502: } ! 503: else ! 504: { ! 505: bTemp = *((UINT8 *) psMemRead->pUserArea + (cpu.z80HL - psMemRead->lowAddr)); ! 506: } ! 507: psMemRead = NULL; ! 508: break; ! 509: } ! 510: ++psMemRead; ! 511: } ! 512: ! 513: if (psMemRead) ! 514: { ! 515: bTemp = cpu.z80Base[cpu.z80HL]; ! 516: } ! 517: ! 518: cpu.z80F &= ~(Z80_FLAG_ZERO | Z80_FLAG_SIGN | Z80_FLAG_HALF_CARRY | Z80_FLAG_OVERFLOW_PARITY | Z80_FLAG_NEGATIVE | Z80_FLAG_CARRY); ! 519: bTemp2 = (bTemp >> 7); ! 520: bTemp = (bTemp << 1) | bTemp2; ! 521: cpu.z80F |= bTemp2 | bPostORFlags[bTemp]; ! 522: psMemWrite = cpu.z80MemWrite; /* Beginning of our handler */ ! 523: while (psMemWrite->lowAddr != 0xffffffff) ! 524: { ! 525: if ((cpu.z80HL >= psMemWrite->lowAddr) && (cpu.z80HL <= psMemWrite->highAddr)) ! 526: { ! 527: cpu.z80pc = (UINT32) pbPC - (UINT32) cpu.z80Base; ! 528: if (psMemWrite->memoryCall) ! 529: { ! 530: psMemWrite->memoryCall(cpu.z80HL, bTemp, psMemWrite); ! 531: } ! 532: else ! 533: { ! 534: *((UINT8 *) psMemWrite->pUserArea + (cpu.z80HL - psMemWrite->lowAddr)) = bTemp; ! 535: } ! 536: psMemWrite = NULL; ! 537: break; ! 538: } ! 539: ++psMemWrite; ! 540: } ! 541: ! 542: if (psMemWrite) ! 543: { ! 544: cpu.z80Base[cpu.z80HL] = (UINT8) bTemp; ! 545: } ! 546: ! 547: break; ! 548: } ! 549: case 0x07: ! 550: { ! 551: sdwCyclesRemaining -= 8; ! 552: cpu.z80F &= ~(Z80_FLAG_ZERO | Z80_FLAG_SIGN | Z80_FLAG_HALF_CARRY | Z80_FLAG_OVERFLOW_PARITY | Z80_FLAG_NEGATIVE | Z80_FLAG_CARRY); ! 553: bTemp2 = (cpu.z80A >> 7); ! 554: cpu.z80A = (cpu.z80A << 1) | bTemp2; ! 555: cpu.z80F |= bTemp2 | bPostORFlags[cpu.z80A]; ! 556: break; ! 557: } ! 558: case 0x08: ! 559: { ! 560: sdwCyclesRemaining -= 8; ! 561: cpu.z80F &= ~(Z80_FLAG_ZERO | Z80_FLAG_SIGN | Z80_FLAG_HALF_CARRY | Z80_FLAG_OVERFLOW_PARITY | Z80_FLAG_NEGATIVE | Z80_FLAG_CARRY); ! 562: cpu.z80F |= (cpu.z80B & Z80_FLAG_CARRY); ! 563: cpu.z80B = (cpu.z80B >> 1) | (cpu.z80B << 7); ! 564: cpu.z80F |= bPostORFlags[cpu.z80B]; ! 565: break; ! 566: } ! 567: case 0x09: ! 568: { ! 569: sdwCyclesRemaining -= 8; ! 570: cpu.z80F &= ~(Z80_FLAG_ZERO | Z80_FLAG_SIGN | Z80_FLAG_HALF_CARRY | Z80_FLAG_OVERFLOW_PARITY | Z80_FLAG_NEGATIVE | Z80_FLAG_CARRY); ! 571: cpu.z80F |= (cpu.z80C & Z80_FLAG_CARRY); ! 572: cpu.z80C = (cpu.z80C >> 1) | (cpu.z80C << 7); ! 573: cpu.z80F |= bPostORFlags[cpu.z80C]; ! 574: break; ! 575: } ! 576: case 0x0a: ! 577: { ! 578: sdwCyclesRemaining -= 8; ! 579: cpu.z80F &= ~(Z80_FLAG_ZERO | Z80_FLAG_SIGN | Z80_FLAG_HALF_CARRY | Z80_FLAG_OVERFLOW_PARITY | Z80_FLAG_NEGATIVE | Z80_FLAG_CARRY); ! 580: cpu.z80F |= (cpu.z80D & Z80_FLAG_CARRY); ! 581: cpu.z80D = (cpu.z80D >> 1) | (cpu.z80D << 7); ! 582: cpu.z80F |= bPostORFlags[cpu.z80D]; ! 583: break; ! 584: } ! 585: case 0x0b: ! 586: { ! 587: sdwCyclesRemaining -= 8; ! 588: cpu.z80F &= ~(Z80_FLAG_ZERO | Z80_FLAG_SIGN | Z80_FLAG_HALF_CARRY | Z80_FLAG_OVERFLOW_PARITY | Z80_FLAG_NEGATIVE | Z80_FLAG_CARRY); ! 589: cpu.z80F |= (cpu.z80E & Z80_FLAG_CARRY); ! 590: cpu.z80E = (cpu.z80E >> 1) | (cpu.z80E << 7); ! 591: cpu.z80F |= bPostORFlags[cpu.z80E]; ! 592: break; ! 593: } ! 594: case 0x0c: ! 595: { ! 596: sdwCyclesRemaining -= 8; ! 597: cpu.z80F &= ~(Z80_FLAG_ZERO | Z80_FLAG_SIGN | Z80_FLAG_HALF_CARRY | Z80_FLAG_OVERFLOW_PARITY | Z80_FLAG_NEGATIVE | Z80_FLAG_CARRY); ! 598: cpu.z80F |= (cpu.z80H & Z80_FLAG_CARRY); ! 599: cpu.z80H = (cpu.z80H >> 1) | (cpu.z80H << 7); ! 600: cpu.z80F |= bPostORFlags[cpu.z80H]; ! 601: break; ! 602: } ! 603: case 0x0d: ! 604: { ! 605: sdwCyclesRemaining -= 8; ! 606: cpu.z80F &= ~(Z80_FLAG_ZERO | Z80_FLAG_SIGN | Z80_FLAG_HALF_CARRY | Z80_FLAG_OVERFLOW_PARITY | Z80_FLAG_NEGATIVE | Z80_FLAG_CARRY); ! 607: cpu.z80F |= (cpu.z80L & Z80_FLAG_CARRY); ! 608: cpu.z80L = (cpu.z80L >> 1) | (cpu.z80L << 7); ! 609: cpu.z80F |= bPostORFlags[cpu.z80L]; ! 610: break; ! 611: } ! 612: case 0x0e: ! 613: { ! 614: sdwCyclesRemaining -= 15; ! 615: psMemRead = cpu.z80MemRead; /* Beginning of our handler */ ! 616: while (psMemRead->lowAddr != 0xffffffff) ! 617: { ! 618: if ((cpu.z80HL >= psMemRead->lowAddr) && (cpu.z80HL <= psMemRead->highAddr)) ! 619: { ! 620: cpu.z80pc = (UINT32) pbPC - (UINT32) cpu.z80Base; ! 621: if (psMemRead->memoryCall) ! 622: { ! 623: bTemp = psMemRead->memoryCall(cpu.z80HL, psMemRead); ! 624: } ! 625: else ! 626: { ! 627: bTemp = *((UINT8 *) psMemRead->pUserArea + (cpu.z80HL - psMemRead->lowAddr)); ! 628: } ! 629: psMemRead = NULL; ! 630: break; ! 631: } ! 632: ++psMemRead; ! 633: } ! 634: ! 635: if (psMemRead) ! 636: { ! 637: bTemp = cpu.z80Base[cpu.z80HL]; ! 638: } ! 639: ! 640: cpu.z80F &= ~(Z80_FLAG_ZERO | Z80_FLAG_SIGN | Z80_FLAG_HALF_CARRY | Z80_FLAG_OVERFLOW_PARITY | Z80_FLAG_NEGATIVE | Z80_FLAG_CARRY); ! 641: cpu.z80F |= (bTemp & Z80_FLAG_CARRY); ! 642: bTemp = (bTemp >> 1) | (bTemp << 7); ! 643: cpu.z80F |= bPostORFlags[bTemp]; ! 644: psMemWrite = cpu.z80MemWrite; /* Beginning of our handler */ ! 645: while (psMemWrite->lowAddr != 0xffffffff) ! 646: { ! 647: if ((cpu.z80HL >= psMemWrite->lowAddr) && (cpu.z80HL <= psMemWrite->highAddr)) ! 648: { ! 649: cpu.z80pc = (UINT32) pbPC - (UINT32) cpu.z80Base; ! 650: if (psMemWrite->memoryCall) ! 651: { ! 652: psMemWrite->memoryCall(cpu.z80HL, bTemp, psMemWrite); ! 653: } ! 654: else ! 655: { ! 656: *((UINT8 *) psMemWrite->pUserArea + (cpu.z80HL - psMemWrite->lowAddr)) = bTemp; ! 657: } ! 658: psMemWrite = NULL; ! 659: break; ! 660: } ! 661: ++psMemWrite; ! 662: } ! 663: ! 664: if (psMemWrite) ! 665: { ! 666: cpu.z80Base[cpu.z80HL] = (UINT8) bTemp; ! 667: } ! 668: ! 669: break; ! 670: } ! 671: case 0x0f: ! 672: { ! 673: sdwCyclesRemaining -= 8; ! 674: cpu.z80F &= ~(Z80_FLAG_ZERO | Z80_FLAG_SIGN | Z80_FLAG_HALF_CARRY | Z80_FLAG_OVERFLOW_PARITY | Z80_FLAG_NEGATIVE | Z80_FLAG_CARRY); ! 675: cpu.z80F |= (cpu.z80A & Z80_FLAG_CARRY); ! 676: cpu.z80A = (cpu.z80A >> 1) | (cpu.z80A << 7); ! 677: cpu.z80F |= bPostORFlags[cpu.z80A]; ! 678: break; ! 679: } ! 680: case 0x10: ! 681: { ! 682: sdwCyclesRemaining -= 8; ! 683: bTemp2 = cpu.z80F & Z80_FLAG_CARRY; ! 684: cpu.z80F &= ~(Z80_FLAG_ZERO | Z80_FLAG_SIGN | Z80_FLAG_HALF_CARRY | Z80_FLAG_OVERFLOW_PARITY | Z80_FLAG_NEGATIVE | Z80_FLAG_CARRY); ! 685: cpu.z80F |= (cpu.z80B >> 7); ! 686: cpu.z80B = (cpu.z80B << 1) | bTemp2; ! 687: cpu.z80F |= bPostORFlags[cpu.z80B]; ! 688: break; ! 689: } ! 690: case 0x11: ! 691: { ! 692: sdwCyclesRemaining -= 8; ! 693: bTemp2 = cpu.z80F & Z80_FLAG_CARRY; ! 694: cpu.z80F &= ~(Z80_FLAG_ZERO | Z80_FLAG_SIGN | Z80_FLAG_HALF_CARRY | Z80_FLAG_OVERFLOW_PARITY | Z80_FLAG_NEGATIVE | Z80_FLAG_CARRY); ! 695: cpu.z80F |= (cpu.z80C >> 7); ! 696: cpu.z80C = (cpu.z80C << 1) | bTemp2; ! 697: cpu.z80F |= bPostORFlags[cpu.z80C]; ! 698: break; ! 699: } ! 700: case 0x12: ! 701: { ! 702: sdwCyclesRemaining -= 8; ! 703: bTemp2 = cpu.z80F & Z80_FLAG_CARRY; ! 704: cpu.z80F &= ~(Z80_FLAG_ZERO | Z80_FLAG_SIGN | Z80_FLAG_HALF_CARRY | Z80_FLAG_OVERFLOW_PARITY | Z80_FLAG_NEGATIVE | Z80_FLAG_CARRY); ! 705: cpu.z80F |= (cpu.z80D >> 7); ! 706: cpu.z80D = (cpu.z80D << 1) | bTemp2; ! 707: cpu.z80F |= bPostORFlags[cpu.z80D]; ! 708: break; ! 709: } ! 710: case 0x13: ! 711: { ! 712: sdwCyclesRemaining -= 8; ! 713: bTemp2 = cpu.z80F & Z80_FLAG_CARRY; ! 714: cpu.z80F &= ~(Z80_FLAG_ZERO | Z80_FLAG_SIGN | Z80_FLAG_HALF_CARRY | Z80_FLAG_OVERFLOW_PARITY | Z80_FLAG_NEGATIVE | Z80_FLAG_CARRY); ! 715: cpu.z80F |= (cpu.z80E >> 7); ! 716: cpu.z80E = (cpu.z80E << 1) | bTemp2; ! 717: cpu.z80F |= bPostORFlags[cpu.z80E]; ! 718: break; ! 719: } ! 720: case 0x14: ! 721: { ! 722: sdwCyclesRemaining -= 8; ! 723: bTemp2 = cpu.z80F & Z80_FLAG_CARRY; ! 724: cpu.z80F &= ~(Z80_FLAG_ZERO | Z80_FLAG_SIGN | Z80_FLAG_HALF_CARRY | Z80_FLAG_OVERFLOW_PARITY | Z80_FLAG_NEGATIVE | Z80_FLAG_CARRY); ! 725: cpu.z80F |= (cpu.z80H >> 7); ! 726: cpu.z80H = (cpu.z80H << 1) | bTemp2; ! 727: cpu.z80F |= bPostORFlags[cpu.z80H]; ! 728: break; ! 729: } ! 730: case 0x15: ! 731: { ! 732: sdwCyclesRemaining -= 8; ! 733: bTemp2 = cpu.z80F & Z80_FLAG_CARRY; ! 734: cpu.z80F &= ~(Z80_FLAG_ZERO | Z80_FLAG_SIGN | Z80_FLAG_HALF_CARRY | Z80_FLAG_OVERFLOW_PARITY | Z80_FLAG_NEGATIVE | Z80_FLAG_CARRY); ! 735: cpu.z80F |= (cpu.z80L >> 7); ! 736: cpu.z80L = (cpu.z80L << 1) | bTemp2; ! 737: cpu.z80F |= bPostORFlags[cpu.z80L]; ! 738: break; ! 739: } ! 740: case 0x16: ! 741: { ! 742: sdwCyclesRemaining -= 15; ! 743: psMemRead = cpu.z80MemRead; /* Beginning of our handler */ ! 744: while (psMemRead->lowAddr != 0xffffffff) ! 745: { ! 746: if ((cpu.z80HL >= psMemRead->lowAddr) && (cpu.z80HL <= psMemRead->highAddr)) ! 747: { ! 748: cpu.z80pc = (UINT32) pbPC - (UINT32) cpu.z80Base; ! 749: if (psMemRead->memoryCall) ! 750: { ! 751: bTemp = psMemRead->memoryCall(cpu.z80HL, psMemRead); ! 752: } ! 753: else ! 754: { ! 755: bTemp = *((UINT8 *) psMemRead->pUserArea + (cpu.z80HL - psMemRead->lowAddr)); ! 756: } ! 757: psMemRead = NULL; ! 758: break; ! 759: } ! 760: ++psMemRead; ! 761: } ! 762: ! 763: if (psMemRead) ! 764: { ! 765: bTemp = cpu.z80Base[cpu.z80HL]; ! 766: } ! 767: ! 768: bTemp2 = cpu.z80F & Z80_FLAG_CARRY; ! 769: cpu.z80F &= ~(Z80_FLAG_ZERO | Z80_FLAG_SIGN | Z80_FLAG_HALF_CARRY | Z80_FLAG_OVERFLOW_PARITY | Z80_FLAG_NEGATIVE | Z80_FLAG_CARRY); ! 770: cpu.z80F |= (bTemp >> 7); ! 771: bTemp = (bTemp << 1) | bTemp2; ! 772: cpu.z80F |= bPostORFlags[bTemp]; ! 773: psMemWrite = cpu.z80MemWrite; /* Beginning of our handler */ ! 774: while (psMemWrite->lowAddr != 0xffffffff) ! 775: { ! 776: if ((cpu.z80HL >= psMemWrite->lowAddr) && (cpu.z80HL <= psMemWrite->highAddr)) ! 777: { ! 778: cpu.z80pc = (UINT32) pbPC - (UINT32) cpu.z80Base; ! 779: if (psMemWrite->memoryCall) ! 780: { ! 781: psMemWrite->memoryCall(cpu.z80HL, bTemp, psMemWrite); ! 782: } ! 783: else ! 784: { ! 785: *((UINT8 *) psMemWrite->pUserArea + (cpu.z80HL - psMemWrite->lowAddr)) = bTemp; ! 786: } ! 787: psMemWrite = NULL; ! 788: break; ! 789: } ! 790: ++psMemWrite; ! 791: } ! 792: ! 793: if (psMemWrite) ! 794: { ! 795: cpu.z80Base[cpu.z80HL] = (UINT8) bTemp; ! 796: } ! 797: ! 798: break; ! 799: } ! 800: case 0x17: ! 801: { ! 802: sdwCyclesRemaining -= 8; ! 803: bTemp2 = cpu.z80F & Z80_FLAG_CARRY; ! 804: cpu.z80F &= ~(Z80_FLAG_ZERO | Z80_FLAG_SIGN | Z80_FLAG_HALF_CARRY | Z80_FLAG_OVERFLOW_PARITY | Z80_FLAG_NEGATIVE | Z80_FLAG_CARRY); ! 805: cpu.z80F |= (cpu.z80A >> 7); ! 806: cpu.z80A = (cpu.z80A << 1) | bTemp2; ! 807: cpu.z80F |= bPostORFlags[cpu.z80A]; ! 808: break; ! 809: } ! 810: case 0x18: ! 811: { ! 812: sdwCyclesRemaining -= 8; ! 813: bTemp2 = (cpu.z80F & Z80_FLAG_CARRY) << 7; ! 814: cpu.z80F &= ~(Z80_FLAG_ZERO | Z80_FLAG_SIGN | Z80_FLAG_HALF_CARRY | Z80_FLAG_OVERFLOW_PARITY | Z80_FLAG_NEGATIVE | Z80_FLAG_CARRY); ! 815: cpu.z80F |= (cpu.z80B & Z80_FLAG_CARRY); ! 816: cpu.z80B = (cpu.z80B >> 1) | bTemp2; ! 817: cpu.z80F |= bPostORFlags[cpu.z80B]; ! 818: break; ! 819: } ! 820: case 0x19: ! 821: { ! 822: sdwCyclesRemaining -= 8; ! 823: bTemp2 = (cpu.z80F & Z80_FLAG_CARRY) << 7; ! 824: cpu.z80F &= ~(Z80_FLAG_ZERO | Z80_FLAG_SIGN | Z80_FLAG_HALF_CARRY | Z80_FLAG_OVERFLOW_PARITY | Z80_FLAG_NEGATIVE | Z80_FLAG_CARRY); ! 825: cpu.z80F |= (cpu.z80C & Z80_FLAG_CARRY); ! 826: cpu.z80C = (cpu.z80C >> 1) | bTemp2; ! 827: cpu.z80F |= bPostORFlags[cpu.z80C]; ! 828: break; ! 829: } ! 830: case 0x1a: ! 831: { ! 832: sdwCyclesRemaining -= 8; ! 833: bTemp2 = (cpu.z80F & Z80_FLAG_CARRY) << 7; ! 834: cpu.z80F &= ~(Z80_FLAG_ZERO | Z80_FLAG_SIGN | Z80_FLAG_HALF_CARRY | Z80_FLAG_OVERFLOW_PARITY | Z80_FLAG_NEGATIVE | Z80_FLAG_CARRY); ! 835: cpu.z80F |= (cpu.z80D & Z80_FLAG_CARRY); ! 836: cpu.z80D = (cpu.z80D >> 1) | bTemp2; ! 837: cpu.z80F |= bPostORFlags[cpu.z80D]; ! 838: break; ! 839: } ! 840: case 0x1b: ! 841: { ! 842: sdwCyclesRemaining -= 8; ! 843: bTemp2 = (cpu.z80F & Z80_FLAG_CARRY) << 7; ! 844: cpu.z80F &= ~(Z80_FLAG_ZERO | Z80_FLAG_SIGN | Z80_FLAG_HALF_CARRY | Z80_FLAG_OVERFLOW_PARITY | Z80_FLAG_NEGATIVE | Z80_FLAG_CARRY); ! 845: cpu.z80F |= (cpu.z80E & Z80_FLAG_CARRY); ! 846: cpu.z80E = (cpu.z80E >> 1) | bTemp2; ! 847: cpu.z80F |= bPostORFlags[cpu.z80E]; ! 848: break; ! 849: } ! 850: case 0x1c: ! 851: { ! 852: sdwCyclesRemaining -= 8; ! 853: bTemp2 = (cpu.z80F & Z80_FLAG_CARRY) << 7; ! 854: cpu.z80F &= ~(Z80_FLAG_ZERO | Z80_FLAG_SIGN | Z80_FLAG_HALF_CARRY | Z80_FLAG_OVERFLOW_PARITY | Z80_FLAG_NEGATIVE | Z80_FLAG_CARRY); ! 855: cpu.z80F |= (cpu.z80H & Z80_FLAG_CARRY); ! 856: cpu.z80H = (cpu.z80H >> 1) | bTemp2; ! 857: cpu.z80F |= bPostORFlags[cpu.z80H]; ! 858: break; ! 859: } ! 860: case 0x1d: ! 861: { ! 862: sdwCyclesRemaining -= 8; ! 863: bTemp2 = (cpu.z80F & Z80_FLAG_CARRY) << 7; ! 864: cpu.z80F &= ~(Z80_FLAG_ZERO | Z80_FLAG_SIGN | Z80_FLAG_HALF_CARRY | Z80_FLAG_OVERFLOW_PARITY | Z80_FLAG_NEGATIVE | Z80_FLAG_CARRY); ! 865: cpu.z80F |= (cpu.z80L & Z80_FLAG_CARRY); ! 866: cpu.z80L = (cpu.z80L >> 1) | bTemp2; ! 867: cpu.z80F |= bPostORFlags[cpu.z80L]; ! 868: break; ! 869: } ! 870: case 0x1e: ! 871: { ! 872: sdwCyclesRemaining -= 15; ! 873: psMemRead = cpu.z80MemRead; /* Beginning of our handler */ ! 874: while (psMemRead->lowAddr != 0xffffffff) ! 875: { ! 876: if ((cpu.z80HL >= psMemRead->lowAddr) && (cpu.z80HL <= psMemRead->highAddr)) ! 877: { ! 878: cpu.z80pc = (UINT32) pbPC - (UINT32) cpu.z80Base; ! 879: if (psMemRead->memoryCall) ! 880: { ! 881: bTemp = psMemRead->memoryCall(cpu.z80HL, psMemRead); ! 882: } ! 883: else ! 884: { ! 885: bTemp = *((UINT8 *) psMemRead->pUserArea + (cpu.z80HL - psMemRead->lowAddr)); ! 886: } ! 887: psMemRead = NULL; ! 888: break; ! 889: } ! 890: ++psMemRead; ! 891: } ! 892: ! 893: if (psMemRead) ! 894: { ! 895: bTemp = cpu.z80Base[cpu.z80HL]; ! 896: } ! 897: ! 898: bTemp2 = (cpu.z80F & Z80_FLAG_CARRY) << 7; ! 899: cpu.z80F &= ~(Z80_FLAG_ZERO | Z80_FLAG_SIGN | Z80_FLAG_HALF_CARRY | Z80_FLAG_OVERFLOW_PARITY | Z80_FLAG_NEGATIVE | Z80_FLAG_CARRY); ! 900: cpu.z80F |= (bTemp & Z80_FLAG_CARRY); ! 901: bTemp = (bTemp >> 1) | bTemp2; ! 902: cpu.z80F |= bPostORFlags[bTemp]; ! 903: psMemWrite = cpu.z80MemWrite; /* Beginning of our handler */ ! 904: while (psMemWrite->lowAddr != 0xffffffff) ! 905: { ! 906: if ((cpu.z80HL >= psMemWrite->lowAddr) && (cpu.z80HL <= psMemWrite->highAddr)) ! 907: { ! 908: cpu.z80pc = (UINT32) pbPC - (UINT32) cpu.z80Base; ! 909: if (psMemWrite->memoryCall) ! 910: { ! 911: psMemWrite->memoryCall(cpu.z80HL, bTemp, psMemWrite); ! 912: } ! 913: else ! 914: { ! 915: *((UINT8 *) psMemWrite->pUserArea + (cpu.z80HL - psMemWrite->lowAddr)) = bTemp; ! 916: } ! 917: psMemWrite = NULL; ! 918: break; ! 919: } ! 920: ++psMemWrite; ! 921: } ! 922: ! 923: if (psMemWrite) ! 924: { ! 925: cpu.z80Base[cpu.z80HL] = (UINT8) bTemp; ! 926: } ! 927: ! 928: break; ! 929: } ! 930: case 0x1f: ! 931: { ! 932: sdwCyclesRemaining -= 8; ! 933: bTemp2 = (cpu.z80F & Z80_FLAG_CARRY) << 7; ! 934: cpu.z80F &= ~(Z80_FLAG_ZERO | Z80_FLAG_SIGN | Z80_FLAG_HALF_CARRY | Z80_FLAG_OVERFLOW_PARITY | Z80_FLAG_NEGATIVE | Z80_FLAG_CARRY); ! 935: cpu.z80F |= (cpu.z80A & Z80_FLAG_CARRY); ! 936: cpu.z80A = (cpu.z80A >> 1) | bTemp2; ! 937: cpu.z80F |= bPostORFlags[cpu.z80A]; ! 938: break; ! 939: } ! 940: case 0x20: ! 941: { ! 942: sdwCyclesRemaining -= 8; ! 943: cpu.z80F &= ~(Z80_FLAG_ZERO | Z80_FLAG_SIGN | Z80_FLAG_HALF_CARRY | Z80_FLAG_OVERFLOW_PARITY | Z80_FLAG_NEGATIVE | Z80_FLAG_CARRY); ! 944: cpu.z80F |= (cpu.z80B >> 7); ! 945: cpu.z80B = (cpu.z80B << 1); ! 946: cpu.z80F |= bPostORFlags[cpu.z80B]; ! 947: break; ! 948: } ! 949: case 0x21: ! 950: { ! 951: sdwCyclesRemaining -= 8; ! 952: cpu.z80F &= ~(Z80_FLAG_ZERO | Z80_FLAG_SIGN | Z80_FLAG_HALF_CARRY | Z80_FLAG_OVERFLOW_PARITY | Z80_FLAG_NEGATIVE | Z80_FLAG_CARRY); ! 953: cpu.z80F |= (cpu.z80C >> 7); ! 954: cpu.z80C = (cpu.z80C << 1); ! 955: cpu.z80F |= bPostORFlags[cpu.z80C]; ! 956: break; ! 957: } ! 958: case 0x22: ! 959: { ! 960: sdwCyclesRemaining -= 8; ! 961: cpu.z80F &= ~(Z80_FLAG_ZERO | Z80_FLAG_SIGN | Z80_FLAG_HALF_CARRY | Z80_FLAG_OVERFLOW_PARITY | Z80_FLAG_NEGATIVE | Z80_FLAG_CARRY); ! 962: cpu.z80F |= (cpu.z80D >> 7); ! 963: cpu.z80D = (cpu.z80D << 1); ! 964: cpu.z80F |= bPostORFlags[cpu.z80D]; ! 965: break; ! 966: } ! 967: case 0x23: ! 968: { ! 969: sdwCyclesRemaining -= 8; ! 970: cpu.z80F &= ~(Z80_FLAG_ZERO | Z80_FLAG_SIGN | Z80_FLAG_HALF_CARRY | Z80_FLAG_OVERFLOW_PARITY | Z80_FLAG_NEGATIVE | Z80_FLAG_CARRY); ! 971: cpu.z80F |= (cpu.z80E >> 7); ! 972: cpu.z80E = (cpu.z80E << 1); ! 973: cpu.z80F |= bPostORFlags[cpu.z80E]; ! 974: break; ! 975: } ! 976: case 0x24: ! 977: { ! 978: sdwCyclesRemaining -= 8; ! 979: cpu.z80F &= ~(Z80_FLAG_ZERO | Z80_FLAG_SIGN | Z80_FLAG_HALF_CARRY | Z80_FLAG_OVERFLOW_PARITY | Z80_FLAG_NEGATIVE | Z80_FLAG_CARRY); ! 980: cpu.z80F |= (cpu.z80H >> 7); ! 981: cpu.z80H = (cpu.z80H << 1); ! 982: cpu.z80F |= bPostORFlags[cpu.z80H]; ! 983: break; ! 984: } ! 985: case 0x25: ! 986: { ! 987: sdwCyclesRemaining -= 8; ! 988: cpu.z80F &= ~(Z80_FLAG_ZERO | Z80_FLAG_SIGN | Z80_FLAG_HALF_CARRY | Z80_FLAG_OVERFLOW_PARITY | Z80_FLAG_NEGATIVE | Z80_FLAG_CARRY); ! 989: cpu.z80F |= (cpu.z80L >> 7); ! 990: cpu.z80L = (cpu.z80L << 1); ! 991: cpu.z80F |= bPostORFlags[cpu.z80L]; ! 992: break; ! 993: } ! 994: case 0x26: ! 995: { ! 996: sdwCyclesRemaining -= 15; ! 997: psMemRead = cpu.z80MemRead; /* Beginning of our handler */ ! 998: while (psMemRead->lowAddr != 0xffffffff) ! 999: { ! 1000: if ((cpu.z80HL >= psMemRead->lowAddr) && (cpu.z80HL <= psMemRead->highAddr)) ! 1001: { ! 1002: cpu.z80pc = (UINT32) pbPC - (UINT32) cpu.z80Base; ! 1003: if (psMemRead->memoryCall) ! 1004: { ! 1005: bTemp = psMemRead->memoryCall(cpu.z80HL, psMemRead); ! 1006: } ! 1007: else ! 1008: { ! 1009: bTemp = *((UINT8 *) psMemRead->pUserArea + (cpu.z80HL - psMemRead->lowAddr)); ! 1010: } ! 1011: psMemRead = NULL; ! 1012: break; ! 1013: } ! 1014: ++psMemRead; ! 1015: } ! 1016: ! 1017: if (psMemRead) ! 1018: { ! 1019: bTemp = cpu.z80Base[cpu.z80HL]; ! 1020: } ! 1021: ! 1022: cpu.z80F &= ~(Z80_FLAG_ZERO | Z80_FLAG_SIGN | Z80_FLAG_HALF_CARRY | Z80_FLAG_OVERFLOW_PARITY | Z80_FLAG_NEGATIVE | Z80_FLAG_CARRY); ! 1023: cpu.z80F |= (bTemp >> 7); ! 1024: bTemp = (bTemp << 1); ! 1025: cpu.z80F |= bPostORFlags[bTemp]; ! 1026: psMemWrite = cpu.z80MemWrite; /* Beginning of our handler */ ! 1027: while (psMemWrite->lowAddr != 0xffffffff) ! 1028: { ! 1029: if ((cpu.z80HL >= psMemWrite->lowAddr) && (cpu.z80HL <= psMemWrite->highAddr)) ! 1030: { ! 1031: cpu.z80pc = (UINT32) pbPC - (UINT32) cpu.z80Base; ! 1032: if (psMemWrite->memoryCall) ! 1033: { ! 1034: psMemWrite->memoryCall(cpu.z80HL, bTemp, psMemWrite); ! 1035: } ! 1036: else ! 1037: { ! 1038: *((UINT8 *) psMemWrite->pUserArea + (cpu.z80HL - psMemWrite->lowAddr)) = bTemp; ! 1039: } ! 1040: psMemWrite = NULL; ! 1041: break; ! 1042: } ! 1043: ++psMemWrite; ! 1044: } ! 1045: ! 1046: if (psMemWrite) ! 1047: { ! 1048: cpu.z80Base[cpu.z80HL] = (UINT8) bTemp; ! 1049: } ! 1050: ! 1051: break; ! 1052: } ! 1053: case 0x27: ! 1054: { ! 1055: sdwCyclesRemaining -= 8; ! 1056: cpu.z80F &= ~(Z80_FLAG_ZERO | Z80_FLAG_SIGN | Z80_FLAG_HALF_CARRY | Z80_FLAG_OVERFLOW_PARITY | Z80_FLAG_NEGATIVE | Z80_FLAG_CARRY); ! 1057: cpu.z80F |= (cpu.z80A >> 7); ! 1058: cpu.z80A = (cpu.z80A << 1); ! 1059: cpu.z80F |= bPostORFlags[cpu.z80A]; ! 1060: break; ! 1061: } ! 1062: case 0x28: ! 1063: { ! 1064: sdwCyclesRemaining -= 8; ! 1065: cpu.z80F &= ~(Z80_FLAG_ZERO | Z80_FLAG_SIGN | Z80_FLAG_HALF_CARRY | Z80_FLAG_OVERFLOW_PARITY | Z80_FLAG_NEGATIVE | Z80_FLAG_CARRY); ! 1066: cpu.z80F |= (cpu.z80B & Z80_FLAG_CARRY); ! 1067: cpu.z80B = (cpu.z80B >> 1) | (cpu.z80B & 0x80); ! 1068: cpu.z80F |= bPostORFlags[cpu.z80B]; ! 1069: break; ! 1070: } ! 1071: case 0x29: ! 1072: { ! 1073: sdwCyclesRemaining -= 8; ! 1074: cpu.z80F &= ~(Z80_FLAG_ZERO | Z80_FLAG_SIGN | Z80_FLAG_HALF_CARRY | Z80_FLAG_OVERFLOW_PARITY | Z80_FLAG_NEGATIVE | Z80_FLAG_CARRY); ! 1075: cpu.z80F |= (cpu.z80C & Z80_FLAG_CARRY); ! 1076: cpu.z80C = (cpu.z80C >> 1) | (cpu.z80C & 0x80); ! 1077: cpu.z80F |= bPostORFlags[cpu.z80C]; ! 1078: break; ! 1079: } ! 1080: case 0x2a: ! 1081: { ! 1082: sdwCyclesRemaining -= 8; ! 1083: cpu.z80F &= ~(Z80_FLAG_ZERO | Z80_FLAG_SIGN | Z80_FLAG_HALF_CARRY | Z80_FLAG_OVERFLOW_PARITY | Z80_FLAG_NEGATIVE | Z80_FLAG_CARRY); ! 1084: cpu.z80F |= (cpu.z80D & Z80_FLAG_CARRY); ! 1085: cpu.z80D = (cpu.z80D >> 1) | (cpu.z80D & 0x80); ! 1086: cpu.z80F |= bPostORFlags[cpu.z80D]; ! 1087: break; ! 1088: } ! 1089: case 0x2b: ! 1090: { ! 1091: sdwCyclesRemaining -= 8; ! 1092: cpu.z80F &= ~(Z80_FLAG_ZERO | Z80_FLAG_SIGN | Z80_FLAG_HALF_CARRY | Z80_FLAG_OVERFLOW_PARITY | Z80_FLAG_NEGATIVE | Z80_FLAG_CARRY); ! 1093: cpu.z80F |= (cpu.z80E & Z80_FLAG_CARRY); ! 1094: cpu.z80E = (cpu.z80E >> 1) | (cpu.z80E & 0x80); ! 1095: cpu.z80F |= bPostORFlags[cpu.z80E]; ! 1096: break; ! 1097: } ! 1098: case 0x2c: ! 1099: { ! 1100: sdwCyclesRemaining -= 8; ! 1101: cpu.z80F &= ~(Z80_FLAG_ZERO | Z80_FLAG_SIGN | Z80_FLAG_HALF_CARRY | Z80_FLAG_OVERFLOW_PARITY | Z80_FLAG_NEGATIVE | Z80_FLAG_CARRY); ! 1102: cpu.z80F |= (cpu.z80H & Z80_FLAG_CARRY); ! 1103: cpu.z80H = (cpu.z80H >> 1) | (cpu.z80H & 0x80); ! 1104: cpu.z80F |= bPostORFlags[cpu.z80H]; ! 1105: break; ! 1106: } ! 1107: case 0x2d: ! 1108: { ! 1109: sdwCyclesRemaining -= 8; ! 1110: cpu.z80F &= ~(Z80_FLAG_ZERO | Z80_FLAG_SIGN | Z80_FLAG_HALF_CARRY | Z80_FLAG_OVERFLOW_PARITY | Z80_FLAG_NEGATIVE | Z80_FLAG_CARRY); ! 1111: cpu.z80F |= (cpu.z80L & Z80_FLAG_CARRY); ! 1112: cpu.z80L = (cpu.z80L >> 1) | (cpu.z80L & 0x80); ! 1113: cpu.z80F |= bPostORFlags[cpu.z80L]; ! 1114: break; ! 1115: } ! 1116: case 0x2e: ! 1117: { ! 1118: sdwCyclesRemaining -= 15; ! 1119: psMemRead = cpu.z80MemRead; /* Beginning of our handler */ ! 1120: while (psMemRead->lowAddr != 0xffffffff) ! 1121: { ! 1122: if ((cpu.z80HL >= psMemRead->lowAddr) && (cpu.z80HL <= psMemRead->highAddr)) ! 1123: { ! 1124: cpu.z80pc = (UINT32) pbPC - (UINT32) cpu.z80Base; ! 1125: if (psMemRead->memoryCall) ! 1126: { ! 1127: bTemp = psMemRead->memoryCall(cpu.z80HL, psMemRead); ! 1128: } ! 1129: else ! 1130: { ! 1131: bTemp = *((UINT8 *) psMemRead->pUserArea + (cpu.z80HL - psMemRead->lowAddr)); ! 1132: } ! 1133: psMemRead = NULL; ! 1134: break; ! 1135: } ! 1136: ++psMemRead; ! 1137: } ! 1138: ! 1139: if (psMemRead) ! 1140: { ! 1141: bTemp = cpu.z80Base[cpu.z80HL]; ! 1142: } ! 1143: ! 1144: cpu.z80F &= ~(Z80_FLAG_ZERO | Z80_FLAG_SIGN | Z80_FLAG_HALF_CARRY | Z80_FLAG_OVERFLOW_PARITY | Z80_FLAG_NEGATIVE | Z80_FLAG_CARRY); ! 1145: cpu.z80F |= (bTemp & Z80_FLAG_CARRY); ! 1146: bTemp = (bTemp >> 1) | (bTemp & 0x80); ! 1147: cpu.z80F |= bPostORFlags[bTemp]; ! 1148: psMemWrite = cpu.z80MemWrite; /* Beginning of our handler */ ! 1149: while (psMemWrite->lowAddr != 0xffffffff) ! 1150: { ! 1151: if ((cpu.z80HL >= psMemWrite->lowAddr) && (cpu.z80HL <= psMemWrite->highAddr)) ! 1152: { ! 1153: cpu.z80pc = (UINT32) pbPC - (UINT32) cpu.z80Base; ! 1154: if (psMemWrite->memoryCall) ! 1155: { ! 1156: psMemWrite->memoryCall(cpu.z80HL, bTemp, psMemWrite); ! 1157: } ! 1158: else ! 1159: { ! 1160: *((UINT8 *) psMemWrite->pUserArea + (cpu.z80HL - psMemWrite->lowAddr)) = bTemp; ! 1161: } ! 1162: psMemWrite = NULL; ! 1163: break; ! 1164: } ! 1165: ++psMemWrite; ! 1166: } ! 1167: ! 1168: if (psMemWrite) ! 1169: { ! 1170: cpu.z80Base[cpu.z80HL] = (UINT8) bTemp; ! 1171: } ! 1172: ! 1173: break; ! 1174: } ! 1175: case 0x2f: ! 1176: { ! 1177: sdwCyclesRemaining -= 8; ! 1178: cpu.z80F &= ~(Z80_FLAG_ZERO | Z80_FLAG_SIGN | Z80_FLAG_HALF_CARRY | Z80_FLAG_OVERFLOW_PARITY | Z80_FLAG_NEGATIVE | Z80_FLAG_CARRY); ! 1179: cpu.z80F |= (cpu.z80A & Z80_FLAG_CARRY); ! 1180: cpu.z80A = (cpu.z80A >> 1) | (cpu.z80A & 0x80); ! 1181: cpu.z80F |= bPostORFlags[cpu.z80A]; ! 1182: break; ! 1183: } ! 1184: case 0x30: ! 1185: { ! 1186: sdwCyclesRemaining -= 8; ! 1187: cpu.z80F &= ~(Z80_FLAG_ZERO | Z80_FLAG_SIGN | Z80_FLAG_HALF_CARRY | Z80_FLAG_OVERFLOW_PARITY | Z80_FLAG_NEGATIVE | Z80_FLAG_CARRY); ! 1188: cpu.z80F |= (cpu.z80B >> 7); ! 1189: cpu.z80B = (cpu.z80B << 1); ! 1190: cpu.z80F |= bPostORFlags[cpu.z80B]; ! 1191: break; ! 1192: } ! 1193: case 0x31: ! 1194: { ! 1195: sdwCyclesRemaining -= 8; ! 1196: cpu.z80F &= ~(Z80_FLAG_ZERO | Z80_FLAG_SIGN | Z80_FLAG_HALF_CARRY | Z80_FLAG_OVERFLOW_PARITY | Z80_FLAG_NEGATIVE | Z80_FLAG_CARRY); ! 1197: cpu.z80F |= (cpu.z80C >> 7); ! 1198: cpu.z80C = (cpu.z80C << 1); ! 1199: cpu.z80F |= bPostORFlags[cpu.z80C]; ! 1200: break; ! 1201: } ! 1202: case 0x32: ! 1203: { ! 1204: sdwCyclesRemaining -= 8; ! 1205: cpu.z80F &= ~(Z80_FLAG_ZERO | Z80_FLAG_SIGN | Z80_FLAG_HALF_CARRY | Z80_FLAG_OVERFLOW_PARITY | Z80_FLAG_NEGATIVE | Z80_FLAG_CARRY); ! 1206: cpu.z80F |= (cpu.z80D >> 7); ! 1207: cpu.z80D = (cpu.z80D << 1); ! 1208: cpu.z80F |= bPostORFlags[cpu.z80D]; ! 1209: break; ! 1210: } ! 1211: case 0x33: ! 1212: { ! 1213: sdwCyclesRemaining -= 8; ! 1214: cpu.z80F &= ~(Z80_FLAG_ZERO | Z80_FLAG_SIGN | Z80_FLAG_HALF_CARRY | Z80_FLAG_OVERFLOW_PARITY | Z80_FLAG_NEGATIVE | Z80_FLAG_CARRY); ! 1215: cpu.z80F |= (cpu.z80E >> 7); ! 1216: cpu.z80E = (cpu.z80E << 1); ! 1217: cpu.z80F |= bPostORFlags[cpu.z80E]; ! 1218: break; ! 1219: } ! 1220: case 0x34: ! 1221: { ! 1222: sdwCyclesRemaining -= 8; ! 1223: cpu.z80F &= ~(Z80_FLAG_ZERO | Z80_FLAG_SIGN | Z80_FLAG_HALF_CARRY | Z80_FLAG_OVERFLOW_PARITY | Z80_FLAG_NEGATIVE | Z80_FLAG_CARRY); ! 1224: cpu.z80F |= (cpu.z80H >> 7); ! 1225: cpu.z80H = (cpu.z80H << 1); ! 1226: cpu.z80F |= bPostORFlags[cpu.z80H]; ! 1227: break; ! 1228: } ! 1229: case 0x35: ! 1230: { ! 1231: sdwCyclesRemaining -= 8; ! 1232: cpu.z80F &= ~(Z80_FLAG_ZERO | Z80_FLAG_SIGN | Z80_FLAG_HALF_CARRY | Z80_FLAG_OVERFLOW_PARITY | Z80_FLAG_NEGATIVE | Z80_FLAG_CARRY); ! 1233: cpu.z80F |= (cpu.z80L >> 7); ! 1234: cpu.z80L = (cpu.z80L << 1); ! 1235: cpu.z80F |= bPostORFlags[cpu.z80L]; ! 1236: break; ! 1237: } ! 1238: case 0x36: ! 1239: { ! 1240: sdwCyclesRemaining -= 15; ! 1241: psMemRead = cpu.z80MemRead; /* Beginning of our handler */ ! 1242: while (psMemRead->lowAddr != 0xffffffff) ! 1243: { ! 1244: if ((cpu.z80HL >= psMemRead->lowAddr) && (cpu.z80HL <= psMemRead->highAddr)) ! 1245: { ! 1246: cpu.z80pc = (UINT32) pbPC - (UINT32) cpu.z80Base; ! 1247: if (psMemRead->memoryCall) ! 1248: { ! 1249: bTemp = psMemRead->memoryCall(cpu.z80HL, psMemRead); ! 1250: } ! 1251: else ! 1252: { ! 1253: bTemp = *((UINT8 *) psMemRead->pUserArea + (cpu.z80HL - psMemRead->lowAddr)); ! 1254: } ! 1255: psMemRead = NULL; ! 1256: break; ! 1257: } ! 1258: ++psMemRead; ! 1259: } ! 1260: ! 1261: if (psMemRead) ! 1262: { ! 1263: bTemp = cpu.z80Base[cpu.z80HL]; ! 1264: } ! 1265: ! 1266: cpu.z80F &= ~(Z80_FLAG_ZERO | Z80_FLAG_SIGN | Z80_FLAG_HALF_CARRY | Z80_FLAG_OVERFLOW_PARITY | Z80_FLAG_NEGATIVE | Z80_FLAG_CARRY); ! 1267: cpu.z80F |= (bTemp >> 7); ! 1268: bTemp = (bTemp << 1); ! 1269: cpu.z80F |= bPostORFlags[bTemp]; ! 1270: psMemWrite = cpu.z80MemWrite; /* Beginning of our handler */ ! 1271: while (psMemWrite->lowAddr != 0xffffffff) ! 1272: { ! 1273: if ((cpu.z80HL >= psMemWrite->lowAddr) && (cpu.z80HL <= psMemWrite->highAddr)) ! 1274: { ! 1275: cpu.z80pc = (UINT32) pbPC - (UINT32) cpu.z80Base; ! 1276: if (psMemWrite->memoryCall) ! 1277: { ! 1278: psMemWrite->memoryCall(cpu.z80HL, bTemp, psMemWrite); ! 1279: } ! 1280: else ! 1281: { ! 1282: *((UINT8 *) psMemWrite->pUserArea + (cpu.z80HL - psMemWrite->lowAddr)) = bTemp; ! 1283: } ! 1284: psMemWrite = NULL; ! 1285: break; ! 1286: } ! 1287: ++psMemWrite; ! 1288: } ! 1289: ! 1290: if (psMemWrite) ! 1291: { ! 1292: cpu.z80Base[cpu.z80HL] = (UINT8) bTemp; ! 1293: } ! 1294: ! 1295: break; ! 1296: } ! 1297: case 0x37: ! 1298: { ! 1299: sdwCyclesRemaining -= 8; ! 1300: cpu.z80F &= ~(Z80_FLAG_ZERO | Z80_FLAG_SIGN | Z80_FLAG_HALF_CARRY | Z80_FLAG_OVERFLOW_PARITY | Z80_FLAG_NEGATIVE | Z80_FLAG_CARRY); ! 1301: cpu.z80F |= (cpu.z80A >> 7); ! 1302: cpu.z80A = (cpu.z80A << 1); ! 1303: cpu.z80F |= bPostORFlags[cpu.z80A]; ! 1304: break; ! 1305: } ! 1306: case 0x38: ! 1307: { ! 1308: sdwCyclesRemaining -= 8; ! 1309: cpu.z80F &= ~(Z80_FLAG_ZERO | Z80_FLAG_SIGN | Z80_FLAG_HALF_CARRY | Z80_FLAG_OVERFLOW_PARITY | Z80_FLAG_NEGATIVE | Z80_FLAG_CARRY); ! 1310: cpu.z80F |= (cpu.z80B & Z80_FLAG_CARRY); ! 1311: cpu.z80B = (cpu.z80B >> 1); ! 1312: cpu.z80F |= bPostORFlags[cpu.z80B]; ! 1313: break; ! 1314: } ! 1315: case 0x39: ! 1316: { ! 1317: sdwCyclesRemaining -= 8; ! 1318: cpu.z80F &= ~(Z80_FLAG_ZERO | Z80_FLAG_SIGN | Z80_FLAG_HALF_CARRY | Z80_FLAG_OVERFLOW_PARITY | Z80_FLAG_NEGATIVE | Z80_FLAG_CARRY); ! 1319: cpu.z80F |= (cpu.z80C & Z80_FLAG_CARRY); ! 1320: cpu.z80C = (cpu.z80C >> 1); ! 1321: cpu.z80F |= bPostORFlags[cpu.z80C]; ! 1322: break; ! 1323: } ! 1324: case 0x3a: ! 1325: { ! 1326: sdwCyclesRemaining -= 8; ! 1327: cpu.z80F &= ~(Z80_FLAG_ZERO | Z80_FLAG_SIGN | Z80_FLAG_HALF_CARRY | Z80_FLAG_OVERFLOW_PARITY | Z80_FLAG_NEGATIVE | Z80_FLAG_CARRY); ! 1328: cpu.z80F |= (cpu.z80D & Z80_FLAG_CARRY); ! 1329: cpu.z80D = (cpu.z80D >> 1); ! 1330: cpu.z80F |= bPostORFlags[cpu.z80D]; ! 1331: break; ! 1332: } ! 1333: case 0x3b: ! 1334: { ! 1335: sdwCyclesRemaining -= 8; ! 1336: cpu.z80F &= ~(Z80_FLAG_ZERO | Z80_FLAG_SIGN | Z80_FLAG_HALF_CARRY | Z80_FLAG_OVERFLOW_PARITY | Z80_FLAG_NEGATIVE | Z80_FLAG_CARRY); ! 1337: cpu.z80F |= (cpu.z80E & Z80_FLAG_CARRY); ! 1338: cpu.z80E = (cpu.z80E >> 1); ! 1339: cpu.z80F |= bPostORFlags[cpu.z80E]; ! 1340: break; ! 1341: } ! 1342: case 0x3c: ! 1343: { ! 1344: sdwCyclesRemaining -= 8; ! 1345: cpu.z80F &= ~(Z80_FLAG_ZERO | Z80_FLAG_SIGN | Z80_FLAG_HALF_CARRY | Z80_FLAG_OVERFLOW_PARITY | Z80_FLAG_NEGATIVE | Z80_FLAG_CARRY); ! 1346: cpu.z80F |= (cpu.z80H & Z80_FLAG_CARRY); ! 1347: cpu.z80H = (cpu.z80H >> 1); ! 1348: cpu.z80F |= bPostORFlags[cpu.z80H]; ! 1349: break; ! 1350: } ! 1351: case 0x3d: ! 1352: { ! 1353: sdwCyclesRemaining -= 8; ! 1354: cpu.z80F &= ~(Z80_FLAG_ZERO | Z80_FLAG_SIGN | Z80_FLAG_HALF_CARRY | Z80_FLAG_OVERFLOW_PARITY | Z80_FLAG_NEGATIVE | Z80_FLAG_CARRY); ! 1355: cpu.z80F |= (cpu.z80L & Z80_FLAG_CARRY); ! 1356: cpu.z80L = (cpu.z80L >> 1); ! 1357: cpu.z80F |= bPostORFlags[cpu.z80L]; ! 1358: break; ! 1359: } ! 1360: case 0x3e: ! 1361: { ! 1362: sdwCyclesRemaining -= 15; ! 1363: psMemRead = cpu.z80MemRead; /* Beginning of our handler */ ! 1364: while (psMemRead->lowAddr != 0xffffffff) ! 1365: { ! 1366: if ((cpu.z80HL >= psMemRead->lowAddr) && (cpu.z80HL <= psMemRead->highAddr)) ! 1367: { ! 1368: cpu.z80pc = (UINT32) pbPC - (UINT32) cpu.z80Base; ! 1369: if (psMemRead->memoryCall) ! 1370: { ! 1371: bTemp = psMemRead->memoryCall(cpu.z80HL, psMemRead); ! 1372: } ! 1373: else ! 1374: { ! 1375: bTemp = *((UINT8 *) psMemRead->pUserArea + (cpu.z80HL - psMemRead->lowAddr)); ! 1376: } ! 1377: psMemRead = NULL; ! 1378: break; ! 1379: } ! 1380: ++psMemRead; ! 1381: } ! 1382: ! 1383: if (psMemRead) ! 1384: { ! 1385: bTemp = cpu.z80Base[cpu.z80HL]; ! 1386: } ! 1387: ! 1388: cpu.z80F &= ~(Z80_FLAG_ZERO | Z80_FLAG_SIGN | Z80_FLAG_HALF_CARRY | Z80_FLAG_OVERFLOW_PARITY | Z80_FLAG_NEGATIVE | Z80_FLAG_CARRY); ! 1389: cpu.z80F |= (bTemp & Z80_FLAG_CARRY); ! 1390: bTemp = (bTemp >> 1); ! 1391: cpu.z80F |= bPostORFlags[bTemp]; ! 1392: psMemWrite = cpu.z80MemWrite; /* Beginning of our handler */ ! 1393: while (psMemWrite->lowAddr != 0xffffffff) ! 1394: { ! 1395: if ((cpu.z80HL >= psMemWrite->lowAddr) && (cpu.z80HL <= psMemWrite->highAddr)) ! 1396: { ! 1397: cpu.z80pc = (UINT32) pbPC - (UINT32) cpu.z80Base; ! 1398: if (psMemWrite->memoryCall) ! 1399: { ! 1400: psMemWrite->memoryCall(cpu.z80HL, bTemp, psMemWrite); ! 1401: } ! 1402: else ! 1403: { ! 1404: *((UINT8 *) psMemWrite->pUserArea + (cpu.z80HL - psMemWrite->lowAddr)) = bTemp; ! 1405: } ! 1406: psMemWrite = NULL; ! 1407: break; ! 1408: } ! 1409: ++psMemWrite; ! 1410: } ! 1411: ! 1412: if (psMemWrite) ! 1413: { ! 1414: cpu.z80Base[cpu.z80HL] = (UINT8) bTemp; ! 1415: } ! 1416: ! 1417: break; ! 1418: } ! 1419: case 0x3f: ! 1420: { ! 1421: sdwCyclesRemaining -= 8; ! 1422: cpu.z80F &= ~(Z80_FLAG_ZERO | Z80_FLAG_SIGN | Z80_FLAG_HALF_CARRY | Z80_FLAG_OVERFLOW_PARITY | Z80_FLAG_NEGATIVE | Z80_FLAG_CARRY); ! 1423: cpu.z80F |= (cpu.z80A & Z80_FLAG_CARRY); ! 1424: cpu.z80A = (cpu.z80A >> 1); ! 1425: cpu.z80F |= bPostORFlags[cpu.z80A]; ! 1426: break; ! 1427: } ! 1428: case 0x40: ! 1429: { ! 1430: sdwCyclesRemaining -= 8; ! 1431: cpu.z80F &= ~(Z80_FLAG_HALF_CARRY | Z80_FLAG_NEGATIVE | Z80_FLAG_ZERO); ! 1432: cpu.z80F |= (Z80_FLAG_HALF_CARRY); ! 1433: if (!(cpu.z80B & 0x01)) ! 1434: { ! 1435: cpu.z80F |= Z80_FLAG_ZERO; ! 1436: } ! 1437: break; ! 1438: } ! 1439: case 0x41: ! 1440: { ! 1441: sdwCyclesRemaining -= 8; ! 1442: cpu.z80F &= ~(Z80_FLAG_HALF_CARRY | Z80_FLAG_NEGATIVE | Z80_FLAG_ZERO); ! 1443: cpu.z80F |= (Z80_FLAG_HALF_CARRY); ! 1444: if (!(cpu.z80C & 0x01)) ! 1445: { ! 1446: cpu.z80F |= Z80_FLAG_ZERO; ! 1447: } ! 1448: break; ! 1449: } ! 1450: case 0x42: ! 1451: { ! 1452: sdwCyclesRemaining -= 8; ! 1453: cpu.z80F &= ~(Z80_FLAG_HALF_CARRY | Z80_FLAG_NEGATIVE | Z80_FLAG_ZERO); ! 1454: cpu.z80F |= (Z80_FLAG_HALF_CARRY); ! 1455: if (!(cpu.z80D & 0x01)) ! 1456: { ! 1457: cpu.z80F |= Z80_FLAG_ZERO; ! 1458: } ! 1459: break; ! 1460: } ! 1461: case 0x43: ! 1462: { ! 1463: sdwCyclesRemaining -= 8; ! 1464: cpu.z80F &= ~(Z80_FLAG_HALF_CARRY | Z80_FLAG_NEGATIVE | Z80_FLAG_ZERO); ! 1465: cpu.z80F |= (Z80_FLAG_HALF_CARRY); ! 1466: if (!(cpu.z80E & 0x01)) ! 1467: { ! 1468: cpu.z80F |= Z80_FLAG_ZERO; ! 1469: } ! 1470: break; ! 1471: } ! 1472: case 0x44: ! 1473: { ! 1474: sdwCyclesRemaining -= 8; ! 1475: cpu.z80F &= ~(Z80_FLAG_HALF_CARRY | Z80_FLAG_NEGATIVE | Z80_FLAG_ZERO); ! 1476: cpu.z80F |= (Z80_FLAG_HALF_CARRY); ! 1477: if (!(cpu.z80H & 0x01)) ! 1478: { ! 1479: cpu.z80F |= Z80_FLAG_ZERO; ! 1480: } ! 1481: break; ! 1482: } ! 1483: case 0x45: ! 1484: { ! 1485: sdwCyclesRemaining -= 8; ! 1486: cpu.z80F &= ~(Z80_FLAG_HALF_CARRY | Z80_FLAG_NEGATIVE | Z80_FLAG_ZERO); ! 1487: cpu.z80F |= (Z80_FLAG_HALF_CARRY); ! 1488: if (!(cpu.z80L & 0x01)) ! 1489: { ! 1490: cpu.z80F |= Z80_FLAG_ZERO; ! 1491: } ! 1492: break; ! 1493: } ! 1494: case 0x46: ! 1495: { ! 1496: sdwCyclesRemaining -= 12; ! 1497: psMemRead = cpu.z80MemRead; /* Beginning of our handler */ ! 1498: while (psMemRead->lowAddr != 0xffffffff) ! 1499: { ! 1500: if ((cpu.z80HL >= psMemRead->lowAddr) && (cpu.z80HL <= psMemRead->highAddr)) ! 1501: { ! 1502: cpu.z80pc = (UINT32) pbPC - (UINT32) cpu.z80Base; ! 1503: if (psMemRead->memoryCall) ! 1504: { ! 1505: bTemp = psMemRead->memoryCall(cpu.z80HL, psMemRead); ! 1506: } ! 1507: else ! 1508: { ! 1509: bTemp = *((UINT8 *) psMemRead->pUserArea + (cpu.z80HL - psMemRead->lowAddr)); ! 1510: } ! 1511: psMemRead = NULL; ! 1512: break; ! 1513: } ! 1514: ++psMemRead; ! 1515: } ! 1516: ! 1517: if (psMemRead) ! 1518: { ! 1519: bTemp = cpu.z80Base[cpu.z80HL]; ! 1520: } ! 1521: ! 1522: cpu.z80F &= ~(Z80_FLAG_HALF_CARRY | Z80_FLAG_NEGATIVE | Z80_FLAG_ZERO); ! 1523: cpu.z80F |= (Z80_FLAG_HALF_CARRY); ! 1524: if (!(bTemp & 0x01)) ! 1525: { ! 1526: cpu.z80F |= Z80_FLAG_ZERO; ! 1527: } ! 1528: break; ! 1529: } ! 1530: case 0x47: ! 1531: { ! 1532: sdwCyclesRemaining -= 8; ! 1533: cpu.z80F &= ~(Z80_FLAG_HALF_CARRY | Z80_FLAG_NEGATIVE | Z80_FLAG_ZERO); ! 1534: cpu.z80F |= (Z80_FLAG_HALF_CARRY); ! 1535: if (!(cpu.z80A & 0x01)) ! 1536: { ! 1537: cpu.z80F |= Z80_FLAG_ZERO; ! 1538: } ! 1539: break; ! 1540: } ! 1541: case 0x48: ! 1542: { ! 1543: sdwCyclesRemaining -= 8; ! 1544: cpu.z80F &= ~(Z80_FLAG_HALF_CARRY | Z80_FLAG_NEGATIVE | Z80_FLAG_ZERO); ! 1545: cpu.z80F |= (Z80_FLAG_HALF_CARRY); ! 1546: if (!(cpu.z80B & 0x02)) ! 1547: { ! 1548: cpu.z80F |= Z80_FLAG_ZERO; ! 1549: } ! 1550: break; ! 1551: } ! 1552: case 0x49: ! 1553: { ! 1554: sdwCyclesRemaining -= 8; ! 1555: cpu.z80F &= ~(Z80_FLAG_HALF_CARRY | Z80_FLAG_NEGATIVE | Z80_FLAG_ZERO); ! 1556: cpu.z80F |= (Z80_FLAG_HALF_CARRY); ! 1557: if (!(cpu.z80C & 0x02)) ! 1558: { ! 1559: cpu.z80F |= Z80_FLAG_ZERO; ! 1560: } ! 1561: break; ! 1562: } ! 1563: case 0x4a: ! 1564: { ! 1565: sdwCyclesRemaining -= 8; ! 1566: cpu.z80F &= ~(Z80_FLAG_HALF_CARRY | Z80_FLAG_NEGATIVE | Z80_FLAG_ZERO); ! 1567: cpu.z80F |= (Z80_FLAG_HALF_CARRY); ! 1568: if (!(cpu.z80D & 0x02)) ! 1569: { ! 1570: cpu.z80F |= Z80_FLAG_ZERO; ! 1571: } ! 1572: break; ! 1573: } ! 1574: case 0x4b: ! 1575: { ! 1576: sdwCyclesRemaining -= 8; ! 1577: cpu.z80F &= ~(Z80_FLAG_HALF_CARRY | Z80_FLAG_NEGATIVE | Z80_FLAG_ZERO); ! 1578: cpu.z80F |= (Z80_FLAG_HALF_CARRY); ! 1579: if (!(cpu.z80E & 0x02)) ! 1580: { ! 1581: cpu.z80F |= Z80_FLAG_ZERO; ! 1582: } ! 1583: break; ! 1584: } ! 1585: case 0x4c: ! 1586: { ! 1587: sdwCyclesRemaining -= 8; ! 1588: cpu.z80F &= ~(Z80_FLAG_HALF_CARRY | Z80_FLAG_NEGATIVE | Z80_FLAG_ZERO); ! 1589: cpu.z80F |= (Z80_FLAG_HALF_CARRY); ! 1590: if (!(cpu.z80H & 0x02)) ! 1591: { ! 1592: cpu.z80F |= Z80_FLAG_ZERO; ! 1593: } ! 1594: break; ! 1595: } ! 1596: case 0x4d: ! 1597: { ! 1598: sdwCyclesRemaining -= 8; ! 1599: cpu.z80F &= ~(Z80_FLAG_HALF_CARRY | Z80_FLAG_NEGATIVE | Z80_FLAG_ZERO); ! 1600: cpu.z80F |= (Z80_FLAG_HALF_CARRY); ! 1601: if (!(cpu.z80L & 0x02)) ! 1602: { ! 1603: cpu.z80F |= Z80_FLAG_ZERO; ! 1604: } ! 1605: break; ! 1606: } ! 1607: case 0x4e: ! 1608: { ! 1609: sdwCyclesRemaining -= 12; ! 1610: psMemRead = cpu.z80MemRead; /* Beginning of our handler */ ! 1611: while (psMemRead->lowAddr != 0xffffffff) ! 1612: { ! 1613: if ((cpu.z80HL >= psMemRead->lowAddr) && (cpu.z80HL <= psMemRead->highAddr)) ! 1614: { ! 1615: cpu.z80pc = (UINT32) pbPC - (UINT32) cpu.z80Base; ! 1616: if (psMemRead->memoryCall) ! 1617: { ! 1618: bTemp = psMemRead->memoryCall(cpu.z80HL, psMemRead); ! 1619: } ! 1620: else ! 1621: { ! 1622: bTemp = *((UINT8 *) psMemRead->pUserArea + (cpu.z80HL - psMemRead->lowAddr)); ! 1623: } ! 1624: psMemRead = NULL; ! 1625: break; ! 1626: } ! 1627: ++psMemRead; ! 1628: } ! 1629: ! 1630: if (psMemRead) ! 1631: { ! 1632: bTemp = cpu.z80Base[cpu.z80HL]; ! 1633: } ! 1634: ! 1635: cpu.z80F &= ~(Z80_FLAG_HALF_CARRY | Z80_FLAG_NEGATIVE | Z80_FLAG_ZERO); ! 1636: cpu.z80F |= (Z80_FLAG_HALF_CARRY); ! 1637: if (!(bTemp & 0x02)) ! 1638: { ! 1639: cpu.z80F |= Z80_FLAG_ZERO; ! 1640: } ! 1641: break; ! 1642: } ! 1643: case 0x4f: ! 1644: { ! 1645: sdwCyclesRemaining -= 8; ! 1646: cpu.z80F &= ~(Z80_FLAG_HALF_CARRY | Z80_FLAG_NEGATIVE | Z80_FLAG_ZERO); ! 1647: cpu.z80F |= (Z80_FLAG_HALF_CARRY); ! 1648: if (!(cpu.z80A & 0x02)) ! 1649: { ! 1650: cpu.z80F |= Z80_FLAG_ZERO; ! 1651: } ! 1652: break; ! 1653: } ! 1654: case 0x50: ! 1655: { ! 1656: sdwCyclesRemaining -= 8; ! 1657: cpu.z80F &= ~(Z80_FLAG_HALF_CARRY | Z80_FLAG_NEGATIVE | Z80_FLAG_ZERO); ! 1658: cpu.z80F |= (Z80_FLAG_HALF_CARRY); ! 1659: if (!(cpu.z80B & 0x04)) ! 1660: { ! 1661: cpu.z80F |= Z80_FLAG_ZERO; ! 1662: } ! 1663: break; ! 1664: } ! 1665: case 0x51: ! 1666: { ! 1667: sdwCyclesRemaining -= 8; ! 1668: cpu.z80F &= ~(Z80_FLAG_HALF_CARRY | Z80_FLAG_NEGATIVE | Z80_FLAG_ZERO); ! 1669: cpu.z80F |= (Z80_FLAG_HALF_CARRY); ! 1670: if (!(cpu.z80C & 0x04)) ! 1671: { ! 1672: cpu.z80F |= Z80_FLAG_ZERO; ! 1673: } ! 1674: break; ! 1675: } ! 1676: case 0x52: ! 1677: { ! 1678: sdwCyclesRemaining -= 8; ! 1679: cpu.z80F &= ~(Z80_FLAG_HALF_CARRY | Z80_FLAG_NEGATIVE | Z80_FLAG_ZERO); ! 1680: cpu.z80F |= (Z80_FLAG_HALF_CARRY); ! 1681: if (!(cpu.z80D & 0x04)) ! 1682: { ! 1683: cpu.z80F |= Z80_FLAG_ZERO; ! 1684: } ! 1685: break; ! 1686: } ! 1687: case 0x53: ! 1688: { ! 1689: sdwCyclesRemaining -= 8; ! 1690: cpu.z80F &= ~(Z80_FLAG_HALF_CARRY | Z80_FLAG_NEGATIVE | Z80_FLAG_ZERO); ! 1691: cpu.z80F |= (Z80_FLAG_HALF_CARRY); ! 1692: if (!(cpu.z80E & 0x04)) ! 1693: { ! 1694: cpu.z80F |= Z80_FLAG_ZERO; ! 1695: } ! 1696: break; ! 1697: } ! 1698: case 0x54: ! 1699: { ! 1700: sdwCyclesRemaining -= 8; ! 1701: cpu.z80F &= ~(Z80_FLAG_HALF_CARRY | Z80_FLAG_NEGATIVE | Z80_FLAG_ZERO); ! 1702: cpu.z80F |= (Z80_FLAG_HALF_CARRY); ! 1703: if (!(cpu.z80H & 0x04)) ! 1704: { ! 1705: cpu.z80F |= Z80_FLAG_ZERO; ! 1706: } ! 1707: break; ! 1708: } ! 1709: case 0x55: ! 1710: { ! 1711: sdwCyclesRemaining -= 8; ! 1712: cpu.z80F &= ~(Z80_FLAG_HALF_CARRY | Z80_FLAG_NEGATIVE | Z80_FLAG_ZERO); ! 1713: cpu.z80F |= (Z80_FLAG_HALF_CARRY); ! 1714: if (!(cpu.z80L & 0x04)) ! 1715: { ! 1716: cpu.z80F |= Z80_FLAG_ZERO; ! 1717: } ! 1718: break; ! 1719: } ! 1720: case 0x56: ! 1721: { ! 1722: sdwCyclesRemaining -= 12; ! 1723: psMemRead = cpu.z80MemRead; /* Beginning of our handler */ ! 1724: while (psMemRead->lowAddr != 0xffffffff) ! 1725: { ! 1726: if ((cpu.z80HL >= psMemRead->lowAddr) && (cpu.z80HL <= psMemRead->highAddr)) ! 1727: { ! 1728: cpu.z80pc = (UINT32) pbPC - (UINT32) cpu.z80Base; ! 1729: if (psMemRead->memoryCall) ! 1730: { ! 1731: bTemp = psMemRead->memoryCall(cpu.z80HL, psMemRead); ! 1732: } ! 1733: else ! 1734: { ! 1735: bTemp = *((UINT8 *) psMemRead->pUserArea + (cpu.z80HL - psMemRead->lowAddr)); ! 1736: } ! 1737: psMemRead = NULL; ! 1738: break; ! 1739: } ! 1740: ++psMemRead; ! 1741: } ! 1742: ! 1743: if (psMemRead) ! 1744: { ! 1745: bTemp = cpu.z80Base[cpu.z80HL]; ! 1746: } ! 1747: ! 1748: cpu.z80F &= ~(Z80_FLAG_HALF_CARRY | Z80_FLAG_NEGATIVE | Z80_FLAG_ZERO); ! 1749: cpu.z80F |= (Z80_FLAG_HALF_CARRY); ! 1750: if (!(bTemp & 0x04)) ! 1751: { ! 1752: cpu.z80F |= Z80_FLAG_ZERO; ! 1753: } ! 1754: break; ! 1755: } ! 1756: case 0x57: ! 1757: { ! 1758: sdwCyclesRemaining -= 8; ! 1759: cpu.z80F &= ~(Z80_FLAG_HALF_CARRY | Z80_FLAG_NEGATIVE | Z80_FLAG_ZERO); ! 1760: cpu.z80F |= (Z80_FLAG_HALF_CARRY); ! 1761: if (!(cpu.z80A & 0x04)) ! 1762: { ! 1763: cpu.z80F |= Z80_FLAG_ZERO; ! 1764: } ! 1765: break; ! 1766: } ! 1767: case 0x58: ! 1768: { ! 1769: sdwCyclesRemaining -= 8; ! 1770: cpu.z80F &= ~(Z80_FLAG_HALF_CARRY | Z80_FLAG_NEGATIVE | Z80_FLAG_ZERO); ! 1771: cpu.z80F |= (Z80_FLAG_HALF_CARRY); ! 1772: if (!(cpu.z80B & 0x08)) ! 1773: { ! 1774: cpu.z80F |= Z80_FLAG_ZERO; ! 1775: } ! 1776: break; ! 1777: } ! 1778: case 0x59: ! 1779: { ! 1780: sdwCyclesRemaining -= 8; ! 1781: cpu.z80F &= ~(Z80_FLAG_HALF_CARRY | Z80_FLAG_NEGATIVE | Z80_FLAG_ZERO); ! 1782: cpu.z80F |= (Z80_FLAG_HALF_CARRY); ! 1783: if (!(cpu.z80C & 0x08)) ! 1784: { ! 1785: cpu.z80F |= Z80_FLAG_ZERO; ! 1786: } ! 1787: break; ! 1788: } ! 1789: case 0x5a: ! 1790: { ! 1791: sdwCyclesRemaining -= 8; ! 1792: cpu.z80F &= ~(Z80_FLAG_HALF_CARRY | Z80_FLAG_NEGATIVE | Z80_FLAG_ZERO); ! 1793: cpu.z80F |= (Z80_FLAG_HALF_CARRY); ! 1794: if (!(cpu.z80D & 0x08)) ! 1795: { ! 1796: cpu.z80F |= Z80_FLAG_ZERO; ! 1797: } ! 1798: break; ! 1799: } ! 1800: case 0x5b: ! 1801: { ! 1802: sdwCyclesRemaining -= 8; ! 1803: cpu.z80F &= ~(Z80_FLAG_HALF_CARRY | Z80_FLAG_NEGATIVE | Z80_FLAG_ZERO); ! 1804: cpu.z80F |= (Z80_FLAG_HALF_CARRY); ! 1805: if (!(cpu.z80E & 0x08)) ! 1806: { ! 1807: cpu.z80F |= Z80_FLAG_ZERO; ! 1808: } ! 1809: break; ! 1810: } ! 1811: case 0x5c: ! 1812: { ! 1813: sdwCyclesRemaining -= 8; ! 1814: cpu.z80F &= ~(Z80_FLAG_HALF_CARRY | Z80_FLAG_NEGATIVE | Z80_FLAG_ZERO); ! 1815: cpu.z80F |= (Z80_FLAG_HALF_CARRY); ! 1816: if (!(cpu.z80H & 0x08)) ! 1817: { ! 1818: cpu.z80F |= Z80_FLAG_ZERO; ! 1819: } ! 1820: break; ! 1821: } ! 1822: case 0x5d: ! 1823: { ! 1824: sdwCyclesRemaining -= 8; ! 1825: cpu.z80F &= ~(Z80_FLAG_HALF_CARRY | Z80_FLAG_NEGATIVE | Z80_FLAG_ZERO); ! 1826: cpu.z80F |= (Z80_FLAG_HALF_CARRY); ! 1827: if (!(cpu.z80L & 0x08)) ! 1828: { ! 1829: cpu.z80F |= Z80_FLAG_ZERO; ! 1830: } ! 1831: break; ! 1832: } ! 1833: case 0x5e: ! 1834: { ! 1835: sdwCyclesRemaining -= 12; ! 1836: psMemRead = cpu.z80MemRead; /* Beginning of our handler */ ! 1837: while (psMemRead->lowAddr != 0xffffffff) ! 1838: { ! 1839: if ((cpu.z80HL >= psMemRead->lowAddr) && (cpu.z80HL <= psMemRead->highAddr)) ! 1840: { ! 1841: cpu.z80pc = (UINT32) pbPC - (UINT32) cpu.z80Base; ! 1842: if (psMemRead->memoryCall) ! 1843: { ! 1844: bTemp = psMemRead->memoryCall(cpu.z80HL, psMemRead); ! 1845: } ! 1846: else ! 1847: { ! 1848: bTemp = *((UINT8 *) psMemRead->pUserArea + (cpu.z80HL - psMemRead->lowAddr)); ! 1849: } ! 1850: psMemRead = NULL; ! 1851: break; ! 1852: } ! 1853: ++psMemRead; ! 1854: } ! 1855: ! 1856: if (psMemRead) ! 1857: { ! 1858: bTemp = cpu.z80Base[cpu.z80HL]; ! 1859: } ! 1860: ! 1861: cpu.z80F &= ~(Z80_FLAG_HALF_CARRY | Z80_FLAG_NEGATIVE | Z80_FLAG_ZERO); ! 1862: cpu.z80F |= (Z80_FLAG_HALF_CARRY); ! 1863: if (!(bTemp & 0x08)) ! 1864: { ! 1865: cpu.z80F |= Z80_FLAG_ZERO; ! 1866: } ! 1867: break; ! 1868: } ! 1869: case 0x5f: ! 1870: { ! 1871: sdwCyclesRemaining -= 8; ! 1872: cpu.z80F &= ~(Z80_FLAG_HALF_CARRY | Z80_FLAG_NEGATIVE | Z80_FLAG_ZERO); ! 1873: cpu.z80F |= (Z80_FLAG_HALF_CARRY); ! 1874: if (!(cpu.z80A & 0x08)) ! 1875: { ! 1876: cpu.z80F |= Z80_FLAG_ZERO; ! 1877: } ! 1878: break; ! 1879: } ! 1880: case 0x60: ! 1881: { ! 1882: sdwCyclesRemaining -= 8; ! 1883: cpu.z80F &= ~(Z80_FLAG_HALF_CARRY | Z80_FLAG_NEGATIVE | Z80_FLAG_ZERO); ! 1884: cpu.z80F |= (Z80_FLAG_HALF_CARRY); ! 1885: if (!(cpu.z80B & 0x10)) ! 1886: { ! 1887: cpu.z80F |= Z80_FLAG_ZERO; ! 1888: } ! 1889: break; ! 1890: } ! 1891: case 0x61: ! 1892: { ! 1893: sdwCyclesRemaining -= 8; ! 1894: cpu.z80F &= ~(Z80_FLAG_HALF_CARRY | Z80_FLAG_NEGATIVE | Z80_FLAG_ZERO); ! 1895: cpu.z80F |= (Z80_FLAG_HALF_CARRY); ! 1896: if (!(cpu.z80C & 0x10)) ! 1897: { ! 1898: cpu.z80F |= Z80_FLAG_ZERO; ! 1899: } ! 1900: break; ! 1901: } ! 1902: case 0x62: ! 1903: { ! 1904: sdwCyclesRemaining -= 8; ! 1905: cpu.z80F &= ~(Z80_FLAG_HALF_CARRY | Z80_FLAG_NEGATIVE | Z80_FLAG_ZERO); ! 1906: cpu.z80F |= (Z80_FLAG_HALF_CARRY); ! 1907: if (!(cpu.z80D & 0x10)) ! 1908: { ! 1909: cpu.z80F |= Z80_FLAG_ZERO; ! 1910: } ! 1911: break; ! 1912: } ! 1913: case 0x63: ! 1914: { ! 1915: sdwCyclesRemaining -= 8; ! 1916: cpu.z80F &= ~(Z80_FLAG_HALF_CARRY | Z80_FLAG_NEGATIVE | Z80_FLAG_ZERO); ! 1917: cpu.z80F |= (Z80_FLAG_HALF_CARRY); ! 1918: if (!(cpu.z80E & 0x10)) ! 1919: { ! 1920: cpu.z80F |= Z80_FLAG_ZERO; ! 1921: } ! 1922: break; ! 1923: } ! 1924: case 0x64: ! 1925: { ! 1926: sdwCyclesRemaining -= 8; ! 1927: cpu.z80F &= ~(Z80_FLAG_HALF_CARRY | Z80_FLAG_NEGATIVE | Z80_FLAG_ZERO); ! 1928: cpu.z80F |= (Z80_FLAG_HALF_CARRY); ! 1929: if (!(cpu.z80H & 0x10)) ! 1930: { ! 1931: cpu.z80F |= Z80_FLAG_ZERO; ! 1932: } ! 1933: break; ! 1934: } ! 1935: case 0x65: ! 1936: { ! 1937: sdwCyclesRemaining -= 8; ! 1938: cpu.z80F &= ~(Z80_FLAG_HALF_CARRY | Z80_FLAG_NEGATIVE | Z80_FLAG_ZERO); ! 1939: cpu.z80F |= (Z80_FLAG_HALF_CARRY); ! 1940: if (!(cpu.z80L & 0x10)) ! 1941: { ! 1942: cpu.z80F |= Z80_FLAG_ZERO; ! 1943: } ! 1944: break; ! 1945: } ! 1946: case 0x66: ! 1947: { ! 1948: sdwCyclesRemaining -= 12; ! 1949: psMemRead = cpu.z80MemRead; /* Beginning of our handler */ ! 1950: while (psMemRead->lowAddr != 0xffffffff) ! 1951: { ! 1952: if ((cpu.z80HL >= psMemRead->lowAddr) && (cpu.z80HL <= psMemRead->highAddr)) ! 1953: { ! 1954: cpu.z80pc = (UINT32) pbPC - (UINT32) cpu.z80Base; ! 1955: if (psMemRead->memoryCall) ! 1956: { ! 1957: bTemp = psMemRead->memoryCall(cpu.z80HL, psMemRead); ! 1958: } ! 1959: else ! 1960: { ! 1961: bTemp = *((UINT8 *) psMemRead->pUserArea + (cpu.z80HL - psMemRead->lowAddr)); ! 1962: } ! 1963: psMemRead = NULL; ! 1964: break; ! 1965: } ! 1966: ++psMemRead; ! 1967: } ! 1968: ! 1969: if (psMemRead) ! 1970: { ! 1971: bTemp = cpu.z80Base[cpu.z80HL]; ! 1972: } ! 1973: ! 1974: cpu.z80F &= ~(Z80_FLAG_HALF_CARRY | Z80_FLAG_NEGATIVE | Z80_FLAG_ZERO); ! 1975: cpu.z80F |= (Z80_FLAG_HALF_CARRY); ! 1976: if (!(bTemp & 0x10)) ! 1977: { ! 1978: cpu.z80F |= Z80_FLAG_ZERO; ! 1979: } ! 1980: break; ! 1981: } ! 1982: case 0x67: ! 1983: { ! 1984: sdwCyclesRemaining -= 8; ! 1985: cpu.z80F &= ~(Z80_FLAG_HALF_CARRY | Z80_FLAG_NEGATIVE | Z80_FLAG_ZERO); ! 1986: cpu.z80F |= (Z80_FLAG_HALF_CARRY); ! 1987: if (!(cpu.z80A & 0x10)) ! 1988: { ! 1989: cpu.z80F |= Z80_FLAG_ZERO; ! 1990: } ! 1991: break; ! 1992: } ! 1993: case 0x68: ! 1994: { ! 1995: sdwCyclesRemaining -= 8; ! 1996: cpu.z80F &= ~(Z80_FLAG_HALF_CARRY | Z80_FLAG_NEGATIVE | Z80_FLAG_ZERO); ! 1997: cpu.z80F |= (Z80_FLAG_HALF_CARRY); ! 1998: if (!(cpu.z80B & 0x20)) ! 1999: { ! 2000: cpu.z80F |= Z80_FLAG_ZERO; ! 2001: } ! 2002: break; ! 2003: } ! 2004: case 0x69: ! 2005: { ! 2006: sdwCyclesRemaining -= 8; ! 2007: cpu.z80F &= ~(Z80_FLAG_HALF_CARRY | Z80_FLAG_NEGATIVE | Z80_FLAG_ZERO); ! 2008: cpu.z80F |= (Z80_FLAG_HALF_CARRY); ! 2009: if (!(cpu.z80C & 0x20)) ! 2010: { ! 2011: cpu.z80F |= Z80_FLAG_ZERO; ! 2012: } ! 2013: break; ! 2014: } ! 2015: case 0x6a: ! 2016: { ! 2017: sdwCyclesRemaining -= 8; ! 2018: cpu.z80F &= ~(Z80_FLAG_HALF_CARRY | Z80_FLAG_NEGATIVE | Z80_FLAG_ZERO); ! 2019: cpu.z80F |= (Z80_FLAG_HALF_CARRY); ! 2020: if (!(cpu.z80D & 0x20)) ! 2021: { ! 2022: cpu.z80F |= Z80_FLAG_ZERO; ! 2023: } ! 2024: break; ! 2025: } ! 2026: case 0x6b: ! 2027: { ! 2028: sdwCyclesRemaining -= 8; ! 2029: cpu.z80F &= ~(Z80_FLAG_HALF_CARRY | Z80_FLAG_NEGATIVE | Z80_FLAG_ZERO); ! 2030: cpu.z80F |= (Z80_FLAG_HALF_CARRY); ! 2031: if (!(cpu.z80E & 0x20)) ! 2032: { ! 2033: cpu.z80F |= Z80_FLAG_ZERO; ! 2034: } ! 2035: break; ! 2036: } ! 2037: case 0x6c: ! 2038: { ! 2039: sdwCyclesRemaining -= 8; ! 2040: cpu.z80F &= ~(Z80_FLAG_HALF_CARRY | Z80_FLAG_NEGATIVE | Z80_FLAG_ZERO); ! 2041: cpu.z80F |= (Z80_FLAG_HALF_CARRY); ! 2042: if (!(cpu.z80H & 0x20)) ! 2043: { ! 2044: cpu.z80F |= Z80_FLAG_ZERO; ! 2045: } ! 2046: break; ! 2047: } ! 2048: case 0x6d: ! 2049: { ! 2050: sdwCyclesRemaining -= 8; ! 2051: cpu.z80F &= ~(Z80_FLAG_HALF_CARRY | Z80_FLAG_NEGATIVE | Z80_FLAG_ZERO); ! 2052: cpu.z80F |= (Z80_FLAG_HALF_CARRY); ! 2053: if (!(cpu.z80L & 0x20)) ! 2054: { ! 2055: cpu.z80F |= Z80_FLAG_ZERO; ! 2056: } ! 2057: break; ! 2058: } ! 2059: case 0x6e: ! 2060: { ! 2061: sdwCyclesRemaining -= 12; ! 2062: psMemRead = cpu.z80MemRead; /* Beginning of our handler */ ! 2063: while (psMemRead->lowAddr != 0xffffffff) ! 2064: { ! 2065: if ((cpu.z80HL >= psMemRead->lowAddr) && (cpu.z80HL <= psMemRead->highAddr)) ! 2066: { ! 2067: cpu.z80pc = (UINT32) pbPC - (UINT32) cpu.z80Base; ! 2068: if (psMemRead->memoryCall) ! 2069: { ! 2070: bTemp = psMemRead->memoryCall(cpu.z80HL, psMemRead); ! 2071: } ! 2072: else ! 2073: { ! 2074: bTemp = *((UINT8 *) psMemRead->pUserArea + (cpu.z80HL - psMemRead->lowAddr)); ! 2075: } ! 2076: psMemRead = NULL; ! 2077: break; ! 2078: } ! 2079: ++psMemRead; ! 2080: } ! 2081: ! 2082: if (psMemRead) ! 2083: { ! 2084: bTemp = cpu.z80Base[cpu.z80HL]; ! 2085: } ! 2086: ! 2087: cpu.z80F &= ~(Z80_FLAG_HALF_CARRY | Z80_FLAG_NEGATIVE | Z80_FLAG_ZERO); ! 2088: cpu.z80F |= (Z80_FLAG_HALF_CARRY); ! 2089: if (!(bTemp & 0x20)) ! 2090: { ! 2091: cpu.z80F |= Z80_FLAG_ZERO; ! 2092: } ! 2093: break; ! 2094: } ! 2095: case 0x6f: ! 2096: { ! 2097: sdwCyclesRemaining -= 8; ! 2098: cpu.z80F &= ~(Z80_FLAG_HALF_CARRY | Z80_FLAG_NEGATIVE | Z80_FLAG_ZERO); ! 2099: cpu.z80F |= (Z80_FLAG_HALF_CARRY); ! 2100: if (!(cpu.z80A & 0x20)) ! 2101: { ! 2102: cpu.z80F |= Z80_FLAG_ZERO; ! 2103: } ! 2104: break; ! 2105: } ! 2106: case 0x70: ! 2107: { ! 2108: sdwCyclesRemaining -= 8; ! 2109: cpu.z80F &= ~(Z80_FLAG_HALF_CARRY | Z80_FLAG_NEGATIVE | Z80_FLAG_ZERO); ! 2110: cpu.z80F |= (Z80_FLAG_HALF_CARRY); ! 2111: if (!(cpu.z80B & 0x40)) ! 2112: { ! 2113: cpu.z80F |= Z80_FLAG_ZERO; ! 2114: } ! 2115: break; ! 2116: } ! 2117: case 0x71: ! 2118: { ! 2119: sdwCyclesRemaining -= 8; ! 2120: cpu.z80F &= ~(Z80_FLAG_HALF_CARRY | Z80_FLAG_NEGATIVE | Z80_FLAG_ZERO); ! 2121: cpu.z80F |= (Z80_FLAG_HALF_CARRY); ! 2122: if (!(cpu.z80C & 0x40)) ! 2123: { ! 2124: cpu.z80F |= Z80_FLAG_ZERO; ! 2125: } ! 2126: break; ! 2127: } ! 2128: case 0x72: ! 2129: { ! 2130: sdwCyclesRemaining -= 8; ! 2131: cpu.z80F &= ~(Z80_FLAG_HALF_CARRY | Z80_FLAG_NEGATIVE | Z80_FLAG_ZERO); ! 2132: cpu.z80F |= (Z80_FLAG_HALF_CARRY); ! 2133: if (!(cpu.z80D & 0x40)) ! 2134: { ! 2135: cpu.z80F |= Z80_FLAG_ZERO; ! 2136: } ! 2137: break; ! 2138: } ! 2139: case 0x73: ! 2140: { ! 2141: sdwCyclesRemaining -= 8; ! 2142: cpu.z80F &= ~(Z80_FLAG_HALF_CARRY | Z80_FLAG_NEGATIVE | Z80_FLAG_ZERO); ! 2143: cpu.z80F |= (Z80_FLAG_HALF_CARRY); ! 2144: if (!(cpu.z80E & 0x40)) ! 2145: { ! 2146: cpu.z80F |= Z80_FLAG_ZERO; ! 2147: } ! 2148: break; ! 2149: } ! 2150: case 0x74: ! 2151: { ! 2152: sdwCyclesRemaining -= 8; ! 2153: cpu.z80F &= ~(Z80_FLAG_HALF_CARRY | Z80_FLAG_NEGATIVE | Z80_FLAG_ZERO); ! 2154: cpu.z80F |= (Z80_FLAG_HALF_CARRY); ! 2155: if (!(cpu.z80H & 0x40)) ! 2156: { ! 2157: cpu.z80F |= Z80_FLAG_ZERO; ! 2158: } ! 2159: break; ! 2160: } ! 2161: case 0x75: ! 2162: { ! 2163: sdwCyclesRemaining -= 8; ! 2164: cpu.z80F &= ~(Z80_FLAG_HALF_CARRY | Z80_FLAG_NEGATIVE | Z80_FLAG_ZERO); ! 2165: cpu.z80F |= (Z80_FLAG_HALF_CARRY); ! 2166: if (!(cpu.z80L & 0x40)) ! 2167: { ! 2168: cpu.z80F |= Z80_FLAG_ZERO; ! 2169: } ! 2170: break; ! 2171: } ! 2172: case 0x76: ! 2173: { ! 2174: sdwCyclesRemaining -= 12; ! 2175: psMemRead = cpu.z80MemRead; /* Beginning of our handler */ ! 2176: while (psMemRead->lowAddr != 0xffffffff) ! 2177: { ! 2178: if ((cpu.z80HL >= psMemRead->lowAddr) && (cpu.z80HL <= psMemRead->highAddr)) ! 2179: { ! 2180: cpu.z80pc = (UINT32) pbPC - (UINT32) cpu.z80Base; ! 2181: if (psMemRead->memoryCall) ! 2182: { ! 2183: bTemp = psMemRead->memoryCall(cpu.z80HL, psMemRead); ! 2184: } ! 2185: else ! 2186: { ! 2187: bTemp = *((UINT8 *) psMemRead->pUserArea + (cpu.z80HL - psMemRead->lowAddr)); ! 2188: } ! 2189: psMemRead = NULL; ! 2190: break; ! 2191: } ! 2192: ++psMemRead; ! 2193: } ! 2194: ! 2195: if (psMemRead) ! 2196: { ! 2197: bTemp = cpu.z80Base[cpu.z80HL]; ! 2198: } ! 2199: ! 2200: cpu.z80F &= ~(Z80_FLAG_HALF_CARRY | Z80_FLAG_NEGATIVE | Z80_FLAG_ZERO); ! 2201: cpu.z80F |= (Z80_FLAG_HALF_CARRY); ! 2202: if (!(bTemp & 0x40)) ! 2203: { ! 2204: cpu.z80F |= Z80_FLAG_ZERO; ! 2205: } ! 2206: break; ! 2207: } ! 2208: case 0x77: ! 2209: { ! 2210: sdwCyclesRemaining -= 8; ! 2211: cpu.z80F &= ~(Z80_FLAG_HALF_CARRY | Z80_FLAG_NEGATIVE | Z80_FLAG_ZERO); ! 2212: cpu.z80F |= (Z80_FLAG_HALF_CARRY); ! 2213: if (!(cpu.z80A & 0x40)) ! 2214: { ! 2215: cpu.z80F |= Z80_FLAG_ZERO; ! 2216: } ! 2217: break; ! 2218: } ! 2219: case 0x78: ! 2220: { ! 2221: sdwCyclesRemaining -= 8; ! 2222: cpu.z80F &= ~(Z80_FLAG_HALF_CARRY | Z80_FLAG_NEGATIVE | Z80_FLAG_ZERO); ! 2223: cpu.z80F |= (Z80_FLAG_HALF_CARRY); ! 2224: if (!(cpu.z80B & 0x80)) ! 2225: { ! 2226: cpu.z80F |= Z80_FLAG_ZERO; ! 2227: } ! 2228: break; ! 2229: } ! 2230: case 0x79: ! 2231: { ! 2232: sdwCyclesRemaining -= 8; ! 2233: cpu.z80F &= ~(Z80_FLAG_HALF_CARRY | Z80_FLAG_NEGATIVE | Z80_FLAG_ZERO); ! 2234: cpu.z80F |= (Z80_FLAG_HALF_CARRY); ! 2235: if (!(cpu.z80C & 0x80)) ! 2236: { ! 2237: cpu.z80F |= Z80_FLAG_ZERO; ! 2238: } ! 2239: break; ! 2240: } ! 2241: case 0x7a: ! 2242: { ! 2243: sdwCyclesRemaining -= 8; ! 2244: cpu.z80F &= ~(Z80_FLAG_HALF_CARRY | Z80_FLAG_NEGATIVE | Z80_FLAG_ZERO); ! 2245: cpu.z80F |= (Z80_FLAG_HALF_CARRY); ! 2246: if (!(cpu.z80D & 0x80)) ! 2247: { ! 2248: cpu.z80F |= Z80_FLAG_ZERO; ! 2249: } ! 2250: break; ! 2251: } ! 2252: case 0x7b: ! 2253: { ! 2254: sdwCyclesRemaining -= 8; ! 2255: cpu.z80F &= ~(Z80_FLAG_HALF_CARRY | Z80_FLAG_NEGATIVE | Z80_FLAG_ZERO); ! 2256: cpu.z80F |= (Z80_FLAG_HALF_CARRY); ! 2257: if (!(cpu.z80E & 0x80)) ! 2258: { ! 2259: cpu.z80F |= Z80_FLAG_ZERO; ! 2260: } ! 2261: break; ! 2262: } ! 2263: case 0x7c: ! 2264: { ! 2265: sdwCyclesRemaining -= 8; ! 2266: cpu.z80F &= ~(Z80_FLAG_HALF_CARRY | Z80_FLAG_NEGATIVE | Z80_FLAG_ZERO); ! 2267: cpu.z80F |= (Z80_FLAG_HALF_CARRY); ! 2268: if (!(cpu.z80H & 0x80)) ! 2269: { ! 2270: cpu.z80F |= Z80_FLAG_ZERO; ! 2271: } ! 2272: break; ! 2273: } ! 2274: case 0x7d: ! 2275: { ! 2276: sdwCyclesRemaining -= 8; ! 2277: cpu.z80F &= ~(Z80_FLAG_HALF_CARRY | Z80_FLAG_NEGATIVE | Z80_FLAG_ZERO); ! 2278: cpu.z80F |= (Z80_FLAG_HALF_CARRY); ! 2279: if (!(cpu.z80L & 0x80)) ! 2280: { ! 2281: cpu.z80F |= Z80_FLAG_ZERO; ! 2282: } ! 2283: break; ! 2284: } ! 2285: case 0x7e: ! 2286: { ! 2287: sdwCyclesRemaining -= 12; ! 2288: psMemRead = cpu.z80MemRead; /* Beginning of our handler */ ! 2289: while (psMemRead->lowAddr != 0xffffffff) ! 2290: { ! 2291: if ((cpu.z80HL >= psMemRead->lowAddr) && (cpu.z80HL <= psMemRead->highAddr)) ! 2292: { ! 2293: cpu.z80pc = (UINT32) pbPC - (UINT32) cpu.z80Base; ! 2294: if (psMemRead->memoryCall) ! 2295: { ! 2296: bTemp = psMemRead->memoryCall(cpu.z80HL, psMemRead); ! 2297: } ! 2298: else ! 2299: { ! 2300: bTemp = *((UINT8 *) psMemRead->pUserArea + (cpu.z80HL - psMemRead->lowAddr)); ! 2301: } ! 2302: psMemRead = NULL; ! 2303: break; ! 2304: } ! 2305: ++psMemRead; ! 2306: } ! 2307: ! 2308: if (psMemRead) ! 2309: { ! 2310: bTemp = cpu.z80Base[cpu.z80HL]; ! 2311: } ! 2312: ! 2313: cpu.z80F &= ~(Z80_FLAG_HALF_CARRY | Z80_FLAG_NEGATIVE | Z80_FLAG_ZERO); ! 2314: cpu.z80F |= (Z80_FLAG_HALF_CARRY); ! 2315: if (!(bTemp & 0x80)) ! 2316: { ! 2317: cpu.z80F |= Z80_FLAG_ZERO; ! 2318: } ! 2319: break; ! 2320: } ! 2321: case 0x7f: ! 2322: { ! 2323: sdwCyclesRemaining -= 8; ! 2324: cpu.z80F &= ~(Z80_FLAG_HALF_CARRY | Z80_FLAG_NEGATIVE | Z80_FLAG_ZERO); ! 2325: cpu.z80F |= (Z80_FLAG_HALF_CARRY); ! 2326: if (!(cpu.z80A & 0x80)) ! 2327: { ! 2328: cpu.z80F |= Z80_FLAG_ZERO; ! 2329: } ! 2330: break; ! 2331: } ! 2332: case 0x80: ! 2333: { ! 2334: sdwCyclesRemaining -= 8; ! 2335: cpu.z80B &= 0xfe; ! 2336: break; ! 2337: } ! 2338: case 0x81: ! 2339: { ! 2340: sdwCyclesRemaining -= 8; ! 2341: cpu.z80C &= 0xfe; ! 2342: break; ! 2343: } ! 2344: case 0x82: ! 2345: { ! 2346: sdwCyclesRemaining -= 8; ! 2347: cpu.z80D &= 0xfe; ! 2348: break; ! 2349: } ! 2350: case 0x83: ! 2351: { ! 2352: sdwCyclesRemaining -= 8; ! 2353: cpu.z80E &= 0xfe; ! 2354: break; ! 2355: } ! 2356: case 0x84: ! 2357: { ! 2358: sdwCyclesRemaining -= 8; ! 2359: cpu.z80H &= 0xfe; ! 2360: break; ! 2361: } ! 2362: case 0x85: ! 2363: { ! 2364: sdwCyclesRemaining -= 8; ! 2365: cpu.z80L &= 0xfe; ! 2366: break; ! 2367: } ! 2368: case 0x86: ! 2369: { ! 2370: sdwCyclesRemaining -= 15; ! 2371: psMemRead = cpu.z80MemRead; /* Beginning of our handler */ ! 2372: while (psMemRead->lowAddr != 0xffffffff) ! 2373: { ! 2374: if ((cpu.z80HL >= psMemRead->lowAddr) && (cpu.z80HL <= psMemRead->highAddr)) ! 2375: { ! 2376: cpu.z80pc = (UINT32) pbPC - (UINT32) cpu.z80Base; ! 2377: if (psMemRead->memoryCall) ! 2378: { ! 2379: bTemp = psMemRead->memoryCall(cpu.z80HL, psMemRead); ! 2380: } ! 2381: else ! 2382: { ! 2383: bTemp = *((UINT8 *) psMemRead->pUserArea + (cpu.z80HL - psMemRead->lowAddr)); ! 2384: } ! 2385: psMemRead = NULL; ! 2386: break; ! 2387: } ! 2388: ++psMemRead; ! 2389: } ! 2390: ! 2391: if (psMemRead) ! 2392: { ! 2393: bTemp = cpu.z80Base[cpu.z80HL]; ! 2394: } ! 2395: ! 2396: bTemp &= 0xfe; ! 2397: psMemWrite = cpu.z80MemWrite; /* Beginning of our handler */ ! 2398: while (psMemWrite->lowAddr != 0xffffffff) ! 2399: { ! 2400: if ((cpu.z80HL >= psMemWrite->lowAddr) && (cpu.z80HL <= psMemWrite->highAddr)) ! 2401: { ! 2402: cpu.z80pc = (UINT32) pbPC - (UINT32) cpu.z80Base; ! 2403: if (psMemWrite->memoryCall) ! 2404: { ! 2405: psMemWrite->memoryCall(cpu.z80HL, bTemp, psMemWrite); ! 2406: } ! 2407: else ! 2408: { ! 2409: *((UINT8 *) psMemWrite->pUserArea + (cpu.z80HL - psMemWrite->lowAddr)) = bTemp; ! 2410: } ! 2411: psMemWrite = NULL; ! 2412: break; ! 2413: } ! 2414: ++psMemWrite; ! 2415: } ! 2416: ! 2417: if (psMemWrite) ! 2418: { ! 2419: cpu.z80Base[cpu.z80HL] = (UINT8) bTemp; ! 2420: } ! 2421: ! 2422: break; ! 2423: } ! 2424: case 0x87: ! 2425: { ! 2426: sdwCyclesRemaining -= 8; ! 2427: cpu.z80A &= 0xfe; ! 2428: break; ! 2429: } ! 2430: case 0x88: ! 2431: { ! 2432: sdwCyclesRemaining -= 8; ! 2433: cpu.z80B &= 0xfd; ! 2434: break; ! 2435: } ! 2436: case 0x89: ! 2437: { ! 2438: sdwCyclesRemaining -= 8; ! 2439: cpu.z80C &= 0xfd; ! 2440: break; ! 2441: } ! 2442: case 0x8a: ! 2443: { ! 2444: sdwCyclesRemaining -= 8; ! 2445: cpu.z80D &= 0xfd; ! 2446: break; ! 2447: } ! 2448: case 0x8b: ! 2449: { ! 2450: sdwCyclesRemaining -= 8; ! 2451: cpu.z80E &= 0xfd; ! 2452: break; ! 2453: } ! 2454: case 0x8c: ! 2455: { ! 2456: sdwCyclesRemaining -= 8; ! 2457: cpu.z80H &= 0xfd; ! 2458: break; ! 2459: } ! 2460: case 0x8d: ! 2461: { ! 2462: sdwCyclesRemaining -= 8; ! 2463: cpu.z80L &= 0xfd; ! 2464: break; ! 2465: } ! 2466: case 0x8e: ! 2467: { ! 2468: sdwCyclesRemaining -= 15; ! 2469: psMemRead = cpu.z80MemRead; /* Beginning of our handler */ ! 2470: while (psMemRead->lowAddr != 0xffffffff) ! 2471: { ! 2472: if ((cpu.z80HL >= psMemRead->lowAddr) && (cpu.z80HL <= psMemRead->highAddr)) ! 2473: { ! 2474: cpu.z80pc = (UINT32) pbPC - (UINT32) cpu.z80Base; ! 2475: if (psMemRead->memoryCall) ! 2476: { ! 2477: bTemp = psMemRead->memoryCall(cpu.z80HL, psMemRead); ! 2478: } ! 2479: else ! 2480: { ! 2481: bTemp = *((UINT8 *) psMemRead->pUserArea + (cpu.z80HL - psMemRead->lowAddr)); ! 2482: } ! 2483: psMemRead = NULL; ! 2484: break; ! 2485: } ! 2486: ++psMemRead; ! 2487: } ! 2488: ! 2489: if (psMemRead) ! 2490: { ! 2491: bTemp = cpu.z80Base[cpu.z80HL]; ! 2492: } ! 2493: ! 2494: bTemp &= 0xfd; ! 2495: psMemWrite = cpu.z80MemWrite; /* Beginning of our handler */ ! 2496: while (psMemWrite->lowAddr != 0xffffffff) ! 2497: { ! 2498: if ((cpu.z80HL >= psMemWrite->lowAddr) && (cpu.z80HL <= psMemWrite->highAddr)) ! 2499: { ! 2500: cpu.z80pc = (UINT32) pbPC - (UINT32) cpu.z80Base; ! 2501: if (psMemWrite->memoryCall) ! 2502: { ! 2503: psMemWrite->memoryCall(cpu.z80HL, bTemp, psMemWrite); ! 2504: } ! 2505: else ! 2506: { ! 2507: *((UINT8 *) psMemWrite->pUserArea + (cpu.z80HL - psMemWrite->lowAddr)) = bTemp; ! 2508: } ! 2509: psMemWrite = NULL; ! 2510: break; ! 2511: } ! 2512: ++psMemWrite; ! 2513: } ! 2514: ! 2515: if (psMemWrite) ! 2516: { ! 2517: cpu.z80Base[cpu.z80HL] = (UINT8) bTemp; ! 2518: } ! 2519: ! 2520: break; ! 2521: } ! 2522: case 0x8f: ! 2523: { ! 2524: sdwCyclesRemaining -= 8; ! 2525: cpu.z80A &= 0xfd; ! 2526: break; ! 2527: } ! 2528: case 0x90: ! 2529: { ! 2530: sdwCyclesRemaining -= 8; ! 2531: cpu.z80B &= 0xfb; ! 2532: break; ! 2533: } ! 2534: case 0x91: ! 2535: { ! 2536: sdwCyclesRemaining -= 8; ! 2537: cpu.z80C &= 0xfb; ! 2538: break; ! 2539: } ! 2540: case 0x92: ! 2541: { ! 2542: sdwCyclesRemaining -= 8; ! 2543: cpu.z80D &= 0xfb; ! 2544: break; ! 2545: } ! 2546: case 0x93: ! 2547: { ! 2548: sdwCyclesRemaining -= 8; ! 2549: cpu.z80E &= 0xfb; ! 2550: break; ! 2551: } ! 2552: case 0x94: ! 2553: { ! 2554: sdwCyclesRemaining -= 8; ! 2555: cpu.z80H &= 0xfb; ! 2556: break; ! 2557: } ! 2558: case 0x95: ! 2559: { ! 2560: sdwCyclesRemaining -= 8; ! 2561: cpu.z80L &= 0xfb; ! 2562: break; ! 2563: } ! 2564: case 0x96: ! 2565: { ! 2566: sdwCyclesRemaining -= 15; ! 2567: psMemRead = cpu.z80MemRead; /* Beginning of our handler */ ! 2568: while (psMemRead->lowAddr != 0xffffffff) ! 2569: { ! 2570: if ((cpu.z80HL >= psMemRead->lowAddr) && (cpu.z80HL <= psMemRead->highAddr)) ! 2571: { ! 2572: cpu.z80pc = (UINT32) pbPC - (UINT32) cpu.z80Base; ! 2573: if (psMemRead->memoryCall) ! 2574: { ! 2575: bTemp = psMemRead->memoryCall(cpu.z80HL, psMemRead); ! 2576: } ! 2577: else ! 2578: { ! 2579: bTemp = *((UINT8 *) psMemRead->pUserArea + (cpu.z80HL - psMemRead->lowAddr)); ! 2580: } ! 2581: psMemRead = NULL; ! 2582: break; ! 2583: } ! 2584: ++psMemRead; ! 2585: } ! 2586: ! 2587: if (psMemRead) ! 2588: { ! 2589: bTemp = cpu.z80Base[cpu.z80HL]; ! 2590: } ! 2591: ! 2592: bTemp &= 0xfb; ! 2593: psMemWrite = cpu.z80MemWrite; /* Beginning of our handler */ ! 2594: while (psMemWrite->lowAddr != 0xffffffff) ! 2595: { ! 2596: if ((cpu.z80HL >= psMemWrite->lowAddr) && (cpu.z80HL <= psMemWrite->highAddr)) ! 2597: { ! 2598: cpu.z80pc = (UINT32) pbPC - (UINT32) cpu.z80Base; ! 2599: if (psMemWrite->memoryCall) ! 2600: { ! 2601: psMemWrite->memoryCall(cpu.z80HL, bTemp, psMemWrite); ! 2602: } ! 2603: else ! 2604: { ! 2605: *((UINT8 *) psMemWrite->pUserArea + (cpu.z80HL - psMemWrite->lowAddr)) = bTemp; ! 2606: } ! 2607: psMemWrite = NULL; ! 2608: break; ! 2609: } ! 2610: ++psMemWrite; ! 2611: } ! 2612: ! 2613: if (psMemWrite) ! 2614: { ! 2615: cpu.z80Base[cpu.z80HL] = (UINT8) bTemp; ! 2616: } ! 2617: ! 2618: break; ! 2619: } ! 2620: case 0x97: ! 2621: { ! 2622: sdwCyclesRemaining -= 8; ! 2623: cpu.z80A &= 0xfb; ! 2624: break; ! 2625: } ! 2626: case 0x98: ! 2627: { ! 2628: sdwCyclesRemaining -= 8; ! 2629: cpu.z80B &= 0xf7; ! 2630: break; ! 2631: } ! 2632: case 0x99: ! 2633: { ! 2634: sdwCyclesRemaining -= 8; ! 2635: cpu.z80C &= 0xf7; ! 2636: break; ! 2637: } ! 2638: case 0x9a: ! 2639: { ! 2640: sdwCyclesRemaining -= 8; ! 2641: cpu.z80D &= 0xf7; ! 2642: break; ! 2643: } ! 2644: case 0x9b: ! 2645: { ! 2646: sdwCyclesRemaining -= 8; ! 2647: cpu.z80E &= 0xf7; ! 2648: break; ! 2649: } ! 2650: case 0x9c: ! 2651: { ! 2652: sdwCyclesRemaining -= 8; ! 2653: cpu.z80H &= 0xf7; ! 2654: break; ! 2655: } ! 2656: case 0x9d: ! 2657: { ! 2658: sdwCyclesRemaining -= 8; ! 2659: cpu.z80L &= 0xf7; ! 2660: break; ! 2661: } ! 2662: case 0x9e: ! 2663: { ! 2664: sdwCyclesRemaining -= 15; ! 2665: psMemRead = cpu.z80MemRead; /* Beginning of our handler */ ! 2666: while (psMemRead->lowAddr != 0xffffffff) ! 2667: { ! 2668: if ((cpu.z80HL >= psMemRead->lowAddr) && (cpu.z80HL <= psMemRead->highAddr)) ! 2669: { ! 2670: cpu.z80pc = (UINT32) pbPC - (UINT32) cpu.z80Base; ! 2671: if (psMemRead->memoryCall) ! 2672: { ! 2673: bTemp = psMemRead->memoryCall(cpu.z80HL, psMemRead); ! 2674: } ! 2675: else ! 2676: { ! 2677: bTemp = *((UINT8 *) psMemRead->pUserArea + (cpu.z80HL - psMemRead->lowAddr)); ! 2678: } ! 2679: psMemRead = NULL; ! 2680: break; ! 2681: } ! 2682: ++psMemRead; ! 2683: } ! 2684: ! 2685: if (psMemRead) ! 2686: { ! 2687: bTemp = cpu.z80Base[cpu.z80HL]; ! 2688: } ! 2689: ! 2690: bTemp &= 0xf7; ! 2691: psMemWrite = cpu.z80MemWrite; /* Beginning of our handler */ ! 2692: while (psMemWrite->lowAddr != 0xffffffff) ! 2693: { ! 2694: if ((cpu.z80HL >= psMemWrite->lowAddr) && (cpu.z80HL <= psMemWrite->highAddr)) ! 2695: { ! 2696: cpu.z80pc = (UINT32) pbPC - (UINT32) cpu.z80Base; ! 2697: if (psMemWrite->memoryCall) ! 2698: { ! 2699: psMemWrite->memoryCall(cpu.z80HL, bTemp, psMemWrite); ! 2700: } ! 2701: else ! 2702: { ! 2703: *((UINT8 *) psMemWrite->pUserArea + (cpu.z80HL - psMemWrite->lowAddr)) = bTemp; ! 2704: } ! 2705: psMemWrite = NULL; ! 2706: break; ! 2707: } ! 2708: ++psMemWrite; ! 2709: } ! 2710: ! 2711: if (psMemWrite) ! 2712: { ! 2713: cpu.z80Base[cpu.z80HL] = (UINT8) bTemp; ! 2714: } ! 2715: ! 2716: break; ! 2717: } ! 2718: case 0x9f: ! 2719: { ! 2720: sdwCyclesRemaining -= 8; ! 2721: cpu.z80A &= 0xf7; ! 2722: break; ! 2723: } ! 2724: case 0xa0: ! 2725: { ! 2726: sdwCyclesRemaining -= 8; ! 2727: cpu.z80B &= 0xef; ! 2728: break; ! 2729: } ! 2730: case 0xa1: ! 2731: { ! 2732: sdwCyclesRemaining -= 8; ! 2733: cpu.z80C &= 0xef; ! 2734: break; ! 2735: } ! 2736: case 0xa2: ! 2737: { ! 2738: sdwCyclesRemaining -= 8; ! 2739: cpu.z80D &= 0xef; ! 2740: break; ! 2741: } ! 2742: case 0xa3: ! 2743: { ! 2744: sdwCyclesRemaining -= 8; ! 2745: cpu.z80E &= 0xef; ! 2746: break; ! 2747: } ! 2748: case 0xa4: ! 2749: { ! 2750: sdwCyclesRemaining -= 8; ! 2751: cpu.z80H &= 0xef; ! 2752: break; ! 2753: } ! 2754: case 0xa5: ! 2755: { ! 2756: sdwCyclesRemaining -= 8; ! 2757: cpu.z80L &= 0xef; ! 2758: break; ! 2759: } ! 2760: case 0xa6: ! 2761: { ! 2762: sdwCyclesRemaining -= 15; ! 2763: psMemRead = cpu.z80MemRead; /* Beginning of our handler */ ! 2764: while (psMemRead->lowAddr != 0xffffffff) ! 2765: { ! 2766: if ((cpu.z80HL >= psMemRead->lowAddr) && (cpu.z80HL <= psMemRead->highAddr)) ! 2767: { ! 2768: cpu.z80pc = (UINT32) pbPC - (UINT32) cpu.z80Base; ! 2769: if (psMemRead->memoryCall) ! 2770: { ! 2771: bTemp = psMemRead->memoryCall(cpu.z80HL, psMemRead); ! 2772: } ! 2773: else ! 2774: { ! 2775: bTemp = *((UINT8 *) psMemRead->pUserArea + (cpu.z80HL - psMemRead->lowAddr)); ! 2776: } ! 2777: psMemRead = NULL; ! 2778: break; ! 2779: } ! 2780: ++psMemRead; ! 2781: } ! 2782: ! 2783: if (psMemRead) ! 2784: { ! 2785: bTemp = cpu.z80Base[cpu.z80HL]; ! 2786: } ! 2787: ! 2788: bTemp &= 0xef; ! 2789: psMemWrite = cpu.z80MemWrite; /* Beginning of our handler */ ! 2790: while (psMemWrite->lowAddr != 0xffffffff) ! 2791: { ! 2792: if ((cpu.z80HL >= psMemWrite->lowAddr) && (cpu.z80HL <= psMemWrite->highAddr)) ! 2793: { ! 2794: cpu.z80pc = (UINT32) pbPC - (UINT32) cpu.z80Base; ! 2795: if (psMemWrite->memoryCall) ! 2796: { ! 2797: psMemWrite->memoryCall(cpu.z80HL, bTemp, psMemWrite); ! 2798: } ! 2799: else ! 2800: { ! 2801: *((UINT8 *) psMemWrite->pUserArea + (cpu.z80HL - psMemWrite->lowAddr)) = bTemp; ! 2802: } ! 2803: psMemWrite = NULL; ! 2804: break; ! 2805: } ! 2806: ++psMemWrite; ! 2807: } ! 2808: ! 2809: if (psMemWrite) ! 2810: { ! 2811: cpu.z80Base[cpu.z80HL] = (UINT8) bTemp; ! 2812: } ! 2813: ! 2814: break; ! 2815: } ! 2816: case 0xa7: ! 2817: { ! 2818: sdwCyclesRemaining -= 8; ! 2819: cpu.z80A &= 0xef; ! 2820: break; ! 2821: } ! 2822: case 0xa8: ! 2823: { ! 2824: sdwCyclesRemaining -= 8; ! 2825: cpu.z80B &= 0xdf; ! 2826: break; ! 2827: } ! 2828: case 0xa9: ! 2829: { ! 2830: sdwCyclesRemaining -= 8; ! 2831: cpu.z80C &= 0xdf; ! 2832: break; ! 2833: } ! 2834: case 0xaa: ! 2835: { ! 2836: sdwCyclesRemaining -= 8; ! 2837: cpu.z80D &= 0xdf; ! 2838: break; ! 2839: } ! 2840: case 0xab: ! 2841: { ! 2842: sdwCyclesRemaining -= 8; ! 2843: cpu.z80E &= 0xdf; ! 2844: break; ! 2845: } ! 2846: case 0xac: ! 2847: { ! 2848: sdwCyclesRemaining -= 8; ! 2849: cpu.z80H &= 0xdf; ! 2850: break; ! 2851: } ! 2852: case 0xad: ! 2853: { ! 2854: sdwCyclesRemaining -= 8; ! 2855: cpu.z80L &= 0xdf; ! 2856: break; ! 2857: } ! 2858: case 0xae: ! 2859: { ! 2860: sdwCyclesRemaining -= 15; ! 2861: psMemRead = cpu.z80MemRead; /* Beginning of our handler */ ! 2862: while (psMemRead->lowAddr != 0xffffffff) ! 2863: { ! 2864: if ((cpu.z80HL >= psMemRead->lowAddr) && (cpu.z80HL <= psMemRead->highAddr)) ! 2865: { ! 2866: cpu.z80pc = (UINT32) pbPC - (UINT32) cpu.z80Base; ! 2867: if (psMemRead->memoryCall) ! 2868: { ! 2869: bTemp = psMemRead->memoryCall(cpu.z80HL, psMemRead); ! 2870: } ! 2871: else ! 2872: { ! 2873: bTemp = *((UINT8 *) psMemRead->pUserArea + (cpu.z80HL - psMemRead->lowAddr)); ! 2874: } ! 2875: psMemRead = NULL; ! 2876: break; ! 2877: } ! 2878: ++psMemRead; ! 2879: } ! 2880: ! 2881: if (psMemRead) ! 2882: { ! 2883: bTemp = cpu.z80Base[cpu.z80HL]; ! 2884: } ! 2885: ! 2886: bTemp &= 0xdf; ! 2887: psMemWrite = cpu.z80MemWrite; /* Beginning of our handler */ ! 2888: while (psMemWrite->lowAddr != 0xffffffff) ! 2889: { ! 2890: if ((cpu.z80HL >= psMemWrite->lowAddr) && (cpu.z80HL <= psMemWrite->highAddr)) ! 2891: { ! 2892: cpu.z80pc = (UINT32) pbPC - (UINT32) cpu.z80Base; ! 2893: if (psMemWrite->memoryCall) ! 2894: { ! 2895: psMemWrite->memoryCall(cpu.z80HL, bTemp, psMemWrite); ! 2896: } ! 2897: else ! 2898: { ! 2899: *((UINT8 *) psMemWrite->pUserArea + (cpu.z80HL - psMemWrite->lowAddr)) = bTemp; ! 2900: } ! 2901: psMemWrite = NULL; ! 2902: break; ! 2903: } ! 2904: ++psMemWrite; ! 2905: } ! 2906: ! 2907: if (psMemWrite) ! 2908: { ! 2909: cpu.z80Base[cpu.z80HL] = (UINT8) bTemp; ! 2910: } ! 2911: ! 2912: break; ! 2913: } ! 2914: case 0xaf: ! 2915: { ! 2916: sdwCyclesRemaining -= 8; ! 2917: cpu.z80A &= 0xdf; ! 2918: break; ! 2919: } ! 2920: case 0xb0: ! 2921: { ! 2922: sdwCyclesRemaining -= 8; ! 2923: cpu.z80B &= 0xbf; ! 2924: break; ! 2925: } ! 2926: case 0xb1: ! 2927: { ! 2928: sdwCyclesRemaining -= 8; ! 2929: cpu.z80C &= 0xbf; ! 2930: break; ! 2931: } ! 2932: case 0xb2: ! 2933: { ! 2934: sdwCyclesRemaining -= 8; ! 2935: cpu.z80D &= 0xbf; ! 2936: break; ! 2937: } ! 2938: case 0xb3: ! 2939: { ! 2940: sdwCyclesRemaining -= 8; ! 2941: cpu.z80E &= 0xbf; ! 2942: break; ! 2943: } ! 2944: case 0xb4: ! 2945: { ! 2946: sdwCyclesRemaining -= 8; ! 2947: cpu.z80H &= 0xbf; ! 2948: break; ! 2949: } ! 2950: case 0xb5: ! 2951: { ! 2952: sdwCyclesRemaining -= 8; ! 2953: cpu.z80L &= 0xbf; ! 2954: break; ! 2955: } ! 2956: case 0xb6: ! 2957: { ! 2958: sdwCyclesRemaining -= 15; ! 2959: psMemRead = cpu.z80MemRead; /* Beginning of our handler */ ! 2960: while (psMemRead->lowAddr != 0xffffffff) ! 2961: { ! 2962: if ((cpu.z80HL >= psMemRead->lowAddr) && (cpu.z80HL <= psMemRead->highAddr)) ! 2963: { ! 2964: cpu.z80pc = (UINT32) pbPC - (UINT32) cpu.z80Base; ! 2965: if (psMemRead->memoryCall) ! 2966: { ! 2967: bTemp = psMemRead->memoryCall(cpu.z80HL, psMemRead); ! 2968: } ! 2969: else ! 2970: { ! 2971: bTemp = *((UINT8 *) psMemRead->pUserArea + (cpu.z80HL - psMemRead->lowAddr)); ! 2972: } ! 2973: psMemRead = NULL; ! 2974: break; ! 2975: } ! 2976: ++psMemRead; ! 2977: } ! 2978: ! 2979: if (psMemRead) ! 2980: { ! 2981: bTemp = cpu.z80Base[cpu.z80HL]; ! 2982: } ! 2983: ! 2984: bTemp &= 0xbf; ! 2985: psMemWrite = cpu.z80MemWrite; /* Beginning of our handler */ ! 2986: while (psMemWrite->lowAddr != 0xffffffff) ! 2987: { ! 2988: if ((cpu.z80HL >= psMemWrite->lowAddr) && (cpu.z80HL <= psMemWrite->highAddr)) ! 2989: { ! 2990: cpu.z80pc = (UINT32) pbPC - (UINT32) cpu.z80Base; ! 2991: if (psMemWrite->memoryCall) ! 2992: { ! 2993: psMemWrite->memoryCall(cpu.z80HL, bTemp, psMemWrite); ! 2994: } ! 2995: else ! 2996: { ! 2997: *((UINT8 *) psMemWrite->pUserArea + (cpu.z80HL - psMemWrite->lowAddr)) = bTemp; ! 2998: } ! 2999: psMemWrite = NULL; ! 3000: break; ! 3001: } ! 3002: ++psMemWrite; ! 3003: } ! 3004: ! 3005: if (psMemWrite) ! 3006: { ! 3007: cpu.z80Base[cpu.z80HL] = (UINT8) bTemp; ! 3008: } ! 3009: ! 3010: break; ! 3011: } ! 3012: case 0xb7: ! 3013: { ! 3014: sdwCyclesRemaining -= 8; ! 3015: cpu.z80A &= 0xbf; ! 3016: break; ! 3017: } ! 3018: case 0xb8: ! 3019: { ! 3020: sdwCyclesRemaining -= 8; ! 3021: cpu.z80B &= 0x7f; ! 3022: break; ! 3023: } ! 3024: case 0xb9: ! 3025: { ! 3026: sdwCyclesRemaining -= 8; ! 3027: cpu.z80C &= 0x7f; ! 3028: break; ! 3029: } ! 3030: case 0xba: ! 3031: { ! 3032: sdwCyclesRemaining -= 8; ! 3033: cpu.z80D &= 0x7f; ! 3034: break; ! 3035: } ! 3036: case 0xbb: ! 3037: { ! 3038: sdwCyclesRemaining -= 8; ! 3039: cpu.z80E &= 0x7f; ! 3040: break; ! 3041: } ! 3042: case 0xbc: ! 3043: { ! 3044: sdwCyclesRemaining -= 8; ! 3045: cpu.z80H &= 0x7f; ! 3046: break; ! 3047: } ! 3048: case 0xbd: ! 3049: { ! 3050: sdwCyclesRemaining -= 8; ! 3051: cpu.z80L &= 0x7f; ! 3052: break; ! 3053: } ! 3054: case 0xbe: ! 3055: { ! 3056: sdwCyclesRemaining -= 15; ! 3057: psMemRead = cpu.z80MemRead; /* Beginning of our handler */ ! 3058: while (psMemRead->lowAddr != 0xffffffff) ! 3059: { ! 3060: if ((cpu.z80HL >= psMemRead->lowAddr) && (cpu.z80HL <= psMemRead->highAddr)) ! 3061: { ! 3062: cpu.z80pc = (UINT32) pbPC - (UINT32) cpu.z80Base; ! 3063: if (psMemRead->memoryCall) ! 3064: { ! 3065: bTemp = psMemRead->memoryCall(cpu.z80HL, psMemRead); ! 3066: } ! 3067: else ! 3068: { ! 3069: bTemp = *((UINT8 *) psMemRead->pUserArea + (cpu.z80HL - psMemRead->lowAddr)); ! 3070: } ! 3071: psMemRead = NULL; ! 3072: break; ! 3073: } ! 3074: ++psMemRead; ! 3075: } ! 3076: ! 3077: if (psMemRead) ! 3078: { ! 3079: bTemp = cpu.z80Base[cpu.z80HL]; ! 3080: } ! 3081: ! 3082: bTemp &= 0x7f; ! 3083: psMemWrite = cpu.z80MemWrite; /* Beginning of our handler */ ! 3084: while (psMemWrite->lowAddr != 0xffffffff) ! 3085: { ! 3086: if ((cpu.z80HL >= psMemWrite->lowAddr) && (cpu.z80HL <= psMemWrite->highAddr)) ! 3087: { ! 3088: cpu.z80pc = (UINT32) pbPC - (UINT32) cpu.z80Base; ! 3089: if (psMemWrite->memoryCall) ! 3090: { ! 3091: psMemWrite->memoryCall(cpu.z80HL, bTemp, psMemWrite); ! 3092: } ! 3093: else ! 3094: { ! 3095: *((UINT8 *) psMemWrite->pUserArea + (cpu.z80HL - psMemWrite->lowAddr)) = bTemp; ! 3096: } ! 3097: psMemWrite = NULL; ! 3098: break; ! 3099: } ! 3100: ++psMemWrite; ! 3101: } ! 3102: ! 3103: if (psMemWrite) ! 3104: { ! 3105: cpu.z80Base[cpu.z80HL] = (UINT8) bTemp; ! 3106: } ! 3107: ! 3108: break; ! 3109: } ! 3110: case 0xbf: ! 3111: { ! 3112: sdwCyclesRemaining -= 8; ! 3113: cpu.z80A &= 0x7f; ! 3114: break; ! 3115: } ! 3116: case 0xc0: ! 3117: { ! 3118: sdwCyclesRemaining -= 8; ! 3119: cpu.z80B |= 0x01; ! 3120: break; ! 3121: } ! 3122: case 0xc1: ! 3123: { ! 3124: sdwCyclesRemaining -= 8; ! 3125: cpu.z80C |= 0x01; ! 3126: break; ! 3127: } ! 3128: case 0xc2: ! 3129: { ! 3130: sdwCyclesRemaining -= 8; ! 3131: cpu.z80D |= 0x01; ! 3132: break; ! 3133: } ! 3134: case 0xc3: ! 3135: { ! 3136: sdwCyclesRemaining -= 8; ! 3137: cpu.z80E |= 0x01; ! 3138: break; ! 3139: } ! 3140: case 0xc4: ! 3141: { ! 3142: sdwCyclesRemaining -= 8; ! 3143: cpu.z80H |= 0x01; ! 3144: break; ! 3145: } ! 3146: case 0xc5: ! 3147: { ! 3148: sdwCyclesRemaining -= 8; ! 3149: cpu.z80L |= 0x01; ! 3150: break; ! 3151: } ! 3152: case 0xc6: ! 3153: { ! 3154: sdwCyclesRemaining -= 15; ! 3155: psMemRead = cpu.z80MemRead; /* Beginning of our handler */ ! 3156: while (psMemRead->lowAddr != 0xffffffff) ! 3157: { ! 3158: if ((cpu.z80HL >= psMemRead->lowAddr) && (cpu.z80HL <= psMemRead->highAddr)) ! 3159: { ! 3160: cpu.z80pc = (UINT32) pbPC - (UINT32) cpu.z80Base; ! 3161: if (psMemRead->memoryCall) ! 3162: { ! 3163: bTemp = psMemRead->memoryCall(cpu.z80HL, psMemRead); ! 3164: } ! 3165: else ! 3166: { ! 3167: bTemp = *((UINT8 *) psMemRead->pUserArea + (cpu.z80HL - psMemRead->lowAddr)); ! 3168: } ! 3169: psMemRead = NULL; ! 3170: break; ! 3171: } ! 3172: ++psMemRead; ! 3173: } ! 3174: ! 3175: if (psMemRead) ! 3176: { ! 3177: bTemp = cpu.z80Base[cpu.z80HL]; ! 3178: } ! 3179: ! 3180: bTemp |= 0x01; ! 3181: psMemWrite = cpu.z80MemWrite; /* Beginning of our handler */ ! 3182: while (psMemWrite->lowAddr != 0xffffffff) ! 3183: { ! 3184: if ((cpu.z80HL >= psMemWrite->lowAddr) && (cpu.z80HL <= psMemWrite->highAddr)) ! 3185: { ! 3186: cpu.z80pc = (UINT32) pbPC - (UINT32) cpu.z80Base; ! 3187: if (psMemWrite->memoryCall) ! 3188: { ! 3189: psMemWrite->memoryCall(cpu.z80HL, bTemp, psMemWrite); ! 3190: } ! 3191: else ! 3192: { ! 3193: *((UINT8 *) psMemWrite->pUserArea + (cpu.z80HL - psMemWrite->lowAddr)) = bTemp; ! 3194: } ! 3195: psMemWrite = NULL; ! 3196: break; ! 3197: } ! 3198: ++psMemWrite; ! 3199: } ! 3200: ! 3201: if (psMemWrite) ! 3202: { ! 3203: cpu.z80Base[cpu.z80HL] = (UINT8) bTemp; ! 3204: } ! 3205: ! 3206: break; ! 3207: } ! 3208: case 0xc7: ! 3209: { ! 3210: sdwCyclesRemaining -= 8; ! 3211: cpu.z80A |= 0x01; ! 3212: break; ! 3213: } ! 3214: case 0xc8: ! 3215: { ! 3216: sdwCyclesRemaining -= 8; ! 3217: cpu.z80B |= 0x02; ! 3218: break; ! 3219: } ! 3220: case 0xc9: ! 3221: { ! 3222: sdwCyclesRemaining -= 8; ! 3223: cpu.z80C |= 0x02; ! 3224: break; ! 3225: } ! 3226: case 0xca: ! 3227: { ! 3228: sdwCyclesRemaining -= 8; ! 3229: cpu.z80D |= 0x02; ! 3230: break; ! 3231: } ! 3232: case 0xcb: ! 3233: { ! 3234: sdwCyclesRemaining -= 8; ! 3235: cpu.z80E |= 0x02; ! 3236: break; ! 3237: } ! 3238: case 0xcc: ! 3239: { ! 3240: sdwCyclesRemaining -= 8; ! 3241: cpu.z80H |= 0x02; ! 3242: break; ! 3243: } ! 3244: case 0xcd: ! 3245: { ! 3246: sdwCyclesRemaining -= 8; ! 3247: cpu.z80L |= 0x02; ! 3248: break; ! 3249: } ! 3250: case 0xce: ! 3251: { ! 3252: sdwCyclesRemaining -= 15; ! 3253: psMemRead = cpu.z80MemRead; /* Beginning of our handler */ ! 3254: while (psMemRead->lowAddr != 0xffffffff) ! 3255: { ! 3256: if ((cpu.z80HL >= psMemRead->lowAddr) && (cpu.z80HL <= psMemRead->highAddr)) ! 3257: { ! 3258: cpu.z80pc = (UINT32) pbPC - (UINT32) cpu.z80Base; ! 3259: if (psMemRead->memoryCall) ! 3260: { ! 3261: bTemp = psMemRead->memoryCall(cpu.z80HL, psMemRead); ! 3262: } ! 3263: else ! 3264: { ! 3265: bTemp = *((UINT8 *) psMemRead->pUserArea + (cpu.z80HL - psMemRead->lowAddr)); ! 3266: } ! 3267: psMemRead = NULL; ! 3268: break; ! 3269: } ! 3270: ++psMemRead; ! 3271: } ! 3272: ! 3273: if (psMemRead) ! 3274: { ! 3275: bTemp = cpu.z80Base[cpu.z80HL]; ! 3276: } ! 3277: ! 3278: bTemp |= 0x02; ! 3279: psMemWrite = cpu.z80MemWrite; /* Beginning of our handler */ ! 3280: while (psMemWrite->lowAddr != 0xffffffff) ! 3281: { ! 3282: if ((cpu.z80HL >= psMemWrite->lowAddr) && (cpu.z80HL <= psMemWrite->highAddr)) ! 3283: { ! 3284: cpu.z80pc = (UINT32) pbPC - (UINT32) cpu.z80Base; ! 3285: if (psMemWrite->memoryCall) ! 3286: { ! 3287: psMemWrite->memoryCall(cpu.z80HL, bTemp, psMemWrite); ! 3288: } ! 3289: else ! 3290: { ! 3291: *((UINT8 *) psMemWrite->pUserArea + (cpu.z80HL - psMemWrite->lowAddr)) = bTemp; ! 3292: } ! 3293: psMemWrite = NULL; ! 3294: break; ! 3295: } ! 3296: ++psMemWrite; ! 3297: } ! 3298: ! 3299: if (psMemWrite) ! 3300: { ! 3301: cpu.z80Base[cpu.z80HL] = (UINT8) bTemp; ! 3302: } ! 3303: ! 3304: break; ! 3305: } ! 3306: case 0xcf: ! 3307: { ! 3308: sdwCyclesRemaining -= 8; ! 3309: cpu.z80A |= 0x02; ! 3310: break; ! 3311: } ! 3312: case 0xd0: ! 3313: { ! 3314: sdwCyclesRemaining -= 8; ! 3315: cpu.z80B |= 0x04; ! 3316: break; ! 3317: } ! 3318: case 0xd1: ! 3319: { ! 3320: sdwCyclesRemaining -= 8; ! 3321: cpu.z80C |= 0x04; ! 3322: break; ! 3323: } ! 3324: case 0xd2: ! 3325: { ! 3326: sdwCyclesRemaining -= 8; ! 3327: cpu.z80D |= 0x04; ! 3328: break; ! 3329: } ! 3330: case 0xd3: ! 3331: { ! 3332: sdwCyclesRemaining -= 8; ! 3333: cpu.z80E |= 0x04; ! 3334: break; ! 3335: } ! 3336: case 0xd4: ! 3337: { ! 3338: sdwCyclesRemaining -= 8; ! 3339: cpu.z80H |= 0x04; ! 3340: break; ! 3341: } ! 3342: case 0xd5: ! 3343: { ! 3344: sdwCyclesRemaining -= 8; ! 3345: cpu.z80L |= 0x04; ! 3346: break; ! 3347: } ! 3348: case 0xd6: ! 3349: { ! 3350: sdwCyclesRemaining -= 15; ! 3351: psMemRead = cpu.z80MemRead; /* Beginning of our handler */ ! 3352: while (psMemRead->lowAddr != 0xffffffff) ! 3353: { ! 3354: if ((cpu.z80HL >= psMemRead->lowAddr) && (cpu.z80HL <= psMemRead->highAddr)) ! 3355: { ! 3356: cpu.z80pc = (UINT32) pbPC - (UINT32) cpu.z80Base; ! 3357: if (psMemRead->memoryCall) ! 3358: { ! 3359: bTemp = psMemRead->memoryCall(cpu.z80HL, psMemRead); ! 3360: } ! 3361: else ! 3362: { ! 3363: bTemp = *((UINT8 *) psMemRead->pUserArea + (cpu.z80HL - psMemRead->lowAddr)); ! 3364: } ! 3365: psMemRead = NULL; ! 3366: break; ! 3367: } ! 3368: ++psMemRead; ! 3369: } ! 3370: ! 3371: if (psMemRead) ! 3372: { ! 3373: bTemp = cpu.z80Base[cpu.z80HL]; ! 3374: } ! 3375: ! 3376: bTemp |= 0x04; ! 3377: psMemWrite = cpu.z80MemWrite; /* Beginning of our handler */ ! 3378: while (psMemWrite->lowAddr != 0xffffffff) ! 3379: { ! 3380: if ((cpu.z80HL >= psMemWrite->lowAddr) && (cpu.z80HL <= psMemWrite->highAddr)) ! 3381: { ! 3382: cpu.z80pc = (UINT32) pbPC - (UINT32) cpu.z80Base; ! 3383: if (psMemWrite->memoryCall) ! 3384: { ! 3385: psMemWrite->memoryCall(cpu.z80HL, bTemp, psMemWrite); ! 3386: } ! 3387: else ! 3388: { ! 3389: *((UINT8 *) psMemWrite->pUserArea + (cpu.z80HL - psMemWrite->lowAddr)) = bTemp; ! 3390: } ! 3391: psMemWrite = NULL; ! 3392: break; ! 3393: } ! 3394: ++psMemWrite; ! 3395: } ! 3396: ! 3397: if (psMemWrite) ! 3398: { ! 3399: cpu.z80Base[cpu.z80HL] = (UINT8) bTemp; ! 3400: } ! 3401: ! 3402: break; ! 3403: } ! 3404: case 0xd7: ! 3405: { ! 3406: sdwCyclesRemaining -= 8; ! 3407: cpu.z80A |= 0x04; ! 3408: break; ! 3409: } ! 3410: case 0xd8: ! 3411: { ! 3412: sdwCyclesRemaining -= 8; ! 3413: cpu.z80B |= 0x08; ! 3414: break; ! 3415: } ! 3416: case 0xd9: ! 3417: { ! 3418: sdwCyclesRemaining -= 8; ! 3419: cpu.z80C |= 0x08; ! 3420: break; ! 3421: } ! 3422: case 0xda: ! 3423: { ! 3424: sdwCyclesRemaining -= 8; ! 3425: cpu.z80D |= 0x08; ! 3426: break; ! 3427: } ! 3428: case 0xdb: ! 3429: { ! 3430: sdwCyclesRemaining -= 8; ! 3431: cpu.z80E |= 0x08; ! 3432: break; ! 3433: } ! 3434: case 0xdc: ! 3435: { ! 3436: sdwCyclesRemaining -= 8; ! 3437: cpu.z80H |= 0x08; ! 3438: break; ! 3439: } ! 3440: case 0xdd: ! 3441: { ! 3442: sdwCyclesRemaining -= 8; ! 3443: cpu.z80L |= 0x08; ! 3444: break; ! 3445: } ! 3446: case 0xde: ! 3447: { ! 3448: sdwCyclesRemaining -= 15; ! 3449: psMemRead = cpu.z80MemRead; /* Beginning of our handler */ ! 3450: while (psMemRead->lowAddr != 0xffffffff) ! 3451: { ! 3452: if ((cpu.z80HL >= psMemRead->lowAddr) && (cpu.z80HL <= psMemRead->highAddr)) ! 3453: { ! 3454: cpu.z80pc = (UINT32) pbPC - (UINT32) cpu.z80Base; ! 3455: if (psMemRead->memoryCall) ! 3456: { ! 3457: bTemp = psMemRead->memoryCall(cpu.z80HL, psMemRead); ! 3458: } ! 3459: else ! 3460: { ! 3461: bTemp = *((UINT8 *) psMemRead->pUserArea + (cpu.z80HL - psMemRead->lowAddr)); ! 3462: } ! 3463: psMemRead = NULL; ! 3464: break; ! 3465: } ! 3466: ++psMemRead; ! 3467: } ! 3468: ! 3469: if (psMemRead) ! 3470: { ! 3471: bTemp = cpu.z80Base[cpu.z80HL]; ! 3472: } ! 3473: ! 3474: bTemp |= 0x08; ! 3475: psMemWrite = cpu.z80MemWrite; /* Beginning of our handler */ ! 3476: while (psMemWrite->lowAddr != 0xffffffff) ! 3477: { ! 3478: if ((cpu.z80HL >= psMemWrite->lowAddr) && (cpu.z80HL <= psMemWrite->highAddr)) ! 3479: { ! 3480: cpu.z80pc = (UINT32) pbPC - (UINT32) cpu.z80Base; ! 3481: if (psMemWrite->memoryCall) ! 3482: { ! 3483: psMemWrite->memoryCall(cpu.z80HL, bTemp, psMemWrite); ! 3484: } ! 3485: else ! 3486: { ! 3487: *((UINT8 *) psMemWrite->pUserArea + (cpu.z80HL - psMemWrite->lowAddr)) = bTemp; ! 3488: } ! 3489: psMemWrite = NULL; ! 3490: break; ! 3491: } ! 3492: ++psMemWrite; ! 3493: } ! 3494: ! 3495: if (psMemWrite) ! 3496: { ! 3497: cpu.z80Base[cpu.z80HL] = (UINT8) bTemp; ! 3498: } ! 3499: ! 3500: break; ! 3501: } ! 3502: case 0xdf: ! 3503: { ! 3504: sdwCyclesRemaining -= 8; ! 3505: cpu.z80A |= 0x08; ! 3506: break; ! 3507: } ! 3508: case 0xe0: ! 3509: { ! 3510: sdwCyclesRemaining -= 8; ! 3511: cpu.z80B |= 0x10; ! 3512: break; ! 3513: } ! 3514: case 0xe1: ! 3515: { ! 3516: sdwCyclesRemaining -= 8; ! 3517: cpu.z80C |= 0x10; ! 3518: break; ! 3519: } ! 3520: case 0xe2: ! 3521: { ! 3522: sdwCyclesRemaining -= 8; ! 3523: cpu.z80D |= 0x10; ! 3524: break; ! 3525: } ! 3526: case 0xe3: ! 3527: { ! 3528: sdwCyclesRemaining -= 8; ! 3529: cpu.z80E |= 0x10; ! 3530: break; ! 3531: } ! 3532: case 0xe4: ! 3533: { ! 3534: sdwCyclesRemaining -= 8; ! 3535: cpu.z80H |= 0x10; ! 3536: break; ! 3537: } ! 3538: case 0xe5: ! 3539: { ! 3540: sdwCyclesRemaining -= 8; ! 3541: cpu.z80L |= 0x10; ! 3542: break; ! 3543: } ! 3544: case 0xe6: ! 3545: { ! 3546: sdwCyclesRemaining -= 15; ! 3547: psMemRead = cpu.z80MemRead; /* Beginning of our handler */ ! 3548: while (psMemRead->lowAddr != 0xffffffff) ! 3549: { ! 3550: if ((cpu.z80HL >= psMemRead->lowAddr) && (cpu.z80HL <= psMemRead->highAddr)) ! 3551: { ! 3552: cpu.z80pc = (UINT32) pbPC - (UINT32) cpu.z80Base; ! 3553: if (psMemRead->memoryCall) ! 3554: { ! 3555: bTemp = psMemRead->memoryCall(cpu.z80HL, psMemRead); ! 3556: } ! 3557: else ! 3558: { ! 3559: bTemp = *((UINT8 *) psMemRead->pUserArea + (cpu.z80HL - psMemRead->lowAddr)); ! 3560: } ! 3561: psMemRead = NULL; ! 3562: break; ! 3563: } ! 3564: ++psMemRead; ! 3565: } ! 3566: ! 3567: if (psMemRead) ! 3568: { ! 3569: bTemp = cpu.z80Base[cpu.z80HL]; ! 3570: } ! 3571: ! 3572: bTemp |= 0x10; ! 3573: psMemWrite = cpu.z80MemWrite; /* Beginning of our handler */ ! 3574: while (psMemWrite->lowAddr != 0xffffffff) ! 3575: { ! 3576: if ((cpu.z80HL >= psMemWrite->lowAddr) && (cpu.z80HL <= psMemWrite->highAddr)) ! 3577: { ! 3578: cpu.z80pc = (UINT32) pbPC - (UINT32) cpu.z80Base; ! 3579: if (psMemWrite->memoryCall) ! 3580: { ! 3581: psMemWrite->memoryCall(cpu.z80HL, bTemp, psMemWrite); ! 3582: } ! 3583: else ! 3584: { ! 3585: *((UINT8 *) psMemWrite->pUserArea + (cpu.z80HL - psMemWrite->lowAddr)) = bTemp; ! 3586: } ! 3587: psMemWrite = NULL; ! 3588: break; ! 3589: } ! 3590: ++psMemWrite; ! 3591: } ! 3592: ! 3593: if (psMemWrite) ! 3594: { ! 3595: cpu.z80Base[cpu.z80HL] = (UINT8) bTemp; ! 3596: } ! 3597: ! 3598: break; ! 3599: } ! 3600: case 0xe7: ! 3601: { ! 3602: sdwCyclesRemaining -= 8; ! 3603: cpu.z80A |= 0x10; ! 3604: break; ! 3605: } ! 3606: case 0xe8: ! 3607: { ! 3608: sdwCyclesRemaining -= 8; ! 3609: cpu.z80B |= 0x20; ! 3610: break; ! 3611: } ! 3612: case 0xe9: ! 3613: { ! 3614: sdwCyclesRemaining -= 8; ! 3615: cpu.z80C |= 0x20; ! 3616: break; ! 3617: } ! 3618: case 0xea: ! 3619: { ! 3620: sdwCyclesRemaining -= 8; ! 3621: cpu.z80D |= 0x20; ! 3622: break; ! 3623: } ! 3624: case 0xeb: ! 3625: { ! 3626: sdwCyclesRemaining -= 8; ! 3627: cpu.z80E |= 0x20; ! 3628: break; ! 3629: } ! 3630: case 0xec: ! 3631: { ! 3632: sdwCyclesRemaining -= 8; ! 3633: cpu.z80H |= 0x20; ! 3634: break; ! 3635: } ! 3636: case 0xed: ! 3637: { ! 3638: sdwCyclesRemaining -= 8; ! 3639: cpu.z80L |= 0x20; ! 3640: break; ! 3641: } ! 3642: case 0xee: ! 3643: { ! 3644: sdwCyclesRemaining -= 15; ! 3645: psMemRead = cpu.z80MemRead; /* Beginning of our handler */ ! 3646: while (psMemRead->lowAddr != 0xffffffff) ! 3647: { ! 3648: if ((cpu.z80HL >= psMemRead->lowAddr) && (cpu.z80HL <= psMemRead->highAddr)) ! 3649: { ! 3650: cpu.z80pc = (UINT32) pbPC - (UINT32) cpu.z80Base; ! 3651: if (psMemRead->memoryCall) ! 3652: { ! 3653: bTemp = psMemRead->memoryCall(cpu.z80HL, psMemRead); ! 3654: } ! 3655: else ! 3656: { ! 3657: bTemp = *((UINT8 *) psMemRead->pUserArea + (cpu.z80HL - psMemRead->lowAddr)); ! 3658: } ! 3659: psMemRead = NULL; ! 3660: break; ! 3661: } ! 3662: ++psMemRead; ! 3663: } ! 3664: ! 3665: if (psMemRead) ! 3666: { ! 3667: bTemp = cpu.z80Base[cpu.z80HL]; ! 3668: } ! 3669: ! 3670: bTemp |= 0x20; ! 3671: psMemWrite = cpu.z80MemWrite; /* Beginning of our handler */ ! 3672: while (psMemWrite->lowAddr != 0xffffffff) ! 3673: { ! 3674: if ((cpu.z80HL >= psMemWrite->lowAddr) && (cpu.z80HL <= psMemWrite->highAddr)) ! 3675: { ! 3676: cpu.z80pc = (UINT32) pbPC - (UINT32) cpu.z80Base; ! 3677: if (psMemWrite->memoryCall) ! 3678: { ! 3679: psMemWrite->memoryCall(cpu.z80HL, bTemp, psMemWrite); ! 3680: } ! 3681: else ! 3682: { ! 3683: *((UINT8 *) psMemWrite->pUserArea + (cpu.z80HL - psMemWrite->lowAddr)) = bTemp; ! 3684: } ! 3685: psMemWrite = NULL; ! 3686: break; ! 3687: } ! 3688: ++psMemWrite; ! 3689: } ! 3690: ! 3691: if (psMemWrite) ! 3692: { ! 3693: cpu.z80Base[cpu.z80HL] = (UINT8) bTemp; ! 3694: } ! 3695: ! 3696: break; ! 3697: } ! 3698: case 0xef: ! 3699: { ! 3700: sdwCyclesRemaining -= 8; ! 3701: cpu.z80A |= 0x20; ! 3702: break; ! 3703: } ! 3704: case 0xf0: ! 3705: { ! 3706: sdwCyclesRemaining -= 8; ! 3707: cpu.z80B |= 0x40; ! 3708: break; ! 3709: } ! 3710: case 0xf1: ! 3711: { ! 3712: sdwCyclesRemaining -= 8; ! 3713: cpu.z80C |= 0x40; ! 3714: break; ! 3715: } ! 3716: case 0xf2: ! 3717: { ! 3718: sdwCyclesRemaining -= 8; ! 3719: cpu.z80D |= 0x40; ! 3720: break; ! 3721: } ! 3722: case 0xf3: ! 3723: { ! 3724: sdwCyclesRemaining -= 8; ! 3725: cpu.z80E |= 0x40; ! 3726: break; ! 3727: } ! 3728: case 0xf4: ! 3729: { ! 3730: sdwCyclesRemaining -= 8; ! 3731: cpu.z80H |= 0x40; ! 3732: break; ! 3733: } ! 3734: case 0xf5: ! 3735: { ! 3736: sdwCyclesRemaining -= 8; ! 3737: cpu.z80L |= 0x40; ! 3738: break; ! 3739: } ! 3740: case 0xf6: ! 3741: { ! 3742: sdwCyclesRemaining -= 15; ! 3743: psMemRead = cpu.z80MemRead; /* Beginning of our handler */ ! 3744: while (psMemRead->lowAddr != 0xffffffff) ! 3745: { ! 3746: if ((cpu.z80HL >= psMemRead->lowAddr) && (cpu.z80HL <= psMemRead->highAddr)) ! 3747: { ! 3748: cpu.z80pc = (UINT32) pbPC - (UINT32) cpu.z80Base; ! 3749: if (psMemRead->memoryCall) ! 3750: { ! 3751: bTemp = psMemRead->memoryCall(cpu.z80HL, psMemRead); ! 3752: } ! 3753: else ! 3754: { ! 3755: bTemp = *((UINT8 *) psMemRead->pUserArea + (cpu.z80HL - psMemRead->lowAddr)); ! 3756: } ! 3757: psMemRead = NULL; ! 3758: break; ! 3759: } ! 3760: ++psMemRead; ! 3761: } ! 3762: ! 3763: if (psMemRead) ! 3764: { ! 3765: bTemp = cpu.z80Base[cpu.z80HL]; ! 3766: } ! 3767: ! 3768: bTemp |= 0x40; ! 3769: psMemWrite = cpu.z80MemWrite; /* Beginning of our handler */ ! 3770: while (psMemWrite->lowAddr != 0xffffffff) ! 3771: { ! 3772: if ((cpu.z80HL >= psMemWrite->lowAddr) && (cpu.z80HL <= psMemWrite->highAddr)) ! 3773: { ! 3774: cpu.z80pc = (UINT32) pbPC - (UINT32) cpu.z80Base; ! 3775: if (psMemWrite->memoryCall) ! 3776: { ! 3777: psMemWrite->memoryCall(cpu.z80HL, bTemp, psMemWrite); ! 3778: } ! 3779: else ! 3780: { ! 3781: *((UINT8 *) psMemWrite->pUserArea + (cpu.z80HL - psMemWrite->lowAddr)) = bTemp; ! 3782: } ! 3783: psMemWrite = NULL; ! 3784: break; ! 3785: } ! 3786: ++psMemWrite; ! 3787: } ! 3788: ! 3789: if (psMemWrite) ! 3790: { ! 3791: cpu.z80Base[cpu.z80HL] = (UINT8) bTemp; ! 3792: } ! 3793: ! 3794: break; ! 3795: } ! 3796: case 0xf7: ! 3797: { ! 3798: sdwCyclesRemaining -= 8; ! 3799: cpu.z80A |= 0x40; ! 3800: break; ! 3801: } ! 3802: case 0xf8: ! 3803: { ! 3804: sdwCyclesRemaining -= 8; ! 3805: cpu.z80B |= 0x80; ! 3806: break; ! 3807: } ! 3808: case 0xf9: ! 3809: { ! 3810: sdwCyclesRemaining -= 8; ! 3811: cpu.z80C |= 0x80; ! 3812: break; ! 3813: } ! 3814: case 0xfa: ! 3815: { ! 3816: sdwCyclesRemaining -= 8; ! 3817: cpu.z80D |= 0x80; ! 3818: break; ! 3819: } ! 3820: case 0xfb: ! 3821: { ! 3822: sdwCyclesRemaining -= 8; ! 3823: cpu.z80E |= 0x80; ! 3824: break; ! 3825: } ! 3826: case 0xfc: ! 3827: { ! 3828: sdwCyclesRemaining -= 8; ! 3829: cpu.z80H |= 0x80; ! 3830: break; ! 3831: } ! 3832: case 0xfd: ! 3833: { ! 3834: sdwCyclesRemaining -= 8; ! 3835: cpu.z80L |= 0x80; ! 3836: break; ! 3837: } ! 3838: case 0xfe: ! 3839: { ! 3840: sdwCyclesRemaining -= 15; ! 3841: psMemRead = cpu.z80MemRead; /* Beginning of our handler */ ! 3842: while (psMemRead->lowAddr != 0xffffffff) ! 3843: { ! 3844: if ((cpu.z80HL >= psMemRead->lowAddr) && (cpu.z80HL <= psMemRead->highAddr)) ! 3845: { ! 3846: cpu.z80pc = (UINT32) pbPC - (UINT32) cpu.z80Base; ! 3847: if (psMemRead->memoryCall) ! 3848: { ! 3849: bTemp = psMemRead->memoryCall(cpu.z80HL, psMemRead); ! 3850: } ! 3851: else ! 3852: { ! 3853: bTemp = *((UINT8 *) psMemRead->pUserArea + (cpu.z80HL - psMemRead->lowAddr)); ! 3854: } ! 3855: psMemRead = NULL; ! 3856: break; ! 3857: } ! 3858: ++psMemRead; ! 3859: } ! 3860: ! 3861: if (psMemRead) ! 3862: { ! 3863: bTemp = cpu.z80Base[cpu.z80HL]; ! 3864: } ! 3865: ! 3866: bTemp |= 0x80; ! 3867: psMemWrite = cpu.z80MemWrite; /* Beginning of our handler */ ! 3868: while (psMemWrite->lowAddr != 0xffffffff) ! 3869: { ! 3870: if ((cpu.z80HL >= psMemWrite->lowAddr) && (cpu.z80HL <= psMemWrite->highAddr)) ! 3871: { ! 3872: cpu.z80pc = (UINT32) pbPC - (UINT32) cpu.z80Base; ! 3873: if (psMemWrite->memoryCall) ! 3874: { ! 3875: psMemWrite->memoryCall(cpu.z80HL, bTemp, psMemWrite); ! 3876: } ! 3877: else ! 3878: { ! 3879: *((UINT8 *) psMemWrite->pUserArea + (cpu.z80HL - psMemWrite->lowAddr)) = bTemp; ! 3880: } ! 3881: psMemWrite = NULL; ! 3882: break; ! 3883: } ! 3884: ++psMemWrite; ! 3885: } ! 3886: ! 3887: if (psMemWrite) ! 3888: { ! 3889: cpu.z80Base[cpu.z80HL] = (UINT8) bTemp; ! 3890: } ! 3891: ! 3892: break; ! 3893: } ! 3894: case 0xff: ! 3895: { ! 3896: sdwCyclesRemaining -= 8; ! 3897: cpu.z80A |= 0x80; ! 3898: break; ! 3899: } ! 3900: } ! 3901: } ! 3902: void EDHandler(void) ! 3903: { ! 3904: switch (*pbPC++) ! 3905: { ! 3906: case 0x00: ! 3907: { ! 3908: InvalidInstruction(2); ! 3909: break; ! 3910: } ! 3911: case 0x01: ! 3912: { ! 3913: InvalidInstruction(2); ! 3914: break; ! 3915: } ! 3916: case 0x02: ! 3917: { ! 3918: InvalidInstruction(2); ! 3919: break; ! 3920: } ! 3921: case 0x03: ! 3922: { ! 3923: InvalidInstruction(2); ! 3924: break; ! 3925: } ! 3926: case 0x04: ! 3927: { ! 3928: InvalidInstruction(2); ! 3929: break; ! 3930: } ! 3931: case 0x05: ! 3932: { ! 3933: InvalidInstruction(2); ! 3934: break; ! 3935: } ! 3936: case 0x06: ! 3937: { ! 3938: InvalidInstruction(2); ! 3939: break; ! 3940: } ! 3941: case 0x07: ! 3942: { ! 3943: InvalidInstruction(2); ! 3944: break; ! 3945: } ! 3946: case 0x08: ! 3947: { ! 3948: InvalidInstruction(2); ! 3949: break; ! 3950: } ! 3951: case 0x09: ! 3952: { ! 3953: InvalidInstruction(2); ! 3954: break; ! 3955: } ! 3956: case 0x0a: ! 3957: { ! 3958: InvalidInstruction(2); ! 3959: break; ! 3960: } ! 3961: case 0x0b: ! 3962: { ! 3963: InvalidInstruction(2); ! 3964: break; ! 3965: } ! 3966: case 0x0c: ! 3967: { ! 3968: InvalidInstruction(2); ! 3969: break; ! 3970: } ! 3971: case 0x0d: ! 3972: { ! 3973: InvalidInstruction(2); ! 3974: break; ! 3975: } ! 3976: case 0x0e: ! 3977: { ! 3978: InvalidInstruction(2); ! 3979: break; ! 3980: } ! 3981: case 0x0f: ! 3982: { ! 3983: InvalidInstruction(2); ! 3984: break; ! 3985: } ! 3986: case 0x10: ! 3987: { ! 3988: InvalidInstruction(2); ! 3989: break; ! 3990: } ! 3991: case 0x11: ! 3992: { ! 3993: InvalidInstruction(2); ! 3994: break; ! 3995: } ! 3996: case 0x12: ! 3997: { ! 3998: InvalidInstruction(2); ! 3999: break; ! 4000: } ! 4001: case 0x13: ! 4002: { ! 4003: InvalidInstruction(2); ! 4004: break; ! 4005: } ! 4006: case 0x14: ! 4007: { ! 4008: InvalidInstruction(2); ! 4009: break; ! 4010: } ! 4011: case 0x15: ! 4012: { ! 4013: InvalidInstruction(2); ! 4014: break; ! 4015: } ! 4016: case 0x16: ! 4017: { ! 4018: InvalidInstruction(2); ! 4019: break; ! 4020: } ! 4021: case 0x17: ! 4022: { ! 4023: InvalidInstruction(2); ! 4024: break; ! 4025: } ! 4026: case 0x18: ! 4027: { ! 4028: InvalidInstruction(2); ! 4029: break; ! 4030: } ! 4031: case 0x19: ! 4032: { ! 4033: InvalidInstruction(2); ! 4034: break; ! 4035: } ! 4036: case 0x1a: ! 4037: { ! 4038: InvalidInstruction(2); ! 4039: break; ! 4040: } ! 4041: case 0x1b: ! 4042: { ! 4043: InvalidInstruction(2); ! 4044: break; ! 4045: } ! 4046: case 0x1c: ! 4047: { ! 4048: InvalidInstruction(2); ! 4049: break; ! 4050: } ! 4051: case 0x1d: ! 4052: { ! 4053: InvalidInstruction(2); ! 4054: break; ! 4055: } ! 4056: case 0x1e: ! 4057: { ! 4058: InvalidInstruction(2); ! 4059: break; ! 4060: } ! 4061: case 0x1f: ! 4062: { ! 4063: InvalidInstruction(2); ! 4064: break; ! 4065: } ! 4066: case 0x20: ! 4067: { ! 4068: InvalidInstruction(2); ! 4069: break; ! 4070: } ! 4071: case 0x21: ! 4072: { ! 4073: InvalidInstruction(2); ! 4074: break; ! 4075: } ! 4076: case 0x22: ! 4077: { ! 4078: InvalidInstruction(2); ! 4079: break; ! 4080: } ! 4081: case 0x23: ! 4082: { ! 4083: InvalidInstruction(2); ! 4084: break; ! 4085: } ! 4086: case 0x24: ! 4087: { ! 4088: InvalidInstruction(2); ! 4089: break; ! 4090: } ! 4091: case 0x25: ! 4092: { ! 4093: InvalidInstruction(2); ! 4094: break; ! 4095: } ! 4096: case 0x26: ! 4097: { ! 4098: InvalidInstruction(2); ! 4099: break; ! 4100: } ! 4101: case 0x27: ! 4102: { ! 4103: InvalidInstruction(2); ! 4104: break; ! 4105: } ! 4106: case 0x28: ! 4107: { ! 4108: InvalidInstruction(2); ! 4109: break; ! 4110: } ! 4111: case 0x29: ! 4112: { ! 4113: InvalidInstruction(2); ! 4114: break; ! 4115: } ! 4116: case 0x2a: ! 4117: { ! 4118: InvalidInstruction(2); ! 4119: break; ! 4120: } ! 4121: case 0x2b: ! 4122: { ! 4123: InvalidInstruction(2); ! 4124: break; ! 4125: } ! 4126: case 0x2c: ! 4127: { ! 4128: InvalidInstruction(2); ! 4129: break; ! 4130: } ! 4131: case 0x2d: ! 4132: { ! 4133: InvalidInstruction(2); ! 4134: break; ! 4135: } ! 4136: case 0x2e: ! 4137: { ! 4138: InvalidInstruction(2); ! 4139: break; ! 4140: } ! 4141: case 0x2f: ! 4142: { ! 4143: InvalidInstruction(2); ! 4144: break; ! 4145: } ! 4146: case 0x30: ! 4147: { ! 4148: InvalidInstruction(2); ! 4149: break; ! 4150: } ! 4151: case 0x31: ! 4152: { ! 4153: InvalidInstruction(2); ! 4154: break; ! 4155: } ! 4156: case 0x32: ! 4157: { ! 4158: InvalidInstruction(2); ! 4159: break; ! 4160: } ! 4161: case 0x33: ! 4162: { ! 4163: InvalidInstruction(2); ! 4164: break; ! 4165: } ! 4166: case 0x34: ! 4167: { ! 4168: InvalidInstruction(2); ! 4169: break; ! 4170: } ! 4171: case 0x35: ! 4172: { ! 4173: InvalidInstruction(2); ! 4174: break; ! 4175: } ! 4176: case 0x36: ! 4177: { ! 4178: InvalidInstruction(2); ! 4179: break; ! 4180: } ! 4181: case 0x37: ! 4182: { ! 4183: InvalidInstruction(2); ! 4184: break; ! 4185: } ! 4186: case 0x38: ! 4187: { ! 4188: InvalidInstruction(2); ! 4189: break; ! 4190: } ! 4191: case 0x39: ! 4192: { ! 4193: InvalidInstruction(2); ! 4194: break; ! 4195: } ! 4196: case 0x3a: ! 4197: { ! 4198: InvalidInstruction(2); ! 4199: break; ! 4200: } ! 4201: case 0x3b: ! 4202: { ! 4203: InvalidInstruction(2); ! 4204: break; ! 4205: } ! 4206: case 0x3c: ! 4207: { ! 4208: InvalidInstruction(2); ! 4209: break; ! 4210: } ! 4211: case 0x3d: ! 4212: { ! 4213: InvalidInstruction(2); ! 4214: break; ! 4215: } ! 4216: case 0x3e: ! 4217: { ! 4218: InvalidInstruction(2); ! 4219: break; ! 4220: } ! 4221: case 0x3f: ! 4222: { ! 4223: InvalidInstruction(2); ! 4224: break; ! 4225: } ! 4226: case 0x40: ! 4227: { ! 4228: sdwCyclesRemaining -= 12; ! 4229: dwAddr = cpu.z80C; ! 4230: psIoRead = cpu.z80IoRead; /* Beginning of our handler */ ! 4231: while (psIoRead->lowIoAddr != 0xffff) ! 4232: { ! 4233: if ((dwAddr >= psIoRead->lowIoAddr) && (dwAddr <= psIoRead->highIoAddr)) ! 4234: { ! 4235: cpu.z80pc = (UINT32) pbPC - (UINT32) cpu.z80Base; ! 4236: cpu.z80B = psIoRead->IOCall(dwAddr, psIoRead); ! 4237: psIoRead = NULL; ! 4238: break; ! 4239: } ! 4240: ++psIoRead; ! 4241: } ! 4242: ! 4243: if (psIoRead) ! 4244: { ! 4245: cpu.z80B = 0xff; /* Unclaimed I/O read */ ! 4246: } ! 4247: ! 4248: cpu.z80F &= ~(Z80_FLAG_SIGN | Z80_FLAG_ZERO | Z80_FLAG_HALF_CARRY | Z80_FLAG_OVERFLOW_PARITY | Z80_FLAG_NEGATIVE); ! 4249: cpu.z80F |= bPostORFlags[cpu.z80B]; ! 4250: break; ! 4251: } ! 4252: case 0x41: ! 4253: { ! 4254: sdwCyclesRemaining -= 12; ! 4255: dwAddr = cpu.z80C; ! 4256: psIoWrite = cpu.z80IoWrite; /* Beginning of our handler */ ! 4257: while (psIoWrite->lowIoAddr != 0xffff) ! 4258: { ! 4259: if ((dwAddr >= psIoWrite->lowIoAddr) && (dwAddr <= psIoWrite->highIoAddr)) ! 4260: { ! 4261: cpu.z80pc = (UINT32) pbPC - (UINT32) cpu.z80Base; ! 4262: psIoWrite->IOCall(dwAddr, cpu.z80B, psIoWrite); ! 4263: psIoWrite = NULL; ! 4264: break; ! 4265: } ! 4266: ++psIoWrite; ! 4267: } ! 4268: ! 4269: break; ! 4270: } ! 4271: case 0x42: ! 4272: { ! 4273: sdwCyclesRemaining -= 15; ! 4274: dwTemp = cpu.z80HL - cpu.z80BC - (cpu.z80F & Z80_FLAG_CARRY); ! 4275: cpu.z80F &= ~(Z80_FLAG_CARRY | Z80_FLAG_NEGATIVE | Z80_FLAG_OVERFLOW_PARITY | Z80_FLAG_HALF_CARRY | Z80_FLAG_ZERO | Z80_FLAG_SIGN); ! 4276: cpu.z80F |= ((dwTemp >> 8) & Z80_FLAG_SIGN); ! 4277: if (0 == (dwTemp & 0xffff)) ! 4278: { ! 4279: cpu.z80F |= Z80_FLAG_ZERO; ! 4280: } ! 4281: cpu.z80F |= (((cpu.z80HL ^ dwTemp ^ cpu.z80BC) >> 8) & Z80_FLAG_HALF_CARRY); ! 4282: cpu.z80F |= ((((cpu.z80BC ^ cpu.z80HL) & (cpu.z80BC ^ dwTemp)) >> 13) & Z80_FLAG_OVERFLOW_PARITY); ! 4283: cpu.z80F |= ((dwTemp >> 16) & Z80_FLAG_CARRY); ! 4284: cpu.z80HL = dwTemp & 0xffff; ! 4285: break; ! 4286: } ! 4287: case 0x43: ! 4288: { ! 4289: sdwCyclesRemaining -= 20; ! 4290: dwTemp = *pbPC++; ! 4291: dwTemp |= ((UINT32) *pbPC++ << 8); ! 4292: psMemWrite = cpu.z80MemWrite; /* Beginning of our handler */ ! 4293: while (psMemWrite->lowAddr != 0xffffffff) ! 4294: { ! 4295: if ((dwTemp >= psMemWrite->lowAddr) && (dwTemp <= psMemWrite->highAddr)) ! 4296: { ! 4297: cpu.z80pc = (UINT32) pbPC - (UINT32) cpu.z80Base; ! 4298: if (psMemWrite->memoryCall) ! 4299: { ! 4300: psMemWrite->memoryCall(dwTemp, (cpu.z80BC & 0xff), psMemWrite); ! 4301: psMemWrite->memoryCall(dwTemp + 1, (cpu.z80BC >> 8), psMemWrite); ! 4302: } ! 4303: else ! 4304: { ! 4305: *((UINT8 *) psMemWrite->pUserArea + (dwTemp - psMemWrite->lowAddr)) = cpu.z80BC; ! 4306: *((UINT8 *) psMemWrite->pUserArea + (dwTemp - psMemWrite->lowAddr) + 1) = cpu.z80BC >> 8; ! 4307: } ! 4308: psMemWrite = NULL; ! 4309: break; ! 4310: } ! 4311: ++psMemWrite; ! 4312: } ! 4313: ! 4314: if (psMemWrite) ! 4315: { ! 4316: cpu.z80Base[dwTemp] = (UINT8) cpu.z80BC; ! 4317: cpu.z80Base[dwTemp + 1] = (UINT8) ((UINT32) cpu.z80BC >> 8); ! 4318: } ! 4319: ! 4320: break; ! 4321: } ! 4322: case 0x44: ! 4323: { ! 4324: sdwCyclesRemaining -= 8; ! 4325: cpu.z80F = (cpu.z80F & ~(Z80_FLAG_CARRY | Z80_FLAG_NEGATIVE | Z80_FLAG_OVERFLOW_PARITY | ! 4326: Z80_FLAG_HALF_CARRY | Z80_FLAG_ZERO | Z80_FLAG_SIGN)) | ! 4327: pbSubSbcTable[((UINT32) 0 << 8) | cpu.z80A]; ! 4328: cpu.z80A = 0 - cpu.z80A; ! 4329: break; ! 4330: } ! 4331: case 0x45: ! 4332: { ! 4333: sdwCyclesRemaining -= 14; ! 4334: pbSP = cpu.z80Base + cpu.z80sp; /* Normalize our stack PTR */ ! 4335: dwAddr = *pbSP++; /* Pop LSB */ ! 4336: dwAddr |= ((UINT32) *pbSP << 8); /* Pop MSB */ ! 4337: cpu.z80sp += 2; /* Pop the word off */ ! 4338: pbPC = (cpu.z80Base + dwAddr); /* Point PC to our return address */ ! 4339: cpu.z80iff &= ~(IFF1); /* Keep IFF2 around */ ! 4340: cpu.z80iff |= ((cpu.z80iff >> 1) & IFF1); /* IFF2->IFF1 */ ! 4341: break; ! 4342: } ! 4343: case 0x46: ! 4344: { ! 4345: sdwCyclesRemaining -= 8; ! 4346: cpu.z80interruptMode = 0; ! 4347: break; ! 4348: } ! 4349: case 0x47: ! 4350: { ! 4351: sdwCyclesRemaining -= 9; ! 4352: cpu.z80i = cpu.z80A; ! 4353: break; ! 4354: } ! 4355: case 0x48: ! 4356: { ! 4357: sdwCyclesRemaining -= 12; ! 4358: dwAddr = cpu.z80C; ! 4359: psIoRead = cpu.z80IoRead; /* Beginning of our handler */ ! 4360: while (psIoRead->lowIoAddr != 0xffff) ! 4361: { ! 4362: if ((dwAddr >= psIoRead->lowIoAddr) && (dwAddr <= psIoRead->highIoAddr)) ! 4363: { ! 4364: cpu.z80pc = (UINT32) pbPC - (UINT32) cpu.z80Base; ! 4365: cpu.z80C = psIoRead->IOCall(dwAddr, psIoRead); ! 4366: psIoRead = NULL; ! 4367: break; ! 4368: } ! 4369: ++psIoRead; ! 4370: } ! 4371: ! 4372: if (psIoRead) ! 4373: { ! 4374: cpu.z80C = 0xff; /* Unclaimed I/O read */ ! 4375: } ! 4376: ! 4377: cpu.z80F &= ~(Z80_FLAG_SIGN | Z80_FLAG_ZERO | Z80_FLAG_HALF_CARRY | Z80_FLAG_OVERFLOW_PARITY | Z80_FLAG_NEGATIVE); ! 4378: cpu.z80F |= bPostORFlags[cpu.z80C]; ! 4379: break; ! 4380: } ! 4381: case 0x49: ! 4382: { ! 4383: sdwCyclesRemaining -= 12; ! 4384: dwAddr = cpu.z80C; ! 4385: psIoWrite = cpu.z80IoWrite; /* Beginning of our handler */ ! 4386: while (psIoWrite->lowIoAddr != 0xffff) ! 4387: { ! 4388: if ((dwAddr >= psIoWrite->lowIoAddr) && (dwAddr <= psIoWrite->highIoAddr)) ! 4389: { ! 4390: cpu.z80pc = (UINT32) pbPC - (UINT32) cpu.z80Base; ! 4391: psIoWrite->IOCall(dwAddr, cpu.z80C, psIoWrite); ! 4392: psIoWrite = NULL; ! 4393: break; ! 4394: } ! 4395: ++psIoWrite; ! 4396: } ! 4397: ! 4398: break; ! 4399: } ! 4400: case 0x4a: ! 4401: { ! 4402: sdwCyclesRemaining -= 15; ! 4403: dwTemp = cpu.z80HL + cpu.z80BC + (cpu.z80F & Z80_FLAG_CARRY); ! 4404: cpu.z80F &= ~(Z80_FLAG_CARRY | Z80_FLAG_NEGATIVE | Z80_FLAG_OVERFLOW_PARITY | Z80_FLAG_HALF_CARRY | Z80_FLAG_ZERO | Z80_FLAG_SIGN); ! 4405: cpu.z80F |= ((dwTemp >> 8) & Z80_FLAG_SIGN); ! 4406: if (0 == (dwTemp & 0xffff)) ! 4407: { ! 4408: cpu.z80F |= Z80_FLAG_ZERO; ! 4409: } ! 4410: cpu.z80F |= (((cpu.z80HL ^ dwTemp ^ cpu.z80BC) >> 8) & Z80_FLAG_HALF_CARRY); ! 4411: cpu.z80F |= ((((cpu.z80BC ^ cpu.z80HL ^ 0x8000) & (cpu.z80BC ^ dwTemp)) >> 13) & Z80_FLAG_OVERFLOW_PARITY); ! 4412: cpu.z80F |= ((dwTemp >> 16) & Z80_FLAG_CARRY); ! 4413: cpu.z80HL = dwTemp & 0xffff; ! 4414: break; ! 4415: } ! 4416: case 0x4b: ! 4417: { ! 4418: sdwCyclesRemaining -= 20; ! 4419: dwTemp = *pbPC++; ! 4420: dwTemp |= ((UINT32) *pbPC++ << 8); ! 4421: psMemRead = cpu.z80MemRead; /* Beginning of our handler */ ! 4422: while (psMemRead->lowAddr != 0xffffffff) ! 4423: { ! 4424: if ((dwTemp >= psMemRead->lowAddr) && (dwTemp <= psMemRead->highAddr)) ! 4425: { ! 4426: cpu.z80pc = (UINT32) pbPC - (UINT32) cpu.z80Base; ! 4427: if (psMemRead->memoryCall) ! 4428: { ! 4429: cpu.z80BC = psMemRead->memoryCall(dwTemp, psMemRead); ! 4430: cpu.z80BC |= (UINT32) ((UINT32) psMemRead->memoryCall(dwTemp + 1, psMemRead) << 8); ! 4431: } ! 4432: else ! 4433: { ! 4434: cpu.z80BC = *((UINT8 *) psMemRead->pUserArea + (dwTemp - psMemRead->lowAddr)); ! 4435: cpu.z80BC |= (UINT32) ((UINT32) *((UINT8 *) psMemRead->pUserArea + (dwTemp - psMemRead->lowAddr + 1)) << 8); ! 4436: } ! 4437: psMemRead = NULL; ! 4438: break; ! 4439: } ! 4440: ++psMemRead; ! 4441: } ! 4442: ! 4443: if (psMemRead) ! 4444: { ! 4445: cpu.z80BC = cpu.z80Base[dwTemp]; ! 4446: cpu.z80BC |= (UINT32) ((UINT32) cpu.z80Base[dwTemp + 1] << 8); ! 4447: } ! 4448: ! 4449: break; ! 4450: } ! 4451: case 0x4c: ! 4452: { ! 4453: sdwCyclesRemaining -= 8; ! 4454: InvalidInstruction(2); ! 4455: break; ! 4456: } ! 4457: case 0x4d: ! 4458: { ! 4459: sdwCyclesRemaining -= 14; ! 4460: pbSP = cpu.z80Base + cpu.z80sp; /* Normalize our stack PTR */ ! 4461: dwAddr = *pbSP++; /* Pop LSB */ ! 4462: dwAddr |= ((UINT32) *pbSP << 8); /* Pop MSB */ ! 4463: cpu.z80sp += 2; /* Pop the word off */ ! 4464: pbPC = (cpu.z80Base + dwAddr); /* Point PC to our return address */ ! 4465: break; ! 4466: } ! 4467: case 0x4e: ! 4468: { ! 4469: sdwCyclesRemaining -= 8; ! 4470: InvalidInstruction(2); ! 4471: break; ! 4472: } ! 4473: case 0x4f: ! 4474: { ! 4475: sdwCyclesRemaining -= 9; ! 4476: cpu.z80r = cpu.z80A; ! 4477: break; ! 4478: } ! 4479: case 0x50: ! 4480: { ! 4481: sdwCyclesRemaining -= 12; ! 4482: dwAddr = cpu.z80C; ! 4483: psIoRead = cpu.z80IoRead; /* Beginning of our handler */ ! 4484: while (psIoRead->lowIoAddr != 0xffff) ! 4485: { ! 4486: if ((dwAddr >= psIoRead->lowIoAddr) && (dwAddr <= psIoRead->highIoAddr)) ! 4487: { ! 4488: cpu.z80pc = (UINT32) pbPC - (UINT32) cpu.z80Base; ! 4489: cpu.z80D = psIoRead->IOCall(dwAddr, psIoRead); ! 4490: psIoRead = NULL; ! 4491: break; ! 4492: } ! 4493: ++psIoRead; ! 4494: } ! 4495: ! 4496: if (psIoRead) ! 4497: { ! 4498: cpu.z80D = 0xff; /* Unclaimed I/O read */ ! 4499: } ! 4500: ! 4501: cpu.z80F &= ~(Z80_FLAG_SIGN | Z80_FLAG_ZERO | Z80_FLAG_HALF_CARRY | Z80_FLAG_OVERFLOW_PARITY | Z80_FLAG_NEGATIVE); ! 4502: cpu.z80F |= bPostORFlags[cpu.z80D]; ! 4503: break; ! 4504: } ! 4505: case 0x51: ! 4506: { ! 4507: sdwCyclesRemaining -= 12; ! 4508: dwAddr = cpu.z80C; ! 4509: psIoWrite = cpu.z80IoWrite; /* Beginning of our handler */ ! 4510: while (psIoWrite->lowIoAddr != 0xffff) ! 4511: { ! 4512: if ((dwAddr >= psIoWrite->lowIoAddr) && (dwAddr <= psIoWrite->highIoAddr)) ! 4513: { ! 4514: cpu.z80pc = (UINT32) pbPC - (UINT32) cpu.z80Base; ! 4515: psIoWrite->IOCall(dwAddr, cpu.z80D, psIoWrite); ! 4516: psIoWrite = NULL; ! 4517: break; ! 4518: } ! 4519: ++psIoWrite; ! 4520: } ! 4521: ! 4522: break; ! 4523: } ! 4524: case 0x52: ! 4525: { ! 4526: sdwCyclesRemaining -= 15; ! 4527: dwTemp = cpu.z80HL - cpu.z80DE - (cpu.z80F & Z80_FLAG_CARRY); ! 4528: cpu.z80F &= ~(Z80_FLAG_CARRY | Z80_FLAG_NEGATIVE | Z80_FLAG_OVERFLOW_PARITY | Z80_FLAG_HALF_CARRY | Z80_FLAG_ZERO | Z80_FLAG_SIGN); ! 4529: cpu.z80F |= ((dwTemp >> 8) & Z80_FLAG_SIGN); ! 4530: if (0 == (dwTemp & 0xffff)) ! 4531: { ! 4532: cpu.z80F |= Z80_FLAG_ZERO; ! 4533: } ! 4534: cpu.z80F |= (((cpu.z80HL ^ dwTemp ^ cpu.z80DE) >> 8) & Z80_FLAG_HALF_CARRY); ! 4535: cpu.z80F |= ((((cpu.z80DE ^ cpu.z80HL) & (cpu.z80DE ^ dwTemp)) >> 13) & Z80_FLAG_OVERFLOW_PARITY); ! 4536: cpu.z80F |= ((dwTemp >> 16) & Z80_FLAG_CARRY); ! 4537: cpu.z80HL = dwTemp & 0xffff; ! 4538: break; ! 4539: } ! 4540: case 0x53: ! 4541: { ! 4542: sdwCyclesRemaining -= 20; ! 4543: dwTemp = *pbPC++; ! 4544: dwTemp |= ((UINT32) *pbPC++ << 8); ! 4545: psMemWrite = cpu.z80MemWrite; /* Beginning of our handler */ ! 4546: while (psMemWrite->lowAddr != 0xffffffff) ! 4547: { ! 4548: if ((dwTemp >= psMemWrite->lowAddr) && (dwTemp <= psMemWrite->highAddr)) ! 4549: { ! 4550: cpu.z80pc = (UINT32) pbPC - (UINT32) cpu.z80Base; ! 4551: if (psMemWrite->memoryCall) ! 4552: { ! 4553: psMemWrite->memoryCall(dwTemp, (cpu.z80DE & 0xff), psMemWrite); ! 4554: psMemWrite->memoryCall(dwTemp + 1, (cpu.z80DE >> 8), psMemWrite); ! 4555: } ! 4556: else ! 4557: { ! 4558: *((UINT8 *) psMemWrite->pUserArea + (dwTemp - psMemWrite->lowAddr)) = cpu.z80DE; ! 4559: *((UINT8 *) psMemWrite->pUserArea + (dwTemp - psMemWrite->lowAddr) + 1) = cpu.z80DE >> 8; ! 4560: } ! 4561: psMemWrite = NULL; ! 4562: break; ! 4563: } ! 4564: ++psMemWrite; ! 4565: } ! 4566: ! 4567: if (psMemWrite) ! 4568: { ! 4569: cpu.z80Base[dwTemp] = (UINT8) cpu.z80DE; ! 4570: cpu.z80Base[dwTemp + 1] = (UINT8) ((UINT32) cpu.z80DE >> 8); ! 4571: } ! 4572: ! 4573: break; ! 4574: } ! 4575: case 0x54: ! 4576: { ! 4577: sdwCyclesRemaining -= 8; ! 4578: InvalidInstruction(2); ! 4579: break; ! 4580: } ! 4581: case 0x55: ! 4582: { ! 4583: sdwCyclesRemaining -= 8; ! 4584: InvalidInstruction(2); ! 4585: break; ! 4586: } ! 4587: case 0x56: ! 4588: { ! 4589: sdwCyclesRemaining -= 8; ! 4590: cpu.z80interruptMode = 1; ! 4591: cpu.z80intAddr = 0x38; ! 4592: break; ! 4593: } ! 4594: case 0x57: ! 4595: { ! 4596: sdwCyclesRemaining -= 9; ! 4597: cpu.z80F &= ~(Z80_FLAG_HALF_CARRY | Z80_FLAG_OVERFLOW_PARITY | Z80_FLAG_NEGATIVE | Z80_FLAG_ZERO | Z80_FLAG_SIGN); ! 4598: cpu.z80F |= ((cpu.z80iff & IFF2) << 1); ! 4599: cpu.z80A = cpu.z80i; ! 4600: cpu.z80F |= bPostORFlags[cpu.z80A]; ! 4601: break; ! 4602: } ! 4603: case 0x58: ! 4604: { ! 4605: sdwCyclesRemaining -= 12; ! 4606: dwAddr = cpu.z80C; ! 4607: psIoRead = cpu.z80IoRead; /* Beginning of our handler */ ! 4608: while (psIoRead->lowIoAddr != 0xffff) ! 4609: { ! 4610: if ((dwAddr >= psIoRead->lowIoAddr) && (dwAddr <= psIoRead->highIoAddr)) ! 4611: { ! 4612: cpu.z80pc = (UINT32) pbPC - (UINT32) cpu.z80Base; ! 4613: cpu.z80E = psIoRead->IOCall(dwAddr, psIoRead); ! 4614: psIoRead = NULL; ! 4615: break; ! 4616: } ! 4617: ++psIoRead; ! 4618: } ! 4619: ! 4620: if (psIoRead) ! 4621: { ! 4622: cpu.z80E = 0xff; /* Unclaimed I/O read */ ! 4623: } ! 4624: ! 4625: cpu.z80F &= ~(Z80_FLAG_SIGN | Z80_FLAG_ZERO | Z80_FLAG_HALF_CARRY | Z80_FLAG_OVERFLOW_PARITY | Z80_FLAG_NEGATIVE); ! 4626: cpu.z80F |= bPostORFlags[cpu.z80E]; ! 4627: break; ! 4628: } ! 4629: case 0x59: ! 4630: { ! 4631: sdwCyclesRemaining -= 12; ! 4632: dwAddr = cpu.z80C; ! 4633: psIoWrite = cpu.z80IoWrite; /* Beginning of our handler */ ! 4634: while (psIoWrite->lowIoAddr != 0xffff) ! 4635: { ! 4636: if ((dwAddr >= psIoWrite->lowIoAddr) && (dwAddr <= psIoWrite->highIoAddr)) ! 4637: { ! 4638: cpu.z80pc = (UINT32) pbPC - (UINT32) cpu.z80Base; ! 4639: psIoWrite->IOCall(dwAddr, cpu.z80E, psIoWrite); ! 4640: psIoWrite = NULL; ! 4641: break; ! 4642: } ! 4643: ++psIoWrite; ! 4644: } ! 4645: ! 4646: break; ! 4647: } ! 4648: case 0x5a: ! 4649: { ! 4650: sdwCyclesRemaining -= 15; ! 4651: dwTemp = cpu.z80HL + cpu.z80DE + (cpu.z80F & Z80_FLAG_CARRY); ! 4652: cpu.z80F &= ~(Z80_FLAG_CARRY | Z80_FLAG_NEGATIVE | Z80_FLAG_OVERFLOW_PARITY | Z80_FLAG_HALF_CARRY | Z80_FLAG_ZERO | Z80_FLAG_SIGN); ! 4653: cpu.z80F |= ((dwTemp >> 8) & Z80_FLAG_SIGN); ! 4654: if (0 == (dwTemp & 0xffff)) ! 4655: { ! 4656: cpu.z80F |= Z80_FLAG_ZERO; ! 4657: } ! 4658: cpu.z80F |= (((cpu.z80HL ^ dwTemp ^ cpu.z80DE) >> 8) & Z80_FLAG_HALF_CARRY); ! 4659: cpu.z80F |= ((((cpu.z80DE ^ cpu.z80HL ^ 0x8000) & (cpu.z80DE ^ dwTemp)) >> 13) & Z80_FLAG_OVERFLOW_PARITY); ! 4660: cpu.z80F |= ((dwTemp >> 16) & Z80_FLAG_CARRY); ! 4661: cpu.z80HL = dwTemp & 0xffff; ! 4662: break; ! 4663: } ! 4664: case 0x5b: ! 4665: { ! 4666: sdwCyclesRemaining -= 20; ! 4667: dwTemp = *pbPC++; ! 4668: dwTemp |= ((UINT32) *pbPC++ << 8); ! 4669: psMemRead = cpu.z80MemRead; /* Beginning of our handler */ ! 4670: while (psMemRead->lowAddr != 0xffffffff) ! 4671: { ! 4672: if ((dwTemp >= psMemRead->lowAddr) && (dwTemp <= psMemRead->highAddr)) ! 4673: { ! 4674: cpu.z80pc = (UINT32) pbPC - (UINT32) cpu.z80Base; ! 4675: if (psMemRead->memoryCall) ! 4676: { ! 4677: cpu.z80DE = psMemRead->memoryCall(dwTemp, psMemRead); ! 4678: cpu.z80DE |= (UINT32) ((UINT32) psMemRead->memoryCall(dwTemp + 1, psMemRead) << 8); ! 4679: } ! 4680: else ! 4681: { ! 4682: cpu.z80DE = *((UINT8 *) psMemRead->pUserArea + (dwTemp - psMemRead->lowAddr)); ! 4683: cpu.z80DE |= (UINT32) ((UINT32) *((UINT8 *) psMemRead->pUserArea + (dwTemp - psMemRead->lowAddr + 1)) << 8); ! 4684: } ! 4685: psMemRead = NULL; ! 4686: break; ! 4687: } ! 4688: ++psMemRead; ! 4689: } ! 4690: ! 4691: if (psMemRead) ! 4692: { ! 4693: cpu.z80DE = cpu.z80Base[dwTemp]; ! 4694: cpu.z80DE |= (UINT32) ((UINT32) cpu.z80Base[dwTemp + 1] << 8); ! 4695: } ! 4696: ! 4697: break; ! 4698: } ! 4699: case 0x5c: ! 4700: { ! 4701: sdwCyclesRemaining -= 8; ! 4702: InvalidInstruction(2); ! 4703: break; ! 4704: } ! 4705: case 0x5d: ! 4706: { ! 4707: sdwCyclesRemaining -= 8; ! 4708: InvalidInstruction(2); ! 4709: break; ! 4710: } ! 4711: case 0x5e: ! 4712: { ! 4713: sdwCyclesRemaining -= 8; ! 4714: cpu.z80interruptMode = 2; ! 4715: break; ! 4716: } ! 4717: case 0x5f: ! 4718: { ! 4719: sdwCyclesRemaining -= 9; ! 4720: cpu.z80F &= ~(Z80_FLAG_HALF_CARRY | Z80_FLAG_SIGN | Z80_FLAG_ZERO | Z80_FLAG_OVERFLOW_PARITY | Z80_FLAG_NEGATIVE); ! 4721: cpu.z80F |= bPostORFlags[cpu.z80r]; ! 4722: cpu.z80F = (cpu.z80F & ~(Z80_FLAG_OVERFLOW_PARITY)) | ((cpu.z80iff & IFF2) << 1); ! 4723: cpu.z80A = cpu.z80r; ! 4724: bTemp = (cpu.z80r + (cpu.z80B + sdwCyclesRemaining + 1 + cpu.z80H)) ^ cpu.z80A; ! 4725: cpu.z80r = (cpu.z80r & 0x80) | (bTemp & 0x7f); ! 4726: break; ! 4727: } ! 4728: case 0x60: ! 4729: { ! 4730: sdwCyclesRemaining -= 12; ! 4731: dwAddr = cpu.z80C; ! 4732: psIoRead = cpu.z80IoRead; /* Beginning of our handler */ ! 4733: while (psIoRead->lowIoAddr != 0xffff) ! 4734: { ! 4735: if ((dwAddr >= psIoRead->lowIoAddr) && (dwAddr <= psIoRead->highIoAddr)) ! 4736: { ! 4737: cpu.z80pc = (UINT32) pbPC - (UINT32) cpu.z80Base; ! 4738: cpu.z80H = psIoRead->IOCall(dwAddr, psIoRead); ! 4739: psIoRead = NULL; ! 4740: break; ! 4741: } ! 4742: ++psIoRead; ! 4743: } ! 4744: ! 4745: if (psIoRead) ! 4746: { ! 4747: cpu.z80H = 0xff; /* Unclaimed I/O read */ ! 4748: } ! 4749: ! 4750: cpu.z80F &= ~(Z80_FLAG_SIGN | Z80_FLAG_ZERO | Z80_FLAG_HALF_CARRY | Z80_FLAG_OVERFLOW_PARITY | Z80_FLAG_NEGATIVE); ! 4751: cpu.z80F |= bPostORFlags[cpu.z80H]; ! 4752: break; ! 4753: } ! 4754: case 0x61: ! 4755: { ! 4756: sdwCyclesRemaining -= 12; ! 4757: dwAddr = cpu.z80C; ! 4758: psIoWrite = cpu.z80IoWrite; /* Beginning of our handler */ ! 4759: while (psIoWrite->lowIoAddr != 0xffff) ! 4760: { ! 4761: if ((dwAddr >= psIoWrite->lowIoAddr) && (dwAddr <= psIoWrite->highIoAddr)) ! 4762: { ! 4763: cpu.z80pc = (UINT32) pbPC - (UINT32) cpu.z80Base; ! 4764: psIoWrite->IOCall(dwAddr, cpu.z80H, psIoWrite); ! 4765: psIoWrite = NULL; ! 4766: break; ! 4767: } ! 4768: ++psIoWrite; ! 4769: } ! 4770: ! 4771: break; ! 4772: } ! 4773: case 0x62: ! 4774: { ! 4775: sdwCyclesRemaining -= 15; ! 4776: dwTemp = cpu.z80HL - cpu.z80HL - (cpu.z80F & Z80_FLAG_CARRY); ! 4777: cpu.z80F &= ~(Z80_FLAG_CARRY | Z80_FLAG_NEGATIVE | Z80_FLAG_OVERFLOW_PARITY | Z80_FLAG_HALF_CARRY | Z80_FLAG_ZERO | Z80_FLAG_SIGN); ! 4778: cpu.z80F |= ((dwTemp >> 8) & Z80_FLAG_SIGN); ! 4779: if (0 == (dwTemp & 0xffff)) ! 4780: { ! 4781: cpu.z80F |= Z80_FLAG_ZERO; ! 4782: } ! 4783: cpu.z80F |= (((cpu.z80HL ^ dwTemp ^ cpu.z80HL) >> 8) & Z80_FLAG_HALF_CARRY); ! 4784: cpu.z80F |= ((((cpu.z80HL ^ cpu.z80HL) & (cpu.z80HL ^ dwTemp)) >> 13) & Z80_FLAG_OVERFLOW_PARITY); ! 4785: cpu.z80F |= ((dwTemp >> 16) & Z80_FLAG_CARRY); ! 4786: cpu.z80HL = dwTemp & 0xffff; ! 4787: break; ! 4788: } ! 4789: case 0x63: ! 4790: { ! 4791: sdwCyclesRemaining -= 20; ! 4792: dwTemp = *pbPC++; ! 4793: dwTemp |= ((UINT32) *pbPC++ << 8); ! 4794: psMemWrite = cpu.z80MemWrite; /* Beginning of our handler */ ! 4795: while (psMemWrite->lowAddr != 0xffffffff) ! 4796: { ! 4797: if ((dwTemp >= psMemWrite->lowAddr) && (dwTemp <= psMemWrite->highAddr)) ! 4798: { ! 4799: cpu.z80pc = (UINT32) pbPC - (UINT32) cpu.z80Base; ! 4800: if (psMemWrite->memoryCall) ! 4801: { ! 4802: psMemWrite->memoryCall(dwTemp, (cpu.z80HL & 0xff), psMemWrite); ! 4803: psMemWrite->memoryCall(dwTemp + 1, (cpu.z80HL >> 8), psMemWrite); ! 4804: } ! 4805: else ! 4806: { ! 4807: *((UINT8 *) psMemWrite->pUserArea + (dwTemp - psMemWrite->lowAddr)) = cpu.z80HL; ! 4808: *((UINT8 *) psMemWrite->pUserArea + (dwTemp - psMemWrite->lowAddr) + 1) = cpu.z80HL >> 8; ! 4809: } ! 4810: psMemWrite = NULL; ! 4811: break; ! 4812: } ! 4813: ++psMemWrite; ! 4814: } ! 4815: ! 4816: if (psMemWrite) ! 4817: { ! 4818: cpu.z80Base[dwTemp] = (UINT8) cpu.z80HL; ! 4819: cpu.z80Base[dwTemp + 1] = (UINT8) ((UINT32) cpu.z80HL >> 8); ! 4820: } ! 4821: ! 4822: break; ! 4823: } ! 4824: case 0x64: ! 4825: { ! 4826: sdwCyclesRemaining -= 8; ! 4827: InvalidInstruction(2); ! 4828: break; ! 4829: } ! 4830: case 0x65: ! 4831: { ! 4832: sdwCyclesRemaining -= 8; ! 4833: InvalidInstruction(2); ! 4834: break; ! 4835: } ! 4836: case 0x66: ! 4837: { ! 4838: sdwCyclesRemaining -= 8; ! 4839: InvalidInstruction(2); ! 4840: break; ! 4841: } ! 4842: case 0x67: ! 4843: { ! 4844: sdwCyclesRemaining -= 18; ! 4845: psMemRead = cpu.z80MemRead; /* Beginning of our handler */ ! 4846: while (psMemRead->lowAddr != 0xffffffff) ! 4847: { ! 4848: if ((cpu.z80HL >= psMemRead->lowAddr) && (cpu.z80HL <= psMemRead->highAddr)) ! 4849: { ! 4850: cpu.z80pc = (UINT32) pbPC - (UINT32) cpu.z80Base; ! 4851: if (psMemRead->memoryCall) ! 4852: { ! 4853: bTemp = psMemRead->memoryCall(cpu.z80HL, psMemRead); ! 4854: } ! 4855: else ! 4856: { ! 4857: bTemp = *((UINT8 *) psMemRead->pUserArea + (cpu.z80HL - psMemRead->lowAddr)); ! 4858: } ! 4859: psMemRead = NULL; ! 4860: break; ! 4861: } ! 4862: ++psMemRead; ! 4863: } ! 4864: ! 4865: if (psMemRead) ! 4866: { ! 4867: bTemp = cpu.z80Base[cpu.z80HL]; ! 4868: } ! 4869: ! 4870: bTemp2 = (cpu.z80A & 0x0f) << 4; ! 4871: cpu.z80A = (cpu.z80A & 0xf0) | (bTemp & 0x0f); ! 4872: bTemp = (bTemp >> 4) | bTemp2; ! 4873: psMemWrite = cpu.z80MemWrite; /* Beginning of our handler */ ! 4874: while (psMemWrite->lowAddr != 0xffffffff) ! 4875: { ! 4876: if ((cpu.z80HL >= psMemWrite->lowAddr) && (cpu.z80HL <= psMemWrite->highAddr)) ! 4877: { ! 4878: cpu.z80pc = (UINT32) pbPC - (UINT32) cpu.z80Base; ! 4879: if (psMemWrite->memoryCall) ! 4880: { ! 4881: psMemWrite->memoryCall(cpu.z80HL, bTemp, psMemWrite); ! 4882: } ! 4883: else ! 4884: { ! 4885: *((UINT8 *) psMemWrite->pUserArea + (cpu.z80HL - psMemWrite->lowAddr)) = bTemp; ! 4886: } ! 4887: psMemWrite = NULL; ! 4888: break; ! 4889: } ! 4890: ++psMemWrite; ! 4891: } ! 4892: ! 4893: if (psMemWrite) ! 4894: { ! 4895: cpu.z80Base[cpu.z80HL] = (UINT8) bTemp; ! 4896: } ! 4897: ! 4898: cpu.z80F &= ~(Z80_FLAG_SIGN | Z80_FLAG_ZERO | Z80_FLAG_HALF_CARRY | Z80_FLAG_OVERFLOW_PARITY | Z80_FLAG_NEGATIVE); ! 4899: cpu.z80F |= bPostORFlags[cpu.z80A]; ! 4900: break; ! 4901: } ! 4902: case 0x68: ! 4903: { ! 4904: sdwCyclesRemaining -= 12; ! 4905: dwAddr = cpu.z80C; ! 4906: psIoRead = cpu.z80IoRead; /* Beginning of our handler */ ! 4907: while (psIoRead->lowIoAddr != 0xffff) ! 4908: { ! 4909: if ((dwAddr >= psIoRead->lowIoAddr) && (dwAddr <= psIoRead->highIoAddr)) ! 4910: { ! 4911: cpu.z80pc = (UINT32) pbPC - (UINT32) cpu.z80Base; ! 4912: cpu.z80L = psIoRead->IOCall(dwAddr, psIoRead); ! 4913: psIoRead = NULL; ! 4914: break; ! 4915: } ! 4916: ++psIoRead; ! 4917: } ! 4918: ! 4919: if (psIoRead) ! 4920: { ! 4921: cpu.z80L = 0xff; /* Unclaimed I/O read */ ! 4922: } ! 4923: ! 4924: cpu.z80F &= ~(Z80_FLAG_SIGN | Z80_FLAG_ZERO | Z80_FLAG_HALF_CARRY | Z80_FLAG_OVERFLOW_PARITY | Z80_FLAG_NEGATIVE); ! 4925: cpu.z80F |= bPostORFlags[cpu.z80L]; ! 4926: break; ! 4927: } ! 4928: case 0x69: ! 4929: { ! 4930: sdwCyclesRemaining -= 12; ! 4931: dwAddr = cpu.z80C; ! 4932: psIoWrite = cpu.z80IoWrite; /* Beginning of our handler */ ! 4933: while (psIoWrite->lowIoAddr != 0xffff) ! 4934: { ! 4935: if ((dwAddr >= psIoWrite->lowIoAddr) && (dwAddr <= psIoWrite->highIoAddr)) ! 4936: { ! 4937: cpu.z80pc = (UINT32) pbPC - (UINT32) cpu.z80Base; ! 4938: psIoWrite->IOCall(dwAddr, cpu.z80L, psIoWrite); ! 4939: psIoWrite = NULL; ! 4940: break; ! 4941: } ! 4942: ++psIoWrite; ! 4943: } ! 4944: ! 4945: break; ! 4946: } ! 4947: case 0x6a: ! 4948: { ! 4949: sdwCyclesRemaining -= 15; ! 4950: dwTemp = cpu.z80HL + cpu.z80HL + (cpu.z80F & Z80_FLAG_CARRY); ! 4951: cpu.z80F &= ~(Z80_FLAG_CARRY | Z80_FLAG_NEGATIVE | Z80_FLAG_OVERFLOW_PARITY | Z80_FLAG_HALF_CARRY | Z80_FLAG_ZERO | Z80_FLAG_SIGN); ! 4952: cpu.z80F |= ((dwTemp >> 8) & Z80_FLAG_SIGN); ! 4953: if (0 == (dwTemp & 0xffff)) ! 4954: { ! 4955: cpu.z80F |= Z80_FLAG_ZERO; ! 4956: } ! 4957: cpu.z80F |= (((cpu.z80HL ^ dwTemp ^ cpu.z80HL) >> 8) & Z80_FLAG_HALF_CARRY); ! 4958: cpu.z80F |= ((((cpu.z80HL ^ cpu.z80HL ^ 0x8000) & (cpu.z80HL ^ dwTemp)) >> 13) & Z80_FLAG_OVERFLOW_PARITY); ! 4959: cpu.z80F |= ((dwTemp >> 16) & Z80_FLAG_CARRY); ! 4960: cpu.z80HL = dwTemp & 0xffff; ! 4961: break; ! 4962: } ! 4963: case 0x6b: ! 4964: { ! 4965: sdwCyclesRemaining -= 20; ! 4966: InvalidInstruction(2); ! 4967: break; ! 4968: } ! 4969: case 0x6c: ! 4970: { ! 4971: sdwCyclesRemaining -= 8; ! 4972: InvalidInstruction(2); ! 4973: break; ! 4974: } ! 4975: case 0x6d: ! 4976: { ! 4977: sdwCyclesRemaining -= 8; ! 4978: InvalidInstruction(2); ! 4979: break; ! 4980: } ! 4981: case 0x6e: ! 4982: { ! 4983: sdwCyclesRemaining -= 8; ! 4984: InvalidInstruction(2); ! 4985: break; ! 4986: } ! 4987: case 0x6f: ! 4988: { ! 4989: sdwCyclesRemaining -= 18; ! 4990: psMemRead = cpu.z80MemRead; /* Beginning of our handler */ ! 4991: while (psMemRead->lowAddr != 0xffffffff) ! 4992: { ! 4993: if ((cpu.z80HL >= psMemRead->lowAddr) && (cpu.z80HL <= psMemRead->highAddr)) ! 4994: { ! 4995: cpu.z80pc = (UINT32) pbPC - (UINT32) cpu.z80Base; ! 4996: if (psMemRead->memoryCall) ! 4997: { ! 4998: bTemp = psMemRead->memoryCall(cpu.z80HL, psMemRead); ! 4999: } ! 5000: else ! 5001: { ! 5002: bTemp = *((UINT8 *) psMemRead->pUserArea + (cpu.z80HL - psMemRead->lowAddr)); ! 5003: } ! 5004: psMemRead = NULL; ! 5005: break; ! 5006: } ! 5007: ++psMemRead; ! 5008: } ! 5009: ! 5010: if (psMemRead) ! 5011: { ! 5012: bTemp = cpu.z80Base[cpu.z80HL]; ! 5013: } ! 5014: ! 5015: bTemp2 = (cpu.z80A & 0x0f); ! 5016: cpu.z80A = (cpu.z80A & 0xf0) | (bTemp >> 4); ! 5017: bTemp = (bTemp << 4) | bTemp2; ! 5018: psMemWrite = cpu.z80MemWrite; /* Beginning of our handler */ ! 5019: while (psMemWrite->lowAddr != 0xffffffff) ! 5020: { ! 5021: if ((cpu.z80HL >= psMemWrite->lowAddr) && (cpu.z80HL <= psMemWrite->highAddr)) ! 5022: { ! 5023: cpu.z80pc = (UINT32) pbPC - (UINT32) cpu.z80Base; ! 5024: if (psMemWrite->memoryCall) ! 5025: { ! 5026: psMemWrite->memoryCall(cpu.z80HL, bTemp, psMemWrite); ! 5027: } ! 5028: else ! 5029: { ! 5030: *((UINT8 *) psMemWrite->pUserArea + (cpu.z80HL - psMemWrite->lowAddr)) = bTemp; ! 5031: } ! 5032: psMemWrite = NULL; ! 5033: break; ! 5034: } ! 5035: ++psMemWrite; ! 5036: } ! 5037: ! 5038: if (psMemWrite) ! 5039: { ! 5040: cpu.z80Base[cpu.z80HL] = (UINT8) bTemp; ! 5041: } ! 5042: ! 5043: cpu.z80F &= ~(Z80_FLAG_SIGN | Z80_FLAG_ZERO | Z80_FLAG_HALF_CARRY | Z80_FLAG_OVERFLOW_PARITY | Z80_FLAG_NEGATIVE); ! 5044: cpu.z80F |= bPostORFlags[cpu.z80A]; ! 5045: break; ! 5046: } ! 5047: case 0x70: ! 5048: { ! 5049: sdwCyclesRemaining -= 12; ! 5050: InvalidInstruction(2); ! 5051: break; ! 5052: } ! 5053: case 0x71: ! 5054: { ! 5055: sdwCyclesRemaining -= 12; ! 5056: InvalidInstruction(2); ! 5057: break; ! 5058: } ! 5059: case 0x72: ! 5060: { ! 5061: sdwCyclesRemaining -= 15; ! 5062: dwTemp = cpu.z80HL - cpu.z80sp - (cpu.z80F & Z80_FLAG_CARRY); ! 5063: cpu.z80F &= ~(Z80_FLAG_CARRY | Z80_FLAG_NEGATIVE | Z80_FLAG_OVERFLOW_PARITY | Z80_FLAG_HALF_CARRY | Z80_FLAG_ZERO | Z80_FLAG_SIGN); ! 5064: cpu.z80F |= ((dwTemp >> 8) & Z80_FLAG_SIGN); ! 5065: if (0 == (dwTemp & 0xffff)) ! 5066: { ! 5067: cpu.z80F |= Z80_FLAG_ZERO; ! 5068: } ! 5069: cpu.z80F |= (((cpu.z80HL ^ dwTemp ^ cpu.z80sp) >> 8) & Z80_FLAG_HALF_CARRY); ! 5070: cpu.z80F |= ((((cpu.z80sp ^ cpu.z80HL) & (cpu.z80sp ^ dwTemp)) >> 13) & Z80_FLAG_OVERFLOW_PARITY); ! 5071: cpu.z80F |= ((dwTemp >> 16) & Z80_FLAG_CARRY); ! 5072: cpu.z80HL = dwTemp & 0xffff; ! 5073: break; ! 5074: } ! 5075: case 0x73: ! 5076: { ! 5077: sdwCyclesRemaining -= 20; ! 5078: dwTemp = *pbPC++; ! 5079: dwTemp |= ((UINT32) *pbPC++ << 8); ! 5080: psMemWrite = cpu.z80MemWrite; /* Beginning of our handler */ ! 5081: while (psMemWrite->lowAddr != 0xffffffff) ! 5082: { ! 5083: if ((dwTemp >= psMemWrite->lowAddr) && (dwTemp <= psMemWrite->highAddr)) ! 5084: { ! 5085: cpu.z80pc = (UINT32) pbPC - (UINT32) cpu.z80Base; ! 5086: if (psMemWrite->memoryCall) ! 5087: { ! 5088: psMemWrite->memoryCall(dwTemp, (cpu.z80sp & 0xff), psMemWrite); ! 5089: psMemWrite->memoryCall(dwTemp + 1, (cpu.z80sp >> 8), psMemWrite); ! 5090: } ! 5091: else ! 5092: { ! 5093: *((UINT8 *) psMemWrite->pUserArea + (dwTemp - psMemWrite->lowAddr)) = cpu.z80sp; ! 5094: *((UINT8 *) psMemWrite->pUserArea + (dwTemp - psMemWrite->lowAddr) + 1) = cpu.z80sp >> 8; ! 5095: } ! 5096: psMemWrite = NULL; ! 5097: break; ! 5098: } ! 5099: ++psMemWrite; ! 5100: } ! 5101: ! 5102: if (psMemWrite) ! 5103: { ! 5104: cpu.z80Base[dwTemp] = (UINT8) cpu.z80sp; ! 5105: cpu.z80Base[dwTemp + 1] = (UINT8) ((UINT32) cpu.z80sp >> 8); ! 5106: } ! 5107: ! 5108: break; ! 5109: } ! 5110: case 0x74: ! 5111: { ! 5112: sdwCyclesRemaining -= 8; ! 5113: InvalidInstruction(2); ! 5114: break; ! 5115: } ! 5116: case 0x75: ! 5117: { ! 5118: sdwCyclesRemaining -= 8; ! 5119: InvalidInstruction(2); ! 5120: break; ! 5121: } ! 5122: case 0x76: ! 5123: { ! 5124: sdwCyclesRemaining -= 8; ! 5125: InvalidInstruction(2); ! 5126: break; ! 5127: } ! 5128: case 0x77: ! 5129: { ! 5130: InvalidInstruction(2); ! 5131: break; ! 5132: } ! 5133: case 0x78: ! 5134: { ! 5135: sdwCyclesRemaining -= 12; ! 5136: dwAddr = cpu.z80C; ! 5137: psIoRead = cpu.z80IoRead; /* Beginning of our handler */ ! 5138: while (psIoRead->lowIoAddr != 0xffff) ! 5139: { ! 5140: if ((dwAddr >= psIoRead->lowIoAddr) && (dwAddr <= psIoRead->highIoAddr)) ! 5141: { ! 5142: cpu.z80pc = (UINT32) pbPC - (UINT32) cpu.z80Base; ! 5143: cpu.z80A = psIoRead->IOCall(dwAddr, psIoRead); ! 5144: psIoRead = NULL; ! 5145: break; ! 5146: } ! 5147: ++psIoRead; ! 5148: } ! 5149: ! 5150: if (psIoRead) ! 5151: { ! 5152: cpu.z80A = 0xff; /* Unclaimed I/O read */ ! 5153: } ! 5154: ! 5155: cpu.z80F &= ~(Z80_FLAG_SIGN | Z80_FLAG_ZERO | Z80_FLAG_HALF_CARRY | Z80_FLAG_OVERFLOW_PARITY | Z80_FLAG_NEGATIVE); ! 5156: cpu.z80F |= bPostORFlags[cpu.z80A]; ! 5157: break; ! 5158: } ! 5159: case 0x79: ! 5160: { ! 5161: sdwCyclesRemaining -= 12; ! 5162: dwAddr = cpu.z80C; ! 5163: psIoWrite = cpu.z80IoWrite; /* Beginning of our handler */ ! 5164: while (psIoWrite->lowIoAddr != 0xffff) ! 5165: { ! 5166: if ((dwAddr >= psIoWrite->lowIoAddr) && (dwAddr <= psIoWrite->highIoAddr)) ! 5167: { ! 5168: cpu.z80pc = (UINT32) pbPC - (UINT32) cpu.z80Base; ! 5169: psIoWrite->IOCall(dwAddr, cpu.z80A, psIoWrite); ! 5170: psIoWrite = NULL; ! 5171: break; ! 5172: } ! 5173: ++psIoWrite; ! 5174: } ! 5175: ! 5176: break; ! 5177: } ! 5178: case 0x7a: ! 5179: { ! 5180: sdwCyclesRemaining -= 15; ! 5181: dwTemp = cpu.z80HL + cpu.z80sp + (cpu.z80F & Z80_FLAG_CARRY); ! 5182: cpu.z80F &= ~(Z80_FLAG_CARRY | Z80_FLAG_NEGATIVE | Z80_FLAG_OVERFLOW_PARITY | Z80_FLAG_HALF_CARRY | Z80_FLAG_ZERO | Z80_FLAG_SIGN); ! 5183: cpu.z80F |= ((dwTemp >> 8) & Z80_FLAG_SIGN); ! 5184: if (0 == (dwTemp & 0xffff)) ! 5185: { ! 5186: cpu.z80F |= Z80_FLAG_ZERO; ! 5187: } ! 5188: cpu.z80F |= (((cpu.z80HL ^ dwTemp ^ cpu.z80sp) >> 8) & Z80_FLAG_HALF_CARRY); ! 5189: cpu.z80F |= ((((cpu.z80sp ^ cpu.z80HL ^ 0x8000) & (cpu.z80sp ^ dwTemp)) >> 13) & Z80_FLAG_OVERFLOW_PARITY); ! 5190: cpu.z80F |= ((dwTemp >> 16) & Z80_FLAG_CARRY); ! 5191: cpu.z80HL = dwTemp & 0xffff; ! 5192: break; ! 5193: } ! 5194: case 0x7b: ! 5195: { ! 5196: sdwCyclesRemaining -= 20; ! 5197: dwTemp = *pbPC++; ! 5198: dwTemp |= ((UINT32) *pbPC++ << 8); ! 5199: psMemRead = cpu.z80MemRead; /* Beginning of our handler */ ! 5200: while (psMemRead->lowAddr != 0xffffffff) ! 5201: { ! 5202: if ((dwTemp >= psMemRead->lowAddr) && (dwTemp <= psMemRead->highAddr)) ! 5203: { ! 5204: cpu.z80pc = (UINT32) pbPC - (UINT32) cpu.z80Base; ! 5205: if (psMemRead->memoryCall) ! 5206: { ! 5207: cpu.z80sp = psMemRead->memoryCall(dwTemp, psMemRead); ! 5208: cpu.z80sp |= (UINT32) ((UINT32) psMemRead->memoryCall(dwTemp + 1, psMemRead) << 8); ! 5209: } ! 5210: else ! 5211: { ! 5212: cpu.z80sp = *((UINT8 *) psMemRead->pUserArea + (dwTemp - psMemRead->lowAddr)); ! 5213: cpu.z80sp |= (UINT32) ((UINT32) *((UINT8 *) psMemRead->pUserArea + (dwTemp - psMemRead->lowAddr + 1)) << 8); ! 5214: } ! 5215: psMemRead = NULL; ! 5216: break; ! 5217: } ! 5218: ++psMemRead; ! 5219: } ! 5220: ! 5221: if (psMemRead) ! 5222: { ! 5223: cpu.z80sp = cpu.z80Base[dwTemp]; ! 5224: cpu.z80sp |= (UINT32) ((UINT32) cpu.z80Base[dwTemp + 1] << 8); ! 5225: } ! 5226: ! 5227: break; ! 5228: } ! 5229: case 0x7c: ! 5230: { ! 5231: sdwCyclesRemaining -= 8; ! 5232: InvalidInstruction(2); ! 5233: break; ! 5234: } ! 5235: case 0x7d: ! 5236: { ! 5237: sdwCyclesRemaining -= 8; ! 5238: InvalidInstruction(2); ! 5239: break; ! 5240: } ! 5241: case 0x7e: ! 5242: { ! 5243: sdwCyclesRemaining -= 8; ! 5244: InvalidInstruction(2); ! 5245: break; ! 5246: } ! 5247: case 0x7f: ! 5248: { ! 5249: InvalidInstruction(2); ! 5250: break; ! 5251: } ! 5252: case 0x80: ! 5253: { ! 5254: InvalidInstruction(2); ! 5255: break; ! 5256: } ! 5257: case 0x81: ! 5258: { ! 5259: InvalidInstruction(2); ! 5260: break; ! 5261: } ! 5262: case 0x82: ! 5263: { ! 5264: InvalidInstruction(2); ! 5265: break; ! 5266: } ! 5267: case 0x83: ! 5268: { ! 5269: InvalidInstruction(2); ! 5270: break; ! 5271: } ! 5272: case 0x84: ! 5273: { ! 5274: InvalidInstruction(2); ! 5275: break; ! 5276: } ! 5277: case 0x85: ! 5278: { ! 5279: InvalidInstruction(2); ! 5280: break; ! 5281: } ! 5282: case 0x86: ! 5283: { ! 5284: InvalidInstruction(2); ! 5285: break; ! 5286: } ! 5287: case 0x87: ! 5288: { ! 5289: InvalidInstruction(2); ! 5290: break; ! 5291: } ! 5292: case 0x88: ! 5293: { ! 5294: InvalidInstruction(2); ! 5295: break; ! 5296: } ! 5297: case 0x89: ! 5298: { ! 5299: InvalidInstruction(2); ! 5300: break; ! 5301: } ! 5302: case 0x8a: ! 5303: { ! 5304: InvalidInstruction(2); ! 5305: break; ! 5306: } ! 5307: case 0x8b: ! 5308: { ! 5309: InvalidInstruction(2); ! 5310: break; ! 5311: } ! 5312: case 0x8c: ! 5313: { ! 5314: InvalidInstruction(2); ! 5315: break; ! 5316: } ! 5317: case 0x8d: ! 5318: { ! 5319: InvalidInstruction(2); ! 5320: break; ! 5321: } ! 5322: case 0x8e: ! 5323: { ! 5324: InvalidInstruction(2); ! 5325: break; ! 5326: } ! 5327: case 0x8f: ! 5328: { ! 5329: InvalidInstruction(2); ! 5330: break; ! 5331: } ! 5332: case 0x90: ! 5333: { ! 5334: InvalidInstruction(2); ! 5335: break; ! 5336: } ! 5337: case 0x91: ! 5338: { ! 5339: InvalidInstruction(2); ! 5340: break; ! 5341: } ! 5342: case 0x92: ! 5343: { ! 5344: InvalidInstruction(2); ! 5345: break; ! 5346: } ! 5347: case 0x93: ! 5348: { ! 5349: InvalidInstruction(2); ! 5350: break; ! 5351: } ! 5352: case 0x94: ! 5353: { ! 5354: InvalidInstruction(2); ! 5355: break; ! 5356: } ! 5357: case 0x95: ! 5358: { ! 5359: InvalidInstruction(2); ! 5360: break; ! 5361: } ! 5362: case 0x96: ! 5363: { ! 5364: InvalidInstruction(2); ! 5365: break; ! 5366: } ! 5367: case 0x97: ! 5368: { ! 5369: InvalidInstruction(2); ! 5370: break; ! 5371: } ! 5372: case 0x98: ! 5373: { ! 5374: InvalidInstruction(2); ! 5375: break; ! 5376: } ! 5377: case 0x99: ! 5378: { ! 5379: InvalidInstruction(2); ! 5380: break; ! 5381: } ! 5382: case 0x9a: ! 5383: { ! 5384: InvalidInstruction(2); ! 5385: break; ! 5386: } ! 5387: case 0x9b: ! 5388: { ! 5389: InvalidInstruction(2); ! 5390: break; ! 5391: } ! 5392: case 0x9c: ! 5393: { ! 5394: InvalidInstruction(2); ! 5395: break; ! 5396: } ! 5397: case 0x9d: ! 5398: { ! 5399: InvalidInstruction(2); ! 5400: break; ! 5401: } ! 5402: case 0x9e: ! 5403: { ! 5404: InvalidInstruction(2); ! 5405: break; ! 5406: } ! 5407: case 0x9f: ! 5408: { ! 5409: InvalidInstruction(2); ! 5410: break; ! 5411: } ! 5412: case 0xa0: ! 5413: { ! 5414: sdwCyclesRemaining -= 16; ! 5415: psMemRead = cpu.z80MemRead; /* Beginning of our handler */ ! 5416: while (psMemRead->lowAddr != 0xffffffff) ! 5417: { ! 5418: if ((cpu.z80HL >= psMemRead->lowAddr) && (cpu.z80HL <= psMemRead->highAddr)) ! 5419: { ! 5420: cpu.z80pc = (UINT32) pbPC - (UINT32) cpu.z80Base; ! 5421: if (psMemRead->memoryCall) ! 5422: { ! 5423: bTemp = psMemRead->memoryCall(cpu.z80HL, psMemRead); ! 5424: } ! 5425: else ! 5426: { ! 5427: bTemp = *((UINT8 *) psMemRead->pUserArea + (cpu.z80HL - psMemRead->lowAddr)); ! 5428: } ! 5429: psMemRead = NULL; ! 5430: break; ! 5431: } ! 5432: ++psMemRead; ! 5433: } ! 5434: ! 5435: if (psMemRead) ! 5436: { ! 5437: bTemp = cpu.z80Base[cpu.z80HL]; ! 5438: } ! 5439: ! 5440: psMemWrite = cpu.z80MemWrite; /* Beginning of our handler */ ! 5441: while (psMemWrite->lowAddr != 0xffffffff) ! 5442: { ! 5443: if ((cpu.z80DE >= psMemWrite->lowAddr) && (cpu.z80DE <= psMemWrite->highAddr)) ! 5444: { ! 5445: cpu.z80pc = (UINT32) pbPC - (UINT32) cpu.z80Base; ! 5446: if (psMemWrite->memoryCall) ! 5447: { ! 5448: psMemWrite->memoryCall(cpu.z80DE, bTemp, psMemWrite); ! 5449: } ! 5450: else ! 5451: { ! 5452: *((UINT8 *) psMemWrite->pUserArea + (cpu.z80DE - psMemWrite->lowAddr)) = bTemp; ! 5453: } ! 5454: psMemWrite = NULL; ! 5455: break; ! 5456: } ! 5457: ++psMemWrite; ! 5458: } ! 5459: ! 5460: if (psMemWrite) ! 5461: { ! 5462: cpu.z80Base[cpu.z80DE] = (UINT8) bTemp; ! 5463: } ! 5464: ! 5465: ++cpu.z80HL; ! 5466: ++cpu.z80DE; ! 5467: --cpu.z80BC; ! 5468: cpu.z80HL &= 0xffff; ! 5469: cpu.z80DE &= 0xffff; ! 5470: cpu.z80BC &= 0xffff; ! 5471: cpu.z80F &= ~(Z80_FLAG_HALF_CARRY | Z80_FLAG_NEGATIVE | Z80_FLAG_OVERFLOW_PARITY); ! 5472: if (cpu.z80BC) ! 5473: { ! 5474: cpu.z80F |= Z80_FLAG_OVERFLOW_PARITY; ! 5475: } ! 5476: break; ! 5477: } ! 5478: case 0xa1: ! 5479: { ! 5480: sdwCyclesRemaining -= 16; ! 5481: { ! 5482: psMemRead = cpu.z80MemRead; /* Beginning of our handler */ ! 5483: while (psMemRead->lowAddr != 0xffffffff) ! 5484: { ! 5485: if ((cpu.z80HL >= psMemRead->lowAddr) && (cpu.z80HL <= psMemRead->highAddr)) ! 5486: { ! 5487: cpu.z80pc = (UINT32) pbPC - (UINT32) cpu.z80Base; ! 5488: if (psMemRead->memoryCall) ! 5489: { ! 5490: bTemp = psMemRead->memoryCall(cpu.z80HL, psMemRead); ! 5491: } ! 5492: else ! 5493: { ! 5494: bTemp = *((UINT8 *) psMemRead->pUserArea + (cpu.z80HL - psMemRead->lowAddr)); ! 5495: } ! 5496: psMemRead = NULL; ! 5497: break; ! 5498: } ! 5499: ++psMemRead; ! 5500: } ! 5501: ! 5502: if (psMemRead) ! 5503: { ! 5504: bTemp = cpu.z80Base[cpu.z80HL]; ! 5505: } ! 5506: ! 5507: cpu.z80HL++; ! 5508: cpu.z80HL &= 0xffff; ! 5509: cpu.z80BC--; ! 5510: cpu.z80BC &= 0xffff; ! 5511: } ! 5512: cpu.z80F &= ~(Z80_FLAG_ZERO | Z80_FLAG_SIGN | Z80_FLAG_HALF_CARRY | Z80_FLAG_OVERFLOW_PARITY | Z80_FLAG_NEGATIVE); ! 5513: cpu.z80F |= (pbSubSbcTable[((UINT32) cpu.z80A << 8) | bTemp] & (Z80_FLAG_SIGN | Z80_FLAG_NEGATIVE | Z80_FLAG_ZERO)); ! 5514: if (cpu.z80BC) ! 5515: { ! 5516: cpu.z80F |= Z80_FLAG_OVERFLOW_PARITY; ! 5517: } ! 5518: break; ! 5519: } ! 5520: case 0xa2: ! 5521: { ! 5522: sdwCyclesRemaining -= 16; ! 5523: { ! 5524: psIoRead = cpu.z80IoRead; /* Beginning of our handler */ ! 5525: while (psIoRead->lowIoAddr != 0xffff) ! 5526: { ! 5527: if ((cpu.z80B >= psIoRead->lowIoAddr) && (cpu.z80B <= psIoRead->highIoAddr)) ! 5528: { ! 5529: cpu.z80pc = (UINT32) pbPC - (UINT32) cpu.z80Base; ! 5530: bTemp = psIoRead->IOCall(cpu.z80B, psIoRead); ! 5531: psIoRead = NULL; ! 5532: break; ! 5533: } ! 5534: ++psIoRead; ! 5535: } ! 5536: ! 5537: if (psIoRead) ! 5538: { ! 5539: bTemp = 0xff; /* Unclaimed I/O read */ ! 5540: } ! 5541: ! 5542: psMemWrite = cpu.z80MemWrite; /* Beginning of our handler */ ! 5543: while (psMemWrite->lowAddr != 0xffffffff) ! 5544: { ! 5545: if ((cpu.z80HL >= psMemWrite->lowAddr) && (cpu.z80HL <= psMemWrite->highAddr)) ! 5546: { ! 5547: cpu.z80pc = (UINT32) pbPC - (UINT32) cpu.z80Base; ! 5548: if (psMemWrite->memoryCall) ! 5549: { ! 5550: psMemWrite->memoryCall(cpu.z80HL, bTemp, psMemWrite); ! 5551: } ! 5552: else ! 5553: { ! 5554: *((UINT8 *) psMemWrite->pUserArea + (cpu.z80HL - psMemWrite->lowAddr)) = bTemp; ! 5555: } ! 5556: psMemWrite = NULL; ! 5557: break; ! 5558: } ! 5559: ++psMemWrite; ! 5560: } ! 5561: ! 5562: if (psMemWrite) ! 5563: { ! 5564: cpu.z80Base[cpu.z80HL] = (UINT8) bTemp; ! 5565: } ! 5566: ! 5567: cpu.z80HL++; ! 5568: cpu.z80HL &= 0xffff; ! 5569: sdwCyclesRemaining -= 16; ! 5570: cpu.z80B--; ! 5571: } ! 5572: cpu.z80F &= ~(Z80_FLAG_ZERO | Z80_FLAG_SIGN | Z80_FLAG_HALF_CARRY | Z80_FLAG_OVERFLOW_PARITY | Z80_FLAG_NEGATIVE); ! 5573: cpu.z80F |= (bPostORFlags[bTemp] & (Z80_FLAG_SIGN | Z80_FLAG_NEGATIVE | Z80_FLAG_HALF_CARRY | Z80_FLAG_OVERFLOW_PARITY)); ! 5574: if (cpu.z80B) ! 5575: { ! 5576: cpu.z80F |= Z80_FLAG_OVERFLOW_PARITY; ! 5577: pbPC -= 2; ! 5578: } ! 5579: break; ! 5580: } ! 5581: case 0xa3: ! 5582: { ! 5583: sdwCyclesRemaining -= 16; ! 5584: { ! 5585: psMemRead = cpu.z80MemRead; /* Beginning of our handler */ ! 5586: while (psMemRead->lowAddr != 0xffffffff) ! 5587: { ! 5588: if ((cpu.z80HL >= psMemRead->lowAddr) && (cpu.z80HL <= psMemRead->highAddr)) ! 5589: { ! 5590: cpu.z80pc = (UINT32) pbPC - (UINT32) cpu.z80Base; ! 5591: if (psMemRead->memoryCall) ! 5592: { ! 5593: bTemp = psMemRead->memoryCall(cpu.z80HL, psMemRead); ! 5594: } ! 5595: else ! 5596: { ! 5597: bTemp = *((UINT8 *) psMemRead->pUserArea + (cpu.z80HL - psMemRead->lowAddr)); ! 5598: } ! 5599: psMemRead = NULL; ! 5600: break; ! 5601: } ! 5602: ++psMemRead; ! 5603: } ! 5604: ! 5605: if (psMemRead) ! 5606: { ! 5607: bTemp = cpu.z80Base[cpu.z80HL]; ! 5608: } ! 5609: ! 5610: psIoWrite = cpu.z80IoWrite; /* Beginning of our handler */ ! 5611: while (psIoWrite->lowIoAddr != 0xffff) ! 5612: { ! 5613: if ((cpu.z80BC >= psIoWrite->lowIoAddr) && (cpu.z80BC <= psIoWrite->highIoAddr)) ! 5614: { ! 5615: cpu.z80pc = (UINT32) pbPC - (UINT32) cpu.z80Base; ! 5616: psIoWrite->IOCall(cpu.z80BC, bTemp, psIoWrite); ! 5617: psIoWrite = NULL; ! 5618: break; ! 5619: } ! 5620: ++psIoWrite; ! 5621: } ! 5622: ! 5623: cpu.z80HL++; ! 5624: cpu.z80HL &= 0xffff; ! 5625: sdwCyclesRemaining -= 16; ! 5626: cpu.z80B--; ! 5627: } ! 5628: cpu.z80F &= ~(Z80_FLAG_ZERO | Z80_FLAG_SIGN | Z80_FLAG_HALF_CARRY | Z80_FLAG_OVERFLOW_PARITY | Z80_FLAG_NEGATIVE); ! 5629: cpu.z80F |= (bPostORFlags[bTemp] & (Z80_FLAG_SIGN | Z80_FLAG_NEGATIVE | Z80_FLAG_HALF_CARRY | Z80_FLAG_OVERFLOW_PARITY)); ! 5630: if (cpu.z80B) ! 5631: { ! 5632: cpu.z80F |= Z80_FLAG_OVERFLOW_PARITY; ! 5633: } ! 5634: break; ! 5635: } ! 5636: case 0xa4: ! 5637: { ! 5638: InvalidInstruction(2); ! 5639: break; ! 5640: } ! 5641: case 0xa5: ! 5642: { ! 5643: InvalidInstruction(2); ! 5644: break; ! 5645: } ! 5646: case 0xa6: ! 5647: { ! 5648: InvalidInstruction(2); ! 5649: break; ! 5650: } ! 5651: case 0xa7: ! 5652: { ! 5653: InvalidInstruction(2); ! 5654: break; ! 5655: } ! 5656: case 0xa8: ! 5657: { ! 5658: sdwCyclesRemaining -= 16; ! 5659: psMemRead = cpu.z80MemRead; /* Beginning of our handler */ ! 5660: while (psMemRead->lowAddr != 0xffffffff) ! 5661: { ! 5662: if ((cpu.z80HL >= psMemRead->lowAddr) && (cpu.z80HL <= psMemRead->highAddr)) ! 5663: { ! 5664: cpu.z80pc = (UINT32) pbPC - (UINT32) cpu.z80Base; ! 5665: if (psMemRead->memoryCall) ! 5666: { ! 5667: bTemp = psMemRead->memoryCall(cpu.z80HL, psMemRead); ! 5668: } ! 5669: else ! 5670: { ! 5671: bTemp = *((UINT8 *) psMemRead->pUserArea + (cpu.z80HL - psMemRead->lowAddr)); ! 5672: } ! 5673: psMemRead = NULL; ! 5674: break; ! 5675: } ! 5676: ++psMemRead; ! 5677: } ! 5678: ! 5679: if (psMemRead) ! 5680: { ! 5681: bTemp = cpu.z80Base[cpu.z80HL]; ! 5682: } ! 5683: ! 5684: psMemWrite = cpu.z80MemWrite; /* Beginning of our handler */ ! 5685: while (psMemWrite->lowAddr != 0xffffffff) ! 5686: { ! 5687: if ((cpu.z80DE >= psMemWrite->lowAddr) && (cpu.z80DE <= psMemWrite->highAddr)) ! 5688: { ! 5689: cpu.z80pc = (UINT32) pbPC - (UINT32) cpu.z80Base; ! 5690: if (psMemWrite->memoryCall) ! 5691: { ! 5692: psMemWrite->memoryCall(cpu.z80DE, bTemp, psMemWrite); ! 5693: } ! 5694: else ! 5695: { ! 5696: *((UINT8 *) psMemWrite->pUserArea + (cpu.z80DE - psMemWrite->lowAddr)) = bTemp; ! 5697: } ! 5698: psMemWrite = NULL; ! 5699: break; ! 5700: } ! 5701: ++psMemWrite; ! 5702: } ! 5703: ! 5704: if (psMemWrite) ! 5705: { ! 5706: cpu.z80Base[cpu.z80DE] = (UINT8) bTemp; ! 5707: } ! 5708: ! 5709: --cpu.z80HL; ! 5710: --cpu.z80DE; ! 5711: --cpu.z80BC; ! 5712: cpu.z80HL &= 0xffff; ! 5713: cpu.z80DE &= 0xffff; ! 5714: cpu.z80BC &= 0xffff; ! 5715: cpu.z80F &= ~(Z80_FLAG_HALF_CARRY | Z80_FLAG_NEGATIVE | Z80_FLAG_OVERFLOW_PARITY); ! 5716: if (cpu.z80BC) ! 5717: { ! 5718: cpu.z80F |= Z80_FLAG_OVERFLOW_PARITY; ! 5719: } ! 5720: break; ! 5721: } ! 5722: case 0xa9: ! 5723: { ! 5724: sdwCyclesRemaining -= 16; ! 5725: { ! 5726: psMemRead = cpu.z80MemRead; /* Beginning of our handler */ ! 5727: while (psMemRead->lowAddr != 0xffffffff) ! 5728: { ! 5729: if ((cpu.z80HL >= psMemRead->lowAddr) && (cpu.z80HL <= psMemRead->highAddr)) ! 5730: { ! 5731: cpu.z80pc = (UINT32) pbPC - (UINT32) cpu.z80Base; ! 5732: if (psMemRead->memoryCall) ! 5733: { ! 5734: bTemp = psMemRead->memoryCall(cpu.z80HL, psMemRead); ! 5735: } ! 5736: else ! 5737: { ! 5738: bTemp = *((UINT8 *) psMemRead->pUserArea + (cpu.z80HL - psMemRead->lowAddr)); ! 5739: } ! 5740: psMemRead = NULL; ! 5741: break; ! 5742: } ! 5743: ++psMemRead; ! 5744: } ! 5745: ! 5746: if (psMemRead) ! 5747: { ! 5748: bTemp = cpu.z80Base[cpu.z80HL]; ! 5749: } ! 5750: ! 5751: cpu.z80HL--; ! 5752: cpu.z80HL &= 0xffff; ! 5753: cpu.z80BC--; ! 5754: cpu.z80BC &= 0xffff; ! 5755: } ! 5756: cpu.z80F &= ~(Z80_FLAG_ZERO | Z80_FLAG_SIGN | Z80_FLAG_HALF_CARRY | Z80_FLAG_OVERFLOW_PARITY | Z80_FLAG_NEGATIVE); ! 5757: cpu.z80F |= (pbSubSbcTable[((UINT32) cpu.z80A << 8) | bTemp] & (Z80_FLAG_SIGN | Z80_FLAG_NEGATIVE | Z80_FLAG_ZERO)); ! 5758: if (cpu.z80BC) ! 5759: { ! 5760: cpu.z80F |= Z80_FLAG_OVERFLOW_PARITY; ! 5761: } ! 5762: break; ! 5763: } ! 5764: case 0xaa: ! 5765: { ! 5766: sdwCyclesRemaining -= 16; ! 5767: { ! 5768: psIoRead = cpu.z80IoRead; /* Beginning of our handler */ ! 5769: while (psIoRead->lowIoAddr != 0xffff) ! 5770: { ! 5771: if ((cpu.z80B >= psIoRead->lowIoAddr) && (cpu.z80B <= psIoRead->highIoAddr)) ! 5772: { ! 5773: cpu.z80pc = (UINT32) pbPC - (UINT32) cpu.z80Base; ! 5774: bTemp = psIoRead->IOCall(cpu.z80B, psIoRead); ! 5775: psIoRead = NULL; ! 5776: break; ! 5777: } ! 5778: ++psIoRead; ! 5779: } ! 5780: ! 5781: if (psIoRead) ! 5782: { ! 5783: bTemp = 0xff; /* Unclaimed I/O read */ ! 5784: } ! 5785: ! 5786: psMemWrite = cpu.z80MemWrite; /* Beginning of our handler */ ! 5787: while (psMemWrite->lowAddr != 0xffffffff) ! 5788: { ! 5789: if ((cpu.z80HL >= psMemWrite->lowAddr) && (cpu.z80HL <= psMemWrite->highAddr)) ! 5790: { ! 5791: cpu.z80pc = (UINT32) pbPC - (UINT32) cpu.z80Base; ! 5792: if (psMemWrite->memoryCall) ! 5793: { ! 5794: psMemWrite->memoryCall(cpu.z80HL, bTemp, psMemWrite); ! 5795: } ! 5796: else ! 5797: { ! 5798: *((UINT8 *) psMemWrite->pUserArea + (cpu.z80HL - psMemWrite->lowAddr)) = bTemp; ! 5799: } ! 5800: psMemWrite = NULL; ! 5801: break; ! 5802: } ! 5803: ++psMemWrite; ! 5804: } ! 5805: ! 5806: if (psMemWrite) ! 5807: { ! 5808: cpu.z80Base[cpu.z80HL] = (UINT8) bTemp; ! 5809: } ! 5810: ! 5811: cpu.z80HL--; ! 5812: cpu.z80HL &= 0xffff; ! 5813: sdwCyclesRemaining -= 16; ! 5814: cpu.z80B--; ! 5815: } ! 5816: cpu.z80F &= ~(Z80_FLAG_ZERO | Z80_FLAG_SIGN | Z80_FLAG_HALF_CARRY | Z80_FLAG_OVERFLOW_PARITY | Z80_FLAG_NEGATIVE); ! 5817: cpu.z80F |= (bPostORFlags[bTemp] & (Z80_FLAG_SIGN | Z80_FLAG_NEGATIVE | Z80_FLAG_HALF_CARRY | Z80_FLAG_OVERFLOW_PARITY)); ! 5818: if (cpu.z80B) ! 5819: { ! 5820: cpu.z80F |= Z80_FLAG_OVERFLOW_PARITY; ! 5821: pbPC -= 2; ! 5822: } ! 5823: break; ! 5824: } ! 5825: case 0xab: ! 5826: { ! 5827: sdwCyclesRemaining -= 16; ! 5828: { ! 5829: psMemRead = cpu.z80MemRead; /* Beginning of our handler */ ! 5830: while (psMemRead->lowAddr != 0xffffffff) ! 5831: { ! 5832: if ((cpu.z80HL >= psMemRead->lowAddr) && (cpu.z80HL <= psMemRead->highAddr)) ! 5833: { ! 5834: cpu.z80pc = (UINT32) pbPC - (UINT32) cpu.z80Base; ! 5835: if (psMemRead->memoryCall) ! 5836: { ! 5837: bTemp = psMemRead->memoryCall(cpu.z80HL, psMemRead); ! 5838: } ! 5839: else ! 5840: { ! 5841: bTemp = *((UINT8 *) psMemRead->pUserArea + (cpu.z80HL - psMemRead->lowAddr)); ! 5842: } ! 5843: psMemRead = NULL; ! 5844: break; ! 5845: } ! 5846: ++psMemRead; ! 5847: } ! 5848: ! 5849: if (psMemRead) ! 5850: { ! 5851: bTemp = cpu.z80Base[cpu.z80HL]; ! 5852: } ! 5853: ! 5854: psIoWrite = cpu.z80IoWrite; /* Beginning of our handler */ ! 5855: while (psIoWrite->lowIoAddr != 0xffff) ! 5856: { ! 5857: if ((cpu.z80BC >= psIoWrite->lowIoAddr) && (cpu.z80BC <= psIoWrite->highIoAddr)) ! 5858: { ! 5859: cpu.z80pc = (UINT32) pbPC - (UINT32) cpu.z80Base; ! 5860: psIoWrite->IOCall(cpu.z80BC, bTemp, psIoWrite); ! 5861: psIoWrite = NULL; ! 5862: break; ! 5863: } ! 5864: ++psIoWrite; ! 5865: } ! 5866: ! 5867: cpu.z80HL--; ! 5868: cpu.z80HL &= 0xffff; ! 5869: sdwCyclesRemaining -= 16; ! 5870: cpu.z80B--; ! 5871: } ! 5872: cpu.z80F &= ~(Z80_FLAG_ZERO | Z80_FLAG_SIGN | Z80_FLAG_HALF_CARRY | Z80_FLAG_OVERFLOW_PARITY | Z80_FLAG_NEGATIVE); ! 5873: cpu.z80F |= (bPostORFlags[bTemp] & (Z80_FLAG_SIGN | Z80_FLAG_NEGATIVE | Z80_FLAG_HALF_CARRY | Z80_FLAG_OVERFLOW_PARITY)); ! 5874: if (cpu.z80B) ! 5875: { ! 5876: cpu.z80F |= Z80_FLAG_OVERFLOW_PARITY; ! 5877: } ! 5878: break; ! 5879: } ! 5880: case 0xac: ! 5881: { ! 5882: InvalidInstruction(2); ! 5883: break; ! 5884: } ! 5885: case 0xad: ! 5886: { ! 5887: InvalidInstruction(2); ! 5888: break; ! 5889: } ! 5890: case 0xae: ! 5891: { ! 5892: InvalidInstruction(2); ! 5893: break; ! 5894: } ! 5895: case 0xaf: ! 5896: { ! 5897: InvalidInstruction(2); ! 5898: break; ! 5899: } ! 5900: case 0xb0: ! 5901: { ! 5902: sdwCyclesRemaining -= 16; ! 5903: while ((sdwCyclesRemaining > 0) && (cpu.z80BC)) ! 5904: { ! 5905: psMemRead = cpu.z80MemRead; /* Beginning of our handler */ ! 5906: while (psMemRead->lowAddr != 0xffffffff) ! 5907: { ! 5908: if ((cpu.z80HL >= psMemRead->lowAddr) && (cpu.z80HL <= psMemRead->highAddr)) ! 5909: { ! 5910: cpu.z80pc = (UINT32) pbPC - (UINT32) cpu.z80Base; ! 5911: if (psMemRead->memoryCall) ! 5912: { ! 5913: bTemp = psMemRead->memoryCall(cpu.z80HL, psMemRead); ! 5914: } ! 5915: else ! 5916: { ! 5917: bTemp = *((UINT8 *) psMemRead->pUserArea + (cpu.z80HL - psMemRead->lowAddr)); ! 5918: } ! 5919: psMemRead = NULL; ! 5920: break; ! 5921: } ! 5922: ++psMemRead; ! 5923: } ! 5924: ! 5925: if (psMemRead) ! 5926: { ! 5927: bTemp = cpu.z80Base[cpu.z80HL]; ! 5928: } ! 5929: ! 5930: psMemWrite = cpu.z80MemWrite; /* Beginning of our handler */ ! 5931: while (psMemWrite->lowAddr != 0xffffffff) ! 5932: { ! 5933: if ((cpu.z80DE >= psMemWrite->lowAddr) && (cpu.z80DE <= psMemWrite->highAddr)) ! 5934: { ! 5935: cpu.z80pc = (UINT32) pbPC - (UINT32) cpu.z80Base; ! 5936: if (psMemWrite->memoryCall) ! 5937: { ! 5938: psMemWrite->memoryCall(cpu.z80DE, bTemp, psMemWrite); ! 5939: } ! 5940: else ! 5941: { ! 5942: *((UINT8 *) psMemWrite->pUserArea + (cpu.z80DE - psMemWrite->lowAddr)) = bTemp; ! 5943: } ! 5944: psMemWrite = NULL; ! 5945: break; ! 5946: } ! 5947: ++psMemWrite; ! 5948: } ! 5949: ! 5950: if (psMemWrite) ! 5951: { ! 5952: cpu.z80Base[cpu.z80DE] = (UINT8) bTemp; ! 5953: } ! 5954: ! 5955: ++cpu.z80HL; ! 5956: ++cpu.z80DE; ! 5957: --cpu.z80BC; ! 5958: cpu.z80HL &= 0xffff; ! 5959: cpu.z80DE &= 0xffff; ! 5960: cpu.z80BC &= 0xffff; ! 5961: sdwCyclesRemaining -= 21; ! 5962: } ! 5963: cpu.z80F &= ~(Z80_FLAG_HALF_CARRY | Z80_FLAG_NEGATIVE | Z80_FLAG_OVERFLOW_PARITY); ! 5964: if (cpu.z80BC) ! 5965: { ! 5966: pbPC -= 2; /* Back up so we hit this instruction again */ ! 5967: cpu.z80F |= Z80_FLAG_OVERFLOW_PARITY; ! 5968: } ! 5969: sdwCyclesRemaining -= 16; ! 5970: break; ! 5971: } ! 5972: case 0xb1: ! 5973: { ! 5974: sdwCyclesRemaining -= 16; ! 5975: while ((sdwCyclesRemaining >= 0) && (cpu.z80BC)) ! 5976: { ! 5977: psMemRead = cpu.z80MemRead; /* Beginning of our handler */ ! 5978: while (psMemRead->lowAddr != 0xffffffff) ! 5979: { ! 5980: if ((cpu.z80HL >= psMemRead->lowAddr) && (cpu.z80HL <= psMemRead->highAddr)) ! 5981: { ! 5982: cpu.z80pc = (UINT32) pbPC - (UINT32) cpu.z80Base; ! 5983: if (psMemRead->memoryCall) ! 5984: { ! 5985: bTemp = psMemRead->memoryCall(cpu.z80HL, psMemRead); ! 5986: } ! 5987: else ! 5988: { ! 5989: bTemp = *((UINT8 *) psMemRead->pUserArea + (cpu.z80HL - psMemRead->lowAddr)); ! 5990: } ! 5991: psMemRead = NULL; ! 5992: break; ! 5993: } ! 5994: ++psMemRead; ! 5995: } ! 5996: ! 5997: if (psMemRead) ! 5998: { ! 5999: bTemp = cpu.z80Base[cpu.z80HL]; ! 6000: } ! 6001: ! 6002: cpu.z80HL++; ! 6003: cpu.z80HL &= 0xffff; ! 6004: cpu.z80BC--; ! 6005: cpu.z80BC &= 0xffff; ! 6006: sdwCyclesRemaining -= 16; ! 6007: if (cpu.z80A == bTemp) ! 6008: { ! 6009: break; ! 6010: } ! 6011: } ! 6012: cpu.z80F &= ~(Z80_FLAG_ZERO | Z80_FLAG_SIGN | Z80_FLAG_HALF_CARRY | Z80_FLAG_OVERFLOW_PARITY | Z80_FLAG_NEGATIVE); ! 6013: cpu.z80F |= (pbSubSbcTable[((UINT32) cpu.z80A << 8) | bTemp] & (Z80_FLAG_SIGN | Z80_FLAG_NEGATIVE | Z80_FLAG_ZERO)); ! 6014: if (cpu.z80BC) ! 6015: { ! 6016: cpu.z80F |= Z80_FLAG_OVERFLOW_PARITY; ! 6017: } ! 6018: break; ! 6019: } ! 6020: case 0xb2: ! 6021: { ! 6022: sdwCyclesRemaining -= 16; ! 6023: while ((sdwCyclesRemaining > 0) && (cpu.z80B)) ! 6024: { ! 6025: psIoRead = cpu.z80IoRead; /* Beginning of our handler */ ! 6026: while (psIoRead->lowIoAddr != 0xffff) ! 6027: { ! 6028: if ((cpu.z80B >= psIoRead->lowIoAddr) && (cpu.z80B <= psIoRead->highIoAddr)) ! 6029: { ! 6030: cpu.z80pc = (UINT32) pbPC - (UINT32) cpu.z80Base; ! 6031: bTemp = psIoRead->IOCall(cpu.z80B, psIoRead); ! 6032: psIoRead = NULL; ! 6033: break; ! 6034: } ! 6035: ++psIoRead; ! 6036: } ! 6037: ! 6038: if (psIoRead) ! 6039: { ! 6040: bTemp = 0xff; /* Unclaimed I/O read */ ! 6041: } ! 6042: ! 6043: psMemWrite = cpu.z80MemWrite; /* Beginning of our handler */ ! 6044: while (psMemWrite->lowAddr != 0xffffffff) ! 6045: { ! 6046: if ((cpu.z80HL >= psMemWrite->lowAddr) && (cpu.z80HL <= psMemWrite->highAddr)) ! 6047: { ! 6048: cpu.z80pc = (UINT32) pbPC - (UINT32) cpu.z80Base; ! 6049: if (psMemWrite->memoryCall) ! 6050: { ! 6051: psMemWrite->memoryCall(cpu.z80HL, bTemp, psMemWrite); ! 6052: } ! 6053: else ! 6054: { ! 6055: *((UINT8 *) psMemWrite->pUserArea + (cpu.z80HL - psMemWrite->lowAddr)) = bTemp; ! 6056: } ! 6057: psMemWrite = NULL; ! 6058: break; ! 6059: } ! 6060: ++psMemWrite; ! 6061: } ! 6062: ! 6063: if (psMemWrite) ! 6064: { ! 6065: cpu.z80Base[cpu.z80HL] = (UINT8) bTemp; ! 6066: } ! 6067: ! 6068: cpu.z80HL++; ! 6069: cpu.z80HL &= 0xffff; ! 6070: sdwCyclesRemaining -= 16; ! 6071: cpu.z80B--; ! 6072: } ! 6073: cpu.z80F &= ~(Z80_FLAG_ZERO | Z80_FLAG_SIGN | Z80_FLAG_HALF_CARRY | Z80_FLAG_OVERFLOW_PARITY | Z80_FLAG_NEGATIVE); ! 6074: cpu.z80F |= (bPostORFlags[bTemp] & (Z80_FLAG_SIGN | Z80_FLAG_NEGATIVE | Z80_FLAG_HALF_CARRY | Z80_FLAG_OVERFLOW_PARITY)); ! 6075: if (cpu.z80B) ! 6076: { ! 6077: cpu.z80F |= Z80_FLAG_OVERFLOW_PARITY; ! 6078: pbPC -= 2; ! 6079: } ! 6080: break; ! 6081: } ! 6082: case 0xb3: ! 6083: { ! 6084: sdwCyclesRemaining -= 16; ! 6085: while ((sdwCyclesRemaining > 0) && (cpu.z80B)) ! 6086: { ! 6087: psMemRead = cpu.z80MemRead; /* Beginning of our handler */ ! 6088: while (psMemRead->lowAddr != 0xffffffff) ! 6089: { ! 6090: if ((cpu.z80HL >= psMemRead->lowAddr) && (cpu.z80HL <= psMemRead->highAddr)) ! 6091: { ! 6092: cpu.z80pc = (UINT32) pbPC - (UINT32) cpu.z80Base; ! 6093: if (psMemRead->memoryCall) ! 6094: { ! 6095: bTemp = psMemRead->memoryCall(cpu.z80HL, psMemRead); ! 6096: } ! 6097: else ! 6098: { ! 6099: bTemp = *((UINT8 *) psMemRead->pUserArea + (cpu.z80HL - psMemRead->lowAddr)); ! 6100: } ! 6101: psMemRead = NULL; ! 6102: break; ! 6103: } ! 6104: ++psMemRead; ! 6105: } ! 6106: ! 6107: if (psMemRead) ! 6108: { ! 6109: bTemp = cpu.z80Base[cpu.z80HL]; ! 6110: } ! 6111: ! 6112: psIoWrite = cpu.z80IoWrite; /* Beginning of our handler */ ! 6113: while (psIoWrite->lowIoAddr != 0xffff) ! 6114: { ! 6115: if ((cpu.z80BC >= psIoWrite->lowIoAddr) && (cpu.z80BC <= psIoWrite->highIoAddr)) ! 6116: { ! 6117: cpu.z80pc = (UINT32) pbPC - (UINT32) cpu.z80Base; ! 6118: psIoWrite->IOCall(cpu.z80BC, bTemp, psIoWrite); ! 6119: psIoWrite = NULL; ! 6120: break; ! 6121: } ! 6122: ++psIoWrite; ! 6123: } ! 6124: ! 6125: cpu.z80HL++; ! 6126: cpu.z80HL &= 0xffff; ! 6127: sdwCyclesRemaining -= 16; ! 6128: cpu.z80B--; ! 6129: } ! 6130: cpu.z80F &= ~(Z80_FLAG_ZERO | Z80_FLAG_SIGN | Z80_FLAG_HALF_CARRY | Z80_FLAG_OVERFLOW_PARITY | Z80_FLAG_NEGATIVE); ! 6131: cpu.z80F |= (bPostORFlags[bTemp] & (Z80_FLAG_SIGN | Z80_FLAG_NEGATIVE | Z80_FLAG_HALF_CARRY | Z80_FLAG_OVERFLOW_PARITY)); ! 6132: if (cpu.z80B) ! 6133: { ! 6134: cpu.z80F |= Z80_FLAG_OVERFLOW_PARITY; ! 6135: } ! 6136: break; ! 6137: } ! 6138: case 0xb4: ! 6139: { ! 6140: InvalidInstruction(2); ! 6141: break; ! 6142: } ! 6143: case 0xb5: ! 6144: { ! 6145: InvalidInstruction(2); ! 6146: break; ! 6147: } ! 6148: case 0xb6: ! 6149: { ! 6150: InvalidInstruction(2); ! 6151: break; ! 6152: } ! 6153: case 0xb7: ! 6154: { ! 6155: InvalidInstruction(2); ! 6156: break; ! 6157: } ! 6158: case 0xb8: ! 6159: { ! 6160: sdwCyclesRemaining -= 16; ! 6161: while ((sdwCyclesRemaining > 0) && (cpu.z80BC)) ! 6162: { ! 6163: psMemRead = cpu.z80MemRead; /* Beginning of our handler */ ! 6164: while (psMemRead->lowAddr != 0xffffffff) ! 6165: { ! 6166: if ((cpu.z80HL >= psMemRead->lowAddr) && (cpu.z80HL <= psMemRead->highAddr)) ! 6167: { ! 6168: cpu.z80pc = (UINT32) pbPC - (UINT32) cpu.z80Base; ! 6169: if (psMemRead->memoryCall) ! 6170: { ! 6171: bTemp = psMemRead->memoryCall(cpu.z80HL, psMemRead); ! 6172: } ! 6173: else ! 6174: { ! 6175: bTemp = *((UINT8 *) psMemRead->pUserArea + (cpu.z80HL - psMemRead->lowAddr)); ! 6176: } ! 6177: psMemRead = NULL; ! 6178: break; ! 6179: } ! 6180: ++psMemRead; ! 6181: } ! 6182: ! 6183: if (psMemRead) ! 6184: { ! 6185: bTemp = cpu.z80Base[cpu.z80HL]; ! 6186: } ! 6187: ! 6188: psMemWrite = cpu.z80MemWrite; /* Beginning of our handler */ ! 6189: while (psMemWrite->lowAddr != 0xffffffff) ! 6190: { ! 6191: if ((cpu.z80DE >= psMemWrite->lowAddr) && (cpu.z80DE <= psMemWrite->highAddr)) ! 6192: { ! 6193: cpu.z80pc = (UINT32) pbPC - (UINT32) cpu.z80Base; ! 6194: if (psMemWrite->memoryCall) ! 6195: { ! 6196: psMemWrite->memoryCall(cpu.z80DE, bTemp, psMemWrite); ! 6197: } ! 6198: else ! 6199: { ! 6200: *((UINT8 *) psMemWrite->pUserArea + (cpu.z80DE - psMemWrite->lowAddr)) = bTemp; ! 6201: } ! 6202: psMemWrite = NULL; ! 6203: break; ! 6204: } ! 6205: ++psMemWrite; ! 6206: } ! 6207: ! 6208: if (psMemWrite) ! 6209: { ! 6210: cpu.z80Base[cpu.z80DE] = (UINT8) bTemp; ! 6211: } ! 6212: ! 6213: --cpu.z80HL; ! 6214: --cpu.z80DE; ! 6215: --cpu.z80BC; ! 6216: cpu.z80HL &= 0xffff; ! 6217: cpu.z80DE &= 0xffff; ! 6218: cpu.z80BC &= 0xffff; ! 6219: sdwCyclesRemaining -= 21; ! 6220: } ! 6221: cpu.z80F &= ~(Z80_FLAG_HALF_CARRY | Z80_FLAG_NEGATIVE | Z80_FLAG_OVERFLOW_PARITY); ! 6222: if (cpu.z80BC) ! 6223: { ! 6224: pbPC -= 2; /* Back up so we hit this instruction again */ ! 6225: cpu.z80F |= Z80_FLAG_OVERFLOW_PARITY; ! 6226: } ! 6227: sdwCyclesRemaining -= 16; ! 6228: break; ! 6229: } ! 6230: case 0xb9: ! 6231: { ! 6232: sdwCyclesRemaining -= 16; ! 6233: while ((sdwCyclesRemaining >= 0) && (cpu.z80BC)) ! 6234: { ! 6235: psMemRead = cpu.z80MemRead; /* Beginning of our handler */ ! 6236: while (psMemRead->lowAddr != 0xffffffff) ! 6237: { ! 6238: if ((cpu.z80HL >= psMemRead->lowAddr) && (cpu.z80HL <= psMemRead->highAddr)) ! 6239: { ! 6240: cpu.z80pc = (UINT32) pbPC - (UINT32) cpu.z80Base; ! 6241: if (psMemRead->memoryCall) ! 6242: { ! 6243: bTemp = psMemRead->memoryCall(cpu.z80HL, psMemRead); ! 6244: } ! 6245: else ! 6246: { ! 6247: bTemp = *((UINT8 *) psMemRead->pUserArea + (cpu.z80HL - psMemRead->lowAddr)); ! 6248: } ! 6249: psMemRead = NULL; ! 6250: break; ! 6251: } ! 6252: ++psMemRead; ! 6253: } ! 6254: ! 6255: if (psMemRead) ! 6256: { ! 6257: bTemp = cpu.z80Base[cpu.z80HL]; ! 6258: } ! 6259: ! 6260: cpu.z80HL--; ! 6261: cpu.z80HL &= 0xffff; ! 6262: cpu.z80BC--; ! 6263: cpu.z80BC &= 0xffff; ! 6264: sdwCyclesRemaining -= 16; ! 6265: if (cpu.z80A == bTemp) ! 6266: { ! 6267: break; ! 6268: } ! 6269: } ! 6270: cpu.z80F &= ~(Z80_FLAG_ZERO | Z80_FLAG_SIGN | Z80_FLAG_HALF_CARRY | Z80_FLAG_OVERFLOW_PARITY | Z80_FLAG_NEGATIVE); ! 6271: cpu.z80F |= (pbSubSbcTable[((UINT32) cpu.z80A << 8) | bTemp] & (Z80_FLAG_SIGN | Z80_FLAG_NEGATIVE | Z80_FLAG_ZERO)); ! 6272: if (cpu.z80BC) ! 6273: { ! 6274: cpu.z80F |= Z80_FLAG_OVERFLOW_PARITY; ! 6275: } ! 6276: break; ! 6277: } ! 6278: case 0xba: ! 6279: { ! 6280: sdwCyclesRemaining -= 16; ! 6281: while ((sdwCyclesRemaining > 0) && (cpu.z80B)) ! 6282: { ! 6283: psIoRead = cpu.z80IoRead; /* Beginning of our handler */ ! 6284: while (psIoRead->lowIoAddr != 0xffff) ! 6285: { ! 6286: if ((cpu.z80B >= psIoRead->lowIoAddr) && (cpu.z80B <= psIoRead->highIoAddr)) ! 6287: { ! 6288: cpu.z80pc = (UINT32) pbPC - (UINT32) cpu.z80Base; ! 6289: bTemp = psIoRead->IOCall(cpu.z80B, psIoRead); ! 6290: psIoRead = NULL; ! 6291: break; ! 6292: } ! 6293: ++psIoRead; ! 6294: } ! 6295: ! 6296: if (psIoRead) ! 6297: { ! 6298: bTemp = 0xff; /* Unclaimed I/O read */ ! 6299: } ! 6300: ! 6301: psMemWrite = cpu.z80MemWrite; /* Beginning of our handler */ ! 6302: while (psMemWrite->lowAddr != 0xffffffff) ! 6303: { ! 6304: if ((cpu.z80HL >= psMemWrite->lowAddr) && (cpu.z80HL <= psMemWrite->highAddr)) ! 6305: { ! 6306: cpu.z80pc = (UINT32) pbPC - (UINT32) cpu.z80Base; ! 6307: if (psMemWrite->memoryCall) ! 6308: { ! 6309: psMemWrite->memoryCall(cpu.z80HL, bTemp, psMemWrite); ! 6310: } ! 6311: else ! 6312: { ! 6313: *((UINT8 *) psMemWrite->pUserArea + (cpu.z80HL - psMemWrite->lowAddr)) = bTemp; ! 6314: } ! 6315: psMemWrite = NULL; ! 6316: break; ! 6317: } ! 6318: ++psMemWrite; ! 6319: } ! 6320: ! 6321: if (psMemWrite) ! 6322: { ! 6323: cpu.z80Base[cpu.z80HL] = (UINT8) bTemp; ! 6324: } ! 6325: ! 6326: cpu.z80HL--; ! 6327: cpu.z80HL &= 0xffff; ! 6328: sdwCyclesRemaining -= 16; ! 6329: cpu.z80B--; ! 6330: } ! 6331: cpu.z80F &= ~(Z80_FLAG_ZERO | Z80_FLAG_SIGN | Z80_FLAG_HALF_CARRY | Z80_FLAG_OVERFLOW_PARITY | Z80_FLAG_NEGATIVE); ! 6332: cpu.z80F |= (bPostORFlags[bTemp] & (Z80_FLAG_SIGN | Z80_FLAG_NEGATIVE | Z80_FLAG_HALF_CARRY | Z80_FLAG_OVERFLOW_PARITY)); ! 6333: if (cpu.z80B) ! 6334: { ! 6335: cpu.z80F |= Z80_FLAG_OVERFLOW_PARITY; ! 6336: pbPC -= 2; ! 6337: } ! 6338: break; ! 6339: } ! 6340: case 0xbb: ! 6341: { ! 6342: sdwCyclesRemaining -= 16; ! 6343: while ((sdwCyclesRemaining > 0) && (cpu.z80B)) ! 6344: { ! 6345: psMemRead = cpu.z80MemRead; /* Beginning of our handler */ ! 6346: while (psMemRead->lowAddr != 0xffffffff) ! 6347: { ! 6348: if ((cpu.z80HL >= psMemRead->lowAddr) && (cpu.z80HL <= psMemRead->highAddr)) ! 6349: { ! 6350: cpu.z80pc = (UINT32) pbPC - (UINT32) cpu.z80Base; ! 6351: if (psMemRead->memoryCall) ! 6352: { ! 6353: bTemp = psMemRead->memoryCall(cpu.z80HL, psMemRead); ! 6354: } ! 6355: else ! 6356: { ! 6357: bTemp = *((UINT8 *) psMemRead->pUserArea + (cpu.z80HL - psMemRead->lowAddr)); ! 6358: } ! 6359: psMemRead = NULL; ! 6360: break; ! 6361: } ! 6362: ++psMemRead; ! 6363: } ! 6364: ! 6365: if (psMemRead) ! 6366: { ! 6367: bTemp = cpu.z80Base[cpu.z80HL]; ! 6368: } ! 6369: ! 6370: psIoWrite = cpu.z80IoWrite; /* Beginning of our handler */ ! 6371: while (psIoWrite->lowIoAddr != 0xffff) ! 6372: { ! 6373: if ((cpu.z80BC >= psIoWrite->lowIoAddr) && (cpu.z80BC <= psIoWrite->highIoAddr)) ! 6374: { ! 6375: cpu.z80pc = (UINT32) pbPC - (UINT32) cpu.z80Base; ! 6376: psIoWrite->IOCall(cpu.z80BC, bTemp, psIoWrite); ! 6377: psIoWrite = NULL; ! 6378: break; ! 6379: } ! 6380: ++psIoWrite; ! 6381: } ! 6382: ! 6383: cpu.z80HL--; ! 6384: cpu.z80HL &= 0xffff; ! 6385: sdwCyclesRemaining -= 16; ! 6386: cpu.z80B--; ! 6387: } ! 6388: cpu.z80F &= ~(Z80_FLAG_ZERO | Z80_FLAG_SIGN | Z80_FLAG_HALF_CARRY | Z80_FLAG_OVERFLOW_PARITY | Z80_FLAG_NEGATIVE); ! 6389: cpu.z80F |= (bPostORFlags[bTemp] & (Z80_FLAG_SIGN | Z80_FLAG_NEGATIVE | Z80_FLAG_HALF_CARRY | Z80_FLAG_OVERFLOW_PARITY)); ! 6390: if (cpu.z80B) ! 6391: { ! 6392: cpu.z80F |= Z80_FLAG_OVERFLOW_PARITY; ! 6393: } ! 6394: break; ! 6395: } ! 6396: case 0xbc: ! 6397: { ! 6398: InvalidInstruction(2); ! 6399: break; ! 6400: } ! 6401: case 0xbd: ! 6402: { ! 6403: InvalidInstruction(2); ! 6404: break; ! 6405: } ! 6406: case 0xbe: ! 6407: { ! 6408: InvalidInstruction(2); ! 6409: break; ! 6410: } ! 6411: case 0xbf: ! 6412: { ! 6413: InvalidInstruction(2); ! 6414: break; ! 6415: } ! 6416: case 0xc0: ! 6417: { ! 6418: InvalidInstruction(2); ! 6419: break; ! 6420: } ! 6421: case 0xc1: ! 6422: { ! 6423: InvalidInstruction(2); ! 6424: break; ! 6425: } ! 6426: case 0xc2: ! 6427: { ! 6428: InvalidInstruction(2); ! 6429: break; ! 6430: } ! 6431: case 0xc3: ! 6432: { ! 6433: InvalidInstruction(2); ! 6434: break; ! 6435: } ! 6436: case 0xc4: ! 6437: { ! 6438: InvalidInstruction(2); ! 6439: break; ! 6440: } ! 6441: case 0xc5: ! 6442: { ! 6443: InvalidInstruction(2); ! 6444: break; ! 6445: } ! 6446: case 0xc6: ! 6447: { ! 6448: InvalidInstruction(2); ! 6449: break; ! 6450: } ! 6451: case 0xc7: ! 6452: { ! 6453: InvalidInstruction(2); ! 6454: break; ! 6455: } ! 6456: case 0xc8: ! 6457: { ! 6458: InvalidInstruction(2); ! 6459: break; ! 6460: } ! 6461: case 0xc9: ! 6462: { ! 6463: InvalidInstruction(2); ! 6464: break; ! 6465: } ! 6466: case 0xca: ! 6467: { ! 6468: InvalidInstruction(2); ! 6469: break; ! 6470: } ! 6471: case 0xcb: ! 6472: { ! 6473: InvalidInstruction(2); ! 6474: break; ! 6475: } ! 6476: case 0xcc: ! 6477: { ! 6478: InvalidInstruction(2); ! 6479: break; ! 6480: } ! 6481: case 0xcd: ! 6482: { ! 6483: InvalidInstruction(2); ! 6484: break; ! 6485: } ! 6486: case 0xce: ! 6487: { ! 6488: InvalidInstruction(2); ! 6489: break; ! 6490: } ! 6491: case 0xcf: ! 6492: { ! 6493: InvalidInstruction(2); ! 6494: break; ! 6495: } ! 6496: case 0xd0: ! 6497: { ! 6498: InvalidInstruction(2); ! 6499: break; ! 6500: } ! 6501: case 0xd1: ! 6502: { ! 6503: InvalidInstruction(2); ! 6504: break; ! 6505: } ! 6506: case 0xd2: ! 6507: { ! 6508: InvalidInstruction(2); ! 6509: break; ! 6510: } ! 6511: case 0xd3: ! 6512: { ! 6513: InvalidInstruction(2); ! 6514: break; ! 6515: } ! 6516: case 0xd4: ! 6517: { ! 6518: InvalidInstruction(2); ! 6519: break; ! 6520: } ! 6521: case 0xd5: ! 6522: { ! 6523: InvalidInstruction(2); ! 6524: break; ! 6525: } ! 6526: case 0xd6: ! 6527: { ! 6528: InvalidInstruction(2); ! 6529: break; ! 6530: } ! 6531: case 0xd7: ! 6532: { ! 6533: InvalidInstruction(2); ! 6534: break; ! 6535: } ! 6536: case 0xd8: ! 6537: { ! 6538: InvalidInstruction(2); ! 6539: break; ! 6540: } ! 6541: case 0xd9: ! 6542: { ! 6543: InvalidInstruction(2); ! 6544: break; ! 6545: } ! 6546: case 0xda: ! 6547: { ! 6548: InvalidInstruction(2); ! 6549: break; ! 6550: } ! 6551: case 0xdb: ! 6552: { ! 6553: InvalidInstruction(2); ! 6554: break; ! 6555: } ! 6556: case 0xdc: ! 6557: { ! 6558: InvalidInstruction(2); ! 6559: break; ! 6560: } ! 6561: case 0xdd: ! 6562: { ! 6563: InvalidInstruction(2); ! 6564: break; ! 6565: } ! 6566: case 0xde: ! 6567: { ! 6568: InvalidInstruction(2); ! 6569: break; ! 6570: } ! 6571: case 0xdf: ! 6572: { ! 6573: InvalidInstruction(2); ! 6574: break; ! 6575: } ! 6576: case 0xe0: ! 6577: { ! 6578: InvalidInstruction(2); ! 6579: break; ! 6580: } ! 6581: case 0xe1: ! 6582: { ! 6583: InvalidInstruction(2); ! 6584: break; ! 6585: } ! 6586: case 0xe2: ! 6587: { ! 6588: InvalidInstruction(2); ! 6589: break; ! 6590: } ! 6591: case 0xe3: ! 6592: { ! 6593: InvalidInstruction(2); ! 6594: break; ! 6595: } ! 6596: case 0xe4: ! 6597: { ! 6598: InvalidInstruction(2); ! 6599: break; ! 6600: } ! 6601: case 0xe5: ! 6602: { ! 6603: InvalidInstruction(2); ! 6604: break; ! 6605: } ! 6606: case 0xe6: ! 6607: { ! 6608: InvalidInstruction(2); ! 6609: break; ! 6610: } ! 6611: case 0xe7: ! 6612: { ! 6613: InvalidInstruction(2); ! 6614: break; ! 6615: } ! 6616: case 0xe8: ! 6617: { ! 6618: InvalidInstruction(2); ! 6619: break; ! 6620: } ! 6621: case 0xe9: ! 6622: { ! 6623: InvalidInstruction(2); ! 6624: break; ! 6625: } ! 6626: case 0xea: ! 6627: { ! 6628: InvalidInstruction(2); ! 6629: break; ! 6630: } ! 6631: case 0xeb: ! 6632: { ! 6633: InvalidInstruction(2); ! 6634: break; ! 6635: } ! 6636: case 0xec: ! 6637: { ! 6638: InvalidInstruction(2); ! 6639: break; ! 6640: } ! 6641: case 0xed: ! 6642: { ! 6643: InvalidInstruction(2); ! 6644: break; ! 6645: } ! 6646: case 0xee: ! 6647: { ! 6648: InvalidInstruction(2); ! 6649: break; ! 6650: } ! 6651: case 0xef: ! 6652: { ! 6653: InvalidInstruction(2); ! 6654: break; ! 6655: } ! 6656: case 0xf0: ! 6657: { ! 6658: InvalidInstruction(2); ! 6659: break; ! 6660: } ! 6661: case 0xf1: ! 6662: { ! 6663: InvalidInstruction(2); ! 6664: break; ! 6665: } ! 6666: case 0xf2: ! 6667: { ! 6668: InvalidInstruction(2); ! 6669: break; ! 6670: } ! 6671: case 0xf3: ! 6672: { ! 6673: InvalidInstruction(2); ! 6674: break; ! 6675: } ! 6676: case 0xf4: ! 6677: { ! 6678: InvalidInstruction(2); ! 6679: break; ! 6680: } ! 6681: case 0xf5: ! 6682: { ! 6683: InvalidInstruction(2); ! 6684: break; ! 6685: } ! 6686: case 0xf6: ! 6687: { ! 6688: InvalidInstruction(2); ! 6689: break; ! 6690: } ! 6691: case 0xf7: ! 6692: { ! 6693: InvalidInstruction(2); ! 6694: break; ! 6695: } ! 6696: case 0xf8: ! 6697: { ! 6698: InvalidInstruction(2); ! 6699: break; ! 6700: } ! 6701: case 0xf9: ! 6702: { ! 6703: InvalidInstruction(2); ! 6704: break; ! 6705: } ! 6706: case 0xfa: ! 6707: { ! 6708: InvalidInstruction(2); ! 6709: break; ! 6710: } ! 6711: case 0xfb: ! 6712: { ! 6713: InvalidInstruction(2); ! 6714: break; ! 6715: } ! 6716: case 0xfc: ! 6717: { ! 6718: InvalidInstruction(2); ! 6719: break; ! 6720: } ! 6721: case 0xfd: ! 6722: { ! 6723: InvalidInstruction(2); ! 6724: break; ! 6725: } ! 6726: case 0xfe: ! 6727: { ! 6728: InvalidInstruction(2); ! 6729: break; ! 6730: } ! 6731: case 0xff: ! 6732: { ! 6733: InvalidInstruction(2); ! 6734: break; ! 6735: } ! 6736: } ! 6737: } ! 6738: ! 6739: void DDHandler(void) ! 6740: { ! 6741: switch (*pbPC++) ! 6742: { ! 6743: case 0x00: ! 6744: { ! 6745: InvalidInstruction(2); ! 6746: break; ! 6747: } ! 6748: case 0x01: ! 6749: { ! 6750: InvalidInstruction(2); ! 6751: break; ! 6752: } ! 6753: case 0x02: ! 6754: { ! 6755: InvalidInstruction(2); ! 6756: break; ! 6757: } ! 6758: case 0x03: ! 6759: { ! 6760: InvalidInstruction(2); ! 6761: break; ! 6762: } ! 6763: case 0x04: ! 6764: { ! 6765: InvalidInstruction(2); ! 6766: break; ! 6767: } ! 6768: case 0x05: ! 6769: { ! 6770: InvalidInstruction(2); ! 6771: break; ! 6772: } ! 6773: case 0x06: ! 6774: { ! 6775: InvalidInstruction(2); ! 6776: break; ! 6777: } ! 6778: case 0x07: ! 6779: { ! 6780: InvalidInstruction(2); ! 6781: break; ! 6782: } ! 6783: case 0x08: ! 6784: { ! 6785: InvalidInstruction(2); ! 6786: break; ! 6787: } ! 6788: case 0x09: ! 6789: { ! 6790: sdwCyclesRemaining -= 15; ! 6791: cpu.z80F &= ~(Z80_FLAG_CARRY | Z80_FLAG_NEGATIVE | Z80_FLAG_HALF_CARRY); ! 6792: dwTemp = cpu.z80IX + cpu.z80BC; ! 6793: cpu.z80F |= ((dwTemp >> 16) & Z80_FLAG_CARRY) | (((cpu.z80IX ^ dwTemp ^ cpu.z80BC) >> 8) & Z80_FLAG_HALF_CARRY); ! 6794: cpu.z80IX = dwTemp & 0xffff; ! 6795: break; ! 6796: } ! 6797: case 0x0a: ! 6798: { ! 6799: InvalidInstruction(2); ! 6800: break; ! 6801: } ! 6802: case 0x0b: ! 6803: { ! 6804: InvalidInstruction(2); ! 6805: break; ! 6806: } ! 6807: case 0x0c: ! 6808: { ! 6809: InvalidInstruction(2); ! 6810: break; ! 6811: } ! 6812: case 0x0d: ! 6813: { ! 6814: InvalidInstruction(2); ! 6815: break; ! 6816: } ! 6817: case 0x0e: ! 6818: { ! 6819: InvalidInstruction(2); ! 6820: break; ! 6821: } ! 6822: case 0x0f: ! 6823: { ! 6824: InvalidInstruction(2); ! 6825: break; ! 6826: } ! 6827: case 0x10: ! 6828: { ! 6829: InvalidInstruction(2); ! 6830: break; ! 6831: } ! 6832: case 0x11: ! 6833: { ! 6834: InvalidInstruction(2); ! 6835: break; ! 6836: } ! 6837: case 0x12: ! 6838: { ! 6839: InvalidInstruction(2); ! 6840: break; ! 6841: } ! 6842: case 0x13: ! 6843: { ! 6844: InvalidInstruction(2); ! 6845: break; ! 6846: } ! 6847: case 0x14: ! 6848: { ! 6849: InvalidInstruction(2); ! 6850: break; ! 6851: } ! 6852: case 0x15: ! 6853: { ! 6854: InvalidInstruction(2); ! 6855: break; ! 6856: } ! 6857: case 0x16: ! 6858: { ! 6859: InvalidInstruction(2); ! 6860: break; ! 6861: } ! 6862: case 0x17: ! 6863: { ! 6864: InvalidInstruction(2); ! 6865: break; ! 6866: } ! 6867: case 0x18: ! 6868: { ! 6869: InvalidInstruction(2); ! 6870: break; ! 6871: } ! 6872: case 0x19: ! 6873: { ! 6874: sdwCyclesRemaining -= 15; ! 6875: cpu.z80F &= ~(Z80_FLAG_CARRY | Z80_FLAG_NEGATIVE | Z80_FLAG_HALF_CARRY); ! 6876: dwTemp = cpu.z80IX + cpu.z80DE; ! 6877: cpu.z80F |= ((dwTemp >> 16) & Z80_FLAG_CARRY) | (((cpu.z80IX ^ dwTemp ^ cpu.z80DE) >> 8) & Z80_FLAG_HALF_CARRY); ! 6878: cpu.z80IX = dwTemp & 0xffff; ! 6879: break; ! 6880: } ! 6881: case 0x1a: ! 6882: { ! 6883: InvalidInstruction(2); ! 6884: break; ! 6885: } ! 6886: case 0x1b: ! 6887: { ! 6888: InvalidInstruction(2); ! 6889: break; ! 6890: } ! 6891: case 0x1c: ! 6892: { ! 6893: InvalidInstruction(2); ! 6894: break; ! 6895: } ! 6896: case 0x1d: ! 6897: { ! 6898: InvalidInstruction(2); ! 6899: break; ! 6900: } ! 6901: case 0x1e: ! 6902: { ! 6903: InvalidInstruction(2); ! 6904: break; ! 6905: } ! 6906: case 0x1f: ! 6907: { ! 6908: InvalidInstruction(2); ! 6909: break; ! 6910: } ! 6911: case 0x20: ! 6912: { ! 6913: InvalidInstruction(2); ! 6914: break; ! 6915: } ! 6916: case 0x21: ! 6917: { ! 6918: sdwCyclesRemaining -= 14; ! 6919: cpu.z80IX = *pbPC++; ! 6920: cpu.z80IX |= ((UINT32) *pbPC++ << 8); ! 6921: break; ! 6922: } ! 6923: case 0x22: ! 6924: { ! 6925: sdwCyclesRemaining -= 20; ! 6926: dwAddr = *pbPC++; ! 6927: dwAddr |= ((UINT32) *pbPC++ << 8); ! 6928: psMemWrite = cpu.z80MemWrite; /* Beginning of our handler */ ! 6929: while (psMemWrite->lowAddr != 0xffffffff) ! 6930: { ! 6931: if ((dwAddr >= psMemWrite->lowAddr) && (dwAddr <= psMemWrite->highAddr)) ! 6932: { ! 6933: cpu.z80pc = (UINT32) pbPC - (UINT32) cpu.z80Base; ! 6934: if (psMemWrite->memoryCall) ! 6935: { ! 6936: psMemWrite->memoryCall(dwAddr, (cpu.z80IX & 0xff), psMemWrite); ! 6937: psMemWrite->memoryCall(dwAddr + 1, (cpu.z80IX >> 8), psMemWrite); ! 6938: } ! 6939: else ! 6940: { ! 6941: *((UINT8 *) psMemWrite->pUserArea + (dwAddr - psMemWrite->lowAddr)) = cpu.z80IX; ! 6942: *((UINT8 *) psMemWrite->pUserArea + (dwAddr - psMemWrite->lowAddr) + 1) = cpu.z80IX >> 8; ! 6943: } ! 6944: psMemWrite = NULL; ! 6945: break; ! 6946: } ! 6947: ++psMemWrite; ! 6948: } ! 6949: ! 6950: if (psMemWrite) ! 6951: { ! 6952: cpu.z80Base[dwAddr] = (UINT8) cpu.z80IX; ! 6953: cpu.z80Base[dwAddr + 1] = (UINT8) ((UINT32) cpu.z80IX >> 8); ! 6954: } ! 6955: ! 6956: break; ! 6957: } ! 6958: case 0x23: ! 6959: { ! 6960: sdwCyclesRemaining -= 10; ! 6961: cpu.z80IX++; ! 6962: cpu.z80IX &= 0xffff; ! 6963: break; ! 6964: } ! 6965: case 0x24: ! 6966: { ! 6967: sdwCyclesRemaining -= 9; ! 6968: cpu.z80F &= ~(Z80_FLAG_SIGN | Z80_FLAG_ZERO | Z80_FLAG_HALF_CARRY | Z80_FLAG_OVERFLOW_PARITY | Z80_FLAG_NEGATIVE); ! 6969: cpu.z80F |= bPostIncFlags[cpu.z80XH++]; ! 6970: break; ! 6971: } ! 6972: case 0x25: ! 6973: { ! 6974: sdwCyclesRemaining -= 9; ! 6975: cpu.z80F &= ~(Z80_FLAG_SIGN | Z80_FLAG_ZERO | Z80_FLAG_HALF_CARRY | Z80_FLAG_OVERFLOW_PARITY | Z80_FLAG_NEGATIVE); ! 6976: cpu.z80F |= bPostDecFlags[cpu.z80XH--]; ! 6977: break; ! 6978: } ! 6979: case 0x26: ! 6980: { ! 6981: sdwCyclesRemaining -= 9; ! 6982: cpu.z80XH = *pbPC++; ! 6983: break; ! 6984: } ! 6985: case 0x27: ! 6986: { ! 6987: InvalidInstruction(2); ! 6988: break; ! 6989: } ! 6990: case 0x28: ! 6991: { ! 6992: InvalidInstruction(2); ! 6993: break; ! 6994: } ! 6995: case 0x29: ! 6996: { ! 6997: sdwCyclesRemaining -= 15; ! 6998: cpu.z80F &= ~(Z80_FLAG_CARRY | Z80_FLAG_NEGATIVE | Z80_FLAG_HALF_CARRY); ! 6999: dwTemp = cpu.z80IX + cpu.z80IX; ! 7000: cpu.z80F |= ((dwTemp >> 16) & Z80_FLAG_CARRY) | (((cpu.z80IX ^ dwTemp ^ cpu.z80HL) >> 8) & Z80_FLAG_HALF_CARRY); ! 7001: cpu.z80IX = dwTemp & 0xffff; ! 7002: break; ! 7003: } ! 7004: case 0x2a: ! 7005: { ! 7006: sdwCyclesRemaining -= 20; ! 7007: dwAddr = *pbPC++; ! 7008: dwAddr |= ((UINT32) *pbPC++ << 8); ! 7009: psMemRead = cpu.z80MemRead; /* Beginning of our handler */ ! 7010: while (psMemRead->lowAddr != 0xffffffff) ! 7011: { ! 7012: if ((dwAddr >= psMemRead->lowAddr) && (dwAddr <= psMemRead->highAddr)) ! 7013: { ! 7014: cpu.z80pc = (UINT32) pbPC - (UINT32) cpu.z80Base; ! 7015: if (psMemRead->memoryCall) ! 7016: { ! 7017: cpu.z80IX = psMemRead->memoryCall(dwAddr, psMemRead); ! 7018: cpu.z80IX |= (UINT32) ((UINT32) psMemRead->memoryCall(dwAddr + 1, psMemRead) << 8); ! 7019: } ! 7020: else ! 7021: { ! 7022: cpu.z80IX = *((UINT8 *) psMemRead->pUserArea + (dwAddr - psMemRead->lowAddr)); ! 7023: cpu.z80IX |= (UINT32) ((UINT32) *((UINT8 *) psMemRead->pUserArea + (dwAddr - psMemRead->lowAddr + 1)) << 8); ! 7024: } ! 7025: psMemRead = NULL; ! 7026: break; ! 7027: } ! 7028: ++psMemRead; ! 7029: } ! 7030: ! 7031: if (psMemRead) ! 7032: { ! 7033: cpu.z80IX = cpu.z80Base[dwAddr]; ! 7034: cpu.z80IX |= (UINT32) ((UINT32) cpu.z80Base[dwAddr + 1] << 8); ! 7035: } ! 7036: ! 7037: break; ! 7038: } ! 7039: case 0x2b: ! 7040: { ! 7041: sdwCyclesRemaining -= 10; ! 7042: cpu.z80IX--; ! 7043: cpu.z80IX &= 0xffff; ! 7044: break; ! 7045: } ! 7046: case 0x2c: ! 7047: { ! 7048: sdwCyclesRemaining -= 9; ! 7049: cpu.z80F &= ~(Z80_FLAG_SIGN | Z80_FLAG_ZERO | Z80_FLAG_HALF_CARRY | Z80_FLAG_OVERFLOW_PARITY | Z80_FLAG_NEGATIVE); ! 7050: cpu.z80F |= bPostIncFlags[cpu.z80XL++]; ! 7051: break; ! 7052: } ! 7053: case 0x2d: ! 7054: { ! 7055: sdwCyclesRemaining -= 9; ! 7056: cpu.z80F &= ~(Z80_FLAG_SIGN | Z80_FLAG_ZERO | Z80_FLAG_HALF_CARRY | Z80_FLAG_OVERFLOW_PARITY | Z80_FLAG_NEGATIVE); ! 7057: cpu.z80F |= bPostDecFlags[cpu.z80XL--]; ! 7058: break; ! 7059: } ! 7060: case 0x2e: ! 7061: { ! 7062: sdwCyclesRemaining -= 9; ! 7063: cpu.z80XL = *pbPC++; ! 7064: break; ! 7065: } ! 7066: case 0x2f: ! 7067: { ! 7068: InvalidInstruction(2); ! 7069: break; ! 7070: } ! 7071: case 0x30: ! 7072: { ! 7073: InvalidInstruction(2); ! 7074: break; ! 7075: } ! 7076: case 0x31: ! 7077: { ! 7078: InvalidInstruction(2); ! 7079: break; ! 7080: } ! 7081: case 0x32: ! 7082: { ! 7083: InvalidInstruction(2); ! 7084: break; ! 7085: } ! 7086: case 0x33: ! 7087: { ! 7088: InvalidInstruction(2); ! 7089: break; ! 7090: } ! 7091: case 0x34: ! 7092: { ! 7093: sdwCyclesRemaining -= 23; ! 7094: sdwAddr = (INT8) *pbPC++; /* Get LSB first */ ! 7095: dwAddr = (sdwAddr + (INT32) cpu.z80IX) & 0xffff; ! 7096: psMemRead = cpu.z80MemRead; /* Beginning of our handler */ ! 7097: while (psMemRead->lowAddr != 0xffffffff) ! 7098: { ! 7099: if ((dwAddr >= psMemRead->lowAddr) && (dwAddr <= psMemRead->highAddr)) ! 7100: { ! 7101: cpu.z80pc = (UINT32) pbPC - (UINT32) cpu.z80Base; ! 7102: if (psMemRead->memoryCall) ! 7103: { ! 7104: bTemp = psMemRead->memoryCall(dwAddr, psMemRead); ! 7105: } ! 7106: else ! 7107: { ! 7108: bTemp = *((UINT8 *) psMemRead->pUserArea + (dwAddr - psMemRead->lowAddr)); ! 7109: } ! 7110: psMemRead = NULL; ! 7111: break; ! 7112: } ! 7113: ++psMemRead; ! 7114: } ! 7115: ! 7116: if (psMemRead) ! 7117: { ! 7118: bTemp = cpu.z80Base[dwAddr]; ! 7119: } ! 7120: ! 7121: cpu.z80F &= ~(Z80_FLAG_SIGN | Z80_FLAG_ZERO | Z80_FLAG_HALF_CARRY | Z80_FLAG_OVERFLOW_PARITY | Z80_FLAG_NEGATIVE); ! 7122: cpu.z80F |= bPostIncFlags[bTemp++]; ! 7123: psMemWrite = cpu.z80MemWrite; /* Beginning of our handler */ ! 7124: while (psMemWrite->lowAddr != 0xffffffff) ! 7125: { ! 7126: if ((dwAddr >= psMemWrite->lowAddr) && (dwAddr <= psMemWrite->highAddr)) ! 7127: { ! 7128: cpu.z80pc = (UINT32) pbPC - (UINT32) cpu.z80Base; ! 7129: if (psMemWrite->memoryCall) ! 7130: { ! 7131: psMemWrite->memoryCall(dwAddr, bTemp, psMemWrite); ! 7132: } ! 7133: else ! 7134: { ! 7135: *((UINT8 *) psMemWrite->pUserArea + (dwAddr - psMemWrite->lowAddr)) = bTemp; ! 7136: } ! 7137: psMemWrite = NULL; ! 7138: break; ! 7139: } ! 7140: ++psMemWrite; ! 7141: } ! 7142: ! 7143: if (psMemWrite) ! 7144: { ! 7145: cpu.z80Base[dwAddr] = (UINT8) bTemp; ! 7146: } ! 7147: ! 7148: break; ! 7149: } ! 7150: case 0x35: ! 7151: { ! 7152: sdwCyclesRemaining -= 23; ! 7153: sdwAddr = (INT8) *pbPC++; /* Get LSB first */ ! 7154: dwAddr = (sdwAddr + (INT32) cpu.z80IX) & 0xffff; ! 7155: psMemRead = cpu.z80MemRead; /* Beginning of our handler */ ! 7156: while (psMemRead->lowAddr != 0xffffffff) ! 7157: { ! 7158: if ((dwAddr >= psMemRead->lowAddr) && (dwAddr <= psMemRead->highAddr)) ! 7159: { ! 7160: cpu.z80pc = (UINT32) pbPC - (UINT32) cpu.z80Base; ! 7161: if (psMemRead->memoryCall) ! 7162: { ! 7163: bTemp = psMemRead->memoryCall(dwAddr, psMemRead); ! 7164: } ! 7165: else ! 7166: { ! 7167: bTemp = *((UINT8 *) psMemRead->pUserArea + (dwAddr - psMemRead->lowAddr)); ! 7168: } ! 7169: psMemRead = NULL; ! 7170: break; ! 7171: } ! 7172: ++psMemRead; ! 7173: } ! 7174: ! 7175: if (psMemRead) ! 7176: { ! 7177: bTemp = cpu.z80Base[dwAddr]; ! 7178: } ! 7179: ! 7180: cpu.z80F &= ~(Z80_FLAG_SIGN | Z80_FLAG_ZERO | Z80_FLAG_HALF_CARRY | Z80_FLAG_OVERFLOW_PARITY | Z80_FLAG_NEGATIVE); ! 7181: cpu.z80F |= bPostDecFlags[bTemp--]; ! 7182: psMemWrite = cpu.z80MemWrite; /* Beginning of our handler */ ! 7183: while (psMemWrite->lowAddr != 0xffffffff) ! 7184: { ! 7185: if ((dwAddr >= psMemWrite->lowAddr) && (dwAddr <= psMemWrite->highAddr)) ! 7186: { ! 7187: cpu.z80pc = (UINT32) pbPC - (UINT32) cpu.z80Base; ! 7188: if (psMemWrite->memoryCall) ! 7189: { ! 7190: psMemWrite->memoryCall(dwAddr, bTemp, psMemWrite); ! 7191: } ! 7192: else ! 7193: { ! 7194: *((UINT8 *) psMemWrite->pUserArea + (dwAddr - psMemWrite->lowAddr)) = bTemp; ! 7195: } ! 7196: psMemWrite = NULL; ! 7197: break; ! 7198: } ! 7199: ++psMemWrite; ! 7200: } ! 7201: ! 7202: if (psMemWrite) ! 7203: { ! 7204: cpu.z80Base[dwAddr] = (UINT8) bTemp; ! 7205: } ! 7206: ! 7207: break; ! 7208: } ! 7209: case 0x36: ! 7210: { ! 7211: sdwCyclesRemaining -= 19; ! 7212: sdwAddr = (INT8) *pbPC++; // Get the offset ! 7213: sdwAddr = ((INT32) cpu.z80IX + sdwAddr) & 0xffff; ! 7214: psMemWrite = cpu.z80MemWrite; /* Beginning of our handler */ ! 7215: while (psMemWrite->lowAddr != 0xffffffff) ! 7216: { ! 7217: if ((sdwAddr >= psMemWrite->lowAddr) && (sdwAddr <= psMemWrite->highAddr)) ! 7218: { ! 7219: cpu.z80pc = (UINT32) pbPC - (UINT32) cpu.z80Base; ! 7220: if (psMemWrite->memoryCall) ! 7221: { ! 7222: psMemWrite->memoryCall(sdwAddr, *pbPC++, psMemWrite); ! 7223: } ! 7224: else ! 7225: { ! 7226: *((UINT8 *) psMemWrite->pUserArea + (sdwAddr - psMemWrite->lowAddr)) = *pbPC++; ! 7227: } ! 7228: psMemWrite = NULL; ! 7229: break; ! 7230: } ! 7231: ++psMemWrite; ! 7232: } ! 7233: ! 7234: if (psMemWrite) ! 7235: { ! 7236: cpu.z80Base[sdwAddr] = (UINT8) *pbPC++; ! 7237: } ! 7238: ! 7239: break; ! 7240: } ! 7241: case 0x37: ! 7242: { ! 7243: InvalidInstruction(2); ! 7244: break; ! 7245: } ! 7246: case 0x38: ! 7247: { ! 7248: InvalidInstruction(2); ! 7249: break; ! 7250: } ! 7251: case 0x39: ! 7252: { ! 7253: sdwCyclesRemaining -= 15; ! 7254: cpu.z80F &= ~(Z80_FLAG_CARRY | Z80_FLAG_NEGATIVE | Z80_FLAG_HALF_CARRY); ! 7255: dwTemp = cpu.z80IX + cpu.z80sp; ! 7256: cpu.z80F |= ((dwTemp >> 16) & Z80_FLAG_CARRY) | (((cpu.z80IX ^ dwTemp ^ cpu.z80sp) >> 8) & Z80_FLAG_HALF_CARRY); ! 7257: cpu.z80IX = dwTemp & 0xffff; ! 7258: break; ! 7259: } ! 7260: case 0x3a: ! 7261: { ! 7262: InvalidInstruction(2); ! 7263: break; ! 7264: } ! 7265: case 0x3b: ! 7266: { ! 7267: InvalidInstruction(2); ! 7268: break; ! 7269: } ! 7270: case 0x3c: ! 7271: { ! 7272: InvalidInstruction(2); ! 7273: break; ! 7274: } ! 7275: case 0x3d: ! 7276: { ! 7277: InvalidInstruction(2); ! 7278: break; ! 7279: } ! 7280: case 0x3e: ! 7281: { ! 7282: InvalidInstruction(2); ! 7283: break; ! 7284: } ! 7285: case 0x3f: ! 7286: { ! 7287: InvalidInstruction(2); ! 7288: break; ! 7289: } ! 7290: case 0x40: ! 7291: { ! 7292: InvalidInstruction(2); ! 7293: break; ! 7294: } ! 7295: case 0x41: ! 7296: { ! 7297: InvalidInstruction(2); ! 7298: break; ! 7299: } ! 7300: case 0x42: ! 7301: { ! 7302: InvalidInstruction(2); ! 7303: break; ! 7304: } ! 7305: case 0x43: ! 7306: { ! 7307: InvalidInstruction(2); ! 7308: break; ! 7309: } ! 7310: case 0x44: ! 7311: { ! 7312: sdwCyclesRemaining -= 9; ! 7313: cpu.z80B = cpu.z80XH; ! 7314: break; ! 7315: } ! 7316: case 0x45: ! 7317: { ! 7318: sdwCyclesRemaining -= 9; ! 7319: cpu.z80B = cpu.z80XL; ! 7320: break; ! 7321: } ! 7322: case 0x46: ! 7323: { ! 7324: sdwCyclesRemaining -= 19; ! 7325: sdwAddr = (INT8) *pbPC++; // Get the offset ! 7326: sdwAddr = ((INT32) cpu.z80IX + sdwAddr) & 0xffff; ! 7327: psMemRead = cpu.z80MemRead; /* Beginning of our handler */ ! 7328: while (psMemRead->lowAddr != 0xffffffff) ! 7329: { ! 7330: if ((sdwAddr >= psMemRead->lowAddr) && (sdwAddr <= psMemRead->highAddr)) ! 7331: { ! 7332: cpu.z80pc = (UINT32) pbPC - (UINT32) cpu.z80Base; ! 7333: if (psMemRead->memoryCall) ! 7334: { ! 7335: cpu.z80B = psMemRead->memoryCall(sdwAddr, psMemRead); ! 7336: } ! 7337: else ! 7338: { ! 7339: cpu.z80B = *((UINT8 *) psMemRead->pUserArea + (sdwAddr - psMemRead->lowAddr)); ! 7340: } ! 7341: psMemRead = NULL; ! 7342: break; ! 7343: } ! 7344: ++psMemRead; ! 7345: } ! 7346: ! 7347: if (psMemRead) ! 7348: { ! 7349: cpu.z80B = cpu.z80Base[sdwAddr]; ! 7350: } ! 7351: ! 7352: break; ! 7353: } ! 7354: case 0x47: ! 7355: { ! 7356: InvalidInstruction(2); ! 7357: break; ! 7358: } ! 7359: case 0x48: ! 7360: { ! 7361: InvalidInstruction(2); ! 7362: break; ! 7363: } ! 7364: case 0x49: ! 7365: { ! 7366: InvalidInstruction(2); ! 7367: break; ! 7368: } ! 7369: case 0x4a: ! 7370: { ! 7371: InvalidInstruction(2); ! 7372: break; ! 7373: } ! 7374: case 0x4b: ! 7375: { ! 7376: InvalidInstruction(2); ! 7377: break; ! 7378: } ! 7379: case 0x4c: ! 7380: { ! 7381: sdwCyclesRemaining -= 9; ! 7382: cpu.z80C = cpu.z80XH; ! 7383: break; ! 7384: } ! 7385: case 0x4d: ! 7386: { ! 7387: sdwCyclesRemaining -= 9; ! 7388: cpu.z80C = cpu.z80XL; ! 7389: break; ! 7390: } ! 7391: case 0x4e: ! 7392: { ! 7393: sdwCyclesRemaining -= 19; ! 7394: sdwAddr = (INT8) *pbPC++; // Get the offset ! 7395: sdwAddr = ((INT32) cpu.z80IX + sdwAddr) & 0xffff; ! 7396: psMemRead = cpu.z80MemRead; /* Beginning of our handler */ ! 7397: while (psMemRead->lowAddr != 0xffffffff) ! 7398: { ! 7399: if ((sdwAddr >= psMemRead->lowAddr) && (sdwAddr <= psMemRead->highAddr)) ! 7400: { ! 7401: cpu.z80pc = (UINT32) pbPC - (UINT32) cpu.z80Base; ! 7402: if (psMemRead->memoryCall) ! 7403: { ! 7404: cpu.z80C = psMemRead->memoryCall(sdwAddr, psMemRead); ! 7405: } ! 7406: else ! 7407: { ! 7408: cpu.z80C = *((UINT8 *) psMemRead->pUserArea + (sdwAddr - psMemRead->lowAddr)); ! 7409: } ! 7410: psMemRead = NULL; ! 7411: break; ! 7412: } ! 7413: ++psMemRead; ! 7414: } ! 7415: ! 7416: if (psMemRead) ! 7417: { ! 7418: cpu.z80C = cpu.z80Base[sdwAddr]; ! 7419: } ! 7420: ! 7421: break; ! 7422: } ! 7423: case 0x4f: ! 7424: { ! 7425: InvalidInstruction(2); ! 7426: break; ! 7427: } ! 7428: case 0x50: ! 7429: { ! 7430: InvalidInstruction(2); ! 7431: break; ! 7432: } ! 7433: case 0x51: ! 7434: { ! 7435: InvalidInstruction(2); ! 7436: break; ! 7437: } ! 7438: case 0x52: ! 7439: { ! 7440: InvalidInstruction(2); ! 7441: break; ! 7442: } ! 7443: case 0x53: ! 7444: { ! 7445: InvalidInstruction(2); ! 7446: break; ! 7447: } ! 7448: case 0x54: ! 7449: { ! 7450: sdwCyclesRemaining -= 9; ! 7451: cpu.z80D = cpu.z80XH; ! 7452: break; ! 7453: } ! 7454: case 0x55: ! 7455: { ! 7456: sdwCyclesRemaining -= 9; ! 7457: cpu.z80D = cpu.z80XL; ! 7458: break; ! 7459: } ! 7460: case 0x56: ! 7461: { ! 7462: sdwCyclesRemaining -= 19; ! 7463: sdwAddr = (INT8) *pbPC++; // Get the offset ! 7464: sdwAddr = ((INT32) cpu.z80IX + sdwAddr) & 0xffff; ! 7465: psMemRead = cpu.z80MemRead; /* Beginning of our handler */ ! 7466: while (psMemRead->lowAddr != 0xffffffff) ! 7467: { ! 7468: if ((sdwAddr >= psMemRead->lowAddr) && (sdwAddr <= psMemRead->highAddr)) ! 7469: { ! 7470: cpu.z80pc = (UINT32) pbPC - (UINT32) cpu.z80Base; ! 7471: if (psMemRead->memoryCall) ! 7472: { ! 7473: cpu.z80D = psMemRead->memoryCall(sdwAddr, psMemRead); ! 7474: } ! 7475: else ! 7476: { ! 7477: cpu.z80D = *((UINT8 *) psMemRead->pUserArea + (sdwAddr - psMemRead->lowAddr)); ! 7478: } ! 7479: psMemRead = NULL; ! 7480: break; ! 7481: } ! 7482: ++psMemRead; ! 7483: } ! 7484: ! 7485: if (psMemRead) ! 7486: { ! 7487: cpu.z80D = cpu.z80Base[sdwAddr]; ! 7488: } ! 7489: ! 7490: break; ! 7491: } ! 7492: case 0x57: ! 7493: { ! 7494: InvalidInstruction(2); ! 7495: break; ! 7496: } ! 7497: case 0x58: ! 7498: { ! 7499: InvalidInstruction(2); ! 7500: break; ! 7501: } ! 7502: case 0x59: ! 7503: { ! 7504: InvalidInstruction(2); ! 7505: break; ! 7506: } ! 7507: case 0x5a: ! 7508: { ! 7509: InvalidInstruction(2); ! 7510: break; ! 7511: } ! 7512: case 0x5b: ! 7513: { ! 7514: InvalidInstruction(2); ! 7515: break; ! 7516: } ! 7517: case 0x5c: ! 7518: { ! 7519: sdwCyclesRemaining -= 9; ! 7520: cpu.z80E = cpu.z80XH; ! 7521: break; ! 7522: } ! 7523: case 0x5d: ! 7524: { ! 7525: sdwCyclesRemaining -= 9; ! 7526: cpu.z80E = cpu.z80XL; ! 7527: break; ! 7528: } ! 7529: case 0x5e: ! 7530: { ! 7531: sdwCyclesRemaining -= 19; ! 7532: sdwAddr = (INT8) *pbPC++; // Get the offset ! 7533: sdwAddr = ((INT32) cpu.z80IX + sdwAddr) & 0xffff; ! 7534: psMemRead = cpu.z80MemRead; /* Beginning of our handler */ ! 7535: while (psMemRead->lowAddr != 0xffffffff) ! 7536: { ! 7537: if ((sdwAddr >= psMemRead->lowAddr) && (sdwAddr <= psMemRead->highAddr)) ! 7538: { ! 7539: cpu.z80pc = (UINT32) pbPC - (UINT32) cpu.z80Base; ! 7540: if (psMemRead->memoryCall) ! 7541: { ! 7542: cpu.z80E = psMemRead->memoryCall(sdwAddr, psMemRead); ! 7543: } ! 7544: else ! 7545: { ! 7546: cpu.z80E = *((UINT8 *) psMemRead->pUserArea + (sdwAddr - psMemRead->lowAddr)); ! 7547: } ! 7548: psMemRead = NULL; ! 7549: break; ! 7550: } ! 7551: ++psMemRead; ! 7552: } ! 7553: ! 7554: if (psMemRead) ! 7555: { ! 7556: cpu.z80E = cpu.z80Base[sdwAddr]; ! 7557: } ! 7558: ! 7559: break; ! 7560: } ! 7561: case 0x5f: ! 7562: { ! 7563: InvalidInstruction(2); ! 7564: break; ! 7565: } ! 7566: case 0x60: ! 7567: { ! 7568: sdwCyclesRemaining -= 9; ! 7569: cpu.z80XH = cpu.z80B; ! 7570: break; ! 7571: } ! 7572: case 0x61: ! 7573: { ! 7574: sdwCyclesRemaining -= 9; ! 7575: cpu.z80XH = cpu.z80C; ! 7576: break; ! 7577: } ! 7578: case 0x62: ! 7579: { ! 7580: sdwCyclesRemaining -= 9; ! 7581: cpu.z80XH = cpu.z80D; ! 7582: break; ! 7583: } ! 7584: case 0x63: ! 7585: { ! 7586: sdwCyclesRemaining -= 9; ! 7587: cpu.z80XH = cpu.z80E; ! 7588: break; ! 7589: } ! 7590: case 0x64: ! 7591: { ! 7592: sdwCyclesRemaining -= 9; ! 7593: break; ! 7594: } ! 7595: case 0x65: ! 7596: { ! 7597: sdwCyclesRemaining -= 9; ! 7598: cpu.z80XH = cpu.z80XL; ! 7599: break; ! 7600: } ! 7601: case 0x66: ! 7602: { ! 7603: sdwCyclesRemaining -= 19; ! 7604: sdwAddr = (INT8) *pbPC++; // Get the offset ! 7605: sdwAddr = ((INT32) cpu.z80IX + sdwAddr) & 0xffff; ! 7606: psMemRead = cpu.z80MemRead; /* Beginning of our handler */ ! 7607: while (psMemRead->lowAddr != 0xffffffff) ! 7608: { ! 7609: if ((sdwAddr >= psMemRead->lowAddr) && (sdwAddr <= psMemRead->highAddr)) ! 7610: { ! 7611: cpu.z80pc = (UINT32) pbPC - (UINT32) cpu.z80Base; ! 7612: if (psMemRead->memoryCall) ! 7613: { ! 7614: cpu.z80H = psMemRead->memoryCall(sdwAddr, psMemRead); ! 7615: } ! 7616: else ! 7617: { ! 7618: cpu.z80H = *((UINT8 *) psMemRead->pUserArea + (sdwAddr - psMemRead->lowAddr)); ! 7619: } ! 7620: psMemRead = NULL; ! 7621: break; ! 7622: } ! 7623: ++psMemRead; ! 7624: } ! 7625: ! 7626: if (psMemRead) ! 7627: { ! 7628: cpu.z80H = cpu.z80Base[sdwAddr]; ! 7629: } ! 7630: ! 7631: break; ! 7632: } ! 7633: case 0x67: ! 7634: { ! 7635: sdwCyclesRemaining -= 9; ! 7636: cpu.z80XH = cpu.z80A; ! 7637: break; ! 7638: } ! 7639: case 0x68: ! 7640: { ! 7641: sdwCyclesRemaining -= 9; ! 7642: cpu.z80XL = cpu.z80B; ! 7643: break; ! 7644: } ! 7645: case 0x69: ! 7646: { ! 7647: sdwCyclesRemaining -= 9; ! 7648: cpu.z80XL = cpu.z80C; ! 7649: break; ! 7650: } ! 7651: case 0x6a: ! 7652: { ! 7653: sdwCyclesRemaining -= 9; ! 7654: cpu.z80XL = cpu.z80D; ! 7655: break; ! 7656: } ! 7657: case 0x6b: ! 7658: { ! 7659: sdwCyclesRemaining -= 9; ! 7660: cpu.z80XL = cpu.z80E; ! 7661: break; ! 7662: } ! 7663: case 0x6c: ! 7664: { ! 7665: sdwCyclesRemaining -= 9; ! 7666: cpu.z80XL = cpu.z80XH; ! 7667: break; ! 7668: } ! 7669: case 0x6d: ! 7670: { ! 7671: sdwCyclesRemaining -= 9; ! 7672: break; ! 7673: } ! 7674: case 0x6e: ! 7675: { ! 7676: sdwCyclesRemaining -= 19; ! 7677: sdwAddr = (INT8) *pbPC++; // Get the offset ! 7678: sdwAddr = ((INT32) cpu.z80IX + sdwAddr) & 0xffff; ! 7679: psMemRead = cpu.z80MemRead; /* Beginning of our handler */ ! 7680: while (psMemRead->lowAddr != 0xffffffff) ! 7681: { ! 7682: if ((sdwAddr >= psMemRead->lowAddr) && (sdwAddr <= psMemRead->highAddr)) ! 7683: { ! 7684: cpu.z80pc = (UINT32) pbPC - (UINT32) cpu.z80Base; ! 7685: if (psMemRead->memoryCall) ! 7686: { ! 7687: cpu.z80L = psMemRead->memoryCall(sdwAddr, psMemRead); ! 7688: } ! 7689: else ! 7690: { ! 7691: cpu.z80L = *((UINT8 *) psMemRead->pUserArea + (sdwAddr - psMemRead->lowAddr)); ! 7692: } ! 7693: psMemRead = NULL; ! 7694: break; ! 7695: } ! 7696: ++psMemRead; ! 7697: } ! 7698: ! 7699: if (psMemRead) ! 7700: { ! 7701: cpu.z80L = cpu.z80Base[sdwAddr]; ! 7702: } ! 7703: ! 7704: break; ! 7705: } ! 7706: case 0x6f: ! 7707: { ! 7708: sdwCyclesRemaining -= 9; ! 7709: cpu.z80XL = cpu.z80A; ! 7710: break; ! 7711: } ! 7712: case 0x70: ! 7713: { ! 7714: sdwCyclesRemaining -= 19; ! 7715: sdwAddr = (INT8) *pbPC++; // Get the offset ! 7716: sdwAddr = ((INT32) cpu.z80IX + sdwAddr) & 0xffff; ! 7717: psMemWrite = cpu.z80MemWrite; /* Beginning of our handler */ ! 7718: while (psMemWrite->lowAddr != 0xffffffff) ! 7719: { ! 7720: if ((sdwAddr >= psMemWrite->lowAddr) && (sdwAddr <= psMemWrite->highAddr)) ! 7721: { ! 7722: cpu.z80pc = (UINT32) pbPC - (UINT32) cpu.z80Base; ! 7723: if (psMemWrite->memoryCall) ! 7724: { ! 7725: psMemWrite->memoryCall(sdwAddr, cpu.z80B, psMemWrite); ! 7726: } ! 7727: else ! 7728: { ! 7729: *((UINT8 *) psMemWrite->pUserArea + (sdwAddr - psMemWrite->lowAddr)) = cpu.z80B; ! 7730: } ! 7731: psMemWrite = NULL; ! 7732: break; ! 7733: } ! 7734: ++psMemWrite; ! 7735: } ! 7736: ! 7737: if (psMemWrite) ! 7738: { ! 7739: cpu.z80Base[sdwAddr] = (UINT8) cpu.z80B; ! 7740: } ! 7741: ! 7742: break; ! 7743: } ! 7744: case 0x71: ! 7745: { ! 7746: sdwCyclesRemaining -= 19; ! 7747: sdwAddr = (INT8) *pbPC++; // Get the offset ! 7748: sdwAddr = ((INT32) cpu.z80IX + sdwAddr) & 0xffff; ! 7749: psMemWrite = cpu.z80MemWrite; /* Beginning of our handler */ ! 7750: while (psMemWrite->lowAddr != 0xffffffff) ! 7751: { ! 7752: if ((sdwAddr >= psMemWrite->lowAddr) && (sdwAddr <= psMemWrite->highAddr)) ! 7753: { ! 7754: cpu.z80pc = (UINT32) pbPC - (UINT32) cpu.z80Base; ! 7755: if (psMemWrite->memoryCall) ! 7756: { ! 7757: psMemWrite->memoryCall(sdwAddr, cpu.z80C, psMemWrite); ! 7758: } ! 7759: else ! 7760: { ! 7761: *((UINT8 *) psMemWrite->pUserArea + (sdwAddr - psMemWrite->lowAddr)) = cpu.z80C; ! 7762: } ! 7763: psMemWrite = NULL; ! 7764: break; ! 7765: } ! 7766: ++psMemWrite; ! 7767: } ! 7768: ! 7769: if (psMemWrite) ! 7770: { ! 7771: cpu.z80Base[sdwAddr] = (UINT8) cpu.z80C; ! 7772: } ! 7773: ! 7774: break; ! 7775: } ! 7776: case 0x72: ! 7777: { ! 7778: sdwCyclesRemaining -= 19; ! 7779: sdwAddr = (INT8) *pbPC++; // Get the offset ! 7780: sdwAddr = ((INT32) cpu.z80IX + sdwAddr) & 0xffff; ! 7781: psMemWrite = cpu.z80MemWrite; /* Beginning of our handler */ ! 7782: while (psMemWrite->lowAddr != 0xffffffff) ! 7783: { ! 7784: if ((sdwAddr >= psMemWrite->lowAddr) && (sdwAddr <= psMemWrite->highAddr)) ! 7785: { ! 7786: cpu.z80pc = (UINT32) pbPC - (UINT32) cpu.z80Base; ! 7787: if (psMemWrite->memoryCall) ! 7788: { ! 7789: psMemWrite->memoryCall(sdwAddr, cpu.z80D, psMemWrite); ! 7790: } ! 7791: else ! 7792: { ! 7793: *((UINT8 *) psMemWrite->pUserArea + (sdwAddr - psMemWrite->lowAddr)) = cpu.z80D; ! 7794: } ! 7795: psMemWrite = NULL; ! 7796: break; ! 7797: } ! 7798: ++psMemWrite; ! 7799: } ! 7800: ! 7801: if (psMemWrite) ! 7802: { ! 7803: cpu.z80Base[sdwAddr] = (UINT8) cpu.z80D; ! 7804: } ! 7805: ! 7806: break; ! 7807: } ! 7808: case 0x73: ! 7809: { ! 7810: sdwCyclesRemaining -= 19; ! 7811: sdwAddr = (INT8) *pbPC++; // Get the offset ! 7812: sdwAddr = ((INT32) cpu.z80IX + sdwAddr) & 0xffff; ! 7813: psMemWrite = cpu.z80MemWrite; /* Beginning of our handler */ ! 7814: while (psMemWrite->lowAddr != 0xffffffff) ! 7815: { ! 7816: if ((sdwAddr >= psMemWrite->lowAddr) && (sdwAddr <= psMemWrite->highAddr)) ! 7817: { ! 7818: cpu.z80pc = (UINT32) pbPC - (UINT32) cpu.z80Base; ! 7819: if (psMemWrite->memoryCall) ! 7820: { ! 7821: psMemWrite->memoryCall(sdwAddr, cpu.z80E, psMemWrite); ! 7822: } ! 7823: else ! 7824: { ! 7825: *((UINT8 *) psMemWrite->pUserArea + (sdwAddr - psMemWrite->lowAddr)) = cpu.z80E; ! 7826: } ! 7827: psMemWrite = NULL; ! 7828: break; ! 7829: } ! 7830: ++psMemWrite; ! 7831: } ! 7832: ! 7833: if (psMemWrite) ! 7834: { ! 7835: cpu.z80Base[sdwAddr] = (UINT8) cpu.z80E; ! 7836: } ! 7837: ! 7838: break; ! 7839: } ! 7840: case 0x74: ! 7841: { ! 7842: sdwCyclesRemaining -= 19; ! 7843: sdwAddr = (INT8) *pbPC++; // Get the offset ! 7844: sdwAddr = ((INT32) cpu.z80IX + sdwAddr) & 0xffff; ! 7845: psMemWrite = cpu.z80MemWrite; /* Beginning of our handler */ ! 7846: while (psMemWrite->lowAddr != 0xffffffff) ! 7847: { ! 7848: if ((sdwAddr >= psMemWrite->lowAddr) && (sdwAddr <= psMemWrite->highAddr)) ! 7849: { ! 7850: cpu.z80pc = (UINT32) pbPC - (UINT32) cpu.z80Base; ! 7851: if (psMemWrite->memoryCall) ! 7852: { ! 7853: psMemWrite->memoryCall(sdwAddr, cpu.z80H, psMemWrite); ! 7854: } ! 7855: else ! 7856: { ! 7857: *((UINT8 *) psMemWrite->pUserArea + (sdwAddr - psMemWrite->lowAddr)) = cpu.z80H; ! 7858: } ! 7859: psMemWrite = NULL; ! 7860: break; ! 7861: } ! 7862: ++psMemWrite; ! 7863: } ! 7864: ! 7865: if (psMemWrite) ! 7866: { ! 7867: cpu.z80Base[sdwAddr] = (UINT8) cpu.z80H; ! 7868: } ! 7869: ! 7870: break; ! 7871: } ! 7872: case 0x75: ! 7873: { ! 7874: sdwCyclesRemaining -= 19; ! 7875: sdwAddr = (INT8) *pbPC++; // Get the offset ! 7876: sdwAddr = ((INT32) cpu.z80IX + sdwAddr) & 0xffff; ! 7877: psMemWrite = cpu.z80MemWrite; /* Beginning of our handler */ ! 7878: while (psMemWrite->lowAddr != 0xffffffff) ! 7879: { ! 7880: if ((sdwAddr >= psMemWrite->lowAddr) && (sdwAddr <= psMemWrite->highAddr)) ! 7881: { ! 7882: cpu.z80pc = (UINT32) pbPC - (UINT32) cpu.z80Base; ! 7883: if (psMemWrite->memoryCall) ! 7884: { ! 7885: psMemWrite->memoryCall(sdwAddr, cpu.z80L, psMemWrite); ! 7886: } ! 7887: else ! 7888: { ! 7889: *((UINT8 *) psMemWrite->pUserArea + (sdwAddr - psMemWrite->lowAddr)) = cpu.z80L; ! 7890: } ! 7891: psMemWrite = NULL; ! 7892: break; ! 7893: } ! 7894: ++psMemWrite; ! 7895: } ! 7896: ! 7897: if (psMemWrite) ! 7898: { ! 7899: cpu.z80Base[sdwAddr] = (UINT8) cpu.z80L; ! 7900: } ! 7901: ! 7902: break; ! 7903: } ! 7904: case 0x76: ! 7905: { ! 7906: sdwCyclesRemaining -= 19; ! 7907: InvalidInstruction(2); ! 7908: break; ! 7909: } ! 7910: case 0x77: ! 7911: { ! 7912: sdwCyclesRemaining -= 19; ! 7913: sdwAddr = (INT8) *pbPC++; // Get the offset ! 7914: sdwAddr = ((INT32) cpu.z80IX + sdwAddr) & 0xffff; ! 7915: psMemWrite = cpu.z80MemWrite; /* Beginning of our handler */ ! 7916: while (psMemWrite->lowAddr != 0xffffffff) ! 7917: { ! 7918: if ((sdwAddr >= psMemWrite->lowAddr) && (sdwAddr <= psMemWrite->highAddr)) ! 7919: { ! 7920: cpu.z80pc = (UINT32) pbPC - (UINT32) cpu.z80Base; ! 7921: if (psMemWrite->memoryCall) ! 7922: { ! 7923: psMemWrite->memoryCall(sdwAddr, cpu.z80A, psMemWrite); ! 7924: } ! 7925: else ! 7926: { ! 7927: *((UINT8 *) psMemWrite->pUserArea + (sdwAddr - psMemWrite->lowAddr)) = cpu.z80A; ! 7928: } ! 7929: psMemWrite = NULL; ! 7930: break; ! 7931: } ! 7932: ++psMemWrite; ! 7933: } ! 7934: ! 7935: if (psMemWrite) ! 7936: { ! 7937: cpu.z80Base[sdwAddr] = (UINT8) cpu.z80A; ! 7938: } ! 7939: ! 7940: break; ! 7941: } ! 7942: case 0x78: ! 7943: { ! 7944: InvalidInstruction(2); ! 7945: break; ! 7946: } ! 7947: case 0x79: ! 7948: { ! 7949: InvalidInstruction(2); ! 7950: break; ! 7951: } ! 7952: case 0x7a: ! 7953: { ! 7954: InvalidInstruction(2); ! 7955: break; ! 7956: } ! 7957: case 0x7b: ! 7958: { ! 7959: InvalidInstruction(2); ! 7960: break; ! 7961: } ! 7962: case 0x7c: ! 7963: { ! 7964: sdwCyclesRemaining -= 9; ! 7965: cpu.z80A = cpu.z80XH; ! 7966: break; ! 7967: } ! 7968: case 0x7d: ! 7969: { ! 7970: sdwCyclesRemaining -= 9; ! 7971: cpu.z80A = cpu.z80XL; ! 7972: break; ! 7973: } ! 7974: case 0x7e: ! 7975: { ! 7976: sdwCyclesRemaining -= 19; ! 7977: sdwAddr = (INT8) *pbPC++; // Get the offset ! 7978: sdwAddr = ((INT32) cpu.z80IX + sdwAddr) & 0xffff; ! 7979: psMemRead = cpu.z80MemRead; /* Beginning of our handler */ ! 7980: while (psMemRead->lowAddr != 0xffffffff) ! 7981: { ! 7982: if ((sdwAddr >= psMemRead->lowAddr) && (sdwAddr <= psMemRead->highAddr)) ! 7983: { ! 7984: cpu.z80pc = (UINT32) pbPC - (UINT32) cpu.z80Base; ! 7985: if (psMemRead->memoryCall) ! 7986: { ! 7987: cpu.z80A = psMemRead->memoryCall(sdwAddr, psMemRead); ! 7988: } ! 7989: else ! 7990: { ! 7991: cpu.z80A = *((UINT8 *) psMemRead->pUserArea + (sdwAddr - psMemRead->lowAddr)); ! 7992: } ! 7993: psMemRead = NULL; ! 7994: break; ! 7995: } ! 7996: ++psMemRead; ! 7997: } ! 7998: ! 7999: if (psMemRead) ! 8000: { ! 8001: cpu.z80A = cpu.z80Base[sdwAddr]; ! 8002: } ! 8003: ! 8004: break; ! 8005: } ! 8006: case 0x7f: ! 8007: { ! 8008: InvalidInstruction(2); ! 8009: break; ! 8010: } ! 8011: case 0x80: ! 8012: { ! 8013: InvalidInstruction(2); ! 8014: break; ! 8015: } ! 8016: case 0x81: ! 8017: { ! 8018: InvalidInstruction(2); ! 8019: break; ! 8020: } ! 8021: case 0x82: ! 8022: { ! 8023: InvalidInstruction(2); ! 8024: break; ! 8025: } ! 8026: case 0x83: ! 8027: { ! 8028: InvalidInstruction(2); ! 8029: break; ! 8030: } ! 8031: case 0x84: ! 8032: { ! 8033: sdwCyclesRemaining -= 9; ! 8034: bTemp2 = cpu.z80A + cpu.z80XH; ! 8035: cpu.z80F = (cpu.z80F & ~(Z80_FLAG_CARRY | Z80_FLAG_NEGATIVE | Z80_FLAG_OVERFLOW_PARITY | ! 8036: Z80_FLAG_HALF_CARRY | Z80_FLAG_ZERO | Z80_FLAG_SIGN)) | ! 8037: pbAddAdcTable[((UINT32) cpu.z80A << 8) | cpu.z80XH]; ! 8038: break; ! 8039: } ! 8040: case 0x85: ! 8041: { ! 8042: sdwCyclesRemaining -= 9; ! 8043: bTemp2 = cpu.z80A + cpu.z80XL; ! 8044: cpu.z80F = (cpu.z80F & ~(Z80_FLAG_CARRY | Z80_FLAG_NEGATIVE | Z80_FLAG_OVERFLOW_PARITY | ! 8045: Z80_FLAG_HALF_CARRY | Z80_FLAG_ZERO | Z80_FLAG_SIGN)) | ! 8046: pbAddAdcTable[((UINT32) cpu.z80A << 8) | cpu.z80XL]; ! 8047: break; ! 8048: } ! 8049: case 0x86: ! 8050: { ! 8051: sdwCyclesRemaining -= 19; ! 8052: sdwAddr = (INT8) *pbPC++; /* Get LSB first */ ! 8053: dwAddr = (sdwAddr + (INT32) cpu.z80IX) & 0xffff; ! 8054: psMemRead = cpu.z80MemRead; /* Beginning of our handler */ ! 8055: while (psMemRead->lowAddr != 0xffffffff) ! 8056: { ! 8057: if ((dwAddr >= psMemRead->lowAddr) && (dwAddr <= psMemRead->highAddr)) ! 8058: { ! 8059: cpu.z80pc = (UINT32) pbPC - (UINT32) cpu.z80Base; ! 8060: if (psMemRead->memoryCall) ! 8061: { ! 8062: bTemp = psMemRead->memoryCall(dwAddr, psMemRead); ! 8063: } ! 8064: else ! 8065: { ! 8066: bTemp = *((UINT8 *) psMemRead->pUserArea + (dwAddr - psMemRead->lowAddr)); ! 8067: } ! 8068: psMemRead = NULL; ! 8069: break; ! 8070: } ! 8071: ++psMemRead; ! 8072: } ! 8073: ! 8074: if (psMemRead) ! 8075: { ! 8076: bTemp = cpu.z80Base[dwAddr]; ! 8077: } ! 8078: ! 8079: cpu.z80F = (cpu.z80F & ~(Z80_FLAG_CARRY | Z80_FLAG_NEGATIVE | Z80_FLAG_OVERFLOW_PARITY | ! 8080: Z80_FLAG_HALF_CARRY | Z80_FLAG_ZERO | Z80_FLAG_SIGN)) | ! 8081: pbAddAdcTable[((UINT32) cpu.z80A << 8) | bTemp]; ! 8082: cpu.z80A += bTemp; ! 8083: break; ! 8084: } ! 8085: case 0x87: ! 8086: { ! 8087: InvalidInstruction(2); ! 8088: break; ! 8089: } ! 8090: case 0x88: ! 8091: { ! 8092: InvalidInstruction(2); ! 8093: break; ! 8094: } ! 8095: case 0x89: ! 8096: { ! 8097: InvalidInstruction(2); ! 8098: break; ! 8099: } ! 8100: case 0x8a: ! 8101: { ! 8102: InvalidInstruction(2); ! 8103: break; ! 8104: } ! 8105: case 0x8b: ! 8106: { ! 8107: InvalidInstruction(2); ! 8108: break; ! 8109: } ! 8110: case 0x8c: ! 8111: { ! 8112: sdwCyclesRemaining -= 9; ! 8113: bTemp2 = cpu.z80A + cpu.z80XH + (cpu.z80F & Z80_FLAG_CARRY); ! 8114: cpu.z80F = (cpu.z80F & ~(Z80_FLAG_CARRY | Z80_FLAG_NEGATIVE | Z80_FLAG_OVERFLOW_PARITY | ! 8115: Z80_FLAG_HALF_CARRY | Z80_FLAG_ZERO | Z80_FLAG_SIGN)) | ! 8116: pbAddAdcTable[((UINT32) cpu.z80A << 8) | cpu.z80XH | (((UINT32) cpu.z80F & Z80_FLAG_CARRY) << 16)]; ! 8117: break; ! 8118: } ! 8119: case 0x8d: ! 8120: { ! 8121: sdwCyclesRemaining -= 9; ! 8122: bTemp2 = cpu.z80A + cpu.z80XL + (cpu.z80F & Z80_FLAG_CARRY); ! 8123: cpu.z80F = (cpu.z80F & ~(Z80_FLAG_CARRY | Z80_FLAG_NEGATIVE | Z80_FLAG_OVERFLOW_PARITY | ! 8124: Z80_FLAG_HALF_CARRY | Z80_FLAG_ZERO | Z80_FLAG_SIGN)) | ! 8125: pbAddAdcTable[((UINT32) cpu.z80A << 8) | cpu.z80XL | (((UINT32) cpu.z80F & Z80_FLAG_CARRY) << 16)]; ! 8126: break; ! 8127: } ! 8128: case 0x8e: ! 8129: { ! 8130: sdwCyclesRemaining -= 19; ! 8131: sdwAddr = (INT8) *pbPC++; /* Get LSB first */ ! 8132: dwAddr = (sdwAddr + (INT32) cpu.z80IX) & 0xffff; ! 8133: psMemRead = cpu.z80MemRead; /* Beginning of our handler */ ! 8134: while (psMemRead->lowAddr != 0xffffffff) ! 8135: { ! 8136: if ((dwAddr >= psMemRead->lowAddr) && (dwAddr <= psMemRead->highAddr)) ! 8137: { ! 8138: cpu.z80pc = (UINT32) pbPC - (UINT32) cpu.z80Base; ! 8139: if (psMemRead->memoryCall) ! 8140: { ! 8141: bTemp = psMemRead->memoryCall(dwAddr, psMemRead); ! 8142: } ! 8143: else ! 8144: { ! 8145: bTemp = *((UINT8 *) psMemRead->pUserArea + (dwAddr - psMemRead->lowAddr)); ! 8146: } ! 8147: psMemRead = NULL; ! 8148: break; ! 8149: } ! 8150: ++psMemRead; ! 8151: } ! 8152: ! 8153: if (psMemRead) ! 8154: { ! 8155: bTemp = cpu.z80Base[dwAddr]; ! 8156: } ! 8157: ! 8158: bTemp2 = (cpu.z80F & Z80_FLAG_CARRY); ! 8159: cpu.z80F = (cpu.z80F & ~(Z80_FLAG_CARRY | Z80_FLAG_NEGATIVE | Z80_FLAG_OVERFLOW_PARITY | ! 8160: Z80_FLAG_HALF_CARRY | Z80_FLAG_ZERO | Z80_FLAG_SIGN)) | ! 8161: pbAddAdcTable[((UINT32) cpu.z80A << 8) | bTemp | (((UINT32) cpu.z80F & Z80_FLAG_CARRY) << 16)]; ! 8162: cpu.z80A += bTemp + bTemp2; ! 8163: break; ! 8164: } ! 8165: case 0x8f: ! 8166: { ! 8167: InvalidInstruction(2); ! 8168: break; ! 8169: } ! 8170: case 0x90: ! 8171: { ! 8172: InvalidInstruction(2); ! 8173: break; ! 8174: } ! 8175: case 0x91: ! 8176: { ! 8177: InvalidInstruction(2); ! 8178: break; ! 8179: } ! 8180: case 0x92: ! 8181: { ! 8182: InvalidInstruction(2); ! 8183: break; ! 8184: } ! 8185: case 0x93: ! 8186: { ! 8187: InvalidInstruction(2); ! 8188: break; ! 8189: } ! 8190: case 0x94: ! 8191: { ! 8192: sdwCyclesRemaining -= 9; ! 8193: bTemp2 = cpu.z80A - cpu.z80XH; ! 8194: cpu.z80F = (cpu.z80F & ~(Z80_FLAG_CARRY | Z80_FLAG_NEGATIVE | Z80_FLAG_OVERFLOW_PARITY | ! 8195: Z80_FLAG_HALF_CARRY | Z80_FLAG_ZERO | Z80_FLAG_SIGN)) | ! 8196: pbSubSbcTable[((UINT32) cpu.z80A << 8) | cpu.z80XH]; ! 8197: break; ! 8198: } ! 8199: case 0x95: ! 8200: { ! 8201: sdwCyclesRemaining -= 9; ! 8202: bTemp2 = cpu.z80A - cpu.z80XL; ! 8203: cpu.z80F = (cpu.z80F & ~(Z80_FLAG_CARRY | Z80_FLAG_NEGATIVE | Z80_FLAG_OVERFLOW_PARITY | ! 8204: Z80_FLAG_HALF_CARRY | Z80_FLAG_ZERO | Z80_FLAG_SIGN)) | ! 8205: pbSubSbcTable[((UINT32) cpu.z80A << 8) | cpu.z80XL]; ! 8206: break; ! 8207: } ! 8208: case 0x96: ! 8209: { ! 8210: sdwCyclesRemaining -= 19; ! 8211: sdwAddr = (INT8) *pbPC++; /* Get LSB first */ ! 8212: dwAddr = (sdwAddr + (INT32) cpu.z80IX) & 0xffff; ! 8213: psMemRead = cpu.z80MemRead; /* Beginning of our handler */ ! 8214: while (psMemRead->lowAddr != 0xffffffff) ! 8215: { ! 8216: if ((dwAddr >= psMemRead->lowAddr) && (dwAddr <= psMemRead->highAddr)) ! 8217: { ! 8218: cpu.z80pc = (UINT32) pbPC - (UINT32) cpu.z80Base; ! 8219: if (psMemRead->memoryCall) ! 8220: { ! 8221: bTemp = psMemRead->memoryCall(dwAddr, psMemRead); ! 8222: } ! 8223: else ! 8224: { ! 8225: bTemp = *((UINT8 *) psMemRead->pUserArea + (dwAddr - psMemRead->lowAddr)); ! 8226: } ! 8227: psMemRead = NULL; ! 8228: break; ! 8229: } ! 8230: ++psMemRead; ! 8231: } ! 8232: ! 8233: if (psMemRead) ! 8234: { ! 8235: bTemp = cpu.z80Base[dwAddr]; ! 8236: } ! 8237: ! 8238: cpu.z80F = (cpu.z80F & ~(Z80_FLAG_CARRY | Z80_FLAG_NEGATIVE | Z80_FLAG_OVERFLOW_PARITY | ! 8239: Z80_FLAG_HALF_CARRY | Z80_FLAG_ZERO | Z80_FLAG_SIGN)) | ! 8240: pbSubSbcTable[((UINT32) cpu.z80A << 8) | bTemp]; ! 8241: cpu.z80A -= bTemp; ! 8242: break; ! 8243: } ! 8244: case 0x97: ! 8245: { ! 8246: InvalidInstruction(2); ! 8247: break; ! 8248: } ! 8249: case 0x98: ! 8250: { ! 8251: InvalidInstruction(2); ! 8252: break; ! 8253: } ! 8254: case 0x99: ! 8255: { ! 8256: InvalidInstruction(2); ! 8257: break; ! 8258: } ! 8259: case 0x9a: ! 8260: { ! 8261: InvalidInstruction(2); ! 8262: break; ! 8263: } ! 8264: case 0x9b: ! 8265: { ! 8266: InvalidInstruction(2); ! 8267: break; ! 8268: } ! 8269: case 0x9c: ! 8270: { ! 8271: sdwCyclesRemaining -= 9; ! 8272: bTemp2 = cpu.z80A - cpu.z80XH - (cpu.z80F & Z80_FLAG_CARRY); ! 8273: cpu.z80F = (cpu.z80F & ~(Z80_FLAG_CARRY | Z80_FLAG_NEGATIVE | Z80_FLAG_OVERFLOW_PARITY | ! 8274: Z80_FLAG_HALF_CARRY | Z80_FLAG_ZERO | Z80_FLAG_SIGN)) | ! 8275: pbSubSbcTable[((UINT32) cpu.z80A << 8) | cpu.z80XH | (((UINT32) cpu.z80F & Z80_FLAG_CARRY) << 16)]; ! 8276: break; ! 8277: } ! 8278: case 0x9d: ! 8279: { ! 8280: sdwCyclesRemaining -= 9; ! 8281: bTemp2 = cpu.z80A - cpu.z80XL - (cpu.z80F & Z80_FLAG_CARRY); ! 8282: cpu.z80F = (cpu.z80F & ~(Z80_FLAG_CARRY | Z80_FLAG_NEGATIVE | Z80_FLAG_OVERFLOW_PARITY | ! 8283: Z80_FLAG_HALF_CARRY | Z80_FLAG_ZERO | Z80_FLAG_SIGN)) | ! 8284: pbSubSbcTable[((UINT32) cpu.z80A << 8) | cpu.z80XL | (((UINT32) cpu.z80F & Z80_FLAG_CARRY) << 16)]; ! 8285: break; ! 8286: } ! 8287: case 0x9e: ! 8288: { ! 8289: sdwCyclesRemaining -= 19; ! 8290: sdwAddr = (INT8) *pbPC++; /* Get LSB first */ ! 8291: dwAddr = (sdwAddr + (INT32) cpu.z80IX) & 0xffff; ! 8292: psMemRead = cpu.z80MemRead; /* Beginning of our handler */ ! 8293: while (psMemRead->lowAddr != 0xffffffff) ! 8294: { ! 8295: if ((dwAddr >= psMemRead->lowAddr) && (dwAddr <= psMemRead->highAddr)) ! 8296: { ! 8297: cpu.z80pc = (UINT32) pbPC - (UINT32) cpu.z80Base; ! 8298: if (psMemRead->memoryCall) ! 8299: { ! 8300: bTemp = psMemRead->memoryCall(dwAddr, psMemRead); ! 8301: } ! 8302: else ! 8303: { ! 8304: bTemp = *((UINT8 *) psMemRead->pUserArea + (dwAddr - psMemRead->lowAddr)); ! 8305: } ! 8306: psMemRead = NULL; ! 8307: break; ! 8308: } ! 8309: ++psMemRead; ! 8310: } ! 8311: ! 8312: if (psMemRead) ! 8313: { ! 8314: bTemp = cpu.z80Base[dwAddr]; ! 8315: } ! 8316: ! 8317: bTemp2 = cpu.z80A; ! 8318: cpu.z80A = cpu.z80A - bTemp - (cpu.z80F & Z80_FLAG_CARRY); ! 8319: cpu.z80F = (cpu.z80F & ~(Z80_FLAG_CARRY | Z80_FLAG_NEGATIVE | Z80_FLAG_OVERFLOW_PARITY | ! 8320: Z80_FLAG_HALF_CARRY | Z80_FLAG_ZERO | Z80_FLAG_SIGN)) | ! 8321: pbSubSbcTable[((UINT32) bTemp2 << 8) | bTemp | (((UINT32) cpu.z80F & Z80_FLAG_CARRY) << 16)]; ! 8322: break; ! 8323: } ! 8324: case 0x9f: ! 8325: { ! 8326: InvalidInstruction(2); ! 8327: break; ! 8328: } ! 8329: case 0xa0: ! 8330: { ! 8331: InvalidInstruction(2); ! 8332: break; ! 8333: } ! 8334: case 0xa1: ! 8335: { ! 8336: InvalidInstruction(2); ! 8337: break; ! 8338: } ! 8339: case 0xa2: ! 8340: { ! 8341: InvalidInstruction(2); ! 8342: break; ! 8343: } ! 8344: case 0xa3: ! 8345: { ! 8346: InvalidInstruction(2); ! 8347: break; ! 8348: } ! 8349: case 0xa4: ! 8350: { ! 8351: sdwCyclesRemaining -= 9; ! 8352: cpu.z80A &= cpu.z80XH; ! 8353: cpu.z80F &= ~(Z80_FLAG_CARRY | Z80_FLAG_NEGATIVE | Z80_FLAG_OVERFLOW_PARITY | Z80_FLAG_HALF_CARRY | Z80_FLAG_ZERO | Z80_FLAG_SIGN); ! 8354: cpu.z80F |= bPostANDFlags[cpu.z80A]; ! 8355: ! 8356: break; ! 8357: } ! 8358: case 0xa5: ! 8359: { ! 8360: sdwCyclesRemaining -= 9; ! 8361: cpu.z80A &= cpu.z80XL; ! 8362: cpu.z80F &= ~(Z80_FLAG_CARRY | Z80_FLAG_NEGATIVE | Z80_FLAG_OVERFLOW_PARITY | Z80_FLAG_HALF_CARRY | Z80_FLAG_ZERO | Z80_FLAG_SIGN); ! 8363: cpu.z80F |= bPostANDFlags[cpu.z80A]; ! 8364: ! 8365: break; ! 8366: } ! 8367: case 0xa6: ! 8368: { ! 8369: sdwCyclesRemaining -= 19; ! 8370: sdwAddr = (INT8) *pbPC++; /* Get LSB first */ ! 8371: dwAddr = (sdwAddr + (INT32) cpu.z80IX) & 0xffff; ! 8372: psMemRead = cpu.z80MemRead; /* Beginning of our handler */ ! 8373: while (psMemRead->lowAddr != 0xffffffff) ! 8374: { ! 8375: if ((dwAddr >= psMemRead->lowAddr) && (dwAddr <= psMemRead->highAddr)) ! 8376: { ! 8377: cpu.z80pc = (UINT32) pbPC - (UINT32) cpu.z80Base; ! 8378: if (psMemRead->memoryCall) ! 8379: { ! 8380: bTemp = psMemRead->memoryCall(dwAddr, psMemRead); ! 8381: } ! 8382: else ! 8383: { ! 8384: bTemp = *((UINT8 *) psMemRead->pUserArea + (dwAddr - psMemRead->lowAddr)); ! 8385: } ! 8386: psMemRead = NULL; ! 8387: break; ! 8388: } ! 8389: ++psMemRead; ! 8390: } ! 8391: ! 8392: if (psMemRead) ! 8393: { ! 8394: bTemp = cpu.z80Base[dwAddr]; ! 8395: } ! 8396: ! 8397: cpu.z80A &= bTemp; ! 8398: cpu.z80F &= ~(Z80_FLAG_CARRY | Z80_FLAG_NEGATIVE | Z80_FLAG_OVERFLOW_PARITY | Z80_FLAG_HALF_CARRY | Z80_FLAG_ZERO | Z80_FLAG_SIGN); ! 8399: cpu.z80F |= bPostANDFlags[cpu.z80A]; ! 8400: ! 8401: break; ! 8402: } ! 8403: case 0xa7: ! 8404: { ! 8405: InvalidInstruction(2); ! 8406: break; ! 8407: } ! 8408: case 0xa8: ! 8409: { ! 8410: InvalidInstruction(2); ! 8411: break; ! 8412: } ! 8413: case 0xa9: ! 8414: { ! 8415: InvalidInstruction(2); ! 8416: break; ! 8417: } ! 8418: case 0xaa: ! 8419: { ! 8420: InvalidInstruction(2); ! 8421: break; ! 8422: } ! 8423: case 0xab: ! 8424: { ! 8425: InvalidInstruction(2); ! 8426: break; ! 8427: } ! 8428: case 0xac: ! 8429: { ! 8430: sdwCyclesRemaining -= 9; ! 8431: cpu.z80A ^= cpu.z80XH; ! 8432: cpu.z80F &= ~(Z80_FLAG_CARRY | Z80_FLAG_NEGATIVE | Z80_FLAG_OVERFLOW_PARITY | Z80_FLAG_HALF_CARRY | Z80_FLAG_ZERO | Z80_FLAG_SIGN); ! 8433: cpu.z80F |= bPostORFlags[cpu.z80A]; ! 8434: ! 8435: break; ! 8436: } ! 8437: case 0xad: ! 8438: { ! 8439: sdwCyclesRemaining -= 9; ! 8440: cpu.z80A ^= cpu.z80XL; ! 8441: cpu.z80F &= ~(Z80_FLAG_CARRY | Z80_FLAG_NEGATIVE | Z80_FLAG_OVERFLOW_PARITY | Z80_FLAG_HALF_CARRY | Z80_FLAG_ZERO | Z80_FLAG_SIGN); ! 8442: cpu.z80F |= bPostORFlags[cpu.z80A]; ! 8443: ! 8444: break; ! 8445: } ! 8446: case 0xae: ! 8447: { ! 8448: sdwCyclesRemaining -= 19; ! 8449: sdwAddr = (INT8) *pbPC++; /* Get LSB first */ ! 8450: dwAddr = (sdwAddr + (INT32) cpu.z80IX) & 0xffff; ! 8451: psMemRead = cpu.z80MemRead; /* Beginning of our handler */ ! 8452: while (psMemRead->lowAddr != 0xffffffff) ! 8453: { ! 8454: if ((dwAddr >= psMemRead->lowAddr) && (dwAddr <= psMemRead->highAddr)) ! 8455: { ! 8456: cpu.z80pc = (UINT32) pbPC - (UINT32) cpu.z80Base; ! 8457: if (psMemRead->memoryCall) ! 8458: { ! 8459: bTemp = psMemRead->memoryCall(dwAddr, psMemRead); ! 8460: } ! 8461: else ! 8462: { ! 8463: bTemp = *((UINT8 *) psMemRead->pUserArea + (dwAddr - psMemRead->lowAddr)); ! 8464: } ! 8465: psMemRead = NULL; ! 8466: break; ! 8467: } ! 8468: ++psMemRead; ! 8469: } ! 8470: ! 8471: if (psMemRead) ! 8472: { ! 8473: bTemp = cpu.z80Base[dwAddr]; ! 8474: } ! 8475: ! 8476: cpu.z80A ^= bTemp; ! 8477: cpu.z80F &= ~(Z80_FLAG_CARRY | Z80_FLAG_NEGATIVE | Z80_FLAG_OVERFLOW_PARITY | Z80_FLAG_HALF_CARRY | Z80_FLAG_ZERO | Z80_FLAG_SIGN); ! 8478: cpu.z80F |= bPostORFlags[cpu.z80A]; ! 8479: ! 8480: break; ! 8481: } ! 8482: case 0xaf: ! 8483: { ! 8484: InvalidInstruction(2); ! 8485: break; ! 8486: } ! 8487: case 0xb0: ! 8488: { ! 8489: InvalidInstruction(2); ! 8490: break; ! 8491: } ! 8492: case 0xb1: ! 8493: { ! 8494: InvalidInstruction(2); ! 8495: break; ! 8496: } ! 8497: case 0xb2: ! 8498: { ! 8499: InvalidInstruction(2); ! 8500: break; ! 8501: } ! 8502: case 0xb3: ! 8503: { ! 8504: InvalidInstruction(2); ! 8505: break; ! 8506: } ! 8507: case 0xb4: ! 8508: { ! 8509: sdwCyclesRemaining -= 9; ! 8510: cpu.z80A |= cpu.z80XH; ! 8511: cpu.z80F &= ~(Z80_FLAG_CARRY | Z80_FLAG_NEGATIVE | Z80_FLAG_OVERFLOW_PARITY | Z80_FLAG_HALF_CARRY | Z80_FLAG_ZERO | Z80_FLAG_SIGN); ! 8512: cpu.z80F |= bPostORFlags[cpu.z80A]; ! 8513: ! 8514: break; ! 8515: } ! 8516: case 0xb5: ! 8517: { ! 8518: sdwCyclesRemaining -= 9; ! 8519: cpu.z80A |= cpu.z80XL; ! 8520: cpu.z80F &= ~(Z80_FLAG_CARRY | Z80_FLAG_NEGATIVE | Z80_FLAG_OVERFLOW_PARITY | Z80_FLAG_HALF_CARRY | Z80_FLAG_ZERO | Z80_FLAG_SIGN); ! 8521: cpu.z80F |= bPostORFlags[cpu.z80A]; ! 8522: ! 8523: break; ! 8524: } ! 8525: case 0xb6: ! 8526: { ! 8527: sdwCyclesRemaining -= 19; ! 8528: sdwAddr = (INT8) *pbPC++; /* Get LSB first */ ! 8529: dwAddr = (sdwAddr + (INT32) cpu.z80IX) & 0xffff; ! 8530: psMemRead = cpu.z80MemRead; /* Beginning of our handler */ ! 8531: while (psMemRead->lowAddr != 0xffffffff) ! 8532: { ! 8533: if ((dwAddr >= psMemRead->lowAddr) && (dwAddr <= psMemRead->highAddr)) ! 8534: { ! 8535: cpu.z80pc = (UINT32) pbPC - (UINT32) cpu.z80Base; ! 8536: if (psMemRead->memoryCall) ! 8537: { ! 8538: bTemp = psMemRead->memoryCall(dwAddr, psMemRead); ! 8539: } ! 8540: else ! 8541: { ! 8542: bTemp = *((UINT8 *) psMemRead->pUserArea + (dwAddr - psMemRead->lowAddr)); ! 8543: } ! 8544: psMemRead = NULL; ! 8545: break; ! 8546: } ! 8547: ++psMemRead; ! 8548: } ! 8549: ! 8550: if (psMemRead) ! 8551: { ! 8552: bTemp = cpu.z80Base[dwAddr]; ! 8553: } ! 8554: ! 8555: cpu.z80A |= bTemp; ! 8556: cpu.z80F &= ~(Z80_FLAG_CARRY | Z80_FLAG_NEGATIVE | Z80_FLAG_OVERFLOW_PARITY | Z80_FLAG_HALF_CARRY | Z80_FLAG_ZERO | Z80_FLAG_SIGN); ! 8557: cpu.z80F |= bPostORFlags[cpu.z80A]; ! 8558: ! 8559: break; ! 8560: } ! 8561: case 0xb7: ! 8562: { ! 8563: InvalidInstruction(2); ! 8564: break; ! 8565: } ! 8566: case 0xb8: ! 8567: { ! 8568: InvalidInstruction(2); ! 8569: break; ! 8570: } ! 8571: case 0xb9: ! 8572: { ! 8573: InvalidInstruction(2); ! 8574: break; ! 8575: } ! 8576: case 0xba: ! 8577: { ! 8578: InvalidInstruction(2); ! 8579: break; ! 8580: } ! 8581: case 0xbb: ! 8582: { ! 8583: InvalidInstruction(2); ! 8584: break; ! 8585: } ! 8586: case 0xbc: ! 8587: { ! 8588: sdwCyclesRemaining -= 9; ! 8589: cpu.z80F &= ~(Z80_FLAG_CARRY | Z80_FLAG_NEGATIVE | Z80_FLAG_OVERFLOW_PARITY | Z80_FLAG_HALF_CARRY | Z80_FLAG_ZERO | Z80_FLAG_SIGN); ! 8590: cpu.z80F |= bPostORFlags[cpu.z80A]; ! 8591: ! 8592: break; ! 8593: } ! 8594: case 0xbd: ! 8595: { ! 8596: sdwCyclesRemaining -= 9; ! 8597: cpu.z80F &= ~(Z80_FLAG_CARRY | Z80_FLAG_NEGATIVE | Z80_FLAG_OVERFLOW_PARITY | Z80_FLAG_HALF_CARRY | Z80_FLAG_ZERO | Z80_FLAG_SIGN); ! 8598: cpu.z80F |= bPostORFlags[cpu.z80A]; ! 8599: ! 8600: break; ! 8601: } ! 8602: case 0xbe: ! 8603: { ! 8604: sdwCyclesRemaining -= 19; ! 8605: sdwAddr = (INT8) *pbPC++; /* Get LSB first */ ! 8606: dwAddr = (sdwAddr + (INT32) cpu.z80IX) & 0xffff; ! 8607: psMemRead = cpu.z80MemRead; /* Beginning of our handler */ ! 8608: while (psMemRead->lowAddr != 0xffffffff) ! 8609: { ! 8610: if ((dwAddr >= psMemRead->lowAddr) && (dwAddr <= psMemRead->highAddr)) ! 8611: { ! 8612: cpu.z80pc = (UINT32) pbPC - (UINT32) cpu.z80Base; ! 8613: if (psMemRead->memoryCall) ! 8614: { ! 8615: bTemp = psMemRead->memoryCall(dwAddr, psMemRead); ! 8616: } ! 8617: else ! 8618: { ! 8619: bTemp = *((UINT8 *) psMemRead->pUserArea + (dwAddr - psMemRead->lowAddr)); ! 8620: } ! 8621: psMemRead = NULL; ! 8622: break; ! 8623: } ! 8624: ++psMemRead; ! 8625: } ! 8626: ! 8627: if (psMemRead) ! 8628: { ! 8629: bTemp = cpu.z80Base[dwAddr]; ! 8630: } ! 8631: ! 8632: cpu.z80F = (cpu.z80F & ~(Z80_FLAG_CARRY | Z80_FLAG_NEGATIVE | Z80_FLAG_OVERFLOW_PARITY | ! 8633: Z80_FLAG_HALF_CARRY | Z80_FLAG_ZERO | Z80_FLAG_SIGN)) | ! 8634: pbSubSbcTable[((UINT32) cpu.z80A << 8) | bTemp]; ! 8635: break; ! 8636: } ! 8637: case 0xbf: ! 8638: { ! 8639: InvalidInstruction(2); ! 8640: break; ! 8641: } ! 8642: case 0xc0: ! 8643: { ! 8644: InvalidInstruction(2); ! 8645: break; ! 8646: } ! 8647: case 0xc1: ! 8648: { ! 8649: InvalidInstruction(2); ! 8650: break; ! 8651: } ! 8652: case 0xc2: ! 8653: { ! 8654: InvalidInstruction(2); ! 8655: break; ! 8656: } ! 8657: case 0xc3: ! 8658: { ! 8659: InvalidInstruction(2); ! 8660: break; ! 8661: } ! 8662: case 0xc4: ! 8663: { ! 8664: InvalidInstruction(2); ! 8665: break; ! 8666: } ! 8667: case 0xc5: ! 8668: { ! 8669: InvalidInstruction(2); ! 8670: break; ! 8671: } ! 8672: case 0xc6: ! 8673: { ! 8674: InvalidInstruction(2); ! 8675: break; ! 8676: } ! 8677: case 0xc7: ! 8678: { ! 8679: InvalidInstruction(2); ! 8680: break; ! 8681: } ! 8682: case 0xc8: ! 8683: { ! 8684: InvalidInstruction(2); ! 8685: break; ! 8686: } ! 8687: case 0xc9: ! 8688: { ! 8689: InvalidInstruction(2); ! 8690: break; ! 8691: } ! 8692: case 0xca: ! 8693: { ! 8694: InvalidInstruction(2); ! 8695: break; ! 8696: } ! 8697: case 0xcb: ! 8698: { ! 8699: DDFDCBHandler(0); ! 8700: break; ! 8701: } ! 8702: case 0xcc: ! 8703: { ! 8704: InvalidInstruction(2); ! 8705: break; ! 8706: } ! 8707: case 0xcd: ! 8708: { ! 8709: InvalidInstruction(2); ! 8710: break; ! 8711: } ! 8712: case 0xce: ! 8713: { ! 8714: InvalidInstruction(2); ! 8715: break; ! 8716: } ! 8717: case 0xcf: ! 8718: { ! 8719: InvalidInstruction(2); ! 8720: break; ! 8721: } ! 8722: case 0xd0: ! 8723: { ! 8724: InvalidInstruction(2); ! 8725: break; ! 8726: } ! 8727: case 0xd1: ! 8728: { ! 8729: InvalidInstruction(2); ! 8730: break; ! 8731: } ! 8732: case 0xd2: ! 8733: { ! 8734: InvalidInstruction(2); ! 8735: break; ! 8736: } ! 8737: case 0xd3: ! 8738: { ! 8739: InvalidInstruction(2); ! 8740: break; ! 8741: } ! 8742: case 0xd4: ! 8743: { ! 8744: InvalidInstruction(2); ! 8745: break; ! 8746: } ! 8747: case 0xd5: ! 8748: { ! 8749: InvalidInstruction(2); ! 8750: break; ! 8751: } ! 8752: case 0xd6: ! 8753: { ! 8754: InvalidInstruction(2); ! 8755: break; ! 8756: } ! 8757: case 0xd7: ! 8758: { ! 8759: InvalidInstruction(2); ! 8760: break; ! 8761: } ! 8762: case 0xd8: ! 8763: { ! 8764: InvalidInstruction(2); ! 8765: break; ! 8766: } ! 8767: case 0xd9: ! 8768: { ! 8769: InvalidInstruction(2); ! 8770: break; ! 8771: } ! 8772: case 0xda: ! 8773: { ! 8774: InvalidInstruction(2); ! 8775: break; ! 8776: } ! 8777: case 0xdb: ! 8778: { ! 8779: InvalidInstruction(2); ! 8780: break; ! 8781: } ! 8782: case 0xdc: ! 8783: { ! 8784: InvalidInstruction(2); ! 8785: break; ! 8786: } ! 8787: case 0xdd: ! 8788: { ! 8789: InvalidInstruction(2); ! 8790: break; ! 8791: } ! 8792: case 0xde: ! 8793: { ! 8794: InvalidInstruction(2); ! 8795: break; ! 8796: } ! 8797: case 0xdf: ! 8798: { ! 8799: InvalidInstruction(2); ! 8800: break; ! 8801: } ! 8802: case 0xe0: ! 8803: { ! 8804: InvalidInstruction(2); ! 8805: break; ! 8806: } ! 8807: case 0xe1: ! 8808: { ! 8809: sdwCyclesRemaining -= 14; ! 8810: psMemRead = cpu.z80MemRead; /* Beginning of our handler */ ! 8811: while (psMemRead->lowAddr != 0xffffffff) ! 8812: { ! 8813: if ((cpu.z80sp >= psMemRead->lowAddr) && (cpu.z80sp <= psMemRead->highAddr)) ! 8814: { ! 8815: cpu.z80pc = (UINT32) pbPC - (UINT32) cpu.z80Base; ! 8816: if (psMemRead->memoryCall) ! 8817: { ! 8818: cpu.z80IX = psMemRead->memoryCall(cpu.z80sp, psMemRead); ! 8819: cpu.z80IX |= (UINT32) ((UINT32) psMemRead->memoryCall(cpu.z80sp + 1, psMemRead) << 8); ! 8820: } ! 8821: else ! 8822: { ! 8823: cpu.z80IX = *((UINT8 *) psMemRead->pUserArea + (cpu.z80sp - psMemRead->lowAddr)); ! 8824: cpu.z80IX |= (UINT32) ((UINT32) *((UINT8 *) psMemRead->pUserArea + (cpu.z80sp - psMemRead->lowAddr + 1)) << 8); ! 8825: } ! 8826: psMemRead = NULL; ! 8827: break; ! 8828: } ! 8829: ++psMemRead; ! 8830: } ! 8831: ! 8832: if (psMemRead) ! 8833: { ! 8834: cpu.z80IX = cpu.z80Base[cpu.z80sp]; ! 8835: cpu.z80IX |= (UINT32) ((UINT32) cpu.z80Base[cpu.z80sp + 1] << 8); ! 8836: } ! 8837: ! 8838: cpu.z80sp += 2; ! 8839: pbSP = (cpu.z80Base + cpu.z80sp); /* Normalize the stack pointer */ ! 8840: break; ! 8841: } ! 8842: case 0xe2: ! 8843: { ! 8844: InvalidInstruction(2); ! 8845: break; ! 8846: } ! 8847: case 0xe3: ! 8848: { ! 8849: sdwCyclesRemaining -= 23; ! 8850: psMemRead = cpu.z80MemRead; /* Beginning of our handler */ ! 8851: while (psMemRead->lowAddr != 0xffffffff) ! 8852: { ! 8853: if ((cpu.z80sp >= psMemRead->lowAddr) && (cpu.z80sp <= psMemRead->highAddr)) ! 8854: { ! 8855: cpu.z80pc = (UINT32) pbPC - (UINT32) cpu.z80Base; ! 8856: if (psMemRead->memoryCall) ! 8857: { ! 8858: dwAddr = psMemRead->memoryCall(cpu.z80sp, psMemRead); ! 8859: dwAddr |= (UINT32) ((UINT32) psMemRead->memoryCall(cpu.z80sp + 1, psMemRead) << 8); ! 8860: } ! 8861: else ! 8862: { ! 8863: dwAddr = *((UINT8 *) psMemRead->pUserArea + (cpu.z80sp - psMemRead->lowAddr)); ! 8864: dwAddr |= (UINT32) ((UINT32) *((UINT8 *) psMemRead->pUserArea + (cpu.z80sp - psMemRead->lowAddr + 1)) << 8); ! 8865: } ! 8866: psMemRead = NULL; ! 8867: break; ! 8868: } ! 8869: ++psMemRead; ! 8870: } ! 8871: ! 8872: if (psMemRead) ! 8873: { ! 8874: dwAddr = cpu.z80Base[cpu.z80sp]; ! 8875: dwAddr |= (UINT32) ((UINT32) cpu.z80Base[cpu.z80sp + 1] << 8); ! 8876: } ! 8877: ! 8878: psMemWrite = cpu.z80MemWrite; /* Beginning of our handler */ ! 8879: while (psMemWrite->lowAddr != 0xffffffff) ! 8880: { ! 8881: if ((cpu.z80sp >= psMemWrite->lowAddr) && (cpu.z80sp <= psMemWrite->highAddr)) ! 8882: { ! 8883: cpu.z80pc = (UINT32) pbPC - (UINT32) cpu.z80Base; ! 8884: if (psMemWrite->memoryCall) ! 8885: { ! 8886: psMemWrite->memoryCall(cpu.z80sp, (cpu.z80IX & 0xff), psMemWrite); ! 8887: psMemWrite->memoryCall(cpu.z80sp + 1, (cpu.z80IX >> 8), psMemWrite); ! 8888: } ! 8889: else ! 8890: { ! 8891: *((UINT8 *) psMemWrite->pUserArea + (cpu.z80sp - psMemWrite->lowAddr)) = cpu.z80IX; ! 8892: *((UINT8 *) psMemWrite->pUserArea + (cpu.z80sp - psMemWrite->lowAddr) + 1) = cpu.z80IX >> 8; ! 8893: } ! 8894: psMemWrite = NULL; ! 8895: break; ! 8896: } ! 8897: ++psMemWrite; ! 8898: } ! 8899: ! 8900: if (psMemWrite) ! 8901: { ! 8902: cpu.z80Base[cpu.z80sp] = (UINT8) cpu.z80IX; ! 8903: cpu.z80Base[cpu.z80sp + 1] = (UINT8) ((UINT32) cpu.z80IX >> 8); ! 8904: } ! 8905: ! 8906: cpu.z80IX = dwAddr; ! 8907: break; ! 8908: } ! 8909: case 0xe4: ! 8910: { ! 8911: InvalidInstruction(2); ! 8912: break; ! 8913: } ! 8914: case 0xe5: ! 8915: { ! 8916: sdwCyclesRemaining -= 15; ! 8917: cpu.z80sp -= 2; ! 8918: pbSP = (cpu.z80Base + cpu.z80sp); /* Normalize the stack pointer */ ! 8919: psMemWrite = cpu.z80MemWrite; /* Beginning of our handler */ ! 8920: while (psMemWrite->lowAddr != 0xffffffff) ! 8921: { ! 8922: if ((cpu.z80sp >= psMemWrite->lowAddr) && (cpu.z80sp <= psMemWrite->highAddr)) ! 8923: { ! 8924: cpu.z80pc = (UINT32) pbPC - (UINT32) cpu.z80Base; ! 8925: if (psMemWrite->memoryCall) ! 8926: { ! 8927: psMemWrite->memoryCall(cpu.z80sp, (cpu.z80IX & 0xff), psMemWrite); ! 8928: psMemWrite->memoryCall(cpu.z80sp + 1, (cpu.z80IX >> 8), psMemWrite); ! 8929: } ! 8930: else ! 8931: { ! 8932: *((UINT8 *) psMemWrite->pUserArea + (cpu.z80sp - psMemWrite->lowAddr)) = cpu.z80IX; ! 8933: *((UINT8 *) psMemWrite->pUserArea + (cpu.z80sp - psMemWrite->lowAddr) + 1) = cpu.z80IX >> 8; ! 8934: } ! 8935: psMemWrite = NULL; ! 8936: break; ! 8937: } ! 8938: ++psMemWrite; ! 8939: } ! 8940: ! 8941: if (psMemWrite) ! 8942: { ! 8943: cpu.z80Base[cpu.z80sp] = (UINT8) cpu.z80IX; ! 8944: cpu.z80Base[cpu.z80sp + 1] = (UINT8) ((UINT32) cpu.z80IX >> 8); ! 8945: } ! 8946: ! 8947: break; ! 8948: } ! 8949: case 0xe6: ! 8950: { ! 8951: InvalidInstruction(2); ! 8952: break; ! 8953: } ! 8954: case 0xe7: ! 8955: { ! 8956: InvalidInstruction(2); ! 8957: break; ! 8958: } ! 8959: case 0xe8: ! 8960: { ! 8961: InvalidInstruction(2); ! 8962: break; ! 8963: } ! 8964: case 0xe9: ! 8965: { ! 8966: sdwCyclesRemaining -= 8; ! 8967: pbPC = cpu.z80Base + cpu.z80IX; ! 8968: break; ! 8969: } ! 8970: case 0xea: ! 8971: { ! 8972: InvalidInstruction(2); ! 8973: break; ! 8974: } ! 8975: case 0xeb: ! 8976: { ! 8977: InvalidInstruction(2); ! 8978: break; ! 8979: } ! 8980: case 0xec: ! 8981: { ! 8982: InvalidInstruction(2); ! 8983: break; ! 8984: } ! 8985: case 0xed: ! 8986: { ! 8987: InvalidInstruction(2); ! 8988: break; ! 8989: } ! 8990: case 0xee: ! 8991: { ! 8992: InvalidInstruction(2); ! 8993: break; ! 8994: } ! 8995: case 0xef: ! 8996: { ! 8997: InvalidInstruction(2); ! 8998: break; ! 8999: } ! 9000: case 0xf0: ! 9001: { ! 9002: InvalidInstruction(2); ! 9003: break; ! 9004: } ! 9005: case 0xf1: ! 9006: { ! 9007: InvalidInstruction(2); ! 9008: break; ! 9009: } ! 9010: case 0xf2: ! 9011: { ! 9012: InvalidInstruction(2); ! 9013: break; ! 9014: } ! 9015: case 0xf3: ! 9016: { ! 9017: InvalidInstruction(2); ! 9018: break; ! 9019: } ! 9020: case 0xf4: ! 9021: { ! 9022: InvalidInstruction(2); ! 9023: break; ! 9024: } ! 9025: case 0xf5: ! 9026: { ! 9027: InvalidInstruction(2); ! 9028: break; ! 9029: } ! 9030: case 0xf6: ! 9031: { ! 9032: InvalidInstruction(2); ! 9033: break; ! 9034: } ! 9035: case 0xf7: ! 9036: { ! 9037: InvalidInstruction(2); ! 9038: break; ! 9039: } ! 9040: case 0xf8: ! 9041: { ! 9042: InvalidInstruction(2); ! 9043: break; ! 9044: } ! 9045: case 0xf9: ! 9046: { ! 9047: sdwCyclesRemaining -= 10; ! 9048: cpu.z80sp = cpu.z80IX; ! 9049: break; ! 9050: } ! 9051: case 0xfa: ! 9052: { ! 9053: InvalidInstruction(2); ! 9054: break; ! 9055: } ! 9056: case 0xfb: ! 9057: { ! 9058: InvalidInstruction(2); ! 9059: break; ! 9060: } ! 9061: case 0xfc: ! 9062: { ! 9063: InvalidInstruction(2); ! 9064: break; ! 9065: } ! 9066: case 0xfd: ! 9067: { ! 9068: InvalidInstruction(2); ! 9069: break; ! 9070: } ! 9071: case 0xfe: ! 9072: { ! 9073: InvalidInstruction(2); ! 9074: break; ! 9075: } ! 9076: case 0xff: ! 9077: { ! 9078: InvalidInstruction(2); ! 9079: break; ! 9080: } ! 9081: } ! 9082: } ! 9083: void DDFDCBHandler(UINT32 dwWhich) ! 9084: { ! 9085: if (dwWhich) ! 9086: { ! 9087: dwAddr = (UINT32) ((INT32) cpu.z80IY + ((INT32) *pbPC++)) & 0xffff; ! 9088: } ! 9089: else ! 9090: { ! 9091: dwAddr = (UINT32) ((INT32) cpu.z80IX + ((INT32) *pbPC++)) & 0xffff; ! 9092: } ! 9093: ! 9094: psMemRead = cpu.z80MemRead; /* Beginning of our handler */ ! 9095: while (psMemRead->lowAddr != 0xffffffff) ! 9096: { ! 9097: if ((dwAddr >= psMemRead->lowAddr) && (dwAddr <= psMemRead->highAddr)) ! 9098: { ! 9099: cpu.z80pc = (UINT32) pbPC - (UINT32) cpu.z80Base; ! 9100: if (psMemRead->memoryCall) ! 9101: { ! 9102: bTemp = psMemRead->memoryCall(dwAddr, psMemRead); ! 9103: } ! 9104: else ! 9105: { ! 9106: bTemp = *((UINT8 *) psMemRead->pUserArea + (dwAddr - psMemRead->lowAddr)); ! 9107: } ! 9108: psMemRead = NULL; ! 9109: break; ! 9110: } ! 9111: ++psMemRead; ! 9112: } ! 9113: ! 9114: if (psMemRead) ! 9115: { ! 9116: bTemp = cpu.z80Base[dwAddr]; ! 9117: } ! 9118: ! 9119: switch (*pbPC++) ! 9120: { ! 9121: case 0x00: ! 9122: { ! 9123: InvalidInstruction(4); ! 9124: break; ! 9125: } ! 9126: case 0x01: ! 9127: { ! 9128: InvalidInstruction(4); ! 9129: break; ! 9130: } ! 9131: case 0x02: ! 9132: { ! 9133: InvalidInstruction(4); ! 9134: break; ! 9135: } ! 9136: case 0x03: ! 9137: { ! 9138: InvalidInstruction(4); ! 9139: break; ! 9140: } ! 9141: case 0x04: ! 9142: { ! 9143: InvalidInstruction(4); ! 9144: break; ! 9145: } ! 9146: case 0x05: ! 9147: { ! 9148: InvalidInstruction(4); ! 9149: break; ! 9150: } ! 9151: case 0x06: ! 9152: { ! 9153: sdwCyclesRemaining -= 23; ! 9154: cpu.z80F &= ~(Z80_FLAG_ZERO | Z80_FLAG_SIGN | Z80_FLAG_HALF_CARRY | Z80_FLAG_OVERFLOW_PARITY | Z80_FLAG_NEGATIVE | Z80_FLAG_CARRY); ! 9155: bTemp2 = (bTemp >> 7); ! 9156: bTemp = (bTemp << 1) | bTemp2; ! 9157: cpu.z80F |= bTemp2 | bPostORFlags[bTemp]; ! 9158: psMemWrite = cpu.z80MemWrite; /* Beginning of our handler */ ! 9159: while (psMemWrite->lowAddr != 0xffffffff) ! 9160: { ! 9161: if ((dwAddr >= psMemWrite->lowAddr) && (dwAddr <= psMemWrite->highAddr)) ! 9162: { ! 9163: cpu.z80pc = (UINT32) pbPC - (UINT32) cpu.z80Base; ! 9164: if (psMemWrite->memoryCall) ! 9165: { ! 9166: psMemWrite->memoryCall(dwAddr, bTemp, psMemWrite); ! 9167: } ! 9168: else ! 9169: { ! 9170: *((UINT8 *) psMemWrite->pUserArea + (dwAddr - psMemWrite->lowAddr)) = bTemp; ! 9171: } ! 9172: psMemWrite = NULL; ! 9173: break; ! 9174: } ! 9175: ++psMemWrite; ! 9176: } ! 9177: ! 9178: if (psMemWrite) ! 9179: { ! 9180: cpu.z80Base[dwAddr] = (UINT8) bTemp; ! 9181: } ! 9182: ! 9183: break; ! 9184: } ! 9185: case 0x07: ! 9186: { ! 9187: InvalidInstruction(4); ! 9188: break; ! 9189: } ! 9190: case 0x08: ! 9191: { ! 9192: InvalidInstruction(4); ! 9193: break; ! 9194: } ! 9195: case 0x09: ! 9196: { ! 9197: InvalidInstruction(4); ! 9198: break; ! 9199: } ! 9200: case 0x0a: ! 9201: { ! 9202: InvalidInstruction(4); ! 9203: break; ! 9204: } ! 9205: case 0x0b: ! 9206: { ! 9207: InvalidInstruction(4); ! 9208: break; ! 9209: } ! 9210: case 0x0c: ! 9211: { ! 9212: InvalidInstruction(4); ! 9213: break; ! 9214: } ! 9215: case 0x0d: ! 9216: { ! 9217: InvalidInstruction(4); ! 9218: break; ! 9219: } ! 9220: case 0x0e: ! 9221: { ! 9222: sdwCyclesRemaining -= 23; ! 9223: cpu.z80F &= ~(Z80_FLAG_ZERO | Z80_FLAG_SIGN | Z80_FLAG_HALF_CARRY | Z80_FLAG_OVERFLOW_PARITY | Z80_FLAG_NEGATIVE | Z80_FLAG_CARRY); ! 9224: cpu.z80F |= (bTemp & Z80_FLAG_CARRY); ! 9225: bTemp = (bTemp >> 1) | (bTemp << 7); ! 9226: cpu.z80F |= bPostORFlags[bTemp]; ! 9227: psMemWrite = cpu.z80MemWrite; /* Beginning of our handler */ ! 9228: while (psMemWrite->lowAddr != 0xffffffff) ! 9229: { ! 9230: if ((dwAddr >= psMemWrite->lowAddr) && (dwAddr <= psMemWrite->highAddr)) ! 9231: { ! 9232: cpu.z80pc = (UINT32) pbPC - (UINT32) cpu.z80Base; ! 9233: if (psMemWrite->memoryCall) ! 9234: { ! 9235: psMemWrite->memoryCall(dwAddr, bTemp, psMemWrite); ! 9236: } ! 9237: else ! 9238: { ! 9239: *((UINT8 *) psMemWrite->pUserArea + (dwAddr - psMemWrite->lowAddr)) = bTemp; ! 9240: } ! 9241: psMemWrite = NULL; ! 9242: break; ! 9243: } ! 9244: ++psMemWrite; ! 9245: } ! 9246: ! 9247: if (psMemWrite) ! 9248: { ! 9249: cpu.z80Base[dwAddr] = (UINT8) bTemp; ! 9250: } ! 9251: ! 9252: break; ! 9253: } ! 9254: case 0x0f: ! 9255: { ! 9256: InvalidInstruction(4); ! 9257: break; ! 9258: } ! 9259: case 0x10: ! 9260: { ! 9261: InvalidInstruction(4); ! 9262: break; ! 9263: } ! 9264: case 0x11: ! 9265: { ! 9266: InvalidInstruction(4); ! 9267: break; ! 9268: } ! 9269: case 0x12: ! 9270: { ! 9271: InvalidInstruction(4); ! 9272: break; ! 9273: } ! 9274: case 0x13: ! 9275: { ! 9276: InvalidInstruction(4); ! 9277: break; ! 9278: } ! 9279: case 0x14: ! 9280: { ! 9281: InvalidInstruction(4); ! 9282: break; ! 9283: } ! 9284: case 0x15: ! 9285: { ! 9286: InvalidInstruction(4); ! 9287: break; ! 9288: } ! 9289: case 0x16: ! 9290: { ! 9291: sdwCyclesRemaining -= 23; ! 9292: bTemp2 = cpu.z80F & Z80_FLAG_CARRY; ! 9293: cpu.z80F &= ~(Z80_FLAG_ZERO | Z80_FLAG_SIGN | Z80_FLAG_HALF_CARRY | Z80_FLAG_OVERFLOW_PARITY | Z80_FLAG_NEGATIVE | Z80_FLAG_CARRY); ! 9294: cpu.z80F |= (bTemp >> 7); ! 9295: bTemp = (bTemp << 1) | bTemp2; ! 9296: cpu.z80F |= bPostORFlags[bTemp]; ! 9297: psMemWrite = cpu.z80MemWrite; /* Beginning of our handler */ ! 9298: while (psMemWrite->lowAddr != 0xffffffff) ! 9299: { ! 9300: if ((dwAddr >= psMemWrite->lowAddr) && (dwAddr <= psMemWrite->highAddr)) ! 9301: { ! 9302: cpu.z80pc = (UINT32) pbPC - (UINT32) cpu.z80Base; ! 9303: if (psMemWrite->memoryCall) ! 9304: { ! 9305: psMemWrite->memoryCall(dwAddr, bTemp, psMemWrite); ! 9306: } ! 9307: else ! 9308: { ! 9309: *((UINT8 *) psMemWrite->pUserArea + (dwAddr - psMemWrite->lowAddr)) = bTemp; ! 9310: } ! 9311: psMemWrite = NULL; ! 9312: break; ! 9313: } ! 9314: ++psMemWrite; ! 9315: } ! 9316: ! 9317: if (psMemWrite) ! 9318: { ! 9319: cpu.z80Base[dwAddr] = (UINT8) bTemp; ! 9320: } ! 9321: ! 9322: break; ! 9323: } ! 9324: case 0x17: ! 9325: { ! 9326: InvalidInstruction(4); ! 9327: break; ! 9328: } ! 9329: case 0x18: ! 9330: { ! 9331: InvalidInstruction(4); ! 9332: break; ! 9333: } ! 9334: case 0x19: ! 9335: { ! 9336: InvalidInstruction(4); ! 9337: break; ! 9338: } ! 9339: case 0x1a: ! 9340: { ! 9341: InvalidInstruction(4); ! 9342: break; ! 9343: } ! 9344: case 0x1b: ! 9345: { ! 9346: InvalidInstruction(4); ! 9347: break; ! 9348: } ! 9349: case 0x1c: ! 9350: { ! 9351: InvalidInstruction(4); ! 9352: break; ! 9353: } ! 9354: case 0x1d: ! 9355: { ! 9356: InvalidInstruction(4); ! 9357: break; ! 9358: } ! 9359: case 0x1e: ! 9360: { ! 9361: sdwCyclesRemaining -= 23; ! 9362: bTemp2 = (cpu.z80F & Z80_FLAG_CARRY) << 7; ! 9363: cpu.z80F &= ~(Z80_FLAG_ZERO | Z80_FLAG_SIGN | Z80_FLAG_HALF_CARRY | Z80_FLAG_OVERFLOW_PARITY | Z80_FLAG_NEGATIVE | Z80_FLAG_CARRY); ! 9364: cpu.z80F |= (bTemp & Z80_FLAG_CARRY); ! 9365: bTemp = (bTemp >> 1) | bTemp2; ! 9366: cpu.z80F |= bPostORFlags[bTemp]; ! 9367: psMemWrite = cpu.z80MemWrite; /* Beginning of our handler */ ! 9368: while (psMemWrite->lowAddr != 0xffffffff) ! 9369: { ! 9370: if ((dwAddr >= psMemWrite->lowAddr) && (dwAddr <= psMemWrite->highAddr)) ! 9371: { ! 9372: cpu.z80pc = (UINT32) pbPC - (UINT32) cpu.z80Base; ! 9373: if (psMemWrite->memoryCall) ! 9374: { ! 9375: psMemWrite->memoryCall(dwAddr, bTemp, psMemWrite); ! 9376: } ! 9377: else ! 9378: { ! 9379: *((UINT8 *) psMemWrite->pUserArea + (dwAddr - psMemWrite->lowAddr)) = bTemp; ! 9380: } ! 9381: psMemWrite = NULL; ! 9382: break; ! 9383: } ! 9384: ++psMemWrite; ! 9385: } ! 9386: ! 9387: if (psMemWrite) ! 9388: { ! 9389: cpu.z80Base[dwAddr] = (UINT8) bTemp; ! 9390: } ! 9391: ! 9392: break; ! 9393: } ! 9394: case 0x1f: ! 9395: { ! 9396: InvalidInstruction(4); ! 9397: break; ! 9398: } ! 9399: case 0x20: ! 9400: { ! 9401: InvalidInstruction(4); ! 9402: break; ! 9403: } ! 9404: case 0x21: ! 9405: { ! 9406: InvalidInstruction(4); ! 9407: break; ! 9408: } ! 9409: case 0x22: ! 9410: { ! 9411: InvalidInstruction(4); ! 9412: break; ! 9413: } ! 9414: case 0x23: ! 9415: { ! 9416: InvalidInstruction(4); ! 9417: break; ! 9418: } ! 9419: case 0x24: ! 9420: { ! 9421: InvalidInstruction(4); ! 9422: break; ! 9423: } ! 9424: case 0x25: ! 9425: { ! 9426: InvalidInstruction(4); ! 9427: break; ! 9428: } ! 9429: case 0x26: ! 9430: { ! 9431: sdwCyclesRemaining -= 23; ! 9432: cpu.z80F &= ~(Z80_FLAG_ZERO | Z80_FLAG_SIGN | Z80_FLAG_HALF_CARRY | Z80_FLAG_OVERFLOW_PARITY | Z80_FLAG_NEGATIVE | Z80_FLAG_CARRY); ! 9433: cpu.z80F |= (bTemp >> 7); ! 9434: bTemp = (bTemp << 1); ! 9435: cpu.z80F |= bPostORFlags[bTemp]; ! 9436: psMemWrite = cpu.z80MemWrite; /* Beginning of our handler */ ! 9437: while (psMemWrite->lowAddr != 0xffffffff) ! 9438: { ! 9439: if ((dwAddr >= psMemWrite->lowAddr) && (dwAddr <= psMemWrite->highAddr)) ! 9440: { ! 9441: cpu.z80pc = (UINT32) pbPC - (UINT32) cpu.z80Base; ! 9442: if (psMemWrite->memoryCall) ! 9443: { ! 9444: psMemWrite->memoryCall(dwAddr, bTemp, psMemWrite); ! 9445: } ! 9446: else ! 9447: { ! 9448: *((UINT8 *) psMemWrite->pUserArea + (dwAddr - psMemWrite->lowAddr)) = bTemp; ! 9449: } ! 9450: psMemWrite = NULL; ! 9451: break; ! 9452: } ! 9453: ++psMemWrite; ! 9454: } ! 9455: ! 9456: if (psMemWrite) ! 9457: { ! 9458: cpu.z80Base[dwAddr] = (UINT8) bTemp; ! 9459: } ! 9460: ! 9461: break; ! 9462: } ! 9463: case 0x27: ! 9464: { ! 9465: InvalidInstruction(4); ! 9466: break; ! 9467: } ! 9468: case 0x28: ! 9469: { ! 9470: InvalidInstruction(4); ! 9471: break; ! 9472: } ! 9473: case 0x29: ! 9474: { ! 9475: InvalidInstruction(4); ! 9476: break; ! 9477: } ! 9478: case 0x2a: ! 9479: { ! 9480: InvalidInstruction(4); ! 9481: break; ! 9482: } ! 9483: case 0x2b: ! 9484: { ! 9485: InvalidInstruction(4); ! 9486: break; ! 9487: } ! 9488: case 0x2c: ! 9489: { ! 9490: InvalidInstruction(4); ! 9491: break; ! 9492: } ! 9493: case 0x2d: ! 9494: { ! 9495: InvalidInstruction(4); ! 9496: break; ! 9497: } ! 9498: case 0x2e: ! 9499: { ! 9500: sdwCyclesRemaining -= 23; ! 9501: cpu.z80F &= ~(Z80_FLAG_ZERO | Z80_FLAG_SIGN | Z80_FLAG_HALF_CARRY | Z80_FLAG_OVERFLOW_PARITY | Z80_FLAG_NEGATIVE | Z80_FLAG_CARRY); ! 9502: cpu.z80F |= (bTemp & Z80_FLAG_CARRY); ! 9503: bTemp = (bTemp >> 1) | (bTemp & 0x80); ! 9504: cpu.z80F |= bPostORFlags[bTemp]; ! 9505: psMemWrite = cpu.z80MemWrite; /* Beginning of our handler */ ! 9506: while (psMemWrite->lowAddr != 0xffffffff) ! 9507: { ! 9508: if ((dwAddr >= psMemWrite->lowAddr) && (dwAddr <= psMemWrite->highAddr)) ! 9509: { ! 9510: cpu.z80pc = (UINT32) pbPC - (UINT32) cpu.z80Base; ! 9511: if (psMemWrite->memoryCall) ! 9512: { ! 9513: psMemWrite->memoryCall(dwAddr, bTemp, psMemWrite); ! 9514: } ! 9515: else ! 9516: { ! 9517: *((UINT8 *) psMemWrite->pUserArea + (dwAddr - psMemWrite->lowAddr)) = bTemp; ! 9518: } ! 9519: psMemWrite = NULL; ! 9520: break; ! 9521: } ! 9522: ++psMemWrite; ! 9523: } ! 9524: ! 9525: if (psMemWrite) ! 9526: { ! 9527: cpu.z80Base[dwAddr] = (UINT8) bTemp; ! 9528: } ! 9529: ! 9530: break; ! 9531: } ! 9532: case 0x2f: ! 9533: { ! 9534: InvalidInstruction(4); ! 9535: break; ! 9536: } ! 9537: case 0x30: ! 9538: { ! 9539: InvalidInstruction(4); ! 9540: break; ! 9541: } ! 9542: case 0x31: ! 9543: { ! 9544: InvalidInstruction(4); ! 9545: break; ! 9546: } ! 9547: case 0x32: ! 9548: { ! 9549: InvalidInstruction(4); ! 9550: break; ! 9551: } ! 9552: case 0x33: ! 9553: { ! 9554: InvalidInstruction(4); ! 9555: break; ! 9556: } ! 9557: case 0x34: ! 9558: { ! 9559: InvalidInstruction(4); ! 9560: break; ! 9561: } ! 9562: case 0x35: ! 9563: { ! 9564: InvalidInstruction(4); ! 9565: break; ! 9566: } ! 9567: case 0x36: ! 9568: { ! 9569: sdwCyclesRemaining -= 23; ! 9570: InvalidInstruction(4); ! 9571: break; ! 9572: } ! 9573: case 0x37: ! 9574: { ! 9575: InvalidInstruction(4); ! 9576: break; ! 9577: } ! 9578: case 0x38: ! 9579: { ! 9580: InvalidInstruction(4); ! 9581: break; ! 9582: } ! 9583: case 0x39: ! 9584: { ! 9585: InvalidInstruction(4); ! 9586: break; ! 9587: } ! 9588: case 0x3a: ! 9589: { ! 9590: InvalidInstruction(4); ! 9591: break; ! 9592: } ! 9593: case 0x3b: ! 9594: { ! 9595: InvalidInstruction(4); ! 9596: break; ! 9597: } ! 9598: case 0x3c: ! 9599: { ! 9600: InvalidInstruction(4); ! 9601: break; ! 9602: } ! 9603: case 0x3d: ! 9604: { ! 9605: InvalidInstruction(4); ! 9606: break; ! 9607: } ! 9608: case 0x3e: ! 9609: { ! 9610: sdwCyclesRemaining -= 23; ! 9611: cpu.z80F &= ~(Z80_FLAG_ZERO | Z80_FLAG_SIGN | Z80_FLAG_HALF_CARRY | Z80_FLAG_OVERFLOW_PARITY | Z80_FLAG_NEGATIVE | Z80_FLAG_CARRY); ! 9612: cpu.z80F |= (bTemp & Z80_FLAG_CARRY); ! 9613: bTemp = (bTemp >> 1); ! 9614: cpu.z80F |= bPostORFlags[bTemp]; ! 9615: psMemWrite = cpu.z80MemWrite; /* Beginning of our handler */ ! 9616: while (psMemWrite->lowAddr != 0xffffffff) ! 9617: { ! 9618: if ((dwAddr >= psMemWrite->lowAddr) && (dwAddr <= psMemWrite->highAddr)) ! 9619: { ! 9620: cpu.z80pc = (UINT32) pbPC - (UINT32) cpu.z80Base; ! 9621: if (psMemWrite->memoryCall) ! 9622: { ! 9623: psMemWrite->memoryCall(dwAddr, bTemp, psMemWrite); ! 9624: } ! 9625: else ! 9626: { ! 9627: *((UINT8 *) psMemWrite->pUserArea + (dwAddr - psMemWrite->lowAddr)) = bTemp; ! 9628: } ! 9629: psMemWrite = NULL; ! 9630: break; ! 9631: } ! 9632: ++psMemWrite; ! 9633: } ! 9634: ! 9635: if (psMemWrite) ! 9636: { ! 9637: cpu.z80Base[dwAddr] = (UINT8) bTemp; ! 9638: } ! 9639: ! 9640: break; ! 9641: } ! 9642: case 0x3f: ! 9643: { ! 9644: InvalidInstruction(4); ! 9645: break; ! 9646: } ! 9647: case 0x40: ! 9648: { ! 9649: sdwCyclesRemaining -= 20; ! 9650: InvalidInstruction(4); ! 9651: break; ! 9652: } ! 9653: case 0x41: ! 9654: { ! 9655: sdwCyclesRemaining -= 20; ! 9656: InvalidInstruction(4); ! 9657: break; ! 9658: } ! 9659: case 0x42: ! 9660: { ! 9661: sdwCyclesRemaining -= 20; ! 9662: InvalidInstruction(4); ! 9663: break; ! 9664: } ! 9665: case 0x43: ! 9666: { ! 9667: sdwCyclesRemaining -= 20; ! 9668: InvalidInstruction(4); ! 9669: break; ! 9670: } ! 9671: case 0x44: ! 9672: { ! 9673: sdwCyclesRemaining -= 20; ! 9674: InvalidInstruction(4); ! 9675: break; ! 9676: } ! 9677: case 0x45: ! 9678: { ! 9679: sdwCyclesRemaining -= 20; ! 9680: InvalidInstruction(4); ! 9681: break; ! 9682: } ! 9683: case 0x46: ! 9684: { ! 9685: sdwCyclesRemaining -= 20; ! 9686: cpu.z80F = (cpu.z80F & ~(Z80_FLAG_ZERO | Z80_FLAG_NEGATIVE)) | Z80_FLAG_HALF_CARRY; ! 9687: if (!(bTemp & 0x01)) ! 9688: { ! 9689: cpu.z80F |= Z80_FLAG_ZERO; ! 9690: } ! 9691: break; ! 9692: } ! 9693: case 0x47: ! 9694: { ! 9695: sdwCyclesRemaining -= 20; ! 9696: InvalidInstruction(4); ! 9697: break; ! 9698: } ! 9699: case 0x48: ! 9700: { ! 9701: sdwCyclesRemaining -= 20; ! 9702: InvalidInstruction(4); ! 9703: break; ! 9704: } ! 9705: case 0x49: ! 9706: { ! 9707: sdwCyclesRemaining -= 20; ! 9708: InvalidInstruction(4); ! 9709: break; ! 9710: } ! 9711: case 0x4a: ! 9712: { ! 9713: sdwCyclesRemaining -= 20; ! 9714: InvalidInstruction(4); ! 9715: break; ! 9716: } ! 9717: case 0x4b: ! 9718: { ! 9719: sdwCyclesRemaining -= 20; ! 9720: InvalidInstruction(4); ! 9721: break; ! 9722: } ! 9723: case 0x4c: ! 9724: { ! 9725: sdwCyclesRemaining -= 20; ! 9726: InvalidInstruction(4); ! 9727: break; ! 9728: } ! 9729: case 0x4d: ! 9730: { ! 9731: sdwCyclesRemaining -= 20; ! 9732: InvalidInstruction(4); ! 9733: break; ! 9734: } ! 9735: case 0x4e: ! 9736: { ! 9737: sdwCyclesRemaining -= 20; ! 9738: cpu.z80F = (cpu.z80F & ~(Z80_FLAG_ZERO | Z80_FLAG_NEGATIVE)) | Z80_FLAG_HALF_CARRY; ! 9739: if (!(bTemp & 0x02)) ! 9740: { ! 9741: cpu.z80F |= Z80_FLAG_ZERO; ! 9742: } ! 9743: break; ! 9744: } ! 9745: case 0x4f: ! 9746: { ! 9747: sdwCyclesRemaining -= 20; ! 9748: InvalidInstruction(4); ! 9749: break; ! 9750: } ! 9751: case 0x50: ! 9752: { ! 9753: sdwCyclesRemaining -= 20; ! 9754: InvalidInstruction(4); ! 9755: break; ! 9756: } ! 9757: case 0x51: ! 9758: { ! 9759: sdwCyclesRemaining -= 20; ! 9760: InvalidInstruction(4); ! 9761: break; ! 9762: } ! 9763: case 0x52: ! 9764: { ! 9765: sdwCyclesRemaining -= 20; ! 9766: InvalidInstruction(4); ! 9767: break; ! 9768: } ! 9769: case 0x53: ! 9770: { ! 9771: sdwCyclesRemaining -= 20; ! 9772: InvalidInstruction(4); ! 9773: break; ! 9774: } ! 9775: case 0x54: ! 9776: { ! 9777: sdwCyclesRemaining -= 20; ! 9778: InvalidInstruction(4); ! 9779: break; ! 9780: } ! 9781: case 0x55: ! 9782: { ! 9783: sdwCyclesRemaining -= 20; ! 9784: InvalidInstruction(4); ! 9785: break; ! 9786: } ! 9787: case 0x56: ! 9788: { ! 9789: sdwCyclesRemaining -= 20; ! 9790: cpu.z80F = (cpu.z80F & ~(Z80_FLAG_ZERO | Z80_FLAG_NEGATIVE)) | Z80_FLAG_HALF_CARRY; ! 9791: if (!(bTemp & 0x04)) ! 9792: { ! 9793: cpu.z80F |= Z80_FLAG_ZERO; ! 9794: } ! 9795: break; ! 9796: } ! 9797: case 0x57: ! 9798: { ! 9799: sdwCyclesRemaining -= 20; ! 9800: InvalidInstruction(4); ! 9801: break; ! 9802: } ! 9803: case 0x58: ! 9804: { ! 9805: sdwCyclesRemaining -= 20; ! 9806: InvalidInstruction(4); ! 9807: break; ! 9808: } ! 9809: case 0x59: ! 9810: { ! 9811: sdwCyclesRemaining -= 20; ! 9812: InvalidInstruction(4); ! 9813: break; ! 9814: } ! 9815: case 0x5a: ! 9816: { ! 9817: sdwCyclesRemaining -= 20; ! 9818: InvalidInstruction(4); ! 9819: break; ! 9820: } ! 9821: case 0x5b: ! 9822: { ! 9823: sdwCyclesRemaining -= 20; ! 9824: InvalidInstruction(4); ! 9825: break; ! 9826: } ! 9827: case 0x5c: ! 9828: { ! 9829: sdwCyclesRemaining -= 20; ! 9830: InvalidInstruction(4); ! 9831: break; ! 9832: } ! 9833: case 0x5d: ! 9834: { ! 9835: sdwCyclesRemaining -= 20; ! 9836: InvalidInstruction(4); ! 9837: break; ! 9838: } ! 9839: case 0x5e: ! 9840: { ! 9841: sdwCyclesRemaining -= 20; ! 9842: cpu.z80F = (cpu.z80F & ~(Z80_FLAG_ZERO | Z80_FLAG_NEGATIVE)) | Z80_FLAG_HALF_CARRY; ! 9843: if (!(bTemp & 0x08)) ! 9844: { ! 9845: cpu.z80F |= Z80_FLAG_ZERO; ! 9846: } ! 9847: break; ! 9848: } ! 9849: case 0x5f: ! 9850: { ! 9851: sdwCyclesRemaining -= 20; ! 9852: InvalidInstruction(4); ! 9853: break; ! 9854: } ! 9855: case 0x60: ! 9856: { ! 9857: sdwCyclesRemaining -= 20; ! 9858: InvalidInstruction(4); ! 9859: break; ! 9860: } ! 9861: case 0x61: ! 9862: { ! 9863: sdwCyclesRemaining -= 20; ! 9864: InvalidInstruction(4); ! 9865: break; ! 9866: } ! 9867: case 0x62: ! 9868: { ! 9869: sdwCyclesRemaining -= 20; ! 9870: InvalidInstruction(4); ! 9871: break; ! 9872: } ! 9873: case 0x63: ! 9874: { ! 9875: sdwCyclesRemaining -= 20; ! 9876: InvalidInstruction(4); ! 9877: break; ! 9878: } ! 9879: case 0x64: ! 9880: { ! 9881: sdwCyclesRemaining -= 20; ! 9882: InvalidInstruction(4); ! 9883: break; ! 9884: } ! 9885: case 0x65: ! 9886: { ! 9887: sdwCyclesRemaining -= 20; ! 9888: InvalidInstruction(4); ! 9889: break; ! 9890: } ! 9891: case 0x66: ! 9892: { ! 9893: sdwCyclesRemaining -= 20; ! 9894: cpu.z80F = (cpu.z80F & ~(Z80_FLAG_ZERO | Z80_FLAG_NEGATIVE)) | Z80_FLAG_HALF_CARRY; ! 9895: if (!(bTemp & 0x10)) ! 9896: { ! 9897: cpu.z80F |= Z80_FLAG_ZERO; ! 9898: } ! 9899: break; ! 9900: } ! 9901: case 0x67: ! 9902: { ! 9903: sdwCyclesRemaining -= 20; ! 9904: InvalidInstruction(4); ! 9905: break; ! 9906: } ! 9907: case 0x68: ! 9908: { ! 9909: sdwCyclesRemaining -= 20; ! 9910: InvalidInstruction(4); ! 9911: break; ! 9912: } ! 9913: case 0x69: ! 9914: { ! 9915: sdwCyclesRemaining -= 20; ! 9916: InvalidInstruction(4); ! 9917: break; ! 9918: } ! 9919: case 0x6a: ! 9920: { ! 9921: sdwCyclesRemaining -= 20; ! 9922: InvalidInstruction(4); ! 9923: break; ! 9924: } ! 9925: case 0x6b: ! 9926: { ! 9927: sdwCyclesRemaining -= 20; ! 9928: InvalidInstruction(4); ! 9929: break; ! 9930: } ! 9931: case 0x6c: ! 9932: { ! 9933: sdwCyclesRemaining -= 20; ! 9934: InvalidInstruction(4); ! 9935: break; ! 9936: } ! 9937: case 0x6d: ! 9938: { ! 9939: sdwCyclesRemaining -= 20; ! 9940: InvalidInstruction(4); ! 9941: break; ! 9942: } ! 9943: case 0x6e: ! 9944: { ! 9945: sdwCyclesRemaining -= 20; ! 9946: cpu.z80F = (cpu.z80F & ~(Z80_FLAG_ZERO | Z80_FLAG_NEGATIVE)) | Z80_FLAG_HALF_CARRY; ! 9947: if (!(bTemp & 0x20)) ! 9948: { ! 9949: cpu.z80F |= Z80_FLAG_ZERO; ! 9950: } ! 9951: break; ! 9952: } ! 9953: case 0x6f: ! 9954: { ! 9955: sdwCyclesRemaining -= 20; ! 9956: InvalidInstruction(4); ! 9957: break; ! 9958: } ! 9959: case 0x70: ! 9960: { ! 9961: sdwCyclesRemaining -= 20; ! 9962: InvalidInstruction(4); ! 9963: break; ! 9964: } ! 9965: case 0x71: ! 9966: { ! 9967: sdwCyclesRemaining -= 20; ! 9968: InvalidInstruction(4); ! 9969: break; ! 9970: } ! 9971: case 0x72: ! 9972: { ! 9973: sdwCyclesRemaining -= 20; ! 9974: InvalidInstruction(4); ! 9975: break; ! 9976: } ! 9977: case 0x73: ! 9978: { ! 9979: sdwCyclesRemaining -= 20; ! 9980: InvalidInstruction(4); ! 9981: break; ! 9982: } ! 9983: case 0x74: ! 9984: { ! 9985: sdwCyclesRemaining -= 20; ! 9986: InvalidInstruction(4); ! 9987: break; ! 9988: } ! 9989: case 0x75: ! 9990: { ! 9991: sdwCyclesRemaining -= 20; ! 9992: InvalidInstruction(4); ! 9993: break; ! 9994: } ! 9995: case 0x76: ! 9996: { ! 9997: sdwCyclesRemaining -= 20; ! 9998: cpu.z80F = (cpu.z80F & ~(Z80_FLAG_ZERO | Z80_FLAG_NEGATIVE)) | Z80_FLAG_HALF_CARRY; ! 9999: if (!(bTemp & 0x40)) ! 10000: { ! 10001: cpu.z80F |= Z80_FLAG_ZERO; ! 10002: } ! 10003: break; ! 10004: } ! 10005: case 0x77: ! 10006: { ! 10007: sdwCyclesRemaining -= 20; ! 10008: InvalidInstruction(4); ! 10009: break; ! 10010: } ! 10011: case 0x78: ! 10012: { ! 10013: sdwCyclesRemaining -= 20; ! 10014: InvalidInstruction(4); ! 10015: break; ! 10016: } ! 10017: case 0x79: ! 10018: { ! 10019: sdwCyclesRemaining -= 20; ! 10020: InvalidInstruction(4); ! 10021: break; ! 10022: } ! 10023: case 0x7a: ! 10024: { ! 10025: sdwCyclesRemaining -= 20; ! 10026: InvalidInstruction(4); ! 10027: break; ! 10028: } ! 10029: case 0x7b: ! 10030: { ! 10031: sdwCyclesRemaining -= 20; ! 10032: InvalidInstruction(4); ! 10033: break; ! 10034: } ! 10035: case 0x7c: ! 10036: { ! 10037: sdwCyclesRemaining -= 20; ! 10038: InvalidInstruction(4); ! 10039: break; ! 10040: } ! 10041: case 0x7d: ! 10042: { ! 10043: sdwCyclesRemaining -= 20; ! 10044: InvalidInstruction(4); ! 10045: break; ! 10046: } ! 10047: case 0x7e: ! 10048: { ! 10049: sdwCyclesRemaining -= 20; ! 10050: cpu.z80F = (cpu.z80F & ~(Z80_FLAG_ZERO | Z80_FLAG_NEGATIVE)) | Z80_FLAG_HALF_CARRY; ! 10051: if (!(bTemp & 0x80)) ! 10052: { ! 10053: cpu.z80F |= Z80_FLAG_ZERO; ! 10054: } ! 10055: break; ! 10056: } ! 10057: case 0x7f: ! 10058: { ! 10059: sdwCyclesRemaining -= 20; ! 10060: InvalidInstruction(4); ! 10061: break; ! 10062: } ! 10063: case 0x80: ! 10064: { ! 10065: InvalidInstruction(4); ! 10066: break; ! 10067: } ! 10068: case 0x81: ! 10069: { ! 10070: InvalidInstruction(4); ! 10071: break; ! 10072: } ! 10073: case 0x82: ! 10074: { ! 10075: InvalidInstruction(4); ! 10076: break; ! 10077: } ! 10078: case 0x83: ! 10079: { ! 10080: InvalidInstruction(4); ! 10081: break; ! 10082: } ! 10083: case 0x84: ! 10084: { ! 10085: InvalidInstruction(4); ! 10086: break; ! 10087: } ! 10088: case 0x85: ! 10089: { ! 10090: InvalidInstruction(4); ! 10091: break; ! 10092: } ! 10093: case 0x86: ! 10094: { ! 10095: sdwCyclesRemaining -= 23; ! 10096: bTemp &= 0xfe; ! 10097: psMemWrite = cpu.z80MemWrite; /* Beginning of our handler */ ! 10098: while (psMemWrite->lowAddr != 0xffffffff) ! 10099: { ! 10100: if ((dwAddr >= psMemWrite->lowAddr) && (dwAddr <= psMemWrite->highAddr)) ! 10101: { ! 10102: cpu.z80pc = (UINT32) pbPC - (UINT32) cpu.z80Base; ! 10103: if (psMemWrite->memoryCall) ! 10104: { ! 10105: psMemWrite->memoryCall(dwAddr, bTemp, psMemWrite); ! 10106: } ! 10107: else ! 10108: { ! 10109: *((UINT8 *) psMemWrite->pUserArea + (dwAddr - psMemWrite->lowAddr)) = bTemp; ! 10110: } ! 10111: psMemWrite = NULL; ! 10112: break; ! 10113: } ! 10114: ++psMemWrite; ! 10115: } ! 10116: ! 10117: if (psMemWrite) ! 10118: { ! 10119: cpu.z80Base[dwAddr] = (UINT8) bTemp; ! 10120: } ! 10121: ! 10122: break; ! 10123: } ! 10124: case 0x87: ! 10125: { ! 10126: InvalidInstruction(4); ! 10127: break; ! 10128: } ! 10129: case 0x88: ! 10130: { ! 10131: InvalidInstruction(4); ! 10132: break; ! 10133: } ! 10134: case 0x89: ! 10135: { ! 10136: InvalidInstruction(4); ! 10137: break; ! 10138: } ! 10139: case 0x8a: ! 10140: { ! 10141: InvalidInstruction(4); ! 10142: break; ! 10143: } ! 10144: case 0x8b: ! 10145: { ! 10146: InvalidInstruction(4); ! 10147: break; ! 10148: } ! 10149: case 0x8c: ! 10150: { ! 10151: InvalidInstruction(4); ! 10152: break; ! 10153: } ! 10154: case 0x8d: ! 10155: { ! 10156: InvalidInstruction(4); ! 10157: break; ! 10158: } ! 10159: case 0x8e: ! 10160: { ! 10161: sdwCyclesRemaining -= 23; ! 10162: bTemp &= 0xfd; ! 10163: psMemWrite = cpu.z80MemWrite; /* Beginning of our handler */ ! 10164: while (psMemWrite->lowAddr != 0xffffffff) ! 10165: { ! 10166: if ((dwAddr >= psMemWrite->lowAddr) && (dwAddr <= psMemWrite->highAddr)) ! 10167: { ! 10168: cpu.z80pc = (UINT32) pbPC - (UINT32) cpu.z80Base; ! 10169: if (psMemWrite->memoryCall) ! 10170: { ! 10171: psMemWrite->memoryCall(dwAddr, bTemp, psMemWrite); ! 10172: } ! 10173: else ! 10174: { ! 10175: *((UINT8 *) psMemWrite->pUserArea + (dwAddr - psMemWrite->lowAddr)) = bTemp; ! 10176: } ! 10177: psMemWrite = NULL; ! 10178: break; ! 10179: } ! 10180: ++psMemWrite; ! 10181: } ! 10182: ! 10183: if (psMemWrite) ! 10184: { ! 10185: cpu.z80Base[dwAddr] = (UINT8) bTemp; ! 10186: } ! 10187: ! 10188: break; ! 10189: } ! 10190: case 0x8f: ! 10191: { ! 10192: InvalidInstruction(4); ! 10193: break; ! 10194: } ! 10195: case 0x90: ! 10196: { ! 10197: InvalidInstruction(4); ! 10198: break; ! 10199: } ! 10200: case 0x91: ! 10201: { ! 10202: InvalidInstruction(4); ! 10203: break; ! 10204: } ! 10205: case 0x92: ! 10206: { ! 10207: InvalidInstruction(4); ! 10208: break; ! 10209: } ! 10210: case 0x93: ! 10211: { ! 10212: InvalidInstruction(4); ! 10213: break; ! 10214: } ! 10215: case 0x94: ! 10216: { ! 10217: InvalidInstruction(4); ! 10218: break; ! 10219: } ! 10220: case 0x95: ! 10221: { ! 10222: InvalidInstruction(4); ! 10223: break; ! 10224: } ! 10225: case 0x96: ! 10226: { ! 10227: sdwCyclesRemaining -= 23; ! 10228: bTemp &= 0xfb; ! 10229: psMemWrite = cpu.z80MemWrite; /* Beginning of our handler */ ! 10230: while (psMemWrite->lowAddr != 0xffffffff) ! 10231: { ! 10232: if ((dwAddr >= psMemWrite->lowAddr) && (dwAddr <= psMemWrite->highAddr)) ! 10233: { ! 10234: cpu.z80pc = (UINT32) pbPC - (UINT32) cpu.z80Base; ! 10235: if (psMemWrite->memoryCall) ! 10236: { ! 10237: psMemWrite->memoryCall(dwAddr, bTemp, psMemWrite); ! 10238: } ! 10239: else ! 10240: { ! 10241: *((UINT8 *) psMemWrite->pUserArea + (dwAddr - psMemWrite->lowAddr)) = bTemp; ! 10242: } ! 10243: psMemWrite = NULL; ! 10244: break; ! 10245: } ! 10246: ++psMemWrite; ! 10247: } ! 10248: ! 10249: if (psMemWrite) ! 10250: { ! 10251: cpu.z80Base[dwAddr] = (UINT8) bTemp; ! 10252: } ! 10253: ! 10254: break; ! 10255: } ! 10256: case 0x97: ! 10257: { ! 10258: InvalidInstruction(4); ! 10259: break; ! 10260: } ! 10261: case 0x98: ! 10262: { ! 10263: InvalidInstruction(4); ! 10264: break; ! 10265: } ! 10266: case 0x99: ! 10267: { ! 10268: InvalidInstruction(4); ! 10269: break; ! 10270: } ! 10271: case 0x9a: ! 10272: { ! 10273: InvalidInstruction(4); ! 10274: break; ! 10275: } ! 10276: case 0x9b: ! 10277: { ! 10278: InvalidInstruction(4); ! 10279: break; ! 10280: } ! 10281: case 0x9c: ! 10282: { ! 10283: InvalidInstruction(4); ! 10284: break; ! 10285: } ! 10286: case 0x9d: ! 10287: { ! 10288: InvalidInstruction(4); ! 10289: break; ! 10290: } ! 10291: case 0x9e: ! 10292: { ! 10293: sdwCyclesRemaining -= 23; ! 10294: bTemp &= 0xf7; ! 10295: psMemWrite = cpu.z80MemWrite; /* Beginning of our handler */ ! 10296: while (psMemWrite->lowAddr != 0xffffffff) ! 10297: { ! 10298: if ((dwAddr >= psMemWrite->lowAddr) && (dwAddr <= psMemWrite->highAddr)) ! 10299: { ! 10300: cpu.z80pc = (UINT32) pbPC - (UINT32) cpu.z80Base; ! 10301: if (psMemWrite->memoryCall) ! 10302: { ! 10303: psMemWrite->memoryCall(dwAddr, bTemp, psMemWrite); ! 10304: } ! 10305: else ! 10306: { ! 10307: *((UINT8 *) psMemWrite->pUserArea + (dwAddr - psMemWrite->lowAddr)) = bTemp; ! 10308: } ! 10309: psMemWrite = NULL; ! 10310: break; ! 10311: } ! 10312: ++psMemWrite; ! 10313: } ! 10314: ! 10315: if (psMemWrite) ! 10316: { ! 10317: cpu.z80Base[dwAddr] = (UINT8) bTemp; ! 10318: } ! 10319: ! 10320: break; ! 10321: } ! 10322: case 0x9f: ! 10323: { ! 10324: InvalidInstruction(4); ! 10325: break; ! 10326: } ! 10327: case 0xa0: ! 10328: { ! 10329: InvalidInstruction(4); ! 10330: break; ! 10331: } ! 10332: case 0xa1: ! 10333: { ! 10334: InvalidInstruction(4); ! 10335: break; ! 10336: } ! 10337: case 0xa2: ! 10338: { ! 10339: InvalidInstruction(4); ! 10340: break; ! 10341: } ! 10342: case 0xa3: ! 10343: { ! 10344: InvalidInstruction(4); ! 10345: break; ! 10346: } ! 10347: case 0xa4: ! 10348: { ! 10349: InvalidInstruction(4); ! 10350: break; ! 10351: } ! 10352: case 0xa5: ! 10353: { ! 10354: InvalidInstruction(4); ! 10355: break; ! 10356: } ! 10357: case 0xa6: ! 10358: { ! 10359: sdwCyclesRemaining -= 23; ! 10360: bTemp &= 0xef; ! 10361: psMemWrite = cpu.z80MemWrite; /* Beginning of our handler */ ! 10362: while (psMemWrite->lowAddr != 0xffffffff) ! 10363: { ! 10364: if ((dwAddr >= psMemWrite->lowAddr) && (dwAddr <= psMemWrite->highAddr)) ! 10365: { ! 10366: cpu.z80pc = (UINT32) pbPC - (UINT32) cpu.z80Base; ! 10367: if (psMemWrite->memoryCall) ! 10368: { ! 10369: psMemWrite->memoryCall(dwAddr, bTemp, psMemWrite); ! 10370: } ! 10371: else ! 10372: { ! 10373: *((UINT8 *) psMemWrite->pUserArea + (dwAddr - psMemWrite->lowAddr)) = bTemp; ! 10374: } ! 10375: psMemWrite = NULL; ! 10376: break; ! 10377: } ! 10378: ++psMemWrite; ! 10379: } ! 10380: ! 10381: if (psMemWrite) ! 10382: { ! 10383: cpu.z80Base[dwAddr] = (UINT8) bTemp; ! 10384: } ! 10385: ! 10386: break; ! 10387: } ! 10388: case 0xa7: ! 10389: { ! 10390: InvalidInstruction(4); ! 10391: break; ! 10392: } ! 10393: case 0xa8: ! 10394: { ! 10395: InvalidInstruction(4); ! 10396: break; ! 10397: } ! 10398: case 0xa9: ! 10399: { ! 10400: InvalidInstruction(4); ! 10401: break; ! 10402: } ! 10403: case 0xaa: ! 10404: { ! 10405: InvalidInstruction(4); ! 10406: break; ! 10407: } ! 10408: case 0xab: ! 10409: { ! 10410: InvalidInstruction(4); ! 10411: break; ! 10412: } ! 10413: case 0xac: ! 10414: { ! 10415: InvalidInstruction(4); ! 10416: break; ! 10417: } ! 10418: case 0xad: ! 10419: { ! 10420: InvalidInstruction(4); ! 10421: break; ! 10422: } ! 10423: case 0xae: ! 10424: { ! 10425: sdwCyclesRemaining -= 23; ! 10426: bTemp &= 0xdf; ! 10427: psMemWrite = cpu.z80MemWrite; /* Beginning of our handler */ ! 10428: while (psMemWrite->lowAddr != 0xffffffff) ! 10429: { ! 10430: if ((dwAddr >= psMemWrite->lowAddr) && (dwAddr <= psMemWrite->highAddr)) ! 10431: { ! 10432: cpu.z80pc = (UINT32) pbPC - (UINT32) cpu.z80Base; ! 10433: if (psMemWrite->memoryCall) ! 10434: { ! 10435: psMemWrite->memoryCall(dwAddr, bTemp, psMemWrite); ! 10436: } ! 10437: else ! 10438: { ! 10439: *((UINT8 *) psMemWrite->pUserArea + (dwAddr - psMemWrite->lowAddr)) = bTemp; ! 10440: } ! 10441: psMemWrite = NULL; ! 10442: break; ! 10443: } ! 10444: ++psMemWrite; ! 10445: } ! 10446: ! 10447: if (psMemWrite) ! 10448: { ! 10449: cpu.z80Base[dwAddr] = (UINT8) bTemp; ! 10450: } ! 10451: ! 10452: break; ! 10453: } ! 10454: case 0xaf: ! 10455: { ! 10456: InvalidInstruction(4); ! 10457: break; ! 10458: } ! 10459: case 0xb0: ! 10460: { ! 10461: InvalidInstruction(4); ! 10462: break; ! 10463: } ! 10464: case 0xb1: ! 10465: { ! 10466: InvalidInstruction(4); ! 10467: break; ! 10468: } ! 10469: case 0xb2: ! 10470: { ! 10471: InvalidInstruction(4); ! 10472: break; ! 10473: } ! 10474: case 0xb3: ! 10475: { ! 10476: InvalidInstruction(4); ! 10477: break; ! 10478: } ! 10479: case 0xb4: ! 10480: { ! 10481: InvalidInstruction(4); ! 10482: break; ! 10483: } ! 10484: case 0xb5: ! 10485: { ! 10486: InvalidInstruction(4); ! 10487: break; ! 10488: } ! 10489: case 0xb6: ! 10490: { ! 10491: sdwCyclesRemaining -= 23; ! 10492: bTemp &= 0xbf; ! 10493: psMemWrite = cpu.z80MemWrite; /* Beginning of our handler */ ! 10494: while (psMemWrite->lowAddr != 0xffffffff) ! 10495: { ! 10496: if ((dwAddr >= psMemWrite->lowAddr) && (dwAddr <= psMemWrite->highAddr)) ! 10497: { ! 10498: cpu.z80pc = (UINT32) pbPC - (UINT32) cpu.z80Base; ! 10499: if (psMemWrite->memoryCall) ! 10500: { ! 10501: psMemWrite->memoryCall(dwAddr, bTemp, psMemWrite); ! 10502: } ! 10503: else ! 10504: { ! 10505: *((UINT8 *) psMemWrite->pUserArea + (dwAddr - psMemWrite->lowAddr)) = bTemp; ! 10506: } ! 10507: psMemWrite = NULL; ! 10508: break; ! 10509: } ! 10510: ++psMemWrite; ! 10511: } ! 10512: ! 10513: if (psMemWrite) ! 10514: { ! 10515: cpu.z80Base[dwAddr] = (UINT8) bTemp; ! 10516: } ! 10517: ! 10518: break; ! 10519: } ! 10520: case 0xb7: ! 10521: { ! 10522: InvalidInstruction(4); ! 10523: break; ! 10524: } ! 10525: case 0xb8: ! 10526: { ! 10527: InvalidInstruction(4); ! 10528: break; ! 10529: } ! 10530: case 0xb9: ! 10531: { ! 10532: InvalidInstruction(4); ! 10533: break; ! 10534: } ! 10535: case 0xba: ! 10536: { ! 10537: InvalidInstruction(4); ! 10538: break; ! 10539: } ! 10540: case 0xbb: ! 10541: { ! 10542: InvalidInstruction(4); ! 10543: break; ! 10544: } ! 10545: case 0xbc: ! 10546: { ! 10547: InvalidInstruction(4); ! 10548: break; ! 10549: } ! 10550: case 0xbd: ! 10551: { ! 10552: InvalidInstruction(4); ! 10553: break; ! 10554: } ! 10555: case 0xbe: ! 10556: { ! 10557: sdwCyclesRemaining -= 23; ! 10558: bTemp &= 0x7f; ! 10559: psMemWrite = cpu.z80MemWrite; /* Beginning of our handler */ ! 10560: while (psMemWrite->lowAddr != 0xffffffff) ! 10561: { ! 10562: if ((dwAddr >= psMemWrite->lowAddr) && (dwAddr <= psMemWrite->highAddr)) ! 10563: { ! 10564: cpu.z80pc = (UINT32) pbPC - (UINT32) cpu.z80Base; ! 10565: if (psMemWrite->memoryCall) ! 10566: { ! 10567: psMemWrite->memoryCall(dwAddr, bTemp, psMemWrite); ! 10568: } ! 10569: else ! 10570: { ! 10571: *((UINT8 *) psMemWrite->pUserArea + (dwAddr - psMemWrite->lowAddr)) = bTemp; ! 10572: } ! 10573: psMemWrite = NULL; ! 10574: break; ! 10575: } ! 10576: ++psMemWrite; ! 10577: } ! 10578: ! 10579: if (psMemWrite) ! 10580: { ! 10581: cpu.z80Base[dwAddr] = (UINT8) bTemp; ! 10582: } ! 10583: ! 10584: break; ! 10585: } ! 10586: case 0xbf: ! 10587: { ! 10588: InvalidInstruction(4); ! 10589: break; ! 10590: } ! 10591: case 0xc0: ! 10592: { ! 10593: InvalidInstruction(4); ! 10594: break; ! 10595: } ! 10596: case 0xc1: ! 10597: { ! 10598: InvalidInstruction(4); ! 10599: break; ! 10600: } ! 10601: case 0xc2: ! 10602: { ! 10603: InvalidInstruction(4); ! 10604: break; ! 10605: } ! 10606: case 0xc3: ! 10607: { ! 10608: InvalidInstruction(4); ! 10609: break; ! 10610: } ! 10611: case 0xc4: ! 10612: { ! 10613: InvalidInstruction(4); ! 10614: break; ! 10615: } ! 10616: case 0xc5: ! 10617: { ! 10618: InvalidInstruction(4); ! 10619: break; ! 10620: } ! 10621: case 0xc6: ! 10622: { ! 10623: sdwCyclesRemaining -= 23; ! 10624: bTemp |= 0x01; ! 10625: psMemWrite = cpu.z80MemWrite; /* Beginning of our handler */ ! 10626: while (psMemWrite->lowAddr != 0xffffffff) ! 10627: { ! 10628: if ((dwAddr >= psMemWrite->lowAddr) && (dwAddr <= psMemWrite->highAddr)) ! 10629: { ! 10630: cpu.z80pc = (UINT32) pbPC - (UINT32) cpu.z80Base; ! 10631: if (psMemWrite->memoryCall) ! 10632: { ! 10633: psMemWrite->memoryCall(dwAddr, bTemp, psMemWrite); ! 10634: } ! 10635: else ! 10636: { ! 10637: *((UINT8 *) psMemWrite->pUserArea + (dwAddr - psMemWrite->lowAddr)) = bTemp; ! 10638: } ! 10639: psMemWrite = NULL; ! 10640: break; ! 10641: } ! 10642: ++psMemWrite; ! 10643: } ! 10644: ! 10645: if (psMemWrite) ! 10646: { ! 10647: cpu.z80Base[dwAddr] = (UINT8) bTemp; ! 10648: } ! 10649: ! 10650: break; ! 10651: } ! 10652: case 0xc7: ! 10653: { ! 10654: InvalidInstruction(4); ! 10655: break; ! 10656: } ! 10657: case 0xc8: ! 10658: { ! 10659: InvalidInstruction(4); ! 10660: break; ! 10661: } ! 10662: case 0xc9: ! 10663: { ! 10664: InvalidInstruction(4); ! 10665: break; ! 10666: } ! 10667: case 0xca: ! 10668: { ! 10669: InvalidInstruction(4); ! 10670: break; ! 10671: } ! 10672: case 0xcb: ! 10673: { ! 10674: InvalidInstruction(4); ! 10675: break; ! 10676: } ! 10677: case 0xcc: ! 10678: { ! 10679: InvalidInstruction(4); ! 10680: break; ! 10681: } ! 10682: case 0xcd: ! 10683: { ! 10684: InvalidInstruction(4); ! 10685: break; ! 10686: } ! 10687: case 0xce: ! 10688: { ! 10689: sdwCyclesRemaining -= 23; ! 10690: bTemp |= 0x02; ! 10691: psMemWrite = cpu.z80MemWrite; /* Beginning of our handler */ ! 10692: while (psMemWrite->lowAddr != 0xffffffff) ! 10693: { ! 10694: if ((dwAddr >= psMemWrite->lowAddr) && (dwAddr <= psMemWrite->highAddr)) ! 10695: { ! 10696: cpu.z80pc = (UINT32) pbPC - (UINT32) cpu.z80Base; ! 10697: if (psMemWrite->memoryCall) ! 10698: { ! 10699: psMemWrite->memoryCall(dwAddr, bTemp, psMemWrite); ! 10700: } ! 10701: else ! 10702: { ! 10703: *((UINT8 *) psMemWrite->pUserArea + (dwAddr - psMemWrite->lowAddr)) = bTemp; ! 10704: } ! 10705: psMemWrite = NULL; ! 10706: break; ! 10707: } ! 10708: ++psMemWrite; ! 10709: } ! 10710: ! 10711: if (psMemWrite) ! 10712: { ! 10713: cpu.z80Base[dwAddr] = (UINT8) bTemp; ! 10714: } ! 10715: ! 10716: break; ! 10717: } ! 10718: case 0xcf: ! 10719: { ! 10720: InvalidInstruction(4); ! 10721: break; ! 10722: } ! 10723: case 0xd0: ! 10724: { ! 10725: InvalidInstruction(4); ! 10726: break; ! 10727: } ! 10728: case 0xd1: ! 10729: { ! 10730: InvalidInstruction(4); ! 10731: break; ! 10732: } ! 10733: case 0xd2: ! 10734: { ! 10735: InvalidInstruction(4); ! 10736: break; ! 10737: } ! 10738: case 0xd3: ! 10739: { ! 10740: InvalidInstruction(4); ! 10741: break; ! 10742: } ! 10743: case 0xd4: ! 10744: { ! 10745: InvalidInstruction(4); ! 10746: break; ! 10747: } ! 10748: case 0xd5: ! 10749: { ! 10750: InvalidInstruction(4); ! 10751: break; ! 10752: } ! 10753: case 0xd6: ! 10754: { ! 10755: sdwCyclesRemaining -= 23; ! 10756: bTemp |= 0x04; ! 10757: psMemWrite = cpu.z80MemWrite; /* Beginning of our handler */ ! 10758: while (psMemWrite->lowAddr != 0xffffffff) ! 10759: { ! 10760: if ((dwAddr >= psMemWrite->lowAddr) && (dwAddr <= psMemWrite->highAddr)) ! 10761: { ! 10762: cpu.z80pc = (UINT32) pbPC - (UINT32) cpu.z80Base; ! 10763: if (psMemWrite->memoryCall) ! 10764: { ! 10765: psMemWrite->memoryCall(dwAddr, bTemp, psMemWrite); ! 10766: } ! 10767: else ! 10768: { ! 10769: *((UINT8 *) psMemWrite->pUserArea + (dwAddr - psMemWrite->lowAddr)) = bTemp; ! 10770: } ! 10771: psMemWrite = NULL; ! 10772: break; ! 10773: } ! 10774: ++psMemWrite; ! 10775: } ! 10776: ! 10777: if (psMemWrite) ! 10778: { ! 10779: cpu.z80Base[dwAddr] = (UINT8) bTemp; ! 10780: } ! 10781: ! 10782: break; ! 10783: } ! 10784: case 0xd7: ! 10785: { ! 10786: InvalidInstruction(4); ! 10787: break; ! 10788: } ! 10789: case 0xd8: ! 10790: { ! 10791: InvalidInstruction(4); ! 10792: break; ! 10793: } ! 10794: case 0xd9: ! 10795: { ! 10796: InvalidInstruction(4); ! 10797: break; ! 10798: } ! 10799: case 0xda: ! 10800: { ! 10801: InvalidInstruction(4); ! 10802: break; ! 10803: } ! 10804: case 0xdb: ! 10805: { ! 10806: InvalidInstruction(4); ! 10807: break; ! 10808: } ! 10809: case 0xdc: ! 10810: { ! 10811: InvalidInstruction(4); ! 10812: break; ! 10813: } ! 10814: case 0xdd: ! 10815: { ! 10816: InvalidInstruction(4); ! 10817: break; ! 10818: } ! 10819: case 0xde: ! 10820: { ! 10821: sdwCyclesRemaining -= 23; ! 10822: bTemp |= 0x08; ! 10823: psMemWrite = cpu.z80MemWrite; /* Beginning of our handler */ ! 10824: while (psMemWrite->lowAddr != 0xffffffff) ! 10825: { ! 10826: if ((dwAddr >= psMemWrite->lowAddr) && (dwAddr <= psMemWrite->highAddr)) ! 10827: { ! 10828: cpu.z80pc = (UINT32) pbPC - (UINT32) cpu.z80Base; ! 10829: if (psMemWrite->memoryCall) ! 10830: { ! 10831: psMemWrite->memoryCall(dwAddr, bTemp, psMemWrite); ! 10832: } ! 10833: else ! 10834: { ! 10835: *((UINT8 *) psMemWrite->pUserArea + (dwAddr - psMemWrite->lowAddr)) = bTemp; ! 10836: } ! 10837: psMemWrite = NULL; ! 10838: break; ! 10839: } ! 10840: ++psMemWrite; ! 10841: } ! 10842: ! 10843: if (psMemWrite) ! 10844: { ! 10845: cpu.z80Base[dwAddr] = (UINT8) bTemp; ! 10846: } ! 10847: ! 10848: break; ! 10849: } ! 10850: case 0xdf: ! 10851: { ! 10852: InvalidInstruction(4); ! 10853: break; ! 10854: } ! 10855: case 0xe0: ! 10856: { ! 10857: InvalidInstruction(4); ! 10858: break; ! 10859: } ! 10860: case 0xe1: ! 10861: { ! 10862: InvalidInstruction(4); ! 10863: break; ! 10864: } ! 10865: case 0xe2: ! 10866: { ! 10867: InvalidInstruction(4); ! 10868: break; ! 10869: } ! 10870: case 0xe3: ! 10871: { ! 10872: InvalidInstruction(4); ! 10873: break; ! 10874: } ! 10875: case 0xe4: ! 10876: { ! 10877: InvalidInstruction(4); ! 10878: break; ! 10879: } ! 10880: case 0xe5: ! 10881: { ! 10882: InvalidInstruction(4); ! 10883: break; ! 10884: } ! 10885: case 0xe6: ! 10886: { ! 10887: sdwCyclesRemaining -= 23; ! 10888: bTemp |= 0x10; ! 10889: psMemWrite = cpu.z80MemWrite; /* Beginning of our handler */ ! 10890: while (psMemWrite->lowAddr != 0xffffffff) ! 10891: { ! 10892: if ((dwAddr >= psMemWrite->lowAddr) && (dwAddr <= psMemWrite->highAddr)) ! 10893: { ! 10894: cpu.z80pc = (UINT32) pbPC - (UINT32) cpu.z80Base; ! 10895: if (psMemWrite->memoryCall) ! 10896: { ! 10897: psMemWrite->memoryCall(dwAddr, bTemp, psMemWrite); ! 10898: } ! 10899: else ! 10900: { ! 10901: *((UINT8 *) psMemWrite->pUserArea + (dwAddr - psMemWrite->lowAddr)) = bTemp; ! 10902: } ! 10903: psMemWrite = NULL; ! 10904: break; ! 10905: } ! 10906: ++psMemWrite; ! 10907: } ! 10908: ! 10909: if (psMemWrite) ! 10910: { ! 10911: cpu.z80Base[dwAddr] = (UINT8) bTemp; ! 10912: } ! 10913: ! 10914: break; ! 10915: } ! 10916: case 0xe7: ! 10917: { ! 10918: InvalidInstruction(4); ! 10919: break; ! 10920: } ! 10921: case 0xe8: ! 10922: { ! 10923: InvalidInstruction(4); ! 10924: break; ! 10925: } ! 10926: case 0xe9: ! 10927: { ! 10928: InvalidInstruction(4); ! 10929: break; ! 10930: } ! 10931: case 0xea: ! 10932: { ! 10933: InvalidInstruction(4); ! 10934: break; ! 10935: } ! 10936: case 0xeb: ! 10937: { ! 10938: InvalidInstruction(4); ! 10939: break; ! 10940: } ! 10941: case 0xec: ! 10942: { ! 10943: InvalidInstruction(4); ! 10944: break; ! 10945: } ! 10946: case 0xed: ! 10947: { ! 10948: InvalidInstruction(4); ! 10949: break; ! 10950: } ! 10951: case 0xee: ! 10952: { ! 10953: sdwCyclesRemaining -= 23; ! 10954: bTemp |= 0x20; ! 10955: psMemWrite = cpu.z80MemWrite; /* Beginning of our handler */ ! 10956: while (psMemWrite->lowAddr != 0xffffffff) ! 10957: { ! 10958: if ((dwAddr >= psMemWrite->lowAddr) && (dwAddr <= psMemWrite->highAddr)) ! 10959: { ! 10960: cpu.z80pc = (UINT32) pbPC - (UINT32) cpu.z80Base; ! 10961: if (psMemWrite->memoryCall) ! 10962: { ! 10963: psMemWrite->memoryCall(dwAddr, bTemp, psMemWrite); ! 10964: } ! 10965: else ! 10966: { ! 10967: *((UINT8 *) psMemWrite->pUserArea + (dwAddr - psMemWrite->lowAddr)) = bTemp; ! 10968: } ! 10969: psMemWrite = NULL; ! 10970: break; ! 10971: } ! 10972: ++psMemWrite; ! 10973: } ! 10974: ! 10975: if (psMemWrite) ! 10976: { ! 10977: cpu.z80Base[dwAddr] = (UINT8) bTemp; ! 10978: } ! 10979: ! 10980: break; ! 10981: } ! 10982: case 0xef: ! 10983: { ! 10984: InvalidInstruction(4); ! 10985: break; ! 10986: } ! 10987: case 0xf0: ! 10988: { ! 10989: InvalidInstruction(4); ! 10990: break; ! 10991: } ! 10992: case 0xf1: ! 10993: { ! 10994: InvalidInstruction(4); ! 10995: break; ! 10996: } ! 10997: case 0xf2: ! 10998: { ! 10999: InvalidInstruction(4); ! 11000: break; ! 11001: } ! 11002: case 0xf3: ! 11003: { ! 11004: InvalidInstruction(4); ! 11005: break; ! 11006: } ! 11007: case 0xf4: ! 11008: { ! 11009: InvalidInstruction(4); ! 11010: break; ! 11011: } ! 11012: case 0xf5: ! 11013: { ! 11014: InvalidInstruction(4); ! 11015: break; ! 11016: } ! 11017: case 0xf6: ! 11018: { ! 11019: sdwCyclesRemaining -= 23; ! 11020: bTemp |= 0x40; ! 11021: psMemWrite = cpu.z80MemWrite; /* Beginning of our handler */ ! 11022: while (psMemWrite->lowAddr != 0xffffffff) ! 11023: { ! 11024: if ((dwAddr >= psMemWrite->lowAddr) && (dwAddr <= psMemWrite->highAddr)) ! 11025: { ! 11026: cpu.z80pc = (UINT32) pbPC - (UINT32) cpu.z80Base; ! 11027: if (psMemWrite->memoryCall) ! 11028: { ! 11029: psMemWrite->memoryCall(dwAddr, bTemp, psMemWrite); ! 11030: } ! 11031: else ! 11032: { ! 11033: *((UINT8 *) psMemWrite->pUserArea + (dwAddr - psMemWrite->lowAddr)) = bTemp; ! 11034: } ! 11035: psMemWrite = NULL; ! 11036: break; ! 11037: } ! 11038: ++psMemWrite; ! 11039: } ! 11040: ! 11041: if (psMemWrite) ! 11042: { ! 11043: cpu.z80Base[dwAddr] = (UINT8) bTemp; ! 11044: } ! 11045: ! 11046: break; ! 11047: } ! 11048: case 0xf7: ! 11049: { ! 11050: InvalidInstruction(4); ! 11051: break; ! 11052: } ! 11053: case 0xf8: ! 11054: { ! 11055: InvalidInstruction(4); ! 11056: break; ! 11057: } ! 11058: case 0xf9: ! 11059: { ! 11060: InvalidInstruction(4); ! 11061: break; ! 11062: } ! 11063: case 0xfa: ! 11064: { ! 11065: InvalidInstruction(4); ! 11066: break; ! 11067: } ! 11068: case 0xfb: ! 11069: { ! 11070: InvalidInstruction(4); ! 11071: break; ! 11072: } ! 11073: case 0xfc: ! 11074: { ! 11075: InvalidInstruction(4); ! 11076: break; ! 11077: } ! 11078: case 0xfd: ! 11079: { ! 11080: InvalidInstruction(4); ! 11081: break; ! 11082: } ! 11083: case 0xfe: ! 11084: { ! 11085: sdwCyclesRemaining -= 23; ! 11086: bTemp |= 0x80; ! 11087: psMemWrite = cpu.z80MemWrite; /* Beginning of our handler */ ! 11088: while (psMemWrite->lowAddr != 0xffffffff) ! 11089: { ! 11090: if ((dwAddr >= psMemWrite->lowAddr) && (dwAddr <= psMemWrite->highAddr)) ! 11091: { ! 11092: cpu.z80pc = (UINT32) pbPC - (UINT32) cpu.z80Base; ! 11093: if (psMemWrite->memoryCall) ! 11094: { ! 11095: psMemWrite->memoryCall(dwAddr, bTemp, psMemWrite); ! 11096: } ! 11097: else ! 11098: { ! 11099: *((UINT8 *) psMemWrite->pUserArea + (dwAddr - psMemWrite->lowAddr)) = bTemp; ! 11100: } ! 11101: psMemWrite = NULL; ! 11102: break; ! 11103: } ! 11104: ++psMemWrite; ! 11105: } ! 11106: ! 11107: if (psMemWrite) ! 11108: { ! 11109: cpu.z80Base[dwAddr] = (UINT8) bTemp; ! 11110: } ! 11111: ! 11112: break; ! 11113: } ! 11114: case 0xff: ! 11115: { ! 11116: InvalidInstruction(4); ! 11117: break; ! 11118: } ! 11119: } ! 11120: } ! 11121: void FDHandler(void) ! 11122: { ! 11123: switch (*pbPC++) ! 11124: { ! 11125: case 0x00: ! 11126: { ! 11127: InvalidInstruction(2); ! 11128: break; ! 11129: } ! 11130: case 0x01: ! 11131: { ! 11132: InvalidInstruction(2); ! 11133: break; ! 11134: } ! 11135: case 0x02: ! 11136: { ! 11137: InvalidInstruction(2); ! 11138: break; ! 11139: } ! 11140: case 0x03: ! 11141: { ! 11142: InvalidInstruction(2); ! 11143: break; ! 11144: } ! 11145: case 0x04: ! 11146: { ! 11147: InvalidInstruction(2); ! 11148: break; ! 11149: } ! 11150: case 0x05: ! 11151: { ! 11152: InvalidInstruction(2); ! 11153: break; ! 11154: } ! 11155: case 0x06: ! 11156: { ! 11157: InvalidInstruction(2); ! 11158: break; ! 11159: } ! 11160: case 0x07: ! 11161: { ! 11162: InvalidInstruction(2); ! 11163: break; ! 11164: } ! 11165: case 0x08: ! 11166: { ! 11167: InvalidInstruction(2); ! 11168: break; ! 11169: } ! 11170: case 0x09: ! 11171: { ! 11172: sdwCyclesRemaining -= 15; ! 11173: cpu.z80F &= ~(Z80_FLAG_CARRY | Z80_FLAG_NEGATIVE | Z80_FLAG_HALF_CARRY); ! 11174: dwTemp = cpu.z80IY + cpu.z80BC; ! 11175: cpu.z80F |= ((dwTemp >> 16) & Z80_FLAG_CARRY) | (((cpu.z80IY ^ dwTemp ^ cpu.z80BC) >> 8) & Z80_FLAG_HALF_CARRY); ! 11176: cpu.z80IY = dwTemp & 0xffff; ! 11177: break; ! 11178: } ! 11179: case 0x0a: ! 11180: { ! 11181: InvalidInstruction(2); ! 11182: break; ! 11183: } ! 11184: case 0x0b: ! 11185: { ! 11186: InvalidInstruction(2); ! 11187: break; ! 11188: } ! 11189: case 0x0c: ! 11190: { ! 11191: InvalidInstruction(2); ! 11192: break; ! 11193: } ! 11194: case 0x0d: ! 11195: { ! 11196: InvalidInstruction(2); ! 11197: break; ! 11198: } ! 11199: case 0x0e: ! 11200: { ! 11201: InvalidInstruction(2); ! 11202: break; ! 11203: } ! 11204: case 0x0f: ! 11205: { ! 11206: InvalidInstruction(2); ! 11207: break; ! 11208: } ! 11209: case 0x10: ! 11210: { ! 11211: InvalidInstruction(2); ! 11212: break; ! 11213: } ! 11214: case 0x11: ! 11215: { ! 11216: InvalidInstruction(2); ! 11217: break; ! 11218: } ! 11219: case 0x12: ! 11220: { ! 11221: InvalidInstruction(2); ! 11222: break; ! 11223: } ! 11224: case 0x13: ! 11225: { ! 11226: InvalidInstruction(2); ! 11227: break; ! 11228: } ! 11229: case 0x14: ! 11230: { ! 11231: InvalidInstruction(2); ! 11232: break; ! 11233: } ! 11234: case 0x15: ! 11235: { ! 11236: InvalidInstruction(2); ! 11237: break; ! 11238: } ! 11239: case 0x16: ! 11240: { ! 11241: InvalidInstruction(2); ! 11242: break; ! 11243: } ! 11244: case 0x17: ! 11245: { ! 11246: InvalidInstruction(2); ! 11247: break; ! 11248: } ! 11249: case 0x18: ! 11250: { ! 11251: InvalidInstruction(2); ! 11252: break; ! 11253: } ! 11254: case 0x19: ! 11255: { ! 11256: sdwCyclesRemaining -= 15; ! 11257: cpu.z80F &= ~(Z80_FLAG_CARRY | Z80_FLAG_NEGATIVE | Z80_FLAG_HALF_CARRY); ! 11258: dwTemp = cpu.z80IY + cpu.z80DE; ! 11259: cpu.z80F |= ((dwTemp >> 16) & Z80_FLAG_CARRY) | (((cpu.z80IY ^ dwTemp ^ cpu.z80DE) >> 8) & Z80_FLAG_HALF_CARRY); ! 11260: cpu.z80IY = dwTemp & 0xffff; ! 11261: break; ! 11262: } ! 11263: case 0x1a: ! 11264: { ! 11265: InvalidInstruction(2); ! 11266: break; ! 11267: } ! 11268: case 0x1b: ! 11269: { ! 11270: InvalidInstruction(2); ! 11271: break; ! 11272: } ! 11273: case 0x1c: ! 11274: { ! 11275: InvalidInstruction(2); ! 11276: break; ! 11277: } ! 11278: case 0x1d: ! 11279: { ! 11280: InvalidInstruction(2); ! 11281: break; ! 11282: } ! 11283: case 0x1e: ! 11284: { ! 11285: InvalidInstruction(2); ! 11286: break; ! 11287: } ! 11288: case 0x1f: ! 11289: { ! 11290: InvalidInstruction(2); ! 11291: break; ! 11292: } ! 11293: case 0x20: ! 11294: { ! 11295: InvalidInstruction(2); ! 11296: break; ! 11297: } ! 11298: case 0x21: ! 11299: { ! 11300: sdwCyclesRemaining -= 14; ! 11301: cpu.z80IY = *pbPC++; ! 11302: cpu.z80IY |= ((UINT32) *pbPC++ << 8); ! 11303: break; ! 11304: } ! 11305: case 0x22: ! 11306: { ! 11307: sdwCyclesRemaining -= 20; ! 11308: dwAddr = *pbPC++; ! 11309: dwAddr |= ((UINT32) *pbPC++ << 8); ! 11310: psMemWrite = cpu.z80MemWrite; /* Beginning of our handler */ ! 11311: while (psMemWrite->lowAddr != 0xffffffff) ! 11312: { ! 11313: if ((dwAddr >= psMemWrite->lowAddr) && (dwAddr <= psMemWrite->highAddr)) ! 11314: { ! 11315: cpu.z80pc = (UINT32) pbPC - (UINT32) cpu.z80Base; ! 11316: if (psMemWrite->memoryCall) ! 11317: { ! 11318: psMemWrite->memoryCall(dwAddr, (cpu.z80IY & 0xff), psMemWrite); ! 11319: psMemWrite->memoryCall(dwAddr + 1, (cpu.z80IY >> 8), psMemWrite); ! 11320: } ! 11321: else ! 11322: { ! 11323: *((UINT8 *) psMemWrite->pUserArea + (dwAddr - psMemWrite->lowAddr)) = cpu.z80IY; ! 11324: *((UINT8 *) psMemWrite->pUserArea + (dwAddr - psMemWrite->lowAddr) + 1) = cpu.z80IY >> 8; ! 11325: } ! 11326: psMemWrite = NULL; ! 11327: break; ! 11328: } ! 11329: ++psMemWrite; ! 11330: } ! 11331: ! 11332: if (psMemWrite) ! 11333: { ! 11334: cpu.z80Base[dwAddr] = (UINT8) cpu.z80IY; ! 11335: cpu.z80Base[dwAddr + 1] = (UINT8) ((UINT32) cpu.z80IY >> 8); ! 11336: } ! 11337: ! 11338: break; ! 11339: } ! 11340: case 0x23: ! 11341: { ! 11342: sdwCyclesRemaining -= 10; ! 11343: cpu.z80IY++; ! 11344: cpu.z80IY &= 0xffff; ! 11345: break; ! 11346: } ! 11347: case 0x24: ! 11348: { ! 11349: sdwCyclesRemaining -= 9; ! 11350: cpu.z80F &= ~(Z80_FLAG_SIGN | Z80_FLAG_ZERO | Z80_FLAG_HALF_CARRY | Z80_FLAG_OVERFLOW_PARITY | Z80_FLAG_NEGATIVE); ! 11351: cpu.z80F |= bPostIncFlags[cpu.z80YH++]; ! 11352: break; ! 11353: } ! 11354: case 0x25: ! 11355: { ! 11356: sdwCyclesRemaining -= 9; ! 11357: cpu.z80F &= ~(Z80_FLAG_SIGN | Z80_FLAG_ZERO | Z80_FLAG_HALF_CARRY | Z80_FLAG_OVERFLOW_PARITY | Z80_FLAG_NEGATIVE); ! 11358: cpu.z80F |= bPostDecFlags[cpu.z80YH--]; ! 11359: break; ! 11360: } ! 11361: case 0x26: ! 11362: { ! 11363: sdwCyclesRemaining -= 9; ! 11364: cpu.z80YH = *pbPC++; ! 11365: break; ! 11366: } ! 11367: case 0x27: ! 11368: { ! 11369: InvalidInstruction(2); ! 11370: break; ! 11371: } ! 11372: case 0x28: ! 11373: { ! 11374: InvalidInstruction(2); ! 11375: break; ! 11376: } ! 11377: case 0x29: ! 11378: { ! 11379: sdwCyclesRemaining -= 15; ! 11380: cpu.z80F &= ~(Z80_FLAG_CARRY | Z80_FLAG_NEGATIVE | Z80_FLAG_HALF_CARRY); ! 11381: dwTemp = cpu.z80IY + cpu.z80IY; ! 11382: cpu.z80F |= ((dwTemp >> 16) & Z80_FLAG_CARRY) | (((cpu.z80IY ^ dwTemp ^ cpu.z80HL) >> 8) & Z80_FLAG_HALF_CARRY); ! 11383: cpu.z80IY = dwTemp & 0xffff; ! 11384: break; ! 11385: } ! 11386: case 0x2a: ! 11387: { ! 11388: sdwCyclesRemaining -= 20; ! 11389: dwAddr = *pbPC++; ! 11390: dwAddr |= ((UINT32) *pbPC++ << 8); ! 11391: psMemRead = cpu.z80MemRead; /* Beginning of our handler */ ! 11392: while (psMemRead->lowAddr != 0xffffffff) ! 11393: { ! 11394: if ((dwAddr >= psMemRead->lowAddr) && (dwAddr <= psMemRead->highAddr)) ! 11395: { ! 11396: cpu.z80pc = (UINT32) pbPC - (UINT32) cpu.z80Base; ! 11397: if (psMemRead->memoryCall) ! 11398: { ! 11399: cpu.z80IY = psMemRead->memoryCall(dwAddr, psMemRead); ! 11400: cpu.z80IY |= (UINT32) ((UINT32) psMemRead->memoryCall(dwAddr + 1, psMemRead) << 8); ! 11401: } ! 11402: else ! 11403: { ! 11404: cpu.z80IY = *((UINT8 *) psMemRead->pUserArea + (dwAddr - psMemRead->lowAddr)); ! 11405: cpu.z80IY |= (UINT32) ((UINT32) *((UINT8 *) psMemRead->pUserArea + (dwAddr - psMemRead->lowAddr + 1)) << 8); ! 11406: } ! 11407: psMemRead = NULL; ! 11408: break; ! 11409: } ! 11410: ++psMemRead; ! 11411: } ! 11412: ! 11413: if (psMemRead) ! 11414: { ! 11415: cpu.z80IY = cpu.z80Base[dwAddr]; ! 11416: cpu.z80IY |= (UINT32) ((UINT32) cpu.z80Base[dwAddr + 1] << 8); ! 11417: } ! 11418: ! 11419: break; ! 11420: } ! 11421: case 0x2b: ! 11422: { ! 11423: sdwCyclesRemaining -= 10; ! 11424: cpu.z80IY--; ! 11425: cpu.z80IY &= 0xffff; ! 11426: break; ! 11427: } ! 11428: case 0x2c: ! 11429: { ! 11430: sdwCyclesRemaining -= 9; ! 11431: cpu.z80F &= ~(Z80_FLAG_SIGN | Z80_FLAG_ZERO | Z80_FLAG_HALF_CARRY | Z80_FLAG_OVERFLOW_PARITY | Z80_FLAG_NEGATIVE); ! 11432: cpu.z80F |= bPostIncFlags[cpu.z80YL++]; ! 11433: break; ! 11434: } ! 11435: case 0x2d: ! 11436: { ! 11437: sdwCyclesRemaining -= 9; ! 11438: cpu.z80F &= ~(Z80_FLAG_SIGN | Z80_FLAG_ZERO | Z80_FLAG_HALF_CARRY | Z80_FLAG_OVERFLOW_PARITY | Z80_FLAG_NEGATIVE); ! 11439: cpu.z80F |= bPostDecFlags[cpu.z80YL--]; ! 11440: break; ! 11441: } ! 11442: case 0x2e: ! 11443: { ! 11444: sdwCyclesRemaining -= 9; ! 11445: cpu.z80YL = *pbPC++; ! 11446: break; ! 11447: } ! 11448: case 0x2f: ! 11449: { ! 11450: InvalidInstruction(2); ! 11451: break; ! 11452: } ! 11453: case 0x30: ! 11454: { ! 11455: InvalidInstruction(2); ! 11456: break; ! 11457: } ! 11458: case 0x31: ! 11459: { ! 11460: InvalidInstruction(2); ! 11461: break; ! 11462: } ! 11463: case 0x32: ! 11464: { ! 11465: InvalidInstruction(2); ! 11466: break; ! 11467: } ! 11468: case 0x33: ! 11469: { ! 11470: InvalidInstruction(2); ! 11471: break; ! 11472: } ! 11473: case 0x34: ! 11474: { ! 11475: sdwCyclesRemaining -= 23; ! 11476: sdwAddr = (INT8) *pbPC++; /* Get LSB first */ ! 11477: dwAddr = (sdwAddr + (INT32) cpu.z80IY) & 0xffff; ! 11478: psMemRead = cpu.z80MemRead; /* Beginning of our handler */ ! 11479: while (psMemRead->lowAddr != 0xffffffff) ! 11480: { ! 11481: if ((dwAddr >= psMemRead->lowAddr) && (dwAddr <= psMemRead->highAddr)) ! 11482: { ! 11483: cpu.z80pc = (UINT32) pbPC - (UINT32) cpu.z80Base; ! 11484: if (psMemRead->memoryCall) ! 11485: { ! 11486: bTemp = psMemRead->memoryCall(dwAddr, psMemRead); ! 11487: } ! 11488: else ! 11489: { ! 11490: bTemp = *((UINT8 *) psMemRead->pUserArea + (dwAddr - psMemRead->lowAddr)); ! 11491: } ! 11492: psMemRead = NULL; ! 11493: break; ! 11494: } ! 11495: ++psMemRead; ! 11496: } ! 11497: ! 11498: if (psMemRead) ! 11499: { ! 11500: bTemp = cpu.z80Base[dwAddr]; ! 11501: } ! 11502: ! 11503: cpu.z80F &= ~(Z80_FLAG_SIGN | Z80_FLAG_ZERO | Z80_FLAG_HALF_CARRY | Z80_FLAG_OVERFLOW_PARITY | Z80_FLAG_NEGATIVE); ! 11504: cpu.z80F |= bPostIncFlags[bTemp++]; ! 11505: psMemWrite = cpu.z80MemWrite; /* Beginning of our handler */ ! 11506: while (psMemWrite->lowAddr != 0xffffffff) ! 11507: { ! 11508: if ((dwAddr >= psMemWrite->lowAddr) && (dwAddr <= psMemWrite->highAddr)) ! 11509: { ! 11510: cpu.z80pc = (UINT32) pbPC - (UINT32) cpu.z80Base; ! 11511: if (psMemWrite->memoryCall) ! 11512: { ! 11513: psMemWrite->memoryCall(dwAddr, bTemp, psMemWrite); ! 11514: } ! 11515: else ! 11516: { ! 11517: *((UINT8 *) psMemWrite->pUserArea + (dwAddr - psMemWrite->lowAddr)) = bTemp; ! 11518: } ! 11519: psMemWrite = NULL; ! 11520: break; ! 11521: } ! 11522: ++psMemWrite; ! 11523: } ! 11524: ! 11525: if (psMemWrite) ! 11526: { ! 11527: cpu.z80Base[dwAddr] = (UINT8) bTemp; ! 11528: } ! 11529: ! 11530: break; ! 11531: } ! 11532: case 0x35: ! 11533: { ! 11534: sdwCyclesRemaining -= 23; ! 11535: sdwAddr = (INT8) *pbPC++; /* Get LSB first */ ! 11536: dwAddr = (sdwAddr + (INT32) cpu.z80IY) & 0xffff; ! 11537: psMemRead = cpu.z80MemRead; /* Beginning of our handler */ ! 11538: while (psMemRead->lowAddr != 0xffffffff) ! 11539: { ! 11540: if ((dwAddr >= psMemRead->lowAddr) && (dwAddr <= psMemRead->highAddr)) ! 11541: { ! 11542: cpu.z80pc = (UINT32) pbPC - (UINT32) cpu.z80Base; ! 11543: if (psMemRead->memoryCall) ! 11544: { ! 11545: bTemp = psMemRead->memoryCall(dwAddr, psMemRead); ! 11546: } ! 11547: else ! 11548: { ! 11549: bTemp = *((UINT8 *) psMemRead->pUserArea + (dwAddr - psMemRead->lowAddr)); ! 11550: } ! 11551: psMemRead = NULL; ! 11552: break; ! 11553: } ! 11554: ++psMemRead; ! 11555: } ! 11556: ! 11557: if (psMemRead) ! 11558: { ! 11559: bTemp = cpu.z80Base[dwAddr]; ! 11560: } ! 11561: ! 11562: cpu.z80F &= ~(Z80_FLAG_SIGN | Z80_FLAG_ZERO | Z80_FLAG_HALF_CARRY | Z80_FLAG_OVERFLOW_PARITY | Z80_FLAG_NEGATIVE); ! 11563: cpu.z80F |= bPostDecFlags[bTemp--]; ! 11564: psMemWrite = cpu.z80MemWrite; /* Beginning of our handler */ ! 11565: while (psMemWrite->lowAddr != 0xffffffff) ! 11566: { ! 11567: if ((dwAddr >= psMemWrite->lowAddr) && (dwAddr <= psMemWrite->highAddr)) ! 11568: { ! 11569: cpu.z80pc = (UINT32) pbPC - (UINT32) cpu.z80Base; ! 11570: if (psMemWrite->memoryCall) ! 11571: { ! 11572: psMemWrite->memoryCall(dwAddr, bTemp, psMemWrite); ! 11573: } ! 11574: else ! 11575: { ! 11576: *((UINT8 *) psMemWrite->pUserArea + (dwAddr - psMemWrite->lowAddr)) = bTemp; ! 11577: } ! 11578: psMemWrite = NULL; ! 11579: break; ! 11580: } ! 11581: ++psMemWrite; ! 11582: } ! 11583: ! 11584: if (psMemWrite) ! 11585: { ! 11586: cpu.z80Base[dwAddr] = (UINT8) bTemp; ! 11587: } ! 11588: ! 11589: break; ! 11590: } ! 11591: case 0x36: ! 11592: { ! 11593: sdwCyclesRemaining -= 19; ! 11594: sdwAddr = (INT8) *pbPC++; // Get the offset ! 11595: sdwAddr = ((INT32) cpu.z80IY + sdwAddr) & 0xffff; ! 11596: psMemWrite = cpu.z80MemWrite; /* Beginning of our handler */ ! 11597: while (psMemWrite->lowAddr != 0xffffffff) ! 11598: { ! 11599: if ((sdwAddr >= psMemWrite->lowAddr) && (sdwAddr <= psMemWrite->highAddr)) ! 11600: { ! 11601: cpu.z80pc = (UINT32) pbPC - (UINT32) cpu.z80Base; ! 11602: if (psMemWrite->memoryCall) ! 11603: { ! 11604: psMemWrite->memoryCall(sdwAddr, *pbPC++, psMemWrite); ! 11605: } ! 11606: else ! 11607: { ! 11608: *((UINT8 *) psMemWrite->pUserArea + (sdwAddr - psMemWrite->lowAddr)) = *pbPC++; ! 11609: } ! 11610: psMemWrite = NULL; ! 11611: break; ! 11612: } ! 11613: ++psMemWrite; ! 11614: } ! 11615: ! 11616: if (psMemWrite) ! 11617: { ! 11618: cpu.z80Base[sdwAddr] = (UINT8) *pbPC++; ! 11619: } ! 11620: ! 11621: break; ! 11622: } ! 11623: case 0x37: ! 11624: { ! 11625: InvalidInstruction(2); ! 11626: break; ! 11627: } ! 11628: case 0x38: ! 11629: { ! 11630: InvalidInstruction(2); ! 11631: break; ! 11632: } ! 11633: case 0x39: ! 11634: { ! 11635: sdwCyclesRemaining -= 15; ! 11636: cpu.z80F &= ~(Z80_FLAG_CARRY | Z80_FLAG_NEGATIVE | Z80_FLAG_HALF_CARRY); ! 11637: dwTemp = cpu.z80IY + cpu.z80sp; ! 11638: cpu.z80F |= ((dwTemp >> 16) & Z80_FLAG_CARRY) | (((cpu.z80IY ^ dwTemp ^ cpu.z80sp) >> 8) & Z80_FLAG_HALF_CARRY); ! 11639: cpu.z80IY = dwTemp & 0xffff; ! 11640: break; ! 11641: } ! 11642: case 0x3a: ! 11643: { ! 11644: InvalidInstruction(2); ! 11645: break; ! 11646: } ! 11647: case 0x3b: ! 11648: { ! 11649: InvalidInstruction(2); ! 11650: break; ! 11651: } ! 11652: case 0x3c: ! 11653: { ! 11654: InvalidInstruction(2); ! 11655: break; ! 11656: } ! 11657: case 0x3d: ! 11658: { ! 11659: InvalidInstruction(2); ! 11660: break; ! 11661: } ! 11662: case 0x3e: ! 11663: { ! 11664: InvalidInstruction(2); ! 11665: break; ! 11666: } ! 11667: case 0x3f: ! 11668: { ! 11669: InvalidInstruction(2); ! 11670: break; ! 11671: } ! 11672: case 0x40: ! 11673: { ! 11674: InvalidInstruction(2); ! 11675: break; ! 11676: } ! 11677: case 0x41: ! 11678: { ! 11679: InvalidInstruction(2); ! 11680: break; ! 11681: } ! 11682: case 0x42: ! 11683: { ! 11684: InvalidInstruction(2); ! 11685: break; ! 11686: } ! 11687: case 0x43: ! 11688: { ! 11689: InvalidInstruction(2); ! 11690: break; ! 11691: } ! 11692: case 0x44: ! 11693: { ! 11694: sdwCyclesRemaining -= 9; ! 11695: cpu.z80B = cpu.z80YH; ! 11696: break; ! 11697: } ! 11698: case 0x45: ! 11699: { ! 11700: sdwCyclesRemaining -= 9; ! 11701: cpu.z80B = cpu.z80YL; ! 11702: break; ! 11703: } ! 11704: case 0x46: ! 11705: { ! 11706: sdwCyclesRemaining -= 19; ! 11707: sdwAddr = (INT8) *pbPC++; // Get the offset ! 11708: sdwAddr = ((INT32) cpu.z80IY + sdwAddr) & 0xffff; ! 11709: psMemRead = cpu.z80MemRead; /* Beginning of our handler */ ! 11710: while (psMemRead->lowAddr != 0xffffffff) ! 11711: { ! 11712: if ((sdwAddr >= psMemRead->lowAddr) && (sdwAddr <= psMemRead->highAddr)) ! 11713: { ! 11714: cpu.z80pc = (UINT32) pbPC - (UINT32) cpu.z80Base; ! 11715: if (psMemRead->memoryCall) ! 11716: { ! 11717: cpu.z80B = psMemRead->memoryCall(sdwAddr, psMemRead); ! 11718: } ! 11719: else ! 11720: { ! 11721: cpu.z80B = *((UINT8 *) psMemRead->pUserArea + (sdwAddr - psMemRead->lowAddr)); ! 11722: } ! 11723: psMemRead = NULL; ! 11724: break; ! 11725: } ! 11726: ++psMemRead; ! 11727: } ! 11728: ! 11729: if (psMemRead) ! 11730: { ! 11731: cpu.z80B = cpu.z80Base[sdwAddr]; ! 11732: } ! 11733: ! 11734: break; ! 11735: } ! 11736: case 0x47: ! 11737: { ! 11738: InvalidInstruction(2); ! 11739: break; ! 11740: } ! 11741: case 0x48: ! 11742: { ! 11743: InvalidInstruction(2); ! 11744: break; ! 11745: } ! 11746: case 0x49: ! 11747: { ! 11748: InvalidInstruction(2); ! 11749: break; ! 11750: } ! 11751: case 0x4a: ! 11752: { ! 11753: InvalidInstruction(2); ! 11754: break; ! 11755: } ! 11756: case 0x4b: ! 11757: { ! 11758: InvalidInstruction(2); ! 11759: break; ! 11760: } ! 11761: case 0x4c: ! 11762: { ! 11763: sdwCyclesRemaining -= 9; ! 11764: cpu.z80C = cpu.z80YH; ! 11765: break; ! 11766: } ! 11767: case 0x4d: ! 11768: { ! 11769: sdwCyclesRemaining -= 9; ! 11770: cpu.z80C = cpu.z80YL; ! 11771: break; ! 11772: } ! 11773: case 0x4e: ! 11774: { ! 11775: sdwCyclesRemaining -= 19; ! 11776: sdwAddr = (INT8) *pbPC++; // Get the offset ! 11777: sdwAddr = ((INT32) cpu.z80IY + sdwAddr) & 0xffff; ! 11778: psMemRead = cpu.z80MemRead; /* Beginning of our handler */ ! 11779: while (psMemRead->lowAddr != 0xffffffff) ! 11780: { ! 11781: if ((sdwAddr >= psMemRead->lowAddr) && (sdwAddr <= psMemRead->highAddr)) ! 11782: { ! 11783: cpu.z80pc = (UINT32) pbPC - (UINT32) cpu.z80Base; ! 11784: if (psMemRead->memoryCall) ! 11785: { ! 11786: cpu.z80C = psMemRead->memoryCall(sdwAddr, psMemRead); ! 11787: } ! 11788: else ! 11789: { ! 11790: cpu.z80C = *((UINT8 *) psMemRead->pUserArea + (sdwAddr - psMemRead->lowAddr)); ! 11791: } ! 11792: psMemRead = NULL; ! 11793: break; ! 11794: } ! 11795: ++psMemRead; ! 11796: } ! 11797: ! 11798: if (psMemRead) ! 11799: { ! 11800: cpu.z80C = cpu.z80Base[sdwAddr]; ! 11801: } ! 11802: ! 11803: break; ! 11804: } ! 11805: case 0x4f: ! 11806: { ! 11807: InvalidInstruction(2); ! 11808: break; ! 11809: } ! 11810: case 0x50: ! 11811: { ! 11812: InvalidInstruction(2); ! 11813: break; ! 11814: } ! 11815: case 0x51: ! 11816: { ! 11817: InvalidInstruction(2); ! 11818: break; ! 11819: } ! 11820: case 0x52: ! 11821: { ! 11822: InvalidInstruction(2); ! 11823: break; ! 11824: } ! 11825: case 0x53: ! 11826: { ! 11827: InvalidInstruction(2); ! 11828: break; ! 11829: } ! 11830: case 0x54: ! 11831: { ! 11832: sdwCyclesRemaining -= 9; ! 11833: cpu.z80D = cpu.z80YH; ! 11834: break; ! 11835: } ! 11836: case 0x55: ! 11837: { ! 11838: sdwCyclesRemaining -= 9; ! 11839: cpu.z80D = cpu.z80YL; ! 11840: break; ! 11841: } ! 11842: case 0x56: ! 11843: { ! 11844: sdwCyclesRemaining -= 19; ! 11845: sdwAddr = (INT8) *pbPC++; // Get the offset ! 11846: sdwAddr = ((INT32) cpu.z80IY + sdwAddr) & 0xffff; ! 11847: psMemRead = cpu.z80MemRead; /* Beginning of our handler */ ! 11848: while (psMemRead->lowAddr != 0xffffffff) ! 11849: { ! 11850: if ((sdwAddr >= psMemRead->lowAddr) && (sdwAddr <= psMemRead->highAddr)) ! 11851: { ! 11852: cpu.z80pc = (UINT32) pbPC - (UINT32) cpu.z80Base; ! 11853: if (psMemRead->memoryCall) ! 11854: { ! 11855: cpu.z80D = psMemRead->memoryCall(sdwAddr, psMemRead); ! 11856: } ! 11857: else ! 11858: { ! 11859: cpu.z80D = *((UINT8 *) psMemRead->pUserArea + (sdwAddr - psMemRead->lowAddr)); ! 11860: } ! 11861: psMemRead = NULL; ! 11862: break; ! 11863: } ! 11864: ++psMemRead; ! 11865: } ! 11866: ! 11867: if (psMemRead) ! 11868: { ! 11869: cpu.z80D = cpu.z80Base[sdwAddr]; ! 11870: } ! 11871: ! 11872: break; ! 11873: } ! 11874: case 0x57: ! 11875: { ! 11876: InvalidInstruction(2); ! 11877: break; ! 11878: } ! 11879: case 0x58: ! 11880: { ! 11881: InvalidInstruction(2); ! 11882: break; ! 11883: } ! 11884: case 0x59: ! 11885: { ! 11886: InvalidInstruction(2); ! 11887: break; ! 11888: } ! 11889: case 0x5a: ! 11890: { ! 11891: InvalidInstruction(2); ! 11892: break; ! 11893: } ! 11894: case 0x5b: ! 11895: { ! 11896: InvalidInstruction(2); ! 11897: break; ! 11898: } ! 11899: case 0x5c: ! 11900: { ! 11901: sdwCyclesRemaining -= 9; ! 11902: cpu.z80E = cpu.z80YH; ! 11903: break; ! 11904: } ! 11905: case 0x5d: ! 11906: { ! 11907: sdwCyclesRemaining -= 9; ! 11908: cpu.z80E = cpu.z80YL; ! 11909: break; ! 11910: } ! 11911: case 0x5e: ! 11912: { ! 11913: sdwCyclesRemaining -= 19; ! 11914: sdwAddr = (INT8) *pbPC++; // Get the offset ! 11915: sdwAddr = ((INT32) cpu.z80IY + sdwAddr) & 0xffff; ! 11916: psMemRead = cpu.z80MemRead; /* Beginning of our handler */ ! 11917: while (psMemRead->lowAddr != 0xffffffff) ! 11918: { ! 11919: if ((sdwAddr >= psMemRead->lowAddr) && (sdwAddr <= psMemRead->highAddr)) ! 11920: { ! 11921: cpu.z80pc = (UINT32) pbPC - (UINT32) cpu.z80Base; ! 11922: if (psMemRead->memoryCall) ! 11923: { ! 11924: cpu.z80E = psMemRead->memoryCall(sdwAddr, psMemRead); ! 11925: } ! 11926: else ! 11927: { ! 11928: cpu.z80E = *((UINT8 *) psMemRead->pUserArea + (sdwAddr - psMemRead->lowAddr)); ! 11929: } ! 11930: psMemRead = NULL; ! 11931: break; ! 11932: } ! 11933: ++psMemRead; ! 11934: } ! 11935: ! 11936: if (psMemRead) ! 11937: { ! 11938: cpu.z80E = cpu.z80Base[sdwAddr]; ! 11939: } ! 11940: ! 11941: break; ! 11942: } ! 11943: case 0x5f: ! 11944: { ! 11945: InvalidInstruction(2); ! 11946: break; ! 11947: } ! 11948: case 0x60: ! 11949: { ! 11950: sdwCyclesRemaining -= 9; ! 11951: cpu.z80YH = cpu.z80B; ! 11952: break; ! 11953: } ! 11954: case 0x61: ! 11955: { ! 11956: sdwCyclesRemaining -= 9; ! 11957: cpu.z80YH = cpu.z80C; ! 11958: break; ! 11959: } ! 11960: case 0x62: ! 11961: { ! 11962: sdwCyclesRemaining -= 9; ! 11963: cpu.z80YH = cpu.z80D; ! 11964: break; ! 11965: } ! 11966: case 0x63: ! 11967: { ! 11968: sdwCyclesRemaining -= 9; ! 11969: cpu.z80YH = cpu.z80E; ! 11970: break; ! 11971: } ! 11972: case 0x64: ! 11973: { ! 11974: sdwCyclesRemaining -= 9; ! 11975: break; ! 11976: } ! 11977: case 0x65: ! 11978: { ! 11979: sdwCyclesRemaining -= 9; ! 11980: cpu.z80YH = cpu.z80YL; ! 11981: break; ! 11982: } ! 11983: case 0x66: ! 11984: { ! 11985: sdwCyclesRemaining -= 19; ! 11986: sdwAddr = (INT8) *pbPC++; // Get the offset ! 11987: sdwAddr = ((INT32) cpu.z80IY + sdwAddr) & 0xffff; ! 11988: psMemRead = cpu.z80MemRead; /* Beginning of our handler */ ! 11989: while (psMemRead->lowAddr != 0xffffffff) ! 11990: { ! 11991: if ((sdwAddr >= psMemRead->lowAddr) && (sdwAddr <= psMemRead->highAddr)) ! 11992: { ! 11993: cpu.z80pc = (UINT32) pbPC - (UINT32) cpu.z80Base; ! 11994: if (psMemRead->memoryCall) ! 11995: { ! 11996: cpu.z80H = psMemRead->memoryCall(sdwAddr, psMemRead); ! 11997: } ! 11998: else ! 11999: { ! 12000: cpu.z80H = *((UINT8 *) psMemRead->pUserArea + (sdwAddr - psMemRead->lowAddr)); ! 12001: } ! 12002: psMemRead = NULL; ! 12003: break; ! 12004: } ! 12005: ++psMemRead; ! 12006: } ! 12007: ! 12008: if (psMemRead) ! 12009: { ! 12010: cpu.z80H = cpu.z80Base[sdwAddr]; ! 12011: } ! 12012: ! 12013: break; ! 12014: } ! 12015: case 0x67: ! 12016: { ! 12017: sdwCyclesRemaining -= 9; ! 12018: cpu.z80YH = cpu.z80A; ! 12019: break; ! 12020: } ! 12021: case 0x68: ! 12022: { ! 12023: sdwCyclesRemaining -= 9; ! 12024: cpu.z80YL = cpu.z80B; ! 12025: break; ! 12026: } ! 12027: case 0x69: ! 12028: { ! 12029: sdwCyclesRemaining -= 9; ! 12030: cpu.z80YL = cpu.z80C; ! 12031: break; ! 12032: } ! 12033: case 0x6a: ! 12034: { ! 12035: sdwCyclesRemaining -= 9; ! 12036: cpu.z80YL = cpu.z80D; ! 12037: break; ! 12038: } ! 12039: case 0x6b: ! 12040: { ! 12041: sdwCyclesRemaining -= 9; ! 12042: cpu.z80YL = cpu.z80E; ! 12043: break; ! 12044: } ! 12045: case 0x6c: ! 12046: { ! 12047: sdwCyclesRemaining -= 9; ! 12048: cpu.z80YL = cpu.z80YH; ! 12049: break; ! 12050: } ! 12051: case 0x6d: ! 12052: { ! 12053: sdwCyclesRemaining -= 9; ! 12054: break; ! 12055: } ! 12056: case 0x6e: ! 12057: { ! 12058: sdwCyclesRemaining -= 19; ! 12059: sdwAddr = (INT8) *pbPC++; // Get the offset ! 12060: sdwAddr = ((INT32) cpu.z80IY + sdwAddr) & 0xffff; ! 12061: psMemRead = cpu.z80MemRead; /* Beginning of our handler */ ! 12062: while (psMemRead->lowAddr != 0xffffffff) ! 12063: { ! 12064: if ((sdwAddr >= psMemRead->lowAddr) && (sdwAddr <= psMemRead->highAddr)) ! 12065: { ! 12066: cpu.z80pc = (UINT32) pbPC - (UINT32) cpu.z80Base; ! 12067: if (psMemRead->memoryCall) ! 12068: { ! 12069: cpu.z80L = psMemRead->memoryCall(sdwAddr, psMemRead); ! 12070: } ! 12071: else ! 12072: { ! 12073: cpu.z80L = *((UINT8 *) psMemRead->pUserArea + (sdwAddr - psMemRead->lowAddr)); ! 12074: } ! 12075: psMemRead = NULL; ! 12076: break; ! 12077: } ! 12078: ++psMemRead; ! 12079: } ! 12080: ! 12081: if (psMemRead) ! 12082: { ! 12083: cpu.z80L = cpu.z80Base[sdwAddr]; ! 12084: } ! 12085: ! 12086: break; ! 12087: } ! 12088: case 0x6f: ! 12089: { ! 12090: sdwCyclesRemaining -= 9; ! 12091: cpu.z80YL = cpu.z80A; ! 12092: break; ! 12093: } ! 12094: case 0x70: ! 12095: { ! 12096: sdwCyclesRemaining -= 19; ! 12097: sdwAddr = (INT8) *pbPC++; // Get the offset ! 12098: sdwAddr = ((INT32) cpu.z80IY + sdwAddr) & 0xffff; ! 12099: psMemWrite = cpu.z80MemWrite; /* Beginning of our handler */ ! 12100: while (psMemWrite->lowAddr != 0xffffffff) ! 12101: { ! 12102: if ((sdwAddr >= psMemWrite->lowAddr) && (sdwAddr <= psMemWrite->highAddr)) ! 12103: { ! 12104: cpu.z80pc = (UINT32) pbPC - (UINT32) cpu.z80Base; ! 12105: if (psMemWrite->memoryCall) ! 12106: { ! 12107: psMemWrite->memoryCall(sdwAddr, cpu.z80B, psMemWrite); ! 12108: } ! 12109: else ! 12110: { ! 12111: *((UINT8 *) psMemWrite->pUserArea + (sdwAddr - psMemWrite->lowAddr)) = cpu.z80B; ! 12112: } ! 12113: psMemWrite = NULL; ! 12114: break; ! 12115: } ! 12116: ++psMemWrite; ! 12117: } ! 12118: ! 12119: if (psMemWrite) ! 12120: { ! 12121: cpu.z80Base[sdwAddr] = (UINT8) cpu.z80B; ! 12122: } ! 12123: ! 12124: break; ! 12125: } ! 12126: case 0x71: ! 12127: { ! 12128: sdwCyclesRemaining -= 19; ! 12129: sdwAddr = (INT8) *pbPC++; // Get the offset ! 12130: sdwAddr = ((INT32) cpu.z80IY + sdwAddr) & 0xffff; ! 12131: psMemWrite = cpu.z80MemWrite; /* Beginning of our handler */ ! 12132: while (psMemWrite->lowAddr != 0xffffffff) ! 12133: { ! 12134: if ((sdwAddr >= psMemWrite->lowAddr) && (sdwAddr <= psMemWrite->highAddr)) ! 12135: { ! 12136: cpu.z80pc = (UINT32) pbPC - (UINT32) cpu.z80Base; ! 12137: if (psMemWrite->memoryCall) ! 12138: { ! 12139: psMemWrite->memoryCall(sdwAddr, cpu.z80C, psMemWrite); ! 12140: } ! 12141: else ! 12142: { ! 12143: *((UINT8 *) psMemWrite->pUserArea + (sdwAddr - psMemWrite->lowAddr)) = cpu.z80C; ! 12144: } ! 12145: psMemWrite = NULL; ! 12146: break; ! 12147: } ! 12148: ++psMemWrite; ! 12149: } ! 12150: ! 12151: if (psMemWrite) ! 12152: { ! 12153: cpu.z80Base[sdwAddr] = (UINT8) cpu.z80C; ! 12154: } ! 12155: ! 12156: break; ! 12157: } ! 12158: case 0x72: ! 12159: { ! 12160: sdwCyclesRemaining -= 19; ! 12161: sdwAddr = (INT8) *pbPC++; // Get the offset ! 12162: sdwAddr = ((INT32) cpu.z80IY + sdwAddr) & 0xffff; ! 12163: psMemWrite = cpu.z80MemWrite; /* Beginning of our handler */ ! 12164: while (psMemWrite->lowAddr != 0xffffffff) ! 12165: { ! 12166: if ((sdwAddr >= psMemWrite->lowAddr) && (sdwAddr <= psMemWrite->highAddr)) ! 12167: { ! 12168: cpu.z80pc = (UINT32) pbPC - (UINT32) cpu.z80Base; ! 12169: if (psMemWrite->memoryCall) ! 12170: { ! 12171: psMemWrite->memoryCall(sdwAddr, cpu.z80D, psMemWrite); ! 12172: } ! 12173: else ! 12174: { ! 12175: *((UINT8 *) psMemWrite->pUserArea + (sdwAddr - psMemWrite->lowAddr)) = cpu.z80D; ! 12176: } ! 12177: psMemWrite = NULL; ! 12178: break; ! 12179: } ! 12180: ++psMemWrite; ! 12181: } ! 12182: ! 12183: if (psMemWrite) ! 12184: { ! 12185: cpu.z80Base[sdwAddr] = (UINT8) cpu.z80D; ! 12186: } ! 12187: ! 12188: break; ! 12189: } ! 12190: case 0x73: ! 12191: { ! 12192: sdwCyclesRemaining -= 19; ! 12193: sdwAddr = (INT8) *pbPC++; // Get the offset ! 12194: sdwAddr = ((INT32) cpu.z80IY + sdwAddr) & 0xffff; ! 12195: psMemWrite = cpu.z80MemWrite; /* Beginning of our handler */ ! 12196: while (psMemWrite->lowAddr != 0xffffffff) ! 12197: { ! 12198: if ((sdwAddr >= psMemWrite->lowAddr) && (sdwAddr <= psMemWrite->highAddr)) ! 12199: { ! 12200: cpu.z80pc = (UINT32) pbPC - (UINT32) cpu.z80Base; ! 12201: if (psMemWrite->memoryCall) ! 12202: { ! 12203: psMemWrite->memoryCall(sdwAddr, cpu.z80E, psMemWrite); ! 12204: } ! 12205: else ! 12206: { ! 12207: *((UINT8 *) psMemWrite->pUserArea + (sdwAddr - psMemWrite->lowAddr)) = cpu.z80E; ! 12208: } ! 12209: psMemWrite = NULL; ! 12210: break; ! 12211: } ! 12212: ++psMemWrite; ! 12213: } ! 12214: ! 12215: if (psMemWrite) ! 12216: { ! 12217: cpu.z80Base[sdwAddr] = (UINT8) cpu.z80E; ! 12218: } ! 12219: ! 12220: break; ! 12221: } ! 12222: case 0x74: ! 12223: { ! 12224: sdwCyclesRemaining -= 19; ! 12225: sdwAddr = (INT8) *pbPC++; // Get the offset ! 12226: sdwAddr = ((INT32) cpu.z80IY + sdwAddr) & 0xffff; ! 12227: psMemWrite = cpu.z80MemWrite; /* Beginning of our handler */ ! 12228: while (psMemWrite->lowAddr != 0xffffffff) ! 12229: { ! 12230: if ((sdwAddr >= psMemWrite->lowAddr) && (sdwAddr <= psMemWrite->highAddr)) ! 12231: { ! 12232: cpu.z80pc = (UINT32) pbPC - (UINT32) cpu.z80Base; ! 12233: if (psMemWrite->memoryCall) ! 12234: { ! 12235: psMemWrite->memoryCall(sdwAddr, cpu.z80H, psMemWrite); ! 12236: } ! 12237: else ! 12238: { ! 12239: *((UINT8 *) psMemWrite->pUserArea + (sdwAddr - psMemWrite->lowAddr)) = cpu.z80H; ! 12240: } ! 12241: psMemWrite = NULL; ! 12242: break; ! 12243: } ! 12244: ++psMemWrite; ! 12245: } ! 12246: ! 12247: if (psMemWrite) ! 12248: { ! 12249: cpu.z80Base[sdwAddr] = (UINT8) cpu.z80H; ! 12250: } ! 12251: ! 12252: break; ! 12253: } ! 12254: case 0x75: ! 12255: { ! 12256: sdwCyclesRemaining -= 19; ! 12257: sdwAddr = (INT8) *pbPC++; // Get the offset ! 12258: sdwAddr = ((INT32) cpu.z80IY + sdwAddr) & 0xffff; ! 12259: psMemWrite = cpu.z80MemWrite; /* Beginning of our handler */ ! 12260: while (psMemWrite->lowAddr != 0xffffffff) ! 12261: { ! 12262: if ((sdwAddr >= psMemWrite->lowAddr) && (sdwAddr <= psMemWrite->highAddr)) ! 12263: { ! 12264: cpu.z80pc = (UINT32) pbPC - (UINT32) cpu.z80Base; ! 12265: if (psMemWrite->memoryCall) ! 12266: { ! 12267: psMemWrite->memoryCall(sdwAddr, cpu.z80L, psMemWrite); ! 12268: } ! 12269: else ! 12270: { ! 12271: *((UINT8 *) psMemWrite->pUserArea + (sdwAddr - psMemWrite->lowAddr)) = cpu.z80L; ! 12272: } ! 12273: psMemWrite = NULL; ! 12274: break; ! 12275: } ! 12276: ++psMemWrite; ! 12277: } ! 12278: ! 12279: if (psMemWrite) ! 12280: { ! 12281: cpu.z80Base[sdwAddr] = (UINT8) cpu.z80L; ! 12282: } ! 12283: ! 12284: break; ! 12285: } ! 12286: case 0x76: ! 12287: { ! 12288: sdwCyclesRemaining -= 19; ! 12289: InvalidInstruction(2); ! 12290: break; ! 12291: } ! 12292: case 0x77: ! 12293: { ! 12294: sdwCyclesRemaining -= 19; ! 12295: sdwAddr = (INT8) *pbPC++; // Get the offset ! 12296: sdwAddr = ((INT32) cpu.z80IY + sdwAddr) & 0xffff; ! 12297: psMemWrite = cpu.z80MemWrite; /* Beginning of our handler */ ! 12298: while (psMemWrite->lowAddr != 0xffffffff) ! 12299: { ! 12300: if ((sdwAddr >= psMemWrite->lowAddr) && (sdwAddr <= psMemWrite->highAddr)) ! 12301: { ! 12302: cpu.z80pc = (UINT32) pbPC - (UINT32) cpu.z80Base; ! 12303: if (psMemWrite->memoryCall) ! 12304: { ! 12305: psMemWrite->memoryCall(sdwAddr, cpu.z80A, psMemWrite); ! 12306: } ! 12307: else ! 12308: { ! 12309: *((UINT8 *) psMemWrite->pUserArea + (sdwAddr - psMemWrite->lowAddr)) = cpu.z80A; ! 12310: } ! 12311: psMemWrite = NULL; ! 12312: break; ! 12313: } ! 12314: ++psMemWrite; ! 12315: } ! 12316: ! 12317: if (psMemWrite) ! 12318: { ! 12319: cpu.z80Base[sdwAddr] = (UINT8) cpu.z80A; ! 12320: } ! 12321: ! 12322: break; ! 12323: } ! 12324: case 0x78: ! 12325: { ! 12326: InvalidInstruction(2); ! 12327: break; ! 12328: } ! 12329: case 0x79: ! 12330: { ! 12331: InvalidInstruction(2); ! 12332: break; ! 12333: } ! 12334: case 0x7a: ! 12335: { ! 12336: InvalidInstruction(2); ! 12337: break; ! 12338: } ! 12339: case 0x7b: ! 12340: { ! 12341: InvalidInstruction(2); ! 12342: break; ! 12343: } ! 12344: case 0x7c: ! 12345: { ! 12346: sdwCyclesRemaining -= 9; ! 12347: cpu.z80A = cpu.z80YH; ! 12348: break; ! 12349: } ! 12350: case 0x7d: ! 12351: { ! 12352: sdwCyclesRemaining -= 9; ! 12353: cpu.z80A = cpu.z80YL; ! 12354: break; ! 12355: } ! 12356: case 0x7e: ! 12357: { ! 12358: sdwCyclesRemaining -= 19; ! 12359: sdwAddr = (INT8) *pbPC++; // Get the offset ! 12360: sdwAddr = ((INT32) cpu.z80IY + sdwAddr) & 0xffff; ! 12361: psMemRead = cpu.z80MemRead; /* Beginning of our handler */ ! 12362: while (psMemRead->lowAddr != 0xffffffff) ! 12363: { ! 12364: if ((sdwAddr >= psMemRead->lowAddr) && (sdwAddr <= psMemRead->highAddr)) ! 12365: { ! 12366: cpu.z80pc = (UINT32) pbPC - (UINT32) cpu.z80Base; ! 12367: if (psMemRead->memoryCall) ! 12368: { ! 12369: cpu.z80A = psMemRead->memoryCall(sdwAddr, psMemRead); ! 12370: } ! 12371: else ! 12372: { ! 12373: cpu.z80A = *((UINT8 *) psMemRead->pUserArea + (sdwAddr - psMemRead->lowAddr)); ! 12374: } ! 12375: psMemRead = NULL; ! 12376: break; ! 12377: } ! 12378: ++psMemRead; ! 12379: } ! 12380: ! 12381: if (psMemRead) ! 12382: { ! 12383: cpu.z80A = cpu.z80Base[sdwAddr]; ! 12384: } ! 12385: ! 12386: break; ! 12387: } ! 12388: case 0x7f: ! 12389: { ! 12390: InvalidInstruction(2); ! 12391: break; ! 12392: } ! 12393: case 0x80: ! 12394: { ! 12395: InvalidInstruction(2); ! 12396: break; ! 12397: } ! 12398: case 0x81: ! 12399: { ! 12400: InvalidInstruction(2); ! 12401: break; ! 12402: } ! 12403: case 0x82: ! 12404: { ! 12405: InvalidInstruction(2); ! 12406: break; ! 12407: } ! 12408: case 0x83: ! 12409: { ! 12410: InvalidInstruction(2); ! 12411: break; ! 12412: } ! 12413: case 0x84: ! 12414: { ! 12415: sdwCyclesRemaining -= 9; ! 12416: bTemp2 = cpu.z80A + cpu.z80YH; ! 12417: cpu.z80F = (cpu.z80F & ~(Z80_FLAG_CARRY | Z80_FLAG_NEGATIVE | Z80_FLAG_OVERFLOW_PARITY | ! 12418: Z80_FLAG_HALF_CARRY | Z80_FLAG_ZERO | Z80_FLAG_SIGN)) | ! 12419: pbAddAdcTable[((UINT32) cpu.z80A << 8) | cpu.z80YH]; ! 12420: break; ! 12421: } ! 12422: case 0x85: ! 12423: { ! 12424: sdwCyclesRemaining -= 9; ! 12425: bTemp2 = cpu.z80A + cpu.z80YL; ! 12426: cpu.z80F = (cpu.z80F & ~(Z80_FLAG_CARRY | Z80_FLAG_NEGATIVE | Z80_FLAG_OVERFLOW_PARITY | ! 12427: Z80_FLAG_HALF_CARRY | Z80_FLAG_ZERO | Z80_FLAG_SIGN)) | ! 12428: pbAddAdcTable[((UINT32) cpu.z80A << 8) | cpu.z80YL]; ! 12429: break; ! 12430: } ! 12431: case 0x86: ! 12432: { ! 12433: sdwCyclesRemaining -= 19; ! 12434: sdwAddr = (INT8) *pbPC++; /* Get LSB first */ ! 12435: dwAddr = (sdwAddr + (INT32) cpu.z80IY) & 0xffff; ! 12436: psMemRead = cpu.z80MemRead; /* Beginning of our handler */ ! 12437: while (psMemRead->lowAddr != 0xffffffff) ! 12438: { ! 12439: if ((dwAddr >= psMemRead->lowAddr) && (dwAddr <= psMemRead->highAddr)) ! 12440: { ! 12441: cpu.z80pc = (UINT32) pbPC - (UINT32) cpu.z80Base; ! 12442: if (psMemRead->memoryCall) ! 12443: { ! 12444: bTemp = psMemRead->memoryCall(dwAddr, psMemRead); ! 12445: } ! 12446: else ! 12447: { ! 12448: bTemp = *((UINT8 *) psMemRead->pUserArea + (dwAddr - psMemRead->lowAddr)); ! 12449: } ! 12450: psMemRead = NULL; ! 12451: break; ! 12452: } ! 12453: ++psMemRead; ! 12454: } ! 12455: ! 12456: if (psMemRead) ! 12457: { ! 12458: bTemp = cpu.z80Base[dwAddr]; ! 12459: } ! 12460: ! 12461: cpu.z80F = (cpu.z80F & ~(Z80_FLAG_CARRY | Z80_FLAG_NEGATIVE | Z80_FLAG_OVERFLOW_PARITY | ! 12462: Z80_FLAG_HALF_CARRY | Z80_FLAG_ZERO | Z80_FLAG_SIGN)) | ! 12463: pbAddAdcTable[((UINT32) cpu.z80A << 8) | bTemp]; ! 12464: cpu.z80A += bTemp; ! 12465: break; ! 12466: } ! 12467: case 0x87: ! 12468: { ! 12469: InvalidInstruction(2); ! 12470: break; ! 12471: } ! 12472: case 0x88: ! 12473: { ! 12474: InvalidInstruction(2); ! 12475: break; ! 12476: } ! 12477: case 0x89: ! 12478: { ! 12479: InvalidInstruction(2); ! 12480: break; ! 12481: } ! 12482: case 0x8a: ! 12483: { ! 12484: InvalidInstruction(2); ! 12485: break; ! 12486: } ! 12487: case 0x8b: ! 12488: { ! 12489: InvalidInstruction(2); ! 12490: break; ! 12491: } ! 12492: case 0x8c: ! 12493: { ! 12494: sdwCyclesRemaining -= 9; ! 12495: bTemp2 = cpu.z80A + cpu.z80YH + (cpu.z80F & Z80_FLAG_CARRY); ! 12496: cpu.z80F = (cpu.z80F & ~(Z80_FLAG_CARRY | Z80_FLAG_NEGATIVE | Z80_FLAG_OVERFLOW_PARITY | ! 12497: Z80_FLAG_HALF_CARRY | Z80_FLAG_ZERO | Z80_FLAG_SIGN)) | ! 12498: pbAddAdcTable[((UINT32) cpu.z80A << 8) | cpu.z80YH | (((UINT32) cpu.z80F & Z80_FLAG_CARRY) << 16)]; ! 12499: break; ! 12500: } ! 12501: case 0x8d: ! 12502: { ! 12503: sdwCyclesRemaining -= 9; ! 12504: bTemp2 = cpu.z80A + cpu.z80YL + (cpu.z80F & Z80_FLAG_CARRY); ! 12505: cpu.z80F = (cpu.z80F & ~(Z80_FLAG_CARRY | Z80_FLAG_NEGATIVE | Z80_FLAG_OVERFLOW_PARITY | ! 12506: Z80_FLAG_HALF_CARRY | Z80_FLAG_ZERO | Z80_FLAG_SIGN)) | ! 12507: pbAddAdcTable[((UINT32) cpu.z80A << 8) | cpu.z80YL | (((UINT32) cpu.z80F & Z80_FLAG_CARRY) << 16)]; ! 12508: break; ! 12509: } ! 12510: case 0x8e: ! 12511: { ! 12512: sdwCyclesRemaining -= 19; ! 12513: sdwAddr = (INT8) *pbPC++; /* Get LSB first */ ! 12514: dwAddr = (sdwAddr + (INT32) cpu.z80IY) & 0xffff; ! 12515: psMemRead = cpu.z80MemRead; /* Beginning of our handler */ ! 12516: while (psMemRead->lowAddr != 0xffffffff) ! 12517: { ! 12518: if ((dwAddr >= psMemRead->lowAddr) && (dwAddr <= psMemRead->highAddr)) ! 12519: { ! 12520: cpu.z80pc = (UINT32) pbPC - (UINT32) cpu.z80Base; ! 12521: if (psMemRead->memoryCall) ! 12522: { ! 12523: bTemp = psMemRead->memoryCall(dwAddr, psMemRead); ! 12524: } ! 12525: else ! 12526: { ! 12527: bTemp = *((UINT8 *) psMemRead->pUserArea + (dwAddr - psMemRead->lowAddr)); ! 12528: } ! 12529: psMemRead = NULL; ! 12530: break; ! 12531: } ! 12532: ++psMemRead; ! 12533: } ! 12534: ! 12535: if (psMemRead) ! 12536: { ! 12537: bTemp = cpu.z80Base[dwAddr]; ! 12538: } ! 12539: ! 12540: bTemp2 = (cpu.z80F & Z80_FLAG_CARRY); ! 12541: cpu.z80F = (cpu.z80F & ~(Z80_FLAG_CARRY | Z80_FLAG_NEGATIVE | Z80_FLAG_OVERFLOW_PARITY | ! 12542: Z80_FLAG_HALF_CARRY | Z80_FLAG_ZERO | Z80_FLAG_SIGN)) | ! 12543: pbAddAdcTable[((UINT32) cpu.z80A << 8) | bTemp | (((UINT32) cpu.z80F & Z80_FLAG_CARRY) << 16)]; ! 12544: cpu.z80A += bTemp + bTemp2; ! 12545: break; ! 12546: } ! 12547: case 0x8f: ! 12548: { ! 12549: InvalidInstruction(2); ! 12550: break; ! 12551: } ! 12552: case 0x90: ! 12553: { ! 12554: InvalidInstruction(2); ! 12555: break; ! 12556: } ! 12557: case 0x91: ! 12558: { ! 12559: InvalidInstruction(2); ! 12560: break; ! 12561: } ! 12562: case 0x92: ! 12563: { ! 12564: InvalidInstruction(2); ! 12565: break; ! 12566: } ! 12567: case 0x93: ! 12568: { ! 12569: InvalidInstruction(2); ! 12570: break; ! 12571: } ! 12572: case 0x94: ! 12573: { ! 12574: sdwCyclesRemaining -= 9; ! 12575: bTemp2 = cpu.z80A - cpu.z80YH; ! 12576: cpu.z80F = (cpu.z80F & ~(Z80_FLAG_CARRY | Z80_FLAG_NEGATIVE | Z80_FLAG_OVERFLOW_PARITY | ! 12577: Z80_FLAG_HALF_CARRY | Z80_FLAG_ZERO | Z80_FLAG_SIGN)) | ! 12578: pbSubSbcTable[((UINT32) cpu.z80A << 8) | cpu.z80YH]; ! 12579: break; ! 12580: } ! 12581: case 0x95: ! 12582: { ! 12583: sdwCyclesRemaining -= 9; ! 12584: bTemp2 = cpu.z80A - cpu.z80YL; ! 12585: cpu.z80F = (cpu.z80F & ~(Z80_FLAG_CARRY | Z80_FLAG_NEGATIVE | Z80_FLAG_OVERFLOW_PARITY | ! 12586: Z80_FLAG_HALF_CARRY | Z80_FLAG_ZERO | Z80_FLAG_SIGN)) | ! 12587: pbSubSbcTable[((UINT32) cpu.z80A << 8) | cpu.z80YL]; ! 12588: break; ! 12589: } ! 12590: case 0x96: ! 12591: { ! 12592: sdwCyclesRemaining -= 19; ! 12593: sdwAddr = (INT8) *pbPC++; /* Get LSB first */ ! 12594: dwAddr = (sdwAddr + (INT32) cpu.z80IY) & 0xffff; ! 12595: psMemRead = cpu.z80MemRead; /* Beginning of our handler */ ! 12596: while (psMemRead->lowAddr != 0xffffffff) ! 12597: { ! 12598: if ((dwAddr >= psMemRead->lowAddr) && (dwAddr <= psMemRead->highAddr)) ! 12599: { ! 12600: cpu.z80pc = (UINT32) pbPC - (UINT32) cpu.z80Base; ! 12601: if (psMemRead->memoryCall) ! 12602: { ! 12603: bTemp = psMemRead->memoryCall(dwAddr, psMemRead); ! 12604: } ! 12605: else ! 12606: { ! 12607: bTemp = *((UINT8 *) psMemRead->pUserArea + (dwAddr - psMemRead->lowAddr)); ! 12608: } ! 12609: psMemRead = NULL; ! 12610: break; ! 12611: } ! 12612: ++psMemRead; ! 12613: } ! 12614: ! 12615: if (psMemRead) ! 12616: { ! 12617: bTemp = cpu.z80Base[dwAddr]; ! 12618: } ! 12619: ! 12620: cpu.z80F = (cpu.z80F & ~(Z80_FLAG_CARRY | Z80_FLAG_NEGATIVE | Z80_FLAG_OVERFLOW_PARITY | ! 12621: Z80_FLAG_HALF_CARRY | Z80_FLAG_ZERO | Z80_FLAG_SIGN)) | ! 12622: pbSubSbcTable[((UINT32) cpu.z80A << 8) | bTemp]; ! 12623: cpu.z80A -= bTemp; ! 12624: break; ! 12625: } ! 12626: case 0x97: ! 12627: { ! 12628: InvalidInstruction(2); ! 12629: break; ! 12630: } ! 12631: case 0x98: ! 12632: { ! 12633: InvalidInstruction(2); ! 12634: break; ! 12635: } ! 12636: case 0x99: ! 12637: { ! 12638: InvalidInstruction(2); ! 12639: break; ! 12640: } ! 12641: case 0x9a: ! 12642: { ! 12643: InvalidInstruction(2); ! 12644: break; ! 12645: } ! 12646: case 0x9b: ! 12647: { ! 12648: InvalidInstruction(2); ! 12649: break; ! 12650: } ! 12651: case 0x9c: ! 12652: { ! 12653: sdwCyclesRemaining -= 9; ! 12654: bTemp2 = cpu.z80A - cpu.z80YH - (cpu.z80F & Z80_FLAG_CARRY); ! 12655: cpu.z80F = (cpu.z80F & ~(Z80_FLAG_CARRY | Z80_FLAG_NEGATIVE | Z80_FLAG_OVERFLOW_PARITY | ! 12656: Z80_FLAG_HALF_CARRY | Z80_FLAG_ZERO | Z80_FLAG_SIGN)) | ! 12657: pbSubSbcTable[((UINT32) cpu.z80A << 8) | cpu.z80YH | (((UINT32) cpu.z80F & Z80_FLAG_CARRY) << 16)]; ! 12658: break; ! 12659: } ! 12660: case 0x9d: ! 12661: { ! 12662: sdwCyclesRemaining -= 9; ! 12663: bTemp2 = cpu.z80A - cpu.z80YL - (cpu.z80F & Z80_FLAG_CARRY); ! 12664: cpu.z80F = (cpu.z80F & ~(Z80_FLAG_CARRY | Z80_FLAG_NEGATIVE | Z80_FLAG_OVERFLOW_PARITY | ! 12665: Z80_FLAG_HALF_CARRY | Z80_FLAG_ZERO | Z80_FLAG_SIGN)) | ! 12666: pbSubSbcTable[((UINT32) cpu.z80A << 8) | cpu.z80YL | (((UINT32) cpu.z80F & Z80_FLAG_CARRY) << 16)]; ! 12667: break; ! 12668: } ! 12669: case 0x9e: ! 12670: { ! 12671: sdwCyclesRemaining -= 19; ! 12672: sdwAddr = (INT8) *pbPC++; /* Get LSB first */ ! 12673: dwAddr = (sdwAddr + (INT32) cpu.z80IY) & 0xffff; ! 12674: psMemRead = cpu.z80MemRead; /* Beginning of our handler */ ! 12675: while (psMemRead->lowAddr != 0xffffffff) ! 12676: { ! 12677: if ((dwAddr >= psMemRead->lowAddr) && (dwAddr <= psMemRead->highAddr)) ! 12678: { ! 12679: cpu.z80pc = (UINT32) pbPC - (UINT32) cpu.z80Base; ! 12680: if (psMemRead->memoryCall) ! 12681: { ! 12682: bTemp = psMemRead->memoryCall(dwAddr, psMemRead); ! 12683: } ! 12684: else ! 12685: { ! 12686: bTemp = *((UINT8 *) psMemRead->pUserArea + (dwAddr - psMemRead->lowAddr)); ! 12687: } ! 12688: psMemRead = NULL; ! 12689: break; ! 12690: } ! 12691: ++psMemRead; ! 12692: } ! 12693: ! 12694: if (psMemRead) ! 12695: { ! 12696: bTemp = cpu.z80Base[dwAddr]; ! 12697: } ! 12698: ! 12699: bTemp2 = cpu.z80A; ! 12700: cpu.z80A = cpu.z80A - bTemp - (cpu.z80F & Z80_FLAG_CARRY); ! 12701: cpu.z80F = (cpu.z80F & ~(Z80_FLAG_CARRY | Z80_FLAG_NEGATIVE | Z80_FLAG_OVERFLOW_PARITY | ! 12702: Z80_FLAG_HALF_CARRY | Z80_FLAG_ZERO | Z80_FLAG_SIGN)) | ! 12703: pbSubSbcTable[((UINT32) bTemp2 << 8) | bTemp | (((UINT32) cpu.z80F & Z80_FLAG_CARRY) << 16)]; ! 12704: break; ! 12705: } ! 12706: case 0x9f: ! 12707: { ! 12708: InvalidInstruction(2); ! 12709: break; ! 12710: } ! 12711: case 0xa0: ! 12712: { ! 12713: InvalidInstruction(2); ! 12714: break; ! 12715: } ! 12716: case 0xa1: ! 12717: { ! 12718: InvalidInstruction(2); ! 12719: break; ! 12720: } ! 12721: case 0xa2: ! 12722: { ! 12723: InvalidInstruction(2); ! 12724: break; ! 12725: } ! 12726: case 0xa3: ! 12727: { ! 12728: InvalidInstruction(2); ! 12729: break; ! 12730: } ! 12731: case 0xa4: ! 12732: { ! 12733: sdwCyclesRemaining -= 9; ! 12734: cpu.z80A &= cpu.z80YH; ! 12735: cpu.z80F &= ~(Z80_FLAG_CARRY | Z80_FLAG_NEGATIVE | Z80_FLAG_OVERFLOW_PARITY | Z80_FLAG_HALF_CARRY | Z80_FLAG_ZERO | Z80_FLAG_SIGN); ! 12736: cpu.z80F |= bPostANDFlags[cpu.z80A]; ! 12737: ! 12738: break; ! 12739: } ! 12740: case 0xa5: ! 12741: { ! 12742: sdwCyclesRemaining -= 9; ! 12743: cpu.z80A &= cpu.z80YL; ! 12744: cpu.z80F &= ~(Z80_FLAG_CARRY | Z80_FLAG_NEGATIVE | Z80_FLAG_OVERFLOW_PARITY | Z80_FLAG_HALF_CARRY | Z80_FLAG_ZERO | Z80_FLAG_SIGN); ! 12745: cpu.z80F |= bPostANDFlags[cpu.z80A]; ! 12746: ! 12747: break; ! 12748: } ! 12749: case 0xa6: ! 12750: { ! 12751: sdwCyclesRemaining -= 19; ! 12752: sdwAddr = (INT8) *pbPC++; /* Get LSB first */ ! 12753: dwAddr = (sdwAddr + (INT32) cpu.z80IY) & 0xffff; ! 12754: psMemRead = cpu.z80MemRead; /* Beginning of our handler */ ! 12755: while (psMemRead->lowAddr != 0xffffffff) ! 12756: { ! 12757: if ((dwAddr >= psMemRead->lowAddr) && (dwAddr <= psMemRead->highAddr)) ! 12758: { ! 12759: cpu.z80pc = (UINT32) pbPC - (UINT32) cpu.z80Base; ! 12760: if (psMemRead->memoryCall) ! 12761: { ! 12762: bTemp = psMemRead->memoryCall(dwAddr, psMemRead); ! 12763: } ! 12764: else ! 12765: { ! 12766: bTemp = *((UINT8 *) psMemRead->pUserArea + (dwAddr - psMemRead->lowAddr)); ! 12767: } ! 12768: psMemRead = NULL; ! 12769: break; ! 12770: } ! 12771: ++psMemRead; ! 12772: } ! 12773: ! 12774: if (psMemRead) ! 12775: { ! 12776: bTemp = cpu.z80Base[dwAddr]; ! 12777: } ! 12778: ! 12779: cpu.z80A &= bTemp; ! 12780: cpu.z80F &= ~(Z80_FLAG_CARRY | Z80_FLAG_NEGATIVE | Z80_FLAG_OVERFLOW_PARITY | Z80_FLAG_HALF_CARRY | Z80_FLAG_ZERO | Z80_FLAG_SIGN); ! 12781: cpu.z80F |= bPostANDFlags[cpu.z80A]; ! 12782: ! 12783: break; ! 12784: } ! 12785: case 0xa7: ! 12786: { ! 12787: InvalidInstruction(2); ! 12788: break; ! 12789: } ! 12790: case 0xa8: ! 12791: { ! 12792: InvalidInstruction(2); ! 12793: break; ! 12794: } ! 12795: case 0xa9: ! 12796: { ! 12797: InvalidInstruction(2); ! 12798: break; ! 12799: } ! 12800: case 0xaa: ! 12801: { ! 12802: InvalidInstruction(2); ! 12803: break; ! 12804: } ! 12805: case 0xab: ! 12806: { ! 12807: InvalidInstruction(2); ! 12808: break; ! 12809: } ! 12810: case 0xac: ! 12811: { ! 12812: sdwCyclesRemaining -= 9; ! 12813: cpu.z80A ^= cpu.z80YH; ! 12814: cpu.z80F &= ~(Z80_FLAG_CARRY | Z80_FLAG_NEGATIVE | Z80_FLAG_OVERFLOW_PARITY | Z80_FLAG_HALF_CARRY | Z80_FLAG_ZERO | Z80_FLAG_SIGN); ! 12815: cpu.z80F |= bPostORFlags[cpu.z80A]; ! 12816: ! 12817: break; ! 12818: } ! 12819: case 0xad: ! 12820: { ! 12821: sdwCyclesRemaining -= 9; ! 12822: cpu.z80A ^= cpu.z80YL; ! 12823: cpu.z80F &= ~(Z80_FLAG_CARRY | Z80_FLAG_NEGATIVE | Z80_FLAG_OVERFLOW_PARITY | Z80_FLAG_HALF_CARRY | Z80_FLAG_ZERO | Z80_FLAG_SIGN); ! 12824: cpu.z80F |= bPostORFlags[cpu.z80A]; ! 12825: ! 12826: break; ! 12827: } ! 12828: case 0xae: ! 12829: { ! 12830: sdwCyclesRemaining -= 19; ! 12831: sdwAddr = (INT8) *pbPC++; /* Get LSB first */ ! 12832: dwAddr = (sdwAddr + (INT32) cpu.z80IY) & 0xffff; ! 12833: psMemRead = cpu.z80MemRead; /* Beginning of our handler */ ! 12834: while (psMemRead->lowAddr != 0xffffffff) ! 12835: { ! 12836: if ((dwAddr >= psMemRead->lowAddr) && (dwAddr <= psMemRead->highAddr)) ! 12837: { ! 12838: cpu.z80pc = (UINT32) pbPC - (UINT32) cpu.z80Base; ! 12839: if (psMemRead->memoryCall) ! 12840: { ! 12841: bTemp = psMemRead->memoryCall(dwAddr, psMemRead); ! 12842: } ! 12843: else ! 12844: { ! 12845: bTemp = *((UINT8 *) psMemRead->pUserArea + (dwAddr - psMemRead->lowAddr)); ! 12846: } ! 12847: psMemRead = NULL; ! 12848: break; ! 12849: } ! 12850: ++psMemRead; ! 12851: } ! 12852: ! 12853: if (psMemRead) ! 12854: { ! 12855: bTemp = cpu.z80Base[dwAddr]; ! 12856: } ! 12857: ! 12858: cpu.z80A ^= bTemp; ! 12859: cpu.z80F &= ~(Z80_FLAG_CARRY | Z80_FLAG_NEGATIVE | Z80_FLAG_OVERFLOW_PARITY | Z80_FLAG_HALF_CARRY | Z80_FLAG_ZERO | Z80_FLAG_SIGN); ! 12860: cpu.z80F |= bPostORFlags[cpu.z80A]; ! 12861: ! 12862: break; ! 12863: } ! 12864: case 0xaf: ! 12865: { ! 12866: InvalidInstruction(2); ! 12867: break; ! 12868: } ! 12869: case 0xb0: ! 12870: { ! 12871: InvalidInstruction(2); ! 12872: break; ! 12873: } ! 12874: case 0xb1: ! 12875: { ! 12876: InvalidInstruction(2); ! 12877: break; ! 12878: } ! 12879: case 0xb2: ! 12880: { ! 12881: InvalidInstruction(2); ! 12882: break; ! 12883: } ! 12884: case 0xb3: ! 12885: { ! 12886: InvalidInstruction(2); ! 12887: break; ! 12888: } ! 12889: case 0xb4: ! 12890: { ! 12891: sdwCyclesRemaining -= 9; ! 12892: cpu.z80A |= cpu.z80YH; ! 12893: cpu.z80F &= ~(Z80_FLAG_CARRY | Z80_FLAG_NEGATIVE | Z80_FLAG_OVERFLOW_PARITY | Z80_FLAG_HALF_CARRY | Z80_FLAG_ZERO | Z80_FLAG_SIGN); ! 12894: cpu.z80F |= bPostORFlags[cpu.z80A]; ! 12895: ! 12896: break; ! 12897: } ! 12898: case 0xb5: ! 12899: { ! 12900: sdwCyclesRemaining -= 9; ! 12901: cpu.z80A |= cpu.z80YL; ! 12902: cpu.z80F &= ~(Z80_FLAG_CARRY | Z80_FLAG_NEGATIVE | Z80_FLAG_OVERFLOW_PARITY | Z80_FLAG_HALF_CARRY | Z80_FLAG_ZERO | Z80_FLAG_SIGN); ! 12903: cpu.z80F |= bPostORFlags[cpu.z80A]; ! 12904: ! 12905: break; ! 12906: } ! 12907: case 0xb6: ! 12908: { ! 12909: sdwCyclesRemaining -= 19; ! 12910: sdwAddr = (INT8) *pbPC++; /* Get LSB first */ ! 12911: dwAddr = (sdwAddr + (INT32) cpu.z80IY) & 0xffff; ! 12912: psMemRead = cpu.z80MemRead; /* Beginning of our handler */ ! 12913: while (psMemRead->lowAddr != 0xffffffff) ! 12914: { ! 12915: if ((dwAddr >= psMemRead->lowAddr) && (dwAddr <= psMemRead->highAddr)) ! 12916: { ! 12917: cpu.z80pc = (UINT32) pbPC - (UINT32) cpu.z80Base; ! 12918: if (psMemRead->memoryCall) ! 12919: { ! 12920: bTemp = psMemRead->memoryCall(dwAddr, psMemRead); ! 12921: } ! 12922: else ! 12923: { ! 12924: bTemp = *((UINT8 *) psMemRead->pUserArea + (dwAddr - psMemRead->lowAddr)); ! 12925: } ! 12926: psMemRead = NULL; ! 12927: break; ! 12928: } ! 12929: ++psMemRead; ! 12930: } ! 12931: ! 12932: if (psMemRead) ! 12933: { ! 12934: bTemp = cpu.z80Base[dwAddr]; ! 12935: } ! 12936: ! 12937: cpu.z80A |= bTemp; ! 12938: cpu.z80F &= ~(Z80_FLAG_CARRY | Z80_FLAG_NEGATIVE | Z80_FLAG_OVERFLOW_PARITY | Z80_FLAG_HALF_CARRY | Z80_FLAG_ZERO | Z80_FLAG_SIGN); ! 12939: cpu.z80F |= bPostORFlags[cpu.z80A]; ! 12940: ! 12941: break; ! 12942: } ! 12943: case 0xb7: ! 12944: { ! 12945: InvalidInstruction(2); ! 12946: break; ! 12947: } ! 12948: case 0xb8: ! 12949: { ! 12950: InvalidInstruction(2); ! 12951: break; ! 12952: } ! 12953: case 0xb9: ! 12954: { ! 12955: InvalidInstruction(2); ! 12956: break; ! 12957: } ! 12958: case 0xba: ! 12959: { ! 12960: InvalidInstruction(2); ! 12961: break; ! 12962: } ! 12963: case 0xbb: ! 12964: { ! 12965: InvalidInstruction(2); ! 12966: break; ! 12967: } ! 12968: case 0xbc: ! 12969: { ! 12970: sdwCyclesRemaining -= 9; ! 12971: cpu.z80F &= ~(Z80_FLAG_CARRY | Z80_FLAG_NEGATIVE | Z80_FLAG_OVERFLOW_PARITY | Z80_FLAG_HALF_CARRY | Z80_FLAG_ZERO | Z80_FLAG_SIGN); ! 12972: cpu.z80F |= bPostORFlags[cpu.z80A]; ! 12973: ! 12974: break; ! 12975: } ! 12976: case 0xbd: ! 12977: { ! 12978: sdwCyclesRemaining -= 9; ! 12979: cpu.z80F &= ~(Z80_FLAG_CARRY | Z80_FLAG_NEGATIVE | Z80_FLAG_OVERFLOW_PARITY | Z80_FLAG_HALF_CARRY | Z80_FLAG_ZERO | Z80_FLAG_SIGN); ! 12980: cpu.z80F |= bPostORFlags[cpu.z80A]; ! 12981: ! 12982: break; ! 12983: } ! 12984: case 0xbe: ! 12985: { ! 12986: sdwCyclesRemaining -= 19; ! 12987: sdwAddr = (INT8) *pbPC++; /* Get LSB first */ ! 12988: dwAddr = (sdwAddr + (INT32) cpu.z80IY) & 0xffff; ! 12989: psMemRead = cpu.z80MemRead; /* Beginning of our handler */ ! 12990: while (psMemRead->lowAddr != 0xffffffff) ! 12991: { ! 12992: if ((dwAddr >= psMemRead->lowAddr) && (dwAddr <= psMemRead->highAddr)) ! 12993: { ! 12994: cpu.z80pc = (UINT32) pbPC - (UINT32) cpu.z80Base; ! 12995: if (psMemRead->memoryCall) ! 12996: { ! 12997: bTemp = psMemRead->memoryCall(dwAddr, psMemRead); ! 12998: } ! 12999: else ! 13000: { ! 13001: bTemp = *((UINT8 *) psMemRead->pUserArea + (dwAddr - psMemRead->lowAddr)); ! 13002: } ! 13003: psMemRead = NULL; ! 13004: break; ! 13005: } ! 13006: ++psMemRead; ! 13007: } ! 13008: ! 13009: if (psMemRead) ! 13010: { ! 13011: bTemp = cpu.z80Base[dwAddr]; ! 13012: } ! 13013: ! 13014: cpu.z80F = (cpu.z80F & ~(Z80_FLAG_CARRY | Z80_FLAG_NEGATIVE | Z80_FLAG_OVERFLOW_PARITY | ! 13015: Z80_FLAG_HALF_CARRY | Z80_FLAG_ZERO | Z80_FLAG_SIGN)) | ! 13016: pbSubSbcTable[((UINT32) cpu.z80A << 8) | bTemp]; ! 13017: break; ! 13018: } ! 13019: case 0xbf: ! 13020: { ! 13021: InvalidInstruction(2); ! 13022: break; ! 13023: } ! 13024: case 0xc0: ! 13025: { ! 13026: InvalidInstruction(2); ! 13027: break; ! 13028: } ! 13029: case 0xc1: ! 13030: { ! 13031: InvalidInstruction(2); ! 13032: break; ! 13033: } ! 13034: case 0xc2: ! 13035: { ! 13036: InvalidInstruction(2); ! 13037: break; ! 13038: } ! 13039: case 0xc3: ! 13040: { ! 13041: InvalidInstruction(2); ! 13042: break; ! 13043: } ! 13044: case 0xc4: ! 13045: { ! 13046: InvalidInstruction(2); ! 13047: break; ! 13048: } ! 13049: case 0xc5: ! 13050: { ! 13051: InvalidInstruction(2); ! 13052: break; ! 13053: } ! 13054: case 0xc6: ! 13055: { ! 13056: InvalidInstruction(2); ! 13057: break; ! 13058: } ! 13059: case 0xc7: ! 13060: { ! 13061: InvalidInstruction(2); ! 13062: break; ! 13063: } ! 13064: case 0xc8: ! 13065: { ! 13066: InvalidInstruction(2); ! 13067: break; ! 13068: } ! 13069: case 0xc9: ! 13070: { ! 13071: InvalidInstruction(2); ! 13072: break; ! 13073: } ! 13074: case 0xca: ! 13075: { ! 13076: InvalidInstruction(2); ! 13077: break; ! 13078: } ! 13079: case 0xcb: ! 13080: { ! 13081: DDFDCBHandler(1); ! 13082: break; ! 13083: } ! 13084: case 0xcc: ! 13085: { ! 13086: InvalidInstruction(2); ! 13087: break; ! 13088: } ! 13089: case 0xcd: ! 13090: { ! 13091: InvalidInstruction(2); ! 13092: break; ! 13093: } ! 13094: case 0xce: ! 13095: { ! 13096: InvalidInstruction(2); ! 13097: break; ! 13098: } ! 13099: case 0xcf: ! 13100: { ! 13101: InvalidInstruction(2); ! 13102: break; ! 13103: } ! 13104: case 0xd0: ! 13105: { ! 13106: InvalidInstruction(2); ! 13107: break; ! 13108: } ! 13109: case 0xd1: ! 13110: { ! 13111: InvalidInstruction(2); ! 13112: break; ! 13113: } ! 13114: case 0xd2: ! 13115: { ! 13116: InvalidInstruction(2); ! 13117: break; ! 13118: } ! 13119: case 0xd3: ! 13120: { ! 13121: InvalidInstruction(2); ! 13122: break; ! 13123: } ! 13124: case 0xd4: ! 13125: { ! 13126: InvalidInstruction(2); ! 13127: break; ! 13128: } ! 13129: case 0xd5: ! 13130: { ! 13131: InvalidInstruction(2); ! 13132: break; ! 13133: } ! 13134: case 0xd6: ! 13135: { ! 13136: InvalidInstruction(2); ! 13137: break; ! 13138: } ! 13139: case 0xd7: ! 13140: { ! 13141: InvalidInstruction(2); ! 13142: break; ! 13143: } ! 13144: case 0xd8: ! 13145: { ! 13146: InvalidInstruction(2); ! 13147: break; ! 13148: } ! 13149: case 0xd9: ! 13150: { ! 13151: InvalidInstruction(2); ! 13152: break; ! 13153: } ! 13154: case 0xda: ! 13155: { ! 13156: InvalidInstruction(2); ! 13157: break; ! 13158: } ! 13159: case 0xdb: ! 13160: { ! 13161: InvalidInstruction(2); ! 13162: break; ! 13163: } ! 13164: case 0xdc: ! 13165: { ! 13166: InvalidInstruction(2); ! 13167: break; ! 13168: } ! 13169: case 0xdd: ! 13170: { ! 13171: InvalidInstruction(2); ! 13172: break; ! 13173: } ! 13174: case 0xde: ! 13175: { ! 13176: InvalidInstruction(2); ! 13177: break; ! 13178: } ! 13179: case 0xdf: ! 13180: { ! 13181: InvalidInstruction(2); ! 13182: break; ! 13183: } ! 13184: case 0xe0: ! 13185: { ! 13186: InvalidInstruction(2); ! 13187: break; ! 13188: } ! 13189: case 0xe1: ! 13190: { ! 13191: sdwCyclesRemaining -= 14; ! 13192: psMemRead = cpu.z80MemRead; /* Beginning of our handler */ ! 13193: while (psMemRead->lowAddr != 0xffffffff) ! 13194: { ! 13195: if ((cpu.z80sp >= psMemRead->lowAddr) && (cpu.z80sp <= psMemRead->highAddr)) ! 13196: { ! 13197: cpu.z80pc = (UINT32) pbPC - (UINT32) cpu.z80Base; ! 13198: if (psMemRead->memoryCall) ! 13199: { ! 13200: cpu.z80IY = psMemRead->memoryCall(cpu.z80sp, psMemRead); ! 13201: cpu.z80IY |= (UINT32) ((UINT32) psMemRead->memoryCall(cpu.z80sp + 1, psMemRead) << 8); ! 13202: } ! 13203: else ! 13204: { ! 13205: cpu.z80IY = *((UINT8 *) psMemRead->pUserArea + (cpu.z80sp - psMemRead->lowAddr)); ! 13206: cpu.z80IY |= (UINT32) ((UINT32) *((UINT8 *) psMemRead->pUserArea + (cpu.z80sp - psMemRead->lowAddr + 1)) << 8); ! 13207: } ! 13208: psMemRead = NULL; ! 13209: break; ! 13210: } ! 13211: ++psMemRead; ! 13212: } ! 13213: ! 13214: if (psMemRead) ! 13215: { ! 13216: cpu.z80IY = cpu.z80Base[cpu.z80sp]; ! 13217: cpu.z80IY |= (UINT32) ((UINT32) cpu.z80Base[cpu.z80sp + 1] << 8); ! 13218: } ! 13219: ! 13220: cpu.z80sp += 2; ! 13221: pbSP = (cpu.z80Base + cpu.z80sp); /* Normalize the stack pointer */ ! 13222: break; ! 13223: } ! 13224: case 0xe2: ! 13225: { ! 13226: InvalidInstruction(2); ! 13227: break; ! 13228: } ! 13229: case 0xe3: ! 13230: { ! 13231: sdwCyclesRemaining -= 23; ! 13232: psMemRead = cpu.z80MemRead; /* Beginning of our handler */ ! 13233: while (psMemRead->lowAddr != 0xffffffff) ! 13234: { ! 13235: if ((cpu.z80sp >= psMemRead->lowAddr) && (cpu.z80sp <= psMemRead->highAddr)) ! 13236: { ! 13237: cpu.z80pc = (UINT32) pbPC - (UINT32) cpu.z80Base; ! 13238: if (psMemRead->memoryCall) ! 13239: { ! 13240: dwAddr = psMemRead->memoryCall(cpu.z80sp, psMemRead); ! 13241: dwAddr |= (UINT32) ((UINT32) psMemRead->memoryCall(cpu.z80sp + 1, psMemRead) << 8); ! 13242: } ! 13243: else ! 13244: { ! 13245: dwAddr = *((UINT8 *) psMemRead->pUserArea + (cpu.z80sp - psMemRead->lowAddr)); ! 13246: dwAddr |= (UINT32) ((UINT32) *((UINT8 *) psMemRead->pUserArea + (cpu.z80sp - psMemRead->lowAddr + 1)) << 8); ! 13247: } ! 13248: psMemRead = NULL; ! 13249: break; ! 13250: } ! 13251: ++psMemRead; ! 13252: } ! 13253: ! 13254: if (psMemRead) ! 13255: { ! 13256: dwAddr = cpu.z80Base[cpu.z80sp]; ! 13257: dwAddr |= (UINT32) ((UINT32) cpu.z80Base[cpu.z80sp + 1] << 8); ! 13258: } ! 13259: ! 13260: psMemWrite = cpu.z80MemWrite; /* Beginning of our handler */ ! 13261: while (psMemWrite->lowAddr != 0xffffffff) ! 13262: { ! 13263: if ((cpu.z80sp >= psMemWrite->lowAddr) && (cpu.z80sp <= psMemWrite->highAddr)) ! 13264: { ! 13265: cpu.z80pc = (UINT32) pbPC - (UINT32) cpu.z80Base; ! 13266: if (psMemWrite->memoryCall) ! 13267: { ! 13268: psMemWrite->memoryCall(cpu.z80sp, (cpu.z80IY & 0xff), psMemWrite); ! 13269: psMemWrite->memoryCall(cpu.z80sp + 1, (cpu.z80IY >> 8), psMemWrite); ! 13270: } ! 13271: else ! 13272: { ! 13273: *((UINT8 *) psMemWrite->pUserArea + (cpu.z80sp - psMemWrite->lowAddr)) = cpu.z80IY; ! 13274: *((UINT8 *) psMemWrite->pUserArea + (cpu.z80sp - psMemWrite->lowAddr) + 1) = cpu.z80IY >> 8; ! 13275: } ! 13276: psMemWrite = NULL; ! 13277: break; ! 13278: } ! 13279: ++psMemWrite; ! 13280: } ! 13281: ! 13282: if (psMemWrite) ! 13283: { ! 13284: cpu.z80Base[cpu.z80sp] = (UINT8) cpu.z80IY; ! 13285: cpu.z80Base[cpu.z80sp + 1] = (UINT8) ((UINT32) cpu.z80IY >> 8); ! 13286: } ! 13287: ! 13288: cpu.z80IY = dwAddr; ! 13289: break; ! 13290: } ! 13291: case 0xe4: ! 13292: { ! 13293: InvalidInstruction(2); ! 13294: break; ! 13295: } ! 13296: case 0xe5: ! 13297: { ! 13298: sdwCyclesRemaining -= 15; ! 13299: cpu.z80sp -= 2; ! 13300: pbSP = (cpu.z80Base + cpu.z80sp); /* Normalize the stack pointer */ ! 13301: psMemWrite = cpu.z80MemWrite; /* Beginning of our handler */ ! 13302: while (psMemWrite->lowAddr != 0xffffffff) ! 13303: { ! 13304: if ((cpu.z80sp >= psMemWrite->lowAddr) && (cpu.z80sp <= psMemWrite->highAddr)) ! 13305: { ! 13306: cpu.z80pc = (UINT32) pbPC - (UINT32) cpu.z80Base; ! 13307: if (psMemWrite->memoryCall) ! 13308: { ! 13309: psMemWrite->memoryCall(cpu.z80sp, (cpu.z80IY & 0xff), psMemWrite); ! 13310: psMemWrite->memoryCall(cpu.z80sp + 1, (cpu.z80IY >> 8), psMemWrite); ! 13311: } ! 13312: else ! 13313: { ! 13314: *((UINT8 *) psMemWrite->pUserArea + (cpu.z80sp - psMemWrite->lowAddr)) = cpu.z80IY; ! 13315: *((UINT8 *) psMemWrite->pUserArea + (cpu.z80sp - psMemWrite->lowAddr) + 1) = cpu.z80IY >> 8; ! 13316: } ! 13317: psMemWrite = NULL; ! 13318: break; ! 13319: } ! 13320: ++psMemWrite; ! 13321: } ! 13322: ! 13323: if (psMemWrite) ! 13324: { ! 13325: cpu.z80Base[cpu.z80sp] = (UINT8) cpu.z80IY; ! 13326: cpu.z80Base[cpu.z80sp + 1] = (UINT8) ((UINT32) cpu.z80IY >> 8); ! 13327: } ! 13328: ! 13329: break; ! 13330: } ! 13331: case 0xe6: ! 13332: { ! 13333: InvalidInstruction(2); ! 13334: break; ! 13335: } ! 13336: case 0xe7: ! 13337: { ! 13338: InvalidInstruction(2); ! 13339: break; ! 13340: } ! 13341: case 0xe8: ! 13342: { ! 13343: InvalidInstruction(2); ! 13344: break; ! 13345: } ! 13346: case 0xe9: ! 13347: { ! 13348: sdwCyclesRemaining -= 8; ! 13349: pbPC = cpu.z80Base + cpu.z80IY; ! 13350: break; ! 13351: } ! 13352: case 0xea: ! 13353: { ! 13354: InvalidInstruction(2); ! 13355: break; ! 13356: } ! 13357: case 0xeb: ! 13358: { ! 13359: InvalidInstruction(2); ! 13360: break; ! 13361: } ! 13362: case 0xec: ! 13363: { ! 13364: InvalidInstruction(2); ! 13365: break; ! 13366: } ! 13367: case 0xed: ! 13368: { ! 13369: InvalidInstruction(2); ! 13370: break; ! 13371: } ! 13372: case 0xee: ! 13373: { ! 13374: InvalidInstruction(2); ! 13375: break; ! 13376: } ! 13377: case 0xef: ! 13378: { ! 13379: InvalidInstruction(2); ! 13380: break; ! 13381: } ! 13382: case 0xf0: ! 13383: { ! 13384: InvalidInstruction(2); ! 13385: break; ! 13386: } ! 13387: case 0xf1: ! 13388: { ! 13389: InvalidInstruction(2); ! 13390: break; ! 13391: } ! 13392: case 0xf2: ! 13393: { ! 13394: InvalidInstruction(2); ! 13395: break; ! 13396: } ! 13397: case 0xf3: ! 13398: { ! 13399: InvalidInstruction(2); ! 13400: break; ! 13401: } ! 13402: case 0xf4: ! 13403: { ! 13404: InvalidInstruction(2); ! 13405: break; ! 13406: } ! 13407: case 0xf5: ! 13408: { ! 13409: InvalidInstruction(2); ! 13410: break; ! 13411: } ! 13412: case 0xf6: ! 13413: { ! 13414: InvalidInstruction(2); ! 13415: break; ! 13416: } ! 13417: case 0xf7: ! 13418: { ! 13419: InvalidInstruction(2); ! 13420: break; ! 13421: } ! 13422: case 0xf8: ! 13423: { ! 13424: InvalidInstruction(2); ! 13425: break; ! 13426: } ! 13427: case 0xf9: ! 13428: { ! 13429: sdwCyclesRemaining -= 10; ! 13430: cpu.z80sp = cpu.z80IY; ! 13431: break; ! 13432: } ! 13433: case 0xfa: ! 13434: { ! 13435: InvalidInstruction(2); ! 13436: break; ! 13437: } ! 13438: case 0xfb: ! 13439: { ! 13440: InvalidInstruction(2); ! 13441: break; ! 13442: } ! 13443: case 0xfc: ! 13444: { ! 13445: InvalidInstruction(2); ! 13446: break; ! 13447: } ! 13448: case 0xfd: ! 13449: { ! 13450: InvalidInstruction(2); ! 13451: break; ! 13452: } ! 13453: case 0xfe: ! 13454: { ! 13455: InvalidInstruction(2); ! 13456: break; ! 13457: } ! 13458: case 0xff: ! 13459: { ! 13460: InvalidInstruction(2); ! 13461: break; ! 13462: } ! 13463: } ! 13464: } ! 13465: /* Main execution entry point */ ! 13466: ! 13467: UINT32 mz80exec(UINT32 dwCycles) ! 13468: { ! 13469: UINT8 bOpcode; ! 13470: ! 13471: dwReturnCode = 0x80000000; /* Assume it'll work */ ! 13472: sdwCyclesRemaining = dwCycles; ! 13473: dwOriginalCycles = dwCycles; ! 13474: if (cpu.z80halted) ! 13475: { ! 13476: dwElapsedTicks += dwCycles; ! 13477: return(0x80000000); ! 13478: } ! 13479: ! 13480: pbPC = cpu.z80Base + cpu.z80pc; ! 13481: ! 13482: while (sdwCyclesRemaining > 0) ! 13483: { ! 13484: bOpcode = *pbPC++; ! 13485: switch (bOpcode) ! 13486: { ! 13487: case 0x00: ! 13488: { ! 13489: sdwCyclesRemaining -= 4; ! 13490: /* Intentionally not doing anything - NOP! */ ! 13491: break; ! 13492: } ! 13493: case 0x01: ! 13494: { ! 13495: sdwCyclesRemaining -= 10; ! 13496: cpu.z80BC = *pbPC++; /* LSB First */ ! 13497: cpu.z80BC |= (((UINT32) *pbPC++ << 8)); /* Now the MSB */ ! 13498: break; ! 13499: } ! 13500: case 0x02: ! 13501: { ! 13502: sdwCyclesRemaining -= 7; ! 13503: psMemWrite = cpu.z80MemWrite; /* Beginning of our handler */ ! 13504: while (psMemWrite->lowAddr != 0xffffffff) ! 13505: { ! 13506: if ((cpu.z80BC >= psMemWrite->lowAddr) && (cpu.z80BC <= psMemWrite->highAddr)) ! 13507: { ! 13508: cpu.z80pc = (UINT32) pbPC - (UINT32) cpu.z80Base; ! 13509: if (psMemWrite->memoryCall) ! 13510: { ! 13511: psMemWrite->memoryCall(cpu.z80BC, cpu.z80A, psMemWrite); ! 13512: } ! 13513: else ! 13514: { ! 13515: *((UINT8 *) psMemWrite->pUserArea + (cpu.z80BC - psMemWrite->lowAddr)) = cpu.z80A; ! 13516: } ! 13517: psMemWrite = NULL; ! 13518: break; ! 13519: } ! 13520: ++psMemWrite; ! 13521: } ! 13522: ! 13523: if (psMemWrite) ! 13524: { ! 13525: cpu.z80Base[cpu.z80BC] = (UINT8) cpu.z80A; ! 13526: } ! 13527: ! 13528: break; ! 13529: } ! 13530: case 0x03: ! 13531: { ! 13532: sdwCyclesRemaining -= 6; ! 13533: cpu.z80BC++; ! 13534: cpu.z80BC &= 0xffff; ! 13535: break; ! 13536: } ! 13537: case 0x04: ! 13538: { ! 13539: sdwCyclesRemaining -= 4; ! 13540: cpu.z80F &= ~(Z80_FLAG_SIGN | Z80_FLAG_ZERO | Z80_FLAG_HALF_CARRY | Z80_FLAG_OVERFLOW_PARITY | Z80_FLAG_NEGATIVE); ! 13541: cpu.z80F |= bPostIncFlags[cpu.z80B++]; ! 13542: break; ! 13543: } ! 13544: case 0x05: ! 13545: { ! 13546: sdwCyclesRemaining -= 4; ! 13547: cpu.z80F &= ~(Z80_FLAG_SIGN | Z80_FLAG_ZERO | Z80_FLAG_HALF_CARRY | Z80_FLAG_OVERFLOW_PARITY); ! 13548: cpu.z80F |= bPostDecFlags[cpu.z80B--]; ! 13549: break; ! 13550: } ! 13551: case 0x06: ! 13552: { ! 13553: sdwCyclesRemaining -= 7; ! 13554: cpu.z80B = *pbPC++; /* Get immediate byte into register */ ! 13555: break; ! 13556: } ! 13557: case 0x07: ! 13558: { ! 13559: sdwCyclesRemaining -= 4; ! 13560: cpu.z80F &= ~(Z80_FLAG_CARRY | Z80_FLAG_NEGATIVE | Z80_FLAG_HALF_CARRY); ! 13561: cpu.z80F |= (cpu.z80A >> 7); ! 13562: cpu.z80A = (cpu.z80A << 1) | (cpu.z80A >> 7); ! 13563: break; ! 13564: } ! 13565: case 0x08: ! 13566: { ! 13567: sdwCyclesRemaining -= 4; ! 13568: dwAddr = (UINT32) cpu.z80AF; ! 13569: cpu.z80AF = cpu.z80afprime; ! 13570: cpu.z80afprime = dwAddr; ! 13571: break; ! 13572: } ! 13573: case 0x09: ! 13574: { ! 13575: sdwCyclesRemaining -= 11; ! 13576: cpu.z80F &= ~(Z80_FLAG_CARRY | Z80_FLAG_NEGATIVE | Z80_FLAG_HALF_CARRY); ! 13577: dwTemp = cpu.z80HL + cpu.z80BC; ! 13578: cpu.z80F |= ((dwTemp >> 16) & Z80_FLAG_CARRY) | (((cpu.z80HL ^ dwTemp ^ cpu.z80BC) >> 8) & Z80_FLAG_HALF_CARRY); ! 13579: cpu.z80HL = dwTemp & 0xffff; ! 13580: break; ! 13581: } ! 13582: case 0x0a: ! 13583: { ! 13584: sdwCyclesRemaining -= 7; ! 13585: psMemRead = cpu.z80MemRead; /* Beginning of our handler */ ! 13586: while (psMemRead->lowAddr != 0xffffffff) ! 13587: { ! 13588: if ((cpu.z80BC >= psMemRead->lowAddr) && (cpu.z80BC <= psMemRead->highAddr)) ! 13589: { ! 13590: cpu.z80pc = (UINT32) pbPC - (UINT32) cpu.z80Base; ! 13591: if (psMemRead->memoryCall) ! 13592: { ! 13593: cpu.z80A = psMemRead->memoryCall(cpu.z80BC, psMemRead); ! 13594: } ! 13595: else ! 13596: { ! 13597: cpu.z80A = *((UINT8 *) psMemRead->pUserArea + (cpu.z80BC - psMemRead->lowAddr)); ! 13598: } ! 13599: psMemRead = NULL; ! 13600: break; ! 13601: } ! 13602: ++psMemRead; ! 13603: } ! 13604: ! 13605: if (psMemRead) ! 13606: { ! 13607: cpu.z80A = cpu.z80Base[cpu.z80BC]; ! 13608: } ! 13609: ! 13610: break; ! 13611: } ! 13612: case 0x0b: ! 13613: { ! 13614: sdwCyclesRemaining -= 6; ! 13615: cpu.z80BC--; ! 13616: cpu.z80BC &= 0xffff; ! 13617: break; ! 13618: } ! 13619: case 0x0c: ! 13620: { ! 13621: sdwCyclesRemaining -= 4; ! 13622: cpu.z80F &= ~(Z80_FLAG_SIGN | Z80_FLAG_ZERO | Z80_FLAG_HALF_CARRY | Z80_FLAG_OVERFLOW_PARITY | Z80_FLAG_NEGATIVE); ! 13623: cpu.z80F |= bPostIncFlags[cpu.z80C++]; ! 13624: break; ! 13625: } ! 13626: case 0x0d: ! 13627: { ! 13628: sdwCyclesRemaining -= 4; ! 13629: cpu.z80F &= ~(Z80_FLAG_SIGN | Z80_FLAG_ZERO | Z80_FLAG_HALF_CARRY | Z80_FLAG_OVERFLOW_PARITY); ! 13630: cpu.z80F |= bPostDecFlags[cpu.z80C--]; ! 13631: break; ! 13632: } ! 13633: case 0x0e: ! 13634: { ! 13635: sdwCyclesRemaining -= 7; ! 13636: cpu.z80C = *pbPC++; /* Get immediate byte into register */ ! 13637: break; ! 13638: } ! 13639: case 0x0f: ! 13640: { ! 13641: sdwCyclesRemaining -= 4; ! 13642: cpu.z80F &= ~(Z80_FLAG_CARRY | Z80_FLAG_NEGATIVE | Z80_FLAG_HALF_CARRY); ! 13643: cpu.z80F |= (cpu.z80A & Z80_FLAG_CARRY); ! 13644: cpu.z80A = (cpu.z80A >> 1) | (cpu.z80A << 7); ! 13645: break; ! 13646: } ! 13647: case 0x10: ! 13648: { ! 13649: sdwCyclesRemaining -= 8; ! 13650: sdwAddr = (INT8) *pbPC++; /* Get LSB first */ ! 13651: if (--cpu.z80B) ! 13652: { ! 13653: dwElapsedTicks += 5; /* 5 More for jump taken */ ! 13654: cpu.z80pc = (UINT32) pbPC - (UINT32) cpu.z80Base; ! 13655: sdwAddr = (sdwAddr + (INT32) cpu.z80pc) & 0xffff; ! 13656: pbPC = cpu.z80Base + sdwAddr; /* Normalize the address */ ! 13657: } ! 13658: break; ! 13659: } ! 13660: case 0x11: ! 13661: { ! 13662: sdwCyclesRemaining -= 10; ! 13663: cpu.z80DE = *pbPC++; /* LSB First */ ! 13664: cpu.z80DE |= (((UINT32) *pbPC++ << 8)); /* Now the MSB */ ! 13665: break; ! 13666: } ! 13667: case 0x12: ! 13668: { ! 13669: sdwCyclesRemaining -= 7; ! 13670: psMemWrite = cpu.z80MemWrite; /* Beginning of our handler */ ! 13671: while (psMemWrite->lowAddr != 0xffffffff) ! 13672: { ! 13673: if ((cpu.z80DE >= psMemWrite->lowAddr) && (cpu.z80DE <= psMemWrite->highAddr)) ! 13674: { ! 13675: cpu.z80pc = (UINT32) pbPC - (UINT32) cpu.z80Base; ! 13676: if (psMemWrite->memoryCall) ! 13677: { ! 13678: psMemWrite->memoryCall(cpu.z80DE, cpu.z80A, psMemWrite); ! 13679: } ! 13680: else ! 13681: { ! 13682: *((UINT8 *) psMemWrite->pUserArea + (cpu.z80DE - psMemWrite->lowAddr)) = cpu.z80A; ! 13683: } ! 13684: psMemWrite = NULL; ! 13685: break; ! 13686: } ! 13687: ++psMemWrite; ! 13688: } ! 13689: ! 13690: if (psMemWrite) ! 13691: { ! 13692: cpu.z80Base[cpu.z80DE] = (UINT8) cpu.z80A; ! 13693: } ! 13694: ! 13695: break; ! 13696: } ! 13697: case 0x13: ! 13698: { ! 13699: sdwCyclesRemaining -= 6; ! 13700: cpu.z80DE++; ! 13701: cpu.z80DE &= 0xffff; ! 13702: break; ! 13703: } ! 13704: case 0x14: ! 13705: { ! 13706: sdwCyclesRemaining -= 4; ! 13707: cpu.z80F &= ~(Z80_FLAG_SIGN | Z80_FLAG_ZERO | Z80_FLAG_HALF_CARRY | Z80_FLAG_OVERFLOW_PARITY | Z80_FLAG_NEGATIVE); ! 13708: cpu.z80F |= bPostIncFlags[cpu.z80D++]; ! 13709: break; ! 13710: } ! 13711: case 0x15: ! 13712: { ! 13713: sdwCyclesRemaining -= 4; ! 13714: cpu.z80F &= ~(Z80_FLAG_SIGN | Z80_FLAG_ZERO | Z80_FLAG_HALF_CARRY | Z80_FLAG_OVERFLOW_PARITY); ! 13715: cpu.z80F |= bPostDecFlags[cpu.z80D--]; ! 13716: break; ! 13717: } ! 13718: case 0x16: ! 13719: { ! 13720: sdwCyclesRemaining -= 7; ! 13721: cpu.z80D = *pbPC++; /* Get immediate byte into register */ ! 13722: break; ! 13723: } ! 13724: case 0x17: ! 13725: { ! 13726: sdwCyclesRemaining -= 4; ! 13727: bTemp = cpu.z80A >> 7; ! 13728: cpu.z80A = (cpu.z80A << 1) | (cpu.z80F & Z80_FLAG_CARRY); ! 13729: cpu.z80F = (cpu.z80F & ~(Z80_FLAG_CARRY | Z80_FLAG_NEGATIVE | Z80_FLAG_HALF_CARRY)) | bTemp; ! 13730: break; ! 13731: } ! 13732: case 0x18: ! 13733: { ! 13734: sdwCyclesRemaining -= 12; ! 13735: sdwAddr = (INT8) *pbPC++; /* Get LSB first */ ! 13736: cpu.z80pc = (UINT32) pbPC - (UINT32) cpu.z80Base; ! 13737: sdwAddr = (sdwAddr + (INT32) cpu.z80pc) & 0xffff; ! 13738: { ! 13739: sdwCyclesRemaining -= 5; ! 13740: pbPC = cpu.z80Base + sdwAddr; /* Normalize the address */ ! 13741: } ! 13742: break; ! 13743: } ! 13744: case 0x19: ! 13745: { ! 13746: sdwCyclesRemaining -= 11; ! 13747: cpu.z80F &= ~(Z80_FLAG_CARRY | Z80_FLAG_NEGATIVE | Z80_FLAG_HALF_CARRY); ! 13748: dwTemp = cpu.z80HL + cpu.z80DE; ! 13749: cpu.z80F |= ((dwTemp >> 16) & Z80_FLAG_CARRY) | (((cpu.z80HL ^ dwTemp ^ cpu.z80DE) >> 8) & Z80_FLAG_HALF_CARRY); ! 13750: cpu.z80HL = dwTemp & 0xffff; ! 13751: break; ! 13752: } ! 13753: case 0x1a: ! 13754: { ! 13755: sdwCyclesRemaining -= 7; ! 13756: psMemRead = cpu.z80MemRead; /* Beginning of our handler */ ! 13757: while (psMemRead->lowAddr != 0xffffffff) ! 13758: { ! 13759: if ((cpu.z80DE >= psMemRead->lowAddr) && (cpu.z80DE <= psMemRead->highAddr)) ! 13760: { ! 13761: cpu.z80pc = (UINT32) pbPC - (UINT32) cpu.z80Base; ! 13762: if (psMemRead->memoryCall) ! 13763: { ! 13764: cpu.z80A = psMemRead->memoryCall(cpu.z80DE, psMemRead); ! 13765: } ! 13766: else ! 13767: { ! 13768: cpu.z80A = *((UINT8 *) psMemRead->pUserArea + (cpu.z80DE - psMemRead->lowAddr)); ! 13769: } ! 13770: psMemRead = NULL; ! 13771: break; ! 13772: } ! 13773: ++psMemRead; ! 13774: } ! 13775: ! 13776: if (psMemRead) ! 13777: { ! 13778: cpu.z80A = cpu.z80Base[cpu.z80DE]; ! 13779: } ! 13780: ! 13781: break; ! 13782: } ! 13783: case 0x1b: ! 13784: { ! 13785: sdwCyclesRemaining -= 6; ! 13786: cpu.z80DE--; ! 13787: cpu.z80DE &= 0xffff; ! 13788: break; ! 13789: } ! 13790: case 0x1c: ! 13791: { ! 13792: sdwCyclesRemaining -= 4; ! 13793: cpu.z80F &= ~(Z80_FLAG_SIGN | Z80_FLAG_ZERO | Z80_FLAG_HALF_CARRY | Z80_FLAG_OVERFLOW_PARITY | Z80_FLAG_NEGATIVE); ! 13794: cpu.z80F |= bPostIncFlags[cpu.z80E++]; ! 13795: break; ! 13796: } ! 13797: case 0x1d: ! 13798: { ! 13799: sdwCyclesRemaining -= 4; ! 13800: cpu.z80F &= ~(Z80_FLAG_SIGN | Z80_FLAG_ZERO | Z80_FLAG_HALF_CARRY | Z80_FLAG_OVERFLOW_PARITY); ! 13801: cpu.z80F |= bPostDecFlags[cpu.z80E--]; ! 13802: break; ! 13803: } ! 13804: case 0x1e: ! 13805: { ! 13806: sdwCyclesRemaining -= 7; ! 13807: cpu.z80E = *pbPC++; /* Get immediate byte into register */ ! 13808: break; ! 13809: } ! 13810: case 0x1f: ! 13811: { ! 13812: sdwCyclesRemaining -= 4; ! 13813: bTemp = (cpu.z80F & Z80_FLAG_CARRY) << 7; ! 13814: cpu.z80F = (cpu.z80F & ~(Z80_FLAG_CARRY | Z80_FLAG_NEGATIVE | Z80_FLAG_HALF_CARRY)) | (cpu.z80A & Z80_FLAG_CARRY); ! 13815: cpu.z80A = ((cpu.z80A >> 1) | bTemp); ! 13816: break; ! 13817: } ! 13818: case 0x20: ! 13819: { ! 13820: sdwCyclesRemaining -= 7; ! 13821: sdwAddr = (INT8) *pbPC++; /* Get LSB first */ ! 13822: cpu.z80pc = (UINT32) pbPC - (UINT32) cpu.z80Base; ! 13823: sdwAddr = (sdwAddr + (INT32) cpu.z80pc) & 0xffff; ! 13824: if (!(cpu.z80F & Z80_FLAG_ZERO)) ! 13825: { ! 13826: sdwCyclesRemaining -= 5; ! 13827: pbPC = cpu.z80Base + sdwAddr; /* Normalize the address */ ! 13828: } ! 13829: break; ! 13830: } ! 13831: case 0x21: ! 13832: { ! 13833: sdwCyclesRemaining -= 10; ! 13834: cpu.z80HL = *pbPC++; /* LSB First */ ! 13835: cpu.z80HL |= (((UINT32) *pbPC++ << 8)); /* Now the MSB */ ! 13836: break; ! 13837: } ! 13838: case 0x22: ! 13839: { ! 13840: sdwCyclesRemaining -= 16; ! 13841: dwTemp = *pbPC++; ! 13842: dwTemp |= ((UINT32) *pbPC++ << 8); ! 13843: psMemWrite = cpu.z80MemWrite; /* Beginning of our handler */ ! 13844: while (psMemWrite->lowAddr != 0xffffffff) ! 13845: { ! 13846: if ((dwTemp >= psMemWrite->lowAddr) && (dwTemp <= psMemWrite->highAddr)) ! 13847: { ! 13848: cpu.z80pc = (UINT32) pbPC - (UINT32) cpu.z80Base; ! 13849: if (psMemWrite->memoryCall) ! 13850: { ! 13851: psMemWrite->memoryCall(dwTemp, (cpu.z80HL & 0xff), psMemWrite); ! 13852: psMemWrite->memoryCall(dwTemp + 1, (cpu.z80HL >> 8), psMemWrite); ! 13853: } ! 13854: else ! 13855: { ! 13856: *((UINT8 *) psMemWrite->pUserArea + (dwTemp - psMemWrite->lowAddr)) = cpu.z80HL; ! 13857: *((UINT8 *) psMemWrite->pUserArea + (dwTemp - psMemWrite->lowAddr) + 1) = cpu.z80HL >> 8; ! 13858: } ! 13859: psMemWrite = NULL; ! 13860: break; ! 13861: } ! 13862: ++psMemWrite; ! 13863: } ! 13864: ! 13865: if (psMemWrite) ! 13866: { ! 13867: cpu.z80Base[dwTemp] = (UINT8) cpu.z80HL; ! 13868: cpu.z80Base[dwTemp + 1] = (UINT8) ((UINT32) cpu.z80HL >> 8); ! 13869: } ! 13870: ! 13871: break; ! 13872: } ! 13873: case 0x23: ! 13874: { ! 13875: sdwCyclesRemaining -= 6; ! 13876: cpu.z80HL++; ! 13877: cpu.z80HL &= 0xffff; ! 13878: break; ! 13879: } ! 13880: case 0x24: ! 13881: { ! 13882: sdwCyclesRemaining -= 4; ! 13883: cpu.z80F &= ~(Z80_FLAG_SIGN | Z80_FLAG_ZERO | Z80_FLAG_HALF_CARRY | Z80_FLAG_OVERFLOW_PARITY | Z80_FLAG_NEGATIVE); ! 13884: cpu.z80F |= bPostIncFlags[cpu.z80H++]; ! 13885: break; ! 13886: } ! 13887: case 0x25: ! 13888: { ! 13889: sdwCyclesRemaining -= 4; ! 13890: cpu.z80F &= ~(Z80_FLAG_SIGN | Z80_FLAG_ZERO | Z80_FLAG_HALF_CARRY | Z80_FLAG_OVERFLOW_PARITY); ! 13891: cpu.z80F |= bPostDecFlags[cpu.z80H--]; ! 13892: break; ! 13893: } ! 13894: case 0x26: ! 13895: { ! 13896: sdwCyclesRemaining -= 7; ! 13897: cpu.z80H = *pbPC++; /* Get immediate byte into register */ ! 13898: break; ! 13899: } ! 13900: case 0x27: ! 13901: { ! 13902: sdwCyclesRemaining -= 4; ! 13903: dwAddr = (((cpu.z80F & Z80_FLAG_CARRY) | ! 13904: ((cpu.z80F & Z80_FLAG_HALF_CARRY) >> 3) | ! 13905: ((cpu.z80F & Z80_FLAG_NEGATIVE) << 1)) << 8) | cpu.z80A; ! 13906: cpu.z80F &= ~(Z80_FLAG_CARRY | Z80_FLAG_OVERFLOW_PARITY | Z80_FLAG_HALF_CARRY | Z80_FLAG_ZERO | Z80_FLAG_SIGN); ! 13907: cpu.z80F |= (wDAATable[dwAddr] >> 8); ! 13908: cpu.z80A = wDAATable[dwAddr] & 0xff; ! 13909: break; ! 13910: } ! 13911: case 0x28: ! 13912: { ! 13913: sdwCyclesRemaining -= 7; ! 13914: sdwAddr = (INT8) *pbPC++; /* Get LSB first */ ! 13915: cpu.z80pc = (UINT32) pbPC - (UINT32) cpu.z80Base; ! 13916: sdwAddr = (sdwAddr + (INT32) cpu.z80pc) & 0xffff; ! 13917: if (cpu.z80F & Z80_FLAG_ZERO) ! 13918: { ! 13919: sdwCyclesRemaining -= 5; ! 13920: pbPC = cpu.z80Base + sdwAddr; /* Normalize the address */ ! 13921: } ! 13922: break; ! 13923: } ! 13924: case 0x29: ! 13925: { ! 13926: sdwCyclesRemaining -= 11; ! 13927: cpu.z80F &= ~(Z80_FLAG_CARRY | Z80_FLAG_NEGATIVE | Z80_FLAG_HALF_CARRY); ! 13928: dwTemp = cpu.z80HL + cpu.z80HL; ! 13929: cpu.z80F |= ((dwTemp >> 16) & Z80_FLAG_CARRY) | (((cpu.z80HL ^ dwTemp ^ cpu.z80HL) >> 8) & Z80_FLAG_HALF_CARRY); ! 13930: cpu.z80HL = dwTemp & 0xffff; ! 13931: break; ! 13932: } ! 13933: case 0x2a: ! 13934: { ! 13935: sdwCyclesRemaining -= 16; ! 13936: dwAddr = *pbPC++; ! 13937: dwAddr |= ((UINT32) *pbPC++ << 8); ! 13938: psMemRead = cpu.z80MemRead; /* Beginning of our handler */ ! 13939: while (psMemRead->lowAddr != 0xffffffff) ! 13940: { ! 13941: if ((dwAddr >= psMemRead->lowAddr) && (dwAddr <= psMemRead->highAddr)) ! 13942: { ! 13943: cpu.z80pc = (UINT32) pbPC - (UINT32) cpu.z80Base; ! 13944: if (psMemRead->memoryCall) ! 13945: { ! 13946: cpu.z80HL = psMemRead->memoryCall(dwAddr, psMemRead); ! 13947: cpu.z80HL |= (UINT32) ((UINT32) psMemRead->memoryCall(dwAddr + 1, psMemRead) << 8); ! 13948: } ! 13949: else ! 13950: { ! 13951: cpu.z80HL = *((UINT8 *) psMemRead->pUserArea + (dwAddr - psMemRead->lowAddr)); ! 13952: cpu.z80HL |= (UINT32) ((UINT32) *((UINT8 *) psMemRead->pUserArea + (dwAddr - psMemRead->lowAddr + 1)) << 8); ! 13953: } ! 13954: psMemRead = NULL; ! 13955: break; ! 13956: } ! 13957: ++psMemRead; ! 13958: } ! 13959: ! 13960: if (psMemRead) ! 13961: { ! 13962: cpu.z80HL = cpu.z80Base[dwAddr]; ! 13963: cpu.z80HL |= (UINT32) ((UINT32) cpu.z80Base[dwAddr + 1] << 8); ! 13964: } ! 13965: ! 13966: break; ! 13967: } ! 13968: case 0x2b: ! 13969: { ! 13970: sdwCyclesRemaining -= 6; ! 13971: cpu.z80HL--; ! 13972: cpu.z80HL &= 0xffff; ! 13973: break; ! 13974: } ! 13975: case 0x2c: ! 13976: { ! 13977: sdwCyclesRemaining -= 4; ! 13978: cpu.z80F &= ~(Z80_FLAG_SIGN | Z80_FLAG_ZERO | Z80_FLAG_HALF_CARRY | Z80_FLAG_OVERFLOW_PARITY | Z80_FLAG_NEGATIVE); ! 13979: cpu.z80F |= bPostIncFlags[cpu.z80L++]; ! 13980: break; ! 13981: } ! 13982: case 0x2d: ! 13983: { ! 13984: sdwCyclesRemaining -= 4; ! 13985: cpu.z80F &= ~(Z80_FLAG_SIGN | Z80_FLAG_ZERO | Z80_FLAG_HALF_CARRY | Z80_FLAG_OVERFLOW_PARITY); ! 13986: cpu.z80F |= bPostDecFlags[cpu.z80L--]; ! 13987: break; ! 13988: } ! 13989: case 0x2e: ! 13990: { ! 13991: sdwCyclesRemaining -= 7; ! 13992: cpu.z80L = *pbPC++; /* Get immediate byte into register */ ! 13993: break; ! 13994: } ! 13995: case 0x2f: ! 13996: { ! 13997: sdwCyclesRemaining -= 4; ! 13998: cpu.z80A ^= 0xff; ! 13999: cpu.z80F |= (Z80_FLAG_NEGATIVE | Z80_FLAG_HALF_CARRY); ! 14000: break; ! 14001: } ! 14002: case 0x30: ! 14003: { ! 14004: sdwCyclesRemaining -= 7; ! 14005: sdwAddr = (INT8) *pbPC++; /* Get LSB first */ ! 14006: cpu.z80pc = (UINT32) pbPC - (UINT32) cpu.z80Base; ! 14007: sdwAddr = (sdwAddr + (INT32) cpu.z80pc) & 0xffff; ! 14008: if (!(cpu.z80F & Z80_FLAG_CARRY)) ! 14009: { ! 14010: sdwCyclesRemaining -= 5; ! 14011: pbPC = cpu.z80Base + sdwAddr; /* Normalize the address */ ! 14012: } ! 14013: break; ! 14014: } ! 14015: case 0x31: ! 14016: { ! 14017: sdwCyclesRemaining -= 10; ! 14018: cpu.z80sp = *pbPC++; /* LSB First */ ! 14019: cpu.z80sp |= (((UINT32) *pbPC++ << 8)); /* Now the MSB */ ! 14020: break; ! 14021: } ! 14022: case 0x32: ! 14023: { ! 14024: sdwCyclesRemaining -= 13; ! 14025: dwTemp = *pbPC++; ! 14026: dwTemp |= ((UINT32) *pbPC++ << 8); ! 14027: psMemWrite = cpu.z80MemWrite; /* Beginning of our handler */ ! 14028: while (psMemWrite->lowAddr != 0xffffffff) ! 14029: { ! 14030: if ((dwTemp >= psMemWrite->lowAddr) && (dwTemp <= psMemWrite->highAddr)) ! 14031: { ! 14032: cpu.z80pc = (UINT32) pbPC - (UINT32) cpu.z80Base; ! 14033: if (psMemWrite->memoryCall) ! 14034: { ! 14035: psMemWrite->memoryCall(dwTemp, cpu.z80A, psMemWrite); ! 14036: } ! 14037: else ! 14038: { ! 14039: *((UINT8 *) psMemWrite->pUserArea + (dwTemp - psMemWrite->lowAddr)) = cpu.z80A; ! 14040: } ! 14041: psMemWrite = NULL; ! 14042: break; ! 14043: } ! 14044: ++psMemWrite; ! 14045: } ! 14046: ! 14047: if (psMemWrite) ! 14048: { ! 14049: cpu.z80Base[dwTemp] = (UINT8) cpu.z80A; ! 14050: } ! 14051: ! 14052: break; ! 14053: } ! 14054: case 0x33: ! 14055: { ! 14056: sdwCyclesRemaining -= 6; ! 14057: cpu.z80sp++; ! 14058: cpu.z80sp &= 0xffff; ! 14059: break; ! 14060: } ! 14061: case 0x34: ! 14062: { ! 14063: sdwCyclesRemaining -= 11; ! 14064: psMemRead = cpu.z80MemRead; /* Beginning of our handler */ ! 14065: while (psMemRead->lowAddr != 0xffffffff) ! 14066: { ! 14067: if ((cpu.z80HL >= psMemRead->lowAddr) && (cpu.z80HL <= psMemRead->highAddr)) ! 14068: { ! 14069: cpu.z80pc = (UINT32) pbPC - (UINT32) cpu.z80Base; ! 14070: if (psMemRead->memoryCall) ! 14071: { ! 14072: bTemp = psMemRead->memoryCall(cpu.z80HL, psMemRead); ! 14073: } ! 14074: else ! 14075: { ! 14076: bTemp = *((UINT8 *) psMemRead->pUserArea + (cpu.z80HL - psMemRead->lowAddr)); ! 14077: } ! 14078: psMemRead = NULL; ! 14079: break; ! 14080: } ! 14081: ++psMemRead; ! 14082: } ! 14083: ! 14084: if (psMemRead) ! 14085: { ! 14086: bTemp = cpu.z80Base[cpu.z80HL]; ! 14087: } ! 14088: ! 14089: cpu.z80F &= ~(Z80_FLAG_SIGN | Z80_FLAG_ZERO | Z80_FLAG_HALF_CARRY | Z80_FLAG_OVERFLOW_PARITY | Z80_FLAG_NEGATIVE); ! 14090: cpu.z80F |= bPostIncFlags[bTemp]; ! 14091: bTemp++; ! 14092: psMemWrite = cpu.z80MemWrite; /* Beginning of our handler */ ! 14093: while (psMemWrite->lowAddr != 0xffffffff) ! 14094: { ! 14095: if ((cpu.z80HL >= psMemWrite->lowAddr) && (cpu.z80HL <= psMemWrite->highAddr)) ! 14096: { ! 14097: cpu.z80pc = (UINT32) pbPC - (UINT32) cpu.z80Base; ! 14098: if (psMemWrite->memoryCall) ! 14099: { ! 14100: psMemWrite->memoryCall(cpu.z80HL, bTemp, psMemWrite); ! 14101: } ! 14102: else ! 14103: { ! 14104: *((UINT8 *) psMemWrite->pUserArea + (cpu.z80HL - psMemWrite->lowAddr)) = bTemp; ! 14105: } ! 14106: psMemWrite = NULL; ! 14107: break; ! 14108: } ! 14109: ++psMemWrite; ! 14110: } ! 14111: ! 14112: if (psMemWrite) ! 14113: { ! 14114: cpu.z80Base[cpu.z80HL] = (UINT8) bTemp; ! 14115: } ! 14116: ! 14117: break; ! 14118: } ! 14119: case 0x35: ! 14120: { ! 14121: sdwCyclesRemaining -= 11; ! 14122: psMemRead = cpu.z80MemRead; /* Beginning of our handler */ ! 14123: while (psMemRead->lowAddr != 0xffffffff) ! 14124: { ! 14125: if ((cpu.z80HL >= psMemRead->lowAddr) && (cpu.z80HL <= psMemRead->highAddr)) ! 14126: { ! 14127: cpu.z80pc = (UINT32) pbPC - (UINT32) cpu.z80Base; ! 14128: if (psMemRead->memoryCall) ! 14129: { ! 14130: bTemp = psMemRead->memoryCall(cpu.z80HL, psMemRead); ! 14131: } ! 14132: else ! 14133: { ! 14134: bTemp = *((UINT8 *) psMemRead->pUserArea + (cpu.z80HL - psMemRead->lowAddr)); ! 14135: } ! 14136: psMemRead = NULL; ! 14137: break; ! 14138: } ! 14139: ++psMemRead; ! 14140: } ! 14141: ! 14142: if (psMemRead) ! 14143: { ! 14144: bTemp = cpu.z80Base[cpu.z80HL]; ! 14145: } ! 14146: ! 14147: cpu.z80F &= ~(Z80_FLAG_SIGN | Z80_FLAG_ZERO | Z80_FLAG_HALF_CARRY | Z80_FLAG_OVERFLOW_PARITY | Z80_FLAG_NEGATIVE); ! 14148: cpu.z80F |= bPostDecFlags[bTemp]; ! 14149: bTemp--; ! 14150: psMemWrite = cpu.z80MemWrite; /* Beginning of our handler */ ! 14151: while (psMemWrite->lowAddr != 0xffffffff) ! 14152: { ! 14153: if ((cpu.z80HL >= psMemWrite->lowAddr) && (cpu.z80HL <= psMemWrite->highAddr)) ! 14154: { ! 14155: cpu.z80pc = (UINT32) pbPC - (UINT32) cpu.z80Base; ! 14156: if (psMemWrite->memoryCall) ! 14157: { ! 14158: psMemWrite->memoryCall(cpu.z80HL, bTemp, psMemWrite); ! 14159: } ! 14160: else ! 14161: { ! 14162: *((UINT8 *) psMemWrite->pUserArea + (cpu.z80HL - psMemWrite->lowAddr)) = bTemp; ! 14163: } ! 14164: psMemWrite = NULL; ! 14165: break; ! 14166: } ! 14167: ++psMemWrite; ! 14168: } ! 14169: ! 14170: if (psMemWrite) ! 14171: { ! 14172: cpu.z80Base[cpu.z80HL] = (UINT8) bTemp; ! 14173: } ! 14174: ! 14175: break; ! 14176: } ! 14177: case 0x36: ! 14178: { ! 14179: sdwCyclesRemaining -= 10; ! 14180: psMemWrite = cpu.z80MemWrite; /* Beginning of our handler */ ! 14181: while (psMemWrite->lowAddr != 0xffffffff) ! 14182: { ! 14183: if ((cpu.z80HL >= psMemWrite->lowAddr) && (cpu.z80HL <= psMemWrite->highAddr)) ! 14184: { ! 14185: cpu.z80pc = (UINT32) pbPC - (UINT32) cpu.z80Base; ! 14186: if (psMemWrite->memoryCall) ! 14187: { ! 14188: psMemWrite->memoryCall(cpu.z80HL, *pbPC++, psMemWrite); ! 14189: } ! 14190: else ! 14191: { ! 14192: *((UINT8 *) psMemWrite->pUserArea + (cpu.z80HL - psMemWrite->lowAddr)) = *pbPC++; ! 14193: } ! 14194: psMemWrite = NULL; ! 14195: break; ! 14196: } ! 14197: ++psMemWrite; ! 14198: } ! 14199: ! 14200: if (psMemWrite) ! 14201: { ! 14202: cpu.z80Base[cpu.z80HL] = (UINT8) *pbPC++; ! 14203: } ! 14204: ! 14205: break; ! 14206: } ! 14207: case 0x37: ! 14208: { ! 14209: sdwCyclesRemaining -= 4; ! 14210: cpu.z80F &= ~(Z80_FLAG_HALF_CARRY | Z80_FLAG_NEGATIVE); ! 14211: cpu.z80F |= Z80_FLAG_CARRY; ! 14212: break; ! 14213: } ! 14214: case 0x38: ! 14215: { ! 14216: sdwCyclesRemaining -= 7; ! 14217: sdwAddr = (INT8) *pbPC++; /* Get LSB first */ ! 14218: cpu.z80pc = (UINT32) pbPC - (UINT32) cpu.z80Base; ! 14219: sdwAddr = (sdwAddr + (INT32) cpu.z80pc) & 0xffff; ! 14220: if (cpu.z80F & Z80_FLAG_CARRY) ! 14221: { ! 14222: sdwCyclesRemaining -= 5; ! 14223: pbPC = cpu.z80Base + sdwAddr; /* Normalize the address */ ! 14224: } ! 14225: break; ! 14226: } ! 14227: case 0x39: ! 14228: { ! 14229: sdwCyclesRemaining -= 11; ! 14230: cpu.z80F &= ~(Z80_FLAG_CARRY | Z80_FLAG_NEGATIVE | Z80_FLAG_HALF_CARRY); ! 14231: dwTemp = cpu.z80HL + cpu.z80sp; ! 14232: cpu.z80F |= ((dwTemp >> 16) & Z80_FLAG_CARRY) | (((cpu.z80HL ^ dwTemp ^ cpu.z80sp) >> 8) & Z80_FLAG_HALF_CARRY); ! 14233: cpu.z80HL = dwTemp & 0xffff; ! 14234: break; ! 14235: } ! 14236: case 0x3a: ! 14237: { ! 14238: sdwCyclesRemaining -= 13; ! 14239: dwTemp = *pbPC++; ! 14240: dwTemp |= (((UINT32) *pbPC++) << 8); ! 14241: psMemRead = cpu.z80MemRead; /* Beginning of our handler */ ! 14242: while (psMemRead->lowAddr != 0xffffffff) ! 14243: { ! 14244: if ((dwTemp >= psMemRead->lowAddr) && (dwTemp <= psMemRead->highAddr)) ! 14245: { ! 14246: cpu.z80pc = (UINT32) pbPC - (UINT32) cpu.z80Base; ! 14247: if (psMemRead->memoryCall) ! 14248: { ! 14249: cpu.z80A = psMemRead->memoryCall(dwTemp, psMemRead); ! 14250: } ! 14251: else ! 14252: { ! 14253: cpu.z80A = *((UINT8 *) psMemRead->pUserArea + (dwTemp - psMemRead->lowAddr)); ! 14254: } ! 14255: psMemRead = NULL; ! 14256: break; ! 14257: } ! 14258: ++psMemRead; ! 14259: } ! 14260: ! 14261: if (psMemRead) ! 14262: { ! 14263: cpu.z80A = cpu.z80Base[dwTemp]; ! 14264: } ! 14265: ! 14266: break; ! 14267: } ! 14268: case 0x3b: ! 14269: { ! 14270: sdwCyclesRemaining -= 6; ! 14271: cpu.z80sp--; ! 14272: cpu.z80sp &= 0xffff; ! 14273: break; ! 14274: } ! 14275: case 0x3c: ! 14276: { ! 14277: sdwCyclesRemaining -= 4; ! 14278: cpu.z80F &= ~(Z80_FLAG_SIGN | Z80_FLAG_ZERO | Z80_FLAG_HALF_CARRY | Z80_FLAG_OVERFLOW_PARITY | Z80_FLAG_NEGATIVE); ! 14279: cpu.z80F |= bPostIncFlags[cpu.z80A++]; ! 14280: break; ! 14281: } ! 14282: case 0x3d: ! 14283: { ! 14284: sdwCyclesRemaining -= 4; ! 14285: cpu.z80F &= ~(Z80_FLAG_SIGN | Z80_FLAG_ZERO | Z80_FLAG_HALF_CARRY | Z80_FLAG_OVERFLOW_PARITY); ! 14286: cpu.z80F |= bPostDecFlags[cpu.z80A--]; ! 14287: break; ! 14288: } ! 14289: case 0x3e: ! 14290: { ! 14291: sdwCyclesRemaining -= 7; ! 14292: cpu.z80A = *pbPC++; /* Get immediate byte into register */ ! 14293: break; ! 14294: } ! 14295: case 0x3f: ! 14296: { ! 14297: sdwCyclesRemaining -= 4; ! 14298: bTemp = (cpu.z80F & Z80_FLAG_CARRY) << 4; ! 14299: cpu.z80F &= ~(Z80_FLAG_HALF_CARRY | Z80_FLAG_NEGATIVE); ! 14300: cpu.z80F ^= Z80_FLAG_CARRY; ! 14301: break; ! 14302: } ! 14303: case 0x40: ! 14304: { ! 14305: sdwCyclesRemaining -= 4; ! 14306: break; ! 14307: } ! 14308: case 0x41: ! 14309: { ! 14310: sdwCyclesRemaining -= 4; ! 14311: cpu.z80B = cpu.z80C; ! 14312: break; ! 14313: } ! 14314: case 0x42: ! 14315: { ! 14316: sdwCyclesRemaining -= 4; ! 14317: cpu.z80B = cpu.z80D; ! 14318: break; ! 14319: } ! 14320: case 0x43: ! 14321: { ! 14322: sdwCyclesRemaining -= 4; ! 14323: cpu.z80B = cpu.z80E; ! 14324: break; ! 14325: } ! 14326: case 0x44: ! 14327: { ! 14328: sdwCyclesRemaining -= 4; ! 14329: cpu.z80B = cpu.z80H; ! 14330: break; ! 14331: } ! 14332: case 0x45: ! 14333: { ! 14334: sdwCyclesRemaining -= 4; ! 14335: cpu.z80B = cpu.z80L; ! 14336: break; ! 14337: } ! 14338: case 0x46: ! 14339: { ! 14340: sdwCyclesRemaining -= 7; ! 14341: psMemRead = cpu.z80MemRead; /* Beginning of our handler */ ! 14342: while (psMemRead->lowAddr != 0xffffffff) ! 14343: { ! 14344: if ((cpu.z80HL >= psMemRead->lowAddr) && (cpu.z80HL <= psMemRead->highAddr)) ! 14345: { ! 14346: cpu.z80pc = (UINT32) pbPC - (UINT32) cpu.z80Base; ! 14347: if (psMemRead->memoryCall) ! 14348: { ! 14349: cpu.z80B = psMemRead->memoryCall(cpu.z80HL, psMemRead); ! 14350: } ! 14351: else ! 14352: { ! 14353: cpu.z80B = *((UINT8 *) psMemRead->pUserArea + (cpu.z80HL - psMemRead->lowAddr)); ! 14354: } ! 14355: psMemRead = NULL; ! 14356: break; ! 14357: } ! 14358: ++psMemRead; ! 14359: } ! 14360: ! 14361: if (psMemRead) ! 14362: { ! 14363: cpu.z80B = cpu.z80Base[cpu.z80HL]; ! 14364: } ! 14365: ! 14366: break; ! 14367: } ! 14368: case 0x47: ! 14369: { ! 14370: sdwCyclesRemaining -= 4; ! 14371: cpu.z80B = cpu.z80A; ! 14372: break; ! 14373: } ! 14374: case 0x48: ! 14375: { ! 14376: sdwCyclesRemaining -= 4; ! 14377: cpu.z80C = cpu.z80B; ! 14378: break; ! 14379: } ! 14380: case 0x49: ! 14381: { ! 14382: sdwCyclesRemaining -= 4; ! 14383: break; ! 14384: } ! 14385: case 0x4a: ! 14386: { ! 14387: sdwCyclesRemaining -= 4; ! 14388: cpu.z80C = cpu.z80D; ! 14389: break; ! 14390: } ! 14391: case 0x4b: ! 14392: { ! 14393: sdwCyclesRemaining -= 4; ! 14394: cpu.z80C = cpu.z80E; ! 14395: break; ! 14396: } ! 14397: case 0x4c: ! 14398: { ! 14399: sdwCyclesRemaining -= 4; ! 14400: cpu.z80C = cpu.z80H; ! 14401: break; ! 14402: } ! 14403: case 0x4d: ! 14404: { ! 14405: sdwCyclesRemaining -= 4; ! 14406: cpu.z80C = cpu.z80L; ! 14407: break; ! 14408: } ! 14409: case 0x4e: ! 14410: { ! 14411: sdwCyclesRemaining -= 7; ! 14412: psMemRead = cpu.z80MemRead; /* Beginning of our handler */ ! 14413: while (psMemRead->lowAddr != 0xffffffff) ! 14414: { ! 14415: if ((cpu.z80HL >= psMemRead->lowAddr) && (cpu.z80HL <= psMemRead->highAddr)) ! 14416: { ! 14417: cpu.z80pc = (UINT32) pbPC - (UINT32) cpu.z80Base; ! 14418: if (psMemRead->memoryCall) ! 14419: { ! 14420: cpu.z80C = psMemRead->memoryCall(cpu.z80HL, psMemRead); ! 14421: } ! 14422: else ! 14423: { ! 14424: cpu.z80C = *((UINT8 *) psMemRead->pUserArea + (cpu.z80HL - psMemRead->lowAddr)); ! 14425: } ! 14426: psMemRead = NULL; ! 14427: break; ! 14428: } ! 14429: ++psMemRead; ! 14430: } ! 14431: ! 14432: if (psMemRead) ! 14433: { ! 14434: cpu.z80C = cpu.z80Base[cpu.z80HL]; ! 14435: } ! 14436: ! 14437: break; ! 14438: } ! 14439: case 0x4f: ! 14440: { ! 14441: sdwCyclesRemaining -= 4; ! 14442: cpu.z80C = cpu.z80A; ! 14443: break; ! 14444: } ! 14445: case 0x50: ! 14446: { ! 14447: sdwCyclesRemaining -= 4; ! 14448: cpu.z80D = cpu.z80B; ! 14449: break; ! 14450: } ! 14451: case 0x51: ! 14452: { ! 14453: sdwCyclesRemaining -= 4; ! 14454: cpu.z80D = cpu.z80C; ! 14455: break; ! 14456: } ! 14457: case 0x52: ! 14458: { ! 14459: sdwCyclesRemaining -= 4; ! 14460: break; ! 14461: } ! 14462: case 0x53: ! 14463: { ! 14464: sdwCyclesRemaining -= 4; ! 14465: cpu.z80D = cpu.z80E; ! 14466: break; ! 14467: } ! 14468: case 0x54: ! 14469: { ! 14470: sdwCyclesRemaining -= 4; ! 14471: cpu.z80D = cpu.z80H; ! 14472: break; ! 14473: } ! 14474: case 0x55: ! 14475: { ! 14476: sdwCyclesRemaining -= 4; ! 14477: cpu.z80D = cpu.z80L; ! 14478: break; ! 14479: } ! 14480: case 0x56: ! 14481: { ! 14482: sdwCyclesRemaining -= 7; ! 14483: psMemRead = cpu.z80MemRead; /* Beginning of our handler */ ! 14484: while (psMemRead->lowAddr != 0xffffffff) ! 14485: { ! 14486: if ((cpu.z80HL >= psMemRead->lowAddr) && (cpu.z80HL <= psMemRead->highAddr)) ! 14487: { ! 14488: cpu.z80pc = (UINT32) pbPC - (UINT32) cpu.z80Base; ! 14489: if (psMemRead->memoryCall) ! 14490: { ! 14491: cpu.z80D = psMemRead->memoryCall(cpu.z80HL, psMemRead); ! 14492: } ! 14493: else ! 14494: { ! 14495: cpu.z80D = *((UINT8 *) psMemRead->pUserArea + (cpu.z80HL - psMemRead->lowAddr)); ! 14496: } ! 14497: psMemRead = NULL; ! 14498: break; ! 14499: } ! 14500: ++psMemRead; ! 14501: } ! 14502: ! 14503: if (psMemRead) ! 14504: { ! 14505: cpu.z80D = cpu.z80Base[cpu.z80HL]; ! 14506: } ! 14507: ! 14508: break; ! 14509: } ! 14510: case 0x57: ! 14511: { ! 14512: sdwCyclesRemaining -= 4; ! 14513: cpu.z80D = cpu.z80A; ! 14514: break; ! 14515: } ! 14516: case 0x58: ! 14517: { ! 14518: sdwCyclesRemaining -= 4; ! 14519: cpu.z80E = cpu.z80B; ! 14520: break; ! 14521: } ! 14522: case 0x59: ! 14523: { ! 14524: sdwCyclesRemaining -= 4; ! 14525: cpu.z80E = cpu.z80C; ! 14526: break; ! 14527: } ! 14528: case 0x5a: ! 14529: { ! 14530: sdwCyclesRemaining -= 4; ! 14531: cpu.z80E = cpu.z80D; ! 14532: break; ! 14533: } ! 14534: case 0x5b: ! 14535: { ! 14536: sdwCyclesRemaining -= 4; ! 14537: break; ! 14538: } ! 14539: case 0x5c: ! 14540: { ! 14541: sdwCyclesRemaining -= 4; ! 14542: cpu.z80E = cpu.z80H; ! 14543: break; ! 14544: } ! 14545: case 0x5d: ! 14546: { ! 14547: sdwCyclesRemaining -= 4; ! 14548: cpu.z80E = cpu.z80L; ! 14549: break; ! 14550: } ! 14551: case 0x5e: ! 14552: { ! 14553: sdwCyclesRemaining -= 7; ! 14554: psMemRead = cpu.z80MemRead; /* Beginning of our handler */ ! 14555: while (psMemRead->lowAddr != 0xffffffff) ! 14556: { ! 14557: if ((cpu.z80HL >= psMemRead->lowAddr) && (cpu.z80HL <= psMemRead->highAddr)) ! 14558: { ! 14559: cpu.z80pc = (UINT32) pbPC - (UINT32) cpu.z80Base; ! 14560: if (psMemRead->memoryCall) ! 14561: { ! 14562: cpu.z80E = psMemRead->memoryCall(cpu.z80HL, psMemRead); ! 14563: } ! 14564: else ! 14565: { ! 14566: cpu.z80E = *((UINT8 *) psMemRead->pUserArea + (cpu.z80HL - psMemRead->lowAddr)); ! 14567: } ! 14568: psMemRead = NULL; ! 14569: break; ! 14570: } ! 14571: ++psMemRead; ! 14572: } ! 14573: ! 14574: if (psMemRead) ! 14575: { ! 14576: cpu.z80E = cpu.z80Base[cpu.z80HL]; ! 14577: } ! 14578: ! 14579: break; ! 14580: } ! 14581: case 0x5f: ! 14582: { ! 14583: sdwCyclesRemaining -= 4; ! 14584: cpu.z80E = cpu.z80A; ! 14585: break; ! 14586: } ! 14587: case 0x60: ! 14588: { ! 14589: sdwCyclesRemaining -= 4; ! 14590: cpu.z80H = cpu.z80B; ! 14591: break; ! 14592: } ! 14593: case 0x61: ! 14594: { ! 14595: sdwCyclesRemaining -= 4; ! 14596: cpu.z80H = cpu.z80C; ! 14597: break; ! 14598: } ! 14599: case 0x62: ! 14600: { ! 14601: sdwCyclesRemaining -= 4; ! 14602: cpu.z80H = cpu.z80D; ! 14603: break; ! 14604: } ! 14605: case 0x63: ! 14606: { ! 14607: sdwCyclesRemaining -= 4; ! 14608: cpu.z80H = cpu.z80E; ! 14609: break; ! 14610: } ! 14611: case 0x64: ! 14612: { ! 14613: sdwCyclesRemaining -= 4; ! 14614: break; ! 14615: } ! 14616: case 0x65: ! 14617: { ! 14618: sdwCyclesRemaining -= 4; ! 14619: cpu.z80H = cpu.z80L; ! 14620: break; ! 14621: } ! 14622: case 0x66: ! 14623: { ! 14624: sdwCyclesRemaining -= 7; ! 14625: psMemRead = cpu.z80MemRead; /* Beginning of our handler */ ! 14626: while (psMemRead->lowAddr != 0xffffffff) ! 14627: { ! 14628: if ((cpu.z80HL >= psMemRead->lowAddr) && (cpu.z80HL <= psMemRead->highAddr)) ! 14629: { ! 14630: cpu.z80pc = (UINT32) pbPC - (UINT32) cpu.z80Base; ! 14631: if (psMemRead->memoryCall) ! 14632: { ! 14633: cpu.z80H = psMemRead->memoryCall(cpu.z80HL, psMemRead); ! 14634: } ! 14635: else ! 14636: { ! 14637: cpu.z80H = *((UINT8 *) psMemRead->pUserArea + (cpu.z80HL - psMemRead->lowAddr)); ! 14638: } ! 14639: psMemRead = NULL; ! 14640: break; ! 14641: } ! 14642: ++psMemRead; ! 14643: } ! 14644: ! 14645: if (psMemRead) ! 14646: { ! 14647: cpu.z80H = cpu.z80Base[cpu.z80HL]; ! 14648: } ! 14649: ! 14650: break; ! 14651: } ! 14652: case 0x67: ! 14653: { ! 14654: sdwCyclesRemaining -= 4; ! 14655: cpu.z80H = cpu.z80A; ! 14656: break; ! 14657: } ! 14658: case 0x68: ! 14659: { ! 14660: sdwCyclesRemaining -= 4; ! 14661: cpu.z80L = cpu.z80B; ! 14662: break; ! 14663: } ! 14664: case 0x69: ! 14665: { ! 14666: sdwCyclesRemaining -= 4; ! 14667: cpu.z80L = cpu.z80C; ! 14668: break; ! 14669: } ! 14670: case 0x6a: ! 14671: { ! 14672: sdwCyclesRemaining -= 4; ! 14673: cpu.z80L = cpu.z80D; ! 14674: break; ! 14675: } ! 14676: case 0x6b: ! 14677: { ! 14678: sdwCyclesRemaining -= 4; ! 14679: cpu.z80L = cpu.z80E; ! 14680: break; ! 14681: } ! 14682: case 0x6c: ! 14683: { ! 14684: sdwCyclesRemaining -= 4; ! 14685: cpu.z80L = cpu.z80H; ! 14686: break; ! 14687: } ! 14688: case 0x6d: ! 14689: { ! 14690: sdwCyclesRemaining -= 4; ! 14691: break; ! 14692: } ! 14693: case 0x6e: ! 14694: { ! 14695: sdwCyclesRemaining -= 7; ! 14696: psMemRead = cpu.z80MemRead; /* Beginning of our handler */ ! 14697: while (psMemRead->lowAddr != 0xffffffff) ! 14698: { ! 14699: if ((cpu.z80HL >= psMemRead->lowAddr) && (cpu.z80HL <= psMemRead->highAddr)) ! 14700: { ! 14701: cpu.z80pc = (UINT32) pbPC - (UINT32) cpu.z80Base; ! 14702: if (psMemRead->memoryCall) ! 14703: { ! 14704: cpu.z80L = psMemRead->memoryCall(cpu.z80HL, psMemRead); ! 14705: } ! 14706: else ! 14707: { ! 14708: cpu.z80L = *((UINT8 *) psMemRead->pUserArea + (cpu.z80HL - psMemRead->lowAddr)); ! 14709: } ! 14710: psMemRead = NULL; ! 14711: break; ! 14712: } ! 14713: ++psMemRead; ! 14714: } ! 14715: ! 14716: if (psMemRead) ! 14717: { ! 14718: cpu.z80L = cpu.z80Base[cpu.z80HL]; ! 14719: } ! 14720: ! 14721: break; ! 14722: } ! 14723: case 0x6f: ! 14724: { ! 14725: sdwCyclesRemaining -= 4; ! 14726: cpu.z80L = cpu.z80A; ! 14727: break; ! 14728: } ! 14729: case 0x70: ! 14730: { ! 14731: sdwCyclesRemaining -= 7; ! 14732: psMemWrite = cpu.z80MemWrite; /* Beginning of our handler */ ! 14733: while (psMemWrite->lowAddr != 0xffffffff) ! 14734: { ! 14735: if ((cpu.z80HL >= psMemWrite->lowAddr) && (cpu.z80HL <= psMemWrite->highAddr)) ! 14736: { ! 14737: cpu.z80pc = (UINT32) pbPC - (UINT32) cpu.z80Base; ! 14738: if (psMemWrite->memoryCall) ! 14739: { ! 14740: psMemWrite->memoryCall(cpu.z80HL, cpu.z80B, psMemWrite); ! 14741: } ! 14742: else ! 14743: { ! 14744: *((UINT8 *) psMemWrite->pUserArea + (cpu.z80HL - psMemWrite->lowAddr)) = cpu.z80B; ! 14745: } ! 14746: psMemWrite = NULL; ! 14747: break; ! 14748: } ! 14749: ++psMemWrite; ! 14750: } ! 14751: ! 14752: if (psMemWrite) ! 14753: { ! 14754: cpu.z80Base[cpu.z80HL] = (UINT8) cpu.z80B; ! 14755: } ! 14756: ! 14757: break; ! 14758: } ! 14759: case 0x71: ! 14760: { ! 14761: sdwCyclesRemaining -= 7; ! 14762: psMemWrite = cpu.z80MemWrite; /* Beginning of our handler */ ! 14763: while (psMemWrite->lowAddr != 0xffffffff) ! 14764: { ! 14765: if ((cpu.z80HL >= psMemWrite->lowAddr) && (cpu.z80HL <= psMemWrite->highAddr)) ! 14766: { ! 14767: cpu.z80pc = (UINT32) pbPC - (UINT32) cpu.z80Base; ! 14768: if (psMemWrite->memoryCall) ! 14769: { ! 14770: psMemWrite->memoryCall(cpu.z80HL, cpu.z80C, psMemWrite); ! 14771: } ! 14772: else ! 14773: { ! 14774: *((UINT8 *) psMemWrite->pUserArea + (cpu.z80HL - psMemWrite->lowAddr)) = cpu.z80C; ! 14775: } ! 14776: psMemWrite = NULL; ! 14777: break; ! 14778: } ! 14779: ++psMemWrite; ! 14780: } ! 14781: ! 14782: if (psMemWrite) ! 14783: { ! 14784: cpu.z80Base[cpu.z80HL] = (UINT8) cpu.z80C; ! 14785: } ! 14786: ! 14787: break; ! 14788: } ! 14789: case 0x72: ! 14790: { ! 14791: sdwCyclesRemaining -= 7; ! 14792: psMemWrite = cpu.z80MemWrite; /* Beginning of our handler */ ! 14793: while (psMemWrite->lowAddr != 0xffffffff) ! 14794: { ! 14795: if ((cpu.z80HL >= psMemWrite->lowAddr) && (cpu.z80HL <= psMemWrite->highAddr)) ! 14796: { ! 14797: cpu.z80pc = (UINT32) pbPC - (UINT32) cpu.z80Base; ! 14798: if (psMemWrite->memoryCall) ! 14799: { ! 14800: psMemWrite->memoryCall(cpu.z80HL, cpu.z80D, psMemWrite); ! 14801: } ! 14802: else ! 14803: { ! 14804: *((UINT8 *) psMemWrite->pUserArea + (cpu.z80HL - psMemWrite->lowAddr)) = cpu.z80D; ! 14805: } ! 14806: psMemWrite = NULL; ! 14807: break; ! 14808: } ! 14809: ++psMemWrite; ! 14810: } ! 14811: ! 14812: if (psMemWrite) ! 14813: { ! 14814: cpu.z80Base[cpu.z80HL] = (UINT8) cpu.z80D; ! 14815: } ! 14816: ! 14817: break; ! 14818: } ! 14819: case 0x73: ! 14820: { ! 14821: sdwCyclesRemaining -= 7; ! 14822: psMemWrite = cpu.z80MemWrite; /* Beginning of our handler */ ! 14823: while (psMemWrite->lowAddr != 0xffffffff) ! 14824: { ! 14825: if ((cpu.z80HL >= psMemWrite->lowAddr) && (cpu.z80HL <= psMemWrite->highAddr)) ! 14826: { ! 14827: cpu.z80pc = (UINT32) pbPC - (UINT32) cpu.z80Base; ! 14828: if (psMemWrite->memoryCall) ! 14829: { ! 14830: psMemWrite->memoryCall(cpu.z80HL, cpu.z80E, psMemWrite); ! 14831: } ! 14832: else ! 14833: { ! 14834: *((UINT8 *) psMemWrite->pUserArea + (cpu.z80HL - psMemWrite->lowAddr)) = cpu.z80E; ! 14835: } ! 14836: psMemWrite = NULL; ! 14837: break; ! 14838: } ! 14839: ++psMemWrite; ! 14840: } ! 14841: ! 14842: if (psMemWrite) ! 14843: { ! 14844: cpu.z80Base[cpu.z80HL] = (UINT8) cpu.z80E; ! 14845: } ! 14846: ! 14847: break; ! 14848: } ! 14849: case 0x74: ! 14850: { ! 14851: sdwCyclesRemaining -= 7; ! 14852: psMemWrite = cpu.z80MemWrite; /* Beginning of our handler */ ! 14853: while (psMemWrite->lowAddr != 0xffffffff) ! 14854: { ! 14855: if ((cpu.z80HL >= psMemWrite->lowAddr) && (cpu.z80HL <= psMemWrite->highAddr)) ! 14856: { ! 14857: cpu.z80pc = (UINT32) pbPC - (UINT32) cpu.z80Base; ! 14858: if (psMemWrite->memoryCall) ! 14859: { ! 14860: psMemWrite->memoryCall(cpu.z80HL, cpu.z80H, psMemWrite); ! 14861: } ! 14862: else ! 14863: { ! 14864: *((UINT8 *) psMemWrite->pUserArea + (cpu.z80HL - psMemWrite->lowAddr)) = cpu.z80H; ! 14865: } ! 14866: psMemWrite = NULL; ! 14867: break; ! 14868: } ! 14869: ++psMemWrite; ! 14870: } ! 14871: ! 14872: if (psMemWrite) ! 14873: { ! 14874: cpu.z80Base[cpu.z80HL] = (UINT8) cpu.z80H; ! 14875: } ! 14876: ! 14877: break; ! 14878: } ! 14879: case 0x75: ! 14880: { ! 14881: sdwCyclesRemaining -= 7; ! 14882: psMemWrite = cpu.z80MemWrite; /* Beginning of our handler */ ! 14883: while (psMemWrite->lowAddr != 0xffffffff) ! 14884: { ! 14885: if ((cpu.z80HL >= psMemWrite->lowAddr) && (cpu.z80HL <= psMemWrite->highAddr)) ! 14886: { ! 14887: cpu.z80pc = (UINT32) pbPC - (UINT32) cpu.z80Base; ! 14888: if (psMemWrite->memoryCall) ! 14889: { ! 14890: psMemWrite->memoryCall(cpu.z80HL, cpu.z80L, psMemWrite); ! 14891: } ! 14892: else ! 14893: { ! 14894: *((UINT8 *) psMemWrite->pUserArea + (cpu.z80HL - psMemWrite->lowAddr)) = cpu.z80L; ! 14895: } ! 14896: psMemWrite = NULL; ! 14897: break; ! 14898: } ! 14899: ++psMemWrite; ! 14900: } ! 14901: ! 14902: if (psMemWrite) ! 14903: { ! 14904: cpu.z80Base[cpu.z80HL] = (UINT8) cpu.z80L; ! 14905: } ! 14906: ! 14907: break; ! 14908: } ! 14909: case 0x76: ! 14910: { ! 14911: sdwCyclesRemaining -= 4; ! 14912: cpu.z80halted = 1; ! 14913: dwElapsedTicks += sdwCyclesRemaining; ! 14914: sdwCyclesRemaining = 0; ! 14915: break; ! 14916: } ! 14917: case 0x77: ! 14918: { ! 14919: sdwCyclesRemaining -= 7; ! 14920: psMemWrite = cpu.z80MemWrite; /* Beginning of our handler */ ! 14921: while (psMemWrite->lowAddr != 0xffffffff) ! 14922: { ! 14923: if ((cpu.z80HL >= psMemWrite->lowAddr) && (cpu.z80HL <= psMemWrite->highAddr)) ! 14924: { ! 14925: cpu.z80pc = (UINT32) pbPC - (UINT32) cpu.z80Base; ! 14926: if (psMemWrite->memoryCall) ! 14927: { ! 14928: psMemWrite->memoryCall(cpu.z80HL, cpu.z80A, psMemWrite); ! 14929: } ! 14930: else ! 14931: { ! 14932: *((UINT8 *) psMemWrite->pUserArea + (cpu.z80HL - psMemWrite->lowAddr)) = cpu.z80A; ! 14933: } ! 14934: psMemWrite = NULL; ! 14935: break; ! 14936: } ! 14937: ++psMemWrite; ! 14938: } ! 14939: ! 14940: if (psMemWrite) ! 14941: { ! 14942: cpu.z80Base[cpu.z80HL] = (UINT8) cpu.z80A; ! 14943: } ! 14944: ! 14945: break; ! 14946: } ! 14947: case 0x78: ! 14948: { ! 14949: sdwCyclesRemaining -= 4; ! 14950: cpu.z80A = cpu.z80B; ! 14951: break; ! 14952: } ! 14953: case 0x79: ! 14954: { ! 14955: sdwCyclesRemaining -= 4; ! 14956: cpu.z80A = cpu.z80C; ! 14957: break; ! 14958: } ! 14959: case 0x7a: ! 14960: { ! 14961: sdwCyclesRemaining -= 4; ! 14962: cpu.z80A = cpu.z80D; ! 14963: break; ! 14964: } ! 14965: case 0x7b: ! 14966: { ! 14967: sdwCyclesRemaining -= 4; ! 14968: cpu.z80A = cpu.z80E; ! 14969: break; ! 14970: } ! 14971: case 0x7c: ! 14972: { ! 14973: sdwCyclesRemaining -= 4; ! 14974: cpu.z80A = cpu.z80H; ! 14975: break; ! 14976: } ! 14977: case 0x7d: ! 14978: { ! 14979: sdwCyclesRemaining -= 4; ! 14980: cpu.z80A = cpu.z80L; ! 14981: break; ! 14982: } ! 14983: case 0x7e: ! 14984: { ! 14985: sdwCyclesRemaining -= 7; ! 14986: psMemRead = cpu.z80MemRead; /* Beginning of our handler */ ! 14987: while (psMemRead->lowAddr != 0xffffffff) ! 14988: { ! 14989: if ((cpu.z80HL >= psMemRead->lowAddr) && (cpu.z80HL <= psMemRead->highAddr)) ! 14990: { ! 14991: cpu.z80pc = (UINT32) pbPC - (UINT32) cpu.z80Base; ! 14992: if (psMemRead->memoryCall) ! 14993: { ! 14994: cpu.z80A = psMemRead->memoryCall(cpu.z80HL, psMemRead); ! 14995: } ! 14996: else ! 14997: { ! 14998: cpu.z80A = *((UINT8 *) psMemRead->pUserArea + (cpu.z80HL - psMemRead->lowAddr)); ! 14999: } ! 15000: psMemRead = NULL; ! 15001: break; ! 15002: } ! 15003: ++psMemRead; ! 15004: } ! 15005: ! 15006: if (psMemRead) ! 15007: { ! 15008: cpu.z80A = cpu.z80Base[cpu.z80HL]; ! 15009: } ! 15010: ! 15011: break; ! 15012: } ! 15013: case 0x7f: ! 15014: { ! 15015: sdwCyclesRemaining -= 4; ! 15016: break; ! 15017: } ! 15018: case 0x80: ! 15019: { ! 15020: sdwCyclesRemaining -= 4; ! 15021: bTemp2 = cpu.z80A + cpu.z80B; ! 15022: cpu.z80F = (cpu.z80F & ~(Z80_FLAG_CARRY | Z80_FLAG_NEGATIVE | Z80_FLAG_OVERFLOW_PARITY | ! 15023: Z80_FLAG_HALF_CARRY | Z80_FLAG_ZERO | Z80_FLAG_SIGN)) | ! 15024: pbAddAdcTable[((UINT32) cpu.z80A << 8) | cpu.z80B]; ! 15025: cpu.z80A = bTemp2; ! 15026: break; ! 15027: } ! 15028: case 0x81: ! 15029: { ! 15030: sdwCyclesRemaining -= 4; ! 15031: bTemp2 = cpu.z80A + cpu.z80C; ! 15032: cpu.z80F = (cpu.z80F & ~(Z80_FLAG_CARRY | Z80_FLAG_NEGATIVE | Z80_FLAG_OVERFLOW_PARITY | ! 15033: Z80_FLAG_HALF_CARRY | Z80_FLAG_ZERO | Z80_FLAG_SIGN)) | ! 15034: pbAddAdcTable[((UINT32) cpu.z80A << 8) | cpu.z80C]; ! 15035: cpu.z80A = bTemp2; ! 15036: break; ! 15037: } ! 15038: case 0x82: ! 15039: { ! 15040: sdwCyclesRemaining -= 4; ! 15041: bTemp2 = cpu.z80A + cpu.z80D; ! 15042: cpu.z80F = (cpu.z80F & ~(Z80_FLAG_CARRY | Z80_FLAG_NEGATIVE | Z80_FLAG_OVERFLOW_PARITY | ! 15043: Z80_FLAG_HALF_CARRY | Z80_FLAG_ZERO | Z80_FLAG_SIGN)) | ! 15044: pbAddAdcTable[((UINT32) cpu.z80A << 8) | cpu.z80D]; ! 15045: cpu.z80A = bTemp2; ! 15046: break; ! 15047: } ! 15048: case 0x83: ! 15049: { ! 15050: sdwCyclesRemaining -= 4; ! 15051: bTemp2 = cpu.z80A + cpu.z80E; ! 15052: cpu.z80F = (cpu.z80F & ~(Z80_FLAG_CARRY | Z80_FLAG_NEGATIVE | Z80_FLAG_OVERFLOW_PARITY | ! 15053: Z80_FLAG_HALF_CARRY | Z80_FLAG_ZERO | Z80_FLAG_SIGN)) | ! 15054: pbAddAdcTable[((UINT32) cpu.z80A << 8) | cpu.z80E]; ! 15055: cpu.z80A = bTemp2; ! 15056: break; ! 15057: } ! 15058: case 0x84: ! 15059: { ! 15060: sdwCyclesRemaining -= 4; ! 15061: bTemp2 = cpu.z80A + cpu.z80H; ! 15062: cpu.z80F = (cpu.z80F & ~(Z80_FLAG_CARRY | Z80_FLAG_NEGATIVE | Z80_FLAG_OVERFLOW_PARITY | ! 15063: Z80_FLAG_HALF_CARRY | Z80_FLAG_ZERO | Z80_FLAG_SIGN)) | ! 15064: pbAddAdcTable[((UINT32) cpu.z80A << 8) | cpu.z80H]; ! 15065: cpu.z80A = bTemp2; ! 15066: break; ! 15067: } ! 15068: case 0x85: ! 15069: { ! 15070: sdwCyclesRemaining -= 4; ! 15071: bTemp2 = cpu.z80A + cpu.z80L; ! 15072: cpu.z80F = (cpu.z80F & ~(Z80_FLAG_CARRY | Z80_FLAG_NEGATIVE | Z80_FLAG_OVERFLOW_PARITY | ! 15073: Z80_FLAG_HALF_CARRY | Z80_FLAG_ZERO | Z80_FLAG_SIGN)) | ! 15074: pbAddAdcTable[((UINT32) cpu.z80A << 8) | cpu.z80L]; ! 15075: cpu.z80A = bTemp2; ! 15076: break; ! 15077: } ! 15078: case 0x86: ! 15079: { ! 15080: sdwCyclesRemaining -= 7; ! 15081: psMemRead = cpu.z80MemRead; /* Beginning of our handler */ ! 15082: while (psMemRead->lowAddr != 0xffffffff) ! 15083: { ! 15084: if ((cpu.z80HL >= psMemRead->lowAddr) && (cpu.z80HL <= psMemRead->highAddr)) ! 15085: { ! 15086: cpu.z80pc = (UINT32) pbPC - (UINT32) cpu.z80Base; ! 15087: if (psMemRead->memoryCall) ! 15088: { ! 15089: bTemp = psMemRead->memoryCall(cpu.z80HL, psMemRead); ! 15090: } ! 15091: else ! 15092: { ! 15093: bTemp = *((UINT8 *) psMemRead->pUserArea + (cpu.z80HL - psMemRead->lowAddr)); ! 15094: } ! 15095: psMemRead = NULL; ! 15096: break; ! 15097: } ! 15098: ++psMemRead; ! 15099: } ! 15100: ! 15101: if (psMemRead) ! 15102: { ! 15103: bTemp = cpu.z80Base[cpu.z80HL]; ! 15104: } ! 15105: ! 15106: bTemp2 = cpu.z80A + bTemp; ! 15107: cpu.z80F = (cpu.z80F & ~(Z80_FLAG_CARRY | Z80_FLAG_NEGATIVE | Z80_FLAG_OVERFLOW_PARITY | ! 15108: Z80_FLAG_HALF_CARRY | Z80_FLAG_ZERO | Z80_FLAG_SIGN)) | ! 15109: pbAddAdcTable[((UINT32) cpu.z80A << 8) | bTemp]; ! 15110: cpu.z80A = bTemp2; ! 15111: break; ! 15112: } ! 15113: case 0x87: ! 15114: { ! 15115: sdwCyclesRemaining -= 4; ! 15116: bTemp2 = cpu.z80A + cpu.z80A; ! 15117: cpu.z80F = (cpu.z80F & ~(Z80_FLAG_CARRY | Z80_FLAG_NEGATIVE | Z80_FLAG_OVERFLOW_PARITY | ! 15118: Z80_FLAG_HALF_CARRY | Z80_FLAG_ZERO | Z80_FLAG_SIGN)) | ! 15119: pbAddAdcTable[((UINT32) cpu.z80A << 8) | cpu.z80A]; ! 15120: cpu.z80A = bTemp2; ! 15121: break; ! 15122: } ! 15123: case 0x88: ! 15124: { ! 15125: sdwCyclesRemaining -= 4; ! 15126: bTemp2 = cpu.z80A + cpu.z80B + (cpu.z80F & Z80_FLAG_CARRY); ! 15127: cpu.z80F = (cpu.z80F & ~(Z80_FLAG_CARRY | Z80_FLAG_NEGATIVE | Z80_FLAG_OVERFLOW_PARITY | ! 15128: Z80_FLAG_HALF_CARRY | Z80_FLAG_ZERO | Z80_FLAG_SIGN)) | ! 15129: pbAddAdcTable[((UINT32) cpu.z80A << 8) | cpu.z80B | (((UINT32) cpu.z80F & Z80_FLAG_CARRY) << 16)]; ! 15130: cpu.z80A = bTemp2; ! 15131: break; ! 15132: } ! 15133: case 0x89: ! 15134: { ! 15135: sdwCyclesRemaining -= 4; ! 15136: bTemp2 = cpu.z80A + cpu.z80C + (cpu.z80F & Z80_FLAG_CARRY); ! 15137: cpu.z80F = (cpu.z80F & ~(Z80_FLAG_CARRY | Z80_FLAG_NEGATIVE | Z80_FLAG_OVERFLOW_PARITY | ! 15138: Z80_FLAG_HALF_CARRY | Z80_FLAG_ZERO | Z80_FLAG_SIGN)) | ! 15139: pbAddAdcTable[((UINT32) cpu.z80A << 8) | cpu.z80C | (((UINT32) cpu.z80F & Z80_FLAG_CARRY) << 16)]; ! 15140: cpu.z80A = bTemp2; ! 15141: break; ! 15142: } ! 15143: case 0x8a: ! 15144: { ! 15145: sdwCyclesRemaining -= 4; ! 15146: bTemp2 = cpu.z80A + cpu.z80D + (cpu.z80F & Z80_FLAG_CARRY); ! 15147: cpu.z80F = (cpu.z80F & ~(Z80_FLAG_CARRY | Z80_FLAG_NEGATIVE | Z80_FLAG_OVERFLOW_PARITY | ! 15148: Z80_FLAG_HALF_CARRY | Z80_FLAG_ZERO | Z80_FLAG_SIGN)) | ! 15149: pbAddAdcTable[((UINT32) cpu.z80A << 8) | cpu.z80D | (((UINT32) cpu.z80F & Z80_FLAG_CARRY) << 16)]; ! 15150: cpu.z80A = bTemp2; ! 15151: break; ! 15152: } ! 15153: case 0x8b: ! 15154: { ! 15155: sdwCyclesRemaining -= 4; ! 15156: bTemp2 = cpu.z80A + cpu.z80E + (cpu.z80F & Z80_FLAG_CARRY); ! 15157: cpu.z80F = (cpu.z80F & ~(Z80_FLAG_CARRY | Z80_FLAG_NEGATIVE | Z80_FLAG_OVERFLOW_PARITY | ! 15158: Z80_FLAG_HALF_CARRY | Z80_FLAG_ZERO | Z80_FLAG_SIGN)) | ! 15159: pbAddAdcTable[((UINT32) cpu.z80A << 8) | cpu.z80E | (((UINT32) cpu.z80F & Z80_FLAG_CARRY) << 16)]; ! 15160: cpu.z80A = bTemp2; ! 15161: break; ! 15162: } ! 15163: case 0x8c: ! 15164: { ! 15165: sdwCyclesRemaining -= 4; ! 15166: bTemp2 = cpu.z80A + cpu.z80H + (cpu.z80F & Z80_FLAG_CARRY); ! 15167: cpu.z80F = (cpu.z80F & ~(Z80_FLAG_CARRY | Z80_FLAG_NEGATIVE | Z80_FLAG_OVERFLOW_PARITY | ! 15168: Z80_FLAG_HALF_CARRY | Z80_FLAG_ZERO | Z80_FLAG_SIGN)) | ! 15169: pbAddAdcTable[((UINT32) cpu.z80A << 8) | cpu.z80H | (((UINT32) cpu.z80F & Z80_FLAG_CARRY) << 16)]; ! 15170: cpu.z80A = bTemp2; ! 15171: break; ! 15172: } ! 15173: case 0x8d: ! 15174: { ! 15175: sdwCyclesRemaining -= 4; ! 15176: bTemp2 = cpu.z80A + cpu.z80L + (cpu.z80F & Z80_FLAG_CARRY); ! 15177: cpu.z80F = (cpu.z80F & ~(Z80_FLAG_CARRY | Z80_FLAG_NEGATIVE | Z80_FLAG_OVERFLOW_PARITY | ! 15178: Z80_FLAG_HALF_CARRY | Z80_FLAG_ZERO | Z80_FLAG_SIGN)) | ! 15179: pbAddAdcTable[((UINT32) cpu.z80A << 8) | cpu.z80L | (((UINT32) cpu.z80F & Z80_FLAG_CARRY) << 16)]; ! 15180: cpu.z80A = bTemp2; ! 15181: break; ! 15182: } ! 15183: case 0x8e: ! 15184: { ! 15185: sdwCyclesRemaining -= 7; ! 15186: psMemRead = cpu.z80MemRead; /* Beginning of our handler */ ! 15187: while (psMemRead->lowAddr != 0xffffffff) ! 15188: { ! 15189: if ((cpu.z80HL >= psMemRead->lowAddr) && (cpu.z80HL <= psMemRead->highAddr)) ! 15190: { ! 15191: cpu.z80pc = (UINT32) pbPC - (UINT32) cpu.z80Base; ! 15192: if (psMemRead->memoryCall) ! 15193: { ! 15194: bTemp = psMemRead->memoryCall(cpu.z80HL, psMemRead); ! 15195: } ! 15196: else ! 15197: { ! 15198: bTemp = *((UINT8 *) psMemRead->pUserArea + (cpu.z80HL - psMemRead->lowAddr)); ! 15199: } ! 15200: psMemRead = NULL; ! 15201: break; ! 15202: } ! 15203: ++psMemRead; ! 15204: } ! 15205: ! 15206: if (psMemRead) ! 15207: { ! 15208: bTemp = cpu.z80Base[cpu.z80HL]; ! 15209: } ! 15210: ! 15211: bTemp2 = cpu.z80A + bTemp + (cpu.z80F & Z80_FLAG_CARRY); ! 15212: cpu.z80F = (cpu.z80F & ~(Z80_FLAG_CARRY | Z80_FLAG_NEGATIVE | Z80_FLAG_OVERFLOW_PARITY | ! 15213: Z80_FLAG_HALF_CARRY | Z80_FLAG_ZERO | Z80_FLAG_SIGN)) | ! 15214: pbAddAdcTable[((UINT32) cpu.z80A << 8) | bTemp | (((UINT32) cpu.z80F & Z80_FLAG_CARRY) << 16)]; ! 15215: cpu.z80A = bTemp2; ! 15216: break; ! 15217: } ! 15218: case 0x8f: ! 15219: { ! 15220: sdwCyclesRemaining -= 4; ! 15221: bTemp2 = cpu.z80A + cpu.z80A + (cpu.z80F & Z80_FLAG_CARRY); ! 15222: cpu.z80F = (cpu.z80F & ~(Z80_FLAG_CARRY | Z80_FLAG_NEGATIVE | Z80_FLAG_OVERFLOW_PARITY | ! 15223: Z80_FLAG_HALF_CARRY | Z80_FLAG_ZERO | Z80_FLAG_SIGN)) | ! 15224: pbAddAdcTable[((UINT32) cpu.z80A << 8) | cpu.z80A | (((UINT32) cpu.z80F & Z80_FLAG_CARRY) << 16)]; ! 15225: cpu.z80A = bTemp2; ! 15226: break; ! 15227: } ! 15228: case 0x90: ! 15229: { ! 15230: sdwCyclesRemaining -= 4; ! 15231: bTemp2 = cpu.z80A - cpu.z80B; ! 15232: cpu.z80F = (cpu.z80F & ~(Z80_FLAG_CARRY | Z80_FLAG_NEGATIVE | Z80_FLAG_OVERFLOW_PARITY | ! 15233: Z80_FLAG_HALF_CARRY | Z80_FLAG_ZERO | Z80_FLAG_SIGN)) | ! 15234: pbSubSbcTable[((UINT32) cpu.z80A << 8) | cpu.z80B]; ! 15235: cpu.z80A = bTemp2; ! 15236: break; ! 15237: } ! 15238: case 0x91: ! 15239: { ! 15240: sdwCyclesRemaining -= 4; ! 15241: bTemp2 = cpu.z80A - cpu.z80C; ! 15242: cpu.z80F = (cpu.z80F & ~(Z80_FLAG_CARRY | Z80_FLAG_NEGATIVE | Z80_FLAG_OVERFLOW_PARITY | ! 15243: Z80_FLAG_HALF_CARRY | Z80_FLAG_ZERO | Z80_FLAG_SIGN)) | ! 15244: pbSubSbcTable[((UINT32) cpu.z80A << 8) | cpu.z80C]; ! 15245: cpu.z80A = bTemp2; ! 15246: break; ! 15247: } ! 15248: case 0x92: ! 15249: { ! 15250: sdwCyclesRemaining -= 4; ! 15251: bTemp2 = cpu.z80A - cpu.z80D; ! 15252: cpu.z80F = (cpu.z80F & ~(Z80_FLAG_CARRY | Z80_FLAG_NEGATIVE | Z80_FLAG_OVERFLOW_PARITY | ! 15253: Z80_FLAG_HALF_CARRY | Z80_FLAG_ZERO | Z80_FLAG_SIGN)) | ! 15254: pbSubSbcTable[((UINT32) cpu.z80A << 8) | cpu.z80D]; ! 15255: cpu.z80A = bTemp2; ! 15256: break; ! 15257: } ! 15258: case 0x93: ! 15259: { ! 15260: sdwCyclesRemaining -= 4; ! 15261: bTemp2 = cpu.z80A - cpu.z80E; ! 15262: cpu.z80F = (cpu.z80F & ~(Z80_FLAG_CARRY | Z80_FLAG_NEGATIVE | Z80_FLAG_OVERFLOW_PARITY | ! 15263: Z80_FLAG_HALF_CARRY | Z80_FLAG_ZERO | Z80_FLAG_SIGN)) | ! 15264: pbSubSbcTable[((UINT32) cpu.z80A << 8) | cpu.z80E]; ! 15265: cpu.z80A = bTemp2; ! 15266: break; ! 15267: } ! 15268: case 0x94: ! 15269: { ! 15270: sdwCyclesRemaining -= 4; ! 15271: bTemp2 = cpu.z80A - cpu.z80H; ! 15272: cpu.z80F = (cpu.z80F & ~(Z80_FLAG_CARRY | Z80_FLAG_NEGATIVE | Z80_FLAG_OVERFLOW_PARITY | ! 15273: Z80_FLAG_HALF_CARRY | Z80_FLAG_ZERO | Z80_FLAG_SIGN)) | ! 15274: pbSubSbcTable[((UINT32) cpu.z80A << 8) | cpu.z80H]; ! 15275: cpu.z80A = bTemp2; ! 15276: break; ! 15277: } ! 15278: case 0x95: ! 15279: { ! 15280: sdwCyclesRemaining -= 4; ! 15281: bTemp2 = cpu.z80A - cpu.z80L; ! 15282: cpu.z80F = (cpu.z80F & ~(Z80_FLAG_CARRY | Z80_FLAG_NEGATIVE | Z80_FLAG_OVERFLOW_PARITY | ! 15283: Z80_FLAG_HALF_CARRY | Z80_FLAG_ZERO | Z80_FLAG_SIGN)) | ! 15284: pbSubSbcTable[((UINT32) cpu.z80A << 8) | cpu.z80L]; ! 15285: cpu.z80A = bTemp2; ! 15286: break; ! 15287: } ! 15288: case 0x96: ! 15289: { ! 15290: sdwCyclesRemaining -= 7; ! 15291: psMemRead = cpu.z80MemRead; /* Beginning of our handler */ ! 15292: while (psMemRead->lowAddr != 0xffffffff) ! 15293: { ! 15294: if ((cpu.z80HL >= psMemRead->lowAddr) && (cpu.z80HL <= psMemRead->highAddr)) ! 15295: { ! 15296: cpu.z80pc = (UINT32) pbPC - (UINT32) cpu.z80Base; ! 15297: if (psMemRead->memoryCall) ! 15298: { ! 15299: bTemp = psMemRead->memoryCall(cpu.z80HL, psMemRead); ! 15300: } ! 15301: else ! 15302: { ! 15303: bTemp = *((UINT8 *) psMemRead->pUserArea + (cpu.z80HL - psMemRead->lowAddr)); ! 15304: } ! 15305: psMemRead = NULL; ! 15306: break; ! 15307: } ! 15308: ++psMemRead; ! 15309: } ! 15310: ! 15311: if (psMemRead) ! 15312: { ! 15313: bTemp = cpu.z80Base[cpu.z80HL]; ! 15314: } ! 15315: ! 15316: bTemp2 = cpu.z80A - bTemp; ! 15317: cpu.z80F = (cpu.z80F & ~(Z80_FLAG_CARRY | Z80_FLAG_NEGATIVE | Z80_FLAG_OVERFLOW_PARITY | ! 15318: Z80_FLAG_HALF_CARRY | Z80_FLAG_ZERO | Z80_FLAG_SIGN)) | ! 15319: pbSubSbcTable[((UINT32) cpu.z80A << 8) | bTemp]; ! 15320: cpu.z80A = bTemp2; ! 15321: break; ! 15322: } ! 15323: case 0x97: ! 15324: { ! 15325: sdwCyclesRemaining -= 4; ! 15326: bTemp2 = cpu.z80A - cpu.z80A; ! 15327: cpu.z80F = (cpu.z80F & ~(Z80_FLAG_CARRY | Z80_FLAG_NEGATIVE | Z80_FLAG_OVERFLOW_PARITY | ! 15328: Z80_FLAG_HALF_CARRY | Z80_FLAG_ZERO | Z80_FLAG_SIGN)) | ! 15329: pbSubSbcTable[((UINT32) cpu.z80A << 8) | cpu.z80A]; ! 15330: cpu.z80A = bTemp2; ! 15331: break; ! 15332: } ! 15333: case 0x98: ! 15334: { ! 15335: sdwCyclesRemaining -= 4; ! 15336: bTemp2 = cpu.z80A - cpu.z80B - (cpu.z80F & Z80_FLAG_CARRY); ! 15337: cpu.z80F = (cpu.z80F & ~(Z80_FLAG_CARRY | Z80_FLAG_NEGATIVE | Z80_FLAG_OVERFLOW_PARITY | ! 15338: Z80_FLAG_HALF_CARRY | Z80_FLAG_ZERO | Z80_FLAG_SIGN)) | ! 15339: pbSubSbcTable[((UINT32) cpu.z80A << 8) | cpu.z80B | (((UINT32) cpu.z80F & Z80_FLAG_CARRY) << 16)]; ! 15340: cpu.z80A = bTemp2; ! 15341: break; ! 15342: } ! 15343: case 0x99: ! 15344: { ! 15345: sdwCyclesRemaining -= 4; ! 15346: bTemp2 = cpu.z80A - cpu.z80C - (cpu.z80F & Z80_FLAG_CARRY); ! 15347: cpu.z80F = (cpu.z80F & ~(Z80_FLAG_CARRY | Z80_FLAG_NEGATIVE | Z80_FLAG_OVERFLOW_PARITY | ! 15348: Z80_FLAG_HALF_CARRY | Z80_FLAG_ZERO | Z80_FLAG_SIGN)) | ! 15349: pbSubSbcTable[((UINT32) cpu.z80A << 8) | cpu.z80C | (((UINT32) cpu.z80F & Z80_FLAG_CARRY) << 16)]; ! 15350: cpu.z80A = bTemp2; ! 15351: break; ! 15352: } ! 15353: case 0x9a: ! 15354: { ! 15355: sdwCyclesRemaining -= 4; ! 15356: bTemp2 = cpu.z80A - cpu.z80D - (cpu.z80F & Z80_FLAG_CARRY); ! 15357: cpu.z80F = (cpu.z80F & ~(Z80_FLAG_CARRY | Z80_FLAG_NEGATIVE | Z80_FLAG_OVERFLOW_PARITY | ! 15358: Z80_FLAG_HALF_CARRY | Z80_FLAG_ZERO | Z80_FLAG_SIGN)) | ! 15359: pbSubSbcTable[((UINT32) cpu.z80A << 8) | cpu.z80D | (((UINT32) cpu.z80F & Z80_FLAG_CARRY) << 16)]; ! 15360: cpu.z80A = bTemp2; ! 15361: break; ! 15362: } ! 15363: case 0x9b: ! 15364: { ! 15365: sdwCyclesRemaining -= 4; ! 15366: bTemp2 = cpu.z80A - cpu.z80E - (cpu.z80F & Z80_FLAG_CARRY); ! 15367: cpu.z80F = (cpu.z80F & ~(Z80_FLAG_CARRY | Z80_FLAG_NEGATIVE | Z80_FLAG_OVERFLOW_PARITY | ! 15368: Z80_FLAG_HALF_CARRY | Z80_FLAG_ZERO | Z80_FLAG_SIGN)) | ! 15369: pbSubSbcTable[((UINT32) cpu.z80A << 8) | cpu.z80E | (((UINT32) cpu.z80F & Z80_FLAG_CARRY) << 16)]; ! 15370: cpu.z80A = bTemp2; ! 15371: break; ! 15372: } ! 15373: case 0x9c: ! 15374: { ! 15375: sdwCyclesRemaining -= 4; ! 15376: bTemp2 = cpu.z80A - cpu.z80H - (cpu.z80F & Z80_FLAG_CARRY); ! 15377: cpu.z80F = (cpu.z80F & ~(Z80_FLAG_CARRY | Z80_FLAG_NEGATIVE | Z80_FLAG_OVERFLOW_PARITY | ! 15378: Z80_FLAG_HALF_CARRY | Z80_FLAG_ZERO | Z80_FLAG_SIGN)) | ! 15379: pbSubSbcTable[((UINT32) cpu.z80A << 8) | cpu.z80H | (((UINT32) cpu.z80F & Z80_FLAG_CARRY) << 16)]; ! 15380: cpu.z80A = bTemp2; ! 15381: break; ! 15382: } ! 15383: case 0x9d: ! 15384: { ! 15385: sdwCyclesRemaining -= 4; ! 15386: bTemp2 = cpu.z80A - cpu.z80L - (cpu.z80F & Z80_FLAG_CARRY); ! 15387: cpu.z80F = (cpu.z80F & ~(Z80_FLAG_CARRY | Z80_FLAG_NEGATIVE | Z80_FLAG_OVERFLOW_PARITY | ! 15388: Z80_FLAG_HALF_CARRY | Z80_FLAG_ZERO | Z80_FLAG_SIGN)) | ! 15389: pbSubSbcTable[((UINT32) cpu.z80A << 8) | cpu.z80L | (((UINT32) cpu.z80F & Z80_FLAG_CARRY) << 16)]; ! 15390: cpu.z80A = bTemp2; ! 15391: break; ! 15392: } ! 15393: case 0x9e: ! 15394: { ! 15395: sdwCyclesRemaining -= 7; ! 15396: psMemRead = cpu.z80MemRead; /* Beginning of our handler */ ! 15397: while (psMemRead->lowAddr != 0xffffffff) ! 15398: { ! 15399: if ((cpu.z80HL >= psMemRead->lowAddr) && (cpu.z80HL <= psMemRead->highAddr)) ! 15400: { ! 15401: cpu.z80pc = (UINT32) pbPC - (UINT32) cpu.z80Base; ! 15402: if (psMemRead->memoryCall) ! 15403: { ! 15404: bTemp = psMemRead->memoryCall(cpu.z80HL, psMemRead); ! 15405: } ! 15406: else ! 15407: { ! 15408: bTemp = *((UINT8 *) psMemRead->pUserArea + (cpu.z80HL - psMemRead->lowAddr)); ! 15409: } ! 15410: psMemRead = NULL; ! 15411: break; ! 15412: } ! 15413: ++psMemRead; ! 15414: } ! 15415: ! 15416: if (psMemRead) ! 15417: { ! 15418: bTemp = cpu.z80Base[cpu.z80HL]; ! 15419: } ! 15420: ! 15421: bTemp2 = cpu.z80A - bTemp - (cpu.z80F & Z80_FLAG_CARRY); ! 15422: cpu.z80F = (cpu.z80F & ~(Z80_FLAG_CARRY | Z80_FLAG_NEGATIVE | Z80_FLAG_OVERFLOW_PARITY | ! 15423: Z80_FLAG_HALF_CARRY | Z80_FLAG_ZERO | Z80_FLAG_SIGN)) | ! 15424: pbSubSbcTable[((UINT32) cpu.z80A << 8) | bTemp | (((UINT32) cpu.z80F & Z80_FLAG_CARRY) << 16)]; ! 15425: cpu.z80A = bTemp2; ! 15426: break; ! 15427: } ! 15428: case 0x9f: ! 15429: { ! 15430: sdwCyclesRemaining -= 4; ! 15431: bTemp2 = cpu.z80A - cpu.z80A - (cpu.z80F & Z80_FLAG_CARRY); ! 15432: cpu.z80F = (cpu.z80F & ~(Z80_FLAG_CARRY | Z80_FLAG_NEGATIVE | Z80_FLAG_OVERFLOW_PARITY | ! 15433: Z80_FLAG_HALF_CARRY | Z80_FLAG_ZERO | Z80_FLAG_SIGN)) | ! 15434: pbSubSbcTable[((UINT32) cpu.z80A << 8) | cpu.z80A | (((UINT32) cpu.z80F & Z80_FLAG_CARRY) << 16)]; ! 15435: cpu.z80A = bTemp2; ! 15436: break; ! 15437: } ! 15438: case 0xa0: ! 15439: { ! 15440: sdwCyclesRemaining -= 4; ! 15441: cpu.z80A &= cpu.z80B; ! 15442: cpu.z80F &= ~(Z80_FLAG_CARRY | Z80_FLAG_NEGATIVE | Z80_FLAG_OVERFLOW_PARITY | Z80_FLAG_HALF_CARRY | Z80_FLAG_ZERO | Z80_FLAG_SIGN); ! 15443: cpu.z80F |= bPostANDFlags[cpu.z80A]; ! 15444: ! 15445: break; ! 15446: } ! 15447: case 0xa1: ! 15448: { ! 15449: sdwCyclesRemaining -= 4; ! 15450: cpu.z80A &= cpu.z80C; ! 15451: cpu.z80F &= ~(Z80_FLAG_CARRY | Z80_FLAG_NEGATIVE | Z80_FLAG_OVERFLOW_PARITY | Z80_FLAG_HALF_CARRY | Z80_FLAG_ZERO | Z80_FLAG_SIGN); ! 15452: cpu.z80F |= bPostANDFlags[cpu.z80A]; ! 15453: ! 15454: break; ! 15455: } ! 15456: case 0xa2: ! 15457: { ! 15458: sdwCyclesRemaining -= 4; ! 15459: cpu.z80A &= cpu.z80D; ! 15460: cpu.z80F &= ~(Z80_FLAG_CARRY | Z80_FLAG_NEGATIVE | Z80_FLAG_OVERFLOW_PARITY | Z80_FLAG_HALF_CARRY | Z80_FLAG_ZERO | Z80_FLAG_SIGN); ! 15461: cpu.z80F |= bPostANDFlags[cpu.z80A]; ! 15462: ! 15463: break; ! 15464: } ! 15465: case 0xa3: ! 15466: { ! 15467: sdwCyclesRemaining -= 4; ! 15468: cpu.z80A &= cpu.z80E; ! 15469: cpu.z80F &= ~(Z80_FLAG_CARRY | Z80_FLAG_NEGATIVE | Z80_FLAG_OVERFLOW_PARITY | Z80_FLAG_HALF_CARRY | Z80_FLAG_ZERO | Z80_FLAG_SIGN); ! 15470: cpu.z80F |= bPostANDFlags[cpu.z80A]; ! 15471: ! 15472: break; ! 15473: } ! 15474: case 0xa4: ! 15475: { ! 15476: sdwCyclesRemaining -= 4; ! 15477: cpu.z80A &= cpu.z80H; ! 15478: cpu.z80F &= ~(Z80_FLAG_CARRY | Z80_FLAG_NEGATIVE | Z80_FLAG_OVERFLOW_PARITY | Z80_FLAG_HALF_CARRY | Z80_FLAG_ZERO | Z80_FLAG_SIGN); ! 15479: cpu.z80F |= bPostANDFlags[cpu.z80A]; ! 15480: ! 15481: break; ! 15482: } ! 15483: case 0xa5: ! 15484: { ! 15485: sdwCyclesRemaining -= 4; ! 15486: cpu.z80A &= cpu.z80L; ! 15487: cpu.z80F &= ~(Z80_FLAG_CARRY | Z80_FLAG_NEGATIVE | Z80_FLAG_OVERFLOW_PARITY | Z80_FLAG_HALF_CARRY | Z80_FLAG_ZERO | Z80_FLAG_SIGN); ! 15488: cpu.z80F |= bPostANDFlags[cpu.z80A]; ! 15489: ! 15490: break; ! 15491: } ! 15492: case 0xa6: ! 15493: { ! 15494: sdwCyclesRemaining -= 7; ! 15495: psMemRead = cpu.z80MemRead; /* Beginning of our handler */ ! 15496: while (psMemRead->lowAddr != 0xffffffff) ! 15497: { ! 15498: if ((cpu.z80HL >= psMemRead->lowAddr) && (cpu.z80HL <= psMemRead->highAddr)) ! 15499: { ! 15500: cpu.z80pc = (UINT32) pbPC - (UINT32) cpu.z80Base; ! 15501: if (psMemRead->memoryCall) ! 15502: { ! 15503: bTemp = psMemRead->memoryCall(cpu.z80HL, psMemRead); ! 15504: } ! 15505: else ! 15506: { ! 15507: bTemp = *((UINT8 *) psMemRead->pUserArea + (cpu.z80HL - psMemRead->lowAddr)); ! 15508: } ! 15509: psMemRead = NULL; ! 15510: break; ! 15511: } ! 15512: ++psMemRead; ! 15513: } ! 15514: ! 15515: if (psMemRead) ! 15516: { ! 15517: bTemp = cpu.z80Base[cpu.z80HL]; ! 15518: } ! 15519: ! 15520: cpu.z80A &= bTemp; ! 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 0xa7: ! 15527: { ! 15528: sdwCyclesRemaining -= 4; ! 15529: cpu.z80A &= cpu.z80A; ! 15530: cpu.z80F &= ~(Z80_FLAG_CARRY | Z80_FLAG_NEGATIVE | Z80_FLAG_OVERFLOW_PARITY | Z80_FLAG_HALF_CARRY | Z80_FLAG_ZERO | Z80_FLAG_SIGN); ! 15531: cpu.z80F |= bPostANDFlags[cpu.z80A]; ! 15532: ! 15533: break; ! 15534: } ! 15535: case 0xa8: ! 15536: { ! 15537: sdwCyclesRemaining -= 4; ! 15538: cpu.z80A ^= cpu.z80B; ! 15539: cpu.z80F &= ~(Z80_FLAG_CARRY | Z80_FLAG_NEGATIVE | Z80_FLAG_OVERFLOW_PARITY | Z80_FLAG_HALF_CARRY | Z80_FLAG_ZERO | Z80_FLAG_SIGN); ! 15540: cpu.z80F |= bPostORFlags[cpu.z80A]; ! 15541: ! 15542: break; ! 15543: } ! 15544: case 0xa9: ! 15545: { ! 15546: sdwCyclesRemaining -= 4; ! 15547: cpu.z80A ^= cpu.z80C; ! 15548: cpu.z80F &= ~(Z80_FLAG_CARRY | Z80_FLAG_NEGATIVE | Z80_FLAG_OVERFLOW_PARITY | Z80_FLAG_HALF_CARRY | Z80_FLAG_ZERO | Z80_FLAG_SIGN); ! 15549: cpu.z80F |= bPostORFlags[cpu.z80A]; ! 15550: ! 15551: break; ! 15552: } ! 15553: case 0xaa: ! 15554: { ! 15555: sdwCyclesRemaining -= 4; ! 15556: cpu.z80A ^= cpu.z80D; ! 15557: cpu.z80F &= ~(Z80_FLAG_CARRY | Z80_FLAG_NEGATIVE | Z80_FLAG_OVERFLOW_PARITY | Z80_FLAG_HALF_CARRY | Z80_FLAG_ZERO | Z80_FLAG_SIGN); ! 15558: cpu.z80F |= bPostORFlags[cpu.z80A]; ! 15559: ! 15560: break; ! 15561: } ! 15562: case 0xab: ! 15563: { ! 15564: sdwCyclesRemaining -= 4; ! 15565: cpu.z80A ^= cpu.z80E; ! 15566: cpu.z80F &= ~(Z80_FLAG_CARRY | Z80_FLAG_NEGATIVE | Z80_FLAG_OVERFLOW_PARITY | Z80_FLAG_HALF_CARRY | Z80_FLAG_ZERO | Z80_FLAG_SIGN); ! 15567: cpu.z80F |= bPostORFlags[cpu.z80A]; ! 15568: ! 15569: break; ! 15570: } ! 15571: case 0xac: ! 15572: { ! 15573: sdwCyclesRemaining -= 4; ! 15574: cpu.z80A ^= cpu.z80H; ! 15575: cpu.z80F &= ~(Z80_FLAG_CARRY | Z80_FLAG_NEGATIVE | Z80_FLAG_OVERFLOW_PARITY | Z80_FLAG_HALF_CARRY | Z80_FLAG_ZERO | Z80_FLAG_SIGN); ! 15576: cpu.z80F |= bPostORFlags[cpu.z80A]; ! 15577: ! 15578: break; ! 15579: } ! 15580: case 0xad: ! 15581: { ! 15582: sdwCyclesRemaining -= 4; ! 15583: cpu.z80A ^= cpu.z80L; ! 15584: cpu.z80F &= ~(Z80_FLAG_CARRY | Z80_FLAG_NEGATIVE | Z80_FLAG_OVERFLOW_PARITY | Z80_FLAG_HALF_CARRY | Z80_FLAG_ZERO | Z80_FLAG_SIGN); ! 15585: cpu.z80F |= bPostORFlags[cpu.z80A]; ! 15586: ! 15587: break; ! 15588: } ! 15589: case 0xae: ! 15590: { ! 15591: sdwCyclesRemaining -= 7; ! 15592: psMemRead = cpu.z80MemRead; /* Beginning of our handler */ ! 15593: while (psMemRead->lowAddr != 0xffffffff) ! 15594: { ! 15595: if ((cpu.z80HL >= psMemRead->lowAddr) && (cpu.z80HL <= psMemRead->highAddr)) ! 15596: { ! 15597: cpu.z80pc = (UINT32) pbPC - (UINT32) cpu.z80Base; ! 15598: if (psMemRead->memoryCall) ! 15599: { ! 15600: bTemp = psMemRead->memoryCall(cpu.z80HL, psMemRead); ! 15601: } ! 15602: else ! 15603: { ! 15604: bTemp = *((UINT8 *) psMemRead->pUserArea + (cpu.z80HL - psMemRead->lowAddr)); ! 15605: } ! 15606: psMemRead = NULL; ! 15607: break; ! 15608: } ! 15609: ++psMemRead; ! 15610: } ! 15611: ! 15612: if (psMemRead) ! 15613: { ! 15614: bTemp = cpu.z80Base[cpu.z80HL]; ! 15615: } ! 15616: ! 15617: cpu.z80A ^= bTemp; ! 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 0xaf: ! 15624: { ! 15625: sdwCyclesRemaining -= 4; ! 15626: cpu.z80A ^= cpu.z80A; ! 15627: cpu.z80F &= ~(Z80_FLAG_CARRY | Z80_FLAG_NEGATIVE | Z80_FLAG_OVERFLOW_PARITY | Z80_FLAG_HALF_CARRY | Z80_FLAG_ZERO | Z80_FLAG_SIGN); ! 15628: cpu.z80F |= bPostORFlags[cpu.z80A]; ! 15629: ! 15630: break; ! 15631: } ! 15632: case 0xb0: ! 15633: { ! 15634: sdwCyclesRemaining -= 4; ! 15635: cpu.z80A |= cpu.z80B; ! 15636: cpu.z80F &= ~(Z80_FLAG_CARRY | Z80_FLAG_NEGATIVE | Z80_FLAG_OVERFLOW_PARITY | Z80_FLAG_HALF_CARRY | Z80_FLAG_ZERO | Z80_FLAG_SIGN); ! 15637: cpu.z80F |= bPostORFlags[cpu.z80A]; ! 15638: ! 15639: break; ! 15640: } ! 15641: case 0xb1: ! 15642: { ! 15643: sdwCyclesRemaining -= 4; ! 15644: cpu.z80A |= cpu.z80C; ! 15645: cpu.z80F &= ~(Z80_FLAG_CARRY | Z80_FLAG_NEGATIVE | Z80_FLAG_OVERFLOW_PARITY | Z80_FLAG_HALF_CARRY | Z80_FLAG_ZERO | Z80_FLAG_SIGN); ! 15646: cpu.z80F |= bPostORFlags[cpu.z80A]; ! 15647: ! 15648: break; ! 15649: } ! 15650: case 0xb2: ! 15651: { ! 15652: sdwCyclesRemaining -= 4; ! 15653: cpu.z80A |= cpu.z80D; ! 15654: cpu.z80F &= ~(Z80_FLAG_CARRY | Z80_FLAG_NEGATIVE | Z80_FLAG_OVERFLOW_PARITY | Z80_FLAG_HALF_CARRY | Z80_FLAG_ZERO | Z80_FLAG_SIGN); ! 15655: cpu.z80F |= bPostORFlags[cpu.z80A]; ! 15656: ! 15657: break; ! 15658: } ! 15659: case 0xb3: ! 15660: { ! 15661: sdwCyclesRemaining -= 4; ! 15662: cpu.z80A |= cpu.z80E; ! 15663: cpu.z80F &= ~(Z80_FLAG_CARRY | Z80_FLAG_NEGATIVE | Z80_FLAG_OVERFLOW_PARITY | Z80_FLAG_HALF_CARRY | Z80_FLAG_ZERO | Z80_FLAG_SIGN); ! 15664: cpu.z80F |= bPostORFlags[cpu.z80A]; ! 15665: ! 15666: break; ! 15667: } ! 15668: case 0xb4: ! 15669: { ! 15670: sdwCyclesRemaining -= 4; ! 15671: cpu.z80A |= cpu.z80H; ! 15672: cpu.z80F &= ~(Z80_FLAG_CARRY | Z80_FLAG_NEGATIVE | Z80_FLAG_OVERFLOW_PARITY | Z80_FLAG_HALF_CARRY | Z80_FLAG_ZERO | Z80_FLAG_SIGN); ! 15673: cpu.z80F |= bPostORFlags[cpu.z80A]; ! 15674: ! 15675: break; ! 15676: } ! 15677: case 0xb5: ! 15678: { ! 15679: sdwCyclesRemaining -= 4; ! 15680: cpu.z80A |= cpu.z80L; ! 15681: cpu.z80F &= ~(Z80_FLAG_CARRY | Z80_FLAG_NEGATIVE | Z80_FLAG_OVERFLOW_PARITY | Z80_FLAG_HALF_CARRY | Z80_FLAG_ZERO | Z80_FLAG_SIGN); ! 15682: cpu.z80F |= bPostORFlags[cpu.z80A]; ! 15683: ! 15684: break; ! 15685: } ! 15686: case 0xb6: ! 15687: { ! 15688: sdwCyclesRemaining -= 7; ! 15689: psMemRead = cpu.z80MemRead; /* Beginning of our handler */ ! 15690: while (psMemRead->lowAddr != 0xffffffff) ! 15691: { ! 15692: if ((cpu.z80HL >= psMemRead->lowAddr) && (cpu.z80HL <= psMemRead->highAddr)) ! 15693: { ! 15694: cpu.z80pc = (UINT32) pbPC - (UINT32) cpu.z80Base; ! 15695: if (psMemRead->memoryCall) ! 15696: { ! 15697: bTemp = psMemRead->memoryCall(cpu.z80HL, psMemRead); ! 15698: } ! 15699: else ! 15700: { ! 15701: bTemp = *((UINT8 *) psMemRead->pUserArea + (cpu.z80HL - psMemRead->lowAddr)); ! 15702: } ! 15703: psMemRead = NULL; ! 15704: break; ! 15705: } ! 15706: ++psMemRead; ! 15707: } ! 15708: ! 15709: if (psMemRead) ! 15710: { ! 15711: bTemp = cpu.z80Base[cpu.z80HL]; ! 15712: } ! 15713: ! 15714: cpu.z80A |= bTemp; ! 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 0xb7: ! 15721: { ! 15722: sdwCyclesRemaining -= 4; ! 15723: cpu.z80A |= cpu.z80A; ! 15724: cpu.z80F &= ~(Z80_FLAG_CARRY | Z80_FLAG_NEGATIVE | Z80_FLAG_OVERFLOW_PARITY | Z80_FLAG_HALF_CARRY | Z80_FLAG_ZERO | Z80_FLAG_SIGN); ! 15725: cpu.z80F |= bPostORFlags[cpu.z80A]; ! 15726: ! 15727: break; ! 15728: } ! 15729: case 0xb8: ! 15730: { ! 15731: sdwCyclesRemaining -= 4; ! 15732: cpu.z80F = (cpu.z80F & ~(Z80_FLAG_CARRY | Z80_FLAG_NEGATIVE | Z80_FLAG_OVERFLOW_PARITY | ! 15733: Z80_FLAG_HALF_CARRY | Z80_FLAG_ZERO | Z80_FLAG_SIGN)) | ! 15734: pbSubSbcTable[((UINT32) cpu.z80A << 8) | cpu.z80B]; ! 15735: break; ! 15736: } ! 15737: case 0xb9: ! 15738: { ! 15739: sdwCyclesRemaining -= 4; ! 15740: cpu.z80F = (cpu.z80F & ~(Z80_FLAG_CARRY | Z80_FLAG_NEGATIVE | Z80_FLAG_OVERFLOW_PARITY | ! 15741: Z80_FLAG_HALF_CARRY | Z80_FLAG_ZERO | Z80_FLAG_SIGN)) | ! 15742: pbSubSbcTable[((UINT32) cpu.z80A << 8) | cpu.z80C]; ! 15743: break; ! 15744: } ! 15745: case 0xba: ! 15746: { ! 15747: sdwCyclesRemaining -= 4; ! 15748: cpu.z80F = (cpu.z80F & ~(Z80_FLAG_CARRY | Z80_FLAG_NEGATIVE | Z80_FLAG_OVERFLOW_PARITY | ! 15749: Z80_FLAG_HALF_CARRY | Z80_FLAG_ZERO | Z80_FLAG_SIGN)) | ! 15750: pbSubSbcTable[((UINT32) cpu.z80A << 8) | cpu.z80D]; ! 15751: break; ! 15752: } ! 15753: case 0xbb: ! 15754: { ! 15755: sdwCyclesRemaining -= 4; ! 15756: cpu.z80F = (cpu.z80F & ~(Z80_FLAG_CARRY | Z80_FLAG_NEGATIVE | Z80_FLAG_OVERFLOW_PARITY | ! 15757: Z80_FLAG_HALF_CARRY | Z80_FLAG_ZERO | Z80_FLAG_SIGN)) | ! 15758: pbSubSbcTable[((UINT32) cpu.z80A << 8) | cpu.z80E]; ! 15759: break; ! 15760: } ! 15761: case 0xbc: ! 15762: { ! 15763: sdwCyclesRemaining -= 4; ! 15764: cpu.z80F = (cpu.z80F & ~(Z80_FLAG_CARRY | Z80_FLAG_NEGATIVE | Z80_FLAG_OVERFLOW_PARITY | ! 15765: Z80_FLAG_HALF_CARRY | Z80_FLAG_ZERO | Z80_FLAG_SIGN)) | ! 15766: pbSubSbcTable[((UINT32) cpu.z80A << 8) | cpu.z80H]; ! 15767: break; ! 15768: } ! 15769: case 0xbd: ! 15770: { ! 15771: sdwCyclesRemaining -= 4; ! 15772: cpu.z80F = (cpu.z80F & ~(Z80_FLAG_CARRY | Z80_FLAG_NEGATIVE | Z80_FLAG_OVERFLOW_PARITY | ! 15773: Z80_FLAG_HALF_CARRY | Z80_FLAG_ZERO | Z80_FLAG_SIGN)) | ! 15774: pbSubSbcTable[((UINT32) cpu.z80A << 8) | cpu.z80L]; ! 15775: break; ! 15776: } ! 15777: case 0xbe: ! 15778: { ! 15779: sdwCyclesRemaining -= 7; ! 15780: psMemRead = cpu.z80MemRead; /* Beginning of our handler */ ! 15781: while (psMemRead->lowAddr != 0xffffffff) ! 15782: { ! 15783: if ((cpu.z80HL >= psMemRead->lowAddr) && (cpu.z80HL <= psMemRead->highAddr)) ! 15784: { ! 15785: cpu.z80pc = (UINT32) pbPC - (UINT32) cpu.z80Base; ! 15786: if (psMemRead->memoryCall) ! 15787: { ! 15788: bTemp = psMemRead->memoryCall(cpu.z80HL, psMemRead); ! 15789: } ! 15790: else ! 15791: { ! 15792: bTemp = *((UINT8 *) psMemRead->pUserArea + (cpu.z80HL - psMemRead->lowAddr)); ! 15793: } ! 15794: psMemRead = NULL; ! 15795: break; ! 15796: } ! 15797: ++psMemRead; ! 15798: } ! 15799: ! 15800: if (psMemRead) ! 15801: { ! 15802: bTemp = cpu.z80Base[cpu.z80HL]; ! 15803: } ! 15804: ! 15805: cpu.z80F = (cpu.z80F & ~(Z80_FLAG_CARRY | Z80_FLAG_NEGATIVE | Z80_FLAG_OVERFLOW_PARITY | ! 15806: Z80_FLAG_HALF_CARRY | Z80_FLAG_ZERO | Z80_FLAG_SIGN)) | ! 15807: pbSubSbcTable[((UINT32) cpu.z80A << 8) | bTemp]; ! 15808: break; ! 15809: } ! 15810: case 0xbf: ! 15811: { ! 15812: sdwCyclesRemaining -= 4; ! 15813: cpu.z80F = (cpu.z80F & ~(Z80_FLAG_CARRY | Z80_FLAG_NEGATIVE | Z80_FLAG_OVERFLOW_PARITY | ! 15814: Z80_FLAG_HALF_CARRY | Z80_FLAG_ZERO | Z80_FLAG_SIGN)) | ! 15815: pbSubSbcTable[((UINT32) cpu.z80A << 8) | cpu.z80A]; ! 15816: break; ! 15817: } ! 15818: case 0xc0: ! 15819: { ! 15820: sdwCyclesRemaining -= 5; ! 15821: if (!(cpu.z80F & Z80_FLAG_ZERO)) ! 15822: { ! 15823: dwElapsedTicks += 6; ! 15824: pbSP = cpu.z80Base + cpu.z80sp; /* Normalize our stack PTR */ ! 15825: dwAddr = *pbSP++; /* Pop LSB */ ! 15826: dwAddr |= ((UINT32) *pbSP << 8); /* Pop MSB */ ! 15827: cpu.z80sp += 2; /* Pop the word off */ ! 15828: pbPC = (cpu.z80Base + dwAddr); /* Point PC to our return address */ ! 15829: } ! 15830: break; ! 15831: } ! 15832: case 0xc1: ! 15833: { ! 15834: sdwCyclesRemaining -= 10; ! 15835: psMemRead = cpu.z80MemRead; /* Beginning of our handler */ ! 15836: while (psMemRead->lowAddr != 0xffffffff) ! 15837: { ! 15838: if ((cpu.z80sp >= psMemRead->lowAddr) && (cpu.z80sp <= psMemRead->highAddr)) ! 15839: { ! 15840: cpu.z80pc = (UINT32) pbPC - (UINT32) cpu.z80Base; ! 15841: if (psMemRead->memoryCall) ! 15842: { ! 15843: cpu.z80BC = psMemRead->memoryCall(cpu.z80sp, psMemRead); ! 15844: cpu.z80BC |= (UINT32) ((UINT32) psMemRead->memoryCall(cpu.z80sp + 1, psMemRead) << 8); ! 15845: } ! 15846: else ! 15847: { ! 15848: cpu.z80BC = *((UINT8 *) psMemRead->pUserArea + (cpu.z80sp - psMemRead->lowAddr)); ! 15849: cpu.z80BC |= (UINT32) ((UINT32) *((UINT8 *) psMemRead->pUserArea + (cpu.z80sp - psMemRead->lowAddr + 1)) << 8); ! 15850: } ! 15851: psMemRead = NULL; ! 15852: break; ! 15853: } ! 15854: ++psMemRead; ! 15855: } ! 15856: ! 15857: if (psMemRead) ! 15858: { ! 15859: cpu.z80BC = cpu.z80Base[cpu.z80sp]; ! 15860: cpu.z80BC |= (UINT32) ((UINT32) cpu.z80Base[cpu.z80sp + 1] << 8); ! 15861: } ! 15862: ! 15863: cpu.z80sp += 2; ! 15864: pbSP = (cpu.z80Base + cpu.z80sp); /* Normalize the stack pointer */ ! 15865: break; ! 15866: } ! 15867: case 0xc2: ! 15868: { ! 15869: sdwCyclesRemaining -= 10; ! 15870: dwAddr = *pbPC++; /* Get LSB first */ ! 15871: dwAddr |= ((UINT32) *pbPC++ << 8); /* Get MSB last */ ! 15872: if (!(cpu.z80F & Z80_FLAG_ZERO)) ! 15873: { ! 15874: pbPC = cpu.z80Base + dwAddr; /* Normalize the address */ ! 15875: } ! 15876: break; ! 15877: } ! 15878: case 0xc3: ! 15879: { ! 15880: sdwCyclesRemaining -= 10; ! 15881: dwAddr = *pbPC++; /* Get LSB first */ ! 15882: dwAddr |= ((UINT32) *pbPC++ << 8); /* Get MSB last */ ! 15883: pbPC = cpu.z80Base + dwAddr; /* Normalize the address */ ! 15884: break; ! 15885: } ! 15886: case 0xc4: ! 15887: { ! 15888: sdwCyclesRemaining -= 10; ! 15889: dwAddr = *pbPC++; /* Get LSB first */ ! 15890: dwAddr |= ((UINT32) *pbPC++ << 8); /* Get MSB last */ ! 15891: if (!(cpu.z80F & Z80_FLAG_ZERO)) ! 15892: { ! 15893: cpu.z80pc = (UINT32) pbPC - (UINT32) cpu.z80Base; ! 15894: pbSP = (cpu.z80Base + cpu.z80sp - 1); /* Normalize the stack pointer */ ! 15895: *pbSP-- = cpu.z80pc >> 8; /* MSB */ ! 15896: *pbSP = (UINT8) cpu.z80pc; /* LSB */ ! 15897: cpu.z80sp -= 2; /* Back our stack up */ ! 15898: pbPC = cpu.z80Base + dwAddr; /* Normalize the address */ ! 15899: } ! 15900: break; ! 15901: } ! 15902: case 0xc5: ! 15903: { ! 15904: sdwCyclesRemaining -= 11; ! 15905: cpu.z80sp -= 2; ! 15906: pbSP = (cpu.z80Base + cpu.z80sp); /* Normalize the stack pointer */ ! 15907: psMemWrite = cpu.z80MemWrite; /* Beginning of our handler */ ! 15908: while (psMemWrite->lowAddr != 0xffffffff) ! 15909: { ! 15910: if ((cpu.z80sp >= psMemWrite->lowAddr) && (cpu.z80sp <= psMemWrite->highAddr)) ! 15911: { ! 15912: cpu.z80pc = (UINT32) pbPC - (UINT32) cpu.z80Base; ! 15913: if (psMemWrite->memoryCall) ! 15914: { ! 15915: psMemWrite->memoryCall(cpu.z80sp, (cpu.z80BC & 0xff), psMemWrite); ! 15916: psMemWrite->memoryCall(cpu.z80sp + 1, (cpu.z80BC >> 8), psMemWrite); ! 15917: } ! 15918: else ! 15919: { ! 15920: *((UINT8 *) psMemWrite->pUserArea + (cpu.z80sp - psMemWrite->lowAddr)) = cpu.z80BC; ! 15921: *((UINT8 *) psMemWrite->pUserArea + (cpu.z80sp - psMemWrite->lowAddr) + 1) = cpu.z80BC >> 8; ! 15922: } ! 15923: psMemWrite = NULL; ! 15924: break; ! 15925: } ! 15926: ++psMemWrite; ! 15927: } ! 15928: ! 15929: if (psMemWrite) ! 15930: { ! 15931: cpu.z80Base[cpu.z80sp] = (UINT8) cpu.z80BC; ! 15932: cpu.z80Base[cpu.z80sp + 1] = (UINT8) ((UINT32) cpu.z80BC >> 8); ! 15933: } ! 15934: ! 15935: break; ! 15936: } ! 15937: case 0xc6: ! 15938: { ! 15939: sdwCyclesRemaining -= 7; ! 15940: bTemp = *pbPC++; ! 15941: cpu.z80F = (cpu.z80F & ~(Z80_FLAG_CARRY | Z80_FLAG_NEGATIVE | Z80_FLAG_OVERFLOW_PARITY | ! 15942: Z80_FLAG_HALF_CARRY | Z80_FLAG_ZERO | Z80_FLAG_SIGN)) | ! 15943: pbAddAdcTable[((UINT32) cpu.z80A << 8) | bTemp]; ! 15944: cpu.z80A += bTemp; ! 15945: break; ! 15946: } ! 15947: case 0xc7: ! 15948: { ! 15949: sdwCyclesRemaining -= 11; ! 15950: cpu.z80pc = (UINT32) pbPC - (UINT32) cpu.z80Base; ! 15951: pbSP = (cpu.z80Base + cpu.z80sp - 1); /* Normalize the stack pointer */ ! 15952: *pbSP-- = cpu.z80pc >> 8; /* LSB */ ! 15953: *pbSP = (UINT8) cpu.z80pc; /* MSB */ ! 15954: cpu.z80sp -= 2; /* Back our stack up */ ! 15955: pbPC = cpu.z80Base + 0x00; /* Normalize the address */ ! 15956: break; ! 15957: } ! 15958: case 0xc8: ! 15959: { ! 15960: sdwCyclesRemaining -= 5; ! 15961: if (cpu.z80F & Z80_FLAG_ZERO) ! 15962: { ! 15963: dwElapsedTicks += 6; ! 15964: pbSP = cpu.z80Base + cpu.z80sp; /* Normalize our stack PTR */ ! 15965: dwAddr = *pbSP++; /* Pop LSB */ ! 15966: dwAddr |= ((UINT32) *pbSP << 8); /* Pop MSB */ ! 15967: cpu.z80sp += 2; /* Pop the word off */ ! 15968: pbPC = (cpu.z80Base + dwAddr); /* Point PC to our return address */ ! 15969: } ! 15970: break; ! 15971: } ! 15972: case 0xc9: ! 15973: { ! 15974: sdwCyclesRemaining -= 10; ! 15975: pbSP = cpu.z80Base + cpu.z80sp; /* Normalize our stack PTR */ ! 15976: dwAddr = *pbSP++; /* Pop LSB */ ! 15977: dwAddr |= ((UINT32) *pbSP << 8); /* Pop MSB */ ! 15978: cpu.z80sp += 2; /* Pop the word off */ ! 15979: pbPC = (cpu.z80Base + dwAddr); /* Point PC to our return address */ ! 15980: break; ! 15981: } ! 15982: case 0xca: ! 15983: { ! 15984: sdwCyclesRemaining -= 10; ! 15985: dwAddr = *pbPC++; /* Get LSB first */ ! 15986: dwAddr |= ((UINT32) *pbPC++ << 8); /* Get MSB last */ ! 15987: if (cpu.z80F & Z80_FLAG_ZERO) ! 15988: { ! 15989: pbPC = cpu.z80Base + dwAddr; /* Normalize the address */ ! 15990: } ! 15991: break; ! 15992: } ! 15993: case 0xcb: ! 15994: { ! 15995: CBHandler(); ! 15996: break; ! 15997: } ! 15998: case 0xcc: ! 15999: { ! 16000: sdwCyclesRemaining -= 10; ! 16001: dwAddr = *pbPC++; /* Get LSB first */ ! 16002: dwAddr |= ((UINT32) *pbPC++ << 8); /* Get MSB last */ ! 16003: if (cpu.z80F & Z80_FLAG_ZERO) ! 16004: { ! 16005: cpu.z80pc = (UINT32) pbPC - (UINT32) cpu.z80Base; ! 16006: pbSP = (cpu.z80Base + cpu.z80sp - 1); /* Normalize the stack pointer */ ! 16007: *pbSP-- = cpu.z80pc >> 8; /* MSB */ ! 16008: *pbSP = (UINT8) cpu.z80pc; /* LSB */ ! 16009: cpu.z80sp -= 2; /* Back our stack up */ ! 16010: pbPC = cpu.z80Base + dwAddr; /* Normalize the address */ ! 16011: } ! 16012: break; ! 16013: } ! 16014: case 0xcd: ! 16015: { ! 16016: sdwCyclesRemaining -= 17; ! 16017: dwAddr = *pbPC++; /* Get LSB first */ ! 16018: dwAddr |= ((UINT32) *pbPC++ << 8); /* Get MSB last */ ! 16019: cpu.z80pc = (UINT32) pbPC - (UINT32) cpu.z80Base; ! 16020: pbSP = (cpu.z80Base + cpu.z80sp - 1); /* Normalize the stack pointer */ ! 16021: *pbSP-- = cpu.z80pc >> 8; /* LSB */ ! 16022: *pbSP = (UINT8) cpu.z80pc; /* MSB */ ! 16023: cpu.z80sp -= 2; /* Back our stack up */ ! 16024: pbPC = cpu.z80Base + dwAddr; /* Normalize the address */ ! 16025: break; ! 16026: } ! 16027: case 0xce: ! 16028: { ! 16029: sdwCyclesRemaining -= 7; ! 16030: bTemp = *pbPC++ + (cpu.z80F & Z80_FLAG_CARRY); ! 16031: cpu.z80F = (cpu.z80F & ~(Z80_FLAG_CARRY | Z80_FLAG_NEGATIVE | Z80_FLAG_OVERFLOW_PARITY | ! 16032: Z80_FLAG_HALF_CARRY | Z80_FLAG_ZERO | Z80_FLAG_SIGN)) | ! 16033: pbAddAdcTable[((UINT32) cpu.z80A << 8) | bTemp | (((UINT32) cpu.z80F & Z80_FLAG_CARRY) << 16)]; ! 16034: cpu.z80A += bTemp; ! 16035: break; ! 16036: } ! 16037: case 0xcf: ! 16038: { ! 16039: sdwCyclesRemaining -= 11; ! 16040: cpu.z80pc = (UINT32) pbPC - (UINT32) cpu.z80Base; ! 16041: pbSP = (cpu.z80Base + cpu.z80sp - 1); /* Normalize the stack pointer */ ! 16042: *pbSP-- = cpu.z80pc >> 8; /* LSB */ ! 16043: *pbSP = (UINT8) cpu.z80pc; /* MSB */ ! 16044: cpu.z80sp -= 2; /* Back our stack up */ ! 16045: pbPC = cpu.z80Base + 0x08; /* Normalize the address */ ! 16046: break; ! 16047: } ! 16048: case 0xd0: ! 16049: { ! 16050: sdwCyclesRemaining -= 5; ! 16051: if (!(cpu.z80F & Z80_FLAG_CARRY)) ! 16052: { ! 16053: dwElapsedTicks += 6; ! 16054: pbSP = cpu.z80Base + cpu.z80sp; /* Normalize our stack PTR */ ! 16055: dwAddr = *pbSP++; /* Pop LSB */ ! 16056: dwAddr |= ((UINT32) *pbSP << 8); /* Pop MSB */ ! 16057: cpu.z80sp += 2; /* Pop the word off */ ! 16058: pbPC = (cpu.z80Base + dwAddr); /* Point PC to our return address */ ! 16059: } ! 16060: break; ! 16061: } ! 16062: case 0xd1: ! 16063: { ! 16064: sdwCyclesRemaining -= 10; ! 16065: psMemRead = cpu.z80MemRead; /* Beginning of our handler */ ! 16066: while (psMemRead->lowAddr != 0xffffffff) ! 16067: { ! 16068: if ((cpu.z80sp >= psMemRead->lowAddr) && (cpu.z80sp <= psMemRead->highAddr)) ! 16069: { ! 16070: cpu.z80pc = (UINT32) pbPC - (UINT32) cpu.z80Base; ! 16071: if (psMemRead->memoryCall) ! 16072: { ! 16073: cpu.z80DE = psMemRead->memoryCall(cpu.z80sp, psMemRead); ! 16074: cpu.z80DE |= (UINT32) ((UINT32) psMemRead->memoryCall(cpu.z80sp + 1, psMemRead) << 8); ! 16075: } ! 16076: else ! 16077: { ! 16078: cpu.z80DE = *((UINT8 *) psMemRead->pUserArea + (cpu.z80sp - psMemRead->lowAddr)); ! 16079: cpu.z80DE |= (UINT32) ((UINT32) *((UINT8 *) psMemRead->pUserArea + (cpu.z80sp - psMemRead->lowAddr + 1)) << 8); ! 16080: } ! 16081: psMemRead = NULL; ! 16082: break; ! 16083: } ! 16084: ++psMemRead; ! 16085: } ! 16086: ! 16087: if (psMemRead) ! 16088: { ! 16089: cpu.z80DE = cpu.z80Base[cpu.z80sp]; ! 16090: cpu.z80DE |= (UINT32) ((UINT32) cpu.z80Base[cpu.z80sp + 1] << 8); ! 16091: } ! 16092: ! 16093: cpu.z80sp += 2; ! 16094: pbSP = (cpu.z80Base + cpu.z80sp); /* Normalize the stack pointer */ ! 16095: break; ! 16096: } ! 16097: case 0xd2: ! 16098: { ! 16099: sdwCyclesRemaining -= 10; ! 16100: dwAddr = *pbPC++; /* Get LSB first */ ! 16101: dwAddr |= ((UINT32) *pbPC++ << 8); /* Get MSB last */ ! 16102: if (!(cpu.z80F & Z80_FLAG_CARRY)) ! 16103: { ! 16104: pbPC = cpu.z80Base + dwAddr; /* Normalize the address */ ! 16105: } ! 16106: break; ! 16107: } ! 16108: case 0xd3: ! 16109: { ! 16110: sdwCyclesRemaining -= 11; ! 16111: dwTemp = *pbPC++; ! 16112: psIoWrite = cpu.z80IoWrite; /* Beginning of our handler */ ! 16113: while (psIoWrite->lowIoAddr != 0xffff) ! 16114: { ! 16115: if ((dwTemp >= psIoWrite->lowIoAddr) && (dwTemp <= psIoWrite->highIoAddr)) ! 16116: { ! 16117: cpu.z80pc = (UINT32) pbPC - (UINT32) cpu.z80Base; ! 16118: psIoWrite->IOCall(dwTemp, cpu.z80A, psIoWrite); ! 16119: psIoWrite = NULL; ! 16120: break; ! 16121: } ! 16122: ++psIoWrite; ! 16123: } ! 16124: ! 16125: break; ! 16126: } ! 16127: case 0xd4: ! 16128: { ! 16129: sdwCyclesRemaining -= 10; ! 16130: dwAddr = *pbPC++; /* Get LSB first */ ! 16131: dwAddr |= ((UINT32) *pbPC++ << 8); /* Get MSB last */ ! 16132: if (!(cpu.z80F & Z80_FLAG_CARRY)) ! 16133: { ! 16134: cpu.z80pc = (UINT32) pbPC - (UINT32) cpu.z80Base; ! 16135: pbSP = (cpu.z80Base + cpu.z80sp - 1); /* Normalize the stack pointer */ ! 16136: *pbSP-- = cpu.z80pc >> 8; /* MSB */ ! 16137: *pbSP = (UINT8) cpu.z80pc; /* LSB */ ! 16138: cpu.z80sp -= 2; /* Back our stack up */ ! 16139: pbPC = cpu.z80Base + dwAddr; /* Normalize the address */ ! 16140: } ! 16141: break; ! 16142: } ! 16143: case 0xd5: ! 16144: { ! 16145: sdwCyclesRemaining -= 11; ! 16146: cpu.z80sp -= 2; ! 16147: pbSP = (cpu.z80Base + cpu.z80sp); /* Normalize the stack pointer */ ! 16148: psMemWrite = cpu.z80MemWrite; /* Beginning of our handler */ ! 16149: while (psMemWrite->lowAddr != 0xffffffff) ! 16150: { ! 16151: if ((cpu.z80sp >= psMemWrite->lowAddr) && (cpu.z80sp <= psMemWrite->highAddr)) ! 16152: { ! 16153: cpu.z80pc = (UINT32) pbPC - (UINT32) cpu.z80Base; ! 16154: if (psMemWrite->memoryCall) ! 16155: { ! 16156: psMemWrite->memoryCall(cpu.z80sp, (cpu.z80DE & 0xff), psMemWrite); ! 16157: psMemWrite->memoryCall(cpu.z80sp + 1, (cpu.z80DE >> 8), psMemWrite); ! 16158: } ! 16159: else ! 16160: { ! 16161: *((UINT8 *) psMemWrite->pUserArea + (cpu.z80sp - psMemWrite->lowAddr)) = cpu.z80DE; ! 16162: *((UINT8 *) psMemWrite->pUserArea + (cpu.z80sp - psMemWrite->lowAddr) + 1) = cpu.z80DE >> 8; ! 16163: } ! 16164: psMemWrite = NULL; ! 16165: break; ! 16166: } ! 16167: ++psMemWrite; ! 16168: } ! 16169: ! 16170: if (psMemWrite) ! 16171: { ! 16172: cpu.z80Base[cpu.z80sp] = (UINT8) cpu.z80DE; ! 16173: cpu.z80Base[cpu.z80sp + 1] = (UINT8) ((UINT32) cpu.z80DE >> 8); ! 16174: } ! 16175: ! 16176: break; ! 16177: } ! 16178: case 0xd6: ! 16179: { ! 16180: sdwCyclesRemaining -= 7; ! 16181: bTemp = *pbPC++; ! 16182: cpu.z80F = (cpu.z80F & ~(Z80_FLAG_CARRY | Z80_FLAG_NEGATIVE | Z80_FLAG_OVERFLOW_PARITY | ! 16183: Z80_FLAG_HALF_CARRY | Z80_FLAG_ZERO | Z80_FLAG_SIGN)) | ! 16184: pbSubSbcTable[((UINT32) cpu.z80A << 8) | bTemp]; ! 16185: cpu.z80A -= bTemp; ! 16186: break; ! 16187: } ! 16188: case 0xd7: ! 16189: { ! 16190: sdwCyclesRemaining -= 11; ! 16191: cpu.z80pc = (UINT32) pbPC - (UINT32) cpu.z80Base; ! 16192: pbSP = (cpu.z80Base + cpu.z80sp - 1); /* Normalize the stack pointer */ ! 16193: *pbSP-- = cpu.z80pc >> 8; /* LSB */ ! 16194: *pbSP = (UINT8) cpu.z80pc; /* MSB */ ! 16195: cpu.z80sp -= 2; /* Back our stack up */ ! 16196: pbPC = cpu.z80Base + 0x10; /* Normalize the address */ ! 16197: break; ! 16198: } ! 16199: case 0xd8: ! 16200: { ! 16201: sdwCyclesRemaining -= 5; ! 16202: if (cpu.z80F & Z80_FLAG_CARRY) ! 16203: { ! 16204: dwElapsedTicks += 6; ! 16205: pbSP = cpu.z80Base + cpu.z80sp; /* Normalize our stack PTR */ ! 16206: dwAddr = *pbSP++; /* Pop LSB */ ! 16207: dwAddr |= ((UINT32) *pbSP << 8); /* Pop MSB */ ! 16208: cpu.z80sp += 2; /* Pop the word off */ ! 16209: pbPC = (cpu.z80Base + dwAddr); /* Point PC to our return address */ ! 16210: } ! 16211: break; ! 16212: } ! 16213: case 0xd9: ! 16214: { ! 16215: sdwCyclesRemaining -= 4; ! 16216: dwTemp = cpu.z80DE; ! 16217: cpu.z80DE = cpu.z80deprime; ! 16218: cpu.z80deprime = dwTemp; ! 16219: dwTemp = cpu.z80BC; ! 16220: cpu.z80BC = cpu.z80bcprime; ! 16221: cpu.z80bcprime = dwTemp; ! 16222: dwTemp = cpu.z80HL; ! 16223: cpu.z80HL = cpu.z80hlprime; ! 16224: cpu.z80hlprime = dwTemp; ! 16225: break; ! 16226: } ! 16227: case 0xda: ! 16228: { ! 16229: sdwCyclesRemaining -= 10; ! 16230: dwAddr = *pbPC++; /* Get LSB first */ ! 16231: dwAddr |= ((UINT32) *pbPC++ << 8); /* Get MSB last */ ! 16232: if (cpu.z80F & Z80_FLAG_CARRY) ! 16233: { ! 16234: pbPC = cpu.z80Base + dwAddr; /* Normalize the address */ ! 16235: } ! 16236: break; ! 16237: } ! 16238: case 0xdb: ! 16239: { ! 16240: sdwCyclesRemaining -= 11; ! 16241: dwTemp = *pbPC++; ! 16242: psIoRead = cpu.z80IoRead; /* Beginning of our handler */ ! 16243: while (psIoRead->lowIoAddr != 0xffff) ! 16244: { ! 16245: if ((dwTemp >= psIoRead->lowIoAddr) && (dwTemp <= psIoRead->highIoAddr)) ! 16246: { ! 16247: cpu.z80pc = (UINT32) pbPC - (UINT32) cpu.z80Base; ! 16248: cpu.z80A = psIoRead->IOCall(dwTemp, psIoRead); ! 16249: psIoRead = NULL; ! 16250: break; ! 16251: } ! 16252: ++psIoRead; ! 16253: } ! 16254: ! 16255: if (psIoRead) ! 16256: { ! 16257: cpu.z80A = 0xff; /* Unclaimed I/O read */ ! 16258: } ! 16259: ! 16260: break; ! 16261: } ! 16262: case 0xdc: ! 16263: { ! 16264: sdwCyclesRemaining -= 10; ! 16265: dwAddr = *pbPC++; /* Get LSB first */ ! 16266: dwAddr |= ((UINT32) *pbPC++ << 8); /* Get MSB last */ ! 16267: if (cpu.z80F & Z80_FLAG_CARRY) ! 16268: { ! 16269: cpu.z80pc = (UINT32) pbPC - (UINT32) cpu.z80Base; ! 16270: pbSP = (cpu.z80Base + cpu.z80sp - 1); /* Normalize the stack pointer */ ! 16271: *pbSP-- = cpu.z80pc >> 8; /* MSB */ ! 16272: *pbSP = (UINT8) cpu.z80pc; /* LSB */ ! 16273: cpu.z80sp -= 2; /* Back our stack up */ ! 16274: pbPC = cpu.z80Base + dwAddr; /* Normalize the address */ ! 16275: } ! 16276: break; ! 16277: } ! 16278: case 0xdd: ! 16279: { ! 16280: DDHandler(); ! 16281: break; ! 16282: } ! 16283: case 0xde: ! 16284: { ! 16285: sdwCyclesRemaining -= 7; ! 16286: bTemp = *pbPC++ + (cpu.z80F & Z80_FLAG_CARRY); ! 16287: cpu.z80F = (cpu.z80F & ~(Z80_FLAG_CARRY | Z80_FLAG_NEGATIVE | Z80_FLAG_OVERFLOW_PARITY | ! 16288: Z80_FLAG_HALF_CARRY | Z80_FLAG_ZERO | Z80_FLAG_SIGN)) | ! 16289: pbSubSbcTable[((UINT32) cpu.z80A << 8) | bTemp | (((UINT32) cpu.z80F & Z80_FLAG_CARRY) << 16)]; ! 16290: cpu.z80A = cpu.z80A - bTemp; ! 16291: break; ! 16292: } ! 16293: case 0xdf: ! 16294: { ! 16295: sdwCyclesRemaining -= 11; ! 16296: cpu.z80pc = (UINT32) pbPC - (UINT32) cpu.z80Base; ! 16297: pbSP = (cpu.z80Base + cpu.z80sp - 1); /* Normalize the stack pointer */ ! 16298: *pbSP-- = cpu.z80pc >> 8; /* LSB */ ! 16299: *pbSP = (UINT8) cpu.z80pc; /* MSB */ ! 16300: cpu.z80sp -= 2; /* Back our stack up */ ! 16301: pbPC = cpu.z80Base + 0x18; /* Normalize the address */ ! 16302: break; ! 16303: } ! 16304: case 0xe0: ! 16305: { ! 16306: sdwCyclesRemaining -= 5; ! 16307: if (!(cpu.z80F & Z80_FLAG_OVERFLOW_PARITY)) ! 16308: { ! 16309: dwElapsedTicks += 6; ! 16310: pbSP = cpu.z80Base + cpu.z80sp; /* Normalize our stack PTR */ ! 16311: dwAddr = *pbSP++; /* Pop LSB */ ! 16312: dwAddr |= ((UINT32) *pbSP << 8); /* Pop MSB */ ! 16313: cpu.z80sp += 2; /* Pop the word off */ ! 16314: pbPC = (cpu.z80Base + dwAddr); /* Point PC to our return address */ ! 16315: } ! 16316: break; ! 16317: } ! 16318: case 0xe1: ! 16319: { ! 16320: sdwCyclesRemaining -= 10; ! 16321: psMemRead = cpu.z80MemRead; /* Beginning of our handler */ ! 16322: while (psMemRead->lowAddr != 0xffffffff) ! 16323: { ! 16324: if ((cpu.z80sp >= psMemRead->lowAddr) && (cpu.z80sp <= psMemRead->highAddr)) ! 16325: { ! 16326: cpu.z80pc = (UINT32) pbPC - (UINT32) cpu.z80Base; ! 16327: if (psMemRead->memoryCall) ! 16328: { ! 16329: cpu.z80HL = psMemRead->memoryCall(cpu.z80sp, psMemRead); ! 16330: cpu.z80HL |= (UINT32) ((UINT32) psMemRead->memoryCall(cpu.z80sp + 1, psMemRead) << 8); ! 16331: } ! 16332: else ! 16333: { ! 16334: cpu.z80HL = *((UINT8 *) psMemRead->pUserArea + (cpu.z80sp - psMemRead->lowAddr)); ! 16335: cpu.z80HL |= (UINT32) ((UINT32) *((UINT8 *) psMemRead->pUserArea + (cpu.z80sp - psMemRead->lowAddr + 1)) << 8); ! 16336: } ! 16337: psMemRead = NULL; ! 16338: break; ! 16339: } ! 16340: ++psMemRead; ! 16341: } ! 16342: ! 16343: if (psMemRead) ! 16344: { ! 16345: cpu.z80HL = cpu.z80Base[cpu.z80sp]; ! 16346: cpu.z80HL |= (UINT32) ((UINT32) cpu.z80Base[cpu.z80sp + 1] << 8); ! 16347: } ! 16348: ! 16349: cpu.z80sp += 2; ! 16350: pbSP = (cpu.z80Base + cpu.z80sp); /* Normalize the stack pointer */ ! 16351: break; ! 16352: } ! 16353: case 0xe2: ! 16354: { ! 16355: sdwCyclesRemaining -= 10; ! 16356: dwAddr = *pbPC++; /* Get LSB first */ ! 16357: dwAddr |= ((UINT32) *pbPC++ << 8); /* Get MSB last */ ! 16358: if (!(cpu.z80F & Z80_FLAG_OVERFLOW_PARITY)) ! 16359: { ! 16360: pbPC = cpu.z80Base + dwAddr; /* Normalize the address */ ! 16361: } ! 16362: break; ! 16363: } ! 16364: case 0xe3: ! 16365: { ! 16366: sdwCyclesRemaining -= 19; ! 16367: psMemRead = cpu.z80MemRead; /* Beginning of our handler */ ! 16368: while (psMemRead->lowAddr != 0xffffffff) ! 16369: { ! 16370: if ((cpu.z80sp >= psMemRead->lowAddr) && (cpu.z80sp <= psMemRead->highAddr)) ! 16371: { ! 16372: cpu.z80pc = (UINT32) pbPC - (UINT32) cpu.z80Base; ! 16373: if (psMemRead->memoryCall) ! 16374: { ! 16375: dwAddr = psMemRead->memoryCall(cpu.z80sp, psMemRead); ! 16376: dwAddr |= (UINT32) ((UINT32) psMemRead->memoryCall(cpu.z80sp + 1, psMemRead) << 8); ! 16377: } ! 16378: else ! 16379: { ! 16380: dwAddr = *((UINT8 *) psMemRead->pUserArea + (cpu.z80sp - psMemRead->lowAddr)); ! 16381: dwAddr |= (UINT32) ((UINT32) *((UINT8 *) psMemRead->pUserArea + (cpu.z80sp - psMemRead->lowAddr + 1)) << 8); ! 16382: } ! 16383: psMemRead = NULL; ! 16384: break; ! 16385: } ! 16386: ++psMemRead; ! 16387: } ! 16388: ! 16389: if (psMemRead) ! 16390: { ! 16391: dwAddr = cpu.z80Base[cpu.z80sp]; ! 16392: dwAddr |= (UINT32) ((UINT32) cpu.z80Base[cpu.z80sp + 1] << 8); ! 16393: } ! 16394: ! 16395: psMemWrite = cpu.z80MemWrite; /* Beginning of our handler */ ! 16396: while (psMemWrite->lowAddr != 0xffffffff) ! 16397: { ! 16398: if ((cpu.z80sp >= psMemWrite->lowAddr) && (cpu.z80sp <= psMemWrite->highAddr)) ! 16399: { ! 16400: cpu.z80pc = (UINT32) pbPC - (UINT32) cpu.z80Base; ! 16401: if (psMemWrite->memoryCall) ! 16402: { ! 16403: psMemWrite->memoryCall(cpu.z80sp, (cpu.z80HL & 0xff), psMemWrite); ! 16404: psMemWrite->memoryCall(cpu.z80sp + 1, (cpu.z80HL >> 8), psMemWrite); ! 16405: } ! 16406: else ! 16407: { ! 16408: *((UINT8 *) psMemWrite->pUserArea + (cpu.z80sp - psMemWrite->lowAddr)) = cpu.z80HL; ! 16409: *((UINT8 *) psMemWrite->pUserArea + (cpu.z80sp - psMemWrite->lowAddr) + 1) = cpu.z80HL >> 8; ! 16410: } ! 16411: psMemWrite = NULL; ! 16412: break; ! 16413: } ! 16414: ++psMemWrite; ! 16415: } ! 16416: ! 16417: if (psMemWrite) ! 16418: { ! 16419: cpu.z80Base[cpu.z80sp] = (UINT8) cpu.z80HL; ! 16420: cpu.z80Base[cpu.z80sp + 1] = (UINT8) ((UINT32) cpu.z80HL >> 8); ! 16421: } ! 16422: ! 16423: cpu.z80HL = dwAddr; ! 16424: break; ! 16425: } ! 16426: case 0xe4: ! 16427: { ! 16428: sdwCyclesRemaining -= 10; ! 16429: dwAddr = *pbPC++; /* Get LSB first */ ! 16430: dwAddr |= ((UINT32) *pbPC++ << 8); /* Get MSB last */ ! 16431: if (!(cpu.z80F & Z80_FLAG_OVERFLOW_PARITY)) ! 16432: { ! 16433: cpu.z80pc = (UINT32) pbPC - (UINT32) cpu.z80Base; ! 16434: pbSP = (cpu.z80Base + cpu.z80sp - 1); /* Normalize the stack pointer */ ! 16435: *pbSP-- = cpu.z80pc >> 8; /* MSB */ ! 16436: *pbSP = (UINT8) cpu.z80pc; /* LSB */ ! 16437: cpu.z80sp -= 2; /* Back our stack up */ ! 16438: pbPC = cpu.z80Base + dwAddr; /* Normalize the address */ ! 16439: } ! 16440: break; ! 16441: } ! 16442: case 0xe5: ! 16443: { ! 16444: sdwCyclesRemaining -= 11; ! 16445: cpu.z80sp -= 2; ! 16446: pbSP = (cpu.z80Base + cpu.z80sp); /* Normalize the stack pointer */ ! 16447: psMemWrite = cpu.z80MemWrite; /* Beginning of our handler */ ! 16448: while (psMemWrite->lowAddr != 0xffffffff) ! 16449: { ! 16450: if ((cpu.z80sp >= psMemWrite->lowAddr) && (cpu.z80sp <= psMemWrite->highAddr)) ! 16451: { ! 16452: cpu.z80pc = (UINT32) pbPC - (UINT32) cpu.z80Base; ! 16453: if (psMemWrite->memoryCall) ! 16454: { ! 16455: psMemWrite->memoryCall(cpu.z80sp, (cpu.z80HL & 0xff), psMemWrite); ! 16456: psMemWrite->memoryCall(cpu.z80sp + 1, (cpu.z80HL >> 8), psMemWrite); ! 16457: } ! 16458: else ! 16459: { ! 16460: *((UINT8 *) psMemWrite->pUserArea + (cpu.z80sp - psMemWrite->lowAddr)) = cpu.z80HL; ! 16461: *((UINT8 *) psMemWrite->pUserArea + (cpu.z80sp - psMemWrite->lowAddr) + 1) = cpu.z80HL >> 8; ! 16462: } ! 16463: psMemWrite = NULL; ! 16464: break; ! 16465: } ! 16466: ++psMemWrite; ! 16467: } ! 16468: ! 16469: if (psMemWrite) ! 16470: { ! 16471: cpu.z80Base[cpu.z80sp] = (UINT8) cpu.z80HL; ! 16472: cpu.z80Base[cpu.z80sp + 1] = (UINT8) ((UINT32) cpu.z80HL >> 8); ! 16473: } ! 16474: ! 16475: break; ! 16476: } ! 16477: case 0xe6: ! 16478: { ! 16479: sdwCyclesRemaining -= 7; ! 16480: cpu.z80A &= *pbPC++; ! 16481: cpu.z80F &= ~(Z80_FLAG_CARRY | Z80_FLAG_NEGATIVE | Z80_FLAG_OVERFLOW_PARITY | Z80_FLAG_HALF_CARRY | Z80_FLAG_ZERO | Z80_FLAG_SIGN); ! 16482: cpu.z80F |= bPostANDFlags[cpu.z80A]; ! 16483: ! 16484: break; ! 16485: } ! 16486: case 0xe7: ! 16487: { ! 16488: sdwCyclesRemaining -= 11; ! 16489: cpu.z80pc = (UINT32) pbPC - (UINT32) cpu.z80Base; ! 16490: pbSP = (cpu.z80Base + cpu.z80sp - 1); /* Normalize the stack pointer */ ! 16491: *pbSP-- = cpu.z80pc >> 8; /* LSB */ ! 16492: *pbSP = (UINT8) cpu.z80pc; /* MSB */ ! 16493: cpu.z80sp -= 2; /* Back our stack up */ ! 16494: pbPC = cpu.z80Base + 0x20; /* Normalize the address */ ! 16495: break; ! 16496: } ! 16497: case 0xe8: ! 16498: { ! 16499: sdwCyclesRemaining -= 5; ! 16500: if (cpu.z80F & Z80_FLAG_OVERFLOW_PARITY) ! 16501: { ! 16502: dwElapsedTicks += 6; ! 16503: pbSP = cpu.z80Base + cpu.z80sp; /* Normalize our stack PTR */ ! 16504: dwAddr = *pbSP++; /* Pop LSB */ ! 16505: dwAddr |= ((UINT32) *pbSP << 8); /* Pop MSB */ ! 16506: cpu.z80sp += 2; /* Pop the word off */ ! 16507: pbPC = (cpu.z80Base + dwAddr); /* Point PC to our return address */ ! 16508: } ! 16509: break; ! 16510: } ! 16511: case 0xe9: ! 16512: { ! 16513: sdwCyclesRemaining -= 4; ! 16514: pbPC = cpu.z80Base + cpu.z80HL; ! 16515: break; ! 16516: } ! 16517: case 0xea: ! 16518: { ! 16519: sdwCyclesRemaining -= 10; ! 16520: dwAddr = *pbPC++; /* Get LSB first */ ! 16521: dwAddr |= ((UINT32) *pbPC++ << 8); /* Get MSB last */ ! 16522: if (cpu.z80F & Z80_FLAG_OVERFLOW_PARITY) ! 16523: { ! 16524: pbPC = cpu.z80Base + dwAddr; /* Normalize the address */ ! 16525: } ! 16526: break; ! 16527: } ! 16528: case 0xeb: ! 16529: { ! 16530: sdwCyclesRemaining -= 4; ! 16531: dwAddr = cpu.z80DE; ! 16532: cpu.z80DE = cpu.z80HL; ! 16533: cpu.z80HL = dwAddr; ! 16534: break; ! 16535: } ! 16536: case 0xec: ! 16537: { ! 16538: sdwCyclesRemaining -= 10; ! 16539: dwAddr = *pbPC++; /* Get LSB first */ ! 16540: dwAddr |= ((UINT32) *pbPC++ << 8); /* Get MSB last */ ! 16541: if (cpu.z80F & Z80_FLAG_OVERFLOW_PARITY) ! 16542: { ! 16543: cpu.z80pc = (UINT32) pbPC - (UINT32) cpu.z80Base; ! 16544: pbSP = (cpu.z80Base + cpu.z80sp - 1); /* Normalize the stack pointer */ ! 16545: *pbSP-- = cpu.z80pc >> 8; /* MSB */ ! 16546: *pbSP = (UINT8) cpu.z80pc; /* LSB */ ! 16547: cpu.z80sp -= 2; /* Back our stack up */ ! 16548: pbPC = cpu.z80Base + dwAddr; /* Normalize the address */ ! 16549: } ! 16550: break; ! 16551: } ! 16552: case 0xed: ! 16553: { ! 16554: EDHandler(); ! 16555: break; ! 16556: } ! 16557: case 0xee: ! 16558: { ! 16559: sdwCyclesRemaining -= 7; ! 16560: cpu.z80A ^= *pbPC++; ! 16561: cpu.z80F &= ~(Z80_FLAG_CARRY | Z80_FLAG_NEGATIVE | Z80_FLAG_OVERFLOW_PARITY | Z80_FLAG_HALF_CARRY | Z80_FLAG_ZERO | Z80_FLAG_SIGN); ! 16562: cpu.z80F |= bPostORFlags[cpu.z80A]; ! 16563: ! 16564: break; ! 16565: } ! 16566: case 0xef: ! 16567: { ! 16568: sdwCyclesRemaining -= 11; ! 16569: cpu.z80pc = (UINT32) pbPC - (UINT32) cpu.z80Base; ! 16570: pbSP = (cpu.z80Base + cpu.z80sp - 1); /* Normalize the stack pointer */ ! 16571: *pbSP-- = cpu.z80pc >> 8; /* LSB */ ! 16572: *pbSP = (UINT8) cpu.z80pc; /* MSB */ ! 16573: cpu.z80sp -= 2; /* Back our stack up */ ! 16574: pbPC = cpu.z80Base + 0x28; /* Normalize the address */ ! 16575: break; ! 16576: } ! 16577: case 0xf0: ! 16578: { ! 16579: sdwCyclesRemaining -= 5; ! 16580: if (!(cpu.z80F & Z80_FLAG_SIGN)) ! 16581: { ! 16582: dwElapsedTicks += 6; ! 16583: pbSP = cpu.z80Base + cpu.z80sp; /* Normalize our stack PTR */ ! 16584: dwAddr = *pbSP++; /* Pop LSB */ ! 16585: dwAddr |= ((UINT32) *pbSP << 8); /* Pop MSB */ ! 16586: cpu.z80sp += 2; /* Pop the word off */ ! 16587: pbPC = (cpu.z80Base + dwAddr); /* Point PC to our return address */ ! 16588: } ! 16589: break; ! 16590: } ! 16591: case 0xf1: ! 16592: { ! 16593: sdwCyclesRemaining -= 10; ! 16594: psMemRead = cpu.z80MemRead; /* Beginning of our handler */ ! 16595: while (psMemRead->lowAddr != 0xffffffff) ! 16596: { ! 16597: if ((cpu.z80sp >= psMemRead->lowAddr) && (cpu.z80sp <= psMemRead->highAddr)) ! 16598: { ! 16599: cpu.z80pc = (UINT32) pbPC - (UINT32) cpu.z80Base; ! 16600: if (psMemRead->memoryCall) ! 16601: { ! 16602: cpu.z80AF = psMemRead->memoryCall(cpu.z80sp, psMemRead); ! 16603: cpu.z80AF |= (UINT32) ((UINT32) psMemRead->memoryCall(cpu.z80sp + 1, psMemRead) << 8); ! 16604: } ! 16605: else ! 16606: { ! 16607: cpu.z80AF = *((UINT8 *) psMemRead->pUserArea + (cpu.z80sp - psMemRead->lowAddr)); ! 16608: cpu.z80AF |= (UINT32) ((UINT32) *((UINT8 *) psMemRead->pUserArea + (cpu.z80sp - psMemRead->lowAddr + 1)) << 8); ! 16609: } ! 16610: psMemRead = NULL; ! 16611: break; ! 16612: } ! 16613: ++psMemRead; ! 16614: } ! 16615: ! 16616: if (psMemRead) ! 16617: { ! 16618: cpu.z80AF = cpu.z80Base[cpu.z80sp]; ! 16619: cpu.z80AF |= (UINT32) ((UINT32) cpu.z80Base[cpu.z80sp + 1] << 8); ! 16620: } ! 16621: ! 16622: cpu.z80sp += 2; ! 16623: pbSP = (cpu.z80Base + cpu.z80sp); /* Normalize the stack pointer */ ! 16624: break; ! 16625: } ! 16626: case 0xf2: ! 16627: { ! 16628: sdwCyclesRemaining -= 10; ! 16629: dwAddr = *pbPC++; /* Get LSB first */ ! 16630: dwAddr |= ((UINT32) *pbPC++ << 8); /* Get MSB last */ ! 16631: if (!(cpu.z80F & Z80_FLAG_SIGN)) ! 16632: { ! 16633: pbPC = cpu.z80Base + dwAddr; /* Normalize the address */ ! 16634: } ! 16635: break; ! 16636: } ! 16637: case 0xf3: ! 16638: { ! 16639: sdwCyclesRemaining -= 4; ! 16640: cpu.z80iff &= (~IFF1); ! 16641: break; ! 16642: } ! 16643: case 0xf4: ! 16644: { ! 16645: sdwCyclesRemaining -= 10; ! 16646: dwAddr = *pbPC++; /* Get LSB first */ ! 16647: dwAddr |= ((UINT32) *pbPC++ << 8); /* Get MSB last */ ! 16648: if (!(cpu.z80F & Z80_FLAG_SIGN)) ! 16649: { ! 16650: cpu.z80pc = (UINT32) pbPC - (UINT32) cpu.z80Base; ! 16651: pbSP = (cpu.z80Base + cpu.z80sp - 1); /* Normalize the stack pointer */ ! 16652: *pbSP-- = cpu.z80pc >> 8; /* MSB */ ! 16653: *pbSP = (UINT8) cpu.z80pc; /* LSB */ ! 16654: cpu.z80sp -= 2; /* Back our stack up */ ! 16655: pbPC = cpu.z80Base + dwAddr; /* Normalize the address */ ! 16656: } ! 16657: break; ! 16658: } ! 16659: case 0xf5: ! 16660: { ! 16661: sdwCyclesRemaining -= 11; ! 16662: cpu.z80sp -= 2; ! 16663: pbSP = (cpu.z80Base + cpu.z80sp); /* Normalize the stack pointer */ ! 16664: psMemWrite = cpu.z80MemWrite; /* Beginning of our handler */ ! 16665: while (psMemWrite->lowAddr != 0xffffffff) ! 16666: { ! 16667: if ((cpu.z80sp >= psMemWrite->lowAddr) && (cpu.z80sp <= psMemWrite->highAddr)) ! 16668: { ! 16669: cpu.z80pc = (UINT32) pbPC - (UINT32) cpu.z80Base; ! 16670: if (psMemWrite->memoryCall) ! 16671: { ! 16672: psMemWrite->memoryCall(cpu.z80sp, (cpu.z80AF & 0xff), psMemWrite); ! 16673: psMemWrite->memoryCall(cpu.z80sp + 1, (cpu.z80AF >> 8), psMemWrite); ! 16674: } ! 16675: else ! 16676: { ! 16677: *((UINT8 *) psMemWrite->pUserArea + (cpu.z80sp - psMemWrite->lowAddr)) = cpu.z80AF; ! 16678: *((UINT8 *) psMemWrite->pUserArea + (cpu.z80sp - psMemWrite->lowAddr) + 1) = cpu.z80AF >> 8; ! 16679: } ! 16680: psMemWrite = NULL; ! 16681: break; ! 16682: } ! 16683: ++psMemWrite; ! 16684: } ! 16685: ! 16686: if (psMemWrite) ! 16687: { ! 16688: cpu.z80Base[cpu.z80sp] = (UINT8) cpu.z80AF; ! 16689: cpu.z80Base[cpu.z80sp + 1] = (UINT8) ((UINT32) cpu.z80AF >> 8); ! 16690: } ! 16691: ! 16692: break; ! 16693: } ! 16694: case 0xf6: ! 16695: { ! 16696: sdwCyclesRemaining -= 7; ! 16697: cpu.z80A |= *pbPC++; ! 16698: cpu.z80F &= ~(Z80_FLAG_CARRY | Z80_FLAG_NEGATIVE | Z80_FLAG_OVERFLOW_PARITY | Z80_FLAG_HALF_CARRY | Z80_FLAG_ZERO | Z80_FLAG_SIGN); ! 16699: cpu.z80F |= bPostORFlags[cpu.z80A]; ! 16700: ! 16701: break; ! 16702: } ! 16703: case 0xf7: ! 16704: { ! 16705: sdwCyclesRemaining -= 11; ! 16706: cpu.z80pc = (UINT32) pbPC - (UINT32) cpu.z80Base; ! 16707: pbSP = (cpu.z80Base + cpu.z80sp - 1); /* Normalize the stack pointer */ ! 16708: *pbSP-- = cpu.z80pc >> 8; /* LSB */ ! 16709: *pbSP = (UINT8) cpu.z80pc; /* MSB */ ! 16710: cpu.z80sp -= 2; /* Back our stack up */ ! 16711: pbPC = cpu.z80Base + 0x30; /* Normalize the address */ ! 16712: break; ! 16713: } ! 16714: case 0xf8: ! 16715: { ! 16716: sdwCyclesRemaining -= 5; ! 16717: if (cpu.z80F & Z80_FLAG_SIGN) ! 16718: { ! 16719: dwElapsedTicks += 6; ! 16720: pbSP = cpu.z80Base + cpu.z80sp; /* Normalize our stack PTR */ ! 16721: dwAddr = *pbSP++; /* Pop LSB */ ! 16722: dwAddr |= ((UINT32) *pbSP << 8); /* Pop MSB */ ! 16723: cpu.z80sp += 2; /* Pop the word off */ ! 16724: pbPC = (cpu.z80Base + dwAddr); /* Point PC to our return address */ ! 16725: } ! 16726: break; ! 16727: } ! 16728: case 0xf9: ! 16729: { ! 16730: sdwCyclesRemaining -= 6; ! 16731: cpu.z80sp = cpu.z80HL; ! 16732: break; ! 16733: } ! 16734: case 0xfa: ! 16735: { ! 16736: sdwCyclesRemaining -= 10; ! 16737: dwAddr = *pbPC++; /* Get LSB first */ ! 16738: dwAddr |= ((UINT32) *pbPC++ << 8); /* Get MSB last */ ! 16739: if (cpu.z80F & Z80_FLAG_SIGN) ! 16740: { ! 16741: pbPC = cpu.z80Base + dwAddr; /* Normalize the address */ ! 16742: } ! 16743: break; ! 16744: } ! 16745: case 0xfb: ! 16746: { ! 16747: sdwCyclesRemaining -= 4; ! 16748: cpu.z80iff |= IFF1; ! 16749: break; ! 16750: } ! 16751: case 0xfc: ! 16752: { ! 16753: sdwCyclesRemaining -= 10; ! 16754: dwAddr = *pbPC++; /* Get LSB first */ ! 16755: dwAddr |= ((UINT32) *pbPC++ << 8); /* Get MSB last */ ! 16756: if (cpu.z80F & Z80_FLAG_SIGN) ! 16757: { ! 16758: cpu.z80pc = (UINT32) pbPC - (UINT32) cpu.z80Base; ! 16759: pbSP = (cpu.z80Base + cpu.z80sp - 1); /* Normalize the stack pointer */ ! 16760: *pbSP-- = cpu.z80pc >> 8; /* MSB */ ! 16761: *pbSP = (UINT8) cpu.z80pc; /* LSB */ ! 16762: cpu.z80sp -= 2; /* Back our stack up */ ! 16763: pbPC = cpu.z80Base + dwAddr; /* Normalize the address */ ! 16764: } ! 16765: break; ! 16766: } ! 16767: case 0xfd: ! 16768: { ! 16769: FDHandler(); ! 16770: break; ! 16771: } ! 16772: case 0xfe: ! 16773: { ! 16774: sdwCyclesRemaining -= 7; ! 16775: cpu.z80F = (cpu.z80F & ~(Z80_FLAG_CARRY | Z80_FLAG_NEGATIVE | Z80_FLAG_OVERFLOW_PARITY | ! 16776: Z80_FLAG_HALF_CARRY | Z80_FLAG_ZERO | Z80_FLAG_SIGN)) | ! 16777: pbSubSbcTable[((UINT32) cpu.z80A << 8) | *pbPC++]; ! 16778: break; ! 16779: } ! 16780: case 0xff: ! 16781: { ! 16782: sdwCyclesRemaining -= 11; ! 16783: cpu.z80pc = (UINT32) pbPC - (UINT32) cpu.z80Base; ! 16784: pbSP = (cpu.z80Base + cpu.z80sp - 1); /* Normalize the stack pointer */ ! 16785: *pbSP-- = cpu.z80pc >> 8; /* LSB */ ! 16786: *pbSP = (UINT8) cpu.z80pc; /* MSB */ ! 16787: cpu.z80sp -= 2; /* Back our stack up */ ! 16788: pbPC = cpu.z80Base + 0x38; /* Normalize the address */ ! 16789: break; ! 16790: } ! 16791: } ! 16792: } ! 16793: ! 16794: dwElapsedTicks += (dwOriginalCycles - sdwCyclesRemaining); ! 16795: ! 16796: cpu.z80pc = (UINT32) pbPC - (UINT32) cpu.z80Base; ! 16797: return(dwReturnCode); /* Indicate success */ ! 16798: } ! 16799: ! 16800: /* Get mz80's context */ ! 16801: ! 16802: void mz80GetContext(void *pData) ! 16803: { ! 16804: memcpy(pData, &cpu, sizeof(CONTEXTMZ80)); ! 16805: } ! 16806: ! 16807: /* Set mz80's context */ ! 16808: ! 16809: void mz80SetContext(void *pData) ! 16810: { ! 16811: memcpy(&cpu, pData, sizeof(CONTEXTMZ80)); ! 16812: } ! 16813: ! 16814: /* Get mz80's context size */ ! 16815: ! 16816: UINT32 mz80GetContextSize(void) ! 16817: { ! 16818: return(sizeof(CONTEXTMZ80)); ! 16819: } ! 16820: ! 16821: /* This will return the elapsed ticks */ ! 16822: ! 16823: UINT32 mz80GetElapsedTicks(UINT32 dwClear) ! 16824: { ! 16825: UINT32 dwTemp = dwElapsedTicks; ! 16826: ! 16827: if (dwClear) ! 16828: { ! 16829: dwElapsedTicks = 0; ! 16830: } ! 16831: ! 16832: return(dwTemp); ! 16833: } ! 16834: ! 16835: /* Releases mz80 from its current timeslice */ ! 16836: ! 16837: void mz80ReleaseTimeslice(void) ! 16838: { ! 16839: dwOriginalCycles -= sdwCyclesRemaining; ! 16840: sdwCyclesRemaining = 0; ! 16841: } ! 16842: ! 16843: /* This routine is mz80's reset handler */ ! 16844: ! 16845: void mz80reset(void) ! 16846: { ! 16847: cpu.z80halted = 0; ! 16848: cpu.z80AF = 0; ! 16849: cpu.z80F = Z80_FLAG_ZERO; ! 16850: cpu.z80BC = 0; ! 16851: cpu.z80DE = 0; ! 16852: cpu.z80HL = 0; ! 16853: cpu.z80afprime = 0; ! 16854: cpu.z80bcprime = 0; ! 16855: cpu.z80deprime = 0; ! 16856: cpu.z80hlprime = 0; ! 16857: cpu.z80i = 0; ! 16858: cpu.z80r = 0; ! 16859: cpu.z80IX = 0xffff; /* Yes, this is intentional */ ! 16860: cpu.z80IY = 0xffff; /* Yes, this is intentional */ ! 16861: cpu.z80pc = 0; ! 16862: cpu.z80sp = 0; ! 16863: cpu.z80interruptMode = 0; ! 16864: cpu.z80intAddr = 0x38; ! 16865: cpu.z80nmiAddr = 0x66; ! 16866: } ! 16867: ! 16868: /* Interrupt handler */ ! 16869: ! 16870: UINT32 mz80int(UINT32 dwLowAddr) ! 16871: { ! 16872: cpu.z80halted = 0; ! 16873: if (0 == (cpu.z80iff & IFF1)) ! 16874: return(0xffffffff); ! 16875: cpu.z80iff &= ~(IFF1 | IFF2); ! 16876: pbSP = (cpu.z80Base + cpu.z80sp - 1); /* Normalize the stack pointer */ ! 16877: *pbSP-- = cpu.z80pc >> 8; /* LSB */ ! 16878: *pbSP = (UINT8) cpu.z80pc; /* MSB */ ! 16879: cpu.z80sp -= 2; /* Back our stack up */ ! 16880: if (2 == cpu.z80interruptMode) ! 16881: { ! 16882: cpu.z80pc = ((UINT16) cpu.z80i << 8) | (dwLowAddr & 0xff); ! 16883: cpu.z80pc = ((UINT16) cpu.z80Base[cpu.z80pc + 1] << 8) | (cpu.z80Base[cpu.z80pc]); ! 16884: } ! 16885: else ! 16886: { ! 16887: cpu.z80pc = cpu.z80intAddr; ! 16888: } ! 16889: pbPC = cpu.z80Base + cpu.z80pc; /* Normalize the address */ ! 16890: return(0); ! 16891: } ! 16892: ! 16893: /* NMI Handler */ ! 16894: ! 16895: UINT32 mz80nmi(void) ! 16896: { ! 16897: cpu.z80halted = 0; ! 16898: pbSP = (cpu.z80Base + cpu.z80sp - 1); /* Normalize the stack pointer */ ! 16899: *pbSP-- = cpu.z80pc >> 8; /* LSB */ ! 16900: *pbSP = (UINT8) cpu.z80pc; /* MSB */ ! 16901: cpu.z80sp -= 2; /* Back our stack up */ ! 16902: cpu.z80pc = cpu.z80nmiAddr; /* Our NMI */ ! 16903: return(0); ! 16904: } ! 16905: ! 16906: /* Initialize MZ80 for action */ ! 16907: ! 16908: void mz80init(void) ! 16909: { ! 16910: UINT32 dwLoop; ! 16911: UINT8 *pbTempPtr; ! 16912: UINT8 *pbTempPtr2; ! 16913: UINT8 bNewAdd; ! 16914: UINT8 bNewSub; ! 16915: UINT8 bFlag; ! 16916: UINT8 bLow; ! 16917: UINT8 bHigh; ! 16918: UINT8 bCarry; ! 16919: ! 16920: if (NULL == pbAddAdcTable) ! 16921: { ! 16922: pbAddAdcTable = malloc(256*256*2); ! 16923: ! 16924: if (NULL == pbAddAdcTable) ! 16925: { ! 16926: return; ! 16927: } ! 16928: ! 16929: pbTempPtr = pbAddAdcTable; ! 16930: ! 16931: pbSubSbcTable = malloc(256*256*2); ! 16932: ! 16933: if (NULL == pbSubSbcTable) ! 16934: { ! 16935: return; ! 16936: } ! 16937: ! 16938: pbTempPtr2 = pbSubSbcTable; ! 16939: ! 16940: for (dwLoop = 0; dwLoop < (256*256*2); dwLoop++) ! 16941: { ! 16942: bLow = dwLoop & 0xff; ! 16943: bHigh = (dwLoop >> 8) & 0xff; ! 16944: bCarry = (dwLoop >> 16); ! 16945: ! 16946: bFlag = 0; ! 16947: bNewAdd = bHigh + bLow + bCarry; ! 16948: ! 16949: if (0 == bNewAdd) ! 16950: { ! 16951: bFlag |= Z80_FLAG_ZERO; ! 16952: } ! 16953: else ! 16954: { ! 16955: bFlag = bNewAdd & 0x80; /* Sign flag */ ! 16956: } ! 16957: ! 16958: if (((UINT32) bLow + (UINT32) bHigh + (UINT32) bCarry) >= 0x100) ! 16959: { ! 16960: bFlag |= Z80_FLAG_CARRY; ! 16961: } ! 16962: ! 16963: if ( ((bLow ^ bHigh ^ 0x80) & (bLow ^ (bNewAdd & 0x80))) & 0x80) ! 16964: { ! 16965: bFlag |= Z80_FLAG_OVERFLOW_PARITY; ! 16966: } ! 16967: ! 16968: if (((bLow & 0x0f) + (bHigh & 0x0f) + bCarry) >= 0x10) ! 16969: { ! 16970: bFlag |= Z80_FLAG_HALF_CARRY; ! 16971: } ! 16972: ! 16973: *pbTempPtr++ = bFlag; /* Store our new flag */ ! 16974: ! 16975: // Now do subtract - Zero ! 16976: ! 16977: bFlag = Z80_FLAG_NEGATIVE; ! 16978: bNewSub = bHigh - bLow - bCarry; ! 16979: ! 16980: if (0 == bNewSub) ! 16981: { ! 16982: bFlag |= Z80_FLAG_ZERO; ! 16983: } ! 16984: else ! 16985: { ! 16986: bFlag |= bNewSub & 0x80; /* Sign flag */ ! 16987: } ! 16988: ! 16989: if ( ((INT32) bHigh - (INT32) bLow - (INT32) bCarry) < 0) ! 16990: { ! 16991: bFlag |= Z80_FLAG_CARRY; ! 16992: } ! 16993: ! 16994: if ( ((INT32) (bHigh & 0xf) - (INT32) (bLow & 0x0f) - (INT32) bCarry) < 0) ! 16995: { ! 16996: bFlag |= Z80_FLAG_HALF_CARRY; ! 16997: } ! 16998: ! 16999: if ( ((bLow ^ bHigh) & (bHigh ^ bNewSub) & 0x80) ) ! 17000: { ! 17001: bFlag |= Z80_FLAG_OVERFLOW_PARITY; ! 17002: } ! 17003: ! 17004: *pbTempPtr2++ = bFlag; /* Store our sub flag */ ! 17005: ! 17006: } ! 17007: } ! 17008: } ! 17009: /* Shut down MZ80 */ ! 17010: ! 17011: void mz80shutdown(void) ! 17012: { ! 17013: } ! 17014:
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.