zlib-thin.ads@ 78319

Last change on this file since 78319 was 58208, checked in by vboxsync, 9 years ago
zlib 1.2.8 unmodified
Property svn:eol-style set to `native`
File size: 15.4 KB

Line
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;

Note: See TracBrowser for help on using the repository browser.

source: vbox/trunk/src/libs/zlib-1.2.8/contrib/ada/zlib-thin.ads@ 78319

Download in other formats: