Copyright (C) 1995-2003 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 arising from the use of this software.
Permission is granted to anyone to use this software for any purpose, including commercial applications, and to alter it and redistribute it freely, subject to the following restrictions:
Visit http://www.gzip.org/zlib/ for the official zlib web page.
Compression can be done in a single step if the buffers are large enough (for example if an input file is mmap'ed), or can be done by repeated calls of the compression function. In the latter case, the application must provide more input and/or consume the output (providing more output space) before each call.
The compressed data format used by the
in-memory functions is the zlib format, which is a zlib wrapper
documented in RFC 1950, wrapped around a deflate stream, which is
itself documented in RFC 1951.
The library also 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.
The zlib format was designed to be compact and
fast for use in memory and on communications channels. The gzip
format was designed for single-file compression on file systems, has a
larger header than zlib to maintain directory information, and uses a
different, slower check method than zlib.
This library does not provide any functions to
write gzip files in memory. However such functions could be easily
written using zlib's deflate function, the documentation in the gzip
RFC, and the examples in gzio.c.
The library does not install any signal handler. The decoder checks the consistency of the compressed data, so the library should never crash even in case of corrupted input.
compress 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.
compress2 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, Z_STREAM_ERROR if the level parameter is invalid.
This function can be used to decompress a whole file at once if the input file is mmap'ed.
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.
gzopen can be used to read a file which is not in gzip format ; in this case gzread will directly read from the file without decompression.
gzopen returns NULL if the file could not be opened or if there was insufficient memory to allocate the (de)compression Zstate ; errno can be checked to distinguish the two cases (if errno is zero, the zlib error is Z_MEM_ERROR).
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 gzdopen(dup(fd), mode).
gzdopen returns NULL if there was insufficient memory to allocate the (de)compression Zstate.
gzsetparams returns Z_OK if success, or Z_STREAM_ERROR if the file was not opened for writing.
gzread returns the number of uncompressed bytes actually read (in {bytes, buffer}; (0 for end of file, -1 for error)).
gzputs returns the number of characters written, or -1 in case of error.
gzgets returns buf, or "" in case of error.
gzflush should be called only when strictly necessary because it can degrade compression.
If the file is opened for reading, this function is emulated but can be extremely slow. If the file is opened for writing, only forward seeks are supported ; gzseek then compresses a sequence of zeroes up to the new starting position.
gzseek returns the resulting offset location as measured in bytes from the beginning of the uncompressed stream, or -1 in case of error, in particular if the file is opened for writing and the new starting position would be before the current position.
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 (the input data is simply copied a block at a time).
Z_DEFAULT_COMPRESSION requests a default compromise between speed and compression (currently equivalent to level 6).
deflateInit returns Z_OK if success, Z_MEM_ERROR if there was not enough memory, Z_STREAM_ERROR if level is not a valid compression level, Z_VERSION_ERROR if the zlib library version (zlib_version) is incompatible with the version assumed by the caller (ZLIB_VERSION). Zmsg is set to null if there is no error message. deflateInit does not perform any compression: this will be done by deflate().
The detailed semantics are as follows. deflate performs one or both of the following actions:
Before the call of deflate(), the application should ensure that at least one of the actions is possible, by providing more input and/or consuming more output, and updating Zavail_in or Zavail_out accordingly ; Zavail_out should never be zero before the call. The application can consume the compressed output when it wants, for example when the output buffer is full (Zavail_out == 0), or after each call of deflate(). If deflate returns Z_OK and with zero Zavail_out, it must be called again after making room in the output buffer because there might be more output pending.
If the parameter flush is set to Z_SYNC_FLUSH, all pending output is flushed to the output buffer and the output is aligned on a byte boundary, so that the decompressor can get all input data available so far. (In particular Zavail_in is zero after the call if enough output space has been provided before the call.) Flushing may degrade compression for some compression algorithms and so it should be used only when necessary.
If flush is set to Z_FULL_FLUSH, all output is flushed as with Z_SYNC_FLUSH, and the compression Zstate is reset so that decompression can restart from this point if previous compressed data has been damaged or if random access is desired. Using Z_FULL_FLUSH too often can seriously degrade the compression.
If deflate returns with Zavail_out == 0, this function must be called
again with the same value of the flush parameter and more output space
(updated Zavail_out), until the flush is
complete (deflate returns with non-zero Zavail_out). In the case of a Z_FULL_FLUSH or Z_SYNC_FLUSH,
make sure that Zavail_out is greater than six
to avoid repeated flush markers due to Zavail_out
== 0 on return.
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 enough output space ; if deflate returns with Z_OK, this function must be called again with Z_FINISH and more output space (updated Zavail_out) but no more input data, until it returns with Z_STREAM_END or an error. After 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, Zavail_out must be at least the value returned by deflateBound. If deflate does not return Z_STREAM_END, then it must be called again as described above.
deflate() sets strm-> Zadler to the adler32 checksum of all input read so far (that is, Ztotal_in bytes).
deflate() may update Zdata_type if it can make a good guess about the input data type (Z_ASCII or Z_BINARY). In doubt, the data is considered binary. This field is only for information purposes and does not affect the compression algorithm in any manner.
deflate() returns Z_OK
if some progress has been made (more input processed or more output
produced), Z_STREAM_END if all input has
been consumed and all output has been produced (only when flush is set
to Z_FINISH), Z_STREAM_ERROR
if the stream Zstate was inconsistent (for
example
if Znext_in or Znext_out
was NULL), Z_BUF_ERROR if no progress is
possible (for example Zavail_in or Zavail_out was zero). Note that Z_BUF_ERROR is not fatal, and deflate() can be called again with more input and
more output space to continue compressing.
deflateEnd returns Z_OK if success, Z_STREAM_ERROR if the stream Zstate was inconsistent, Z_DATA_ERROR if the stream was freed prematurely (some input or output was discarded). In the error case, Zmsg may be set but then points to a static string (which must not be deallocated).
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 version assumed by the caller. msg is set to null if there is no error message. inflateInit does not perform any decompression apart from reading the zlib header if present: this will be done by inflate(). (So next_in and avail_in may be modified, but next_out and avail_out are unchanged.)
The detailed semantics are as follows. inflate performs one or both of the following actions:
Before the call of inflate(), the application should ensure that at least one of the actions is possible, by providing more input and/or consuming more output, and updating the Znext_* and Zavail_* values accordingly. The application can consume the uncompressed output when it wants, for example when the output buffer is full (Zavail_out == 0), or after each call of inflate(). If inflate returns Z_OK and with zero Zavail_out, it must be called again after making room in the output buffer because there might be more output pending.
The flush parameter of inflate() can be Z_NO_FLUSH, Z_SYNC_FLUSH,
Z_FINISH, or Z_BLOCK.
Z_SYNC_FLUSH requests that inflate() flush as much output as possible to the
output buffer. Z_BLOCK requests that inflate() stop if and when it get to the next
deflate block boundary. When decoding the zlib or gzip format, this
will cause inflate() to return immediately
after the header and before the first block. When doing a raw inflate, inflate() will go ahead and process the first
block, and will return when it gets to the end of that block, or when
it runs out of data.
The Z_BLOCK option assists in appending to or
combining deflate streams. Also to assist in this, on return inflate() will set strm->Zdata_type
to the number of unused bits in the last byte taken from strm->Znext_in, plus 64 if inflate()
is currently decoding the last block in the deflate stream, plus 128 if
inflate() returned immediately after
decoding an end-of-block code or decoding the complete header up to
just before the first byte of the deflate stream. The end-of-block will
not be indicated until all of the uncompressed data from that block has
been written to strm->Znext_out. The
number of unused bits may in general be greater than seven, except when
bit 7 of Zdata_type is set, in which case the
number of unused bits will be less than eight.
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; Zavail_out must be large enough to hold all the uncompressed data. (The size of the uncompressed data may have been saved by the compressor for this purpose.) The next operation on this stream must be inflateEnd to deallocate the decompression Zstate. The use of Z_FINISH is never required, but can be used to inform inflate that a faster approach may be used for the single inflate() call.
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 only effect of the
flush parameter in this implementation is on the return value of inflate(), as noted below, or when it returns
early because Z_BLOCK is used.
If a preset dictionary is needed after this call (see inflateSetDictionary below), inflate sets strm->Zadler
to the adler32 checksum of the dictionary
chosen by the compressor and returns Z_NEED_DICT;
otherwise it sets strm->Zadler to the adler32 checksum of all output produced so far
(that is, Ztotal_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() will decompress and check either
zlib-wrapped or gzip-wrapped deflate data. The header type is
detected automatically. Any information contained in the gzip
header is not retained, so applications that need that information
should instead use raw inflate, see inflateInit2()
below, or inflateBack() and perform their
own processing of the gzip header and trailer.
inflate() returns Z_OK if some progress has been made (more input processed or more output produced), Z_STREAM_END if the end of the compressed data has been reached and all uncompressed output has been produced, Z_NEED_DICT if a preset dictionary is needed at this point, Z_DATA_ERROR if the input data was corrupted (input stream not conforming to the zlib format or incorrect check value), Z_STREAM_ERROR if the stream structure was inconsistent (for example if Znext_in or Znext_out was NULL), Z_MEM_ERROR if there was not enough memory, Z_BUF_ERROR if no progress is possible or if there was not enough room in the output buffer when Z_FINISH is used. Note that Z_BUF_ERROR is not fatal, and inflate() can be called again with more input and more output space to continue decompressing. If Z_DATA_ERROR is returned, the application may then call inflateSync() to look for a good compression block if a partial recovery of the data is desired.
inflateEnd returns Z_OK if success, Z_STREAM_ERROR if the stream Zstate was inconsistent. In the error case, Zmsg may be set but then points to a static string (which must not be deallocated).
The method parameter is the compression method. It must be Z_DEFLATED in this version of the library.
The windowBits parameter is the base two logarithm of the window size (the size of the history buffer). It should be in the range 8..15 for this version of the library. Larger values of this parameter result in better compression at the expense of memory usage. The default value is 15 if deflateInit is used instead.
windowBits can also be -8..-15 for raw deflate. In this case, -windowBits determines the window size. deflate() will then generate raw deflate data with no zlib header or trailer, and will not compute an adler32 check value.
windowBits can also be greater than 15 for optional gzip encoding. Add 16 to windowBits to write a simple gzip header and trailer around the compressed data instead of a zlib wrapper. The gzip header will have no file name, no extra data, no comment, no modification time (set to zero), no header crc, and the operating system will be set to 255 (unknown).
The memLevel parameter specifies how much memory should be allocated for the internal compression Zstate. memLevel=1 uses minimum memory but is slow and reduces compression ratio ; memLevel=9 uses maximum memory for optimal speed. The default value is 8.
The strategy parameter is used to tune the compression
algorithm. Use the value Z_DEFAULT_STRATEGY
for normal data, Z_FILTERED for data
produced
by a filter (or predictor), Z_HUFFMAN_ONLY
to force Huffman encoding only (no string match), or Z_RLE
to limit match distances to one (run-length encoding). Filtered data
consists mostly of small values with a somewhat random distribution. In
this case, the compression algorithm is tuned to compress them better.
The effect of Z_FILTERED is to force more
Huffman coding and less string matching; it is somewhat intermediate
between Z_DEFAULT and Z_HUFFMAN_ONLY. Z_RLE
is designed to be almost as fast as Z_HUFFMAN_ONLY,
but give better compression for PNG image data. The strategy parameter
only affects the compression ratio but not the correctness of the
compressed output even if it is not set appropriately.
deflateInit2 returns Z_OK if success, Z_MEM_ERROR if there was not enough memory, Z_STREAM_ERROR if a parameter is invalid (such as an invalid method). Zmsg is set to null if there is no error message. deflateInit2 does not perform any compression: this will be done by deflate().
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 dictionary is most useful when the data to be compressed is short and can be predicted with good accuracy ; the data can then be compressed better than with the default empty dictionary.
Depending on the size of the compression data structures selected by deflateInit or deflateInit2, a part of the dictionary may in effect be discarded, for example if the dictionary is larger than the window size in deflate or deflate2. Thus the strings most likely to be useful should be put at the end of the dictionary, not at the front.
Upon return of this function, strm-> Zadler
is set to the adler32 value of the dictionary ;
the decompressor may
later use this value to determine which dictionary has been used by the
compressor. (The adler32 value applies to the
whole dictionary even if
only a subset of the dictionary is actually used by the compressor.) If
a raw deflate was requested, then the adler32
value is not computed and strm->Zadler is not
set.
deflateSetDictionary returns Z_OK if success, or Z_STREAM_ERROR if a parameter is invalid (such as NULL dictionary) or the stream Zstate is inconsistent (for example if deflate has already been called for this stream or if the compression method is bsort). deflateSetDictionary does not perform any compression: this will be done by deflate().
This function can be useful when several compression strategies will be tried, for example when there are several ways of pre-processing the input data with a filter. The streams that will be discarded should then be freed by calling deflateEnd. Note that deflateCopy duplicates the internal compression Zstate which can be quite large, so this strategy is slow and can consume lots of memory.
deflateCopy returns Z_OK if success, Z_MEM_ERROR if there was not enough memory, Z_STREAM_ERROR if the source stream Zstate was inconsistent (such as Zalloc being NULL). Zmsg is left unchanged in both source and destination.
deflateReset returns Z_OK if success, or Z_STREAM_ERROR if the source stream Zstate was inconsistent (such as Zalloc or Zstate being NULL).
Before the call of deflateParams, the stream Zstate must be set as for a call of deflate(), since the currently available input may have to be compressed and flushed. In particular, strm-> Zavail_out must be non-zero.
deflateParams returns Z_OK if success, Z_STREAM_ERROR if the source stream Zstate was inconsistent or if a parameter was invalid, Z_BUF_ERROR if strm-> Zavail_out was zero.
deflatePrime returns Z_OK if success, or Z_STREAM_ERROR if the source stream state was inconsistent.
The windowBits parameter is the base two logarithm of the maximum window size (the size of the history buffer). It should be in the range 8..15 for this version of the library. The default value is 15 if inflateInit is used instead. windowBits must be greater than or equal to the windowBits value provided to deflateInit2() while compressing, or it must be equal to 15 if deflateInit2() was not used. If a compressed stream with a larger window size is given as input, inflate() will return with the error code Z_DATA_ERROR instead of trying to allocate a larger window.
windowBits can also be -8..-15 for raw inflate. In this case, -windowBits determines the window size. inflate() will then process raw deflate data, not looking for a zlib or gzip header, not generating a check value, and not looking for any check values for comparison at the end of the stream. This is for use with other formats that use the deflate compressed data format such as zip. Those formats provide their own check values. If a custom format is developed using the raw deflate format for compressed data, it is recommended that a check value such as an adler32 or a crc32 be applied to the uncompressed data as is done in the zlib, gzip, and zip formats. For most applications, the zlib format should be used as is. Note that comments above on the use in deflateInit2() applies to the magnitude of windowBits.
windowBits can also be greater than 15 for optional gzip
decoding. Add 32 to windowBits to enable zlib and gzip decoding with
automatic header detection, or add 16 to decode only the gzip format
(the zlib format will return a Z_DATA_ERROR).
inflateInit2 returns Z_OK if success, Z_MEM_ERROR if there was not enough memory, Z_STREAM_ERROR if a parameter is invalid (such as a negative memLevel). Zmsg is set to null if there is no error message. inflateInit2 does not perform any decompression apart from reading the zlib header if present: this will be done by inflate(). (So Znext_in and Zavail_in may be modified, but Znext_out and Zavail_out are unchanged.)
inflateSetDictionary returns Z_OK if success, Z_STREAM_ERROR if a parameter is invalid (such as NULL dictionary) or the stream Zstate 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().
inflateSync returns Z_OK if a full flush point has been found, Z_BUF_ERROR if no more input was provided, Z_DATA_ERROR if no flush point has been found, or Z_STREAM_ERROR if the stream structure was inconsistent. In the success case, the application may save the current current value of Ztotal_in which indicates where valid compressed data was found. In the error case, the application may repeatedly call inflateSync, providing more input each time, until success or end of the input data.
This function can be useful when randomly accessing a large stream. The first pass through the stream can periodically record the inflate state, allowing restarting inflate at those points when randomly accessing the stream.
inflateCopy returns Z_OK if success, Z_MEM_ERROR if there was not enough memory, Z_STREAM_ERROR if the source stream state was inconsistent (such as Zalloc being NULL). Zmsg is left unchanged in both source and destination.
inflateReset returns Z_OK if success, or Z_STREAM_ERROR if the source stream Zstate was inconsistent (such as Zalloc or Zstate being NULL).
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 allocated, or Z_VERSION_ERROR if the version of the library does not match the version of the header file.
inflateBackInit() must be called first to allocate the internal state and to initialize the state with the user-provided window buffer. inflateBack() may then be used multiple times to inflate a complete, raw deflate stream with each call. inflateBackEnd() is then called to free the allocated state.
A raw deflate stream is one with no zlib or gzip header or trailer. This routine would normally be used in a utility that reads zip or gzip files and writes out uncompressed files. The utility would decode the header and process the trailer on its own, hence this routine expects only the raw deflate stream to decompress. This is different from the normal behavior of inflate(), which expects either a zlib or gzip header and trailer around the deflate stream.
inflateBack() uses two subroutines supplied by the caller that are then called by inflateBack() for input and output. inflateBack() calls those routines until it reads a complete deflate stream and writes out all of the uncompressed data, or until it encounters an error. The function's parameters and return types are defined below in the in_func and out_func typedefs. inflateBack() will call in(in_desc, &buf) which should return the number of bytes of provided input, and a pointer to that input in buf. If there is no input available, in() must return zero--buf is ignored in that case--and inflateBack() will return a buffer error. inflateBack() will call out(out_desc, buf, len) to write the uncompressed data buf[0..len-1]. out() should return zero on success, or non-zero on failure. If out() returns non-zero, inflateBack() will return with an error. Neither in() nor out() are permitted to change the contents of the window provided to inflateBackInit(), which is also the buffer that out() uses to write from. The length written by out() will be at most the window size. Any non-zero amount of input may be provided by in().
For convenience, inflateBack() can be provided input on the first call by setting strm->Znext_in and strm->Zavail_in. If that input is exhausted, then in() will be called. Therefore strm->Znext_in must be initialized before calling inflateBack(). If strm->Znext_in is Z_NULL, then in() will be called immediately for input. If strm->Znext_in is not Z_NULL, then strm->Zavail_in must also be initialized, and then if strm->Zavail_in is not zero, input will initially be taken from strm->Znext_in[0 .. strm->Zavail_in - 1].
The in_desc and out_desc parameters of inflateBack() is passed as the first parameter of in() and out() respectively when they are called. These descriptors can be optionally used to pass any information that the caller- supplied in() and out() functions need to do their job.
On return, inflateBack() will set strm->Znext_in and strm->Zavail_in to pass back any unused input that was provided by the last in() call. The return values of inflateBack() can be Z_STREAM_END on success, Z_BUF_ERROR if in() or out() returned an error, Z_DATA_ERROR if there was a format error in the deflate stream (in which case strm->Zmsg is set to indicate the nature of the error), or Z_STREAM_ERROR if the stream was not properly initialized. In the case of Z_BUF_ERROR, an input or output error can be distinguished using strm->Znext_in which will be Z_NULL only if in() returned an error. If strm->Znext_in is not Z_NULL, then the Z_BUF_ERROR was due to out() returning non-zero. (in() will always be called before out(), so strm->Znext_in is assured to be defined if out() returns non-zero.) Note that inflateBack() cannot return Z_OK.
An Adler-32 checksum is almost as reliable as a CRC32 but can be computed much faster. Usage example:
adler = adler32(0, Z_NULL)
buffer = ""
while not(equal(buffer, -1)) do
buffer = read_buffer(len)
adler = adler32(adler, buffer)
end while
if adler != original_adler then
error()
end if
crc = crc32(0, {})
buffer = {}
while not(equal(buffer, -1)) do
buffer = read_buffer(len)
crc = crc32(crc, buffer)
end while
if crc != original_crc then
error()
end if
global constant --struct z_stream_s {
Znext_in = 0, -- Bytef*-- pointer to next input byte
Zavail_in = 4, -- uInt -- number of bytes available at Znext_in
Ztotal_in = 8, -- uLong -- total number of input bytes read so far
Znext_out = 12, -- Bytef*-- next output byte should be put here (at the place pointed to)
Zavail_out = 16,-- uInt -- remaining free space at Znext_out
Ztotal_out = 20,-- uLong -- total number of bytes output so far
Zmsg = 24, --char* -- last error message, NULL if no error
Zstate = 28, --struct internal_state*-- not visible by applications
Zalloc = 32, -- alloc_func -- used to allocate the internal Zstate
Zfree = 36, -- free_func -- used to free the internal Zstate
Zopaque = 40, -- voidpf -- private data object passed to Zalloc and Zfree
Zdata_type = 44,-- int -- best guess about the data type: ascii or binary
Zadler = 48, -- uLong -- adler32 value of the uncompressed data
Zreserved = 52 -- uLong -- reserved for future use
--} z_stream
global function z_streamp(object setup)
Allocates space for a z_stream. setup
contains
optional data to fill the structure with. It must contain all 14 values.The Zopaque value provided by the application will be passed as the first parameter for calls of Zalloc and Zfree. This can be useful for custom memory management. The compression library attaches no meaning to the Zopaque value.
Zalloc must return Z_NULL if there is not enough memory for the object. If zlib is used in a multi-threaded application, Zalloc and Zfree must be thread safe.
The fields Ztotal_in and Ztotal_out can be used for statistics or progress reports. After compression, Ztotal_in holds the total size of the uncompressed data and may be saved for use in the decompressor (particularly if the decompressor wants to decompress everything in a single step).
-- Allowed flush values ; see deflate() below for details
global constant Z_NO_FLUSH = 0,
Z_PARTIAL_FLUSH = 1,
-- will be removed, use Z_SYNC_FLUSH instead
Z_SYNC_FLUSH = 2,
Z_FULL_FLUSH = 3,
Z_FINISH = 4,
Z_BLOCK = 5
-- * Return codes for the compression/decompression functions. Negative
-- * values are errors, positive values are used for special but normal events.
-- *
global constant Z_OK = 0,
Z_STREAM_END = 1,
Z_NEED_DICT = 2,
Z_ERRNO = -1,
Z_STREAM_ERROR = -2,
Z_DATA_ERROR = -3,
Z_MEM_ERROR = -4,
Z_BUF_ERROR = -5,
Z_VERSION_ERROR = -6
-- Compression Levels
global constant Z_NO_COMPRESSION = 0,
Z_BEST_SPEED = 1,
Z_BEST_COMPRESSION = 9,
Z_DEFAULT_COMPRESSION = -1
-- compression strategy ; see deflateInit2() above for details
global constant Z_FILTERED = 1,
Z_HUFFMAN_ONLY = 2,
Z_RLE = 3,
Z_DEFAULT_STRATEGY = 0
-- Possible values of the Zdata_type field (though see inflate())
global constant Z_BINARY = 0,
Z_ASCII = 1,
Z_UNKNOWN = 2
-- The deflate compression method (the only one supported in this version)
global constant Z_DEFLATED = 8
global constant Z_NULL = 0 -- for initializing Zalloc, Zfree, Zopaque
Other functions: