root/trunk/ExtraFileUtils.pas

///////////////////////////////////////////////////////////
//                     ExtraFileUtils                    //
//        Ìîäóëü ñ ñàìîïàëüíûìè ôóíêöèÿìè è ïðî÷èì       //
//                  äëÿ ðàáîòû ñ ôàéëàìè.                //
//             Copyright (C) 2007 Gipat Group            //
//              Ðàñïðîñòðàíÿåòñÿ íà óñëîâèÿõ             //
//                      LGPL v2.1                        //
//                                                       //
//                  www.gipatgroup.org                   //
///////////////////////////////////////////////////////////

//Ê ðàáîòå íàä äàííûì ôàéëîì ïðèëîæèëè ðóêè, íîãè.... êîðî÷å àôôòàðû:
// 1) Immortal (immortalGAD@rambler.ru)
// 2) Sagrer (sagrer@yandex.ru)

////////////////////////////////////////////////////////////////////////

unit ExtraFileUtils;

{$IFDEF FPC}
  {$mode objfpc}
{$ENDIF FPC}

{$H+}

interface

uses
  windows, Classes, SysUtils,
  {$IFDEF LCL} FileUtil, {$ELSE} CodeFromLCL, StrUtils, {$ENDIF LCL}
  ExtraFunctions, syncobjs;

const
// Ðàçìåð áóôôåðà, êîòîðûé áóäåò èñïîëüçîâàòñüÿ äëÿ êîïèðîâàíèÿ ôàéëîâ
  FILECOPY_BUFFER_SIZE = 81920;
// Íåðåàëüíîå çíà÷åíèå àòòðèáóòà
  INVALID_SYSFILE_ATTR :LongInt = -1;
  
// âîçðâðàùàåìûå çíà÷åíèÿ
  resOk = 0;
  resParametersError = 1;
/////////////////////////
  
type
// òàêè ïîêà òîëüêî äëÿ âíóòðåííåãî ïîëüçîâàíèÿ.
  IOException = class(Exception) end;
  TFileSystemIterator = class;
  
////////////////////////////////////////////////////////////////////////////////
// Ïðîòîòèï ïðîöåäóðû, äëÿ èíôîðìèðîâàíèÿ î õîäå êîïèðîâàíèÿ
  TCopyFileProgressCallback = procedure(const current, total :Int64) of object;
// Ïðîòîòèï ïðîöåäóðû, äëÿ èíôîðìèðîâàíèÿ î çàâåðøåíèè
  TCopyFileFinishCallback   = procedure(const resultt :Boolean) of object;

// êëàññ äëÿ àñèíõðîííîãî êîïèðîâàíèÿ ôàéëà.
  TCopyFileThread = class (TThread)
    private
      curLock, totalLock :TCriticalSection;
      _current, _total :Int64;
    protected
      procedure Execute; override;
      function  GetTotal   :Int64;
      procedure SetTotal  (const value :Int64);
      function  GetCurrent :Int64;
      procedure SetCurrent(const value :Int64);
    public
      // ðåçóëüòàò îïåðàöèè
      CopyResult :Boolean;
      CopyFileProgress :TCopyFileProgressCallback;
      CopyFileFinish   :TCopyFileFinishCallback;
      SourceFilePath   :AnsiString;
      DestFilePath     :AnsiString;
      OverwriteExists  :Boolean;  // ïåðåïèñûâàòü ôàéë , åñëè óæå ñóùåñòâóåò
      property Total   :Int64 read GetTotal;
      property Current :Int64 read GetCurrent;

      //Êîíñòðóêòîðû-äåñòðóêòîðû.
      constructor Create(const source, dest :AnsiString; const overwriteExists , startSuspended :Boolean);
      destructor Destroy; override;
  end;

////////////////////////////////////////////////////////////////////////////////
//  áàçîâûé êëàññ, äëÿ ïðåäñòàâëåíèÿ ôàéëà èëè ïàïêè
  TFileSystemElemInfo = class
    protected
      SearchRec :TSearchRec;
    public
      // àáñîëþòíûé ïóòü ê ôàéëó èëè ïàïêå
      FullPath :AnsiString;
      constructor Create(const filePath :AnsiString); overload; virtual;
      constructor Create(const filePath: AnsiString; const searchInfo :TSearchRec); overload; virtual;
      function  Name :AnsiString; virtual;
      function  Attributes :Longint; virtual;
      function  Exists :Boolean; virtual; abstract;
      function  CopyTo(const path :AnsiString; const overwriteExists :Boolean = false) :Boolean; virtual; abstract;
      function  Delete :Boolean; virtual ;abstract;
  end;

////////////////////////////////////////////////////////////////////////////////
//  êëàññ äëÿ ðàáîòû ñ ôàéëàìè
  TFileInfo = class (TFileSystemElemInfo)
    public
      function CopyTo(const path :AnsiString; const overwriteExists :Boolean = false) :Boolean; override;
      function Delete :Boolean; override;
      function Exists :Boolean; override;
  end;
  
