| 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.13'; |
| 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. |