Ian Redmond
8080 emulator for mbed. Will run CP/M v2.0 from disk image on local file system. hopefully.
Embed:
(wiki syntax)
Show/hide line numbers
main.cpp
00001 //------------------------------------CP/M on MBED----------------------------------- 00002 // Emulate an 8080 and run CP/M v2.0 from a disk image saved on local storage. 00003 // 00004 // Inspired by excellent CP/M-on-AVR by Sprite_tm : http://spritesmods.com/?art=avrcpm 00005 // and by 00006 // 00007 // Basically a C reworking of Sprite's AVR machinecode. 00008 00009 #include "mbed.h" 00010 00011 void do_op_00(); void do_op_01(); void do_op_02(); void do_op_03(); void do_op_04(); void do_op_05(); void do_op_06(); void do_op_07(); 00012 void do_op_08(); void do_op_09(); void do_op_0A(); void do_op_0B(); void do_op_0C(); void do_op_0D(); void do_op_0E(); void do_op_0F(); 00013 void do_op_10(); void do_op_11(); void do_op_12(); void do_op_13(); void do_op_14(); void do_op_15(); void do_op_16(); void do_op_17(); 00014 void do_op_18(); void do_op_19(); void do_op_1A(); void do_op_1B(); void do_op_1C(); void do_op_1D(); void do_op_1E(); void do_op_1F(); 00015 void do_op_20(); void do_op_21(); void do_op_22(); void do_op_23(); void do_op_24(); void do_op_25(); void do_op_26(); void do_op_27(); 00016 void do_op_28(); void do_op_29(); void do_op_2A(); void do_op_2B(); void do_op_2C(); void do_op_2D(); void do_op_2E(); void do_op_2F(); 00017 void do_op_30(); void do_op_31(); void do_op_32(); void do_op_33(); void do_op_34(); void do_op_35(); void do_op_36(); void do_op_37(); 00018 void do_op_38(); void do_op_39(); void do_op_3A(); void do_op_3B(); void do_op_3C(); void do_op_3D(); void do_op_3E(); void do_op_3F(); 00019 void do_op_40(); void do_op_41(); void do_op_42(); void do_op_43(); void do_op_44(); void do_op_45(); void do_op_46(); void do_op_47(); 00020 void do_op_48(); void do_op_49(); void do_op_4A(); void do_op_4B(); void do_op_4C(); void do_op_4D(); void do_op_4E(); void do_op_4F(); 00021 void do_op_50(); void do_op_51(); void do_op_52(); void do_op_53(); void do_op_54(); void do_op_55(); void do_op_56(); void do_op_57(); 00022 void do_op_58(); void do_op_59(); void do_op_5A(); void do_op_5B(); void do_op_5C(); void do_op_5D(); void do_op_5E(); void do_op_5F(); 00023 void do_op_60(); void do_op_61(); void do_op_62(); void do_op_63(); void do_op_64(); void do_op_65(); void do_op_66(); void do_op_67(); 00024 void do_op_68(); void do_op_69(); void do_op_6A(); void do_op_6B(); void do_op_6C(); void do_op_6D(); void do_op_6E(); void do_op_6F(); 00025 void do_op_70(); void do_op_71(); void do_op_72(); void do_op_73(); void do_op_74(); void do_op_75(); void do_op_76(); void do_op_77(); 00026 void do_op_78(); void do_op_79(); void do_op_7A(); void do_op_7B(); void do_op_7C(); void do_op_7D(); void do_op_7E(); void do_op_7F(); 00027 void do_op_80(); void do_op_81(); void do_op_82(); void do_op_83(); void do_op_84(); void do_op_85(); void do_op_86(); void do_op_87(); 00028 void do_op_88(); void do_op_89(); void do_op_8A(); void do_op_8B(); void do_op_8C(); void do_op_8D(); void do_op_8E(); void do_op_8F(); 00029 void do_op_90(); void do_op_91(); void do_op_92(); void do_op_93(); void do_op_94(); void do_op_95(); void do_op_96(); void do_op_97(); 00030 void do_op_98(); void do_op_99(); void do_op_9A(); void do_op_9B(); void do_op_9C(); void do_op_9D(); void do_op_9E(); void do_op_9F(); 00031 void do_op_A0(); void do_op_A1(); void do_op_A2(); void do_op_A3(); void do_op_A4(); void do_op_A5(); void do_op_A6(); void do_op_A7(); 00032 void do_op_A8(); void do_op_A9(); void do_op_AA(); void do_op_AB(); void do_op_AC(); void do_op_AD(); void do_op_AE(); void do_op_AF(); 00033 void do_op_B0(); void do_op_B1(); void do_op_B2(); void do_op_B3(); void do_op_B4(); void do_op_B5(); void do_op_B6(); void do_op_B7(); 00034 void do_op_B8(); void do_op_B9(); void do_op_BA(); void do_op_BB(); void do_op_BC(); void do_op_BD(); void do_op_BE(); void do_op_BF(); 00035 void do_op_C0(); void do_op_C1(); void do_op_C2(); void do_op_C3(); void do_op_C4(); void do_op_C5(); void do_op_C6(); void do_op_C7(); 00036 void do_op_C8(); void do_op_C9(); void do_op_CA(); void do_op_CB(); void do_op_CC(); void do_op_CD(); void do_op_CE(); void do_op_CF(); 00037 void do_op_D0(); void do_op_D1(); void do_op_D2(); void do_op_D3(); void do_op_D4(); void do_op_D5(); void do_op_D6(); void do_op_D7(); 00038 void do_op_D8(); void do_op_D9(); void do_op_DA(); void do_op_DB(); void do_op_DC(); void do_op_DD(); void do_op_DE(); void do_op_DF(); 00039 void do_op_E0(); void do_op_E1(); void do_op_E2(); void do_op_E3(); void do_op_E4(); void do_op_E5(); void do_op_E6(); void do_op_E7(); 00040 void do_op_E8(); void do_op_E9(); void do_op_EA(); void do_op_EB(); void do_op_EC(); void do_op_ED(); void do_op_EE(); void do_op_EF(); 00041 void do_op_F0(); void do_op_F1(); void do_op_F2(); void do_op_F3(); void do_op_F4(); void do_op_F5(); void do_op_F6(); void do_op_F7(); 00042 void do_op_F8(); void do_op_F9(); void do_op_FA(); void do_op_FB(); void do_op_FC(); void do_op_FD(); void do_op_FE(); void do_op_FF(); 00043 00044 typedef void (*ptr2function)(void); 00045 00046 const ptr2function function[] = { 00047 &do_op_00,&do_op_01,&do_op_02,&do_op_03,&do_op_04,&do_op_05,&do_op_06,&do_op_07, 00048 &do_op_08,&do_op_09,&do_op_0A,&do_op_0B,&do_op_0C,&do_op_0D,&do_op_0E,&do_op_0F, 00049 &do_op_10,&do_op_11,&do_op_12,&do_op_13,&do_op_14,&do_op_15,&do_op_16,&do_op_17, 00050 &do_op_18,&do_op_19,&do_op_1A,&do_op_1B,&do_op_1C,&do_op_1D,&do_op_1E,&do_op_1F, 00051 &do_op_20,&do_op_21,&do_op_22,&do_op_23,&do_op_24,&do_op_25,&do_op_26,&do_op_27, 00052 &do_op_28,&do_op_29,&do_op_2A,&do_op_2B,&do_op_2C,&do_op_2D,&do_op_2E,&do_op_2F, 00053 &do_op_30,&do_op_31,&do_op_32,&do_op_33,&do_op_34,&do_op_35,&do_op_36,&do_op_37, 00054 &do_op_38,&do_op_39,&do_op_3A,&do_op_3B,&do_op_3C,&do_op_3D,&do_op_3E,&do_op_3F, 00055 &do_op_40,&do_op_41,&do_op_42,&do_op_43,&do_op_44,&do_op_45,&do_op_46,&do_op_47, 00056 &do_op_48,&do_op_49,&do_op_4A,&do_op_4B,&do_op_4C,&do_op_4D,&do_op_4E,&do_op_4F, 00057 &do_op_50,&do_op_51,&do_op_52,&do_op_53,&do_op_54,&do_op_55,&do_op_56,&do_op_57, 00058 &do_op_58,&do_op_59,&do_op_5A,&do_op_5B,&do_op_5C,&do_op_5D,&do_op_5E,&do_op_5F, 00059 &do_op_60,&do_op_61,&do_op_62,&do_op_63,&do_op_64,&do_op_65,&do_op_66,&do_op_67, 00060 &do_op_68,&do_op_69,&do_op_6A,&do_op_6B,&do_op_6C,&do_op_6D,&do_op_6E,&do_op_6F, 00061 &do_op_70,&do_op_71,&do_op_72,&do_op_73,&do_op_74,&do_op_75,&do_op_76,&do_op_77, 00062 &do_op_78,&do_op_79,&do_op_7A,&do_op_7B,&do_op_7C,&do_op_7D,&do_op_7E,&do_op_7F, 00063 &do_op_80,&do_op_81,&do_op_82,&do_op_83,&do_op_84,&do_op_85,&do_op_86,&do_op_87, 00064 &do_op_88,&do_op_89,&do_op_8A,&do_op_8B,&do_op_8C,&do_op_8D,&do_op_8E,&do_op_8F, 00065 &do_op_90,&do_op_91,&do_op_92,&do_op_93,&do_op_94,&do_op_95,&do_op_96,&do_op_97, 00066 &do_op_98,&do_op_99,&do_op_9A,&do_op_9B,&do_op_9C,&do_op_9D,&do_op_9E,&do_op_9F, 00067 &do_op_A0,&do_op_A1,&do_op_A2,&do_op_A3,&do_op_A4,&do_op_A5,&do_op_A6,&do_op_A7, 00068 &do_op_A8,&do_op_A9,&do_op_AA,&do_op_AB,&do_op_AC,&do_op_AD,&do_op_AE,&do_op_AF, 00069 &do_op_B0,&do_op_B1,&do_op_B2,&do_op_B3,&do_op_B4,&do_op_B5,&do_op_B6,&do_op_B7, 00070 &do_op_B8,&do_op_B9,&do_op_BA,&do_op_BB,&do_op_BC,&do_op_BD,&do_op_BE,&do_op_BF, 00071 &do_op_C0,&do_op_C1,&do_op_C2,&do_op_C3,&do_op_C4,&do_op_C5,&do_op_C6,&do_op_C7, 00072 &do_op_C8,&do_op_C9,&do_op_CA,&do_op_CB,&do_op_CC,&do_op_CD,&do_op_CE,&do_op_CF, 00073 &do_op_D0,&do_op_D1,&do_op_D2,&do_op_D3,&do_op_D4,&do_op_D5,&do_op_D6,&do_op_D7, 00074 &do_op_D8,&do_op_D9,&do_op_DA,&do_op_DB,&do_op_DC,&do_op_DD,&do_op_DE,&do_op_DF, 00075 &do_op_E0,&do_op_E1,&do_op_E2,&do_op_E3,&do_op_E4,&do_op_E5,&do_op_E6,&do_op_E7, 00076 &do_op_E8,&do_op_E9,&do_op_EA,&do_op_EB,&do_op_EC,&do_op_ED,&do_op_EE,&do_op_EF, 00077 &do_op_F0,&do_op_F1,&do_op_F2,&do_op_F3,&do_op_F4,&do_op_F5,&do_op_F6,&do_op_F7, 00078 &do_op_F8,&do_op_F9,&do_op_FA,&do_op_FB,&do_op_FC,&do_op_FD,&do_op_FE,&do_op_FF } ; 00079 00080 char rA; // 8080 registers 00081 char rB; 00082 char rC; 00083 char rD; 00084 char rE; 00085 char rH; 00086 char rL; 00087 char rSPH; // stack pointer (stack grows down in memory) 00088 char rSPL; 00089 char rPCH; // Program counter 00090 char rPCL; 00091 00092 int pc; // 16 bit versions of pc/sp for convienience. 00093 int sp; 00094 00095 //Flag bits in rF 00096 #define FL_S 7 00097 #define FL_Z 6 00098 #define FL_H 4 00099 #define FL_P 2 00100 #define FL_N 1 00101 #define FL_C 0 00102 char rF; // Status flags 00103 00104 char oph; // operating registers when decoding instruction 00105 char opl; 00106 int op; // 16 bit version used for 16 bit arithmetic and setting status bits. 00107 00108 char temp; 00109 00110 bool nostore; // true if we need to skip the store phase (for conditional instructions). 00111 00112 char RAM[20*1024]; 00113 00114 int track; 00115 int sector; 00116 int dma; // DMA address for disk read/write 00117 00118 Serial serial(USBTX, USBRX); // tx, rx 00119 LocalFileSystem local("local"); // access to local file system. 00120 00121 void clear(char bit) { 00122 rF=rF&((0xFEF<<bit)>>8); 00123 } 00124 00125 void set(char bit) { 00126 rF = rF|(0x01<<bit); 00127 } 00128 00129 void set_flags(int result, char bits) { 00130 int mask = 0xff; 00131 char b = 1; 00132 if (bits==16) mask = 0xffff; 00133 rF = 0x00; 00134 if ((result>>bits)&0x01) set(FL_C); // Carry flag = bit 8 or bit 16, depending. 00135 if ((result>>3)&0x01) set(FL_H); // half-carry = bit 3 00136 if ((result&mask)==0) set(FL_Z); // Zero flag 00137 for(int i=0; i<bits; i++) if ((result>>i)&0x01) b++; if (b&0x01) set(FL_P); // Set Parity if num of ones is EVEN 00138 if ((result>>(bits-1))&0x01) set(FL_S); // Sign flag = bit 7 or 15 00139 } 00140 00141 void sync_rpc() { // make rPCL and rPCH match PC 00142 rPCL = (char)(pc&0xff); 00143 rPCH = (char)((pc>>8)&0xff); 00144 } 00145 00146 void sync_rsp() { // make rSPL and rSPH match SP 00147 rSPL = (char)(sp&0xff); 00148 rSPH = (char)((sp>>8)&0xff); 00149 } 00150 00151 void sync_op() { 00152 opl = (char)(op&0xff); 00153 oph = (char)((op>>8)&0xff); 00154 } 00155 00156 void push(char h, char l) { // push 16 bits 00157 RAM[--sp] = h; 00158 RAM[--sp] = l; 00159 sync_rsp(); 00160 } 00161 00162 int pop() { // pop 16 bits. 00163 int r; 00164 r = RAM[sp++]; 00165 r = r + RAM[sp++]<<8; 00166 sync_rsp(); 00167 return r; 00168 } 00169 00170 void read_sector(char *buffer, int t, int s) { // read 128 bytes from track/sector to buffer. 26 sectors to a track. 00171 FILE *fp = fopen("/local/cpm_disk", "r"); 00172 fseek( fp, (26*t+s)*128, SEEK_SET ); 00173 fread( buffer, sizeof(char), 128, fp ); 00174 fclose(fp); 00175 } 00176 00177 void write_sector(char *buffer, int t, int s) { // write 128 bytes from buffer to sector. 00178 FILE *fp = fopen("/local/cpm_disk", "w"); 00179 fseek( fp, (26*t+s)*128, SEEK_SET ); 00180 fwrite( buffer, sizeof(int), 128, fp ); 00181 fclose(fp); 00182 } 00183 00184 //================================================================================= 00185 // BIOS routines. 00186 // HW accessed via IN / OUT instructions. 00187 // 00188 // The hw is modelled to make writing a CPM BIOS easier. 00189 // Ports: 00190 // 0 - Con status. Returns 0xFF if the UART has a byte, 0 otherwise. 00191 // 1 - Console input, aka UDR. 00192 // 2 - Console output 00193 // 16 - Track select 00194 // 18 - Sector select (26 sectors to a track) 00195 // 20 - Write addr l 00196 // 21 - Write addr h 00197 // 22 - Trigger - write 1 to read, 2 to write a sector using the above info. 00198 // This will automatically move track, sector and dma addr to the next sector. 00199 00200 void out_command(char p) { 00201 switch(p) { 00202 case (2) : 00203 serial.putc(rA); 00204 break; 00205 case (16) : 00206 track = rA; 00207 break; 00208 case (18) : 00209 sector = rA; 00210 break; 00211 case (20) : 00212 dma = (dma&0xff00)|rA; 00213 break; 00214 case (21) : 00215 dma = (dma&0x00ff)|(rA<<8); 00216 break; 00217 case (22) : 00218 switch(rA) { 00219 case(1) : 00220 read_sector(&RAM[dma],track, sector); 00221 break; 00222 case(2) : 00223 write_sector(&RAM[dma],track, sector); 00224 break; 00225 } 00226 sector = (sector+1)%26; 00227 if (sector==0) track++; 00228 dma = dma+128; 00229 break; 00230 } 00231 } 00232 00233 //================================================================================= 00234 // BIOS routines. 00235 // HW accessed via IN / OUT instructions. 00236 // 00237 // The hw is modelled to make writing a CPM BIOS easier. 00238 // Ports: 00239 // 0 - Con status. Returns 0xFF if the UART has a byte, 0 otherwise. 00240 // 1 - Console input, aka UDR. 00241 // 2 - Console output 00242 // 16 - Track select 00243 // 18 - Sector select (26 sectors to a track) 00244 // 20 - Write addr l 00245 // 21 - Write addr h 00246 // 22 - Trigger - write 1 to read, 2 to write a sector using the above info. 00247 // This will automatically move track, sector and dma addr to the next sector. 00248 00249 char in_command(char p) { 00250 char r = 0; 00251 switch(p) { 00252 case(0) : 00253 if (serial.readable()) r = 0xff; else r = 0x00; 00254 break; 00255 case(1) : 00256 r = serial.getc(); 00257 break; 00258 } 00259 return r; 00260 } 00261 00262 //================================================================================= 00263 // MAIN. 00264 // load IPL from sector 0 (128 bytes) to 0x2000 and execute. 00265 // 00266 00267 int main() { 00268 read_sector(&RAM[0x2000], 0, 0); // read in first sector, contains IPL. 00269 pc = 0x2000; 00270 sync_rpc(); 00271 while(1) { 00272 function[RAM[pc]](); 00273 } 00274 } 00275 00276 //================================================================================= 00277 // FETCH operations. 00278 // fetch registers or memory contents into op registers ahead of an operation. 00279 00280 void FETCH_NOP() {} 00281 00282 void FETCH_A() { opl = rA; } 00283 void FETCH_B() { opl = rB; } 00284 void FETCH_C() { opl = rC; } 00285 void FETCH_D() { opl = rD; } 00286 void FETCH_E() { opl = rE; } 00287 void FETCH_H() { opl = rH; } 00288 void FETCH_L() { opl = rL; } 00289 00290 void FETCH_AF() { opl = rF; oph = rA; } // Assumes flags are correct!! 00291 void FETCH_BC() { opl = rC; oph = rB; } 00292 void FETCH_DE() { opl = rE; oph = rD; } 00293 void FETCH_HL() { opl = rL; oph = rH; } 00294 void FETCH_SP() { opl = rSPL; oph = rSPH; } 00295 00296 void FETCH_DIR8() { opl = RAM[pc++]; sync_rpc(); } 00297 void FETCH_DIR16() { opl = RAM[pc++]; oph = RAM[pc++]; sync_rpc(); } 00298 void FETCH_RST() { opl = RAM[pc]&0x38; oph = 0; } 00299 00300 void FETCH_MBC() { opl = RAM[rB<<8+rC]; } 00301 void FETCH_MDE() { opl = RAM[rD<<8+rE]; } 00302 void FETCH_MHL() { opl = RAM[rH<<8+rL]; } 00303 void FETCH_MSP() { opl = RAM[rSPH<<8+rSPL]; } 00304 00305 //================================================================================= 00306 // STORE operations. 00307 // store op to registers or memory locations after operation. 00308 00309 void STORE_NOP() {}; 00310 00311 void STORE_A() { rA = opl; } 00312 void STORE_B() { rB = opl; } 00313 void STORE_C() { rC = opl; } 00314 void STORE_D() { rD = opl; } 00315 void STORE_E() { rE = opl; } 00316 void STORE_H() { rH = opl; } 00317 void STORE_L() { rL = opl; } 00318 00319 void STORE_AF() { rF = opl; rA = oph; } // Assumes flags are correct!! 00320 void STORE_BC() { rC = opl; rB = oph; } 00321 void STORE_DE() { rE = opl; rD = oph; } 00322 void STORE_HL() { rL = opl; rH = oph; } 00323 void STORE_SP() { rSPL = opl; rSPH = oph; } 00324 00325 void STORE_MBC() { RAM[rB<<8+rC] = opl; } 00326 void STORE_MDE() { RAM[rD<<8+rE] = opl; } 00327 void STORE_MHL() { RAM[rH<<8+rL] = opl; } 00328 00329 void STORE_AM() { RAM[opl + oph<<8] = rA; } 00330 00331 void STORE_PC() { rPCL = opl; rPCH = oph; pc = opl+(oph<<8); } 00332 void STORE_CALL(){ sync_rpc(); push(rPCH, rPCL); rPCL = opl; rPCH = oph; pc = rPCH<<8 + rPCL; } 00333 void STORE_RET() { pc = pop(); sync_rpc(); } 00334 void STORE_MSP() { sp = (rSPH<<8)+rSPL; RAM[sp] = opl; RAM[sp+1] = oph; } 00335 00336 //================================================================================= 00337 // OPerations. 00338 // store op to registers or memory locations after operation. 00339 00340 void OP_NOP() {} 00341 void OP_INC() { op = opl; op++; set_flags(op,8); sync_op(); } 00342 void OP_DEC() { op = opl; op--; set_flags(op,8); sync_op(); } 00343 void OP_INC16() { op = opl + oph<<8; op++; sync_op(); } // no flags 00344 void OP_DEC16() { op = opl + oph<<8; op--; sync_op(); } // no flags 00345 void OP_RRC() { clear(FL_C); if (opl&0x01) set(FL_C); opl=(opl>>1); if ((rF>>FL_C)&0x01) opl = opl|0x80; } 00346 void OP_RLC() { clear(FL_C); if (opl&0x80) set(FL_C); opl=(opl<<1); if ((rF>>FL_C)&0x01) opl = opl|0x01; } 00347 void OP_RR() { temp = rF; clear(FL_C); if (opl&0x01) set(FL_C); opl= opl>>1; if ((temp>>FL_C)&0x01) opl = opl|0x80; } 00348 void OP_RL() { temp = rF; clear(FL_C); if (opl&0x80) set(FL_C); opl= opl<<1; if ((temp>>FL_C)&0x01) opl = opl|0x01; } 00349 void OP_ADDA() { op = opl; op = op + rA; set_flags(op,8); sync_op(); } 00350 void OP_ADCA() { op = opl; op = op + rA + (rF>>FL_C)&0x01; set_flags(op,8); sync_op(); } 00351 void OP_SUBFA() { op = rA - opl; set_flags(op,8); sync_op(); } 00352 void OP_SBCFA() { op = rA - opl -(rF>>FL_C)&0x01; set_flags(op,8); sync_op(); } 00353 void OP_ANDA() { opl = opl&rA; set_flags(opl,8); } 00354 void OP_ORA() { opl = opl|rA; set_flags(opl,8); } 00355 void OP_XORA() { opl = opl^rA; set_flags(opl,8); } 00356 void OP_ADDHL() { op = opl + oph<<8; op +=(rH<<8)+rL; set_flags(op, 16); } 00357 void OP_STHL() { op = opl + oph<<8; RAM[op] = rL; RAM[op+1] = rH; } 00358 void OP_RMEM16(){ temp = (rH<<8)+rL; opl = RAM[temp]; oph = RAM[temp+1]; } 00359 void OP_RMEM8() { temp = (rH<<8)+rL; opl = RAM[temp]; } 00360 void OP_SCF() { set(FL_C); } // set Carry 00361 void OP_CCF() { rF = rF^(1<<FL_C); } // compliement Carry 00362 void OP_CPL() { opl = !opl; rF = rF|(1<<FL_N|1<<FL_H); } 00363 void OP_PUSH16(){ sp = (rSPH<<8)+rSPL; RAM[--sp] = oph; RAM[--sp] = opl; sync_rsp(); } 00364 void OP_POP16() { sp = (rSPH<<8)+rSPL; opl = RAM[sp++]; oph = RAM[sp++]; sync_rsp(); } 00365 void OP_EXHL() { temp = rL; rL = opl; opl = temp; temp = rH; rH = oph; oph = temp; } 00366 void OP_IFNZ() { if (rF&(1<<FL_Z)) nostore = true; } 00367 void OP_IFZ() { if (!(rF&(1<<FL_Z))) nostore = true; } 00368 void OP_IFNC() { if (rF&(1<<FL_C)) nostore = true; } 00369 void OP_IFC() { if (!(rF&(1<<FL_C))) nostore = true; } 00370 void OP_IFPO() { if (!(rF&(1<<FL_P))) nostore = true; } 00371 void OP_IFPE() { if (rF&(1<<FL_P)) nostore = true; } 00372 void OP_IFP() { if (!(rF&(1<<FL_S))) nostore = true; } 00373 void OP_IFM() { if (rF&(1<<FL_S)) nostore = true; } 00374 void OP_OUTA() { out_command(opl); } 00375 void OP_INA() { rA = in_command(opl); } 00376 void OP_INV() { serial.printf("Invalid opcode at %04X : %02X.\n", pc, RAM[pc]); while(1); } 00377 void OP_DI() { OP_INV(); } 00378 void OP_EI() { OP_INV(); } 00379 void OP_DA() { OP_INV(); } // to implement!! 00380 00381 //================================================================================= 00382 // Operations broken down into fetch/op/store phases. 00383 // 00384 00385 void do_op_00() { FETCH_NOP(); OP_NOP(); STORE_NOP(); } // 00 NOP 00386 void do_op_01() { FETCH_DIR16(); OP_NOP(); STORE_BC(); } // 01 nnnnLDBC,nn 00387 void do_op_02() { FETCH_A(); OP_NOP(); STORE_MBC(); } // 02 LD(BC),A 00388 void do_op_03() { FETCH_BC(); OP_INC16(); STORE_BC(); } // 03 INCBC 00389 void do_op_04() { FETCH_B(); OP_INC(); STORE_B(); } // 04 INCB 00390 void do_op_05() { FETCH_B(); OP_DEC(); STORE_B(); } // 05 DECB 00391 void do_op_06() { FETCH_DIR8(); OP_NOP(); STORE_B(); } // 06 nnLDB,n 00392 void do_op_07() { FETCH_A(); OP_RLC(); STORE_A(); } // 07 RLCA 00393 void do_op_08() { FETCH_NOP(); OP_INV(); STORE_NOP(); } // 08 EXAF,AF'(Z80) 00394 void do_op_09() { FETCH_BC(); OP_ADDHL(); STORE_HL(); } // 09 ADDHL,BC 00395 void do_op_0A() { FETCH_MBC(); OP_NOP(); STORE_A(); } // 0A LDA,(BC) 00396 void do_op_0B() { FETCH_BC(); OP_DEC16(); STORE_BC(); } // 0B DECBC 00397 void do_op_0C() { FETCH_C(); OP_INC(); STORE_C(); } // 0C INCC 00398 void do_op_0D() { FETCH_C(); OP_DEC(); STORE_C(); } // 0D DECC 00399 void do_op_0E() { FETCH_DIR8(); OP_NOP(); STORE_C(); } // 0E nnLDC,n 00400 void do_op_0F() { FETCH_A(); OP_RRC(); STORE_A(); } // 0F RRCA 00401 void do_op_10() { FETCH_NOP(); OP_INV(); STORE_NOP(); } // 10 ooDJNZo(Z80) 00402 void do_op_11() { FETCH_DIR16(); OP_NOP(); STORE_DE(); } // 11 nnnnLDDE,nn 00403 void do_op_12() { FETCH_A(); OP_NOP(); STORE_MDE(); } // 12 LD(DE),A 00404 void do_op_13() { FETCH_DE(); OP_INC16(); STORE_DE(); } // 13 INCDE 00405 void do_op_14() { FETCH_D(); OP_INC(); STORE_D(); } // 14 INCD 00406 void do_op_15() { FETCH_D(); OP_DEC(); STORE_D(); } // 15 DECD 00407 void do_op_16() { FETCH_DIR8(); OP_NOP(); STORE_D(); } // 16 nnLDD,n 00408 void do_op_17() { FETCH_A(); OP_RL(); STORE_A(); } // 17 RLA 00409 void do_op_18() { FETCH_NOP(); OP_INV(); STORE_NOP(); } // 18 ooJRo(Z80) 00410 void do_op_19() { FETCH_DE(); OP_ADDHL(); STORE_HL(); } // 19 ADDHL,DE 00411 void do_op_1A() { FETCH_MDE(); OP_NOP(); STORE_A(); } // 1A LDA,(DE) 00412 void do_op_1B() { FETCH_DE(); OP_DEC16(); STORE_DE(); } // 1B DECDE 00413 void do_op_1C() { FETCH_E(); OP_INC(); STORE_E(); } // 1C INCE 00414 void do_op_1D() { FETCH_E(); OP_DEC(); STORE_E(); } // 1D DECE 00415 void do_op_1E() { FETCH_DIR8(); OP_NOP(); STORE_E(); } // 1E nnLDE,n 00416 void do_op_1F() { FETCH_A(); OP_RR(); STORE_A(); } // 1F RRA 00417 void do_op_20() { FETCH_NOP(); OP_INV(); STORE_NOP(); } // 20 ooJRNZ,o(Z80) 00418 void do_op_21() { FETCH_DIR16(); OP_NOP(); STORE_HL(); } // 21 nnnnLDHL,nn 00419 void do_op_22() { FETCH_DIR16(); OP_STHL(); STORE_NOP(); } // 22 nnnnLD(nn),HL 00420 void do_op_23() { FETCH_HL(); OP_INC16(); STORE_HL(); } // 23 INCHL 00421 void do_op_24() { FETCH_H(); OP_INC(); STORE_H(); } // 24 INCH 00422 void do_op_25() { FETCH_H(); OP_DEC(); STORE_H(); } // 25 DECH 00423 void do_op_26() { FETCH_DIR8(); OP_NOP(); STORE_H(); } // 26 nnLDH,n 00424 void do_op_27() { FETCH_A(); OP_DA(); STORE_A(); } // 27 DAA 00425 void do_op_28() { FETCH_NOP(); OP_INV(); STORE_NOP(); } // 28 ooJRZ,o(Z80) 00426 void do_op_29() { FETCH_HL(); OP_ADDHL(); STORE_HL(); } // 29 ADDHL,HL 00427 void do_op_2A() { FETCH_DIR16(); OP_RMEM16(); STORE_HL(); } // 2A nnnnLDHL,(nn) 00428 void do_op_2B() { FETCH_HL(); OP_DEC16(); STORE_HL(); } // 2B DECHL 00429 void do_op_2C() { FETCH_L(); OP_INC(); STORE_L(); } // 2C INCL 00430 void do_op_2D() { FETCH_L(); OP_DEC(); STORE_L(); } // 2D DECL 00431 void do_op_2E() { FETCH_DIR8(); OP_NOP(); STORE_L(); } // 2E nnLDL,n 00432 void do_op_2F() { FETCH_A(); OP_CPL(); STORE_A(); } // 2F CPL 00433 void do_op_30() { FETCH_NOP(); OP_INV(); STORE_NOP(); } // 30 ooJRNC,o(Z80) 00434 void do_op_31() { FETCH_DIR16(); OP_NOP(); STORE_SP(); } // 31 nnnnLDSP,nn 00435 void do_op_32() { FETCH_DIR16(); OP_NOP(); STORE_AM(); } // 32 nnnnLD(nn),A 00436 void do_op_33() { FETCH_SP(); OP_INC16(); STORE_SP(); } // 33 INCSP 00437 void do_op_34() { FETCH_MHL(); OP_INC(); STORE_MHL(); } // 34 INC(HL) 00438 void do_op_35() { FETCH_MHL(); OP_DEC(); STORE_MHL(); } // 35 DEC(HL) 00439 void do_op_36() { FETCH_DIR8(); OP_NOP(); STORE_MHL(); } // 36 nnLD(HL),n 00440 void do_op_37() { FETCH_NOP(); OP_SCF(); STORE_NOP(); } // 37 SCF 00441 void do_op_38() { FETCH_NOP(); OP_INV(); STORE_NOP(); } // 38 ooJRC,o(Z80) 00442 void do_op_39() { FETCH_SP(); OP_ADDHL(); STORE_HL(); } // 39 ADDHL,SP 00443 void do_op_3A() { FETCH_DIR16(); OP_RMEM8(); STORE_A(); } // 3A nnnnLDA,(nn) 00444 void do_op_3B() { FETCH_SP(); OP_DEC16(); STORE_SP(); } // 3B DECSP 00445 void do_op_3C() { FETCH_A(); OP_INC(); STORE_A(); } // 3C INCA 00446 void do_op_3D() { FETCH_A(); OP_DEC(); STORE_A(); } // 3D DECA 00447 void do_op_3E() { FETCH_DIR8(); OP_NOP(); STORE_A(); } // 3E nnLDA,n 00448 void do_op_3F() { FETCH_NOP(); OP_CCF(); STORE_NOP(); } // 3F CCF(ComplementCarryFlag,gvd) 00449 void do_op_40() { FETCH_B(); OP_NOP(); STORE_B(); } // 40 LDB,r 00450 void do_op_41() { FETCH_C(); OP_NOP(); STORE_B(); } // 41 LDB,r 00451 void do_op_42() { FETCH_D(); OP_NOP(); STORE_B(); } // 42 LDB,r 00452 void do_op_43() { FETCH_E(); OP_NOP(); STORE_B(); } // 43 LDB,r 00453 void do_op_44() { FETCH_H(); OP_NOP(); STORE_B(); } // 44 LDB,r 00454 void do_op_45() { FETCH_L(); OP_NOP(); STORE_B(); } // 45 LDB,r 00455 void do_op_46() { FETCH_MHL(); OP_NOP(); STORE_B(); } // 46 LDB,r 00456 void do_op_47() { FETCH_A(); OP_NOP(); STORE_B(); } // 47 LDB,r 00457 void do_op_48() { FETCH_B(); OP_NOP(); STORE_C(); } // 48 LDC,r 00458 void do_op_49() { FETCH_C(); OP_NOP(); STORE_C(); } // 49 LDC,r 00459 void do_op_4A() { FETCH_D(); OP_NOP(); STORE_C(); } // 4A LDC,r 00460 void do_op_4B() { FETCH_E(); OP_NOP(); STORE_C(); } // 4B LDC,r 00461 void do_op_4C() { FETCH_H(); OP_NOP(); STORE_C(); } // 4C LDC,r 00462 void do_op_4D() { FETCH_L(); OP_NOP(); STORE_C(); } // 4D LDC,r 00463 void do_op_4E() { FETCH_MHL(); OP_NOP(); STORE_C(); } // 4E LDC,r 00464 void do_op_4F() { FETCH_A(); OP_NOP(); STORE_C(); } // 4F LDC,r 00465 void do_op_50() { FETCH_B(); OP_NOP(); STORE_D(); } // 50 LDD,r 00466 void do_op_51() { FETCH_C(); OP_NOP(); STORE_D(); } // 51 LDD,r 00467 void do_op_52() { FETCH_D(); OP_NOP(); STORE_D(); } // 52 LDD,r 00468 void do_op_53() { FETCH_E(); OP_NOP(); STORE_D(); } // 53 LDD,r 00469 void do_op_54() { FETCH_H(); OP_NOP(); STORE_D(); } // 54 LDD,r 00470 void do_op_55() { FETCH_L(); OP_NOP(); STORE_D(); } // 55 LDD,r 00471 void do_op_56() { FETCH_MHL(); OP_NOP(); STORE_D(); } // 56 LDD,r 00472 void do_op_57() { FETCH_A(); OP_NOP(); STORE_D(); } // 57 LDD,r 00473 void do_op_58() { FETCH_B(); OP_NOP(); STORE_E(); } // 58 LDE,r 00474 void do_op_59() { FETCH_C(); OP_NOP(); STORE_E(); } // 59 LDE,r 00475 void do_op_5A() { FETCH_D(); OP_NOP(); STORE_E(); } // 5A LDE,r 00476 void do_op_5B() { FETCH_E(); OP_NOP(); STORE_E(); } // 5B LDE,r 00477 void do_op_5C() { FETCH_H(); OP_NOP(); STORE_E(); } // 5C LDE,r 00478 void do_op_5D() { FETCH_L(); OP_NOP(); STORE_E(); } // 5D LDE,r 00479 void do_op_5E() { FETCH_MHL(); OP_NOP(); STORE_E(); } // 5E LDE,r 00480 void do_op_5F() { FETCH_A(); OP_NOP(); STORE_E(); } // 5F LDE,r 00481 void do_op_60() { FETCH_B(); OP_NOP(); STORE_H(); } // 60 LDH,r 00482 void do_op_61() { FETCH_C(); OP_NOP(); STORE_H(); } // 61 LDH,r 00483 void do_op_62() { FETCH_D(); OP_NOP(); STORE_H(); } // 62 LDH,r 00484 void do_op_63() { FETCH_E(); OP_NOP(); STORE_H(); } // 63 LDH,r 00485 void do_op_64() { FETCH_H(); OP_NOP(); STORE_H(); } // 64 LDH,r 00486 void do_op_65() { FETCH_L(); OP_NOP(); STORE_H(); } // 65 LDH,r 00487 void do_op_66() { FETCH_MHL(); OP_NOP(); STORE_H(); } // 66 LDH,r 00488 void do_op_67() { FETCH_A(); OP_NOP(); STORE_H(); } // 67 LDH,r 00489 void do_op_68() { FETCH_B(); OP_NOP(); STORE_L(); } // 68 LDL,r 00490 void do_op_69() { FETCH_C(); OP_NOP(); STORE_L(); } // 69 LDL,r 00491 void do_op_6A() { FETCH_D(); OP_NOP(); STORE_L(); } // 6A LDL,r 00492 void do_op_6B() { FETCH_E(); OP_NOP(); STORE_L(); } // 6B LDL,r 00493 void do_op_6C() { FETCH_H(); OP_NOP(); STORE_L(); } // 6C LDL,r 00494 void do_op_6D() { FETCH_L(); OP_NOP(); STORE_L(); } // 6D LDL,r 00495 void do_op_6E() { FETCH_MHL(); OP_NOP(); STORE_L(); } // 6E LDL,r 00496 void do_op_6F() { FETCH_A(); OP_NOP(); STORE_L(); } // 6F LDL,r 00497 void do_op_70() { FETCH_B(); OP_NOP(); STORE_MHL(); } // 70 LD(HL),r 00498 void do_op_71() { FETCH_C(); OP_NOP(); STORE_MHL(); } // 71 LD(HL),r 00499 void do_op_72() { FETCH_D(); OP_NOP(); STORE_MHL(); } // 72 LD(HL),r 00500 void do_op_73() { FETCH_E(); OP_NOP(); STORE_MHL(); } // 73 LD(HL),r 00501 void do_op_74() { FETCH_H(); OP_NOP(); STORE_MHL(); } // 74 LD(HL),r 00502 void do_op_75() { FETCH_L(); OP_NOP(); STORE_MHL(); } // 75 LD(HL),r 00503 void do_op_76() { FETCH_NOP(); OP_NOP(); STORE_NOP(); } // 76 HALT 00504 void do_op_77() { FETCH_A(); OP_NOP(); STORE_MHL(); } // 77 LD(HL),r 00505 void do_op_78() { FETCH_B(); OP_NOP(); STORE_A(); } // 78 LDA,r 00506 void do_op_79() { FETCH_C(); OP_NOP(); STORE_A(); } // 79 LDA,r 00507 void do_op_7A() { FETCH_D(); OP_NOP(); STORE_A(); } // 7A LDA,r 00508 void do_op_7B() { FETCH_E(); OP_NOP(); STORE_A(); } // 7B LDA,r 00509 void do_op_7C() { FETCH_H(); OP_NOP(); STORE_A(); } // 7C LDA,r 00510 void do_op_7D() { FETCH_L(); OP_NOP(); STORE_A(); } // 7D LDA,r 00511 void do_op_7E() { FETCH_MHL(); OP_NOP(); STORE_A(); } // 7E LDA,r 00512 void do_op_7F() { FETCH_A(); OP_NOP(); STORE_A(); } // 7F LDA,r 00513 void do_op_80() { FETCH_B(); OP_ADDA(); STORE_A(); } // 80 ADDA,r 00514 void do_op_81() { FETCH_C(); OP_ADDA(); STORE_A(); } // 81 ADDA,r 00515 void do_op_82() { FETCH_D(); OP_ADDA(); STORE_A(); } // 82 ADDA,r 00516 void do_op_83() { FETCH_E(); OP_ADDA(); STORE_A(); } // 83 ADDA,r 00517 void do_op_84() { FETCH_H(); OP_ADDA(); STORE_A(); } // 84 ADDA,r 00518 void do_op_85() { FETCH_L(); OP_ADDA(); STORE_A(); } // 85 ADDA,r 00519 void do_op_86() { FETCH_MHL(); OP_ADDA(); STORE_A(); } // 86 ADDA,r 00520 void do_op_87() { FETCH_A(); OP_ADDA(); STORE_A(); } // 87 ADDA,r 00521 void do_op_88() { FETCH_B(); OP_ADCA(); STORE_A(); } // 88 ADCA,r 00522 void do_op_89() { FETCH_C(); OP_ADCA(); STORE_A(); } // 89 ADCA,r 00523 void do_op_8A() { FETCH_D(); OP_ADCA(); STORE_A(); } // 8A ADCA,r 00524 void do_op_8B() { FETCH_E(); OP_ADCA(); STORE_A(); } // 8B ADCA,r 00525 void do_op_8C() { FETCH_H(); OP_ADCA(); STORE_A(); } // 8C ADCA,r 00526 void do_op_8D() { FETCH_L(); OP_ADCA(); STORE_A(); } // 8D ADCA,r 00527 void do_op_8E() { FETCH_MHL(); OP_ADCA(); STORE_A(); } // 8E ADCA,r 00528 void do_op_8F() { FETCH_A(); OP_ADCA(); STORE_A(); } // 8F ADCA,r 00529 void do_op_90() { FETCH_B(); OP_SUBFA(); STORE_A(); } // 90 SUBA,r 00530 void do_op_91() { FETCH_C(); OP_SUBFA(); STORE_A(); } // 91 SUBA,r 00531 void do_op_92() { FETCH_D(); OP_SUBFA(); STORE_A(); } // 92 SUBA,r 00532 void do_op_93() { FETCH_E(); OP_SUBFA(); STORE_A(); } // 93 SUBA,r 00533 void do_op_94() { FETCH_H(); OP_SUBFA(); STORE_A(); } // 94 SUBA,r 00534 void do_op_95() { FETCH_L(); OP_SUBFA(); STORE_A(); } // 95 SUBA,r 00535 void do_op_96() { FETCH_MHL(); OP_SUBFA(); STORE_A(); } // 96 SUBA,r 00536 void do_op_97() { FETCH_A(); OP_SUBFA(); STORE_A(); } // 97 SUBA,r 00537 void do_op_98() { FETCH_B(); OP_SBCFA(); STORE_A(); } // 98 SBCA,r 00538 void do_op_99() { FETCH_C(); OP_SBCFA(); STORE_A(); } // 99 SBCA,r 00539 void do_op_9A() { FETCH_D(); OP_SBCFA(); STORE_A(); } // 9A SBCA,r 00540 void do_op_9B() { FETCH_E(); OP_SBCFA(); STORE_A(); } // 9B SBCA,r 00541 void do_op_9C() { FETCH_H(); OP_SBCFA(); STORE_A(); } // 9C SBCA,r 00542 void do_op_9D() { FETCH_L(); OP_SBCFA(); STORE_A(); } // 9D SBCA,r 00543 void do_op_9E() { FETCH_MHL(); OP_SBCFA(); STORE_A(); } // 9E SBCA,r 00544 void do_op_9F() { FETCH_A(); OP_SBCFA(); STORE_A(); } // 9F SBCA,r 00545 void do_op_A0() { FETCH_B(); OP_ANDA(); STORE_A(); } // A0 ANDA,r 00546 void do_op_A1() { FETCH_C(); OP_ANDA(); STORE_A(); } // A1 ANDA,r 00547 void do_op_A2() { FETCH_D(); OP_ANDA(); STORE_A(); } // A2 ANDA,r 00548 void do_op_A3() { FETCH_E(); OP_ANDA(); STORE_A(); } // A3 ANDA,r 00549 void do_op_A4() { FETCH_H(); OP_ANDA(); STORE_A(); } // A4 ANDA,r 00550 void do_op_A5() { FETCH_L(); OP_ANDA(); STORE_A(); } // A5 ANDA,r 00551 void do_op_A6() { FETCH_MHL(); OP_ANDA(); STORE_A(); } // A6 ANDA,r 00552 void do_op_A7() { FETCH_A(); OP_ANDA(); STORE_A(); } // A7 ANDA,r 00553 void do_op_A8() { FETCH_B(); OP_XORA(); STORE_A(); } // A8 XORA,r 00554 void do_op_A9() { FETCH_C(); OP_XORA(); STORE_A(); } // A9 XORA,r 00555 void do_op_AA() { FETCH_D(); OP_XORA(); STORE_A(); } // AA XORA,r 00556 void do_op_AB() { FETCH_E(); OP_XORA(); STORE_A(); } // AB XORA,r 00557 void do_op_AC() { FETCH_H(); OP_XORA(); STORE_A(); } // AC XORA,r 00558 void do_op_AD() { FETCH_L(); OP_XORA(); STORE_A(); } // AD XORA,r 00559 void do_op_AE() { FETCH_MHL(); OP_XORA(); STORE_A(); } // AE XORA,r 00560 void do_op_AF() { FETCH_A(); OP_XORA(); STORE_A(); } // AF XORA,r 00561 void do_op_B0() { FETCH_B(); OP_ORA(); STORE_A(); } // B0 ORA,r 00562 void do_op_B1() { FETCH_C(); OP_ORA(); STORE_A(); } // B1 ORA,r 00563 void do_op_B2() { FETCH_D(); OP_ORA(); STORE_A(); } // B2 ORA,r 00564 void do_op_B3() { FETCH_E(); OP_ORA(); STORE_A(); } // B3 ORA,r 00565 void do_op_B4() { FETCH_H(); OP_ORA(); STORE_A(); } // B4 ORA,r 00566 void do_op_B5() { FETCH_L(); OP_ORA(); STORE_A(); } // B5 ORA,r 00567 void do_op_B6() { FETCH_MHL(); OP_ORA(); STORE_A(); } // B6 ORA,r 00568 void do_op_B7() { FETCH_A(); OP_ORA(); STORE_A(); } // B7 ORA,r 00569 void do_op_B8() { FETCH_B(); OP_SUBFA(); STORE_NOP(); } // B8 CPA,r 00570 void do_op_B9() { FETCH_C(); OP_SUBFA(); STORE_NOP(); } // B9 CPA,r 00571 void do_op_BA() { FETCH_D(); OP_SUBFA(); STORE_NOP(); } // BA CPA,r 00572 void do_op_BB() { FETCH_E(); OP_SUBFA(); STORE_NOP(); } // BB CPA,r 00573 void do_op_BC() { FETCH_H(); OP_SUBFA(); STORE_NOP(); } // BC CPA,r 00574 void do_op_BD() { FETCH_L(); OP_SUBFA(); STORE_NOP(); } // BD CPA,r 00575 void do_op_BE() { FETCH_MHL(); OP_SUBFA(); STORE_NOP(); } // BE CPA,r 00576 void do_op_BF() { FETCH_A(); OP_SUBFA(); STORE_NOP(); } // BF CPA,r 00577 void do_op_C0() { FETCH_NOP(); OP_IFNZ(); STORE_RET(); } // C0 RETNZ 00578 void do_op_C1() { FETCH_NOP(); OP_POP16(); STORE_BC(); } // C1 POPBC 00579 void do_op_C2() { FETCH_DIR16(); OP_IFNZ(); STORE_PC(); } // C2 nnnnJPNZ,nn 00580 void do_op_C3() { FETCH_DIR16(); OP_NOP(); STORE_PC(); } // C3 nnnnJPnn 00581 void do_op_C4() { FETCH_DIR16(); OP_IFNZ(); STORE_CALL(); } // C4 nnnnCALLNZ,nn 00582 void do_op_C5() { FETCH_BC(); OP_PUSH16(); STORE_NOP(); } // C5 PUSHBC 00583 void do_op_C6() { FETCH_DIR8(); OP_ADDA(); STORE_A(); } // C6 nnADDA,n 00584 void do_op_C7() { FETCH_RST(); OP_NOP(); STORE_CALL(); } // C7 RST0 00585 void do_op_C8() { FETCH_NOP(); OP_IFZ(); STORE_RET(); } // C8 RETZ 00586 void do_op_C9() { FETCH_NOP(); OP_NOP(); STORE_RET(); } // C9 RET 00587 void do_op_CA() { FETCH_DIR16(); OP_IFZ(); STORE_PC(); } // CA nnnnJPZ,nn 00588 void do_op_CB() { FETCH_NOP(); OP_INV(); STORE_NOP(); } // CB (Z80specific) 00589 void do_op_CC() { FETCH_DIR16(); OP_IFZ(); STORE_CALL(); } // CC nnnnCALLZ,nn 00590 void do_op_CD() { FETCH_DIR16(); OP_NOP(); STORE_CALL(); } // CD nnnnCALLnn 00591 void do_op_CE() { FETCH_DIR8(); OP_ADCA(); STORE_A(); } // CE nnADCA,n 00592 void do_op_CF() { FETCH_RST(); OP_NOP(); STORE_CALL(); } // CF RST8H 00593 void do_op_D0() { FETCH_NOP(); OP_IFNC(); STORE_RET(); } // D0 RETNC 00594 void do_op_D1() { FETCH_NOP(); OP_POP16(); STORE_DE(); } // D1 POPDE 00595 void do_op_D2() { FETCH_DIR16(); OP_IFNC(); STORE_PC(); } // D2 nnnnJPNC,nn 00596 void do_op_D3() { FETCH_DIR8(); OP_OUTA(); STORE_NOP(); } // D3 nnOUT(n),A 00597 void do_op_D4() { FETCH_DIR16(); OP_IFNC(); STORE_CALL(); } // D4 nnnnCALLNC,nn 00598 void do_op_D5() { FETCH_DE(); OP_PUSH16(); STORE_NOP(); } // D5 PUSHDE 00599 void do_op_D6() { FETCH_DIR8(); OP_SUBFA(); STORE_A(); } // D6 nnSUBn 00600 void do_op_D7() { FETCH_RST(); OP_NOP(); STORE_CALL(); } // D7 RST10H 00601 void do_op_D8() { FETCH_NOP(); OP_IFC(); STORE_RET(); } // D8 RETC 00602 void do_op_D9() { FETCH_NOP(); OP_INV(); STORE_NOP(); } // D9 EXX(Z80) 00603 void do_op_DA() { FETCH_DIR16(); OP_IFC(); STORE_PC(); } // DA nnnnJPC,nn 00604 void do_op_DB() { FETCH_DIR8(); OP_INA(); STORE_A(); } // DB nnINA,(n) 00605 void do_op_DC() { FETCH_DIR16(); OP_IFC(); STORE_CALL(); } // DC nnnnCALLC,nn 00606 void do_op_DD() { FETCH_NOP(); OP_INV(); STORE_NOP(); } // DD (Z80) 00607 void do_op_DE() { FETCH_DIR8(); OP_SBCFA(); STORE_A(); } // DE nnSBCA,n 00608 void do_op_DF() { FETCH_RST(); OP_NOP(); STORE_CALL(); } // DF RST18H 00609 void do_op_E0() { FETCH_NOP(); OP_IFPO(); STORE_RET(); } // E0 RETPO 00610 void do_op_E1() { FETCH_NOP(); OP_POP16(); STORE_HL(); } // E1 POPHL 00611 void do_op_E2() { FETCH_DIR16(); OP_IFPO(); STORE_PC(); } // E2 nnnnJPPO,nn 00612 void do_op_E3() { FETCH_MSP(); OP_EXHL(); STORE_MSP(); } // E3 EX(SP),HL 00613 void do_op_E4() { FETCH_DIR16(); OP_IFPO(); STORE_CALL(); } // E4 nnnnCALLPO,nn 00614 void do_op_E5() { FETCH_HL(); OP_PUSH16(); STORE_NOP(); } // E5 PUSHHL 00615 void do_op_E6() { FETCH_DIR8(); OP_ANDA(); STORE_A(); } // E6 nnANDn 00616 void do_op_E7() { FETCH_RST(); OP_NOP(); STORE_CALL(); } // E7 RST20H 00617 void do_op_E8() { FETCH_NOP(); OP_IFPE(); STORE_RET(); } // E8 RETPE 00618 void do_op_E9() { FETCH_HL(); OP_NOP(); STORE_PC(); } // E9 JP(HL) 00619 void do_op_EA() { FETCH_DIR16(); OP_IFPE(); STORE_PC(); } // EA nnnnJPPE,nn 00620 void do_op_EB() { FETCH_DE(); OP_EXHL(); STORE_DE(); } // EB EXDE,HL 00621 void do_op_EC() { FETCH_DIR16(); OP_IFPE(); STORE_CALL(); } // EC nnnnCALLPE,nn 00622 void do_op_ED() { FETCH_NOP(); OP_INV(); STORE_NOP(); } // ED (Z80specific) 00623 void do_op_EE() { FETCH_DIR8(); OP_XORA(); STORE_A(); } // EE nnXORn 00624 void do_op_EF() { FETCH_RST(); OP_NOP(); STORE_CALL(); } // EF RST28H 00625 void do_op_F0() { FETCH_NOP(); OP_IFP(); STORE_RET(); } // F0 RETP 00626 void do_op_F1() { FETCH_NOP(); OP_POP16(); STORE_AF(); } // F1 POPAF 00627 void do_op_F2() { FETCH_DIR16(); OP_IFP(); STORE_PC(); } // F2 nnnnJPP,nn 00628 void do_op_F3() { FETCH_NOP(); OP_DI(); STORE_NOP(); } // F3 DI 00629 void do_op_F4() { FETCH_DIR16(); OP_IFP(); STORE_CALL(); } // F4 nnnnCALLP,nn 00630 void do_op_F5() { FETCH_AF(); OP_PUSH16(); STORE_NOP(); } // F5 PUSHAF 00631 void do_op_F6() { FETCH_DIR8(); OP_ORA(); STORE_A(); } // F6 nnORn 00632 void do_op_F7() { FETCH_RST(); OP_NOP(); STORE_CALL(); } // F7 RST30H 00633 void do_op_F8() { FETCH_NOP(); OP_IFM(); STORE_RET(); } // F8 RETM 00634 void do_op_F9() { FETCH_HL(); OP_NOP(); STORE_SP(); } // F9 LDSP,HL 00635 void do_op_FA() { FETCH_DIR16(); OP_IFM(); STORE_PC(); } // FA nnnnJPM,nn 00636 void do_op_FB() { FETCH_NOP(); OP_EI(); STORE_NOP(); } // FB EI 00637 void do_op_FC() { FETCH_DIR16(); OP_IFM(); STORE_CALL(); } // FC nnnnCALLM,nn 00638 void do_op_FD() { FETCH_NOP(); OP_INV(); STORE_NOP(); } // FD (Z80specific) 00639 void do_op_FE() { FETCH_DIR8(); OP_SUBFA(); STORE_NOP(); } // FE nnCPn 00640 void do_op_FF() { FETCH_RST(); OP_NOP(); STORE_CALL(); } // FF RST38H
Generated on Sat Jul 23 2022 01:21:50 by
1.7.2