home *** CD-ROM | disk | FTP | other *** search
/ Atari FTP / ATARI_FTP_0693.zip / ATARI_FTP_0693 / Tex / td187src.lzh / FILEIO.I < prev    next >
Text File  |  1991-12-14  |  6KB  |  278 lines
  1. IMPLEMENTATION MODULE FileIO;
  2.  
  3. FROM SYSTEM IMPORT ADDRESS, ADR;
  4. IMPORT MagicStrings, MagicDOS, MagicConvert, MagicSys, mtAlerts, Diverses;
  5. (**
  6. IMPORT RTD;
  7. **)
  8.  
  9. CONST NUL     =   0C ;
  10.       NULL    =  MagicSys.LOC(0);
  11.       NULLL   =  MagicSys.sWORD(0);
  12.       LF      =  12C ;
  13.       FF      =  14C ;
  14.       CR      =  15C ;
  15.       BufSize = 2048 ;
  16. VAR InputBuffer     : ARRAY [0..BufSize-1] OF MagicSys.LOC;
  17.     LastReadLoc     : MagicSys.LOC;
  18.     LastReadWord    : MagicSys.sWORD;
  19.     MaxPos, BufPos  : INTEGER;
  20.     eof             : BOOLEAN;
  21.  
  22. PROCEDURE FillBuffer(Filehandle : INTEGER);
  23. VAR bytesread : MagicSys.lCARDINAL;
  24. BEGIN
  25.   bytesread := MagicSys.CastToLCard(BufSize);
  26.   MagicDOS.Fread(Filehandle, bytesread, ADR(InputBuffer));
  27.   eof := bytesread <> MagicSys.CastToLCard(BufSize);
  28.   MaxPos := MagicSys.CastToInt(MagicSys.CastToCard(bytesread));
  29.   BufPos := 0;
  30. (**
  31.   Variablen.CheckSentinel('Leaving FillBuffer');
  32. **)
  33. END FillBuffer;
  34.  
  35. PROCEDURE Rewrite(VAR filehandle : INTEGER;
  36.                   REF filename   : ARRAY OF CHAR);
  37. BEGIN
  38.   filehandle := MagicDOS.Fcreate ( filename , {} );
  39. (**
  40.   Variablen.CheckSentinel('Leaving Rewrite');
  41. **)
  42. END Rewrite;
  43.  
  44. PROCEDURE Fopen(VAR filehandle : INTEGER;
  45.                     filemode   : INTEGER;
  46.                 REF filename   : ARRAY OF CHAR) : BOOLEAN;
  47. VAR Button : INTEGER;
  48.     pos    : INTEGER;
  49.     str    : ARRAY [0..127] OF CHAR;
  50.     num    : ARRAY [0..4] OF CHAR;
  51. BEGIN
  52.   filehandle := MagicDOS.Fopen ( filename , filemode );
  53.   IF filehandle < 6 THEN
  54.     str := "[4][ File-error #-?? !][ [OK ]" ;
  55.     pos := 0;
  56.     WHILE (str[pos]<>'?') DO
  57.       INC (pos);
  58.     END;
  59.     MagicConvert.IntToStr ( filehandle , 3 , num ) ;
  60.     str [ pos ] := num [ 1 ] ; str [ pos + 1 ] := num [ 2 ] ;
  61.     mtAlerts.SetIcon(mtAlerts.Disk);
  62.     Button := Diverses.Alert ( 1 , str ) ;
  63.     RETURN FALSE;
  64.    ELSE
  65.     RETURN TRUE;
  66.   END;
  67. END Fopen;
  68.  
  69. PROCEDURE Reset(VAR filehandle : INTEGER;
  70.                 REF filename   : ARRAY OF CHAR);
  71. BEGIN
  72.  AgainLine    := FALSE;
  73.  AgainChar    := FALSE;
  74.  LastReadLoc  := NULL;
  75.  LastReadWord := NULLL;
  76.  BufPos       := 0;
  77. (**
  78.  RTD.Write('Reset', filename);
  79. **)
  80.  IF Fopen ( filehandle, MagicDOS.Read, filename ) THEN
  81.    EOF := FALSE;
  82.    FillBuffer(filehandle);
  83. (**
  84.    RTD.Message('File opened');
  85. **)
  86.   ELSE
  87.    filehandle   := -1;
  88.    LastReadLoc  := NULL;
  89.    LastReadWord := NULLL;
  90.    EOF := TRUE;
  91.  END;
  92. (**
  93.   Variablen.CheckSentinel('Leaving Reset');
  94. **)
  95. END Reset;
  96.  
  97. PROCEDURE Close(file : INTEGER);
  98. VAR dum : INTEGER;
  99. BEGIN
  100.   dum := MagicDOS.Fclose ( file ) ;
  101.   EOF := TRUE;
  102.   eof := TRUE;
  103.   BufPos := 0;
  104. (**
  105.   Variablen.CheckSentinel('Leaving Close');
  106. **)
  107. END Close;
  108.  
  109. PROCEDURE ReadChar(File: INTEGER; VAR char : MagicSys.LOC );
  110. BEGIN
  111. (**
  112.   RTD.Message('IRC');
  113. **)
  114.   IF NOT AgainChar THEN
  115.     IF BufPos >= MaxPos THEN
  116.       EOF := eof;
  117.       FillBuffer(File);
  118.     END;
  119.     IF NOT EOF THEN
  120.       LastReadLoc := InputBuffer[BufPos];
  121.       INC(BufPos);
  122.      ELSE
  123.       LastReadLoc := NULL;
  124.     END;
  125.    ELSE
  126.     AgainChar := FALSE;
  127.   END;
  128.   char := LastReadLoc;
  129. (**
  130.   RTD.Message('ORC');
  131.   Variablen.CheckSentinel('Leaving ReadChar');
  132. **)
  133. END ReadChar;
  134.  
  135. PROCEDURE ReadWord (File: INTEGER; VAR word : MagicSys.sWORD );
  136. VAR (*$Reg*) rec : RECORD
  137.            CASE : BOOLEAN OF
  138.             TRUE : barr : ARRAY [0..1] OF MagicSys.LOC; |
  139.             FALSE: wrd  : MagicSys.sWORD; |
  140.            END;
  141.           END;
  142. BEGIN
  143.   IF NOT EOF THEN
  144.     ReadChar(File, rec.barr[0]);
  145.     ReadChar(File, rec.barr[1]);
  146.     word := rec.wrd;
  147.   END;
  148. END ReadWord;
  149.  
  150.  
  151. PROCEDURE ReadNWords(File: INTEGER; N : CARDINAL; VAR wrdArr : ARRAY OF MagicSys.sWORD );
  152. VAR c : CARDINAL;
  153. BEGIN
  154. (**
  155.   RTD.Message('IRNW');
  156. **)
  157.   FOR c:=1 TO N DO
  158.     ReadWord(File, wrdArr[c-1]);
  159.   END;
  160. (**
  161.   RTD.Message('ORNW');
  162. **)
  163. END ReadNWords;
  164.  
  165. PROCEDURE ReadNBytes(File: INTEGER; N : CARDINAL; VAR byteArr : ARRAY OF MagicSys.LOC );
  166. VAR c : CARDINAL;
  167. BEGIN
  168. (**
  169.   RTD.Message('IRNB');
  170. **)
  171.   FOR c:=1 TO N DO
  172.     ReadChar(File, byteArr[c-1]);
  173.   END;
  174. (**
  175.   RTD.Message('ORNB');
  176. **)
  177. END ReadNBytes;
  178.  
  179.  
  180. PROCEDURE WriteChar(File : INTEGER; char : MagicSys.LOC);
  181. VAR temp : ARRAY [0..3] OF MagicSys.LOC;
  182.     len  : CARDINAL ;
  183.     long : MagicSys.lCARDINAL ;
  184.     adr  : ADDRESS  ;
  185.  
  186. BEGIN
  187.   temp[0] := char;
  188.   long := 1;
  189.   adr  := ADR(temp);
  190.   MagicDOS.Fwrite ( File , long , adr ) ;
  191. (**
  192.   Variablen.CheckSentinel('Leaving WriteChar');
  193. **)
  194. END WriteChar;
  195.  
  196. PROCEDURE WriteLn (File: INTEGER; REF Line : ARRAY OF CHAR ) ;
  197. VAR len  : CARDINAL ;
  198.     long : MagicSys.lCARDINAL ;
  199.     adr  : ADDRESS  ;
  200.     buffer: ARRAY [0..255] OF CHAR;
  201. BEGIN
  202.   MagicStrings.Assign(Line, buffer);
  203.   len  := LENGTH(buffer);
  204.   IF UnixLine THEN
  205.     buffer[len] := LF;
  206.     INC(len);
  207.    ELSE
  208.     buffer[len  ] := CR;
  209.     buffer[len+1] := LF;
  210.     INC(len, 2);
  211.   END;
  212.   buffer[len] := 0C;
  213.   len  := LENGTH(buffer);
  214.   long := MagicSys.CastToLCard ( len ) ;
  215.   adr  := ADR ( buffer ) ;
  216.   MagicDOS.Fwrite ( File , long , adr ) ;
  217. (**
  218.   IF UnixLine THEN
  219.     WriteChar(File, LF);
  220.    ELSE
  221.     WriteChar(File, CR);
  222.     WriteChar(File, LF);
  223.   END;
  224. **)
  225. (**
  226.   Variablen.CheckSentinel('Leaving WriteLn ');
  227. **)
  228. END WriteLn ;
  229.  
  230.  
  231. PROCEDURE ReadLn  (File: INTEGER; VAR Line : ARRAY OF CHAR ) ;
  232.  
  233. TYPE chset = SET OF CHAR;
  234.  
  235. VAR c      : CHAR;
  236.     i      : INTEGER;
  237.     crlf   : BOOLEAN;
  238.     MyLine : ARRAY [0..255] OF CHAR;
  239.  
  240. BEGIN
  241.   IF NOT AgainLine THEN
  242.     FOR i:= 0 TO 255 DO MyLine[i] := 0C; END;
  243.     IF NOT EOF THEN
  244.       i := 0;
  245.       crlf := FALSE;
  246.       (* Überliest leere Zeilen !!! *)
  247.       REPEAT
  248.         ReadChar(File, c);
  249.       UNTIL EOF OR NOT (c IN chset{CR,LF,FF});
  250.       REPEAT
  251.         IF c<>0C THEN
  252.           IF c=11C THEN c := ' '; END; (* TAB *)
  253.           IF c IN chset{CR,LF,FF} THEN
  254.             crlf := TRUE;
  255.            ELSE
  256.             MyLine[i] := c;
  257.             i := i + 1;
  258.           END;
  259.         END;
  260.         (* Um Unix-Zeilen-Trennung zu verarbeiten: LF statt CRLF *)
  261.         IF NOT crlf AND NOT EOF THEN
  262.           ReadChar(File, c);
  263.         END;
  264.       UNTIL EOF OR crlf;
  265.     END;
  266.     MagicStrings.Assign(MyLine, Line);
  267.   END;
  268.   AgainLine := FALSE;
  269. (**
  270.   Variablen.CheckSentinel('Leaving ReadLn');
  271. **)
  272. END ReadLn;
  273.  
  274. BEGIN
  275.   UnixLine := FALSE;
  276. END FileIO.
  277.  
  278.