---

console.cc

Go to the documentation of this file.

// console.cc 
//      Routines to simulate a serial port to a console device.
//      A console has input (a keyboard) and output (a display).
//      These are each simulated by operations on UNIX files.
//      The simulated device is asynchronous,
//      so we have to invoke the interrupt handler (after a simulated
//      delay), to signal that a byte has arrived and/or that a written
//      byte has departed.
//
//  DO NOT CHANGE -- part of the machine emulation
//
// Copyright (c) 1992-1993 The Regents of the University of California.
// All rights reserved.  See copyright.h for copyright notice and limitation 
// of liability and disclaimer of warranty provisions.

#include "copyright.h"
#include "console.h"
#include "system.h"

// Dummy functions because C++ is weird about pointers to member functions
static void ConsoleReadPoll(int c) 
{ Console *console = (Console *)c; console->CheckCharAvail(); }
static void ConsoleWriteDone(int c)
{ Console *console = (Console *)c; console->WriteDone(); }

//----------------------------------------------------------------------
// Console::Console
//      Initialize the simulation of a hardware console device.
//
//      "readFile" -- UNIX file simulating the keyboard (NULL -> use stdin)
//      "writeFile" -- UNIX file simulating the display (NULL -> use stdout)
//      "readAvail" is the interrupt handler called when a character arrives
//              from the keyboard
//      "writeDone" is the interrupt handler called when a character has
//              been output, so that it is ok to request the next char be
//              output
//----------------------------------------------------------------------

Console::Console(char *readFile, char *writeFile, VoidFunctionPtr readAvail, 
                VoidFunctionPtr writeDone, int callArg)
{
    if (readFile == NULL)
        readFileNo = 0;                                 // keyboard = stdin
    else
        readFileNo = OpenForReadWrite(readFile, TRUE);  // should be read-only
    if (writeFile == NULL)
        writeFileNo = 1;                                // display = stdout
    else
        writeFileNo = OpenForWrite(writeFile);

    // set up the stuff to emulate asynchronous interrupts
    writeHandler = writeDone;
    readHandler = readAvail;
    handlerArg = callArg;
    putBusy = FALSE;
    incoming = EOF;

    // start polling for incoming packets
    interrupt->Schedule(ConsoleReadPoll, (int)this, ConsoleTime, ConsoleReadInt);
}

//----------------------------------------------------------------------
// Console::~Console
//      Clean up console emulation
//----------------------------------------------------------------------

Console::~Console()
{
    if (readFileNo != 0)
        Close(readFileNo);
    if (writeFileNo != 1)
        Close(writeFileNo);
}

//----------------------------------------------------------------------
// Console::CheckCharAvail()
//      Periodically called to check if a character is available for
//      input from the simulated keyboard (eg, has it been typed?).
//
//      Only read it in if there is buffer space for it (if the previous
//      character has been grabbed out of the buffer by the Nachos kernel).
//      Invoke the "read" interrupt handler, once the character has been 
//      put into the buffer. 
//----------------------------------------------------------------------

void
Console::CheckCharAvail()
{
    char c;

    // schedule the next time to poll for a packet
    interrupt->Schedule(ConsoleReadPoll, (int)this, ConsoleTime, 
                        ConsoleReadInt);

    // do nothing if character is already buffered, or none to be read
    if ((incoming != EOF) || !PollFile(readFileNo))
        return;   

    // otherwise, read character and tell user about it
    Read(readFileNo, &c, sizeof(char));
    incoming = c ;
    stats->numConsoleCharsRead++;
    (*readHandler)(handlerArg); 
}

//----------------------------------------------------------------------
// Console::WriteDone()
//      Internal routine called when it is time to invoke the interrupt
//      handler to tell the Nachos kernel that the output character has
//      completed.
//----------------------------------------------------------------------

void
Console::WriteDone()
{
    putBusy = FALSE;
    stats->numConsoleCharsWritten++;
    (*writeHandler)(handlerArg);
}

//----------------------------------------------------------------------
// Console::GetChar()
//      Read a character from the input buffer, if there is any there.
//      Either return the character, or EOF if none buffered.
//----------------------------------------------------------------------

char
Console::GetChar()
{
   char ch = incoming;

   incoming = EOF;
   return ch;
}

//----------------------------------------------------------------------
// Console::PutChar()
//      Write a character to the simulated display, schedule an interrupt 
//      to occur in the future, and return.
//----------------------------------------------------------------------

void
Console::PutChar(char ch)
{
    ASSERT(putBusy == FALSE);
    WriteFile(writeFileNo, &ch, sizeof(char));
    putBusy = TRUE;
    interrupt->Schedule(ConsoleWriteDone, (int)this, ConsoleTime,
                                        ConsoleWriteInt);
}

---

The University of Southern California does not screen or control the content on this website and thus does not guarantee the accuracy, integrity, or quality of such content. All content on this website is provided by and is the sole responsibility of the person from which such content originated, and such content does not necessarily reflect the opinions of the University administration or the Board of Trustees