simulator.c

#include "simulator.h"

int parseArgument(char * arg) {
	if (strcmp(arg, "--debug") == 0 || strcmp(arg, "-d") == 0) {
		enableDebugMode();
		return 0;
	} else {
		char * flag_name = strtok(arg, "=");
		char * flag_value = strtok(NULL, "=");
		int flag_intValue;
		if (strcmp(flag_name, "--timer") == 0 || strcmp(flag_name, "-t") == 0) {
			if (flag_value != NULL) flag_intValue = getInteger(flag_value);
			if (flag_intValue >= 1 && flag_intValue <= 1024) {
				enableTimer();
				setTimeSlice(flag_intValue);
				return 0;
			} else if (flag_intValue != 0) {
				printf("Invalid arguement %d to timer flag. Timer value should be between 0 and 1024\n", flag_intValue);
				return -1;
			} else {
				disableTimer();
				return 0;
			}
		} else {
			printf("Invalid arguement %s", arg);
			return -1;
		}
	}
}

int main(int argc, char **argv) {
	initializeDebug();
	int i = 1;
	while (i < argc) {
		if (parseArgument(argv[i++]) == -1) exit(0);
	}
	initializeRegisters();
	run(isTimerEnabled());
}



/*
 *	This function does the following:
 *		1. Loads OS Startup Code.
 *		2. Copies the instruction to be parsed as per the address specified by the IP register.
 *		3. Checks whether interrupt is disabled. If not th clock ticks.
 *		4. Begins the lexical analysis by getting the first token and passing it as arguement to executeOneInstruction.
 *		5. If step flag is enabled enters debug mode
 *		6. Finally checks if time slice allocated is over or not. If yes and mode is user mode ,and if interrupt is enabled then
 *			INT 0 code is run.
 */
void run(int is_timer_enabled) {
	if (is_timer_enabled) resetTimer();
	loadStartupCode();
	int instr;
	while (1) {
		YY_FLUSH_BUFFER;
		if (getInstruction(instruction) == -1) continue;	//gets the next instruction in variable instruction		
		instr = yylex();
		if (mode == USER_MODE && is_timer_enabled) timerTick();
		executeOneInstruction(instr);
		if ((watch_count > 0 && checkWatch() == 1) || step_flag == 1) debugInterface();
		if (isTimerCountZero() && is_timer_enabled && mode == USER_MODE) {
			resetTimer();
			invokeHardwareInterrupt(0);
			if (step_flag == 1) printf("TIMER Interrupt\n");
		}
	}
}



/*
 *	This code is used to execute each instruction.
 */
void executeOneInstruction(int instr) {
	int X, Y, flagX1, flagX2, flagY1, flagY2, operation;
	char string[WORD_SIZE];
	bzero(string, 16);
	switch (instr) {
		case START:
			storeInteger(reg[IP_REG], getInteger(reg[IP_REG]) + WORDS_PER_INSTR);	//increment IP
			break;
		case MOV:						//1st phase:get the value		2nd phase:store the value
			X = yylex();
			flagX1 = yylval.flag;
			flagX2 = yylval.flag2;
			Y = yylex();
			flagY1 = yylval.flag;
			flagY2 = yylval.flag2;
			strcpy(string, yylval.data);
			if (!performMOV(X, flagX1, flagX2, Y, flagY1, flagY2, string)) return;
			storeInteger(reg[IP_REG], getInteger(reg[IP_REG]) + WORDS_PER_INSTR);
		break;
		case ARITH:
			operation = yylval.flag;
			X = yylex();
			flagX1 = yylval.flag;
			if (operation != INR && operation != DCR) {
				Y = yylex();
				flagY1 = yylval.flag;
			}
			if (!performArithmetic(X, flagX1, Y, flagY1, operation)) return;
			storeInteger(reg[IP_REG], getInteger(reg[IP_REG]) + WORDS_PER_INSTR);
		break;
		case LOGIC:
			operation = yylval.flag;
			X = yylex();
			flagX1 = yylval.flag;
			Y = yylex();
			flagY1 = yylval.flag;
			if (!performLogic(X, flagX1, Y, flagY1, operation)) return;
			storeInteger(reg[IP_REG], getInteger(reg[IP_REG]) + WORDS_PER_INSTR);
		break;
		case BRANCH:
			operation = yylval.flag;
			X = yylex();
			flagX1 = yylval.flag;
			if (operation != JMP) {
				Y = yylex();
				flagY1 = yylval.flag;				
			}
			if (!performBranching(X, flagX1, Y, flagY1, operation)) return;
			break;
								
		case PUSH:
			X = yylex();
			flagX1 = yylval.flag;
			if (!performPush(X, flagX1)) return;
			storeInteger(reg[IP_REG], getInteger(reg[IP_REG]) + WORDS_PER_INSTR);
			break;
			
		case POP:
			X = yylex();
			flagX1 = yylval.flag;
			if (!performPop(X, flagX1)) return;
			storeInteger(reg[IP_REG], getInteger(reg[IP_REG]) + WORDS_PER_INSTR);
			break;

		case CALL:
			X = yylex();
			flagX1 = yylval.flag;
			if (!performCall(X, flagX1)) return;
			break;

		case RET:
			if (!performRet()) return;
			break;

		case INT:
			X = yylex();
			flagX1 = yylval.flag;
			if (!performINT(X, flagX1)) return;
			break;

		case IRET:
			if (!performIRET()) return;
			break;

		case IN:
			X = yylex();
			flagX1 = yylval.flag;
			if (!performIN(X, flagX1)) return;
			storeInteger(reg[IP_REG], getInteger(reg[IP_REG]) + WORDS_PER_INSTR);
			break;
		
		case OUT:
			X = yylex();
			flagX1 = yylval.flag;
			if (!performOUT(X, flagX1)) return;
			storeInteger(reg[IP_REG], getInteger(reg[IP_REG]) + WORDS_PER_INSTR);
			break;

		case LOAD:
		case STORE:
			X = yylex();
			flagX1 = yylval.flag;
			Y = yylex();
			flagY1 = yylval.flag;
			if (!performLoadStore(X, flagX1, Y, flagY1, instr)) return;
			storeInteger(reg[IP_REG], getInteger(reg[IP_REG]) + WORDS_PER_INSTR);
			break;
				
		case HALT:
			if (mode == USER_MODE) {
				raiseException(newException(EX_ILLINSTR, "Call to Privileged Instruction HALT in USER mode", 0));
				return;
			}
			printf("Machine is halting\n");
			exit(0);
			break;
		case END:
			break;
		
		case BRKP:
			if (isDebugModeOn()) {
				step_flag = 1;
				printf("\nXSM Debug Environment\nType \"help\" for getting a list of commands\n");
			}
			storeInteger(reg[IP_REG], getInteger(reg[IP_REG]) + WORDS_PER_INSTR);
			break;
		default:
			raiseException(newException(EX_ILLINSTR, "Illegal Instruction", 0));
			return;
	}
}