Lines Matching full:of
2 /* zlib.h -- interface of the 'zlib' general purpose compression library
9 arising from the use of this software.
15 1. The origin of this software must not be misrepresented; you must not
50 decompression functions, including integrity checks of the uncompressed data.
51 This version of the library supports only one compression method (deflation)
56 or can be done by repeated calls of the compression function. In the latter
65 with an interface similar to that of stdio using the functions that start
78 the consistency of the compressed data, so the library should never crash
79 even in the case of corrupted input.
82 typedef voidpf (*alloc_func) OF((voidpf opaque, uInt items, uInt size));
83 typedef void (*free_func) OF((voidpf opaque, voidpf address));
89 uInt avail_in; /* number of bytes available at next_in */
90 uLong total_in; /* total number of input bytes read so far */
94 uLong total_out; /* total number of bytes output so far */
105 uLong adler; /* Adler-32 or CRC-32 value of the uncompressed data */
113 for more details on the meanings of these fields.
142 parameter for calls of zalloc and zfree. This can be useful for custom
155 returned by zalloc for objects of exactly 65536 bytes *must* have their
158 any allocation of 64K objects, at the expense of compression ratio, compile
162 reports. After compression, total_in holds the total size of the
208 /* Possible values of the data_type field for deflate() */
221 ZEXTERN const char * ZEXPORT zlibVersion OF((void));
229 ZEXTERN int ZEXPORT deflateInit OF((z_streamp strm, int level));
251 ZEXTERN int ZEXPORT deflate OF((z_streamp strm, int flush));
258 The detailed semantics are as follows. deflate performs one or both of the
264 processing will resume at this point for the next call of deflate().
272 Before the call of deflate(), the application should ensure that at least
273 one of the actions is possible, by providing more input and/or consuming more
277 == 0), or after each call of deflate(). If deflate returns Z_OK and with
298 output buffer, but the output is not aligned to a byte boundary. All of the
307 seven bits of the current block are held to be written as the next byte after
309 be provided enough bits at this point in order to complete decompression of
312 the emission of deflate blocks.
321 with the same value of the flush parameter and more output space (updated
323 avail_out). In the case of a Z_FULL_FLUSH or Z_SYNC_FLUSH, make sure that
342 deflate() sets strm->adler to the Adler-32 checksum of all input read
344 strm->adler will be the CRC-32 checksum of the input read so far. (See
364 ZEXTERN int ZEXPORT deflateEnd OF((z_streamp strm));
379 ZEXTERN int ZEXPORT inflateInit OF((z_streamp strm));
383 the caller. In the current version of inflate, the provided input is not
384 read or consumed. The allocation of a sliding window will be deferred to
385 the first call of inflate (if the decompression does not complete on the
396 implementation of inflateInit() does not process any header information --
401 ZEXTERN int ZEXPORT inflate OF((z_streamp strm, int flush));
408 The detailed semantics are as follows. inflate performs one or both of the
414 accordingly, and processing will resume at this point for the next call of
422 Before the call of inflate(), the application should ensure that at least
423 one of the actions is possible, by providing more input and/or consuming more
425 caller of inflate() does not provide both available input and available
428 when the output buffer is full (avail_out == 0), or after each call of
433 The flush parameter of inflate() can be Z_NO_FLUSH, Z_SYNC_FLUSH, Z_FINISH,
440 gets to the end of that block, or when it runs out of data.
444 number of unused bits in the last byte taken from strm->next_in, plus 64 if
446 128 if inflate() returned immediately after decoding an end-of-block code or
447 decoding the complete header up to just before the first byte of the deflate
448 stream. The end-of-block will not be indicated until all of the uncompressed
449 data from that block has been written to strm->next_out. The number of
450 unused bits may in general be greater than seven, except when bit 7 of
451 data_type is set, in which case the number of unused bits will be less than
453 flush options, and so can be used to determine the amount of currently
457 end of each deflate block header is reached, before any actual data in that
458 block is decoded. This allows the caller to determine the length of the
460 256 is added to the value of strm->data_type when inflate() returns
461 immediately after reaching the end of the deflate block header.
465 single call of inflate), the parameter flush should be set to Z_FINISH. In
467 avail_out must be large enough to hold all of the uncompressed data for the
468 operation to complete. (The size of the uncompressed data may have been
469 saved by the compressor for this purpose.) The use of Z_FINISH is not
474 does not complete, either because not all of the stream is provided or not
481 first call. So the effects of the flush parameter in this implementation are
482 on the return value of inflate() as noted below, when inflate() returns early
483 when Z_BLOCK or Z_TREES is used, and when inflate() avoids the allocation of
487 below), inflate sets strm->adler to the Adler-32 checksum of the dictionary
489 strm->adler to the Adler-32 checksum of all output produced so far (that is,
491 below. At the end of the stream, inflate() checks that its computed Adler-32
499 gzip-wrapped deflate data, strm->adler32 is set to the CRC-32 of the output
504 or more output produced), Z_STREAM_END if the end of the compressed data has
517 recovery of the data is to be attempted.
521 ZEXTERN int ZEXPORT inflateEnd OF((z_streamp strm));
539 ZEXTERN int ZEXPORT deflateInit2 OF((z_streamp strm,
546 This is another version of deflateInit with more compression options. The
550 this version of the library.
552 The windowBits parameter is the base two logarithm of the window size
553 (the size of the history buffer). It should be in the range 8..15 for this
554 version of the library. Larger values of this parameter result in better
555 compression at the expense of memory usage. The default value is 15 if
558 For the current implementation of deflate(), a windowBits value of 8 (a
559 window size of 256 bytes) is not supported. As a result, a request for 8
562 checked against the initialization of inflate(). The remedy is to not use 8
572 compressed data instead of a zlib wrapper. The gzip header will have no
576 being written, strm->adler is a CRC-32 instead of an Adler-32.
579 rejected as invalid, since only the zlib header provides a means of
586 as a function of windowBits and memLevel.
592 encoding). Filtered data consists mostly of small values with a somewhat
594 compress them better. The effect of Z_FILTERED is to force more Huffman
599 correctness of the compressed output even if it is not set appropriately.
600 Z_FIXED prevents the use of dynamic Huffman codes, allowing for a simpler
611 ZEXTERN int ZEXPORT deflateSetDictionary OF((z_streamp strm,
618 deflateReset, and before any call of deflate. When doing raw deflate, this
619 function must be called either before any call of deflate, or immediately
620 after the completion of a deflate block, i.e. after all input has been
621 consumed and all output has been delivered when using any of the flush
626 The dictionary should consist of strings (byte sequences) that are likely
628 used strings preferably put towards the end of the dictionary. Using a
633 Depending on the size of the compression data structures selected by
634 deflateInit or deflateInit2, a part of the dictionary may in effect be
637 useful should be put at the end of the dictionary, not at the front. In
638 addition, the current implementation of deflate will use at most the window
639 size minus 262 bytes of the provided dictionary.
641 Upon return of this function, strm->adler is set to the Adler-32 value
642 of the dictionary; the decompressor may later use this value to determine
644 applies to the whole dictionary even if only a subset of the dictionary is
655 ZEXTERN int ZEXPORT deflateGetDictionary OF((z_streamp strm,
660 set to the number of bytes in the dictionary, and that many bytes are copied
668 to 258 bytes less in that case, due to how zlib's implementation of deflate
670 up to 258 bytes long. If the application needs the last window-size bytes of
671 input, then that would need to be saved by the application outside of zlib.
677 ZEXTERN int ZEXPORT deflateCopy OF((z_streamp dest,
680 Sets the destination stream as a complete copy of the source stream.
683 tried, for example when there are several ways of pre-processing the input
687 consume lots of memory.
695 ZEXTERN int ZEXPORT deflateReset OF((z_streamp strm));
706 ZEXTERN int ZEXPORT deflateParams OF((z_streamp strm,
711 interpretation of level and strategy is as in deflateInit2(). This can be
712 used to switch between compression and straight copy of the input data, or
713 to switch to a different kind of input data requiring a different strategy.
714 If the compression approach (which is a function of the level) or the
720 of deflate().
737 there was not enough output space to complete the compression of the
739 in the case of a Z_BUF_ERROR, the parameters are not changed. A return
740 value of Z_BUF_ERROR is not fatal, in which case deflateParams() can be
744 ZEXTERN int ZEXPORT deflateTune OF((z_streamp strm,
754 specific input data. Read the deflate.c source code for the meaning of the
761 ZEXTERN uLong ZEXPORT deflateBound OF((z_streamp strm,
765 deflation of sourceLen bytes. It must be called after deflateInit() or
776 ZEXTERN int ZEXPORT deflatePending OF((z_streamp strm,
780 deflatePending() returns the number of bytes and bits of output that have
783 The number of bits of output not provided are between 0 and 7, where they
791 ZEXTERN int ZEXPORT deflatePrime OF((z_streamp strm,
800 than or equal to 16, and that many of the least significant bits of value
808 ZEXTERN int ZEXPORT deflateSetHeader OF((z_streamp strm,
813 after deflateInit2() or deflateReset() and before the first call of
820 the current versions of the command-line version of gzip (up through version
833 ZEXTERN int ZEXPORT inflateInit2 OF((z_streamp strm,
836 This is another version of inflateInit with an extra parameter. The
840 The windowBits parameter is the base two logarithm of the maximum window
841 size (the size of the history buffer). It should be in the range 8..15 for
842 this version of the library. The default value is 15 if inflateInit is used
847 Z_DATA_ERROR instead of trying to allocate a larger window.
850 the zlib header of the compressed stream.
855 looking for any check values for comparison at the end of the stream. This
862 above on the use in deflateInit2() applies to the magnitude of windowBits.
868 CRC-32 instead of an Adler-32. Unlike the gunzip utility and gzread() (see
870 inflate() will return Z_STREAM_END at the end of the gzip member. The state
883 of inflateInit2() does not process any header information -- that is
887 ZEXTERN int ZEXPORT inflateSetDictionary OF((z_streamp strm,
892 sequence. This function must be called immediately after a call of inflate,
894 can be determined from the Adler-32 value returned by that call of inflate.
906 perform any decompression: this will be done by subsequent calls of
910 ZEXTERN int ZEXPORT inflateGetDictionary OF((z_streamp strm,
915 set to the number of bytes in the dictionary, and that many bytes are copied
925 ZEXTERN int ZEXPORT inflateSync OF((z_streamp strm));
928 for the description of deflate with Z_FULL_FLUSH) can be found, or until all
932 All full flush points have this pattern, but not all occurrences of this
938 In the success case, the application may save the current current value of
941 input each time, until success or end of the input data.
944 ZEXTERN int ZEXPORT inflateCopy OF((z_streamp dest,
947 Sets the destination stream as a complete copy of the source stream.
960 ZEXTERN int ZEXPORT inflateReset OF((z_streamp strm));
970 ZEXTERN int ZEXPORT inflateReset2 OF((z_streamp strm,
984 ZEXTERN int ZEXPORT inflatePrime OF((z_streamp strm,
990 middle of a byte. The provided bits will be used before any bytes are used
993 inflateReset(). bits must be less than or equal to 16, and that many of the
994 least significant bits of value will be inserted in the input.
1005 ZEXTERN long ZEXPORT inflateMark OF((z_streamp strm));
1007 This function returns two values, one in the lower 16 bits of the return
1010 zero, then inflate() is currently decoding information outside of a block.
1012 the middle of a stored block, with the lower value equaling the number of
1014 it is the number of bits back from the current bit position in the input of
1016 that case the lower value is the number of bytes already emitted for that
1020 decoding of the code, or if it has completed decoding but is waiting for
1025 output of a code may span boundaries of random access blocks. The current
1033 ZEXTERN int ZEXPORT inflateGetHeader OF((z_streamp strm,
1038 inflateInit2() or inflateReset(), and before the first call of inflate().
1049 contains the maximum number of bytes to write to extra. Once done is true,
1056 of extra, name, or comment are not Z_NULL and the respective field is not
1058 absence. This allows the use of deflateSetHeader() with the returned
1074 ZEXTERN int ZEXPORT inflateBackInit OF((z_streamp strm, int windowBits,
1081 logarithm of the window size, in the range 8..15. window is a caller
1082 supplied buffer of that size. Except for special applications where it is
1087 See inflateBack() for the usage of these routines.
1089 inflateBackInit will return Z_OK on success, Z_STREAM_ERROR if any of
1091 allocated, or Z_VERSION_ERROR if the version of the library does not match
1092 the version of the header file.
1095 typedef unsigned (*in_func) OF((void FAR *,
1097 typedef int (*out_func) OF((void FAR *, unsigned char FAR *, unsigned));
1099 ZEXTERN int ZEXPORT inflateBack OF((z_streamp strm,
1122 behavior of inflate(), which expects a zlib header and trailer around the
1127 routines until it reads a complete deflate stream and writes out all of the
1131 number of bytes of provided input, and a pointer to that input in buf. If
1137 out() are permitted to change the contents of the window provided to
1140 amount of input may be provided by in().
1150 The in_desc and out_desc parameters of inflateBack() is passed as the
1151 first parameter of in() and out() respectively when they are called. These
1157 return values of inflateBack() can be Z_STREAM_END on success, Z_BUF_ERROR
1160 of the error), or Z_STREAM_ERROR if the stream was not properly initialized.
1161 In the case of Z_BUF_ERROR, an input or output error can be distinguished
1169 ZEXTERN int ZEXPORT inflateBackEnd OF((z_streamp strm));
1177 ZEXTERN uLong ZEXPORT zlibCompileFlags OF((void));
1181 1.0: size of uInt
1182 3.2: size of uLong
1183 5.4: size of voidpf (pointer)
1184 7.6: size of z_off_t
1223 The following utility functions are implemented on top of the basic
1226 functions). The source code of these utility functions can be modified if
1230 ZEXTERN int ZEXPORT compress OF((Bytef *dest, uLongf *destLen,
1234 the byte length of the source buffer. Upon entry, destLen is the total size
1235 of the destination buffer, which must be at least the value returned by
1236 compressBound(sourceLen). Upon exit, destLen is the actual size of the
1238 parameter of Z_DEFAULT_COMPRESSION.
1245 ZEXTERN int ZEXPORT compress2 OF((Bytef *dest, uLongf *destLen,
1251 length of the source buffer. Upon entry, destLen is the total size of the
1253 compressBound(sourceLen). Upon exit, destLen is the actual size of the
1261 ZEXTERN uLong ZEXPORT compressBound OF((uLong sourceLen));
1268 ZEXTERN int ZEXPORT uncompress OF((Bytef *dest, uLongf *destLen,
1272 the byte length of the source buffer. Upon entry, destLen is the total size
1273 of the destination buffer, which must be large enough to hold the entire
1274 uncompressed data. (The size of the uncompressed data must have been saved
1276 mechanism outside the scope of this compression library.) Upon exit, destLen
1277 is the actual size of the uncompressed data.
1286 ZEXTERN int ZEXPORT uncompress2 OF((Bytef *dest, uLongf *destLen,
1290 length of the source is *sourceLen. On return, *sourceLen is the number of
1298 an interface similar to that of stdio, using the functions that start with
1306 ZEXTERN gzFile ZEXPORT gzopen OF((const char *path, const char *mode));
1313 as in "wb9F". (See the description of deflateInit2 for more information
1317 "a" can be used instead of "w" to request that the gzip stream that will
1319 reading and writing to the same gzip file is not supported. The addition of
1321 already exists. On systems that support it, the addition of "e" when
1324 These functions, as well as gzip, will read and decode a sequence of gzip
1325 streams in a file. The append function of gzopen() can be used to create
1328 nor does it look for the end of the gzip streams to begin appending. gzopen
1343 ZEXTERN gzFile ZEXPORT gzdopen OF((int fd, const char *mode));
1349 The next call of gzclose on the returned gzFile will also close the file
1366 ZEXTERN int ZEXPORT gzbuffer OF((gzFile file, unsigned size));
1373 buffer size of, for example, 64K or 128K bytes will noticeably increase the
1374 speed of decompression (reading).
1382 ZEXTERN int ZEXPORT gzsetparams OF((gzFile file, int level, int strategy));
1385 description of deflateInit2 for the meaning of these parameters. Previously
1393 ZEXTERN int ZEXPORT gzread OF((gzFile file, voidp buf, unsigned len));
1396 the input file is not in gzip format, gzread copies the given number of
1399 After reaching the end of a gzip stream in the input, gzread will continue
1400 to read, looking for another gzip stream. Any number of gzip streams may be
1406 Upon reaching the end of the input, gzread will return with the available
1408 gzclearerr can be used to clear the end of file indicator in order to permit
1411 middle of a gzip stream. Note that gzread does not return -1 in the event
1412 of an incomplete gzip stream. This error is deferred until gzclose(), which
1413 will return Z_BUF_ERROR if the last gzread ended in the middle of a gzip
1417 gzread returns the number of uncompressed bytes actually read, less than
1418 len for end of file, or -1 for error. If len is too large to fit in an int,
1423 ZEXTERN z_size_t ZEXPORT gzfread OF((voidp buf, z_size_t size, z_size_t nitems,
1426 Read and decompress up to nitems items of size size from file into buf,
1427 otherwise operating as gzread() does. This duplicates the interface of
1432 gzfread() returns the number of full items read of size size, or zero if
1433 the end of the file was reached and a full item could not be read, or if
1435 order to determine if there was an error. If the multiplication of size and
1439 In the event that the end of file is reached and only a partial item is
1441 multiple of size, then the final partial item is nevetheless read into buf
1442 and the end-of-file flag is set. The length of the partial item read is not
1443 provided, but could be inferred from the result of gztell(). This behavior
1444 is the same as the behavior of fread() implementations in common libraries,
1445 but it prevents the direct use of gzfread() to read a concurrently written
1446 file, reseting and retrying on end-of-file, when size is not 1.
1449 ZEXTERN int ZEXPORT gzwrite OF((gzFile file, voidpc buf, unsigned len));
1452 returns the number of uncompressed bytes written or 0 in case of error.
1455 ZEXTERN z_size_t ZEXPORT gzfwrite OF((voidpc buf, z_size_t size,
1458 Compress and write nitems items of size size from buf to file, duplicating
1459 the interface of stdio's fwrite(), with size_t request and return types. If
1463 gzfwrite() returns the number of full items written of size size, or zero
1464 if there was an error. If the multiplication of size and nitems overflows,
1472 control of the string format, as in fprintf. gzprintf returns the number of
1474 of error. The number of uncompressed bytes written is limited to 8191, or
1484 ZEXTERN int ZEXPORT gzputs OF((gzFile file, const char *s));
1489 gzputs returns the number of characters written, or -1 in case of error.
1492 ZEXTERN char * ZEXPORT gzgets OF((gzFile file, char *buf, int len));
1496 end-of-file condition is encountered. If any characters are read or if len
1498 are read due to an end-of-file or len is less than one, then the buffer is
1502 for end-of-file or in case of error. If there was an error, the contents at
1506 ZEXTERN int ZEXPORT gzputc OF((gzFile file, int c));
1509 returns the value that was written, or -1 in case of error.
1512 ZEXTERN int ZEXPORT gzgetc OF((gzFile file));
1515 in case of end of file or error. This is implemented as a macro for speed.
1516 As such, it does not do all of the checking the other functions do. I.e.
1521 ZEXTERN int ZEXPORT gzungetc OF((int c, gzFile file));
1524 the next read. At least one character of push-back is always allowed.
1528 output buffer size of pushed characters is allowed. (See gzbuffer above.)
1533 ZEXTERN int ZEXPORT gzflush OF((gzFile file, int flush));
1549 ZEXTERN z_off_t ZEXPORT gzseek OF((gzFile file,
1553 or gzwrite on file. The offset represents a number of bytes in the
1559 supported; gzseek then compresses a sequence of zeroes up to the new
1563 the beginning of the uncompressed stream, or -1 in case of error, in
1568 ZEXTERN int ZEXPORT gzrewind OF((gzFile file));
1576 ZEXTERN z_off_t ZEXPORT gztell OF((gzFile file));
1579 This position represents a number of bytes in the uncompressed data stream,
1581 the middle of a file using gzdopen().
1587 ZEXTERN z_off_t ZEXPORT gzoffset OF((gzFile file));
1589 Return the current compressed (actual) read or write offset of file. This
1590 offset includes the count of bytes that precede the gzip stream, for example
1596 ZEXTERN int ZEXPORT gzeof OF((gzFile file));
1598 Return true (1) if the end-of-file indicator for file has been set while
1599 reading, false (0) otherwise. Note that the end-of-file indicator is set
1600 only if the read tried to go past the end of the input, but came up short.
1603 number of bytes remaining in the input file. This will happen if the input
1604 file size is an exact multiple of the buffer size.
1607 unless the end-of-file indicator is reset by gzclearerr() and the input file
1608 has grown since the previous end of file was detected.
1611 ZEXTERN int ZEXPORT gzdirect OF((gzFile file));
1628 linking statically, using gzdirect() will include all of the zlib code for
1632 ZEXTERN int ZEXPORT gzclose OF((gzFile file));
1641 file operation error, Z_MEM_ERROR if out of memory, Z_BUF_ERROR if the
1642 last read ended in the middle of a gzip stream, or Z_OK on success.
1645 ZEXTERN int ZEXPORT gzclose_r OF((gzFile file));
1646 ZEXTERN int ZEXPORT gzclose_w OF((gzFile file));
1650 using these instead of gzclose() is that they avoid linking in zlib
1657 ZEXTERN const char * ZEXPORT gzerror OF((gzFile file, int *errnum));
1669 gzerror() should be used to distinguish errors from end-of-file for those
1673 ZEXTERN void ZEXPORT gzclearerr OF((gzFile file));
1675 Clear the error and end-of-file flags for file. This is analogous to the
1690 ZEXTERN uLong ZEXPORT adler32 OF((uLong adler, const Bytef *buf, uInt len));
1693 return the updated checksum. An Adler-32 value is in the range of a 32-bit
1710 ZEXTERN uLong ZEXPORT adler32_z OF((uLong adler, const Bytef *buf,
1717 ZEXTERN uLong ZEXPORT adler32_combine OF((uLong adler1, uLong adler2,
1720 Combine two Adler-32 checksums into one. For two sequences of bytes, seq1
1722 each, adler1 and adler2. adler32_combine() returns the Adler-32 checksum of
1728 ZEXTERN uLong ZEXPORT crc32 OF((uLong crc, const Bytef *buf, uInt len));
1731 updated CRC-32. A CRC-32 value is in the range of a 32-bit unsigned integer.
1746 ZEXTERN uLong ZEXPORT crc32_z OF((uLong crc, const Bytef *buf,
1753 ZEXTERN uLong ZEXPORT crc32_combine OF((uLong crc1, uLong crc2, z_off_t len2));
1755 Combine two CRC-32 check values into one. For two sequences of bytes,
1758 check value of seq1 and seq2 concatenated, requiring only crc1, crc2, and
1763 ZEXTERN uLong ZEXPORT crc32_combine_gen OF((z_off_t len2));
1769 ZEXTERN uLong ZEXPORT crc32_combine_op OF((uLong crc1, uLong crc2, uLong op));
1771 Give the same result as crc32_combine(), using op in place of len2. op is
1780 * and the compiler's view of z_stream:
1782 ZEXTERN int ZEXPORT deflateInit_ OF((z_streamp strm, int level,
1784 ZEXTERN int ZEXPORT inflateInit_ OF((z_streamp strm,
1786 ZEXTERN int ZEXPORT deflateInit2_ OF((z_streamp strm, int level, int method,
1790 ZEXTERN int ZEXPORT inflateInit2_ OF((z_streamp strm, int windowBits,
1792 ZEXTERN int ZEXPORT inflateBackInit_ OF((z_streamp strm, int windowBits,
1840 ZEXTERN int ZEXPORT gzgetc_ OF((gzFile file)); /* backward compatibility */
1857 ZEXTERN gzFile ZEXPORT gzopen64 OF((const char *, const char *));
1858 ZEXTERN z_off64_t ZEXPORT gzseek64 OF((gzFile, z_off64_t, int));
1859 ZEXTERN z_off64_t ZEXPORT gztell64 OF((gzFile));
1860 ZEXTERN z_off64_t ZEXPORT gzoffset64 OF((gzFile));
1861 ZEXTERN uLong ZEXPORT adler32_combine64 OF((uLong, uLong, z_off64_t));
1862 ZEXTERN uLong ZEXPORT crc32_combine64 OF((uLong, uLong, z_off64_t));
1863 ZEXTERN uLong ZEXPORT crc32_combine_gen64 OF((z_off64_t));
1885 ZEXTERN gzFile ZEXPORT gzopen64 OF((const char *, const char *));
1886 ZEXTERN z_off_t ZEXPORT gzseek64 OF((gzFile, z_off_t, int));
1887 ZEXTERN z_off_t ZEXPORT gztell64 OF((gzFile));
1888 ZEXTERN z_off_t ZEXPORT gzoffset64 OF((gzFile));
1889 ZEXTERN uLong ZEXPORT adler32_combine64 OF((uLong, uLong, z_off_t));
1890 ZEXTERN uLong ZEXPORT crc32_combine64 OF((uLong, uLong, z_off_t));
1891 ZEXTERN uLong ZEXPORT crc32_combine_gen64 OF((z_off_t));
1894 ZEXTERN gzFile ZEXPORT gzopen OF((const char *, const char *));
1895 ZEXTERN z_off_t ZEXPORT gzseek OF((gzFile, z_off_t, int));
1896 ZEXTERN z_off_t ZEXPORT gztell OF((gzFile));
1897 ZEXTERN z_off_t ZEXPORT gzoffset OF((gzFile));
1898 ZEXTERN uLong ZEXPORT adler32_combine OF((uLong, uLong, z_off_t));
1899 ZEXTERN uLong ZEXPORT crc32_combine OF((uLong, uLong, z_off_t));
1900 ZEXTERN uLong ZEXPORT crc32_combine_gen OF((z_off_t));
1905 ZEXTERN uLong ZEXPORT adler32_combine OF((uLong, uLong, z_off_t));
1906 ZEXTERN uLong ZEXPORT crc32_combine OF((uLong, uLong, z_off_t));
1907 ZEXTERN uLong ZEXPORT crc32_combine_gen OF((z_off_t));
1912 ZEXTERN const char * ZEXPORT zError OF((int));
1913 ZEXTERN int ZEXPORT inflateSyncPoint OF((z_streamp));
1914 ZEXTERN const z_crc_t FAR * ZEXPORT get_crc_table OF((void));
1915 ZEXTERN int ZEXPORT inflateUndermine OF((z_streamp, int));
1916 ZEXTERN int ZEXPORT inflateValidate OF((z_streamp, int));
1917 ZEXTERN unsigned long ZEXPORT inflateCodesUsed OF ((z_streamp));
1918 ZEXTERN int ZEXPORT inflateResetKeep OF((z_streamp));
1919 ZEXTERN int ZEXPORT deflateResetKeep OF((z_streamp));
1921 ZEXTERN gzFile ZEXPORT gzopen_w OF((const wchar_t *path,