////////////////////////////////////////////////////////////////////////////////
//  êëàññ äëÿ ðàáîòû ñ äèðåêòîðèåé
  TDirectoryInfo = class (TFileSystemElemInfo)
    public
      function CopyTo(const path :AnsiString; const overwriteExists :Boolean = false) :Boolean; override;
      function Delete :Boolean; override;
      function Exists :Boolean; override;
      function GetFiles :TFileSystemIterator; overload;
      function GetFiles(const mask :AnsiString) :TFileSystemIterator; overload;
      function GetDirectories :TFileSystemIterator; overload;
      function GetDirectories(const mask :AnsiString) :TFileSystemIterator; overload;
  end;
  
////////////////////////////////////////////////////////////////////////////////
// êëàññ äëÿ ïåðåáîðà ôàéëîâ è ïîääèðåêîðèé â äèðåêòîðèè
  TFileSystemIterator = class
    protected
      searchInfo :TSearchRec;
      folder     :AnsiString;
    public
      Current    :TFileSystemElemInfo;  // òåêóùèé ôàéë\ïàïêà
      SearchAttr :Longint;
      constructor Create(const folderPath :AnsiString; const onlyFiles :Boolean = false); overload;
      constructor Create(const folderPath :AnsiString; const attrPredicat :Longint); overload;
      constructor Create(const folderPath, searchMask :AnsiString; const onlyFiles :Boolean = false); overload;
      constructor Create(const folderPath, searchMask :AnsiString; const attrPredicat :Longint); overload; //
      destructor  Destroy; override;
      function Next :Boolean;
  end;

// Êëàññ äëÿ ðàáîòû ñ âðåìåííûìè ïàïêàìè. ×èñòèò temp ïî çàâåðøåíèþ ðàáîòû.
  TTempFolder = class
    protected
      path :AnsiString;
      name :AnsiString;
    public
      constructor Create(const subName :AnsiString);
      destructor  Destroy; override;
      function GetTempPath :AnsiString;   //ïîëó÷èòü ïóòü ê âðåìåííîé äèðåêòîðèè
  end;
  
////////////////////////////////////////////////////////////////////////////////
//  Ïðîöåäóðû è ôóíêöèè
////////////////////////////////////////////////////////////////////////////////

// êîïèðóåò äèððåêòîðèþ
function CopyDirectory(const sourceDir, destDir :AnsiString; const overwriteExists :Boolean = false;
                        const recursive :Boolean = true) :Boolean;


//AsyncCopyFile - êîïèðóåò ôàéë â îòäåëüíîì ïîòîêå
function AsyncCopyFileEx(const sourcePath, destPath :AnsiString; const onFinish :TCopyFileFinishCallback;
                        const onProgress :TCopyFileProgressCallback; const overwriteExists :Boolean = false) :TThread;
function AsyncCopyFile(const sourcePath, destPath :AnsiString; const onFinish :TCopyFileFinishCallback;
                        const overwriteExists :Boolean = false) :TThread;

// SysFileExists - ïðîâåðÿåò ñóùåñòâóåò ëè ïî óêàçàííîìó ïóòè ôàéë èëè ïàïêà
function FileSystemElemExists(const path :AnsiString) :Boolean;

// IsDirectory - ïðîâåðÿåò ïî ïóòè èëè àòðèáóòàì ÿâëÿåòñÿ èëè "ýòî" ïàïêîé
function IsDirectory(const path :AnsiString) :Boolean; overload;
function IsDirectory(const attr :Longint) :Boolean; overload;

Function IsLocalPath(const PathStr : AnsiString) : boolean;     //Âîçâðàùàåò true åñëè ïóòü ëîêàëüíûé, è false åñëè ãëîáàëüíûé. Ïîä ëîêàëüíûì ïîíèìàåòñÿ ïóòü íà÷èíàþùèéñÿ ñ òî÷êè.
Function IsGlobalPath(const PathStr : AnsiString) : boolean;   //Âîçâðàùàåò true åñëè ïóòü ãëîáàëüíûé. Ïîä ãëîáàëüíûì ïîíèìàåòñÿ ïóòü, íà÷èíàþùèéñÿ íà èìÿ äèñêà (ôóíêöèÿ äëÿ âåíäîâ).
Function FixLocalPath(const PathStr : AnsiString) : AnsiString;   //Ïðàâèëüíî îôîðìëÿåò ïðåäïîëîæèòåëüíî ëîêàëüíûé íî íåïðàâèëüíî îôîðìëåííûé ïóòü - ÷òîá áûëà òî÷êà â íà÷àëå.
Function ResolveLocalPath(const LocalPath, GlobalPath : AnsiString) : AnsiString;  //Ïðåâðàòèòü îòíîñèòåëüíûé ïóòü â àáñîëþòíûé
Function GetLocalPath(const GlobalRoot, FullPath : AnsiString): AnsiString;    //Âåðíóòü îòíîñèòåëüíûé ïóòü.
Function GetFileSize(const FileName : AnsiString) : Int64;   //Ïîëó÷èòü ðàçìåð ôàéëà.
function GetFilesNumber(const DirName : AnsiString; const Recursive : boolean) : LongInt;//Ïîäñ÷èòàòü êîëè÷åñòâî ôàéëîâ è ïàïîê â ïàïêå...
Function IsDirsChild(const DirName, ChildName : AnsiString) : boolean;   //Ïðîâåðèòü - ïðèíàäëåæèò ëè ïóòü ChildName ïóòè DirName.
function AddExtensionIfAbsent(const path, extension :String) :String; // äîáàëÿåò ðàñøèðåíèå åñëè åãî åùå íåò.
function GetFileNameWithoutExtension(const path :String) :String;  // ÷èñòîå èìÿ ôàéëà, áåç ðàñøèðåíèÿ
Function HasLastSlash(const Str : string) : boolean;    //Ôóíêà äëÿ ïðîâåðêè íàëè÷èÿ ïîñëåäíåãî ñëýøà.
Function AddLastSlash(const str : string) : string;     //Ôóíêà äëÿ äîáàâëåíèÿ â ïóòü ïîñëåäíåãî ñëýøà (åñëè íàäî).
Function DelLastSlash(const Str : string) : string;     //Óäàëÿåò ïîñëåäíèé ñëåø åñëè îí åñòü.

