hw4 test

code/machine/interrupt.h

@@ -37,35 +37,41 @@
 #include "list.h"
 #include "callback.h"
 
+#include "filesys.h"
+
+typedef int OpenFileId;
+
 // Interrupts can be disabled (IntOff) or enabled (IntOn)
 enum IntStatus { IntOff, IntOn };
 
 // Nachos can be running kernel code (SystemMode), user code (UserMode),
 // or there can be no runnable thread, because the ready list 
 // is empty (IdleMode).
-enum MachineStatus {IdleMode, SystemMode, UserMode};
+enum MachineStatus { IdleMode, SystemMode, UserMode };
 
 // IntType records which hardware device generated an interrupt.
 // In Nachos, we support a hardware timer device, a disk, a console
 // display and keyboard, and a network.
-enum IntType { TimerInt, DiskInt, ConsoleWriteInt, ConsoleReadInt, 
-			NetworkSendInt, NetworkRecvInt};
+enum IntType {
+  TimerInt, DiskInt, ConsoleWriteInt, ConsoleReadInt,
+  NetworkSendInt, NetworkRecvInt
+};
 
 // The following class defines an interrupt that is scheduled
 // to occur in the future.  The internal data structures are
 // left public to make it simpler to manipulate.
 
 class PendingInterrupt {
-  public:
-    PendingInterrupt(CallBackObj *callOnInt, int time, IntType kind);
-				// initialize an interrupt that will
-				// occur in the future
+public:
+  PendingInterrupt(CallBackObj* callOnInt, int time, IntType kind);
+  // initialize an interrupt that will
+  // occur in the future
 
-    CallBackObj *callOnInterrupt;// The object (in the hardware device
-				// emulator) to call when the interrupt occurs
-    
-    int when;			// When the interrupt is supposed to fire
-    IntType type;		// for debugging
+  CallBackObj* callOnInterrupt;// The object (in the hardware device
+  // emulator) to call when the interrupt occurs
+
+  int when;			// When the interrupt is supposed to fire
+  IntType type;		// for debugging
 };
 
 // The following class defines the data structures for the simulation
@@ -74,72 +80,76 @@ class PendingInterrupt {
 // in the future.
 
 class Interrupt {
-  public:
-    Interrupt();		// initialize the interrupt simulation
-    ~Interrupt();		// de-allocate data structures
-    
-    IntStatus SetLevel(IntStatus level);
-    				// Disable or enable interrupts 
-				// and return previous setting.
+public:
+  Interrupt();		// initialize the interrupt simulation
+  ~Interrupt();		// de-allocate data structures
 
-    void Enable() { (void) SetLevel(IntOn); }
-				// Enable interrupts.
-    IntStatus getLevel() {return level;}
-    				// Return whether interrupts
-				// are enabled or disabled
-    
-    void Idle(); 		// The ready queue is empty, roll 
-				// simulated time forward until the 
-				// next interrupt
+  IntStatus SetLevel(IntStatus level);
+  // Disable or enable interrupts 
+  // and return previous setting.
 
-    void Halt(); 		// quit and print out stats
+  void Enable() { (void)SetLevel(IntOn); }
+  // Enable interrupts.
+  IntStatus getLevel() { return level; }
+  // Return whether interrupts
+  // are enabled or disabled
 
-    void PrintInt(int number);
-	  int CreateFile(char *filename);
- 
-    void YieldOnReturn();	// cause a context switch on return 
-				// from an interrupt handler
+  void Idle(); 		// The ready queue is empty, roll 
+  // simulated time forward until the 
+  // next interrupt
 
-    MachineStatus getStatus() { return status; } 
-    void setStatus(MachineStatus st) { status = st; }
-        			// idle, kernel, user
+  void Halt(); 		// quit and print out stats
 
-    void DumpState();		// Print interrupt state
-    
+  void PrintInt(int number);
+  int CreateFile(char* filename);
+  OpenFileId OpenFile(char* filename);
+  int WriteFile(char* buffer, int size, OpenFileId fd);
+  int CloseFile(OpenFileId fd);
+  int ReadFile(char* buffer, int size, OpenFileId fd);
 
-    // NOTE: the following are internal to the hardware simulation code.
-    // DO NOT call these directly.  I should make them "private",
-    // but they need to be public since they are called by the
-    // hardware device simulators.
+  void YieldOnReturn();	// cause a context switch on return 
+  // from an interrupt handler
 
-    void Schedule(CallBackObj *callTo, int when, IntType type);
-    				// Schedule an interrupt to occur
-				// at time "when".  This is called
-    				// by the hardware device simulators.
-    
-    void OneTick();       	// Advance simulated time
+  MachineStatus getStatus() { return status; }
+  void setStatus(MachineStatus st) { status = st; }
+  // idle, kernel, user
 
-  private:
-    IntStatus level;		// are interrupts enabled or disabled?
-    SortedList<PendingInterrupt *> *pending;		
-    				// the list of interrupts scheduled
-				// to occur in the future
-    //int writeFileNo;            //UNIX file emulating the display
-    bool inHandler;		// TRUE if we are running an interrupt handler
-    //bool putBusy;               // Is a PrintInt operation in progress
-                                  //If so, you cannoot do another one
-    bool yieldOnReturn; 	// TRUE if we are to context switch
-				// on return from the interrupt handler
-    MachineStatus status;	// idle, kernel mode, user mode
+  void DumpState();		// Print interrupt state
 
-    // these functions are internal to the interrupt simulation code
 
-    bool CheckIfDue(bool advanceClock); 
-    				// Check if any interrupts are supposed
-				// to occur now, and if so, do them
+  // NOTE: the following are internal to the hardware simulation code.
+  // DO NOT call these directly.  I should make them "private",
+  // but they need to be public since they are called by the
+  // hardware device simulators.
 
-    void ChangeLevel(IntStatus old, 	// SetLevel, without advancing the
-			IntStatus now); // simulated time
+  void Schedule(CallBackObj* callTo, int when, IntType type);
+  // Schedule an interrupt to occur
+  // at time "when".  This is called
+  // by the hardware device simulators.
+
+  void OneTick();       	// Advance simulated time
+
+private:
+  IntStatus level;		// are interrupts enabled or disabled?
+  SortedList<PendingInterrupt*>* pending;
+  // the list of interrupts scheduled
+  // to occur in the future
+  //int writeFileNo;            //UNIX file emulating the display
+  bool inHandler;		// TRUE if we are running an interrupt handler
+  //bool putBusy;               // Is a PrintInt operation in progress
+                                //If so, you cannoot do another one
+  bool yieldOnReturn; 	// TRUE if we are to context switch
+  // on return from the interrupt handler
+  MachineStatus status;	// idle, kernel mode, user mode
+
+  // these functions are internal to the interrupt simulation code
+
+  bool CheckIfDue(bool advanceClock);
+  // Check if any interrupts are supposed
+  // to occur now, and if so, do them
+
+  void ChangeLevel(IntStatus old, 	// SetLevel, without advancing the
+    IntStatus now); // simulated time
 };
 
 #endif // INTERRRUPT_H