Commit | Line | Data |
---|---|---|
5ca28f79 L |
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; |