implementation

//////////////////////////  TFileSystemIterator     ///////////////////////////////
constructor TFileSystemIterator.Create(const folderPath :AnsiString; const onlyFiles :Boolean = false);
begin
  Create(folderPath, AllDirectoryEntriesMask, onlyFiles);
end;

constructor TFileSystemIterator.Create(const folderPath :AnsiString; const attrPredicat :Longint);
begin
  Create(folderPath, AllDirectoryEntriesMask, attrPredicat);
end;

constructor TFileSystemIterator.Create(const folderPath, searchMask :AnsiString; const onlyFiles :Boolean = false);
var
  temp :Longint;
begin
  temp := faAnyFile;
  if onlyFiles then begin
    temp := temp and not faDirectory;
  end;
  Create(folderPath, searchMask, temp);
end;

constructor TFileSystemIterator.Create(const folderPath, searchMask :AnsiString; const attrPredicat :Longint);
begin
  inherited Create;
  Self.SearchAttr := attrPredicat;
  Self.folder := folderPath;
  FindFirst(AppendPathDelim(folderPath) + searchMask, faAnyFile, searchInfo);
end;

destructor TFileSystemIterator.Destroy;
begin
  inherited;
  FindClose(searchInfo);
end;

function TFileSystemIterator.Next :Boolean;
begin
  Result := (FindNext(searchInfo) = 0);
  if not Result then exit;
  
  if (searchInfo.Name = '.') or (searchInfo.Name = '..') then begin
    Result := Self.Next;
    exit;
  end;
  
  if (searchInfo.Attr and SearchAttr) = 0 then begin
    Result := Self.Next;
    exit;
  end;

  if IsDirectory(searchInfo.Attr) then
    Current := TDirectoryInfo.Create(folder, searchInfo)
  else
    Current := TFileInfo.Create(folder, searchInfo);

end;

///////////////////              TCopyFileThread             ///////////////////

//  êîíñòðóêòîð
constructor TCopyFileThread.Create(const source, dest :AnsiString; const overwriteExists, startSuspended :Boolean);
begin
  inherited Create(startSuspended);
  SourceFilePath := source;
  DestFilePath   := dest;
  self.OverwriteExists := overwriteExists;
  self._current := 0;
  Self._total := -1;
  totalLock := TCriticalSection.Create;
  curLock   := TCriticalSection.Create;
end;

destructor TCopyFileThread.Destroy;
begin
  inherited;
  totalLock.Free;
  curLock.Free;
end;

//  ïðîöåäóðà , êîïèðóåò ôàéë.
procedure TCopyFileThread.Execute;
var
  sourceStream :TFileStream;
  destStream   :TFileStream;
  curr, max    :Int64;
  stepReaded   :Integer;
  part, temp   :Int64;
  buffer       :array[0 .. FILECOPY_BUFFER_SIZE - 1] of byte;
begin
  CopyResult := false;
  
  if not FileExists(SourceFilePath) then begin
    if assigned (CopyFileFinish) then CopyFileFinish(false);
    exit;
  end;
  
  // Ïðîâåðÿåì ñóùåñòóåò ëè ôàéë êîòîðûé ìû ñîáèðàåìñÿ ñîçäàòü. Åñëè äà - òî åñëè ðàçðåøåííî ïðîáóåì óäàëèòü,
  // â ñëó÷àå íåóäà÷è âûõîäèì.
  if FileExists(DestFilePath) then begin
    if (not OverwriteExists) or (not DeleteFile(DestFilePath)) then begin
      if assigned (CopyFileFinish) then CopyFileFinish(false);
      exit;
    end;
  end;
  
  // îòêðûâàåì ïîòîêè
  sourceStream := TFileStream.Create(SourceFilePath, fmOpenRead);
  destStream   := TFileStream.Create(DestFilePath, fmCreate);
  
  curr := 0;
  max := sourceStream.Size;
  SetTotal(max);
  part := total div 100;
  temp := 0;

  try
    while (curr < max) do begin
      stepReaded := sourceStream.Read(buffer, FILECOPY_BUFFER_SIZE);
      destStream.Write(buffer, stepReaded);
      curr := curr + stepReaded;
      SetCurrent(curr);
      // áóäåì ñîîáùàòü î ïðîãðåññå ïî îêîí÷àíèþ êîïèðîâàíèÿ êàæäîé 100-é ÷àñòè,
      // ÷òîáû íå ïåðåãðóæàòü ïîòîê âûçîâàìè.
      if assigned(CopyFileProgress) then begin
        temp := temp + stepReaded;
        if temp >= part then begin
          temp := temp mod part;
          CopyFileProgress(curr, max);
        end;
      end;
    end;
  finally
    sourceStream.Free;
    destStream.Free;
  end;
  
  CopyResult := true;
  if assigned (CopyFileFinish) then CopyFileFinish(CopyResult);

