Subversion Repositories Kolibri OS

Rev

Go to most recent revision | Blame | Last modification | View Log | Download | RSS feed

  1. (*
  2.     Copyright 2016 Anton Krotov
  3.  
  4.     This program is free software: you can redistribute it and/or modify
  5.     it under the terms of the GNU Lesser General Public License as published by
  6.     the Free Software Foundation, either version 3 of the License, or
  7.     (at your option) any later version.
  8.  
  9.     This program is distributed in the hope that it will be useful,
  10.     but WITHOUT ANY WARRANTY; without even the implied warranty of
  11.     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  12.     GNU Lesser General Public License for more details.
  13.  
  14.     You should have received a copy of the GNU Lesser General Public License
  15.     along with this program.  If not, see <http://www.gnu.org/licenses/>.
  16. *)
  17.  
  18. MODULE File;
  19.  
  20. IMPORT sys := SYSTEM, KOSAPI;
  21.  
  22. CONST
  23.  
  24.   SEEK_BEG* = 0; SEEK_CUR* = 1; SEEK_END* = 2;
  25.  
  26. TYPE
  27.  
  28.   FNAME* = ARRAY 520 OF CHAR;
  29.  
  30.   FS* = POINTER TO rFS;
  31.  
  32.   rFS* = RECORD
  33.     subfunc*, pos*, hpos*, bytes*, buffer*: INTEGER;
  34.     name*: FNAME
  35.   END;
  36.  
  37.   FD* = POINTER TO rFD;
  38.  
  39.   rFD* = RECORD
  40.     attr*: INTEGER;
  41.     ntyp*: CHAR;
  42.     reserved: ARRAY 3 OF CHAR;
  43.     time_create*, date_create*,
  44.     time_access*, date_access*,
  45.     time_modif*,  date_modif*,
  46.     size*, hsize*: INTEGER;
  47.     name*: FNAME
  48.   END;
  49.  
  50. PROCEDURE [stdcall] f_68_27(file_name: INTEGER; VAR size: INTEGER): INTEGER;
  51. BEGIN
  52.   sys.CODE("53");               (* push    ebx              *)
  53.   sys.CODE("6A44");             (* push    68               *)
  54.   sys.CODE("58");               (* pop     eax              *)
  55.   sys.CODE("6A1B");             (* push    27               *)
  56.   sys.CODE("5B");               (* pop     ebx              *)
  57.   sys.CODE("8B4D08");           (* mov     ecx, [ebp + 08h] *)
  58.   sys.CODE("CD40");             (* int     40h              *)
  59.   sys.CODE("8B4D0C");           (* mov     ecx, [ebp + 0Ch] *)
  60.   sys.CODE("8911");             (* mov     [ecx], edx       *)
  61.   sys.CODE("5B");               (* pop     ebx              *)
  62.   sys.CODE("C9");               (* leave                    *)
  63.   sys.CODE("C20800");           (* ret     08h              *)
  64.   RETURN 0
  65. END f_68_27;
  66.  
  67. PROCEDURE Load*(FName: ARRAY OF CHAR; VAR size: INTEGER): INTEGER;
  68.   RETURN f_68_27(sys.ADR(FName[0]), size)
  69. END Load;
  70.  
  71. PROCEDURE GetFileInfo*(FName: ARRAY OF CHAR; VAR Info: rFD): BOOLEAN;
  72. VAR res2: INTEGER; fs: rFS;
  73. BEGIN
  74.   fs.subfunc := 5;
  75.   fs.pos := 0;
  76.   fs.hpos := 0;
  77.   fs.bytes := 0;
  78.   fs.buffer := sys.ADR(Info);
  79.   COPY(FName, fs.name)
  80.   RETURN KOSAPI.sysfunc22(70, sys.ADR(fs), res2) = 0
  81. END GetFileInfo;
  82.  
  83. PROCEDURE Exists*(FName: ARRAY OF CHAR): BOOLEAN;
  84. VAR fd: rFD;
  85. BEGIN
  86.   RETURN GetFileInfo(FName, fd) & ~(4 IN BITS(fd.attr))
  87. END Exists;
  88.  
  89. PROCEDURE Close*(VAR F: FS);
  90. BEGIN
  91.   IF F # NIL THEN
  92.     DISPOSE(F)
  93.   END
  94. END Close;
  95.  
  96. PROCEDURE Open*(FName: ARRAY OF CHAR): FS;
  97. VAR F: FS;
  98. BEGIN
  99.   IF Exists(FName) THEN
  100.     NEW(F);
  101.     IF F # NIL THEN
  102.       F.subfunc := 0;
  103.       F.pos := 0;
  104.       F.hpos := 0;
  105.       F.bytes := 0;
  106.       F.buffer := 0;
  107.       COPY(FName, F.name)
  108.     END
  109.   ELSE
  110.     F := NIL
  111.   END
  112.   RETURN F
  113. END Open;
  114.  
  115. PROCEDURE Delete*(FName: ARRAY OF CHAR): BOOLEAN;
  116. VAR F: FS; res, res2: INTEGER;
  117. BEGIN
  118.   IF Exists(FName) THEN
  119.     NEW(F);
  120.     IF F # NIL THEN
  121.       F.subfunc := 8;
  122.       F.pos := 0;
  123.       F.hpos := 0;
  124.       F.bytes := 0;
  125.       F.buffer := 0;
  126.       COPY(FName, F.name);
  127.       res := KOSAPI.sysfunc22(70, sys.ADR(F^), res2);
  128.       DISPOSE(F)
  129.     ELSE
  130.       res := -1
  131.     END
  132.   ELSE
  133.     res := -1
  134.   END
  135.   RETURN res = 0
  136. END Delete;
  137.  
  138. PROCEDURE Seek*(F: FS; Offset, Origin: INTEGER): INTEGER;
  139. VAR res: INTEGER; fd: rFD;
  140. BEGIN
  141.   IF (F # NIL) & GetFileInfo(F.name, fd) & (BITS(fd.attr) * {4} = {}) THEN
  142.     CASE Origin OF
  143.     |SEEK_BEG: F.pos := Offset
  144.     |SEEK_CUR: F.pos := F.pos + Offset
  145.     |SEEK_END: F.pos := fd.size + Offset
  146.     ELSE
  147.     END;
  148.     res := F.pos
  149.   ELSE
  150.     res := -1
  151.   END
  152.   RETURN res
  153. END Seek;
  154.  
  155. PROCEDURE Read*(F: FS; Buffer, Count: INTEGER): INTEGER;
  156. VAR res, res2: INTEGER;
  157. BEGIN
  158.   IF F # NIL THEN
  159.     F.subfunc := 0;
  160.     F.bytes := Count;
  161.     F.buffer := Buffer;
  162.     res := KOSAPI.sysfunc22(70, sys.ADR(F^), res2);
  163.     IF res2 > 0 THEN
  164.       F.pos := F.pos + res2
  165.     END
  166.   ELSE
  167.     res2 := 0
  168.   END
  169.   RETURN res2
  170. END Read;
  171.  
  172. PROCEDURE Write*(F: FS; Buffer, Count: INTEGER): INTEGER;
  173. VAR res, res2: INTEGER;
  174. BEGIN
  175.   IF F # NIL THEN
  176.     F.subfunc := 3;
  177.     F.bytes := Count;
  178.     F.buffer := Buffer;
  179.     res := KOSAPI.sysfunc22(70, sys.ADR(F^), res2);
  180.     IF res2 > 0 THEN
  181.       F.pos := F.pos + res2
  182.     END
  183.   ELSE
  184.     res2 := 0
  185.   END
  186.   RETURN res2
  187. END Write;
  188.  
  189. PROCEDURE Create*(FName: ARRAY OF CHAR): FS;
  190. VAR F: FS; res2: INTEGER;
  191. BEGIN
  192.   NEW(F);
  193.   IF F # NIL THEN
  194.     F.subfunc := 2;
  195.     F.pos := 0;
  196.     F.hpos := 0;
  197.     F.bytes := 0;
  198.     F.buffer := 0;
  199.     COPY(FName, F.name);
  200.     IF KOSAPI.sysfunc22(70, sys.ADR(F^), res2) # 0 THEN
  201.       DISPOSE(F)
  202.     END
  203.   END
  204.   RETURN F
  205. END Create;
  206.  
  207. PROCEDURE DirExists*(FName: ARRAY OF CHAR): BOOLEAN;
  208. VAR fd: rFD;
  209. BEGIN
  210.   RETURN GetFileInfo(FName, fd) & (4 IN BITS(fd.attr))
  211. END DirExists;
  212.  
  213. PROCEDURE CreateDir*(DirName: ARRAY OF CHAR): BOOLEAN;
  214. VAR F: FS; res, res2: INTEGER;
  215. BEGIN
  216.   NEW(F);
  217.   IF F # NIL THEN
  218.     F.subfunc := 9;
  219.     F.pos := 0;
  220.     F.hpos := 0;
  221.     F.bytes := 0;
  222.     F.buffer := 0;
  223.     COPY(DirName, F.name);
  224.     res := KOSAPI.sysfunc22(70, sys.ADR(F^), res2);
  225.     DISPOSE(F)
  226.   ELSE
  227.     res := -1
  228.   END
  229.   RETURN res = 0
  230. END CreateDir;
  231.  
  232. PROCEDURE DeleteDir*(DirName: ARRAY OF CHAR): BOOLEAN;
  233. VAR F: FS; res, res2: INTEGER;
  234. BEGIN
  235.   IF DirExists(DirName) THEN
  236.     NEW(F);
  237.     IF F # NIL THEN
  238.       F.subfunc := 8;
  239.       F.pos := 0;
  240.       F.hpos := 0;
  241.       F.bytes := 0;
  242.       F.buffer := 0;
  243.       COPY(DirName, F.name);
  244.       res := KOSAPI.sysfunc22(70, sys.ADR(F^), res2);
  245.       DISPOSE(F)
  246.     ELSE
  247.       res := -1
  248.     END
  249.   ELSE
  250.     res := -1
  251.   END
  252.   RETURN res = 0
  253. END DeleteDir;
  254.  
  255. END File.