third_party/zlib: Initial copy of zlib.
[sfrench/samba-autobuild/.git] / third_party / zlib / contrib / ada / zlib-thin.ads
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;