XFormAus.mod.m2cc
914 lines (863 with data), 32.2 kB
#ifdef __TERM__
IMPLEMENTATION MODULE TFormAus;
#endif
#ifdef __FILE__
IMPLEMENTATION MODULE FFormAus;
#endif
#ifdef __STREAM__
IMPLEMENTATION MODULE SFormAus;
#endif
(*========================================================================*)
(* WICHTIG: BITTE NUR DIE DATEI XFormAus.mod.m2cc EDITIEREN !!! *)
(*========================================================================*)
#ifdef KOMMENTAR
(* *)
(* Dieses Module enthaelt Versionen fuer *)
(* *)
(* - die Bildschirmausgabe (TFormAus.mod) *)
(* *)
(* m2cc -D __TERM__ < XFormAus.mod.m2cc > TFormAus.mod *)
(* *)
(* - die Ausgabe in eine Datei (FFormAus.mod) *)
(* *)
(* m2cc -D __FILE__ < XFormAus.mod.m2cc > FFormAus.mod *)
(* *)
(* - die Ausgabe in einen Stream (SFormAus.mod) *)
(* *)
(* m2cc -D __STREAM__ < XFormAus.mod.m2cc > SFormAus.mod *)
(* *)
(*------------------------------------------------------------------------*)
#endif
(* *)
#ifdef __TERM__
(* Prozeduren zur Ausgabe von N Parametern (WriteN) auf dem Bildschirm *)
(* Procedures for the output of N parameters (WriteN) on the screen *)
(* ------------------------------------------------------------------- *)
#endif
#ifdef __FILE__
(* Prozeduren zur Ausgabe von N Parametern (dWriteN) in eine Datei *)
(* Procedures for the output of N parameters (dWriteN) on a file *)
(* --------------------------------------------------------------- *)
#endif
#ifdef __STREAM__
(* Prozeduren zur Ausgabe von N Parametern (dWriteN) auf einen Stream *)
(* Procedures for the output of N parameters (dWriteN) on a stream *)
(* ------------------------------------------------------------------- *)
#endif
(* Letzte Bearbeitung: *)
(* *)
(* 05.09.94, MRi: Durchsicht von FormAus *)
(* 02.08.95, MRi: Durchsicht von SFormAus *)
(* 22.06.15, MRi: Einf"uhren des "An"-Formats in WriteN,dWriteN *)
(* 02.10.16, MRi: Aufsplitten der Module FormAus und SFormAus in *)
(* TFormAus,FFormAus,SFormAus *)
(* 04.01.18, MRi: Erstellen eines einheitlichen Basismodules fuer den *)
(* Praeprozessoer m2cc *)
(* Hinzufuegen von {d}Write6 *)
(* 05.01.18, MRi: Hinzufuegen der Routinen {d}Write7 und SetExpAnz *)
(* 21.03.18, MRi: In SetExpAnz wird nun auf {SIO|TIO|FIO2}.SetExpAnz *)
(* referenziert *)
(* 01.09.18, MRi: Korrektur in ByteToStr wenn Zeichenkettenlaenge = 255 *)
(* d.h. Zeichenkette vom Typ "Deklera.STRING" *)
(*------------------------------------------------------------------------*)
(* Offene Punkte *)
(* *)
(* - Eventuell die Formatanweisung ausgeben wenn eine ByteToXXX Routinen *)
(* einen Fehler meldet so dass diese leichter gefunden werden kann. *)
(* - Durchsicht der Laengenparameter fuer Cardinal *)
(* - Ausschreiben einer LONGINT wie LONGCARD behandeln *)
(* - Ausschreiben von REAL einfuegen - Mechanismus wie bei CARDINAL *)
(*------------------------------------------------------------------------*)
(* Implementation : Michael Riedl *)
(* Licence : GNU Lesser General Public License (LGPL) *)
(*------------------------------------------------------------------------*)
(* $Id: XFormAus.mod.m2cc,v 1.3 2018/09/01 10:07:50 mriedl Exp mriedl $ *)
#ifdef __TERM__
#endif
#ifdef __FILE__
#endif
#ifdef __STREAM__
#endif
FROM SYSTEM IMPORT BYTE,TSIZE,ADR;
FROM ConvTypes IMPORT ConvResults;
FROM Errors IMPORT Fehler,Fehlerflag,ErrOut;
IMPORT Errors;
#ifdef __TERM__
FROM FileSystem IMPORT Output,File;
IMPORT FIO2;
#endif
#ifdef __FILE__
FROM FileSystem IMPORT File;
IMPORT FIO2;
#endif
#ifdef __STREAM__
FROM Streams IMPORT Stream;
IMPORT SIO;
#endif
FROM StringsLib IMPORT Copy,Concat;
FROM Deklera IMPORT STRING;
FROM NumConvert IMPORT StringToCard,StringToInt;
IMPORT TIO;
FROM FormAusLib IMPORT WrByteStr,ByteToInt,ByteToCard,
ByteToLngCard,ByteToLngReal,StrPrt,
PreParseFormat;
PROCEDURE SetExpAnz(nExp : CARDINAL);
BEGIN
IF (nExp < 1) OR (nExp > 4) THEN nExp:=4; END;
#ifdef __TERM__
FIO2.SetExpAnz(nExp);
#endif
#ifdef __FILE__
FIO2.SetExpAnz(nExp);
#endif
#ifdef __STREAM__
SIO.SetExpAnz(nExp);
#endif
END SetExpAnz;
#ifdef __TERM__
PROCEDURE dWrByteStr( Aus : File;
#endif
#ifdef __FILE__
PROCEDURE dWrByteStr( Aus : File;
#endif
#ifdef __STREAM__
PROCEDURE dWrByteStr(VAR Aus : Stream; (* F"ur Mocka *)
#endif
Str : ARRAY OF BYTE;
Laenge : CARDINAL);
VAR String : StrPrt;
BEGIN
String:=ADR(Str);
IF (Laenge >= TSIZE(STRING)) THEN
IF (Laenge > TSIZE(STRING)) THEN
(* Keine Fehlermeldung wenn Zeichenkette vom Typ "STRING" *)
ErrOut("Zeichenkette zu lang (xFormAus.ByteToStr) !");
END;
Laenge:=TSIZE(STRING) - 1;
END;
String^[Laenge]:=0C;
#ifdef __TERM__
FIO2.WrStr(Aus,String^);
#endif
#ifdef __FILE__
FIO2.WrStr(Aus,String^);
#endif
#ifdef __STREAM__
SIO.WrStr(Aus,String^);
#endif
END dWrByteStr;
#ifdef __TERM__
PROCEDURE dWrByteStrN( Aus : File;
#endif
#ifdef __FILE__
PROCEDURE dWrByteStrN( Aus : File;
#endif
#ifdef __STREAM__
PROCEDURE dWrByteStrN(VAR Aus : Stream; (* F"ur Mocka *)
#endif
Str : ARRAY OF BYTE; (* F"ur Mocka *)
Laenge : CARDINAL);
VAR String : StrPrt;
BEGIN
String:=ADR(Str);
IF (Laenge > TSIZE(STRING)) THEN
ErrOut("Zeichenkette zu lang (xFormAus.ByteToStr) !");
Laenge:=TSIZE(STRING) - 1;
END;
String^[Laenge]:=0C;
#ifdef __TERM__
FIO2.WrStrForm(Aus,String^,-VAL(INTEGER,Laenge));
#endif
#ifdef __FILE__
FIO2.WrStrForm(Aus,String^,-VAL(INTEGER,Laenge));
#endif
#ifdef __STREAM__
SIO.WrStrForm(Aus,String^,-VAL(INTEGER,Laenge));
#endif
END dWrByteStrN;
CONST max = 9; (* Maximalzahl der Parameter *)
TYPE ByteFeld = ARRAY [1..max] OF ARRAY [0..255] OF BYTE;
VAR Parameter : ByteFeld;
Laengen : ARRAY [1..max] OF CARDINAL;
FFlag : ARRAY [strAllRight..strEmpty] OF ARRAY [0..31] OF CHAR;
#ifdef __TERM__
PROCEDURE dWriteN( Aus : File;
#endif
#ifdef __FILE__
PROCEDURE dWriteN( Aus : File;
#endif
#ifdef __STREAM__
PROCEDURE dWriteN(VAR Aus : Stream;
#endif
Format : ARRAY OF CHAR;
Anzahl : CARDINAL);
(*----------------------------------------------------------------*)
(* Schreibt Anzahl Parameter nach Format in die Datei Aus. *)
(*----------------------------------------------------------------*)
CONST debug = FALSE; (* Ausschreiben auf dem Bildschirm ? *)
VAR Int : INTEGER;
Card : CARDINAL;
LngCard : LONGCARD;
X : LONGREAL;
ZahlStr : STRING;
i,k,l,n,Par : CARDINAL;
m : INTEGER;
result : ConvResults;
gesperrt : BOOLEAN;
LFormat : STRING; (* Lokale Kopie des Format-StringsLib. *)
done : BOOLEAN;
BEGIN
Copy(LFormat,Format); (* Wegen m"oglicherweise fehlendem 0C *)
(* nX nach Xn, n(fmt) nach n*fmt ... *)
PreParseFormat(LFormat,LFormat,done);
IF NOT done THEN
ErrOut("Fehler in PreParseFormat (xFormAus)");
END;
i:=0; Par:=1; gesperrt:=FALSE; Fehler:=FALSE;
WHILE (LFormat[i] # 0C) DO
CASE CAP(LFormat[i]) OF
#ifdef __TERM__
'/' : FIO2.WrLn(Aus); INC(i);
#endif
#ifdef __FILE__
'/' : FIO2.WrLn(Aus); INC(i);
#endif
#ifdef __STREAM__
'/' : SIO.WrLn(Aus); INC(i);
#endif
IF debug THEN TIO.WrLn; END;
|'X' : IF (LFormat[i+1] = ',') OR (LFormat[i+1] = 0C) THEN
#ifdef __TERM__
FIO2.WrChar(Aus,' '); INC(i);
#endif
#ifdef __FILE__
FIO2.WrChar(Aus,' '); INC(i);
#endif
#ifdef __STREAM__
SIO.WrChar(Aus,' '); INC(i);
#endif
IF debug THEN TIO.WrChar(' '); END;
ELSE
INC(i); k:=0;
WHILE (LFormat[i] # ',') AND (LFormat[i] # 0C) DO
ZahlStr[k]:=LFormat[i];
INC(i); INC(k);
END;
ZahlStr[k]:=0C;
StringToCard(ZahlStr,k,result);
IF (result = strAllRight) THEN
FOR l:=1 TO k DO
#ifdef __TERM__
FIO2.WrChar(Aus,' ');
#endif
#ifdef __FILE__
FIO2.WrChar(Aus,' ');
#endif
#ifdef __STREAM__
SIO.WrChar(Aus,' ');
#endif
IF debug THEN TIO.WrChar(' '); END;
END;
END;
END;|
'A' : INC(i);
IF NOT gesperrt THEN
IF (LFormat[i] = ',') OR (LFormat[i] = 0C) THEN
(* "A" wird wie "S" behandelt *)
dWrByteStr(Aus,Parameter[Par],Laengen[Par]); INC(Par);
ELSE
(* "An" wurde angegeben *)
k:=0;
WHILE (LFormat[i] # ',') AND (LFormat[i] # 0C) DO
ZahlStr[k]:=LFormat[i];
INC(i); INC(k);
END;
ZahlStr[k]:=0C;
StringToCard(ZahlStr,n,result);
IF (result # strAllRight) THEN
Concat(Fehlerflag,FFlag[result],
" (SFormAus.dWriteN) (A?) !");
ErrOut(Fehlerflag); n:=3;
END;
(* Nochmal pruefen *)
dWrByteStrN(Aus,Parameter[Par],n);
INC(Par);
END;
ELSE
ErrOut('Fehler bei String-Ausgabe (WriteN).');
Fehler:=TRUE;
RETURN;
END;
IF (Par > Anzahl) THEN gesperrt:=TRUE; END; |
'S' : INC(i);
IF NOT gesperrt THEN
dWrByteStr(Aus,Parameter[Par],Laengen[Par]); INC(Par);
IF debug THEN WrByteStr(Parameter[Par],Laengen[Par]); END;
ELSE
ErrOut('Fehler bei String-Ausgabe (dWriteN).');
Fehler:=TRUE;
RETURN;
END;
IF (Par > Anzahl) THEN gesperrt:=TRUE; END; |
'F' : INC(i); k:=0;
WHILE (LFormat[i] # '.') DO
ZahlStr[k]:=LFormat[i];
INC(i); INC(k);
END;
ZahlStr[k]:=0C;
StringToCard(ZahlStr,n,result);
IF (result # strAllRight) THEN
Concat(Fehlerflag,FFlag[result]," (SFormAus.dWriteN) (F?.m) !");
ErrOut(Fehlerflag); n:=12;
END;
INC(i); k:=0;
WHILE (LFormat[i] # ',') AND (LFormat[i] # 0C) DO
ZahlStr[k]:=LFormat[i];
INC(i); INC(k);
END;
ZahlStr[k]:=0C;
StringToInt(ZahlStr,m,result);
IF (result # strAllRight) THEN
Concat(Fehlerflag,FFlag[result]," (SFormAus.dWriteN) (Fn.?) !");
ErrOut(Fehlerflag); m:=6;
END;
IF NOT gesperrt THEN
X:=ByteToLngReal(Parameter[Par],Laengen[Par]); INC(Par);
#ifdef __TERM__
FIO2.WrLngReal(Aus,X,n,m);
#endif
#ifdef __FILE__
FIO2.WrLngReal(Aus,X,n,m);
#endif
#ifdef __STREAM__
SIO.WrLngReal(Aus,X,n,m);
#endif
IF debug THEN TIO.WrLngReal(X,n,m); END;
ELSE
ErrOut('Fehler bei Flie\3komma-Ausgabe (dWriteN).');
Fehler:=TRUE;
RETURN;
END;
IF (Par > Anzahl) THEN gesperrt:=TRUE; END; |
'E' : INC(i); k:=0;
WHILE (LFormat[i] # '.') DO
ZahlStr[k]:=LFormat[i];
INC(i); INC(k);
END;
ZahlStr[k]:=0C;
StringToCard(ZahlStr,n,result);
IF (result # strAllRight) THEN
Concat(Fehlerflag,FFlag[result]," (SFormAus.dWriteN) (E?.m) !");
ErrOut(Fehlerflag); n:=20;
END;
INC(i); k:=0;
WHILE (LFormat[i] # ',') AND (LFormat[i] # 0C) DO
ZahlStr[k]:=LFormat[i];
INC(i); INC(k);
END;
ZahlStr[k]:=0C;
StringToInt(ZahlStr,m,result);
IF (result # strAllRight) THEN
Concat(Fehlerflag,FFlag[result]," (SFormAus.dWriteN) (En.?) !");
ErrOut(Fehlerflag); m:=8;
END;
IF NOT gesperrt THEN
X:=ByteToLngReal(Parameter[Par],Laengen[Par]); INC(Par);
#ifdef __TERM__
FIO2.WrLngReal(Aus,X,n,-m);
#endif
#ifdef __FILE__
FIO2.WrLngReal(Aus,X,n,-m);
#endif
#ifdef __STREAM__
SIO.WrLngReal(Aus,X,n,-m);
#endif
IF debug THEN TIO.WrLngReal(X,n,-m); END;
ELSE
ErrOut('Fehler bei Festkomma-Ausgabe (dWriteN).');
Fehler:=TRUE;
RETURN;
END;
IF (Par > Anzahl) THEN gesperrt:=TRUE; END; |
'I' : INC(i); k:=0;
WHILE (LFormat[i] # ',') AND (LFormat[i] # 0C) DO
ZahlStr[k]:=LFormat[i];
INC(i); INC(k);
END;
ZahlStr[k]:=0C;
StringToCard(ZahlStr,n,result);
IF (result # strAllRight) THEN
Concat(Fehlerflag,FFlag[result]," (SFormAus.dWriteN) (I?) !");
ErrOut(Fehlerflag); n:=3;
END;
IF NOT gesperrt THEN
Int:=ByteToInt(Parameter[Par],Laengen[Par]); INC(Par);
#ifdef __TERM__
FIO2.WrInt(Aus,Int,n);
#endif
#ifdef __FILE__
FIO2.WrInt(Aus,Int,n);
#endif
#ifdef __STREAM__
SIO.WrInt(Aus,Int,n);
#endif
IF debug THEN TIO.WrInt(Int,n); END;
ELSE
ErrOut('Fehler bei INTEGER-Ausgabe (dWriteN).');
Fehler:=TRUE;
RETURN;
END;
IF (Par > Anzahl) THEN gesperrt:=TRUE; END; |
'C' : INC(i); k:=0;
WHILE (LFormat[i] # ',') AND (LFormat[i] # 0C) DO
ZahlStr[k]:=LFormat[i];
INC(i); INC(k);
END;
ZahlStr[k]:=0C;
StringToCard(ZahlStr,n,result);
IF (result # strAllRight) THEN
Concat(Fehlerflag,FFlag[result]," (SFormAus.dWriteN) (C?) !");
ErrOut(Fehlerflag); n:=3;
END;
IF NOT gesperrt THEN
IF (Laengen[Par] = 2) THEN
Card:=ByteToCard(Parameter[Par],Laengen[Par]);
INC(Par);
#ifdef __TERM__
FIO2.WrCard(Aus,Card,n);
#endif
#ifdef __FILE__
FIO2.WrCard(Aus,Card,n);
#endif
#ifdef __STREAM__
SIO.WrCard(Aus,Card,n);
#endif
ELSE (* LONGCARD - Argument *)
LngCard:=ByteToLngCard(Parameter[Par],Laengen[Par]);
INC(Par);
#ifdef __TERM__
FIO2.WrLngCard(Aus,LngCard,n);
#endif
#ifdef __FILE__
FIO2.WrLngCard(Aus,LngCard,n);
#endif
#ifdef __STREAM__
SIO.WrLngCard(Aus,LngCard,n);
#endif
IF debug THEN TIO.WrLngCard(LngCard,n); END;
END;
ELSE
ErrOut('Fehler bei CARDINAL-Ausgabe (dWriteN).');
Fehler:=TRUE;
RETURN;
END;
IF (Par > Anzahl) THEN gesperrt:=TRUE; END; |
',' : INC(i);|
ELSE
Fehler:=TRUE;
ErrOut('Falsches Format (dWriteN).');
Errors.WriteString("Format : "); Errors.WriteString(LFormat);
Errors.WriteLn;
RETURN;
END;
END;
END dWriteN;
(*........................................................................*)
#ifdef __TERM__
PROCEDURE Write1( Format : ARRAY OF CHAR;
#endif
#ifdef __FILE__
PROCEDURE dWrite1( Aus : File;
Format : ARRAY OF CHAR;
#endif
#ifdef __STREAM__
PROCEDURE dWrite1(VAR Aus : Stream;
Format : ARRAY OF CHAR;
#endif
Par1 : ARRAY OF BYTE);
VAR i : CARDINAL;
BEGIN
Fehler:=FALSE;
Laengen[1]:=HIGH(Par1)+1;
FOR i:=0 TO HIGH(Par1) DO Parameter[1,i]:=Par1[i]; END;
#ifdef __TERM__
dWriteN(Output,Format,1);
IF Fehler THEN ErrOut('Falsches Format (TFormAus.Write1)'); END;
END Write1;
#endif
#ifdef __FILE__
dWriteN(Aus,Format,1);
IF Fehler THEN ErrOut('Falsches Format (FFormAus.Write1)'); END;
END dWrite1;
#endif
#ifdef __STREAM__
dWriteN(Aus,Format,1);
IF Fehler THEN ErrOut('Falsches Format (SFormAus.Write1)'); END;
END dWrite1;
#endif
(*........................................................................*)
#ifdef __TERM__
PROCEDURE Write2( Format : ARRAY OF CHAR;
#endif
#ifdef __FILE__
PROCEDURE dWrite2( Aus : File;
Format : ARRAY OF CHAR;
#endif
#ifdef __STREAM__
PROCEDURE dWrite2(VAR Aus : Stream;
Format : ARRAY OF CHAR;
#endif
Par1 : ARRAY OF BYTE;
Par2 : ARRAY OF BYTE);
VAR i : CARDINAL;
BEGIN
Fehler:=FALSE;
Laengen[1]:=HIGH(Par1)+1; Laengen[2]:=HIGH(Par2)+1;
FOR i:=0 TO HIGH(Par1) DO Parameter[1,i]:=Par1[i]; END;
FOR i:=0 TO HIGH(Par2) DO Parameter[2,i]:=Par2[i]; END;
#ifdef __TERM__
dWriteN(Output,Format,2);
IF Fehler THEN ErrOut('Falsches Format (TFormAus.Write2)'); END;
END Write2;
#endif
#ifdef __FILE__
dWriteN(Aus,Format,2);
IF Fehler THEN ErrOut('Falsches Format (FFormAus.Write2)'); END;
END dWrite2;
#endif
#ifdef __STREAM__
dWriteN(Aus,Format,2);
IF Fehler THEN ErrOut('Falsches Format (SFormAus.Write2)'); END;
END dWrite2;
#endif
(*........................................................................*)
#ifdef __TERM__
PROCEDURE Write3( Format : ARRAY OF CHAR;
#endif
#ifdef __FILE__
PROCEDURE dWrite3( Aus : File;
Format : ARRAY OF CHAR;
#endif
#ifdef __STREAM__
PROCEDURE dWrite3(VAR Aus : Stream;
Format : ARRAY OF CHAR;
#endif
Par1 : ARRAY OF BYTE;
Par2 : ARRAY OF BYTE;
Par3 : ARRAY OF BYTE);
VAR i : CARDINAL;
BEGIN
Fehler:=FALSE;
Laengen[1]:=HIGH(Par1)+1; Laengen[2]:=HIGH(Par2)+1;
Laengen[3]:=HIGH(Par3)+1;
FOR i:=0 TO HIGH(Par1) DO Parameter[1,i]:=Par1[i]; END;
FOR i:=0 TO HIGH(Par2) DO Parameter[2,i]:=Par2[i]; END;
FOR i:=0 TO HIGH(Par3) DO Parameter[3,i]:=Par3[i]; END;
#ifdef __TERM__
dWriteN(Output,Format,3);
IF Fehler THEN ErrOut('Falsches Format (TFormAus.Write3)'); END;
END Write3;
#endif
#ifdef __FILE__
dWriteN(Aus,Format,3);
IF Fehler THEN ErrOut('Falsches Format (FFormAus.Write3)'); END;
END dWrite3;
#endif
#ifdef __STREAM__
dWriteN(Aus,Format,3);
IF Fehler THEN ErrOut('Falsches Format (SFormAus.Write3)'); END;
END dWrite3;
#endif
(*........................................................................*)
#ifdef __TERM__
PROCEDURE Write4( Format : ARRAY OF CHAR;
#endif
#ifdef __FILE__
PROCEDURE dWrite4( Aus : File;
Format : ARRAY OF CHAR;
#endif
#ifdef __STREAM__
PROCEDURE dWrite4(VAR Aus : Stream;
Format : ARRAY OF CHAR;
#endif
Par1 : ARRAY OF BYTE;
Par2 : ARRAY OF BYTE;
Par3 : ARRAY OF BYTE;
Par4 : ARRAY OF BYTE);
VAR i : CARDINAL;
BEGIN
Fehler:=FALSE;
Laengen[1]:=HIGH(Par1)+1; Laengen[2]:=HIGH(Par2)+1;
Laengen[3]:=HIGH(Par3)+1; Laengen[4]:=HIGH(Par4)+1;
FOR i:=0 TO HIGH(Par1) DO Parameter[1,i]:=Par1[i]; END;
FOR i:=0 TO HIGH(Par2) DO Parameter[2,i]:=Par2[i]; END;
FOR i:=0 TO HIGH(Par3) DO Parameter[3,i]:=Par3[i]; END;
FOR i:=0 TO HIGH(Par4) DO Parameter[4,i]:=Par4[i]; END;
#ifdef __TERM__
dWriteN(Output,Format,4);
IF Fehler THEN ErrOut('Falsches Format (TFormAus.Write4)'); END;
END Write4;
#endif
#ifdef __FILE__
dWriteN(Aus,Format,4);
IF Fehler THEN ErrOut('Falsches Format (FFormAus.Write4)'); END;
END dWrite4;
#endif
#ifdef __STREAM__
dWriteN(Aus,Format,4);
IF Fehler THEN ErrOut('Falsches Format (SFormAus.Write4)'); END;
END dWrite4;
#endif
(*........................................................................*)
#ifdef __TERM__
PROCEDURE Write5( Format : ARRAY OF CHAR;
#endif
#ifdef __FILE__
PROCEDURE dWrite5( Aus : File;
Format : ARRAY OF CHAR;
#endif
#ifdef __STREAM__
PROCEDURE dWrite5(VAR Aus : Stream;
Format : ARRAY OF CHAR;
#endif
Par1 : ARRAY OF BYTE;
Par2 : ARRAY OF BYTE;
Par3 : ARRAY OF BYTE;
Par4 : ARRAY OF BYTE;
Par5 : ARRAY OF BYTE);
VAR i : CARDINAL;
BEGIN
Fehler:=FALSE;
Laengen[1]:=HIGH(Par1)+1; Laengen[2]:=HIGH(Par2)+1;
Laengen[3]:=HIGH(Par3)+1; Laengen[4]:=HIGH(Par4)+1;
Laengen[5]:=HIGH(Par5)+1;
FOR i:=0 TO HIGH(Par1) DO Parameter[1,i]:=Par1[i]; END;
FOR i:=0 TO HIGH(Par2) DO Parameter[2,i]:=Par2[i]; END;
FOR i:=0 TO HIGH(Par3) DO Parameter[3,i]:=Par3[i]; END;
FOR i:=0 TO HIGH(Par4) DO Parameter[4,i]:=Par4[i]; END;
FOR i:=0 TO HIGH(Par5) DO Parameter[5,i]:=Par5[i]; END;
#ifdef __TERM__
dWriteN(Output,Format,5);
IF Fehler THEN ErrOut('Falsches Format (TFormAus.Write5)'); END;
END Write5;
#endif
#ifdef __FILE__
dWriteN(Aus,Format,5);
IF Fehler THEN ErrOut('Falsches Format (FFormAus.Write5)'); END;
END dWrite5;
#endif
#ifdef __STREAM__
dWriteN(Aus,Format,5);
IF Fehler THEN ErrOut('Falsches Format (SFormAus.Write5)'); END;
END dWrite5;
#endif
(*........................................................................*)
#ifdef __TERM__
PROCEDURE Write6( Format : ARRAY OF CHAR;
#endif
#ifdef __FILE__
PROCEDURE dWrite6( Aus : File;
Format : ARRAY OF CHAR;
#endif
#ifdef __STREAM__
PROCEDURE dWrite6(VAR Aus : Stream;
Format : ARRAY OF CHAR;
#endif
Par1 : ARRAY OF BYTE;
Par2 : ARRAY OF BYTE;
Par3 : ARRAY OF BYTE;
Par4 : ARRAY OF BYTE;
Par5 : ARRAY OF BYTE;
Par6 : ARRAY OF BYTE);
VAR i : CARDINAL;
BEGIN
Fehler:=FALSE;
Laengen[1]:=HIGH(Par1)+1; Laengen[2]:=HIGH(Par2)+1;
Laengen[3]:=HIGH(Par3)+1; Laengen[4]:=HIGH(Par4)+1;
Laengen[5]:=HIGH(Par5)+1; Laengen[6]:=HIGH(Par6)+1;
FOR i:=0 TO HIGH(Par1) DO Parameter[1,i]:=Par1[i]; END;
FOR i:=0 TO HIGH(Par2) DO Parameter[2,i]:=Par2[i]; END;
FOR i:=0 TO HIGH(Par3) DO Parameter[3,i]:=Par3[i]; END;
FOR i:=0 TO HIGH(Par4) DO Parameter[4,i]:=Par4[i]; END;
FOR i:=0 TO HIGH(Par5) DO Parameter[5,i]:=Par5[i]; END;
FOR i:=0 TO HIGH(Par6) DO Parameter[6,i]:=Par6[i]; END;
#ifdef __TERM__
dWriteN(Output,Format,6);
IF Fehler THEN ErrOut('Falsches Format (TFormAus.Write6)'); END;
END Write6;
#endif
#ifdef __FILE__
dWriteN(Aus,Format,6);
IF Fehler THEN ErrOut('Falsches Format (FFormAus.Write6)'); END;
END dWrite6;
#endif
#ifdef __STREAM__
dWriteN(Aus,Format,6);
IF Fehler THEN ErrOut('Falsches Format (SFormAus.Write6)'); END;
END dWrite6;
#endif
(*........................................................................*)
#ifdef __TERM__
PROCEDURE Write7( Format : ARRAY OF CHAR;
#endif
#ifdef __FILE__
PROCEDURE dWrite7( Aus : File;
Format : ARRAY OF CHAR;
#endif
#ifdef __STREAM__
PROCEDURE dWrite7(VAR Aus : Stream;
Format : ARRAY OF CHAR;
#endif
Par1 : ARRAY OF BYTE;
Par2 : ARRAY OF BYTE;
Par3 : ARRAY OF BYTE;
Par4 : ARRAY OF BYTE;
Par5 : ARRAY OF BYTE;
Par6 : ARRAY OF BYTE;
Par7 : ARRAY OF BYTE);
VAR i : CARDINAL;
BEGIN
Fehler:=FALSE;
Laengen[1]:=HIGH(Par1)+1; Laengen[2]:=HIGH(Par2)+1;
Laengen[3]:=HIGH(Par3)+1; Laengen[4]:=HIGH(Par4)+1;
Laengen[5]:=HIGH(Par5)+1; Laengen[6]:=HIGH(Par6)+1;
Laengen[7]:=HIGH(Par7)+1;
FOR i:=0 TO HIGH(Par1) DO Parameter[1,i]:=Par1[i]; END;
FOR i:=0 TO HIGH(Par2) DO Parameter[2,i]:=Par2[i]; END;
FOR i:=0 TO HIGH(Par3) DO Parameter[3,i]:=Par3[i]; END;
FOR i:=0 TO HIGH(Par4) DO Parameter[4,i]:=Par4[i]; END;
FOR i:=0 TO HIGH(Par5) DO Parameter[5,i]:=Par5[i]; END;
FOR i:=0 TO HIGH(Par6) DO Parameter[6,i]:=Par6[i]; END;
FOR i:=0 TO HIGH(Par7) DO Parameter[7,i]:=Par7[i]; END;
#ifdef __TERM__
dWriteN(Output,Format,7);
IF Fehler THEN ErrOut('Falsches Format (TFormAus.Write7)'); END;
END Write7;
#endif
#ifdef __FILE__
dWriteN(Aus,Format,7);
IF Fehler THEN ErrOut('Falsches Format (FFormAus.Write7)'); END;
END dWrite7;
#endif
#ifdef __STREAM__
dWriteN(Aus,Format,7);
IF Fehler THEN ErrOut('Falsches Format (SFormAus.Write7)'); END;
END dWrite7;
#endif
(*........................................................................*)
#ifdef __TERM__
PROCEDURE Write8( Format : ARRAY OF CHAR;
#endif
#ifdef __FILE__
PROCEDURE dWrite8( Aus : File;
Format : ARRAY OF CHAR;
#endif
#ifdef __STREAM__
PROCEDURE dWrite8(VAR Aus : Stream;
Format : ARRAY OF CHAR;
#endif
Par1 : ARRAY OF BYTE;
Par2 : ARRAY OF BYTE;
Par3 : ARRAY OF BYTE;
Par4 : ARRAY OF BYTE;
Par5 : ARRAY OF BYTE;
Par6 : ARRAY OF BYTE;
Par7 : ARRAY OF BYTE;
Par8 : ARRAY OF BYTE);
VAR i : CARDINAL;
BEGIN
Fehler:=FALSE;
Laengen[1]:=HIGH(Par1)+1; Laengen[2]:=HIGH(Par2)+1;
Laengen[3]:=HIGH(Par3)+1; Laengen[4]:=HIGH(Par4)+1;
Laengen[5]:=HIGH(Par5)+1; Laengen[6]:=HIGH(Par6)+1;
Laengen[7]:=HIGH(Par7)+1; Laengen[8]:=HIGH(Par8)+1;
FOR i:=0 TO HIGH(Par1) DO Parameter[1,i]:=Par1[i]; END;
FOR i:=0 TO HIGH(Par2) DO Parameter[2,i]:=Par2[i]; END;
FOR i:=0 TO HIGH(Par3) DO Parameter[3,i]:=Par3[i]; END;
FOR i:=0 TO HIGH(Par4) DO Parameter[4,i]:=Par4[i]; END;
FOR i:=0 TO HIGH(Par5) DO Parameter[5,i]:=Par5[i]; END;
FOR i:=0 TO HIGH(Par6) DO Parameter[6,i]:=Par6[i]; END;
FOR i:=0 TO HIGH(Par7) DO Parameter[7,i]:=Par7[i]; END;
FOR i:=0 TO HIGH(Par8) DO Parameter[8,i]:=Par8[i]; END;
#ifdef __TERM__
dWriteN(Output,Format,8);
IF Fehler THEN ErrOut('Falsches Format (TFormAus.Write8)'); END;
END Write8;
#endif
#ifdef __FILE__
dWriteN(Aus,Format,8);
IF Fehler THEN ErrOut('Falsches Format (FFormAus.Write8)'); END;
END dWrite8;
#endif
#ifdef __STREAM__
dWriteN(Aus,Format,8);
IF Fehler THEN ErrOut('Falsches Format (SFormAus.Write8)'); END;
END dWrite8;
#endif
(*........................................................................*)
#ifdef __TERM__
PROCEDURE Write9( Format : ARRAY OF CHAR;
#endif
#ifdef __FILE__
PROCEDURE dWrite9( Aus : File;
Format : ARRAY OF CHAR;
#endif
#ifdef __STREAM__
PROCEDURE dWrite9(VAR Aus : Stream;
Format : ARRAY OF CHAR;
#endif
Par1 : ARRAY OF BYTE;
Par2 : ARRAY OF BYTE;
Par3 : ARRAY OF BYTE;
Par4 : ARRAY OF BYTE;
Par5 : ARRAY OF BYTE;
Par6 : ARRAY OF BYTE;
Par7 : ARRAY OF BYTE;
Par8 : ARRAY OF BYTE;
Par9 : ARRAY OF BYTE);
VAR i : CARDINAL;
BEGIN
Fehler:=FALSE;
Laengen[1]:=HIGH(Par1)+1; Laengen[2]:=HIGH(Par2)+1;
Laengen[3]:=HIGH(Par3)+1; Laengen[4]:=HIGH(Par4)+1;
Laengen[5]:=HIGH(Par5)+1; Laengen[6]:=HIGH(Par6)+1;
Laengen[7]:=HIGH(Par7)+1; Laengen[8]:=HIGH(Par8)+1;
Laengen[9]:=HIGH(Par9)+1;
FOR i:=0 TO HIGH(Par1) DO Parameter[1,i]:=Par1[i]; END;
FOR i:=0 TO HIGH(Par2) DO Parameter[2,i]:=Par2[i]; END;
FOR i:=0 TO HIGH(Par3) DO Parameter[3,i]:=Par3[i]; END;
FOR i:=0 TO HIGH(Par4) DO Parameter[4,i]:=Par4[i]; END;
FOR i:=0 TO HIGH(Par5) DO Parameter[5,i]:=Par5[i]; END;
FOR i:=0 TO HIGH(Par6) DO Parameter[6,i]:=Par6[i]; END;
FOR i:=0 TO HIGH(Par7) DO Parameter[7,i]:=Par7[i]; END;
FOR i:=0 TO HIGH(Par8) DO Parameter[8,i]:=Par8[i]; END;
FOR i:=0 TO HIGH(Par9) DO Parameter[9,i]:=Par9[i]; END;
#ifdef __TERM__
dWriteN(Output,Format,9);
IF Fehler THEN ErrOut('Falsches Format (TFormAus.Write9)'); END;
END Write9;
#endif
#ifdef __FILE__
dWriteN(Aus,Format,9);
IF Fehler THEN ErrOut('Falsches Format (FFormAus.Write9)'); END;
END dWrite9;
#endif
#ifdef __STREAM__
dWriteN(Aus,Format,9);
IF Fehler THEN ErrOut('Falsches Format (SFormAus.Write9)'); END;
END dWrite9;
#endif
BEGIN
FFlag[strAllRight] := 'In Ordnung !';
FFlag[strOutOfRange] := 'Wertebereichsueberschreitung !';
FFlag[strWrongFormat] := 'Falsches Format !';
FFlag[strEmpty] := 'Zeichenkette leer !';
#ifdef __TERM__
END TFormAus.
#endif
#ifdef __FILE__
END FFormAus.
#endif
#ifdef __STREAM__
END SFormAus.
#endif