← Back to branch summary

~ubuntu-branches/ubuntu/natty/luatex/natty

« back to all changes in this revision

Viewing changes to source/libs/zlib/zlib-1.2.5/contrib/ada/zlib-thin.ads

  • Committer: Package Import Robot
  • Author(s): Norbert Preining
  • Date: 2010-12-13 23:22:59 UTC
  • mfrom: (0.2.1) (1.5.4) (4.3.12 experimental)
  • Revision ID: package-import@ubuntu.com-20101213232259-nqq2mq5z5x6qldw3
Tags: 0.65.0-1
* new upstream release
* ship two source packages as they are distributed by upstream, only
  renamed to match source package requirements. Fix debian/rules
  to install the manual pdf from the right place

Show diffs side-by-side

added added

removed removed

Lines of Context:
source/libs/zlib/zlib-1.2.5/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, 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;