开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > Windows编程 > 通讯编程 > 查看源码
zlib-thin.ads
资源名称：ns-allinone-2.33.tar.gz　[点击查看]
上传用户：rrhhcc
上传日期：2015-12-11
资源大小：54129k
文件大小：15k
源码类别：

通讯编程

开发平台：

Visual C++

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. ----------------------------------------------------------------
  9. --  $Id: zlib-thin.ads,v 1.11 2004/07/23 06:33:11 vagul Exp $
  11. with Interfaces.C.Strings;
  13. with System;
  15. private package ZLib.Thin is
  17.    --  From zconf.h
  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
  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;
  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;
  44.    type ULong_Access is access ULong;
  45.    type Int_Access is access Int;
  47.    subtype Voidp is System.Address;            --  zconf.h:232
  49.    subtype Byte_Access is Voidp;
  51.    Nul : constant Voidp := System.Null_Address;
  52.    --  end from zconf
  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
  111.    type Z_Stream is private;
  113.    type Z_Streamp is access all Z_Stream;     --  zlib.h:89
  115.    type alloc_func is access function
  116.      (Opaque : Voidp;
  117.       Items  : UInt;
  118.       Size   : UInt)
  119.       return Voidp; --  zlib.h:63
  121.    type free_func is access procedure (opaque : Voidp; address : Voidp);
  123.    function zlibVersion return Chars_Ptr;
  125.    function Deflate (strm : Z_Streamp; flush : Int) return Int;
  127.    function DeflateEnd (strm : Z_Streamp) return Int;
  129.    function Inflate (strm : Z_Streamp; flush : Int) return Int;
  131.    function InflateEnd (strm : Z_Streamp) return Int;
  133.    function deflateSetDictionary
  134.      (strm       : Z_Streamp;
  135.       dictionary : Byte_Access;
  136.       dictLength : UInt)
  137.       return       Int;
  139.    function deflateCopy (dest : Z_Streamp; source : Z_Streamp) return Int;
  140.    --  zlib.h:478
  142.    function deflateReset (strm : Z_Streamp) return Int; -- zlib.h:495
  144.    function deflateParams
  145.      (strm     : Z_Streamp;
  146.       level    : Int;
  147.       strategy : Int)
  148.       return     Int;       -- zlib.h:506
  150.    function inflateSetDictionary
  151.      (strm       : Z_Streamp;
  152.       dictionary : Byte_Access;
  153.       dictLength : UInt)
  154.       return       Int; --  zlib.h:548
  156.    function inflateSync (strm : Z_Streamp) return Int;  --  zlib.h:565
  158.    function inflateReset (strm : Z_Streamp) return Int; --  zlib.h:580
  160.    function compress
  161.      (dest      : Byte_Access;
  162.       destLen   : ULong_Access;
  163.       source    : Byte_Access;
  164.       sourceLen : ULong)
  165.       return      Int;           -- zlib.h:601
  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
  175.    function uncompress
  176.      (dest      : Byte_Access;
  177.       destLen   : ULong_Access;
  178.       source    : Byte_Access;
  179.       sourceLen : ULong)
  180.       return      Int;
  182.    function gzopen (path : Chars_Ptr; mode : Chars_Ptr) return gzFile;
  184.    function gzdopen (fd : Int; mode : Chars_Ptr) return gzFile;
  186.    function gzsetparams
  187.      (file     : gzFile;
  188.       level    : Int;
  189.       strategy : Int)
  190.       return     Int;
  192.    function gzread
  193.      (file : gzFile;
  194.       buf  : Voidp;
  195.       len  : UInt)
  196.       return Int;
  198.    function gzwrite
  199.      (file : in gzFile;
  200.       buf  : in Voidp;
  201.       len  : in UInt)
  202.       return Int;
  204.    function gzprintf (file : in gzFile; format : in Chars_Ptr) return Int;
  206.    function gzputs (file : in gzFile; s : in Chars_Ptr) return Int;
  208.    function gzgets
  209.      (file : gzFile;
  210.       buf  : Chars_Ptr;
  211.       len  : Int)
  212.       return Chars_Ptr;
  214.    function gzputc (file : gzFile; char : Int) return Int;
  216.    function gzgetc (file : gzFile) return Int;
  218.    function gzflush (file : gzFile; flush : Int) return Int;
  220.    function gzseek
  221.      (file   : gzFile;
  222.       offset : Int;
  223.       whence : Int)
  224.       return   Int;
  226.    function gzrewind (file : gzFile) return Int;
  228.    function gztell (file : gzFile) return Int;
  230.    function gzeof (file : gzFile) return Int;
  232.    function gzclose (file : gzFile) return Int;
  234.    function gzerror (file : gzFile; errnum : Int_Access) return Chars_Ptr;
  236.    function adler32
  237.      (adler : ULong;
  238.       buf   : Byte_Access;
  239.       len   : UInt)
  240.       return  ULong;
  242.    function crc32
  243.      (crc  : ULong;
  244.       buf  : Byte_Access;
  245.       len  : UInt)
  246.       return ULong;
  248.    function deflateInit
  249.      (strm        : Z_Streamp;
  250.       level       : Int;
  251.       version     : Chars_Ptr;
  252.       stream_size : Int)
  253.       return        Int;
  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;
  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);
  276.    function inflateInit
  277.      (strm        : Z_Streamp;
  278.       version     : Chars_Ptr;
  279.       stream_size : Int)
  280.       return        Int;
  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;
  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.
  298.    function Inflate_Init (strm : Z_Streamp; windowBits : Int) return Int;
  299.    pragma Inline (Inflate_Init);
  301.    function zError (err : Int) return Chars_Ptr;
  303.    function inflateSyncPoint (z : Z_Streamp) return Int;
  305.    function get_crc_table return ULong_Access;
  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.
  313.    procedure Set_In
  314.      (Strm   : in out Z_Stream;
  315.       Buffer : in Voidp;
  316.       Size   : in UInt);
  317.    pragma Inline (Set_In);
  319.    procedure Set_Out
  320.      (Strm   : in out Z_Stream;
  321.       Buffer : in Voidp;
  322.       Size   : in UInt);
  323.    pragma Inline (Set_Out);
  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);
  332.    function Last_Error_Message (Strm : in Z_Stream) return String;
  333.    pragma Inline (Last_Error_Message);
  335.    function Avail_Out (Strm : in Z_Stream) return UInt;
  336.    pragma Inline (Avail_Out);
  338.    function Avail_In (Strm : in Z_Stream) return UInt;
  339.    pragma Inline (Avail_In);
  341.    function Total_In (Strm : in Z_Stream) return ULong;
  342.    pragma Inline (Total_In);
  344.    function Total_Out (Strm : in Z_Stream) return ULong;
  345.    pragma Inline (Total_Out);
  347.    function inflateCopy
  348.      (dest   : in Z_Streamp;
  349.       Source : in Z_Streamp)
  350.       return Int;
  352.    function compressBound (Source_Len : in ULong) return ULong;
  354.    function deflateBound
  355.      (Strm       : in Z_Streamp;
  356.       Source_Len : in ULong)
  357.       return     ULong;
  359.    function gzungetc (C : in Int; File : in  gzFile) return Int;
  361.    function zlibCompileFlags return ULong;
  363. private
  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;
  385.    pragma Convention (C, Z_Stream);
  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");
  429.    --  since zlib 1.2.0:
  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");
  437.    pragma Import (C, inflateBackInit, "inflateBackInit_");
  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.
  447.    --  pragma Import (C, inflateBack, "inflateBack");
  448.    --  pragma Import (C, inflateBackEnd, "inflateBackEnd");
  450. end ZLib.Thin;