TextIOApplet.java

Go to the documentation of this file.

 
 
import java.io.*;
import java.awt.*;
import java.awt.event.*;
import javax.swing.*;
import java.util.IllegalFormatException;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
 
 
abstract public class TextIOApplet extends JApplet {
   
   /* Modified November 2007 to empty the TextIO input buffer when switching from one
    * input source to another. This fixes a bug that allows input from the previous input
    * source to be read after the new source has been selected.  This bug also allowed
    * input to carry over from one call to the runProgram() program to the next.
    */
   
   /* Modified December 2010; added a "catch" handler for Error to the try..catch statement
    * in the run() method in class ProgRun .  Without this, errors such as StackOverflowError would 
    * not be displayed in the applet.  (It's not a good idea to catch Errors in general, but the
    * thread is going to end anyway.)
    */
   
   //**************** Stuff that is relevant to concrete subclasses of this class ***************
   
   abstract protected void runProgram();
   
   protected TextIOObject TextIO;
 
   protected BogusSystem System;
   
    protected String getDefaultAppletTitle() {
          return "TextIO Applet";
    }
    
    protected String getTitle() {
          return message.getText();
    }
    
    protected void setTitle(String title) {
          message.setText(title);
    }
   
   protected void doDelay(int milliseconds) {
      console.checkAbort();
      if (milliseconds <= 0)
         Thread.yield();
      else {
         synchronized(console) {
            try {
               console.wait(milliseconds);
            }
            catch (InterruptedException e) {
            }
         }
      }
   }
   
     protected void checkAbort() {
           console.checkAbort();
     }
     
    protected static class AbortException extends RuntimeException {
    }
 
   protected class BogusSystem {
      PrintWriter out;
      BufferedReader in;
      public long currentTimeMillis() {
         return java.lang.System.currentTimeMillis();
      }
      public void exit(int ignored) {
         throw new RuntimeException("Program ended with System.exit().");
      }
   }
 
   //************* Everything after this point is implementation **************************
   
   //************* Implementing the applet ************************************************
   
   private volatile Thread runner;   // For executing the runProgram() method in a separate thread.
   private volatile boolean aborted; // Set to true when the user clicks the "Abort" button.
   private volatile boolean programIsRunning;  // Set to true when the runProgram() method is running.
   
   private JButton runAgainButton;  // Button can be clicked after program ends to run it again.
   private JButton abortButton;     // Button can be clicked to abort a program that is running.
   private JLabel message;          // The message displayed at the top of the applet.
   
   public TextIOApplet() {
      console = new Console();
      System = new BogusSystem();
      System.in = in = standardInput = console.inputStream;
      System.out = out = standardOutput = console.outputStream;
      TextIO = new TextIOObject();
      JPanel bottom = new JPanel();
      abortButton = new JButton("Abort Program");
      bottom.add(abortButton);
      abortButton.setEnabled(false);
      abortButton.addActionListener( new ActionListener() {
         public void actionPerformed(ActionEvent evt) {
            synchronized(console) {
               aborted = true;
               abortButton.setEnabled(false);
               abortButton.setText("Aborting...");
               console.notify();
            }
         }
      });
      runAgainButton = new JButton("Run the Program");
      runAgainButton.addActionListener( new ActionListener() { 
         public void actionPerformed(ActionEvent evt) {
            synchronized(console) {
               programIsRunning = true;
               console.notify();
            }
         }
      });
      bottom.add(runAgainButton);
      bottom.setBackground(Color.LIGHT_GRAY);
      runAgainButton.setBackground(Color.LIGHT_GRAY);
      abortButton.setBackground(Color.LIGHT_GRAY);
      message = new JLabel(getDefaultAppletTitle(),JLabel.CENTER);
      message.setForeground(Color.RED);
      message.setBackground(Color.LIGHT_GRAY);
      Font f = message.getFont();
      message.setFont(new Font(f.getName(),Font.BOLD,(int)(f.getSize()*1.12)));
      JPanel top = new JPanel();
      top.setLayout(new BorderLayout());
      top.setBackground(Color.LIGHT_GRAY);
      top.setBorder(BorderFactory.createEmptyBorder(5,5,5,5));
      top.add(message);
      JPanel panel = new JPanel();
      panel.setLayout(new BorderLayout(2,2));
      panel.setBackground(Color.DARK_GRAY);
      panel.setBorder(BorderFactory.createLineBorder(Color.DARK_GRAY,3));
      panel.add(console,BorderLayout.CENTER);
      panel.add(console.scroller,BorderLayout.EAST);
      panel.add(bottom,BorderLayout.SOUTH);
      panel.add(top,BorderLayout.NORTH);
      setContentPane(panel);
   }
   
