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