common/dist/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, 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;