zlib/contrib/pascal/zlibpas.pas

   1 (* zlibpas -- Pascal interface to the zlib data compression library
   2  *
   3  * Copyright (C) 2003 Cosmin Truta.
   4  * Derived from original sources by Bob Dellaca.
   5  * For conditions of distribution and use, see copyright notice in readme.txt
   6  *)
   7
   8 unit zlibpas;
   9
  10 interface
  11
  12 const
  13   ZLIB_VERSION = '1.2.11';
  14   ZLIB_VERNUM  = $12a0;
  15
  16 type
  17   alloc_func = function(opaque: Pointer; items, size: Integer): Pointer;
  18                  cdecl;
  19   free_func  = procedure(opaque, address: Pointer);
  20                  cdecl;
  21
  22   in_func    = function(opaque: Pointer; var buf: PByte): Integer;
  23                  cdecl;
  24   out_func   = function(opaque: Pointer; buf: PByte; size: Integer): Integer;
  25                  cdecl;
  26
  27   z_streamp = ^z_stream;
  28   z_stream = packed record
  29     next_in: PChar;       (* next input byte *)
  30     avail_in: Integer;    (* number of bytes available at next_in *)
  31     total_in: LongInt;    (* total nb of input bytes read so far *)
  32
  33     next_out: PChar;      (* next output byte should be put there *)
  34     avail_out: Integer;   (* remaining free space at next_out *)
  35     total_out: LongInt;   (* total nb of bytes output so far *)
  36
  37     msg: PChar;           (* last error message, NULL if no error *)
  38     state: Pointer;       (* not visible by applications *)
  39
  40     zalloc: alloc_func;   (* used to allocate the internal state *)
  41     zfree: free_func;     (* used to free the internal state *)
  42     opaque: Pointer;      (* private data object passed to zalloc and zfree *)
  43
  44     data_type: Integer;   (* best guess about the data type: ascii or binary *)
  45     adler: LongInt;       (* adler32 value of the uncompressed data *)
  46     reserved: LongInt;    (* reserved for future use *)
  47   end;
  48
  49   gz_headerp = ^gz_header;
  50   gz_header = packed record
  51     text: Integer;        (* true if compressed data believed to be text *)
  52     time: LongInt;        (* modification time *)
  53     xflags: Integer;      (* extra flags (not used when writing a gzip file) *)
  54     os: Integer;          (* operating system *)
  55     extra: PChar;         (* pointer to extra field or Z_NULL if none *)
  56     extra_len: Integer;   (* extra field length (valid if extra != Z_NULL) *)
  57     extra_max: Integer;   (* space at extra (only when reading header) *)
  58     name: PChar;          (* pointer to zero-terminated file name or Z_NULL *)
  59     name_max: Integer;    (* space at name (only when reading header) *)
  60     comment: PChar;       (* pointer to zero-terminated comment or Z_NULL *)
  61     comm_max: Integer;    (* space at comment (only when reading header) *)
  62     hcrc: Integer;        (* true if there was or will be a header crc *)
  63     done: Integer;        (* true when done reading gzip header *)
  64   end;
  65
  66 (* constants *)
  67 const
  68   Z_NO_FLUSH      = 0;
  69   Z_PARTIAL_FLUSH = 1;
  70   Z_SYNC_FLUSH    = 2;
  71   Z_FULL_FLUSH    = 3;
  72   Z_FINISH        = 4;
  73   Z_BLOCK         = 5;
  74   Z_TREES         = 6;
  75
  76   Z_OK            =  0;
  77   Z_STREAM_END    =  1;
  78   Z_NEED_DICT     =  2;
  79   Z_ERRNO         = -1;
  80   Z_STREAM_ERROR  = -2;
  81   Z_DATA_ERROR    = -3;
  82   Z_MEM_ERROR     = -4;
  83   Z_BUF_ERROR     = -5;
  84   Z_VERSION_ERROR = -6;
  85
  86   Z_NO_COMPRESSION       =  0;
  87   Z_BEST_SPEED           =  1;
  88   Z_BEST_COMPRESSION     =  9;
  89   Z_DEFAULT_COMPRESSION  = -1;
  90
  91   Z_FILTERED            = 1;
  92   Z_HUFFMAN_ONLY        = 2;
  93   Z_RLE                 = 3;
  94   Z_FIXED               = 4;
  95   Z_DEFAULT_STRATEGY    = 0;
  96
  97   Z_BINARY   = 0;
  98   Z_TEXT     = 1;
  99   Z_ASCII    = 1;
 100   Z_UNKNOWN  = 2;
 101
 102   Z_DEFLATED = 8;
 103
 104 (* basic functions *)
 105 function zlibVersion: PChar;
 106 function deflateInit(var strm: z_stream; level: Integer): Integer;
 107 function deflate(var strm: z_stream; flush: Integer): Integer;
 108 function deflateEnd(var strm: z_stream): Integer;
 109 function inflateInit(var strm: z_stream): Integer;
 110 function inflate(var strm: z_stream; flush: Integer): Integer;
 111 function inflateEnd(var strm: z_stream): Integer;
 112
 113 (* advanced functions *)
 114 function deflateInit2(var strm: z_stream; level, method, windowBits,
 115                       memLevel, strategy: Integer): Integer;
 116 function deflateSetDictionary(var strm: z_stream; const dictionary: PChar;
 117                               dictLength: Integer): Integer;
 118 function deflateCopy(var dest, source: z_stream): Integer;
 119 function deflateReset(var strm: z_stream): Integer;
 120 function deflateParams(var strm: z_stream; level, strategy: Integer): Integer;
 121 function deflateTune(var strm: z_stream; good_length, max_lazy, nice_length, max_chain: Integer): Integer;
 122 function deflateBound(var strm: z_stream; sourceLen: LongInt): LongInt;
 123 function deflatePending(var strm: z_stream; var pending: Integer; var bits: Integer): Integer;
 124 function deflatePrime(var strm: z_stream; bits, value: Integer): Integer;
 125 function deflateSetHeader(var strm: z_stream; head: gz_header): Integer;
 126 function inflateInit2(var strm: z_stream; windowBits: Integer): Integer;
 127 function inflateSetDictionary(var strm: z_stream; const dictionary: PChar;
 128                               dictLength: Integer): Integer;
 129 function inflateSync(var strm: z_stream): Integer;
 130 function inflateCopy(var dest, source: z_stream): Integer;
 131 function inflateReset(var strm: z_stream): Integer;
 132 function inflateReset2(var strm: z_stream; windowBits: Integer): Integer;
 133 function inflatePrime(var strm: z_stream; bits, value: Integer): Integer;
 134 function inflateMark(var strm: z_stream): LongInt;
 135 function inflateGetHeader(var strm: z_stream; var head: gz_header): Integer;
 136 function inflateBackInit(var strm: z_stream;
 137                          windowBits: Integer; window: PChar): Integer;
 138 function inflateBack(var strm: z_stream; in_fn: in_func; in_desc: Pointer;
 139                      out_fn: out_func; out_desc: Pointer): Integer;
 140 function inflateBackEnd(var strm: z_stream): Integer;
 141 function zlibCompileFlags: LongInt;
 142
 143 (* utility functions *)
 144 function compress(dest: PChar; var destLen: LongInt;
 145                   const source: PChar; sourceLen: LongInt): Integer;
 146 function compress2(dest: PChar; var destLen: LongInt;
 147                   const source: PChar; sourceLen: LongInt;
 148                   level: Integer): Integer;
 149 function compressBound(sourceLen: LongInt): LongInt;
 150 function uncompress(dest: PChar; var destLen: LongInt;
 151                     const source: PChar; sourceLen: LongInt): Integer;
 152
 153 (* checksum functions *)
 154 function adler32(adler: LongInt; const buf: PChar; len: Integer): LongInt;
 155 function adler32_combine(adler1, adler2, len2: LongInt): LongInt;
 156 function crc32(crc: LongInt; const buf: PChar; len: Integer): LongInt;
 157 function crc32_combine(crc1, crc2, len2: LongInt): LongInt;
 158
 159 (* various hacks, don't look :) *)
 160 function deflateInit_(var strm: z_stream; level: Integer;
 161                       const version: PChar; stream_size: Integer): Integer;
 162 function inflateInit_(var strm: z_stream; const version: PChar;
 163                       stream_size: Integer): Integer;
 164 function deflateInit2_(var strm: z_stream;
 165                        level, method, windowBits, memLevel, strategy: Integer;
 166                        const version: PChar; stream_size: Integer): Integer;
 167 function inflateInit2_(var strm: z_stream; windowBits: Integer;
 168                        const version: PChar; stream_size: Integer): Integer;
 169 function inflateBackInit_(var strm: z_stream;
 170                           windowBits: Integer; window: PChar;
 171                           const version: PChar; stream_size: Integer): Integer;
 172
 173
 174 implementation
 175
 176 {$L adler32.obj}
 177 {$L compress.obj}
 178 {$L crc32.obj}
 179 {$L deflate.obj}
 180 {$L infback.obj}
 181 {$L inffast.obj}
 182 {$L inflate.obj}
 183 {$L inftrees.obj}
 184 {$L trees.obj}
 185 {$L uncompr.obj}
 186 {$L zutil.obj}
 187
 188 function adler32; external;
 189 function adler32_combine; external;
 190 function compress; external;
 191 function compress2; external;
 192 function compressBound; external;
 193 function crc32; external;
 194 function crc32_combine; external;
 195 function deflate; external;
 196 function deflateBound; external;
 197 function deflateCopy; external;
 198 function deflateEnd; external;
 199 function deflateInit_; external;
 200 function deflateInit2_; external;
 201 function deflateParams; external;
 202 function deflatePending; external;
 203 function deflatePrime; external;
 204 function deflateReset; external;
 205 function deflateSetDictionary; external;
 206 function deflateSetHeader; external;
 207 function deflateTune; external;
 208 function inflate; external;
 209 function inflateBack; external;
 210 function inflateBackEnd; external;
 211 function inflateBackInit_; external;
 212 function inflateCopy; external;
 213 function inflateEnd; external;
 214 function inflateGetHeader; external;
 215 function inflateInit_; external;
 216 function inflateInit2_; external;
 217 function inflateMark; external;
 218 function inflatePrime; external;
 219 function inflateReset; external;
 220 function inflateReset2; external;
 221 function inflateSetDictionary; external;
 222 function inflateSync; external;
 223 function uncompress; external;
 224 function zlibCompileFlags; external;
 225 function zlibVersion; external;
 226
 227 function deflateInit(var strm: z_stream; level: Integer): Integer;
 228 begin
 229   Result := deflateInit_(strm, level, ZLIB_VERSION, sizeof(z_stream));
 230 end;
 231
 232 function deflateInit2(var strm: z_stream; level, method, windowBits, memLevel,
 233                       strategy: Integer): Integer;
 234 begin
 235   Result := deflateInit2_(strm, level, method, windowBits, memLevel, strategy,
 236                           ZLIB_VERSION, sizeof(z_stream));
 237 end;
 238
 239 function inflateInit(var strm: z_stream): Integer;
 240 begin
 241   Result := inflateInit_(strm, ZLIB_VERSION, sizeof(z_stream));
 242 end;
 243
 244 function inflateInit2(var strm: z_stream; windowBits: Integer): Integer;
 245 begin
 246   Result := inflateInit2_(strm, windowBits, ZLIB_VERSION, sizeof(z_stream));
 247 end;
 248
 249 function inflateBackInit(var strm: z_stream;
 250                          windowBits: Integer; window: PChar): Integer;
 251 begin
 252   Result := inflateBackInit_(strm, windowBits, window,
 253                              ZLIB_VERSION, sizeof(z_stream));
 254 end;
 255
 256 function _malloc(Size: Integer): Pointer; cdecl;
 257 begin
 258   GetMem(Result, Size);
 259 end;
 260
 261 procedure _free(Block: Pointer); cdecl;
 262 begin
 263   FreeMem(Block);
 264 end;
 265
 266 procedure _memset(P: Pointer; B: Byte; count: Integer); cdecl;
 267 begin
 268   FillChar(P^, count, B);
 269 end;
 270
 271 procedure _memcpy(dest, source: Pointer; count: Integer); cdecl;
 272 begin
 273   Move(source^, dest^, count);
 274 end;
 275
 276 end.