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
11with Interfaces.C.Strings;
12
13with System;
14
15private 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
363private
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
450end ZLib.Thin;
451