   private class ProgRun extends Thread {  // Defines the thread that runs the program.
      public void run() {
         while (true) {
            synchronized(console) {
               while (!programIsRunning) {
                  try {
                     console.wait(1000);
                  }
                  catch (InterruptedException e) {
                  }
               }
            }
            message.setText(getDefaultAppletTitle());
            abortButton.setEnabled(true);
            runAgainButton.setEnabled(false);
            console.clear();
            console.requestFocus();
            try {
               if (programIsRunning) {
                  aborted = false;
                  runProgram();
               }
            }
            catch (AbortException e) {
               aborted = false;
               console.putString("\n\n\n   ***** PROGRAM ABORTED BY USER *****\n\n\n");
            }
            catch (Exception e) {
               aborted = false;
               console.putString("\n\n\n   ***** PROGRAM TERMINATED BY EXCEPTION ***** \n\n\n");
               e.printStackTrace(standardOutput);
            }
            catch (Error e) {
               aborted = false;
               console.putString("\n\n\n   ***** PROGRAM TERMINATED BY Error ***** \n\n");
               console.putString("   ***** " + e.toString() + "\n\n");
            }
            finally {
               programIsRunning = false;
               console.doingInput = false;
               aborted = false;
               abortButton.setEnabled(false);
               abortButton.setText("Abort Program");
               runAgainButton.setEnabled(true);
               runAgainButton.setText("Run Program Again");
               TextIO.readStandardInput();
               TextIO.writeStandardOutput();
            }
         }
      }
   }
   
   public void init() {
      runner = new ProgRun();
      programIsRunning = false;
      runner.start();
   }
   
   protected class TextIOObject {
      
      public final char EOF = (char)0xFFFF; 
      
      public final char EOLN = '\n';          // The value returned by peek() when at end-of-line.
      
      
      public void readStandardInput() {
         if (readingStandardInput)
            return;
         try {
            in.close();
         }
         catch (Exception e) {
         }
         emptyBuffer();  // Added November 2007
         in = standardInput;
         inputFileName = null;
         readingStandardInput = true;
         inputErrorCount = 0;
      }
      
      public void readStream(InputStream inputStream) {
         if (inputStream == null)
            readStandardInput();
         else
            readStream(new InputStreamReader(inputStream));
      }
      
      public void readStream(Reader inputStream) {
         if (inputStream == null)
            readStandardInput();
         else {
            if ( inputStream instanceof BufferedReader)
               in = (BufferedReader)inputStream;
            else
               in = new BufferedReader(inputStream);
            emptyBuffer();  // Added November 2007
            inputFileName = null;
            readingStandardInput = false;
            inputErrorCount = 0;
         }
      }
      
      public void readFile(String fileName) {
         if (fileName == null) // Go back to reading standard input
            readStandardInput();
         else {
            BufferedReader newin;
            try {
               newin = new BufferedReader( new FileReader(fileName) );
            }
            catch (Exception e) {
               throw new IllegalArgumentException("Can't open file \"" + fileName + "\" for input.\n"
                     + "(Error :" + e + ")");
            }
            if (! readingStandardInput) { // close current input stream
               try {
                  in.close();
               }
               catch (Exception e) {
               }
            }
            emptyBuffer();  // Added November 2007
            in = newin;
            readingStandardInput = false;
            inputErrorCount = 0;
            inputFileName = fileName;
         }
      }
      
      public boolean readUserSelectedFile() {
         if (fileDialog == null)
            fileDialog = new JFileChooser();
         fileDialog.setDialogTitle("Select File for Input");
         int option = fileDialog.showOpenDialog(console);
         if (option != JFileChooser.APPROVE_OPTION)
            return false;
         File selectedFile = fileDialog.getSelectedFile();
         BufferedReader newin;
         try {
            newin = new BufferedReader( new FileReader(selectedFile) );
         }
         catch (Exception e) {
            throw new IllegalArgumentException("Can't open file \"" + selectedFile.getName() + "\" for input.\n"
                  + "(Error :" + e + ")");
         }
         if (!readingStandardInput) { // close current file
            try {
               in.close();
            }
            catch (Exception e) {
            }
         }
         emptyBuffer();  // Added November 2007
         in = newin;
         inputFileName = selectedFile.getName();
         readingStandardInput = false;
         inputErrorCount = 0;
         return true;
      }
      
