www.pudn.com > lzss.rar > LZEXPLIC.PAS
{$I LZDefine.inc}
unit LZExplic;
{ sample "explicit" or "dynamic" import unit for ChiefLZ.dll ... }
interface
uses
{$ifdef Win32}
Windows,
SysUtils,
LZ_Link,
{$else Win32}
{$ifdef dpmi}
WinAPI,
{$else dpmi}
WinTypes,
WinProcs,
{$endif dpmi}
{$ifdef Delphi}
Messages,
SysUtils,
{$else Delphi}
{$ifndef dpmi}
Win31,
{$endif dpmi}
Strings,
{$endif Delphi}
{$endif Win32}
ChfTypes,
ChfUtils;
{exported functions}
VAR IsChiefLZArchive: Function(const fName: {$ifdef Win32} string
{$else} PChar
{$endif} ): boolean;
{$ifdef Win32} stdcall; {$endif Win32}
{$ifdef Win32}
VAR GetChiefLZFileName: Function(const fName: string): string;
stdcall;
{$else}
VAR GetChiefLZFileName: Function(fName, Dest:PChar): boolean;
{$endif Win32}
VAR GetChiefLZFileSize: Function(fName: {$ifdef Win32} string
{$else} PChar
{$endif}): LongInt;
{$ifdef Win32} stdcall; {$endif Win32}
VAR GetChiefLZArchiveInfo: Function(const ArchName: {$ifdef Win32} string;
{$else Win32} PChar;
{$endif Win32}
var Header: TChiefLZArchiveHeader): boolean;
{$ifdef Win32} stdcall; {$endif Win32}
VAR GetChiefLZArchiveSize: Function(const ArchName: {$ifdef Win32} string
{$else Win32} PChar
{$endif Win32}): LongInt;
{$ifdef Win32} stdcall; {$endif Win32}
VAR LZCompress: Function(const {$ifdef Win32} Source, Dest: string
{$else} aSource, aDest: pChar
{$endif};
LZQuestion: TLZQuestionFunc;
aProc: TLZReportProc): LongInt;
{$ifdef Win32} stdcall; {$endif Win32}
VAR LZDecompress: Function({$ifdef Win32} Source, Dest: string
{$else} const aSource, aDest: PChar
{$endif};
LZQuestion: TLZQuestionFunc;
aProc: TLZReportProc): LongInt;
{$ifdef Win32} stdcall; {$endif Win32}
VAR IsChiefLZFile: Function(const fName: {$ifdef Win32} string
{$else} PChar
{$endif}): boolean;
{$ifdef Win32} stdcall; {$endif Win32}
VAR LZArchive: Function(const fSpec, ArchName: {$ifdef Win32} string
{$else} PChar
{$endif};
LZRecurseDirs: TLZRecurse;
aProc: TLZReportProc): LongInt;
{$ifdef Win32} stdcall; {$endif Win32}
VAR LZDearchive: Function(ArchName: {$ifdef Win32} string
{$else} PChar
{$endif};
{$ifdef Win32} DefDir: string
{$else} const aDefDir: PChar
{$endif};
LZQuestion: TLZQuestionFunc;
aProc: TLZReportProc;
aRename: TLZRenameFunc): LongInt;
{$ifdef Win32} stdcall; {$endif Win32}
VAR LZCompressEx: Function(const {$ifdef Win32} Name: string
{$else} aName: PChar
{$endif};
ReplaceQuestion: TLZQuestionFunc;
aProc: TLZReportProc): LongInt;
{$ifdef Win32} stdcall; {$endif Win32}
VAR LZDecompressEx: Function({$ifdef Win32} Name: string
{$else} aName: PChar
{$endif};
ReplaceQuestion: TLZQuestionFunc;
aProc: TLZReportProc): LongInt;
{$ifdef Win32} stdcall; {$endif Win32}
VAR GetLZMarkerChar: Function: Char; {$ifdef Win32} stdcall; {$endif}
VAR SetLZMarkerChar: Procedure(const NewChar: Char);
{$ifdef Win32} stdcall; {$endif}
VAR ChiefLZDLLVersion: Function: Integer; {$ifdef Win32} stdcall; {$endif}
Var GetFullLZName: Function(Const X: TChiefLZArchiveHeader;
Index: Integer): String;
{$ifdef Win32} stdcall; {$endif}
Function LoadChiefLZDLL(DLLName: PChar): {$ifdef Win32} BOOL {$else} Integer {$endif};
{load the ChiefLZ DLL - Win16 returns 0 if successful,
and something else if not successful
- Win32 returns True if successful and False otherwise
If False, the error code is obtained by calling
GetLastError()
- you can supply a new DLL name to use instead of
the default "ChiefLZ.DLL".
Call this first, before doing anything}
Function UnloadChiefLZDLL: {$ifdef Win32} BOOL {$else} Boolean {$endif};
{unload the DLL - call this last, after doing the LZ functions}
Function GetChiefLZDLLHandle: THandle;
{return the value of the ChiefLZDLLHandle}
implementation
{$ifdef Win32}
Var
{$else Win32}
Const
{$endif Win32}
ChiefLZDLLHandle: THandle = 0;
{$ifdef Win32}
Var
{$else Win32}
Const
{$endif Win32}
ChiefLZDLLDefaultName: PChar = 'ChiefLZ.DLL'; {DLL Name}
{ This is the default in the DLL "load" function; we will use this pointer
if no other is passed in LoadChiefLZDLL() }
{/////////////////////////////////////////////}
{$ifdef Win32}
function LoadChiefLZProc(var FuncAddr: Pointer;
const FuncIndex: Integer): boolean;
var
LocalAddr: Pointer;
begin
LocalAddr := GetProcAddress(ChiefLZDLLHandle, Ptr(FuncIndex));
Result := LocalAddr <> nil;
if Result then
FuncAddr := LocalAddr
end;
{$endif Win32}
{/////////////////////////////////////////////}
{/////////////////////////////////////////////}
Function LoadChiefLZDLL(DLLName: PChar): {$ifdef Win32} BOOL {$else} Integer {$endif};
{$ifndef DPMI}
Var
OldWError: THandle;
{$endif DPMI}
Begin
{see if we supplied another DLL name; use default if we didn't ...}
if StrLen(DLLName) = 0 then
DLLName := ChiefLZDLLDefaultName;
{$ifdef Win32}
{
First check that a DLL hasn't already been loaded ... There is no
guarantee that the existing DLL is the same as DLLName, and loading
library DLLName will destroy ChiefLZDLLHandle ...
}
if ChiefLZDLLHandle <> 0 then
RaiseError(EChiefLZDLL,SDLLReadyLoaded);
{
Load DLL, putting Windows handle in ChiefLZDLLHandle ...
}
OldWError := SetErrorMode(sem_NoOpenFileErrorBox);
ChiefLZDLLHandle := LoadLibrary(DLLName);
SetErrorMode(OldWError);
if ChiefLZDLLHandle = 0 then
Result := False // Load failed
else
{
Loaded successfully: put the addresses of the DLL functions into
procedural and functional variables ...
}
begin
Result := LoadChiefLZProc(@LZCompress, 1) and
LoadChiefLZProc(@LZDecompress, 2) and
LoadChiefLZProc(@IsChiefLZFile, 3) and
LoadChiefLZProc(@LZArchive, 4) and
LoadChiefLZProc(@LZDearchive, 5) and
LoadChiefLZProc(@IsChiefLZArchive, 6) and
LoadChiefLZProc(@GetChiefLZFileName, 7) and
LoadChiefLZProc(@GetChiefLZFileSize, 8) and
LoadChiefLZProc(@GetChiefLZArchiveInfo, 9) and
LoadChiefLZProc(@LZCompressEx, 10) and
LoadChiefLZProc(@LZDecompressEx, 11) and
LoadChiefLZProc(@GetLZMarkerChar, 12) and
LoadChiefLZProc(@SetLZMarkerChar, 13) and
LoadChiefLZProc(@GetFullLZName, 14) and
LoadChiefLZProc(@ChiefLZDLLVersion, 15) and
LoadChiefLZProc(@GetChiefLZArchiveSize, 16);
if not Result then
UnloadChiefLZDLL // At least one load failed: backtrack out...
end
{$else Win32}
LoadChiefLZDLL := -1; {DLL can't be loaded}
{$ifndef DPMI}
OldWError := SetErrorMode(sem_NoOpenFileErrorBox);
{$endif DPMI}
{v1.01 - fixed bug on next line}
ChiefLZDLLHandle := LoadLibrary(DLLName);
{$ifndef DPMI}
SetErrorMode(OldWError);
{$endif DPMI}
If ChiefLZDLLHandle <= 32 then Exit;
LoadChiefLZDLL := -2; {undefined dyna-link}
@LZCompress := GetProcAddress(ChiefLZDLLHandle, 'LZCompress');
@LZDecompress := GetProcAddress(ChiefLZDLLHandle, 'LZDecompress');
@IsChiefLZFile := GetProcAddress(ChiefLZDLLHandle, 'IsChiefLZFile');
@LZArchive := GetProcAddress(ChiefLZDLLHandle, 'LZArchive');
@LZDeArchive := GetProcAddress(ChiefLZDLLHandle, 'LZDearchive');
@IsChiefLZArchive := GetProcAddress(ChiefLZDLLHandle, 'IsChiefLZArchive');
@GetChiefLZFileName:= GetProcAddress(ChiefLZDLLHandle, 'GetChiefLZFileName');
@GetChiefLZFileSize:= GetProcAddress(ChiefLZDLLHandle, 'GetChiefLZFileSize');
@GetChiefLZArchiveInfo:= GetProcAddress(ChiefLZDLLHandle, 'GetChiefLZArchiveInfo');
@LZCompressEx := GetProcAddress(ChiefLZDLLHandle, 'LZCompressEx');
@LZDeCompressEx := GetProcAddress(ChiefLZDLLHandle, 'LZDecompressEx');
@GetLZMarkerChar := GetProcAddress(ChiefLZDLLHandle, 'GetLZMarkerChar');
@SetLZMarkerChar := GetProcAddress(ChiefLZDLLHandle, 'SetLZMarkerChar');
@GetFullLZName := GetProcAddress(ChiefLZDLLHandle, 'GetFullLZName');
@ChiefLZDLLVersion := GetProcAddress(ChiefLZDLLHandle, 'ChiefLZDLLVersion');
@GetChiefLZArchiveSize := GetProcAddress(ChiefLZDLLHandle, 'GetChiefLZArchiveSize');
If (@LZCompress = Nil)
or (@LZDecompress = Nil)
or (@IsChiefLZFile = Nil)
or (@LZArchive = Nil)
or (@LZDeArchive = Nil)
or (@IsChiefLZArchive = Nil)
or (@GetChiefLZFileName = Nil)
or (@GetChiefLZFileSize = Nil)
or (@GetChiefLZArchiveInfo = Nil)
or (@LZCompressEx = Nil)
or (@LZDeCompressEx = Nil)
or (@GetLZMarkerChar = Nil)
or (@SetLZMarkerChar = Nil)
or (@GetFullLZName = Nil)
or (@ChiefLZDLLVersion = Nil)
or (@GetChiefLZArchiveSize = Nil)
then begin
FreeLibrary(ChiefLZDLLHandle);
ChiefLZDLLHandle := 0;
Exit;
end;
LoadChiefLZDLL := 0; {success}
{$endif Win32}
End;
{/////////////////////////////////////////////}
{$ifdef Win32}
Function UnloadChiefLZDLL: BOOL;
Begin
{
Make sure the DLL has been loaded first ...
}
if ChiefLZDLLHandle = 0 then
Result := True // DLL is (was already) unloaded
else
{
WAS loaded: now to unload ...
}
begin
Result := FreeLibrary(ChiefLZDLLHandle);
if Result then
ChiefLZDLLHandle := 0 // Success
end
End;
{$else Win32}
Function UnloadChiefLZDLL: Boolean;
Begin
UnloadChiefLZDLL := False; {invalid handle}
If ChiefLZDLLHandle > 32
then begin
FreeLibrary(ChiefLZDLLHandle);
UnloadChiefLZDLL := True;
end;
ChiefLZDLLHandle := 0;
End;
{$endif Win32}
{/////////////////////////////////////////////}
Function GetChiefLZDLLHandle: THandle;
{return the value of the ChiefLZDLLHandle}
Begin
GetChiefLZDLLHandle := ChiefLZDLLHandle
End;
{/////////////////////////////////////////////}
{/////////////////////////////////////////////}
{/////////////////////////////////////////////}
{/////////////////////////////////////////////}
{/////////////////////////////////////////////}
End.