Specifications for the Computer Class

Public static constants: Constants are needed to represent the size of memory (which will be 32), each machine language instruction (such as HALT = 0, LDA = 1, STA = 2, and so on), and status information. Use a different integer value for each. The main program should use the status constants when checking the status returned by the loadProgram method and the runProgram method. Use the following status constants.

• SUCCESS - a value that represents a successful operation (such as loading or running a program)
• OUT_OF_MEMORY - a value that is returned when the user tries to load a program that is too long
• INVALID_OPCODE - a value returned when the operation code for an instruction is invalid (the valid values are 0 - 6).
• INVALID_PC_ADDRESS - a value returned when a memory address in the program counter is invalid (valid memory addresses will be in the range 0 up to but not including the length of the current program - a program may not use memory outside of its allocated space).
• INVALID_OP_ADDRESS - a value returned with a memory address for the operand is invalid.

Instance Variables: The class must have the following instance data.

• A variable of type int representing the program counter.
• A variable of type int representing the instruction register.
• A variable of type int representing the accumulator.
• An array of ints representing memory.
• A variable of type int representing the length of the current program.

Public Methods: The class must have the following public methods.

• A constructor that takes no parameters. The constructor instantiates the memory array to contain 32 values of type int.

• A toString method that returns a String representation of the state of the computer. The string should show the contents of memory currently being used by the program, and the current values of the program counter, instruction register, and accumulator, all appropriately labeled. Here's an example (this would be the state of the computer after running example #1 on the Assignment #4 handout) of a possible format for the string returned.

  Memory Address     Contents
        0	   	     5
        1		     3
        2		     100
        3		     301
        4	 	     206
        5	     	     0
        6		     8
  
  Program Counter: 6
  Instruction Register: 0
  Accumulator: 8
  
  

• A method loadProgram that takes no parameters and returns a status value (an int). The status returned should indicate either a successful load (return the constant SUCCESS) or an unsuccessful load (in this case the problem would be running out of memory so the constant OUT_OF_MEMORY should be returned). The load method will prompt the user to enter in the machine code for the program one line at a time followed by a -1 to indicate all instructions have been entered. The method should use a sentinel controlled while loop that reads the values and stores them in the memory array, making sure that the user does not enter more values than the array holds. If the user tries to add more instructions than memory holds the status should be set to OUT_OF_MEMORY; otherwise the method should prompt the user to enter the address of the first executable instruction in the program. That value is read in and stored in the program counter. The method should return the status (either SUCCESS or OUT_OF_MEMORY).

• A method runProgram that takes no parameters and simulates the fetch-execute cycle of the computer. This method will call private methods to perform the individual tasks in the fetch-execute cycle. The method must return a status value (an int that will have one of four values - SUCCESS, if all went well, INVALID_PC_ADDRESS, if an invalid address is encountered in the program counter, INVALID_OPCODE, if an instruction with an invalid operation code was encountered, or INVALID_OP_ADDRESS, if an invalid memory address was encountered). These status values will be returned to this method from the private methods (below).

• Getter methods for the program counter and the instruction register.

Private methods: The class should have the following helper methods that will be called by the runProgram method.

• fetch() - simulates the "fetch" part of the fetch-execute cycle. It checks to make sure the current value in the program counter is a valid memory reference (it must be in the range of 0 up to the length of the current program); if it is, it stores the value in memory at that address in the instruction register and increments the program counter. If it isn't valid, a status of INVALID_PC_ADDRESS should be returned; otherwise the SUCCESS status should be returned.

• decodeExecute() - simulates the "decode the instruction and send signals to execute it" part of the fetch-execute cycle. The method should return one of the following ints: INVALID_OPCODE (if the integer in the instruction register does not have a valid opcode (0 - 6)), INVALID_OP_ADDRESS (if the address part is out of the range for the program), HALT (if the instruction is the HALT instruction), or SUCCESS (if the instruction was correct and not the HALT instruction). The method gets the opcode from the instruction in the instruction register (think about how to use integer division / to get the first digit, the hundreds digit, in a 3-digit number). If the opcode is not valid the status should be set to INVALID_OPCODE. If it is valid, the method should then get the address of the operand (how can you use % to get the last two digits?). If it is not valid the status should be set to INVALID_OP_ADDRESS. If both the opcode and operand are valid (the status is SUCCESS) and the instruction is not the halt instruction, the appropriate method is called to execute the instruction. The method returns the integer representing HALT or the status.

• A method for each machine language instruction (except halt). Each method takes one integer parameter representing the address of the instruction operand. Since the decodeExecute method has already checked the validity of the address, these methods just needs to "execute" the instruction (for example, all the load method does is put the value from memory at the given address in the accumulator). These methods will have void return type.