|
|
|
|
@ -1,7 +1,7 @@ |
|
|
|
|
/* zlib.h -- interface of the 'zlib' general purpose compression library
|
|
|
|
|
version 1.2.13, October 13th, 2022 |
|
|
|
|
version 1.3, August 18th, 2023 |
|
|
|
|
|
|
|
|
|
Copyright (C) 1995-2022 Jean-loup Gailly and Mark Adler |
|
|
|
|
Copyright (C) 1995-2023 Jean-loup Gailly and Mark Adler |
|
|
|
|
|
|
|
|
|
This software is provided 'as-is', without any express or implied |
|
|
|
|
warranty. In no event will the authors be held liable for any damages |
|
|
|
|
@ -37,11 +37,11 @@ |
|
|
|
|
extern "C" { |
|
|
|
|
#endif |
|
|
|
|
|
|
|
|
|
#define ZLIB_VERSION "1.2.13" |
|
|
|
|
#define ZLIB_VERNUM 0x12d0 |
|
|
|
|
#define ZLIB_VERSION "1.3" |
|
|
|
|
#define ZLIB_VERNUM 0x1300 |
|
|
|
|
#define ZLIB_VER_MAJOR 1 |
|
|
|
|
#define ZLIB_VER_MINOR 2 |
|
|
|
|
#define ZLIB_VER_REVISION 13 |
|
|
|
|
#define ZLIB_VER_MINOR 3 |
|
|
|
|
#define ZLIB_VER_REVISION 0 |
|
|
|
|
#define ZLIB_VER_SUBREVISION 0 |
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
|
@ -78,8 +78,8 @@ extern "C" { |
|
|
|
|
even in the case of corrupted input. |
|
|
|
|
*/ |
|
|
|
|
|
|
|
|
|
typedef voidpf (*alloc_func) OF((voidpf opaque, uInt items, uInt size)); |
|
|
|
|
typedef void (*free_func) OF((voidpf opaque, voidpf address)); |
|
|
|
|
typedef voidpf (*alloc_func)(voidpf opaque, uInt items, uInt size); |
|
|
|
|
typedef void (*free_func)(voidpf opaque, voidpf address); |
|
|
|
|
|
|
|
|
|
struct internal_state; |
|
|
|
|
|
|
|
|
|
@ -219,7 +219,7 @@ typedef gz_header FAR *gz_headerp; |
|
|
|
|
|
|
|
|
|
/* basic functions */ |
|
|
|
|
|
|
|
|
|
ZEXTERN const char * ZEXPORT zlibVersion OF((void)); |
|
|
|
|
ZEXTERN const char * ZEXPORT zlibVersion(void); |
|
|
|
|
/* The application can compare zlibVersion and ZLIB_VERSION for consistency.
|
|
|
|
|
If the first character differs, the library code actually used is not |
|
|
|
|
compatible with the zlib.h header file used by the application. This check |
|
|
|
|
@ -227,12 +227,12 @@ ZEXTERN const char * ZEXPORT zlibVersion OF((void)); |
|
|
|
|
*/ |
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
|
ZEXTERN int ZEXPORT deflateInit OF((z_streamp strm, int level)); |
|
|
|
|
ZEXTERN int ZEXPORT deflateInit(z_streamp strm, int level); |
|
|
|
|
|
|
|
|
|
Initializes the internal stream state for compression. The fields |
|
|
|
|
zalloc, zfree and opaque must be initialized before by the caller. If |
|
|
|
|
zalloc and zfree are set to Z_NULL, deflateInit updates them to use default |
|
|
|
|
allocation functions. |
|
|
|
|
allocation functions. total_in, total_out, adler, and msg are initialized. |
|
|
|
|
|
|
|
|
|
The compression level must be Z_DEFAULT_COMPRESSION, or between 0 and 9: |
|
|
|
|
1 gives best speed, 9 gives best compression, 0 gives no compression at all |
|
|
|
|
@ -249,7 +249,7 @@ ZEXTERN int ZEXPORT deflateInit OF((z_streamp strm, int level)); |
|
|
|
|
*/ |
|
|
|
|
|
|
|
|
|
|
|
|
|
|
ZEXTERN int ZEXPORT deflate OF((z_streamp strm, int flush)); |
|
|
|
|
ZEXTERN int ZEXPORT deflate(z_streamp strm, int flush); |
|
|
|
|
/*
|
|
|
|
|
deflate compresses as much data as possible, and stops when the input |
|
|
|
|
buffer becomes empty or the output buffer becomes full. It may introduce |
|
|
|
|
@ -322,8 +322,8 @@ ZEXTERN int ZEXPORT deflate OF((z_streamp strm, int flush)); |
|
|
|
|
with the same value of the flush parameter and more output space (updated |
|
|
|
|
avail_out), until the flush is complete (deflate returns with non-zero |
|
|
|
|
avail_out). In the case of a Z_FULL_FLUSH or Z_SYNC_FLUSH, make sure that |
|
|
|
|
avail_out is greater than six to avoid repeated flush markers due to |
|
|
|
|
avail_out == 0 on return. |
|
|
|
|
avail_out is greater than six when the flush marker begins, in order to avoid |
|
|
|
|
repeated flush markers upon calling deflate() again when avail_out == 0. |
|
|
|
|
|
|
|
|
|
If the parameter flush is set to Z_FINISH, pending input is processed, |
|
|
|
|
pending output is flushed and deflate returns with Z_STREAM_END if there was |
|
|
|
|
@ -362,7 +362,7 @@ ZEXTERN int ZEXPORT deflate OF((z_streamp strm, int flush)); |
|
|
|
|
*/ |
|
|
|
|
|
|
|
|
|
|
|
|
|
|
ZEXTERN int ZEXPORT deflateEnd OF((z_streamp strm)); |
|
|
|
|
ZEXTERN int ZEXPORT deflateEnd(z_streamp strm); |
|
|
|
|
/*
|
|
|
|
|
All dynamically allocated data structures for this stream are freed. |
|
|
|
|
This function discards any unprocessed input and does not flush any pending |
|
|
|
|
@ -378,7 +378,7 @@ ZEXTERN int ZEXPORT deflateEnd OF((z_streamp strm)); |
|
|
|
|
#endif /* !Z_FREETYPE */ |
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
|
ZEXTERN int ZEXPORT inflateInit OF((z_streamp strm)); |
|
|
|
|
ZEXTERN int ZEXPORT inflateInit(z_streamp strm); |
|
|
|
|
|
|
|
|
|
Initializes the internal stream state for decompression. The fields |
|
|
|
|
next_in, avail_in, zalloc, zfree and opaque must be initialized before by |
|
|
|
|
@ -386,7 +386,8 @@ ZEXTERN int ZEXPORT inflateInit OF((z_streamp strm)); |
|
|
|
|
read or consumed. The allocation of a sliding window will be deferred to |
|
|
|
|
the first call of inflate (if the decompression does not complete on the |
|
|
|
|
first call). If zalloc and zfree are set to Z_NULL, inflateInit updates |
|
|
|
|
them to use default allocation functions. |
|
|
|
|
them to use default allocation functions. total_in, total_out, adler, and |
|
|
|
|
msg are initialized. |
|
|
|
|
|
|
|
|
|
inflateInit returns Z_OK if success, Z_MEM_ERROR if there was not enough |
|
|
|
|
memory, Z_VERSION_ERROR if the zlib library version is incompatible with the |
|
|
|
|
@ -400,7 +401,7 @@ ZEXTERN int ZEXPORT inflateInit OF((z_streamp strm)); |
|
|
|
|
*/ |
|
|
|
|
|
|
|
|
|
|
|
|
|
|
ZEXTERN int ZEXPORT inflate OF((z_streamp strm, int flush)); |
|
|
|
|
ZEXTERN int ZEXPORT inflate(z_streamp strm, int flush); |
|
|
|
|
/*
|
|
|
|
|
inflate decompresses as much data as possible, and stops when the input |
|
|
|
|
buffer becomes empty or the output buffer becomes full. It may introduce |
|
|
|
|
@ -520,7 +521,7 @@ ZEXTERN int ZEXPORT inflate OF((z_streamp strm, int flush)); |
|
|
|
|
*/ |
|
|
|
|
|
|
|
|
|
|
|
|
|
|
ZEXTERN int ZEXPORT inflateEnd OF((z_streamp strm)); |
|
|
|
|
ZEXTERN int ZEXPORT inflateEnd(z_streamp strm); |
|
|
|
|
/*
|
|
|
|
|
All dynamically allocated data structures for this stream are freed. |
|
|
|
|
This function discards any unprocessed input and does not flush any pending |
|
|
|
|
@ -540,12 +541,12 @@ ZEXTERN int ZEXPORT inflateEnd OF((z_streamp strm)); |
|
|
|
|
#ifndef Z_FREETYPE |
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
|
ZEXTERN int ZEXPORT deflateInit2 OF((z_streamp strm, |
|
|
|
|
int level, |
|
|
|
|
int method, |
|
|
|
|
int windowBits, |
|
|
|
|
int memLevel, |
|
|
|
|
int strategy)); |
|
|
|
|
ZEXTERN int ZEXPORT deflateInit2(z_streamp strm, |
|
|
|
|
int level, |
|
|
|
|
int method, |
|
|
|
|
int windowBits, |
|
|
|
|
int memLevel, |
|
|
|
|
int strategy); |
|
|
|
|
|
|
|
|
|
This is another version of deflateInit with more compression options. The |
|
|
|
|
fields zalloc, zfree and opaque must be initialized before by the caller. |
|
|
|
|
@ -612,9 +613,9 @@ ZEXTERN int ZEXPORT deflateInit2 OF((z_streamp strm, |
|
|
|
|
compression: this will be done by deflate(). |
|
|
|
|
*/ |
|
|
|
|
|
|
|
|
|
ZEXTERN int ZEXPORT deflateSetDictionary OF((z_streamp strm, |
|
|
|
|
const Bytef *dictionary, |
|
|
|
|
uInt dictLength)); |
|
|
|
|
ZEXTERN int ZEXPORT deflateSetDictionary(z_streamp strm, |
|
|
|
|
const Bytef *dictionary, |
|
|
|
|
uInt dictLength); |
|
|
|
|
/*
|
|
|
|
|
Initializes the compression dictionary from the given byte sequence |
|
|
|
|
without producing any compressed output. When using the zlib format, this |
|
|
|
|
@ -656,9 +657,9 @@ ZEXTERN int ZEXPORT deflateSetDictionary OF((z_streamp strm, |
|
|
|
|
not perform any compression: this will be done by deflate(). |
|
|
|
|
*/ |
|
|
|
|
|
|
|
|
|
ZEXTERN int ZEXPORT deflateGetDictionary OF((z_streamp strm, |
|
|
|
|
Bytef *dictionary, |
|
|
|
|
uInt *dictLength)); |
|
|
|
|
ZEXTERN int ZEXPORT deflateGetDictionary(z_streamp strm, |
|
|
|
|
Bytef *dictionary, |
|
|
|
|
uInt *dictLength); |
|
|
|
|
/*
|
|
|
|
|
Returns the sliding dictionary being maintained by deflate. dictLength is |
|
|
|
|
set to the number of bytes in the dictionary, and that many bytes are copied |
|
|
|
|
@ -678,8 +679,8 @@ ZEXTERN int ZEXPORT deflateGetDictionary OF((z_streamp strm, |
|
|
|
|
stream state is inconsistent. |
|
|
|
|
*/ |
|
|
|
|
|
|
|
|
|
ZEXTERN int ZEXPORT deflateCopy OF((z_streamp dest, |
|
|
|
|
z_streamp source)); |
|
|
|
|
ZEXTERN int ZEXPORT deflateCopy(z_streamp dest, |
|
|
|
|
z_streamp source); |
|
|
|
|
/*
|
|
|
|
|
Sets the destination stream as a complete copy of the source stream. |
|
|
|
|
|
|
|
|
|
@ -696,20 +697,20 @@ ZEXTERN int ZEXPORT deflateCopy OF((z_streamp dest, |
|
|
|
|
destination. |
|
|
|
|
*/ |
|
|
|
|
|
|
|
|
|
ZEXTERN int ZEXPORT deflateReset OF((z_streamp strm)); |
|
|
|
|
ZEXTERN int ZEXPORT deflateReset(z_streamp strm); |
|
|
|
|
/*
|
|
|
|
|
This function is equivalent to deflateEnd followed by deflateInit, but |
|
|
|
|
does not free and reallocate the internal compression state. The stream |
|
|
|
|
will leave the compression level and any other attributes that may have been |
|
|
|
|
set unchanged. |
|
|
|
|
set unchanged. total_in, total_out, adler, and msg are initialized. |
|
|
|
|
|
|
|
|
|
deflateReset returns Z_OK if success, or Z_STREAM_ERROR if the source |
|
|
|
|
stream state was inconsistent (such as zalloc or state being Z_NULL). |
|
|
|
|
*/ |
|
|
|
|
|
|
|
|
|
ZEXTERN int ZEXPORT deflateParams OF((z_streamp strm, |
|
|
|
|
int level, |
|
|
|
|
int strategy)); |
|
|
|
|
ZEXTERN int ZEXPORT deflateParams(z_streamp strm, |
|
|
|
|
int level, |
|
|
|
|
int strategy); |
|
|
|
|
/*
|
|
|
|
|
Dynamically update the compression level and compression strategy. The |
|
|
|
|
interpretation of level and strategy is as in deflateInit2(). This can be |
|
|
|
|
@ -734,7 +735,7 @@ ZEXTERN int ZEXPORT deflateParams OF((z_streamp strm, |
|
|
|
|
Then no more input data should be provided before the deflateParams() call. |
|
|
|
|
If this is done, the old level and strategy will be applied to the data |
|
|
|
|
compressed before deflateParams(), and the new level and strategy will be |
|
|
|
|
applied to the the data compressed after deflateParams(). |
|
|
|
|
applied to the data compressed after deflateParams(). |
|
|
|
|
|
|
|
|
|
deflateParams returns Z_OK on success, Z_STREAM_ERROR if the source stream |
|
|
|
|
state was inconsistent or if a parameter was invalid, or Z_BUF_ERROR if |
|
|
|
|
@ -745,11 +746,11 @@ ZEXTERN int ZEXPORT deflateParams OF((z_streamp strm, |
|
|
|
|
retried with more output space. |
|
|
|
|
*/ |
|
|
|
|
|
|
|
|
|
ZEXTERN int ZEXPORT deflateTune OF((z_streamp strm, |
|
|
|
|
int good_length, |
|
|
|
|
int max_lazy, |
|
|
|
|
int nice_length, |
|
|
|
|
int max_chain)); |
|
|
|
|
ZEXTERN int ZEXPORT deflateTune(z_streamp strm, |
|
|
|
|
int good_length, |
|
|
|
|
int max_lazy, |
|
|
|
|
int nice_length, |
|
|
|
|
int max_chain); |
|
|
|
|
/*
|
|
|
|
|
Fine tune deflate's internal compression parameters. This should only be |
|
|
|
|
used by someone who understands the algorithm used by zlib's deflate for |
|
|
|
|
@ -762,8 +763,8 @@ ZEXTERN int ZEXPORT deflateTune OF((z_streamp strm, |
|
|
|
|
returns Z_OK on success, or Z_STREAM_ERROR for an invalid deflate stream. |
|
|
|
|
*/ |
|
|
|
|
|
|
|
|
|
ZEXTERN uLong ZEXPORT deflateBound OF((z_streamp strm, |
|
|
|
|
uLong sourceLen)); |
|
|
|
|
ZEXTERN uLong ZEXPORT deflateBound(z_streamp strm, |
|
|
|
|
uLong sourceLen); |
|
|
|
|
/*
|
|
|
|
|
deflateBound() returns an upper bound on the compressed size after |
|
|
|
|
deflation of sourceLen bytes. It must be called after deflateInit() or |
|
|
|
|
@ -777,9 +778,9 @@ ZEXTERN uLong ZEXPORT deflateBound OF((z_streamp strm, |
|
|
|
|
than Z_FINISH or Z_NO_FLUSH are used. |
|
|
|
|
*/ |
|
|
|
|
|
|
|
|
|
ZEXTERN int ZEXPORT deflatePending OF((z_streamp strm, |
|
|
|
|
unsigned *pending, |
|
|
|
|
int *bits)); |
|
|
|
|
ZEXTERN int ZEXPORT deflatePending(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 |
|
|
|
|
@ -792,9 +793,9 @@ ZEXTERN int ZEXPORT deflatePending OF((z_streamp strm, |
|
|
|
|
stream state was inconsistent. |
|
|
|
|
*/ |
|
|
|
|
|
|
|
|
|
ZEXTERN int ZEXPORT deflatePrime OF((z_streamp strm, |
|
|
|
|
int bits, |
|
|
|
|
int value)); |
|
|
|
|
ZEXTERN int ZEXPORT deflatePrime(z_streamp strm, |
|
|
|
|
int bits, |
|
|
|
|
int value); |
|
|
|
|
/*
|
|
|
|
|
deflatePrime() inserts bits in the deflate output stream. The intent |
|
|
|
|
is that this function is used to start off the deflate output with the bits |
|
|
|
|
@ -809,8 +810,8 @@ ZEXTERN int ZEXPORT deflatePrime OF((z_streamp strm, |
|
|
|
|
source stream state was inconsistent. |
|
|
|
|
*/ |
|
|
|
|
|
|
|
|
|
ZEXTERN int ZEXPORT deflateSetHeader OF((z_streamp strm, |
|
|
|
|
gz_headerp head)); |
|
|
|
|
ZEXTERN int ZEXPORT deflateSetHeader(z_streamp strm, |
|
|
|
|
gz_headerp head); |
|
|
|
|
/*
|
|
|
|
|
deflateSetHeader() provides gzip header information for when a gzip |
|
|
|
|
stream is requested by deflateInit2(). deflateSetHeader() may be called |
|
|
|
|
@ -826,16 +827,17 @@ ZEXTERN int ZEXPORT deflateSetHeader OF((z_streamp strm, |
|
|
|
|
gzip file" and give up. |
|
|
|
|
|
|
|
|
|
If deflateSetHeader is not used, the default gzip header has text false, |
|
|
|
|
the time set to zero, and os set to 255, with no extra, name, or comment |
|
|
|
|
fields. The gzip header is returned to the default state by deflateReset(). |
|
|
|
|
the time set to zero, and os set to the current operating system, with no |
|
|
|
|
extra, name, or comment fields. The gzip header is returned to the default |
|
|
|
|
state by deflateReset(). |
|
|
|
|
|
|
|
|
|
deflateSetHeader returns Z_OK if success, or Z_STREAM_ERROR if the source |
|
|
|
|
stream state was inconsistent. |
|
|
|
|
*/ |
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
|
ZEXTERN int ZEXPORT inflateInit2 OF((z_streamp strm, |
|
|
|
|
int windowBits)); |
|
|
|
|
ZEXTERN int ZEXPORT inflateInit2(z_streamp strm, |
|
|
|
|
int windowBits); |
|
|
|
|
|
|
|
|
|
This is another version of inflateInit with an extra parameter. The |
|
|
|
|
fields next_in, avail_in, zalloc, zfree and opaque must be initialized |
|
|
|
|
@ -888,9 +890,9 @@ ZEXTERN int ZEXPORT inflateInit2 OF((z_streamp strm, |
|
|
|
|
deferred until inflate() is called. |
|
|
|
|
*/ |
|
|
|
|
|
|
|
|
|
ZEXTERN int ZEXPORT inflateSetDictionary OF((z_streamp strm, |
|
|
|
|
const Bytef *dictionary, |
|
|
|
|
uInt dictLength)); |
|
|
|
|
ZEXTERN int ZEXPORT inflateSetDictionary(z_streamp strm, |
|
|
|
|
const Bytef *dictionary, |
|
|
|
|
uInt dictLength); |
|
|
|
|
/*
|
|
|
|
|
Initializes the decompression dictionary from the given uncompressed byte |
|
|
|
|
sequence. This function must be called immediately after a call of inflate, |
|
|
|
|
@ -911,9 +913,9 @@ ZEXTERN int ZEXPORT inflateSetDictionary OF((z_streamp strm, |
|
|
|
|
inflate(). |
|
|
|
|
*/ |
|
|
|
|
|
|
|
|
|
ZEXTERN int ZEXPORT inflateGetDictionary OF((z_streamp strm, |
|
|
|
|
Bytef *dictionary, |
|
|
|
|
uInt *dictLength)); |
|
|
|
|
ZEXTERN int ZEXPORT inflateGetDictionary(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 |
|
|
|
|
@ -926,7 +928,7 @@ ZEXTERN int ZEXPORT inflateGetDictionary OF((z_streamp strm, |
|
|
|
|
stream state is inconsistent. |
|
|
|
|
*/ |
|
|
|
|
|
|
|
|
|
ZEXTERN int ZEXPORT inflateSync OF((z_streamp strm)); |
|
|
|
|
ZEXTERN int ZEXPORT inflateSync(z_streamp strm); |
|
|
|
|
/*
|
|
|
|
|
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 |
|
|
|
|
@ -945,8 +947,8 @@ ZEXTERN int ZEXPORT inflateSync OF((z_streamp strm)); |
|
|
|
|
input each time, until success or end of the input data. |
|
|
|
|
*/ |
|
|
|
|
|
|
|
|
|
ZEXTERN int ZEXPORT inflateCopy OF((z_streamp dest, |
|
|
|
|
z_streamp source)); |
|
|
|
|
ZEXTERN int ZEXPORT inflateCopy(z_streamp dest, |
|
|
|
|
z_streamp source); |
|
|
|
|
/*
|
|
|
|
|
Sets the destination stream as a complete copy of the source stream. |
|
|
|
|
|
|
|
|
|
@ -963,18 +965,19 @@ ZEXTERN int ZEXPORT inflateCopy OF((z_streamp dest, |
|
|
|
|
|
|
|
|
|
#endif /* !Z_FREETYPE */ |
|
|
|
|
|
|
|
|
|
ZEXTERN int ZEXPORT inflateReset OF((z_streamp strm)); |
|
|
|
|
ZEXTERN int ZEXPORT inflateReset(z_streamp strm); |
|
|
|
|
/*
|
|
|
|
|
This function is equivalent to inflateEnd followed by inflateInit, |
|
|
|
|
but does not free and reallocate the internal decompression state. The |
|
|
|
|
stream will keep attributes that may have been set by inflateInit2. |
|
|
|
|
total_in, total_out, adler, and msg are initialized. |
|
|
|
|
|
|
|
|
|
inflateReset returns Z_OK if success, or Z_STREAM_ERROR if the source |
|
|
|
|
stream state was inconsistent (such as zalloc or state being Z_NULL). |
|
|
|
|
*/ |
|
|
|
|
|
|
|
|
|
ZEXTERN int ZEXPORT inflateReset2 OF((z_streamp strm, |
|
|
|
|
int windowBits)); |
|
|
|
|
ZEXTERN int ZEXPORT inflateReset2(z_streamp strm, |
|
|
|
|
int windowBits); |
|
|
|
|
/*
|
|
|
|
|
This function is the same as inflateReset, but it also permits changing |
|
|
|
|
the wrap and window size requests. The windowBits parameter is interpreted |
|
|
|
|
@ -989,9 +992,9 @@ ZEXTERN int ZEXPORT inflateReset2 OF((z_streamp strm, |
|
|
|
|
|
|
|
|
|
#ifndef Z_FREETYPE |
|
|
|
|
|
|
|
|
|
ZEXTERN int ZEXPORT inflatePrime OF((z_streamp strm, |
|
|
|
|
int bits, |
|
|
|
|
int value)); |
|
|
|
|
ZEXTERN int ZEXPORT inflatePrime(z_streamp strm, |
|
|
|
|
int bits, |
|
|
|
|
int value); |
|
|
|
|
/*
|
|
|
|
|
This function inserts bits in the inflate input stream. The intent is |
|
|
|
|
that this function is used to start inflating at a bit position in the |
|
|
|
|
@ -1010,7 +1013,7 @@ ZEXTERN int ZEXPORT inflatePrime OF((z_streamp strm, |
|
|
|
|
stream state was inconsistent. |
|
|
|
|
*/ |
|
|
|
|
|
|
|
|
|
ZEXTERN long ZEXPORT inflateMark OF((z_streamp strm)); |
|
|
|
|
ZEXTERN long ZEXPORT inflateMark(z_streamp strm); |
|
|
|
|
/*
|
|
|
|
|
This function returns two values, one in the lower 16 bits of the return |
|
|
|
|
value, and the other in the remaining upper bits, obtained by shifting the |
|
|
|
|
@ -1038,8 +1041,8 @@ ZEXTERN long ZEXPORT inflateMark OF((z_streamp strm)); |
|
|
|
|
source stream state was inconsistent. |
|
|
|
|
*/ |
|
|
|
|
|
|
|
|
|
ZEXTERN int ZEXPORT inflateGetHeader OF((z_streamp strm, |
|
|
|
|
gz_headerp head)); |
|
|
|
|
ZEXTERN int ZEXPORT inflateGetHeader(z_streamp strm, |
|
|
|
|
gz_headerp head); |
|
|
|
|
/*
|
|
|
|
|
inflateGetHeader() requests that gzip header information be stored in the |
|
|
|
|
provided gz_header structure. inflateGetHeader() may be called after |
|
|
|
|
@ -1081,8 +1084,8 @@ ZEXTERN int ZEXPORT inflateGetHeader OF((z_streamp strm, |
|
|
|
|
#endif /* !Z_FREETYPE */ |
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
|
ZEXTERN int ZEXPORT inflateBackInit OF((z_streamp strm, int windowBits, |
|
|
|
|
unsigned char FAR *window)); |
|
|
|
|
ZEXTERN int ZEXPORT inflateBackInit(z_streamp strm, int windowBits, |
|
|
|
|
unsigned char FAR *window); |
|
|
|
|
|
|
|
|
|
Initialize the internal stream state for decompression using inflateBack() |
|
|
|
|
calls. The fields zalloc, zfree and opaque in strm must be initialized |
|
|
|
|
@ -1102,15 +1105,15 @@ ZEXTERN int ZEXPORT inflateBackInit OF((z_streamp strm, int windowBits, |
|
|
|
|
the version of the header file. |
|
|
|
|
*/ |
|
|
|
|
|
|
|
|
|
typedef unsigned (*in_func) OF((void FAR *, |
|
|
|
|
z_const unsigned char FAR * FAR *)); |
|
|
|
|
typedef int (*out_func) OF((void FAR *, unsigned char FAR *, unsigned)); |
|
|
|
|
typedef unsigned (*in_func)(void FAR *, |
|
|
|
|
z_const unsigned char FAR * FAR *); |
|
|
|
|
typedef int (*out_func)(void FAR *, unsigned char FAR *, unsigned); |
|
|
|
|
|
|
|
|
|
#ifndef Z_FREETYPE |
|
|
|
|
|
|
|
|
|
ZEXTERN int ZEXPORT inflateBack OF((z_streamp strm, |
|
|
|
|
in_func in, void FAR *in_desc, |
|
|
|
|
out_func out, void FAR *out_desc)); |
|
|
|
|
ZEXTERN int ZEXPORT inflateBack(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 |
|
|
|
|
interface for input and output. This is potentially more efficient than |
|
|
|
|
@ -1178,7 +1181,7 @@ ZEXTERN int ZEXPORT inflateBack OF((z_streamp strm, |
|
|
|
|
cannot return Z_OK. |
|
|
|
|
*/ |
|
|
|
|
|
|
|
|
|
ZEXTERN int ZEXPORT inflateBackEnd OF((z_streamp strm)); |
|
|
|
|
ZEXTERN int ZEXPORT inflateBackEnd(z_streamp strm); |
|
|
|
|
/*
|
|
|
|
|
All memory allocated by inflateBackInit() is freed. |
|
|
|
|
|
|
|
|
|
@ -1186,7 +1189,7 @@ ZEXTERN int ZEXPORT inflateBackEnd OF((z_streamp strm)); |
|
|
|
|
state was inconsistent. |
|
|
|
|
*/ |
|
|
|
|
|
|
|
|
|
ZEXTERN uLong ZEXPORT zlibCompileFlags OF((void)); |
|
|
|
|
ZEXTERN uLong ZEXPORT zlibCompileFlags(void); |
|
|
|
|
/* Return flags indicating compile-time options.
|
|
|
|
|
|
|
|
|
|
Type sizes, two bits each, 00 = 16 bits, 01 = 32, 10 = 64, 11 = other: |
|
|
|
|
@ -1241,8 +1244,8 @@ ZEXTERN uLong ZEXPORT zlibCompileFlags OF((void)); |
|
|
|
|
you need special options. |
|
|
|
|
*/ |
|
|
|
|
|
|
|
|
|
ZEXTERN int ZEXPORT compress OF((Bytef *dest, uLongf *destLen, |
|
|
|
|
const Bytef *source, uLong sourceLen)); |
|
|
|
|
ZEXTERN int ZEXPORT compress(Bytef *dest, uLongf *destLen, |
|
|
|
|
const Bytef *source, uLong sourceLen); |
|
|
|
|
/*
|
|
|
|
|
Compresses the source buffer into the destination buffer. sourceLen is |
|
|
|
|
the byte length of the source buffer. Upon entry, destLen is the total size |
|
|
|
|
@ -1256,9 +1259,9 @@ ZEXTERN int ZEXPORT compress OF((Bytef *dest, uLongf *destLen, |
|
|
|
|
buffer. |
|
|
|
|
*/ |
|
|
|
|
|
|
|
|
|
ZEXTERN int ZEXPORT compress2 OF((Bytef *dest, uLongf *destLen, |
|
|
|
|
const Bytef *source, uLong sourceLen, |
|
|
|
|
int level)); |
|
|
|
|
ZEXTERN int ZEXPORT compress2(Bytef *dest, uLongf *destLen, |
|
|
|
|
const Bytef *source, uLong sourceLen, |
|
|
|
|
int level); |
|
|
|
|
/*
|
|
|
|
|
Compresses the source buffer into the destination buffer. The level |
|
|
|
|
parameter has the same meaning as in deflateInit. sourceLen is the byte |
|
|
|
|
@ -1272,15 +1275,15 @@ ZEXTERN int ZEXPORT compress2 OF((Bytef *dest, uLongf *destLen, |
|
|
|
|
Z_STREAM_ERROR if the level parameter is invalid. |
|
|
|
|
*/ |
|
|
|
|
|
|
|
|
|
ZEXTERN uLong ZEXPORT compressBound OF((uLong sourceLen)); |
|
|
|
|
ZEXTERN uLong ZEXPORT compressBound(uLong sourceLen); |
|
|
|
|
/*
|
|
|
|
|
compressBound() returns an upper bound on the compressed size after |
|
|
|
|
compress() or compress2() on sourceLen bytes. It would be used before a |
|
|
|
|
compress() or compress2() call to allocate the destination buffer. |
|
|
|
|
*/ |
|
|
|
|
|
|
|
|
|
ZEXTERN int ZEXPORT uncompress OF((Bytef *dest, uLongf *destLen, |
|
|
|
|
const Bytef *source, uLong sourceLen)); |
|
|
|
|
ZEXTERN int ZEXPORT uncompress(Bytef *dest, uLongf *destLen, |
|
|
|
|
const Bytef *source, uLong sourceLen); |
|
|
|
|
/*
|
|
|
|
|
Decompresses the source buffer into the destination buffer. sourceLen is |
|
|
|
|
the byte length of the source buffer. Upon entry, destLen is the total size |
|
|
|
|
@ -1297,8 +1300,8 @@ ZEXTERN int ZEXPORT uncompress OF((Bytef *dest, uLongf *destLen, |
|
|
|
|
buffer with the uncompressed data up to that point. |
|
|
|
|
*/ |
|
|
|
|
|
|
|
|
|
ZEXTERN int ZEXPORT uncompress2 OF((Bytef *dest, uLongf *destLen, |
|
|
|
|
const Bytef *source, uLong *sourceLen)); |
|
|
|
|
ZEXTERN int ZEXPORT uncompress2(Bytef *dest, uLongf *destLen, |
|
|
|
|
const Bytef *source, uLong *sourceLen); |
|
|
|
|
/*
|
|
|
|
|
Same as uncompress, except that sourceLen is a pointer, where the |
|
|
|
|
length of the source is *sourceLen. On return, *sourceLen is the number of |
|
|
|
|
@ -1317,7 +1320,7 @@ ZEXTERN int ZEXPORT uncompress2 OF((Bytef *dest, uLongf *destLen, |
|
|
|
|
typedef struct gzFile_s *gzFile; /* semi-opaque gzip file descriptor */ |
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
|
ZEXTERN gzFile ZEXPORT gzopen OF((const char *path, const char *mode)); |
|
|
|
|
ZEXTERN gzFile ZEXPORT gzopen(const char *path, const char *mode); |
|
|
|
|
|
|
|
|
|
Open the gzip (.gz) file at path for reading and decompressing, or |
|
|
|
|
compressing and writing. The mode parameter is as in fopen ("rb" or "wb") |
|
|
|
|
@ -1354,7 +1357,7 @@ ZEXTERN gzFile ZEXPORT gzopen OF((const char *path, const char *mode)); |
|
|
|
|
file could not be opened. |
|
|
|
|
*/ |
|
|
|
|
|
|
|
|
|
ZEXTERN gzFile ZEXPORT gzdopen OF((int fd, const char *mode)); |
|
|
|
|
ZEXTERN gzFile ZEXPORT gzdopen(int fd, const char *mode); |
|
|
|
|
/*
|
|
|
|
|
Associate a gzFile with the file descriptor fd. File descriptors are |
|
|
|
|
obtained from calls like open, dup, creat, pipe or fileno (if the file has |
|
|
|
|
@ -1377,7 +1380,7 @@ ZEXTERN gzFile ZEXPORT gzdopen OF((int fd, const char *mode)); |
|
|
|
|
will not detect if fd is invalid (unless fd is -1). |
|
|
|
|
*/ |
|
|
|
|
|
|
|
|
|
ZEXTERN int ZEXPORT gzbuffer OF((gzFile file, unsigned size)); |
|
|
|
|
ZEXTERN int ZEXPORT gzbuffer(gzFile file, unsigned size); |
|
|
|
|
/*
|
|
|
|
|
Set the internal buffer size used by this library's functions for file to |
|
|
|
|
size. The default buffer size is 8192 bytes. This function must be called |
|
|
|
|
@ -1393,7 +1396,7 @@ ZEXTERN int ZEXPORT gzbuffer OF((gzFile file, unsigned size)); |
|
|
|
|
too late. |
|
|
|
|
*/ |
|
|
|
|
|
|
|
|
|
ZEXTERN int ZEXPORT gzsetparams OF((gzFile file, int level, int strategy)); |
|
|
|
|
ZEXTERN int ZEXPORT gzsetparams(gzFile file, int level, int strategy); |
|
|
|
|
/*
|
|
|
|
|
Dynamically update the compression level and strategy for file. See the |
|
|
|
|
description of deflateInit2 for the meaning of these parameters. Previously |
|
|
|
|
@ -1404,7 +1407,7 @@ ZEXTERN int ZEXPORT gzsetparams OF((gzFile file, int level, int strategy)); |
|
|
|
|
or Z_MEM_ERROR if there is a memory allocation error. |
|
|
|
|
*/ |
|
|
|
|
|
|
|
|
|
ZEXTERN int ZEXPORT gzread OF((gzFile file, voidp buf, unsigned len)); |
|
|
|
|
ZEXTERN int ZEXPORT gzread(gzFile file, voidp buf, unsigned len); |
|
|
|
|
/*
|
|
|
|
|
Read and decompress up to len uncompressed bytes from file into buf. If |
|
|
|
|
the input file is not in gzip format, gzread copies the given number of |
|
|
|
|
@ -1434,8 +1437,8 @@ ZEXTERN int ZEXPORT gzread OF((gzFile file, voidp buf, unsigned len)); |
|
|
|
|
Z_STREAM_ERROR. |
|
|
|
|
*/ |
|
|
|
|
|
|
|
|
|
ZEXTERN z_size_t ZEXPORT gzfread OF((voidp buf, z_size_t size, z_size_t nitems, |
|
|
|
|
gzFile file)); |
|
|
|
|
ZEXTERN z_size_t ZEXPORT gzfread(voidp buf, z_size_t size, z_size_t nitems, |
|
|
|
|
gzFile file); |
|
|
|
|
/*
|
|
|
|
|
Read and decompress up to nitems items of size size from file into buf, |
|
|
|
|
otherwise operating as gzread() does. This duplicates the interface of |
|
|
|
|
@ -1460,14 +1463,14 @@ ZEXTERN z_size_t ZEXPORT gzfread OF((voidp buf, z_size_t size, z_size_t nitems, |
|
|
|
|
file, resetting and retrying on end-of-file, when size is not 1. |
|
|
|
|
*/ |
|
|
|
|
|
|
|
|
|
ZEXTERN int ZEXPORT gzwrite OF((gzFile file, voidpc buf, unsigned len)); |
|
|
|
|
ZEXTERN int ZEXPORT gzwrite(gzFile file, voidpc buf, unsigned len); |
|
|
|
|
/*
|
|
|
|
|
Compress and write the len uncompressed bytes at buf to file. gzwrite |
|
|
|
|
returns the number of uncompressed bytes written or 0 in case of error. |
|
|
|
|
*/ |
|
|
|
|
|
|
|
|
|
ZEXTERN z_size_t ZEXPORT gzfwrite OF((voidpc buf, z_size_t size, |
|
|
|
|
z_size_t nitems, gzFile file)); |
|
|
|
|
ZEXTERN z_size_t ZEXPORT gzfwrite(voidpc buf, z_size_t size, |
|
|
|
|
z_size_t nitems, gzFile file); |
|
|
|
|
/*
|
|
|
|
|
Compress and write nitems items of size size from buf to file, duplicating |
|
|
|
|
the interface of stdio's fwrite(), with size_t request and return types. If |
|
|
|
|
@ -1480,7 +1483,7 @@ ZEXTERN z_size_t ZEXPORT gzfwrite OF((voidpc buf, z_size_t size, |
|
|
|
|
is returned, and the error state is set to Z_STREAM_ERROR. |
|
|
|
|
*/ |
|
|
|
|
|
|
|
|
|
ZEXTERN int ZEXPORTVA gzprintf Z_ARG((gzFile file, const char *format, ...)); |
|
|
|
|
ZEXTERN int ZEXPORTVA gzprintf(gzFile file, const char *format, ...); |
|
|
|
|
/*
|
|
|
|
|
Convert, format, compress, and write the arguments (...) to file under |
|
|
|
|
control of the string format, as in fprintf. gzprintf returns the number of |
|
|
|
|
@ -1495,7 +1498,7 @@ ZEXTERN int ZEXPORTVA gzprintf Z_ARG((gzFile file, const char *format, ...)); |
|
|
|
|
This can be determined using zlibCompileFlags(). |
|
|
|
|
*/ |
|
|
|
|
|
|
|
|
|
ZEXTERN int ZEXPORT gzputs OF((gzFile file, const char *s)); |
|
|
|
|
ZEXTERN int ZEXPORT gzputs(gzFile file, const char *s); |
|
|
|
|
/*
|
|
|
|
|
Compress and write the given null-terminated string s to file, excluding |
|
|
|
|
the terminating null character. |
|
|
|
|
@ -1503,7 +1506,7 @@ ZEXTERN int ZEXPORT gzputs OF((gzFile file, const char *s)); |
|
|
|
|
gzputs returns the number of characters written, or -1 in case of error. |
|
|
|
|
*/ |
|
|
|
|
|
|
|
|
|
ZEXTERN char * ZEXPORT gzgets OF((gzFile file, char *buf, int len)); |
|
|
|
|
ZEXTERN char * ZEXPORT gzgets(gzFile file, char *buf, int len); |
|
|
|
|
/*
|
|
|
|
|
Read and decompress bytes from file into buf, until len-1 characters are |
|
|
|
|
read, or until a newline character is read and transferred to buf, or an |
|
|
|
|
@ -1517,13 +1520,13 @@ ZEXTERN char * ZEXPORT gzgets OF((gzFile file, char *buf, int len)); |
|
|
|
|
buf are indeterminate. |
|
|
|
|
*/ |
|
|
|
|
|
|
|
|
|
ZEXTERN int ZEXPORT gzputc OF((gzFile file, int c)); |
|
|
|
|
ZEXTERN int ZEXPORT gzputc(gzFile file, int c); |
|
|
|
|
/*
|
|
|
|
|
Compress and write c, converted to an unsigned char, into file. gzputc |
|
|
|
|
returns the value that was written, or -1 in case of error. |
|
|
|
|
*/ |
|
|
|
|
|
|
|
|
|
ZEXTERN int ZEXPORT gzgetc OF((gzFile file)); |
|
|
|
|
ZEXTERN int ZEXPORT gzgetc(gzFile file); |
|
|
|
|
/*
|
|
|
|
|
Read and decompress one byte from file. gzgetc returns this byte or -1 |
|
|
|
|
in case of end of file or error. This is implemented as a macro for speed. |
|
|
|
|
@ -1532,7 +1535,7 @@ ZEXTERN int ZEXPORT gzgetc OF((gzFile file)); |
|
|
|
|
points to has been clobbered or not. |
|
|
|
|
*/ |
|
|
|
|
|
|
|
|
|
ZEXTERN int ZEXPORT gzungetc OF((int c, gzFile file)); |
|
|
|
|
ZEXTERN int ZEXPORT gzungetc(int c, gzFile file); |
|
|
|
|
/*
|
|
|
|
|
Push c back onto the stream for file to be read as the first character on |
|
|
|
|
the next read. At least one character of push-back is always allowed. |
|
|
|
|
@ -1544,7 +1547,7 @@ ZEXTERN int ZEXPORT gzungetc OF((int c, gzFile file)); |
|
|
|
|
gzseek() or gzrewind(). |
|
|
|
|
*/ |
|
|
|
|
|
|
|
|
|
ZEXTERN int ZEXPORT gzflush OF((gzFile file, int flush)); |
|
|
|
|
ZEXTERN int ZEXPORT gzflush(gzFile file, int flush); |
|
|
|
|
/*
|
|
|
|
|
Flush all pending output to file. The parameter flush is as in the |
|
|
|
|
deflate() function. The return value is the zlib error number (see function |
|
|
|
|
@ -1560,8 +1563,8 @@ ZEXTERN int ZEXPORT gzflush OF((gzFile file, int flush)); |
|
|
|
|
*/ |
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
|
ZEXTERN z_off_t ZEXPORT gzseek OF((gzFile file, |
|
|
|
|
z_off_t offset, int whence)); |
|
|
|
|
ZEXTERN z_off_t ZEXPORT gzseek(gzFile file, |
|
|
|
|
z_off_t offset, int whence); |
|
|
|
|
|
|
|
|
|
Set the starting position to offset relative to whence for the next gzread |
|
|
|
|
or gzwrite on file. The offset represents a number of bytes in the |
|
|
|
|
@ -1579,7 +1582,7 @@ ZEXTERN z_off_t ZEXPORT gzseek OF((gzFile file, |
|
|
|
|
would be before the current position. |
|
|
|
|
*/ |
|
|
|
|
|
|
|
|
|
ZEXTERN int ZEXPORT gzrewind OF((gzFile file)); |
|
|
|
|
ZEXTERN int ZEXPORT gzrewind(gzFile file); |
|
|
|
|
/*
|
|
|
|
|
Rewind file. This function is supported only for reading. |
|
|
|
|
|
|
|
|
|
@ -1587,7 +1590,7 @@ ZEXTERN int ZEXPORT gzrewind OF((gzFile file)); |
|
|
|
|
*/ |
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
|
ZEXTERN z_off_t ZEXPORT gztell OF((gzFile file)); |
|
|
|
|
ZEXTERN z_off_t ZEXPORT gztell(gzFile file); |
|
|
|
|
|
|
|
|
|
Return the starting position for the next gzread or gzwrite on file. |
|
|
|
|
This position represents a number of bytes in the uncompressed data stream, |
|
|
|
|
@ -1598,7 +1601,7 @@ ZEXTERN z_off_t ZEXPORT gztell OF((gzFile file)); |
|
|
|
|
*/ |
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
|
ZEXTERN z_off_t ZEXPORT gzoffset OF((gzFile file)); |
|
|
|
|
ZEXTERN z_off_t ZEXPORT gzoffset(gzFile file); |
|
|
|
|
|
|
|
|
|
Return the current compressed (actual) read or write offset of file. This |
|
|
|
|
offset includes the count of bytes that precede the gzip stream, for example |
|
|
|
|
@ -1607,7 +1610,7 @@ ZEXTERN z_off_t ZEXPORT gzoffset OF((gzFile file)); |
|
|
|
|
be used for a progress indicator. On error, gzoffset() returns -1. |
|
|
|
|
*/ |
|
|
|
|
|
|
|
|
|
ZEXTERN int ZEXPORT gzeof OF((gzFile file)); |
|
|
|
|
ZEXTERN int ZEXPORT gzeof(gzFile file); |
|
|
|
|
/*
|
|
|
|
|
Return true (1) if the end-of-file indicator for file has been set while |
|
|
|
|
reading, false (0) otherwise. Note that the end-of-file indicator is set |
|
|
|
|
@ -1622,7 +1625,7 @@ ZEXTERN int ZEXPORT gzeof OF((gzFile file)); |
|
|
|
|
has grown since the previous end of file was detected. |
|
|
|
|
*/ |
|
|
|
|
|
|
|
|
|
ZEXTERN int ZEXPORT gzdirect OF((gzFile file)); |
|
|
|
|
ZEXTERN int ZEXPORT gzdirect(gzFile file); |
|
|
|
|
/*
|
|
|
|
|
Return true (1) if file is being copied directly while reading, or false |
|
|
|
|
(0) if file is a gzip stream being decompressed. |
|
|
|
|
@ -1643,7 +1646,7 @@ ZEXTERN int ZEXPORT gzdirect OF((gzFile file)); |
|
|
|
|
gzip file reading and decompression, which may not be desired.) |
|
|
|
|
*/ |
|
|
|
|
|
|
|
|
|
ZEXTERN int ZEXPORT gzclose OF((gzFile file)); |
|
|
|
|
ZEXTERN int ZEXPORT gzclose(gzFile file); |
|
|
|
|
/*
|
|
|
|
|
Flush all pending output for file, if necessary, close file and |
|
|
|
|
deallocate the (de)compression state. Note that once file is closed, you |
|
|
|
|
@ -1656,8 +1659,8 @@ ZEXTERN int ZEXPORT gzclose OF((gzFile file)); |
|
|
|
|
last read ended in the middle of a gzip stream, or Z_OK on success. |
|
|
|
|
*/ |
|
|
|
|
|
|
|
|
|
ZEXTERN int ZEXPORT gzclose_r OF((gzFile file)); |
|
|
|
|
ZEXTERN int ZEXPORT gzclose_w OF((gzFile file)); |
|
|
|
|
ZEXTERN int ZEXPORT gzclose_r(gzFile file); |
|
|
|
|
ZEXTERN int ZEXPORT gzclose_w(gzFile file); |
|
|
|
|
/*
|
|
|
|
|
Same as gzclose(), but gzclose_r() is only for use when reading, and |
|
|
|
|
gzclose_w() is only for use when writing or appending. The advantage to |
|
|
|
|
@ -1668,7 +1671,7 @@ ZEXTERN int ZEXPORT gzclose_w OF((gzFile file)); |
|
|
|
|
zlib library. |
|
|
|
|
*/ |
|
|
|
|
|
|
|
|
|
ZEXTERN const char * ZEXPORT gzerror OF((gzFile file, int *errnum)); |
|
|
|
|
ZEXTERN const char * ZEXPORT gzerror(gzFile file, int *errnum); |
|
|
|
|
/*
|
|
|
|
|
Return the error message for the last error which occurred on file. |
|
|
|
|
errnum is set to zlib error number. If an error occurred in the file system |
|
|
|
|
@ -1684,7 +1687,7 @@ ZEXTERN const char * ZEXPORT gzerror OF((gzFile file, int *errnum)); |
|
|
|
|
functions above that do not distinguish those cases in their return values. |
|
|
|
|
*/ |
|
|
|
|
|
|
|
|
|
ZEXTERN void ZEXPORT gzclearerr OF((gzFile file)); |
|
|
|
|
ZEXTERN void ZEXPORT gzclearerr(gzFile file); |
|
|
|
|
/*
|
|
|
|
|
Clear 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 |
|
|
|
|
@ -1701,7 +1704,7 @@ ZEXTERN void ZEXPORT gzclearerr OF((gzFile file)); |
|
|
|
|
library. |
|
|
|
|
*/ |
|
|
|
|
|
|
|
|
|
ZEXTERN uLong ZEXPORT adler32 OF((uLong adler, const Bytef *buf, uInt len)); |
|
|
|
|
ZEXTERN uLong ZEXPORT adler32(uLong adler, const Bytef *buf, uInt len); |
|
|
|
|
/*
|
|
|
|
|
Update a running Adler-32 checksum with the bytes buf[0..len-1] and |
|
|
|
|
return the updated checksum. An Adler-32 value is in the range of a 32-bit |
|
|
|
|
@ -1721,15 +1724,15 @@ ZEXTERN uLong ZEXPORT adler32 OF((uLong adler, const Bytef *buf, uInt len)); |
|
|
|
|
if (adler != original_adler) error(); |
|
|
|
|
*/ |
|
|
|
|
|
|
|
|
|
ZEXTERN uLong ZEXPORT adler32_z OF((uLong adler, const Bytef *buf, |
|
|
|
|
z_size_t len)); |
|
|
|
|
ZEXTERN uLong ZEXPORT adler32_z(uLong adler, const Bytef *buf, |
|
|
|
|
z_size_t len); |
|
|
|
|
/*
|
|
|
|
|
Same as adler32(), but with a size_t length. |
|
|
|
|
*/ |
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
|
ZEXTERN uLong ZEXPORT adler32_combine OF((uLong adler1, uLong adler2, |
|
|
|
|
z_off_t len2)); |
|
|
|
|
ZEXTERN uLong ZEXPORT adler32_combine(uLong adler1, uLong adler2, |
|
|
|
|
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 |
|
|
|
|
@ -1739,7 +1742,7 @@ ZEXTERN uLong ZEXPORT adler32_combine OF((uLong adler1, uLong adler2, |
|
|
|
|
negative, the result has no meaning or utility. |
|
|
|
|
*/ |
|
|
|
|
|
|
|
|
|
ZEXTERN uLong ZEXPORT crc32 OF((uLong crc, const Bytef *buf, uInt len)); |
|
|
|
|
ZEXTERN uLong ZEXPORT crc32(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. A CRC-32 value is in the range of a 32-bit unsigned integer. |
|
|
|
|
@ -1757,14 +1760,14 @@ ZEXTERN uLong ZEXPORT crc32 OF((uLong crc, const Bytef *buf, uInt len)); |
|
|
|
|
if (crc != original_crc) error(); |
|
|
|
|
*/ |
|
|
|
|
|
|
|
|
|
ZEXTERN uLong ZEXPORT crc32_z OF((uLong crc, const Bytef *buf, |
|
|
|
|
z_size_t len)); |
|
|
|
|
ZEXTERN uLong ZEXPORT crc32_z(uLong crc, const Bytef *buf, |
|
|
|
|
z_size_t len); |
|
|
|
|
/*
|
|
|
|
|
Same as crc32(), but with a size_t length. |
|
|
|
|
*/ |
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
|
ZEXTERN uLong ZEXPORT crc32_combine OF((uLong crc1, uLong crc2, z_off_t len2)); |
|
|
|
|
ZEXTERN uLong ZEXPORT crc32_combine(uLong crc1, uLong crc2, z_off_t len2); |
|
|
|
|
|
|
|
|
|
Combine two CRC-32 check values into one. For two sequences of bytes, |
|
|
|
|
seq1 and seq2 with lengths len1 and len2, CRC-32 check values were |
|
|
|
|
@ -1774,7 +1777,7 @@ ZEXTERN uLong ZEXPORT crc32_combine OF((uLong crc1, uLong crc2, z_off_t len2)); |
|
|
|
|
*/ |
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
|
ZEXTERN uLong ZEXPORT crc32_combine_gen OF((z_off_t len2)); |
|
|
|
|
ZEXTERN uLong ZEXPORT crc32_combine_gen(z_off_t len2); |
|
|
|
|
|
|
|
|
|
Return the operator corresponding to length len2, to be used with |
|
|
|
|
crc32_combine_op(). |
|
|
|
|
@ -1782,7 +1785,7 @@ ZEXTERN uLong ZEXPORT crc32_combine_gen OF((z_off_t len2)); |
|
|
|
|
|
|
|
|
|
#ifndef Z_FREETYPE |
|
|
|
|
|
|
|
|
|
ZEXTERN uLong ZEXPORT crc32_combine_op OF((uLong crc1, uLong crc2, uLong op)); |
|
|
|
|
ZEXTERN uLong ZEXPORT crc32_combine_op(uLong crc1, uLong crc2, uLong op); |
|
|
|
|
/*
|
|
|
|
|
Give the same result as crc32_combine(), using op in place of len2. op is |
|
|
|
|
is generated from len2 by crc32_combine_gen(). This will be faster than |
|
|
|
|
@ -1795,20 +1798,20 @@ ZEXTERN uLong ZEXPORT crc32_combine_op OF((uLong crc1, uLong crc2, uLong op)); |
|
|
|
|
/* deflateInit and inflateInit are macros to allow checking the zlib version
|
|
|
|
|
* and the compiler's view of z_stream: |
|
|
|
|
*/ |
|
|
|
|
ZEXTERN int ZEXPORT deflateInit_ OF((z_streamp strm, int level, |
|
|
|
|
const char *version, int stream_size)); |
|
|
|
|
ZEXTERN int ZEXPORT inflateInit_ OF((z_streamp strm, |
|
|
|
|
const char *version, int stream_size)); |
|
|
|
|
ZEXTERN int ZEXPORT deflateInit2_ OF((z_streamp strm, int level, int method, |
|
|
|
|
int windowBits, int memLevel, |
|
|
|
|
int strategy, const char *version, |
|
|
|
|
int stream_size)); |
|
|
|
|
ZEXTERN int ZEXPORT inflateInit2_ OF((z_streamp strm, int windowBits, |
|
|
|
|
const char *version, int stream_size)); |
|
|
|
|
ZEXTERN int ZEXPORT inflateBackInit_ OF((z_streamp strm, int windowBits, |
|
|
|
|
unsigned char FAR *window, |
|
|
|
|
const char *version, |
|
|
|
|
int stream_size)); |
|
|
|
|
ZEXTERN int ZEXPORT deflateInit_(z_streamp strm, int level, |
|
|
|
|
const char *version, int stream_size); |
|
|
|
|
ZEXTERN int ZEXPORT inflateInit_(z_streamp strm, |
|
|
|
|
const char *version, int stream_size); |
|
|
|
|
ZEXTERN int ZEXPORT deflateInit2_(z_streamp strm, int level, int method, |
|
|
|
|
int windowBits, int memLevel, |
|
|
|
|
int strategy, const char *version, |
|
|
|
|
int stream_size); |
|
|
|
|
ZEXTERN int ZEXPORT inflateInit2_(z_streamp strm, int windowBits, |
|
|
|
|
const char *version, int stream_size); |
|
|
|
|
ZEXTERN int ZEXPORT inflateBackInit_(z_streamp strm, int windowBits, |
|
|
|
|
unsigned char FAR *window, |
|
|
|
|
const char *version, |
|
|
|
|
int stream_size); |
|
|
|
|
#ifdef Z_PREFIX_SET |
|
|
|
|
# define z_deflateInit(strm, level) \ |
|
|
|
|
deflateInit_((strm), (level), ZLIB_VERSION, (int)sizeof(z_stream)) |
|
|
|
|
@ -1841,9 +1844,8 @@ ZEXTERN int ZEXPORT inflateBackInit_ OF((z_streamp strm, int windowBits, |
|
|
|
|
|
|
|
|
|
#else /* Z_FREETYPE */ |
|
|
|
|
|
|
|
|
|
|
|
|
|
|
ZEXTERN int ZEXPORT inflateInit2_ OF((z_streamp strm, int windowBits, |
|
|
|
|
const char *version, int stream_size)); |
|
|
|
|
ZEXTERN int ZEXPORT inflateInit2_(z_streamp strm, int windowBits, |
|
|
|
|
const char *version, int stream_size); |
|
|
|
|
|
|
|
|
|
# define inflateInit2(strm, windowBits) \ |
|
|
|
|
inflateInit2_((strm), (windowBits), ZLIB_VERSION, \
|
|
|
|
|
@ -1851,7 +1853,6 @@ ZEXTERN int ZEXPORT inflateInit2_ OF((z_streamp strm, int windowBits, |
|
|
|
|
|
|
|
|
|
#endif /* Z_FREETYPE */ |
|
|
|
|
|
|
|
|
|
|
|
|
|
|
#ifndef Z_SOLO |
|
|
|
|
|
|
|
|
|
/* gzgetc() macro and its supporting function and exposed data structure. Note
|
|
|
|
|
@ -1866,7 +1867,7 @@ struct gzFile_s { |
|
|
|
|
unsigned char *next; |
|
|
|
|
z_off64_t pos; |
|
|
|
|
}; |
|
|
|
|
ZEXTERN int ZEXPORT gzgetc_ OF((gzFile file)); /* backward compatibility */ |
|
|
|
|
ZEXTERN int ZEXPORT gzgetc_(gzFile file); /* backward compatibility */ |
|
|
|
|
#ifdef Z_PREFIX_SET |
|
|
|
|
# undef z_gzgetc |
|
|
|
|
# define z_gzgetc(g) \ |
|
|
|
|
@ -1883,13 +1884,13 @@ ZEXTERN int ZEXPORT gzgetc_ OF((gzFile file)); /* backward compatibility */ |
|
|
|
|
* without large file support, _LFS64_LARGEFILE must also be true |
|
|
|
|
*/ |
|
|
|
|
#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)); |
|
|
|
|
ZEXTERN uLong ZEXPORT crc32_combine_gen64 OF((z_off64_t)); |
|
|
|
|
ZEXTERN gzFile ZEXPORT gzopen64(const char *, const char *); |
|
|
|
|
ZEXTERN z_off64_t ZEXPORT gzseek64(gzFile, z_off64_t, int); |
|
|
|
|
ZEXTERN z_off64_t ZEXPORT gztell64(gzFile); |
|
|
|
|
ZEXTERN z_off64_t ZEXPORT gzoffset64(gzFile); |
|
|
|
|
ZEXTERN uLong ZEXPORT adler32_combine64(uLong, uLong, z_off64_t); |
|
|
|
|
ZEXTERN uLong ZEXPORT crc32_combine64(uLong, uLong, z_off64_t); |
|
|
|
|
ZEXTERN uLong ZEXPORT crc32_combine_gen64(z_off64_t); |
|
|
|
|
#endif |
|
|
|
|
|
|
|
|
|
#if !defined(ZLIB_INTERNAL) && defined(Z_WANT64) |
|
|
|
|
@ -1911,55 +1912,55 @@ ZEXTERN int ZEXPORT gzgetc_ OF((gzFile file)); /* backward compatibility */ |
|
|
|
|
# define crc32_combine_gen crc32_combine_gen64 |
|
|
|
|
# endif |
|
|
|
|
# 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 gzoffset64 OF((gzFile)); |
|
|
|
|
ZEXTERN uLong ZEXPORT adler32_combine64 OF((uLong, uLong, z_off_t)); |
|
|
|
|
ZEXTERN uLong ZEXPORT crc32_combine64 OF((uLong, uLong, z_off_t)); |
|
|
|
|
ZEXTERN uLong ZEXPORT crc32_combine_gen64 OF((z_off_t)); |
|
|
|
|
ZEXTERN gzFile ZEXPORT gzopen64(const char *, const char *); |
|
|
|
|
ZEXTERN z_off_t ZEXPORT gzseek64(gzFile, z_off_t, int); |
|
|
|
|
ZEXTERN z_off_t ZEXPORT gztell64(gzFile); |
|
|
|
|
ZEXTERN z_off_t ZEXPORT gzoffset64(gzFile); |
|
|
|
|
ZEXTERN uLong ZEXPORT adler32_combine64(uLong, uLong, z_off_t); |
|
|
|
|
ZEXTERN uLong ZEXPORT crc32_combine64(uLong, uLong, z_off_t); |
|
|
|
|
ZEXTERN uLong ZEXPORT crc32_combine_gen64(z_off_t); |
|
|
|
|
# endif |
|
|
|
|
#else |
|
|
|
|
ZEXTERN gzFile ZEXPORT gzopen OF((const char *, const char *)); |
|
|
|
|
ZEXTERN z_off_t ZEXPORT gzseek OF((gzFile, z_off_t, int)); |
|
|
|
|
ZEXTERN z_off_t ZEXPORT gztell 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)); |
|
|
|
|
ZEXTERN uLong ZEXPORT crc32_combine_gen OF((z_off_t)); |
|
|
|
|
ZEXTERN gzFile ZEXPORT gzopen(const char *, const char *); |
|
|
|
|
ZEXTERN z_off_t ZEXPORT gzseek(gzFile, z_off_t, int); |
|
|
|
|
ZEXTERN z_off_t ZEXPORT gztell(gzFile); |
|
|
|
|
ZEXTERN z_off_t ZEXPORT gzoffset(gzFile); |
|
|
|
|
ZEXTERN uLong ZEXPORT adler32_combine(uLong, uLong, z_off_t); |
|
|
|
|
ZEXTERN uLong ZEXPORT crc32_combine(uLong, uLong, z_off_t); |
|
|
|
|
ZEXTERN uLong ZEXPORT crc32_combine_gen(z_off_t); |
|
|
|
|
#endif |
|
|
|
|
|
|
|
|
|
#else /* Z_SOLO */ |
|
|
|
|
|
|
|
|
|
#ifndef Z_FREETYPE |
|
|
|
|
ZEXTERN uLong ZEXPORT adler32_combine OF((uLong, uLong, z_off_t)); |
|
|
|
|
ZEXTERN uLong ZEXPORT crc32_combine OF((uLong, uLong, z_off_t)); |
|
|
|
|
ZEXTERN uLong ZEXPORT crc32_combine_gen OF((z_off_t)); |
|
|
|
|
ZEXTERN uLong ZEXPORT adler32_combine(uLong, uLong, z_off_t); |
|
|
|
|
ZEXTERN uLong ZEXPORT crc32_combine(uLong, uLong, z_off_t); |
|
|
|
|
ZEXTERN uLong ZEXPORT crc32_combine_gen(z_off_t); |
|
|
|
|
#endif |
|
|
|
|
|
|
|
|
|
#endif /* !Z_SOLO */ |
|
|
|
|
|
|
|
|
|
/* undocumented functions */ |
|
|
|
|
#ifndef Z_FREETYPE |
|
|
|
|
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 inflateValidate OF((z_streamp, int)); |
|
|
|
|
ZEXTERN unsigned long ZEXPORT inflateCodesUsed OF((z_streamp)); |
|
|
|
|
ZEXTERN const char * ZEXPORT zError(int); |
|
|
|
|
ZEXTERN int ZEXPORT inflateSyncPoint(z_streamp); |
|
|
|
|
ZEXTERN const z_crc_t FAR * ZEXPORT get_crc_table(void); |
|
|
|
|
ZEXTERN int ZEXPORT inflateUndermine(z_streamp, int); |
|
|
|
|
ZEXTERN int ZEXPORT inflateValidate(z_streamp, int); |
|
|
|
|
ZEXTERN unsigned long ZEXPORT inflateCodesUsed(z_streamp); |
|
|
|
|
#endif /* !Z_FREETYPE */ |
|
|
|
|
ZEXTERN int ZEXPORT inflateResetKeep OF((z_streamp)); |
|
|
|
|
ZEXTERN int ZEXPORT inflateResetKeep(z_streamp); |
|
|
|
|
#ifndef Z_FREETYPE |
|
|
|
|
ZEXTERN int ZEXPORT deflateResetKeep OF((z_streamp)); |
|
|
|
|
ZEXTERN int ZEXPORT deflateResetKeep(z_streamp); |
|
|
|
|
#if defined(_WIN32) && !defined(Z_SOLO) |
|
|
|
|
ZEXTERN gzFile ZEXPORT gzopen_w OF((const wchar_t *path, |
|
|
|
|
const char *mode)); |
|
|
|
|
ZEXTERN gzFile ZEXPORT gzopen_w(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 int ZEXPORTVA gzvprintf(gzFile file, |
|
|
|
|
const char *format, |
|
|
|
|
va_list va); |
|
|
|
|
# endif |
|
|
|
|
#endif |
|
|
|
|
#endif /* !Z_FREETYPE */ |
|
|
|
|
|
Werner Lemberg
1 year ago