(*----------------------------------------------------------------------
    :Program.    FileHelper.mod
    :Author.     Philippe Gressly
    :Address.    Näfenhaus, CH-8926 Kappel a/Albis
    :History.    V1.0, Dec-89, Philippe Gressly
    :Copyright.  PD .
    :Language.   Modula-II
    :Translator. M2Amiga
    :Contents.   Routines to handle Files. Strings and Numbers.
----------------------------------------------------------------------*)

IMPLEMENTATION MODULE FileHelp;


FROM DOS IMPORT FileHandlePtr, Read, Write;
FROM SYSTEM IMPORT FFP, ADR;
FROM Str IMPORT Length;
FROM ASCII IMPORT lf;
FROM Conversions IMPORT StrToVal, ValToStr;
IMPORT FFPConversions;       (* StrToReal, RealToStr *)
IMPORT LongRealConversions;  (* StrToReal, RealToStr *)
IMPORT RealConversions;      (* StrToReal, RealToStr *)



PROCEDURE ReadAWord(F: FileHandlePtr; VAR St: ARRAY OF CHAR): BOOLEAN;
VAR i : INTEGER; ch: CHAR; act: LONGINT;
BEGIN
   IF F = NIL THEN RETURN FALSE END;
   i := 0;
   ch := CHR(0);
   (* Skip leading Blanks *)
   WHILE ch <= ' ' DO
      act := Read(F, ADR(ch), 1);
      IF act <= 0 THEN RETURN FALSE END;
   END;
   WHILE ch > ' ' DO
      IF i < HIGH(St) THEN
         St[i] := ch;
         INC(i)
      END;
      ch := CHR(0);
      act := Read(F, ADR(ch), 1);
   END; (* While *)
   St[i] := CHR(0);
   RETURN TRUE
END ReadAWord;



PROCEDURE ReadALine(F: FileHandlePtr; VAR St: ARRAY OF CHAR): BOOLEAN;
VAR i : INTEGER; ch: CHAR; act: LONGINT;
BEGIN
   IF F = NIL THEN RETURN FALSE END;
   i := 0;
   ch := CHR(0);
   (* Skip blank lines *)
   WHILE ch < ' ' DO
      act := Read(F, ADR(ch), 1);
      IF act <= 0 THEN RETURN FALSE END;
   END;
   WHILE ch >= ' ' DO
      IF i < HIGH(St) THEN
         St[i] := ch;
         INC(i)
      END;
      ch := CHR(0);
      act := Read(F, ADR(ch), 1);
   END; (* While *)
   St[i] := CHR(0);
   RETURN TRUE
END ReadALine;


PROCEDURE ReadAChar(F: FileHandlePtr; VAR Ch: CHAR): BOOLEAN;
VAR act : LONGINT;
BEGIN
   IF F = NIL THEN RETURN FALSE END;
   act := Read(F, ADR(Ch), 1);
   RETURN act <= 0
END ReadAChar;



PROCEDURE WriteAWord(VAR F: FileHandlePtr; St: ARRAY OF CHAR): BOOLEAN;
VAR Li: LONGINT;
    LineFeed: CHAR;
BEGIN
   IF F = NIL THEN RETURN FALSE END;
   Li := Write(F, ADR(St), LONGCARD(Length(St)));
   IF (Li = 0) AND (Length(St) > 0) THEN RETURN FALSE END;
   RETURN TRUE
END WriteAWord;



PROCEDURE WriteAChar(VAR F: FileHandlePtr; Ch: CHAR): BOOLEAN;
VAR Li: LONGINT;
BEGIN
   IF F = NIL THEN RETURN FALSE END;
   Li := Write(F, ADR(Ch), 1);
   RETURN Li = 1
END WriteAChar;



PROCEDURE WriteALine(VAR F: FileHandlePtr; St: ARRAY OF CHAR): BOOLEAN;
VAR Ok: BOOLEAN;
BEGIN
   Ok := WriteAWord(F, St);
   IF NOT Ok THEN RETURN FALSE END;
   RETURN WriteAChar(F, lf)
END WriteALine;





PROCEDURE ReadIntF(F: FileHandlePtr; VAR I: INTEGER; As: BOOLEAN): BOOLEAN;
VAR St: ARRAY [0..255] OF CHAR;
    Li: LONGINT;
    sig, err, Ok: BOOLEAN;
BEGIN
   IF F = NIL THEN RETURN FALSE END;
   IF As THEN
      Li := Read(F, ADR(I), SIZE(INTEGER));
      RETURN Li = SIZE(INTEGER);
   ELSE
      Ok := ReadAWord(F, St);
      IF NOT Ok THEN RETURN FALSE END;
      StrToVal(St, Li, sig, 10, err);
      I := INTEGER(Li);
      RETURN NOT err
   END
