|
1 ---------------------------------------------------------------- |
|
2 -- ZLib for Ada thick binding. -- |
|
3 -- -- |
|
4 -- Copyright (C) 2002-2003 Dmitriy Anisimkov -- |
|
5 -- -- |
|
6 -- Open source license information is in the zlib.ads file. -- |
|
7 ---------------------------------------------------------------- |
|
8 |
|
9 -- $Id: zlib-thin.ads,v 1.11 2004/07/23 06:33:11 vagul Exp $ |
|
10 |
|
11 with Interfaces.C.Strings; |
|
12 |
|
13 with System; |
|
14 |
|
15 private package ZLib.Thin is |
|
16 |
|
17 -- From zconf.h |
|
18 |
|
19 MAX_MEM_LEVEL : constant := 9; -- zconf.h:105 |
|
20 -- zconf.h:105 |
|
21 MAX_WBITS : constant := 15; -- zconf.h:115 |
|
22 -- 32K LZ77 window |
|
23 -- zconf.h:115 |
|
24 SEEK_SET : constant := 8#0000#; -- zconf.h:244 |
|
25 -- Seek from beginning of file. |
|
26 -- zconf.h:244 |
|
27 SEEK_CUR : constant := 1; -- zconf.h:245 |
|
28 -- Seek from current position. |
|
29 -- zconf.h:245 |
|
30 SEEK_END : constant := 2; -- zconf.h:246 |
|
31 -- Set file pointer to EOF plus "offset" |
|
32 -- zconf.h:246 |
|
33 |
|
34 type Byte is new Interfaces.C.unsigned_char; -- 8 bits |
|
35 -- zconf.h:214 |
|
36 type UInt is new Interfaces.C.unsigned; -- 16 bits or more |
|
37 -- zconf.h:216 |
|
38 type Int is new Interfaces.C.int; |
|
39 |
|
40 type ULong is new Interfaces.C.unsigned_long; -- 32 bits or more |
|
41 -- zconf.h:217 |
|
42 subtype Chars_Ptr is Interfaces.C.Strings.chars_ptr; |
|
43 |
|
44 type ULong_Access is access ULong; |
|
45 type Int_Access is access Int; |
|
46 |
|
47 subtype Voidp is System.Address; -- zconf.h:232 |
|
48 |
|
49 subtype Byte_Access is Voidp; |
|
50 |
|
51 Nul : constant Voidp := System.Null_Address; |
|
52 -- end from zconf |
|
53 |
|
54 Z_NO_FLUSH : constant := 8#0000#; -- zlib.h:125 |
|
55 -- zlib.h:125 |
|
56 Z_PARTIAL_FLUSH : constant := 1; -- zlib.h:126 |
|
57 -- will be removed, use |
|
58 -- Z_SYNC_FLUSH instead |
|
59 -- zlib.h:126 |
|
60 Z_SYNC_FLUSH : constant := 2; -- zlib.h:127 |
|
61 -- zlib.h:127 |
|
62 Z_FULL_FLUSH : constant := 3; -- zlib.h:128 |
|
63 -- zlib.h:128 |
|
64 Z_FINISH : constant := 4; -- zlib.h:129 |
|
65 -- zlib.h:129 |
|
66 Z_OK : constant := 8#0000#; -- zlib.h:132 |
|
67 -- zlib.h:132 |
|
68 Z_STREAM_END : constant := 1; -- zlib.h:133 |
|
69 -- zlib.h:133 |
|
70 Z_NEED_DICT : constant := 2; -- zlib.h:134 |
|
71 -- zlib.h:134 |
|
72 Z_ERRNO : constant := -1; -- zlib.h:135 |
|
73 -- zlib.h:135 |
|
74 Z_STREAM_ERROR : constant := -2; -- zlib.h:136 |
|
75 -- zlib.h:136 |
|
76 Z_DATA_ERROR : constant := -3; -- zlib.h:137 |
|
77 -- zlib.h:137 |
|
78 Z_MEM_ERROR : constant := -4; -- zlib.h:138 |
|
79 -- zlib.h:138 |
|
80 Z_BUF_ERROR : constant := -5; -- zlib.h:139 |
|
81 -- zlib.h:139 |
|
82 Z_VERSION_ERROR : constant := -6; -- zlib.h:140 |
|
83 -- zlib.h:140 |
|
84 Z_NO_COMPRESSION : constant := 8#0000#; -- zlib.h:145 |
|
85 -- zlib.h:145 |
|
86 Z_BEST_SPEED : constant := 1; -- zlib.h:146 |
|
87 -- zlib.h:146 |
|
88 Z_BEST_COMPRESSION : constant := 9; -- zlib.h:147 |
|
89 -- zlib.h:147 |
|
90 Z_DEFAULT_COMPRESSION : constant := -1; -- zlib.h:148 |
|
91 -- zlib.h:148 |
|
92 Z_FILTERED : constant := 1; -- zlib.h:151 |
|
93 -- zlib.h:151 |
|
94 Z_HUFFMAN_ONLY : constant := 2; -- zlib.h:152 |
|
95 -- zlib.h:152 |
|
96 Z_DEFAULT_STRATEGY : constant := 8#0000#; -- zlib.h:153 |
|
97 -- zlib.h:153 |
|
98 Z_BINARY : constant := 8#0000#; -- zlib.h:156 |
|
99 -- zlib.h:156 |
|
100 Z_ASCII : constant := 1; -- zlib.h:157 |
|
101 -- zlib.h:157 |
|
102 Z_UNKNOWN : constant := 2; -- zlib.h:158 |
|
103 -- zlib.h:158 |
|
104 Z_DEFLATED : constant := 8; -- zlib.h:161 |
|
105 -- zlib.h:161 |
|
106 Z_NULL : constant := 8#0000#; -- zlib.h:164 |
|
107 -- for initializing zalloc, zfree, opaque |
|
108 -- zlib.h:164 |
|
109 type gzFile is new Voidp; -- zlib.h:646 |
|
110 |
|
111 type Z_Stream is private; |
|
112 |
|
113 type Z_Streamp is access all Z_Stream; -- zlib.h:89 |
|
114 |
|
115 type alloc_func is access function |
|
116 (Opaque : Voidp; |
|
117 Items : UInt; |
|
118 Size : UInt) |
|
119 return Voidp; -- zlib.h:63 |
|
120 |
|
121 type free_func is access procedure (opaque : Voidp; address : Voidp); |
|
122 |
|
123 function zlibVersion return Chars_Ptr; |
|
124 |
|
125 function Deflate (strm : Z_Streamp; flush : Int) return Int; |
|
126 |
|
127 function DeflateEnd (strm : Z_Streamp) return Int; |
|
128 |
|
129 function Inflate (strm : Z_Streamp; flush : Int) return Int; |
|
130 |
|
131 function InflateEnd (strm : Z_Streamp) return Int; |
|
132 |
|
133 function deflateSetDictionary |
|
134 (strm : Z_Streamp; |
|
135 dictionary : Byte_Access; |
|
136 dictLength : UInt) |
|
137 return Int; |
|
138 |
|
139 function deflateCopy (dest : Z_Streamp; source : Z_Streamp) return Int; |
|
140 -- zlib.h:478 |
|
141 |
|
142 function deflateReset (strm : Z_Streamp) return Int; -- zlib.h:495 |
|
143 |
|
144 function deflateParams |
|
145 (strm : Z_Streamp; |
|
146 level : Int; |
|
147 strategy : Int) |
|
148 return Int; -- zlib.h:506 |
|
149 |
|
150 function inflateSetDictionary |
|
151 (strm : Z_Streamp; |
|
152 dictionary : Byte_Access; |
|
153 dictLength : UInt) |
|
154 return Int; -- zlib.h:548 |
|
155 |
|
156 function inflateSync (strm : Z_Streamp) return Int; -- zlib.h:565 |
|
157 |
|
158 function inflateReset (strm : Z_Streamp) return Int; -- zlib.h:580 |
|
159 |
|
160 function compress |
|
161 (dest : Byte_Access; |
|
162 destLen : ULong_Access; |
|
163 source : Byte_Access; |
|
164 sourceLen : ULong) |
|
165 return Int; -- zlib.h:601 |
|
166 |
|
167 function compress2 |
|
168 (dest : Byte_Access; |
|
169 destLen : ULong_Access; |
|
170 source : Byte_Access; |
|
171 sourceLen : ULong; |
|
172 level : Int) |
|
173 return Int; -- zlib.h:615 |
|
174 |
|
175 function uncompress |
|
176 (dest : Byte_Access; |
|
177 destLen : ULong_Access; |
|
178 source : Byte_Access; |
|
179 sourceLen : ULong) |
|
180 return Int; |
|
181 |
|
182 function gzopen (path : Chars_Ptr; mode : Chars_Ptr) return gzFile; |
|
183 |
|
184 function gzdopen (fd : Int; mode : Chars_Ptr) return gzFile; |
|
185 |
|
186 function gzsetparams |
|
187 (file : gzFile; |
|
188 level : Int; |
|
189 strategy : Int) |
|
190 return Int; |
|
191 |
|
192 function gzread |
|
193 (file : gzFile; |
|
194 buf : Voidp; |
|
195 len : UInt) |
|
196 return Int; |
|
197 |
|
198 function gzwrite |
|
199 (file : in gzFile; |
|
200 buf : in Voidp; |
|
201 len : in UInt) |
|
202 return Int; |
|
203 |
|
204 function gzprintf (file : in gzFile; format : in Chars_Ptr) return Int; |
|
205 |
|
206 function gzputs (file : in gzFile; s : in Chars_Ptr) return Int; |
|
207 |
|
208 function gzgets |
|
209 (file : gzFile; |
|
210 buf : Chars_Ptr; |
|
211 len : Int) |
|
212 return Chars_Ptr; |
|
213 |
|
214 function gzputc (file : gzFile; char : Int) return Int; |
|
215 |
|
216 function gzgetc (file : gzFile) return Int; |
|
217 |
|
218 function gzflush (file : gzFile; flush : Int) return Int; |
|
219 |
|
220 function gzseek |
|
221 (file : gzFile; |
|
222 offset : Int; |
|
223 whence : Int) |
|
224 return Int; |
|
225 |
|
226 function gzrewind (file : gzFile) return Int; |
|
227 |
|
228 function gztell (file : gzFile) return Int; |
|
229 |
|
230 function gzeof (file : gzFile) return Int; |
|
231 |
|
232 function gzclose (file : gzFile) return Int; |
|
233 |
|
234 function gzerror (file : gzFile; errnum : Int_Access) return Chars_Ptr; |
|
235 |
|
236 function adler32 |
|
237 (adler : ULong; |
|
238 buf : Byte_Access; |
|
239 len : UInt) |
|
240 return ULong; |
|
241 |
|
242 function crc32 |
|
243 (crc : ULong; |
|
244 buf : Byte_Access; |
|
245 len : UInt) |
|
246 return ULong; |
|
247 |
|
248 function deflateInit |
|
249 (strm : Z_Streamp; |
|
250 level : Int; |
|
251 version : Chars_Ptr; |
|
252 stream_size : Int) |
|
253 return Int; |
|
254 |
|
255 function deflateInit2 |
|
256 (strm : Z_Streamp; |
|
257 level : Int; |
|
258 method : Int; |
|
259 windowBits : Int; |
|
260 memLevel : Int; |
|
261 strategy : Int; |
|
262 version : Chars_Ptr; |
|
263 stream_size : Int) |
|
264 return Int; |
|
265 |
|
266 function Deflate_Init |
|
267 (strm : Z_Streamp; |
|
268 level : Int; |
|
269 method : Int; |
|
270 windowBits : Int; |
|
271 memLevel : Int; |
|
272 strategy : Int) |
|
273 return Int; |
|
274 pragma Inline (Deflate_Init); |
|
275 |
|
276 function inflateInit |
|
277 (strm : Z_Streamp; |
|
278 version : Chars_Ptr; |
|
279 stream_size : Int) |
|
280 return Int; |
|
281 |
|
282 function inflateInit2 |
|
283 (strm : in Z_Streamp; |
|
284 windowBits : in Int; |
|
285 version : in Chars_Ptr; |
|
286 stream_size : in Int) |
|
287 return Int; |
|
288 |
|
289 function inflateBackInit |
|
290 (strm : in Z_Streamp; |
|
291 windowBits : in Int; |
|
292 window : in Byte_Access; |
|
293 version : in Chars_Ptr; |
|
294 stream_size : in Int) |
|
295 return Int; |
|
296 -- Size of window have to be 2**windowBits. |
|
297 |
|
298 function Inflate_Init (strm : Z_Streamp; windowBits : Int) return Int; |
|
299 pragma Inline (Inflate_Init); |
|
300 |
|
301 function zError (err : Int) return Chars_Ptr; |
|
302 |
|
303 function inflateSyncPoint (z : Z_Streamp) return Int; |
|
304 |
|
305 function get_crc_table return ULong_Access; |
|
306 |
|
307 -- Interface to the available fields of the z_stream structure. |
|
308 -- The application must update next_in and avail_in when avail_in has |
|
309 -- dropped to zero. It must update next_out and avail_out when avail_out |
|
310 -- has dropped to zero. The application must initialize zalloc, zfree and |
|
311 -- opaque before calling the init function. |
|
312 |
|
313 procedure Set_In |
|
314 (Strm : in out Z_Stream; |
|
315 Buffer : in Voidp; |
|
316 Size : in UInt); |
|
317 pragma Inline (Set_In); |
|
318 |
|
319 procedure Set_Out |
|
320 (Strm : in out Z_Stream; |
|
321 Buffer : in Voidp; |
|
322 Size : in UInt); |
|
323 pragma Inline (Set_Out); |
|
324 |
|
325 procedure Set_Mem_Func |
|
326 (Strm : in out Z_Stream; |
|
327 Opaque : in Voidp; |
|
328 Alloc : in alloc_func; |
|
329 Free : in free_func); |
|
330 pragma Inline (Set_Mem_Func); |
|
331 |
|
332 function Last_Error_Message (Strm : in Z_Stream) return String; |
|
333 pragma Inline (Last_Error_Message); |
|
334 |
|
335 function Avail_Out (Strm : in Z_Stream) return UInt; |
|
336 pragma Inline (Avail_Out); |
|
337 |
|
338 function Avail_In (Strm : in Z_Stream) return UInt; |
|
339 pragma Inline (Avail_In); |
|
340 |
|
341 function Total_In (Strm : in Z_Stream) return ULong; |
|
342 pragma Inline (Total_In); |
|
343 |
|
344 function Total_Out (Strm : in Z_Stream) return ULong; |
|
345 pragma Inline (Total_Out); |
|
346 |
|
347 function inflateCopy |
|
348 (dest : in Z_Streamp; |
|
349 Source : in Z_Streamp) |
|
350 return Int; |
|
351 |
|
352 function compressBound (Source_Len : in ULong) return ULong; |
|
353 |
|
354 function deflateBound |
|
355 (Strm : in Z_Streamp; |
|
356 Source_Len : in ULong) |
|
357 return ULong; |
|
358 |
|
359 function gzungetc (C : in Int; File : in gzFile) return Int; |
|
360 |
|
361 function zlibCompileFlags return ULong; |
|
362 |
|
363 private |
|
364 |
|
365 type Z_Stream is record -- zlib.h:68 |
|
366 Next_In : Voidp := Nul; -- next input byte |
|
367 Avail_In : UInt := 0; -- number of bytes available at next_in |
|
368 Total_In : ULong := 0; -- total nb of input bytes read so far |
|
369 Next_Out : Voidp := Nul; -- next output byte should be put there |
|
370 Avail_Out : UInt := 0; -- remaining free space at next_out |
|
371 Total_Out : ULong := 0; -- total nb of bytes output so far |
|
372 msg : Chars_Ptr; -- last error message, NULL if no error |
|
373 state : Voidp; -- not visible by applications |
|
374 zalloc : alloc_func := null; -- used to allocate the internal state |
|
375 zfree : free_func := null; -- used to free the internal state |
|
376 opaque : Voidp; -- private data object passed to |
|
377 -- zalloc and zfree |
|
378 data_type : Int; -- best guess about the data type: |
|
379 -- ascii or binary |
|
380 adler : ULong; -- adler32 value of the uncompressed |
|
381 -- data |
|
382 reserved : ULong; -- reserved for future use |
|
383 end record; |
|
384 |
|
385 pragma Convention (C, Z_Stream); |
|
386 |
|
387 pragma Import (C, zlibVersion, "zlibVersion"); |
|
388 pragma Import (C, Deflate, "deflate"); |
|
389 pragma Import (C, DeflateEnd, "deflateEnd"); |
|
390 pragma Import (C, Inflate, "inflate"); |
|
391 pragma Import (C, InflateEnd, "inflateEnd"); |
|
392 pragma Import (C, deflateSetDictionary, "deflateSetDictionary"); |
|
393 pragma Import (C, deflateCopy, "deflateCopy"); |
|
394 pragma Import (C, deflateReset, "deflateReset"); |
|
395 pragma Import (C, deflateParams, "deflateParams"); |
|
396 pragma Import (C, inflateSetDictionary, "inflateSetDictionary"); |
|
397 pragma Import (C, inflateSync, "inflateSync"); |
|
398 pragma Import (C, inflateReset, "inflateReset"); |
|
399 pragma Import (C, compress, "compress"); |
|
400 pragma Import (C, compress2, "compress2"); |
|
401 pragma Import (C, uncompress, "uncompress"); |
|
402 pragma Import (C, gzopen, "gzopen"); |
|
403 pragma Import (C, gzdopen, "gzdopen"); |
|
404 pragma Import (C, gzsetparams, "gzsetparams"); |
|
405 pragma Import (C, gzread, "gzread"); |
|
406 pragma Import (C, gzwrite, "gzwrite"); |
|
407 pragma Import (C, gzprintf, "gzprintf"); |
|
408 pragma Import (C, gzputs, "gzputs"); |
|
409 pragma Import (C, gzgets, "gzgets"); |
|
410 pragma Import (C, gzputc, "gzputc"); |
|
411 pragma Import (C, gzgetc, "gzgetc"); |
|
412 pragma Import (C, gzflush, "gzflush"); |
|
413 pragma Import (C, gzseek, "gzseek"); |
|
414 pragma Import (C, gzrewind, "gzrewind"); |
|
415 pragma Import (C, gztell, "gztell"); |
|
416 pragma Import (C, gzeof, "gzeof"); |
|
417 pragma Import (C, gzclose, "gzclose"); |
|
418 pragma Import (C, gzerror, "gzerror"); |
|
419 pragma Import (C, adler32, "adler32"); |
|
420 pragma Import (C, crc32, "crc32"); |
|
421 pragma Import (C, deflateInit, "deflateInit_"); |
|
422 pragma Import (C, inflateInit, "inflateInit_"); |
|
423 pragma Import (C, deflateInit2, "deflateInit2_"); |
|
424 pragma Import (C, inflateInit2, "inflateInit2_"); |
|
425 pragma Import (C, zError, "zError"); |
|
426 pragma Import (C, inflateSyncPoint, "inflateSyncPoint"); |
|
427 pragma Import (C, get_crc_table, "get_crc_table"); |
|
428 |
|
429 -- since zlib 1.2.0: |
|
430 |
|
431 pragma Import (C, inflateCopy, "inflateCopy"); |
|
432 pragma Import (C, compressBound, "compressBound"); |
|
433 pragma Import (C, deflateBound, "deflateBound"); |
|
434 pragma Import (C, gzungetc, "gzungetc"); |
|
435 pragma Import (C, zlibCompileFlags, "zlibCompileFlags"); |
|
436 |
|
437 pragma Import (C, inflateBackInit, "inflateBackInit_"); |
|
438 |
|
439 -- I stopped binding the inflateBack routines, becouse realize that |
|
440 -- it does not support zlib and gzip headers for now, and have no |
|
441 -- symmetric deflateBack routines. |
|
442 -- ZLib-Ada is symmetric regarding deflate/inflate data transformation |
|
443 -- and has a similar generic callback interface for the |
|
444 -- deflate/inflate transformation based on the regular Deflate/Inflate |
|
445 -- routines. |
|
446 |
|
447 -- pragma Import (C, inflateBack, "inflateBack"); |
|
448 -- pragma Import (C, inflateBackEnd, "inflateBackEnd"); |
|
449 |
|
450 end ZLib.Thin; |