From 5ed7f74756abccb01f3a2bf7f30862a7386f430d Mon Sep 17 00:00:00 2001 From: Johannes Schindelin Date: Wed, 16 Jan 2008 15:49:55 +0000 Subject: [PATCH] zlib 1.2.3 --- include/zconf.h | 332 ++++++++++++ include/zlib.h | 1357 +++++++++++++++++++++++++++++++++++++++++++++++++ lib/libz.a | Bin 0 -> 74276 bytes share/man/man3/zlib.3 | 159 ++++++ src/zlib/fileList.txt | 4 + 5 files changed, 1852 insertions(+) create mode 100644 include/zconf.h create mode 100644 include/zlib.h create mode 100644 lib/libz.a create mode 100644 share/man/man3/zlib.3 create mode 100644 src/zlib/fileList.txt diff --git a/include/zconf.h b/include/zconf.h new file mode 100644 index 00000000..ea2db4ba --- /dev/null +++ b/include/zconf.h @@ -0,0 +1,332 @@ +/* zconf.h -- configuration of the zlib compression library + * Copyright (C) 1995-2005 Jean-loup Gailly. + * For conditions of distribution and use, see copyright notice in zlib.h + */ + +/* @(#) $Id$ */ + +#ifndef ZCONF_H +#define ZCONF_H + +/* + * If you *really* need a unique prefix for all types and library functions, + * compile with -DZ_PREFIX. The "standard" zlib should be compiled without it. + */ +#ifdef Z_PREFIX +# define deflateInit_ z_deflateInit_ +# define deflate z_deflate +# define deflateEnd z_deflateEnd +# define inflateInit_ z_inflateInit_ +# define inflate z_inflate +# define inflateEnd z_inflateEnd +# define deflateInit2_ z_deflateInit2_ +# define deflateSetDictionary z_deflateSetDictionary +# define deflateCopy z_deflateCopy +# define deflateReset z_deflateReset +# define deflateParams z_deflateParams +# define deflateBound z_deflateBound +# define deflatePrime z_deflatePrime +# define inflateInit2_ z_inflateInit2_ +# define inflateSetDictionary z_inflateSetDictionary +# define inflateSync z_inflateSync +# define inflateSyncPoint z_inflateSyncPoint +# define inflateCopy z_inflateCopy +# define inflateReset z_inflateReset +# define inflateBack z_inflateBack +# define inflateBackEnd z_inflateBackEnd +# define compress z_compress +# define compress2 z_compress2 +# define compressBound z_compressBound +# define uncompress z_uncompress +# define adler32 z_adler32 +# define crc32 z_crc32 +# define get_crc_table z_get_crc_table +# define zError z_zError + +# define alloc_func z_alloc_func +# define free_func z_free_func +# define in_func z_in_func +# define out_func z_out_func +# define Byte z_Byte +# define uInt z_uInt +# define uLong z_uLong +# define Bytef z_Bytef +# define charf z_charf +# define intf z_intf +# define uIntf z_uIntf +# define uLongf z_uLongf +# define voidpf z_voidpf +# define voidp z_voidp +#endif + +#if defined(__MSDOS__) && !defined(MSDOS) +# define MSDOS +#endif +#if (defined(OS_2) || defined(__OS2__)) && !defined(OS2) +# define OS2 +#endif +#if defined(_WINDOWS) && !defined(WINDOWS) +# define WINDOWS +#endif +#if defined(_WIN32) || defined(_WIN32_WCE) || defined(__WIN32__) +# ifndef WIN32 +# define WIN32 +# endif +#endif +#if (defined(MSDOS) || defined(OS2) || defined(WINDOWS)) && !defined(WIN32) +# if !defined(__GNUC__) && !defined(__FLAT__) && !defined(__386__) +# ifndef SYS16BIT +# define SYS16BIT +# endif +# endif +#endif + +/* + * Compile with -DMAXSEG_64K if the alloc function cannot allocate more + * than 64k bytes at a time (needed on systems with 16-bit int). + */ +#ifdef SYS16BIT +# define MAXSEG_64K +#endif +#ifdef MSDOS +# define UNALIGNED_OK +#endif + +#ifdef __STDC_VERSION__ +# ifndef STDC +# define STDC +# endif +# if __STDC_VERSION__ >= 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 1 /* 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/include/zlib.h b/include/zlib.h new file mode 100644 index 00000000..02281792 --- /dev/null +++ b/include/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 */ diff --git a/lib/libz.a b/lib/libz.a new file mode 100644 index 0000000000000000000000000000000000000000..1f2fe9af9a9355f03774e676a10f2a17fd9a6dfd GIT binary patch literal 74276 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 literal 0 HcwPel00001 diff --git a/share/man/man3/zlib.3 b/share/man/man3/zlib.3 new file mode 100644 index 00000000..90b81628 --- /dev/null +++ b/share/man/man3/zlib.3 @@ -0,0 +1,159 @@ +.TH ZLIB 3 "18 July 2005" +.SH NAME +zlib \- compression/decompression library +.SH SYNOPSIS +[see +.I zlib.h +for full description] +.SH DESCRIPTION +The +.I zlib +library is a general purpose data compression library. +The code is thread safe. +It 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. +.LP +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. +.LP +The library also supports reading and writing files in +.IR gzip (1) +(.gz) format +with an interface similar to that of stdio. +.LP +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. +.LP +All functions of the compression library are documented in the file +.IR zlib.h . +The distribution source includes examples of use of the library +in the files +.I example.c +and +.IR minigzip.c . +.LP +Changes to this version are documented in the file +.I ChangeLog +that accompanies the source, +and are concerned primarily with bug fixes and portability enhancements. +.LP +A Java implementation of +.I zlib +is available in the Java Development Kit 1.1: +.IP +http://www.javasoft.com/products/JDK/1.1/docs/api/Package-java.util.zip.html +.LP +A Perl interface to +.IR zlib , +written by Paul Marquess (pmqs@cpan.org), +is available at CPAN (Comprehensive Perl Archive Network) sites, +including: +.IP +http://www.cpan.org/modules/by-module/Compress/ +.LP +A Python interface to +.IR zlib , +written by A.M. Kuchling (amk@magnet.com), +is available in Python 1.5 and later versions: +.IP +http://www.python.org/doc/lib/module-zlib.html +.LP +A +.I zlib +binding for +.IR tcl (1), +written by Andreas Kupries (a.kupries@westend.com), +is availlable at: +.IP +http://www.westend.com/~kupries/doc/trf/man/man.html +.LP +An experimental package to read and write files in .zip format, +written on top of +.I zlib +by Gilles Vollant (info@winimage.com), +is available at: +.IP +http://www.winimage.com/zLibDll/unzip.html +and also in the +.I contrib/minizip +directory of the main +.I zlib +web site. +.SH "SEE ALSO" +The +.I zlib +web site can be found at either of these locations: +.IP +http://www.zlib.org +.br +http://www.gzip.org/zlib/ +.LP +The data format used by the zlib library is described by RFC +(Request for Comments) 1950 to 1952 in the files: +.IP +http://www.ietf.org/rfc/rfc1950.txt (concerning zlib format) +.br +http://www.ietf.org/rfc/rfc1951.txt (concerning deflate format) +.br +http://www.ietf.org/rfc/rfc1952.txt (concerning gzip format) +.LP +These documents are also available in other formats from: +.IP +ftp://ftp.uu.net/graphics/png/documents/zlib/zdoc-index.html +.LP +Mark Nelson (markn@ieee.org) wrote an article about +.I zlib +for the Jan. 1997 issue of Dr. Dobb's Journal; +a copy of the article is available at: +.IP +http://dogma.net/markn/articles/zlibtool/zlibtool.htm +.SH "REPORTING PROBLEMS" +Before reporting a problem, +please check the +.I zlib +web site to verify that you have the latest version of +.IR zlib ; +otherwise, +obtain the latest version and see if the problem still exists. +Please read the +.I zlib +FAQ at: +.IP +http://www.gzip.org/zlib/zlib_faq.html +.LP +before asking for help. +Send questions and/or comments to zlib@gzip.org, +or (for the Windows DLL version) to Gilles Vollant (info@winimage.com). +.SH AUTHORS +Version 1.2.3 +Copyright (C) 1995-2005 Jean-loup Gailly (jloup@gzip.org) +and Mark Adler (madler@alumni.caltech.edu). +.LP +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. +See the distribution directory with respect to requirements +governing redistribution. +The deflate format used by +.I zlib +was defined by Phil Katz. +The deflate and +.I zlib +specifications were written by L. Peter Deutsch. +Thanks to all the people who reported problems and suggested various +improvements in +.IR zlib ; +who are too numerous to cite here. +.LP +UNIX manual page by R. P. C. Rodgers, +U.S. National Library of Medicine (rodgers@nlm.nih.gov). +.\" end of man page diff --git a/src/zlib/fileList.txt b/src/zlib/fileList.txt new file mode 100644 index 00000000..aa797982 --- /dev/null +++ b/src/zlib/fileList.txt @@ -0,0 +1,4 @@ +/include/zconf.h +/include/zlib.h +/lib/libz.a +/share/man/man3/zlib.3 -- 2.11.4.GIT