end;


function TCopyFileThread.GetTotal :Int64;
begin
  totalLock.Acquire;
  try
    Result := _total;
  finally
    totalLock.Release;
  end;
end;

procedure TCopyFileThread.SetTotal(const value :Int64);
begin
  totalLock.Acquire;
  try
    _total := value;
  finally
    totalLock.Release;
  end;
end;

function TCopyFileThread.GetCurrent :Int64;
begin
  curLock.Acquire;
  try
    Result := _current;
  finally
    curLock.Release;
  end;
end;

procedure TCopyFileThread.SetCurrent(const value :Int64);
begin
  curLock.Acquire;
  try
    _current := value;
  finally
    curLock.Release;
  end;
end;

///////////////////////  TFileSystemIterator  & co    /////////////////////////////

// êîíñòðóêòîð
constructor TFileSystemElemInfo.Create(const filePath :AnsiString);
begin
  inherited Create;
  Self.FullPath := filePath;
end;

// êîíñòðóêòîð
constructor TFileSystemElemInfo.Create(const filePath: AnsiString; const searchInfo :TSearchRec);
begin
  Create(AppendPathDelim(filePath) + searchInfo.Name);
  Self.SearchRec := searchInfo;
end;

// âçÿòü àòòðèáóò
function TFileSystemElemInfo.Attributes :Longint;
begin
  // åñëè îïðåäåëåíà ñòðóêòóðà SearchRec
  if (SearchRec.FindHandle = 0) then
    Result := INVALID_SYSFILE_ATTR
  else
    Result := SearchRec.Attr;
end;

// èçâëå÷ü èìÿ èç ïóòè
function TFileSystemElemInfo.Name :AnsiString;
begin
  Result := SearchRec.Name;
  if (Result = '') then
    Result := ExtractFileName(FullPath);
end;

// êîïàåò
function TFileInfo.CopyTo(const path :AnsiString; const overwriteExists :Boolean = false) :Boolean;
begin
  if FileExists(path) then begin
    if overwriteExists then begin
      if not DeleteFile(path) then begin
        Result := false;
        exit;
      end;
    end else begin
      Result := true;
      exit;
    end;
  end;
  {$IFDEF LCL}
  Result := FileUtil.CopyFile(FullPath, path);
  {$ELSE}
  Result := Windows.CopyFile(PChar(FullPath), PChar(path), false);
  {$ENDIF}
end;

// óäàëÿåò
function TFileInfo.Delete :Boolean;
begin
  Result := false;
  if FileExists(FullPath) then
    Result := DeleteFile(FullPath);
end;

// à åñòü ëè ó íàñ òàêîé ôàéë?
function TFileInfo.Exists :Boolean;
begin
  Result := FileExists(FullPath);
end;

// òîæå êîïèðóåò.
function TDirectoryInfo.CopyTo(const path :AnsiString; const overwriteExists :Boolean = false) :Boolean;
begin
  Result := CopyDirectory(FullPath, path, overwriteExists, true);
end;

// óäàëÿåò íàôèã.
function TDirectoryInfo.Delete :Boolean;
begin
  Result := DeleteDirectory(FullPath, false);
end;

// åñòü ëè ïàïêà
function TDirectoryInfo.Exists :Boolean;
begin
  Result := DirectoryExists(FullPath);
end;

// ïîëó÷èòü èòåðàòîð íà ôàéëû âíóòðè ïàïêè
function TDirectoryInfo.GetFiles: TFileSystemIterator;
begin
  Result := GetFiles('*');
end;

// ïîëó÷èòü èòåðåàòîð íà âñå ÷àéëä-ïàïêè
function TDirectoryInfo.GetFiles(const mask :AnsiString) :TFileSystemIterator;
begin
  Result := TFileSystemIterator.Create(FullPath, mask, true);
end;

function TDirectoryInfo.GetDirectories :TFileSystemIterator;
begin
  Result := GetDirectories('*');
end;

function TDirectoryInfo.GetDirectories(const mask :AnsiString) :TFileSystemIterator;
begin
  Result := TFileSystemIterator.Create(FullPath, mask, faDirectory);
