summaryrefslogtreecommitdiff
diff options
context:
space:
mode:
authoralekseiplusplus <alekseijeaves@protonmail.com>2023-04-21 03:44:47 +1000
committeralekseiplusplus <alekseijeaves@protonmail.com>2023-04-21 03:44:47 +1000
commitee742e6020248f9695cc9ce5bbace5f42814383e (patch)
treed8be3463f30027c965e821ac63b8b6eae047390d
parentc4c28762385c52d0c349da72e3f3bbed64197411 (diff)
have to call it a night.
-rw-r--r--.gitignore4
-rw-r--r--ToDo2
-rw-r--r--assembler.c2
-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.c323
-rw-r--r--interpreter.c4
-rw-r--r--main.c6
-rw-r--r--makefile3
-rw-r--r--test.c45
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
diff --git a/ToDo b/ToDo
index b5c1cc3..74d2dfa 100644
--- a/ToDo
+++ b/ToDo
@@ -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;
diff --git a/main.c b/main.c
deleted file mode 100644
index 1df62a0..0000000
--- a/main.c
+++ /dev/null
@@ -1,6 +0,0 @@
-#include"include.h"
-#include"debug.h"
-
-int main(int argc, char *argv[]){
-
-} \ No newline at end of file
diff --git a/makefile b/makefile
index 41cddbc..636b454 100644
--- a/makefile
+++ b/makefile
@@ -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
diff --git a/test.c b/test.c
index 29b327b..7da793c 100644
--- a/test.c
+++ b/test.c
@@ -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