END ReadIntF;



PROCEDURE WritIntF(F: FileHandlePtr;     I: INTEGER; As: BOOLEAN): BOOLEAN;
VAR St: ARRAY [0..255] OF CHAR;
    Li: LONGINT;
    err: BOOLEAN;
BEGIN
   IF F = NIL THEN RETURN FALSE END;
   IF As THEN
      Li := Write(F, ADR(I), SIZE(INTEGER));
      RETURN Li = SIZE(INTEGER)
   ELSE
      ValToStr(I, I < 0, St,10,7," ",err);
      IF err THEN RETURN FALSE END;
      RETURN WriteAWord(F, St);
   END
END WritIntF;



PROCEDURE ReadCardF(F: FileHandlePtr; VAR C: CARDINAL; As: BOOLEAN): BOOLEAN;
VAR St: ARRAY [0..255] OF CHAR;
    Li: LONGINT;
    sig, err, Ok: BOOLEAN;
BEGIN
   IF F = NIL THEN RETURN FALSE END;
   IF As THEN
      Li := Read(F, ADR(C), SIZE(CARDINAL));
      RETURN Li = SIZE(CARDINAL);
   ELSE
      Ok := ReadAWord(F, St);
      IF NOT Ok THEN RETURN FALSE END;
      StrToVal(St, Li, sig, 10, err);
      C := CARDINAL(Li);
      RETURN NOT err
   END
END ReadCardF;



PROCEDURE WritCardF(F: FileHandlePtr;     C: CARDINAL; As: BOOLEAN): BOOLEAN;
VAR St: ARRAY [0..255] OF CHAR;
    Li: LONGINT;
    err: BOOLEAN;
BEGIN
   IF F = NIL THEN RETURN FALSE END;
   IF As THEN
      Li := Write(F, ADR(C), SIZE(CARDINAL));
      RETURN Li = SIZE(CARDINAL)
   ELSE
      ValToStr(C, FALSE, St, 10, 7," ",err);
      IF err THEN RETURN FALSE END;
      RETURN WriteAWord(F, St);
   END
END WritCardF;



PROCEDURE ReadLongIntF(F: FileHandlePtr; VAR I: LONGINT; As: BOOLEAN): BOOLEAN;
VAR St: ARRAY [0..255] OF CHAR;
    Li: LONGINT;
    sig, err, Ok: BOOLEAN;
BEGIN
   IF F = NIL THEN RETURN FALSE END;
   IF As THEN
      Li := Read(F, ADR(I), SIZE(LONGINT));
      RETURN Li = SIZE(LONGINT);
   ELSE
      Ok := ReadAWord(F, St);
      IF NOT Ok THEN RETURN FALSE END;
      StrToVal(St, I, sig, 10, err);
      RETURN NOT err
   END
END ReadLongIntF;


PROCEDURE WritLongIntF(F: FileHandlePtr;     I: LONGINT; As: BOOLEAN): BOOLEAN;
VAR St: ARRAY [0..255] OF CHAR;
    Li: LONGINT;
    err:BOOLEAN;
BEGIN
   IF F = NIL THEN RETURN FALSE END;
   IF As THEN
      Li := Write(F, ADR(I), SIZE(LONGINT));
      RETURN Li = SIZE(LONGINT)
   ELSE
      ValToStr(I, FALSE, St, 10, 7," ",err);
      IF err THEN RETURN FALSE END;
      RETURN WriteAWord(F, St)
   END
END WritLongIntF;



PROCEDURE ReadLongCardF(F: FileHandlePtr; VAR C: LONGCARD; As: BOOLEAN): BOOLEAN;
VAR St: ARRAY [0..255] OF CHAR;
    Li: LONGINT;
    sig, err, Ok: BOOLEAN;
BEGIN
   IF F = NIL THEN RETURN FALSE END;
   IF As THEN
      Li := Read(F, ADR(C), SIZE(LONGCARD));
      RETURN Li = SIZE(LONGCARD);
   ELSE
      Ok := ReadAWord(F, St);
      IF NOT Ok THEN RETURN FALSE END;
      StrToVal(St, Li, sig, 10, err);
      C := LONGCARD(Li);
      RETURN NOT err
   END
END ReadLongCardF;


PROCEDURE WritLongCardF(F: FileHandlePtr;     C: LONGCARD; As: BOOLEAN): BOOLEAN;
VAR St: ARRAY [0..255] OF CHAR;
    Li: LONGINT;
    err:BOOLEAN;