      public void writeStandardOutput() {
         if (writingStandardOutput)
            return;
         try {
            out.close();
         }
         catch (Exception e) {
         }
         outputFileName = null;
         outputErrorCount = 0;
         out = standardOutput;
         writingStandardOutput = true;
      }
      
      
      public void writeStream(OutputStream outputStream) {
         if (outputStream == null)
            writeStandardOutput();
         else
            writeStream(new PrintWriter(outputStream));
      }
      
      public void writeStream(PrintWriter outputStream) {
         if (outputStream == null)
            writeStandardOutput();
         else {
            out = outputStream;
            outputFileName = null;
            outputErrorCount = 0;
            writingStandardOutput = false;
         }
      }
      
      
      public void writeFile(String fileName) {
         if (fileName == null)  // Go back to reading standard output
            writeStandardOutput();
         else {
            PrintWriter newout;
            try {
               newout = new PrintWriter(new FileWriter(fileName));
            }
            catch (Exception e) {
               throw new IllegalArgumentException("Can't open file \"" + fileName + "\" for output.\n"
                     + "(Error :" + e + ")");
            }
            if (!writingStandardOutput) {
               try {
                  out.close();
               }
               catch (Exception e) {
               }
            }
            out = newout;
            writingStandardOutput = false;
            outputFileName = fileName;
            outputErrorCount = 0;
         }
      }
      
      public boolean writeUserSelectedFile() {
         if (fileDialog == null)
            fileDialog = new JFileChooser();
         fileDialog.setDialogTitle("Select File for Output");
         File selectedFile;
         while (true) {
            int option = fileDialog.showSaveDialog(console);
            if (option != JFileChooser.APPROVE_OPTION)
               return false;  // user canceled
            selectedFile = fileDialog.getSelectedFile();
            if (selectedFile.exists()) {
               int response = JOptionPane.showConfirmDialog(console,
                     "The file \"" + selectedFile.getName() + "\" already exists.  Do you want to replace it?",
                     "Replace existing file?",
                     JOptionPane.YES_NO_OPTION, JOptionPane.WARNING_MESSAGE);
               if (response == JOptionPane.YES_OPTION)
                  break;
            }
            else {
               break;
            }
         }
         PrintWriter newout;
         try {
            newout = new PrintWriter(new FileWriter(selectedFile));
         }
         catch (Exception e) {
            throw new IllegalArgumentException("Can't open file \"" + selectedFile.getName() + "\" for output.\n"
                  + "(Error :" + e + ")");
         }
         if (!writingStandardOutput) {
            try {
               out.close();
            }
            catch (Exception e) {
            }
         }
         out = newout;
         writingStandardOutput = false;
         outputFileName = selectedFile.getName();
         outputErrorCount = 0;
         return true;
      }
      
      
      public String getInputFileName() {
         return inputFileName;
      }
      
      
      public String getOutputFileName() {
         return outputFileName;
      }
      
      
      // *************************** Output Methods *********************************
      
      public void put(Object x) { 
         out.print(x); 
         out.flush();
         if (out.checkError())
            outputError("Error while writing output.");
      }
      
      public void put(Object x, int minChars)  { 
         if (minChars <= 0)
            out.print(x);
         else {
            out.printf("%" + minChars + "s", x);
            out.flush();
         }
         if (out.checkError())
            outputError("Error while writing output.");
      }
      
      public void putln(Object x) { 
         out.println(x);
         out.flush();
         if (out.checkError())
            outputError("Error while writing output.");
      }
      
      public void putln(Object x, int minChars) {
         put(x,minChars);
         out.println();
         out.flush();
         if (out.checkError())
            outputError("Error while writing output.");
      }
      
      public void putln() {
         out.println();
         out.flush();
         if (out.checkError())
            outputError("Error while writing output.");
      }
      
