Mercurial > hg > sv-dependency-builds

comparison src/zlib-1.2.8/contrib/ada/zlib-thin.ads @ 43:5ea0608b923f

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
Current zlib source
author Chris Cannam
date Tue, 18 Oct 2016 14:33:52 +0100
parents
children
comparison
equal deleted inserted replaced
42:2cd0e3b3e1fd 43:5ea0608b923f
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;