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 11with Interfaces.C.Strings; 12 13with System; 14 15private 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 363private 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, because 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 450end ZLib.Thin; 451