      public void putf(String format, Object... items) {
         if (format == null)
            throw new IllegalArgumentException("Null format string in TextIO.putf() method.");
         try {
            out.printf(format,items);
         }
         catch (IllegalFormatException e) {
            throw new IllegalArgumentException("Illegal format string in TextIO.putf() method.");
         }
         out.flush();
         if (out.checkError())
            outputError("Error while writing output.");
      }
      
      // *************************** Input Methods *********************************
      
      public boolean eoln() { 
         return peek() == '\n'; 
      }
      
      public boolean eof()  { 
         return peek() == EOF; 
      }
      
      public char getAnyChar() { 
         return readChar(); 
      }
      
      public char peek() { 
         return lookChar();
      }
      
      public void skipBlanks() { 
         char ch=lookChar();
         while (ch != EOF && ch != '\n' && Character.isWhitespace(ch)) {
            readChar();
            ch = lookChar();
         }
      }
      
      private void skipWhitespace() {
         char ch=lookChar();
         while (ch != EOF && Character.isWhitespace(ch)) {
            readChar();
            if (ch == '\n' && readingStandardInput && writingStandardOutput) {
               out.print("? ");
               out.flush();
            }
            ch = lookChar();
         }
      }
      
      public byte getlnByte() { 
         byte x=getByte(); 
         emptyBuffer(); 
         return x; 
      }
      
      public short getlnShort() {
         short x=getShort();
         emptyBuffer(); 
         return x; 
      }
      
      public int getlnInt() { 
         int x=getInt(); 
         emptyBuffer(); 
         return x; 
      }
      
      public long getlnLong() {
         long x=getLong(); 
         emptyBuffer(); 
         return x;
      }
      
      public float getlnFloat() {
         float x=getFloat(); 
         emptyBuffer(); 
         return x;
      }
      
      public double getlnDouble() { 
         double x=getDouble(); 
         emptyBuffer(); 
         return x; 
      }
      
      public char getlnChar() {
         char x=getChar(); 
         emptyBuffer(); 
         return x;
      }
      
      public boolean getlnBoolean() { 
         boolean x=getBoolean(); 
         emptyBuffer();
         return x; 
      }
      
      public String getlnWord() {
         String x=getWord(); 
         emptyBuffer(); 
         return x; 
      }
      
      public String getlnString() {
         return getln();
      } 
      
      public String getln() {
         StringBuffer s = new StringBuffer(100);
         char ch = readChar();
         while (ch != '\n') {
            s.append(ch);
            ch = readChar();
         }
         return s.toString();
      }
      
      public byte getByte()   { 
         return (byte)readInteger(-128L,127L); 
      }
      
      public short getShort() { 
         return (short)readInteger(-32768L,32767L);
      }   
      
      public int getInt()     { 
         return (int)readInteger(Integer.MIN_VALUE, Integer.MAX_VALUE);
      }
      
      public long getLong()   { 
         return readInteger(Long.MIN_VALUE, Long.MAX_VALUE); 
      }
      
      public char getChar() { 
         skipWhitespace();
         return readChar();
      }
      
      public float getFloat() {
         float x = 0.0F;
         while (true) {
            String str = readRealString();
            if (str == null) {
               errorMessage("Floating point number not found.",
                     "Real number in the range " + (-Float.MAX_VALUE) + " to " + Float.MAX_VALUE);
            }
            else {
               try { 
                  x = Float.parseFloat(str); 
               }
               catch (NumberFormatException e) {
                  errorMessage("Illegal floating point input, " + str + ".",
                        "Real number in the range " + (-Float.MAX_VALUE) + " to " + Float.MAX_VALUE);
                  continue;
               }
               if (Float.isInfinite(x)) {
                  errorMessage("Floating point input outside of legal range, " + str + ".",
                        "Real number in the range " + (-Float.MAX_VALUE) + " to " + Float.MAX_VALUE);
                  continue;
               }
               break;
            }
         }
         inputErrorCount = 0;
         return x;
      }
      
