diff options
| -rw-r--r-- | .gitignore | 4 | ||||
| -rw-r--r-- | ToDo | 2 | ||||
| -rw-r--r-- | assembler.c | 2 | ||||
| -rw-r--r-- | headers/addressing.h (renamed from addressing.h) | 9 | ||||
| -rw-r--r-- | headers/applesystem.h (renamed from applesystem.h) | 0 | ||||
| -rw-r--r-- | headers/debug.h (renamed from debug.h) | 0 | ||||
| -rw-r--r-- | headers/include.h (renamed from include.h) | 2 | ||||
| -rw-r--r-- | headers/instruction-init.h (renamed from instruction-init.h) | 42 | ||||
| -rw-r--r-- | headers/instructions.h (renamed from instruction.h) | 0 | ||||
| -rw-r--r-- | instruction-bin.c | 323 | ||||
| -rw-r--r-- | interpreter.c | 4 | ||||
| -rw-r--r-- | main.c | 6 | ||||
| -rw-r--r-- | makefile | 3 | ||||
| -rw-r--r-- | test.c | 45 |
14 files changed, 214 insertions, 228 deletions
diff --git a/.gitignore b/.gitignore new file mode 100644 index 0000000..9656d78 --- /dev/null +++ b/.gitignore @@ -0,0 +1,4 @@ +main +instructions.bin +instruction-dump +.vscode/settings.json @@ -1,5 +1,7 @@ Before the next commit, this should all be completed. +First and foremost, make sure reading is possible. + Create the makefile. Fix directory structures and header files before it gets even messier. Delete unnecessary files. diff --git a/assembler.c b/assembler.c index b20d13b..1797d9b 100644 --- a/assembler.c +++ b/assembler.c @@ -2,8 +2,6 @@ // A minimalistic assembler for creating binary files. #include"stdio.h" -//syscall library - int main(int argc; char* argv[]){ int output = 0; diff --git a/addressing.h b/headers/addressing.h index d764e8f..d9d8e98 100644 --- a/addressing.h +++ b/headers/addressing.h @@ -28,16 +28,11 @@ struct AddData{ typedef struct AddData AddData; - - #include"instruction-init.h" - //Holds address of current instruction. void* current_instruction; - - Addressing fAddressGetLength(Addressing addr){ switch(addr){ case eAbsolute: case eAbsoluteIndexedX: case eAbsoluteIndexedY: @@ -49,12 +44,9 @@ Addressing fAddressGetLength(Addressing addr){ } } - AddData fAddress(Addressing addr, short x) { AddData ret; - // might seperate the rest of these out? - // ADDRESS switch(addr){ @@ -114,7 +106,6 @@ AddData fAddress(Addressing addr, short x) { ret.value = Memory[ret.add]; } - // LENGTH ret.length = fAddressGetLength(addr); diff --git a/applesystem.h b/headers/applesystem.h index 6b2f818..6b2f818 100644 --- a/applesystem.h +++ b/headers/applesystem.h diff --git a/debug.h b/headers/debug.h index bb6ba40..bb6ba40 100644 --- a/debug.h +++ b/headers/debug.h diff --git a/include.h b/headers/include.h index 4bffe1e..9a537c4 100644 --- a/include.h +++ b/headers/include.h @@ -4,4 +4,4 @@ #include"string.h" #include"applesystem.h" #include"addressing.h" -#include"instruction.h"
\ No newline at end of file +#include"instructions.h"
\ No newline at end of file diff --git a/instruction-init.h b/headers/instruction-init.h index 12cdfa4..488f73c 100644 --- a/instruction-init.h +++ b/headers/instruction-init.h @@ -3,40 +3,39 @@ // also defines the array used to refer to functions //InstructionTable -void* IT; +void* InstructionTable; void (*func)(Addressing, address); -#define InstructionTableSize (256*(sizeof(uintptr_t) + sizeof(Addressing))) +#define InstructionTableSize (256 * (sizeof(uintptr_t) + sizeof(Addressing))) /* -uintptr_t getITFunction(int i){ //Segmentation fault is occurring here, likely in next one too - uintptr_t r = (IT + (sizeof(uintptr_t)*i)); +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 getITAddressing(int i){ - Addressing r = (IT + (sizeof(uintptr_t)*256) + (sizeof(Addressing)*i)); +Addressing getInstructionTableAddressing(int i){ + Addressing r = (InstructionTable + (sizeof(uintptr_t)*256) + (sizeof(Addressing)*i)); return r; } */ - -void callIT(int i, address val){ - uintptr_t a = (IT + (sizeof(uintptr_t) * i)); - memcpy(&func, a, sizeof(uintptr_t)); - Addressing* r = (IT + ((sizeof(uintptr_t)*256) + (sizeof(Addressing) * i))); - func(*r, val); +void callInstructionTable(int i, address val){ + printf("Table:\t%x\n", InstructionTable); + uintptr_t* a = (InstructionTable + (sizeof(uintptr_t) * 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"); } -void initIT(){ - IT = malloc(InstructionTableSize); +void initInstructionTable(){ + InstructionTable = malloc(InstructionTableSize); FILE* fs = fopen("instructions.bin", "r"); - /*if (fs == NULL){ - system("instruction-dump"); - }*/ - for(char* c = IT; c < (IT + InstructionTableSize); c++){ //NEED TO MAKE (IT + (256*(sizeof(uintptr_t) + sizeof(Addressing)))) a macro - *c = fgetc(fs); + for(byte* c = InstructionTable; c < (InstructionTable + InstructionTableSize); c++){ //NEED TO MAKE (InstructionTable + (256*(sizeof(uintptr_t) + sizeof(Addressing)))) a macro + *c = (byte)fgetc(fs); } //Investigate whether doing word sized units would increase speed fclose(fs); //read in the instruction data binary @@ -110,7 +109,4 @@ void fSED(Addressing, address); void fSEI(Addressing, address); // NOP/BRK Instructions void fNOP(Addressing, address); -void fBRK(Addressing, address); - - - +void fBRK(Addressing, address);
\ No newline at end of file diff --git a/instruction.h b/headers/instructions.h index 96f5719..96f5719 100644 --- a/instruction.h +++ b/headers/instructions.h diff --git a/instruction-bin.c b/instruction-bin.c index d470c74..074a1e4 100644 --- a/instruction-bin.c +++ b/instruction-bin.c @@ -1,256 +1,257 @@ -#include"include.h" +#include"headers/include.h" -void setIT(int i, uintptr_t p, Addressing r); -void setAllIT(); +void setInstructionTable(int i, uintptr_t p, Addressing r); + +void setAllInstructionTable(); int main(){ - setAllIT(); + setAllInstructionTable(); // here, do calls to dump all instructions into a bin file FILE* fs = fopen("instructions.bin", "w"); - for(char* c = IT; c < (IT + InstructionTableSize); c++){ + for(char* c = InstructionTable; c < (InstructionTable + InstructionTableSize); c++){ fputc(*c, fs); } fclose(fs); } -void setIT(int i, uintptr_t p, Addressing r){ - uintptr_t* p1 = (IT + (sizeof(uintptr_t)*i)); +void setInstructionTable(int i, uintptr_t p, Addressing r){ + uintptr_t* p1 = (InstructionTable + (sizeof(uintptr_t)*i)); *p1 = p; - Addressing* r1 = (IT + (sizeof(uintptr_t)*256) + (sizeof(Addressing)*i)); + Addressing* r1 = (InstructionTable + (sizeof(uintptr_t)*256) + (sizeof(Addressing)*i)); *r1 = r; } -void setAllIT(){ - IT = malloc(256 * (sizeof(uintptr_t) + sizeof(Addressing))); +void setAllInstructionTable(){ + InstructionTable = malloc(256 * (sizeof(uintptr_t) + sizeof(Addressing))); // Load and Store Instructions // fLDA(Addressing, address); - setIT(0xA9, (uintptr_t)&fLDA, eImmediate); - setIT(0xA5, (uintptr_t)&fLDA, eZeroPage); - setIT(0xB5, (uintptr_t)&fLDA, eZeroPageIndexedX); - setIT(0xAD, (uintptr_t)&fLDA, eAbsolute); - setIT(0xBD, (uintptr_t)&fLDA, eAbsoluteIndexedX); - setIT(0xB9, (uintptr_t)&fLDA, eAbsoluteIndexedY); - setIT(0xA1, (uintptr_t)&fLDA, eIndexedIndirect); - setIT(0xB1, (uintptr_t)&fLDA, eIndirectIndexed); + 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); - setIT(0xA2, (uintptr_t)&fLDX, eImmediate); - setIT(0xA6, (uintptr_t)&fLDX, eZeroPage); - setIT(0xB6, (uintptr_t)&fLDX, eZeroPageIndexedY); - setIT(0xAE, (uintptr_t)&fLDX, eAbsolute); - setIT(0xBE, (uintptr_t)&fLDX, eAbsoluteIndexedY); + 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); - setIT(0xA0, (uintptr_t)&fLDY, eImmediate); - setIT(0xA4, (uintptr_t)&fLDY, eZeroPage); - setIT(0xB4, (uintptr_t)&fLDY, eZeroPageIndexedX); - setIT(0xAC, (uintptr_t)&fLDY, eAbsolute); - setIT(0xBC, (uintptr_t)&fLDY, eAbsoluteIndexedX); + 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); - setIT(0x85, (uintptr_t)&fSTA, eZeroPage); - setIT(0x95, (uintptr_t)&fSTA, eZeroPageIndexedX); - setIT(0x8D, (uintptr_t)&fSTA, eAbsolute); - setIT(0x9D, (uintptr_t)&fSTA, eAbsoluteIndexedX); - setIT(0x99, (uintptr_t)&fSTA, eAbsoluteIndexedY); - setIT(0x81, (uintptr_t)&fSTA, eIndexedIndirect); - setIT(0x91, (uintptr_t)&fSTA, eIndirectIndexed); + 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); - setIT(0x86, (uintptr_t)&fSTX, eZeroPage); - setIT(0x96, (uintptr_t)&fSTX, eZeroPageIndexedX); - setIT(0x8E, (uintptr_t)&fSTX, eAbsolute); + setInstructionTable(0x86, (uintptr_t)&fSTX, eZeroPage); + setInstructionTable(0x96, (uintptr_t)&fSTX, eZeroPageIndexedX); + setInstructionTable(0x8E, (uintptr_t)&fSTX, eAbsolute); // fSTY(Addressing, address); - setIT(0x84, (uintptr_t)&fSTY, eZeroPage); - setIT(0x94, (uintptr_t)&fSTY, eZeroPageIndexedY); - setIT(0x8C, (uintptr_t)&fSTY, eAbsolute); + setInstructionTable(0x84, (uintptr_t)&fSTY, eZeroPage); + setInstructionTable(0x94, (uintptr_t)&fSTY, eZeroPageIndexedY); + setInstructionTable(0x8C, (uintptr_t)&fSTY, eAbsolute); // Arithmetic Instructions // fADC(Addressing, address); - setIT(0x69, (uintptr_t)&fADC, eImmediate); - setIT(0x65, (uintptr_t)&fADC, eZeroPage); - setIT(0x75, (uintptr_t)&fADC, eZeroPageIndexedX); - setIT(0x6D, (uintptr_t)&fADC, eAbsolute); - setIT(0x7D, (uintptr_t)&fADC, eAbsoluteIndexedX); - setIT(0x79, (uintptr_t)&fADC, eAbsoluteIndexedY); - setIT(0x61, (uintptr_t)&fADC, eIndexedIndirect); - setIT(0x71, (uintptr_t)&fADC, eIndirectIndexed); + 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); - setIT(0xE9, (uintptr_t)&fSBC, eImmediate); - setIT(0xE5, (uintptr_t)&fSBC, eZeroPage); - setIT(0xF5, (uintptr_t)&fSBC, eZeroPageIndexedX); - setIT(0xED, (uintptr_t)&fSBC, eAbsolute); - setIT(0xFD, (uintptr_t)&fSBC, eAbsoluteIndexedX); - setIT(0xF9, (uintptr_t)&fSBC, eAbsoluteIndexedY); - setIT(0xE1, (uintptr_t)&fSBC, eIndexedIndirect); - setIT(0xF1, (uintptr_t)&fSBC, eIndirectIndexed); + 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); - setIT(0xE6, (uintptr_t)&fINC, eZeroPage); - setIT(0xF6, (uintptr_t)&fINC, eZeroPageIndexedX); - setIT(0xEE, (uintptr_t)&fINC, eAbsolute); - setIT(0xFE, (uintptr_t)&fINC, eAbsoluteIndexedX); + 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); - setIT(0xE8, (uintptr_t)&fINX, eImplied); + setInstructionTable(0xE8, (uintptr_t)&fINX, eImplied); //INY(Addressing, address); - setIT(0xC8, (uintptr_t)&fINY, eImplied); + setInstructionTable(0xC8, (uintptr_t)&fINY, eImplied); //DEC(Addressing, address); - setIT(0xC6, (uintptr_t)&fDEC, eZeroPage); - setIT(0xD6, (uintptr_t)&fDEC, eZeroPageIndexedX); - setIT(0xCE, (uintptr_t)&fDEC, eAbsolute); - setIT(0xDE, (uintptr_t)&fDEC, eAbsoluteIndexedX); + 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); - setIT(0xCA, (uintptr_t)&fDEX, eImplied); + setInstructionTable(0xCA, (uintptr_t)&fDEX, eImplied); //DEY(Addressing, address); - setIT(0x88, (uintptr_t)&fDEY, eImplied); + setInstructionTable(0x88, (uintptr_t)&fDEY, eImplied); // Logical Instructions //AND(Addressing, address); - setIT(0x29, (uintptr_t)&fAND, eImmediate); - setIT(0x25, (uintptr_t)&fAND, eZeroPage); - setIT(0x35, (uintptr_t)&fAND, eZeroPageIndexedX); - setIT(0x2D, (uintptr_t)&fAND, eAbsolute); - setIT(0x3D, (uintptr_t)&fAND, eAbsoluteIndexedX); - setIT(0x39, (uintptr_t)&fAND, eAbsoluteIndexedY); - setIT(0x21, (uintptr_t)&fAND, eIndexedIndirect); - setIT(0x31, (uintptr_t)&fAND, eIndirectIndexed); + 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); - setIT(0x09, (uintptr_t)&fORA, eImmediate); - setIT(0x05, (uintptr_t)&fORA, eZeroPage); - setIT(0x15, (uintptr_t)&fORA, eZeroPageIndexedX); - setIT(0x0D, (uintptr_t)&fORA, eAbsolute); - setIT(0x1D, (uintptr_t)&fORA, eAbsoluteIndexedX); - setIT(0x19, (uintptr_t)&fORA, eAbsoluteIndexedY); - setIT(0x01, (uintptr_t)&fORA, eIndexedIndirect); - setIT(0x11, (uintptr_t)&fORA, eIndirectIndexed); + 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); - setIT(0x49, (uintptr_t)&fEOR, eImmediate); - setIT(0x45, (uintptr_t)&fEOR, eZeroPage); - setIT(0x55, (uintptr_t)&fEOR, eZeroPageIndexedX); - setIT(0x4D, (uintptr_t)&fEOR, eAbsolute); - setIT(0x5D, (uintptr_t)&fEOR, eAbsoluteIndexedX); - setIT(0x59, (uintptr_t)&fEOR, eAbsoluteIndexedY); - setIT(0x41, (uintptr_t)&fEOR, eIndexedIndirect); - setIT(0x51, (uintptr_t)&fEOR, eIndirectIndexed); + 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); - setIT(0x4C, (uintptr_t)&fJMP, eAbsolute); - setIT(0x6C, (uintptr_t)&fJMP, eIndirectAbsolute); + setInstructionTable(0x4C, (uintptr_t)&fJMP, eAbsolute); + setInstructionTable(0x6C, (uintptr_t)&fJMP, eIndirectAbsolute); //BCC(Addressing, address); - setIT(0x90, (uintptr_t)&fBCC, eRelative); + setInstructionTable(0x90, (uintptr_t)&fBCC, eRelative); //BCS(Addressing, address); - setIT(0xB0, (uintptr_t)&fBCS, eRelative); + setInstructionTable(0xB0, (uintptr_t)&fBCS, eRelative); //BEQ(Addressing, address); - setIT(0xF0, (uintptr_t)&fBEQ, eRelative); + setInstructionTable(0xF0, (uintptr_t)&fBEQ, eRelative); //BNE(Addressing, address); - setIT(0xD0, (uintptr_t)&fBNE, eRelative); + setInstructionTable(0xD0, (uintptr_t)&fBNE, eRelative); //BMI(Addressing, address); - setIT(0x30, (uintptr_t)&fBMI, eRelative); + setInstructionTable(0x30, (uintptr_t)&fBMI, eRelative); //BPL(Addressing, address); - setIT(0x10, (uintptr_t)&fBPL, eRelative); + setInstructionTable(0x10, (uintptr_t)&fBPL, eRelative); //BVS(Addressing, address); - setIT(0x70, (uintptr_t)&fBVS, eRelative); + setInstructionTable(0x70, (uintptr_t)&fBVS, eRelative); //BVC(Addressing, address); - setIT(0x50, (uintptr_t)&fBVC, eRelative); + setInstructionTable(0x50, (uintptr_t)&fBVC, eRelative); //CMP(Addressing, address); - setIT(0xC9, (uintptr_t)&fCMP, eImmediate); - setIT(0xC5, (uintptr_t)&fCMP, eZeroPage); - setIT(0xD5, (uintptr_t)&fCMP, eZeroPageIndexedX); - setIT(0xCD, (uintptr_t)&fCMP, eAbsolute); - setIT(0xDD, (uintptr_t)&fCMP, eAbsoluteIndexedX); - setIT(0xD9, (uintptr_t)&fCMP, eAbsoluteIndexedY); - setIT(0xC1, (uintptr_t)&fCMP, eIndexedIndirect); - setIT(0xD1, (uintptr_t)&fCMP, eIndirectIndexed); + 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); - setIT(0xE0, (uintptr_t)&fCPX, eImmediate); - setIT(0xE4, (uintptr_t)&fCPX, eZeroPage); - setIT(0xEC, (uintptr_t)&fCPX, eAbsolute); + setInstructionTable(0xE0, (uintptr_t)&fCPX, eImmediate); + setInstructionTable(0xE4, (uintptr_t)&fCPX, eZeroPage); + setInstructionTable(0xEC, (uintptr_t)&fCPX, eAbsolute); //CPY(Addressing, address); - setIT(0xC0, (uintptr_t)&fCPY, eImmediate); - setIT(0xC4, (uintptr_t)&fCPY, eZeroPage); - setIT(0xCC, (uintptr_t)&fCPY, eAbsolute); + setInstructionTable(0xC0, (uintptr_t)&fCPY, eImmediate); + setInstructionTable(0xC4, (uintptr_t)&fCPY, eZeroPage); + setInstructionTable(0xCC, (uintptr_t)&fCPY, eAbsolute); //BIT(Addressing, address); - setIT(0x4C, (uintptr_t)&fBIT, eZeroPage); - setIT(0x6C, (uintptr_t)&fBIT, eAbsolute); + setInstructionTable(0x4C, (uintptr_t)&fBIT, eZeroPage); + setInstructionTable(0x6C, (uintptr_t)&fBIT, eAbsolute); // Shift and Rotate Instructions //ASL(Addressing, address); - setIT(0x0A, (uintptr_t)&fASL, eAccumulator); - setIT(0x06, (uintptr_t)&fASL, eZeroPage); - setIT(0x16, (uintptr_t)&fASL, eZeroPageIndexedX); - setIT(0x0E, (uintptr_t)&fASL, eAbsolute); - setIT(0x1E, (uintptr_t)&fASL, eAbsoluteIndexedX); + 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); - setIT(0x4A, (uintptr_t)&fLSR, eAccumulator); - setIT(0x46, (uintptr_t)&fLSR, eZeroPage); - setIT(0x56, (uintptr_t)&fLSR, eZeroPageIndexedX); - setIT(0x4E, (uintptr_t)&fLSR, eAbsolute); - setIT(0x5E, (uintptr_t)&fLSR, eAbsoluteIndexedX); + 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); - setIT(0x2A, (uintptr_t)&fROL, eAccumulator); - setIT(0x26, (uintptr_t)&fROL, eZeroPage); - setIT(0x36, (uintptr_t)&fROL, eZeroPageIndexedX); - setIT(0x2E, (uintptr_t)&fROL, eAbsolute); - setIT(0x3E, (uintptr_t)&fROL, eAbsoluteIndexedX); + 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); - setIT(0x6A, (uintptr_t)&fROR, eAccumulator); - setIT(0x66, (uintptr_t)&fROR, eZeroPage); - setIT(0x76, (uintptr_t)&fROR, eZeroPageIndexedX); - setIT(0x6E, (uintptr_t)&fROR, eAbsolute); - setIT(0x7E, (uintptr_t)&fROR, eAbsoluteIndexedX); + 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); - setIT(0xAA, (uintptr_t)&fTAX, eImplied); + setInstructionTable(0xAA, (uintptr_t)&fTAX, eImplied); //TAY(Addressing, address); - setIT(0xA8, (uintptr_t)&fTAY, eImplied); + setInstructionTable(0xA8, (uintptr_t)&fTAY, eImplied); //TXA(Addressing, address); - setIT(0x8A, (uintptr_t)&fTXA, eImplied); + setInstructionTable(0x8A, (uintptr_t)&fTXA, eImplied); //TYA(Addressing, address); - setIT(0x98, (uintptr_t)&fTYA, eImplied); + setInstructionTable(0x98, (uintptr_t)&fTYA, eImplied); // Stack Instructions //TSX(Addressing, address); - setIT(0xBA, (uintptr_t)&fTSX, eImplied); + setInstructionTable(0xBA, (uintptr_t)&fTSX, eImplied); //TXS(Addressing, address); - setIT(0x9A, (uintptr_t)&fTXS, eImplied); + setInstructionTable(0x9A, (uintptr_t)&fTXS, eImplied); //PHA(Addressing, address); - setIT(0x48, (uintptr_t)&fPHA, eImplied); + setInstructionTable(0x48, (uintptr_t)&fPHA, eImplied); //PHP(Addressing, address); - setIT(0x08, (uintptr_t)&fPHP, eImplied); + setInstructionTable(0x08, (uintptr_t)&fPHP, eImplied); //PLA(Addressing, address); - setIT(0x68, (uintptr_t)&fPLA, eImplied); + setInstructionTable(0x68, (uintptr_t)&fPLA, eImplied); //PLP(Addressing, address); - setIT(0x28, (uintptr_t)&fPLP, eImplied); + setInstructionTable(0x28, (uintptr_t)&fPLP, eImplied); // Subroutine Instructions //JSR(Addressing, address); - setIT(0x20, (uintptr_t)&fJSR, eAbsolute); + setInstructionTable(0x20, (uintptr_t)&fJSR, eAbsolute); //RTS(Addressing, address); - setIT(0x60, (uintptr_t)&fRTS, eImplied); + setInstructionTable(0x60, (uintptr_t)&fRTS, eImplied); //RTI(Addressing, address); - setIT(0x40, (uintptr_t)&fRTI, eImplied); + setInstructionTable(0x40, (uintptr_t)&fRTI, eImplied); // Set/Reset Insutrctions //CLC(Addressing, address); - setIT(0x18, (uintptr_t)&fCLC, eImplied); + setInstructionTable(0x18, (uintptr_t)&fCLC, eImplied); //CLD(Addressing, address); - setIT(0xD8, (uintptr_t)&fCLD, eImplied); + setInstructionTable(0xD8, (uintptr_t)&fCLD, eImplied); //CLI(Addressing, address); - setIT(0x58, (uintptr_t)&fCLI, eImplied); + setInstructionTable(0x58, (uintptr_t)&fCLI, eImplied); //CLV(Addressing, address); - setIT(0xB8, (uintptr_t)&fCLV, eImplied); + setInstructionTable(0xB8, (uintptr_t)&fCLV, eImplied); //SEC(Addressing, address); - setIT(0x38, (uintptr_t)&fSEC, eImplied); + setInstructionTable(0x38, (uintptr_t)&fSEC, eImplied); //SED(Addressing, address); - setIT(0xF8, (uintptr_t)&fSED, eImplied); + setInstructionTable(0xF8, (uintptr_t)&fSED, eImplied); //SEI(Addressing, address); - setIT(0x78, (uintptr_t)&fSEI, eImplied); + setInstructionTable(0x78, (uintptr_t)&fSEI, eImplied); // NOP/BRK Instructions //NOP(Addressing, address); - setIT(0xEA, (uintptr_t)&fNOP, eImplied); + setInstructionTable(0xEA, (uintptr_t)&fNOP, eImplied); //BRK(Addressing, address); - setIT(0x00, (uintptr_t)&fBRK, eImplied); + setInstructionTable(0x00, (uintptr_t)&fBRK, eImplied); } diff --git a/interpreter.c b/interpreter.c index 6fea22e..e49c77a 100644 --- a/interpreter.c +++ b/interpreter.c @@ -7,8 +7,8 @@ M - Dump a page of memory */ -#include"include.h" -#include"debug.h" +#include"headers/include.h" +#include"headers/debug.h" int main(){ char c; @@ -1,6 +0,0 @@ -#include"include.h" -#include"debug.h" - -int main(int argc, char *argv[]){ - -}
\ No newline at end of file @@ -1,3 +1,2 @@ main: - gcc instruction-bin.c -o instruction-dump - gcc test.c -o main + gcc test.c -o main
\ No newline at end of file @@ -1,23 +1,24 @@ -#include"include.h" -#include"debug.h" - -int main(){ - char c; - unsigned char a, b; - - initIT(); - - printf("\n\n"); - - dStatusDump(); dIdataDump(); printf("\n"); - - //func(*(IT + ((sizeof(uintptr_t)*256)) + (0xA9 * sizeof(Addressing))), *(IT + ((sizeof(uintptr_t)*0xA9)))); - - callIT(0xA9, 0x01); - - dStatusDump(); dIdataDump(); - - printf("%x\n", (IT + 31)); - - return 0; +#include"headers/include.h" +#include"headers/debug.h" + +int main(int argc, char *argv[]){ + initInstructionTable(); + + uintptr_t* a; + Addressing* b; + for(int i = 0; i < 256; i++){ + a = InstructionTable + (i * sizeof(uintptr_t)); + printf("\t%x", *a); if(*a < 0x10) printf("\t"); + if ((i % 4) == 3) printf("\n"); + } + for(int i = 0; i < 256; i++){ + b = InstructionTable + (256 * sizeof(uintptr_t)) + (i * sizeof(Addressing)); + printf("\t%x", *b); if(*b < 0x10) printf("\t"); + if ((i % 4) == 3) printf("\n"); + } + printf("\n"); + + dStatusDump(); dIdataDump(); printf("\n"); + callInstructionTable(0x00, 0x01); + dStatusDump(); dIdataDump(); printf("\n"); }
\ No newline at end of file |