end;

//////////////////////////  TTempFolder     ///////////////////////////////
// êîíñòðóêòîð. ñîçäàåò âðåìåííóþ äèðåêòîðèþ
constructor TTempFolder.Create(const subName :AnsiString);
var
  temp :TGUID;
begin
  CreateGUID(temp);
  // ñîáñòâåííî ïóòü ê ïàïêå
  path := AppendPathDelim(GetTempDir) + GUIDToString(temp) + PathDelim;
  ForceDirectories(path + subName);
  name := subName;
end;

// ÷èñòèò çà ñîáîé
destructor  TTempFolder.Destroy;
begin
  inherited;
  DeleteDirectory(path, false);
end;

//ïîëó÷èòü ïóòü ê âðåìåííîé äèðåêòîðèè
function TTempFolder.GetTempPath :AnsiString;
begin
  Result := AppendPathDelim(path + name);
end;

////////////////////////////////////////////////////////////////////////////////
// êîïèðóåò äèðåêòîðèþ
function CopyDirectory(const sourceDir, destDir :AnsiString; const overwriteExists :Boolean = false;
                        const recursive :Boolean = true) :Boolean;
var
  it :TFileSystemIterator;
begin
  Result := false;
  if not DirectoryExists(sourceDir) then begin
    exit;
  end;
  // åñëè destDir åùå íå ñóùåñòâóåò, ñîçäàåì
  if not DirectoryExists(destDir) then ForceDirectories(destDir);
  it := TFileSystemIterator.Create(sourceDir, not recursive);
  try
    while it.Next do begin
      if not it.Current.CopyTo(AppendPathDelim(destDir) + it.Current.Name, overwriteExists) then begin
        exit;
      end;
    end;
    Result := true;
  finally
    it.Free;
  end;
end;

// êîïèðóåò ôàéë â îòäåëüíîì ïîòîê
function AsyncCopyFileEx(const sourcePath, destPath :AnsiString; const onFinish :TCopyFileFinishCallback;
                       const onProgress :TCopyFileProgressCallback; const overwriteExists :Boolean = false) :TThread;
var
  worker :TCopyFileThread;
begin
  worker := TCopyFileThread.Create(sourcePath, destPath, overwriteExists ,true);
  worker.CopyFileProgress := onProgress;
  worker.CopyFileFinish   := onFinish;
  worker.FreeOnTerminate  := true;
  worker.Resume;
  Result := worker;
end;

// êîïèðîâàíèÿ ôàéëà â îòäåëüíîì ïîòîêå
function AsyncCopyFile(const sourcePath, destPath :AnsiString; const onFinish :TCopyFileFinishCallback;
                        const overwriteExists :Boolean = false) :TThread;
begin
  Result := AsyncCopyFileEx(sourcePath, destPath, onFinish, nil, overwriteExists);
end;

function FileSystemElemExists(const path :AnsiString) :Boolean;
begin
  Result := (FileGetAttr(path) <> INVALID_SYSFILE_ATTR);
end;

// à äèðåêòîðèÿ ëè ïî ïåðåäàííîìó ïóòè ?
function IsDirectory(const path :AnsiString) :Boolean;
var
  attr :Longint;
begin
  attr := FileGetAttr(path);
  if attr <> INVALID_SYSFILE_ATTR then begin
    Result := IsDirectory(attr);
  end else
    Result  := false;
end;

// ïðîâåðÿò ÿâëÿåòñÿ ëè ñèñòåìíûé ôàéë äèðåêòîðèåé ïî àòòðèáóòàì
function IsDirectory(const attr :Longint) :Boolean;
begin
  Result := (attr and faDirectory) = faDirectory;
end;


////////////////   èìïîðò èç ExtraFunctionsCLC  ////////////////////////////////
Function IsLocalPath(const PathStr : string) : boolean;
//Âîçâðàùàåò true åñëè ïóòü ëîêàëüíûé, è false åñëè ãëîáàëüíûé.
//Ïîä ëîêàëüíûì ïîíèìàåòñÿ ïóòü íà÷èíàþùèéñÿ ñ òî÷êè.
begin
  Result := false;   //Ïî óìîë÷àíèþ ñ÷èòàåì ÷òî ïóòü ãëîáàëåí.

  if Length(PathStr) >= 1 then begin
    if PathStr[1] = '.' then begin
      Result := true;
    end;
  end;
end;

Function IsGlobalPath(const PathStr : AnsiString) : boolean;
//Âîçâðàùàåò true åñëè ïóòü ãëîáàëüíûé. Ïîä ãëîáàëüíûì ïîíèìàåòñÿ ïóòü,
//íà÷èíàþùèéñÿ íà èìÿ äèñêà (ôóíêöèÿ äëÿ âåíäîâ).
begin
  Result := false;   //Ïî óìîë÷àíèþ ñ÷èòàåì ÷òî ïóòü íå ãëîáàëåí.

  if Length(PathStr) >= 3 then begin
    if PathStr[2]+PathStr[3] = ':\' then begin
      Result := true;
    end;
  end;
