Important changes to repositories hosted on mbed.com
Mbed hosted mercurial repositories are deprecated and are due to be permanently deleted in July 2026.
To keep a copy of this software download the repository Zip archive or clone locally using Mercurial.
It is also possible to export all your personal repositories from the account settings page.
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