restemplate/indy/Protocols/IdZLibHeaders.pas

unit IdZLibHeaders;

{
 zlibpas -- Pascal interface to the zlib data compression library
 * Gabriel Corneanu (gabrielcorneanu(AT)yahoo.com)
       Derived from original sources by Bob Dellaca and Cosmin Truta.
   - TZStreamType
   - deflateInitEx
   - inflateInitEx
*}
{
JPM - note that I made dynamic loading for FreePascal (since that still may not
suppport external .obj files properly.  It also makes it easier to support several
different platforms in one file.
}

interface

{$I IdCompilerDefines.inc}

{$WRITEABLECONST OFF}
{
TODO:  Wait for Emb to decide how to approach ZLib for their 64-bit support
before we proceed at our end.
}
{$UNDEF STATICLOAD_ZLIB}
{$UNDEF STATIC_CDECL_PROCS}
{$IFDEF DCC}
  {$IFDEF WIN32}
{
For Win32, we use some .obj files.  These .objs were compiled from the ZLib
source-code folder with "make -f contrib\delphi\zlibd32.mak" using Borland's
"make" and "bcc32".  The .objs are compiled with the
"-DZEXPORT=__fastcall -DZEXPORTVA=__cdecl"  parameter.  Do NOT change
the function calling conventions unless you know what you are doing and
the C++ objects are compiled appropriately.

The only things that still are cdecl are the callback functions.
}
    {$IFNDEF BCB5_DUMMY_BUILD}
      {$DEFINE STATICLOAD_ZLIB}
      {$IFDEF VCL_XE2_OR_ABOVE}
        {$DEFINE STATIC_CDECL_PROCS}
      {$ENDIF}
    {$ENDIF}
    {$ALIGN OFF}
  {$ENDIF}
  {$IFDEF WIN64}
    {$ALIGN ON}
    {$MINENUMSIZE 4}
    {$IFNDEF BCB5_DUMMY_BUILD}
      {$DEFINE STATICLOAD_ZLIB}
    {$ENDIF}
  {$ENDIF}
{$ELSE}
  {$packrecords C}
{$ENDIF}

uses
  //reference off_t
  {$IFDEF KYLIXCOMPAT}
  libc,
  {$ENDIF}
  {$IFDEF USE_VCL_POSIX}
  Posix.SysTypes,
  {$ENDIF}
  {$IFDEF USE_BASEUNIX}
  baseunix,
  {$ENDIF}
  IdGlobal, IdCTypes
  {$IFNDEF STATICLOAD_ZLIB}
  , IdException
  {$ENDIF};

{$IFDEF STATICLOAD_ZLIB}
(*$HPPEMIT '// For Win32, we use some .obj files.  These .objs were compiled from the ZLib'*)
(*$HPPEMIT '// source-code folder with "make -f contrib\delphi\zlibd32.mak" using Borland's'*)
(*$HPPEMIT '// "make" and "bcc32".  The .objs are compiled with the'*)
(*$HPPEMIT '// "-DZEXPORT=__fastcall -DZEXPORTVA=__cdecl"  parameter.  Do NOT change'*)
(*$HPPEMIT '// the function calling conventions unless you know what you are doing and'*)
(*$HPPEMIT '// the C++ objects are compiled appropriately.'*)
(*$HPPEMIT '//'*)
(*$HPPEMIT '// The only things that still are cdecl are the callback functions.'*)
(*$HPPEMIT ''*)
  {$IFDEF STATIC_CDECL_PROCS}
(*$HPPEMIT '#define ZEXPORT __cdecl'*)
  {$ELSE}
(*$HPPEMIT '#define ZEXPORT __fastcall'*)
  {$ENDIF}
{$ELSE}
(*$HPPEMIT '#define ZEXPORT __cdecl'*)
{$ENDIF}
(*$HPPEMIT '#define ZEXPORTVA __cdecl'*)
(*$HPPEMIT '#if !defined(__MACTYPES__)'*)
(*$HPPEMIT '  // We are defining __MACTYPES__ in order to skip the declaration of "Byte" as it causes'*)
(*$HPPEMIT '  // ambiguity with System::Byte'*)
(*$HPPEMIT '  #define __MACTYPES__'*)
(*$HPPEMIT '  #define __REMOVE_MACTYPES__'*)
(*$HPPEMIT '#endif'*)
(*$HPPEMIT '#if defined(__USE_ZLIBH__)'*)
(*$HPPEMIT '  #include "ZLib\zlib.h"'*)
(*$HPPEMIT '#else'*)
(*$HPPEMIT 'typedef void * __cdecl (*alloc_func)(void * opaque, unsigned items, unsigned size);'*)
(*$HPPEMIT ''*)
(*$HPPEMIT 'typedef void __cdecl (*free_func)(void * opaque, void * address);'*)
(*$HPPEMIT ''*)
(*$HPPEMIT '#pragma pack(push,1)'*)
{$IFDEF VCL_XE_OR_ABOVE}
(*$HPPEMIT 'struct DECLSPEC_DRECORD z_stream'*)
{$ELSE}
(*$HPPEMIT 'struct z_stream'*)
{$ENDIF}
(*$HPPEMIT '{'*)
(*$HPPEMIT '	'*)
(*$HPPEMIT 'public:'*)
(*$HPPEMIT '	char *next_in;'*)
(*$HPPEMIT '	unsigned avail_in;'*)
(*$HPPEMIT '	unsigned total_in;'*)
(*$HPPEMIT '	char *next_out;'*)
(*$HPPEMIT '	unsigned avail_out;'*)
(*$HPPEMIT '	unsigned total_out;'*)
(*$HPPEMIT '	char *msg;'*)
(*$HPPEMIT '	void *state;'*)
(*$HPPEMIT '	alloc_func zalloc;'*)
(*$HPPEMIT '	free_func zfree;'*)
(*$HPPEMIT '	void *opaque;'*)
(*$HPPEMIT '	int data_type;'*)
(*$HPPEMIT '	unsigned adler;'*)
(*$HPPEMIT '	unsigned reserved;'*)
(*$HPPEMIT '};'*)
(*$HPPEMIT '#pragma pack(pop)'*)
(*$HPPEMIT ''*)
(*$HPPEMIT '#if !defined(__clang__) && !defined(__CPP__)'*)
(*$HPPEMIT '#if sizeof(z_stream) < 56'*)
(*$HPPEMIT '#pragma message "Pascal/C++ size mismatch: (C++) sizeof(z_stream) < (Pascal) [size: 56, align: 1] (WARNING)"'*)
(*$HPPEMIT '#pragma sizeof(z_stream)'*)
(*$HPPEMIT '#endif'*)
(*$HPPEMIT ''*)
(*$HPPEMIT '#if sizeof(z_stream) > 56'*)
(*$HPPEMIT '#pragma message "Pascal/C++ size mismatch: (C++) sizeof(z_stream) > (Pascal) [size: 56, align: 1] (WARNING)"'*)
(*$HPPEMIT '#pragma sizeof(z_stream)'*)
(*$HPPEMIT '#endif'*)
(*$HPPEMIT ''*)
(*$HPPEMIT '#if alignof(z_stream) < 1'*)
(*$HPPEMIT '#pragma message "Pascal/C++ alignment mismatch: (C++) alignof(z_stream) < (Pascal) [size: 56, align: 1] (WARNING)"'*)
(*$HPPEMIT '#endif'*)
(*$HPPEMIT ''*)
(*$HPPEMIT '#if alignof(z_stream) > 1'*)
(*$HPPEMIT '#pragma message "Pascal/C++ alignment mismatch: (C++) alignof(z_stream) > (Pascal) [size: 56, align: 1] (WARNING)"'*)
(*$HPPEMIT '#endif'*)
(*$HPPEMIT '#endif'*)
(*$HPPEMIT ''*)
(*$HPPEMIT ''*)
(*$HPPEMIT 'struct gz_header;'*)
(*$HPPEMIT 'typedef gz_header *gz_headerp;'*)
(*$HPPEMIT ''*)
(*$HPPEMIT '#pragma pack(push,1)'*)
{$IFDEF VCL_XE_OR_ABOVE}
(*$HPPEMIT 'struct DECLSPEC_DRECORD gz_header'*)
{$ELSE}
(*$HPPEMIT 'struct gz_header'*)
{$ENDIF}
(*$HPPEMIT '{'*)
(*$HPPEMIT '	'*)
(*$HPPEMIT 'public:'*)
(*$HPPEMIT '	int text;'*)
(*$HPPEMIT '	unsigned time;'*)
(*$HPPEMIT '	int xflags;'*)
(*$HPPEMIT '	int os;'*)
(*$HPPEMIT '	System::Byte *extra;'*)
(*$HPPEMIT '	unsigned extra_len;'*)
(*$HPPEMIT '	unsigned extra_max;'*)
(*$HPPEMIT '	char *name;'*)
(*$HPPEMIT '	unsigned name_max;'*)
(*$HPPEMIT '	char *comment;'*)
(*$HPPEMIT '	unsigned comm_max;'*)
(*$HPPEMIT '	int hcrc;'*)
(*$HPPEMIT '	int done;'*)
(*$HPPEMIT '};'*)
(*$HPPEMIT '#pragma pack(pop)'*)
(*$HPPEMIT ''*)
(*$HPPEMIT '#if !defined(__clang__) && !defined(__CPP__)'*)
(*$HPPEMIT '#if sizeof(gz_header) < 52'*)
(*$HPPEMIT '#pragma message "Pascal/C++ size mismatch: (C++) sizeof(gz_header) < (Pascal) [size: 52, align: 1] (WARNING)"'*)
(*$HPPEMIT '#pragma sizeof(gz_header)'*)
(*$HPPEMIT '#endif'*)
(*$HPPEMIT ''*)
(*$HPPEMIT '#if sizeof(gz_header) > 52'*)
(*$HPPEMIT '#pragma message "Pascal/C++ size mismatch: (C++) sizeof(gz_header) > (Pascal) [size: 52, align: 1] (WARNING)"'*)
(*$HPPEMIT '#pragma sizeof(gz_header)'*)
(*$HPPEMIT '#endif'*)
(*$HPPEMIT ''*)
(*$HPPEMIT '#if alignof(gz_header) < 1'*)
(*$HPPEMIT '#pragma message "Pascal/C++ alignment mismatch: (C++) alignof(gz_header) < (Pascal) [size: 52, align: 1] (WARNING)"'*)
(*$HPPEMIT '#endif'*)
(*$HPPEMIT ''*)
(*$HPPEMIT '#if alignof(gz_header) > 1'*)
(*$HPPEMIT '#pragma message "Pascal/C++ alignment mismatch: (C++) alignof(gz_header) > (Pascal) [size: 52, align: 1] (WARNING)"'*)
(*$HPPEMIT '#endif'*)
(*$HPPEMIT '#endif'*)
(*$HPPEMIT '#endif'*)
(*$HPPEMIT '#if defined(__REMOVE_MACTYPES__)'*)
(*$HPPEMIT '  // Cleanup workaround for "Byte" ambiguity'*)
(*$HPPEMIT '  #if defined(__MACTYPES__)'*)
(*$HPPEMIT '    #undef __MACTYPES__'*)
(*$HPPEMIT '  #endif'*)
(*$HPPEMIT '  #undef __REMOVE_MACTYPES__'*)
(*$HPPEMIT '#endif'*)

const
  {$EXTERNALSYM ZLIB_VERSION}
  ZLIB_VERSION = '1.2.5';
  {$EXTERNALSYM ZLIB_VERNUM}
  ZLIB_VERNUM = $1250;
  {$EXTERNALSYM ZLIB_VER_MAJOR}
  ZLIB_VER_MAJOR = 1;
  {$EXTERNALSYM ZLIB_VER_MINOR}
  ZLIB_VER_MINOR = 2;
  {$EXTERNALSYM ZLIB_VER_REVISION}
  ZLIB_VER_REVISION = 5;
  {$EXTERNALSYM ZLIB_VER_SUBREVISION}
  ZLIB_VER_SUBREVISION = 0;

type
{JPM - I made some types from our old header to the new C types defined originally
 for compatability.}
  {$EXTERNALSYM z_off_t}
  {$IFDEF USE_VCL_POSIX}
  z_off_t = off_t;
  {$ENDIF}
  {$IFDEF KYLIXCOMPAT}
  z_off_t = off_t;
  {$ENDIF}
  {$IFDEF USE_BASEUNIX}
  z_off_t = off_t;
  {$ENDIF}
  {$IFDEF WINDOWS}
  z_off_t = TIdC_LONG;
  {$ENDIF}

  {$EXTERNALSYM alloc_func}
  alloc_func = function(opaque: Pointer; items, size: TIdC_UINT): Pointer;  cdecl;
  {$EXTERNALSYM TAlloc}
  TAlloc     = alloc_func;
  {$EXTERNALSYM free_func}
  free_func  = procedure(opaque, address: Pointer); cdecl;
  {$EXTERNALSYM TFree}
  TFree      = free_func;
  {$EXTERNALSYM in_func}
  in_func    = function(opaque: Pointer; var buf: PByte): TIdC_UNSIGNED; cdecl;
  {$EXTERNALSYM TInFunc}
  TInFunc    = in_func;
  {$EXTERNALSYM out_func}
  out_func   = function(opaque: Pointer; buf: PByte; size: TIdC_UNSIGNED): TIdC_INT; cdecl;
  {$EXTERNALSYM TOutFunc}
  TOutFunc   = out_func;
  {$EXTERNALSYM z_streamp}
  z_streamp = ^z_stream;
  {$EXTERNALSYM z_stream}
  z_stream = record
    next_in: PIdAnsiChar;     (* next input byte *)
    avail_in: TIdC_UINT;    (* number of bytes available at next_in *)
    total_in: TIdC_ULONG;    (* total nb of input bytes read so far *)

    next_out: PIdAnsiChar;    (* next output byte should be put there *)
    avail_out: TIdC_UINT;   (* remaining free space at next_out *)
    total_out: TIdC_ULONG;   (* total nb of bytes output so far *)

    msg: PIdAnsiChar;         (* last error message, NULL if no error *)
    state: Pointer;       (* not visible by applications *)

    zalloc: alloc_func;   (* used to allocate the internal state *)
    zfree: free_func;     (* used to free the internal state *)
    opaque: Pointer;      (* private data object passed to zalloc and zfree *)

    data_type: TIdC_INT;   (* best guess about the data type: ascii or binary *)
    adler: TIdC_ULONG;       (* adler32 value of the uncompressed data *)
    reserved: TIdC_ULONG;    (* reserved for future use *)
  end;
  {$EXTERNALSYM TZStreamRec}
  TZStreamRec = z_stream;
  {$EXTERNALSYM PZStreamRec}
  PZStreamRec = z_streamp;

(*
  gzip header information passed to and from zlib routines.  See RFC 1952
  for more details on the meanings of these fields.
*)
  {$EXTERNALSYM gz_headerp}
  gz_headerp = ^gz_header;
  {$EXTERNALSYM gz_header}
  gz_header = record
    text       : TIdC_INT;   //* true if compressed data believed to be text */
    time       : TIdC_ULONG;  //* modification time */
    xflags     : TIdC_INT;   //* extra flags (not used when writing a gzip file) */
    os         : TIdC_INT;   //* operating system */
    extra      : PByte;     //* pointer to extra field or Z_NULL if none */
    extra_len  : TIdC_UINT;  //* extra field length (valid if extra != Z_NULL) */
    extra_max  : TIdC_UINT;  //* space at extra (only when reading header) */
    name       : PIdAnsiChar;   //* pointer to zero-terminated file name or Z_NULL */
    name_max   : TIdC_UINT;  //* space at name (only when reading header) */
    comment    : PIdAnsiChar;   //* pointer to zero-terminated comment or Z_NULL */
    comm_max   : TIdC_UINT;  //* space at comment (only when reading header) */
    hcrc       : TIdC_INT;   //* true if there was or will be a header crc */
    done       : TIdC_INT;   //* true when done reading gzip header (not used when writing a gzip file) */
  end;
  {$EXTERNALSYM PgzHeaderRec}
  PgzHeaderRec = gz_headerp;
  {$EXTERNALSYM TgzHeaderRec}
  TgzHeaderRec = gz_header;

type
  TZStreamType = (
    zsZLib,  //standard zlib stream
    zsGZip,  //gzip stream
    zsRaw);  //raw stream (without any header)

(* constants *)
const
  Z_NO_FLUSH      = 0;
  {$EXTERNALSYM Z_NO_FLUSH}
  Z_PARTIAL_FLUSH = 1;
  {$EXTERNALSYM Z_PARTIAL_FLUSH}
  Z_SYNC_FLUSH    = 2;
  {$EXTERNALSYM Z_SYNC_FLUSH}
  Z_FULL_FLUSH    = 3;
  {$EXTERNALSYM Z_FULL_FLUSH}
  Z_FINISH        = 4;
  {$EXTERNALSYM Z_FINISH}
  Z_BLOCK         = 5;
  {$EXTERNALSYM Z_BLOCK}
  Z_TREES         = 6;
  {$EXTERNALSYM Z_TREES}
  Z_OK            =  0;
  {$EXTERNALSYM Z_OK}
  Z_STREAM_END    =  1;
  {$EXTERNALSYM Z_STREAM_END}
  Z_NEED_DICT     =  2;
  {$EXTERNALSYM Z_NEED_DICT}
  Z_ERRNO         = -1;
  {$EXTERNALSYM Z_ERRNO}
  Z_STREAM_ERROR  = -2;
  {$EXTERNALSYM Z_STREAM_ERROR}
  Z_DATA_ERROR    = -3;
  {$EXTERNALSYM Z_DATA_ERROR}
  Z_MEM_ERROR     = -4;
  {$EXTERNALSYM Z_MEM_ERROR}
  Z_BUF_ERROR     = -5;
  {$EXTERNALSYM Z_BUF_ERROR}
  Z_VERSION_ERROR = -6;
  {$EXTERNALSYM Z_VERSION_ERROR}

  Z_NO_COMPRESSION       =  0;
  {$EXTERNALSYM Z_NO_COMPRESSION}
  Z_BEST_SPEED           =  1;
  {$EXTERNALSYM Z_BEST_SPEED}
  Z_BEST_COMPRESSION     =  9;
  {$EXTERNALSYM Z_BEST_COMPRESSION}
  Z_DEFAULT_COMPRESSION  = -1;
  {$EXTERNALSYM Z_DEFAULT_COMPRESSION}

  Z_FILTERED            = 1;
  {$EXTERNALSYM Z_FILTERED}
  Z_HUFFMAN_ONLY        = 2;
  {$EXTERNALSYM Z_HUFFMAN_ONLY}
  Z_RLE                 = 3;
  {$EXTERNALSYM Z_RLE}
  Z_DEFAULT_STRATEGY    = 0;
  {$EXTERNALSYM Z_DEFAULT_STRATEGY}

  Z_BINARY   = 0;
  {$EXTERNALSYM Z_BINARY}
  Z_TEXT     = 1;
  {$EXTERNALSYM Z_TEXT}
  Z_ASCII    = Z_TEXT;   //* for compatibility with 1.2.2 and earlier */
  {$EXTERNALSYM Z_ASCII}
  Z_UNKNOWN  = 2;
  {$EXTERNALSYM Z_UNKNOWN}

  Z_DEFLATED = 8;
  {$EXTERNALSYM Z_DEFLATED}
  Z_NULL = 0;  //* for initializing zalloc, zfree, opaque */
  {$EXTERNALSYM Z_NULL}

  MAX_WBITS = 15; { 32K LZ77 window }
  {$EXTERNALSYM MAX_WBITS}

  MAX_MEM_LEVEL = 9;
  {$EXTERNALSYM MAX_MEM_LEVEL}
  DEF_MEM_LEVEL = 8; { if MAX_MEM_LEVEL > 8 }
  {$EXTERNALSYM DEF_MEM_LEVEL}

{$EXTERNALSYM inflateInit}
function inflateInit(var strm: z_stream): TIdC_INT;
{$IFDEF USE_INLINE} inline; {$ENDIF}

{$EXTERNALSYM inflateBackInit}
function inflateBackInit(var strm: z_stream;
                         windowBits: TIdC_INT; window: PIdAnsiChar): TIdC_INT;
{$IFDEF USE_INLINE} inline; {$ENDIF}

{$EXTERNALSYM inflateInit2}
function inflateInit2(var strm: z_stream; windowBits: TIdC_INT): TIdC_INT;
{$IFDEF USE_INLINE} inline; {$ENDIF}

{$EXTERNALSYM deflateInit}
function deflateInit(var strm: z_stream; level: TIdC_INT): TIdC_INT;
{$IFDEF USE_INLINE} inline; {$ENDIF}

{$EXTERNALSYM deflateInit2}
function deflateInit2(var strm: z_stream; level, method, windowBits,
                      memLevel, strategy: TIdC_INT): TIdC_INT;
{$IFDEF USE_INLINE} inline; {$ENDIF}

{not sure if these should be externalsymed but might not be a bad idea}

{$EXTERNALSYM deflateInitEx}
function deflateInitEx(var strm: z_stream; level: TIdC_INT; streamtype: TZStreamType = zsZLib): TIdC_INT;

{$EXTERNALSYM inflateInitEx}
function inflateInitEx(var strm: z_stream; streamtype: TZStreamType = zsZLib): TIdC_INT;

{$EXTERNALSYM adler32}
{$EXTERNALSYM adler32_combine}
{$EXTERNALSYM compress}
{$EXTERNALSYM compress2}
{$EXTERNALSYM compressBound}
{$EXTERNALSYM crc32}
{$EXTERNALSYM crc32_combine}
{$EXTERNALSYM deflate}
{$EXTERNALSYM deflateBound}
{$EXTERNALSYM deflateCopy}
{$EXTERNALSYM deflateEnd}
{$EXTERNALSYM deflateInit_}
{$EXTERNALSYM deflateInit2_}
{$EXTERNALSYM deflateParams}
{$EXTERNALSYM deflatePrime}
{$EXTERNALSYM deflateTune}
{$EXTERNALSYM deflateReset}
{$EXTERNALSYM deflateSetDictionary}
{$EXTERNALSYM inflate}
{$EXTERNALSYM inflateBack}
{$EXTERNALSYM inflateBackEnd}
{$EXTERNALSYM inflateBackInit_}
{$EXTERNALSYM inflateCopy}
{$EXTERNALSYM inflateEnd; external}
{$EXTERNALSYM inflateInit_}
{$EXTERNALSYM inflateInit2_}
{$EXTERNALSYM inflateReset}
{$EXTERNALSYM inflateReset2}
{$EXTERNALSYM inflateSetDictionary}
{$EXTERNALSYM inflateSync}
{$EXTERNALSYM uncompress}
{$EXTERNALSYM zlibCompileFlags}
{$EXTERNALSYM zError}
{$EXTERNALSYM inflateSyncPoint}
{$EXTERNALSYM get_crc_table}
{$EXTERNALSYM inflateUndermine}
{$EXTERNALSYM zlibVersion}
{$EXTERNALSYM deflateSetHeader}
{$EXTERNALSYM inflatePrime}
{$EXTERNALSYM inflateMark}
{$EXTERNALSYM inflateGetHeader}

{$IFNDEF STATICLOAD_ZLIB}
type
  EIdZLibStubError = class(EIdException)
  protected
    FError : UInt32;
    FErrorMessage : String;
    FTitle : String;
  public
    constructor Build(const ATitle : String; AError : UInt32);
    property Error : UInt32 read FError;
    property ErrorMessage : String read FErrorMessage;
    property Title : String read FTitle;
  end;

type
  {$EXTERNALSYM LPN_adler32}
  LPN_adler32 = function (adler: TIdC_ULONG;
    const buf: PIdAnsiChar; len: TIdC_UINT): TIdC_ULONG; cdecl;
  {$EXTERNALSYM LPN_adler32_combine}
  LPN_adler32_combine = function (crc1, crc2 : TIdC_ULONG;
    len2 : z_off_t) : TIdC_ULONG; cdecl;
  {$EXTERNALSYM LPN_compress}
  LPN_compress = function (dest: PIdAnsiChar; var destLen: TIdC_ULONG;
    const source: PIdAnsiChar; sourceLen: TIdC_ULONG): TIdC_INT;cdecl;
  {$EXTERNALSYM LPN_compress2}
  LPN_compress2 = function(dest: PIdAnsiChar; var destLen: TIdC_ULONG;
                  const source: PIdAnsiChar; sourceLen: TIdC_ULONG;
                  level: TIdC_INT): TIdC_INT; cdecl;
  {$EXTERNALSYM LPN_compressBound}
  LPN_compressBound = function (sourceLen: TIdC_ULONG): TIdC_ULONG;cdecl;
  {$EXTERNALSYM LPN_crc32}
  LPN_crc32 = function (crc: TIdC_ULONG; const buf: PIdAnsiChar;
                len: TIdC_UINT): TIdC_ULONG; cdecl;
  {$EXTERNALSYM LPN_crc32_combine}
  LPN_crc32_combine = function (crc1, crc2 : TIdC_ULONG;
    len2 : z_off_t) : TIdC_ULONG; cdecl;
  {$EXTERNALSYM LPN_deflate}
  LPN_deflate = function (var strm: z_stream; flush: TIdC_INT): TIdC_INT; cdecl;
  {$EXTERNALSYM LPN_deflateBound}
  LPN_deflateBound = function (var strm: z_stream;
    sourceLen: TIdC_ULONG): TIdC_ULONG; cdecl;
  {$EXTERNALSYM LPN_deflateCopy}
  LPN_deflateCopy = function (var dest, source: z_stream): TIdC_INT; cdecl;
  {$EXTERNALSYM LPN_deflateEnd}
  LPN_deflateEnd = function (var strm: z_stream):  TIdC_INT; cdecl;
  {$EXTERNALSYM LPN_deflateInit_}
  LPN_deflateInit_ = function (var strm: z_stream; level: TIdC_INT;
                      const version: PIdAnsiChar; stream_size: TIdC_INT): TIdC_INT;cdecl;
  {$EXTERNALSYM LPN_deflateInit2_}
  LPN_deflateInit2_ = function (var strm: z_stream;
                       level, method, windowBits, memLevel, strategy: TIdC_INT;
                       const version: PIdAnsiChar; stream_size: TIdC_INT): TIdC_INT;cdecl;
  {$EXTERNALSYM LPN_deflateParams}
  LPN_deflateParams = function (var strm: z_stream; level, strategy: TIdC_INT): TIdC_INT; cdecl;
  {$EXTERNALSYM LPN_deflatePrime}
  LPN_deflatePrime = function (var strm: z_stream; bits, value: TIdC_INT): TIdC_INT; cdecl;
  {$EXTERNALSYM LPN_deflateTune}
  LPN_deflateTune = function (var strm : z_stream; good_length : TIdC_INT;
    max_lazy, nice_length, max_chain : TIdC_INT) : TIdC_INT; cdecl;
  {$EXTERNALSYM LPN_deflateReset}
  LPN_deflateReset = function (var strm: z_stream): TIdC_INT; cdecl;
  {$EXTERNALSYM LPN_deflateSetDictionary}
  LPN_deflateSetDictionary = function (var strm: z_stream; const dictionary: PIdAnsiChar;
                              dictLength: TIdC_UINT): TIdC_INT; cdecl;
  {$EXTERNALSYM LPN_inflate}
  LPN_inflate = function (var strm: z_stream; flush: TIdC_INT): TIdC_INT; cdecl;
  {$EXTERNALSYM LPN_inflateBack}
  LPN_inflateBack = function (var strm: z_stream; in_fn: in_func; in_desc: Pointer;
                     out_fn: out_func; out_desc: Pointer): TIdC_INT; cdecl;
  {$EXTERNALSYM LPN_inflateBackEnd}
  LPN_inflateBackEnd = function (var strm: z_stream): TIdC_INT; cdecl;
  {$EXTERNALSYM LPN_inflateBackInit_}
  LPN_inflateBackInit_ = function (var strm: z_stream;
                          windowBits: TIdC_INT; window: PIdAnsiChar;
                          const version: PIdAnsiChar; stream_size: TIdC_INT): TIdC_INT; cdecl;
  {$EXTERNALSYM LPN_inflateCopy}
  LPN_inflateCopy = function (var dest, source: z_stream): TIdC_INT; cdecl;
  {$EXTERNALSYM LPN_inflateEnd}
  LPN_inflateEnd = function (var strm: z_stream): TIdC_INT; cdecl;
  {$EXTERNALSYM LPN_inflateInit_}
  LPN_inflateInit_ = function (var strm: z_stream; const version: PIdAnsiChar;
                      stream_size: TIdC_INT): TIdC_INT; cdecl;
  {$EXTERNALSYM LPN_inflateInit2_}
  LPN_inflateInit2_ = function (var strm: z_stream; windowBits: TIdC_INT;
                       const version: PIdAnsiChar; stream_size: TIdC_INT): TIdC_INT;cdecl;
  {$EXTERNALSYM LPN_inflateReset}
  LPN_inflateReset = function (var strm: z_stream): TIdC_INT; cdecl;
  {$EXTERNALSYM LPN_inflateReset2}
  LPN_inflateReset2 = function (var strm : z_stream; windowBits : TIdC_INT) : TIdC_INT; cdecl;
  {$EXTERNALSYM LPN_inflatePrime}
  LPN_inflatePrime = function (var strm : z_stream; bits, value : TIdC_INT ) : TIdC_INT;  cdecl;
  {$EXTERNALSYM LPN_inflateMark}
  LPN_inflateMark = function (var strm : z_stream) : TIdC_LONG; cdecl;
  {$EXTERNALSYM LPN_inflateSetDictionary}
  LPN_inflateSetDictionary = function (var strm: z_stream; const dictionary: PIdAnsiChar;
                              dictLength: TIdC_UINT): TIdC_INT; cdecl;
  {$EXTERNALSYM LPN_inflateSync}
  LPN_inflateSync = function (var strm: z_stream): TIdC_INT; cdecl;
  {$EXTERNALSYM LPN_uncompress}
  LPN_uncompress = function (dest: PIdAnsiChar; var destLen: TIdC_ULONG;
                   const source: PIdAnsiChar; sourceLen: TIdC_ULONG): TIdC_INT;cdecl;
  {$EXTERNALSYM LPN_zlibCompileFlags}
  LPN_zlibCompileFlags = function : TIdC_ULONG; cdecl;
  {$EXTERNALSYM LPN_zError}
  LPN_zError = function (err : TIdC_INT) : PIdAnsiChar; cdecl;
  {$EXTERNALSYM LPN_inflateSyncPoint}
  LPN_inflateSyncPoint = function (var z : TZStreamRec) : TIdC_INT; cdecl;
  {$EXTERNALSYM LPN_get_crc_table}
  LPN_get_crc_table = function : PIdC_ULONG; cdecl;
  {$EXTERNALSYM LPN_zlibVersion}
  LPN_zlibVersion = function : PIdAnsiChar; cdecl;
  {$EXTERNALSYM LPN_inflateUndermine}
  LPN_inflateUndermine = function (var strm: z_stream; subvert : TIdC_INT ) : TIdC_INT; cdecl;
  {$EXTERNALSYM LPN_deflateSetHeader}
  LPN_deflateSetHeader = function (var strm: z_stream; var head: gz_header): TIdC_INT; cdecl;
  {$EXTERNALSYM LPN_inflateGetHeader}
  LPN_inflateGetHeader = function (var strm: z_stream; var head: gz_header): TIdC_INT; cdecl;

{Vars}
var
  adler32 : LPN_adler32 = nil;
  adler32_combine : LPN_adler32_combine = nil;
  compress : LPN_compress = nil;
  compress2 : LPN_compress2 = nil;
  compressBound : LPN_compressBound = nil;
  crc32 : LPN_crc32 = nil;
  crc32_combine : LPN_crc32_combine = nil;
  deflate : LPN_deflate = nil; 
  deflateBound : LPN_deflateBound = nil;
  deflateCopy : LPN_deflateCopy = nil;
  deflateEnd : LPN_deflateEnd = nil;
  deflateInit_ : LPN_deflateInit_ = nil; 
  deflateInit2_ : LPN_deflateInit2_ = nil;
  deflateParams : LPN_deflateParams = nil;
  
  deflatePrime :LPN_deflatePrime = nil;
  deflateTune : LPN_deflateTune = nil;
  deflateReset : LPN_deflateReset = nil;
  deflateSetDictionary : LPN_deflateSetDictionary = nil;
  inflate : LPN_inflate = nil; 
  inflateBack : LPN_inflateBack = nil;
  inflateBackEnd : LPN_inflateBackEnd = nil;
  inflateEnd : LPN_inflateEnd = nil; 
  inflateBackInit_ : LPN_inflateBackInit_ = nil;
  inflateCopy : LPN_inflateCopy = nil;
  inflateInit_ : LPN_inflateInit_ = nil;
  inflateInit2_ : LPN_inflateInit2_ = nil;
  inflateReset : LPN_inflateReset = nil;

  inflateReset2 : LPN_inflateReset2 = nil;
  inflatePrime : LPN_inflatePrime = nil;
  inflateMark : LPN_inflateMark = nil;

  inflateSetDictionary : LPN_inflateSetDictionary = nil;
  inflateSync : LPN_inflateSync = nil; 
  uncompress : LPN_uncompress = nil; 
  zlibCompileFlags : LPN_zlibCompileFlags = nil;
  zError : LPN_zError = nil; 
  inflateSyncPoint : LPN_inflateSyncPoint = nil;
  get_crc_table : LPN_get_crc_table = nil;
  inflateUndermine : LPN_inflateUndermine = nil;
  zlibVersion : LPN_zlibVersion = nil;
  deflateSetHeader : LPN_deflateSetHeader = nil;
  inflateGetHeader : LPN_inflateGetHeader = nil;

procedure IdZLibSetLibPath(const APath: String);

{$ELSE}

(* basic functions *)
function zlibVersion: PIdAnsiChar; {$IFDEF STATIC_CDECL_PROCS} cdecl; {$ENDIF}

function deflate(var strm: z_stream; flush: TIdC_INT): TIdC_INT; {$IFDEF STATIC_CDECL_PROCS} cdecl; {$ENDIF}
function deflateEnd(var strm: z_stream): TIdC_INT; {$IFDEF STATIC_CDECL_PROCS} cdecl; {$ENDIF}

function inflate(var strm: z_stream; flush: TIdC_INT): TIdC_INT; {$IFDEF STATIC_CDECL_PROCS} cdecl; {$ENDIF}
function inflateEnd(var strm: z_stream): TIdC_INT; {$IFDEF STATIC_CDECL_PROCS} cdecl; {$ENDIF}

(* advanced functions *)

function deflateSetDictionary(var strm: z_stream; const dictionary: PIdAnsiChar;
                              dictLength: TIdC_UINT): TIdC_INT;  {$IFDEF STATIC_CDECL_PROCS} cdecl; {$ENDIF}
function deflateCopy(var dest, source: z_stream): TIdC_INT;  {$IFDEF STATIC_CDECL_PROCS} cdecl; {$ENDIF}
function deflateReset(var strm: z_stream): TIdC_INT;  {$IFDEF STATIC_CDECL_PROCS} cdecl; {$ENDIF}
function deflateParams(var strm: z_stream; level, strategy: TIdC_INT): TIdC_INT; {$IFDEF STATIC_CDECL_PROCS} cdecl; {$ENDIF}
{JPM Addition}
function deflateTune(var strm : z_stream; good_length : TIdC_INT;
    max_lazy, nice_length, max_chain : TIdC_INT) : TIdC_INT;  {$IFDEF STATIC_CDECL_PROCS} cdecl; {$ENDIF}
function deflateBound(var strm: z_stream;
    sourceLen: TIdC_ULONG): TIdC_ULONG;  {$IFDEF STATIC_CDECL_PROCS} cdecl; {$ENDIF}
function deflatePrime(var strm: z_stream; bits, value: TIdC_INT): TIdC_INT;  {$IFDEF STATIC_CDECL_PROCS} cdecl; {$ENDIF}

function inflateSetDictionary(var strm: z_stream; const dictionary: PIdAnsiChar;
                              dictLength: TIdC_UINT): TIdC_INT;  {$IFDEF STATIC_CDECL_PROCS} cdecl; {$ENDIF}
function inflateSync(var strm: z_stream): TIdC_INT;  {$IFDEF STATIC_CDECL_PROCS} cdecl; {$ENDIF}
function inflateCopy(var dest, source: z_stream): TIdC_INT;  {$IFDEF STATIC_CDECL_PROCS} cdecl; {$ENDIF}
function inflateReset(var strm: z_stream): TIdC_INT;  {$IFDEF STATIC_CDECL_PROCS} cdecl; {$ENDIF}
function inflateReset2(var strm : z_stream; windowBits : TIdC_INT) : TIdC_INT;  {$IFDEF STATIC_CDECL_PROCS} cdecl; {$ENDIF}
function inflatePrime(var strm : z_stream; bits, value : TIdC_INT ) : TIdC_INT;  {$IFDEF STATIC_CDECL_PROCS} cdecl; {$ENDIF}
function inflateMark(var strm : z_stream) : TIdC_LONG;  {$IFDEF STATIC_CDECL_PROCS} cdecl; {$ENDIF}
function inflateBack(var strm: z_stream; in_fn: in_func; in_desc: Pointer;
                     out_fn: out_func; out_desc: Pointer): TIdC_INT;  {$IFDEF STATIC_CDECL_PROCS} cdecl; {$ENDIF}
function inflateBackEnd(var strm: z_stream): TIdC_INT;  {$IFDEF STATIC_CDECL_PROCS} cdecl; {$ENDIF}

function zlibCompileFlags: TIdC_ULONG;   {$IFDEF STATIC_CDECL_PROCS} cdecl; {$ENDIF}

{JPM Additional functions}
function  zError (err : TIdC_INT) : PIdAnsiChar;  {$IFDEF STATIC_CDECL_PROCS} cdecl; {$ENDIF}
function inflateSyncPoint(var z : TZStreamRec) : TIdC_INT; {$IFDEF STATIC_CDECL_PROCS} cdecl; {$ENDIF}
//const uLongf * get_crc_table (void);
function inflateUndermine(var strm: z_stream; subvert : TIdC_INT ) : TIdC_INT; {$IFDEF STATIC_CDECL_PROCS} cdecl; {$ENDIF}

function  get_crc_table : PIdC_ULONG;  {$IFDEF STATIC_CDECL_PROCS} cdecl; {$ENDIF}
{end JPM additions}

(* utility functions *)
function compress(dest: PIdAnsiChar; var destLen: TIdC_ULONG;
                  const source: PIdAnsiChar; sourceLen: TIdC_ULONG): TIdC_INT; {$IFDEF STATIC_CDECL_PROCS} cdecl; {$ENDIF}
function compress2(dest: PIdAnsiChar; var destLen: TIdC_ULONG;
                  const source: PIdAnsiChar; sourceLen: TIdC_ULONG;
                  level: TIdC_INT): TIdC_INT;  {$IFDEF STATIC_CDECL_PROCS} cdecl; {$ENDIF}
function compressBound(sourceLen: TIdC_ULONG): TIdC_ULONG;  {$IFDEF STATIC_CDECL_PROCS} cdecl; {$ENDIF}
function uncompress(dest: PIdAnsiChar; var destLen: TIdC_ULONG;
                   const source: PIdAnsiChar; sourceLen: TIdC_ULONG): TIdC_INT;  {$IFDEF STATIC_CDECL_PROCS} cdecl; {$ENDIF}

(* checksum functions *)
function adler32(adler: TIdC_ULONG;
    const buf: PIdAnsiChar; len: TIdC_UINT): TIdC_ULONG;  {$IFDEF STATIC_CDECL_PROCS} cdecl; {$ENDIF}
function adler32_combine(crc1, crc2 : TIdC_ULONG; len2 : z_off_t) : TIdC_ULONG; {$IFDEF STATIC_CDECL_PROCS} cdecl; {$ENDIF}
function crc32(crc: TIdC_ULONG; const buf: PIdAnsiChar;
                len: TIdC_UINT): TIdC_ULONG;  {$IFDEF STATIC_CDECL_PROCS} cdecl; {$ENDIF}
function crc32_combine(crc1, crc2 : TIdC_ULONG; len2 : z_off_t) : TIdC_ULONG;  {$IFDEF STATIC_CDECL_PROCS} cdecl; {$ENDIF}
(* various hacks, don't look :) *)
function deflateInit_(var strm: z_stream; level: TIdC_INT;
                      const version: PIdAnsiChar; stream_size: TIdC_INT): TIdC_INT;  {$IFDEF STATIC_CDECL_PROCS} cdecl; {$ENDIF}
function inflateInit_(var strm: z_stream; const version: PIdAnsiChar;
                      stream_size: TIdC_INT): TIdC_INT;  {$IFDEF STATIC_CDECL_PROCS} cdecl; {$ENDIF}
function deflateInit2_(var strm: z_stream;
                       level, method, windowBits, memLevel, strategy: TIdC_INT;
                       const version: PIdAnsiChar; stream_size: TIdC_INT): TIdC_INT; {$IFDEF STATIC_CDECL_PROCS} cdecl; {$ENDIF}
function inflateInit2_(var strm: z_stream; windowBits: TIdC_INT;
                       const version: PIdAnsiChar; stream_size: TIdC_INT): TIdC_INT;  {$IFDEF STATIC_CDECL_PROCS} cdecl; {$ENDIF}
function inflateBackInit_(var strm: z_stream;
                          windowBits: TIdC_INT; window: PIdAnsiChar;
                          const version: PIdAnsiChar; stream_size: TIdC_INT): TIdC_INT; {$IFDEF STATIC_CDECL_PROCS} cdecl; {$ENDIF}

function deflateSetHeader(var strm: z_stream; var head: gz_header): TIdC_INT;  {$IFDEF STATIC_CDECL_PROCS} cdecl; {$ENDIF}
function inflateGetHeader(var strm: z_stream; var head: gz_header): TIdC_INT;  {$IFDEF STATIC_CDECL_PROCS} cdecl; {$ENDIF}
{$ENDIF}

{$EXTERNALSYM zlibAllocMem}
function zlibAllocMem(AppData: Pointer; Items, Size: TIdC_UINT): Pointer; cdecl;
{$EXTERNALSYM zlibFreeMem}
procedure zlibFreeMem(AppData, Block: Pointer); cdecl;
{$EXTERNALSYM Load}
function Load : Boolean;
{$EXTERNALSYM Unload}
procedure Unload;
{$EXTERNALSYM Loaded}
function Loaded : Boolean;

{minor additional helper functions}
{$EXTERNALSYM _malloc}
function _malloc(Size: Integer): Pointer; cdecl;
{$EXTERNALSYM _free}
procedure _free(Block: Pointer); cdecl;
{$EXTERNALSYM _memset}
procedure _memset(P: Pointer; B: Byte; count: Integer); cdecl;
{$EXTERNALSYM _memcpy}
procedure _memcpy(dest, source: Pointer; count: Integer); cdecl;

implementation

uses
  SysUtils
  {$IFNDEF STATICLOAD_ZLIB}
  , IdZLibConst
    {$IFDEF KYLIXCOMPAT}
  , libc
    {$ENDIF}
    {$IFDEF FPC}
  , DynLibs // better add DynLibs only for fpc
    {$ENDIF}
    {$IFDEF WINDOWS}
  , Windows
    {$ENDIF}
  {$ELSE}
      {$IFDEF VCL_XE2_OR_ABOVE}
  , System.Win.Crtl {$NOINCLUDE System.Win.Crtl}
      {$ENDIF}
  {$ENDIF};

{$IFDEF STATICLOAD_ZLIB}
{$IFNDEF VCL_XE2_OR_ABOVE}
  {$L adler32.obj}
  {$L compress.obj}
  {$L crc32.obj}
  {$L deflate.obj}
  {$L infback.obj}
  {$L inffast.obj}
  {$L inflate.obj}
  {$L inftrees.obj}
  {$L trees.obj}
  {$L uncompr.obj}
  {$L zutil.obj}
{$ELSE}
  {$IFDEF WIN32}
    {$L ZLib\i386-Win32-ZLib\zlibudec.obj} // undecorated stubs which are not needed for x64 compilation
    {$L ZLib\i386-Win32-ZLib\deflate.obj}
    {$L ZLib\i386-Win32-ZLib\inflate.obj}
    {$L ZLib\i386-Win32-ZLib\infback.obj}
    {$L ZLib\i386-Win32-ZLib\inffast.obj}
    {$L ZLib\i386-Win32-ZLib\inftrees.obj}
    {$L ZLib\i386-Win32-ZLib\trees.obj}
    {$L ZLib\i386-Win32-ZLib\compress.obj}
    {$L ZLib\i386-Win32-ZLib\uncompr.obj}
    {$L ZLib\i386-Win32-ZLib\adler32.obj}
    {$L ZLib\i386-Win32-ZLib\crc32.obj}
    {$L ZLib\i386-Win32-ZLib\zutil.obj}
    {$L ZLib\i386-Win32-ZLib\gzclose.obj}
    {$L ZLib\i386-Win32-ZLib\gzread.obj}
    {$L ZLib\i386-Win32-ZLib\gzwrite.obj}
    {$L ZLib\i386-Win32-ZLib\gzlib.obj}
  {$ENDIF}
  {$IFDEF WIN64}
    {$L ZLib\x86_64-Win64-ZLib\deflate.obj}
    {$L ZLib\x86_64-Win64-ZLib\inflate.obj}
    {$L ZLib\x86_64-Win64-ZLib\infback.obj}
    {$L ZLib\x86_64-Win64-ZLib\inffast.obj}
    {$L ZLib\x86_64-Win64-ZLib\inftrees.obj}
    {$L ZLib\x86_64-Win64-ZLib\trees.obj}
    {$L ZLib\x86_64-Win64-ZLib\compress.obj}
    {$L ZLib\x86_64-Win64-ZLib\uncompr.obj}
    {$L ZLib\x86_64-Win64-ZLib\adler32.obj}
    {$L ZLib\x86_64-Win64-ZLib\crc32.obj}
    {$L ZLib\x86_64-Win64-ZLib\zutil.obj}
    {$L ZLib\x86_64-Win64-ZLib\gzclose.obj}
    {$L ZLib\x86_64-Win64-ZLib\gzread.obj}
    {$L ZLib\x86_64-Win64-ZLib\gzwrite.obj}
    {$L ZLib\x86_64-Win64-ZLib\gzlib.obj}
  {$ENDIF}
{$ENDIF}

function adler32; external;
function adler32_combine; external;
function compress; external;
function compress2; external;
function compressBound; external;
function crc32; external;
function crc32_combine; external;
function deflate; external;
function deflateBound; external;
function deflateCopy; external;
function deflateEnd; external;
function deflateInit_; external;
function deflateInit2_; external;
function deflateParams; external;
function deflatePrime; external;
function deflateTune; external;
function deflateReset; external;
function deflateSetDictionary; external;
function inflate; external;
function inflateBack; external;
function inflateBackEnd; external;
function inflateBackInit_; external;
function inflateCopy; external;
function inflateEnd; external;
function inflateInit_; external;
function inflateInit2_; external;
function inflateReset; external;
function inflateReset2; external;
function inflateSetDictionary; external;
function inflateSync; external;
function uncompress; external;
function zlibCompileFlags; external;
function zError; external;
function inflateSyncPoint; external;
function get_crc_table; external;
function inflateUndermine; external;
function zlibVersion; external;
function deflateSetHeader; external;
function inflatePrime; external;
function inflateMark; external;
function inflateGetHeader; external;
{$ELSE}
var
  {$IFDEF UNIX}
  hZlib: HModule = nilhandle;
  {$ELSE}
  hZLib: THandle = 0;
  {$ENDIF}

  {$IFDEF UNIX}
const
  //The extensions will be resolved by IdGlobal.HackLoad
  //This is a little messy because symbolic links to libraries may not always be the same
  //in various Unix types.  Even then, there could possibly be differences.
  libzlib = 'libz';
  libvers : array [0..3] of string = ('.1','','.3','.2');
  {$ENDIF}
  {$IFDEF NETWARE}  {zlib.nlm comes with netware6}
const
  libzlib = 'zlib';
  {$ENDIF}
  {$IFDEF WIN32}
  //Note that this is the official ZLIB1 .DLL from the http://www.zlib.net/
const
  libzlib = 'zlib1.dll';
  {$ENDIF}
  {$IFDEF WIN64}
  //Note that this is not an official ZLIB .DLL.  It was obtained from:
  //http://www.winimage.com/zLibDll/
  //
  //It is defined with the WINAPI conventions instead of the standard cdecl
  //conventions.  Get the DLL for Win32-x86.
const
  libzlib = 'zlibwapi.dll';
  {$ENDIF}
  {$IFDEF WINCE}
  //Note that zlibce can be found at http://www.tenik.co.jp/~adachi/wince/zlibce/
const
  libzlib = 'zlibce';
  {$ENDIF}

constructor EIdZLibStubError.Build(const ATitle : String; AError : UInt32);
begin
  FTitle := ATitle;
  FError := AError;
  if AError = 0 then begin
    inherited Create(ATitle);
  end else begin
    FErrorMessage := SysUtils.SysErrorMessage(AError);
    inherited Create(ATitle + ': ' + FErrorMessage);    {Do not Localize}
  end;
end;

function FixupStub(hDll: THandle; const AName: {$IFDEF WINCE}TIdUnicodeString{$ELSE}string{$ENDIF}): Pointer;
begin
  if hDll = 0 then begin
    raise EIdZLibStubError.Build(Format(RSZLibCallError, [AName]), 0);
  end;
  Result := GetProcAddress(hDll, {$IFDEF WINCE}PWideChar{$ELSE}PChar{$ENDIF}(AName));
  if Result = nil then begin
    raise EIdZLibStubError.Build(Format(RSZLibCallError, [AName]), 10022);
  end;
end;

function stub_adler32(adler: TIdC_ULONG; const buf: PIdAnsiChar;
  len: TIdC_UINT): TIdC_ULONG; cdecl;
begin
  adler32 := FixupStub(hZLib, 'adler32'); {Do not Localize}
  Result := adler32(adler, buf, len);
end;

function stub_adler32_combine (crc1, crc2 : TIdC_ULONG;
  len2 : z_off_t) : TIdC_ULONG; cdecl;
begin
  adler32_combine := FixupStub(hZLib, 'adler32_combine'); {Do not Localize}
  Result := adler32_combine(crc1, crc2, len2);
end;

function stub_compress(dest: PIdAnsiChar; var destLen: TIdC_ULONG;
  const source: PIdAnsiChar; sourceLen: TIdC_ULONG): TIdC_INT; cdecl;
begin
  compress := FixupStub(hZLib, 'compress'); {Do not Localize}
  Result := compress(dest,destLen,source,sourceLen);
end;

function stub_compress2(dest: PIdAnsiChar; var destLen: TIdC_ULONG;
  const source: PIdAnsiChar; sourceLen: TIdC_ULONG;
  level: TIdC_INT): TIdC_INT; cdecl;
begin
  compress2 := FixupStub(hZLib, 'compress2'); {Do not Localize}
  Result := compress2(dest, destLen, source, sourceLen, level);
end;


function stub_compressBound(sourceLen: TIdC_ULONG): TIdC_ULONG; cdecl;
begin
  compressBound := FixupStub(hZLib, 'compressBound'); {Do not Localize}
  Result := compressBound(sourcelen);
end;

function stub_crc32(crc: TIdC_ULONG; const buf: PIdAnsiChar;
  len: TIdC_UINT): TIdC_ULONG; cdecl;
begin
  crc32 := FixupStub(hZLib, 'crc32'); {Do not Localize}
  Result := crc32(crc, buf, len);
end;

function stub_crc32_combine (crc1, crc2 : TIdC_ULONG;
  len2 : z_off_t) : TIdC_ULONG; cdecl;
begin
  crc32_combine := FixupStub(hZLib, 'crc32_combine'); {Do not Localize}
  Result := crc32_combine(crc1, crc2, len2);
end;

function stub_deflate(var strm: z_stream; flush: TIdC_INT): TIdC_INT; cdecl;
begin
  deflate := FixupStub(hZLib, 'deflate'); {Do not Localize}
  Result := deflate(strm, flush);
end;

function stub_deflateBound(var strm: z_stream;
  sourceLen: TIdC_ULONG): TIdC_ULONG; cdecl;
begin
  deflateBound := FixupStub(hZLib, 'deflateBound'); {Do not Localize}
  Result := deflateBound(strm, sourceLen);
end;

function stub_deflateCopy(var dest, source: z_stream): TIdC_INT; cdecl;
begin
  deflateCopy := FixupStub(hZLib, 'deflateCopy'); {Do not Localize}
  Result := deflateCopy(dest, source);
end;

function stub_deflateEnd(var strm: z_stream):  TIdC_INT; cdecl;
begin
  deflateEnd := FixupStub(hZLib, 'deflateEnd'); {Do not Localize}
  Result := deflateEnd(strm);
end;

function stub_deflateInit_(var strm: z_stream; level: TIdC_INT;
  const version: PIdAnsiChar; stream_size: TIdC_INT): TIdC_INT;cdecl;
begin
  deflateInit_ := FixupStub(hZLib, 'deflateInit_'); {Do not Localize}
  Result := deflateInit_(strm, level, version, stream_size);
end;                

function stub_deflateInit2_(var strm: z_stream;
  level, method, windowBits, memLevel, strategy: TIdC_INT;
  const version: PIdAnsiChar; stream_size: TIdC_INT): TIdC_INT;cdecl;
begin
  deflateInit2_ := FixupStub(hZLib, 'deflateInit2_'); {Do not Localize}
  Result := deflateInit2_(strm,level, method, windowBits, memLevel, strategy,
    version, stream_size);
end;

function stub_deflateParams (var strm: z_stream; level, strategy: TIdC_INT): TIdC_INT; cdecl;
begin
  deflateParams := FixupStub(hZLib, 'deflateParams'); {Do not Localize}
  Result := deflateParams (strm, level, strategy);
end;

function stub_deflatePrime (var strm: z_stream; bits, value: TIdC_INT): TIdC_INT; cdecl;
begin
  deflatePrime := FixupStub(hZLib, 'deflatePrime'); {Do not Localize}
  Result := deflateParams (strm, bits, value);
end;

function stub_deflateTune(var strm : z_stream; good_length : TIdC_INT;
  max_lazy, nice_length, max_chain : TIdC_INT) : TIdC_INT; cdecl;
begin
  deflateTune := FixupStub(hZLib, 'deflateTune'); {Do not Localize}
  Result := deflateTune(strm, good_length, max_lazy, nice_length, max_chain) ;
end;

function stub_deflateReset (var strm: z_stream): TIdC_INT; cdecl;
begin
  deflateReset := FixupStub(hZLib, 'deflateReset'); {Do not Localize}
  Result := deflateReset(strm);
end;
  
function stub_deflateSetDictionary(var strm: z_stream; const dictionary: PIdAnsiChar;
  dictLength: TIdC_UINT): TIdC_INT; cdecl;
begin
  deflateSetDictionary := FixupStub(hZLib, 'deflateSetDictionary'); {Do not Localize}
  Result := deflateSetDictionary(strm, dictionary, dictLength);
end;

function stub_inflate(var strm: z_stream; flush: TIdC_INT): TIdC_INT;  cdecl;
begin
  inflate := FixupStub(hZLib, 'inflate'); {Do not Localize}
  Result := inflate(strm, flush);
end;

function stub_inflateBack(var strm: z_stream; in_fn: in_func; in_desc: Pointer;
  out_fn: out_func; out_desc: Pointer): TIdC_INT; cdecl;  
begin
  inflateBack := FixupStub(hZLib, 'inflateBack'); {Do not Localize}
  Result := inflateBack(strm, in_fn, in_desc, out_fn, out_desc);
end;
 
function stub_inflateBackEnd(var strm: z_stream): TIdC_INT; cdecl;     
begin
  inflateBackEnd := FixupStub(hZLib, 'inflateBackEnd'); {Do not Localize}
  Result := inflateBackEnd(strm);
end;

function stub_inflateEnd(var strm: z_stream): TIdC_INT; cdecl;
begin
  inflateEnd := FixupStub(hZLib, 'inflateEnd'); {Do not Localize}
  Result := inflateEnd(strm);
end;

function stub_inflateBackInit_(var strm: z_stream;
  windowBits: TIdC_INT; window: PIdAnsiChar;
  const version: PIdAnsiChar; stream_size: TIdC_INT): TIdC_INT; cdecl;
begin
  inflateBackInit_ := FixupStub(hZLib, 'inflateBackInit_'); {Do not Localize}
  Result := inflateBackInit_(strm, windowBits, window, version, stream_size);
end;

function stub_inflateInit2_(var strm: z_stream; windowBits: TIdC_INT;
  const version: PIdAnsiChar; stream_size: TIdC_INT): TIdC_INT;cdecl;
begin
  inflateInit2_ := FixupStub(hZLib, 'inflateInit2_'); {Do not Localize}
  Result := inflateInit2_(strm, windowBits, version, stream_size);
end;

function stub_inflateCopy(var dest, source: z_stream): TIdC_INT; cdecl;
begin
  inflateCopy := FixupStub(hZLib, 'inflateCopy'); {Do not Localize}
  Result := inflateCopy(dest, source);
end;


function  stub_inflateInit_(var strm: z_stream; const version: PIdAnsiChar;
  stream_size: TIdC_INT): TIdC_INT; cdecl;
begin
  inflateInit_ := FixupStub(hZLib, 'inflateInit_'); {Do not Localize}
  Result := inflateInit_(strm, version, stream_size);
end;

function stub_inflateReset(var strm: z_stream): TIdC_INT; cdecl;
begin
  inflateReset := FixupStub(hZLib, 'inflateReset'); {Do not Localize}
  Result := inflateReset(strm);
end;

function stub_inflateReset2(var strm : z_stream; windowBits : TIdC_INT) : TIdC_INT; cdecl;
begin
  inflateReset2 := FixupStub(hZLib, 'inflateReset2'); {Do not Localize}
  Result := inflateReset2(strm, windowBits);
end;

function stub_inflatePrime(var strm : z_stream; bits, value : TIdC_INT ) : TIdC_INT; cdecl;
begin
  inflatePrime := FixupStub(hZLib, 'inflatePrime'); {Do not Localize}
  Result := inflatePrime(strm, bits, value);
end;

function stub_inflateMark(var strm : z_stream) : TIdC_LONG; cdecl;
begin
  inflateMark := FixupStub(hZLib, 'inflateMark'); {Do not Localize}
  Result := inflateMark(strm);
end;

function stub_inflateSetDictionary(var strm: z_stream; const dictionary: PIdAnsiChar;
  dictLength: TIdC_UINT): TIdC_INT;cdecl;
begin
  inflateSetDictionary := FixupStub(hZLib, 'inflateSetDictionary'); {Do not Localize}
  Result := inflateSetDictionary(strm, dictionary, dictLength);
end;                              

function stub_inflateSync(var strm: z_stream): TIdC_INT; cdecl;
begin
  inflateSync := FixupStub(hZLib, 'inflateSync'); {Do not Localize}
  Result := inflateSync(strm);
end;
  
function stub_uncompress (dest: PIdAnsiChar; var destLen: TIdC_ULONG;
  const source: PIdAnsiChar; sourceLen: TIdC_ULONG): TIdC_INT;cdecl;
begin
  uncompress := FixupStub(hZLib, 'uncompress'); {Do not Localize}
  Result := uncompress (dest, destLen, source, sourceLen);
end;
                   
function stub_zlibCompileFlags : TIdC_ULONG; cdecl;
begin
  zlibCompileFlags := FixupStub(hZLib, 'zlibCompileFlags'); {Do not Localize}
  Result := zlibCompileFlags;
end;

function stub_zError(err : TIdC_INT) : PIdAnsiChar; cdecl;
begin
  zError := FixupStub(hZLib, 'zError'); {Do not Localize}
  Result := zError(err);
end;

function stub_inflateSyncPoint(var z : TZStreamRec) : TIdC_INT; cdecl;
begin
  inflateSyncPoint := FixupStub(hZLib, 'inflateSyncPoint'); {Do not Localize}
  Result := inflateSyncPoint(z);
end; 

function stub_get_crc_table : PIdC_ULONG; cdecl;
begin
  get_crc_table := FixupStub(hZLib, 'get_crc_table'); {Do not Localize}
  Result := get_crc_table;
end;

function stub_inflateUndermine(var strm: z_stream; subvert : TIdC_INT ) : TIdC_INT; cdecl;
begin
  inflateUndermine := FixupStub(hZLib, 'inflateUndermine'); {Do not Localize}
  Result := inflateUndermine(strm,subvert);
end;

function stub_zlibVersion : PIdAnsiChar; cdecl;
begin
  Result := '';
  zlibVersion := FixupStub(hZLib, 'zlibVersion'); {Do not Localize}
  if Assigned(zlibVersion) then begin
    Result := zlibVersion;
  end;
end;

function stub_deflateSetHeader(var strm: z_stream; var head: gz_header): TIdC_INT; cdecl;
begin
  deflateSetHeader := FixupStub(hZLib, 'deflateSetHeader'); {Do not Localize}
  Result := deflateSetHeader(strm, head);
end;  

function stub_inflateGetHeader(var strm: z_stream; var head: gz_header): TIdC_INT; cdecl;
begin
  inflateGetHeader := FixupStub(hZLib, 'inflateGetHeader'); {Do not Localize}
  Result := inflateGetHeader(strm, head);
end;

procedure InitializeStubs;
begin
  adler32 := stub_adler32;
  adler32_combine := stub_adler32_combine;
  compress := stub_compress;
  compress2 := stub_compress2;
  compressBound := stub_compressBound;
  crc32 := stub_crc32;
  crc32_combine := stub_crc32_combine;
  deflate := stub_deflate;
  deflateBound := stub_deflateBound;
  deflateCopy := stub_deflateCopy;
  deflateEnd := stub_deflateEnd;
  deflateInit_ := stub_deflateInit_;
  deflateInit2_ := stub_deflateInit2_;
  deflateParams := stub_deflateParams;
  deflatePrime := stub_deflatePrime;
  deflateTune := stub_deflateTune;
  deflateReset := stub_deflateReset;
  deflateSetDictionary := stub_deflateSetDictionary;
  inflate := stub_inflate;
  inflateBack := stub_inflateBack;
  inflateBackEnd := stub_inflateBackEnd;
  inflateBackInit_ := stub_inflateBackInit_;
  inflateCopy := stub_inflateCopy;
  inflateEnd := stub_inflateEnd;
  inflateInit_ := stub_inflateInit_;
  inflateInit2_ := stub_inflateInit2_;
  inflateReset := stub_inflateReset;
  inflateReset2 := stub_inflateReset2;
  inflatePrime := stub_inflatePrime;
  inflateMark := stub_inflateMark;

  inflateSetDictionary := stub_inflateSetDictionary;
  inflateSync := stub_inflateSync;
  uncompress := stub_uncompress; 
  zlibCompileFlags := stub_zlibCompileFlags;
  zError := stub_zError;
  inflateUndermine := stub_inflateUndermine;
  inflateSyncPoint := stub_inflateSyncPoint;

  get_crc_table := stub_get_crc_table;
  zlibVersion := stub_zlibVersion;
  deflateSetHeader := stub_deflateSetHeader;
  inflateGetHeader := stub_inflateGetHeader;
end;
{$ENDIF}

function deflateInit(var strm: z_stream; level: TIdC_INT): TIdC_INT;
begin
//  if not Assigned(strm.zalloc) then strm.zalloc := zlibAllocMem;
//  if not Assigned(strm.zfree)  then strm.zfree  := zlibFreeMem;
  Result := deflateInit_(strm, level, ZLIB_VERSION, sizeof(z_stream));
end;

function deflateInit2(var strm: z_stream; level, method, windowBits,
  memLevel, strategy: TIdC_INT): TIdC_INT;
begin
//  if not Assigned(strm.zalloc) then strm.zalloc := zlibAllocMem;
//  if not Assigned(strm.zfree)  then strm.zfree  := zlibFreeMem;
  Result := deflateInit2_(strm, level, method, windowBits, memLevel, strategy,
                          ZLIB_VERSION, sizeof(z_stream));
end;

const
  WBits : array[TZStreamType] of TIdC_INT = (MAX_WBITS, MAX_WBITS + 16, -MAX_WBITS);

function deflateInitEx(var strm: z_stream; level: TIdC_INT; streamtype: TZStreamType = zsZLib): TIdC_INT;
begin
  Result := deflateInit2(strm, level, Z_DEFLATED, WBits[streamtype],
    MAX_MEM_LEVEL, Z_DEFAULT_STRATEGY);
end;

function inflateInitEx(var strm: z_stream; streamtype: TZStreamType = zsZLib): TIdC_INT;
begin
  Result := inflateInit2(strm, WBits[streamtype]);
end;

function inflateInit(var strm: z_stream): TIdC_INT;
begin
//  if not Assigned(strm.zalloc) then strm.zalloc := zlibAllocMem;
//  if not Assigned(strm.zfree)  then strm.zfree  := zlibFreeMem;
  Result := inflateInit_(strm, ZLIB_VERSION, sizeof(z_stream));
end;

function inflateInit2(var strm: z_stream; windowBits: TIdC_INT): TIdC_INT;
begin
  if not Assigned(strm.zalloc) then begin
    strm.zalloc := zlibAllocMem;
  end;
  if not Assigned(strm.zfree) then begin
    strm.zfree  := zlibFreeMem;
  end;
  Result := inflateInit2_(strm, windowBits, ZLIB_VERSION, SizeOf(z_stream));
end;

function inflateBackInit(var strm: z_stream; windowBits: TIdC_INT;
  window: PIdAnsiChar): TIdC_INT;
begin
  Result := inflateBackInit_(strm, windowBits, window, ZLIB_VERSION, SizeOf(z_stream));
end;


{minor additional helper functions}
function _malloc(Size: Integer): Pointer; cdecl;
begin
  GetMem(Result, Size);
end;

procedure _free(Block: Pointer); cdecl;
begin
  FreeMem(Block);
end;

procedure _memset(P: Pointer; B: Byte; count: Integer); cdecl;
begin
  FillChar(P^, count, B);
end;

procedure _memcpy(dest, source: Pointer; count: Integer); cdecl;
begin
  Move(source^, dest^, count);
end;

function zlibAllocMem(AppData: Pointer; Items, Size: TIdC_UINT): Pointer; cdecl;
begin
  GetMem(Result, Items*Size);
//  Result := AllocMem(Items * Size);
end;

procedure zlibFreeMem(AppData, Block: Pointer); cdecl;
begin
  FreeMem(Block);
end;

{$IFDEF STATICLOAD_ZLIB}
function Load : Boolean;
begin
  Result := True;
end;

procedure Unload;
begin
end;

function Loaded : Boolean;
begin
  Result := True;
end;
{$ELSE}

var
  GIdZLibPath: String = '';

procedure IdZLibSetLibPath(const APath: String);
begin
  if APath <> '' then begin
    GIdZLibPath := IndyIncludeTrailingPathDelimiter(APath);
  end else begin
    GIdZLibPath := '';
  end;
end;

function Load : Boolean;
begin
  Result := Loaded;
  if not Result then begin
    //In Windows, you should use SafeLoadLibrary instead of the LoadLibrary API
    //call because LoadLibrary messes with the FPU control word.
    {$IFDEF WINDOWS}
    hZLib := SafeLoadLibrary(GIdZLibPath + libzlib);
    {$ELSE}
      {$IFDEF UNIX}
    hZLib := HackLoad(GIdZLibPath + libzlib, libvers);
      {$ELSE}
    hZLib := LoadLibrary(GIdZLibPath + libzlib);
        {$IFDEF USE_INVALIDATE_MOD_CACHE}
    InvalidateModuleCache;
        {$ENDIF}
      {$ENDIF}
    {$ENDIF}
    Result := Loaded;
  end;
end;

procedure Unload;
begin
  if Loaded then begin
    FreeLibrary(hZLib);
    {$IFDEF DELPHI_CROSS}
    InvalidateModuleCache;
    {$ENDIF}
    hZLib := 0;
    InitializeStubs;
  end;
end;

function Loaded : Boolean;
begin
  Result := (hZLib <> 0);
end;
{$ENDIF}

{$IFNDEF STATICLOAD_ZLIB}
initialization
  InitializeStubs;
  Load;

finalization
  Unload;
  InitializeStubs;
{$ENDIF}

end.