OAqqq

diff --git a/userprog/systemcall.cc b/userprog/systemcall.cc
index 15257be..f633d60 100644
--- a/userprog/systemcall.cc
+++ b/userprog/systemcall.cc
@@ -50,16 +50,16 @@ void do_system_call(int syscall_num) {
   case SC_Read:
     returnvalue = System_Read ((int) reg4, (char*) reg5, (int) reg6);
     break;
-  case SC_Write:    
+  case SC_Write:
     returnvalue = System_Write ((int) reg4, (char *) reg5, (int) reg6);
     break;
-  case SC_Close:    
+  case SC_Close:
     returnvalue = System_Close ((int) reg4);
     break;
   case SC_Unlink:
     returnvalue = System_Unlink ((char *) reg4);
     break;
-  case SC_Fork:     
+  case SC_Fork:
     returnvalue = System_Fork();
     break;
   case SC_GetPID:
@@ -68,9 +68,12 @@ void do_system_call(int syscall_num) {
   case SC_GetPPID:
     returnvalue = System_GetPPID ();
     break;
-  case SC_Yield:    
+  case SC_Yield:
     System_Yield();
     break;
+  case SC_Nice:
+    returnvalue = System_Nice((int) reg4);
+    break;
   default:
     fprintf (stderr, "Nonexistent system call: %d\n", syscall_num);
     returnvalue = -1;
@@ -83,7 +86,7 @@ void do_system_call(int syscall_num) {
 int System_Create (char *user_space_filename) {
   char * filename = new char[MAXFILENAMELENGTH];
 
-  if (!filename) { 
+  if (!filename) {
     return -ENOMEM;
   }
   system_read_null (user_space_filename, filename);
@@ -103,8 +106,8 @@ int System_Open (char *user_space_filename) {
   int fd;
   char * filename = new char[MAXFILENAMELENGTH];
   OpenFile *file;
-  
-  if (!filename) { 
+
+  if (!filename) {
     return -ENOMEM;
   }
   system_read_null (user_space_filename, filename);
@@ -144,18 +147,18 @@ int System_Read (int from_fd, char* to_user_space, int num_to_read) {
    char *buffer;
    int bytesread;
    OpenFile *file;
-   
+
    buffer = new char[num_to_read];
    if (buffer == NULL) {
      return -ENOMEM;
    }
-   
+
    FDTEntry *fdte = currentThread->getFD (from_fd);
    if (!fdte) {
      delete [] buffer;
      return -EBADF;
    }
-   
+
    switch (fdte->type) {
    case ConsoleFile :
      bytesread = ConsoleRead (buffer, num_to_read);
@@ -169,7 +172,7 @@ int System_Read (int from_fd, char* to_user_space, int num_to_read) {
      return -EBADF;
      break;
    }
-   
+
    for (ssize_t i = 0; i < bytesread; i++) {
      bool ok;
      ok = machine->WriteMem ((int)(to_user_space + i), 1, (int) buffer[i]);
@@ -183,7 +186,7 @@ int System_Read (int from_fd, char* to_user_space, int num_to_read) {
        }
      }
    }
-   
+
    delete [] buffer;
    return (int)bytesread;
 }
@@ -201,9 +204,9 @@ int System_Write (int to_fd, char * from_user_space, int num_to_write) {
   int byteswritten;
   char* buffer;
   OpenFile *file;
-  
+
   buffer = new char[num_to_write + 1];
-  
+
   if (buffer == NULL) {
     return -ENOMEM;
   }
@@ -213,7 +216,7 @@ int System_Write (int to_fd, char * from_user_space, int num_to_write) {
     delete [] buffer;
     return -EBADF;
   }
-  
+
   for (int i = 0; i < num_to_write; i++) {
     bool ok;
     ok = machine->ReadMem ((int)(from_user_space + i), 1, (int *)&buffer[i]);
@@ -228,8 +231,8 @@ int System_Write (int to_fd, char * from_user_space, int num_to_write) {
     }
   }
   buffer [num_to_write] = '\0';
-  
-  
+
+
   switch (fdte->type) {
   case ConsoleFile :
     byteswritten = ConsoleWrite (buffer, num_to_write);
@@ -243,7 +246,7 @@ int System_Write (int to_fd, char * from_user_space, int num_to_write) {
     return -EBADF;
     break;
   }
-  
+
   delete [] buffer;
   return byteswritten;
 }
@@ -271,7 +274,7 @@ int System_Close (int fd) {
   }
   currentThread->setFD (fd, (FDTEntry *) NULL);
 
-  return 0;  
+  return 0;
 }
 
 
@@ -280,7 +283,7 @@ int System_Close (int fd) {
 int System_Unlink (char *user_space_filename) {
   char * filename = new char[MAXFILENAMELENGTH];
 
-  if (!filename) { 
+  if (!filename) {
     return -ENOMEM;
   }
   system_read_null (user_space_filename, filename);
@@ -317,7 +320,7 @@ void System_Exit (int exitvalue) {
   if (printProcStats && currentThread->procStats) {
     currentThread->procStats->ShortPrint (currentThread->Get_Id());
   }
-  
+
   parent = currentThread->Get_Parent_Ptr ();
   if (!parent) {
     currentThread->Finish ();
@@ -347,11 +350,11 @@ int System_Wait (int *exitvalue) {
   Thread *child;
   int childexitvalue;
   int pid;
-  
+
   if (currentThread->Get_Num_Children () == 0) {
     return -ECHILD;
   }
-  
+
   // currentThread waiting on the semaphore ChildExited
   currentThread->ChildExited->P ();
 
@@ -360,7 +363,7 @@ int System_Wait (int *exitvalue) {
   if (!child) {
     ASSERT (false);
   }
-  
+
   if (exitvalue) {
     bool ok;
 
@@ -383,7 +386,7 @@ int System_Wait (int *exitvalue) {
 	child->Set_Exit_Val (-childexitvalue); //FIXME : Since the exitvalue for child is written above into memory
 					       // this Set_Exit_Val is solely for the purpose of signalling child's
 					       // Exit status, to the parent, which thread_exit_status does.
-					       //  So do we need this line ?? 
+					       //  So do we need this line ??
   }
 
   return (pid);
@@ -393,20 +396,20 @@ int System_Wait (int *exitvalue) {
 // ================================================================
 // System_Exec:
 // Parameters: register 4 contains a pointer to the filename of
-//             the executable image.  
-// Note: The executable image can take NO arguments.  
+//             the executable image.
+// Note: The executable image can take NO arguments.
 // Entry Point: Called from do_system_call
 // ================================================================
 int System_Exec (char * user_space_filename) {
   int ret;
   char * filename = new char[MAXFILENAMELENGTH];
- 
-  if (!filename) { 
+
+  if (!filename) {
     return -ENOMEM;
   }
   system_read_null( user_space_filename, filename);
   currentThread->setName(filename);
-  
+
   OpenFile *executable = fileSystem->Open(filename);
   if ( executable == NULL ) {
     printf("Unable to open file %s\n", filename);
@@ -421,10 +424,10 @@ int System_Exec (char * user_space_filename) {
   if (ret < 0) {
     return ret;
   }
-  
+
   currentThread->space->InitRegisters();
-  currentThread->space->RestoreState();  
-  
+  currentThread->space->RestoreState();
+
   machine->Run();                     // jump to the user progam
   ASSERT(false);                      // machine->Run never returns;
   return 0;                           // make gcc happy
@@ -443,7 +446,7 @@ int System_Fork( ) {
   }
   // Creat an AddrSpace object for the thread
   AddrSpace *space = new AddrSpace (t);
-  
+
   if (!space) {
     delete t;
     return -EAGAIN;
@@ -463,19 +466,19 @@ int System_Fork( ) {
   }
   //calling the Thread::Fork function with Do_Fork as an argument
   pid = t->Fork((void(*)(size_t))Do_Fork, (size_t)0);
-  
-  //Add the number of children to the currentThread by incrementing the 
+
+  //Add the number of children to the currentThread by incrementing the
   //member variable Children of the Thread class
   currentThread->Add_Child ();
 
   IntStatus oldLevel = interrupt->SetLevel(IntOff);
   // FIXME: Should this be here or in Thread::Fork()?
-  // THIS should be here because the status of thread "t" can be set to 
+  // THIS should be here because the status of thread "t" can be set to
   // "READY" only after all operations on it have been completed and it is
   // considered to be done only after the previous instruction finishes
   // adding the Children variable after returning from the Thread::Fork()
-  // function allocating the stack and returning to this function.(System_Fork) 
-  scheduler->ReadyToRun(t);              // ReadyToRun assumes that interrupts 
+  // function allocating the stack and returning to this function.(System_Fork)
+  scheduler->ReadyToRun(t);              // ReadyToRun assumes that interrupts
                                          // are disabled!
   (void) interrupt->SetLevel(oldLevel);
 
@@ -483,6 +486,16 @@ int System_Fork( ) {
 }
 
 
+// ==========================================================================
+// System_Nice :
+// ==========================================================================
+#include <iostream>
+int System_Nice(int incr) {
+
+  currentThread->setPriority(currentThread->getPriority() + incr);
+  currentThread->Yield();
+}
+
 // ================================================================
 // ================================================================
 void System_Yield() {
@@ -543,7 +556,7 @@ int system_read_null( char * from_user_space, char * to_k_space ) {
 void Do_Fork(size_t dummy) {
   dummy = 0;  // Keep gcc happy; the mechanism we use to call this only works
 	      // with functions that take 1 size_t argument
-  
+
   currentThread->RestoreUserState();
   currentThread->space->RestoreState();