1 ----------------------------------------------------------------
2 -- ZLib for Ada thick binding. --
4 -- Copyright (C) 2002-2003 Dmitriy Anisimkov --
6 -- Open source license information is in the zlib.ads file. --
7 ----------------------------------------------------------------
9 -- $Id: zlib-thin.ads,v 1.11 2004/07/23 06:33:11 vagul Exp $
11 with Interfaces.C.Strings;
15 private package ZLib.Thin is
19 MAX_MEM_LEVEL : constant := 9; -- zconf.h:105
21 MAX_WBITS : constant := 15; -- zconf.h:115
24 SEEK_SET : constant := 8#0000#; -- zconf.h:244
25 -- Seek from beginning of file.
27 SEEK_CUR : constant := 1; -- zconf.h:245
28 -- Seek from current position.
30 SEEK_END : constant := 2; -- zconf.h:246
31 -- Set file pointer to EOF plus "offset"
34 type Byte is new Interfaces.C.unsigned_char; -- 8 bits
36 type UInt is new Interfaces.C.unsigned; -- 16 bits or more
38 type Int is new Interfaces.C.int;
40 type ULong is new Interfaces.C.unsigned_long; -- 32 bits or more
42 subtype Chars_Ptr is Interfaces.C.Strings.chars_ptr;
44 type ULong_Access is access ULong;
45 type Int_Access is access Int;
47 subtype Voidp is System.Address; -- zconf.h:232
49 subtype Byte_Access is Voidp;
51 Nul : constant Voidp := System.Null_Address;
54 Z_NO_FLUSH : constant := 8#0000#; -- zlib.h:125
56 Z_PARTIAL_FLUSH : constant := 1; -- zlib.h:126
57 -- will be removed, use
58 -- Z_SYNC_FLUSH instead
60 Z_SYNC_FLUSH : constant := 2; -- zlib.h:127
62 Z_FULL_FLUSH : constant := 3; -- zlib.h:128
64 Z_FINISH : constant := 4; -- zlib.h:129
66 Z_OK : constant := 8#0000#; -- zlib.h:132
68 Z_STREAM_END : constant := 1; -- zlib.h:133
70 Z_NEED_DICT : constant := 2; -- zlib.h:134
72 Z_ERRNO : constant := -1; -- zlib.h:135
74 Z_STREAM_ERROR : constant := -2; -- zlib.h:136
76 Z_DATA_ERROR : constant := -3; -- zlib.h:137
78 Z_MEM_ERROR : constant := -4; -- zlib.h:138
80 Z_BUF_ERROR : constant := -5; -- zlib.h:139
82 Z_VERSION_ERROR : constant := -6; -- zlib.h:140
84 Z_NO_COMPRESSION : constant := 8#0000#; -- zlib.h:145
86 Z_BEST_SPEED : constant := 1; -- zlib.h:146
88 Z_BEST_COMPRESSION : constant := 9; -- zlib.h:147
90 Z_DEFAULT_COMPRESSION : constant := -1; -- zlib.h:148
92 Z_FILTERED : constant := 1; -- zlib.h:151
94 Z_HUFFMAN_ONLY : constant := 2; -- zlib.h:152
96 Z_DEFAULT_STRATEGY : constant := 8#0000#; -- zlib.h:153
98 Z_BINARY : constant := 8#0000#; -- zlib.h:156
100 Z_ASCII : constant := 1; -- zlib.h:157
102 Z_UNKNOWN : constant := 2; -- zlib.h:158
104 Z_DEFLATED : constant := 8; -- zlib.h:161
106 Z_NULL : constant := 8#0000#; -- zlib.h:164
107 -- for initializing zalloc, zfree, opaque
109 type gzFile is new Voidp; -- zlib.h:646
111 type Z_Stream is private;
113 type Z_Streamp is access all Z_Stream; -- zlib.h:89
115 type alloc_func is access function
119 return Voidp; -- zlib.h:63
121 type free_func is access procedure (opaque : Voidp; address : Voidp);
123 function zlibVersion return Chars_Ptr;
125 function Deflate (strm : Z_Streamp; flush : Int) return Int;
127 function DeflateEnd (strm : Z_Streamp) return Int;
129 function Inflate (strm : Z_Streamp; flush : Int) return Int;
131 function InflateEnd (strm : Z_Streamp) return Int;
133 function deflateSetDictionary
135 dictionary : Byte_Access;
139 function deflateCopy (dest : Z_Streamp; source : Z_Streamp) return Int;
142 function deflateReset (strm : Z_Streamp) return Int; -- zlib.h:495
144 function deflateParams
148 return Int; -- zlib.h:506
150 function inflateSetDictionary
152 dictionary : Byte_Access;
154 return Int; -- zlib.h:548
156 function inflateSync (strm : Z_Streamp) return Int; -- zlib.h:565
158 function inflateReset (strm : Z_Streamp) return Int; -- zlib.h:580
162 destLen : ULong_Access;
163 source : Byte_Access;
165 return Int; -- zlib.h:601
169 destLen : ULong_Access;
170 source : Byte_Access;
173 return Int; -- zlib.h:615
177 destLen : ULong_Access;
178 source : Byte_Access;
182 function gzopen (path : Chars_Ptr; mode : Chars_Ptr) return gzFile;
184 function gzdopen (fd : Int; mode : Chars_Ptr) return gzFile;
204 function gzprintf (file : in gzFile; format : in Chars_Ptr) return Int;
206 function gzputs (file : in gzFile; s : in Chars_Ptr) return Int;
214 function gzputc (file : gzFile; char : Int) return Int;
216 function gzgetc (file : gzFile) return Int;
218 function gzflush (file : gzFile; flush : Int) return Int;
226 function gzrewind (file : gzFile) return Int;
228 function gztell (file : gzFile) return Int;
230 function gzeof (file : gzFile) return Int;
232 function gzclose (file : gzFile) return Int;
234 function gzerror (file : gzFile; errnum : Int_Access) return Chars_Ptr;
255 function deflateInit2
266 function Deflate_Init
274 pragma Inline (Deflate_Init);
282 function inflateInit2
283 (strm : in Z_Streamp;
285 version : in Chars_Ptr;
286 stream_size : in Int)
289 function inflateBackInit
290 (strm : in Z_Streamp;
292 window : in Byte_Access;
293 version : in Chars_Ptr;
294 stream_size : in Int)
296 -- Size of window have to be 2**windowBits.
298 function Inflate_Init (strm : Z_Streamp; windowBits : Int) return Int;
299 pragma Inline (Inflate_Init);
301 function zError (err : Int) return Chars_Ptr;
303 function inflateSyncPoint (z : Z_Streamp) return Int;
305 function get_crc_table return ULong_Access;
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.
314 (Strm : in out Z_Stream;
317 pragma Inline (Set_In);
320 (Strm : in out Z_Stream;
323 pragma Inline (Set_Out);
325 procedure Set_Mem_Func
326 (Strm : in out Z_Stream;
328 Alloc : in alloc_func;
329 Free : in free_func);
330 pragma Inline (Set_Mem_Func);
332 function Last_Error_Message (Strm : in Z_Stream) return String;
333 pragma Inline (Last_Error_Message);
335 function Avail_Out (Strm : in Z_Stream) return UInt;
336 pragma Inline (Avail_Out);
338 function Avail_In (Strm : in Z_Stream) return UInt;
339 pragma Inline (Avail_In);
341 function Total_In (Strm : in Z_Stream) return ULong;
342 pragma Inline (Total_In);
344 function Total_Out (Strm : in Z_Stream) return ULong;
345 pragma Inline (Total_Out);
348 (dest : in Z_Streamp;
349 Source : in Z_Streamp)
352 function compressBound (Source_Len : in ULong) return ULong;
354 function deflateBound
355 (Strm : in Z_Streamp;
356 Source_Len : in ULong)
359 function gzungetc (C : in Int; File : in gzFile) return Int;
361 function zlibCompileFlags return ULong;
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
378 data_type : Int; -- best guess about the data type:
380 adler : ULong; -- adler32 value of the uncompressed
382 reserved : ULong; -- reserved for future use
385 pragma Convention (C, Z_Stream);
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");
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");
437 pragma Import (C, inflateBackInit, "inflateBackInit_");
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
447 -- pragma Import (C, inflateBack, "inflateBack");
448 -- pragma Import (C, inflateBackEnd, "inflateBackEnd");