      public double getDouble() {
         double x = 0.0;
         while (true) {
            String str = readRealString();
            if (str == null) {
               errorMessage("Floating point number not found.",
                     "Real number in the range " + (-Double.MAX_VALUE) + " to " + Double.MAX_VALUE);
            }
            else {
               try { 
                  x = Double.parseDouble(str); 
               }
               catch (NumberFormatException e) {
                  errorMessage("Illegal floating point input, " + str + ".",
                        "Real number in the range " + (-Double.MAX_VALUE) + " to " + Double.MAX_VALUE);
                  continue;
               }
               if (Double.isInfinite(x)) {
                  errorMessage("Floating point input outside of legal range, " + str + ".",
                        "Real number in the range " + (-Double.MAX_VALUE) + " to " + Double.MAX_VALUE);
                  continue;
               }
               break;
            }
         }
         inputErrorCount = 0;
         return x;
      }
      
      public String getWord() {
         skipWhitespace();
         StringBuffer str = new StringBuffer(50);
         char ch = lookChar();
         while (ch == EOF || !Character.isWhitespace(ch)) {
            str.append(readChar());
            ch = lookChar();
         }
         return str.toString();
      }
      
      public boolean getBoolean() {
         boolean ans = false;
         while (true) {
            String s = getWord();
            if ( s.equalsIgnoreCase("true") || s.equalsIgnoreCase("t") ||
                  s.equalsIgnoreCase("yes")  || s.equalsIgnoreCase("y") ||
                  s.equals("1") ) {
               ans = true;
               break;
            }
            else if ( s.equalsIgnoreCase("false") || s.equalsIgnoreCase("f") ||
                  s.equalsIgnoreCase("no")  || s.equalsIgnoreCase("n") ||
                  s.equals("0") ) {
               ans = false;
               break;
            }
            else
               errorMessage("Illegal boolean input value.",
               "one of:  true, false, t, f, yes, no, y, n, 0, or 1");
         }
         inputErrorCount = 0;
         return ans;
      }
      
      private String readRealString() {   // read chars from input following syntax of real numbers
         skipWhitespace();
         if (lookChar() == EOF)
            return null;
         if (floatMatcher == null)
            floatMatcher = floatRegex.matcher(buffer);
         floatMatcher.region(pos,buffer.length());
         if (floatMatcher.lookingAt()) {
            String str = floatMatcher.group();
            pos = floatMatcher.end();
            return str;
         }
         else 
            return null;
      }
      
      private String readIntegerString() {  // read chars from input following syntax of integers
         skipWhitespace();
         if (lookChar() == EOF)
            return null;
         if (integerMatcher == null)
            integerMatcher = integerRegex.matcher(buffer);
         integerMatcher.region(pos,buffer.length());
         if (integerMatcher.lookingAt()) {
            String str = integerMatcher.group();
            pos = integerMatcher.end();
            return str;
         }
         else 
            return null;
      }
      
      private long readInteger(long min, long max) {  // read long integer, limited to specified range
         long x=0;
         while (true) {
            String s = readIntegerString();
            if (s == null){
               errorMessage("Integer value not found in input.",
                     "Integer in the range " + min + " to " + max);
            }
            else {
               String str = s.toString();
               try { 
                  x = Long.parseLong(str);
               }
               catch (NumberFormatException e) {
                  errorMessage("Illegal integer input, " + str + ".",
                        "Integer in the range " + min + " to " + max);
                  continue;
               }
               if (x < min || x > max) {
                  errorMessage("Integer input outside of legal range, " + str + ".",
                        "Integer in the range " + min + " to " + max);
                  continue;
               }
               break;
            }
         }
         inputErrorCount = 0;
         return x;
      }
      
      
      private void errorMessage(String message, String expecting) {  // Report error on input.
         console.clearTypeAhead();
         if (readingStandardInput && writingStandardOutput) {
            // inform user of error and force user to re-enter.
            out.println();
            out.print("  *** Error in input: " + message + "\n");
            out.print("  *** Expecting: " + expecting + "\n");
            out.print("  *** Discarding Input: ");
            if (lookChar() == '\n')
               out.print("(end-of-line)\n\n");
            else {
               while (lookChar() != '\n')    // Discard and echo remaining chars on the current line of input.
                  out.print(readChar());
               out.print("\n\n");
            }
            out.print("Please re-enter: ");
            out.flush();
            readChar();  // discard the end-of-line character
            inputErrorCount++;
            if (inputErrorCount >= 10)
               throw new IllegalArgumentException("Too many input consecutive input errors on standard input.");
         }
         else if (inputFileName != null)
            throw new IllegalArgumentException("Error while reading from file \"" + inputFileName + "\":\n" 
                  + message + "\nExpecting " + expecting);
         else
            throw new IllegalArgumentException("Error while reading from inptu stream:\n" 
                  + message + "\nExpecting " + expecting);
      }
      
