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

-- 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.11 2004/07/23 06:33:11 vagul 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, because 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;