Commit | Line | Data |
---|---|---|
5ca28f79 L |
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 | |
9c7e3b0e | 13 | ZLIB_VERSION = '1.2.11'; |
de1ab01e | 14 | ZLIB_VERNUM = $12a0; |
5ca28f79 L |
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. |