DEFINITION MODULE PascalIO;
(* This module provides for I/O that is essentially equivalent to the I/O
   provided by Pascal with "text", or "file of char".
   However, the user must call a cleanup routine at the end of his program
   for the output buffers to be flushed.
*)

  CONST	Eos = 0C;		(* End of string character *)

  TYPE	Text;

  VAR	Input, Output: Text;	(* standard input and standard output available
				   immediately.
				   Standard output is not buffered when
				   connected to a terminal.
				*)
  VAR	Notext: Text;		(* Initialize your Text variables with this *)

  PROCEDURE Reset(VAR InputText: Text; Filename: ARRAY OF CHAR);
  (* When InputText indicates an open textfile, it is first flushed
     and closed. Then, the file indicated by "Filename" is opened for reading.
     If this fails, a runtime error results. Otherwise, InputText is
     associated with the new input file.
  *)

  PROCEDURE Rewrite(VAR OutputText: Text; Filename: ARRAY OF CHAR);
  (* When OutputText indicates an open textfile, it is first flushed
     and closed. Then, the file indicated by "Filename" is opened for writing.
     If this fails, a runtime error results. Otherwise, OutputText is
     associated with the new output file.
  *)

  PROCEDURE CloseOutput();
  (* To be called at the end of the program, to flush all output buffers *)

  (***************************************************************************
     Input routines;
     All these routines result in a runtime error when not called with either
     "Input", or a "Text" value obtained by Reset.
     Also, the routines that actually advance the "read pointer", result in a
     runtime error when end of file is reached prematurely.
  ****************************************************************************)

  PROCEDURE NextChar(InputText: Text): CHAR;
  (* Returns the next character of the InputText, 0C on end of file.
     Does not advance the "read pointer", so behaves much like "input^"
     in Pascal. However, unlike Pascal, if Eoln(InputText) is true, it
     returns the newline character, rather than a space.
  *)

  PROCEDURE Get(InputText: Text);
  (* Advances the "read pointer" by one character *)

  PROCEDURE Eoln(InputText: Text): BOOLEAN;
  (* Returns TRUE if the next character of the InputText is a linefeed.
     Unlike Pascal however, it does not produce a runtime error when
     called when Eof(InputText) is TRUE.
  *)

  PROCEDURE Eof(InputText: Text): BOOLEAN;
  (* Returns TRUE if the end of the InputText is reached *)

  PROCEDURE ReadChar(InputText: Text; VAR Char: CHAR);
  (* Read a character from the InputText, and leave result in "Char".
     Unlike Pascal, if Eoln(InputText) is true, the newline character
     is put in "Char".
  *)

  PROCEDURE ReadLn(InputText: Text);
  (* Skip the rest of the current line of the InputText,
     including the linefeed
  *)

  PROCEDURE ReadInteger(InputText: Text; VAR Integer: INTEGER);
  (* Skip leading blanks, read an optionally signed integer from the
     InputText, and leave the result in "Integer".
     If no integer is read, or when overflow occurs, a runtime error results.
     Input stops at the character following the integer.
  *)

  PROCEDURE ReadCardinal(InputText: Text; VAR Cardinal: CARDINAL);
  (* Skip leading blanks, read a cardinal from the InputText, and leave the
     result in "Cardinal".
     If no cardinal is read, or when overflow occurs, a runtime error results.
     Input stops at the character following the cardinal.
  *)

  PROCEDURE ReadReal(InputText: Text; VAR Real: REAL);
  (* Skip leading blanks, read a real from the InputText, and leave the
     result in "Real".
     Syntax:
      real -->	[(+|-)] digit {digit} [. digit {digit}]
		[ E [(+|-)] digit {digit} ]
     If no real is read, or when overflow/underflow occurs, a runtime error
     results.
     Input stops at the character following the real.
  *)

  (***************************************************************************
     Output routines;
     All these routines result in a runtime error when not called with either
     "Output", or a "Text" value obtained by Rewrite.
  ****************************************************************************)

  PROCEDURE WriteChar(OutputText: Text; Char: CHAR);
  (* Writes the character "Char" to the OutputText *)

  PROCEDURE WriteLn(OutputText: Text);
  (* Writes a linefeed to the OutputText *)

  PROCEDURE Page(OutputText: Text);
  (* Writes a form-feed to the OutputText *)

  PROCEDURE WriteInteger(OutputText: Text; Integer: INTEGER; Width: CARDINAL);
  (* Write integer "Integer" to the OutputText, using at least "Width" places,
     blank-padding to the left if needed.
  *)

  PROCEDURE WriteCardinal(OutputText: Text; Cardinal, Width: CARDINAL);
  (* Write cardinal "Cardinal" to the OutputText, using at least
     "Width" places, blank-padding to the left if needed.
  *)

  PROCEDURE WriteBoolean(OutputText: Text; Boolean: BOOLEAN; Width: CARDINAL);
  (* Write boolean "Boolean" to the OutputText, using at least "Width" places,
     blank-padding to the left if needed.
     Equivalent to WriteString(OutputText, " TRUE", Width), or
		   WriteString(OutputText, "FALSE", Width)
  *)

  PROCEDURE WriteString(OutputText: Text;
			String: ARRAY OF CHAR; Width: CARDINAL);
  (* Write string "String" to the OutputText, using at least "Width" places,
     blank-padding to the left if needed.
     The string is terminated either by the character Eos, or the upperbound of
     the array "String".
  *)

  PROCEDURE WriteReal(OutputText: Text; Real: REAL; Width, Nfrac: CARDINAL);
  (* Write real "Real" to the OutputText. If "Nfrac" = 0, use scientific
     notation, otherwise use fixed-point notation with "Nfrac" digits behind
     the dot.
     Always use at least "Width" places, blank-padding to the left if needed.
  *)

END PascalIO.