      private char lookChar() {  // return next character from input
         if (buffer == null || pos > buffer.length())
            fillBuffer();
         if (buffer == null)
            return EOF;
         else if (pos == buffer.length())
            return '\n';
         else 
            return buffer.charAt(pos);
      }
      
      private char readChar() {  // return and discard next character from input
         char ch = lookChar();
         if (buffer == null) {
            if (readingStandardInput)
               throw new IllegalArgumentException("Attempt to read past end-of-file in standard input???");
            else
               throw new IllegalArgumentException("Attempt to read past end-of-file in file \"" + inputFileName + "\".");
         }
         pos++;
         return ch;
      }
      
      private void fillBuffer() {    // Wait for user to type a line and press return,
         try {
            buffer = in.readLine();
         }
         catch (Exception e) {
            if (e instanceof AbortException)
               throw (AbortException)e;
            else if (readingStandardInput)
               throw new IllegalArgumentException("Error while reading standard input???");
            else if (inputFileName != null)
               throw new IllegalArgumentException("Error while attempting to read from file \"" + inputFileName + "\".");
            else
               throw new IllegalArgumentException("Errow while attempting to read form an input stream.");
         }
         pos = 0;
         floatMatcher = null;
         integerMatcher = null;
      }
      
      private void emptyBuffer() {   // discard the rest of the current line of input
         buffer = null;
      }
      
      private void outputError(String message) {  // Report an error on output.
         if (writingStandardOutput) {
            java.lang.System.err.println("Error occurred in TextIO while writing to standard output!!");
            outputErrorCount++;
            if (outputErrorCount >= 10) {
               outputErrorCount = 0;
               throw new IllegalArgumentException("Too many errors while writing to standard output.");
            }
         }
         else if (outputFileName != null){
            throw new IllegalArgumentException("Error occurred while writing to file \"" 
                  + outputFileName+ "\":\n   " + message);
         }
         else {
            throw new IllegalArgumentException("Error occurred while writing to output stream:\n   " + message);
         }
      }
   }
   
   // ******************************* Defining the GUI ***************************************
   
   private class Console extends JPanel {
      JScrollBar scroller;
      BufferedReader inputStream;
      PrintWriter outputStream;
      String[] lines;
      int topLine;
      int lineCount;
      int rows, columns;
      volatile boolean doingInput;
      volatile String inputBuffer;
      volatile boolean cursorOn = true;
      volatile int inputStartLine, inputStartColumn;
      volatile String typeAheadBuffer = "";
      FontMetrics fontMetrics;
      int lineSkip;
      int charWidth;
      final int MARGIN = 6;
      final Color CURSOR_COLOR = new Color(200,0,0);
 
      Console() {
         Font f = getFont();
         f = new Font("Monospaced",Font.PLAIN,f.getSize());
         setFont(f);
         fontMetrics = getFontMetrics(f);
         lineSkip = (int)(fontMetrics.getHeight() * 1.2);  
         charWidth = fontMetrics.charWidth('W');
         setPreferredSize(new Dimension(2*MARGIN + 80*charWidth, 2*MARGIN + (25-1)*lineSkip + fontMetrics.getAscent() + fontMetrics.getDescent()));
         setBackground(Color.WHITE);
         setForeground(Color.BLACK);
         setBorder(BorderFactory.createLineBorder(Color.LIGHT_GRAY, 3));
         addFocusListener( new FocusListener() {
            public void focusLost(FocusEvent evt) {
               setBorder(BorderFactory.createLineBorder(Color.LIGHT_GRAY,3));
            }
            public void focusGained(FocusEvent evt) {
               setBorder(BorderFactory.createLineBorder(Color.CYAN,3));
            }
         } );
         addMouseListener( new MouseAdapter() {
            public void mousePressed(MouseEvent evt) {
               requestFocus();
            }
         } );
         addKeyListener( new KeyAdapter() {
            public void keyTyped(KeyEvent evt) {
               char ch = evt.getKeyChar();
               if (ch == KeyEvent.CHAR_UNDEFINED)
                  return;
               if (!doingInput) {
                  typeAheadBuffer += ch;
                  return;
               }
               synchronized(Console.this) {
                  doInputChar(ch);
                  Console.this.notify();
               }
            }
         } );
         lines = new String[2000];
         lineCount = 1;
         lines[0] = "";
         scroller = new JScrollBar(JScrollBar.VERTICAL,0,80,0,80);
         scroller.setEnabled(false);
         scroller.addAdjustmentListener( new AdjustmentListener() { 
            public void adjustmentValueChanged(AdjustmentEvent evt) {
               topLine = scroller.getValue();
               repaint();
            }
         });
         inputStream = new BufferedReader(new CIN());
         outputStream = new PrintWriter(new COUT());
      }
      
