home *** CD-ROM | disk | FTP | other *** search
/ Beijing Paradise BBS Backup / PARADISE.ISO / software / BBSDOORW / MKMSG102.ZIP / MKFILE.PAS < prev    next >
Encoding:
Pascal/Delphi Source File  |  1993-08-15  |  28.8 KB  |  1,434 lines
  1. Unit MkFile;
  2. {$I MKB.Def}
  3.  
  4. Interface
  5.  
  6. {$IFDEF WINDOWS}
  7. Uses WinDos;
  8. {$ELSE}
  9. Uses Dos;
  10. {$ENDIF}
  11.  
  12. Const
  13.   fmReadOnly = 0;          {FileMode constants}
  14.   fmWriteOnly = 1;
  15.   fmReadWrite = 2;
  16.   fmDenyAll = 16;
  17.   fmDenyWrite = 32;
  18.   fmDenyRead = 48;
  19.   fmDenyNone = 64;
  20.   fmNoInherit = 128;
  21.  
  22.  
  23. Const
  24.   Tries: Word = 150;
  25.   TryDelay: Word = 100;
  26.  
  27.  
  28. {$IFDEF WINDOWS}
  29. Type
  30.   PathStr = String[128];
  31.   DirStr = String[128];
  32.   NameStr = String[13];
  33.   ExtStr = String[4];
  34. {$ENDIF}
  35.  
  36.  
  37. Type FindRec = Record
  38.   {$IFDEF WINDOWS}
  39.   SR: TSearchRec;
  40.   TStr: Array[0..180] of Char;
  41.   {$ELSE}
  42.   SR: SearchRec;
  43.   {$ENDIF}
  44.   Dir: DirStr;
  45.   Name: NameStr;
  46.   Ext: ExtStr;
  47.   DError: Word;
  48.   End;
  49.  
  50.  
  51. Type FindObj = Object
  52.   FI: ^FindRec;
  53.   Procedure Init; {Initialize}
  54.   Procedure Done; {Done}
  55.   Procedure FFirst(FN: String); {Find first}
  56.   Procedure FNext;
  57.   Function  Found: Boolean; {File was found}
  58.   Function  GetName: String; {Get Filename}
  59.   Function  GetFullPath: String; {Get filename with path}
  60.   Function  GetDate: LongInt; {Get file date}
  61.   Function  GetSize: LongInt; {Get file size}
  62.   End;
  63.  
  64.  
  65. Type TFileRec = Record
  66.   MsgBuffer: Array[1..1024] of Char;
  67.   BufferPtr: Word;
  68.   BufferChars: Word;
  69.   BufferStart: LongInt;
  70.   BufferFile: File;
  71.   StringPtr: LongInt;
  72.   CurrentStr: String;
  73.   StringFound: Boolean;
  74.   Error: Word;
  75.   End;
  76.  
  77.  
  78. Type TFile = Object
  79.   TF: ^TFileRec;
  80.   Procedure Init;
  81.   Procedure Done;
  82.   Function  GetString:String;          {Get string from file}
  83.   Function  GetUString: String; {Get LF delimited string}
  84.   Function  OpenTextFile(FilePath: String): Boolean;  {Open file}
  85.   Function  CloseTextFile: Boolean;    {Close file}
  86.   Function  GetChar: Char;             {Internal use}
  87.   Procedure BufferRead;                {Internal use}
  88.   Function  StringFound: Boolean;      {Was a string found}
  89.   Function  SeekTextFile(SeekPos: LongInt): Boolean; {Seek to position}
  90.   Function  GetTextPos: LongInt;       {Get text file position}
  91.   Function  Restart: Boolean;          {Reset to start of file}
  92.   End;
  93.  
  94.  
  95.  
  96. Var
  97.   FileError: Word;
  98.  
  99.  
  100. Function  FileExist(FName: String): Boolean;
  101. Function  SizeFile(FName: String): LongInt;
  102. Function  DateFile(FName: String): LongInt;
  103. Function  FindPath(FileName: String): String;
  104. Function  LongLo(InNum: LongInt): Word;
  105. Function  LongHi(InNum: LongInt): Word;
  106. Function  LockFile(Var F; LockStart: LongInt; LockLength: LongInt): Word;
  107. Function  UnLockFile(Var F; LockStart: LongInt; LockLength: LongInt): Word;
  108. Function  shAssign(Var F: File; FName: String): Boolean;
  109. Function  shLock(Var F; LockStart,LockLength: LongInt): Word;
  110. Procedure FlushFile(Var F); {Dupe file handle, close dupe handle}
  111. Function  shReset(Var F: File; RecSize: Word): Boolean;
  112. Function  shRead(Var F: File; Var Rec; ReadSize: Word; Var NumRead: Word): Boolean;
  113. Function  shWrite(Var F: File; Var Rec; ReadSize: Word): Boolean;
  114. Function  shOpenFile(Var F: File; PathName: String): Boolean;
  115. Function  shMakeFile(Var F: File; PathName: String): Boolean;
  116. Procedure shCloseFile(Var F: File);
  117. Function  shSeekFile(Var F: File; FPos: LongInt): Boolean;
  118. Function  shFindFile(Pathname: String; Var Name: String; Var Size, Time: LongInt): Boolean;
  119. Procedure shSetFTime(Var F: File; Time: LongInt);
  120. Function  GetCurrentPath: String;
  121. Procedure CleanDir(FileDir: String);
  122. {$IFDEF WINDOWS}
  123. Function  GetEnv(Str: String): String;
  124. Function  FExpand(Str: String): String;
  125. Procedure FSplit(Path: String; Var Dir: String; Var Name: String; Var Ext: String);
  126. Function  FSearch(Path: String; DirList: String): String;
  127. {$ENDIF}
  128. Function  IsDevice(FilePath: String): Boolean;
  129. Function  LoadFilePos(FN: String; Var Rec; FS: Word; FPos: LongInt): Word;
  130. Function  LoadFile(FN: String; Var Rec; FS: Word): Word;
  131. Function  SaveFilePos(FN: String; Var Rec; FS: Word; FPos: LongInt): Word;
  132. Function  SaveFile(FN: String; Var Rec; FS: Word): Word;
  133. Function  ExtendFile(FN: String; ToSize: LongInt): Word;
  134. Function  CreateTempDir(FN: String): String;
  135. Function  GetTempName(FN: String): String;
  136. Function  GetTextPos(Var F: Text): LongInt;
  137. Function  FindOnPath(FN: String; Var OutName: String): Boolean;
  138. Function  CopyFile(FN1: String; FN2: String): Boolean;
  139. Function  EraseFile(FN: String): Boolean;
  140.  
  141.  
  142. Implementation
  143.  
  144. {$IFDEF WINDOWS}
  145. Uses Strings, MKWCrt;
  146. {$ELSE}
  147. Uses
  148.   {$IFDEF OPRO}
  149.   OpCrt;
  150.   {$ELSE}
  151.   Crt;
  152.   {$ENDIF}
  153. {$ENDIF}
  154.  
  155.  
  156. {$IFDEF WINDOWS}
  157. Function GetEnv(Str: String): String;
  158.   Var
  159.     NStr: Array[0..128] of Char;
  160.     PStr: PChar;
  161.  
  162.   Begin
  163.   StrPCopy(NStr, Str);
  164.   PStr := GetEnvVar(NStr);
  165.   If PStr = nil Then
  166.     GetEnv := ''
  167.   Else
  168.     GetEnv := StrPas(PStr);
  169.   End;
  170. {$ENDIF}
  171.  
  172. {$IFDEF WINDOWS}
  173. Function FExpand(Str: String): String;
  174.   Var
  175.     IStr: Array[0..128] of Char;
  176.     OStr: Array[0..128] of Char;
  177.  
  178.   Begin
  179.   StrPCopy(IStr, Str);
  180.   FileExpand(OStr, IStr);
  181.   FExpand := StrPas(OStr);
  182.   End;
  183. {$ENDIF}
  184.  
  185. {$IFDEF WINDOWS}
  186. Procedure FSplit(Path: String; Var Dir: String; Var Name: String; Var Ext: String);
  187.   Var
  188.     FPath: Array[0..129] of Char;
  189.     TD: Array[0..129] of Char;
  190.     TN: Array[0..14] of Char;
  191.     TE: Array[0..5] of Char;
  192.  
  193.   Begin
  194.   StrPCopy(FPath, Path);
  195.   FileSplit(FPath, TD, TN, TE);
  196.   Dir := StrPas(TD);
  197.   Name := StrPas(TN);
  198.   Ext := StrPas(TE);
  199.   End;
  200. {$ENDIF}
  201.  
  202. {$IFDEF WINDOWS}
  203. Function  FSearch(Path: String; DirList: String): String;
  204.   Var
  205.     FPath: Array[0..129] of Char;
  206.     DL: Array[0..129] of Char;
  207.     RS: Array[0..129] of Char;
  208.  
  209.   Begin
  210.   StrPCopy(Fpath, Path);
  211.   StrPCopy(DL, DirList);
  212.   FileSearch(RS, FPath, DL);
  213.   FSearch := StrPas(RS);
  214.   End;
  215. {$ENDIF}
  216.  
  217. Procedure FindObj.Init;
  218.   Begin
  219.   New(FI);
  220.   FI^.DError := 1;
  221.   End;
  222.  
  223.  
  224. Procedure FindObj.Done;
  225.   Begin
  226.   Dispose(FI);
  227.   End;
  228.  
  229.  
  230. Procedure FindObj.FFirst(FN: String);
  231.   Begin
  232.   FN := FExpand(FN);
  233.   FSplit(FN, FI^.Dir, FI^.Name, FI^.Ext);
  234.   {$IFDEF WINDOWS}
  235.   StrPCopy(FI^.TStr, FN);
  236.   FindFirst(FI^.TStr, faReadOnly + faArchive, FI^.SR);
  237.   {$ELSE}
  238.   FindFirst(FN, Archive + ReadOnly, FI^.SR);
  239.   {$ENDIF}
  240.   FI^.DError := DosError;
  241.   End;
  242.  
  243.  
  244. Function  FindObj.GetName: String;
  245.   Begin
  246.   If Found Then
  247.     Begin
  248.     {$IFDEF WINDOWS}
  249.     GetName := StrPas(FI^.SR.Name)
  250.     {$ELSE}
  251.     GetName := FI^.SR.Name
  252.     {$ENDIF}
  253.     End
  254.   Else
  255.     GetName := '';
  256.   End;
  257.  
  258.  
  259. Function FindObj.GetFullPath: String;
  260.   Begin
  261.   GetFullPath := FI^.Dir + GetName;
  262.   End;
  263.  
  264.  
  265. Function  FindObj.GetSize: LongInt;
  266.   Begin
  267.   If Found Then
  268.     GetSize := FI^.SR.Size
  269.   Else
  270.     GetSize := 0;
  271.   End;
  272.  
  273.  
  274. Function  FindObj.GetDate: LongInt;
  275.   Begin
  276.   If Found Then
  277.     GetDate := FI^.SR.Time
  278.   Else
  279.     GetDate := 0;
  280.   End;
  281.  
  282.  
  283. Procedure FindObj.FNext;
  284.   Begin
  285.   FindNext(FI^.SR);
  286.   FI^.DError := DosError;
  287.   End;
  288.  
  289.  
  290. Function FindObj.Found: Boolean;
  291.   Begin
  292.   Found := (FI^.DError = 0);
  293.   End;
  294.  
  295.  
  296. Function shAssign(Var F: File; FName: String): Boolean;
  297.   Begin
  298.   Assign(F, FName);
  299.   FileError := IoResult;
  300.   shAssign := (FileError = 0);
  301.   End;
  302.  
  303.  
  304.  
  305. Function shRead(Var F: File; Var Rec; ReadSize: Word; Var NumRead: Word): Boolean;
  306.   Var
  307.     Count: Word;
  308.     Code: Word;
  309.  
  310.   Begin
  311.   Count := Tries;
  312.   Code := 5;
  313.   While ((Count > 0) and (Code = 5)) Do
  314.     Begin
  315.     BlockRead(F,Rec,ReadSize,NumRead);
  316.     Code := IoResult;
  317.     End;
  318.   FileError := Code;
  319.   ShRead := (Code = 0);
  320.   End;
  321.  
  322.  
  323. Function shWrite(Var F: File; Var Rec; ReadSize: Word): Boolean;
  324.   Var
  325.     Count: Word;
  326.     Code: Word;
  327.  
  328.   Begin
  329.   Count := Tries;
  330.   Code := 5;
  331.   While ((Count > 0) and (Code = 5)) Do
  332.     Begin
  333.     BlockWrite(F,Rec,ReadSize);
  334.     Code := IoResult;
  335.     End;
  336.   FileError := Code;
  337.   shWrite := (Code = 0);
  338.   End;
  339.  
  340.  
  341. Procedure CleanDir(FileDir: String);
  342.   Var
  343.     {$IFDEF WINDOWS}
  344.       SR: TSearchRec;
  345.       TStr: Array[0..128] of Char;
  346.     {$ELSE}
  347.       SR: SearchRec;
  348.     {$ENDIF}
  349.     F: File;
  350.  
  351.   Begin
  352.   {$IFDEF WINDOWS}
  353.   StrPCopy(TStr, FileDir);
  354.   StrCat(TStr,'*.*');
  355.   FindFirst(TStr, faReadOnly + faArchive, SR);
  356.   {$ELSE}
  357.   FindFirst(FileDir + '*.*', ReadOnly + Archive, SR);
  358.   {$ENDIF}
  359.   While DosError = 0 Do
  360.     Begin
  361.     {$IFDEF WINDOWS}
  362.     If Not shAssign(F, FileDir + StrPas(SR.Name)) Then;
  363.     {$ELSE}
  364.     If Not shAssign(F, FileDir + SR.Name) Then;
  365.     {$ENDIF}
  366.     Erase(F);
  367.     If IoResult <> 0 Then;
  368.     FindNext(SR);
  369.     End;
  370.   End;
  371.  
  372.  
  373.  
  374. {$IFDEF WINDOWS}
  375. Function GetCurrentPath: String;
  376.   Var
  377.     Path: Array[0..128] of Char;
  378.     CName: Array[0..13] of Char;
  379.     CExt: Array[0..4] of Char;
  380.     TStr: Array[0..128] of Char;
  381.  
  382.   Begin
  383.   FileExpand('*.*', TStr);
  384.   FileSplit(TStr, Path, CName, CExt);
  385.   GetCurrentPath := StrPas(Path);
  386.   End;
  387. {$ELSE}
  388. Function GetCurrentPath: String;
  389.   Var
  390.     CName: NameStr;
  391.     Path: DirStr;
  392.     CExt: ExtStr;
  393.  
  394.   Begin
  395.   FSplit(FExpand('*.*'),Path,CName,CExt);
  396.   GetCurrentPath := Path;
  397.   End;
  398. {$ENDIF}
  399.  
  400.  
  401. Function shLock(Var F; LockStart,LockLength: LongInt): Word;
  402.   Var
  403.     Count: Word;
  404.     Code: Word;
  405.  
  406.   Begin
  407.   Count := Tries;
  408.   Code := $21;
  409.   While ((Count > 0) and (Code = $21)) Do
  410.     Begin
  411.     Code := LockFile(F,LockStart,LockLength);
  412.     Dec(Count);
  413.     If Code = $21 Then
  414.       Delay(TryDelay);
  415.     End;
  416.   If Code = 1 Then
  417.     Code := 0;
  418.   shLock := Code;
  419.   End;
  420.  
  421.  
  422.  
  423. Function shReset(Var F: File; RecSize: Word): Boolean;
  424.   Var
  425.     Count: Word;
  426.     Code: Word;
  427.  
  428.   Begin
  429.   Count := Tries;
  430.   Code := 5;
  431.   While ((Count > 0) and (Code = 5)) Do
  432.     Begin
  433.     Reset(F,RecSize);
  434.     Code := IoResult;
  435.     End;
  436.   FileError := Code;
  437.   ShReset := (Code = 0);
  438.   End;
  439.  
  440.  
  441. Procedure FlushFile(Var F); {Dupe file handle, close dupe handle}
  442.   Var
  443.     Handle: Word Absolute F;
  444.   {$IFDEF BASMINT}
  445.     Tmp: Word;
  446.   {$ELSE}
  447.     {$IFDEF WINDOWS}
  448.     Regs: TRegisters;
  449.     {$ELSE}
  450.     Regs: Registers;
  451.     {$ENDIF}
  452.   {$ENDIF}
  453.  
  454.   Begin
  455.   {$IFDEF BASMINT}
  456.   Tmp := Handle;
  457.   Asm
  458.     Mov ah, $45;
  459.     Mov bx, Tmp;
  460.     Int $21;
  461.     Jc  @JFlush;
  462.     Mov bx, ax;
  463.     Mov ah, $3e;
  464.     Int $21;
  465.     @JFlush:
  466.     End;
  467.   {$ELSE}
  468.   Regs.ah := $45;
  469.   Regs.bx := Handle;
  470.   MsDos(Regs);
  471.   If (Regs.Flags and 1) = 0 Then   {carry}
  472.     Begin
  473.     Regs.bx := Regs.ax;
  474.     Regs.Ah := $3e;
  475.     MsDos(Regs);
  476.     End;
  477.   {$ENDIF}
  478.   End;
  479.  
  480.  
  481. Function LockFile(Var F; LockStart: LongInt; LockLength: LongInt): Word;
  482.   Var
  483.     Handle: Word Absolute F;
  484.     Tmp: Word;
  485.     StrtHi: Word;
  486.     StrtLo: Word;
  487.     LgHi: Word;
  488.     LgLo: Word;
  489.   {$IFNDEF BASMINT}
  490.     {$IFDEF WINDOWS}
  491.     Regs: TRegisters;
  492.     {$ELSE}
  493.     Regs: Registers;
  494.     {$ENDIF}
  495.   {$ENDIF}
  496.  
  497.   Begin
  498.   Tmp := Handle;
  499.   StrtHi := LongHi(LockStart);
  500.   StrtLo := LongLo(LockStart);
  501.   LgHi := LongHi(LockLength);
  502.   LgLo := LongLo(LockLength);
  503.   {$IFDEF BASMINT}
  504.   Asm
  505.     Mov ah, $5c;
  506.     Mov al, $00;
  507.     Mov bx, Tmp;
  508.     Mov cx, StrtHi;
  509.     Mov dx, StrtLo;
  510.     Mov si, LgHi;                 {00h = success           }
  511.     Mov di, LgLo;                 {01h = share not loaded  }
  512.     Int $21;                      {06h = invalid handle    }
  513.     Jc @JLock                     {21h = lock violation    }
  514.     Mov ax, $00;                  {24h = share buffer full }
  515.     @JLock:
  516.     Mov Tmp, ax;
  517.     End;
  518.   {$ELSE}
  519.   Regs.ah := $5c;
  520.   Regs.al := $00;
  521.   Regs.bx := Tmp;
  522.   Regs.cx := StrtHi;
  523.   Regs.dx := StrtLo;
  524.   Regs.si := LgHi;
  525.   Regs.di := LgLo;
  526.   MsDos(Regs);
  527.   If (Regs.Flags and 1) = 0 Then
  528.     Begin
  529.     Regs.ax := 0;
  530.     End;
  531.   Tmp := Regs.ax;
  532.   {$ENDIF}
  533.   If Tmp = 1 Then
  534.     Tmp := 0;
  535.   LockFile := Tmp;
  536.   End;
  537.  
  538.  
  539. Function UnLockFile(Var F; LockStart: LongInt; LockLength: LongInt): Word;
  540.   Var
  541.     Handle: Word Absolute F;
  542.     Tmp: Word;
  543.     StrtHi: Word;
  544.     StrtLo: Word;
  545.     LgHi: Word;
  546.     LgLo: Word;
  547.   {$IFNDEF BASMINT}
  548.     {$IFDEF WINDOWS}
  549.     Regs: TRegisters;
  550.     {$ELSE}
  551.     Regs: Registers;
  552.     {$ENDIF}
  553.   {$ENDIF}
  554.  
  555.   Begin
  556.   Tmp := Handle;
  557.   StrtHi := LongHi(LockStart);
  558.   StrtLo := LongLo(LockStart);
  559.   LgHi := LongHi(LockLength);
  560.   LgLo := LongLo(LockLength);
  561.   {$IFDEF BASMINT}
  562.   Asm
  563.     Mov ah, $5c;
  564.     Mov al, $01;
  565.     Mov bx, Tmp;
  566.     Mov cx, StrtHi;
  567.     Mov dx, StrtLo;
  568.     Mov si, LgHi;                 {00h = success           }
  569.     Mov di, LgLo;                 {01h = share not loaded  }
  570.     Int $21;                      {06h = invalid handle    }
  571.     Jc @JLock                     {21h = lock violation    }
  572.     Mov ax, $00;                  {24h = share buffer full }
  573.     @JLock:
  574.     Mov Tmp, ax;
  575.     End;
  576.   {$ELSE}
  577.   Regs.ah := $5c;
  578.   Regs.al := $01;
  579.   Regs.bx := Tmp;
  580.   Regs.cx := StrtHi;
  581.   Regs.dx := StrtLo;
  582.   Regs.si := LgHi;
  583.   Regs.di := LgLo;
  584.   MsDos(Regs);
  585.   If (Regs.Flags and 1) = 0 Then
  586.     Begin
  587.     Regs.ax := 0;
  588.     End;
  589.   Tmp := Regs.ax;
  590.   {$ENDIF}
  591.   If Tmp = 1 Then
  592.     Tmp := 0;
  593.   UnLockFile := Tmp;
  594.   End;
  595.  
  596.  
  597. Function LongLo(InNum: LongInt): Word;
  598.   Begin
  599.   LongLo := InNum and $FFFF;
  600.   End;
  601.  
  602.  
  603. Function LongHi(InNum: LongInt): Word;
  604.   Begin
  605.   LongHi := InNum Shr 16;
  606.   End;
  607.  
  608.  
  609. Function SizeFile(FName: String): LongInt;
  610.   Var
  611.     {$IFDEF WINDOWS}
  612.     SR: TSearchRec;
  613.     TStr: Array[0..128] of Char;
  614.     {$ELSE}
  615.     SR: SearchRec;
  616.     {$ENDIF}
  617.  
  618.   Begin
  619.   {$IFDEF WINDOWS}
  620.   StrPCopy(TStr, FName);
  621.   FindFirst(TStr, faAnyFile, SR);
  622.   {$ELSE}
  623.   FindFirst(FName, AnyFile, SR);
  624.   {$ENDIF}
  625.   If DosError = 0 Then
  626.     SizeFile := SR.Size
  627.   Else
  628.     SizeFile := -1;
  629.   End;
  630.  
  631.  
  632. Function  DateFile(FName: String): LongInt;
  633.   Var
  634.     {$IFDEF WINDOWS}
  635.     SR: TSearchRec;
  636.     TStr: Array[0..128] of Char;
  637.     {$ELSE}
  638.     SR: SearchRec;
  639.     {$ENDIF}
  640.  
  641.   Begin
  642.   {$IFDEF WINDOWS}
  643.   StrPCopy(TStr, FName);
  644.   FindFirst(TStr, faAnyFile, SR);
  645.   {$ELSE}
  646.   FindFirst(FName, AnyFile, SR);
  647.   {$ENDIF}
  648.   If DosError = 0 Then
  649.     DateFile := SR.Time
  650.   Else
  651.     DateFile := 0;
  652.   End;
  653.  
  654.  
  655. Function FileExist(FName: String): Boolean;
  656.   Var
  657.     {$IFDEF WINDOWS}
  658.     SR: TSearchRec;
  659.     TStr: Array[0..128] of Char;
  660.     {$ELSE}
  661.     SR: SearchRec;
  662.     {$ENDIF}
  663.  
  664.   Begin
  665.   {$IFDEF WINDOWS}
  666.   StrPCopy(TStr, FName);
  667.   FindFirst(TStr, faReadOnly + faHidden + faArchive, SR);
  668.   {$ELSE}
  669.   FindFirst(FName, ReadOnly + Hidden + Archive, SR);
  670.   {$ENDIF}
  671.   If DosError = 0 Then
  672.     FileExist := True
  673.   Else
  674.     FileExist := False;
  675.   If IoResult <> 0 Then;
  676.   End;
  677.  
  678.  
  679. {$IFDEF WINDOWS}
  680. Function FindPath(FileName: String): String;
  681.   Var
  682.     TStr: Array[0..128] of Char;
  683.     NStr: Array[0..14] of Char;
  684.  
  685.   Begin
  686.   If FileExist(FileName) Then
  687.     Begin
  688.     FileExpand(TStr, StrPCopy(NStr,FileName));
  689.     FindPath := StrPas(TStr);
  690.     End
  691.   Else
  692.     Begin
  693.     FileSearch(TStr, StrPCopy(NStr, FileName), GetEnvVar('Path'));
  694.     FileExpand(TStr, TStr);
  695.     FindPath := StrPas(TStr);
  696.     End;
  697.   End;
  698. {$ELSE}
  699. Function FindPath(FileName: String):String;
  700.   Begin
  701.   If FileExist(FileName) Then
  702.     FindPath := FExpand(FileName)
  703.   Else
  704.     FindPath := FExpand(FSearch(FileName,GetEnv('PATH')));
  705.   End;
  706. {$ENDIF}
  707.  
  708.  
  709. Procedure TFile.BufferRead;
  710.   Begin
  711.   TF^.BufferStart := FilePos(TF^.BufferFile);
  712.   if Not shRead (TF^.BufferFile,TF^.MsgBuffer,SizeOf(TF^.MsgBuffer),TF^.BufferChars) Then
  713.     TF^.BufferChars := 0;
  714.   TF^.BufferPtr := 1;
  715.   End;
  716.  
  717.  
  718. Function TFile.GetChar: Char;
  719.   Begin
  720.   If TF^.BufferChars > 0 Then
  721.     GetChar := TF^.MsgBuffer[TF^.BufferPtr]
  722.   Else
  723.     GetChar := #0;
  724.   Inc(TF^.BufferPtr);
  725.   If TF^.BufferPtr > TF^.BufferChars Then
  726.     BufferRead;
  727.   End;
  728.  
  729.  
  730. Function TFile.GetString: String;
  731.  
  732.   Var
  733.     TempStr: String;
  734.     GDone: Boolean;
  735.     Ch: Char;
  736.  
  737.   Begin
  738.     If TF^.MsgBuffer[TF^.BufferPtr] = #10 Then
  739.       Ch := GetChar;
  740.     TF^.StringPtr := TF^.BufferPtr + TF^.BufferStart - 1;
  741.     TempStr := '';
  742.     GDone := False;
  743.     TF^.StringFound := False;
  744.     While Not GDone Do
  745.       Begin
  746.       Ch := GetChar;
  747.       Case Ch Of
  748.         #0:  If TF^.BufferChars = 0 Then
  749.                GDone := True
  750.              Else
  751.                Begin
  752.                Inc(TempStr[0]);
  753.                TempStr[Ord(TempStr[0])] := Ch;
  754.                TF^.StringFound := True;
  755.                If Length(TempStr) = 255 Then
  756.                  GDone := True;
  757.                End;
  758.         #10:;
  759.         #26:;
  760.         #13: Begin
  761.              GDone := True;
  762.              TF^.StringFound := True;
  763.              End;
  764.         Else
  765.           Begin
  766.             Inc(TempStr[0]);
  767.             TempStr[Ord(TempStr[0])] := Ch;
  768.             TF^.StringFound := True;
  769.             If Length(TempStr) = 255 Then
  770.               GDone := True;
  771.           End;
  772.         End;
  773.       End;
  774.     GetString := TempStr;
  775.   End;
  776.  
  777.  
  778. Function TFile.GetUString: String;
  779.  
  780.   Var
  781.     TempStr: String;
  782.     GDone: Boolean;
  783.     Ch: Char;
  784.  
  785.   Begin
  786.     If TF^.MsgBuffer[TF^.BufferPtr] = #10 Then
  787.       Ch := GetChar;
  788.     TF^.StringPtr := TF^.BufferPtr + TF^.BufferStart - 1;
  789.     TempStr := '';
  790.     GDone := False;
  791.     TF^.StringFound := False;
  792.     While Not GDone Do
  793.       Begin
  794.       Ch := GetChar;
  795.       Case Ch Of
  796.         #0:  If TF^.BufferChars = 0 Then
  797.                GDone := True
  798.              Else
  799.                Begin
  800.                Inc(TempStr[0]);
  801.                TempStr[Ord(TempStr[0])] := Ch;
  802.                TF^.StringFound := True;
  803.                If Length(TempStr) = 255 Then
  804.                  GDone := True;
  805.                End;
  806.         #13:;
  807.         #26:;
  808.         #10: Begin
  809.              GDone := True;
  810.              TF^.StringFound := True;
  811.              End;
  812.         Else
  813.           Begin
  814.             Inc(TempStr[0]);
  815.             TempStr[Ord(TempStr[0])] := Ch;
  816.             TF^.StringFound := True;
  817.             If Length(TempStr) = 255 Then
  818.               GDone := True;
  819.           End;
  820.         End;
  821.       End;
  822.     GetUString := TempStr;
  823.   End;
  824.  
  825.  
  826. Function TFile.OpenTextFile(FilePath: String): Boolean;
  827.   Begin
  828.   If Not shAssign(TF^.BufferFile, FilePath) Then;
  829.   FileMode := fmReadOnly + fmDenyNone;
  830.   If Not shReset(TF^.BufferFile,1) Then
  831.     OpenTextFile := False
  832.   Else
  833.     Begin
  834.     BufferRead;
  835.     If TF^.BufferChars > 0 Then
  836.       TF^.StringFound := True
  837.     Else
  838.       TF^.StringFound := False;
  839.     OpenTextFile := True;
  840.     End;
  841.   End;
  842.  
  843.  
  844. Function TFile.SeekTextFile(SeekPos: LongInt): Boolean;
  845.   Begin
  846.   TF^.Error := 0;
  847.   Seek(TF^.BufferFile, SeekPos);
  848.   TF^.Error := IoResult;
  849.   BufferRead;
  850.   SeekTextFile := (TF^.Error = 0);
  851.   End;
  852.  
  853.  
  854. Function TFile.GetTextPos: LongInt;       {Get text file position}
  855.   Begin
  856.   GetTextPos := TF^.BufferStart + TF^.BufferPtr - 1;
  857.   End;
  858.  
  859.  
  860. Function TFile.Restart: Boolean;
  861.   Begin
  862.   Restart := SeekTextFile(0);
  863.   End;
  864.  
  865.  
  866. Function TFile.CloseTextFile: Boolean;
  867.   Begin
  868.   Close(TF^.BufferFile);
  869.   CloseTextFile := (IoResult = 0);
  870.   End;
  871.  
  872.  
  873. Procedure TFile.Init;
  874.   Begin
  875.   New(TF);
  876.   End;
  877.  
  878.  
  879. Procedure TFile.Done;
  880.   Begin
  881.   Close(TF^.BufferFile);
  882.   If IoResult <> 0 Then;
  883.   Dispose(TF);
  884.   End;
  885.  
  886.  
  887. Function TFile.StringFound: Boolean;
  888.   Begin
  889.   StringFound := TF^.StringFound;
  890.   End;
  891.  
  892.  
  893. Function  shOpenFile(Var F: File; PathName: String): Boolean;
  894.   Begin
  895.   Assign(f,pathname);
  896.   FileMode := fmReadWrite + fmDenyNone;
  897.   shOpenFile := shReset(f,1);
  898.   End;
  899.  
  900.  
  901. Function  shMakeFile(Var F: File; PathName: String): Boolean;
  902.   Begin
  903.   Assign(f,pathname);
  904.   ReWrite(f,1);
  905.   shMakeFile := (IOresult = 0);
  906.   END;
  907.  
  908.  
  909. Procedure shCloseFile(Var F: File);
  910.   Begin
  911.   Close(F);
  912.   If (IOresult <> 0) Then;
  913.   End;
  914.  
  915.  
  916. Function  shSeekFile(Var F: File; FPos: LongInt): Boolean;
  917.   Begin
  918.   Seek(F,FPos);
  919.   shSeekFile := (IOresult = 0);
  920.   End;
  921.  
  922.  
  923. Function  shFindFile(Pathname: String; Var Name: String; Var Size, Time: LongInt): Boolean;
  924.   Var
  925.     {$IFDEF WINDOWS}
  926.       SR: TSearchRec;
  927.       PStr: Array[0..128] of Char;
  928.     {$ELSE}
  929.       SR: SearchRec;
  930.    {$ENDIF}
  931.  
  932.   Begin
  933.   {$IFDEF WINDOWS}
  934.   StrPCopy(PStr, PathName);
  935.   FindFirst(PStr, faArchive, SR);
  936.   {$ELSE}
  937.   FindFirst(PathName, Archive, SR);
  938.   {$ENDIF}
  939.   If (DosError = 0) Then
  940.     Begin
  941.     shFindFile := True;
  942.     {$IFDEF WINDOWS}
  943.     Name := StrPas(SR.Name);
  944.     {$ELSE}
  945.     Name := Sr.Name;
  946.     {$ENDIF}
  947.     Size := Sr.Size;
  948.     Time := Sr.Time;
  949.     End
  950.   Else
  951.     Begin
  952.     shFindFile := False;
  953.     End;
  954.   End;
  955.  
  956.  
  957. Procedure shSetFTime(Var F: File; Time: LongInt);
  958.   Begin
  959.   SetFTime(F, Time);
  960.   If (IOresult <> 0) Then;
  961.   End;
  962.  
  963.  
  964.  
  965. Function IsDevice(FilePath: String): Boolean;
  966.   Var
  967.     F: File;
  968.     Handle: Word Absolute F;
  969.     Tmp: Word;
  970.   {$IFNDEF BASMINT}
  971.     {$IFDEF WINDOWS}
  972.     Regs: TRegisters;
  973.     {$ELSE}
  974.     Regs: Registers;
  975.     {$ENDIF}
  976.   {$ENDIF}
  977.  
  978.   Begin
  979.   Assign(F, FilePath);
  980.   Reset(F);
  981.   If IoResult <> 0 Then
  982.     IsDevice := False
  983.   Else
  984.     Begin
  985.     Tmp := Handle;
  986. {$IFDEF BASMINT}
  987.     Asm
  988.       Mov ah, $44;
  989.       Mov al, $00;
  990.       Mov bx, Tmp;
  991.       Int $21;
  992.       Or  dx, $80;
  993.       Je  @JDev;
  994.       Mov ax, $01;
  995.       @JDev:
  996.       Mov ax, $00;
  997.       Mov @Result, al;
  998.       End;
  999. {$ELSE}
  1000.     Regs.ah := $44;
  1001.     Regs.al := $00;
  1002.     Regs.bx := Tmp;
  1003.     MsDos(Regs);
  1004.     IsDevice := (Regs.Dx and $80) <> 0;
  1005. {$ENDIF}
  1006.     End;
  1007.   Close(F);
  1008.   If IoResult <> 0 Then;
  1009.   End;
  1010.  
  1011.  
  1012. Function LoadFile(FN: String; Var Rec; FS: Word): Word;
  1013.   Begin
  1014.   LoadFile := LoadFilePos(FN, Rec, FS, 0);
  1015.   End;
  1016.  
  1017.  
  1018. Function LoadFilePos(FN: String; Var Rec; FS: Word; FPos: LongInt): Word;
  1019.   Var
  1020.     F: File;
  1021.     Error: Word;
  1022.     NumRead: Word;
  1023.  
  1024.   Begin
  1025.   Error := 0;
  1026.   If Not FileExist(FN) Then
  1027.     Error := 8888;
  1028.   If Error = 0 Then
  1029.     Begin
  1030.     If Not shAssign(F, FN) Then
  1031.       Error := FileError;
  1032.     End;
  1033.   FileMode := fmReadOnly + fmDenyNone;
  1034.   If Not shReset(F,1) Then
  1035.     Error := FileError;
  1036.   If Error = 0 Then
  1037.     Begin
  1038.     Seek(F, FPos);
  1039.     Error := IoResult;
  1040.     End;
  1041.   If Error = 0 Then
  1042.     If Not shRead(F, Rec, FS, NumRead) Then
  1043.       Error := FileError;
  1044.   If Error = 0 Then
  1045.     Begin
  1046.     Close(F);
  1047.     Error := IoResult;
  1048.     End;
  1049.   LoadFilePos := Error;
  1050.   End;
  1051.  
  1052.  
  1053. Function SaveFile(FN: String; Var Rec; FS: Word): Word;
  1054.    Begin
  1055.    SaveFile := SaveFilePos(FN, Rec, FS, 0);
  1056.    End;
  1057.  
  1058.  
  1059.  
  1060. Function SaveFilePos(FN: String; Var Rec; FS: Word; FPos: LongInt): Word;
  1061.   Var
  1062.     F: File;
  1063.     Error: Word;
  1064.  
  1065.   Begin
  1066.   Error := 0;
  1067.   If Not shAssign(F, FN) Then
  1068.     Error := FileError;
  1069.   FileMode := fmReadWrite + fmDenyNone;
  1070.   If FileExist(FN) Then
  1071.     Begin
  1072.     If Not shReset(F,1) Then
  1073.       Error := FileError;
  1074.     End
  1075.   Else
  1076.     Begin
  1077.     ReWrite(F,1);
  1078.     Error := IoResult;
  1079.     End;
  1080.   If Error = 0 Then
  1081.     Begin
  1082.     Seek(F, FPos);
  1083.     Error := IoResult;
  1084.     End;
  1085.   If Error = 0 Then
  1086.     If FS > 0 Then
  1087.       Begin
  1088.       If Not shWrite(F, Rec, FS) Then
  1089.         Error := FileError;
  1090.       End;
  1091.   If Error = 0 Then
  1092.     Begin
  1093.     Close(F);
  1094.     Error := IoResult;
  1095.     End;
  1096.   SaveFilePos := Error;
  1097.   End;
  1098.  
  1099.  
  1100. Function ExtendFile(FN: String; ToSize: LongInt): Word;
  1101. {Pads file with nulls to specified size}
  1102.   Type
  1103.     FillType = Array[1..8000] of Byte;
  1104.  
  1105.   Var
  1106.     F: File;
  1107.     Error: Word;
  1108.     FillRec: ^FillType;
  1109.  
  1110.   Begin
  1111.   New(FillRec);
  1112.   FillChar(FillRec^, SizeOf(FillRec^), 0);
  1113.   Error := 0;
  1114.   If Not shAssign(F, FN) Then
  1115.     Error := FileError;
  1116.   FileMode := fmReadWrite + fmDenyNone;
  1117.   If FileExist(FN) Then
  1118.     Begin
  1119.     If Not shReset(F,1) Then
  1120.       Error := FileError;
  1121.     End
  1122.   Else
  1123.     Begin
  1124.     ReWrite(F,1);
  1125.     Error := IoResult;
  1126.     End;
  1127.   If Error = 0 Then
  1128.     Begin
  1129.     Seek(F, FileSize(F));
  1130.     Error := IoResult;
  1131.     End;
  1132.   If Error = 0 Then
  1133.     Begin
  1134.     While ((FileSize(F) < (ToSize - SizeOf(FillRec^))) and (Error = 0)) Do
  1135.     If Not shWrite(F, FillRec^, SizeOf(FillRec^)) Then
  1136.       Error := FileError;
  1137.     End;
  1138.   If ((Error = 0) and (FileSize(F) < ToSize)) Then
  1139.     Begin
  1140.     If Not shWrite(F, FillRec^, ToSize - FileSize(F)) Then
  1141.       Error := FileError;
  1142.     End;
  1143.   If Error = 0 Then
  1144.     Begin
  1145.     Close(F);
  1146.     Error := IoResult;
  1147.     End;
  1148.   Dispose(FillRec);
  1149.   ExtendFile := Error;
  1150.   End;
  1151.  
  1152.  
  1153. Function  CreateTempDir(FN: String): String;
  1154.   Var
  1155.     TOfs: Word;
  1156.     TSeg: Word;
  1157.     FH: Word;
  1158.     i: Word;
  1159.     TmpStr: String;
  1160.  
  1161.   Begin
  1162.   TSeg := Seg(TmpStr[1]);
  1163.   TOfs := Ofs(TmpStr[1]);
  1164.   If ((Length(FN) > 0) and (FN[Length(FN)] <> '\')) Then
  1165.     TmpStr := FN + '\'
  1166.   Else
  1167.     TmpStr := FN;
  1168.   For i := 1 to 16 Do
  1169.    TmpStr[Length(TmpStr) + i] := #0;
  1170.   i := 0;
  1171.   Asm
  1172.     Mov bx, TSeg;
  1173.     Mov ax, TOfs;
  1174.     Push ds;
  1175.     Mov ds, bx;
  1176.     Mov dx, ax;
  1177.     Mov ah, $5a;
  1178.     Mov ch, $00;
  1179.     ; {Mov dx, TSeg;}
  1180.     ; {Mov ds, dx;}
  1181.     ; {Mov dx, TOfs;}
  1182.     Mov cl, $00;
  1183.     Int $21;              {Create tmp file}
  1184.     Mov FH, ax;
  1185.     Mov ax, 1;
  1186.     jc @JErr
  1187.     Mov bx, FH;
  1188.     Mov ah, $3e;
  1189.     jmp @J3;
  1190.     Int $21;              {Close tmp file}
  1191.     @J3:
  1192.     Mov ax, 2;
  1193.     jc @JErr;
  1194.     Mov ah, $41
  1195.     Mov dx, TSeg;
  1196.     Mov ds, dx;
  1197.     Mov dx, TOfs;
  1198.     Int $21;              {Erase tmp file}
  1199.     Mov ax, 3;
  1200.     jc @JErr;
  1201.     Mov ah, $39;
  1202.     Mov dx, TSeg;
  1203.     Mov ds, dx;
  1204.     Mov dx, TOfs;
  1205.     Int $21;              {Create directory}
  1206.     Mov ax, 4;
  1207.     jc @JErr;
  1208.     Jmp @JEnd;
  1209.     @JErr:
  1210.     Mov i, ax;
  1211.     @JEnd:
  1212.     Pop ds;
  1213.     End;
  1214.   TmpStr[0] := #255;
  1215.   TmpStr[0] := Chr(Pos(#0, TmpStr) - 1);
  1216.   If i = 0 Then
  1217.     CreateTempDir := TmpStr
  1218.   Else
  1219.     CreateTempDir := '';
  1220.   End;
  1221.  
  1222. Function  GetTempName(FN: String): String;
  1223.   Var
  1224.     TOfs: Word;
  1225.     TSeg: Word;
  1226.     FH: Word;
  1227.     i: Word;
  1228.     TmpStr: String;
  1229.  
  1230.   Begin
  1231.   TSeg := Seg(TmpStr[1]);
  1232.   TOfs := Ofs(TmpStr[1]);
  1233.   If ((Length(FN) > 0) and (FN[Length(FN)] <> '\')) Then
  1234.     TmpStr := FN + '\'
  1235.   Else
  1236.     TmpStr := FN;
  1237.   For i := 1 to 16 Do
  1238.    TmpStr[Length(TmpStr) + i] := #0;
  1239.   i := 0;
  1240.   Asm
  1241.     Push ds;
  1242.     Mov ah, $5a;
  1243.     Mov ch, $00;
  1244.     Mov dx, TSeg;
  1245.     Mov ds, dx;
  1246.     Mov dx, TOfs;
  1247.     Mov cl, $00;
  1248.     Int $21;              {Create tmp file}
  1249.     Mov FH, ax;
  1250.     Mov ax, 1;
  1251.     jc @JErr
  1252.     Mov bx, FH;
  1253.     Mov ah, $3e;
  1254.     jmp @J3;
  1255.     Int $21;              {Close tmp file}
  1256.     @J3:
  1257.     Mov ax, 2;
  1258.     jc @JErr;
  1259.     Mov ah, $41
  1260.     Mov dx, TSeg;
  1261.     Mov ds, dx;
  1262.     Mov dx, TOfs;
  1263.     Int $21;              {Erase tmp file}
  1264.     Mov ax, 3;
  1265.     jc @JErr;
  1266.     jmp @JEnd
  1267.     @JErr:
  1268.     Mov i, ax;
  1269.     @JEnd:
  1270.     Pop ds;
  1271.     End;
  1272.   TmpStr[0] := #255;
  1273.   TmpStr[0] := Chr(Pos(#0, TmpStr) - 1);
  1274.   If i = 0 Then
  1275.     GetTempName := TmpStr
  1276.   Else
  1277.     GetTempName := '';
  1278.   End;
  1279.  
  1280. Function  GetTextPos(Var F: Text): LongInt;
  1281.   Type WordRec = Record
  1282.     LongLo: Word;
  1283.     LongHi: Word;
  1284.     End;
  1285.  
  1286.   Var
  1287.    {$IFDEF WINDOWS}
  1288.    TR: TTextRec Absolute F;
  1289.    {$ELSE}
  1290.    TR: TextRec Absolute F;
  1291.    {$ENDIF}
  1292.    Tmp: LongInt;
  1293.    Handle: Word;
  1294.    {$IFNDEF BASMINT}
  1295.      {$IFDEF WINDOWS}
  1296.      Regs: TRegisters;
  1297.      {$ELSE}
  1298.      Regs: Registers;
  1299.      {$ENDIF}
  1300.    {$ENDIF}
  1301.  
  1302.   Begin
  1303.   Handle := TR.Handle;
  1304.   {$IFDEF BASMINT}
  1305.   Asm
  1306.     Mov ah, $42;
  1307.     Mov al, $01;
  1308.     Mov bx, Handle;
  1309.     Mov cx, 0;
  1310.     Mov dx, 0;
  1311.     Int $21;
  1312.     Jnc @TP2;
  1313.     Mov ax, $ffff;
  1314.     Mov dx, $ffff;
  1315.     @TP2:
  1316.     Mov WordRec(Tmp).LongLo, ax;
  1317.     Mov WordRec(Tmp).LongHi, dx;
  1318.     End;
  1319.   {$ELSE}
  1320.   Regs.ah := $42;
  1321.   Regs.al := $01;
  1322.   Regs.bx := Handle;
  1323.   Regs.cx := 0;
  1324.   Regs.dx := 0;
  1325.   MsDos(Regs);
  1326.   If (Regs.Flags and 1) <> 0 Then
  1327.     Begin
  1328.     Regs.ax := $ffff;
  1329.     Regs.dx := $ffff;
  1330.     End;
  1331.   WordRec(Tmp).LongLo := Regs.Ax;
  1332.   WordRec(Tmp).LongHi := Regs.Dx;
  1333.   {$ENDIF}
  1334.   If Tmp >= 0 Then
  1335.     Inc(Tmp, TR.BufPos);
  1336.   GetTextPos := Tmp;
  1337.   End;
  1338.  
  1339.  
  1340. Function FindOnPath(FN: String; Var OutName: String): Boolean;
  1341.   Var
  1342.     TmpStr: String;
  1343.  
  1344.   Begin
  1345.   If FileExist(FN) Then
  1346.     Begin
  1347.     OutName := FExpand(FN);
  1348.     FindOnPath := True;
  1349.     End
  1350.   Else
  1351.     Begin
  1352.     TmpStr := FSearch(FN, GetEnv('Path'));
  1353.     If FileExist(TmpStr) Then
  1354.       Begin
  1355.       OutName := TmpStr;
  1356.       FindOnPath := True;
  1357.       End
  1358.     Else
  1359.       Begin
  1360.       OutName := FN;
  1361.       FindOnPath := False;
  1362.       End;
  1363.     End;
  1364.   End;
  1365.  
  1366.  
  1367. Function  CopyFile(FN1: String; FN2: String): Boolean;
  1368.   Type
  1369.     TmpBufType = Array[1..8192] of Byte;
  1370.  
  1371.   Var
  1372.     F1: File;
  1373.     F2: File;
  1374.     NumRead: Word;
  1375.     Buf: ^TmpBufType;
  1376.     Error: Word;
  1377.  
  1378.   Begin
  1379.   New(Buf);
  1380.   Error := 0;
  1381.   Assign(F1, FN1);
  1382.   FileMode := fmReadOnly + fmDenyNone;
  1383.   Reset(F1, 1);
  1384.   Error := IoResult;
  1385.   If Error = 0 Then
  1386.     Begin
  1387.     Assign(F2, FN2);
  1388.     FileMode := fmReadWrite + fmDenyNone;
  1389.     ReWrite(F2, 1);
  1390.     Error := IoResult;
  1391.     End;
  1392.   If Error = 0 Then
  1393.     Begin
  1394.     BlockRead(F1, Buf^, SizeOf(Buf^), NumRead);
  1395.     Error := IoResult;
  1396.     While ((NumRead <> 0) and (Error = 0)) Do
  1397.       Begin
  1398.       BlockWrite(F2, Buf^, NumRead);
  1399.       Error := IoResult;
  1400.       If Error = 0 Then
  1401.         Begin
  1402.         BlockRead(F1, Buf^, SizeOf(Buf^), NumRead);
  1403.         Error := IoResult;
  1404.         End;
  1405.       End;
  1406.     End;
  1407.   If Error = 0 Then
  1408.     Begin
  1409.     Close(F1);
  1410.     Error := IoResult;
  1411.     End;
  1412.   If Error = 0 Then
  1413.     Begin
  1414.     Close(F2);
  1415.     Error := IoResult;
  1416.     End;
  1417.   Dispose(Buf);
  1418.   CopyFile := (Error = 0);
  1419.   End;
  1420.  
  1421.  
  1422. Function  EraseFile(FN: String): Boolean;
  1423.   Var
  1424.     F: File;
  1425.  
  1426.   Begin
  1427.   Assign(F, FN);
  1428.   Erase(F);
  1429.   EraseFile := (IoResult = 0);
  1430.   End;
  1431.  
  1432.  
  1433. End.
  1434.