replace all the stub please, spammer will be reported, don't copy others' answer because it's wrong!

#include #include // For error exit()

// CPU Declarations -- a CPU is a structure with fields for the // different parts of the CPU. // typedef short int Word; // type that represents a word of SDC memory typedef unsigned char Address; // type that represents an SDC address

#define MEMLEN 100 #define NREG 10

struct CPU { Word mem[MEMLEN]; Word reg[NREG]; // Note: "register" is a reserved word Address pc; // Program Counter int running; // running = 1 iff CPU is executing instructions Word ir; // Instruction Register int instr_sign; // sign of instruction int opcode; // opcode field int reg_R; // register field int addr_MM; // memory field }; typedef struct CPU CPU;

// Prototypes [note the functions are also declared in this order] // // *** STUB *** Lab 5 items omitted ....

int read_execute_command(CPU *cpu); int execute_command(char cmd_char, CPU *cpu); void help_message(void); void many_instruction_cycles(int nbr_cycles, CPU *cpu); void one_instruction_cycle(CPU *cpu);

void exec_HLT(CPU *cpu); // *** STUB ***

// Main program: Initialize the cpu, and read the initial memory values. // Then run the command loop to let the user execute the program. // int main(int argc, char *argv[]) { printf("SDC Simulator pt 2 for ***Your name, Lab section *** "); // STUB CPU cpu_value, *cpu = &cpu_value;

// *** STUB *** Lab 5 items omitted (initialize CPU and memory) ....

// Run the command loop // char *prompt = "> "; printf(" Beginning execution; type h for help %s", prompt);

int done = read_execute_command(cpu); while (!done) { printf("%s", prompt); done = read_execute_command(cpu); } return 0; }

// *** STUB *** Rest of Lab 5 items omitted // (initialize_control_unit, ..., print_instr)

// Read a simulator command from the keyboard (q, h, ?, d, number, // or empty line) and execute it. Return true if we hit end-of-input // or execute_command told us to quit. Otherwise return false. // int read_execute_command(CPU *cpu) { // Buffer to read next command line into #define CMD_LINE_LEN 256 char cmd_line[CMD_LINE_LEN]; char *read_success; // NULL if reading in a line fails.

int nbr_cycles; // Number of instruction cycles to execute char cmd_char; // Command 'q', 'h', '?', 'd', or ' ' int done = 0; // Should simulator stop?

read_success = fgets(cmd_line, CMD_LINE_LEN, stdin);

// *** STUB *** done if we have we hit eof

// *** STUB *** // while not done, // Handle q, h, ?, d commands, integer (nbr of instruction cycles), // or empty line (one instruction cycle) // Read next command line, check for eof

return done; }

// Execute a nonnumeric command; complain if it's not 'h', '?', // 'd', 'q' or ' '. Return true for the q command, false otherwise. // int execute_command(char cmd_char, CPU *cpu) { if (cmd_char == '?' || cmd_char == 'h') { help_message(); } // *** STUB **** return 0; }

// Print standard message for simulator help command ('h' or '?') // void help_message(void) { // *** STUB **** }

// Execute a number of instruction cycles. Exceptions: If the // number of cycles is

// *** STUB **** }

// Execute one instruction cycle // void one_instruction_cycle(CPU *cpu) { // If the CPU isn't running, say so and return. // If the pc is out of range, complain and stop running the CPU. // // *** STUB ****

// Get instruction and increment pc // // For printing purposes, we'll save the location of // the instruction (the pc before the increment). // int instr_loc = cpu -> pc; cpu -> ir = cpu -> mem[cpu -> pc]; (cpu -> pc)++;

// Decode instruction into opcode, reg_R, addr_MM, and instruction sign // // *** STUB ****

// Echo instruction // *** STUB ***

switch (cpu -> opcode) { case 0: exec_HLT(cpu); break; // *** STUB **** default: printf("Bad opcode!? %d ", cpu -> opcode); } }

// Execute the halt instruction (make CPU stop running) // void exec_HLT(CPU *cpu) { // *** STUB *** Print a message? cpu -> running = 0; }

For this lab, you have to add a command-processing loop: You read a line containing a simulator command and execute it, read another line and execute it, and so on until you are given the quit command. There are six commands q for quit, d for dump control ut and memory, h and ? for help, an integer (to execute that many instruction cycles), or an empty line (to execute one instruction cycle) 1. To start the command loop, prompt for and read a command line. (You'll want to use the fgets /sscanf technique from the previous lab.) See if the line is empty or has a command. If you hit end-of-file on standard input, exit the program 2. For command q, note that you've seen a quit command and exit the program. (Don't dump things back out, just quit.) 3. For command d, dump out the control unit and the memory values. 4. For h or 2, print out a help message. 5. For an integer (let's call it N), execute the instruction cycles that many times but make sure N is reasonable first. For this lab, you have to add a command-processing loop: You read a line containing a simulator command and execute it, read another line and execute it, and so on until you are given the quit command. There are six commands q for quit, d for dump control ut and memory, h and ? for help, an integer (to execute that many instruction cycles), or an empty line (to execute one instruction cycle) 1. To start the command loop, prompt for and read a command line. (You'll want to use the fgets /sscanf technique from the previous lab.) See if the line is empty or has a command. If you hit end-of-file on standard input, exit the program 2. For command q, note that you've seen a quit command and exit the program. (Don't dump things back out, just quit.) 3. For command d, dump out the control unit and the memory values. 4. For h or 2, print out a help message. 5. For an integer (let's call it N), execute the instruction cycles that many times but make sure N is reasonable first