BEGIN
   IF F = NIL THEN RETURN FALSE END;
   IF As THEN
      Li := Write(F, ADR(C), SIZE(LONGCARD));
      RETURN Li = SIZE(LONGCARD)
   ELSE
      ValToStr(C, FALSE, St, 10, 7," ",err);
      IF err THEN RETURN FALSE END;
      RETURN WriteAWord(F, St)
   END
END WritLongCardF;



PROCEDURE ReadFFPF(F: FileHandlePtr; VAR I: FFP; As: BOOLEAN): BOOLEAN;
VAR St: ARRAY [0..255] OF CHAR;
    Li: LONGINT;
    err, Ok: BOOLEAN;
BEGIN
   IF F = NIL THEN RETURN FALSE END;
   IF As THEN
      Li := Read(F, ADR(I), SIZE(FFP));
      RETURN Li = SIZE(FFP);
   ELSE
      Ok := ReadAWord(F, St);
      IF NOT Ok THEN RETURN FALSE END;
      FFPConversions.StrToReal(St, I, err);
      RETURN NOT err
   END
END ReadFFPF;


PROCEDURE WritFFPF(F: FileHandlePtr;     I: FFP; As: BOOLEAN): BOOLEAN;
VAR St: ARRAY [0..255] OF CHAR;
    Li: LONGINT;
    err: BOOLEAN;
BEGIN
   IF F = NIL THEN RETURN FALSE END;
   IF As THEN
      Li := Write(F, ADR(I), SIZE(FFP));
      RETURN Li = SIZE(FFP)
   ELSE
      FFPConversions.RealToStr(I, St, 15, 10, TRUE, err);
      IF err THEN RETURN FALSE END;
      RETURN WriteAWord(F, St);
   END
END WritFFPF;



PROCEDURE ReadRealF(F: FileHandlePtr; VAR C: REAL; As: BOOLEAN): BOOLEAN;
VAR St: ARRAY [0..255] OF CHAR;
    Li: LONGINT;
    err, Ok: BOOLEAN;
BEGIN
   IF F = NIL THEN RETURN FALSE END;
   IF As THEN
      Li := Read(F, ADR(C), SIZE(REAL));
      RETURN Li = SIZE(REAL);
   ELSE
      Ok := ReadAWord(F, St);
      IF NOT Ok THEN RETURN FALSE END;
      RealConversions.StrToReal(St, C, err);
      RETURN NOT err
   END
END ReadRealF;



PROCEDURE WritRealF(F: FileHandlePtr;     C: REAL; As: BOOLEAN): BOOLEAN;
VAR St: ARRAY [0..255] OF CHAR;
    Li:LONGINT;
    err: BOOLEAN;
BEGIN
   IF F = NIL THEN RETURN FALSE END;
   IF As THEN
      Li := Write(F, ADR(C), SIZE(REAL));
      RETURN Li = SIZE(REAL)
   ELSE
      RealConversions.RealToStr(C, St, 17, 12, TRUE, err);
      IF err THEN RETURN FALSE END;
      RETURN WriteAWord(F, St);
   END
END WritRealF;



PROCEDURE ReadLongRealF(F: FileHandlePtr; VAR I: LONGREAL; As: BOOLEAN): BOOLEAN;
VAR St: ARRAY [0..255] OF CHAR;
    Li: LONGINT;
    Ok, err: BOOLEAN;
BEGIN
   IF F = NIL THEN RETURN FALSE END;
   IF As THEN
      Li := Read(F, ADR(I), SIZE(LONGREAL));
      RETURN Li = SIZE(LONGREAL);
   ELSE
      Ok := ReadAWord(F, St);
      IF NOT Ok THEN RETURN FALSE END;
      LongRealConversions.StrToReal(St, I, err);
      RETURN NOT err
   END
END ReadLongRealF;


PROCEDURE WritLongRealF(F: FileHandlePtr;     I: LONGREAL; As: BOOLEAN): BOOLEAN;
VAR St: ARRAY [0..255] OF CHAR;
    Li: LONGINT;
    err: BOOLEAN;
BEGIN
   IF F = NIL THEN RETURN FALSE END;
   IF As THEN
      Li := Write(F, ADR(I), SIZE(LONGREAL));
      RETURN Li = SIZE(LONGREAL)
   ELSE
      LongRealConversions.RealToStr(I, St, 20, 15, TRUE, err);
      IF err THEN RETURN FALSE END;
      RETURN WriteAWord(F, St)
   END
END WritLongRealF;


END FileHelp.def