c spec idea

Spec idea:

DATA STUFF

struct ProcessorState
	Represents a processor; registers and memory.
	Let's keep the PC incremented to the actual value it's supposed to have in a real arm processor (current instruction +8).
		If the first instruction after a jump is another jump (or if the first instruction of a program is a jump) this might cause a problem (?)
		since in an actual execution the offset starts at 0 and moves to +8 after two instructions. decode() should probably account for this.
	
	struct ProcessorState
	{
  		uint32_t registers[17];
  		uint32_t memory[MEMORY_SIZE];
	};	
	
	IMPLEMENTED
	
Remember to check memory's bounds before accessing it!

Use uint32_t to represent data/instructions/register values
Use bool to represent booleans and int (if you want) to represent anything that doesn't need more than 16 bits (apparently ints can be only 16 bits on some systems)


NON-HELPER FUNCTIONS

main
	uses: loadBinary(...), step(...)

void step(struct ProcessorState *processor)
	Decodes the next instruction and calls the appropriate method to execute it. Handles the PC's offset.
	uses: dataProcessingInstr(...), multiplyInstr(...), dataTransferInstr(...), branchInstr(...)
	
void dataProcessingInstr(struct ProcessorState *processor, int address)
	Executes a data processing instruction stored in processor->memory[address]
	uses: isValidCond(...), barrelShift(...), applyOperation(...)
int32_t applyOperation(int opcode, int32_t operand1, int32_t operand2, int *carry, int *store)
	Applies a binary operation (from an opcode) on two operators. Returns the result, and sets the supplied carry bit if it makes sense to do so.
	Doesn't change the carry bit when performing a logical operation.
	IMPLEMENTED, needs tests


void multiplyInstr(struct ProcessorState *processor, int address)
	Executes a multiplication instruction stored in (*processor).memory[address]
	uses: isValidCond(...)
	
void dataTransferInstr(struct ProcessorState *processor, int address)
	Executes a single data transfer instruction stored in (*processor).memory[address]
	uses: isValidCond(...), barrelShift(...)

void branchInstr(stuct ProcessorState *processor, int address)
	Executes a single branch instruction stored in (*processor).memory[address]
	uses: isValidCond(...),

	
struct ProcessorState *loadBinary(char* src)
	creates a new ProcessorState and loads its memory from a binary file.
	It's probably a good idea for this to check the edianness of the computer the emulator is running on (which is apparently possible at runtime) and flip the
	binary data accordingly when loading it, as things would get really confusing otherwise (operations like arithmetic right shifts wouldn't work properly, I think)


HELPER FUNCTIONS (probably used in more than one method):

uint32_t getBits(uint32_t source, int start, int end)
	Reads bits from source in the range [start, end] (inclusive). Returns a uint32_t with the result as its least significant bits.
	(e.g. getBits(8, 2, 3) == 2 because 8 == 0000'10'00)
	IMPLEMENTED, TESTED

int isSet(uint32_t source, int index)
	Shorthand for getBits(source, index, index)
	IMPLEMENTED, TESTED

int validCond(uint32_t cond, struct ProcessorState *processor)
	Returns 1 if the condition code 'cond' is satisfied by the processor's current state, and 0 otherwise.
	IMPLEMENTED

uint32_t barrelShift(int immediate, uint32_t operand, int *carry, struct ProcessorState *processor)
	Implements the functionality of the barrel shifter. The carry output is written to (*carry), just in case you need it.
	NOTE: for some reason the I bit is used in opposite ways for data processing instructions vs for data transfer instructions. Arbitrarily, this method
	uses the data processing instruction interpretation (so for data transfer instructions just call this method with !I).
	IMPLEMENTED, TESTED

struct ProcessorState *makeProcessor(void)
	Creates a new processor struct. Dynamically allocated, so don't forget to use free() at the end!
	IMPLEMENTED

(optionally)
int32_t *accessMemory(struct ProcessorState *processor, int address)
	Gets an address from memory while ensuring it's not out of bounds
	(only if you want; you can always do bounds checking manually)



TESTING STUFF:
void test(bool pass, char *testname)
	prints out a formatted message stating the test name and whether it passed.
	IMPLEMENTED

uint32_t bin(char* number)
	converts a string representing a binary number (e.g. "01001") to a number. For testing purposes.
	Ignores spaces and leading zeros, so you can format it like the instructions ("0001 0 00 1 0000").
	Doesn't actually check the input at all, so only use it for testing.
	IMPLEMENTED

implemented tests:
void testBitGetters(void)
void testBarrelShifter(void)

tests still needed:
applyOperation (and maybe validCond, but it's quite a simple function so idk)



Put other stuff you've implemented here!