end;

Function FixLocalPath(const PathStr : AnsiString) : AnsiString;
//Ïðàâèëüíî îôîðìëÿåò ïðåäïîëîæèòåëüíî ëîêàëüíûé íî íåïðàâèëüíî îôîðìëåííûé
//ïóòü - ÷òîá áûëà òî÷êà â íà÷àëå.
begin
  Result := PathStr;

  if IsLocalPath(Result) = false then begin
    if Length(Result) >= 1 then begin
      if Result[1] <> '\' then begin
        Result := '\'+Result;
      end;
    end
    else begin
      Result := '\'+Result;
    end;
    Result := '.'+Result;
  end;
end;

Function ResolveLocalPath(const LocalPath, GlobalPath : AnsiString) : AnsiString;
//Ïðåâðàòèòü îòíîñèòåëüíûé ïóòü â àáñîëþòíûé. Åñëè îòíîñèòåëüíûé ïóòü çàäàí íåïðàâèëüíî - ïðåäâàðèòåëüíî
//áóäåò ïîôèêñàí. Åñëè îòíîñèòåëüíûé ïóòü íà ñàìîì äåëå àáñîëþòíûé - âåðíåò àáñîëþòíûé ïóòü
//êîòîðûé ÿêîáû îòíîñèòåëüíûé.
var
  TempLocalPath, LocalParsed : AnsiString;
