DEFINITION MODULE FIO2; (* FileInOut *)
(*------------------------------------------------------------------------*)
(* Fileorientierte Lese- und Schreibprozeduren. *)
(* *)
(* File oriented read and write procedures. *)
(*------------------------------------------------------------------------*)
(* Implementation : Michael Riedl *)
(* Licence : GNU Lesser General Public License (LGPL) *)
(*------------------------------------------------------------------------*)
(* $Id: FIO2.def,v 1.4 2018/03/21 11:05:30 mriedl Exp mriedl $ *)
FROM SYSTEM IMPORT BYTE;
FROM FileSystem IMPORT File;
IMPORT CommonIO;
VAR EOL : BOOLEAN; (* Zeilenende erreicht ja/nein *)
EOF : BOOLEAN;
DiskFull : BOOLEAN;
warn : BOOLEAN;
CONST EoL = CommonIO.EoL; (* Zeichen f"ur Zeilenende. *)
EoF = CommonIO.EoF; (* Zeichen f"ur Dateiende. *)
VAR ExpAnz : CARDINAL; (* *** Obsolet *** *)
(* legt die Anzahl der Ziffern im Exponenten *)
(* fest, bitte die Prozedur "SetExpAnz" nutzen *)
PROCEDURE SetExpAnz(nExp : CARDINAL);
(*----------------------------------------------------------------*)
(* Setzt die Anzahl der Ziffern im Exponenten von Fliesskomma- *)
(* zahlen in Exponentialschreibweise. Der Wert von nExp sollte *)
(* im Bereich [1..4] liegen, Vorgabe ist 2 was fuer die meisten *)
(* Zwecke ausreichend sein sollte. *)
(* Bitte beachten dass dieser Werte fuer TIO und FIO2 *)
(* nicht unabhaengig gewaehlt werden kann da beide Module auf *)
(* dieselben Schreibroutinen in FIO2.mod zurueckgreifen. *)
(* *)
(* Defines the number of digits in the exponent of floating point *)
(* values in sientific or engineering representation. The value *)
(* of nExp shall be in the interval [1..4], default value is 2 *)
(* which should be sufficient for most cases. *)
(* Please note the for TIO and FIO2 the value cannot be choosen *)
(* independently. *)
(*----------------------------------------------------------------*)
PROCEDURE RdWort( Ein : File;
VAR Wort : ARRAY OF CHAR);
(*----------------------------------------------------------------*)
(* Lie\3t solange Zeichen von der Datei Ein, bis eine Zeichen- *)
(* kette beginnt. Ab da wird bis EOL oder dem ersten Trennzeichen *)
(* (' ',CHAR(9)) gelesen. *)
(* Wird dabei HIGH(Wort)-1 "uberschritten, wird die bis dahin *)
(* gelesene Zeichenkette zur"uckgegeben. *)
(* *)
(* Reads charactes from stream "Datei" until a string begins. *)
(* The reads to string "Wort" until the next delimiter *)
(* (' ',ASCII.lf,ASCII.tab). If the string is too long long *)
(* to be placed in "Wort" it will be truncated *)
(*----------------------------------------------------------------*)
PROCEDURE ReadLine(VAR Ein : File; VAR Line : ARRAY OF CHAR);
(*----------------------------------------------------------------*)
(* Einlesen aller Zeichen der aktuellen Zeile aus der Datei Ein *)
(* bis EOL erreicht ist. *)
(* *)
(* Reads all characters in the actual line from stream "Ein" *)
(* until EOL is reached *)
(*----------------------------------------------------------------*)
PROCEDURE WrLn(Datei : File);
(*----------------------------------------------------------------*)
(* Schreibt End-of-Line Marke auf die Textdatei 'Datei'. *)
(* *)
(* Write a newline to stream "Datei" *)
(*----------------------------------------------------------------*)
PROCEDURE WrLnN(Datei : File;
n : CARDINAL); (* Anzahl der Zeilenumbr"uche. *)
(*----------------------------------------------------------------*)
(* Schreibt n End-of-Line Marken auf die Textdatei 'Datei'. *)
(* *)
(* Write "n" times a newline to stream "Datei" *)
(*----------------------------------------------------------------*)
PROCEDURE RdChar( Datei : File;
VAR chr : CHAR);
(*----------------------------------------------------------------*)
(* Liest den CHAR chr von der Textdatei 'Datei'. *)
(* Wenn ein Zeilenumbruch anliegt wird CommonIO.EoL zurueckge- *)
(* geben, wenn das Dateiende erreicht wurde CommonIO.EoF. *)
(* *)
(* Reads character "chr" from file "Datei". In case end of line *)
(* is reached CommonIO.EoL, in case the end of the file is *)
(* reached CommonIO.EoF will be returned. *)
(*----------------------------------------------------------------*)
PROCEDURE WrChar(Datei : File;
chr : CHAR);
(*----------------------------------------------------------------*)
(* Schreibt den CHAR chr auf die Text-Datei Datei. *)
(* Wenn chr = EoL wird dies in cl,lf "ubersetz, wenn in CommonIO *)
(* die Variable CrLf auf TRUE gesetzt ist. *)
(* *)
(* Writes character "chr" to file "Datei" *)
(*----------------------------------------------------------------*)
PROCEDURE WrCharN(VAR Aus : File;
chr : CHAR;
Anzahl : CARDINAL);
(*----------------------------------------------------------------*)
(* Schreibt das Zeichen chr Anzahl mal aus. *)
(* *)
(* Write character "chr" "Anzahl" times to stream "Aus" *)
(*----------------------------------------------------------------*)
PROCEDURE RdStr( Datei : File;
VAR Wort : ARRAY OF CHAR);
(*----------------------------------------------------------------*)
(* Liest den String Wort von der Textdatei 'Datei'. *)
(* *)
(* Reads String "Wort" from file "Datei" *)
(*----------------------------------------------------------------*)
PROCEDURE WrStr(Datei : File;
Wort : ARRAY OF CHAR);
(*----------------------------------------------------------------*)
(* Schreibt den Zeichenkette Wort auf die Text-Datei Datei. *)
(* *)
(* Writes String "Wort" to file "Datei" *)
(*----------------------------------------------------------------*)
PROCEDURE WrStrForm(VAR Aus : File;
Str : ARRAY OF CHAR;
Breite : INTEGER);
(*----------------------------------------------------------------*)
(* Schreibt Str mit der Gesamtbreite Breite aus. Wenn die L"ange *)
(* der Zeichenkette Str kleiner als Breite ist, wird eine ent- *)
(* sprechende Anzahl Leerzeiche vorangestellt (Breite > 0) oder *)
(* angeh"angt (Breite < 0). Ist die L"ange von Str gr"o3er als *)
(* Breite wird Str unver"andert ausgegeben (d.h. es wird dann *)
(* "uber die angeforderte Breite hinaus geschrieben). *)
(* *)
(* Wrties string "Str" to file "Aus" with a minimal width of *)
(* "Breite" characters. If "Breite" > 0 the field will be left *)
(* padded with blanks, if "Breite" < 0 right padding is done. *)
(* If Breite is not sufficient the field will be expanded ! *)
(*----------------------------------------------------------------*)
PROCEDURE RdCard( Datei : File;
VAR c : CARDINAL);
(*----------------------------------------------------------------*)
(* Liest CARDINAL-Zahl c von der Textdatei 'Datei'. *)
(* Im Fehlerfalle wird MAX(CARDINAL) zur"uckgegeben und *)
(* *)
(* Reads cardinal value "c" form "Datei". In case of an error *)
(* MAX(CARDINAL) is returned. *)
(*----------------------------------------------------------------*)
PROCEDURE WrCard(Datei : File;
c : CARDINAL;
n : CARDINAL); (* Feldbreite *)
(*----------------------------------------------------------------*)
(* Schreibt CARDINAL-Zahl c auf die Textdatei 'Datei'. *)
(* Falls die Feldbreite zu klein zur Darstellung der Zahl c ist, *)
(* wird Feldbreite auf die Mindestanzahl von Zeichen erweitert ! *)
(* *)
(* Write value "c" to file "Datei" with a field width of "n". *)
(* If n is choosen too small it will be expanded to the mininal *)
(* value needed to represent c. *)
(*----------------------------------------------------------------*)
PROCEDURE RdHex( Datei : File;
VAR c : CARDINAL);
(*----------------------------------------------------------------*)
(* Liest CARDINAL-Zahl c von der Textdatei 'Datei' in hexa- *)
(* dezimaler Form. Im Fehlerfalle wird MAX(CARDINAL) zur"uck- *)
(* gegeben. *)
(* *)
(* Reads "c" from "Datei" in hexadecimal representation *)
(* In case of an error MAX(CARDINAL) is returend. *)
(*----------------------------------------------------------------*)
PROCEDURE WrHex(Datei : File;
c : CARDINAL;
n : CARDINAL); (* Feldbreite *)
(*----------------------------------------------------------------*)
(* Schreibt CARDINAL-Zahl c auf die Textdatei 'Datei' in hexa- *)
(* dezimaler Form. *)
(* Falls die Feldbreite zu klein zur Darstellung der Zahl c ist, *)
(* wird Feldbreite auf die Mindestanzahl von Zeichen erweitert ! *)
(* *)
(* Writes "c" to "Datei" in hexadecimal representation *)
(*----------------------------------------------------------------*)
PROCEDURE WrBits(Datei : File;
c : CARDINAL;
nbits : CARDINAL); (* Feldbreite *)
(*----------------------------------------------------------------*)
(* Schreibt die ersten nbits BITS der CARDINAL-Zahl c in die *)
(* Textdate "Datei". Das hoechstwertigste Bit wird dabei zuerst *)
(* ausgegeben. Falls die Feldbreite zu klein zur Darstellung der *)
(* Zahl c ist, wird Feldbreite auf die Mindestanzahl von Zeichen *)
(* erweitert ! *)
(* *)
(* Beispiel: c = 13, nbits = 5 , Ausgabe ist "01101" *)
(* *)
(* Writes the first nbits bit of "c" to "Datei". The bit with *)
(* highst value is printed first. If nbits is choosen too small *)
(* the field will be expanded ! *)
(* *)
(* example : c = 13, nbits = 5 , output is "10110" *)
(*----------------------------------------------------------------*)
PROCEDURE RdOct( Datei : File;
VAR c : CARDINAL);
(*----------------------------------------------------------------*)
(* Liest CARDINAL-Zahl c von der Textdatei 'Datei' in okta- *)
(* dezimaler Form. *)
(* Im Fehlerfalle wird MAX(CARDINAL) zur"uckgegeben. *)
(* *)
(* Reads "c" from "Datei" in octal notation form *)
(*----------------------------------------------------------------*)
PROCEDURE WrOct(Datei : File;
c : CARDINAL;
n : CARDINAL); (* Feldbreite *)
(*----------------------------------------------------------------*)
(* Schreibt CARDINAL-Zahl c auf die Textdatei 'Datei' in octa- *)
(* dezimaler Form. *)
(* Falls die Feldbreite zu klein zur Darstellung der Zahl c ist, *)
(* wird Feldbreite auf die Mindestanzahl von Zeichen erweitert ! *)
(* *)
(* Writed "c" to file "Datei" in octal notation form *)
(*----------------------------------------------------------------*)
PROCEDURE RdLngCard( Datei : File;
VAR C : LONGCARD);
(*----------------------------------------------------------------*)
(* Liest LONGCARD-Zahl C von der Textdatei 'Datei'. *)
(* *)
(* Reads value "C" form "Datei". In case of an error *)
(* MAX(CARDINAL) is returned. *)
(*----------------------------------------------------------------*)
PROCEDURE WrLngCard(Datei : File;
C : LONGCARD;
n : CARDINAL); (* Feldbreite *)
(*----------------------------------------------------------------*)
(* Schreibt LONGCARD-Zahl C auf die Textdatei 'Datei'. *)
(* Falls die Feldbreite zu klein zur Darstellung der Zahl C ist, *)
(* wird Feldbreite auf die Mindestanzahl von Zeichen erweitert ! *)
(* *)
(* Write value "C" to file "Datei" with a field width of "n". *)
(* If n is choosen too small it will be expanded to the mininal *)
(* value needed to represent c. *)
(*----------------------------------------------------------------*)
PROCEDURE RdInt( Datei : File;
VAR i : INTEGER);
(*----------------------------------------------------------------*)
(* Liest Integer-Zahl i von der Textdatei 'Datei'. *)
(* *)
(* Reads value "i" form "Datei". In case of an error MAX(INTEGER) *)
(* is returned and Datei.res is set to "notdone" *)
(*----------------------------------------------------------------*)
PROCEDURE WrInt(Datei : File;
i : INTEGER;
n : CARDINAL); (* Feldbreite *)
(*----------------------------------------------------------------*)
(* Schreibt Integer-Zahl i auf die Textdatei 'Datei'. *)
(* *)
(* Writes the value "i" to "Datei" with a field width of "n" *)
(*----------------------------------------------------------------*)
PROCEDURE WrLngInt(Datei : File;
I : LONGINT;
n : CARDINAL); (* Feldbreite *)
(*----------------------------------------------------------------*)
(* Schreibt Integer-Zahl I auf die Textdatei 'Datei'. *)
(* *)
(* Same as WrInt for LONGINT values *)
(*----------------------------------------------------------------*)
PROCEDURE RdLngReal( Datei : File;
VAR x : LONGREAL);
(*----------------------------------------------------------------*)
(* Liest Real-Zahl x von der Textdatei 'Datei'. *)
(* Syntax : Siehe RealConvert.StingToReal. *)
(* *)
(* Reads real value "x" form "Datei". In case of an error *)
(* MAX(LONGREAL) is returned (should be NAN) *)
(* For the syntax of a value x please refer to *)
(* RealConvert.StringToReal *)
(*----------------------------------------------------------------*)
PROCEDURE WrLngReal(Datei : File;
x : LONGREAL;
Breite : CARDINAL; (* Feldbreite *)
Komma : INTEGER); (* Nachkommastellen *)
(*----------------------------------------------------------------*)
(* Schreibt Real-Zahl x auf die Textdatei 'Datei'. *)
(* Wenn (m < 0) ==> EXP-Darstellung. Es werden "Komma" Nachkomma- *)
(* stellen in einem Feld der Gesamtbreite "Breite". Wenn eine *)
(* Darstellung nicht moeglich ist wird das Feld mit "*" gefuellt *)
(* ("ahnlich Fortran) *)
(* *)
(* Write real value "x" to "Datei" with "Komma" decimal digits *)
(* and a field width of "Breite". If Komma < 0 exponential *)
(* representation is used. In case the value is not representable *)
(* the entire field is filled by "*" (similar to Fortran) *)
(*----------------------------------------------------------------*)
PROCEDURE WrReal(Datei : File;
x : REAL;
Breite : CARDINAL; (* Feldbreite *)
Komma : INTEGER); (* Nachkommastellen *)
(*----------------------------------------------------------------*)
(* Schreibt Real-Zahl x auf die Textdatei 'Datei'. *)
(* Wenn (Komma < 0) ==> EXP-Darstellung *)
(* *)
(* Similar to WrLngReal for "REAL" values. *)
(*----------------------------------------------------------------*)
PROCEDURE WrLngCmplx(Datei : File;
x : LONGCOMPLEX;
Breite : CARDINAL; (* Feldbreite *)
Komma : INTEGER); (* Nachkommastellen *)
(*----------------------------------------------------------------*)
(* Schreibt Complex-Zahl x auf die Textdatei 'Datei'. *)
(* Wenn (Komma < 0) ==> EXP-Darstellung. *)
(* Breite, Komma beziehen sich auf Einzelkomponenten von x. *)
(* *)
(* Write a long complex value to Datei. For "Breite" and "Komma" *)
(* see WrLngReal. *)
(*----------------------------------------------------------------*)
PROCEDURE WrBool(Datei : File;
Bool : BOOLEAN);
(*----------------------------------------------------------------*)
(* Schreibt den BOOLEAN - Ausdruck Bool als String (TRUE/FALSE) *)
(* *)
(* Write "TRUE " or "FALSE" debending on the value of "Bool" *)
(*----------------------------------------------------------------*)
PROCEDURE RdBin( Datei : File;
VAR Objekt : ARRAY OF BYTE);
(*----------------------------------------------------------------*)
(* Lie\3t beliebiges Objekt (Real,Integer,Cardinal,Array,Record *)
(* etc.) bin"ar von der Datei "Datei". *)
(* *)
(* Read an abitrary Objekt (Real,Integer,Cardinal,Array,Record *)
(* etc.) in binary form form file "Datei". *)
(*----------------------------------------------------------------*)
PROCEDURE WrBin( Datei : File;
VAR Objekt : ARRAY OF BYTE);
(*----------------------------------------------------------------*)
(* Schreibt beliebiges Objekt (Real,Integer,Cardinal,Array,Record *)
(* etc.) bin"ar auf die Datei "Datei". *)
(* *)
(* Write an abitrary Objekt (Real,Integer,Cardinal,Array,Record *)
(* etc.) in binary form to file "Datei". *)
(*----------------------------------------------------------------*)
END FIO2.