WebSVN – Kolibri OS – Diff – /programs/develop/libraries/zlib/zlib.h

 /* zlib.h -- interface of the 'zlib' general purpose compression library
-  version 1.2.5, April 19th, 2010
+  version 1.2.8, April 28th, 2013
-  Copyright (C) 1995-2010 Jean-loup Gailly and Mark Adler
+  Copyright (C) 1995-2013 Jean-loup Gailly and Mark Adler
   This software is provided 'as-is', without any express or implied
   Jean-loup Gailly        Mark Adler
   jloup@gzip.org          madler@alumni.caltech.edu
   The data format used by the zlib library is described by RFCs (Request for
-  Comments) 1950 to 1952 in the files http://www.ietf.org/rfc/rfc1950.txt
+  Comments) 1950 to 1952 in the files http://tools.ietf.org/html/rfc1950
-  (zlib format), rfc1951.txt (deflate format) and rfc1952.txt (gzip format).
+  (zlib format), rfc1951 (deflate format) and rfc1952 (gzip format).
 */
 #ifdef __cplusplus
 extern "C" {
 #endif
-#define ZLIB_VERSION "1.2.5"
+#define ZLIB_VERSION "1.2.8"
-#define ZLIB_VERNUM 0x1250
+#define ZLIB_VERNUM 0x1280
 #define ZLIB_VER_MAJOR 1
 #define ZLIB_VER_MINOR 2
-#define ZLIB_VER_REVISION 5
+#define ZLIB_VER_REVISION 8
 #define ZLIB_VER_SUBREVISION 0
 typedef void   (*free_func)  OF((voidpf opaque, voidpf address));
 struct internal_state;
 typedef struct z_stream_s {
-    Bytef    *next_in;  /* next input byte */
+    z_const Bytef *next_in;     /* next input byte */
     uInt     avail_in;  /* number of bytes available at next_in */
-    uLong    total_in;  /* total nb of input bytes read so far */
+    uLong    total_in;  /* total number of input bytes read so far */
     Bytef    *next_out; /* next output byte should be put there */
     uInt     avail_out; /* remaining free space at next_out */
-    uLong    total_out; /* total nb of bytes output so far */
+    uLong    total_out; /* total number of bytes output so far */
-    char     *msg;      /* last error message, NULL if no error */
+    z_const char *msg;  /* last error message, NULL if no error */
   deflate has returned Z_STREAM_END, the only possible operations on the stream
   are deflateReset or deflateEnd.
     Z_FINISH can be used immediately after deflateInit if all the compression
   is to be done in a single step.  In this case, avail_out must be at least the
+  value returned by deflateBound (see below).  Then deflate is guaranteed to
-  value returned by deflateBound (see below).  If deflate does not return
+  return Z_STREAM_END.  If not enough output space is provided, deflate will
-  Z_STREAM_END, then it must be called again as described above.
+  not return Z_STREAM_END, and it must be called again as described above.
     deflate() sets strm->adler to the adler32 checksum of all input read
     inflate() should normally be called until it returns Z_STREAM_END or an
   error.  However if all decompression is to be performed in a single step (a
   single call of inflate), the parameter flush should be set to Z_FINISH.  In
   this case all pending input is processed and all pending output is flushed;
-  avail_out must be large enough to hold all the uncompressed data.  (The size
+  avail_out must be large enough to hold all of the uncompressed data for the
-  of the uncompressed data may have been saved by the compressor for this
+  operation to complete.  (The size of the uncompressed data may have been
-  purpose.) The next operation on this stream must be inflateEnd to deallocate
+  saved by the compressor for this purpose.) The use of Z_FINISH is not
-  the decompression state.  The use of Z_FINISH is never required, but can be
+  required to perform an inflation in one step.  However it may be used to
+  inform inflate that a faster approach can be used for the single inflate()
+  call.  Z_FINISH also informs inflate to not maintain a sliding window if the
+  stream completes, which reduces inflate's memory footprint.  If the stream
+  does not complete, either because not all of the stream is provided or not
+  enough output space is provided, then a sliding window will be allocated and
-  used to inform inflate that a faster approach may be used for the single
+  inflate() can be called again to continue the operation as if Z_NO_FLUSH had
-  inflate() call.
+  been used.
      In this implementation, inflate() always flushes as much output as
   possible to the output buffer, and always uses the faster approach on the
+  first call.  So the effects of the flush parameter in this implementation are
-  first call.  So the only effect of the flush parameter in this implementation
+  on the return value of inflate() as noted below, when inflate() returns early
-  is on the return value of inflate(), as noted below, or when it returns early
+  when Z_BLOCK or Z_TREES is used, and when inflate() avoids the allocation of
-  because Z_BLOCK or Z_TREES is used.
+  memory for a sliding window when Z_FINISH is used.
      If a preset dictionary is needed after this call (see inflateSetDictionary
-  below), inflate sets strm->adler to the adler32 checksum of the dictionary
+  below), inflate sets strm->adler to the Adler-32 checksum of the dictionary
   chosen by the compressor and returns Z_NEED_DICT; otherwise it sets
-  strm->adler to the adler32 checksum of all output produced so far (that is,
+  strm->adler to the Adler-32 checksum of all output produced so far (that is,
   total_out bytes) and returns Z_OK, Z_STREAM_END or an error code as described
   below.  At the end of the stream, inflate() checks that its computed adler32
   checksum is equal to that saved by the compressor and returns Z_STREAM_END
   only if the checksum is correct.
     inflate() can decompress and check either zlib-wrapped or gzip-wrapped
   deflate data.  The header type is detected automatically, if requested when
+  initializing with inflateInit2().  Any information contained in the gzip
+  header is not retained, so applications that need that information should
-  initializing with inflateInit2().  Any information contained in the gzip
+  instead use raw inflate, see inflateInit2() below, or inflateBack() and
-  header is not retained, so applications that need that information should
+  perform their own processing of the gzip header and trailer.  When processing
-  instead use raw inflate, see inflateInit2() below, or inflateBack() and
+  gzip-wrapped deflate data, strm->adler32 is set to the CRC-32 of the output
-  perform their own processing of the gzip header and trailer.
+  producted so far.  The CRC-32 is checked against the gzip trailer.
 ZEXTERN int ZEXPORT deflateSetDictionary OF((z_streamp strm,
                                              const Bytef *dictionary,
                                              uInt  dictLength));
 /*
      Initializes the compression dictionary from the given byte sequence
-   without producing any compressed output.  This function must be called
+   without producing any compressed output.  When using the zlib format, this
-   immediately after deflateInit, deflateInit2 or deflateReset, before any call
+   function must be called immediately after deflateInit, deflateInit2 or
+   deflateReset, and before any call of deflate.  When doing raw deflate, this
+   function must be called either before any call of deflate, or immediately
+   after the completion of a deflate block, i.e. after all input has been
+   consumed and all output has been delivered when using any of the flush
+   options Z_BLOCK, Z_PARTIAL_FLUSH, Z_SYNC_FLUSH, or Z_FULL_FLUSH.  The
-   of deflate.  The compressor and decompressor must use exactly the same
+   compressor and decompressor must use exactly the same dictionary (see
-   dictionary (see inflateSetDictionary).
+   inflateSetDictionary).
      The dictionary should consist of strings (byte sequences) that are likely
    to be encountered later in the data to be compressed, with the most commonly
    used strings preferably put towards the end of the dictionary.  Using a
    adler32 value is not computed and strm->adler is not set.
      deflateSetDictionary returns Z_OK if success, or Z_STREAM_ERROR if a
    parameter is invalid (e.g.  dictionary being Z_NULL) or the stream state is
    inconsistent (for example if deflate has already been called for this stream
-   or if the compression method is bsort).  deflateSetDictionary does not
+   or if not at a block boundary for raw deflate).  deflateSetDictionary does
-   perform any compression: this will be done by deflate().
+   not perform any compression: this will be done by deflate().
 */
 ZEXTERN int ZEXPORT deflateCopy OF((z_streamp dest,
 /*
      deflateBound() returns an upper bound on the compressed size after
    deflation of sourceLen bytes.  It must be called after deflateInit() or
    deflateInit2(), and after deflateSetHeader(), if used.  This would be used
    to allocate an output buffer for deflation in a single pass, and so would be
+   called before deflate().  If that first deflate() call is provided the
+   sourceLen input bytes, an output buffer allocated to the size returned by
+   deflateBound(), and the flush value Z_FINISH, then deflate() is guaranteed
+   to return Z_STREAM_END.  Note that it is possible for the compressed size to
+   be larger than the value returned by deflateBound() if flush options other
+   than Z_FINISH or Z_NO_FLUSH are used.
+*/
+ZEXTERN int ZEXPORT deflatePending OF((z_streamp strm,
+                                       unsigned *pending,
+                                       int *bits));
+/*
+     deflatePending() returns the number of bytes and bits of output that have
+   been generated, but not yet provided in the available output.  The bytes not
+   provided would be due to the available output space having being consumed.
+   The number of bits of output not provided are between 0 and 7, where they
+   await more bits to join them in order to fill out a full byte.  If pending
+   or bits are Z_NULL, then those values are not set.
+     deflatePending returns Z_OK if success, or Z_STREAM_ERROR if the source
-   called before deflate().
+   stream state was inconsistent.
-*/
+ */
 ZEXTERN int ZEXPORT deflatePrime OF((z_streamp strm,
                                      int bits,
    function can only be used for raw deflate, and must be used before the first
    deflate() call after a deflateInit2() or deflateReset().  bits must be less
    than or equal to 16, and that many of the least significant bits of value
    will be inserted in the output.
+     deflatePrime returns Z_OK if success, Z_BUF_ERROR if there was not enough
-     deflatePrime returns Z_OK if success, or Z_STREAM_ERROR if the source
+   room in the internal buffer to insert the bits, or Z_STREAM_ERROR if the
-   stream state was inconsistent.
+   source stream state was inconsistent.
 */
 ZEXTERN int ZEXPORT deflateSetHeader OF((z_streamp strm,
      Initializes the decompression dictionary from the given uncompressed byte
    sequence.  This function must be called immediately after a call of inflate,
    if that call returned Z_NEED_DICT.  The dictionary chosen by the compressor
    can be determined from the adler32 value returned by that call of inflate.
    The compressor and decompressor must use exactly the same dictionary (see
-   deflateSetDictionary).  For raw inflate, this function can be called
+   deflateSetDictionary).  For raw inflate, this function can be called at any
-   immediately after inflateInit2() or inflateReset() and before any call of
+   time to set the dictionary.  If the provided dictionary is smaller than the
+   window and there is already data in the window, then the provided dictionary
-   inflate() to set the dictionary.  The application must insure that the
+   will amend what's there.  The application must insure that the dictionary
-   dictionary that was used for compression is provided.
+   that was used for compression is provided.
      inflateSetDictionary returns Z_OK if success, Z_STREAM_ERROR if a
    parameter is invalid (e.g.  dictionary being Z_NULL) or the stream state is
    inconsistent, Z_DATA_ERROR if the given dictionary doesn't match the
    expected one (incorrect adler32 value).  inflateSetDictionary does not
    perform any decompression: this will be done by subsequent calls of
    inflate().
+*/
+ZEXTERN int ZEXPORT inflateGetDictionary OF((z_streamp strm,
+                                             Bytef *dictionary,
+                                             uInt  *dictLength));
+/*
+     Returns the sliding dictionary being maintained by inflate.  dictLength is
+   set to the number of bytes in the dictionary, and that many bytes are copied
+   to dictionary.  dictionary must have enough space, where 32768 bytes is
+   always enough.  If inflateGetDictionary() is called with dictionary equal to
+   Z_NULL, then only the dictionary length is returned, and nothing is copied.
+   Similary, if dictLength is Z_NULL, then it is not set.
+     inflateGetDictionary returns Z_OK on success, or Z_STREAM_ERROR if the
+   stream state is inconsistent.
 */
 ZEXTERN int ZEXPORT inflateSync OF((z_streamp strm));
 /*
-     Skips invalid compressed data until a full flush point (see above the
+     Skips invalid compressed data until a possible full flush point (see above
+   for the description of deflate with Z_FULL_FLUSH) can be found, or until all
+   available input is skipped.  No output is provided.
+     inflateSync searches for a 00 00 FF FF pattern in the compressed data.
-   description of deflate with Z_FULL_FLUSH) can be found, or until all
+   All full flush points have this pattern, but not all occurrences of this
-   available input is skipped.  No output is provided.
+   pattern are full flush points.
-     inflateSync returns Z_OK if a full flush point has been found, Z_BUF_ERROR
+     inflateSync returns Z_OK if a possible full flush point has been found,
-   if no more input was provided, Z_DATA_ERROR if no flush point has been
+   Z_BUF_ERROR if no more input was provided, Z_DATA_ERROR if no flush point
-   found, or Z_STREAM_ERROR if the stream structure was inconsistent.  In the
+   has been found, or Z_STREAM_ERROR if the stream structure was inconsistent.
-   success case, the application may save the current current value of total_in
+   In the success case, the application may save the current current value of
-   which indicates where valid compressed data was found.  In the error case,
+   total_in which indicates where valid compressed data was found.  In the
-   the application may repeatedly call inflateSync, providing more input each
+   error case, the application may repeatedly call inflateSync, providing more
-   time, until success or end of the input data.
+   input each time, until success or end of the input data.
 */
    deflate streams.
      See inflateBack() for the usage of these routines.
      inflateBackInit will return Z_OK on success, Z_STREAM_ERROR if any of
-   the paramaters are invalid, Z_MEM_ERROR if the internal state could not be
+   the parameters are invalid, Z_MEM_ERROR if the internal state could not be
    allocated, or Z_VERSION_ERROR if the version of the library does not match
    the version of the header file.
+*/
 */
 typedef unsigned (*in_func) OF((void FAR *,
-typedef unsigned (*in_func) OF((void FAR *, unsigned char FAR * FAR *));
+                                z_const unsigned char FAR * FAR *));
 typedef int (*out_func) OF((void FAR *, unsigned char FAR *, unsigned));
 ZEXTERN int ZEXPORT inflateBack OF((z_streamp strm,
                                     in_func in, void FAR *in_desc,
                                     out_func out, void FAR *out_desc));
 /*
+     inflateBack() does a raw inflate with a single call using a call-back
-     inflateBack() does a raw inflate with a single call using a call-back
+   interface for input and output.  This is potentially more efficient than
-   interface for input and output.  This is more efficient than inflate() for
+   inflate() for file i/o applications, in that it avoids copying between the
-   file i/o applications in that it avoids copying between the output and the
+   output and the sliding window by simply making the window itself the output
-   sliding window by simply making the window itself the output buffer.  This
+   buffer.  inflate() can be faster on modern CPUs when used with large
-   function trusts the application to not change the output buffer passed by
+   buffers.  inflateBack() trusts the application to not change the output
-   the output function, at least until inflateBack() returns.
+   buffer passed by the output function, at least until inflateBack() returns.
     Remainder:
 -31: 0 (reserved)
+ */
  */
 #ifndef Z_SOLO
    mechanism outside the scope of this compression library.) Upon exit, destLen
    is the actual size of the uncompressed buffer.
      uncompress returns Z_OK if success, Z_MEM_ERROR if there was not
    enough memory, Z_BUF_ERROR if there was not enough room in the output
+   buffer, or Z_DATA_ERROR if the input data was corrupted or incomplete.  In
+   the case where there is not enough room, uncompress() will fill the output
-   buffer, or Z_DATA_ERROR if the input data was corrupted or incomplete.
+   buffer with the uncompressed data up to that point.
-*/
 */
                         /* gzip file access functions */
 /*
      This library supports reading and writing files in gzip (.gz) format with
    an interface similar to that of stdio, using the functions that start with
    "gz".  The gzip format is different from the zlib format.  gzip is a gzip
    wrapper, documented in RFC 1952, wrapped around a deflate stream.
 */
-typedef voidp gzFile;       /* opaque gzip file descriptor */
+typedef struct gzFile_s *gzFile;    /* semi-opaque gzip file descriptor */
 /*
 ZEXTERN gzFile ZEXPORT gzopen OF((const char *path, const char *mode));
+     Opens a gzip (.gz) file for reading or writing.  The mode parameter is as
+   in fopen ("rb" or "wb") but can also include a compression level ("wb9") or
+   a strategy: 'f' for filtered data as in "wb6f", 'h' for Huffman-only
-     Opens a gzip (.gz) file for reading or writing.  The mode parameter is as
+   compression as in "wb1h", 'R' for run-length encoding as in "wb1R", or 'F'
-   in fopen ("rb" or "wb") but can also include a compression level ("wb9") or
+   for fixed code compression as in "wb9F".  (See the description of
-   a strategy: 'f' for filtered data as in "wb6f", 'h' for Huffman-only
+   deflateInit2 for more information about the strategy parameter.)  'T' will
+   request transparent writing or appending with no compression and not using
+   the gzip format.
+     "a" can be used instead of "w" to request that the gzip stream that will
+   be written be appended to the file.  "+" will result in an error, since
+   reading and writing to the same gzip file is not supported.  The addition of
+   "x" when writing will create the file exclusively, which fails if the file
+   already exists.  On systems that support it, the addition of "e" when
+   reading or writing will set the flag to close the file on an execve() call.
-   compression as in "wb1h", 'R' for run-length encoding as in "wb1R", or 'F'
+     These functions, as well as gzip, will read and decode a sequence of gzip
-   for fixed code compression as in "wb9F".  (See the description of
+   streams in a file.  The append function of gzopen() can be used to create
+   such a file.  (Also see gzflush() for another way to do this.)  When
+   appending, gzopen does not test whether the file begins with a gzip stream,
-   deflateInit2 for more information about the strategy parameter.) Also "a"
+   nor does it look for the end of the gzip streams to begin appending.  gzopen
-   can be used instead of "w" to request that the gzip stream that will be
+   will simply append a gzip stream to the existing file.
    written be appended to the file.  "+" will result in an error, since reading
-   and writing to the same gzip file is not supported.
+     gzopen can be used to read a file which is not in gzip format; in this
      The next call of gzclose on the returned gzFile will also close the file
    descriptor fd, just like fclose(fdopen(fd, mode)) closes the file descriptor
    fd.  If you want to keep fd open, use fd = dup(fd_keep); gz = gzdopen(fd,
    mode);.  The duplicated descriptor should be saved to avoid a leak, since
+   gzdopen does not close fd if it fails.  If you are using fileno() to get the
+   file descriptor from a FILE *, then you will have to use dup() to avoid
+   double-close()ing the file descriptor.  Both gzclose() and fclose() will
+   close the associated file descriptor, so they need to have different file
-   gzdopen does not close fd if it fails.
+   descriptors.
      gzdopen returns NULL if there was insufficient memory to allocate the
    gzFile state, if an invalid mode was specified (an 'r', 'w', or 'a' was not
 */
 ZEXTERN int ZEXPORT gzread OF((gzFile file, voidp buf, unsigned len));
 /*
      Reads the given number of uncompressed bytes from the compressed file.  If
-   the input file was not in gzip format, gzread copies the given number of
+   the input file is not in gzip format, gzread copies the given number of
-   bytes into the buffer.
+   bytes into the buffer directly from the file.
      After reaching the end of a gzip stream in the input, gzread will continue
+   to read, looking for another gzip stream.  Any number of gzip streams may be
+   concatenated in the input file, and will all be decompressed by gzread().
+   If something other than a gzip stream is encountered after a gzip stream,
+   that remaining trailing garbage is ignored (and no error is returned).
+     gzread can be used to read a gzip file that is being concurrently written.
+   Upon reaching the end of the input, gzread will return with the available
+   data.  If the error code returned by gzerror is Z_OK or Z_BUF_ERROR, then
+   gzclearerr can be used to clear the end of file indicator in order to permit
-   to read, looking for another gzip stream, or failing that, reading the rest
+   gzread to be tried again.  Z_OK indicates that a gzip stream was completed
+   on the last gzread.  Z_BUF_ERROR indicates that the input file ended in the
+   middle of a gzip stream.  Note that gzread does not return -1 in the event
+   of an incomplete gzip stream.  This error is deferred until gzclose(), which
-   of the input file directly without decompression.  The entire input file
+   will return Z_BUF_ERROR if the last gzread ended in the middle of a gzip
-   will be read if gzread is called until it returns less than the requested
+   stream.  Alternatively, gzerror can be used before gzclose to detect this
-   len.
+   case.
      Writes the given number of uncompressed bytes into the compressed file.
    gzwrite returns the number of uncompressed bytes written or 0 in case of
    error.
 */
-ZEXTERN int ZEXPORTVA gzprintf OF((gzFile file, const char *format, ...));
+ZEXTERN int ZEXPORTVA gzprintf Z_ARG((gzFile file, const char *format, ...));
 /*
      Converts, formats, and writes the arguments to the compressed file under
    control of the format string, as in fprintf.  gzprintf returns the number of
    uncompressed bytes actually written, or 0 in case of error.  The number of
 */
 ZEXTERN int ZEXPORT gzgetc OF((gzFile file));
 /*
+     Reads one byte from the compressed file.  gzgetc returns this byte or -1
+   in case of end of file or error.  This is implemented as a macro for speed.
+   As such, it does not do all of the checking the other functions do.  I.e.
-     Reads one byte from the compressed file.  gzgetc returns this byte or -1
+   it does not check to see if file is NULL, nor whether the structure file
-   in case of end of file or error.
+   points to has been clobbered or not.
 */
 ZEXTERN int ZEXPORT gzungetc OF((int c, gzFile file));
 */
 ZEXTERN int ZEXPORT gzdirect OF((gzFile file));
 /*
      Returns true (1) if file is being copied directly while reading, or false
-   (0) if file is a gzip stream being decompressed.  This state can change from
-   false to true while reading the input file if the end of a gzip stream is
-   reached, but is followed by data that is not another gzip stream.
+   (0) if file is a gzip stream being decompressed.
      If the input file is empty, gzdirect() will return true, since the input
    does not contain a gzip stream.
      If gzdirect() is used immediately after gzopen() or gzdopen() it will
+   cause buffers to be allocated to allow reading the file to determine if it
+   is a gzip file.  Therefore if gzbuffer() is used, it should be called before
+   gzdirect().
+     When writing, gzdirect() returns true (1) if transparent writing was
+   requested ("wT" for the gzopen() mode), or false (0) otherwise.  (Note:
+   gzdirect() is not needed when writing.  Transparent writing must be
-   cause buffers to be allocated to allow reading the file to determine if it
+   explicitly requested, so the application already knows the answer.  When
-   is a gzip file.  Therefore if gzbuffer() is used, it should be called before
+   linking statically, using gzdirect() will include all of the zlib code for
-   gzdirect().
+   gzip file reading and decompression, which may not be desired.)
 */
    cannot call gzerror with file, since its structures have been deallocated.
    gzclose must not be called more than once on the same file, just as free
    must not be called more than once on the same allocation.
+     gzclose will return Z_STREAM_ERROR if file is not valid, Z_ERRNO on a
-     gzclose will return Z_STREAM_ERROR if file is not valid, Z_ERRNO on a
+   file operation error, Z_MEM_ERROR if out of memory, Z_BUF_ERROR if the
-   file operation error, or Z_OK on success.
+   last read ended in the middle of a gzip stream, or Z_OK on success.
 */
 ZEXTERN int ZEXPORT gzclose_r OF((gzFile file));
      Clears the error and end-of-file flags for file.  This is analogous to the
    clearerr() function in stdio.  This is useful for continuing to read a gzip
    file that is being written concurrently.
 */
 #endif /* !Z_SOLO */
                         /* checksum functions */
                                           z_off_t len2));
      Combine two Adler-32 checksums into one.  For two sequences of bytes, seq1
    and seq2 with lengths len1 and len2, Adler-32 checksums were calculated for
    each, adler1 and adler2.  adler32_combine() returns the Adler-32 checksum of
+   seq1 and seq2 concatenated, requiring only adler1, adler2, and len2.  Note
+   that the z_off_t type (like off_t) is a signed integer.  If len2 is
-   seq1 and seq2 concatenated, requiring only adler1, adler2, and len2.
+   negative, the result has no meaning or utility.
 */
 ZEXTERN uLong ZEXPORT crc32   OF((uLong crc, const Bytef *buf, uInt len));
 /*
      Update a running CRC-32 with the bytes buf[0..len-1] and return the
    updated CRC-32.  If buf is Z_NULL, this function returns the required
-   initial value for the for the crc.  Pre- and post-conditioning (one's
-   complement) is performed within this function so it shouldn't be done by the
+   initial value for the crc.  Pre- and post-conditioning (one's complement) is
-   application.
+   performed within this function so it shouldn't be done by the application.
 ZEXTERN int ZEXPORT inflateBackInit_ OF((z_streamp strm, int windowBits,
                                          unsigned char FAR *window,
                                          const char *version,
                                          int stream_size));
 #define deflateInit(strm, level) \
-        deflateInit_((strm), (level),       ZLIB_VERSION, sizeof(z_stream))
+        deflateInit_((strm), (level), ZLIB_VERSION, (int)sizeof(z_stream))
 #define inflateInit(strm) \
-        inflateInit_((strm),                ZLIB_VERSION, sizeof(z_stream))
+        inflateInit_((strm), ZLIB_VERSION, (int)sizeof(z_stream))
 #define deflateInit2(strm, level, method, windowBits, memLevel, strategy) \
         deflateInit2_((strm),(level),(method),(windowBits),(memLevel),\
-                      (strategy),           ZLIB_VERSION, sizeof(z_stream))
+                      (strategy), ZLIB_VERSION, (int)sizeof(z_stream))
 #define inflateInit2(strm, windowBits) \
-        inflateInit2_((strm), (windowBits), ZLIB_VERSION, sizeof(z_stream))
+        inflateInit2_((strm), (windowBits), ZLIB_VERSION, \
+                      (int)sizeof(z_stream))
 #define inflateBackInit(strm, windowBits, window) \
         inflateBackInit_((strm), (windowBits), (window), \
-                                            ZLIB_VERSION, sizeof(z_stream))
+                      ZLIB_VERSION, (int)sizeof(z_stream))
+#ifndef Z_SOLO
+/* gzgetc() macro and its supporting function and exposed data structure.  Note
+ * that the real internal state is much larger than the exposed structure.
+ * This abbreviated structure exposes just enough for the gzgetc() macro.  The
+ * user should not mess with these exposed elements, since their names or
+ * behavior could change in the future, perhaps even capriciously.  They can
+ * only be used by the gzgetc() macro.  You have been warned.
+ */
+struct gzFile_s {
+    unsigned have;
+    unsigned char *next;
+    z_off64_t pos;
+};
+ZEXTERN int ZEXPORT gzgetc_ OF((gzFile file));  /* backward compatibility */
+#ifdef Z_PREFIX_SET
+#  undef z_gzgetc
+#  define z_gzgetc(g) \
+          ((g)->have ? ((g)->have--, (g)->pos++, *((g)->next)++) : gzgetc(g))
+#else
+#  define gzgetc(g) \
+          ((g)->have ? ((g)->have--, (g)->pos++, *((g)->next)++) : gzgetc(g))
+#endif
 /* provide 64-bit offset functions if _LARGEFILE64_SOURCE defined, and/or
  * change the regular functions to 64 bits if _FILE_OFFSET_BITS is 64 (if
  * both are true, the application gets the *64 functions, and the regular
  * functions are changed to 64 bits) -- in case these are set on systems
  * without large file support, _LFS64_LARGEFILE must also be true
  */
-#if defined(_LARGEFILE64_SOURCE) && _LFS64_LARGEFILE-0
+#ifdef Z_LARGE64
    ZEXTERN gzFile ZEXPORT gzopen64 OF((const char *, const char *));
    ZEXTERN z_off64_t ZEXPORT gzseek64 OF((gzFile, z_off64_t, int));
    ZEXTERN z_off64_t ZEXPORT gztell64 OF((gzFile));
    ZEXTERN z_off64_t ZEXPORT gzoffset64 OF((gzFile));
    ZEXTERN uLong ZEXPORT adler32_combine64 OF((uLong, uLong, z_off64_t));
    ZEXTERN uLong ZEXPORT crc32_combine64 OF((uLong, uLong, z_off64_t));
 #endif
+#if !defined(ZLIB_INTERNAL) && defined(Z_WANT64)
+#  ifdef Z_PREFIX_SET
+#    define z_gzopen z_gzopen64
+#    define z_gzseek z_gzseek64
+#    define z_gztell z_gztell64
+#    define z_gzoffset z_gzoffset64
+#    define z_adler32_combine z_adler32_combine64
 #    define z_crc32_combine z_crc32_combine64
-#if !defined(ZLIB_INTERNAL) && _FILE_OFFSET_BITS-0 == 64 && _LFS64_LARGEFILE-0
+#  else
-#  define gzopen gzopen64
+#    define gzopen gzopen64
-#  define gzseek gzseek64
+#    define gzseek gzseek64
-#  define gztell gztell64
+#    define gztell gztell64
-#  define gzoffset gzoffset64
+#    define gzoffset gzoffset64
+#    define adler32_combine adler32_combine64
-#  define adler32_combine adler32_combine64
+#    define crc32_combine crc32_combine64
-#  define crc32_combine crc32_combine64
+#  endif
-#  ifdef _LARGEFILE64_SOURCE
+#  ifndef Z_LARGE64
      ZEXTERN gzFile ZEXPORT gzopen64 OF((const char *, const char *));
      ZEXTERN z_off_t ZEXPORT gzseek64 OF((gzFile, z_off_t, int));
      ZEXTERN z_off_t ZEXPORT gztell64 OF((gzFile));
    ZEXTERN z_off_t ZEXPORT gzoffset OF((gzFile));
    ZEXTERN uLong ZEXPORT adler32_combine OF((uLong, uLong, z_off_t));
    ZEXTERN uLong ZEXPORT crc32_combine OF((uLong, uLong, z_off_t));
 #endif
+#else /* Z_SOLO */
+   ZEXTERN uLong ZEXPORT adler32_combine OF((uLong, uLong, z_off_t));
+   ZEXTERN uLong ZEXPORT crc32_combine OF((uLong, uLong, z_off_t));
+#endif /* !Z_SOLO */
 /* hack for buggy compilers */
 #if !defined(ZUTIL_H) && !defined(NO_DUMMY_DECL)
     struct internal_state {int dummy;};
 #endif
 /* undocumented functions */
 ZEXTERN const char   * ZEXPORT zError           OF((int));
 ZEXTERN int            ZEXPORT inflateSyncPoint OF((z_streamp));
+ZEXTERN const z_crc_t FAR * ZEXPORT get_crc_table    OF((void));
+ZEXTERN int            ZEXPORT inflateUndermine OF((z_streamp, int));
+ZEXTERN int            ZEXPORT inflateResetKeep OF((z_streamp));
+ZEXTERN int            ZEXPORT deflateResetKeep OF((z_streamp));
+#if defined(_WIN32) && !defined(Z_SOLO)
+ZEXTERN gzFile         ZEXPORT gzopen_w OF((const wchar_t *path,
+                                            const char *mode));
+#endif
+#if defined(STDC) || defined(Z_HAVE_STDARG_H)
+#  ifndef Z_SOLO
+ZEXTERN int            ZEXPORTVA gzvprintf Z_ARG((gzFile file,
+                                                  const char *format,
+                                                  va_list va));
-ZEXTERN const uLongf * ZEXPORT get_crc_table    OF((void));
+#  endif
-ZEXTERN int            ZEXPORT inflateUndermine OF((z_streamp, int));
+#endif

Subversion Repositories Kolibri OS

(root)/programs/develop/libraries/zlib/zlib.h – Rev 1896 → 3926