begin
  //Ïðèíöèï äåéñòâèÿ: â îòíîñèòåëüíîì ïóòè ìîãóò áûòü òî÷êè è "äâîåòî÷èÿ".
  //Êîïèðóåì â ðåçóëüòàò àáñîëþòíûé ïóòü, óáèðàåì ïîñëåäíèé ñëåø,
  //è äàëüøå ïàðñèì ëîêàëüíûé ïóòü (ïî ñëåøàì) - âñòðå÷àåì òî÷êó - íè÷Î íå äåëàåì,
  //âñòðå÷àåì äâîåòî÷èå - îòðåçàåì îò ðåçóëüòàòà êóñîê äî ïîñëåäíåãî ñëåøà âêëþ÷èòåëüíî,
  //âñòðå÷àåì ÷òî-òî åùå - äîáàâëÿåì â ðåçóëüòàò ñëåø è êîïèðóåì ïðîïàðñåííîå òóäà æå.
  // èòîãå ïîëó÷àåì àáñîëþòíûé ïóòü.

  //Êîïèðóåì â ðåçóëüòàò àáñîëþòíûé ïóòü, óáèðàåì ïîñëåäíèé ñëåø.
  Result := ChompPathDelim(GlobalPath);
  TempLocalPath := LocalPath;     //Ýòî ÷òîá íå ïîðòèòü ïðèñëàííûé â ôóíêöèþ àðãóìåíò.
  
  //Ïðîâåðÿåì - íàäî ëè ïîôèêñàòü ëîêàëüíûé ïóòü? À åñëè íàäî - òî êàê ðàç ïîôèêñàòü.
  if IsGlobalPath(TempLocalPath) = false then begin
    //Ïóòü íå ãëîáàëåí. Îôîðìëåí ëè îí êàê ëîêàëüíûé?
    if IsLocalPath(TempLocalPath) = false then begin
      //Êàê ëîêàëüíûé òîæå íå îôîðìëåí - îôîðìëÿåì.
      TempLocalPath := FixLocalPath(TempLocalPath);
    end;
  end;
  
  //Òåïåðü - åñëè ëîêàëüíûé ïóòü äåéñòâèòåëüíî ëîêàëüíûé - òî ðàáîòàåì.
  if IsLocalPath(TempLocalPath) = true then begin
    repeat
      //Ïàðñèì...
      LocalParsed := Parse(TempLocalPath,'\');

      //Ñìîòðÿ ÷åãî âûïàðñèëè...
      if (LocalParsed = '.') or (LocalParsed = '') then begin
        //Åñëè òî÷êà ëèáî ïðîñòî ñëåø áåç âñåãî - òî íè÷åãî íå äåëàòü.
      end
      else if LocalParsed = '..' then begin
        //Äâå òî÷êè - ïîäíÿòñÿ íà óðîâåíü âûøå...
        ParseTail(Result,'\');
      end
      else begin
        //Åñëè òàì åùå êàêàÿ-òî ôèãíÿ - òî äîáàâëÿåì åž ê ïóòè...
        Result := Result+'\'+LocalParsed;
      end;

    until TempLocalPath = '';

    //Ãîòîâî. Òåïåðü åñëè â LocalPath â êîíöå áûë ñëåø - äîáàâèì è ê ðåçóëüòàòó...
    if HasLastSlash(LocalPath) = true then begin
      Result := Result+'\';
    end;
  end
  else begin
    //Ëîêàëüíûé ïóòü íà ñàìîì äåëå àáñîëþòíûé - åãî è âîçâðàùàåì.
    Result := TempLocalPath;
  end;

end;

Function GetLocalPath(const GlobalRoot, FullPath : AnsiString): AnsiString;
//Âåðíóòü îòíîñèòåëüíûé ïóòü.
var
  TmpGlobalRoot, TmpFullPath, CommonPart, TempStr : AnsiString;
  Finded : boolean;

begin
  //Åñëè ãëîáàëüíûé êîðíåâîé ïóòü íå âõîäèò â ñîñòàâ ïîëíîãî ïóòè.
  if StrPos(PChar(UpperCase(FullPath)),PChar(DelLastSlash(UpperCase(GlobalRoot)))) = nil then begin

    //Ïðîâåðèòü - ñîâïàäàåò ëè ïåðâûé ýëåìåíò ïóòè äî ïåðâîãî ñëåøà - ïîä âåíäàìè ýòî áóäåò áóêâà äèñêà,
    //ïîä êàêèì íèòü ëèíóõîì â òåîðèè îäèíàêîâàÿ ïóñòàÿ ñòðîêà.
    TmpGlobalRoot := AddLastSlash(GlobalRoot);
    TmpFullPath := AddLastSlash(FullPath);
    if UpperCase(Parse(TmpGlobalRoot,'\')) = UpperCase(Parse(TmpFullPath,'\')) then begin
      //Åñëè "äèñê" îäèí è òîò æå - òîãäà ôîðìèðóåì îòíîñèòåëüíûé ïóòü ñ "äâîåòî÷èÿìè".

      //Èùåì îáùóþ ÷àñòü ïóòè...
      CommonPart := '';
      Finded := false;
      TmpGlobalRoot := DelLastSlash(GlobalRoot);
      TmpFullPath := DelLastSlash(FullPath);
      repeat
        TempStr := Parse(TmpGlobalRoot,'\');
        if UpperCase(TempStr) = UpperCase(Parse(TmpFullPath,'\')) then begin
          //Êóñîê ïóòè ñîâïàäàåò.
          CommonPart := CommonPart+TempStr+'\';
        end
        else begin
          //Íå ñîâïàëî. Äåëàåì îòìåòêó. Ïóòü îñòàåòñÿ ñ ïîñëåäíèì ñëåøåì.
          Finded := true;
        end;
      until Finded = true;

      //Òåðü ãåíåðèì îáðåçêè ïóòåé ÷òîá áûëè áåç îáùåé ÷àñòè...
      TmpGlobalRoot := AddLastSlash(GlobalRoot);
      TmpFullPath := AddLastSlash(FullPath);
      TmpGlobalRoot := DelLastSlash(RightStr(TmpGlobalRoot,Length(TmpGlobalRoot)-Length(CommonPart)));
      TmpFullPath := DelLastSlash(RightStr(TmpFullPath,Length(TmpFullPath)-Length(CommonPart)));
      //Òåïåðü ìîæíî ñãåíåðèòü íà÷àëî ðåçóëüòàòà èç äâîåòî÷èé...
      Result := '';
      repeat
        //Ïàðñèì ïîêà TmpGlobalRoot íå îïóñòååò.
        if Parse(TmpGlobalRoot,'\') <> '' then begin
          //Åñëè åùå ÷åãî-òî ïðîïàðñèëîñü - äîáàâëÿåì äâå òî÷êè...
          Result := Result+'..\';
        end;
      until TmpGlobalRoot = '';
      //Òåïåðü äîáàâëÿåì îáðåçîê ïîëíîãî ïóòè.
      Result := Result+TmpFullPath;
      //Âñå, ìîæíî âûõîäèòü.
      Exit;
    end
    else begin
      //Åñëè "äèñê"-è ðàçíûå - ïðîñòî âîçâðàùàåì ïîëíûé ïóòü
      Result := FullPath;
      Exit;
    end;

  end;

  //Åñëè ó íàñ îäèí è òîò æå ïóòü è òàì è òàì - òî ñðàçó âîçâðàùàåì ./
  if UpperCase(DelLastSlash(GlobalRoot)) = UpperCase(DelLastSlash(FullPath)) then begin
    Result := '.\';
    Exit;
  end;

  //Âçÿòü êîïèþ âõîäíîé èíôû...
  TmpGlobalRoot := AddLastSlash(GlobalRoot);
  TmpFullPath := FullPath;

  TmpFullPath := RightStr(TmpFullPath,Length(TmpFullPath)-Length(TmpGlobalRoot));
  Result := '.\'+TmpFullPath;
end;

Function GetFileSize(const FileName : AnsiString) : Int64;
//Ïîëó÷èòü ðàçìåð ôàéëà.
var
  TheFileStream : TFileStream;
begin
  //Ïî óìîë÷àíèþ âîçâðàùàåì íîëü.
  Result := 0;
  //Åñëè ôàéë ñóùåñòâóåò...
  if FileExists(FileName) = true then begin
    //... òî îòêðûâàåì åãî...
    TheFileStream := TFileStream.Create(FileName,fmOpenRead);
    //... è ïîëó÷àåì ðàçìåð.
    Result := TheFileStream.Size;
    //È çàêðûâàåì ôàéëåã.
    TheFileStream.Free;
  end;
end;

Function GetFilesNumber(const DirName : AnsiString; const Recursive : boolean) : LongInt;
//Ïîäñ÷èòàòü êîëè÷åñòâî ôàéëîâ è ïàïîê â ïàïêå...
var
  SearchRec : TSearchRec;
begin
  Result := 0;

  if FindFirst(AddLastSlash(DirName)+'*', faAnyFile and faDirectory, SearchRec) = 0 then begin
    //Åñëè ïîèñê íà÷àò óñïåøíî - íà÷èíàåì (ðåêóðñèâíî åñëè íàäî) ñ÷èòàòü ñîäåðæèìîå.
    repeat
      if (SearchRec.Name <> '.') and (SearchRec.Name <> '..') then begin
        //×åãî-òî íàøëè.
        Result := Result+1;
        //Writeln(SearchRec.Name);
        if Recursive = true then begin
          //Åñëè íàäî äåéñòâîâàòü ðåêóðñèâíî...
          if (SearchRec.Attr and faDirectory) = faDirectory then begin
            //... è åñëè ýòî äèðåêòîðèÿ - òî ïîäñ÷èòûâàåì ýòó äèðåêòîðèþ.
            Result := Result+GetFilesNumber(AddLastSlash(DirName)+SearchRec.Name, Recursive);
          end;
        end;
      end;;
    until FindNext(SearchRec) <> 0;
    SysUtils.FindClose(SearchRec);
  end;
  //Writeln(IntToStr(Result));

end;

Function IsDirsChild(const DirName, ChildName : AnsiString) : boolean;
//Ïðîâåðèòü - ïðèíàäëåæèò ëè ïóòü ChildName ïóòè DirName.
var
  TempStr : AnsiString;
begin
  //Èíèöèàëèçàöèÿ.
  Result := false;     //Èçíà÷àëüíî ïóòü íå ñ÷èòàåòñÿ child-îì

  //Ïîëó÷åíèå "ëîêàëüíîãî ïóòè".
  TempStr := GetLocalPath(DirName,ChildName);
  //Ïðîâåðêà - åñòü ëè òàì ".\"
  if Length(TempStr) > 1 then begin
    //Òîëüêî åñëè èñêîìîå ìîãëî ïîìåñòèòüñÿ â ñòðîêó.
    if TempStr[1]+TempStr[2] = '.\' then begin
      //Èçó÷àåìûé ïóòü ÿâëÿåòñÿ child-îì DirName
      Result := true;
    end;
  end;
end;

// äîáàëÿåò ðàñøèðåíèå åñëè åãî åùå íåò.
function AddExtensionIfAbsent(const path, extension :String) :String;
var
  ex :AnsiString;
begin
  Result := path;
  ex := ExtractFileExt(path);
  if (ex = '') then begin
    Result := path + extension;
  end;
end;

// ÷èñòîå èìÿ ôàéëà, áåç ðàñøèðåíèÿ
function GetFileNameWithoutExtension(const path :String) :String;
var
  fileName :String;
  i        :Integer;
begin
  fileName := ExtractFileName(path);
  i := Length(FileName);
  while (i > 0) and (FileName[i] <> '.') do Dec(i);

  if (i > 0) then
    Result := Copy(FileName, 1, i - 1)
  else
    Result := fileName;
end;

Function HasLastSlash(const Str : string) : boolean;
//Ôóíêà äëÿ ïðîâåðêè íàëè÷èÿ ïîñëåäíåãî ñëýøà.
var
  I : integer;
  LastCh : char;
begin
  if Length(Str) > 0 then begin
    //Ñìûñë ÷òî-òî ïðîâåðÿòü åñòü òîëüêî åñëè ñòðîêà íå ïóñòà.
    I := 0;
    LastCh := #0;
    repeat
      I := I+1;
      If str[I] <> #0 then begin
        LastCh := str[I];
      end;
    until str[I] = #0;
    //Åñëè ïîñëåäíèé ñèìâîë ñëýø òî ðåçóëò òðó, èíà÷å ôàëñ:
    If LastCh = '\' then result := true
    else result := false;
  end
  else begin
    //À åñëè ñòðîêà ïóñòà - òî îíî âñåãäà ôàëñå.
    Result := false;
  end;
end;

Function AddLastSlash(const str : string): string;
//Ôóíêà äëÿ äîáàâëåíèÿ â ïóòü ïîñëåäíåãî ñëýøà (åñëè íàäî).
begin
  //Åñëè ïîñëåäíèé ñèìâîë íå ñëýø - òî ïðèïëþñîâàòèòü åãî òóäû.
  If HasLastSlash(str) = false then result := str+'\'
  else result := str;
end;

Function DelLastSlash(const Str : string) : string;
//Óäàëÿåò ïîñëåäíèé ñëåø åñëè îí åñòü.
begin
  Result := '';
  if HasLastSlash(Str) = true then begin
    SetLength(Result,Length(Str)-1);
    CopyMemory(@Result[1],@Str[1],Length(Str)-1);
  end
  else begin
    Result := Str;
  end;
end;

end.