/*  
 *  file: sos.c
 *  This is the bare-bones Simple Operating System (SOS)
 *  designed to run on the STM machine.
*/

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include "stm.h"
#include "sos.h"

/***************************************************
 * SOS Global Variables
 ***************************************************/

int
     maxinst = -1,       /* Maximum number of instructions */
     procindex = 0;      /* Index of process */

char procname[NAMESIZE];  /* name of process */

/***************************************************
 * Execute a trap 
 ***************************************************/

void exec_trap()
{ int iread, addr;
  char buf[128]; // buffer for string output
  char c;
  int i;

  if (debug) printf("Process %s index %i Trap: ", procname, procindex);
  switch(regs[15]) {
    case 0: 						// halt
	    terminate=1;
            if (debug) printf(" Terminate\n");
            break;
    case 1: 						// input trap
	    if (debug) printf("  >> INPUT TRAP:  regs[14]=%d, ", regs[14]);
            if (regs[14] == 0) {	// integer input
		iread = scanf("%i", &regs[13]);
	    	if (iread == 1) regs[12]=1;
		else if (iread==EOF) regs[12]=0;
            	else error=1;
	    } else {			// string input
		addr = regs[13];
		for (i=0; i< regs[14]; i++){
			scanf("%c", &c);
			mem[addr+i]=c;
			if ((c=='\0')|| (c=='\n') || (c==EOF)) break;
		}
		regs[12] = i;
		if (i==0) error=0;
	    }
            break;
    case 2:						// output trap
	    iread = regs[14];
	    if (debug) printf("\n  >> OUTPUT TRAP:  regs[14]=%d, ", iread);
	    if (iread==0) {		// integer output
		printf("%i \n", regs[13]);
		regs[12] = 1;
	    } else {			// string output
	 	addr = regs[13];
		for (i=0; i< iread; i++) {
		   c = (char)mem[addr+i];
		   if ((c == EOF) || (c=='\0')) break;
		   else buf[i]=c;
		}
		buf[i] = '\0';
		regs[12] = i;		// number of characters read 
		printf("%s", buf);	// output string
	    }
	    break;
   case 10:  						//memory dump
	    if (debug) printf("\n MEMORY DUMP \n");
	    addr = regs[14];				//start address
	    iread = regs[13];				//size of dump
	    for (i=0; i<iread; i++) {
	      printf("Loc %i : %i\n", i, mem[i+addr]);
	    }
	    break;
   default: printf("Invalid trap code\n");
            error=1;
            break;
    }
 }
 
/* PARSING for sos */

int parse_flags(int argc, char* argv[])

{ int ibase = 0, idebug = 0, imax=0, ifilename=1;
            /* Positions of arguments in command line */
  int i;

  for (i=1; i<9; i=i+2) {
     if (argv[i][0] == '-') 
        switch (argv[i][1]) {
           case 'b': ibase = i+1; break;
           case 'd': idebug = i+1; break;
           case 'm': imax = i+1; break;
          }
     else {
       ifilename = i;
       break;
       }
    }
  if (ibase) base=atoi(argv[ibase]);
  if (idebug) debug=atoi(argv[idebug]);
  if (imax) maxinst=atoi(argv[imax]);
  return(ifilename);
}


/* Load the STML code into memory */
/* It is assumed that STML files are correctly formatted; therefore,
   this does no error checking */
/* NOTE: You are allowed to change this function for project 1; however,
   there is no need to do so. */

void load_stm(filename)
char filename[];

{ int count = base, /* Address */
      inst;  /* Instruction */
  char line[240];  /* max length of line in STM file */
  int i;
  FILE *fp;

  fp = fopen(filename, "r");            /* Open the STM file */
  if (fp == NULL)
    { printf("File name error %s\n", filename);
      error = 1;
    }
  fgets(procname, NAMESIZE, fp);  /* read process name */
// printf("work? %s", procname);  // this works...
  procname[strlen(procname)-1] = '\0';  /* get rid of carriage return at end */
// bug?  Seems to cause problems
  fgets(line,240,fp);             /* read length of partition */
  limit=atoi(line);
  if (debug == 2) { 
//strcpy(procname,"test");  // this works...
     printf("Process %s index %i loading from base %i length %i\n", 
            procname, procindex, base, limit);
     printf("Physical address / Virtual address / Instruction\n");
   }
  while (!feof(fp)) {             /* read code and load into memory */
      fgets(line,240,fp);
      if (isdigit(line[0])) {
         sscanf(line, "%i", &mem[count]);
         count++;
        }
    }
  if (debug==2)
     for (i=base; i<count; i++) printf("Ox%x 0x%x 0x%x\n",i, i-base, mem[i]);
  fclose(fp);
}

/***************************************************
 * Set global flags, load the STM file, initialize the STM process
 ***************************************************/

void initialize(int argc, char* argv[])

{ FILE *fp;
  int ifilename, i;
  
  for (i = 0; i < NUMREGS; i++) regs[i] = 0;
  for (i = 0; i < RAMSIZE; i++) mem[i] = 0;
  ifilename = parse_flags(argc,argv);
  load_stm(argv[ifilename]);
}

  
/***************************************************
 * main: initialize, load, execute 
 ***************************************************/

int main(argc, argv)
int argc;
char *argv[];

{ int i;
  
  initialize(argc,argv);
  for (i=0; !error && !terminate && (i != maxinst); i++) exec_stm();
  return 0;
}