Subversion Repositories scarts

----------------------------------------------------------------

--  ZLib for Ada thick binding.                               --

--                                                            --

--  Copyright (C) 2002-2003 Dmitriy Anisimkov                 --

--                                                            --

--  Open source license information is in the zlib.ads file.  --

----------------------------------------------------------------

--  $Id: zlib-thin.ads,v 1.1.1.1 2007/08/18 13:53:33 jeunes2 Exp $

with Interfaces.C.Strings;

with System;

private package ZLib.Thin is

   --  From zconf.h

   MAX_MEM_LEVEL : constant := 9;         --  zconf.h:105

                                          --  zconf.h:105

   MAX_WBITS : constant := 15;      --  zconf.h:115

                                    --  32K LZ77 window

                                    --  zconf.h:115

   SEEK_SET : constant := 8#0000#;  --  zconf.h:244

                                    --  Seek from beginning of file.

                                    --  zconf.h:244

   SEEK_CUR : constant := 1;        --  zconf.h:245

                                    --  Seek from current position.

                                    --  zconf.h:245

   SEEK_END : constant := 2;        --  zconf.h:246

                                    --  Set file pointer to EOF plus "offset"

                                    --  zconf.h:246

   type Byte is new Interfaces.C.unsigned_char; --  8 bits

                                                --  zconf.h:214

   type UInt is new Interfaces.C.unsigned;      --  16 bits or more

                                                --  zconf.h:216

   type Int is new Interfaces.C.int;

   type ULong is new Interfaces.C.unsigned_long;     --  32 bits or more

                                                     --  zconf.h:217

   subtype Chars_Ptr is Interfaces.C.Strings.chars_ptr;

   type ULong_Access is access ULong;

   type Int_Access is access Int;

   subtype Voidp is System.Address;            --  zconf.h:232

   subtype Byte_Access is Voidp;

   Nul : constant Voidp := System.Null_Address;

   --  end from zconf

   Z_NO_FLUSH : constant := 8#0000#;   --  zlib.h:125

                                       --  zlib.h:125

   Z_PARTIAL_FLUSH : constant := 1;       --  zlib.h:126

                                          --  will be removed, use

                                          --  Z_SYNC_FLUSH instead

                                          --  zlib.h:126

   Z_SYNC_FLUSH : constant := 2;       --  zlib.h:127

                                       --  zlib.h:127

   Z_FULL_FLUSH : constant := 3;       --  zlib.h:128

                                       --  zlib.h:128

   Z_FINISH : constant := 4;        --  zlib.h:129

                                    --  zlib.h:129

   Z_OK : constant := 8#0000#;   --  zlib.h:132

                                 --  zlib.h:132

   Z_STREAM_END : constant := 1;       --  zlib.h:133

                                       --  zlib.h:133

   Z_NEED_DICT : constant := 2;        --  zlib.h:134

                                       --  zlib.h:134

   Z_ERRNO : constant := -1;        --  zlib.h:135

                                    --  zlib.h:135

   Z_STREAM_ERROR : constant := -2;       --  zlib.h:136

                                          --  zlib.h:136

   Z_DATA_ERROR : constant := -3;      --  zlib.h:137

                                       --  zlib.h:137

   Z_MEM_ERROR : constant := -4;       --  zlib.h:138

                                       --  zlib.h:138

   Z_BUF_ERROR : constant := -5;       --  zlib.h:139

                                       --  zlib.h:139

   Z_VERSION_ERROR : constant := -6;      --  zlib.h:140

                                          --  zlib.h:140

   Z_NO_COMPRESSION : constant := 8#0000#;   --  zlib.h:145

                                             --  zlib.h:145

   Z_BEST_SPEED : constant := 1;       --  zlib.h:146

                                       --  zlib.h:146

   Z_BEST_COMPRESSION : constant := 9;       --  zlib.h:147

                                             --  zlib.h:147

   Z_DEFAULT_COMPRESSION : constant := -1;      --  zlib.h:148

                                                --  zlib.h:148

   Z_FILTERED : constant := 1;      --  zlib.h:151

                                    --  zlib.h:151

   Z_HUFFMAN_ONLY : constant := 2;        --  zlib.h:152

                                          --  zlib.h:152

   Z_DEFAULT_STRATEGY : constant := 8#0000#; --  zlib.h:153

                                             --  zlib.h:153

   Z_BINARY : constant := 8#0000#;  --  zlib.h:156

                                    --  zlib.h:156

   Z_ASCII : constant := 1;      --  zlib.h:157

                                 --  zlib.h:157

   Z_UNKNOWN : constant := 2;       --  zlib.h:158

                                    --  zlib.h:158

   Z_DEFLATED : constant := 8;      --  zlib.h:161

                                    --  zlib.h:161

   Z_NULL : constant := 8#0000#; --  zlib.h:164

                                 --  for initializing zalloc, zfree, opaque

                                 --  zlib.h:164

   type gzFile is new Voidp;                  --  zlib.h:646

   type Z_Stream is private;

   type Z_Streamp is access all Z_Stream;     --  zlib.h:89

   type alloc_func is access function

     (Opaque : Voidp;

      Items  : UInt;

      Size   : UInt)

      return Voidp; --  zlib.h:63

   type free_func is access procedure (opaque : Voidp; address : Voidp);

   function zlibVersion return Chars_Ptr;

   function Deflate (strm : Z_Streamp; flush : Int) return Int;

   function DeflateEnd (strm : Z_Streamp) return Int;

   function Inflate (strm : Z_Streamp; flush : Int) return Int;

   function InflateEnd (strm : Z_Streamp) return Int;

   function deflateSetDictionary

     (strm       : Z_Streamp;

      dictionary : Byte_Access;

      dictLength : UInt)

      return       Int;

   function deflateCopy (dest : Z_Streamp; source : Z_Streamp) return Int;

   --  zlib.h:478

   function deflateReset (strm : Z_Streamp) return Int; -- zlib.h:495

   function deflateParams

     (strm     : Z_Streamp;

      level    : Int;

      strategy : Int)

      return     Int;       -- zlib.h:506

   function inflateSetDictionary

     (strm       : Z_Streamp;

      dictionary : Byte_Access;

      dictLength : UInt)

      return       Int; --  zlib.h:548

   function inflateSync (strm : Z_Streamp) return Int;  --  zlib.h:565

   function inflateReset (strm : Z_Streamp) return Int; --  zlib.h:580

   function compress

     (dest      : Byte_Access;

      destLen   : ULong_Access;

      source    : Byte_Access;

      sourceLen : ULong)

      return      Int;           -- zlib.h:601

   function compress2

     (dest      : Byte_Access;

      destLen   : ULong_Access;

      source    : Byte_Access;

      sourceLen : ULong;

      level     : Int)

      return      Int;          -- zlib.h:615

   function uncompress

     (dest      : Byte_Access;

      destLen   : ULong_Access;

      source    : Byte_Access;

      sourceLen : ULong)

      return      Int;

   function gzopen (path : Chars_Ptr; mode : Chars_Ptr) return gzFile;

   function gzdopen (fd : Int; mode : Chars_Ptr) return gzFile;

   function gzsetparams

     (file     : gzFile;

      level    : Int;

      strategy : Int)

      return     Int;

   function gzread

     (file : gzFile;

      buf  : Voidp;

      len  : UInt)

      return Int;

   function gzwrite

     (file : in gzFile;

      buf  : in Voidp;

      len  : in UInt)

      return Int;

   function gzprintf (file : in gzFile; format : in Chars_Ptr) return Int;

   function gzputs (file : in gzFile; s : in Chars_Ptr) return Int;

   function gzgets

     (file : gzFile;

      buf  : Chars_Ptr;

      len  : Int)

      return Chars_Ptr;

   function gzputc (file : gzFile; char : Int) return Int;

   function gzgetc (file : gzFile) return Int;

   function gzflush (file : gzFile; flush : Int) return Int;

   function gzseek

     (file   : gzFile;

      offset : Int;

      whence : Int)

      return   Int;

   function gzrewind (file : gzFile) return Int;

   function gztell (file : gzFile) return Int;

   function gzeof (file : gzFile) return Int;

   function gzclose (file : gzFile) return Int;

   function gzerror (file : gzFile; errnum : Int_Access) return Chars_Ptr;

   function adler32

     (adler : ULong;

      buf   : Byte_Access;

      len   : UInt)

      return  ULong;

   function crc32

     (crc  : ULong;

      buf  : Byte_Access;

      len  : UInt)

      return ULong;

   function deflateInit

     (strm        : Z_Streamp;

      level       : Int;

      version     : Chars_Ptr;

      stream_size : Int)

      return        Int;

   function deflateInit2

     (strm        : Z_Streamp;

      level       : Int;

      method      : Int;

      windowBits  : Int;

      memLevel    : Int;

      strategy    : Int;

      version     : Chars_Ptr;

      stream_size : Int)

      return        Int;

   function Deflate_Init

     (strm       : Z_Streamp;

      level      : Int;

      method     : Int;

      windowBits : Int;

      memLevel   : Int;

      strategy   : Int)

      return       Int;

   pragma Inline (Deflate_Init);

   function inflateInit

     (strm        : Z_Streamp;

      version     : Chars_Ptr;

      stream_size : Int)

      return        Int;

   function inflateInit2

     (strm        : in Z_Streamp;

      windowBits  : in Int;

      version     : in Chars_Ptr;

      stream_size : in Int)

      return      Int;

   function inflateBackInit

     (strm        : in Z_Streamp;

      windowBits  : in Int;

      window      : in Byte_Access;

      version     : in Chars_Ptr;

      stream_size : in Int)

      return      Int;

   --  Size of window have to be 2**windowBits.

   function Inflate_Init (strm : Z_Streamp; windowBits : Int) return Int;

   pragma Inline (Inflate_Init);

   function zError (err : Int) return Chars_Ptr;

   function inflateSyncPoint (z : Z_Streamp) return Int;

   function get_crc_table return ULong_Access;

   --  Interface to the available fields of the z_stream structure.

   --  The application must update next_in and avail_in when avail_in has

   --  dropped to zero. It must update next_out and avail_out when avail_out

   --  has dropped to zero. The application must initialize zalloc, zfree and

   --  opaque before calling the init function.

   procedure Set_In

     (Strm   : in out Z_Stream;

      Buffer : in Voidp;

      Size   : in UInt);

   pragma Inline (Set_In);

   procedure Set_Out

     (Strm   : in out Z_Stream;

      Buffer : in Voidp;

      Size   : in UInt);

   pragma Inline (Set_Out);

   procedure Set_Mem_Func

     (Strm   : in out Z_Stream;

      Opaque : in Voidp;

      Alloc  : in alloc_func;

      Free   : in free_func);

   pragma Inline (Set_Mem_Func);

   function Last_Error_Message (Strm : in Z_Stream) return String;

   pragma Inline (Last_Error_Message);

   function Avail_Out (Strm : in Z_Stream) return UInt;

   pragma Inline (Avail_Out);

   function Avail_In (Strm : in Z_Stream) return UInt;

   pragma Inline (Avail_In);

   function Total_In (Strm : in Z_Stream) return ULong;

   pragma Inline (Total_In);

   function Total_Out (Strm : in Z_Stream) return ULong;

   pragma Inline (Total_Out);

   function inflateCopy

     (dest   : in Z_Streamp;

      Source : in Z_Streamp)

      return Int;

   function compressBound (Source_Len : in ULong) return ULong;

   function deflateBound

     (Strm       : in Z_Streamp;

      Source_Len : in ULong)

      return     ULong;

   function gzungetc (C : in Int; File : in  gzFile) return Int;

   function zlibCompileFlags return ULong;

