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