work in progress

6 files changed, 290 insertions, 243 deletions

diff --git a/README.md b/README.md
index f86fda3..1f018ad 100644
--- a/README.md
+++ b/README.md
@@ -8,8 +8,12 @@ My emulator has a handful of specific milestones to achieve that will demonstrat
 2. Run a system monitor program correctly.
 3. Successfully run a BASIC program in Wozniak's BASIC interpreter.
 
+Restrictions of my emulator include:
+
+1. No plans to support illegal instructions as of yet.
+
 Planned core features for the emulator include:
 
 1. A terminal emulator with the original Apple I font.
-2. An emulation of the Apple I cassette reader peripheral, which will let binary files be given as input.
-3. A seperate assembler program so the user may write their own programs to read into the emulator.
\ No newline at end of file
+2. A program to read binary files straight to memory.
+3. An extremely simple assembler so the user may write programs to read into the emulator.
\ No newline at end of file
diff --git a/ToDo b/ToDo
new file mode 100644
index 0000000..b5c1cc3
--- /dev/null
+++ b/ToDo
@@ -0,0 +1,10 @@
+Before the next commit, this should all be completed.
+
+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
diff --git a/a.out b/a.out
deleted file mode 100755
index 82d3b80..0000000
--- a/a.out
+++ /dev/null
diff --git a/instruction-bin.c b/instruction-bin.c
new file mode 100644
index 0000000..d470c74
--- /dev/null
+++ b/instruction-bin.c
@@ -0,0 +1,256 @@
+#include"include.h"
+
+void setIT(int i, uintptr_t p, Addressing r);
+void setAllIT();
+
+int main(){
+	setAllIT();
+	// 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++){
+		fputc(*c, fs);
+	}
+	fclose(fs);
+}
+
+void setIT(int i, uintptr_t p, Addressing r){
+	uintptr_t* p1 = (IT + (sizeof(uintptr_t)*i));
+	*p1 = p;
+
+	Addressing* r1 = (IT + (sizeof(uintptr_t)*256) + (sizeof(Addressing)*i));
+	*r1 = r;
+}
+
+void setAllIT(){
+	IT = 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);
+	// 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);
+	// 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);
+	// 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);
+	// fSTX(Addressing, address);
+	setIT(0x86, (uintptr_t)&fSTX, eZeroPage);
+	setIT(0x96, (uintptr_t)&fSTX, eZeroPageIndexedX);
+	setIT(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);
+
+	// 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);
+	// 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);
+
+	//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);
+	//INX(Addressing, address);
+	setIT(0xE8, (uintptr_t)&fINX, eImplied);
+	//INY(Addressing, address);
+	setIT(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);
+	//DEX(Addressing, address);
+	setIT(0xCA, (uintptr_t)&fDEX, eImplied);
+	//DEY(Addressing, address);
+	setIT(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);
+	//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);
+	//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);
+
+	// Jump, Branch, Compare, and Test Bits
+	//JMP(Addressing, address);
+	setIT(0x4C, (uintptr_t)&fJMP, eAbsolute);
+	setIT(0x6C, (uintptr_t)&fJMP, eIndirectAbsolute);
+	//BCC(Addressing, address);
+	setIT(0x90, (uintptr_t)&fBCC, eRelative);
+	//BCS(Addressing, address);
+	setIT(0xB0, (uintptr_t)&fBCS, eRelative);
+	//BEQ(Addressing, address);
+	setIT(0xF0, (uintptr_t)&fBEQ, eRelative);
+	//BNE(Addressing, address);
+	setIT(0xD0, (uintptr_t)&fBNE, eRelative);
+	//BMI(Addressing, address);
+	setIT(0x30, (uintptr_t)&fBMI, eRelative);
+	//BPL(Addressing, address);
+	setIT(0x10, (uintptr_t)&fBPL, eRelative);
+	//BVS(Addressing, address);
+	setIT(0x70, (uintptr_t)&fBVS, eRelative);
+	//BVC(Addressing, address);
+	setIT(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);
+	//CPX(Addressing, address);
+	setIT(0xE0, (uintptr_t)&fCPX, eImmediate);
+	setIT(0xE4, (uintptr_t)&fCPX, eZeroPage);
+	setIT(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);
+	//BIT(Addressing, address);
+	setIT(0x4C, (uintptr_t)&fBIT, eZeroPage);
+	setIT(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);
+	//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);
+	//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);
+	//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);
+
+	// Transfer Instructions
+	//TAX(Addressing, address);
+	setIT(0xAA, (uintptr_t)&fTAX, eImplied);
+	//TAY(Addressing, address);
+	setIT(0xA8, (uintptr_t)&fTAY, eImplied);
+	//TXA(Addressing, address);
+	setIT(0x8A, (uintptr_t)&fTXA, eImplied);
+	//TYA(Addressing, address);
+	setIT(0x98, (uintptr_t)&fTYA, eImplied);
+
+	// Stack Instructions
+	//TSX(Addressing, address);
+	setIT(0xBA, (uintptr_t)&fTSX, eImplied);
+	//TXS(Addressing, address);
+	setIT(0x9A, (uintptr_t)&fTXS, eImplied);
+	//PHA(Addressing, address);
+	setIT(0x48, (uintptr_t)&fPHA, eImplied);
+	//PHP(Addressing, address);
+	setIT(0x08, (uintptr_t)&fPHP, eImplied);
+	//PLA(Addressing, address);
+	setIT(0x68, (uintptr_t)&fPLA, eImplied);
+	//PLP(Addressing, address);
+	setIT(0x28, (uintptr_t)&fPLP, eImplied);
+
+	// Subroutine Instructions
+	//JSR(Addressing, address);
+	setIT(0x20, (uintptr_t)&fJSR, eAbsolute);
+	//RTS(Addressing, address);
+	setIT(0x60, (uintptr_t)&fRTS, eImplied);
+	//RTI(Addressing, address);
+	setIT(0x40, (uintptr_t)&fRTI, eImplied);
+
+	// Set/Reset Insutrctions
+	//CLC(Addressing, address);
+	setIT(0x18, (uintptr_t)&fCLC, eImplied);
+	//CLD(Addressing, address);
+	setIT(0xD8, (uintptr_t)&fCLD, eImplied);
+	//CLI(Addressing, address);
+	setIT(0x58, (uintptr_t)&fCLI, eImplied);
+	//CLV(Addressing, address);
+	setIT(0xB8, (uintptr_t)&fCLV, eImplied);
+	//SEC(Addressing, address);
+	setIT(0x38, (uintptr_t)&fSEC, eImplied);
+	//SED(Addressing, address);
+	setIT(0xF8, (uintptr_t)&fSED, eImplied);
+	//SEI(Addressing, address);
+	setIT(0x78, (uintptr_t)&fSEI, eImplied);
+
+	// NOP/BRK Instructions
+	//NOP(Addressing, address);
+	setIT(0xEA, (uintptr_t)&fNOP, eImplied);
+	//BRK(Addressing, address);
+	setIT(0x00, (uintptr_t)&fBRK, eImplied);
+}
+
+
diff --git a/instruction-init.h b/instruction-init.h
index adb5047..12cdfa4 100644
--- a/instruction-init.h
+++ b/instruction-init.h
@@ -6,15 +6,7 @@
 void* IT;
 void (*func)(Addressing, address);
 
