141 lines
5.5 KiB
Modula-2
141 lines
5.5 KiB
Modula-2
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 *)
|
|
|
|
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" *)
|
|
|
|
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 "card".
|
|
If no cardinal is read, or when overflow occurs, a runtime error results.
|
|
Input stops at the character following the integer.
|
|
*)
|
|
|
|
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 integer.
|
|
*)
|
|
|
|
(***************************************************************************
|
|
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(" TRUE", Width), or
|
|
WriteString("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.
|