Subversion Repositories Kolibri OS

Rev

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

  1. (*
  2.     Copyright 2016, 2018 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.  
  23. CONST
  24.  
  25.     SEEK_BEG* = 0; SEEK_CUR* = 1; SEEK_END* = 2;
  26.  
  27.  
  28. TYPE
  29.  
  30.     FNAME* = ARRAY 520 OF CHAR;
  31.  
  32.     FS* = POINTER TO rFS;
  33.  
  34.     rFS* = RECORD
  35.         subfunc*, pos*, hpos*, bytes*, buffer*: INTEGER;
  36.         name*: FNAME
  37.     END;
  38.  
  39.     FD* = POINTER TO rFD;
  40.  
  41.     rFD* = RECORD
  42.         attr*: INTEGER;
  43.         ntyp*: CHAR;
  44.         reserved: ARRAY 3 OF CHAR;
  45.         time_create*, date_create*,
  46.         time_access*, date_access*,
  47.         time_modif*,  date_modif*,
  48.         size*, hsize*: INTEGER;
  49.         name*: FNAME
  50.     END;
  51.  
  52.  
  53. PROCEDURE [stdcall] f_68_27 (file_name: INTEGER; VAR size: INTEGER): INTEGER;
  54. BEGIN
  55.     sys.CODE(
  56.     053H,               (*  push    ebx                    *)
  57.     06AH, 044H,         (*  push    68                     *)
  58.     058H,               (*  pop     eax                    *)
  59.     06AH, 01BH,         (*  push    27                     *)
  60.     05BH,               (*  pop     ebx                    *)
  61.     08BH, 04DH, 008H,   (*  mov     ecx, dword [ebp +  8]  *)
  62.     0CDH, 040H,         (*  int     64                     *)
  63.     08BH, 04DH, 00CH,   (*  mov     ecx, dword [ebp + 12]  *)
  64.     089H, 011H,         (*  mov     dword [ecx], edx       *)
  65.     05BH,               (*  pop     ebx                    *)
  66.     0C9H,               (*  leave                          *)
  67.     0C2H, 008H, 000H    (*  ret     8                      *)
  68.     )
  69.     RETURN 0
  70. END f_68_27;
  71.  
  72.  
  73. PROCEDURE Load* (FName: ARRAY OF CHAR; VAR size: INTEGER): INTEGER;
  74.     RETURN f_68_27(sys.ADR(FName[0]), size)
  75. END Load;
  76.  
  77.  
  78. PROCEDURE GetFileInfo* (FName: ARRAY OF CHAR; VAR Info: rFD): BOOLEAN;
  79. VAR
  80.     res2: INTEGER; fs: rFS;  
  81.  
  82. BEGIN
  83.     fs.subfunc := 5;
  84.     fs.pos     := 0;
  85.     fs.hpos    := 0;
  86.     fs.bytes   := 0;
  87.     fs.buffer  := sys.ADR(Info);
  88.     COPY(FName, fs.name)
  89.  
  90.     RETURN KOSAPI.sysfunc22(70, sys.ADR(fs), res2) = 0
  91. END GetFileInfo;  
  92.  
  93.  
  94. PROCEDURE Exists* (FName: ARRAY OF CHAR): BOOLEAN;
  95. VAR
  96.     fd: rFD;
  97. BEGIN
  98.     RETURN GetFileInfo(FName, fd) & ~(4 IN BITS(fd.attr))
  99. END Exists;
  100.              
  101.  
  102. PROCEDURE Close* (VAR F: FS);
  103. BEGIN
  104.     IF F # NIL THEN
  105.         DISPOSE(F)
  106.     END
  107. END Close;
  108.  
  109.  
  110. PROCEDURE Open* (FName: ARRAY OF CHAR): FS;
  111. VAR
  112.     F: FS;    
  113.  
  114. BEGIN  
  115.  
  116.     IF Exists(FName) THEN
  117.         NEW(F);
  118.         IF F # NIL THEN
  119.             F.subfunc := 0;
  120.             F.pos     := 0;
  121.             F.hpos    := 0;
  122.             F.bytes   := 0;
  123.             F.buffer  := 0;
  124.             COPY(FName, F.name)
  125.         END
  126.     ELSE
  127.         F := NIL
  128.     END
  129.  
  130.     RETURN F
  131. END Open;    
  132.  
  133.  
  134. PROCEDURE Delete* (FName: ARRAY OF CHAR): BOOLEAN;
  135. VAR
  136.     F: FS;
  137.     res, res2: INTEGER;
  138.  
  139. BEGIN
  140.  
  141.     IF Exists(FName) THEN
  142.         NEW(F);
  143.         IF F # NIL THEN
  144.             F.subfunc := 8;
  145.             F.pos     := 0;
  146.             F.hpos    := 0;
  147.             F.bytes   := 0;
  148.             F.buffer  := 0;
  149.             COPY(FName, F.name);
  150.             res := KOSAPI.sysfunc22(70, sys.ADR(F^), res2);
  151.             DISPOSE(F)
  152.         ELSE
  153.             res := -1
  154.         END
  155.     ELSE
  156.         res := -1
  157.     END
  158.  
  159.     RETURN res = 0
  160. END Delete;
  161.  
  162.  
  163. PROCEDURE Seek* (F: FS; Offset, Origin: INTEGER): INTEGER;
  164. VAR
  165.     res: INTEGER;
  166.     fd: rFD;
  167.  
  168. BEGIN
  169.  
  170.     IF (F # NIL) & GetFileInfo(F.name, fd) & (BITS(fd.attr) * {4} = {}) THEN
  171.         CASE Origin OF
  172.         |SEEK_BEG: F.pos := Offset
  173.         |SEEK_CUR: F.pos := F.pos + Offset
  174.         |SEEK_END: F.pos := fd.size + Offset
  175.         ELSE
  176.         END;
  177.         res := F.pos
  178.     ELSE
  179.         res := -1
  180.     END
  181.  
  182.     RETURN res
  183. END Seek;
  184.  
  185.  
  186. PROCEDURE Read* (F: FS; Buffer, Count: INTEGER): INTEGER;
  187. VAR
  188.     res, res2: INTEGER;
  189.  
  190. BEGIN
  191.  
  192.     IF F # NIL THEN
  193.         F.subfunc := 0;
  194.         F.bytes   := Count;
  195.         F.buffer  := Buffer;
  196.         res := KOSAPI.sysfunc22(70, sys.ADR(F^), res2);
  197.         IF res2 > 0 THEN
  198.             F.pos := F.pos + res2
  199.         END
  200.     ELSE
  201.         res2 := 0
  202.     END
  203.  
  204.     RETURN res2
  205. END Read;    
  206.  
  207.  
  208. PROCEDURE Write* (F: FS; Buffer, Count: INTEGER): INTEGER;
  209. VAR
  210.     res, res2: INTEGER;
  211.  
  212. BEGIN
  213.  
  214.     IF F # NIL THEN
  215.         F.subfunc := 3;
  216.         F.bytes   := Count;
  217.         F.buffer  := Buffer;
  218.         res := KOSAPI.sysfunc22(70, sys.ADR(F^), res2);
  219.         IF res2 > 0 THEN
  220.             F.pos := F.pos + res2
  221.         END
  222.     ELSE
  223.         res2 := 0
  224.     END
  225.  
  226.     RETURN res2
  227. END Write;
  228.                    
  229.  
  230. PROCEDURE Create* (FName: ARRAY OF CHAR): FS;
  231. VAR
  232.     F: FS;
  233.     res2: INTEGER;
  234.  
  235. BEGIN
  236.     NEW(F);
  237.  
  238.     IF F # NIL THEN
  239.         F.subfunc := 2;
  240.         F.pos     := 0;
  241.         F.hpos    := 0;
  242.         F.bytes   := 0;
  243.         F.buffer  := 0;
  244.         COPY(FName, F.name);
  245.         IF KOSAPI.sysfunc22(70, sys.ADR(F^), res2) # 0 THEN
  246.             DISPOSE(F)
  247.         END
  248.     END
  249.  
  250.     RETURN F
  251. END Create;
  252.    
  253.  
  254. PROCEDURE DirExists* (FName: ARRAY OF CHAR): BOOLEAN;
  255. VAR
  256.     fd: rFD;
  257. BEGIN
  258.     RETURN GetFileInfo(FName, fd) & (4 IN BITS(fd.attr))
  259. END DirExists;      
  260.  
  261.  
  262. PROCEDURE CreateDir* (DirName: ARRAY OF CHAR): BOOLEAN;
  263. VAR
  264.     F: FS;
  265.     res, res2: INTEGER;
  266.  
  267. BEGIN
  268.     NEW(F);
  269.  
  270.     IF F # NIL THEN
  271.         F.subfunc := 9;
  272.         F.pos     := 0;
  273.         F.hpos    := 0;
  274.         F.bytes   := 0;
  275.         F.buffer  := 0;
  276.         COPY(DirName, F.name);
  277.         res := KOSAPI.sysfunc22(70, sys.ADR(F^), res2);
  278.         DISPOSE(F)
  279.     ELSE
  280.         res := -1
  281.     END
  282.  
  283.     RETURN res = 0
  284. END CreateDir;
  285.                            
  286.  
  287. PROCEDURE DeleteDir* (DirName: ARRAY OF CHAR): BOOLEAN;
  288. VAR
  289.     F: FS;
  290.     res, res2: INTEGER;
  291.  
  292. BEGIN
  293.  
  294.     IF DirExists(DirName) THEN
  295.         NEW(F);
  296.         IF F # NIL THEN
  297.             F.subfunc := 8;
  298.             F.pos := 0;
  299.             F.hpos := 0;
  300.             F.bytes := 0;
  301.             F.buffer := 0;
  302.             COPY(DirName, F.name);
  303.             res := KOSAPI.sysfunc22(70, sys.ADR(F^), res2);
  304.             DISPOSE(F)
  305.         ELSE
  306.             res := -1
  307.         END
  308.     ELSE
  309.         res := -1
  310.     END
  311.  
  312.     RETURN res = 0
  313. END DeleteDir;
  314.  
  315.  
  316. END File.