-void setIT(int i, uintptr_t p, Addressing r){
-	uintptr_t* p1 = (IT + (sizeof(uintptr_t)*i));
-	*p1 = p;
-
-	Addressing* r1 = (IT + (sizeof(uintptr_t)*256) + (sizeof(Addressing)*i));
-	*r1 = r;
-
-	printf("DEBUG:\t%x\t%x -> %x\t%x -> %x\n", i, p1, *p1, r1, *r1);
-}
+#define InstructionTableSize (256*(sizeof(uintptr_t) + sizeof(Addressing)))
 
 /*
 uintptr_t getITFunction(int i){	//Segmentation fault is occurring here, likely in next one too
@@ -30,12 +22,25 @@ Addressing getITAddressing(int i){
 
 
 void callIT(int i, address val){
-	uintptr_t a = ((uintptr_t)IT + (sizeof(uintptr_t) * i));
+	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 initIT(){
+	IT = 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);
+	} //Investigate whether doing word sized units would increase speed
+	fclose(fs);
+	//read in the instruction data binary
+}
 
 
 
@@ -107,236 +112,5 @@ void fSEI(Addressing, address);
 void fNOP(Addressing, address);
 void fBRK(Addressing, address);
 
-void initIT(){	//Change this to load a binary file which contains this same information.
-					//So will need to dump the contents of IT at some point.
-	IT = 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);
-	// 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);
-	// 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);
-	// 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);
-	// fSTX(Addressing, address);
-	setIT(0x86, (uintptr_t)&fSTX, eZeroPage);
-	setIT(0x96, (uintptr_t)&fSTX, eZeroPageIndexedX);
-	setIT(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);
-
-	// 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);
-	// 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);
-
-	//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);
-	//INX(Addressing, address);
-	setIT(0xE8, (uintptr_t)&fINX, eImplied);
-	//INY(Addressing, address);
-	setIT(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);
-	//DEX(Addressing, address);
-	setIT(0xCA, (uintptr_t)&fDEX, eImplied);
-	//DEY(Addressing, address);
-	setIT(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);
-	//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);
-	//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);
-
-	// Jump, Branch, Compare, and Test Bits
-	//JMP(Addressing, address);
-	setIT(0x4C, (uintptr_t)&fJMP, eAbsolute);
-	setIT(0x6C, (uintptr_t)&fJMP, eIndirectAbsolute);
-	//BCC(Addressing, address);
-	setIT(0x90, (uintptr_t)&fBCC, eRelative);
-	//BCS(Addressing, address);
-	setIT(0xB0, (uintptr_t)&fBCS, eRelative);
-	//BEQ(Addressing, address);
-	setIT(0xF0, (uintptr_t)&fBEQ, eRelative);
-	//BNE(Addressing, address);
-	setIT(0xD0, (uintptr_t)&fBNE, eRelative);
-	//BMI(Addressing, address);
-	setIT(0x30, (uintptr_t)&fBMI, eRelative);
-	//BPL(Addressing, address);
-	setIT(0x10, (uintptr_t)&fBPL, eRelative);
-	//BVS(Addressing, address);
-	setIT(0x70, (uintptr_t)&fBVS, eRelative);
-	//BVC(Addressing, address);
-	setIT(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);
-	//CPX(Addressing, address);
-	setIT(0xE0, (uintptr_t)&fCPX, eImmediate);
-	setIT(0xE4, (uintptr_t)&fCPX, eZeroPage);
-	setIT(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);
-	//BIT(Addressing, address);
-	setIT(0x4C, (uintptr_t)&fBIT, eZeroPage);
-	setIT(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);
-	//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);
-	//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);
-	//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);
-
-	// Transfer Instructions
-	//TAX(Addressing, address);
-	setIT(0xAA, (uintptr_t)&fTAX, eImplied);
-	//TAY(Addressing, address);
-	setIT(0xA8, (uintptr_t)&fTAY, eImplied);
-	//TXA(Addressing, address);
-	setIT(0x8A, (uintptr_t)&fTXA, eImplied);
-	//TYA(Addressing, address);
-	setIT(0x98, (uintptr_t)&fTYA, eImplied);
-
-	// Stack Instructions
-	//TSX(Addressing, address);
-	setIT(0xBA, (uintptr_t)&fTSX, eImplied);
-	//TXS(Addressing, address);
-	setIT(0x9A, (uintptr_t)&fTXS, eImplied);
-	//PHA(Addressing, address);
-	setIT(0x48, (uintptr_t)&fPHA, eImplied);
-	//PHP(Addressing, address);
-	setIT(0x08, (uintptr_t)&fPHP, eImplied);
-	//PLA(Addressing, address);
-	setIT(0x68, (uintptr_t)&fPLA, eImplied);
-	//PLP(Addressing, address);
-	setIT(0x28, (uintptr_t)&fPLP, eImplied);
-
-	// Subroutine Instructions
-	//JSR(Addressing, address);
-	setIT(0x20, (uintptr_t)&fJSR, eAbsolute);
-	//RTS(Addressing, address);
-	setIT(0x60, (uintptr_t)&fRTS, eImplied);
-	//RTI(Addressing, address);
-	setIT(0x40, (uintptr_t)&fRTI, eImplied);
 
-	// Set/Reset Insutrctions
-	//CLC(Addressing, address);
-	setIT(0x18, (uintptr_t)&fCLC, eImplied);
-	//CLD(Addressing, address);
-	setIT(0xD8, (uintptr_t)&fCLD, eImplied);
-	//CLI(Addressing, address);
-	setIT(0x58, (uintptr_t)&fCLI, eImplied);
-	//CLV(Addressing, address);
-	setIT(0xB8, (uintptr_t)&fCLV, eImplied);
-	//SEC(Addressing, address);
-	setIT(0x38, (uintptr_t)&fSEC, eImplied);
-	//SED(Addressing, address);
-	setIT(0xF8, (uintptr_t)&fSED, eImplied);
-	//SEI(Addressing, address);
-	setIT(0x78, (uintptr_t)&fSEI, eImplied);
 
-	// NOP/BRK Instructions
-	//NOP(Addressing, address);
-	setIT(0xEA, (uintptr_t)&fNOP, eImplied);
-	//BRK(Addressing, address);
-	setIT(0x00, (uintptr_t)&fBRK, eImplied);
-}
\ No newline at end of file
diff --git a/makefile b/makefile
new file mode 100644
index 0000000..41cddbc
--- /dev/null
+++ b/makefile
@@ -0,0 +1,3 @@
+main:
+	gcc instruction-bin.c -o instruction-dump
+	gcc test.c -o main