9e052883 |
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, because 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; |