Switche
unknown
c_cpp
a month ago
35 kB
7
Indexable
Never
for(;;) { switch(rom_data[PC++]) { default: case (0x00): printf("NOP"); break; case (0x06): printf("LDBn"); // load B into n (n = 8 bit immediate value) PC+=1; break; case (0x0E): printf("LDCn"); // load C into n (n = 8 bit immediate value) PC+=1; break; case (0x16): printf("LDDn"); PC+=1; break; case (0x1E): printf("LDEn"); PC+=1; break; case (0x26): printf("LDHn"); PC+=1; break; case (0x2E): printf("LDLn"); PC+=1; break; case (0x7F): printf("LDAa"); // Load A into A break; case (0x78): printf("LDAb"); // Load B into A PC+=1; break; case (0x79): printf("LDAc"); // Load C into A break; case (0x7A): printf("LDAd"); // Load D into A break; case (0x7B): printf("LDAe"); // Load E into A break; case (0x7C): printf("LDAh"); // load H into A break; case (0x7D): printf("LDAl"); // load L into A break; case (0x7E): printf("LDAhl"); // load HL into A, 8 cycles PC+=1; break; case (0x40): printf("LDBb"); // load B into B break; case (0x41): printf("LDBc"); // load C into B break; case (0x42): printf("LDBd"); // load D into B break; case (0x43): printf("LDBe"); // load E into B break; case (0x44): printf("LDBh"); // load H into B break; case (0x45): printf("LDBl"); // load L into B break; case (0x46): printf("LDBhl"); // load HL into B, 8 cycles PC+=1; break; case (0x48): printf("LDCb"); // load B into C break; case (0x49): printf("LDCc"); // load C into C break; case (0x4A): printf("LDCd"); // load D into C break; case (0x4B): printf("LDCe"); // load E into C break; case (0x4C): printf("LDCh"); // load H into C break; case (0x4D): printf("LDCl"); // load L into C break; case (0x4E): printf("LDChl"); // load HL into C, 8 cycles PC+=1; break; case (0x50): printf("LDDb"); // load B into D break; case (0x51): printf("LDDc"); // load C into D break; case (0x52): printf("LDDd"); // load D into D break; case (0x53): printf("LDDe"); // load E into D break; case (0x54): printf("LDDh"); // load H into D break; case (0x55): printf("LDDl"); // load L into D break; case (0x56): printf("LDDhl"); // load HL into D PC+=1; break; case (0x58): printf("LDEb"); // load B into E break; case (0x59): printf("LDEc"); // load C into E break; case (0x5A): printf("LDEd"); // load D into E break; case (0x5B): printf("LDEe"); // load E into E break; case (0x5C): printf("LDEh"); // load H into E break; case (0x5D): printf("LDEl"); // load L into E break; case (0x5E): printf("LDEhl"); // load HL into E PC+=1; break; case (0x60): printf("LDHb"); // load B into H break; case (0x61): printf("LDHc"); // load C into H break; case (0x62): printf("LDHd"); // load D into H break; case (0x63): printf("LDHe"); // load E into H break; case (0x64): printf("LDHh"); // load H into H break; case (0x65): printf("LDHl"); // load L into H PC+=1; break; case (0x66): printf("LDHhl"); // load HL into H PC+=1; break; case (0x68): printf("LDLb"); // load B into L break; case (0x69): printf("LDLc"); // load C into L break; case (0x6A): printf("LDLd"); // load D into L break; case (0x6B): printf("LDLe"); // load E into L break; case (0x6C): printf("LDLh"); // load H into L break; case (0x6D): printf("LDLl"); // load L into L break; case (0x6E): printf("LDLlh"); // load HL into L PC+=1; break; case (0x70): printf("LDHLb"); // load B into HL PC+=1; break; case (0x71): printf("LDHLc"); // load C into HL PC+=1; break; case (0x72): printf("LDHLd"); // load D into HL PC+=1; break; case (0x73): printf("LDHLe"); // load E into HL PC+=1; break; case (0x74): printf("LDHLh"); // load H into HL PC+=1; break; case (0x75): printf("LDHLl"); // load L into HL PC+=1; break; case (0x36): printf("LDHLn"); // load n into HL PC+=1; break; case (0x0A): printf("LDAbc"); // load BC into A break; case (0x1A): printf("LDAde"); // load DE into A break; case (0xFA): printf("LDAnn"); // load two byte immediate value into A, LS byte first PC+=2; break; case (0x3E): printf("LDA#"); // load 1 byte immediate value into A (To confirm) PC+=1; break; case (0x47): printf("LDBa"); // load A into B break; case (0x4F): printf("LDCa"); // load A into C break; case (0x57): printf("LDDa"); // load A into D break; case (0x5F): printf("LDEa"); // load A into E break; case (0x67): printf("LDHa"); // load A into H break; case (0x6F): printf("LDLa"); // load A into L break; case (0x02): printf("LDBCa"); // load A into BC break; case (0x12): printf("LDDEa"); // load A into DE break; case (0x77): printf("LDHLa"); // load A into HL break; case (0xEA): printf("LDnnA"); // load A into nn (16 bits address) PC+=2; break; case (0xF2): printf("LDA[C]"); // Put value at address $FF00 + register C into A. break; case (0xE2): printf("LDC[A]"); // Put A into address $FF00 + register C break; case (0x3A): printf("LDAhl-"); // Put value at address HL into A. Decrement HL. break; case (0x32): printf("LDHL-a"); //Put A into memory address HL. Decrement HL break; case (0x2A): printf("LDAhl+"); //Put value at address HL into A. Increment HL break; case (0x22): printf("LDHL+a"); //Put A into memory address HL. Increment HL break; case (0xE0): printf("LDAn"); //Put memory address $FF00+n into A. n = one byte immediate value PC+=1; break; case (0x01): printf("LDBCnn"); // Put nn in BC, 16 bits nn PC+=2; break; case (0x11): printf("LDDEnn"); // put nn in DE, 16 bits nn PC+=2; break; case (0x21): printf("LDHLnn"); // put nn in HL, 16 bits nn PC+=2; break; case (0x31): printf("LDSPnn"); // put nn into SP, 16 bits nn PC=+2; break; case (0xF9): printf("LDSPhl"); // Put HL into Stack Pointer (SP) break; case (0xF8): printf("LDHLsp+n"); //Put SP + n effective address into HL, n 1 byte signed immediate value PC+=1; break; case (0x08): printf("LDNNsp"); // put stack pointer (SP) at address nn, nn two byte immediate address PC+=2; break; case (0xF5): printf("PUSHaf"); // Push register pair AF onto stack. Decrement Stack Pointer (SP) twice. break; case (0xC5): printf("PUSHbc"); //Push register pair BC onto stack. Decrement Stack Pointer (SP) twice. break; case (0xD5): printf("PUSHde"); //Push register pair DE onto stack. Decrement Stack Pointer (SP) twice. break; case (0xE5): printf("PUSHhl"); //Push register pair HL onto stack. Decrement Stack Pointer (SP) twice. break; case (0xF1): printf("POPaf"); //Pop two bytes off stack into register pair AF.Increment Stack Pointer (SP) twice. break; case (0xC1): printf("POPbc"); //Pop two bytes off stack into register pair BC.Increment Stack Pointer (SP) twice. break; case (0xD1): printf("POPde"); //Pop two bytes off stack into register pair DE.Increment Stack Pointer (SP) twice. break; case (0xE1): printf("POPhl"); //Pop two bytes off stack into register pair HL.Increment Stack Pointer (SP) twice. break; case (0x87): printf("ADDAb"); // Add A to A break; case (0x80): printf("AddAb"); // break; case (0x81): printf("AddAc"); // break; case (0x82): printf("AddAd"); // break; case (0x83): printf("AddAe"); // break; case (0x84): printf("AddAh"); // break; case (0x85): printf("AddAl"); // break; case (0x86): printf("AddAhl"); // break; case (0xC6): printf("AddA#"); // Add value to A PC+=1; break; case (0x8F): printf("ADCAa"); // Add A + Carry flag to A break; case (0x88): printf("ACDAb"); // Add B + Carry flag to A break; case (0x89): printf("ACDAc"); // break; case (0x8A): printf("ACDAd"); // break; case (0x8B): printf("ACDAe"); // break; case (0x8C): printf("ACDAh"); // break; case (0x8D): printf("ACDAl"); // break; case (0x8E): printf("ACDAhl"); // break; case (0xCE): printf("ACDA#"); // Add value + carry flag to A PC+=1; break; case (0x97): printf("SUBAa"); // substract A from A break; case (0x90): printf("SUBAb"); // break; case (0x91): printf("SUBAc"); // break; case (0x92): printf("SUBAd"); // break; case (0x93): printf("SUBAe"); // break; case (0x94): printf("SUBAh"); // break; case (0x95): printf("SUBAl"); // break; case (0x96): printf("SUBAhl"); // break; case (0xD6): printf("SUBA#"); // sub value from A PC+=1; break; case (0x9F): printf("SBCAa"); // Subtract A + Carry flag from A break; case (0x98): printf("SBCAb"); // break; case (0x99): printf("SBCAc"); // break; case (0x9A): printf("SBCAd"); // break; case (0x9B): printf("SBCAe"); // break; case (0x9C): printf("SBCAh"); // break; case (0x9D): printf("SBCAl"); // break; case (0x9E): printf("SBCAhl"); // break; case (0xA7): printf("ANDA"); // Logically AND A with A, result in A break; case (0xA0): printf("ANDB"); // Logically AND A with B, result in A break; case (0xA1): printf("ANDC"); // break; case (0xA2): printf("ANDD"); // break; case (0xA3): printf("ANDE"); // break; case (0xA4): printf("ANDH"); // break; case (0xA5): printf("ANDL"); // break; case (0xA6): printf("ANDHL"); // break; case (0xE6): printf("AND#"); // Logically AND A with 1 byte value, result in A PC+=1; break; case (0xB7): printf("ORA"); // Logical OR A with register A, result in A. break; case (0xB0): printf("ORB"); // Logical OR B with register A, result in A. break; case (0xB1): printf("ORC"); // break; case (0xB2): printf("ORD"); // break; case (0xB3): printf("ORE"); // break; case (0xB4): printf("ORH"); // break; case (0xB5): printf("ORL"); // break; case (0xB6): printf("ORHL"); // break; case (0xF6): printf("OR#"); // Logical OR value with register A, result in A. PC+=1; break; case (0xAF): printf("XORA"); //Logical exclusive OR A with register A, result in A break; case (0xA8): printf("XORB"); // break; case (0xA9): printf("XORC"); // break; case (0xAA): printf("XORD"); // break; case (0xAB): printf("XORE"); // break; case (0xAC): printf("XORH"); // break; case (0xAD): printf("XORL"); // break; case (0xAE): printf("XORHL"); // break; case (0xEE): printf("XOR#"); // PC+=1; break; case (0xBF): printf("CPA"); //Compare A with n. This is basically an A - A subtraction instruction but the results are thrown away. break; case (0xB8): printf("CPB"); // break; case (0xB9): printf("CPC"); // break; case (0xBA): printf("CPD"); // break; case (0xBB): printf("CPE"); // break; case (0xBC): printf("CPH"); // break; case (0xBD): printf("CPL"); // break; case (0xBE): printf("CPHL"); // break; case (0xFE): printf("CP#"); // PC+=1; break; case (0x3C): printf("INCA"); // increment register A break; case (0x04): printf("INCB"); // break; case (0x0C): printf("INCC"); // break; case (0x14): printf("INCD"); // break; case (0x1C): printf("INCE"); // break; case (0x24): printf("INCH"); // break; case (0x2C): printf("INCL"); // break; case (0x34): printf("INCHL"); // break; case (0x3D): printf("DECA"); // Decrement register A break; case (0x05): printf("DECB"); // break; case (0x0D): printf("DECC"); // break; case (0x15): printf("DECD"); // break; case (0x1D): printf("DECE"); // break; case (0x25): printf("DECH"); // break; case (0x2D): printf("DECL"); // break; case (0x35): printf("DECHL"); // break; case (0x09): printf("ADDHLbc"); // Add BC to HL break; case (0x19): printf("ADDHLde"); // break; case (0x29): printf("ADDHLhl"); // break; case (0x39): printf("ADDHlsp"); // break; case (0xE8): printf("ADDSPn"); //Add n to Stack Pointer (SP). n = one byte signed immediate value (#). PC+=1; break; case (0x03): printf("INCBC"); // Increment register BC break; case (0x13): printf("INCDE"); // break; case (0x23): printf("INCHL"); // break; case (0x33): printf("INCSP"); // break; case (0x0B): printf("DECBC"); // Increment register BC break; case (0x1B): printf("DECDE"); // break; case (0x2B): printf("DECHL"); // break; case (0x3B): printf("DECSP"); // break; case (0xCB37): printf("SWAPA"); // Swap upper & lower nibles of A break; case (0xCB30): printf("SWAPB"); // break; case (0xCB31): printf("SWAPC"); // break; case (0xCB32): printf("SWAPD"); // break; case (0xCB33): printf("SWAPE"); // break; case (0xCB34): printf("SWAPH"); // break; case (0xCB35): printf("SWAPL"); // break; case (0xCB36): printf("SWAPHL"); // break; case (0x27): printf("DAA"); //Decimal adjust register A. This instruction adjusts register A so that the correct representation of Binary Coded Decimal (BCD) is obtained. break; case (0x2F): printf("CPL"); // Complement A register. (Flip all bits.) break; case (0x3F): printf("CCF"); //Complement carry flag. If C flag is set, then reset it. If C flag is reset, then set it. break; case (0x37): printf("SCF"); // Set Carry flag. break; case (0x76): printf("HALT"); //power down CPU until an interrupt occurs. Use this whenever possible to reduce energy consumption. break; case (0x10): printf("STOP"); // Halt CPU & LCD display until button pressed. break; case (0xF3): printf("DI"); //This instruction disables interrupts but not immediately. Interrupts are disabled after instruction after DI is executed. break; case (0xFB): printf(""); //Enable interrupts. This intruction enables interrupts but not immediately. Interrupts are enabled after instruction after EI is executed. break; case (0x07): printf("RLCA"); // Rotate A left. Old bit 7 to Carry flag. break; case (0x17): printf("RLA"); // Rotate A left through Carry flag break; case (0x0F): printf("RRCA"); // Rotates A right. Old bit 0 to Carry flag break; case (0x1F): printf("RRA"); // Rotate A right through carry flag break; case (0xCB07): printf("RLCA"); // Rotate A left. Old bit 7 to Carry flag. PC+=1; break; case (0xCB00): printf("RLCB"); // PC+=1; break; case (0xCB01): printf("RLCC"); // PC+=1; break; case (0xCB02): printf("RLCD"); // PC+=1; break; case (0xCB03): printf("RLCE"); // PC+=1; break; case (0xCB04): printf("RLCH"); // PC+=1; break; case (0xCB05): printf("RLCL"); // PC+=1; break; case (0xCB06): printf("RLCHL"); // PC+=1; break; case (0xCB17): printf("RLA"); // Rotate A left through Carry flag. PC+=1; break; case (0xCB10): printf("RLB"); // PC+=1; break; case (0xCB11): printf("RLC"); // PC+=1; break; case (0xCB12): printf("RLD"); // PC+=1; break; case (0xCB13): printf("RLE"); // PC+=1; break; case (0xCB14): printf("RLH"); // PC+=1; break; case (0xCB15): printf("RLL"); // PC+=1; break; case (0xCB16): printf("RLHL"); // PC+=1; break; case (0xCB0F): printf("RRCA"); // Rotate A right. Old bit 0 to Carry flag. PC+=1; break; case (0xCB08): printf("RRCB"); // PC+=1; break; case (0xCB09): printf("RRCC"); // PC+=1; break; case (0xCB0A): printf("RRCD"); // PC+=1; break; case (0xCB0B): printf("RRCE"); // PC+=1; break; case (0xCB0C): printf("RRCH"); // PC+=1; break; case (0xCB0D): printf("RRCL"); // PC+=1; break; case (0xCB0E): printf("RRCHL"); // PC+=1; break; case (0xCB1F): printf("RRA"); //Rotate A right through Carry flag. PC+=1; break; case (0xCB18): printf("RRB"); // PC+=1; break; case (0xCB19): printf("RRC"); // PC+=1; break; case (0xCB1A): printf("RRD"); // PC+=1; break; case (0xCB1B): printf("RRE"); // PC+=1; break; case (0xCB1C): printf("RRH"); // PC+=1; break; case (0xCB1D): printf("RRL"); // PC+=1; break; case (0xCB1E): printf("RRHL"); // PC+=1; break; case (0xCB27): printf("SLAA"); //Shift A left into Carry. LSB of n set to 0. PC+=1; break; case (0xCB20): printf("SLAB"); // PC+=1; break; case (0xCB21): printf("SLAC"); // PC+=1; break; case (0xCB22): printf("SLAD"); // PC+=1; break; case (0xCB23): printf("SLAE"); // PC+=1; break; case (0xCB24): printf("SLAH"); // PC+=1; break; case (0xCB25): printf("SLAL"); // PC+=1; break; case (0xCB26): printf("SLAHL"); // PC+=1; break; case (0xCB2F): printf("SRAA"); // Shift A right into Carry. MSB doesn't change PC+=1; break; case (0xCB28): printf("SRAB"); // PC+=1; break; case (0xCB29): printf("SRAC"); // PC+=1; break; case (0xCB2A): printf("SRAD"); // PC+=1; break; case (0xCB2B): printf("SRAE"); // PC+=1; break; case (0xCB2C): printf("SRAH"); // PC+=1; break; case (0xCB2D): printf("SRAL"); // PC+=1; break; case (0xCB2E): printf("SRAHL"); // PC+=1; break; case (0xCB3F): printf("SRLA"); // Shift A right into Carry. MSB set to 0 PC+=1; break; case (0xCB38): printf("SRLB"); // PC+=1; break; case (0xCB39): printf("SRLC"); // PC+=1; break; case (0xCB3A): printf("SRLD"); // PC+=1; break; case (0xCB3B): printf("SRLE"); // PC+=1; break; case (0xCB3C): printf("SRLH"); // PC+=1; break; case (0xCB3D): printf("SRLL"); // PC+=1; break; case (0xCB3E): printf("SRLHL"); // PC+=1; break; case (0xCB47): printf("BITbA"); // Test bit b in register A. b = [0;7] PC+=1; break; case (0xCB40): printf("BitbB"); // PC+=1; break; case (0xCB41): printf("BitbC"); // PC+=1; break; case (0xCB42): printf("BitbD"); // PC+=1; break; case (0xCB43): printf("bitbE"); // PC+=1; break; case (0xCB44): printf("bitbH"); // PC+=1; break; case (0xCB45): printf("bitbL"); // PC+=1; break; case (0xCB46): printf("bitbHL"); // PC+=1; break; case (0xCBC7): printf("SETAb"); // Set bit b in register A. B = [0-7] PC+=1; break; case (0xCBC0): printf("SETBb"); // PC+=1; break; case (0xCBC1): printf("SETCb"); // PC+=1; break; case (0xCBC2): printf("SETDb"); // PC+=1; break; case (0xCBC3): printf("SETEb"); // PC+=1; break; case (0xCBC4): printf("SETHb"); // PC+=1; break; case (0xCBC5): printf("SETLb"); // PC+=1; break; case (0xCBC6): printf("SETHLb"); // PC+=1; break; case (0xCB87): printf("RESAb"); // Reset bit b in register r. B =[0-7] PC+=1; break; case (0xCB80): printf("RESBb"); // PC+=1; break; case (0xCB81): printf("RESCb"); // PC+=1; break; case (0xCB82): printf("RESDb"); // PC+=1; break; case (0xCB83): printf("RESEb"); // PC+=1; break; case (0xCB84): printf("RESHb"); // PC+=1; break; case (0xCB85): printf("RESLb"); // PC+=1; break; case (0xCB86): printf("RESHLb"); // PC+=1; break; case (0xC3): printf("JPnn"); // Jump to address nn, nn = two byte immediate value. (LS byte first.) PC+=2; break; case (0xC2): printf("JPNZ"); /* Jump to address n if following condition is true: cc = NZ, Jump if Z flag is reset. cc = Z, Jump if Z flag is set. cc = NC, Jump if C flag is reset. cc = C, Jump if C flag is set. */ PC+=2; break; case (0xCA): printf("JPZ"); // PC+=2; break; case (0xD2): printf("JPNC"); // PC+=2; break; case (0xDA): printf("JPC"); // PC+=2; break; case (0xE9): printf("JPHL"); // Jump to address contained in HL. break; case (0x18): printf("JRn"); // Add n to current address and jump to it. n = one byte signed immediate value PC+=1; break; case (0x20): printf("JRNZn"); /* If following condition is true then add n to current address and jump to it: n = one byte signed immediate value cc = NZ, Jump if Z flag is reset. cc = Z, Jump if Z flag is set. cc = NC, Jump if C flag is reset. cc = C, Jump if C flag is set. */ PC+=1; break; case (0x28): printf("JRZn"); // PC+=1; break; case (0x30): printf("JRNCn"); // PC+=1; break; case (0x38): printf("JRCn"); // PC+=1; break; case (0xCD): printf("CALLnn"); //Push address of next instruction onto stack and then jump to address nn. nn = two byte immediate value. (LS byte first.) PC+=2; break; case (0xC4): printf("CALLNZnn"); /*Call address n if following condition is true: cc = NZ, Call if Z flag is reset. cc = Z, Call if Z flag is set. cc = NC, Call if C flag is reset. cc = C, Call if C flag is set.*/ PC+=2; break; case (0xCC): printf("CALLZnn"); // PC+=2; break; case (0xD4): printf("CALLNCnn"); // PC+=2; break; case (0xDC): printf("CALLCnn"); // PC+=2; break; case (0xC7): printf("RST00H"); /* Description: Push present address onto stack. Jump to address $0000 + n. Use with: n = $00,$08,$10,$18,$20,$28,$30,$38*/ break; case (0xCF): printf("RST08H"); // break; case (0xD7): printf("RST10H"); // break; case (0xDF): printf("RST18H"); // break; case (0xE7): printf("RST20H"); // break; case (0xEF): printf("RST28H"); // break; case (0xF7): printf("RST30H"); // break; case (0xFF): printf("RST38H"); // break; case (0xC9): printf("RET"); // Pop two bytes from stack & jump to that address break; case (0xC0): printf("RETNZ"); // Return if Z flag is reset break; case (0xC8): printf("RETZ"); // Return if Z flag is set. break; case (0xD0): printf("RETNC"); // Return if C flag is reset. break; case (0xD8): printf("RETC"); // Return if C flag is set. break; case (0xD9): printf("RETI"); //Pop two bytes from stack & jump to that address then enable interrupts. break; }