      public void paintComponent(Graphics g) {
         super.paintComponent(g);
         if (rows == 0) {
            columns = (getWidth() - 2*MARGIN + 1) / charWidth;
            rows = 1 + (getHeight() - 2*MARGIN - fontMetrics.getAscent()) / lineSkip;
            scroller.setBlockIncrement(rows - 2);
            scrollToEnd();
         }
         for (int i = topLine; i < topLine + rows && i < lineCount; i++)
            g.drawString(lines[i],MARGIN,MARGIN+(i-topLine)*lineSkip + fontMetrics.getAscent());
         if (doingInput && cursorOn) {
            g.setColor(CURSOR_COLOR);
            int x = MARGIN + fontMetrics.stringWidth(lines[lineCount-1])+1;
            int y1 = MARGIN + (lineCount-1-topLine)*lineSkip + fontMetrics.getAscent() + fontMetrics.getDescent();
            int y2 = y1 - fontMetrics.getAscent() - fontMetrics.getDescent();
            g.drawLine(x,y1,x,y2);
            g.drawLine(x+1,y1,x+1,y2);
         }
      }
 
      synchronized void newLine() {
         checkAbort();
         try {
            Thread.sleep(20);
         }
         catch (InterruptedException e) {
         }
         if (lineCount == lines.length) {
            for (int i = 0; i < lines.length-1; i++)
               lines[i] = lines[i+1];
            lines[lines.length-1] = ""; 
            if (doingInput)
               inputStartLine--;
         }
         else {
            lines[lineCount] = "";
            lineCount++;
         }
         scrollToEnd();
         repaint();
      }
      synchronized void putChar(char ch) {
         checkAbort();
         if (ch == '\n') {
            newLine();
            return;
         }
         if (ch == '\t')
            ch = ' ';
         if (!Character.isDefined(ch) || Character.isISOControl(ch))
            return;
         if (columns > 0 && lines[lineCount-1].length() >= columns)
            newLine();
         lines[lineCount-1] += ch;
      }
      
      synchronized void deleteChar() {
         if (lineCount == 0)
            return;
         if (inputStartLine == lineCount-1 && inputStartColumn >= lines[lineCount-1].length())
            return;
         if (lines[lineCount-1].length() > 0)
            lines[lineCount-1] = lines[lineCount-1].substring(0,lines[lineCount-1].length()-1);
         else {
            lineCount--;
            scrollToEnd();
         }
      }
      
      synchronized private void putString(String str) {
         for (int i = 0; i < str.length(); i++)
            putChar(str.charAt(i));
         scrollToEnd();
         repaint();
      }
      
      void scrollToEnd() {
         if (rows == 0)
            return;
         if (lineCount <= rows) {
            topLine = 0;
            scroller.setEnabled(false);
         }
         else {
            topLine = lineCount - rows;
            scroller.setEnabled(true);
         }
         scroller.setValues(topLine,rows,0,rows+topLine);
      }
      
      synchronized void doInputChar(char ch) {
         checkAbort();
         if (ch == 8 || ch == 127) {
            deleteChar();
            if (inputBuffer.length() >  0)
               inputBuffer = inputBuffer.substring(0,inputBuffer.length()-1);
         }
         else if (ch == 13 || ch == 10) {
            newLine();
            doingInput = false;
         }
         else {
            putChar(ch);
            if (ch == '\t')
               ch = ' ';
            if (Character.isDefined(ch) && ! Character.isISOControl(ch))
               inputBuffer += ch;
         }
         scrollToEnd();
         repaint();
      }
      