private

   type Z_Stream is record            -- zlib.h:68

      Next_In   : Voidp      := Nul;  -- next input byte

      Avail_In  : UInt       := 0;    -- number of bytes available at next_in

      Total_In  : ULong      := 0;    -- total nb of input bytes read so far

      Next_Out  : Voidp      := Nul;  -- next output byte should be put there

      Avail_Out : UInt       := 0;    -- remaining free space at next_out

      Total_Out : ULong      := 0;    -- total nb of bytes output so far

      msg       : Chars_Ptr;          -- last error message, NULL if no error

      state     : Voidp;              -- not visible by applications

      zalloc    : alloc_func := null; -- used to allocate the internal state

      zfree     : free_func  := null; -- used to free the internal state

      opaque    : Voidp;              -- private data object passed to

                                      --  zalloc and zfree

      data_type : Int;                -- best guess about the data type:

                                      --  ascii or binary

      adler     : ULong;              -- adler32 value of the uncompressed

                                      --  data

      reserved  : ULong;              -- reserved for future use

   end record;

   pragma Convention (C, Z_Stream);

   pragma Import (C, zlibVersion, "zlibVersion");

   pragma Import (C, Deflate, "deflate");

   pragma Import (C, DeflateEnd, "deflateEnd");

   pragma Import (C, Inflate, "inflate");

   pragma Import (C, InflateEnd, "inflateEnd");

   pragma Import (C, deflateSetDictionary, "deflateSetDictionary");

   pragma Import (C, deflateCopy, "deflateCopy");

   pragma Import (C, deflateReset, "deflateReset");

   pragma Import (C, deflateParams, "deflateParams");

   pragma Import (C, inflateSetDictionary, "inflateSetDictionary");

   pragma Import (C, inflateSync, "inflateSync");

   pragma Import (C, inflateReset, "inflateReset");

   pragma Import (C, compress, "compress");

   pragma Import (C, compress2, "compress2");

   pragma Import (C, uncompress, "uncompress");

   pragma Import (C, gzopen, "gzopen");

   pragma Import (C, gzdopen, "gzdopen");

   pragma Import (C, gzsetparams, "gzsetparams");

   pragma Import (C, gzread, "gzread");

   pragma Import (C, gzwrite, "gzwrite");

   pragma Import (C, gzprintf, "gzprintf");

   pragma Import (C, gzputs, "gzputs");

   pragma Import (C, gzgets, "gzgets");

   pragma Import (C, gzputc, "gzputc");

   pragma Import (C, gzgetc, "gzgetc");

   pragma Import (C, gzflush, "gzflush");

   pragma Import (C, gzseek, "gzseek");

   pragma Import (C, gzrewind, "gzrewind");

   pragma Import (C, gztell, "gztell");

   pragma Import (C, gzeof, "gzeof");

   pragma Import (C, gzclose, "gzclose");

   pragma Import (C, gzerror, "gzerror");

   pragma Import (C, adler32, "adler32");

   pragma Import (C, crc32, "crc32");

   pragma Import (C, deflateInit, "deflateInit_");

   pragma Import (C, inflateInit, "inflateInit_");

   pragma Import (C, deflateInit2, "deflateInit2_");

   pragma Import (C, inflateInit2, "inflateInit2_");

   pragma Import (C, zError, "zError");

   pragma Import (C, inflateSyncPoint, "inflateSyncPoint");

   pragma Import (C, get_crc_table, "get_crc_table");

   --  since zlib 1.2.0:

   pragma Import (C, inflateCopy, "inflateCopy");

   pragma Import (C, compressBound, "compressBound");

   pragma Import (C, deflateBound, "deflateBound");

   pragma Import (C, gzungetc, "gzungetc");

   pragma Import (C, zlibCompileFlags, "zlibCompileFlags");

   pragma Import (C, inflateBackInit, "inflateBackInit_");

   --  I stopped binding the inflateBack routines, becouse realize that

   --  it does not support zlib and gzip headers for now, and have no

   --  symmetric deflateBack routines.

   --  ZLib-Ada is symmetric regarding deflate/inflate data transformation

   --  and has a similar generic callback interface for the

   --  deflate/inflate transformation based on the regular Deflate/Inflate

   --  routines.

   --  pragma Import (C, inflateBack, "inflateBack");

   --  pragma Import (C, inflateBackEnd, "inflateBackEnd");

end ZLib.Thin;