Project - Instruction Cycle
Goal
The goal of this program is to simulate a simple computer processor. The processor will read a program consisting of 32-bit instructions, decode each instruction, and then perform each operation and store the values in registers. Registers are temporary storage locations often referenced by names such as R0, R1, R2, etc. The program will allow users to run a binary program on a set of registers and display the results, mimicking a real computer!

When C programs (and many other languages) are compiled, they are converted to instructions — simple operations that processors execute. Most instructions specify an operation to be performed and the data to be used in that operation. Processors often store data in registers — temporary storage locations that are referenced by name or number in the instruction, as shown in the example below. This instruction adds the contents of registers 0 and 1 (the source operands) and stores the result in register 2 (the destination operand):


ADD R2, R0, R1

In practice, each instruction is encoded as a bit sequence; the processor decodes those bits to determine the operation and operands used for each instruction. Each possible operation is assigned a number, or opcode — for example, 1 might represent addition. Registers are usually referred to by a number.

---

Please place this header in all of your java source files:

/* PROGRAMMER:
 * CLASS: AP Computer Science
 * ASSIGNMENT:
 *
 * CERTIFICATION: I certify that this work is my own and that
 *                none of it is the work of any other person.
 */


Specification
Use the following steps to guide your program development. Pay attention to data types and the necessary arithmetic operations. Test your programs thoroughly! This means trying a variety of input values within the possible range described below.

Create a new Netbeans Project called LastNameFirstInitial_Project4, where LastName is your last name.
Create the following classes and implement them using the descriptions provided.
Test your program on multiple inputs and validate that all methods, constructors, and functionalities work as intended.
All classes described below may have any number of methods or instance variables created or used, as long as it follows the Java standards learned in class.

Class: Registers
Registers are temporary storage directly on a CPU. This allows for extremely fast computation without the need to ask for data from RAM. This class will represent a set of registers that will be used in a given program and its instructions.

Registers should hold a given number of int values in a single instance variable.
A program should always know the next instruction to execute.
A special register called the Program Counter should exist to keep track of the next instruction to be run.
Create a default constructor that should assume 32 registers all containing a value of 0.
Create a constructor that accepts a number of registers and sets all their values to 0.
A method should exist that accepts a register number and returns the value stored within it.
A method should exist that accepts a register number and value, and stores that value at the given register.
A method should exist that prints the contents of all registers in a format like:
	R0 = 1
	R1 = 1
	R2 = 5
	R3 = 10
…

Class: Instruction
An instruction is a single line of 32 binary digits that represents an operation to perform with values in registers and where to store the resulting value.  While real world CPU instructions are very complex and have a variety of formats, all instructions used in this project follow the same format which is:

	<Register> = <Register> <Operator> <Register>
			Or
	<Register> = <Register> <Operator> <Value>
			Or
	<Operator> <Register> <Value>

For example:
	R0 = R1 - R3
	R2 = R3 << 4
	LD R4 15
	R2 = R0 + R32

All Instructions should maintain their binary representation in an instance variable.
Create a constructor that accepts a binary representation of an instruction to be kept.
Most binary instructions can be broken down into the following sections:

   example: 00001 000010 000000 100000 000000000
  operation   destination    src1     src2    shift amount
   5 bits   |   6 bits    | 6 bits | 6 bits |    9 bits

An Instruction should be able to print out its binary representation
Depending on the operation, the binary can be broken into its respective parts
Destination
Source 1
Source 2
Shift amount
An instruction should be able to be executed, given a set of registers to manipulate
Create a method that accepts a Registers object. The evaluation of the instruction will affect only these registers.
An Instruction should be able to print out its human-readable representation, which follows the format:
<Register> = <Register> <Operator> <Register>
E.g. R5 = R4 * R4
Note: based on which operation is being executed, show the appropriate symbol

The following are all valid operations and their decimal equivalent values that may be used in an instruction:

ADD (+) → 1 → adds two values together
E.g. destination = source1 + source2
SUB (-) → 2 → subtracts two values
E.g. destination = source1 - source2
MULT (*) → 3 → multiplies two values together
E.g. destination = source1 * source2
DIV (/) → 4 → divides two values
E.g. destination = source1 / source2
LEFT SHIFT (<<)→ 5 → shifts the source1 value binary left by the shift amount given
E.g. destination = source1 << shftAmt
Example: 1001b << 1 ⇒ 10010b
Example: 10b << 3 ⇒ 10000b
RIGHT SHIFT (>>) → 6 → shifts the source1 value binary right by the shift amount given
E.g. destination = source1 >> shftAmt
Example: 1010b >>1 ⇒ 101b
Example: 101101b >> 3 ⇒ 101b
ROTATE (ROT) ⁠⁠⁠→ 7 → rotates the source1 value binary right by the shift amount. Bits on the right end of the value move to the left of the value.
E.g destination = source1 ROT shftAmt
Example: 11001b ROT 3 ⇒ 00111b
Example: 1001b ROT 1 ⇒ 1100b
LOAD (LD) → 8 → loads the shift amount value into the destination register. Both sources are ignored.
E.g. destination = shftAmt
JUMP (JMP) → 9 → sets the next instruction to run to the shift amount if the value in source 1 is equal to the value in source 2. The destination register is ignored.
E.g. JMP R0 R4 7

Class: Program
A Program will represent a set of related and ordered instructions that are to be run sequentially.

A program must keep track of the Registers it is using during its execution.
A program should keep track of all instructions that are part of the program in an instance variable.
Create a method to add a single instruction to your program.
An instruction added to the program should be the last instruction in the collection of instructions that exists.
Because you do not know how many instructions will be added, you must be aware of how many instructions currently exist, how many can still be added safely, and if necessary expand how much space is available so new instructions can be added. (Arrays are fixed size, so how do you handle this?)
Programs should have a method called execute that accepts no parameters, but runs every instruction one at a time.
Display what number instruction you are running
Display the binary representation of the instruction
Display the human-readable representation of the instruction
Execute the instruction on the existing registers
Example output:

		Instruction 1: 00000100010000000000100000000000
R2 = R0 + R1

Instruction 2: 00000100011000010001000000000000
R3 = R1 + R2

Instruction 3: 00000100100000100001100000000000
R4 = R2 + R3


Class: ProgramTester

Program Tester will read two files to set up our simulation. The first file will be used to create a set of Registers and load them with initial values. The second file will be the binary instructions that can be passed into a Program. Once both are read, the program can be executed.

Create a Scanner to read the register init file.
A register init file will have the following format:
The first line is a single number: the number of registers that can be used.
Then each subsequent line will be an integer value that represents the initial value for each register, starting with register 0. There will be exactly as many values/lines as the number given in the first line of the file.
Create a Registers object from the information in the given register init file.
Print the contents of the registers to verify the initialization and file reading went correctly.
Create a Scanner to read the program binary file.
A program binary file will be any number of lines where each line is a single binary string of 32-bits.
Create a Program object and add each line read from the file to it.
Execute the program using your execute method.
Print the contents of the registers to verify their contents after all operations have occurred.