From 83e8a4494741e6257b18267a58fe8ae342e3229f Mon Sep 17 00:00:00 2001 From: alekseiplusplus Date: Fri, 21 Apr 2023 16:12:16 +1000 Subject: changed dirs, now testing instructions. --- ToDo | 12 +- headers/6502.h | 113 +++++++++++++++++++ headers/addressing.h | 2 +- headers/apple.h | 6 + headers/applesystem.h | 113 ------------------- headers/debug.h | 12 +- headers/include.h | 5 +- headers/instruction-bin.h | 241 --------------------------------------- headers/instruction-init.h | 97 ---------------- headers/instruction-table.h | 266 ++++++++++++++++++++++++++++++++++++++++++++ headers/instructions-init.h | 70 ++++++++++++ headers/instructions.h | 23 ++-- inbin | Bin 30760 -> 0 bytes interpreter.c | 13 +-- test.c | 20 ++-- 15 files changed, 498 insertions(+), 495 deletions(-) create mode 100644 headers/6502.h create mode 100644 headers/apple.h delete mode 100644 headers/applesystem.h delete mode 100644 headers/instruction-bin.h delete mode 100644 headers/instruction-init.h create mode 100644 headers/instruction-table.h create mode 100644 headers/instructions-init.h delete mode 100755 inbin diff --git a/ToDo b/ToDo index 74d2dfa..97814ca 100644 --- a/ToDo +++ b/ToDo @@ -1,12 +1,8 @@ Before the next commit, this should all be completed. -First and foremost, make sure reading is possible. +Go through instruction.h and fix every instruction to work with data structures + + -Create the makefile. -Fix directory structures and header files before it gets even messier. -Delete unnecessary files. -Fix up the instruction dump file. -Expand the names of any acronyms, like IT Figure out simple threading in C to run other programs within the same address space. Perhaps use this to let the emulator run as an engine, which is interfaced by swappable clients, such as the SDL terminal emulator, terminal, and instruction interpreter clients. - Following on from this, functions like a computer hard reset may be useful. -Unstage a.out. \ No newline at end of file + Following on from this, functions like a computer hard reset may be useful. \ No newline at end of file diff --git a/headers/6502.h b/headers/6502.h new file mode 100644 index 0000000..ea92479 --- /dev/null +++ b/headers/6502.h @@ -0,0 +1,113 @@ +// 6502.h +// Core elements of the 6502 CPU + +typedef unsigned char byte; +typedef unsigned short address; +byte acc, X, Y, P, S = 0x00; +address PC = 0x0000; +byte Memory[4096]; // TO DO. Add expansion capability to memory. + +// FLAGS +#define flag_N 0x80 // Negative +#define flag_V 0x40 // Overflow +#define flag_B 0x10 // BRK command +#define flag_D 0x08 // Decimal mode +#define flag_I 0x04 // IRQ disable +#define flag_Z 0x02 // Zero +#define flag_C 0x01 // Carry + +byte getFlag(byte flag) { + return ((P & flag) == flag) ? 1 : 0; +} + +void setFlag(byte flag, int x) { + if (x == 1){ + if ((P & flag) == 0x0) P += flag; + }else if (x == 0){ + if ((P & flag) == flag) P -= flag; + } + else{ + fprintf(stderr, "setFlag() passed arg neither 0 or 1"); + } +} + +void flagSet(byte flag){ + P |= flag; +} + +void flagClear(byte flag){ + P &= ~flag; +} + + +// BCD +// need to actually look into BCD on the 6502 +byte toBCD(byte x){ + if (x < 100){ + byte a = ((x / 10) << 4); + byte b = (x % 10); + return (a + b); + } + else{ + fprintf(stderr, "Number greater than 99 passed to toBCD()"); + } +} + +byte fromBCD(byte x){ + byte a = ((x >> 4) * 10); + byte b = (x & 0xF); + return (a + b); +} + + +// Functions which perform reusable routines for finding if a specific flag should be set. + +void setFlagN(byte x){ + if (x & flag_N == flag_N) + setFlag(flag_N, 1); + else + setFlag(flag_N, 0); +} + +//Perform prior to any changes +void setFlagV(byte x, byte y){ + if ((x & flag_N) == (y & flag_N)){ + if (((x + y) & (flag_N ^ 0xFF)) > 0x7F) setFlag(flag_V, 1); + else setFlag(flag_V, 0); + }else{ + if (((x - y) & (flag_N ^ 0xFF)) > 0x7F) setFlag(flag_V, 1); + else setFlag(flag_V, 0); + } +} + +/*void setFlagB(){ //WORK ON + setFlag(flag_B, 1); +}*/ //Dont really need since its dependent on the BRK insturction + +/*void setFlagD(){ + setFlag(flag_D, 1); +}*/ + +/*void setFlagI(){ //WORK ON + setFlag(flag_Z, 1); +}*/ + +void setFlagZ(int x){ + if (x == 0) + setFlag(flag_Z, 1); + else + setFlag(flag_Z, 0); +} + +//Only 6 instructions, 2 not including stack instructions, use the carry flag. +// Need to look further into implementation details for this. +/*void setFlagC(){ + setFlag(flag_Z, 1); +}*/ + + + + + + + diff --git a/headers/addressing.h b/headers/addressing.h index d9d8e98..58df3f5 100644 --- a/headers/addressing.h +++ b/headers/addressing.h @@ -28,7 +28,7 @@ struct AddData{ typedef struct AddData AddData; -#include"instruction-init.h" +#include"instructions-init.h" //Holds address of current instruction. void* current_instruction; diff --git a/headers/apple.h b/headers/apple.h new file mode 100644 index 0000000..f5cac5c --- /dev/null +++ b/headers/apple.h @@ -0,0 +1,6 @@ +#define MEMORY_SIZE 4096 + +void AppleOn(){ + //Memory = malloc(MEMORY_SIZE); + initInstructionTable(); +} \ No newline at end of file diff --git a/headers/applesystem.h b/headers/applesystem.h deleted file mode 100644 index 6b2f818..0000000 --- a/headers/applesystem.h +++ /dev/null @@ -1,113 +0,0 @@ -// applesystem.h -// Core elements of the 6502 CPU, and flag manipulation. - -typedef unsigned char byte; -typedef unsigned short address; -byte acc, X, Y, P, S = 0x00; -address PC = 0x0000; -byte Memory[4096]; // TO DO. Add expansion capability to memory. - -// FLAGS -const byte flag_N = 0x80; // Negative -const byte flag_V = 0x40; // Overflow -const byte flag_B = 0x10; // BRK command -const byte flag_D = 0x08; // Decimal mode -const byte flag_I = 0x04; // IRQ disable -const byte flag_Z = 0x02; // Zero -const byte flag_C = 0x01; // Carry - -byte getFlag(byte flag) { - return ((P & flag) == flag) ? 1 : 0; -} - -void setFlag(byte flag, int x) { //OVERLOAD TO ACCEPT INT AS WELL - if (x == 1){ - if ((P & flag) == 0x0) P += flag; - }else if (x == 0){ - if ((P & flag) == flag) P -= flag; - } - else{ - fprintf(stderr, "setFlag() passed arg neither 0 or 1"); - } -} - -void flagSet(byte flag){ - P |= flag; -} - -void flagClear(byte flag){ - P &= ~flag; -} - - -// BCD -// need to actually look into BCD on the 6502 -byte toBCD(byte x){ - if (x < 100){ - byte a = ((x / 10) << 4); - byte b = (x % 10); - return (a + b); - } - else{ - fprintf(stderr, "Number greater than 99 passed to toBCD()"); - } -} - -byte fromBCD(byte x){ - byte a = ((x >> 4) * 10); - byte b = (x & 0xF); - return (a + b); -} - - -// Functions which perform reusable routines for finding if a specific flag should be set. - -void setFlagN(byte x){ - if (x & flag_N == flag_N) - setFlag(flag_N, 1); - else - setFlag(flag_N, 0); -} - -//Perform prior to any changes -void setFlagV(byte x, byte y){ - if ((x & flag_N) == (y & flag_N)){ - if (((x + y) & (flag_N ^ 0xFF)) > 0x7F) setFlag(flag_V, 1); - else setFlag(flag_V, 0); - }else{ - if (((x - y) & (flag_N ^ 0xFF)) > 0x7F) setFlag(flag_V, 1); - else setFlag(flag_V, 0); - } -} - -/*void setFlagB(){ //WORK ON - setFlag(flag_B, 1); -}*/ //Dont really need since its dependent on the BRK insturction - -/*void setFlagD(){ - setFlag(flag_D, 1); -}*/ - -/*void setFlagI(){ //WORK ON - setFlag(flag_Z, 1); -}*/ - -void setFlagZ(int x){ - if (x == 0) - setFlag(flag_Z, 1); - else - setFlag(flag_Z, 0); -} - -//Only 6 instructions, 2 not including stack instructions, use the carry flag. -// Need to look further into implementation details for this. -/*void setFlagC(){ - setFlag(flag_Z, 1); -}*/ - - - - - - - diff --git a/headers/debug.h b/headers/debug.h index bb6ba40..cb34dac 100644 --- a/headers/debug.h +++ b/headers/debug.h @@ -33,9 +33,11 @@ void dPageDump(short m){ // Dump CPU values void dStatusDump(void){ - printf(" acc:\t%x\n X:\t%x\n Y:\t%x\nstack:\t%x\nflags:\t%x\n", acc, X, Y, S, P); +printf("\ +..acc:\t%x\tcycles:\t%d\n\ +....X:\t%x\tlength:\t%d\n\ +....Y:\t%x\t...add:\t%x\n\ +stack:\t%x\t.value:\t%x\n\ +flags:\t%x\n\ +", acc, idata.cycles, X, idata.length, Y, idata.add, S, idata.value, P); } - -void dIdataDump(void){ - printf("cycles:\t%d\nlength:\t%d\n add:\t%x\n value:\t%x\n", idata.cycles, idata.length, idata.add, idata.value); -} \ No newline at end of file diff --git a/headers/include.h b/headers/include.h index e2578de..c4a2ef8 100644 --- a/headers/include.h +++ b/headers/include.h @@ -2,7 +2,8 @@ #include"stdint.h" #include"stdlib.h" #include"string.h" -#include"applesystem.h" +#include"6502.h" #include"addressing.h" #include"instructions.h" -#include"instruction-bin.h" \ No newline at end of file +#include"instruction-table.h" +#include"apple.h" \ No newline at end of file diff --git a/headers/instruction-bin.h b/headers/instruction-bin.h deleted file mode 100644 index 0127fd7..0000000 --- a/headers/instruction-bin.h +++ /dev/null @@ -1,241 +0,0 @@ -void setInstructionTable(int i, uintptr_t p, Addressing r){ - uintptr_t* p1 = (InstructionTable + (sizeof(uintptr_t)*i)); - *p1 = p; - - Addressing* r1 = (InstructionTable + (sizeof(uintptr_t)*256) + (sizeof(Addressing)*i)); - *r1 = r; -} - -void initInstructionTable(){ - InstructionTable = malloc(InstructionTableSize); - // Load and Store Instructions - // fLDA(Addressing, address); - setInstructionTable(0xA9, (uintptr_t)&fLDA, eImmediate); - setInstructionTable(0xA5, (uintptr_t)&fLDA, eZeroPage); - setInstructionTable(0xB5, (uintptr_t)&fLDA, eZeroPageIndexedX); - setInstructionTable(0xAD, (uintptr_t)&fLDA, eAbsolute); - setInstructionTable(0xBD, (uintptr_t)&fLDA, eAbsoluteIndexedX); - setInstructionTable(0xB9, (uintptr_t)&fLDA, eAbsoluteIndexedY); - setInstructionTable(0xA1, (uintptr_t)&fLDA, eIndexedIndirect); - setInstructionTable(0xB1, (uintptr_t)&fLDA, eIndirectIndexed); - // fLDX(Addressing, address); - setInstructionTable(0xA2, (uintptr_t)&fLDX, eImmediate); - setInstructionTable(0xA6, (uintptr_t)&fLDX, eZeroPage); - setInstructionTable(0xB6, (uintptr_t)&fLDX, eZeroPageIndexedY); - setInstructionTable(0xAE, (uintptr_t)&fLDX, eAbsolute); - setInstructionTable(0xBE, (uintptr_t)&fLDX, eAbsoluteIndexedY); - // fLDY(Addressing, address); - setInstructionTable(0xA0, (uintptr_t)&fLDY, eImmediate); - setInstructionTable(0xA4, (uintptr_t)&fLDY, eZeroPage); - setInstructionTable(0xB4, (uintptr_t)&fLDY, eZeroPageIndexedX); - setInstructionTable(0xAC, (uintptr_t)&fLDY, eAbsolute); - setInstructionTable(0xBC, (uintptr_t)&fLDY, eAbsoluteIndexedX); - // fSTA(Addressing, address); - setInstructionTable(0x85, (uintptr_t)&fSTA, eZeroPage); - setInstructionTable(0x95, (uintptr_t)&fSTA, eZeroPageIndexedX); - setInstructionTable(0x8D, (uintptr_t)&fSTA, eAbsolute); - setInstructionTable(0x9D, (uintptr_t)&fSTA, eAbsoluteIndexedX); - setInstructionTable(0x99, (uintptr_t)&fSTA, eAbsoluteIndexedY); - setInstructionTable(0x81, (uintptr_t)&fSTA, eIndexedIndirect); - setInstructionTable(0x91, (uintptr_t)&fSTA, eIndirectIndexed); - // fSTX(Addressing, address); - setInstructionTable(0x86, (uintptr_t)&fSTX, eZeroPage); - setInstructionTable(0x96, (uintptr_t)&fSTX, eZeroPageIndexedX); - setInstructionTable(0x8E, (uintptr_t)&fSTX, eAbsolute); - // fSTY(Addressing, address); - setInstructionTable(0x84, (uintptr_t)&fSTY, eZeroPage); - setInstructionTable(0x94, (uintptr_t)&fSTY, eZeroPageIndexedY); - setInstructionTable(0x8C, (uintptr_t)&fSTY, eAbsolute); - - // Arithmetic Instructions - // fADC(Addressing, address); - setInstructionTable(0x69, (uintptr_t)&fADC, eImmediate); - setInstructionTable(0x65, (uintptr_t)&fADC, eZeroPage); - setInstructionTable(0x75, (uintptr_t)&fADC, eZeroPageIndexedX); - setInstructionTable(0x6D, (uintptr_t)&fADC, eAbsolute); - setInstructionTable(0x7D, (uintptr_t)&fADC, eAbsoluteIndexedX); - setInstructionTable(0x79, (uintptr_t)&fADC, eAbsoluteIndexedY); - setInstructionTable(0x61, (uintptr_t)&fADC, eIndexedIndirect); - setInstructionTable(0x71, (uintptr_t)&fADC, eIndirectIndexed); - // fSBC(Addressing, address); - setInstructionTable(0xE9, (uintptr_t)&fSBC, eImmediate); - setInstructionTable(0xE5, (uintptr_t)&fSBC, eZeroPage); - setInstructionTable(0xF5, (uintptr_t)&fSBC, eZeroPageIndexedX); - setInstructionTable(0xED, (uintptr_t)&fSBC, eAbsolute); - setInstructionTable(0xFD, (uintptr_t)&fSBC, eAbsoluteIndexedX); - setInstructionTable(0xF9, (uintptr_t)&fSBC, eAbsoluteIndexedY); - setInstructionTable(0xE1, (uintptr_t)&fSBC, eIndexedIndirect); - setInstructionTable(0xF1, (uintptr_t)&fSBC, eIndirectIndexed); - - //Increment and Decrement Instructions - //INC(Addressing, address); - setInstructionTable(0xE6, (uintptr_t)&fINC, eZeroPage); - setInstructionTable(0xF6, (uintptr_t)&fINC, eZeroPageIndexedX); - setInstructionTable(0xEE, (uintptr_t)&fINC, eAbsolute); - setInstructionTable(0xFE, (uintptr_t)&fINC, eAbsoluteIndexedX); - //INX(Addressing, address); - setInstructionTable(0xE8, (uintptr_t)&fINX, eImplied); - //INY(Addressing, address); - setInstructionTable(0xC8, (uintptr_t)&fINY, eImplied); - //DEC(Addressing, address); - setInstructionTable(0xC6, (uintptr_t)&fDEC, eZeroPage); - setInstructionTable(0xD6, (uintptr_t)&fDEC, eZeroPageIndexedX); - setInstructionTable(0xCE, (uintptr_t)&fDEC, eAbsolute); - setInstructionTable(0xDE, (uintptr_t)&fDEC, eAbsoluteIndexedX); - //DEX(Addressing, address); - setInstructionTable(0xCA, (uintptr_t)&fDEX, eImplied); - //DEY(Addressing, address); - setInstructionTable(0x88, (uintptr_t)&fDEY, eImplied); - - // Logical Instructions - //AND(Addressing, address); - setInstructionTable(0x29, (uintptr_t)&fAND, eImmediate); - setInstructionTable(0x25, (uintptr_t)&fAND, eZeroPage); - setInstructionTable(0x35, (uintptr_t)&fAND, eZeroPageIndexedX); - setInstructionTable(0x2D, (uintptr_t)&fAND, eAbsolute); - setInstructionTable(0x3D, (uintptr_t)&fAND, eAbsoluteIndexedX); - setInstructionTable(0x39, (uintptr_t)&fAND, eAbsoluteIndexedY); - setInstructionTable(0x21, (uintptr_t)&fAND, eIndexedIndirect); - setInstructionTable(0x31, (uintptr_t)&fAND, eIndirectIndexed); - //ORA(Addressing, address); - setInstructionTable(0x09, (uintptr_t)&fORA, eImmediate); - setInstructionTable(0x05, (uintptr_t)&fORA, eZeroPage); - setInstructionTable(0x15, (uintptr_t)&fORA, eZeroPageIndexedX); - setInstructionTable(0x0D, (uintptr_t)&fORA, eAbsolute); - setInstructionTable(0x1D, (uintptr_t)&fORA, eAbsoluteIndexedX); - setInstructionTable(0x19, (uintptr_t)&fORA, eAbsoluteIndexedY); - setInstructionTable(0x01, (uintptr_t)&fORA, eIndexedIndirect); - setInstructionTable(0x11, (uintptr_t)&fORA, eIndirectIndexed); - //EOR(Addressing, address); - setInstructionTable(0x49, (uintptr_t)&fEOR, eImmediate); - setInstructionTable(0x45, (uintptr_t)&fEOR, eZeroPage); - setInstructionTable(0x55, (uintptr_t)&fEOR, eZeroPageIndexedX); - setInstructionTable(0x4D, (uintptr_t)&fEOR, eAbsolute); - setInstructionTable(0x5D, (uintptr_t)&fEOR, eAbsoluteIndexedX); - setInstructionTable(0x59, (uintptr_t)&fEOR, eAbsoluteIndexedY); - setInstructionTable(0x41, (uintptr_t)&fEOR, eIndexedIndirect); - setInstructionTable(0x51, (uintptr_t)&fEOR, eIndirectIndexed); - - // Jump, Branch, Compare, and Test Bits - //JMP(Addressing, address); - setInstructionTable(0x4C, (uintptr_t)&fJMP, eAbsolute); - setInstructionTable(0x6C, (uintptr_t)&fJMP, eIndirectAbsolute); - //BCC(Addressing, address); - setInstructionTable(0x90, (uintptr_t)&fBCC, eRelative); - //BCS(Addressing, address); - setInstructionTable(0xB0, (uintptr_t)&fBCS, eRelative); - //BEQ(Addressing, address); - setInstructionTable(0xF0, (uintptr_t)&fBEQ, eRelative); - //BNE(Addressing, address); - setInstructionTable(0xD0, (uintptr_t)&fBNE, eRelative); - //BMI(Addressing, address); - setInstructionTable(0x30, (uintptr_t)&fBMI, eRelative); - //BPL(Addressing, address); - setInstructionTable(0x10, (uintptr_t)&fBPL, eRelative); - //BVS(Addressing, address); - setInstructionTable(0x70, (uintptr_t)&fBVS, eRelative); - //BVC(Addressing, address); - setInstructionTable(0x50, (uintptr_t)&fBVC, eRelative); - //CMP(Addressing, address); - setInstructionTable(0xC9, (uintptr_t)&fCMP, eImmediate); - setInstructionTable(0xC5, (uintptr_t)&fCMP, eZeroPage); - setInstructionTable(0xD5, (uintptr_t)&fCMP, eZeroPageIndexedX); - setInstructionTable(0xCD, (uintptr_t)&fCMP, eAbsolute); - setInstructionTable(0xDD, (uintptr_t)&fCMP, eAbsoluteIndexedX); - setInstructionTable(0xD9, (uintptr_t)&fCMP, eAbsoluteIndexedY); - setInstructionTable(0xC1, (uintptr_t)&fCMP, eIndexedIndirect); - setInstructionTable(0xD1, (uintptr_t)&fCMP, eIndirectIndexed); - //CPX(Addressing, address); - setInstructionTable(0xE0, (uintptr_t)&fCPX, eImmediate); - setInstructionTable(0xE4, (uintptr_t)&fCPX, eZeroPage); - setInstructionTable(0xEC, (uintptr_t)&fCPX, eAbsolute); - //CPY(Addressing, address); - setInstructionTable(0xC0, (uintptr_t)&fCPY, eImmediate); - setInstructionTable(0xC4, (uintptr_t)&fCPY, eZeroPage); - setInstructionTable(0xCC, (uintptr_t)&fCPY, eAbsolute); - //BIT(Addressing, address); - setInstructionTable(0x4C, (uintptr_t)&fBIT, eZeroPage); - setInstructionTable(0x6C, (uintptr_t)&fBIT, eAbsolute); - - // Shift and Rotate Instructions - //ASL(Addressing, address); - setInstructionTable(0x0A, (uintptr_t)&fASL, eAccumulator); - setInstructionTable(0x06, (uintptr_t)&fASL, eZeroPage); - setInstructionTable(0x16, (uintptr_t)&fASL, eZeroPageIndexedX); - setInstructionTable(0x0E, (uintptr_t)&fASL, eAbsolute); - setInstructionTable(0x1E, (uintptr_t)&fASL, eAbsoluteIndexedX); - //LSR(Addressing, address); - setInstructionTable(0x4A, (uintptr_t)&fLSR, eAccumulator); - setInstructionTable(0x46, (uintptr_t)&fLSR, eZeroPage); - setInstructionTable(0x56, (uintptr_t)&fLSR, eZeroPageIndexedX); - setInstructionTable(0x4E, (uintptr_t)&fLSR, eAbsolute); - setInstructionTable(0x5E, (uintptr_t)&fLSR, eAbsoluteIndexedX); - //ROL(Addressing, address); - setInstructionTable(0x2A, (uintptr_t)&fROL, eAccumulator); - setInstructionTable(0x26, (uintptr_t)&fROL, eZeroPage); - setInstructionTable(0x36, (uintptr_t)&fROL, eZeroPageIndexedX); - setInstructionTable(0x2E, (uintptr_t)&fROL, eAbsolute); - setInstructionTable(0x3E, (uintptr_t)&fROL, eAbsoluteIndexedX); - //ROR(Addressing, address); - setInstructionTable(0x6A, (uintptr_t)&fROR, eAccumulator); - setInstructionTable(0x66, (uintptr_t)&fROR, eZeroPage); - setInstructionTable(0x76, (uintptr_t)&fROR, eZeroPageIndexedX); - setInstructionTable(0x6E, (uintptr_t)&fROR, eAbsolute); - setInstructionTable(0x7E, (uintptr_t)&fROR, eAbsoluteIndexedX); - - // Transfer Instructions - //TAX(Addressing, address); - setInstructionTable(0xAA, (uintptr_t)&fTAX, eImplied); - //TAY(Addressing, address); - setInstructionTable(0xA8, (uintptr_t)&fTAY, eImplied); - //TXA(Addressing, address); - setInstructionTable(0x8A, (uintptr_t)&fTXA, eImplied); - //TYA(Addressing, address); - setInstructionTable(0x98, (uintptr_t)&fTYA, eImplied); - - // Stack Instructions - //TSX(Addressing, address); - setInstructionTable(0xBA, (uintptr_t)&fTSX, eImplied); - //TXS(Addressing, address); - setInstructionTable(0x9A, (uintptr_t)&fTXS, eImplied); - //PHA(Addressing, address); - setInstructionTable(0x48, (uintptr_t)&fPHA, eImplied); - //PHP(Addressing, address); - setInstructionTable(0x08, (uintptr_t)&fPHP, eImplied); - //PLA(Addressing, address); - setInstructionTable(0x68, (uintptr_t)&fPLA, eImplied); - //PLP(Addressing, address); - setInstructionTable(0x28, (uintptr_t)&fPLP, eImplied); - - // Subroutine Instructions - //JSR(Addressing, address); - setInstructionTable(0x20, (uintptr_t)&fJSR, eAbsolute); - //RTS(Addressing, address); - setInstructionTable(0x60, (uintptr_t)&fRTS, eImplied); - //RTI(Addressing, address); - setInstructionTable(0x40, (uintptr_t)&fRTI, eImplied); - - // Set/Reset Insutrctions - //CLC(Addressing, address); - setInstructionTable(0x18, (uintptr_t)&fCLC, eImplied); - //CLD(Addressing, address); - setInstructionTable(0xD8, (uintptr_t)&fCLD, eImplied); - //CLI(Addressing, address); - setInstructionTable(0x58, (uintptr_t)&fCLI, eImplied); - //CLV(Addressing, address); - setInstructionTable(0xB8, (uintptr_t)&fCLV, eImplied); - //SEC(Addressing, address); - setInstructionTable(0x38, (uintptr_t)&fSEC, eImplied); - //SED(Addressing, address); - setInstructionTable(0xF8, (uintptr_t)&fSED, eImplied); - //SEI(Addressing, address); - setInstructionTable(0x78, (uintptr_t)&fSEI, eImplied); - - // NOP/BRK Instructions - //NOP(Addressing, address); - setInstructionTable(0xEA, (uintptr_t)&fNOP, eImplied); - //BRK(Addressing, address); - setInstructionTable(0x00, (uintptr_t)&fBRK, eImplied); -} - - diff --git a/headers/instruction-init.h b/headers/instruction-init.h deleted file mode 100644 index 68b9cf3..0000000 --- a/headers/instruction-init.h +++ /dev/null @@ -1,97 +0,0 @@ -// instruction-init.h -// Initializes every instruction function prior to addressing.h so that function addresses are accessible -// also defines the array used to refer to functions - -//InstructionTable -void* InstructionTable; -void (*func)(Addressing, address); - -#define InstructionTableSize (256 * (sizeof(uintptr_t) + sizeof(Addressing))) - -uintptr_t* getInstructionTableFunction(int i){ //Segmentation fault is occurring here, likely in next one too - uintptr_t* r = (InstructionTable + (sizeof(uintptr_t)*i)); - return r; -} - -Addressing* getInstructionTableAddressing(int i){ - Addressing* r = (InstructionTable + (sizeof(uintptr_t)*256) + (sizeof(Addressing)*i)); - return r; -} - -void callInstructionTable(int i, address val){ - printf("Table:\t%x\n", InstructionTable); - uintptr_t a = getInstructionTableFunction(i); - printf("A Val:\t%x\n", a); - //printf("Before:\t%x\n", func); func = a; printf("After:\t%x\n", func); - printf("Before:\t%x\n", func); memcpy(&func, a, sizeof(uintptr_t)); printf("After:\t%x\n", func); - Addressing* r = (InstructionTable + ((sizeof(uintptr_t)*256) + (sizeof(Addressing) * i))); - func(*r, val); printf("Statement OK"); -} - -// Load and Store Instructions -void fLDA(Addressing, address); -void fLDX(Addressing, address); -void fLDY(Addressing, address); -void fSTA(Addressing, address); -void fSTX(Addressing, address); -void fSTY(Addressing, address); -// Arithmetic Instructions -void fADC(Addressing, address); -void fSBC(Addressing, address); -//Increment and Decrement Instructions -void fINC(Addressing, address); -void fINX(Addressing, address); -void fINY(Addressing, address); -void fDEC(Addressing, address); -void fDEX(Addressing, address); -void fDEY(Addressing, address); -// Logical Instructions -void fAND(Addressing, address); -void fORA(Addressing, address); -void fEOR(Addressing, address); -// Jump, Branch, Compare, and Test Bits -void fJMP(Addressing, address); -void fBCC(Addressing, address); -void fBCS(Addressing, address); -void fBEQ(Addressing, address); -void fBNE(Addressing, address); -void fBMI(Addressing, address); -void fBPL(Addressing, address); -void fBVS(Addressing, address); -void fBVC(Addressing, address); -void fCMP(Addressing, address); -void fCPX(Addressing, address); -void fCPY(Addressing, address); -void fBIT(Addressing, address); -// Shift and Rotate Instructions -void fASL(Addressing, address); -void fLSR(Addressing, address); -void fROL(Addressing, address); -void fROR(Addressing, address); -// Transfer Instructions -void fTAX(Addressing, address); -void fTAY(Addressing, address); -void fTXA(Addressing, address); -void fTYA(Addressing, address); -// Stack Instructions -void fTSX(Addressing, address); -void fTXS(Addressing, address); -void fPHA(Addressing, address); -void fPHP(Addressing, address); -void fPLA(Addressing, address); -void fPLP(Addressing, address); -// Subroutine Instructions -void fJSR(Addressing, address); -void fRTS(Addressing, address); -void fRTI(Addressing, address); -// Set/Reset Insutrctions -void fCLC(Addressing, address); -void fCLD(Addressing, address); -void fCLI(Addressing, address); -void fCLV(Addressing, address); -void fSEC(Addressing, address); -void fSED(Addressing, address); -void fSEI(Addressing, address); -// NOP/BRK Instructions -void fNOP(Addressing, address); -void fBRK(Addressing, address); \ No newline at end of file diff --git a/headers/instruction-table.h b/headers/instruction-table.h new file mode 100644 index 0000000..bb51adb --- /dev/null +++ b/headers/instruction-table.h @@ -0,0 +1,266 @@ +// instruction-table.h +// Defines the instruction table, and the functions to access it. + +void* InstructionTable; +void (*func)(Addressing, address); + +#define InstructionTableSize (256 * (sizeof(uintptr_t) + sizeof(Addressing))) + +uintptr_t* getInstructionTableFunction(int i){ //Segmentation fault is occurring here, likely in next one too + uintptr_t* r = (InstructionTable + (sizeof(uintptr_t)*i)); + return r; +} + +Addressing* getInstructionTableAddressing(int i){ + Addressing* r = (InstructionTable + (sizeof(uintptr_t)*256) + (sizeof(Addressing)*i)); + return r; +} + +void callInstructionTable(int i, address val){ + uintptr_t a = getInstructionTableFunction(i); + memcpy(&func, a, sizeof(uintptr_t)); + Addressing* r = (InstructionTable + ((sizeof(uintptr_t)*256) + (sizeof(Addressing) * i))); + func(*r, val); +} + +void setInstructionTable(int i, uintptr_t p, Addressing r){ + uintptr_t* p1 = (InstructionTable + (sizeof(uintptr_t)*i)); + *p1 = p; + + Addressing* r1 = (InstructionTable + (sizeof(uintptr_t)*256) + (sizeof(Addressing)*i)); + *r1 = r; +} + +void initInstructionTable(){ + InstructionTable = malloc(InstructionTableSize); + // Load and Store Instructions + // fLDA(Addressing, address); + setInstructionTable(0xA9, (uintptr_t)&fLDA, eImmediate); + setInstructionTable(0xA5, (uintptr_t)&fLDA, eZeroPage); + setInstructionTable(0xB5, (uintptr_t)&fLDA, eZeroPageIndexedX); + setInstructionTable(0xAD, (uintptr_t)&fLDA, eAbsolute); + setInstructionTable(0xBD, (uintptr_t)&fLDA, eAbsoluteIndexedX); + setInstructionTable(0xB9, (uintptr_t)&fLDA, eAbsoluteIndexedY); + setInstructionTable(0xA1, (uintptr_t)&fLDA, eIndexedIndirect); + setInstructionTable(0xB1, (uintptr_t)&fLDA, eIndirectIndexed); + // fLDX(Addressing, address); + setInstructionTable(0xA2, (uintptr_t)&fLDX, eImmediate); + setInstructionTable(0xA6, (uintptr_t)&fLDX, eZeroPage); + setInstructionTable(0xB6, (uintptr_t)&fLDX, eZeroPageIndexedY); + setInstructionTable(0xAE, (uintptr_t)&fLDX, eAbsolute); + setInstructionTable(0xBE, (uintptr_t)&fLDX, eAbsoluteIndexedY); + // fLDY(Addressing, address); + setInstructionTable(0xA0, (uintptr_t)&fLDY, eImmediate); + setInstructionTable(0xA4, (uintptr_t)&fLDY, eZeroPage); + setInstructionTable(0xB4, (uintptr_t)&fLDY, eZeroPageIndexedX); + setInstructionTable(0xAC, (uintptr_t)&fLDY, eAbsolute); + setInstructionTable(0xBC, (uintptr_t)&fLDY, eAbsoluteIndexedX); + // fSTA(Addressing, address); + setInstructionTable(0x85, (uintptr_t)&fSTA, eZeroPage); + setInstructionTable(0x95, (uintptr_t)&fSTA, eZeroPageIndexedX); + setInstructionTable(0x8D, (uintptr_t)&fSTA, eAbsolute); + setInstructionTable(0x9D, (uintptr_t)&fSTA, eAbsoluteIndexedX); + setInstructionTable(0x99, (uintptr_t)&fSTA, eAbsoluteIndexedY); + setInstructionTable(0x81, (uintptr_t)&fSTA, eIndexedIndirect); + setInstructionTable(0x91, (uintptr_t)&fSTA, eIndirectIndexed); + // fSTX(Addressing, address); + setInstructionTable(0x86, (uintptr_t)&fSTX, eZeroPage); + setInstructionTable(0x96, (uintptr_t)&fSTX, eZeroPageIndexedX); + setInstructionTable(0x8E, (uintptr_t)&fSTX, eAbsolute); + // fSTY(Addressing, address); + setInstructionTable(0x84, (uintptr_t)&fSTY, eZeroPage); + setInstructionTable(0x94, (uintptr_t)&fSTY, eZeroPageIndexedY); + setInstructionTable(0x8C, (uintptr_t)&fSTY, eAbsolute); + + // Arithmetic Instructions + // fADC(Addressing, address); + setInstructionTable(0x69, (uintptr_t)&fADC, eImmediate); + setInstructionTable(0x65, (uintptr_t)&fADC, eZeroPage); + setInstructionTable(0x75, (uintptr_t)&fADC, eZeroPageIndexedX); + setInstructionTable(0x6D, (uintptr_t)&fADC, eAbsolute); + setInstructionTable(0x7D, (uintptr_t)&fADC, eAbsoluteIndexedX); + setInstructionTable(0x79, (uintptr_t)&fADC, eAbsoluteIndexedY); + setInstructionTable(0x61, (uintptr_t)&fADC, eIndexedIndirect); + setInstructionTable(0x71, (uintptr_t)&fADC, eIndirectIndexed); + // fSBC(Addressing, address); + setInstructionTable(0xE9, (uintptr_t)&fSBC, eImmediate); + setInstructionTable(0xE5, (uintptr_t)&fSBC, eZeroPage); + setInstructionTable(0xF5, (uintptr_t)&fSBC, eZeroPageIndexedX); + setInstructionTable(0xED, (uintptr_t)&fSBC, eAbsolute); + setInstructionTable(0xFD, (uintptr_t)&fSBC, eAbsoluteIndexedX); + setInstructionTable(0xF9, (uintptr_t)&fSBC, eAbsoluteIndexedY); + setInstructionTable(0xE1, (uintptr_t)&fSBC, eIndexedIndirect); + setInstructionTable(0xF1, (uintptr_t)&fSBC, eIndirectIndexed); + + //Increment and Decrement Instructions + //INC(Addressing, address); + setInstructionTable(0xE6, (uintptr_t)&fINC, eZeroPage); + setInstructionTable(0xF6, (uintptr_t)&fINC, eZeroPageIndexedX); + setInstructionTable(0xEE, (uintptr_t)&fINC, eAbsolute); + setInstructionTable(0xFE, (uintptr_t)&fINC, eAbsoluteIndexedX); + //INX(Addressing, address); + setInstructionTable(0xE8, (uintptr_t)&fINX, eImplied); + //INY(Addressing, address); + setInstructionTable(0xC8, (uintptr_t)&fINY, eImplied); + //DEC(Addressing, address); + setInstructionTable(0xC6, (uintptr_t)&fDEC, eZeroPage); + setInstructionTable(0xD6, (uintptr_t)&fDEC, eZeroPageIndexedX); + setInstructionTable(0xCE, (uintptr_t)&fDEC, eAbsolute); + setInstructionTable(0xDE, (uintptr_t)&fDEC, eAbsoluteIndexedX); + //DEX(Addressing, address); + setInstructionTable(0xCA, (uintptr_t)&fDEX, eImplied); + //DEY(Addressing, address); + setInstructionTable(0x88, (uintptr_t)&fDEY, eImplied); + + // Logical Instructions + //AND(Addressing, address); + setInstructionTable(0x29, (uintptr_t)&fAND, eImmediate); + setInstructionTable(0x25, (uintptr_t)&fAND, eZeroPage); + setInstructionTable(0x35, (uintptr_t)&fAND, eZeroPageIndexedX); + setInstructionTable(0x2D, (uintptr_t)&fAND, eAbsolute); + setInstructionTable(0x3D, (uintptr_t)&fAND, eAbsoluteIndexedX); + setInstructionTable(0x39, (uintptr_t)&fAND, eAbsoluteIndexedY); + setInstructionTable(0x21, (uintptr_t)&fAND, eIndexedIndirect); + setInstructionTable(0x31, (uintptr_t)&fAND, eIndirectIndexed); + //ORA(Addressing, address); + setInstructionTable(0x09, (uintptr_t)&fORA, eImmediate); + setInstructionTable(0x05, (uintptr_t)&fORA, eZeroPage); + setInstructionTable(0x15, (uintptr_t)&fORA, eZeroPageIndexedX); + setInstructionTable(0x0D, (uintptr_t)&fORA, eAbsolute); + setInstructionTable(0x1D, (uintptr_t)&fORA, eAbsoluteIndexedX); + setInstructionTable(0x19, (uintptr_t)&fORA, eAbsoluteIndexedY); + setInstructionTable(0x01, (uintptr_t)&fORA, eIndexedIndirect); + setInstructionTable(0x11, (uintptr_t)&fORA, eIndirectIndexed); + //EOR(Addressing, address); + setInstructionTable(0x49, (uintptr_t)&fEOR, eImmediate); + setInstructionTable(0x45, (uintptr_t)&fEOR, eZeroPage); + setInstructionTable(0x55, (uintptr_t)&fEOR, eZeroPageIndexedX); + setInstructionTable(0x4D, (uintptr_t)&fEOR, eAbsolute); + setInstructionTable(0x5D, (uintptr_t)&fEOR, eAbsoluteIndexedX); + setInstructionTable(0x59, (uintptr_t)&fEOR, eAbsoluteIndexedY); + setInstructionTable(0x41, (uintptr_t)&fEOR, eIndexedIndirect); + setInstructionTable(0x51, (uintptr_t)&fEOR, eIndirectIndexed); + + // Jump, Branch, Compare, and Test Bits + //JMP(Addressing, address); + setInstructionTable(0x4C, (uintptr_t)&fJMP, eAbsolute); + setInstructionTable(0x6C, (uintptr_t)&fJMP, eIndirectAbsolute); + //BCC(Addressing, address); + setInstructionTable(0x90, (uintptr_t)&fBCC, eRelative); + //BCS(Addressing, address); + setInstructionTable(0xB0, (uintptr_t)&fBCS, eRelative); + //BEQ(Addressing, address); + setInstructionTable(0xF0, (uintptr_t)&fBEQ, eRelative); + //BNE(Addressing, address); + setInstructionTable(0xD0, (uintptr_t)&fBNE, eRelative); + //BMI(Addressing, address); + setInstructionTable(0x30, (uintptr_t)&fBMI, eRelative); + //BPL(Addressing, address); + setInstructionTable(0x10, (uintptr_t)&fBPL, eRelative); + //BVS(Addressing, address); + setInstructionTable(0x70, (uintptr_t)&fBVS, eRelative); + //BVC(Addressing, address); + setInstructionTable(0x50, (uintptr_t)&fBVC, eRelative); + //CMP(Addressing, address); + setInstructionTable(0xC9, (uintptr_t)&fCMP, eImmediate); + setInstructionTable(0xC5, (uintptr_t)&fCMP, eZeroPage); + setInstructionTable(0xD5, (uintptr_t)&fCMP, eZeroPageIndexedX); + setInstructionTable(0xCD, (uintptr_t)&fCMP, eAbsolute); + setInstructionTable(0xDD, (uintptr_t)&fCMP, eAbsoluteIndexedX); + setInstructionTable(0xD9, (uintptr_t)&fCMP, eAbsoluteIndexedY); + setInstructionTable(0xC1, (uintptr_t)&fCMP, eIndexedIndirect); + setInstructionTable(0xD1, (uintptr_t)&fCMP, eIndirectIndexed); + //CPX(Addressing, address); + setInstructionTable(0xE0, (uintptr_t)&fCPX, eImmediate); + setInstructionTable(0xE4, (uintptr_t)&fCPX, eZeroPage); + setInstructionTable(0xEC, (uintptr_t)&fCPX, eAbsolute); + //CPY(Addressing, address); + setInstructionTable(0xC0, (uintptr_t)&fCPY, eImmediate); + setInstructionTable(0xC4, (uintptr_t)&fCPY, eZeroPage); + setInstructionTable(0xCC, (uintptr_t)&fCPY, eAbsolute); + //BIT(Addressing, address); + setInstructionTable(0x4C, (uintptr_t)&fBIT, eZeroPage); + setInstructionTable(0x6C, (uintptr_t)&fBIT, eAbsolute); + + // Shift and Rotate Instructions + //ASL(Addressing, address); + setInstructionTable(0x0A, (uintptr_t)&fASL, eAccumulator); + setInstructionTable(0x06, (uintptr_t)&fASL, eZeroPage); + setInstructionTable(0x16, (uintptr_t)&fASL, eZeroPageIndexedX); + setInstructionTable(0x0E, (uintptr_t)&fASL, eAbsolute); + setInstructionTable(0x1E, (uintptr_t)&fASL, eAbsoluteIndexedX); + //LSR(Addressing, address); + setInstructionTable(0x4A, (uintptr_t)&fLSR, eAccumulator); + setInstructionTable(0x46, (uintptr_t)&fLSR, eZeroPage); + setInstructionTable(0x56, (uintptr_t)&fLSR, eZeroPageIndexedX); + setInstructionTable(0x4E, (uintptr_t)&fLSR, eAbsolute); + setInstructionTable(0x5E, (uintptr_t)&fLSR, eAbsoluteIndexedX); + //ROL(Addressing, address); + setInstructionTable(0x2A, (uintptr_t)&fROL, eAccumulator); + setInstructionTable(0x26, (uintptr_t)&fROL, eZeroPage); + setInstructionTable(0x36, (uintptr_t)&fROL, eZeroPageIndexedX); + setInstructionTable(0x2E, (uintptr_t)&fROL, eAbsolute); + setInstructionTable(0x3E, (uintptr_t)&fROL, eAbsoluteIndexedX); + //ROR(Addressing, address); + setInstructionTable(0x6A, (uintptr_t)&fROR, eAccumulator); + setInstructionTable(0x66, (uintptr_t)&fROR, eZeroPage); + setInstructionTable(0x76, (uintptr_t)&fROR, eZeroPageIndexedX); + setInstructionTable(0x6E, (uintptr_t)&fROR, eAbsolute); + setInstructionTable(0x7E, (uintptr_t)&fROR, eAbsoluteIndexedX); + + // Transfer Instructions + //TAX(Addressing, address); + setInstructionTable(0xAA, (uintptr_t)&fTAX, eImplied); + //TAY(Addressing, address); + setInstructionTable(0xA8, (uintptr_t)&fTAY, eImplied); + //TXA(Addressing, address); + setInstructionTable(0x8A, (uintptr_t)&fTXA, eImplied); + //TYA(Addressing, address); + setInstructionTable(0x98, (uintptr_t)&fTYA, eImplied); + + // Stack Instructions + //TSX(Addressing, address); + setInstructionTable(0xBA, (uintptr_t)&fTSX, eImplied); + //TXS(Addressing, address); + setInstructionTable(0x9A, (uintptr_t)&fTXS, eImplied); + //PHA(Addressing, address); + setInstructionTable(0x48, (uintptr_t)&fPHA, eImplied); + //PHP(Addressing, address); + setInstructionTable(0x08, (uintptr_t)&fPHP, eImplied); + //PLA(Addressing, address); + setInstructionTable(0x68, (uintptr_t)&fPLA, eImplied); + //PLP(Addressing, address); + setInstructionTable(0x28, (uintptr_t)&fPLP, eImplied); + + // Subroutine Instructions + //JSR(Addressing, address); + setInstructionTable(0x20, (uintptr_t)&fJSR, eAbsolute); + //RTS(Addressing, address); + setInstructionTable(0x60, (uintptr_t)&fRTS, eImplied); + //RTI(Addressing, address); + setInstructionTable(0x40, (uintptr_t)&fRTI, eImplied); + + // Set/Reset Insutrctions + //CLC(Addressing, address); + setInstructionTable(0x18, (uintptr_t)&fCLC, eImplied); + //CLD(Addressing, address); + setInstructionTable(0xD8, (uintptr_t)&fCLD, eImplied); + //CLI(Addressing, address); + setInstructionTable(0x58, (uintptr_t)&fCLI, eImplied); + //CLV(Addressing, address); + setInstructionTable(0xB8, (uintptr_t)&fCLV, eImplied); + //SEC(Addressing, address); + setInstructionTable(0x38, (uintptr_t)&fSEC, eImplied); + //SED(Addressing, address); + setInstructionTable(0xF8, (uintptr_t)&fSED, eImplied); + //SEI(Addressing, address); + setInstructionTable(0x78, (uintptr_t)&fSEI, eImplied); + + // NOP/BRK Instructions + //NOP(Addressing, address); + setInstructionTable(0xEA, (uintptr_t)&fNOP, eImplied); + //BRK(Addressing, address); + setInstructionTable(0x00, (uintptr_t)&fBRK, eImplied); +} + + diff --git a/headers/instructions-init.h b/headers/instructions-init.h new file mode 100644 index 0000000..6fddec4 --- /dev/null +++ b/headers/instructions-init.h @@ -0,0 +1,70 @@ +// instruction-init.h +// Initializes every instruction function prior to addressing.h so that function addresses are accessible + +// Load and Store Instructions +void fLDA(Addressing, address); +void fLDX(Addressing, address); +void fLDY(Addressing, address); +void fSTA(Addressing, address); +void fSTX(Addressing, address); +void fSTY(Addressing, address); +// Arithmetic Instructions +void fADC(Addressing, address); +void fSBC(Addressing, address); +//Increment and Decrement Instructions +void fINC(Addressing, address); +void fINX(Addressing, address); +void fINY(Addressing, address); +void fDEC(Addressing, address); +void fDEX(Addressing, address); +void fDEY(Addressing, address); +// Logical Instructions +void fAND(Addressing, address); +void fORA(Addressing, address); +void fEOR(Addressing, address); +// Jump, Branch, Compare, and Test Bits +void fJMP(Addressing, address); +void fBCC(Addressing, address); +void fBCS(Addressing, address); +void fBEQ(Addressing, address); +void fBNE(Addressing, address); +void fBMI(Addressing, address); +void fBPL(Addressing, address); +void fBVS(Addressing, address); +void fBVC(Addressing, address); +void fCMP(Addressing, address); +void fCPX(Addressing, address); +void fCPY(Addressing, address); +void fBIT(Addressing, address); +// Shift and Rotate Instructions +void fASL(Addressing, address); +void fLSR(Addressing, address); +void fROL(Addressing, address); +void fROR(Addressing, address); +// Transfer Instructions +void fTAX(Addressing, address); +void fTAY(Addressing, address); +void fTXA(Addressing, address); +void fTYA(Addressing, address); +// Stack Instructions +void fTSX(Addressing, address); +void fTXS(Addressing, address); +void fPHA(Addressing, address); +void fPHP(Addressing, address); +void fPLA(Addressing, address); +void fPLP(Addressing, address); +// Subroutine Instructions +void fJSR(Addressing, address); +void fRTS(Addressing, address); +void fRTI(Addressing, address); +// Set/Reset Insutrctions +void fCLC(Addressing, address); +void fCLD(Addressing, address); +void fCLI(Addressing, address); +void fCLV(Addressing, address); +void fSEC(Addressing, address); +void fSED(Addressing, address); +void fSEI(Addressing, address); +// NOP/BRK Instructions +void fNOP(Addressing, address); +void fBRK(Addressing, address); \ No newline at end of file diff --git a/headers/instructions.h b/headers/instructions.h index 96f5719..bdcd442 100644 --- a/headers/instructions.h +++ b/headers/instructions.h @@ -1,13 +1,16 @@ -// instruction.h +// instructions.h // Definition of all instruction functions, handling effect of instruction and flags. -// array/map of pointers which all point -// to the functions which the index corresponds to. -// use that like a sort of map +AddData idata; -//Instruction Data -AddData idata; +/* TO DO + +!!!!!!!! CHECK THAT idata.value IS USED ACROSS ALL FUNCTIONS, NOT VAL !!!!!!!!!!!!!! + ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ +Fix all functions before performing testing + +*/ // Load and Store Instructions @@ -206,15 +209,15 @@ void fBIT(Addressing addr, address val){ idata = fAddress(addr, val); // Shift and Rotate Instructions void fASL(Addressing addr, address val){ idata = fAddress(addr, val); - setFlag(flag_C, (val & 0x80)); - acc = (val << 1); + setFlag(flag_C, (idata.value & 0x80)); + acc = (idata.value << 1); setFlagN(acc); setFlagZ(acc); } void fLSR(Addressing addr, address val){ idata = fAddress(addr, val); - setFlag(flag_C, (val & 0x01)); - acc = (val >> 1); + setFlag(flag_C, (idata.value & 0x01)); + acc = (idata.value >> 1); setFlagN(acc); setFlagZ(acc); } diff --git a/inbin b/inbin deleted file mode 100755 index a6286dd..0000000 Binary files a/inbin and /dev/null differ diff --git a/interpreter.c b/interpreter.c index e49c77a..14ef400 100644 --- a/interpreter.c +++ b/interpreter.c @@ -1,20 +1,15 @@ -/* - * interpreter.c WILL BE a tool which can be used to interpret 6502 machine code inline. - * Machine code is expected as hexadecimal of length 2 or 6, depending on the instruction. - * There are a few special characters which print debug information +//interpreter.c is a tool which can interpret 6502 assembly on the go, for the purposes of testing. +/* Special Commands for debug information Q - Quit P - Processor status dump M - Dump a page of memory - */ +*/ #include"headers/include.h" #include"headers/debug.h" int main(){ - char c; - unsigned char a, b; - - initIT(); + AppleOn(); while(1){ c = fgetc(stdin); diff --git a/test.c b/test.c index 2ced76c..21e9c5d 100644 --- a/test.c +++ b/test.c @@ -1,17 +1,19 @@ +// test.c +// Temporary .c file where arbitrary tests are carried out. + #include"headers/include.h" #include"headers/debug.h" int main(int argc, char *argv[]){ + AppleOn(); initInstructionTable(); - byte* a; - for(int i = 0; i < InstructionTableSize; i++){ - a = InstructionTable + i; - printf("%x\t", *a); - if ((i % 8) == 7) printf("\n"); - } + dStatusDump(); + + fLDA(eImmediate, 0x01); + fSTA(eAbsolute, 0x09); + + dStatusDump(); printf("\n"); - printf("\n"); dStatusDump(); dIdataDump(); printf("%x\n", &fLDA); printf("\n"); - callInstructionTable(0xA9, 0x01); - dStatusDump(); dIdataDump(); printf("\n"); + dPageDump(0x00); } \ No newline at end of file -- cgit v1.2.3