From 75c467e9feeba775e43ba4e6f588a1a74f69e54d Mon Sep 17 00:00:00 2001 From: =?utf8?q?Nguy=E1=BB=85n=20Th=C3=A1i=20Ng=E1=BB=8Dc=20Duy?= Date: Sun, 12 Aug 2007 14:55:47 -0400 Subject: [PATCH] Add zlib --- compat/zlib/libz.a | Bin 0 -> 80572 bytes compat/zlib/zconf.h | 332 +++++++++++++ compat/zlib/zlib.h | 1357 +++++++++++++++++++++++++++++++++++++++++++++++++++ 3 files changed, 1689 insertions(+) create mode 100644 compat/zlib/libz.a create mode 100644 compat/zlib/zconf.h create mode 100644 compat/zlib/zlib.h diff --git a/compat/zlib/libz.a b/compat/zlib/libz.a new file mode 100644 index 0000000000000000000000000000000000000000..bb8c91a4f470387154cf2dfffa134f68d0ffe1c1 GIT binary patch literal 80572 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 199901L +# ifndef STDC99 +# define STDC99 +# endif +# endif +#endif +#if !defined(STDC) && (defined(__STDC__) || defined(__cplusplus)) +# define STDC +#endif +#if !defined(STDC) && (defined(__GNUC__) || defined(__BORLANDC__)) +# define STDC +#endif +#if !defined(STDC) && (defined(MSDOS) || defined(WINDOWS) || defined(WIN32)) +# define STDC +#endif +#if !defined(STDC) && (defined(OS2) || defined(__HOS_AIX__)) +# define STDC +#endif + +#if defined(__OS400__) && !defined(STDC) /* iSeries (formerly AS/400). */ +# define STDC +#endif + +#ifndef STDC +# ifndef const /* cannot use !defined(STDC) && !defined(const) on Mac */ +# define const /* note: need a more gentle solution here */ +# endif +#endif + +/* Some Mac compilers merge all .h files incorrectly: */ +#if defined(__MWERKS__)||defined(applec)||defined(THINK_C)||defined(__SC__) +# define NO_DUMMY_DECL +#endif + +/* Maximum value for memLevel in deflateInit2 */ +#ifndef MAX_MEM_LEVEL +# ifdef MAXSEG_64K +# define MAX_MEM_LEVEL 8 +# else +# define MAX_MEM_LEVEL 9 +# endif +#endif + +/* Maximum value for windowBits in deflateInit2 and inflateInit2. + * WARNING: reducing MAX_WBITS makes minigzip unable to extract .gz files + * created by gzip. (Files created by minigzip can still be extracted by + * gzip.) + */ +#ifndef MAX_WBITS +# define MAX_WBITS 15 /* 32K LZ77 window */ +#endif + +/* The memory requirements for deflate are (in bytes): + (1 << (windowBits+2)) + (1 << (memLevel+9)) + that is: 128K for windowBits=15 + 128K for memLevel = 8 (default values) + plus a few kilobytes for small objects. For example, if you want to reduce + the default memory requirements from 256K to 128K, compile with + make CFLAGS="-O -DMAX_WBITS=14 -DMAX_MEM_LEVEL=7" + Of course this will generally degrade compression (there's no free lunch). + + The memory requirements for inflate are (in bytes) 1 << windowBits + that is, 32K for windowBits=15 (default value) plus a few kilobytes + for small objects. +*/ + + /* Type declarations */ + +#ifndef OF /* function prototypes */ +# ifdef STDC +# define OF(args) args +# else +# define OF(args) () +# endif +#endif + +/* The following definitions for FAR are needed only for MSDOS mixed + * model programming (small or medium model with some far allocations). + * This was tested only with MSC; for other MSDOS compilers you may have + * to define NO_MEMCPY in zutil.h. If you don't need the mixed model, + * just define FAR to be empty. + */ +#ifdef SYS16BIT +# if defined(M_I86SM) || defined(M_I86MM) + /* MSC small or medium model */ +# define SMALL_MEDIUM +# ifdef _MSC_VER +# define FAR _far +# else +# define FAR far +# endif +# endif +# if (defined(__SMALL__) || defined(__MEDIUM__)) + /* Turbo C small or medium model */ +# define SMALL_MEDIUM +# ifdef __BORLANDC__ +# define FAR _far +# else +# define FAR far +# endif +# endif +#endif + +#if defined(WINDOWS) || defined(WIN32) + /* If building or using zlib as a DLL, define ZLIB_DLL. + * This is not mandatory, but it offers a little performance increase. + */ +# ifdef ZLIB_DLL +# if defined(WIN32) && (!defined(__BORLANDC__) || (__BORLANDC__ >= 0x500)) +# ifdef ZLIB_INTERNAL +# define ZEXTERN extern __declspec(dllexport) +# else +# define ZEXTERN extern __declspec(dllimport) +# endif +# endif +# endif /* ZLIB_DLL */ + /* If building or using zlib with the WINAPI/WINAPIV calling convention, + * define ZLIB_WINAPI. + * Caution: the standard ZLIB1.DLL is NOT compiled using ZLIB_WINAPI. + */ +# ifdef ZLIB_WINAPI +# ifdef FAR +# undef FAR +# endif +# include + /* No need for _export, use ZLIB.DEF instead. */ + /* For complete Windows compatibility, use WINAPI, not __stdcall. */ +# define ZEXPORT WINAPI +# ifdef WIN32 +# define ZEXPORTVA WINAPIV +# else +# define ZEXPORTVA FAR CDECL +# endif +# endif +#endif + +#if defined (__BEOS__) +# ifdef ZLIB_DLL +# ifdef ZLIB_INTERNAL +# define ZEXPORT __declspec(dllexport) +# define ZEXPORTVA __declspec(dllexport) +# else +# define ZEXPORT __declspec(dllimport) +# define ZEXPORTVA __declspec(dllimport) +# endif +# endif +#endif + +#ifndef ZEXTERN +# define ZEXTERN extern +#endif +#ifndef ZEXPORT +# define ZEXPORT +#endif +#ifndef ZEXPORTVA +# define ZEXPORTVA +#endif + +#ifndef FAR +# define FAR +#endif + +#if !defined(__MACTYPES__) +typedef unsigned char Byte; /* 8 bits */ +#endif +typedef unsigned int uInt; /* 16 bits or more */ +typedef unsigned long uLong; /* 32 bits or more */ + +#ifdef SMALL_MEDIUM + /* Borland C/C++ and some old MSC versions ignore FAR inside typedef */ +# define Bytef Byte FAR +#else + typedef Byte FAR Bytef; +#endif +typedef char FAR charf; +typedef int FAR intf; +typedef uInt FAR uIntf; +typedef uLong FAR uLongf; + +#ifdef STDC + typedef void const *voidpc; + typedef void FAR *voidpf; + typedef void *voidp; +#else + typedef Byte const *voidpc; + typedef Byte FAR *voidpf; + typedef Byte *voidp; +#endif + +#if 0 /* HAVE_UNISTD_H -- this line is updated by ./configure */ +# include /* for off_t */ +# include /* for SEEK_* and off_t */ +# ifdef VMS +# include /* for off_t */ +# endif +# define z_off_t off_t +#endif +#ifndef SEEK_SET +# define SEEK_SET 0 /* Seek from beginning of file. */ +# define SEEK_CUR 1 /* Seek from current position. */ +# define SEEK_END 2 /* Set file pointer to EOF plus "offset" */ +#endif +#ifndef z_off_t +# define z_off_t long +#endif + +#if defined(__OS400__) +# define NO_vsnprintf +#endif + +#if defined(__MVS__) +# define NO_vsnprintf +# ifdef FAR +# undef FAR +# endif +#endif + +/* MVS linker does not support external names larger than 8 bytes */ +#if defined(__MVS__) +# pragma map(deflateInit_,"DEIN") +# pragma map(deflateInit2_,"DEIN2") +# pragma map(deflateEnd,"DEEND") +# pragma map(deflateBound,"DEBND") +# pragma map(inflateInit_,"ININ") +# pragma map(inflateInit2_,"ININ2") +# pragma map(inflateEnd,"INEND") +# pragma map(inflateSync,"INSY") +# pragma map(inflateSetDictionary,"INSEDI") +# pragma map(compressBound,"CMBND") +# pragma map(inflate_table,"INTABL") +# pragma map(inflate_fast,"INFA") +# pragma map(inflate_copyright,"INCOPY") +#endif + +#endif /* ZCONF_H */ diff --git a/compat/zlib/zlib.h b/compat/zlib/zlib.h new file mode 100644 index 0000000000..022817927c --- /dev/null +++ b/compat/zlib/zlib.h @@ -0,0 +1,1357 @@ +/* zlib.h -- interface of the 'zlib' general purpose compression library + version 1.2.3, July 18th, 2005 + + Copyright (C) 1995-2005 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: + + 1. The origin of this software must not be misrepresented; you must not + claim that you wrote the original software. If you use this software + in a product, an acknowledgment in the product documentation would be + appreciated but is not required. + 2. Altered source versions must be plainly marked as such, and must not be + misrepresented as being the original software. + 3. This notice may not be removed or altered from any source distribution. + + Jean-loup Gailly Mark Adler + jloup@gzip.org madler@alumni.caltech.edu + + + The data format used by the zlib library is described by RFCs (Request for + Comments) 1950 to 1952 in the files http://www.ietf.org/rfc/rfc1950.txt + (zlib format), rfc1951.txt (deflate format) and rfc1952.txt (gzip format). +*/ + +#ifndef ZLIB_H +#define ZLIB_H + +#include "zconf.h" + +#ifdef __cplusplus +extern "C" { +#endif + +#define ZLIB_VERSION "1.2.3" +#define ZLIB_VERNUM 0x1230 + +/* + The 'zlib' compression library provides in-memory compression and + decompression functions, including integrity checks of the uncompressed + data. This version of the library supports only one compression method + (deflation) but other algorithms will be added later and will have the same + stream interface. + + 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 default 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. + + This library can optionally read and write gzip streams in memory as well. + + 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. + + 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. +*/ + +typedef voidpf (*alloc_func) OF((voidpf opaque, uInt items, uInt size)); +typedef void (*free_func) OF((voidpf opaque, voidpf address)); + +struct internal_state; + +typedef struct z_stream_s { + Bytef *next_in; /* next input byte */ + uInt avail_in; /* number of bytes available at next_in */ + uLong total_in; /* total nb of input bytes read so far */ + + Bytef *next_out; /* next output byte should be put there */ + uInt avail_out; /* remaining free space at next_out */ + uLong total_out; /* total nb of bytes output so far */ + + char *msg; /* last error message, NULL if no error */ + struct internal_state FAR *state; /* not visible by applications */ + + alloc_func zalloc; /* used to allocate the internal state */ + free_func zfree; /* used to free the internal state */ + voidpf opaque; /* private data object passed to zalloc and zfree */ + + int data_type; /* best guess about the data type: binary or text */ + uLong adler; /* adler32 value of the uncompressed data */ + uLong reserved; /* reserved for future use */ +} z_stream; + +typedef z_stream FAR *z_streamp; + +/* + gzip header information passed to and from zlib routines. See RFC 1952 + for more details on the meanings of these fields. +*/ +typedef struct gz_header_s { + int text; /* true if compressed data believed to be text */ + uLong time; /* modification time */ + int xflags; /* extra flags (not used when writing a gzip file) */ + int os; /* operating system */ + Bytef *extra; /* pointer to extra field or Z_NULL if none */ + uInt extra_len; /* extra field length (valid if extra != Z_NULL) */ + uInt extra_max; /* space at extra (only when reading header) */ + Bytef *name; /* pointer to zero-terminated file name or Z_NULL */ + uInt name_max; /* space at name (only when reading header) */ + Bytef *comment; /* pointer to zero-terminated comment or Z_NULL */ + uInt comm_max; /* space at comment (only when reading header) */ + int hcrc; /* true if there was or will be a header crc */ + int done; /* true when done reading gzip header (not used + when writing a gzip file) */ +} gz_header; + +typedef gz_header FAR *gz_headerp; + +/* + The application must update next_in and avail_in when avail_in has + dropped to zero. It must update next_out and avail_out when avail_out + has dropped to zero. The application must initialize zalloc, zfree and + opaque before calling the init function. All other fields are set by the + compression library and must not be updated by the application. + + The opaque 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 + opaque 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. + + On 16-bit systems, the functions zalloc and zfree must be able to allocate + exactly 65536 bytes, but will not be required to allocate more than this + if the symbol MAXSEG_64K is defined (see zconf.h). WARNING: On MSDOS, + pointers returned by zalloc for objects of exactly 65536 bytes *must* + have their offset normalized to zero. The default allocation function + provided by this library ensures this (see zutil.c). To reduce memory + requirements and avoid any allocation of 64K objects, at the expense of + compression ratio, compile the library with -DMAX_WBITS=14 (see zconf.h). + + The fields total_in and total_out can be used for statistics or + progress reports. After compression, total_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). +*/ + + /* constants */ + +#define Z_NO_FLUSH 0 +#define Z_PARTIAL_FLUSH 1 /* will be removed, use Z_SYNC_FLUSH instead */ +#define Z_SYNC_FLUSH 2 +#define Z_FULL_FLUSH 3 +#define Z_FINISH 4 +#define Z_BLOCK 5 +/* Allowed flush values; see deflate() and inflate() below for details */ + +#define Z_OK 0 +#define Z_STREAM_END 1 +#define Z_NEED_DICT 2 +#define Z_ERRNO (-1) +#define Z_STREAM_ERROR (-2) +#define Z_DATA_ERROR (-3) +#define Z_MEM_ERROR (-4) +#define Z_BUF_ERROR (-5) +#define Z_VERSION_ERROR (-6) +/* Return codes for the compression/decompression functions. Negative + * values are errors, positive values are used for special but normal events. + */ + +#define Z_NO_COMPRESSION 0 +#define Z_BEST_SPEED 1 +#define Z_BEST_COMPRESSION 9 +#define Z_DEFAULT_COMPRESSION (-1) +/* compression levels */ + +#define Z_FILTERED 1 +#define Z_HUFFMAN_ONLY 2 +#define Z_RLE 3 +#define Z_FIXED 4 +#define Z_DEFAULT_STRATEGY 0 +/* compression strategy; see deflateInit2() below for details */ + +#define Z_BINARY 0 +#define Z_TEXT 1 +#define Z_ASCII Z_TEXT /* for compatibility with 1.2.2 and earlier */ +#define Z_UNKNOWN 2 +/* Possible values of the data_type field (though see inflate()) */ + +#define Z_DEFLATED 8 +/* The deflate compression method (the only one supported in this version) */ + +#define Z_NULL 0 /* for initializing zalloc, zfree, opaque */ + +#define zlib_version zlibVersion() +/* for compatibility with versions < 1.0.2 */ + + /* basic functions */ + +ZEXTERN const char * ZEXPORT zlibVersion OF((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 is automatically made by deflateInit and inflateInit. + */ + +/* +ZEXTERN int ZEXPORT deflateInit OF((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. + + 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). + msg is set to null if there is no error message. deflateInit does not + perform any compression: this will be done by deflate(). +*/ + + +ZEXTERN int ZEXPORT deflate OF((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 some + output latency (reading input without producing any output) except when + forced to flush. + + The detailed semantics are as follows. deflate performs one or both of the + following actions: + + - Compress more input starting at next_in and update next_in and avail_in + accordingly. If not all input can be processed (because there is not + enough room in the output buffer), next_in and avail_in are updated and + processing will resume at this point for the next call of deflate(). + + - Provide more output starting at next_out and update next_out and avail_out + accordingly. This action is forced if the parameter flush is non zero. + Forcing flush frequently degrades the compression ratio, so this parameter + should be set only when necessary (in interactive applications). + Some output may be provided even if flush is not set. + + 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 avail_in or avail_out accordingly; avail_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 + (avail_out == 0), or after each call of deflate(). If deflate returns Z_OK + and with zero avail_out, it must be called again after making room in the + output buffer because there might be more output pending. + + Normally the parameter flush is set to Z_NO_FLUSH, which allows deflate to + decide how much data to accumualte before producing output, in order to + maximize compression. + + 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 + avail_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 state 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 + compression. + + If deflate returns with avail_out == 0, this function must be called again + 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. + + 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 avail_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, avail_out must be at least + the value returned by deflateBound (see below). If deflate does not return + Z_STREAM_END, then it must be called again as described above. + + deflate() sets strm->adler to the adler32 checksum of all input read + so far (that is, total_in bytes). + + deflate() may update strm->data_type if it can make a good guess about + the input data type (Z_BINARY or Z_TEXT). 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 state was inconsistent (for example + if next_in or next_out was NULL), Z_BUF_ERROR if no progress is possible + (for example avail_in or avail_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. +*/ + + +ZEXTERN int ZEXPORT deflateEnd OF((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 output. + + deflateEnd returns Z_OK if success, Z_STREAM_ERROR if the + stream state was inconsistent, Z_DATA_ERROR if the stream was freed + prematurely (some input or output was discarded). In the error case, + msg may be set but then points to a static string (which must not be + deallocated). +*/ + + +/* +ZEXTERN int ZEXPORT inflateInit OF((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 + the caller. If next_in is not Z_NULL and avail_in is large enough (the exact + value depends on the compression method), inflateInit determines the + compression method from the zlib header and allocates all data structures + accordingly; otherwise the allocation will be deferred to the first call of + inflate. If zalloc and zfree are set to Z_NULL, inflateInit updates them to + use default allocation functions. + + 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.) +*/ + + +ZEXTERN int ZEXPORT inflate OF((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 + some output latency (reading input without producing any output) except when + forced to flush. + + The detailed semantics are as follows. inflate performs one or both of the + following actions: + + - Decompress more input starting at next_in and update next_in and avail_in + accordingly. If not all input can be processed (because there is not + enough room in the output buffer), next_in is updated and processing + will resume at this point for the next call of inflate(). + + - Provide more output starting at next_out and update next_out and avail_out + accordingly. inflate() provides as much output as possible, until there + is no more input data or no more space in the output buffer (see below + about the flush parameter). + + 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 next_* and avail_* values accordingly. + The application can consume the uncompressed output when it wants, for + example when the output buffer is full (avail_out == 0), or after each + call of inflate(). If inflate returns Z_OK and with zero avail_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 gets 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->data_type to the + number of unused bits in the last byte taken from strm->next_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->next_out. The + number of unused bits may in general be greater than seven, except when + bit 7 of data_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; avail_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 state. 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->adler to the adler32 checksum of the dictionary + chosen by the compressor and returns Z_NEED_DICT; otherwise it sets + strm->adler to the adler32 checksum of all output produced so far (that is, + total_out bytes) and returns Z_OK, Z_STREAM_END or an error code as described + below. At the end of the stream, inflate() checks that its computed adler32 + checksum is equal to that saved by the compressor and returns Z_STREAM_END + only if the checksum is correct. + + inflate() 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 next_in or next_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. +*/ + + +ZEXTERN int ZEXPORT inflateEnd OF((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 output. + + inflateEnd returns Z_OK if success, Z_STREAM_ERROR if the stream state + was inconsistent. In the error case, msg may be set but then points to a + static string (which must not be deallocated). +*/ + + /* Advanced functions */ + +/* + The following functions are needed only in some special applications. +*/ + +/* +ZEXTERN int ZEXPORT deflateInit2 OF((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 next_in, zalloc, zfree and opaque must be initialized before by + the caller. + + 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). If a + gzip stream is being written, strm->adler is a crc32 instead of an adler32. + + The memLevel parameter specifies how much memory should be allocated + for the internal compression state. 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. See zconf.h for total memory + usage as a function of windowBits and memLevel. + + 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. Z_FIXED prevents the + use of dynamic Huffman codes, allowing for a simpler decoder for special + applications. + + 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). msg is set to null if there is no error message. deflateInit2 does + not perform any compression: this will be done by deflate(). +*/ + +ZEXTERN int ZEXPORT deflateSetDictionary OF((z_streamp strm, + const Bytef *dictionary, + uInt dictLength)); +/* + Initializes the compression dictionary from the given byte sequence + without producing any compressed output. This function must be called + immediately after deflateInit, deflateInit2 or deflateReset, before any + call of deflate. The compressor and decompressor must use exactly the same + dictionary (see inflateSetDictionary). + + The dictionary should consist of strings (byte sequences) that are likely + to be encountered later in the data to be compressed, with the most commonly + used strings preferably put towards the end of the dictionary. Using a + 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. In addition, the + current implementation of deflate will use at most the window size minus + 262 bytes of the provided dictionary. + + Upon return of this function, strm->adler 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->adler 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 state 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(). +*/ + +ZEXTERN int ZEXPORT deflateCopy OF((z_streamp dest, + z_streamp source)); +/* + Sets the destination stream as a complete copy of the source stream. + + 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 state 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 state was inconsistent + (such as zalloc being NULL). msg is left unchanged in both source and + destination. +*/ + +ZEXTERN int ZEXPORT deflateReset OF((z_streamp strm)); +/* + This function is equivalent to deflateEnd followed by deflateInit, + but does not free and reallocate all the internal compression state. + The stream will keep the same compression level and any other attributes + that may have been set by deflateInit2. + + deflateReset returns Z_OK if success, or Z_STREAM_ERROR if the source + stream state was inconsistent (such as zalloc or state being NULL). +*/ + +ZEXTERN int ZEXPORT deflateParams OF((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 + used to switch between compression and straight copy of the input data, or + to switch to a different kind of input data requiring a different + strategy. If the compression level is changed, the input available so far + is compressed with the old level (and may be flushed); the new level will + take effect only at the next call of deflate(). + + Before the call of deflateParams, the stream state must be set as for + a call of deflate(), since the currently available input may have to + be compressed and flushed. In particular, strm->avail_out must be non-zero. + + deflateParams returns Z_OK if success, Z_STREAM_ERROR if the source + stream state was inconsistent or if a parameter was invalid, Z_BUF_ERROR + if strm->avail_out was zero. +*/ + +ZEXTERN int ZEXPORT deflateTune OF((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 + searching for the best matching string, and even then only by the most + fanatic optimizer trying to squeeze out the last compressed bit for their + specific input data. Read the deflate.c source code for the meaning of the + max_lazy, good_length, nice_length, and max_chain parameters. + + deflateTune() can be called after deflateInit() or deflateInit2(), and + returns Z_OK on success, or Z_STREAM_ERROR for an invalid deflate stream. + */ + +ZEXTERN uLong ZEXPORT deflateBound OF((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 deflateInit2(). This would be used to allocate an output buffer + for deflation in a single pass, and so would be called before deflate(). +*/ + +ZEXTERN int ZEXPORT deflatePrime OF((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 leftover from a previous deflate stream when appending to it. As such, + this function can only be used for raw deflate, and must be used before the + first deflate() call after a deflateInit2() or deflateReset(). bits must be + less than or equal to 16, and that many of the least significant bits of + value will be inserted in the output. + + deflatePrime returns Z_OK if success, or Z_STREAM_ERROR if the source + stream state was inconsistent. +*/ + +ZEXTERN int ZEXPORT deflateSetHeader OF((z_streamp strm, + gz_headerp head)); +/* + deflateSetHeader() provides gzip header information for when a gzip + stream is requested by deflateInit2(). deflateSetHeader() may be called + after deflateInit2() or deflateReset() and before the first call of + deflate(). The text, time, os, extra field, name, and comment information + in the provided gz_header structure are written to the gzip header (xflag is + ignored -- the extra flags are set according to the compression level). The + caller must assure that, if not Z_NULL, name and comment are terminated with + a zero byte, and that if extra is not Z_NULL, that extra_len bytes are + available there. If hcrc is true, a gzip header crc is included. Note that + the current versions of the command-line version of gzip (up through version + 1.3.x) do not support header crc's, and will report that it is a "multi-part + 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(). + + 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)); + + This is another version of inflateInit with an extra parameter. The + fields next_in, avail_in, zalloc, zfree and opaque must be initialized + before by the caller. + + 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). If a gzip stream is being decoded, strm->adler is + a crc32 instead of an adler32. + + 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 null strm). msg + 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 next_in and avail_in may be modified, but next_out + and avail_out are unchanged.) +*/ + +ZEXTERN int ZEXPORT inflateSetDictionary OF((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, + if that call returned Z_NEED_DICT. The dictionary chosen by the compressor + can be determined from the adler32 value returned by that call of inflate. + The compressor and decompressor must use exactly the same dictionary (see + deflateSetDictionary). For raw inflate, this function can be called + immediately after inflateInit2() or inflateReset() and before any call of + inflate() to set the dictionary. The application must insure that the + dictionary that was used for compression is provided. + + inflateSetDictionary returns Z_OK if success, Z_STREAM_ERROR if a + parameter is invalid (such as NULL dictionary) or the stream state is + inconsistent, Z_DATA_ERROR if the given dictionary doesn't match the + expected one (incorrect adler32 value). inflateSetDictionary does not + perform any decompression: this will be done by subsequent calls of + inflate(). +*/ + +ZEXTERN int ZEXPORT inflateSync OF((z_streamp strm)); +/* + Skips invalid compressed data until a full flush point (see above the + description of deflate with Z_FULL_FLUSH) can be found, or until all + available input is skipped. No output is provided. + + 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 total_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. +*/ + +ZEXTERN int ZEXPORT inflateCopy OF((z_streamp dest, + z_streamp source)); +/* + Sets the destination stream as a complete copy of the source stream. + + 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). msg is left unchanged in both source and + destination. +*/ + +ZEXTERN int ZEXPORT inflateReset OF((z_streamp strm)); +/* + This function is equivalent to inflateEnd followed by inflateInit, + but does not free and reallocate all the internal decompression state. + The stream will keep attributes that may have been set by inflateInit2. + + inflateReset returns Z_OK if success, or Z_STREAM_ERROR if the source + stream state was inconsistent (such as zalloc or state being NULL). +*/ + +ZEXTERN int ZEXPORT inflatePrime OF((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 + middle of a byte. The provided bits will be used before any bytes are used + from next_in. This function should only be used with raw inflate, and + should be used before the first inflate() call after inflateInit2() or + inflateReset(). bits must be less than or equal to 16, and that many of the + least significant bits of value will be inserted in the input. + + inflatePrime returns Z_OK if success, or Z_STREAM_ERROR if the source + stream state was inconsistent. +*/ + +ZEXTERN int ZEXPORT inflateGetHeader OF((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 + inflateInit2() or inflateReset(), and before the first call of inflate(). + As inflate() processes the gzip stream, head->done is zero until the header + is completed, at which time head->done is set to one. If a zlib stream is + being decoded, then head->done is set to -1 to indicate that there will be + no gzip header information forthcoming. Note that Z_BLOCK can be used to + force inflate() to return immediately after header processing is complete + and before any actual data is decompressed. + + The text, time, xflags, and os fields are filled in with the gzip header + contents. hcrc is set to true if there is a header CRC. (The header CRC + was valid if done is set to one.) If extra is not Z_NULL, then extra_max + contains the maximum number of bytes to write to extra. Once done is true, + extra_len contains the actual extra field length, and extra contains the + extra field, or that field truncated if extra_max is less than extra_len. + If name is not Z_NULL, then up to name_max characters are written there, + terminated with a zero unless the length is greater than name_max. If + comment is not Z_NULL, then up to comm_max characters are written there, + terminated with a zero unless the length is greater than comm_max. When + any of extra, name, or comment are not Z_NULL and the respective field is + not present in the header, then that field is set to Z_NULL to signal its + absence. This allows the use of deflateSetHeader() with the returned + structure to duplicate the header. However if those fields are set to + allocated memory, then the application will need to save those pointers + elsewhere so that they can be eventually freed. + + If inflateGetHeader is not used, then the header information is simply + discarded. The header is always checked for validity, including the header + CRC if present. inflateReset() will reset the process to discard the header + information. The application would need to call inflateGetHeader() again to + retrieve the header from the next gzip stream. + + inflateGetHeader returns Z_OK if success, or Z_STREAM_ERROR if the source + stream state was inconsistent. +*/ + +/* +ZEXTERN int ZEXPORT inflateBackInit OF((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 + before the call. If zalloc and zfree are Z_NULL, then the default library- + derived memory allocation routines are used. windowBits is the base two + logarithm of the window size, in the range 8..15. window is a caller + supplied buffer of that size. Except for special applications where it is + assured that deflate was used with small window sizes, windowBits must be 15 + and a 32K byte window must be supplied to be able to decompress general + deflate streams. + + See inflateBack() for the usage of these routines. + + inflateBackInit will return Z_OK on success, Z_STREAM_ERROR if any of + the paramaters are invalid, Z_MEM_ERROR if the internal state could not + be allocated, or Z_VERSION_ERROR if the version of the library does not + match the version of the header file. +*/ + +typedef unsigned (*in_func) OF((void FAR *, unsigned char FAR * FAR *)); +typedef int (*out_func) OF((void FAR *, unsigned char FAR *, unsigned)); + +ZEXTERN int ZEXPORT inflateBack OF((z_streamp strm, + in_func in, void FAR *in_desc, + out_func out, void FAR *out_desc)); +/* + inflateBack() does a raw inflate with a single call using a call-back + interface for input and output. This is more efficient than inflate() for + file i/o applications in that it avoids copying between the output and the + sliding window by simply making the window itself the output buffer. This + function trusts the application to not change the output buffer passed by + the output function, at least until inflateBack() returns. + + 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 above 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->next_in and strm->avail_in. If that input is exhausted, then + in() will be called. Therefore strm->next_in must be initialized before + calling inflateBack(). If strm->next_in is Z_NULL, then in() will be called + immediately for input. If strm->next_in is not Z_NULL, then strm->avail_in + must also be initialized, and then if strm->avail_in is not zero, input will + initially be taken from strm->next_in[0 .. strm->avail_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->next_in and strm->avail_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->msg 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->next_in which will be Z_NULL only if in() returned + an error. If strm->next 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->next_in is assured to be defined if out() returns non-zero.) Note + that inflateBack() cannot return Z_OK. +*/ + +ZEXTERN int ZEXPORT inflateBackEnd OF((z_streamp strm)); +/* + All memory allocated by inflateBackInit() is freed. + + inflateBackEnd() returns Z_OK on success, or Z_STREAM_ERROR if the stream + state was inconsistent. +*/ + +ZEXTERN uLong ZEXPORT zlibCompileFlags OF((void)); +/* Return flags indicating compile-time options. + + Type sizes, two bits each, 00 = 16 bits, 01 = 32, 10 = 64, 11 = other: + 1.0: size of uInt + 3.2: size of uLong + 5.4: size of voidpf (pointer) + 7.6: size of z_off_t + + Compiler, assembler, and debug options: + 8: DEBUG + 9: ASMV or ASMINF -- use ASM code + 10: ZLIB_WINAPI -- exported functions use the WINAPI calling convention + 11: 0 (reserved) + + One-time table building (smaller code, but not thread-safe if true): + 12: BUILDFIXED -- build static block decoding tables when needed + 13: DYNAMIC_CRC_TABLE -- build CRC calculation tables when needed + 14,15: 0 (reserved) + + Library content (indicates missing functionality): + 16: NO_GZCOMPRESS -- gz* functions cannot compress (to avoid linking + deflate code when not needed) + 17: NO_GZIP -- deflate can't write gzip streams, and inflate can't detect + and decode gzip streams (to avoid linking crc code) + 18-19: 0 (reserved) + + Operation variations (changes in library functionality): + 20: PKZIP_BUG_WORKAROUND -- slightly more permissive inflate + 21: FASTEST -- deflate algorithm with only one, lowest compression level + 22,23: 0 (reserved) + + The sprintf variant used by gzprintf (zero is best): + 24: 0 = vs*, 1 = s* -- 1 means limited to 20 arguments after the format + 25: 0 = *nprintf, 1 = *printf -- 1 means gzprintf() not secure! + 26: 0 = returns value, 1 = void -- 1 means inferred string length returned + + Remainder: + 27-31: 0 (reserved) + */ + + + /* utility functions */ + +/* + The following utility functions are implemented on top of the + basic stream-oriented functions. To simplify the interface, some + default options are assumed (compression level and memory usage, + standard memory allocation functions). The source code of these + utility functions can easily be modified if you need special options. +*/ + +ZEXTERN int ZEXPORT compress OF((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 of the destination buffer, which must be at least the value returned + by compressBound(sourceLen). Upon exit, destLen is the actual size of the + compressed buffer. + This function can be used to compress a whole file at once if the + input file is mmap'ed. + 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. +*/ + +ZEXTERN int ZEXPORT compress2 OF((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 + length of the source buffer. Upon entry, destLen is the total size of the + destination buffer, which must be at least the value returned by + compressBound(sourceLen). Upon exit, destLen is the actual size of the + compressed 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. +*/ + +ZEXTERN uLong ZEXPORT compressBound OF((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)); +/* + Decompresses the source buffer into the destination buffer. sourceLen is + the byte length of the source buffer. Upon entry, destLen is the total + size of the destination buffer, which must be large enough to hold the + entire uncompressed data. (The size of the uncompressed data must have + been saved previously by the compressor and transmitted to the decompressor + by some mechanism outside the scope of this compression library.) + Upon exit, destLen is the actual size of the compressed buffer. + 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. +*/ + + +typedef voidp gzFile; + +ZEXTERN gzFile ZEXPORT gzopen OF((const char *path, const char *mode)); +/* + Opens a gzip (.gz) file for reading or writing. The mode parameter + is as in fopen ("rb" or "wb") but can also include a compression level + ("wb9") or a strategy: 'f' for filtered data as in "wb6f", 'h' for + Huffman only compression as in "wb1h", or 'R' for run-length encoding + as in "wb1R". (See the description of deflateInit2 for more information + about the strategy parameter.) + + 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 state; errno + can be checked to distinguish the two cases (if errno is zero, the + zlib error is Z_MEM_ERROR). */ + +ZEXTERN gzFile ZEXPORT gzdopen OF((int fd, const char *mode)); +/* + gzdopen() associates a gzFile with the file descriptor fd. File + descriptors are obtained from calls like open, dup, creat, pipe or + fileno (in the file has been previously opened with fopen). + The mode parameter is as in gzopen. + 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 state. +*/ + +ZEXTERN int ZEXPORT gzsetparams OF((gzFile file, int level, int strategy)); +/* + Dynamically update the compression level or strategy. See the description + of deflateInit2 for the meaning of these parameters. + gzsetparams returns Z_OK if success, or Z_STREAM_ERROR if the file was not + opened for writing. +*/ + +ZEXTERN int ZEXPORT gzread OF((gzFile file, voidp buf, unsigned len)); +/* + Reads the given number of uncompressed bytes from the compressed file. + If the input file was not in gzip format, gzread copies the given number + of bytes into the buffer. + gzread returns the number of uncompressed bytes actually read (0 for + end of file, -1 for error). */ + +ZEXTERN int ZEXPORT gzwrite OF((gzFile file, + voidpc buf, unsigned len)); +/* + Writes the given number of uncompressed bytes into the compressed file. + gzwrite returns the number of uncompressed bytes actually written + (0 in case of error). +*/ + +ZEXTERN int ZEXPORTVA gzprintf OF((gzFile file, const char *format, ...)); +/* + Converts, formats, and writes the args to the compressed file under + control of the format string, as in fprintf. gzprintf returns the number of + uncompressed bytes actually written (0 in case of error). The number of + uncompressed bytes written is limited to 4095. The caller should assure that + this limit is not exceeded. If it is exceeded, then gzprintf() will return + return an error (0) with nothing written. In this case, there may also be a + buffer overflow with unpredictable consequences, which is possible only if + zlib was compiled with the insecure functions sprintf() or vsprintf() + because the secure snprintf() or vsnprintf() functions were not available. +*/ + +ZEXTERN int ZEXPORT gzputs OF((gzFile file, const char *s)); +/* + Writes the given null-terminated string to the compressed file, excluding + the terminating null character. + gzputs returns the number of characters written, or -1 in case of error. +*/ + +ZEXTERN char * ZEXPORT gzgets OF((gzFile file, char *buf, int len)); +/* + Reads bytes from the compressed file until len-1 characters are read, or + a newline character is read and transferred to buf, or an end-of-file + condition is encountered. The string is then terminated with a null + character. + gzgets returns buf, or Z_NULL in case of error. +*/ + +ZEXTERN int ZEXPORT gzputc OF((gzFile file, int c)); +/* + Writes c, converted to an unsigned char, into the compressed file. + gzputc returns the value that was written, or -1 in case of error. +*/ + +ZEXTERN int ZEXPORT gzgetc OF((gzFile file)); +/* + Reads one byte from the compressed file. gzgetc returns this byte + or -1 in case of end of file or error. +*/ + +ZEXTERN int ZEXPORT gzungetc OF((int c, gzFile file)); +/* + Push one character back onto the stream to be read again later. + Only one character of push-back is allowed. gzungetc() returns the + character pushed, or -1 on failure. gzungetc() will fail if a + character has been pushed but not read yet, or if c is -1. The pushed + character will be discarded if the stream is repositioned with gzseek() + or gzrewind(). +*/ + +ZEXTERN int ZEXPORT gzflush OF((gzFile file, int flush)); +/* + Flushes all pending output into the compressed file. The parameter + flush is as in the deflate() function. The return value is the zlib + error number (see function gzerror below). gzflush returns Z_OK if + the flush parameter is Z_FINISH and all output could be flushed. + gzflush should be called only when strictly necessary because it can + degrade compression. +*/ + +ZEXTERN z_off_t ZEXPORT gzseek OF((gzFile file, + z_off_t offset, int whence)); +/* + Sets the starting position for the next gzread or gzwrite on the + given compressed file. The offset represents a number of bytes in the + uncompressed data stream. The whence parameter is defined as in lseek(2); + the value SEEK_END is not supported. + 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. +*/ + +ZEXTERN int ZEXPORT gzrewind OF((gzFile file)); +/* + Rewinds the given file. This function is supported only for reading. + + gzrewind(file) is equivalent to (int)gzseek(file, 0L, SEEK_SET) +*/ + +ZEXTERN z_off_t ZEXPORT gztell OF((gzFile file)); +/* + Returns the starting position for the next gzread or gzwrite on the + given compressed file. This position represents a number of bytes in the + uncompressed data stream. + + gztell(file) is equivalent to gzseek(file, 0L, SEEK_CUR) +*/ + +ZEXTERN int ZEXPORT gzeof OF((gzFile file)); +/* + Returns 1 when EOF has previously been detected reading the given + input stream, otherwise zero. +*/ + +ZEXTERN int ZEXPORT gzdirect OF((gzFile file)); +/* + Returns 1 if file is being read directly without decompression, otherwise + zero. +*/ + +ZEXTERN int ZEXPORT gzclose OF((gzFile file)); +/* + Flushes all pending output if necessary, closes the compressed file + and deallocates all the (de)compression state. The return value is the zlib + error number (see function gzerror below). +*/ + +ZEXTERN const char * ZEXPORT gzerror OF((gzFile file, int *errnum)); +/* + Returns the error message for the last error which occurred on the + given compressed file. errnum is set to zlib error number. If an + error occurred in the file system and not in the compression library, + errnum is set to Z_ERRNO and the application may consult errno + to get the exact error code. +*/ + +ZEXTERN void ZEXPORT gzclearerr OF((gzFile file)); +/* + Clears the error and end-of-file flags for file. This is analogous to the + clearerr() function in stdio. This is useful for continuing to read a gzip + file that is being written concurrently. +*/ + + /* checksum functions */ + +/* + These functions are not related to compression but are exported + anyway because they might be useful in applications using the + compression library. +*/ + +ZEXTERN uLong ZEXPORT adler32 OF((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. If buf is NULL, this function returns + the required initial value for the checksum. + An Adler-32 checksum is almost as reliable as a CRC32 but can be computed + much faster. Usage example: + + uLong adler = adler32(0L, Z_NULL, 0); + + while (read_buffer(buffer, length) != EOF) { + adler = adler32(adler, buffer, length); + } + if (adler != original_adler) error(); +*/ + +ZEXTERN uLong ZEXPORT adler32_combine OF((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 + each, adler1 and adler2. adler32_combine() returns the Adler-32 checksum of + seq1 and seq2 concatenated, requiring only adler1, adler2, and len2. +*/ + +ZEXTERN uLong ZEXPORT crc32 OF((uLong crc, const Bytef *buf, uInt len)); +/* + Update a running CRC-32 with the bytes buf[0..len-1] and return the + updated CRC-32. If buf is NULL, this function returns the required initial + value for the for the crc. Pre- and post-conditioning (one's complement) is + performed within this function so it shouldn't be done by the application. + Usage example: + + uLong crc = crc32(0L, Z_NULL, 0); + + while (read_buffer(buffer, length) != EOF) { + crc = crc32(crc, buffer, length); + } + if (crc != original_crc) error(); +*/ + +ZEXTERN uLong ZEXPORT crc32_combine OF((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 + calculated for each, crc1 and crc2. crc32_combine() returns the CRC-32 + check value of seq1 and seq2 concatenated, requiring only crc1, crc2, and + len2. +*/ + + + /* various hacks, don't look :) */ + +/* 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)); +#define deflateInit(strm, level) \ + deflateInit_((strm), (level), ZLIB_VERSION, sizeof(z_stream)) +#define inflateInit(strm) \ + inflateInit_((strm), ZLIB_VERSION, sizeof(z_stream)) +#define deflateInit2(strm, level, method, windowBits, memLevel, strategy) \ + deflateInit2_((strm),(level),(method),(windowBits),(memLevel),\ + (strategy), ZLIB_VERSION, sizeof(z_stream)) +#define inflateInit2(strm, windowBits) \ + inflateInit2_((strm), (windowBits), ZLIB_VERSION, sizeof(z_stream)) +#define inflateBackInit(strm, windowBits, window) \ + inflateBackInit_((strm), (windowBits), (window), \ + ZLIB_VERSION, sizeof(z_stream)) + + +#if !defined(ZUTIL_H) && !defined(NO_DUMMY_DECL) + struct internal_state {int dummy;}; /* hack for buggy compilers */ +#endif + +ZEXTERN const char * ZEXPORT zError OF((int)); +ZEXTERN int ZEXPORT inflateSyncPoint OF((z_streamp z)); +ZEXTERN const uLongf * ZEXPORT get_crc_table OF((void)); + +#ifdef __cplusplus +} +#endif + +#endif /* ZLIB_H */ -- 2.11.4.GIT