"Fossies" - the Fresh Open Source Software Archive

Member "muscle/zlib/zlib/contrib/ada/zlib-thin.ads" (21 Nov 2020, 15819 Bytes) of package /linux/privat/muscle7.62.zip:


As a special service "Fossies" has tried to format the requested source page into HTML format using (guessed) ADA95 source code syntax highlighting (style: standard) with prefixed line numbers. Alternatively you can here view or download the uninterpreted source code file. See also the latest Fossies "Diffs" side-by-side code changes report for "zlib-thin.ads": 7.61_vs_7.62.

    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, 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 
  450 end ZLib.Thin;