      synchronized void clearTypeAhead() {
         typeAheadBuffer = "";
      }
      
      synchronized void clear() {
         buffer = null;
         clearTypeAhead();
         lineCount = 1;
         lines[0] = "";
         topLine = 0;
         scrollToEnd();
      }
      
      void checkAbort() {
         if (aborted)
            throw new AbortException();
      }
      
      class CIN extends Reader {  // "Standard input" is replaced in TextIO with an object of this type.
         String buffer;
         int pos;
         public void close() {
         }
         public int read(char[] b, int offset, int length) throws IOException {
            int ct = 0;
            int ch;
            do {
               ch = read();
               b[offset + ct] = (char)ch;
               ct++;
            } while (ch != 10);
            return ct;
         }
         public int read() {
            if (buffer != null && pos < buffer.length()) {
               pos++;
               return buffer.charAt(pos-1);
            }
            synchronized(Console.this) {
               inputStartLine = lineCount - 1;
               inputStartColumn = lines[lineCount-1].length();
               char ch = 0;
               scrollToEnd();
               inputBuffer = "";
               while (typeAheadBuffer.length() > 0) {
                  ch = typeAheadBuffer.charAt(0);
                  typeAheadBuffer = typeAheadBuffer.substring(1);
                  if (ch == 13 || ch == 10)
                     break;
                  doInputChar(ch);
                  repaint();
                  try {
                     Console.this.wait(25);
                  }
                  catch (InterruptedException e) {
                  }
               }
               if (ch != 13 && ch != 10) {
                  doingInput = true;
                  cursorOn = true;
                  requestFocus();
                  while (doingInput) {
                     try {
                        Console.this.wait(300);
                        cursorOn = !cursorOn;
                        repaint();
                     }
                     catch (InterruptedException e) {
                        cursorOn = true;
                        repaint();
                     }
                     checkAbort();
                  }
                  cursorOn = false;
                  repaint();
               }
               buffer = inputBuffer + (char)10;
               pos = 1;
               return buffer.charAt(0);
            }
         }
      }
 
      class COUT extends Writer { // "Standard output" is replaced in TextIO with an object of this type.
         public void write(int b) {
            write(new char[] { (char)(b & 0xFFFF) }, 0, 1);
         }
         public void write(char[] b, int offset, int length) {
            for (int i = offset; i < offset+length; i++) {
               putChar(b[i]);
            }
         }
         public void write(char[] b) {
            write(b,0,b.length);
         }
         public void close() {
         }
         public void flush() {
         }
      }
 
   } // end nested class Console
   
   //************************ Shared private member variables *************************
   
   private String inputFileName;  // Name of file that is the current input source, or null if the source is not a file.
   private String outputFileName; // Name of file that is the current output destination, or null if the destination is not a file.
   
   private JFileChooser fileDialog; // Dialog used by readUserSelectedFile() and writeUserSelectedFile()
   
   private final BufferedReader standardInput;  // wraps the input stream from Console. (Set in initializer.)
   private final PrintWriter standardOutput;  // wraps the output stream. (Set in initializer.)
   
   private BufferedReader in;  // Stream that data is read from; the current input source. (Set in initializer.)
   private PrintWriter out;   // Stream that data is written to; the current output destination. (Set in initializer.)
   
   private boolean readingStandardInput = true;
   private boolean writingStandardOutput = true;
   
   private int inputErrorCount;  // Number of consecutive errors on standard input; reset to 0 when a successful read occurs.
   private int outputErrorCount;  // Number of errors on standard output since it was selected as the output destination.
   
   private Matcher integerMatcher;  // Used for reading integer numbers; created from the integer Regex Pattern.
   private Matcher floatMatcher;   // Used for reading floating point numbers; created from the floatRegex Pattern.
   private final Pattern integerRegex = Pattern.compile("(\\+|-)?[0-9]+");
   private final Pattern floatRegex = Pattern.compile("(\\+|-)?(([0-9]+(\\.[0-9]*)?)|(\\.[0-9]+))((e|E)(\\+|-)?[0-9]+)?");
   
   private String buffer = null;  // One line read from input.
   private int pos = 0;           // Position of next char in input line that has not yet been processed.
   
   private Console console;  // The GUI IO widget used for simulated input/output.
   
 
   
} // end of class TextIO