zlib 0.3 → 0.4
raw patch · 19 files changed
+9144/−70 lines, 19 filesdep +bytestringdep ~base
Dependencies added: bytestring
Dependency ranges changed: base
Files
- Codec/Compression/GZip.hs +3/−3
- Codec/Compression/Zlib.hs +2/−2
- Codec/Compression/Zlib/Internal.hs +54/−43
- Codec/Compression/Zlib/Stream.hsc +13/−5
- LICENSE +23/−0
- cbits/adler32.c +149/−0
- cbits/compress.c +79/−0
- cbits/crc32.c +423/−0
- cbits/deflate.c +1736/−0
- cbits/gzio.c +1026/−0
- cbits/infback.c +623/−0
- cbits/inffast.c +318/−0
- cbits/inflate.c +1368/−0
- cbits/inftrees.c +329/−0
- cbits/trees.c +1219/−0
- cbits/uncompr.c +61/−0
- cbits/zlib.h +1357/−0
- cbits/zutil.c +318/−0
- zlib.cabal +43/−17
Codec/Compression/GZip.hs view
@@ -4,7 +4,7 @@ -- License : BSD-style -- -- Maintainer : duncan.coutts@worc.ox.ac.uk--- Stability : experimental+-- Stability : provisional -- Portability : portable (H98 + FFI) -- -- Compression and decompression of data streams in the gzip format.@@ -37,10 +37,10 @@ compress, compressWith, CompressionLevel(..),- + -- * Decompression decompress- + ) where import Data.ByteString.Lazy (ByteString)
Codec/Compression/Zlib.hs view
@@ -4,7 +4,7 @@ -- License : BSD-style -- -- Maintainer : duncan.coutts@worc.ox.ac.uk--- Stability : experimental+-- Stability : provisional -- Portability : portable (H98 + FFI) -- -- Compression and decompression of data streams in the zlib format.@@ -24,7 +24,7 @@ -- * Decompression decompress- + ) where import Data.ByteString.Lazy (ByteString)
Codec/Compression/Zlib/Internal.hs view
@@ -1,10 +1,10 @@ ----------------------------------------------------------------------------- -- |--- Copyright : (c) 2006 Duncan Coutts+-- Copyright : (c) 2006-2007 Duncan Coutts -- License : BSD-style -- -- Maintainer : duncan.coutts@worc.ox.ac.uk--- Stability : experimental+-- Stability : provisional -- Portability : portable (H98 + FFI) -- -- Pure stream based interface to lower level zlib wrapper@@ -29,12 +29,15 @@ ) where import Prelude hiding (length)-import Control.Monad (liftM, when)+import Control.Monad (when) import Control.Exception (assert)-import qualified Data.ByteString.Lazy as Lazy-import qualified Data.ByteString as Strict-import qualified Data.ByteString.Base as Base-import Data.ByteString.Base (LazyByteString(LPS))+import qualified Data.ByteString.Lazy as L+#ifdef BYTESTRING_IN_BASE+import qualified Data.ByteString.Base as S+#else+import qualified Data.ByteString.Lazy.Internal as L+import qualified Data.ByteString.Internal as S+#endif import qualified Codec.Compression.Zlib.Stream as Stream import Codec.Compression.Zlib.Stream (Stream)@@ -42,8 +45,8 @@ compressDefault :: Stream.Format -> Stream.CompressionLevel- -> Lazy.ByteString- -> Lazy.ByteString+ -> L.ByteString+ -> L.ByteString compressDefault format compressionLevel = compressFull format compressionLevel@@ -54,8 +57,8 @@ decompressDefault :: Stream.Format- -> Lazy.ByteString- -> Lazy.ByteString+ -> L.ByteString+ -> L.ByteString decompressDefault format = decompressFull format Stream.DefaultWindowBits@@ -68,20 +71,24 @@ -> Stream.WindowBits -> Stream.MemoryLevel -> Stream.CompressionStrategy- -> Lazy.ByteString- -> Lazy.ByteString-compressFull format compLevel method bits memLevel strategy (LPS chunks) =- Stream.run $ do+ -> L.ByteString+ -> L.ByteString+compressFull format compLevel method bits memLevel strategy input =+ L.fromChunks $ Stream.run $ do Stream.deflateInit format compLevel method bits memLevel strategy- case chunks of- [] -> liftM LPS (fillBuffers [])- (Base.PS inFPtr offset length : chunks') -> do+ case L.toChunks input of+ [] -> fillBuffers []+ S.PS inFPtr offset length : chunks -> do Stream.pushInputBuffer inFPtr offset length- liftM LPS (fillBuffers chunks')+ fillBuffers chunks where outChunkSize :: Int+#ifdef BYTESTRING_IN_BASE outChunkSize = 16 * 1024 - 16+#else+ outChunkSize = 16 * 1024 - L.chunkOverhead+#endif -- we flick between two states: -- * where one or other buffer is empty@@ -90,8 +97,8 @@ -- - in which case we compress until a buffer is empty fillBuffers ::- [Strict.ByteString]- -> Stream [Strict.ByteString]+ [S.ByteString]+ -> Stream [S.ByteString] fillBuffers inChunks = do Stream.consistencyCheck @@ -106,21 +113,21 @@ assert (inputBufferEmpty || outputBufferFull) $ return () when outputBufferFull $ do- outFPtr <- Stream.unsafeLiftIO (Base.mallocByteString outChunkSize)+ outFPtr <- Stream.unsafeLiftIO (S.mallocByteString outChunkSize) Stream.pushOutputBuffer outFPtr 0 outChunkSize if inputBufferEmpty then case inChunks of [] -> drainBuffers []- (Base.PS inFPtr offset length : inChunks') -> do+ S.PS inFPtr offset length : inChunks' -> do Stream.pushInputBuffer inFPtr offset length drainBuffers inChunks' else drainBuffers inChunks drainBuffers ::- [Strict.ByteString]- -> Stream [Strict.ByteString]+ [S.ByteString]+ -> Stream [S.ByteString] drainBuffers inChunks = do inputBufferEmpty' <- Stream.inputBufferEmpty@@ -139,7 +146,7 @@ if outputBufferFull then do (outFPtr, offset, length) <- Stream.popOutputBuffer outChunks <- Stream.unsafeInterleave (fillBuffers inChunks)- return (Base.PS outFPtr offset length : outChunks)+ return (S.PS outFPtr offset length : outChunks) else do fillBuffers inChunks Stream.StreamEnd -> do@@ -149,7 +156,7 @@ if outputBufferBytesAvailable > 0 then do (outFPtr, offset, length) <- Stream.popOutputBuffer Stream.finalise- return (Base.PS outFPtr offset length : [])+ return [S.PS outFPtr offset length] else do Stream.finalise return [] Stream.BufferError -> fail "BufferError should be impossible!"@@ -160,20 +167,24 @@ decompressFull :: Stream.Format -> Stream.WindowBits- -> Lazy.ByteString- -> Lazy.ByteString-decompressFull format bits (LPS chunks) =- Stream.run $ do+ -> L.ByteString+ -> L.ByteString+decompressFull format bits input =+ L.fromChunks $ Stream.run $ do Stream.inflateInit format bits- case chunks of- [] -> liftM LPS (fillBuffers [])- (Base.PS inFPtr offset length : chunks') -> do+ case L.toChunks input of+ [] -> fillBuffers []+ S.PS inFPtr offset length : chunks -> do Stream.pushInputBuffer inFPtr offset length- liftM LPS (fillBuffers chunks')+ fillBuffers chunks where outChunkSize :: Int+#ifdef BYTESTRING_IN_BASE outChunkSize = 32 * 1024 - 16+#else+ outChunkSize = 32 * 1024 - L.chunkOverhead+#endif -- we flick between two states: -- * where one or other buffer is empty@@ -182,8 +193,8 @@ -- - in which case we compress until a buffer is empty fillBuffers ::- [Strict.ByteString]- -> Stream [Strict.ByteString]+ [S.ByteString]+ -> Stream [S.ByteString] fillBuffers inChunks = do -- in this state there are two possabilities:@@ -197,21 +208,21 @@ assert (inputBufferEmpty || outputBufferFull) $ return () when outputBufferFull $ do- outFPtr <- Stream.unsafeLiftIO (Base.mallocByteString outChunkSize)+ outFPtr <- Stream.unsafeLiftIO (S.mallocByteString outChunkSize) Stream.pushOutputBuffer outFPtr 0 outChunkSize if inputBufferEmpty then case inChunks of [] -> drainBuffers []- (Base.PS inFPtr offset length : inChunks') -> do+ S.PS inFPtr offset length : inChunks' -> do Stream.pushInputBuffer inFPtr offset length drainBuffers inChunks' else drainBuffers inChunks drainBuffers ::- [Strict.ByteString]- -> Stream [Strict.ByteString]+ [S.ByteString]+ -> Stream [S.ByteString] drainBuffers inChunks = do inputBufferEmpty' <- Stream.inputBufferEmpty@@ -229,7 +240,7 @@ if outputBufferFull then do (outFPtr, offset, length) <- Stream.popOutputBuffer outChunks <- Stream.unsafeInterleave (fillBuffers inChunks)- return (Base.PS outFPtr offset length : outChunks)+ return (S.PS outFPtr offset length : outChunks) else do fillBuffers inChunks Stream.StreamEnd -> do@@ -240,7 +251,7 @@ if outputBufferBytesAvailable > 0 then do (outFPtr, offset, length) <- Stream.popOutputBuffer Stream.finalise- return (Base.PS outFPtr offset length : [])+ return [S.PS outFPtr offset length] else do Stream.finalise return [] Stream.BufferError -> fail "premature end of compressed stream"
Codec/Compression/Zlib/Stream.hsc view
@@ -58,7 +58,11 @@ import Foreign import Foreign.C+#ifdef BYTESTRING_IN_BASE import Data.ByteString.Base+#else+import Data.ByteString.Internal+#endif import System.IO.Unsafe (unsafeInterleaveIO) import System.IO (hPutStrLn, stderr) import Control.Monad (liftM)@@ -66,7 +70,7 @@ import Prelude hiding (length) -#include <zlib.h>+#include "zlib.h" pushInputBuffer :: ForeignPtr Word8 -> Int -> Int -> Stream ()@@ -387,14 +391,14 @@ | SyncFlush | FullFlush | Finish- | Block+-- | Block -- only available in zlib 1.2 and later, uncomment if you need it. instance Enum Flush where fromEnum NoFlush = #{const Z_NO_FLUSH} fromEnum SyncFlush = #{const Z_SYNC_FLUSH} fromEnum FullFlush = #{const Z_FULL_FLUSH} fromEnum Finish = #{const Z_FINISH}- fromEnum Block = #{const Z_BLOCK}+-- fromEnum Block = #{const Z_BLOCK} data Format = GZip -- ^ Encode or decode with the gzip header format.@@ -480,19 +484,23 @@ -- 'HuffmanOnly'. | HuffmanOnly -- ^ Use 'HuffmanOnly' to force Huffman encoding only (no -- string match). ++{-+-- -- only available in zlib 1.2 and later, uncomment if you need it. | RLE -- ^ Use 'RLE' to limit match distances to one (run-length -- encoding). 'RLE' is designed to be almost as fast as -- 'HuffmanOnly', but give better compression for PNG -- image data. | Fixed -- ^ 'Fixed' prevents the use of dynamic Huffman codes, -- allowing for a simpler decoder for special applications.+-} instance Enum CompressionStrategy where fromEnum DefaultStrategy = #{const Z_DEFAULT_STRATEGY} fromEnum Filtered = #{const Z_FILTERED} fromEnum HuffmanOnly = #{const Z_HUFFMAN_ONLY}- fromEnum RLE = #{const Z_RLE}- fromEnum Fixed = #{const Z_FIXED}+-- fromEnum RLE = #{const Z_RLE}+-- fromEnum Fixed = #{const Z_FIXED} withStreamPtr :: (Ptr StreamState -> IO a) -> Stream a withStreamPtr f = do
+ LICENSE view
@@ -0,0 +1,23 @@+Copyright (c) 2006-2007, Duncan Coutts+All rights reserved.++Redistribution and use in source and binary forms, with or without+modification, are permitted provided that the following conditions are met:++1. Redistributions of source code must retain the above copyright notice,+ this list of conditions and the following disclaimer.+2. Redistributions in binary form must reproduce the above copyright+ notice, this list of conditions and the following disclaimer in the+ documentation and/or other materials provided with the distribution.++THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"+AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE+IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE+ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE+LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR+CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF+SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS+INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN+CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)+ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE+POSSIBILITY OF SUCH DAMAGE.
+ cbits/adler32.c view
@@ -0,0 +1,149 @@+/* adler32.c -- compute the Adler-32 checksum of a data stream+ * Copyright (C) 1995-2004 Mark Adler+ * For conditions of distribution and use, see copyright notice in zlib.h+ */++/* @(#) $Id$ */++#define ZLIB_INTERNAL+#include "zlib.h"++#define BASE 65521UL /* largest prime smaller than 65536 */+#define NMAX 5552+/* NMAX is the largest n such that 255n(n+1)/2 + (n+1)(BASE-1) <= 2^32-1 */++#define DO1(buf,i) {adler += (buf)[i]; sum2 += adler;}+#define DO2(buf,i) DO1(buf,i); DO1(buf,i+1);+#define DO4(buf,i) DO2(buf,i); DO2(buf,i+2);+#define DO8(buf,i) DO4(buf,i); DO4(buf,i+4);+#define DO16(buf) DO8(buf,0); DO8(buf,8);++/* use NO_DIVIDE if your processor does not do division in hardware */+#ifdef NO_DIVIDE+# define MOD(a) \+ do { \+ if (a >= (BASE << 16)) a -= (BASE << 16); \+ if (a >= (BASE << 15)) a -= (BASE << 15); \+ if (a >= (BASE << 14)) a -= (BASE << 14); \+ if (a >= (BASE << 13)) a -= (BASE << 13); \+ if (a >= (BASE << 12)) a -= (BASE << 12); \+ if (a >= (BASE << 11)) a -= (BASE << 11); \+ if (a >= (BASE << 10)) a -= (BASE << 10); \+ if (a >= (BASE << 9)) a -= (BASE << 9); \+ if (a >= (BASE << 8)) a -= (BASE << 8); \+ if (a >= (BASE << 7)) a -= (BASE << 7); \+ if (a >= (BASE << 6)) a -= (BASE << 6); \+ if (a >= (BASE << 5)) a -= (BASE << 5); \+ if (a >= (BASE << 4)) a -= (BASE << 4); \+ if (a >= (BASE << 3)) a -= (BASE << 3); \+ if (a >= (BASE << 2)) a -= (BASE << 2); \+ if (a >= (BASE << 1)) a -= (BASE << 1); \+ if (a >= BASE) a -= BASE; \+ } while (0)+# define MOD4(a) \+ do { \+ if (a >= (BASE << 4)) a -= (BASE << 4); \+ if (a >= (BASE << 3)) a -= (BASE << 3); \+ if (a >= (BASE << 2)) a -= (BASE << 2); \+ if (a >= (BASE << 1)) a -= (BASE << 1); \+ if (a >= BASE) a -= BASE; \+ } while (0)+#else+# define MOD(a) a %= BASE+# define MOD4(a) a %= BASE+#endif++/* ========================================================================= */+uLong ZEXPORT adler32(adler, buf, len)+ uLong adler;+ const Bytef *buf;+ uInt len;+{+ unsigned long sum2;+ unsigned n;++ /* split Adler-32 into component sums */+ sum2 = (adler >> 16) & 0xffff;+ adler &= 0xffff;++ /* in case user likes doing a byte at a time, keep it fast */+ if (len == 1) {+ adler += buf[0];+ if (adler >= BASE)+ adler -= BASE;+ sum2 += adler;+ if (sum2 >= BASE)+ sum2 -= BASE;+ return adler | (sum2 << 16);+ }++ /* initial Adler-32 value (deferred check for len == 1 speed) */+ if (buf == Z_NULL)+ return 1L;++ /* in case short lengths are provided, keep it somewhat fast */+ if (len < 16) {+ while (len--) {+ adler += *buf++;+ sum2 += adler;+ }+ if (adler >= BASE)+ adler -= BASE;+ MOD4(sum2); /* only added so many BASE's */+ return adler | (sum2 << 16);+ }++ /* do length NMAX blocks -- requires just one modulo operation */+ while (len >= NMAX) {+ len -= NMAX;+ n = NMAX / 16; /* NMAX is divisible by 16 */+ do {+ DO16(buf); /* 16 sums unrolled */+ buf += 16;+ } while (--n);+ MOD(adler);+ MOD(sum2);+ }++ /* do remaining bytes (less than NMAX, still just one modulo) */+ if (len) { /* avoid modulos if none remaining */+ while (len >= 16) {+ len -= 16;+ DO16(buf);+ buf += 16;+ }+ while (len--) {+ adler += *buf++;+ sum2 += adler;+ }+ MOD(adler);+ MOD(sum2);+ }++ /* return recombined sums */+ return adler | (sum2 << 16);+}++/* ========================================================================= */+uLong ZEXPORT adler32_combine(adler1, adler2, len2)+ uLong adler1;+ uLong adler2;+ z_off_t len2;+{+ unsigned long sum1;+ unsigned long sum2;+ unsigned rem;++ /* the derivation of this formula is left as an exercise for the reader */+ rem = (unsigned)(len2 % BASE);+ sum1 = adler1 & 0xffff;+ sum2 = rem * sum1;+ MOD(sum2);+ sum1 += (adler2 & 0xffff) + BASE - 1;+ sum2 += ((adler1 >> 16) & 0xffff) + ((adler2 >> 16) & 0xffff) + BASE - rem;+ if (sum1 > BASE) sum1 -= BASE;+ if (sum1 > BASE) sum1 -= BASE;+ if (sum2 > (BASE << 1)) sum2 -= (BASE << 1);+ if (sum2 > BASE) sum2 -= BASE;+ return sum1 | (sum2 << 16);+}
+ cbits/compress.c view
@@ -0,0 +1,79 @@+/* compress.c -- compress a memory buffer+ * Copyright (C) 1995-2003 Jean-loup Gailly.+ * For conditions of distribution and use, see copyright notice in zlib.h+ */++/* @(#) $Id$ */++#define ZLIB_INTERNAL+#include "zlib.h"++/* ===========================================================================+ 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 0.1% larger than sourceLen plus+ 12 bytes. 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.+*/+int ZEXPORT compress2 (dest, destLen, source, sourceLen, level)+ Bytef *dest;+ uLongf *destLen;+ const Bytef *source;+ uLong sourceLen;+ int level;+{+ z_stream stream;+ int err;++ stream.next_in = (Bytef*)source;+ stream.avail_in = (uInt)sourceLen;+#ifdef MAXSEG_64K+ /* Check for source > 64K on 16-bit machine: */+ if ((uLong)stream.avail_in != sourceLen) return Z_BUF_ERROR;+#endif+ stream.next_out = dest;+ stream.avail_out = (uInt)*destLen;+ if ((uLong)stream.avail_out != *destLen) return Z_BUF_ERROR;++ stream.zalloc = (alloc_func)0;+ stream.zfree = (free_func)0;+ stream.opaque = (voidpf)0;++ err = deflateInit(&stream, level);+ if (err != Z_OK) return err;++ err = deflate(&stream, Z_FINISH);+ if (err != Z_STREAM_END) {+ deflateEnd(&stream);+ return err == Z_OK ? Z_BUF_ERROR : err;+ }+ *destLen = stream.total_out;++ err = deflateEnd(&stream);+ return err;+}++/* ===========================================================================+ */+int ZEXPORT compress (dest, destLen, source, sourceLen)+ Bytef *dest;+ uLongf *destLen;+ const Bytef *source;+ uLong sourceLen;+{+ return compress2(dest, destLen, source, sourceLen, Z_DEFAULT_COMPRESSION);+}++/* ===========================================================================+ If the default memLevel or windowBits for deflateInit() is changed, then+ this function needs to be updated.+ */+uLong ZEXPORT compressBound (sourceLen)+ uLong sourceLen;+{+ return sourceLen + (sourceLen >> 12) + (sourceLen >> 14) + 11;+}
+ cbits/crc32.c view
@@ -0,0 +1,423 @@+/* crc32.c -- compute the CRC-32 of a data stream+ * Copyright (C) 1995-2005 Mark Adler+ * For conditions of distribution and use, see copyright notice in zlib.h+ *+ * Thanks to Rodney Brown <rbrown64@csc.com.au> for his contribution of faster+ * CRC methods: exclusive-oring 32 bits of data at a time, and pre-computing+ * tables for updating the shift register in one step with three exclusive-ors+ * instead of four steps with four exclusive-ors. This results in about a+ * factor of two increase in speed on a Power PC G4 (PPC7455) using gcc -O3.+ */++/* @(#) $Id$ */++/*+ Note on the use of DYNAMIC_CRC_TABLE: there is no mutex or semaphore+ protection on the static variables used to control the first-use generation+ of the crc tables. Therefore, if you #define DYNAMIC_CRC_TABLE, you should+ first call get_crc_table() to initialize the tables before allowing more than+ one thread to use crc32().+ */++#ifdef MAKECRCH+# include <stdio.h>+# ifndef DYNAMIC_CRC_TABLE+# define DYNAMIC_CRC_TABLE+# endif /* !DYNAMIC_CRC_TABLE */+#endif /* MAKECRCH */++#include "zutil.h" /* for STDC and FAR definitions */++#define local static++/* Find a four-byte integer type for crc32_little() and crc32_big(). */+#ifndef NOBYFOUR+# ifdef STDC /* need ANSI C limits.h to determine sizes */+# include <limits.h>+# define BYFOUR+# if (UINT_MAX == 0xffffffffUL)+ typedef unsigned int u4;+# else+# if (ULONG_MAX == 0xffffffffUL)+ typedef unsigned long u4;+# else+# if (USHRT_MAX == 0xffffffffUL)+ typedef unsigned short u4;+# else+# undef BYFOUR /* can't find a four-byte integer type! */+# endif+# endif+# endif+# endif /* STDC */+#endif /* !NOBYFOUR */++/* Definitions for doing the crc four data bytes at a time. */+#ifdef BYFOUR+# define REV(w) (((w)>>24)+(((w)>>8)&0xff00)+ \+ (((w)&0xff00)<<8)+(((w)&0xff)<<24))+ local unsigned long crc32_little OF((unsigned long,+ const unsigned char FAR *, unsigned));+ local unsigned long crc32_big OF((unsigned long,+ const unsigned char FAR *, unsigned));+# define TBLS 8+#else+# define TBLS 1+#endif /* BYFOUR */++/* Local functions for crc concatenation */+local unsigned long gf2_matrix_times OF((unsigned long *mat,+ unsigned long vec));+local void gf2_matrix_square OF((unsigned long *square, unsigned long *mat));++#ifdef DYNAMIC_CRC_TABLE++local volatile int crc_table_empty = 1;+local unsigned long FAR crc_table[TBLS][256];+local void make_crc_table OF((void));+#ifdef MAKECRCH+ local void write_table OF((FILE *, const unsigned long FAR *));+#endif /* MAKECRCH */+/*+ Generate tables for a byte-wise 32-bit CRC calculation on the polynomial:+ x^32+x^26+x^23+x^22+x^16+x^12+x^11+x^10+x^8+x^7+x^5+x^4+x^2+x+1.++ Polynomials over GF(2) are represented in binary, one bit per coefficient,+ with the lowest powers in the most significant bit. Then adding polynomials+ is just exclusive-or, and multiplying a polynomial by x is a right shift by+ one. If we call the above polynomial p, and represent a byte as the+ polynomial q, also with the lowest power in the most significant bit (so the+ byte 0xb1 is the polynomial x^7+x^3+x+1), then the CRC is (q*x^32) mod p,+ where a mod b means the remainder after dividing a by b.++ This calculation is done using the shift-register method of multiplying and+ taking the remainder. The register is initialized to zero, and for each+ incoming bit, x^32 is added mod p to the register if the bit is a one (where+ x^32 mod p is p+x^32 = x^26+...+1), and the register is multiplied mod p by+ x (which is shifting right by one and adding x^32 mod p if the bit shifted+ out is a one). We start with the highest power (least significant bit) of+ q and repeat for all eight bits of q.++ The first table is simply the CRC of all possible eight bit values. This is+ all the information needed to generate CRCs on data a byte at a time for all+ combinations of CRC register values and incoming bytes. The remaining tables+ allow for word-at-a-time CRC calculation for both big-endian and little-+ endian machines, where a word is four bytes.+*/+local void make_crc_table()+{+ unsigned long c;+ int n, k;+ unsigned long poly; /* polynomial exclusive-or pattern */+ /* terms of polynomial defining this crc (except x^32): */+ static volatile int first = 1; /* flag to limit concurrent making */+ static const unsigned char p[] = {0,1,2,4,5,7,8,10,11,12,16,22,23,26};++ /* See if another task is already doing this (not thread-safe, but better+ than nothing -- significantly reduces duration of vulnerability in+ case the advice about DYNAMIC_CRC_TABLE is ignored) */+ if (first) {+ first = 0;++ /* make exclusive-or pattern from polynomial (0xedb88320UL) */+ poly = 0UL;+ for (n = 0; n < sizeof(p)/sizeof(unsigned char); n++)+ poly |= 1UL << (31 - p[n]);++ /* generate a crc for every 8-bit value */+ for (n = 0; n < 256; n++) {+ c = (unsigned long)n;+ for (k = 0; k < 8; k++)+ c = c & 1 ? poly ^ (c >> 1) : c >> 1;+ crc_table[0][n] = c;+ }++#ifdef BYFOUR+ /* generate crc for each value followed by one, two, and three zeros,+ and then the byte reversal of those as well as the first table */+ for (n = 0; n < 256; n++) {+ c = crc_table[0][n];+ crc_table[4][n] = REV(c);+ for (k = 1; k < 4; k++) {+ c = crc_table[0][c & 0xff] ^ (c >> 8);+ crc_table[k][n] = c;+ crc_table[k + 4][n] = REV(c);+ }+ }+#endif /* BYFOUR */++ crc_table_empty = 0;+ }+ else { /* not first */+ /* wait for the other guy to finish (not efficient, but rare) */+ while (crc_table_empty)+ ;+ }++#ifdef MAKECRCH+ /* write out CRC tables to crc32.h */+ {+ FILE *out;++ out = fopen("crc32.h", "w");+ if (out == NULL) return;+ fprintf(out, "/* crc32.h -- tables for rapid CRC calculation\n");+ fprintf(out, " * Generated automatically by crc32.c\n */\n\n");+ fprintf(out, "local const unsigned long FAR ");+ fprintf(out, "crc_table[TBLS][256] =\n{\n {\n");+ write_table(out, crc_table[0]);+# ifdef BYFOUR+ fprintf(out, "#ifdef BYFOUR\n");+ for (k = 1; k < 8; k++) {+ fprintf(out, " },\n {\n");+ write_table(out, crc_table[k]);+ }+ fprintf(out, "#endif\n");+# endif /* BYFOUR */+ fprintf(out, " }\n};\n");+ fclose(out);+ }+#endif /* MAKECRCH */+}++#ifdef MAKECRCH+local void write_table(out, table)+ FILE *out;+ const unsigned long FAR *table;+{+ int n;++ for (n = 0; n < 256; n++)+ fprintf(out, "%s0x%08lxUL%s", n % 5 ? "" : " ", table[n],+ n == 255 ? "\n" : (n % 5 == 4 ? ",\n" : ", "));+}+#endif /* MAKECRCH */++#else /* !DYNAMIC_CRC_TABLE */+/* ========================================================================+ * Tables of CRC-32s of all single-byte values, made by make_crc_table().+ */+#include "crc32.h"+#endif /* DYNAMIC_CRC_TABLE */++/* =========================================================================+ * This function can be used by asm versions of crc32()+ */+const unsigned long FAR * ZEXPORT get_crc_table()+{+#ifdef DYNAMIC_CRC_TABLE+ if (crc_table_empty)+ make_crc_table();+#endif /* DYNAMIC_CRC_TABLE */+ return (const unsigned long FAR *)crc_table;+}++/* ========================================================================= */+#define DO1 crc = crc_table[0][((int)crc ^ (*buf++)) & 0xff] ^ (crc >> 8)+#define DO8 DO1; DO1; DO1; DO1; DO1; DO1; DO1; DO1++/* ========================================================================= */+unsigned long ZEXPORT crc32(crc, buf, len)+ unsigned long crc;+ const unsigned char FAR *buf;+ unsigned len;+{+ if (buf == Z_NULL) return 0UL;++#ifdef DYNAMIC_CRC_TABLE+ if (crc_table_empty)+ make_crc_table();+#endif /* DYNAMIC_CRC_TABLE */++#ifdef BYFOUR+ if (sizeof(void *) == sizeof(ptrdiff_t)) {+ u4 endian;++ endian = 1;+ if (*((unsigned char *)(&endian)))+ return crc32_little(crc, buf, len);+ else+ return crc32_big(crc, buf, len);+ }+#endif /* BYFOUR */+ crc = crc ^ 0xffffffffUL;+ while (len >= 8) {+ DO8;+ len -= 8;+ }+ if (len) do {+ DO1;+ } while (--len);+ return crc ^ 0xffffffffUL;+}++#ifdef BYFOUR++/* ========================================================================= */+#define DOLIT4 c ^= *buf4++; \+ c = crc_table[3][c & 0xff] ^ crc_table[2][(c >> 8) & 0xff] ^ \+ crc_table[1][(c >> 16) & 0xff] ^ crc_table[0][c >> 24]+#define DOLIT32 DOLIT4; DOLIT4; DOLIT4; DOLIT4; DOLIT4; DOLIT4; DOLIT4; DOLIT4++/* ========================================================================= */+local unsigned long crc32_little(crc, buf, len)+ unsigned long crc;+ const unsigned char FAR *buf;+ unsigned len;+{+ register u4 c;+ register const u4 FAR *buf4;++ c = (u4)crc;+ c = ~c;+ while (len && ((ptrdiff_t)buf & 3)) {+ c = crc_table[0][(c ^ *buf++) & 0xff] ^ (c >> 8);+ len--;+ }++ buf4 = (const u4 FAR *)(const void FAR *)buf;+ while (len >= 32) {+ DOLIT32;+ len -= 32;+ }+ while (len >= 4) {+ DOLIT4;+ len -= 4;+ }+ buf = (const unsigned char FAR *)buf4;++ if (len) do {+ c = crc_table[0][(c ^ *buf++) & 0xff] ^ (c >> 8);+ } while (--len);+ c = ~c;+ return (unsigned long)c;+}++/* ========================================================================= */+#define DOBIG4 c ^= *++buf4; \+ c = crc_table[4][c & 0xff] ^ crc_table[5][(c >> 8) & 0xff] ^ \+ crc_table[6][(c >> 16) & 0xff] ^ crc_table[7][c >> 24]+#define DOBIG32 DOBIG4; DOBIG4; DOBIG4; DOBIG4; DOBIG4; DOBIG4; DOBIG4; DOBIG4++/* ========================================================================= */+local unsigned long crc32_big(crc, buf, len)+ unsigned long crc;+ const unsigned char FAR *buf;+ unsigned len;+{+ register u4 c;+ register const u4 FAR *buf4;++ c = REV((u4)crc);+ c = ~c;+ while (len && ((ptrdiff_t)buf & 3)) {+ c = crc_table[4][(c >> 24) ^ *buf++] ^ (c << 8);+ len--;+ }++ buf4 = (const u4 FAR *)(const void FAR *)buf;+ buf4--;+ while (len >= 32) {+ DOBIG32;+ len -= 32;+ }+ while (len >= 4) {+ DOBIG4;+ len -= 4;+ }+ buf4++;+ buf = (const unsigned char FAR *)buf4;++ if (len) do {+ c = crc_table[4][(c >> 24) ^ *buf++] ^ (c << 8);+ } while (--len);+ c = ~c;+ return (unsigned long)(REV(c));+}++#endif /* BYFOUR */++#define GF2_DIM 32 /* dimension of GF(2) vectors (length of CRC) */++/* ========================================================================= */+local unsigned long gf2_matrix_times(mat, vec)+ unsigned long *mat;+ unsigned long vec;+{+ unsigned long sum;++ sum = 0;+ while (vec) {+ if (vec & 1)+ sum ^= *mat;+ vec >>= 1;+ mat++;+ }+ return sum;+}++/* ========================================================================= */+local void gf2_matrix_square(square, mat)+ unsigned long *square;+ unsigned long *mat;+{+ int n;++ for (n = 0; n < GF2_DIM; n++)+ square[n] = gf2_matrix_times(mat, mat[n]);+}++/* ========================================================================= */+uLong ZEXPORT crc32_combine(crc1, crc2, len2)+ uLong crc1;+ uLong crc2;+ z_off_t len2;+{+ int n;+ unsigned long row;+ unsigned long even[GF2_DIM]; /* even-power-of-two zeros operator */+ unsigned long odd[GF2_DIM]; /* odd-power-of-two zeros operator */++ /* degenerate case */+ if (len2 == 0)+ return crc1;++ /* put operator for one zero bit in odd */+ odd[0] = 0xedb88320L; /* CRC-32 polynomial */+ row = 1;+ for (n = 1; n < GF2_DIM; n++) {+ odd[n] = row;+ row <<= 1;+ }++ /* put operator for two zero bits in even */+ gf2_matrix_square(even, odd);++ /* put operator for four zero bits in odd */+ gf2_matrix_square(odd, even);++ /* apply len2 zeros to crc1 (first square will put the operator for one+ zero byte, eight zero bits, in even) */+ do {+ /* apply zeros operator for this bit of len2 */+ gf2_matrix_square(even, odd);+ if (len2 & 1)+ crc1 = gf2_matrix_times(even, crc1);+ len2 >>= 1;++ /* if no more bits set, then done */+ if (len2 == 0)+ break;++ /* another iteration of the loop with odd and even swapped */+ gf2_matrix_square(odd, even);+ if (len2 & 1)+ crc1 = gf2_matrix_times(odd, crc1);+ len2 >>= 1;++ /* if no more bits set, then done */+ } while (len2 != 0);++ /* return combined crc */+ crc1 ^= crc2;+ return crc1;+}
+ cbits/deflate.c view
@@ -0,0 +1,1736 @@+/* deflate.c -- compress data using the deflation algorithm+ * Copyright (C) 1995-2005 Jean-loup Gailly.+ * For conditions of distribution and use, see copyright notice in zlib.h+ */++/*+ * ALGORITHM+ *+ * The "deflation" process depends on being able to identify portions+ * of the input text which are identical to earlier input (within a+ * sliding window trailing behind the input currently being processed).+ *+ * The most straightforward technique turns out to be the fastest for+ * most input files: try all possible matches and select the longest.+ * The key feature of this algorithm is that insertions into the string+ * dictionary are very simple and thus fast, and deletions are avoided+ * completely. Insertions are performed at each input character, whereas+ * string matches are performed only when the previous match ends. So it+ * is preferable to spend more time in matches to allow very fast string+ * insertions and avoid deletions. The matching algorithm for small+ * strings is inspired from that of Rabin & Karp. A brute force approach+ * is used to find longer strings when a small match has been found.+ * A similar algorithm is used in comic (by Jan-Mark Wams) and freeze+ * (by Leonid Broukhis).+ * A previous version of this file used a more sophisticated algorithm+ * (by Fiala and Greene) which is guaranteed to run in linear amortized+ * time, but has a larger average cost, uses more memory and is patented.+ * However the F&G algorithm may be faster for some highly redundant+ * files if the parameter max_chain_length (described below) is too large.+ *+ * ACKNOWLEDGEMENTS+ *+ * The idea of lazy evaluation of matches is due to Jan-Mark Wams, and+ * I found it in 'freeze' written by Leonid Broukhis.+ * Thanks to many people for bug reports and testing.+ *+ * REFERENCES+ *+ * Deutsch, L.P.,"DEFLATE Compressed Data Format Specification".+ * Available in http://www.ietf.org/rfc/rfc1951.txt+ *+ * A description of the Rabin and Karp algorithm is given in the book+ * "Algorithms" by R. Sedgewick, Addison-Wesley, p252.+ *+ * Fiala,E.R., and Greene,D.H.+ * Data Compression with Finite Windows, Comm.ACM, 32,4 (1989) 490-595+ *+ */++/* @(#) $Id$ */++#include "deflate.h"++const char deflate_copyright[] =+ " deflate 1.2.3 Copyright 1995-2005 Jean-loup Gailly ";+/*+ If you use the zlib library in a product, an acknowledgment is welcome+ in the documentation of your product. If for some reason you cannot+ include such an acknowledgment, I would appreciate that you keep this+ copyright string in the executable of your product.+ */++/* ===========================================================================+ * Function prototypes.+ */+typedef enum {+ need_more, /* block not completed, need more input or more output */+ block_done, /* block flush performed */+ finish_started, /* finish started, need only more output at next deflate */+ finish_done /* finish done, accept no more input or output */+} block_state;++typedef block_state (*compress_func) OF((deflate_state *s, int flush));+/* Compression function. Returns the block state after the call. */++local void fill_window OF((deflate_state *s));+local block_state deflate_stored OF((deflate_state *s, int flush));+local block_state deflate_fast OF((deflate_state *s, int flush));+#ifndef FASTEST+local block_state deflate_slow OF((deflate_state *s, int flush));+#endif+local void lm_init OF((deflate_state *s));+local void putShortMSB OF((deflate_state *s, uInt b));+local void flush_pending OF((z_streamp strm));+local int read_buf OF((z_streamp strm, Bytef *buf, unsigned size));+#ifndef FASTEST+#ifdef ASMV+ void match_init OF((void)); /* asm code initialization */+ uInt longest_match OF((deflate_state *s, IPos cur_match));+#else+local uInt longest_match OF((deflate_state *s, IPos cur_match));+#endif+#endif+local uInt longest_match_fast OF((deflate_state *s, IPos cur_match));++#ifdef DEBUG+local void check_match OF((deflate_state *s, IPos start, IPos match,+ int length));+#endif++/* ===========================================================================+ * Local data+ */++#define NIL 0+/* Tail of hash chains */++#ifndef TOO_FAR+# define TOO_FAR 4096+#endif+/* Matches of length 3 are discarded if their distance exceeds TOO_FAR */++#define MIN_LOOKAHEAD (MAX_MATCH+MIN_MATCH+1)+/* Minimum amount of lookahead, except at the end of the input file.+ * See deflate.c for comments about the MIN_MATCH+1.+ */++/* Values for max_lazy_match, good_match and max_chain_length, depending on+ * the desired pack level (0..9). The values given below have been tuned to+ * exclude worst case performance for pathological files. Better values may be+ * found for specific files.+ */+typedef struct config_s {+ ush good_length; /* reduce lazy search above this match length */+ ush max_lazy; /* do not perform lazy search above this match length */+ ush nice_length; /* quit search above this match length */+ ush max_chain;+ compress_func func;+} config;++#ifdef FASTEST+local const config configuration_table[2] = {+/* good lazy nice chain */+/* 0 */ {0, 0, 0, 0, deflate_stored}, /* store only */+/* 1 */ {4, 4, 8, 4, deflate_fast}}; /* max speed, no lazy matches */+#else+local const config configuration_table[10] = {+/* good lazy nice chain */+/* 0 */ {0, 0, 0, 0, deflate_stored}, /* store only */+/* 1 */ {4, 4, 8, 4, deflate_fast}, /* max speed, no lazy matches */+/* 2 */ {4, 5, 16, 8, deflate_fast},+/* 3 */ {4, 6, 32, 32, deflate_fast},++/* 4 */ {4, 4, 16, 16, deflate_slow}, /* lazy matches */+/* 5 */ {8, 16, 32, 32, deflate_slow},+/* 6 */ {8, 16, 128, 128, deflate_slow},+/* 7 */ {8, 32, 128, 256, deflate_slow},+/* 8 */ {32, 128, 258, 1024, deflate_slow},+/* 9 */ {32, 258, 258, 4096, deflate_slow}}; /* max compression */+#endif++/* Note: the deflate() code requires max_lazy >= MIN_MATCH and max_chain >= 4+ * For deflate_fast() (levels <= 3) good is ignored and lazy has a different+ * meaning.+ */++#define EQUAL 0+/* result of memcmp for equal strings */++#ifndef NO_DUMMY_DECL+struct static_tree_desc_s {int dummy;}; /* for buggy compilers */+#endif++/* ===========================================================================+ * Update a hash value with the given input byte+ * IN assertion: all calls to to UPDATE_HASH are made with consecutive+ * input characters, so that a running hash key can be computed from the+ * previous key instead of complete recalculation each time.+ */+#define UPDATE_HASH(s,h,c) (h = (((h)<<s->hash_shift) ^ (c)) & s->hash_mask)+++/* ===========================================================================+ * Insert string str in the dictionary and set match_head to the previous head+ * of the hash chain (the most recent string with same hash key). Return+ * the previous length of the hash chain.+ * If this file is compiled with -DFASTEST, the compression level is forced+ * to 1, and no hash chains are maintained.+ * IN assertion: all calls to to INSERT_STRING are made with consecutive+ * input characters and the first MIN_MATCH bytes of str are valid+ * (except for the last MIN_MATCH-1 bytes of the input file).+ */+#ifdef FASTEST+#define INSERT_STRING(s, str, match_head) \+ (UPDATE_HASH(s, s->ins_h, s->window[(str) + (MIN_MATCH-1)]), \+ match_head = s->head[s->ins_h], \+ s->head[s->ins_h] = (Pos)(str))+#else+#define INSERT_STRING(s, str, match_head) \+ (UPDATE_HASH(s, s->ins_h, s->window[(str) + (MIN_MATCH-1)]), \+ match_head = s->prev[(str) & s->w_mask] = s->head[s->ins_h], \+ s->head[s->ins_h] = (Pos)(str))+#endif++/* ===========================================================================+ * Initialize the hash table (avoiding 64K overflow for 16 bit systems).+ * prev[] will be initialized on the fly.+ */+#define CLEAR_HASH(s) \+ s->head[s->hash_size-1] = NIL; \+ zmemzero((Bytef *)s->head, (unsigned)(s->hash_size-1)*sizeof(*s->head));++/* ========================================================================= */+int ZEXPORT deflateInit_(strm, level, version, stream_size)+ z_streamp strm;+ int level;+ const char *version;+ int stream_size;+{+ return deflateInit2_(strm, level, Z_DEFLATED, MAX_WBITS, DEF_MEM_LEVEL,+ Z_DEFAULT_STRATEGY, version, stream_size);+ /* To do: ignore strm->next_in if we use it as window */+}++/* ========================================================================= */+int ZEXPORT deflateInit2_(strm, level, method, windowBits, memLevel, strategy,+ version, stream_size)+ z_streamp strm;+ int level;+ int method;+ int windowBits;+ int memLevel;+ int strategy;+ const char *version;+ int stream_size;+{+ deflate_state *s;+ int wrap = 1;+ static const char my_version[] = ZLIB_VERSION;++ ushf *overlay;+ /* We overlay pending_buf and d_buf+l_buf. This works since the average+ * output size for (length,distance) codes is <= 24 bits.+ */++ if (version == Z_NULL || version[0] != my_version[0] ||+ stream_size != sizeof(z_stream)) {+ return Z_VERSION_ERROR;+ }+ if (strm == Z_NULL) return Z_STREAM_ERROR;++ strm->msg = Z_NULL;+ if (strm->zalloc == (alloc_func)0) {+ strm->zalloc = zcalloc;+ strm->opaque = (voidpf)0;+ }+ if (strm->zfree == (free_func)0) strm->zfree = zcfree;++#ifdef FASTEST+ if (level != 0) level = 1;+#else+ if (level == Z_DEFAULT_COMPRESSION) level = 6;+#endif++ if (windowBits < 0) { /* suppress zlib wrapper */+ wrap = 0;+ windowBits = -windowBits;+ }+#ifdef GZIP+ else if (windowBits > 15) {+ wrap = 2; /* write gzip wrapper instead */+ windowBits -= 16;+ }+#endif+ if (memLevel < 1 || memLevel > MAX_MEM_LEVEL || method != Z_DEFLATED ||+ windowBits < 8 || windowBits > 15 || level < 0 || level > 9 ||+ strategy < 0 || strategy > Z_FIXED) {+ return Z_STREAM_ERROR;+ }+ if (windowBits == 8) windowBits = 9; /* until 256-byte window bug fixed */+ s = (deflate_state *) ZALLOC(strm, 1, sizeof(deflate_state));+ if (s == Z_NULL) return Z_MEM_ERROR;+ strm->state = (struct internal_state FAR *)s;+ s->strm = strm;++ s->wrap = wrap;+ s->gzhead = Z_NULL;+ s->w_bits = windowBits;+ s->w_size = 1 << s->w_bits;+ s->w_mask = s->w_size - 1;++ s->hash_bits = memLevel + 7;+ s->hash_size = 1 << s->hash_bits;+ s->hash_mask = s->hash_size - 1;+ s->hash_shift = ((s->hash_bits+MIN_MATCH-1)/MIN_MATCH);++ s->window = (Bytef *) ZALLOC(strm, s->w_size, 2*sizeof(Byte));+ s->prev = (Posf *) ZALLOC(strm, s->w_size, sizeof(Pos));+ s->head = (Posf *) ZALLOC(strm, s->hash_size, sizeof(Pos));++ s->lit_bufsize = 1 << (memLevel + 6); /* 16K elements by default */++ overlay = (ushf *) ZALLOC(strm, s->lit_bufsize, sizeof(ush)+2);+ s->pending_buf = (uchf *) overlay;+ s->pending_buf_size = (ulg)s->lit_bufsize * (sizeof(ush)+2L);++ if (s->window == Z_NULL || s->prev == Z_NULL || s->head == Z_NULL ||+ s->pending_buf == Z_NULL) {+ s->status = FINISH_STATE;+ strm->msg = (char*)ERR_MSG(Z_MEM_ERROR);+ deflateEnd (strm);+ return Z_MEM_ERROR;+ }+ s->d_buf = overlay + s->lit_bufsize/sizeof(ush);+ s->l_buf = s->pending_buf + (1+sizeof(ush))*s->lit_bufsize;++ s->level = level;+ s->strategy = strategy;+ s->method = (Byte)method;++ return deflateReset(strm);+}++/* ========================================================================= */+int ZEXPORT deflateSetDictionary (strm, dictionary, dictLength)+ z_streamp strm;+ const Bytef *dictionary;+ uInt dictLength;+{+ deflate_state *s;+ uInt length = dictLength;+ uInt n;+ IPos hash_head = 0;++ if (strm == Z_NULL || strm->state == Z_NULL || dictionary == Z_NULL ||+ strm->state->wrap == 2 ||+ (strm->state->wrap == 1 && strm->state->status != INIT_STATE))+ return Z_STREAM_ERROR;++ s = strm->state;+ if (s->wrap)+ strm->adler = adler32(strm->adler, dictionary, dictLength);++ if (length < MIN_MATCH) return Z_OK;+ if (length > MAX_DIST(s)) {+ length = MAX_DIST(s);+ dictionary += dictLength - length; /* use the tail of the dictionary */+ }+ zmemcpy(s->window, dictionary, length);+ s->strstart = length;+ s->block_start = (long)length;++ /* Insert all strings in the hash table (except for the last two bytes).+ * s->lookahead stays null, so s->ins_h will be recomputed at the next+ * call of fill_window.+ */+ s->ins_h = s->window[0];+ UPDATE_HASH(s, s->ins_h, s->window[1]);+ for (n = 0; n <= length - MIN_MATCH; n++) {+ INSERT_STRING(s, n, hash_head);+ }+ if (hash_head) hash_head = 0; /* to make compiler happy */+ return Z_OK;+}++/* ========================================================================= */+int ZEXPORT deflateReset (strm)+ z_streamp strm;+{+ deflate_state *s;++ if (strm == Z_NULL || strm->state == Z_NULL ||+ strm->zalloc == (alloc_func)0 || strm->zfree == (free_func)0) {+ return Z_STREAM_ERROR;+ }++ strm->total_in = strm->total_out = 0;+ strm->msg = Z_NULL; /* use zfree if we ever allocate msg dynamically */+ strm->data_type = Z_UNKNOWN;++ s = (deflate_state *)strm->state;+ s->pending = 0;+ s->pending_out = s->pending_buf;++ if (s->wrap < 0) {+ s->wrap = -s->wrap; /* was made negative by deflate(..., Z_FINISH); */+ }+ s->status = s->wrap ? INIT_STATE : BUSY_STATE;+ strm->adler =+#ifdef GZIP+ s->wrap == 2 ? crc32(0L, Z_NULL, 0) :+#endif+ adler32(0L, Z_NULL, 0);+ s->last_flush = Z_NO_FLUSH;++ _tr_init(s);+ lm_init(s);++ return Z_OK;+}++/* ========================================================================= */+int ZEXPORT deflateSetHeader (strm, head)+ z_streamp strm;+ gz_headerp head;+{+ if (strm == Z_NULL || strm->state == Z_NULL) return Z_STREAM_ERROR;+ if (strm->state->wrap != 2) return Z_STREAM_ERROR;+ strm->state->gzhead = head;+ return Z_OK;+}++/* ========================================================================= */+int ZEXPORT deflatePrime (strm, bits, value)+ z_streamp strm;+ int bits;+ int value;+{+ if (strm == Z_NULL || strm->state == Z_NULL) return Z_STREAM_ERROR;+ strm->state->bi_valid = bits;+ strm->state->bi_buf = (ush)(value & ((1 << bits) - 1));+ return Z_OK;+}++/* ========================================================================= */+int ZEXPORT deflateParams(strm, level, strategy)+ z_streamp strm;+ int level;+ int strategy;+{+ deflate_state *s;+ compress_func func;+ int err = Z_OK;++ if (strm == Z_NULL || strm->state == Z_NULL) return Z_STREAM_ERROR;+ s = strm->state;++#ifdef FASTEST+ if (level != 0) level = 1;+#else+ if (level == Z_DEFAULT_COMPRESSION) level = 6;+#endif+ if (level < 0 || level > 9 || strategy < 0 || strategy > Z_FIXED) {+ return Z_STREAM_ERROR;+ }+ func = configuration_table[s->level].func;++ if (func != configuration_table[level].func && strm->total_in != 0) {+ /* Flush the last buffer: */+ err = deflate(strm, Z_PARTIAL_FLUSH);+ }+ if (s->level != level) {+ s->level = level;+ s->max_lazy_match = configuration_table[level].max_lazy;+ s->good_match = configuration_table[level].good_length;+ s->nice_match = configuration_table[level].nice_length;+ s->max_chain_length = configuration_table[level].max_chain;+ }+ s->strategy = strategy;+ return err;+}++/* ========================================================================= */+int ZEXPORT deflateTune(strm, good_length, max_lazy, nice_length, max_chain)+ z_streamp strm;+ int good_length;+ int max_lazy;+ int nice_length;+ int max_chain;+{+ deflate_state *s;++ if (strm == Z_NULL || strm->state == Z_NULL) return Z_STREAM_ERROR;+ s = strm->state;+ s->good_match = good_length;+ s->max_lazy_match = max_lazy;+ s->nice_match = nice_length;+ s->max_chain_length = max_chain;+ return Z_OK;+}++/* =========================================================================+ * For the default windowBits of 15 and memLevel of 8, this function returns+ * a close to exact, as well as small, upper bound on the compressed size.+ * They are coded as constants here for a reason--if the #define's are+ * changed, then this function needs to be changed as well. The return+ * value for 15 and 8 only works for those exact settings.+ *+ * For any setting other than those defaults for windowBits and memLevel,+ * the value returned is a conservative worst case for the maximum expansion+ * resulting from using fixed blocks instead of stored blocks, which deflate+ * can emit on compressed data for some combinations of the parameters.+ *+ * This function could be more sophisticated to provide closer upper bounds+ * for every combination of windowBits and memLevel, as well as wrap.+ * But even the conservative upper bound of about 14% expansion does not+ * seem onerous for output buffer allocation.+ */+uLong ZEXPORT deflateBound(strm, sourceLen)+ z_streamp strm;+ uLong sourceLen;+{+ deflate_state *s;+ uLong destLen;++ /* conservative upper bound */+ destLen = sourceLen ++ ((sourceLen + 7) >> 3) + ((sourceLen + 63) >> 6) + 11;++ /* if can't get parameters, return conservative bound */+ if (strm == Z_NULL || strm->state == Z_NULL)+ return destLen;++ /* if not default parameters, return conservative bound */+ s = strm->state;+ if (s->w_bits != 15 || s->hash_bits != 8 + 7)+ return destLen;++ /* default settings: return tight bound for that case */+ return compressBound(sourceLen);+}++/* =========================================================================+ * Put a short in the pending buffer. The 16-bit value is put in MSB order.+ * IN assertion: the stream state is correct and there is enough room in+ * pending_buf.+ */+local void putShortMSB (s, b)+ deflate_state *s;+ uInt b;+{+ put_byte(s, (Byte)(b >> 8));+ put_byte(s, (Byte)(b & 0xff));+}++/* =========================================================================+ * Flush as much pending output as possible. All deflate() output goes+ * through this function so some applications may wish to modify it+ * to avoid allocating a large strm->next_out buffer and copying into it.+ * (See also read_buf()).+ */+local void flush_pending(strm)+ z_streamp strm;+{+ unsigned len = strm->state->pending;++ if (len > strm->avail_out) len = strm->avail_out;+ if (len == 0) return;++ zmemcpy(strm->next_out, strm->state->pending_out, len);+ strm->next_out += len;+ strm->state->pending_out += len;+ strm->total_out += len;+ strm->avail_out -= len;+ strm->state->pending -= len;+ if (strm->state->pending == 0) {+ strm->state->pending_out = strm->state->pending_buf;+ }+}++/* ========================================================================= */+int ZEXPORT deflate (strm, flush)+ z_streamp strm;+ int flush;+{+ int old_flush; /* value of flush param for previous deflate call */+ deflate_state *s;++ if (strm == Z_NULL || strm->state == Z_NULL ||+ flush > Z_FINISH || flush < 0) {+ return Z_STREAM_ERROR;+ }+ s = strm->state;++ if (strm->next_out == Z_NULL ||+ (strm->next_in == Z_NULL && strm->avail_in != 0) ||+ (s->status == FINISH_STATE && flush != Z_FINISH)) {+ ERR_RETURN(strm, Z_STREAM_ERROR);+ }+ if (strm->avail_out == 0) ERR_RETURN(strm, Z_BUF_ERROR);++ s->strm = strm; /* just in case */+ old_flush = s->last_flush;+ s->last_flush = flush;++ /* Write the header */+ if (s->status == INIT_STATE) {+#ifdef GZIP+ if (s->wrap == 2) {+ strm->adler = crc32(0L, Z_NULL, 0);+ put_byte(s, 31);+ put_byte(s, 139);+ put_byte(s, 8);+ if (s->gzhead == NULL) {+ put_byte(s, 0);+ put_byte(s, 0);+ put_byte(s, 0);+ put_byte(s, 0);+ put_byte(s, 0);+ put_byte(s, s->level == 9 ? 2 :+ (s->strategy >= Z_HUFFMAN_ONLY || s->level < 2 ?+ 4 : 0));+ put_byte(s, OS_CODE);+ s->status = BUSY_STATE;+ }+ else {+ put_byte(s, (s->gzhead->text ? 1 : 0) ++ (s->gzhead->hcrc ? 2 : 0) ++ (s->gzhead->extra == Z_NULL ? 0 : 4) ++ (s->gzhead->name == Z_NULL ? 0 : 8) ++ (s->gzhead->comment == Z_NULL ? 0 : 16)+ );+ put_byte(s, (Byte)(s->gzhead->time & 0xff));+ put_byte(s, (Byte)((s->gzhead->time >> 8) & 0xff));+ put_byte(s, (Byte)((s->gzhead->time >> 16) & 0xff));+ put_byte(s, (Byte)((s->gzhead->time >> 24) & 0xff));+ put_byte(s, s->level == 9 ? 2 :+ (s->strategy >= Z_HUFFMAN_ONLY || s->level < 2 ?+ 4 : 0));+ put_byte(s, s->gzhead->os & 0xff);+ if (s->gzhead->extra != NULL) {+ put_byte(s, s->gzhead->extra_len & 0xff);+ put_byte(s, (s->gzhead->extra_len >> 8) & 0xff);+ }+ if (s->gzhead->hcrc)+ strm->adler = crc32(strm->adler, s->pending_buf,+ s->pending);+ s->gzindex = 0;+ s->status = EXTRA_STATE;+ }+ }+ else+#endif+ {+ uInt header = (Z_DEFLATED + ((s->w_bits-8)<<4)) << 8;+ uInt level_flags;++ if (s->strategy >= Z_HUFFMAN_ONLY || s->level < 2)+ level_flags = 0;+ else if (s->level < 6)+ level_flags = 1;+ else if (s->level == 6)+ level_flags = 2;+ else+ level_flags = 3;+ header |= (level_flags << 6);+ if (s->strstart != 0) header |= PRESET_DICT;+ header += 31 - (header % 31);++ s->status = BUSY_STATE;+ putShortMSB(s, header);++ /* Save the adler32 of the preset dictionary: */+ if (s->strstart != 0) {+ putShortMSB(s, (uInt)(strm->adler >> 16));+ putShortMSB(s, (uInt)(strm->adler & 0xffff));+ }+ strm->adler = adler32(0L, Z_NULL, 0);+ }+ }+#ifdef GZIP+ if (s->status == EXTRA_STATE) {+ if (s->gzhead->extra != NULL) {+ uInt beg = s->pending; /* start of bytes to update crc */++ while (s->gzindex < (s->gzhead->extra_len & 0xffff)) {+ if (s->pending == s->pending_buf_size) {+ if (s->gzhead->hcrc && s->pending > beg)+ strm->adler = crc32(strm->adler, s->pending_buf + beg,+ s->pending - beg);+ flush_pending(strm);+ beg = s->pending;+ if (s->pending == s->pending_buf_size)+ break;+ }+ put_byte(s, s->gzhead->extra[s->gzindex]);+ s->gzindex++;+ }+ if (s->gzhead->hcrc && s->pending > beg)+ strm->adler = crc32(strm->adler, s->pending_buf + beg,+ s->pending - beg);+ if (s->gzindex == s->gzhead->extra_len) {+ s->gzindex = 0;+ s->status = NAME_STATE;+ }+ }+ else+ s->status = NAME_STATE;+ }+ if (s->status == NAME_STATE) {+ if (s->gzhead->name != NULL) {+ uInt beg = s->pending; /* start of bytes to update crc */+ int val;++ do {+ if (s->pending == s->pending_buf_size) {+ if (s->gzhead->hcrc && s->pending > beg)+ strm->adler = crc32(strm->adler, s->pending_buf + beg,+ s->pending - beg);+ flush_pending(strm);+ beg = s->pending;+ if (s->pending == s->pending_buf_size) {+ val = 1;+ break;+ }+ }+ val = s->gzhead->name[s->gzindex++];+ put_byte(s, val);+ } while (val != 0);+ if (s->gzhead->hcrc && s->pending > beg)+ strm->adler = crc32(strm->adler, s->pending_buf + beg,+ s->pending - beg);+ if (val == 0) {+ s->gzindex = 0;+ s->status = COMMENT_STATE;+ }+ }+ else+ s->status = COMMENT_STATE;+ }+ if (s->status == COMMENT_STATE) {+ if (s->gzhead->comment != NULL) {+ uInt beg = s->pending; /* start of bytes to update crc */+ int val;++ do {+ if (s->pending == s->pending_buf_size) {+ if (s->gzhead->hcrc && s->pending > beg)+ strm->adler = crc32(strm->adler, s->pending_buf + beg,+ s->pending - beg);+ flush_pending(strm);+ beg = s->pending;+ if (s->pending == s->pending_buf_size) {+ val = 1;+ break;+ }+ }+ val = s->gzhead->comment[s->gzindex++];+ put_byte(s, val);+ } while (val != 0);+ if (s->gzhead->hcrc && s->pending > beg)+ strm->adler = crc32(strm->adler, s->pending_buf + beg,+ s->pending - beg);+ if (val == 0)+ s->status = HCRC_STATE;+ }+ else+ s->status = HCRC_STATE;+ }+ if (s->status == HCRC_STATE) {+ if (s->gzhead->hcrc) {+ if (s->pending + 2 > s->pending_buf_size)+ flush_pending(strm);+ if (s->pending + 2 <= s->pending_buf_size) {+ put_byte(s, (Byte)(strm->adler & 0xff));+ put_byte(s, (Byte)((strm->adler >> 8) & 0xff));+ strm->adler = crc32(0L, Z_NULL, 0);+ s->status = BUSY_STATE;+ }+ }+ else+ s->status = BUSY_STATE;+ }+#endif++ /* Flush as much pending output as possible */+ if (s->pending != 0) {+ flush_pending(strm);+ if (strm->avail_out == 0) {+ /* Since avail_out is 0, deflate will be called again with+ * more output space, but possibly with both pending and+ * avail_in equal to zero. There won't be anything to do,+ * but this is not an error situation so make sure we+ * return OK instead of BUF_ERROR at next call of deflate:+ */+ s->last_flush = -1;+ return Z_OK;+ }++ /* Make sure there is something to do and avoid duplicate consecutive+ * flushes. For repeated and useless calls with Z_FINISH, we keep+ * returning Z_STREAM_END instead of Z_BUF_ERROR.+ */+ } else if (strm->avail_in == 0 && flush <= old_flush &&+ flush != Z_FINISH) {+ ERR_RETURN(strm, Z_BUF_ERROR);+ }++ /* User must not provide more input after the first FINISH: */+ if (s->status == FINISH_STATE && strm->avail_in != 0) {+ ERR_RETURN(strm, Z_BUF_ERROR);+ }++ /* Start a new block or continue the current one.+ */+ if (strm->avail_in != 0 || s->lookahead != 0 ||+ (flush != Z_NO_FLUSH && s->status != FINISH_STATE)) {+ block_state bstate;++ bstate = (*(configuration_table[s->level].func))(s, flush);++ if (bstate == finish_started || bstate == finish_done) {+ s->status = FINISH_STATE;+ }+ if (bstate == need_more || bstate == finish_started) {+ if (strm->avail_out == 0) {+ s->last_flush = -1; /* avoid BUF_ERROR next call, see above */+ }+ return Z_OK;+ /* If flush != Z_NO_FLUSH && avail_out == 0, the next call+ * of deflate should use the same flush parameter to make sure+ * that the flush is complete. So we don't have to output an+ * empty block here, this will be done at next call. This also+ * ensures that for a very small output buffer, we emit at most+ * one empty block.+ */+ }+ if (bstate == block_done) {+ if (flush == Z_PARTIAL_FLUSH) {+ _tr_align(s);+ } else { /* FULL_FLUSH or SYNC_FLUSH */+ _tr_stored_block(s, (char*)0, 0L, 0);+ /* For a full flush, this empty block will be recognized+ * as a special marker by inflate_sync().+ */+ if (flush == Z_FULL_FLUSH) {+ CLEAR_HASH(s); /* forget history */+ }+ }+ flush_pending(strm);+ if (strm->avail_out == 0) {+ s->last_flush = -1; /* avoid BUF_ERROR at next call, see above */+ return Z_OK;+ }+ }+ }+ Assert(strm->avail_out > 0, "bug2");++ if (flush != Z_FINISH) return Z_OK;+ if (s->wrap <= 0) return Z_STREAM_END;++ /* Write the trailer */+#ifdef GZIP+ if (s->wrap == 2) {+ put_byte(s, (Byte)(strm->adler & 0xff));+ put_byte(s, (Byte)((strm->adler >> 8) & 0xff));+ put_byte(s, (Byte)((strm->adler >> 16) & 0xff));+ put_byte(s, (Byte)((strm->adler >> 24) & 0xff));+ put_byte(s, (Byte)(strm->total_in & 0xff));+ put_byte(s, (Byte)((strm->total_in >> 8) & 0xff));+ put_byte(s, (Byte)((strm->total_in >> 16) & 0xff));+ put_byte(s, (Byte)((strm->total_in >> 24) & 0xff));+ }+ else+#endif+ {+ putShortMSB(s, (uInt)(strm->adler >> 16));+ putShortMSB(s, (uInt)(strm->adler & 0xffff));+ }+ flush_pending(strm);+ /* If avail_out is zero, the application will call deflate again+ * to flush the rest.+ */+ if (s->wrap > 0) s->wrap = -s->wrap; /* write the trailer only once! */+ return s->pending != 0 ? Z_OK : Z_STREAM_END;+}++/* ========================================================================= */+int ZEXPORT deflateEnd (strm)+ z_streamp strm;+{+ int status;++ if (strm == Z_NULL || strm->state == Z_NULL) return Z_STREAM_ERROR;++ status = strm->state->status;+ if (status != INIT_STATE &&+ status != EXTRA_STATE &&+ status != NAME_STATE &&+ status != COMMENT_STATE &&+ status != HCRC_STATE &&+ status != BUSY_STATE &&+ status != FINISH_STATE) {+ return Z_STREAM_ERROR;+ }++ /* Deallocate in reverse order of allocations: */+ TRY_FREE(strm, strm->state->pending_buf);+ TRY_FREE(strm, strm->state->head);+ TRY_FREE(strm, strm->state->prev);+ TRY_FREE(strm, strm->state->window);++ ZFREE(strm, strm->state);+ strm->state = Z_NULL;++ return status == BUSY_STATE ? Z_DATA_ERROR : Z_OK;+}++/* =========================================================================+ * Copy the source state to the destination state.+ * To simplify the source, this is not supported for 16-bit MSDOS (which+ * doesn't have enough memory anyway to duplicate compression states).+ */+int ZEXPORT deflateCopy (dest, source)+ z_streamp dest;+ z_streamp source;+{+#ifdef MAXSEG_64K+ return Z_STREAM_ERROR;+#else+ deflate_state *ds;+ deflate_state *ss;+ ushf *overlay;+++ if (source == Z_NULL || dest == Z_NULL || source->state == Z_NULL) {+ return Z_STREAM_ERROR;+ }++ ss = source->state;++ zmemcpy(dest, source, sizeof(z_stream));++ ds = (deflate_state *) ZALLOC(dest, 1, sizeof(deflate_state));+ if (ds == Z_NULL) return Z_MEM_ERROR;+ dest->state = (struct internal_state FAR *) ds;+ zmemcpy(ds, ss, sizeof(deflate_state));+ ds->strm = dest;++ ds->window = (Bytef *) ZALLOC(dest, ds->w_size, 2*sizeof(Byte));+ ds->prev = (Posf *) ZALLOC(dest, ds->w_size, sizeof(Pos));+ ds->head = (Posf *) ZALLOC(dest, ds->hash_size, sizeof(Pos));+ overlay = (ushf *) ZALLOC(dest, ds->lit_bufsize, sizeof(ush)+2);+ ds->pending_buf = (uchf *) overlay;++ if (ds->window == Z_NULL || ds->prev == Z_NULL || ds->head == Z_NULL ||+ ds->pending_buf == Z_NULL) {+ deflateEnd (dest);+ return Z_MEM_ERROR;+ }+ /* following zmemcpy do not work for 16-bit MSDOS */+ zmemcpy(ds->window, ss->window, ds->w_size * 2 * sizeof(Byte));+ zmemcpy(ds->prev, ss->prev, ds->w_size * sizeof(Pos));+ zmemcpy(ds->head, ss->head, ds->hash_size * sizeof(Pos));+ zmemcpy(ds->pending_buf, ss->pending_buf, (uInt)ds->pending_buf_size);++ ds->pending_out = ds->pending_buf + (ss->pending_out - ss->pending_buf);+ ds->d_buf = overlay + ds->lit_bufsize/sizeof(ush);+ ds->l_buf = ds->pending_buf + (1+sizeof(ush))*ds->lit_bufsize;++ ds->l_desc.dyn_tree = ds->dyn_ltree;+ ds->d_desc.dyn_tree = ds->dyn_dtree;+ ds->bl_desc.dyn_tree = ds->bl_tree;++ return Z_OK;+#endif /* MAXSEG_64K */+}++/* ===========================================================================+ * Read a new buffer from the current input stream, update the adler32+ * and total number of bytes read. All deflate() input goes through+ * this function so some applications may wish to modify it to avoid+ * allocating a large strm->next_in buffer and copying from it.+ * (See also flush_pending()).+ */+local int read_buf(strm, buf, size)+ z_streamp strm;+ Bytef *buf;+ unsigned size;+{+ unsigned len = strm->avail_in;++ if (len > size) len = size;+ if (len == 0) return 0;++ strm->avail_in -= len;++ if (strm->state->wrap == 1) {+ strm->adler = adler32(strm->adler, strm->next_in, len);+ }+#ifdef GZIP+ else if (strm->state->wrap == 2) {+ strm->adler = crc32(strm->adler, strm->next_in, len);+ }+#endif+ zmemcpy(buf, strm->next_in, len);+ strm->next_in += len;+ strm->total_in += len;++ return (int)len;+}++/* ===========================================================================+ * Initialize the "longest match" routines for a new zlib stream+ */+local void lm_init (s)+ deflate_state *s;+{+ s->window_size = (ulg)2L*s->w_size;++ CLEAR_HASH(s);++ /* Set the default configuration parameters:+ */+ s->max_lazy_match = configuration_table[s->level].max_lazy;+ s->good_match = configuration_table[s->level].good_length;+ s->nice_match = configuration_table[s->level].nice_length;+ s->max_chain_length = configuration_table[s->level].max_chain;++ s->strstart = 0;+ s->block_start = 0L;+ s->lookahead = 0;+ s->match_length = s->prev_length = MIN_MATCH-1;+ s->match_available = 0;+ s->ins_h = 0;+#ifndef FASTEST+#ifdef ASMV+ match_init(); /* initialize the asm code */+#endif+#endif+}++#ifndef FASTEST+/* ===========================================================================+ * Set match_start to the longest match starting at the given string and+ * return its length. Matches shorter or equal to prev_length are discarded,+ * in which case the result is equal to prev_length and match_start is+ * garbage.+ * IN assertions: cur_match is the head of the hash chain for the current+ * string (strstart) and its distance is <= MAX_DIST, and prev_length >= 1+ * OUT assertion: the match length is not greater than s->lookahead.+ */+#ifndef ASMV+/* For 80x86 and 680x0, an optimized version will be provided in match.asm or+ * match.S. The code will be functionally equivalent.+ */+local uInt longest_match(s, cur_match)+ deflate_state *s;+ IPos cur_match; /* current match */+{+ unsigned chain_length = s->max_chain_length;/* max hash chain length */+ register Bytef *scan = s->window + s->strstart; /* current string */+ register Bytef *match; /* matched string */+ register int len; /* length of current match */+ int best_len = s->prev_length; /* best match length so far */+ int nice_match = s->nice_match; /* stop if match long enough */+ IPos limit = s->strstart > (IPos)MAX_DIST(s) ?+ s->strstart - (IPos)MAX_DIST(s) : NIL;+ /* Stop when cur_match becomes <= limit. To simplify the code,+ * we prevent matches with the string of window index 0.+ */+ Posf *prev = s->prev;+ uInt wmask = s->w_mask;++#ifdef UNALIGNED_OK+ /* Compare two bytes at a time. Note: this is not always beneficial.+ * Try with and without -DUNALIGNED_OK to check.+ */+ register Bytef *strend = s->window + s->strstart + MAX_MATCH - 1;+ register ush scan_start = *(ushf*)scan;+ register ush scan_end = *(ushf*)(scan+best_len-1);+#else+ register Bytef *strend = s->window + s->strstart + MAX_MATCH;+ register Byte scan_end1 = scan[best_len-1];+ register Byte scan_end = scan[best_len];+#endif++ /* The code is optimized for HASH_BITS >= 8 and MAX_MATCH-2 multiple of 16.+ * It is easy to get rid of this optimization if necessary.+ */+ Assert(s->hash_bits >= 8 && MAX_MATCH == 258, "Code too clever");++ /* Do not waste too much time if we already have a good match: */+ if (s->prev_length >= s->good_match) {+ chain_length >>= 2;+ }+ /* Do not look for matches beyond the end of the input. This is necessary+ * to make deflate deterministic.+ */+ if ((uInt)nice_match > s->lookahead) nice_match = s->lookahead;++ Assert((ulg)s->strstart <= s->window_size-MIN_LOOKAHEAD, "need lookahead");++ do {+ Assert(cur_match < s->strstart, "no future");+ match = s->window + cur_match;++ /* Skip to next match if the match length cannot increase+ * or if the match length is less than 2. Note that the checks below+ * for insufficient lookahead only occur occasionally for performance+ * reasons. Therefore uninitialized memory will be accessed, and+ * conditional jumps will be made that depend on those values.+ * However the length of the match is limited to the lookahead, so+ * the output of deflate is not affected by the uninitialized values.+ */+#if (defined(UNALIGNED_OK) && MAX_MATCH == 258)+ /* This code assumes sizeof(unsigned short) == 2. Do not use+ * UNALIGNED_OK if your compiler uses a different size.+ */+ if (*(ushf*)(match+best_len-1) != scan_end ||+ *(ushf*)match != scan_start) continue;++ /* It is not necessary to compare scan[2] and match[2] since they are+ * always equal when the other bytes match, given that the hash keys+ * are equal and that HASH_BITS >= 8. Compare 2 bytes at a time at+ * strstart+3, +5, ... up to strstart+257. We check for insufficient+ * lookahead only every 4th comparison; the 128th check will be made+ * at strstart+257. If MAX_MATCH-2 is not a multiple of 8, it is+ * necessary to put more guard bytes at the end of the window, or+ * to check more often for insufficient lookahead.+ */+ Assert(scan[2] == match[2], "scan[2]?");+ scan++, match++;+ do {+ } while (*(ushf*)(scan+=2) == *(ushf*)(match+=2) &&+ *(ushf*)(scan+=2) == *(ushf*)(match+=2) &&+ *(ushf*)(scan+=2) == *(ushf*)(match+=2) &&+ *(ushf*)(scan+=2) == *(ushf*)(match+=2) &&+ scan < strend);+ /* The funny "do {}" generates better code on most compilers */++ /* Here, scan <= window+strstart+257 */+ Assert(scan <= s->window+(unsigned)(s->window_size-1), "wild scan");+ if (*scan == *match) scan++;++ len = (MAX_MATCH - 1) - (int)(strend-scan);+ scan = strend - (MAX_MATCH-1);++#else /* UNALIGNED_OK */++ if (match[best_len] != scan_end ||+ match[best_len-1] != scan_end1 ||+ *match != *scan ||+ *++match != scan[1]) continue;++ /* The check at best_len-1 can be removed because it will be made+ * again later. (This heuristic is not always a win.)+ * It is not necessary to compare scan[2] and match[2] since they+ * are always equal when the other bytes match, given that+ * the hash keys are equal and that HASH_BITS >= 8.+ */+ scan += 2, match++;+ Assert(*scan == *match, "match[2]?");++ /* We check for insufficient lookahead only every 8th comparison;+ * the 256th check will be made at strstart+258.+ */+ do {+ } while (*++scan == *++match && *++scan == *++match &&+ *++scan == *++match && *++scan == *++match &&+ *++scan == *++match && *++scan == *++match &&+ *++scan == *++match && *++scan == *++match &&+ scan < strend);++ Assert(scan <= s->window+(unsigned)(s->window_size-1), "wild scan");++ len = MAX_MATCH - (int)(strend - scan);+ scan = strend - MAX_MATCH;++#endif /* UNALIGNED_OK */++ if (len > best_len) {+ s->match_start = cur_match;+ best_len = len;+ if (len >= nice_match) break;+#ifdef UNALIGNED_OK+ scan_end = *(ushf*)(scan+best_len-1);+#else+ scan_end1 = scan[best_len-1];+ scan_end = scan[best_len];+#endif+ }+ } while ((cur_match = prev[cur_match & wmask]) > limit+ && --chain_length != 0);++ if ((uInt)best_len <= s->lookahead) return (uInt)best_len;+ return s->lookahead;+}+#endif /* ASMV */+#endif /* FASTEST */++/* ---------------------------------------------------------------------------+ * Optimized version for level == 1 or strategy == Z_RLE only+ */+local uInt longest_match_fast(s, cur_match)+ deflate_state *s;+ IPos cur_match; /* current match */+{+ register Bytef *scan = s->window + s->strstart; /* current string */+ register Bytef *match; /* matched string */+ register int len; /* length of current match */+ register Bytef *strend = s->window + s->strstart + MAX_MATCH;++ /* The code is optimized for HASH_BITS >= 8 and MAX_MATCH-2 multiple of 16.+ * It is easy to get rid of this optimization if necessary.+ */+ Assert(s->hash_bits >= 8 && MAX_MATCH == 258, "Code too clever");++ Assert((ulg)s->strstart <= s->window_size-MIN_LOOKAHEAD, "need lookahead");++ Assert(cur_match < s->strstart, "no future");++ match = s->window + cur_match;++ /* Return failure if the match length is less than 2:+ */+ if (match[0] != scan[0] || match[1] != scan[1]) return MIN_MATCH-1;++ /* The check at best_len-1 can be removed because it will be made+ * again later. (This heuristic is not always a win.)+ * It is not necessary to compare scan[2] and match[2] since they+ * are always equal when the other bytes match, given that+ * the hash keys are equal and that HASH_BITS >= 8.+ */+ scan += 2, match += 2;+ Assert(*scan == *match, "match[2]?");++ /* We check for insufficient lookahead only every 8th comparison;+ * the 256th check will be made at strstart+258.+ */+ do {+ } while (*++scan == *++match && *++scan == *++match &&+ *++scan == *++match && *++scan == *++match &&+ *++scan == *++match && *++scan == *++match &&+ *++scan == *++match && *++scan == *++match &&+ scan < strend);++ Assert(scan <= s->window+(unsigned)(s->window_size-1), "wild scan");++ len = MAX_MATCH - (int)(strend - scan);++ if (len < MIN_MATCH) return MIN_MATCH - 1;++ s->match_start = cur_match;+ return (uInt)len <= s->lookahead ? (uInt)len : s->lookahead;+}++#ifdef DEBUG+/* ===========================================================================+ * Check that the match at match_start is indeed a match.+ */+local void check_match(s, start, match, length)+ deflate_state *s;+ IPos start, match;+ int length;+{+ /* check that the match is indeed a match */+ if (zmemcmp(s->window + match,+ s->window + start, length) != EQUAL) {+ fprintf(stderr, " start %u, match %u, length %d\n",+ start, match, length);+ do {+ fprintf(stderr, "%c%c", s->window[match++], s->window[start++]);+ } while (--length != 0);+ z_error("invalid match");+ }+ if (z_verbose > 1) {+ fprintf(stderr,"\\[%d,%d]", start-match, length);+ do { putc(s->window[start++], stderr); } while (--length != 0);+ }+}+#else+# define check_match(s, start, match, length)+#endif /* DEBUG */++/* ===========================================================================+ * Fill the window when the lookahead becomes insufficient.+ * Updates strstart and lookahead.+ *+ * IN assertion: lookahead < MIN_LOOKAHEAD+ * OUT assertions: strstart <= window_size-MIN_LOOKAHEAD+ * At least one byte has been read, or avail_in == 0; reads are+ * performed for at least two bytes (required for the zip translate_eol+ * option -- not supported here).+ */+local void fill_window(s)+ deflate_state *s;+{+ register unsigned n, m;+ register Posf *p;+ unsigned more; /* Amount of free space at the end of the window. */+ uInt wsize = s->w_size;++ do {+ more = (unsigned)(s->window_size -(ulg)s->lookahead -(ulg)s->strstart);++ /* Deal with !@#$% 64K limit: */+ if (sizeof(int) <= 2) {+ if (more == 0 && s->strstart == 0 && s->lookahead == 0) {+ more = wsize;++ } else if (more == (unsigned)(-1)) {+ /* Very unlikely, but possible on 16 bit machine if+ * strstart == 0 && lookahead == 1 (input done a byte at time)+ */+ more--;+ }+ }++ /* If the window is almost full and there is insufficient lookahead,+ * move the upper half to the lower one to make room in the upper half.+ */+ if (s->strstart >= wsize+MAX_DIST(s)) {++ zmemcpy(s->window, s->window+wsize, (unsigned)wsize);+ s->match_start -= wsize;+ s->strstart -= wsize; /* we now have strstart >= MAX_DIST */+ s->block_start -= (long) wsize;++ /* Slide the hash table (could be avoided with 32 bit values+ at the expense of memory usage). We slide even when level == 0+ to keep the hash table consistent if we switch back to level > 0+ later. (Using level 0 permanently is not an optimal usage of+ zlib, so we don't care about this pathological case.)+ */+ /* %%% avoid this when Z_RLE */+ n = s->hash_size;+ p = &s->head[n];+ do {+ m = *--p;+ *p = (Pos)(m >= wsize ? m-wsize : NIL);+ } while (--n);++ n = wsize;+#ifndef FASTEST+ p = &s->prev[n];+ do {+ m = *--p;+ *p = (Pos)(m >= wsize ? m-wsize : NIL);+ /* If n is not on any hash chain, prev[n] is garbage but+ * its value will never be used.+ */+ } while (--n);+#endif+ more += wsize;+ }+ if (s->strm->avail_in == 0) return;++ /* If there was no sliding:+ * strstart <= WSIZE+MAX_DIST-1 && lookahead <= MIN_LOOKAHEAD - 1 &&+ * more == window_size - lookahead - strstart+ * => more >= window_size - (MIN_LOOKAHEAD-1 + WSIZE + MAX_DIST-1)+ * => more >= window_size - 2*WSIZE + 2+ * In the BIG_MEM or MMAP case (not yet supported),+ * window_size == input_size + MIN_LOOKAHEAD &&+ * strstart + s->lookahead <= input_size => more >= MIN_LOOKAHEAD.+ * Otherwise, window_size == 2*WSIZE so more >= 2.+ * If there was sliding, more >= WSIZE. So in all cases, more >= 2.+ */+ Assert(more >= 2, "more < 2");++ n = read_buf(s->strm, s->window + s->strstart + s->lookahead, more);+ s->lookahead += n;++ /* Initialize the hash value now that we have some input: */+ if (s->lookahead >= MIN_MATCH) {+ s->ins_h = s->window[s->strstart];+ UPDATE_HASH(s, s->ins_h, s->window[s->strstart+1]);+#if MIN_MATCH != 3+ Call UPDATE_HASH() MIN_MATCH-3 more times+#endif+ }+ /* If the whole input has less than MIN_MATCH bytes, ins_h is garbage,+ * but this is not important since only literal bytes will be emitted.+ */++ } while (s->lookahead < MIN_LOOKAHEAD && s->strm->avail_in != 0);+}++/* ===========================================================================+ * Flush the current block, with given end-of-file flag.+ * IN assertion: strstart is set to the end of the current match.+ */+#define FLUSH_BLOCK_ONLY(s, eof) { \+ _tr_flush_block(s, (s->block_start >= 0L ? \+ (charf *)&s->window[(unsigned)s->block_start] : \+ (charf *)Z_NULL), \+ (ulg)((long)s->strstart - s->block_start), \+ (eof)); \+ s->block_start = s->strstart; \+ flush_pending(s->strm); \+ Tracev((stderr,"[FLUSH]")); \+}++/* Same but force premature exit if necessary. */+#define FLUSH_BLOCK(s, eof) { \+ FLUSH_BLOCK_ONLY(s, eof); \+ if (s->strm->avail_out == 0) return (eof) ? finish_started : need_more; \+}++/* ===========================================================================+ * Copy without compression as much as possible from the input stream, return+ * the current block state.+ * This function does not insert new strings in the dictionary since+ * uncompressible data is probably not useful. This function is used+ * only for the level=0 compression option.+ * NOTE: this function should be optimized to avoid extra copying from+ * window to pending_buf.+ */+local block_state deflate_stored(s, flush)+ deflate_state *s;+ int flush;+{+ /* Stored blocks are limited to 0xffff bytes, pending_buf is limited+ * to pending_buf_size, and each stored block has a 5 byte header:+ */+ ulg max_block_size = 0xffff;+ ulg max_start;++ if (max_block_size > s->pending_buf_size - 5) {+ max_block_size = s->pending_buf_size - 5;+ }++ /* Copy as much as possible from input to output: */+ for (;;) {+ /* Fill the window as much as possible: */+ if (s->lookahead <= 1) {++ Assert(s->strstart < s->w_size+MAX_DIST(s) ||+ s->block_start >= (long)s->w_size, "slide too late");++ fill_window(s);+ if (s->lookahead == 0 && flush == Z_NO_FLUSH) return need_more;++ if (s->lookahead == 0) break; /* flush the current block */+ }+ Assert(s->block_start >= 0L, "block gone");++ s->strstart += s->lookahead;+ s->lookahead = 0;++ /* Emit a stored block if pending_buf will be full: */+ max_start = s->block_start + max_block_size;+ if (s->strstart == 0 || (ulg)s->strstart >= max_start) {+ /* strstart == 0 is possible when wraparound on 16-bit machine */+ s->lookahead = (uInt)(s->strstart - max_start);+ s->strstart = (uInt)max_start;+ FLUSH_BLOCK(s, 0);+ }+ /* Flush if we may have to slide, otherwise block_start may become+ * negative and the data will be gone:+ */+ if (s->strstart - (uInt)s->block_start >= MAX_DIST(s)) {+ FLUSH_BLOCK(s, 0);+ }+ }+ FLUSH_BLOCK(s, flush == Z_FINISH);+ return flush == Z_FINISH ? finish_done : block_done;+}++/* ===========================================================================+ * Compress as much as possible from the input stream, return the current+ * block state.+ * This function does not perform lazy evaluation of matches and inserts+ * new strings in the dictionary only for unmatched strings or for short+ * matches. It is used only for the fast compression options.+ */+local block_state deflate_fast(s, flush)+ deflate_state *s;+ int flush;+{+ IPos hash_head = NIL; /* head of the hash chain */+ int bflush; /* set if current block must be flushed */++ for (;;) {+ /* Make sure that we always have enough lookahead, except+ * at the end of the input file. We need MAX_MATCH bytes+ * for the next match, plus MIN_MATCH bytes to insert the+ * string following the next match.+ */+ if (s->lookahead < MIN_LOOKAHEAD) {+ fill_window(s);+ if (s->lookahead < MIN_LOOKAHEAD && flush == Z_NO_FLUSH) {+ return need_more;+ }+ if (s->lookahead == 0) break; /* flush the current block */+ }++ /* Insert the string window[strstart .. strstart+2] in the+ * dictionary, and set hash_head to the head of the hash chain:+ */+ if (s->lookahead >= MIN_MATCH) {+ INSERT_STRING(s, s->strstart, hash_head);+ }++ /* Find the longest match, discarding those <= prev_length.+ * At this point we have always match_length < MIN_MATCH+ */+ if (hash_head != NIL && s->strstart - hash_head <= MAX_DIST(s)) {+ /* To simplify the code, we prevent matches with the string+ * of window index 0 (in particular we have to avoid a match+ * of the string with itself at the start of the input file).+ */+#ifdef FASTEST+ if ((s->strategy != Z_HUFFMAN_ONLY && s->strategy != Z_RLE) ||+ (s->strategy == Z_RLE && s->strstart - hash_head == 1)) {+ s->match_length = longest_match_fast (s, hash_head);+ }+#else+ if (s->strategy != Z_HUFFMAN_ONLY && s->strategy != Z_RLE) {+ s->match_length = longest_match (s, hash_head);+ } else if (s->strategy == Z_RLE && s->strstart - hash_head == 1) {+ s->match_length = longest_match_fast (s, hash_head);+ }+#endif+ /* longest_match() or longest_match_fast() sets match_start */+ }+ if (s->match_length >= MIN_MATCH) {+ check_match(s, s->strstart, s->match_start, s->match_length);++ _tr_tally_dist(s, s->strstart - s->match_start,+ s->match_length - MIN_MATCH, bflush);++ s->lookahead -= s->match_length;++ /* Insert new strings in the hash table only if the match length+ * is not too large. This saves time but degrades compression.+ */+#ifndef FASTEST+ if (s->match_length <= s->max_insert_length &&+ s->lookahead >= MIN_MATCH) {+ s->match_length--; /* string at strstart already in table */+ do {+ s->strstart++;+ INSERT_STRING(s, s->strstart, hash_head);+ /* strstart never exceeds WSIZE-MAX_MATCH, so there are+ * always MIN_MATCH bytes ahead.+ */+ } while (--s->match_length != 0);+ s->strstart++;+ } else+#endif+ {+ s->strstart += s->match_length;+ s->match_length = 0;+ s->ins_h = s->window[s->strstart];+ UPDATE_HASH(s, s->ins_h, s->window[s->strstart+1]);+#if MIN_MATCH != 3+ Call UPDATE_HASH() MIN_MATCH-3 more times+#endif+ /* If lookahead < MIN_MATCH, ins_h is garbage, but it does not+ * matter since it will be recomputed at next deflate call.+ */+ }+ } else {+ /* No match, output a literal byte */+ Tracevv((stderr,"%c", s->window[s->strstart]));+ _tr_tally_lit (s, s->window[s->strstart], bflush);+ s->lookahead--;+ s->strstart++;+ }+ if (bflush) FLUSH_BLOCK(s, 0);+ }+ FLUSH_BLOCK(s, flush == Z_FINISH);+ return flush == Z_FINISH ? finish_done : block_done;+}++#ifndef FASTEST+/* ===========================================================================+ * Same as above, but achieves better compression. We use a lazy+ * evaluation for matches: a match is finally adopted only if there is+ * no better match at the next window position.+ */+local block_state deflate_slow(s, flush)+ deflate_state *s;+ int flush;+{+ IPos hash_head = NIL; /* head of hash chain */+ int bflush; /* set if current block must be flushed */++ /* Process the input block. */+ for (;;) {+ /* Make sure that we always have enough lookahead, except+ * at the end of the input file. We need MAX_MATCH bytes+ * for the next match, plus MIN_MATCH bytes to insert the+ * string following the next match.+ */+ if (s->lookahead < MIN_LOOKAHEAD) {+ fill_window(s);+ if (s->lookahead < MIN_LOOKAHEAD && flush == Z_NO_FLUSH) {+ return need_more;+ }+ if (s->lookahead == 0) break; /* flush the current block */+ }++ /* Insert the string window[strstart .. strstart+2] in the+ * dictionary, and set hash_head to the head of the hash chain:+ */+ if (s->lookahead >= MIN_MATCH) {+ INSERT_STRING(s, s->strstart, hash_head);+ }++ /* Find the longest match, discarding those <= prev_length.+ */+ s->prev_length = s->match_length, s->prev_match = s->match_start;+ s->match_length = MIN_MATCH-1;++ if (hash_head != NIL && s->prev_length < s->max_lazy_match &&+ s->strstart - hash_head <= MAX_DIST(s)) {+ /* To simplify the code, we prevent matches with the string+ * of window index 0 (in particular we have to avoid a match+ * of the string with itself at the start of the input file).+ */+ if (s->strategy != Z_HUFFMAN_ONLY && s->strategy != Z_RLE) {+ s->match_length = longest_match (s, hash_head);+ } else if (s->strategy == Z_RLE && s->strstart - hash_head == 1) {+ s->match_length = longest_match_fast (s, hash_head);+ }+ /* longest_match() or longest_match_fast() sets match_start */++ if (s->match_length <= 5 && (s->strategy == Z_FILTERED+#if TOO_FAR <= 32767+ || (s->match_length == MIN_MATCH &&+ s->strstart - s->match_start > TOO_FAR)+#endif+ )) {++ /* If prev_match is also MIN_MATCH, match_start is garbage+ * but we will ignore the current match anyway.+ */+ s->match_length = MIN_MATCH-1;+ }+ }+ /* If there was a match at the previous step and the current+ * match is not better, output the previous match:+ */+ if (s->prev_length >= MIN_MATCH && s->match_length <= s->prev_length) {+ uInt max_insert = s->strstart + s->lookahead - MIN_MATCH;+ /* Do not insert strings in hash table beyond this. */++ check_match(s, s->strstart-1, s->prev_match, s->prev_length);++ _tr_tally_dist(s, s->strstart -1 - s->prev_match,+ s->prev_length - MIN_MATCH, bflush);++ /* Insert in hash table all strings up to the end of the match.+ * strstart-1 and strstart are already inserted. If there is not+ * enough lookahead, the last two strings are not inserted in+ * the hash table.+ */+ s->lookahead -= s->prev_length-1;+ s->prev_length -= 2;+ do {+ if (++s->strstart <= max_insert) {+ INSERT_STRING(s, s->strstart, hash_head);+ }+ } while (--s->prev_length != 0);+ s->match_available = 0;+ s->match_length = MIN_MATCH-1;+ s->strstart++;++ if (bflush) FLUSH_BLOCK(s, 0);++ } else if (s->match_available) {+ /* If there was no match at the previous position, output a+ * single literal. If there was a match but the current match+ * is longer, truncate the previous match to a single literal.+ */+ Tracevv((stderr,"%c", s->window[s->strstart-1]));+ _tr_tally_lit(s, s->window[s->strstart-1], bflush);+ if (bflush) {+ FLUSH_BLOCK_ONLY(s, 0);+ }+ s->strstart++;+ s->lookahead--;+ if (s->strm->avail_out == 0) return need_more;+ } else {+ /* There is no previous match to compare with, wait for+ * the next step to decide.+ */+ s->match_available = 1;+ s->strstart++;+ s->lookahead--;+ }+ }+ Assert (flush != Z_NO_FLUSH, "no flush?");+ if (s->match_available) {+ Tracevv((stderr,"%c", s->window[s->strstart-1]));+ _tr_tally_lit(s, s->window[s->strstart-1], bflush);+ s->match_available = 0;+ }+ FLUSH_BLOCK(s, flush == Z_FINISH);+ return flush == Z_FINISH ? finish_done : block_done;+}+#endif /* FASTEST */++#if 0+/* ===========================================================================+ * For Z_RLE, simply look for runs of bytes, generate matches only of distance+ * one. Do not maintain a hash table. (It will be regenerated if this run of+ * deflate switches away from Z_RLE.)+ */+local block_state deflate_rle(s, flush)+ deflate_state *s;+ int flush;+{+ int bflush; /* set if current block must be flushed */+ uInt run; /* length of run */+ uInt max; /* maximum length of run */+ uInt prev; /* byte at distance one to match */+ Bytef *scan; /* scan for end of run */++ for (;;) {+ /* Make sure that we always have enough lookahead, except+ * at the end of the input file. We need MAX_MATCH bytes+ * for the longest encodable run.+ */+ if (s->lookahead < MAX_MATCH) {+ fill_window(s);+ if (s->lookahead < MAX_MATCH && flush == Z_NO_FLUSH) {+ return need_more;+ }+ if (s->lookahead == 0) break; /* flush the current block */+ }++ /* See how many times the previous byte repeats */+ run = 0;+ if (s->strstart > 0) { /* if there is a previous byte, that is */+ max = s->lookahead < MAX_MATCH ? s->lookahead : MAX_MATCH;+ scan = s->window + s->strstart - 1;+ prev = *scan++;+ do {+ if (*scan++ != prev)+ break;+ } while (++run < max);+ }++ /* Emit match if have run of MIN_MATCH or longer, else emit literal */+ if (run >= MIN_MATCH) {+ check_match(s, s->strstart, s->strstart - 1, run);+ _tr_tally_dist(s, 1, run - MIN_MATCH, bflush);+ s->lookahead -= run;+ s->strstart += run;+ } else {+ /* No match, output a literal byte */+ Tracevv((stderr,"%c", s->window[s->strstart]));+ _tr_tally_lit (s, s->window[s->strstart], bflush);+ s->lookahead--;+ s->strstart++;+ }+ if (bflush) FLUSH_BLOCK(s, 0);+ }+ FLUSH_BLOCK(s, flush == Z_FINISH);+ return flush == Z_FINISH ? finish_done : block_done;+}+#endif
+ cbits/gzio.c view
@@ -0,0 +1,1026 @@+/* gzio.c -- IO on .gz files+ * Copyright (C) 1995-2005 Jean-loup Gailly.+ * For conditions of distribution and use, see copyright notice in zlib.h+ *+ * Compile this file with -DNO_GZCOMPRESS to avoid the compression code.+ */++/* @(#) $Id$ */++#include <stdio.h>++#include "zutil.h"++#ifdef NO_DEFLATE /* for compatibility with old definition */+# define NO_GZCOMPRESS+#endif++#ifndef NO_DUMMY_DECL+struct internal_state {int dummy;}; /* for buggy compilers */+#endif++#ifndef Z_BUFSIZE+# ifdef MAXSEG_64K+# define Z_BUFSIZE 4096 /* minimize memory usage for 16-bit DOS */+# else+# define Z_BUFSIZE 16384+# endif+#endif+#ifndef Z_PRINTF_BUFSIZE+# define Z_PRINTF_BUFSIZE 4096+#endif++#ifdef __MVS__+# pragma map (fdopen , "\174\174FDOPEN")+ FILE *fdopen(int, const char *);+#endif++#ifndef STDC+extern voidp malloc OF((uInt size));+extern void free OF((voidpf ptr));+#endif++#define ALLOC(size) malloc(size)+#define TRYFREE(p) {if (p) free(p);}++static int const gz_magic[2] = {0x1f, 0x8b}; /* gzip magic header */++/* gzip flag byte */+#define ASCII_FLAG 0x01 /* bit 0 set: file probably ascii text */+#define HEAD_CRC 0x02 /* bit 1 set: header CRC present */+#define EXTRA_FIELD 0x04 /* bit 2 set: extra field present */+#define ORIG_NAME 0x08 /* bit 3 set: original file name present */+#define COMMENT 0x10 /* bit 4 set: file comment present */+#define RESERVED 0xE0 /* bits 5..7: reserved */++typedef struct gz_stream {+ z_stream stream;+ int z_err; /* error code for last stream operation */+ int z_eof; /* set if end of input file */+ FILE *file; /* .gz file */+ Byte *inbuf; /* input buffer */+ Byte *outbuf; /* output buffer */+ uLong crc; /* crc32 of uncompressed data */+ char *msg; /* error message */+ char *path; /* path name for debugging only */+ int transparent; /* 1 if input file is not a .gz file */+ char mode; /* 'w' or 'r' */+ z_off_t start; /* start of compressed data in file (header skipped) */+ z_off_t in; /* bytes into deflate or inflate */+ z_off_t out; /* bytes out of deflate or inflate */+ int back; /* one character push-back */+ int last; /* true if push-back is last character */+} gz_stream;+++local gzFile gz_open OF((const char *path, const char *mode, int fd));+local int do_flush OF((gzFile file, int flush));+local int get_byte OF((gz_stream *s));+local void check_header OF((gz_stream *s));+local int destroy OF((gz_stream *s));+local void putLong OF((FILE *file, uLong x));+local uLong getLong OF((gz_stream *s));++/* ===========================================================================+ Opens a gzip (.gz) file for reading or writing. The mode parameter+ is as in fopen ("rb" or "wb"). The file is given either by file descriptor+ or path name (if fd == -1).+ gz_open 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).+*/+local gzFile gz_open (path, mode, fd)+ const char *path;+ const char *mode;+ int fd;+{+ int err;+ int level = Z_DEFAULT_COMPRESSION; /* compression level */+ int strategy = Z_DEFAULT_STRATEGY; /* compression strategy */+ char *p = (char*)mode;+ gz_stream *s;+ char fmode[80]; /* copy of mode, without the compression level */+ char *m = fmode;++ if (!path || !mode) return Z_NULL;++ s = (gz_stream *)ALLOC(sizeof(gz_stream));+ if (!s) return Z_NULL;++ s->stream.zalloc = (alloc_func)0;+ s->stream.zfree = (free_func)0;+ s->stream.opaque = (voidpf)0;+ s->stream.next_in = s->inbuf = Z_NULL;+ s->stream.next_out = s->outbuf = Z_NULL;+ s->stream.avail_in = s->stream.avail_out = 0;+ s->file = NULL;+ s->z_err = Z_OK;+ s->z_eof = 0;+ s->in = 0;+ s->out = 0;+ s->back = EOF;+ s->crc = crc32(0L, Z_NULL, 0);+ s->msg = NULL;+ s->transparent = 0;++ s->path = (char*)ALLOC(strlen(path)+1);+ if (s->path == NULL) {+ return destroy(s), (gzFile)Z_NULL;+ }+ strcpy(s->path, path); /* do this early for debugging */++ s->mode = '\0';+ do {+ if (*p == 'r') s->mode = 'r';+ if (*p == 'w' || *p == 'a') s->mode = 'w';+ if (*p >= '0' && *p <= '9') {+ level = *p - '0';+ } else if (*p == 'f') {+ strategy = Z_FILTERED;+ } else if (*p == 'h') {+ strategy = Z_HUFFMAN_ONLY;+ } else if (*p == 'R') {+ strategy = Z_RLE;+ } else {+ *m++ = *p; /* copy the mode */+ }+ } while (*p++ && m != fmode + sizeof(fmode));+ if (s->mode == '\0') return destroy(s), (gzFile)Z_NULL;++ if (s->mode == 'w') {+#ifdef NO_GZCOMPRESS+ err = Z_STREAM_ERROR;+#else+ err = deflateInit2(&(s->stream), level,+ Z_DEFLATED, -MAX_WBITS, DEF_MEM_LEVEL, strategy);+ /* windowBits is passed < 0 to suppress zlib header */++ s->stream.next_out = s->outbuf = (Byte*)ALLOC(Z_BUFSIZE);+#endif+ if (err != Z_OK || s->outbuf == Z_NULL) {+ return destroy(s), (gzFile)Z_NULL;+ }+ } else {+ s->stream.next_in = s->inbuf = (Byte*)ALLOC(Z_BUFSIZE);++ err = inflateInit2(&(s->stream), -MAX_WBITS);+ /* windowBits is passed < 0 to tell that there is no zlib header.+ * Note that in this case inflate *requires* an extra "dummy" byte+ * after the compressed stream in order to complete decompression and+ * return Z_STREAM_END. Here the gzip CRC32 ensures that 4 bytes are+ * present after the compressed stream.+ */+ if (err != Z_OK || s->inbuf == Z_NULL) {+ return destroy(s), (gzFile)Z_NULL;+ }+ }+ s->stream.avail_out = Z_BUFSIZE;++ errno = 0;+ s->file = fd < 0 ? F_OPEN(path, fmode) : (FILE*)fdopen(fd, fmode);++ if (s->file == NULL) {+ return destroy(s), (gzFile)Z_NULL;+ }+ if (s->mode == 'w') {+ /* Write a very simple .gz header:+ */+ fprintf(s->file, "%c%c%c%c%c%c%c%c%c%c", gz_magic[0], gz_magic[1],+ Z_DEFLATED, 0 /*flags*/, 0,0,0,0 /*time*/, 0 /*xflags*/, OS_CODE);+ s->start = 10L;+ /* We use 10L instead of ftell(s->file) to because ftell causes an+ * fflush on some systems. This version of the library doesn't use+ * start anyway in write mode, so this initialization is not+ * necessary.+ */+ } else {+ check_header(s); /* skip the .gz header */+ s->start = ftell(s->file) - s->stream.avail_in;+ }++ return (gzFile)s;+}++/* ===========================================================================+ Opens a gzip (.gz) file for reading or writing.+*/+gzFile ZEXPORT gzopen (path, mode)+ const char *path;+ const char *mode;+{+ return gz_open (path, mode, -1);+}++/* ===========================================================================+ Associate a gzFile with the file descriptor fd. fd is not dup'ed here+ to mimic the behavio(u)r of fdopen.+*/+gzFile ZEXPORT gzdopen (fd, mode)+ int fd;+ const char *mode;+{+ char name[46]; /* allow for up to 128-bit integers */++ if (fd < 0) return (gzFile)Z_NULL;+ sprintf(name, "<fd:%d>", fd); /* for debugging */++ return gz_open (name, mode, fd);+}++/* ===========================================================================+ * Update the compression level and strategy+ */+int ZEXPORT gzsetparams (file, level, strategy)+ gzFile file;+ int level;+ int strategy;+{+ gz_stream *s = (gz_stream*)file;++ if (s == NULL || s->mode != 'w') return Z_STREAM_ERROR;++ /* Make room to allow flushing */+ if (s->stream.avail_out == 0) {++ s->stream.next_out = s->outbuf;+ if (fwrite(s->outbuf, 1, Z_BUFSIZE, s->file) != Z_BUFSIZE) {+ s->z_err = Z_ERRNO;+ }+ s->stream.avail_out = Z_BUFSIZE;+ }++ return deflateParams (&(s->stream), level, strategy);+}++/* ===========================================================================+ Read a byte from a gz_stream; update next_in and avail_in. Return EOF+ for end of file.+ IN assertion: the stream s has been sucessfully opened for reading.+*/+local int get_byte(s)+ gz_stream *s;+{+ if (s->z_eof) return EOF;+ if (s->stream.avail_in == 0) {+ errno = 0;+ s->stream.avail_in = (uInt)fread(s->inbuf, 1, Z_BUFSIZE, s->file);+ if (s->stream.avail_in == 0) {+ s->z_eof = 1;+ if (ferror(s->file)) s->z_err = Z_ERRNO;+ return EOF;+ }+ s->stream.next_in = s->inbuf;+ }+ s->stream.avail_in--;+ return *(s->stream.next_in)++;+}++/* ===========================================================================+ Check the gzip header of a gz_stream opened for reading. Set the stream+ mode to transparent if the gzip magic header is not present; set s->err+ to Z_DATA_ERROR if the magic header is present but the rest of the header+ is incorrect.+ IN assertion: the stream s has already been created sucessfully;+ s->stream.avail_in is zero for the first time, but may be non-zero+ for concatenated .gz files.+*/+local void check_header(s)+ gz_stream *s;+{+ int method; /* method byte */+ int flags; /* flags byte */+ uInt len;+ int c;++ /* Assure two bytes in the buffer so we can peek ahead -- handle case+ where first byte of header is at the end of the buffer after the last+ gzip segment */+ len = s->stream.avail_in;+ if (len < 2) {+ if (len) s->inbuf[0] = s->stream.next_in[0];+ errno = 0;+ len = (uInt)fread(s->inbuf + len, 1, Z_BUFSIZE >> len, s->file);+ if (len == 0 && ferror(s->file)) s->z_err = Z_ERRNO;+ s->stream.avail_in += len;+ s->stream.next_in = s->inbuf;+ if (s->stream.avail_in < 2) {+ s->transparent = s->stream.avail_in;+ return;+ }+ }++ /* Peek ahead to check the gzip magic header */+ if (s->stream.next_in[0] != gz_magic[0] ||+ s->stream.next_in[1] != gz_magic[1]) {+ s->transparent = 1;+ return;+ }+ s->stream.avail_in -= 2;+ s->stream.next_in += 2;++ /* Check the rest of the gzip header */+ method = get_byte(s);+ flags = get_byte(s);+ if (method != Z_DEFLATED || (flags & RESERVED) != 0) {+ s->z_err = Z_DATA_ERROR;+ return;+ }++ /* Discard time, xflags and OS code: */+ for (len = 0; len < 6; len++) (void)get_byte(s);++ if ((flags & EXTRA_FIELD) != 0) { /* skip the extra field */+ len = (uInt)get_byte(s);+ len += ((uInt)get_byte(s))<<8;+ /* len is garbage if EOF but the loop below will quit anyway */+ while (len-- != 0 && get_byte(s) != EOF) ;+ }+ if ((flags & ORIG_NAME) != 0) { /* skip the original file name */+ while ((c = get_byte(s)) != 0 && c != EOF) ;+ }+ if ((flags & COMMENT) != 0) { /* skip the .gz file comment */+ while ((c = get_byte(s)) != 0 && c != EOF) ;+ }+ if ((flags & HEAD_CRC) != 0) { /* skip the header crc */+ for (len = 0; len < 2; len++) (void)get_byte(s);+ }+ s->z_err = s->z_eof ? Z_DATA_ERROR : Z_OK;+}++ /* ===========================================================================+ * Cleanup then free the given gz_stream. Return a zlib error code.+ Try freeing in the reverse order of allocations.+ */+local int destroy (s)+ gz_stream *s;+{+ int err = Z_OK;++ if (!s) return Z_STREAM_ERROR;++ TRYFREE(s->msg);++ if (s->stream.state != NULL) {+ if (s->mode == 'w') {+#ifdef NO_GZCOMPRESS+ err = Z_STREAM_ERROR;+#else+ err = deflateEnd(&(s->stream));+#endif+ } else if (s->mode == 'r') {+ err = inflateEnd(&(s->stream));+ }+ }+ if (s->file != NULL && fclose(s->file)) {+#ifdef ESPIPE+ if (errno != ESPIPE) /* fclose is broken for pipes in HP/UX */+#endif+ err = Z_ERRNO;+ }+ if (s->z_err < 0) err = s->z_err;++ TRYFREE(s->inbuf);+ TRYFREE(s->outbuf);+ TRYFREE(s->path);+ TRYFREE(s);+ return err;+}++/* ===========================================================================+ Reads the given number of uncompressed bytes from the compressed file.+ gzread returns the number of bytes actually read (0 for end of file).+*/+int ZEXPORT gzread (file, buf, len)+ gzFile file;+ voidp buf;+ unsigned len;+{+ gz_stream *s = (gz_stream*)file;+ Bytef *start = (Bytef*)buf; /* starting point for crc computation */+ Byte *next_out; /* == stream.next_out but not forced far (for MSDOS) */++ if (s == NULL || s->mode != 'r') return Z_STREAM_ERROR;++ if (s->z_err == Z_DATA_ERROR || s->z_err == Z_ERRNO) return -1;+ if (s->z_err == Z_STREAM_END) return 0; /* EOF */++ next_out = (Byte*)buf;+ s->stream.next_out = (Bytef*)buf;+ s->stream.avail_out = len;++ if (s->stream.avail_out && s->back != EOF) {+ *next_out++ = s->back;+ s->stream.next_out++;+ s->stream.avail_out--;+ s->back = EOF;+ s->out++;+ start++;+ if (s->last) {+ s->z_err = Z_STREAM_END;+ return 1;+ }+ }++ while (s->stream.avail_out != 0) {++ if (s->transparent) {+ /* Copy first the lookahead bytes: */+ uInt n = s->stream.avail_in;+ if (n > s->stream.avail_out) n = s->stream.avail_out;+ if (n > 0) {+ zmemcpy(s->stream.next_out, s->stream.next_in, n);+ next_out += n;+ s->stream.next_out = next_out;+ s->stream.next_in += n;+ s->stream.avail_out -= n;+ s->stream.avail_in -= n;+ }+ if (s->stream.avail_out > 0) {+ s->stream.avail_out -=+ (uInt)fread(next_out, 1, s->stream.avail_out, s->file);+ }+ len -= s->stream.avail_out;+ s->in += len;+ s->out += len;+ if (len == 0) s->z_eof = 1;+ return (int)len;+ }+ if (s->stream.avail_in == 0 && !s->z_eof) {++ errno = 0;+ s->stream.avail_in = (uInt)fread(s->inbuf, 1, Z_BUFSIZE, s->file);+ if (s->stream.avail_in == 0) {+ s->z_eof = 1;+ if (ferror(s->file)) {+ s->z_err = Z_ERRNO;+ break;+ }+ }+ s->stream.next_in = s->inbuf;+ }+ s->in += s->stream.avail_in;+ s->out += s->stream.avail_out;+ s->z_err = inflate(&(s->stream), Z_NO_FLUSH);+ s->in -= s->stream.avail_in;+ s->out -= s->stream.avail_out;++ if (s->z_err == Z_STREAM_END) {+ /* Check CRC and original size */+ s->crc = crc32(s->crc, start, (uInt)(s->stream.next_out - start));+ start = s->stream.next_out;++ if (getLong(s) != s->crc) {+ s->z_err = Z_DATA_ERROR;+ } else {+ (void)getLong(s);+ /* The uncompressed length returned by above getlong() may be+ * different from s->out in case of concatenated .gz files.+ * Check for such files:+ */+ check_header(s);+ if (s->z_err == Z_OK) {+ inflateReset(&(s->stream));+ s->crc = crc32(0L, Z_NULL, 0);+ }+ }+ }+ if (s->z_err != Z_OK || s->z_eof) break;+ }+ s->crc = crc32(s->crc, start, (uInt)(s->stream.next_out - start));++ if (len == s->stream.avail_out &&+ (s->z_err == Z_DATA_ERROR || s->z_err == Z_ERRNO))+ return -1;+ return (int)(len - s->stream.avail_out);+}+++/* ===========================================================================+ Reads one byte from the compressed file. gzgetc returns this byte+ or -1 in case of end of file or error.+*/+int ZEXPORT gzgetc(file)+ gzFile file;+{+ unsigned char c;++ return gzread(file, &c, 1) == 1 ? c : -1;+}+++/* ===========================================================================+ Push one byte back onto the stream.+*/+int ZEXPORT gzungetc(c, file)+ int c;+ gzFile file;+{+ gz_stream *s = (gz_stream*)file;++ if (s == NULL || s->mode != 'r' || c == EOF || s->back != EOF) return EOF;+ s->back = c;+ s->out--;+ s->last = (s->z_err == Z_STREAM_END);+ if (s->last) s->z_err = Z_OK;+ s->z_eof = 0;+ return c;+}+++/* ===========================================================================+ 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.++ The current implementation is not optimized at all.+*/+char * ZEXPORT gzgets(file, buf, len)+ gzFile file;+ char *buf;+ int len;+{+ char *b = buf;+ if (buf == Z_NULL || len <= 0) return Z_NULL;++ while (--len > 0 && gzread(file, buf, 1) == 1 && *buf++ != '\n') ;+ *buf = '\0';+ return b == buf && len > 0 ? Z_NULL : b;+}+++#ifndef NO_GZCOMPRESS+/* ===========================================================================+ Writes the given number of uncompressed bytes into the compressed file.+ gzwrite returns the number of bytes actually written (0 in case of error).+*/+int ZEXPORT gzwrite (file, buf, len)+ gzFile file;+ voidpc buf;+ unsigned len;+{+ gz_stream *s = (gz_stream*)file;++ if (s == NULL || s->mode != 'w') return Z_STREAM_ERROR;++ s->stream.next_in = (Bytef*)buf;+ s->stream.avail_in = len;++ while (s->stream.avail_in != 0) {++ if (s->stream.avail_out == 0) {++ s->stream.next_out = s->outbuf;+ if (fwrite(s->outbuf, 1, Z_BUFSIZE, s->file) != Z_BUFSIZE) {+ s->z_err = Z_ERRNO;+ break;+ }+ s->stream.avail_out = Z_BUFSIZE;+ }+ s->in += s->stream.avail_in;+ s->out += s->stream.avail_out;+ s->z_err = deflate(&(s->stream), Z_NO_FLUSH);+ s->in -= s->stream.avail_in;+ s->out -= s->stream.avail_out;+ if (s->z_err != Z_OK) break;+ }+ s->crc = crc32(s->crc, (const Bytef *)buf, len);++ return (int)(len - s->stream.avail_in);+}+++/* ===========================================================================+ 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).+*/+#ifdef STDC+#include <stdarg.h>++int ZEXPORTVA gzprintf (gzFile file, const char *format, /* args */ ...)+{+ char buf[Z_PRINTF_BUFSIZE];+ va_list va;+ int len;++ buf[sizeof(buf) - 1] = 0;+ va_start(va, format);+#ifdef NO_vsnprintf+# ifdef HAS_vsprintf_void+ (void)vsprintf(buf, format, va);+ va_end(va);+ for (len = 0; len < sizeof(buf); len++)+ if (buf[len] == 0) break;+# else+ len = vsprintf(buf, format, va);+ va_end(va);+# endif+#else+# ifdef HAS_vsnprintf_void+ (void)vsnprintf(buf, sizeof(buf), format, va);+ va_end(va);+ len = strlen(buf);+# else+ len = vsnprintf(buf, sizeof(buf), format, va);+ va_end(va);+# endif+#endif+ if (len <= 0 || len >= (int)sizeof(buf) || buf[sizeof(buf) - 1] != 0)+ return 0;+ return gzwrite(file, buf, (unsigned)len);+}+#else /* not ANSI C */++int ZEXPORTVA gzprintf (file, format, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10,+ a11, a12, a13, a14, a15, a16, a17, a18, a19, a20)+ gzFile file;+ const char *format;+ int a1, a2, a3, a4, a5, a6, a7, a8, a9, a10,+ a11, a12, a13, a14, a15, a16, a17, a18, a19, a20;+{+ char buf[Z_PRINTF_BUFSIZE];+ int len;++ buf[sizeof(buf) - 1] = 0;+#ifdef NO_snprintf+# ifdef HAS_sprintf_void+ sprintf(buf, format, a1, a2, a3, a4, a5, a6, a7, a8,+ a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20);+ for (len = 0; len < sizeof(buf); len++)+ if (buf[len] == 0) break;+# else+ len = sprintf(buf, format, a1, a2, a3, a4, a5, a6, a7, a8,+ a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20);+# endif+#else+# ifdef HAS_snprintf_void+ snprintf(buf, sizeof(buf), format, a1, a2, a3, a4, a5, a6, a7, a8,+ a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20);+ len = strlen(buf);+# else+ len = snprintf(buf, sizeof(buf), format, a1, a2, a3, a4, a5, a6, a7, a8,+ a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20);+# endif+#endif+ if (len <= 0 || len >= sizeof(buf) || buf[sizeof(buf) - 1] != 0)+ return 0;+ return gzwrite(file, buf, len);+}+#endif++/* ===========================================================================+ Writes c, converted to an unsigned char, into the compressed file.+ gzputc returns the value that was written, or -1 in case of error.+*/+int ZEXPORT gzputc(file, c)+ gzFile file;+ int c;+{+ unsigned char cc = (unsigned char) c; /* required for big endian systems */++ return gzwrite(file, &cc, 1) == 1 ? (int)cc : -1;+}+++/* ===========================================================================+ 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.+*/+int ZEXPORT gzputs(file, s)+ gzFile file;+ const char *s;+{+ return gzwrite(file, (char*)s, (unsigned)strlen(s));+}+++/* ===========================================================================+ Flushes all pending output into the compressed file. The parameter+ flush is as in the deflate() function.+*/+local int do_flush (file, flush)+ gzFile file;+ int flush;+{+ uInt len;+ int done = 0;+ gz_stream *s = (gz_stream*)file;++ if (s == NULL || s->mode != 'w') return Z_STREAM_ERROR;++ s->stream.avail_in = 0; /* should be zero already anyway */++ for (;;) {+ len = Z_BUFSIZE - s->stream.avail_out;++ if (len != 0) {+ if ((uInt)fwrite(s->outbuf, 1, len, s->file) != len) {+ s->z_err = Z_ERRNO;+ return Z_ERRNO;+ }+ s->stream.next_out = s->outbuf;+ s->stream.avail_out = Z_BUFSIZE;+ }+ if (done) break;+ s->out += s->stream.avail_out;+ s->z_err = deflate(&(s->stream), flush);+ s->out -= s->stream.avail_out;++ /* Ignore the second of two consecutive flushes: */+ if (len == 0 && s->z_err == Z_BUF_ERROR) s->z_err = Z_OK;++ /* deflate has finished flushing only when it hasn't used up+ * all the available space in the output buffer:+ */+ done = (s->stream.avail_out != 0 || s->z_err == Z_STREAM_END);++ if (s->z_err != Z_OK && s->z_err != Z_STREAM_END) break;+ }+ return s->z_err == Z_STREAM_END ? Z_OK : s->z_err;+}++int ZEXPORT gzflush (file, flush)+ gzFile file;+ int flush;+{+ gz_stream *s = (gz_stream*)file;+ int err = do_flush (file, flush);++ if (err) return err;+ fflush(s->file);+ return s->z_err == Z_STREAM_END ? Z_OK : s->z_err;+}+#endif /* NO_GZCOMPRESS */++/* ===========================================================================+ Sets the starting position for the next gzread or gzwrite on the given+ compressed file. The offset represents a number of bytes in the+ gzseek returns the resulting offset location as measured in bytes from+ the beginning of the uncompressed stream, or -1 in case of error.+ SEEK_END is not implemented, returns error.+ In this version of the library, gzseek can be extremely slow.+*/+z_off_t ZEXPORT gzseek (file, offset, whence)+ gzFile file;+ z_off_t offset;+ int whence;+{+ gz_stream *s = (gz_stream*)file;++ if (s == NULL || whence == SEEK_END ||+ s->z_err == Z_ERRNO || s->z_err == Z_DATA_ERROR) {+ return -1L;+ }++ if (s->mode == 'w') {+#ifdef NO_GZCOMPRESS+ return -1L;+#else+ if (whence == SEEK_SET) {+ offset -= s->in;+ }+ if (offset < 0) return -1L;++ /* At this point, offset is the number of zero bytes to write. */+ if (s->inbuf == Z_NULL) {+ s->inbuf = (Byte*)ALLOC(Z_BUFSIZE); /* for seeking */+ if (s->inbuf == Z_NULL) return -1L;+ zmemzero(s->inbuf, Z_BUFSIZE);+ }+ while (offset > 0) {+ uInt size = Z_BUFSIZE;+ if (offset < Z_BUFSIZE) size = (uInt)offset;++ size = gzwrite(file, s->inbuf, size);+ if (size == 0) return -1L;++ offset -= size;+ }+ return s->in;+#endif+ }+ /* Rest of function is for reading only */++ /* compute absolute position */+ if (whence == SEEK_CUR) {+ offset += s->out;+ }+ if (offset < 0) return -1L;++ if (s->transparent) {+ /* map to fseek */+ s->back = EOF;+ s->stream.avail_in = 0;+ s->stream.next_in = s->inbuf;+ if (fseek(s->file, offset, SEEK_SET) < 0) return -1L;++ s->in = s->out = offset;+ return offset;+ }++ /* For a negative seek, rewind and use positive seek */+ if (offset >= s->out) {+ offset -= s->out;+ } else if (gzrewind(file) < 0) {+ return -1L;+ }+ /* offset is now the number of bytes to skip. */++ if (offset != 0 && s->outbuf == Z_NULL) {+ s->outbuf = (Byte*)ALLOC(Z_BUFSIZE);+ if (s->outbuf == Z_NULL) return -1L;+ }+ if (offset && s->back != EOF) {+ s->back = EOF;+ s->out++;+ offset--;+ if (s->last) s->z_err = Z_STREAM_END;+ }+ while (offset > 0) {+ int size = Z_BUFSIZE;+ if (offset < Z_BUFSIZE) size = (int)offset;++ size = gzread(file, s->outbuf, (uInt)size);+ if (size <= 0) return -1L;+ offset -= size;+ }+ return s->out;+}++/* ===========================================================================+ Rewinds input file.+*/+int ZEXPORT gzrewind (file)+ gzFile file;+{+ gz_stream *s = (gz_stream*)file;++ if (s == NULL || s->mode != 'r') return -1;++ s->z_err = Z_OK;+ s->z_eof = 0;+ s->back = EOF;+ s->stream.avail_in = 0;+ s->stream.next_in = s->inbuf;+ s->crc = crc32(0L, Z_NULL, 0);+ if (!s->transparent) (void)inflateReset(&s->stream);+ s->in = 0;+ s->out = 0;+ return fseek(s->file, s->start, SEEK_SET);+}++/* ===========================================================================+ 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.+*/+z_off_t ZEXPORT gztell (file)+ gzFile file;+{+ return gzseek(file, 0L, SEEK_CUR);+}++/* ===========================================================================+ Returns 1 when EOF has previously been detected reading the given+ input stream, otherwise zero.+*/+int ZEXPORT gzeof (file)+ gzFile file;+{+ gz_stream *s = (gz_stream*)file;++ /* With concatenated compressed files that can have embedded+ * crc trailers, z_eof is no longer the only/best indicator of EOF+ * on a gz_stream. Handle end-of-stream error explicitly here.+ */+ if (s == NULL || s->mode != 'r') return 0;+ if (s->z_eof) return 1;+ return s->z_err == Z_STREAM_END;+}++/* ===========================================================================+ Returns 1 if reading and doing so transparently, otherwise zero.+*/+int ZEXPORT gzdirect (file)+ gzFile file;+{+ gz_stream *s = (gz_stream*)file;++ if (s == NULL || s->mode != 'r') return 0;+ return s->transparent;+}++/* ===========================================================================+ Outputs a long in LSB order to the given file+*/+local void putLong (file, x)+ FILE *file;+ uLong x;+{+ int n;+ for (n = 0; n < 4; n++) {+ fputc((int)(x & 0xff), file);+ x >>= 8;+ }+}++/* ===========================================================================+ Reads a long in LSB order from the given gz_stream. Sets z_err in case+ of error.+*/+local uLong getLong (s)+ gz_stream *s;+{+ uLong x = (uLong)get_byte(s);+ int c;++ x += ((uLong)get_byte(s))<<8;+ x += ((uLong)get_byte(s))<<16;+ c = get_byte(s);+ if (c == EOF) s->z_err = Z_DATA_ERROR;+ x += ((uLong)c)<<24;+ return x;+}++/* ===========================================================================+ Flushes all pending output if necessary, closes the compressed file+ and deallocates all the (de)compression state.+*/+int ZEXPORT gzclose (file)+ gzFile file;+{+ gz_stream *s = (gz_stream*)file;++ if (s == NULL) return Z_STREAM_ERROR;++ if (s->mode == 'w') {+#ifdef NO_GZCOMPRESS+ return Z_STREAM_ERROR;+#else+ if (do_flush (file, Z_FINISH) != Z_OK)+ return destroy((gz_stream*)file);++ putLong (s->file, s->crc);+ putLong (s->file, (uLong)(s->in & 0xffffffff));+#endif+ }+ return destroy((gz_stream*)file);+}++#ifdef STDC+# define zstrerror(errnum) strerror(errnum)+#else+# define zstrerror(errnum) ""+#endif++/* ===========================================================================+ 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.+*/+const char * ZEXPORT gzerror (file, errnum)+ gzFile file;+ int *errnum;+{+ char *m;+ gz_stream *s = (gz_stream*)file;++ if (s == NULL) {+ *errnum = Z_STREAM_ERROR;+ return (const char*)ERR_MSG(Z_STREAM_ERROR);+ }+ *errnum = s->z_err;+ if (*errnum == Z_OK) return (const char*)"";++ m = (char*)(*errnum == Z_ERRNO ? zstrerror(errno) : s->stream.msg);++ if (m == NULL || *m == '\0') m = (char*)ERR_MSG(s->z_err);++ TRYFREE(s->msg);+ s->msg = (char*)ALLOC(strlen(s->path) + strlen(m) + 3);+ if (s->msg == Z_NULL) return (const char*)ERR_MSG(Z_MEM_ERROR);+ strcpy(s->msg, s->path);+ strcat(s->msg, ": ");+ strcat(s->msg, m);+ return (const char*)s->msg;+}++/* ===========================================================================+ Clear the error and end-of-file flags, and do the same for the real file.+*/+void ZEXPORT gzclearerr (file)+ gzFile file;+{+ gz_stream *s = (gz_stream*)file;++ if (s == NULL) return;+ if (s->z_err != Z_STREAM_END) s->z_err = Z_OK;+ s->z_eof = 0;+ clearerr(s->file);+}
+ cbits/infback.c view
@@ -0,0 +1,623 @@+/* infback.c -- inflate using a call-back interface+ * Copyright (C) 1995-2005 Mark Adler+ * For conditions of distribution and use, see copyright notice in zlib.h+ */++/*+ This code is largely copied from inflate.c. Normally either infback.o or+ inflate.o would be linked into an application--not both. The interface+ with inffast.c is retained so that optimized assembler-coded versions of+ inflate_fast() can be used with either inflate.c or infback.c.+ */++#include "zutil.h"+#include "inftrees.h"+#include "inflate.h"+#include "inffast.h"++/* function prototypes */+local void fixedtables OF((struct inflate_state FAR *state));++/*+ strm provides memory allocation functions in zalloc and zfree, or+ Z_NULL to use the library memory allocation functions.++ windowBits is in the range 8..15, and window is a user-supplied+ window and output buffer that is 2**windowBits bytes.+ */+int ZEXPORT inflateBackInit_(strm, windowBits, window, version, stream_size)+z_streamp strm;+int windowBits;+unsigned char FAR *window;+const char *version;+int stream_size;+{+ struct inflate_state FAR *state;++ if (version == Z_NULL || version[0] != ZLIB_VERSION[0] ||+ stream_size != (int)(sizeof(z_stream)))+ return Z_VERSION_ERROR;+ if (strm == Z_NULL || window == Z_NULL ||+ windowBits < 8 || windowBits > 15)+ return Z_STREAM_ERROR;+ strm->msg = Z_NULL; /* in case we return an error */+ if (strm->zalloc == (alloc_func)0) {+ strm->zalloc = zcalloc;+ strm->opaque = (voidpf)0;+ }+ if (strm->zfree == (free_func)0) strm->zfree = zcfree;+ state = (struct inflate_state FAR *)ZALLOC(strm, 1,+ sizeof(struct inflate_state));+ if (state == Z_NULL) return Z_MEM_ERROR;+ Tracev((stderr, "inflate: allocated\n"));+ strm->state = (struct internal_state FAR *)state;+ state->dmax = 32768U;+ state->wbits = windowBits;+ state->wsize = 1U << windowBits;+ state->window = window;+ state->write = 0;+ state->whave = 0;+ return Z_OK;+}++/*+ Return state with length and distance decoding tables and index sizes set to+ fixed code decoding. Normally this returns fixed tables from inffixed.h.+ If BUILDFIXED is defined, then instead this routine builds the tables the+ first time it's called, and returns those tables the first time and+ thereafter. This reduces the size of the code by about 2K bytes, in+ exchange for a little execution time. However, BUILDFIXED should not be+ used for threaded applications, since the rewriting of the tables and virgin+ may not be thread-safe.+ */+local void fixedtables(state)+struct inflate_state FAR *state;+{+#ifdef BUILDFIXED+ static int virgin = 1;+ static code *lenfix, *distfix;+ static code fixed[544];++ /* build fixed huffman tables if first call (may not be thread safe) */+ if (virgin) {+ unsigned sym, bits;+ static code *next;++ /* literal/length table */+ sym = 0;+ while (sym < 144) state->lens[sym++] = 8;+ while (sym < 256) state->lens[sym++] = 9;+ while (sym < 280) state->lens[sym++] = 7;+ while (sym < 288) state->lens[sym++] = 8;+ next = fixed;+ lenfix = next;+ bits = 9;+ inflate_table(LENS, state->lens, 288, &(next), &(bits), state->work);++ /* distance table */+ sym = 0;+ while (sym < 32) state->lens[sym++] = 5;+ distfix = next;+ bits = 5;+ inflate_table(DISTS, state->lens, 32, &(next), &(bits), state->work);++ /* do this just once */+ virgin = 0;+ }+#else /* !BUILDFIXED */+# include "inffixed.h"+#endif /* BUILDFIXED */+ state->lencode = lenfix;+ state->lenbits = 9;+ state->distcode = distfix;+ state->distbits = 5;+}++/* Macros for inflateBack(): */++/* Load returned state from inflate_fast() */+#define LOAD() \+ do { \+ put = strm->next_out; \+ left = strm->avail_out; \+ next = strm->next_in; \+ have = strm->avail_in; \+ hold = state->hold; \+ bits = state->bits; \+ } while (0)++/* Set state from registers for inflate_fast() */+#define RESTORE() \+ do { \+ strm->next_out = put; \+ strm->avail_out = left; \+ strm->next_in = next; \+ strm->avail_in = have; \+ state->hold = hold; \+ state->bits = bits; \+ } while (0)++/* Clear the input bit accumulator */+#define INITBITS() \+ do { \+ hold = 0; \+ bits = 0; \+ } while (0)++/* Assure that some input is available. If input is requested, but denied,+ then return a Z_BUF_ERROR from inflateBack(). */+#define PULL() \+ do { \+ if (have == 0) { \+ have = in(in_desc, &next); \+ if (have == 0) { \+ next = Z_NULL; \+ ret = Z_BUF_ERROR; \+ goto inf_leave; \+ } \+ } \+ } while (0)++/* Get a byte of input into the bit accumulator, or return from inflateBack()+ with an error if there is no input available. */+#define PULLBYTE() \+ do { \+ PULL(); \+ have--; \+ hold += (unsigned long)(*next++) << bits; \+ bits += 8; \+ } while (0)++/* Assure that there are at least n bits in the bit accumulator. If there is+ not enough available input to do that, then return from inflateBack() with+ an error. */+#define NEEDBITS(n) \+ do { \+ while (bits < (unsigned)(n)) \+ PULLBYTE(); \+ } while (0)++/* Return the low n bits of the bit accumulator (n < 16) */+#define BITS(n) \+ ((unsigned)hold & ((1U << (n)) - 1))++/* Remove n bits from the bit accumulator */+#define DROPBITS(n) \+ do { \+ hold >>= (n); \+ bits -= (unsigned)(n); \+ } while (0)++/* Remove zero to seven bits as needed to go to a byte boundary */+#define BYTEBITS() \+ do { \+ hold >>= bits & 7; \+ bits -= bits & 7; \+ } while (0)++/* Assure that some output space is available, by writing out the window+ if it's full. If the write fails, return from inflateBack() with a+ Z_BUF_ERROR. */+#define ROOM() \+ do { \+ if (left == 0) { \+ put = state->window; \+ left = state->wsize; \+ state->whave = left; \+ if (out(out_desc, put, left)) { \+ ret = Z_BUF_ERROR; \+ goto inf_leave; \+ } \+ } \+ } while (0)++/*+ strm provides the memory allocation functions and window buffer on input,+ and provides information on the unused input on return. For Z_DATA_ERROR+ returns, strm will also provide an error message.++ in() and out() are the call-back input and output functions. When+ inflateBack() needs more input, it calls in(). When inflateBack() has+ filled the window with output, or when it completes with data in the+ window, it calls out() to write out the data. The application must not+ change the provided input until in() is called again or inflateBack()+ returns. The application must not change the window/output buffer until+ inflateBack() returns.++ in() and out() are called with a descriptor parameter provided in the+ inflateBack() call. This parameter can be a structure that provides the+ information required to do the read or write, as well as accumulated+ information on the input and output such as totals and check values.++ in() should return zero on failure. out() should return non-zero on+ failure. If either in() or out() fails, than inflateBack() returns a+ Z_BUF_ERROR. strm->next_in can be checked for Z_NULL to see whether it+ was in() or out() that caused in the error. Otherwise, inflateBack()+ returns Z_STREAM_END on success, Z_DATA_ERROR for an deflate format+ error, or Z_MEM_ERROR if it could not allocate memory for the state.+ inflateBack() can also return Z_STREAM_ERROR if the input parameters+ are not correct, i.e. strm is Z_NULL or the state was not initialized.+ */+int ZEXPORT inflateBack(strm, in, in_desc, out, out_desc)+z_streamp strm;+in_func in;+void FAR *in_desc;+out_func out;+void FAR *out_desc;+{+ struct inflate_state FAR *state;+ unsigned char FAR *next; /* next input */+ unsigned char FAR *put; /* next output */+ unsigned have, left; /* available input and output */+ unsigned long hold; /* bit buffer */+ unsigned bits; /* bits in bit buffer */+ unsigned copy; /* number of stored or match bytes to copy */+ unsigned char FAR *from; /* where to copy match bytes from */+ code this; /* current decoding table entry */+ code last; /* parent table entry */+ unsigned len; /* length to copy for repeats, bits to drop */+ int ret; /* return code */+ static const unsigned short order[19] = /* permutation of code lengths */+ {16, 17, 18, 0, 8, 7, 9, 6, 10, 5, 11, 4, 12, 3, 13, 2, 14, 1, 15};++ /* Check that the strm exists and that the state was initialized */+ if (strm == Z_NULL || strm->state == Z_NULL)+ return Z_STREAM_ERROR;+ state = (struct inflate_state FAR *)strm->state;++ /* Reset the state */+ strm->msg = Z_NULL;+ state->mode = TYPE;+ state->last = 0;+ state->whave = 0;+ next = strm->next_in;+ have = next != Z_NULL ? strm->avail_in : 0;+ hold = 0;+ bits = 0;+ put = state->window;+ left = state->wsize;++ /* Inflate until end of block marked as last */+ for (;;)+ switch (state->mode) {+ case TYPE:+ /* determine and dispatch block type */+ if (state->last) {+ BYTEBITS();+ state->mode = DONE;+ break;+ }+ NEEDBITS(3);+ state->last = BITS(1);+ DROPBITS(1);+ switch (BITS(2)) {+ case 0: /* stored block */+ Tracev((stderr, "inflate: stored block%s\n",+ state->last ? " (last)" : ""));+ state->mode = STORED;+ break;+ case 1: /* fixed block */+ fixedtables(state);+ Tracev((stderr, "inflate: fixed codes block%s\n",+ state->last ? " (last)" : ""));+ state->mode = LEN; /* decode codes */+ break;+ case 2: /* dynamic block */+ Tracev((stderr, "inflate: dynamic codes block%s\n",+ state->last ? " (last)" : ""));+ state->mode = TABLE;+ break;+ case 3:+ strm->msg = (char *)"invalid block type";+ state->mode = BAD;+ }+ DROPBITS(2);+ break;++ case STORED:+ /* get and verify stored block length */+ BYTEBITS(); /* go to byte boundary */+ NEEDBITS(32);+ if ((hold & 0xffff) != ((hold >> 16) ^ 0xffff)) {+ strm->msg = (char *)"invalid stored block lengths";+ state->mode = BAD;+ break;+ }+ state->length = (unsigned)hold & 0xffff;+ Tracev((stderr, "inflate: stored length %u\n",+ state->length));+ INITBITS();++ /* copy stored block from input to output */+ while (state->length != 0) {+ copy = state->length;+ PULL();+ ROOM();+ if (copy > have) copy = have;+ if (copy > left) copy = left;+ zmemcpy(put, next, copy);+ have -= copy;+ next += copy;+ left -= copy;+ put += copy;+ state->length -= copy;+ }+ Tracev((stderr, "inflate: stored end\n"));+ state->mode = TYPE;+ break;++ case TABLE:+ /* get dynamic table entries descriptor */+ NEEDBITS(14);+ state->nlen = BITS(5) + 257;+ DROPBITS(5);+ state->ndist = BITS(5) + 1;+ DROPBITS(5);+ state->ncode = BITS(4) + 4;+ DROPBITS(4);+#ifndef PKZIP_BUG_WORKAROUND+ if (state->nlen > 286 || state->ndist > 30) {+ strm->msg = (char *)"too many length or distance symbols";+ state->mode = BAD;+ break;+ }+#endif+ Tracev((stderr, "inflate: table sizes ok\n"));++ /* get code length code lengths (not a typo) */+ state->have = 0;+ while (state->have < state->ncode) {+ NEEDBITS(3);+ state->lens[order[state->have++]] = (unsigned short)BITS(3);+ DROPBITS(3);+ }+ while (state->have < 19)+ state->lens[order[state->have++]] = 0;+ state->next = state->codes;+ state->lencode = (code const FAR *)(state->next);+ state->lenbits = 7;+ ret = inflate_table(CODES, state->lens, 19, &(state->next),+ &(state->lenbits), state->work);+ if (ret) {+ strm->msg = (char *)"invalid code lengths set";+ state->mode = BAD;+ break;+ }+ Tracev((stderr, "inflate: code lengths ok\n"));++ /* get length and distance code code lengths */+ state->have = 0;+ while (state->have < state->nlen + state->ndist) {+ for (;;) {+ this = state->lencode[BITS(state->lenbits)];+ if ((unsigned)(this.bits) <= bits) break;+ PULLBYTE();+ }+ if (this.val < 16) {+ NEEDBITS(this.bits);+ DROPBITS(this.bits);+ state->lens[state->have++] = this.val;+ }+ else {+ if (this.val == 16) {+ NEEDBITS(this.bits + 2);+ DROPBITS(this.bits);+ if (state->have == 0) {+ strm->msg = (char *)"invalid bit length repeat";+ state->mode = BAD;+ break;+ }+ len = (unsigned)(state->lens[state->have - 1]);+ copy = 3 + BITS(2);+ DROPBITS(2);+ }+ else if (this.val == 17) {+ NEEDBITS(this.bits + 3);+ DROPBITS(this.bits);+ len = 0;+ copy = 3 + BITS(3);+ DROPBITS(3);+ }+ else {+ NEEDBITS(this.bits + 7);+ DROPBITS(this.bits);+ len = 0;+ copy = 11 + BITS(7);+ DROPBITS(7);+ }+ if (state->have + copy > state->nlen + state->ndist) {+ strm->msg = (char *)"invalid bit length repeat";+ state->mode = BAD;+ break;+ }+ while (copy--)+ state->lens[state->have++] = (unsigned short)len;+ }+ }++ /* handle error breaks in while */+ if (state->mode == BAD) break;++ /* build code tables */+ state->next = state->codes;+ state->lencode = (code const FAR *)(state->next);+ state->lenbits = 9;+ ret = inflate_table(LENS, state->lens, state->nlen, &(state->next),+ &(state->lenbits), state->work);+ if (ret) {+ strm->msg = (char *)"invalid literal/lengths set";+ state->mode = BAD;+ break;+ }+ state->distcode = (code const FAR *)(state->next);+ state->distbits = 6;+ ret = inflate_table(DISTS, state->lens + state->nlen, state->ndist,+ &(state->next), &(state->distbits), state->work);+ if (ret) {+ strm->msg = (char *)"invalid distances set";+ state->mode = BAD;+ break;+ }+ Tracev((stderr, "inflate: codes ok\n"));+ state->mode = LEN;++ case LEN:+ /* use inflate_fast() if we have enough input and output */+ if (have >= 6 && left >= 258) {+ RESTORE();+ if (state->whave < state->wsize)+ state->whave = state->wsize - left;+ inflate_fast(strm, state->wsize);+ LOAD();+ break;+ }++ /* get a literal, length, or end-of-block code */+ for (;;) {+ this = state->lencode[BITS(state->lenbits)];+ if ((unsigned)(this.bits) <= bits) break;+ PULLBYTE();+ }+ if (this.op && (this.op & 0xf0) == 0) {+ last = this;+ for (;;) {+ this = state->lencode[last.val ++ (BITS(last.bits + last.op) >> last.bits)];+ if ((unsigned)(last.bits + this.bits) <= bits) break;+ PULLBYTE();+ }+ DROPBITS(last.bits);+ }+ DROPBITS(this.bits);+ state->length = (unsigned)this.val;++ /* process literal */+ if (this.op == 0) {+ Tracevv((stderr, this.val >= 0x20 && this.val < 0x7f ?+ "inflate: literal '%c'\n" :+ "inflate: literal 0x%02x\n", this.val));+ ROOM();+ *put++ = (unsigned char)(state->length);+ left--;+ state->mode = LEN;+ break;+ }++ /* process end of block */+ if (this.op & 32) {+ Tracevv((stderr, "inflate: end of block\n"));+ state->mode = TYPE;+ break;+ }++ /* invalid code */+ if (this.op & 64) {+ strm->msg = (char *)"invalid literal/length code";+ state->mode = BAD;+ break;+ }++ /* length code -- get extra bits, if any */+ state->extra = (unsigned)(this.op) & 15;+ if (state->extra != 0) {+ NEEDBITS(state->extra);+ state->length += BITS(state->extra);+ DROPBITS(state->extra);+ }+ Tracevv((stderr, "inflate: length %u\n", state->length));++ /* get distance code */+ for (;;) {+ this = state->distcode[BITS(state->distbits)];+ if ((unsigned)(this.bits) <= bits) break;+ PULLBYTE();+ }+ if ((this.op & 0xf0) == 0) {+ last = this;+ for (;;) {+ this = state->distcode[last.val ++ (BITS(last.bits + last.op) >> last.bits)];+ if ((unsigned)(last.bits + this.bits) <= bits) break;+ PULLBYTE();+ }+ DROPBITS(last.bits);+ }+ DROPBITS(this.bits);+ if (this.op & 64) {+ strm->msg = (char *)"invalid distance code";+ state->mode = BAD;+ break;+ }+ state->offset = (unsigned)this.val;++ /* get distance extra bits, if any */+ state->extra = (unsigned)(this.op) & 15;+ if (state->extra != 0) {+ NEEDBITS(state->extra);+ state->offset += BITS(state->extra);+ DROPBITS(state->extra);+ }+ if (state->offset > state->wsize - (state->whave < state->wsize ?+ left : 0)) {+ strm->msg = (char *)"invalid distance too far back";+ state->mode = BAD;+ break;+ }+ Tracevv((stderr, "inflate: distance %u\n", state->offset));++ /* copy match from window to output */+ do {+ ROOM();+ copy = state->wsize - state->offset;+ if (copy < left) {+ from = put + copy;+ copy = left - copy;+ }+ else {+ from = put - state->offset;+ copy = left;+ }+ if (copy > state->length) copy = state->length;+ state->length -= copy;+ left -= copy;+ do {+ *put++ = *from++;+ } while (--copy);+ } while (state->length != 0);+ break;++ case DONE:+ /* inflate stream terminated properly -- write leftover output */+ ret = Z_STREAM_END;+ if (left < state->wsize) {+ if (out(out_desc, state->window, state->wsize - left))+ ret = Z_BUF_ERROR;+ }+ goto inf_leave;++ case BAD:+ ret = Z_DATA_ERROR;+ goto inf_leave;++ default: /* can't happen, but makes compilers happy */+ ret = Z_STREAM_ERROR;+ goto inf_leave;+ }++ /* Return unused input */+ inf_leave:+ strm->next_in = next;+ strm->avail_in = have;+ return ret;+}++int ZEXPORT inflateBackEnd(strm)+z_streamp strm;+{+ if (strm == Z_NULL || strm->state == Z_NULL || strm->zfree == (free_func)0)+ return Z_STREAM_ERROR;+ ZFREE(strm, strm->state);+ strm->state = Z_NULL;+ Tracev((stderr, "inflate: end\n"));+ return Z_OK;+}
+ cbits/inffast.c view
@@ -0,0 +1,318 @@+/* inffast.c -- fast decoding+ * Copyright (C) 1995-2004 Mark Adler+ * For conditions of distribution and use, see copyright notice in zlib.h+ */++#include "zutil.h"+#include "inftrees.h"+#include "inflate.h"+#include "inffast.h"++#ifndef ASMINF++/* Allow machine dependent optimization for post-increment or pre-increment.+ Based on testing to date,+ Pre-increment preferred for:+ - PowerPC G3 (Adler)+ - MIPS R5000 (Randers-Pehrson)+ Post-increment preferred for:+ - none+ No measurable difference:+ - Pentium III (Anderson)+ - M68060 (Nikl)+ */+#ifdef POSTINC+# define OFF 0+# define PUP(a) *(a)+++#else+# define OFF 1+# define PUP(a) *++(a)+#endif++/*+ Decode literal, length, and distance codes and write out the resulting+ literal and match bytes until either not enough input or output is+ available, an end-of-block is encountered, or a data error is encountered.+ When large enough input and output buffers are supplied to inflate(), for+ example, a 16K input buffer and a 64K output buffer, more than 95% of the+ inflate execution time is spent in this routine.++ Entry assumptions:++ state->mode == LEN+ strm->avail_in >= 6+ strm->avail_out >= 258+ start >= strm->avail_out+ state->bits < 8++ On return, state->mode is one of:++ LEN -- ran out of enough output space or enough available input+ TYPE -- reached end of block code, inflate() to interpret next block+ BAD -- error in block data++ Notes:++ - The maximum input bits used by a length/distance pair is 15 bits for the+ length code, 5 bits for the length extra, 15 bits for the distance code,+ and 13 bits for the distance extra. This totals 48 bits, or six bytes.+ Therefore if strm->avail_in >= 6, then there is enough input to avoid+ checking for available input while decoding.++ - The maximum bytes that a single length/distance pair can output is 258+ bytes, which is the maximum length that can be coded. inflate_fast()+ requires strm->avail_out >= 258 for each loop to avoid checking for+ output space.+ */+void inflate_fast(strm, start)+z_streamp strm;+unsigned start; /* inflate()'s starting value for strm->avail_out */+{+ struct inflate_state FAR *state;+ unsigned char FAR *in; /* local strm->next_in */+ unsigned char FAR *last; /* while in < last, enough input available */+ unsigned char FAR *out; /* local strm->next_out */+ unsigned char FAR *beg; /* inflate()'s initial strm->next_out */+ unsigned char FAR *end; /* while out < end, enough space available */+#ifdef INFLATE_STRICT+ unsigned dmax; /* maximum distance from zlib header */+#endif+ unsigned wsize; /* window size or zero if not using window */+ unsigned whave; /* valid bytes in the window */+ unsigned write; /* window write index */+ unsigned char FAR *window; /* allocated sliding window, if wsize != 0 */+ unsigned long hold; /* local strm->hold */+ unsigned bits; /* local strm->bits */+ code const FAR *lcode; /* local strm->lencode */+ code const FAR *dcode; /* local strm->distcode */+ unsigned lmask; /* mask for first level of length codes */+ unsigned dmask; /* mask for first level of distance codes */+ code this; /* retrieved table entry */+ unsigned op; /* code bits, operation, extra bits, or */+ /* window position, window bytes to copy */+ unsigned len; /* match length, unused bytes */+ unsigned dist; /* match distance */+ unsigned char FAR *from; /* where to copy match from */++ /* copy state to local variables */+ state = (struct inflate_state FAR *)strm->state;+ in = strm->next_in - OFF;+ last = in + (strm->avail_in - 5);+ out = strm->next_out - OFF;+ beg = out - (start - strm->avail_out);+ end = out + (strm->avail_out - 257);+#ifdef INFLATE_STRICT+ dmax = state->dmax;+#endif+ wsize = state->wsize;+ whave = state->whave;+ write = state->write;+ window = state->window;+ hold = state->hold;+ bits = state->bits;+ lcode = state->lencode;+ dcode = state->distcode;+ lmask = (1U << state->lenbits) - 1;+ dmask = (1U << state->distbits) - 1;++ /* decode literals and length/distances until end-of-block or not enough+ input data or output space */+ do {+ if (bits < 15) {+ hold += (unsigned long)(PUP(in)) << bits;+ bits += 8;+ hold += (unsigned long)(PUP(in)) << bits;+ bits += 8;+ }+ this = lcode[hold & lmask];+ dolen:+ op = (unsigned)(this.bits);+ hold >>= op;+ bits -= op;+ op = (unsigned)(this.op);+ if (op == 0) { /* literal */+ Tracevv((stderr, this.val >= 0x20 && this.val < 0x7f ?+ "inflate: literal '%c'\n" :+ "inflate: literal 0x%02x\n", this.val));+ PUP(out) = (unsigned char)(this.val);+ }+ else if (op & 16) { /* length base */+ len = (unsigned)(this.val);+ op &= 15; /* number of extra bits */+ if (op) {+ if (bits < op) {+ hold += (unsigned long)(PUP(in)) << bits;+ bits += 8;+ }+ len += (unsigned)hold & ((1U << op) - 1);+ hold >>= op;+ bits -= op;+ }+ Tracevv((stderr, "inflate: length %u\n", len));+ if (bits < 15) {+ hold += (unsigned long)(PUP(in)) << bits;+ bits += 8;+ hold += (unsigned long)(PUP(in)) << bits;+ bits += 8;+ }+ this = dcode[hold & dmask];+ dodist:+ op = (unsigned)(this.bits);+ hold >>= op;+ bits -= op;+ op = (unsigned)(this.op);+ if (op & 16) { /* distance base */+ dist = (unsigned)(this.val);+ op &= 15; /* number of extra bits */+ if (bits < op) {+ hold += (unsigned long)(PUP(in)) << bits;+ bits += 8;+ if (bits < op) {+ hold += (unsigned long)(PUP(in)) << bits;+ bits += 8;+ }+ }+ dist += (unsigned)hold & ((1U << op) - 1);+#ifdef INFLATE_STRICT+ if (dist > dmax) {+ strm->msg = (char *)"invalid distance too far back";+ state->mode = BAD;+ break;+ }+#endif+ hold >>= op;+ bits -= op;+ Tracevv((stderr, "inflate: distance %u\n", dist));+ op = (unsigned)(out - beg); /* max distance in output */+ if (dist > op) { /* see if copy from window */+ op = dist - op; /* distance back in window */+ if (op > whave) {+ strm->msg = (char *)"invalid distance too far back";+ state->mode = BAD;+ break;+ }+ from = window - OFF;+ if (write == 0) { /* very common case */+ from += wsize - op;+ if (op < len) { /* some from window */+ len -= op;+ do {+ PUP(out) = PUP(from);+ } while (--op);+ from = out - dist; /* rest from output */+ }+ }+ else if (write < op) { /* wrap around window */+ from += wsize + write - op;+ op -= write;+ if (op < len) { /* some from end of window */+ len -= op;+ do {+ PUP(out) = PUP(from);+ } while (--op);+ from = window - OFF;+ if (write < len) { /* some from start of window */+ op = write;+ len -= op;+ do {+ PUP(out) = PUP(from);+ } while (--op);+ from = out - dist; /* rest from output */+ }+ }+ }+ else { /* contiguous in window */+ from += write - op;+ if (op < len) { /* some from window */+ len -= op;+ do {+ PUP(out) = PUP(from);+ } while (--op);+ from = out - dist; /* rest from output */+ }+ }+ while (len > 2) {+ PUP(out) = PUP(from);+ PUP(out) = PUP(from);+ PUP(out) = PUP(from);+ len -= 3;+ }+ if (len) {+ PUP(out) = PUP(from);+ if (len > 1)+ PUP(out) = PUP(from);+ }+ }+ else {+ from = out - dist; /* copy direct from output */+ do { /* minimum length is three */+ PUP(out) = PUP(from);+ PUP(out) = PUP(from);+ PUP(out) = PUP(from);+ len -= 3;+ } while (len > 2);+ if (len) {+ PUP(out) = PUP(from);+ if (len > 1)+ PUP(out) = PUP(from);+ }+ }+ }+ else if ((op & 64) == 0) { /* 2nd level distance code */+ this = dcode[this.val + (hold & ((1U << op) - 1))];+ goto dodist;+ }+ else {+ strm->msg = (char *)"invalid distance code";+ state->mode = BAD;+ break;+ }+ }+ else if ((op & 64) == 0) { /* 2nd level length code */+ this = lcode[this.val + (hold & ((1U << op) - 1))];+ goto dolen;+ }+ else if (op & 32) { /* end-of-block */+ Tracevv((stderr, "inflate: end of block\n"));+ state->mode = TYPE;+ break;+ }+ else {+ strm->msg = (char *)"invalid literal/length code";+ state->mode = BAD;+ break;+ }+ } while (in < last && out < end);++ /* return unused bytes (on entry, bits < 8, so in won't go too far back) */+ len = bits >> 3;+ in -= len;+ bits -= len << 3;+ hold &= (1U << bits) - 1;++ /* update state and return */+ strm->next_in = in + OFF;+ strm->next_out = out + OFF;+ strm->avail_in = (unsigned)(in < last ? 5 + (last - in) : 5 - (in - last));+ strm->avail_out = (unsigned)(out < end ?+ 257 + (end - out) : 257 - (out - end));+ state->hold = hold;+ state->bits = bits;+ return;+}++/*+ inflate_fast() speedups that turned out slower (on a PowerPC G3 750CXe):+ - Using bit fields for code structure+ - Different op definition to avoid & for extra bits (do & for table bits)+ - Three separate decoding do-loops for direct, window, and write == 0+ - Special case for distance > 1 copies to do overlapped load and store copy+ - Explicit branch predictions (based on measured branch probabilities)+ - Deferring match copy and interspersed it with decoding subsequent codes+ - Swapping literal/length else+ - Swapping window/direct else+ - Larger unrolled copy loops (three is about right)+ - Moving len -= 3 statement into middle of loop+ */++#endif /* !ASMINF */
+ cbits/inflate.c view
@@ -0,0 +1,1368 @@+/* inflate.c -- zlib decompression+ * Copyright (C) 1995-2005 Mark Adler+ * For conditions of distribution and use, see copyright notice in zlib.h+ */++/*+ * Change history:+ *+ * 1.2.beta0 24 Nov 2002+ * - First version -- complete rewrite of inflate to simplify code, avoid+ * creation of window when not needed, minimize use of window when it is+ * needed, make inffast.c even faster, implement gzip decoding, and to+ * improve code readability and style over the previous zlib inflate code+ *+ * 1.2.beta1 25 Nov 2002+ * - Use pointers for available input and output checking in inffast.c+ * - Remove input and output counters in inffast.c+ * - Change inffast.c entry and loop from avail_in >= 7 to >= 6+ * - Remove unnecessary second byte pull from length extra in inffast.c+ * - Unroll direct copy to three copies per loop in inffast.c+ *+ * 1.2.beta2 4 Dec 2002+ * - Change external routine names to reduce potential conflicts+ * - Correct filename to inffixed.h for fixed tables in inflate.c+ * - Make hbuf[] unsigned char to match parameter type in inflate.c+ * - Change strm->next_out[-state->offset] to *(strm->next_out - state->offset)+ * to avoid negation problem on Alphas (64 bit) in inflate.c+ *+ * 1.2.beta3 22 Dec 2002+ * - Add comments on state->bits assertion in inffast.c+ * - Add comments on op field in inftrees.h+ * - Fix bug in reuse of allocated window after inflateReset()+ * - Remove bit fields--back to byte structure for speed+ * - Remove distance extra == 0 check in inflate_fast()--only helps for lengths+ * - Change post-increments to pre-increments in inflate_fast(), PPC biased?+ * - Add compile time option, POSTINC, to use post-increments instead (Intel?)+ * - Make MATCH copy in inflate() much faster for when inflate_fast() not used+ * - Use local copies of stream next and avail values, as well as local bit+ * buffer and bit count in inflate()--for speed when inflate_fast() not used+ *+ * 1.2.beta4 1 Jan 2003+ * - Split ptr - 257 statements in inflate_table() to avoid compiler warnings+ * - Move a comment on output buffer sizes from inffast.c to inflate.c+ * - Add comments in inffast.c to introduce the inflate_fast() routine+ * - Rearrange window copies in inflate_fast() for speed and simplification+ * - Unroll last copy for window match in inflate_fast()+ * - Use local copies of window variables in inflate_fast() for speed+ * - Pull out common write == 0 case for speed in inflate_fast()+ * - Make op and len in inflate_fast() unsigned for consistency+ * - Add FAR to lcode and dcode declarations in inflate_fast()+ * - Simplified bad distance check in inflate_fast()+ * - Added inflateBackInit(), inflateBack(), and inflateBackEnd() in new+ * source file infback.c to provide a call-back interface to inflate for+ * programs like gzip and unzip -- uses window as output buffer to avoid+ * window copying+ *+ * 1.2.beta5 1 Jan 2003+ * - Improved inflateBack() interface to allow the caller to provide initial+ * input in strm.+ * - Fixed stored blocks bug in inflateBack()+ *+ * 1.2.beta6 4 Jan 2003+ * - Added comments in inffast.c on effectiveness of POSTINC+ * - Typecasting all around to reduce compiler warnings+ * - Changed loops from while (1) or do {} while (1) to for (;;), again to+ * make compilers happy+ * - Changed type of window in inflateBackInit() to unsigned char *+ *+ * 1.2.beta7 27 Jan 2003+ * - Changed many types to unsigned or unsigned short to avoid warnings+ * - Added inflateCopy() function+ *+ * 1.2.0 9 Mar 2003+ * - Changed inflateBack() interface to provide separate opaque descriptors+ * for the in() and out() functions+ * - Changed inflateBack() argument and in_func typedef to swap the length+ * and buffer address return values for the input function+ * - Check next_in and next_out for Z_NULL on entry to inflate()+ *+ * The history for versions after 1.2.0 are in ChangeLog in zlib distribution.+ */++#include "zutil.h"+#include "inftrees.h"+#include "inflate.h"+#include "inffast.h"++#ifdef MAKEFIXED+# ifndef BUILDFIXED+# define BUILDFIXED+# endif+#endif++/* function prototypes */+local void fixedtables OF((struct inflate_state FAR *state));+local int updatewindow OF((z_streamp strm, unsigned out));+#ifdef BUILDFIXED+ void makefixed OF((void));+#endif+local unsigned syncsearch OF((unsigned FAR *have, unsigned char FAR *buf,+ unsigned len));++int ZEXPORT inflateReset(strm)+z_streamp strm;+{+ struct inflate_state FAR *state;++ if (strm == Z_NULL || strm->state == Z_NULL) return Z_STREAM_ERROR;+ state = (struct inflate_state FAR *)strm->state;+ strm->total_in = strm->total_out = state->total = 0;+ strm->msg = Z_NULL;+ strm->adler = 1; /* to support ill-conceived Java test suite */+ state->mode = HEAD;+ state->last = 0;+ state->havedict = 0;+ state->dmax = 32768U;+ state->head = Z_NULL;+ state->wsize = 0;+ state->whave = 0;+ state->write = 0;+ state->hold = 0;+ state->bits = 0;+ state->lencode = state->distcode = state->next = state->codes;+ Tracev((stderr, "inflate: reset\n"));+ return Z_OK;+}++int ZEXPORT inflatePrime(strm, bits, value)+z_streamp strm;+int bits;+int value;+{+ struct inflate_state FAR *state;++ if (strm == Z_NULL || strm->state == Z_NULL) return Z_STREAM_ERROR;+ state = (struct inflate_state FAR *)strm->state;+ if (bits > 16 || state->bits + bits > 32) return Z_STREAM_ERROR;+ value &= (1L << bits) - 1;+ state->hold += value << state->bits;+ state->bits += bits;+ return Z_OK;+}++int ZEXPORT inflateInit2_(strm, windowBits, version, stream_size)+z_streamp strm;+int windowBits;+const char *version;+int stream_size;+{+ struct inflate_state FAR *state;++ if (version == Z_NULL || version[0] != ZLIB_VERSION[0] ||+ stream_size != (int)(sizeof(z_stream)))+ return Z_VERSION_ERROR;+ if (strm == Z_NULL) return Z_STREAM_ERROR;+ strm->msg = Z_NULL; /* in case we return an error */+ if (strm->zalloc == (alloc_func)0) {+ strm->zalloc = zcalloc;+ strm->opaque = (voidpf)0;+ }+ if (strm->zfree == (free_func)0) strm->zfree = zcfree;+ state = (struct inflate_state FAR *)+ ZALLOC(strm, 1, sizeof(struct inflate_state));+ if (state == Z_NULL) return Z_MEM_ERROR;+ Tracev((stderr, "inflate: allocated\n"));+ strm->state = (struct internal_state FAR *)state;+ if (windowBits < 0) {+ state->wrap = 0;+ windowBits = -windowBits;+ }+ else {+ state->wrap = (windowBits >> 4) + 1;+#ifdef GUNZIP+ if (windowBits < 48) windowBits &= 15;+#endif+ }+ if (windowBits < 8 || windowBits > 15) {+ ZFREE(strm, state);+ strm->state = Z_NULL;+ return Z_STREAM_ERROR;+ }+ state->wbits = (unsigned)windowBits;+ state->window = Z_NULL;+ return inflateReset(strm);+}++int ZEXPORT inflateInit_(strm, version, stream_size)+z_streamp strm;+const char *version;+int stream_size;+{+ return inflateInit2_(strm, DEF_WBITS, version, stream_size);+}++/*+ Return state with length and distance decoding tables and index sizes set to+ fixed code decoding. Normally this returns fixed tables from inffixed.h.+ If BUILDFIXED is defined, then instead this routine builds the tables the+ first time it's called, and returns those tables the first time and+ thereafter. This reduces the size of the code by about 2K bytes, in+ exchange for a little execution time. However, BUILDFIXED should not be+ used for threaded applications, since the rewriting of the tables and virgin+ may not be thread-safe.+ */+local void fixedtables(state)+struct inflate_state FAR *state;+{+#ifdef BUILDFIXED+ static int virgin = 1;+ static code *lenfix, *distfix;+ static code fixed[544];++ /* build fixed huffman tables if first call (may not be thread safe) */+ if (virgin) {+ unsigned sym, bits;+ static code *next;++ /* literal/length table */+ sym = 0;+ while (sym < 144) state->lens[sym++] = 8;+ while (sym < 256) state->lens[sym++] = 9;+ while (sym < 280) state->lens[sym++] = 7;+ while (sym < 288) state->lens[sym++] = 8;+ next = fixed;+ lenfix = next;+ bits = 9;+ inflate_table(LENS, state->lens, 288, &(next), &(bits), state->work);++ /* distance table */+ sym = 0;+ while (sym < 32) state->lens[sym++] = 5;+ distfix = next;+ bits = 5;+ inflate_table(DISTS, state->lens, 32, &(next), &(bits), state->work);++ /* do this just once */+ virgin = 0;+ }+#else /* !BUILDFIXED */+# include "inffixed.h"+#endif /* BUILDFIXED */+ state->lencode = lenfix;+ state->lenbits = 9;+ state->distcode = distfix;+ state->distbits = 5;+}++#ifdef MAKEFIXED+#include <stdio.h>++/*+ Write out the inffixed.h that is #include'd above. Defining MAKEFIXED also+ defines BUILDFIXED, so the tables are built on the fly. makefixed() writes+ those tables to stdout, which would be piped to inffixed.h. A small program+ can simply call makefixed to do this:++ void makefixed(void);++ int main(void)+ {+ makefixed();+ return 0;+ }++ Then that can be linked with zlib built with MAKEFIXED defined and run:++ a.out > inffixed.h+ */+void makefixed()+{+ unsigned low, size;+ struct inflate_state state;++ fixedtables(&state);+ puts(" /* inffixed.h -- table for decoding fixed codes");+ puts(" * Generated automatically by makefixed().");+ puts(" */");+ puts("");+ puts(" /* WARNING: this file should *not* be used by applications.");+ puts(" It is part of the implementation of this library and is");+ puts(" subject to change. Applications should only use zlib.h.");+ puts(" */");+ puts("");+ size = 1U << 9;+ printf(" static const code lenfix[%u] = {", size);+ low = 0;+ for (;;) {+ if ((low % 7) == 0) printf("\n ");+ printf("{%u,%u,%d}", state.lencode[low].op, state.lencode[low].bits,+ state.lencode[low].val);+ if (++low == size) break;+ putchar(',');+ }+ puts("\n };");+ size = 1U << 5;+ printf("\n static const code distfix[%u] = {", size);+ low = 0;+ for (;;) {+ if ((low % 6) == 0) printf("\n ");+ printf("{%u,%u,%d}", state.distcode[low].op, state.distcode[low].bits,+ state.distcode[low].val);+ if (++low == size) break;+ putchar(',');+ }+ puts("\n };");+}+#endif /* MAKEFIXED */++/*+ Update the window with the last wsize (normally 32K) bytes written before+ returning. If window does not exist yet, create it. This is only called+ when a window is already in use, or when output has been written during this+ inflate call, but the end of the deflate stream has not been reached yet.+ It is also called to create a window for dictionary data when a dictionary+ is loaded.++ Providing output buffers larger than 32K to inflate() should provide a speed+ advantage, since only the last 32K of output is copied to the sliding window+ upon return from inflate(), and since all distances after the first 32K of+ output will fall in the output data, making match copies simpler and faster.+ The advantage may be dependent on the size of the processor's data caches.+ */+local int updatewindow(strm, out)+z_streamp strm;+unsigned out;+{+ struct inflate_state FAR *state;+ unsigned copy, dist;++ state = (struct inflate_state FAR *)strm->state;++ /* if it hasn't been done already, allocate space for the window */+ if (state->window == Z_NULL) {+ state->window = (unsigned char FAR *)+ ZALLOC(strm, 1U << state->wbits,+ sizeof(unsigned char));+ if (state->window == Z_NULL) return 1;+ }++ /* if window not in use yet, initialize */+ if (state->wsize == 0) {+ state->wsize = 1U << state->wbits;+ state->write = 0;+ state->whave = 0;+ }++ /* copy state->wsize or less output bytes into the circular window */+ copy = out - strm->avail_out;+ if (copy >= state->wsize) {+ zmemcpy(state->window, strm->next_out - state->wsize, state->wsize);+ state->write = 0;+ state->whave = state->wsize;+ }+ else {+ dist = state->wsize - state->write;+ if (dist > copy) dist = copy;+ zmemcpy(state->window + state->write, strm->next_out - copy, dist);+ copy -= dist;+ if (copy) {+ zmemcpy(state->window, strm->next_out - copy, copy);+ state->write = copy;+ state->whave = state->wsize;+ }+ else {+ state->write += dist;+ if (state->write == state->wsize) state->write = 0;+ if (state->whave < state->wsize) state->whave += dist;+ }+ }+ return 0;+}++/* Macros for inflate(): */++/* check function to use adler32() for zlib or crc32() for gzip */+#ifdef GUNZIP+# define UPDATE(check, buf, len) \+ (state->flags ? crc32(check, buf, len) : adler32(check, buf, len))+#else+# define UPDATE(check, buf, len) adler32(check, buf, len)+#endif++/* check macros for header crc */+#ifdef GUNZIP+# define CRC2(check, word) \+ do { \+ hbuf[0] = (unsigned char)(word); \+ hbuf[1] = (unsigned char)((word) >> 8); \+ check = crc32(check, hbuf, 2); \+ } while (0)++# define CRC4(check, word) \+ do { \+ hbuf[0] = (unsigned char)(word); \+ hbuf[1] = (unsigned char)((word) >> 8); \+ hbuf[2] = (unsigned char)((word) >> 16); \+ hbuf[3] = (unsigned char)((word) >> 24); \+ check = crc32(check, hbuf, 4); \+ } while (0)+#endif++/* Load registers with state in inflate() for speed */+#define LOAD() \+ do { \+ put = strm->next_out; \+ left = strm->avail_out; \+ next = strm->next_in; \+ have = strm->avail_in; \+ hold = state->hold; \+ bits = state->bits; \+ } while (0)++/* Restore state from registers in inflate() */+#define RESTORE() \+ do { \+ strm->next_out = put; \+ strm->avail_out = left; \+ strm->next_in = next; \+ strm->avail_in = have; \+ state->hold = hold; \+ state->bits = bits; \+ } while (0)++/* Clear the input bit accumulator */+#define INITBITS() \+ do { \+ hold = 0; \+ bits = 0; \+ } while (0)++/* Get a byte of input into the bit accumulator, or return from inflate()+ if there is no input available. */+#define PULLBYTE() \+ do { \+ if (have == 0) goto inf_leave; \+ have--; \+ hold += (unsigned long)(*next++) << bits; \+ bits += 8; \+ } while (0)++/* Assure that there are at least n bits in the bit accumulator. If there is+ not enough available input to do that, then return from inflate(). */+#define NEEDBITS(n) \+ do { \+ while (bits < (unsigned)(n)) \+ PULLBYTE(); \+ } while (0)++/* Return the low n bits of the bit accumulator (n < 16) */+#define BITS(n) \+ ((unsigned)hold & ((1U << (n)) - 1))++/* Remove n bits from the bit accumulator */+#define DROPBITS(n) \+ do { \+ hold >>= (n); \+ bits -= (unsigned)(n); \+ } while (0)++/* Remove zero to seven bits as needed to go to a byte boundary */+#define BYTEBITS() \+ do { \+ hold >>= bits & 7; \+ bits -= bits & 7; \+ } while (0)++/* Reverse the bytes in a 32-bit value */+#define REVERSE(q) \+ ((((q) >> 24) & 0xff) + (((q) >> 8) & 0xff00) + \+ (((q) & 0xff00) << 8) + (((q) & 0xff) << 24))++/*+ inflate() uses a state machine to process as much input data and generate as+ much output data as possible before returning. The state machine is+ structured roughly as follows:++ for (;;) switch (state) {+ ...+ case STATEn:+ if (not enough input data or output space to make progress)+ return;+ ... make progress ...+ state = STATEm;+ break;+ ...+ }++ so when inflate() is called again, the same case is attempted again, and+ if the appropriate resources are provided, the machine proceeds to the+ next state. The NEEDBITS() macro is usually the way the state evaluates+ whether it can proceed or should return. NEEDBITS() does the return if+ the requested bits are not available. The typical use of the BITS macros+ is:++ NEEDBITS(n);+ ... do something with BITS(n) ...+ DROPBITS(n);++ where NEEDBITS(n) either returns from inflate() if there isn't enough+ input left to load n bits into the accumulator, or it continues. BITS(n)+ gives the low n bits in the accumulator. When done, DROPBITS(n) drops+ the low n bits off the accumulator. INITBITS() clears the accumulator+ and sets the number of available bits to zero. BYTEBITS() discards just+ enough bits to put the accumulator on a byte boundary. After BYTEBITS()+ and a NEEDBITS(8), then BITS(8) would return the next byte in the stream.++ NEEDBITS(n) uses PULLBYTE() to get an available byte of input, or to return+ if there is no input available. The decoding of variable length codes uses+ PULLBYTE() directly in order to pull just enough bytes to decode the next+ code, and no more.++ Some states loop until they get enough input, making sure that enough+ state information is maintained to continue the loop where it left off+ if NEEDBITS() returns in the loop. For example, want, need, and keep+ would all have to actually be part of the saved state in case NEEDBITS()+ returns:++ case STATEw:+ while (want < need) {+ NEEDBITS(n);+ keep[want++] = BITS(n);+ DROPBITS(n);+ }+ state = STATEx;+ case STATEx:++ As shown above, if the next state is also the next case, then the break+ is omitted.++ A state may also return if there is not enough output space available to+ complete that state. Those states are copying stored data, writing a+ literal byte, and copying a matching string.++ When returning, a "goto inf_leave" is used to update the total counters,+ update the check value, and determine whether any progress has been made+ during that inflate() call in order to return the proper return code.+ Progress is defined as a change in either strm->avail_in or strm->avail_out.+ When there is a window, goto inf_leave will update the window with the last+ output written. If a goto inf_leave occurs in the middle of decompression+ and there is no window currently, goto inf_leave will create one and copy+ output to the window for the next call of inflate().++ In this implementation, the flush parameter of inflate() only affects the+ return code (per zlib.h). inflate() always writes as much as possible to+ strm->next_out, given the space available and the provided input--the effect+ documented in zlib.h of Z_SYNC_FLUSH. Furthermore, inflate() always defers+ the allocation of and copying into a sliding window until necessary, which+ provides the effect documented in zlib.h for Z_FINISH when the entire input+ stream available. So the only thing the flush parameter actually does is:+ when flush is set to Z_FINISH, inflate() cannot return Z_OK. Instead it+ will return Z_BUF_ERROR if it has not reached the end of the stream.+ */++int ZEXPORT inflate(strm, flush)+z_streamp strm;+int flush;+{+ struct inflate_state FAR *state;+ unsigned char FAR *next; /* next input */+ unsigned char FAR *put; /* next output */+ unsigned have, left; /* available input and output */+ unsigned long hold; /* bit buffer */+ unsigned bits; /* bits in bit buffer */+ unsigned in, out; /* save starting available input and output */+ unsigned copy; /* number of stored or match bytes to copy */+ unsigned char FAR *from; /* where to copy match bytes from */+ code this; /* current decoding table entry */+ code last; /* parent table entry */+ unsigned len; /* length to copy for repeats, bits to drop */+ int ret; /* return code */+#ifdef GUNZIP+ unsigned char hbuf[4]; /* buffer for gzip header crc calculation */+#endif+ static const unsigned short order[19] = /* permutation of code lengths */+ {16, 17, 18, 0, 8, 7, 9, 6, 10, 5, 11, 4, 12, 3, 13, 2, 14, 1, 15};++ if (strm == Z_NULL || strm->state == Z_NULL || strm->next_out == Z_NULL ||+ (strm->next_in == Z_NULL && strm->avail_in != 0))+ return Z_STREAM_ERROR;++ state = (struct inflate_state FAR *)strm->state;+ if (state->mode == TYPE) state->mode = TYPEDO; /* skip check */+ LOAD();+ in = have;+ out = left;+ ret = Z_OK;+ for (;;)+ switch (state->mode) {+ case HEAD:+ if (state->wrap == 0) {+ state->mode = TYPEDO;+ break;+ }+ NEEDBITS(16);+#ifdef GUNZIP+ if ((state->wrap & 2) && hold == 0x8b1f) { /* gzip header */+ state->check = crc32(0L, Z_NULL, 0);+ CRC2(state->check, hold);+ INITBITS();+ state->mode = FLAGS;+ break;+ }+ state->flags = 0; /* expect zlib header */+ if (state->head != Z_NULL)+ state->head->done = -1;+ if (!(state->wrap & 1) || /* check if zlib header allowed */+#else+ if (+#endif+ ((BITS(8) << 8) + (hold >> 8)) % 31) {+ strm->msg = (char *)"incorrect header check";+ state->mode = BAD;+ break;+ }+ if (BITS(4) != Z_DEFLATED) {+ strm->msg = (char *)"unknown compression method";+ state->mode = BAD;+ break;+ }+ DROPBITS(4);+ len = BITS(4) + 8;+ if (len > state->wbits) {+ strm->msg = (char *)"invalid window size";+ state->mode = BAD;+ break;+ }+ state->dmax = 1U << len;+ Tracev((stderr, "inflate: zlib header ok\n"));+ strm->adler = state->check = adler32(0L, Z_NULL, 0);+ state->mode = hold & 0x200 ? DICTID : TYPE;+ INITBITS();+ break;+#ifdef GUNZIP+ case FLAGS:+ NEEDBITS(16);+ state->flags = (int)(hold);+ if ((state->flags & 0xff) != Z_DEFLATED) {+ strm->msg = (char *)"unknown compression method";+ state->mode = BAD;+ break;+ }+ if (state->flags & 0xe000) {+ strm->msg = (char *)"unknown header flags set";+ state->mode = BAD;+ break;+ }+ if (state->head != Z_NULL)+ state->head->text = (int)((hold >> 8) & 1);+ if (state->flags & 0x0200) CRC2(state->check, hold);+ INITBITS();+ state->mode = TIME;+ case TIME:+ NEEDBITS(32);+ if (state->head != Z_NULL)+ state->head->time = hold;+ if (state->flags & 0x0200) CRC4(state->check, hold);+ INITBITS();+ state->mode = OS;+ case OS:+ NEEDBITS(16);+ if (state->head != Z_NULL) {+ state->head->xflags = (int)(hold & 0xff);+ state->head->os = (int)(hold >> 8);+ }+ if (state->flags & 0x0200) CRC2(state->check, hold);+ INITBITS();+ state->mode = EXLEN;+ case EXLEN:+ if (state->flags & 0x0400) {+ NEEDBITS(16);+ state->length = (unsigned)(hold);+ if (state->head != Z_NULL)+ state->head->extra_len = (unsigned)hold;+ if (state->flags & 0x0200) CRC2(state->check, hold);+ INITBITS();+ }+ else if (state->head != Z_NULL)+ state->head->extra = Z_NULL;+ state->mode = EXTRA;+ case EXTRA:+ if (state->flags & 0x0400) {+ copy = state->length;+ if (copy > have) copy = have;+ if (copy) {+ if (state->head != Z_NULL &&+ state->head->extra != Z_NULL) {+ len = state->head->extra_len - state->length;+ zmemcpy(state->head->extra + len, next,+ len + copy > state->head->extra_max ?+ state->head->extra_max - len : copy);+ }+ if (state->flags & 0x0200)+ state->check = crc32(state->check, next, copy);+ have -= copy;+ next += copy;+ state->length -= copy;+ }+ if (state->length) goto inf_leave;+ }+ state->length = 0;+ state->mode = NAME;+ case NAME:+ if (state->flags & 0x0800) {+ if (have == 0) goto inf_leave;+ copy = 0;+ do {+ len = (unsigned)(next[copy++]);+ if (state->head != Z_NULL &&+ state->head->name != Z_NULL &&+ state->length < state->head->name_max)+ state->head->name[state->length++] = len;+ } while (len && copy < have);+ if (state->flags & 0x0200)+ state->check = crc32(state->check, next, copy);+ have -= copy;+ next += copy;+ if (len) goto inf_leave;+ }+ else if (state->head != Z_NULL)+ state->head->name = Z_NULL;+ state->length = 0;+ state->mode = COMMENT;+ case COMMENT:+ if (state->flags & 0x1000) {+ if (have == 0) goto inf_leave;+ copy = 0;+ do {+ len = (unsigned)(next[copy++]);+ if (state->head != Z_NULL &&+ state->head->comment != Z_NULL &&+ state->length < state->head->comm_max)+ state->head->comment[state->length++] = len;+ } while (len && copy < have);+ if (state->flags & 0x0200)+ state->check = crc32(state->check, next, copy);+ have -= copy;+ next += copy;+ if (len) goto inf_leave;+ }+ else if (state->head != Z_NULL)+ state->head->comment = Z_NULL;+ state->mode = HCRC;+ case HCRC:+ if (state->flags & 0x0200) {+ NEEDBITS(16);+ if (hold != (state->check & 0xffff)) {+ strm->msg = (char *)"header crc mismatch";+ state->mode = BAD;+ break;+ }+ INITBITS();+ }+ if (state->head != Z_NULL) {+ state->head->hcrc = (int)((state->flags >> 9) & 1);+ state->head->done = 1;+ }+ strm->adler = state->check = crc32(0L, Z_NULL, 0);+ state->mode = TYPE;+ break;+#endif+ case DICTID:+ NEEDBITS(32);+ strm->adler = state->check = REVERSE(hold);+ INITBITS();+ state->mode = DICT;+ case DICT:+ if (state->havedict == 0) {+ RESTORE();+ return Z_NEED_DICT;+ }+ strm->adler = state->check = adler32(0L, Z_NULL, 0);+ state->mode = TYPE;+ case TYPE:+ if (flush == Z_BLOCK) goto inf_leave;+ case TYPEDO:+ if (state->last) {+ BYTEBITS();+ state->mode = CHECK;+ break;+ }+ NEEDBITS(3);+ state->last = BITS(1);+ DROPBITS(1);+ switch (BITS(2)) {+ case 0: /* stored block */+ Tracev((stderr, "inflate: stored block%s\n",+ state->last ? " (last)" : ""));+ state->mode = STORED;+ break;+ case 1: /* fixed block */+ fixedtables(state);+ Tracev((stderr, "inflate: fixed codes block%s\n",+ state->last ? " (last)" : ""));+ state->mode = LEN; /* decode codes */+ break;+ case 2: /* dynamic block */+ Tracev((stderr, "inflate: dynamic codes block%s\n",+ state->last ? " (last)" : ""));+ state->mode = TABLE;+ break;+ case 3:+ strm->msg = (char *)"invalid block type";+ state->mode = BAD;+ }+ DROPBITS(2);+ break;+ case STORED:+ BYTEBITS(); /* go to byte boundary */+ NEEDBITS(32);+ if ((hold & 0xffff) != ((hold >> 16) ^ 0xffff)) {+ strm->msg = (char *)"invalid stored block lengths";+ state->mode = BAD;+ break;+ }+ state->length = (unsigned)hold & 0xffff;+ Tracev((stderr, "inflate: stored length %u\n",+ state->length));+ INITBITS();+ state->mode = COPY;+ case COPY:+ copy = state->length;+ if (copy) {+ if (copy > have) copy = have;+ if (copy > left) copy = left;+ if (copy == 0) goto inf_leave;+ zmemcpy(put, next, copy);+ have -= copy;+ next += copy;+ left -= copy;+ put += copy;+ state->length -= copy;+ break;+ }+ Tracev((stderr, "inflate: stored end\n"));+ state->mode = TYPE;+ break;+ case TABLE:+ NEEDBITS(14);+ state->nlen = BITS(5) + 257;+ DROPBITS(5);+ state->ndist = BITS(5) + 1;+ DROPBITS(5);+ state->ncode = BITS(4) + 4;+ DROPBITS(4);+#ifndef PKZIP_BUG_WORKAROUND+ if (state->nlen > 286 || state->ndist > 30) {+ strm->msg = (char *)"too many length or distance symbols";+ state->mode = BAD;+ break;+ }+#endif+ Tracev((stderr, "inflate: table sizes ok\n"));+ state->have = 0;+ state->mode = LENLENS;+ case LENLENS:+ while (state->have < state->ncode) {+ NEEDBITS(3);+ state->lens[order[state->have++]] = (unsigned short)BITS(3);+ DROPBITS(3);+ }+ while (state->have < 19)+ state->lens[order[state->have++]] = 0;+ state->next = state->codes;+ state->lencode = (code const FAR *)(state->next);+ state->lenbits = 7;+ ret = inflate_table(CODES, state->lens, 19, &(state->next),+ &(state->lenbits), state->work);+ if (ret) {+ strm->msg = (char *)"invalid code lengths set";+ state->mode = BAD;+ break;+ }+ Tracev((stderr, "inflate: code lengths ok\n"));+ state->have = 0;+ state->mode = CODELENS;+ case CODELENS:+ while (state->have < state->nlen + state->ndist) {+ for (;;) {+ this = state->lencode[BITS(state->lenbits)];+ if ((unsigned)(this.bits) <= bits) break;+ PULLBYTE();+ }+ if (this.val < 16) {+ NEEDBITS(this.bits);+ DROPBITS(this.bits);+ state->lens[state->have++] = this.val;+ }+ else {+ if (this.val == 16) {+ NEEDBITS(this.bits + 2);+ DROPBITS(this.bits);+ if (state->have == 0) {+ strm->msg = (char *)"invalid bit length repeat";+ state->mode = BAD;+ break;+ }+ len = state->lens[state->have - 1];+ copy = 3 + BITS(2);+ DROPBITS(2);+ }+ else if (this.val == 17) {+ NEEDBITS(this.bits + 3);+ DROPBITS(this.bits);+ len = 0;+ copy = 3 + BITS(3);+ DROPBITS(3);+ }+ else {+ NEEDBITS(this.bits + 7);+ DROPBITS(this.bits);+ len = 0;+ copy = 11 + BITS(7);+ DROPBITS(7);+ }+ if (state->have + copy > state->nlen + state->ndist) {+ strm->msg = (char *)"invalid bit length repeat";+ state->mode = BAD;+ break;+ }+ while (copy--)+ state->lens[state->have++] = (unsigned short)len;+ }+ }++ /* handle error breaks in while */+ if (state->mode == BAD) break;++ /* build code tables */+ state->next = state->codes;+ state->lencode = (code const FAR *)(state->next);+ state->lenbits = 9;+ ret = inflate_table(LENS, state->lens, state->nlen, &(state->next),+ &(state->lenbits), state->work);+ if (ret) {+ strm->msg = (char *)"invalid literal/lengths set";+ state->mode = BAD;+ break;+ }+ state->distcode = (code const FAR *)(state->next);+ state->distbits = 6;+ ret = inflate_table(DISTS, state->lens + state->nlen, state->ndist,+ &(state->next), &(state->distbits), state->work);+ if (ret) {+ strm->msg = (char *)"invalid distances set";+ state->mode = BAD;+ break;+ }+ Tracev((stderr, "inflate: codes ok\n"));+ state->mode = LEN;+ case LEN:+ if (have >= 6 && left >= 258) {+ RESTORE();+ inflate_fast(strm, out);+ LOAD();+ break;+ }+ for (;;) {+ this = state->lencode[BITS(state->lenbits)];+ if ((unsigned)(this.bits) <= bits) break;+ PULLBYTE();+ }+ if (this.op && (this.op & 0xf0) == 0) {+ last = this;+ for (;;) {+ this = state->lencode[last.val ++ (BITS(last.bits + last.op) >> last.bits)];+ if ((unsigned)(last.bits + this.bits) <= bits) break;+ PULLBYTE();+ }+ DROPBITS(last.bits);+ }+ DROPBITS(this.bits);+ state->length = (unsigned)this.val;+ if ((int)(this.op) == 0) {+ Tracevv((stderr, this.val >= 0x20 && this.val < 0x7f ?+ "inflate: literal '%c'\n" :+ "inflate: literal 0x%02x\n", this.val));+ state->mode = LIT;+ break;+ }+ if (this.op & 32) {+ Tracevv((stderr, "inflate: end of block\n"));+ state->mode = TYPE;+ break;+ }+ if (this.op & 64) {+ strm->msg = (char *)"invalid literal/length code";+ state->mode = BAD;+ break;+ }+ state->extra = (unsigned)(this.op) & 15;+ state->mode = LENEXT;+ case LENEXT:+ if (state->extra) {+ NEEDBITS(state->extra);+ state->length += BITS(state->extra);+ DROPBITS(state->extra);+ }+ Tracevv((stderr, "inflate: length %u\n", state->length));+ state->mode = DIST;+ case DIST:+ for (;;) {+ this = state->distcode[BITS(state->distbits)];+ if ((unsigned)(this.bits) <= bits) break;+ PULLBYTE();+ }+ if ((this.op & 0xf0) == 0) {+ last = this;+ for (;;) {+ this = state->distcode[last.val ++ (BITS(last.bits + last.op) >> last.bits)];+ if ((unsigned)(last.bits + this.bits) <= bits) break;+ PULLBYTE();+ }+ DROPBITS(last.bits);+ }+ DROPBITS(this.bits);+ if (this.op & 64) {+ strm->msg = (char *)"invalid distance code";+ state->mode = BAD;+ break;+ }+ state->offset = (unsigned)this.val;+ state->extra = (unsigned)(this.op) & 15;+ state->mode = DISTEXT;+ case DISTEXT:+ if (state->extra) {+ NEEDBITS(state->extra);+ state->offset += BITS(state->extra);+ DROPBITS(state->extra);+ }+#ifdef INFLATE_STRICT+ if (state->offset > state->dmax) {+ strm->msg = (char *)"invalid distance too far back";+ state->mode = BAD;+ break;+ }+#endif+ if (state->offset > state->whave + out - left) {+ strm->msg = (char *)"invalid distance too far back";+ state->mode = BAD;+ break;+ }+ Tracevv((stderr, "inflate: distance %u\n", state->offset));+ state->mode = MATCH;+ case MATCH:+ if (left == 0) goto inf_leave;+ copy = out - left;+ if (state->offset > copy) { /* copy from window */+ copy = state->offset - copy;+ if (copy > state->write) {+ copy -= state->write;+ from = state->window + (state->wsize - copy);+ }+ else+ from = state->window + (state->write - copy);+ if (copy > state->length) copy = state->length;+ }+ else { /* copy from output */+ from = put - state->offset;+ copy = state->length;+ }+ if (copy > left) copy = left;+ left -= copy;+ state->length -= copy;+ do {+ *put++ = *from++;+ } while (--copy);+ if (state->length == 0) state->mode = LEN;+ break;+ case LIT:+ if (left == 0) goto inf_leave;+ *put++ = (unsigned char)(state->length);+ left--;+ state->mode = LEN;+ break;+ case CHECK:+ if (state->wrap) {+ NEEDBITS(32);+ out -= left;+ strm->total_out += out;+ state->total += out;+ if (out)+ strm->adler = state->check =+ UPDATE(state->check, put - out, out);+ out = left;+ if ((+#ifdef GUNZIP+ state->flags ? hold :+#endif+ REVERSE(hold)) != state->check) {+ strm->msg = (char *)"incorrect data check";+ state->mode = BAD;+ break;+ }+ INITBITS();+ Tracev((stderr, "inflate: check matches trailer\n"));+ }+#ifdef GUNZIP+ state->mode = LENGTH;+ case LENGTH:+ if (state->wrap && state->flags) {+ NEEDBITS(32);+ if (hold != (state->total & 0xffffffffUL)) {+ strm->msg = (char *)"incorrect length check";+ state->mode = BAD;+ break;+ }+ INITBITS();+ Tracev((stderr, "inflate: length matches trailer\n"));+ }+#endif+ state->mode = DONE;+ case DONE:+ ret = Z_STREAM_END;+ goto inf_leave;+ case BAD:+ ret = Z_DATA_ERROR;+ goto inf_leave;+ case MEM:+ return Z_MEM_ERROR;+ case SYNC:+ default:+ return Z_STREAM_ERROR;+ }++ /*+ Return from inflate(), updating the total counts and the check value.+ If there was no progress during the inflate() call, return a buffer+ error. Call updatewindow() to create and/or update the window state.+ Note: a memory error from inflate() is non-recoverable.+ */+ inf_leave:+ RESTORE();+ if (state->wsize || (state->mode < CHECK && out != strm->avail_out))+ if (updatewindow(strm, out)) {+ state->mode = MEM;+ return Z_MEM_ERROR;+ }+ in -= strm->avail_in;+ out -= strm->avail_out;+ strm->total_in += in;+ strm->total_out += out;+ state->total += out;+ if (state->wrap && out)+ strm->adler = state->check =+ UPDATE(state->check, strm->next_out - out, out);+ strm->data_type = state->bits + (state->last ? 64 : 0) ++ (state->mode == TYPE ? 128 : 0);+ if (((in == 0 && out == 0) || flush == Z_FINISH) && ret == Z_OK)+ ret = Z_BUF_ERROR;+ return ret;+}++int ZEXPORT inflateEnd(strm)+z_streamp strm;+{+ struct inflate_state FAR *state;+ if (strm == Z_NULL || strm->state == Z_NULL || strm->zfree == (free_func)0)+ return Z_STREAM_ERROR;+ state = (struct inflate_state FAR *)strm->state;+ if (state->window != Z_NULL) ZFREE(strm, state->window);+ ZFREE(strm, strm->state);+ strm->state = Z_NULL;+ Tracev((stderr, "inflate: end\n"));+ return Z_OK;+}++int ZEXPORT inflateSetDictionary(strm, dictionary, dictLength)+z_streamp strm;+const Bytef *dictionary;+uInt dictLength;+{+ struct inflate_state FAR *state;+ unsigned long id;++ /* check state */+ if (strm == Z_NULL || strm->state == Z_NULL) return Z_STREAM_ERROR;+ state = (struct inflate_state FAR *)strm->state;+ if (state->wrap != 0 && state->mode != DICT)+ return Z_STREAM_ERROR;++ /* check for correct dictionary id */+ if (state->mode == DICT) {+ id = adler32(0L, Z_NULL, 0);+ id = adler32(id, dictionary, dictLength);+ if (id != state->check)+ return Z_DATA_ERROR;+ }++ /* copy dictionary to window */+ if (updatewindow(strm, strm->avail_out)) {+ state->mode = MEM;+ return Z_MEM_ERROR;+ }+ if (dictLength > state->wsize) {+ zmemcpy(state->window, dictionary + dictLength - state->wsize,+ state->wsize);+ state->whave = state->wsize;+ }+ else {+ zmemcpy(state->window + state->wsize - dictLength, dictionary,+ dictLength);+ state->whave = dictLength;+ }+ state->havedict = 1;+ Tracev((stderr, "inflate: dictionary set\n"));+ return Z_OK;+}++int ZEXPORT inflateGetHeader(strm, head)+z_streamp strm;+gz_headerp head;+{+ struct inflate_state FAR *state;++ /* check state */+ if (strm == Z_NULL || strm->state == Z_NULL) return Z_STREAM_ERROR;+ state = (struct inflate_state FAR *)strm->state;+ if ((state->wrap & 2) == 0) return Z_STREAM_ERROR;++ /* save header structure */+ state->head = head;+ head->done = 0;+ return Z_OK;+}++/*+ Search buf[0..len-1] for the pattern: 0, 0, 0xff, 0xff. Return when found+ or when out of input. When called, *have is the number of pattern bytes+ found in order so far, in 0..3. On return *have is updated to the new+ state. If on return *have equals four, then the pattern was found and the+ return value is how many bytes were read including the last byte of the+ pattern. If *have is less than four, then the pattern has not been found+ yet and the return value is len. In the latter case, syncsearch() can be+ called again with more data and the *have state. *have is initialized to+ zero for the first call.+ */+local unsigned syncsearch(have, buf, len)+unsigned FAR *have;+unsigned char FAR *buf;+unsigned len;+{+ unsigned got;+ unsigned next;++ got = *have;+ next = 0;+ while (next < len && got < 4) {+ if ((int)(buf[next]) == (got < 2 ? 0 : 0xff))+ got++;+ else if (buf[next])+ got = 0;+ else+ got = 4 - got;+ next++;+ }+ *have = got;+ return next;+}++int ZEXPORT inflateSync(strm)+z_streamp strm;+{+ unsigned len; /* number of bytes to look at or looked at */+ unsigned long in, out; /* temporary to save total_in and total_out */+ unsigned char buf[4]; /* to restore bit buffer to byte string */+ struct inflate_state FAR *state;++ /* check parameters */+ if (strm == Z_NULL || strm->state == Z_NULL) return Z_STREAM_ERROR;+ state = (struct inflate_state FAR *)strm->state;+ if (strm->avail_in == 0 && state->bits < 8) return Z_BUF_ERROR;++ /* if first time, start search in bit buffer */+ if (state->mode != SYNC) {+ state->mode = SYNC;+ state->hold <<= state->bits & 7;+ state->bits -= state->bits & 7;+ len = 0;+ while (state->bits >= 8) {+ buf[len++] = (unsigned char)(state->hold);+ state->hold >>= 8;+ state->bits -= 8;+ }+ state->have = 0;+ syncsearch(&(state->have), buf, len);+ }++ /* search available input */+ len = syncsearch(&(state->have), strm->next_in, strm->avail_in);+ strm->avail_in -= len;+ strm->next_in += len;+ strm->total_in += len;++ /* return no joy or set up to restart inflate() on a new block */+ if (state->have != 4) return Z_DATA_ERROR;+ in = strm->total_in; out = strm->total_out;+ inflateReset(strm);+ strm->total_in = in; strm->total_out = out;+ state->mode = TYPE;+ return Z_OK;+}++/*+ Returns true if inflate is currently at the end of a block generated by+ Z_SYNC_FLUSH or Z_FULL_FLUSH. This function is used by one PPP+ implementation to provide an additional safety check. PPP uses+ Z_SYNC_FLUSH but removes the length bytes of the resulting empty stored+ block. When decompressing, PPP checks that at the end of input packet,+ inflate is waiting for these length bytes.+ */+int ZEXPORT inflateSyncPoint(strm)+z_streamp strm;+{+ struct inflate_state FAR *state;++ if (strm == Z_NULL || strm->state == Z_NULL) return Z_STREAM_ERROR;+ state = (struct inflate_state FAR *)strm->state;+ return state->mode == STORED && state->bits == 0;+}++int ZEXPORT inflateCopy(dest, source)+z_streamp dest;+z_streamp source;+{+ struct inflate_state FAR *state;+ struct inflate_state FAR *copy;+ unsigned char FAR *window;+ unsigned wsize;++ /* check input */+ if (dest == Z_NULL || source == Z_NULL || source->state == Z_NULL ||+ source->zalloc == (alloc_func)0 || source->zfree == (free_func)0)+ return Z_STREAM_ERROR;+ state = (struct inflate_state FAR *)source->state;++ /* allocate space */+ copy = (struct inflate_state FAR *)+ ZALLOC(source, 1, sizeof(struct inflate_state));+ if (copy == Z_NULL) return Z_MEM_ERROR;+ window = Z_NULL;+ if (state->window != Z_NULL) {+ window = (unsigned char FAR *)+ ZALLOC(source, 1U << state->wbits, sizeof(unsigned char));+ if (window == Z_NULL) {+ ZFREE(source, copy);+ return Z_MEM_ERROR;+ }+ }++ /* copy state */+ zmemcpy(dest, source, sizeof(z_stream));+ zmemcpy(copy, state, sizeof(struct inflate_state));+ if (state->lencode >= state->codes &&+ state->lencode <= state->codes + ENOUGH - 1) {+ copy->lencode = copy->codes + (state->lencode - state->codes);+ copy->distcode = copy->codes + (state->distcode - state->codes);+ }+ copy->next = copy->codes + (state->next - state->codes);+ if (window != Z_NULL) {+ wsize = 1U << state->wbits;+ zmemcpy(window, state->window, wsize);+ }+ copy->window = window;+ dest->state = (struct internal_state FAR *)copy;+ return Z_OK;+}
+ cbits/inftrees.c view
@@ -0,0 +1,329 @@+/* inftrees.c -- generate Huffman trees for efficient decoding+ * Copyright (C) 1995-2005 Mark Adler+ * For conditions of distribution and use, see copyright notice in zlib.h+ */++#include "zutil.h"+#include "inftrees.h"++#define MAXBITS 15++const char inflate_copyright[] =+ " inflate 1.2.3 Copyright 1995-2005 Mark Adler ";+/*+ If you use the zlib library in a product, an acknowledgment is welcome+ in the documentation of your product. If for some reason you cannot+ include such an acknowledgment, I would appreciate that you keep this+ copyright string in the executable of your product.+ */++/*+ Build a set of tables to decode the provided canonical Huffman code.+ The code lengths are lens[0..codes-1]. The result starts at *table,+ whose indices are 0..2^bits-1. work is a writable array of at least+ lens shorts, which is used as a work area. type is the type of code+ to be generated, CODES, LENS, or DISTS. On return, zero is success,+ -1 is an invalid code, and +1 means that ENOUGH isn't enough. table+ on return points to the next available entry's address. bits is the+ requested root table index bits, and on return it is the actual root+ table index bits. It will differ if the request is greater than the+ longest code or if it is less than the shortest code.+ */+int inflate_table(type, lens, codes, table, bits, work)+codetype type;+unsigned short FAR *lens;+unsigned codes;+code FAR * FAR *table;+unsigned FAR *bits;+unsigned short FAR *work;+{+ unsigned len; /* a code's length in bits */+ unsigned sym; /* index of code symbols */+ unsigned min, max; /* minimum and maximum code lengths */+ unsigned root; /* number of index bits for root table */+ unsigned curr; /* number of index bits for current table */+ unsigned drop; /* code bits to drop for sub-table */+ int left; /* number of prefix codes available */+ unsigned used; /* code entries in table used */+ unsigned huff; /* Huffman code */+ unsigned incr; /* for incrementing code, index */+ unsigned fill; /* index for replicating entries */+ unsigned low; /* low bits for current root entry */+ unsigned mask; /* mask for low root bits */+ code this; /* table entry for duplication */+ code FAR *next; /* next available space in table */+ const unsigned short FAR *base; /* base value table to use */+ const unsigned short FAR *extra; /* extra bits table to use */+ int end; /* use base and extra for symbol > end */+ unsigned short count[MAXBITS+1]; /* number of codes of each length */+ unsigned short offs[MAXBITS+1]; /* offsets in table for each length */+ static const unsigned short lbase[31] = { /* Length codes 257..285 base */+ 3, 4, 5, 6, 7, 8, 9, 10, 11, 13, 15, 17, 19, 23, 27, 31,+ 35, 43, 51, 59, 67, 83, 99, 115, 131, 163, 195, 227, 258, 0, 0};+ static const unsigned short lext[31] = { /* Length codes 257..285 extra */+ 16, 16, 16, 16, 16, 16, 16, 16, 17, 17, 17, 17, 18, 18, 18, 18,+ 19, 19, 19, 19, 20, 20, 20, 20, 21, 21, 21, 21, 16, 201, 196};+ static const unsigned short dbase[32] = { /* Distance codes 0..29 base */+ 1, 2, 3, 4, 5, 7, 9, 13, 17, 25, 33, 49, 65, 97, 129, 193,+ 257, 385, 513, 769, 1025, 1537, 2049, 3073, 4097, 6145,+ 8193, 12289, 16385, 24577, 0, 0};+ static const unsigned short dext[32] = { /* Distance codes 0..29 extra */+ 16, 16, 16, 16, 17, 17, 18, 18, 19, 19, 20, 20, 21, 21, 22, 22,+ 23, 23, 24, 24, 25, 25, 26, 26, 27, 27,+ 28, 28, 29, 29, 64, 64};++ /*+ Process a set of code lengths to create a canonical Huffman code. The+ code lengths are lens[0..codes-1]. Each length corresponds to the+ symbols 0..codes-1. The Huffman code is generated by first sorting the+ symbols by length from short to long, and retaining the symbol order+ for codes with equal lengths. Then the code starts with all zero bits+ for the first code of the shortest length, and the codes are integer+ increments for the same length, and zeros are appended as the length+ increases. For the deflate format, these bits are stored backwards+ from their more natural integer increment ordering, and so when the+ decoding tables are built in the large loop below, the integer codes+ are incremented backwards.++ This routine assumes, but does not check, that all of the entries in+ lens[] are in the range 0..MAXBITS. The caller must assure this.+ 1..MAXBITS is interpreted as that code length. zero means that that+ symbol does not occur in this code.++ The codes are sorted by computing a count of codes for each length,+ creating from that a table of starting indices for each length in the+ sorted table, and then entering the symbols in order in the sorted+ table. The sorted table is work[], with that space being provided by+ the caller.++ The length counts are used for other purposes as well, i.e. finding+ the minimum and maximum length codes, determining if there are any+ codes at all, checking for a valid set of lengths, and looking ahead+ at length counts to determine sub-table sizes when building the+ decoding tables.+ */++ /* accumulate lengths for codes (assumes lens[] all in 0..MAXBITS) */+ for (len = 0; len <= MAXBITS; len++)+ count[len] = 0;+ for (sym = 0; sym < codes; sym++)+ count[lens[sym]]++;++ /* bound code lengths, force root to be within code lengths */+ root = *bits;+ for (max = MAXBITS; max >= 1; max--)+ if (count[max] != 0) break;+ if (root > max) root = max;+ if (max == 0) { /* no symbols to code at all */+ this.op = (unsigned char)64; /* invalid code marker */+ this.bits = (unsigned char)1;+ this.val = (unsigned short)0;+ *(*table)++ = this; /* make a table to force an error */+ *(*table)++ = this;+ *bits = 1;+ return 0; /* no symbols, but wait for decoding to report error */+ }+ for (min = 1; min <= MAXBITS; min++)+ if (count[min] != 0) break;+ if (root < min) root = min;++ /* check for an over-subscribed or incomplete set of lengths */+ left = 1;+ for (len = 1; len <= MAXBITS; len++) {+ left <<= 1;+ left -= count[len];+ if (left < 0) return -1; /* over-subscribed */+ }+ if (left > 0 && (type == CODES || max != 1))+ return -1; /* incomplete set */++ /* generate offsets into symbol table for each length for sorting */+ offs[1] = 0;+ for (len = 1; len < MAXBITS; len++)+ offs[len + 1] = offs[len] + count[len];++ /* sort symbols by length, by symbol order within each length */+ for (sym = 0; sym < codes; sym++)+ if (lens[sym] != 0) work[offs[lens[sym]]++] = (unsigned short)sym;++ /*+ Create and fill in decoding tables. In this loop, the table being+ filled is at next and has curr index bits. The code being used is huff+ with length len. That code is converted to an index by dropping drop+ bits off of the bottom. For codes where len is less than drop + curr,+ those top drop + curr - len bits are incremented through all values to+ fill the table with replicated entries.++ root is the number of index bits for the root table. When len exceeds+ root, sub-tables are created pointed to by the root entry with an index+ of the low root bits of huff. This is saved in low to check for when a+ new sub-table should be started. drop is zero when the root table is+ being filled, and drop is root when sub-tables are being filled.++ When a new sub-table is needed, it is necessary to look ahead in the+ code lengths to determine what size sub-table is needed. The length+ counts are used for this, and so count[] is decremented as codes are+ entered in the tables.++ used keeps track of how many table entries have been allocated from the+ provided *table space. It is checked when a LENS table is being made+ against the space in *table, ENOUGH, minus the maximum space needed by+ the worst case distance code, MAXD. This should never happen, but the+ sufficiency of ENOUGH has not been proven exhaustively, hence the check.+ This assumes that when type == LENS, bits == 9.++ sym increments through all symbols, and the loop terminates when+ all codes of length max, i.e. all codes, have been processed. This+ routine permits incomplete codes, so another loop after this one fills+ in the rest of the decoding tables with invalid code markers.+ */++ /* set up for code type */+ switch (type) {+ case CODES:+ base = extra = work; /* dummy value--not used */+ end = 19;+ break;+ case LENS:+ base = lbase;+ base -= 257;+ extra = lext;+ extra -= 257;+ end = 256;+ break;+ default: /* DISTS */+ base = dbase;+ extra = dext;+ end = -1;+ }++ /* initialize state for loop */+ huff = 0; /* starting code */+ sym = 0; /* starting code symbol */+ len = min; /* starting code length */+ next = *table; /* current table to fill in */+ curr = root; /* current table index bits */+ drop = 0; /* current bits to drop from code for index */+ low = (unsigned)(-1); /* trigger new sub-table when len > root */+ used = 1U << root; /* use root table entries */+ mask = used - 1; /* mask for comparing low */++ /* check available table space */+ if (type == LENS && used >= ENOUGH - MAXD)+ return 1;++ /* process all codes and make table entries */+ for (;;) {+ /* create table entry */+ this.bits = (unsigned char)(len - drop);+ if ((int)(work[sym]) < end) {+ this.op = (unsigned char)0;+ this.val = work[sym];+ }+ else if ((int)(work[sym]) > end) {+ this.op = (unsigned char)(extra[work[sym]]);+ this.val = base[work[sym]];+ }+ else {+ this.op = (unsigned char)(32 + 64); /* end of block */+ this.val = 0;+ }++ /* replicate for those indices with low len bits equal to huff */+ incr = 1U << (len - drop);+ fill = 1U << curr;+ min = fill; /* save offset to next table */+ do {+ fill -= incr;+ next[(huff >> drop) + fill] = this;+ } while (fill != 0);++ /* backwards increment the len-bit code huff */+ incr = 1U << (len - 1);+ while (huff & incr)+ incr >>= 1;+ if (incr != 0) {+ huff &= incr - 1;+ huff += incr;+ }+ else+ huff = 0;++ /* go to next symbol, update count, len */+ sym++;+ if (--(count[len]) == 0) {+ if (len == max) break;+ len = lens[work[sym]];+ }++ /* create new sub-table if needed */+ if (len > root && (huff & mask) != low) {+ /* if first time, transition to sub-tables */+ if (drop == 0)+ drop = root;++ /* increment past last table */+ next += min; /* here min is 1 << curr */++ /* determine length of next table */+ curr = len - drop;+ left = (int)(1 << curr);+ while (curr + drop < max) {+ left -= count[curr + drop];+ if (left <= 0) break;+ curr++;+ left <<= 1;+ }++ /* check for enough space */+ used += 1U << curr;+ if (type == LENS && used >= ENOUGH - MAXD)+ return 1;++ /* point entry in root table to sub-table */+ low = huff & mask;+ (*table)[low].op = (unsigned char)curr;+ (*table)[low].bits = (unsigned char)root;+ (*table)[low].val = (unsigned short)(next - *table);+ }+ }++ /*+ Fill in rest of table for incomplete codes. This loop is similar to the+ loop above in incrementing huff for table indices. It is assumed that+ len is equal to curr + drop, so there is no loop needed to increment+ through high index bits. When the current sub-table is filled, the loop+ drops back to the root table to fill in any remaining entries there.+ */+ this.op = (unsigned char)64; /* invalid code marker */+ this.bits = (unsigned char)(len - drop);+ this.val = (unsigned short)0;+ while (huff != 0) {+ /* when done with sub-table, drop back to root table */+ if (drop != 0 && (huff & mask) != low) {+ drop = 0;+ len = root;+ next = *table;+ this.bits = (unsigned char)len;+ }++ /* put invalid code marker in table */+ next[huff >> drop] = this;++ /* backwards increment the len-bit code huff */+ incr = 1U << (len - 1);+ while (huff & incr)+ incr >>= 1;+ if (incr != 0) {+ huff &= incr - 1;+ huff += incr;+ }+ else+ huff = 0;+ }++ /* set return parameters */+ *table += used;+ *bits = root;+ return 0;+}
+ cbits/trees.c view
@@ -0,0 +1,1219 @@+/* trees.c -- output deflated data using Huffman coding+ * Copyright (C) 1995-2005 Jean-loup Gailly+ * For conditions of distribution and use, see copyright notice in zlib.h+ */++/*+ * ALGORITHM+ *+ * The "deflation" process uses several Huffman trees. The more+ * common source values are represented by shorter bit sequences.+ *+ * Each code tree is stored in a compressed form which is itself+ * a Huffman encoding of the lengths of all the code strings (in+ * ascending order by source values). The actual code strings are+ * reconstructed from the lengths in the inflate process, as described+ * in the deflate specification.+ *+ * REFERENCES+ *+ * Deutsch, L.P.,"'Deflate' Compressed Data Format Specification".+ * Available in ftp.uu.net:/pub/archiving/zip/doc/deflate-1.1.doc+ *+ * Storer, James A.+ * Data Compression: Methods and Theory, pp. 49-50.+ * Computer Science Press, 1988. ISBN 0-7167-8156-5.+ *+ * Sedgewick, R.+ * Algorithms, p290.+ * Addison-Wesley, 1983. ISBN 0-201-06672-6.+ */++/* @(#) $Id$ */++/* #define GEN_TREES_H */++#include "deflate.h"++#ifdef DEBUG+# include <ctype.h>+#endif++/* ===========================================================================+ * Constants+ */++#define MAX_BL_BITS 7+/* Bit length codes must not exceed MAX_BL_BITS bits */++#define END_BLOCK 256+/* end of block literal code */++#define REP_3_6 16+/* repeat previous bit length 3-6 times (2 bits of repeat count) */++#define REPZ_3_10 17+/* repeat a zero length 3-10 times (3 bits of repeat count) */++#define REPZ_11_138 18+/* repeat a zero length 11-138 times (7 bits of repeat count) */++local const int extra_lbits[LENGTH_CODES] /* extra bits for each length code */+ = {0,0,0,0,0,0,0,0,1,1,1,1,2,2,2,2,3,3,3,3,4,4,4,4,5,5,5,5,0};++local const int extra_dbits[D_CODES] /* extra bits for each distance code */+ = {0,0,0,0,1,1,2,2,3,3,4,4,5,5,6,6,7,7,8,8,9,9,10,10,11,11,12,12,13,13};++local const int extra_blbits[BL_CODES]/* extra bits for each bit length code */+ = {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,2,3,7};++local const uch bl_order[BL_CODES]+ = {16,17,18,0,8,7,9,6,10,5,11,4,12,3,13,2,14,1,15};+/* The lengths of the bit length codes are sent in order of decreasing+ * probability, to avoid transmitting the lengths for unused bit length codes.+ */++#define Buf_size (8 * 2*sizeof(char))+/* Number of bits used within bi_buf. (bi_buf might be implemented on+ * more than 16 bits on some systems.)+ */++/* ===========================================================================+ * Local data. These are initialized only once.+ */++#define DIST_CODE_LEN 512 /* see definition of array dist_code below */++#if defined(GEN_TREES_H) || !defined(STDC)+/* non ANSI compilers may not accept trees.h */++local ct_data static_ltree[L_CODES+2];+/* The static literal tree. Since the bit lengths are imposed, there is no+ * need for the L_CODES extra codes used during heap construction. However+ * The codes 286 and 287 are needed to build a canonical tree (see _tr_init+ * below).+ */++local ct_data static_dtree[D_CODES];+/* The static distance tree. (Actually a trivial tree since all codes use+ * 5 bits.)+ */++uch _dist_code[DIST_CODE_LEN];+/* Distance codes. The first 256 values correspond to the distances+ * 3 .. 258, the last 256 values correspond to the top 8 bits of+ * the 15 bit distances.+ */++uch _length_code[MAX_MATCH-MIN_MATCH+1];+/* length code for each normalized match length (0 == MIN_MATCH) */++local int base_length[LENGTH_CODES];+/* First normalized length for each code (0 = MIN_MATCH) */++local int base_dist[D_CODES];+/* First normalized distance for each code (0 = distance of 1) */++#else+# include "trees.h"+#endif /* GEN_TREES_H */++struct static_tree_desc_s {+ const ct_data *static_tree; /* static tree or NULL */+ const intf *extra_bits; /* extra bits for each code or NULL */+ int extra_base; /* base index for extra_bits */+ int elems; /* max number of elements in the tree */+ int max_length; /* max bit length for the codes */+};++local static_tree_desc static_l_desc =+{static_ltree, extra_lbits, LITERALS+1, L_CODES, MAX_BITS};++local static_tree_desc static_d_desc =+{static_dtree, extra_dbits, 0, D_CODES, MAX_BITS};++local static_tree_desc static_bl_desc =+{(const ct_data *)0, extra_blbits, 0, BL_CODES, MAX_BL_BITS};++/* ===========================================================================+ * Local (static) routines in this file.+ */++local void tr_static_init OF((void));+local void init_block OF((deflate_state *s));+local void pqdownheap OF((deflate_state *s, ct_data *tree, int k));+local void gen_bitlen OF((deflate_state *s, tree_desc *desc));+local void gen_codes OF((ct_data *tree, int max_code, ushf *bl_count));+local void build_tree OF((deflate_state *s, tree_desc *desc));+local void scan_tree OF((deflate_state *s, ct_data *tree, int max_code));+local void send_tree OF((deflate_state *s, ct_data *tree, int max_code));+local int build_bl_tree OF((deflate_state *s));+local void send_all_trees OF((deflate_state *s, int lcodes, int dcodes,+ int blcodes));+local void compress_block OF((deflate_state *s, ct_data *ltree,+ ct_data *dtree));+local void set_data_type OF((deflate_state *s));+local unsigned bi_reverse OF((unsigned value, int length));+local void bi_windup OF((deflate_state *s));+local void bi_flush OF((deflate_state *s));+local void copy_block OF((deflate_state *s, charf *buf, unsigned len,+ int header));++#ifdef GEN_TREES_H+local void gen_trees_header OF((void));+#endif++#ifndef DEBUG+# define send_code(s, c, tree) send_bits(s, tree[c].Code, tree[c].Len)+ /* Send a code of the given tree. c and tree must not have side effects */++#else /* DEBUG */+# define send_code(s, c, tree) \+ { if (z_verbose>2) fprintf(stderr,"\ncd %3d ",(c)); \+ send_bits(s, tree[c].Code, tree[c].Len); }+#endif++/* ===========================================================================+ * Output a short LSB first on the stream.+ * IN assertion: there is enough room in pendingBuf.+ */+#define put_short(s, w) { \+ put_byte(s, (uch)((w) & 0xff)); \+ put_byte(s, (uch)((ush)(w) >> 8)); \+}++/* ===========================================================================+ * Send a value on a given number of bits.+ * IN assertion: length <= 16 and value fits in length bits.+ */+#ifdef DEBUG+local void send_bits OF((deflate_state *s, int value, int length));++local void send_bits(s, value, length)+ deflate_state *s;+ int value; /* value to send */+ int length; /* number of bits */+{+ Tracevv((stderr," l %2d v %4x ", length, value));+ Assert(length > 0 && length <= 15, "invalid length");+ s->bits_sent += (ulg)length;++ /* If not enough room in bi_buf, use (valid) bits from bi_buf and+ * (16 - bi_valid) bits from value, leaving (width - (16-bi_valid))+ * unused bits in value.+ */+ if (s->bi_valid > (int)Buf_size - length) {+ s->bi_buf |= (value << s->bi_valid);+ put_short(s, s->bi_buf);+ s->bi_buf = (ush)value >> (Buf_size - s->bi_valid);+ s->bi_valid += length - Buf_size;+ } else {+ s->bi_buf |= value << s->bi_valid;+ s->bi_valid += length;+ }+}+#else /* !DEBUG */++#define send_bits(s, value, length) \+{ int len = length;\+ if (s->bi_valid > (int)Buf_size - len) {\+ int val = value;\+ s->bi_buf |= (val << s->bi_valid);\+ put_short(s, s->bi_buf);\+ s->bi_buf = (ush)val >> (Buf_size - s->bi_valid);\+ s->bi_valid += len - Buf_size;\+ } else {\+ s->bi_buf |= (value) << s->bi_valid;\+ s->bi_valid += len;\+ }\+}+#endif /* DEBUG */+++/* the arguments must not have side effects */++/* ===========================================================================+ * Initialize the various 'constant' tables.+ */+local void tr_static_init()+{+#if defined(GEN_TREES_H) || !defined(STDC)+ static int static_init_done = 0;+ int n; /* iterates over tree elements */+ int bits; /* bit counter */+ int length; /* length value */+ int code; /* code value */+ int dist; /* distance index */+ ush bl_count[MAX_BITS+1];+ /* number of codes at each bit length for an optimal tree */++ if (static_init_done) return;++ /* For some embedded targets, global variables are not initialized: */+ static_l_desc.static_tree = static_ltree;+ static_l_desc.extra_bits = extra_lbits;+ static_d_desc.static_tree = static_dtree;+ static_d_desc.extra_bits = extra_dbits;+ static_bl_desc.extra_bits = extra_blbits;++ /* Initialize the mapping length (0..255) -> length code (0..28) */+ length = 0;+ for (code = 0; code < LENGTH_CODES-1; code++) {+ base_length[code] = length;+ for (n = 0; n < (1<<extra_lbits[code]); n++) {+ _length_code[length++] = (uch)code;+ }+ }+ Assert (length == 256, "tr_static_init: length != 256");+ /* Note that the length 255 (match length 258) can be represented+ * in two different ways: code 284 + 5 bits or code 285, so we+ * overwrite length_code[255] to use the best encoding:+ */+ _length_code[length-1] = (uch)code;++ /* Initialize the mapping dist (0..32K) -> dist code (0..29) */+ dist = 0;+ for (code = 0 ; code < 16; code++) {+ base_dist[code] = dist;+ for (n = 0; n < (1<<extra_dbits[code]); n++) {+ _dist_code[dist++] = (uch)code;+ }+ }+ Assert (dist == 256, "tr_static_init: dist != 256");+ dist >>= 7; /* from now on, all distances are divided by 128 */+ for ( ; code < D_CODES; code++) {+ base_dist[code] = dist << 7;+ for (n = 0; n < (1<<(extra_dbits[code]-7)); n++) {+ _dist_code[256 + dist++] = (uch)code;+ }+ }+ Assert (dist == 256, "tr_static_init: 256+dist != 512");++ /* Construct the codes of the static literal tree */+ for (bits = 0; bits <= MAX_BITS; bits++) bl_count[bits] = 0;+ n = 0;+ while (n <= 143) static_ltree[n++].Len = 8, bl_count[8]++;+ while (n <= 255) static_ltree[n++].Len = 9, bl_count[9]++;+ while (n <= 279) static_ltree[n++].Len = 7, bl_count[7]++;+ while (n <= 287) static_ltree[n++].Len = 8, bl_count[8]++;+ /* Codes 286 and 287 do not exist, but we must include them in the+ * tree construction to get a canonical Huffman tree (longest code+ * all ones)+ */+ gen_codes((ct_data *)static_ltree, L_CODES+1, bl_count);++ /* The static distance tree is trivial: */+ for (n = 0; n < D_CODES; n++) {+ static_dtree[n].Len = 5;+ static_dtree[n].Code = bi_reverse((unsigned)n, 5);+ }+ static_init_done = 1;++# ifdef GEN_TREES_H+ gen_trees_header();+# endif+#endif /* defined(GEN_TREES_H) || !defined(STDC) */+}++/* ===========================================================================+ * Genererate the file trees.h describing the static trees.+ */+#ifdef GEN_TREES_H+# ifndef DEBUG+# include <stdio.h>+# endif++# define SEPARATOR(i, last, width) \+ ((i) == (last)? "\n};\n\n" : \+ ((i) % (width) == (width)-1 ? ",\n" : ", "))++void gen_trees_header()+{+ FILE *header = fopen("trees.h", "w");+ int i;++ Assert (header != NULL, "Can't open trees.h");+ fprintf(header,+ "/* header created automatically with -DGEN_TREES_H */\n\n");++ fprintf(header, "local const ct_data static_ltree[L_CODES+2] = {\n");+ for (i = 0; i < L_CODES+2; i++) {+ fprintf(header, "{{%3u},{%3u}}%s", static_ltree[i].Code,+ static_ltree[i].Len, SEPARATOR(i, L_CODES+1, 5));+ }++ fprintf(header, "local const ct_data static_dtree[D_CODES] = {\n");+ for (i = 0; i < D_CODES; i++) {+ fprintf(header, "{{%2u},{%2u}}%s", static_dtree[i].Code,+ static_dtree[i].Len, SEPARATOR(i, D_CODES-1, 5));+ }++ fprintf(header, "const uch _dist_code[DIST_CODE_LEN] = {\n");+ for (i = 0; i < DIST_CODE_LEN; i++) {+ fprintf(header, "%2u%s", _dist_code[i],+ SEPARATOR(i, DIST_CODE_LEN-1, 20));+ }++ fprintf(header, "const uch _length_code[MAX_MATCH-MIN_MATCH+1]= {\n");+ for (i = 0; i < MAX_MATCH-MIN_MATCH+1; i++) {+ fprintf(header, "%2u%s", _length_code[i],+ SEPARATOR(i, MAX_MATCH-MIN_MATCH, 20));+ }++ fprintf(header, "local const int base_length[LENGTH_CODES] = {\n");+ for (i = 0; i < LENGTH_CODES; i++) {+ fprintf(header, "%1u%s", base_length[i],+ SEPARATOR(i, LENGTH_CODES-1, 20));+ }++ fprintf(header, "local const int base_dist[D_CODES] = {\n");+ for (i = 0; i < D_CODES; i++) {+ fprintf(header, "%5u%s", base_dist[i],+ SEPARATOR(i, D_CODES-1, 10));+ }++ fclose(header);+}+#endif /* GEN_TREES_H */++/* ===========================================================================+ * Initialize the tree data structures for a new zlib stream.+ */+void _tr_init(s)+ deflate_state *s;+{+ tr_static_init();++ s->l_desc.dyn_tree = s->dyn_ltree;+ s->l_desc.stat_desc = &static_l_desc;++ s->d_desc.dyn_tree = s->dyn_dtree;+ s->d_desc.stat_desc = &static_d_desc;++ s->bl_desc.dyn_tree = s->bl_tree;+ s->bl_desc.stat_desc = &static_bl_desc;++ s->bi_buf = 0;+ s->bi_valid = 0;+ s->last_eob_len = 8; /* enough lookahead for inflate */+#ifdef DEBUG+ s->compressed_len = 0L;+ s->bits_sent = 0L;+#endif++ /* Initialize the first block of the first file: */+ init_block(s);+}++/* ===========================================================================+ * Initialize a new block.+ */+local void init_block(s)+ deflate_state *s;+{+ int n; /* iterates over tree elements */++ /* Initialize the trees. */+ for (n = 0; n < L_CODES; n++) s->dyn_ltree[n].Freq = 0;+ for (n = 0; n < D_CODES; n++) s->dyn_dtree[n].Freq = 0;+ for (n = 0; n < BL_CODES; n++) s->bl_tree[n].Freq = 0;++ s->dyn_ltree[END_BLOCK].Freq = 1;+ s->opt_len = s->static_len = 0L;+ s->last_lit = s->matches = 0;+}++#define SMALLEST 1+/* Index within the heap array of least frequent node in the Huffman tree */+++/* ===========================================================================+ * Remove the smallest element from the heap and recreate the heap with+ * one less element. Updates heap and heap_len.+ */+#define pqremove(s, tree, top) \+{\+ top = s->heap[SMALLEST]; \+ s->heap[SMALLEST] = s->heap[s->heap_len--]; \+ pqdownheap(s, tree, SMALLEST); \+}++/* ===========================================================================+ * Compares to subtrees, using the tree depth as tie breaker when+ * the subtrees have equal frequency. This minimizes the worst case length.+ */+#define smaller(tree, n, m, depth) \+ (tree[n].Freq < tree[m].Freq || \+ (tree[n].Freq == tree[m].Freq && depth[n] <= depth[m]))++/* ===========================================================================+ * Restore the heap property by moving down the tree starting at node k,+ * exchanging a node with the smallest of its two sons if necessary, stopping+ * when the heap property is re-established (each father smaller than its+ * two sons).+ */+local void pqdownheap(s, tree, k)+ deflate_state *s;+ ct_data *tree; /* the tree to restore */+ int k; /* node to move down */+{+ int v = s->heap[k];+ int j = k << 1; /* left son of k */+ while (j <= s->heap_len) {+ /* Set j to the smallest of the two sons: */+ if (j < s->heap_len &&+ smaller(tree, s->heap[j+1], s->heap[j], s->depth)) {+ j++;+ }+ /* Exit if v is smaller than both sons */+ if (smaller(tree, v, s->heap[j], s->depth)) break;++ /* Exchange v with the smallest son */+ s->heap[k] = s->heap[j]; k = j;++ /* And continue down the tree, setting j to the left son of k */+ j <<= 1;+ }+ s->heap[k] = v;+}++/* ===========================================================================+ * Compute the optimal bit lengths for a tree and update the total bit length+ * for the current block.+ * IN assertion: the fields freq and dad are set, heap[heap_max] and+ * above are the tree nodes sorted by increasing frequency.+ * OUT assertions: the field len is set to the optimal bit length, the+ * array bl_count contains the frequencies for each bit length.+ * The length opt_len is updated; static_len is also updated if stree is+ * not null.+ */+local void gen_bitlen(s, desc)+ deflate_state *s;+ tree_desc *desc; /* the tree descriptor */+{+ ct_data *tree = desc->dyn_tree;+ int max_code = desc->max_code;+ const ct_data *stree = desc->stat_desc->static_tree;+ const intf *extra = desc->stat_desc->extra_bits;+ int base = desc->stat_desc->extra_base;+ int max_length = desc->stat_desc->max_length;+ int h; /* heap index */+ int n, m; /* iterate over the tree elements */+ int bits; /* bit length */+ int xbits; /* extra bits */+ ush f; /* frequency */+ int overflow = 0; /* number of elements with bit length too large */++ for (bits = 0; bits <= MAX_BITS; bits++) s->bl_count[bits] = 0;++ /* In a first pass, compute the optimal bit lengths (which may+ * overflow in the case of the bit length tree).+ */+ tree[s->heap[s->heap_max]].Len = 0; /* root of the heap */++ for (h = s->heap_max+1; h < HEAP_SIZE; h++) {+ n = s->heap[h];+ bits = tree[tree[n].Dad].Len + 1;+ if (bits > max_length) bits = max_length, overflow++;+ tree[n].Len = (ush)bits;+ /* We overwrite tree[n].Dad which is no longer needed */++ if (n > max_code) continue; /* not a leaf node */++ s->bl_count[bits]++;+ xbits = 0;+ if (n >= base) xbits = extra[n-base];+ f = tree[n].Freq;+ s->opt_len += (ulg)f * (bits + xbits);+ if (stree) s->static_len += (ulg)f * (stree[n].Len + xbits);+ }+ if (overflow == 0) return;++ Trace((stderr,"\nbit length overflow\n"));+ /* This happens for example on obj2 and pic of the Calgary corpus */++ /* Find the first bit length which could increase: */+ do {+ bits = max_length-1;+ while (s->bl_count[bits] == 0) bits--;+ s->bl_count[bits]--; /* move one leaf down the tree */+ s->bl_count[bits+1] += 2; /* move one overflow item as its brother */+ s->bl_count[max_length]--;+ /* The brother of the overflow item also moves one step up,+ * but this does not affect bl_count[max_length]+ */+ overflow -= 2;+ } while (overflow > 0);++ /* Now recompute all bit lengths, scanning in increasing frequency.+ * h is still equal to HEAP_SIZE. (It is simpler to reconstruct all+ * lengths instead of fixing only the wrong ones. This idea is taken+ * from 'ar' written by Haruhiko Okumura.)+ */+ for (bits = max_length; bits != 0; bits--) {+ n = s->bl_count[bits];+ while (n != 0) {+ m = s->heap[--h];+ if (m > max_code) continue;+ if ((unsigned) tree[m].Len != (unsigned) bits) {+ Trace((stderr,"code %d bits %d->%d\n", m, tree[m].Len, bits));+ s->opt_len += ((long)bits - (long)tree[m].Len)+ *(long)tree[m].Freq;+ tree[m].Len = (ush)bits;+ }+ n--;+ }+ }+}++/* ===========================================================================+ * Generate the codes for a given tree and bit counts (which need not be+ * optimal).+ * IN assertion: the array bl_count contains the bit length statistics for+ * the given tree and the field len is set for all tree elements.+ * OUT assertion: the field code is set for all tree elements of non+ * zero code length.+ */+local void gen_codes (tree, max_code, bl_count)+ ct_data *tree; /* the tree to decorate */+ int max_code; /* largest code with non zero frequency */+ ushf *bl_count; /* number of codes at each bit length */+{+ ush next_code[MAX_BITS+1]; /* next code value for each bit length */+ ush code = 0; /* running code value */+ int bits; /* bit index */+ int n; /* code index */++ /* The distribution counts are first used to generate the code values+ * without bit reversal.+ */+ for (bits = 1; bits <= MAX_BITS; bits++) {+ next_code[bits] = code = (code + bl_count[bits-1]) << 1;+ }+ /* Check that the bit counts in bl_count are consistent. The last code+ * must be all ones.+ */+ Assert (code + bl_count[MAX_BITS]-1 == (1<<MAX_BITS)-1,+ "inconsistent bit counts");+ Tracev((stderr,"\ngen_codes: max_code %d ", max_code));++ for (n = 0; n <= max_code; n++) {+ int len = tree[n].Len;+ if (len == 0) continue;+ /* Now reverse the bits */+ tree[n].Code = bi_reverse(next_code[len]++, len);++ Tracecv(tree != static_ltree, (stderr,"\nn %3d %c l %2d c %4x (%x) ",+ n, (isgraph(n) ? n : ' '), len, tree[n].Code, next_code[len]-1));+ }+}++/* ===========================================================================+ * Construct one Huffman tree and assigns the code bit strings and lengths.+ * Update the total bit length for the current block.+ * IN assertion: the field freq is set for all tree elements.+ * OUT assertions: the fields len and code are set to the optimal bit length+ * and corresponding code. The length opt_len is updated; static_len is+ * also updated if stree is not null. The field max_code is set.+ */+local void build_tree(s, desc)+ deflate_state *s;+ tree_desc *desc; /* the tree descriptor */+{+ ct_data *tree = desc->dyn_tree;+ const ct_data *stree = desc->stat_desc->static_tree;+ int elems = desc->stat_desc->elems;+ int n, m; /* iterate over heap elements */+ int max_code = -1; /* largest code with non zero frequency */+ int node; /* new node being created */++ /* Construct the initial heap, with least frequent element in+ * heap[SMALLEST]. The sons of heap[n] are heap[2*n] and heap[2*n+1].+ * heap[0] is not used.+ */+ s->heap_len = 0, s->heap_max = HEAP_SIZE;++ for (n = 0; n < elems; n++) {+ if (tree[n].Freq != 0) {+ s->heap[++(s->heap_len)] = max_code = n;+ s->depth[n] = 0;+ } else {+ tree[n].Len = 0;+ }+ }++ /* The pkzip format requires that at least one distance code exists,+ * and that at least one bit should be sent even if there is only one+ * possible code. So to avoid special checks later on we force at least+ * two codes of non zero frequency.+ */+ while (s->heap_len < 2) {+ node = s->heap[++(s->heap_len)] = (max_code < 2 ? ++max_code : 0);+ tree[node].Freq = 1;+ s->depth[node] = 0;+ s->opt_len--; if (stree) s->static_len -= stree[node].Len;+ /* node is 0 or 1 so it does not have extra bits */+ }+ desc->max_code = max_code;++ /* The elements heap[heap_len/2+1 .. heap_len] are leaves of the tree,+ * establish sub-heaps of increasing lengths:+ */+ for (n = s->heap_len/2; n >= 1; n--) pqdownheap(s, tree, n);++ /* Construct the Huffman tree by repeatedly combining the least two+ * frequent nodes.+ */+ node = elems; /* next internal node of the tree */+ do {+ pqremove(s, tree, n); /* n = node of least frequency */+ m = s->heap[SMALLEST]; /* m = node of next least frequency */++ s->heap[--(s->heap_max)] = n; /* keep the nodes sorted by frequency */+ s->heap[--(s->heap_max)] = m;++ /* Create a new node father of n and m */+ tree[node].Freq = tree[n].Freq + tree[m].Freq;+ s->depth[node] = (uch)((s->depth[n] >= s->depth[m] ?+ s->depth[n] : s->depth[m]) + 1);+ tree[n].Dad = tree[m].Dad = (ush)node;+#ifdef DUMP_BL_TREE+ if (tree == s->bl_tree) {+ fprintf(stderr,"\nnode %d(%d), sons %d(%d) %d(%d)",+ node, tree[node].Freq, n, tree[n].Freq, m, tree[m].Freq);+ }+#endif+ /* and insert the new node in the heap */+ s->heap[SMALLEST] = node++;+ pqdownheap(s, tree, SMALLEST);++ } while (s->heap_len >= 2);++ s->heap[--(s->heap_max)] = s->heap[SMALLEST];++ /* At this point, the fields freq and dad are set. We can now+ * generate the bit lengths.+ */+ gen_bitlen(s, (tree_desc *)desc);++ /* The field len is now set, we can generate the bit codes */+ gen_codes ((ct_data *)tree, max_code, s->bl_count);+}++/* ===========================================================================+ * Scan a literal or distance tree to determine the frequencies of the codes+ * in the bit length tree.+ */+local void scan_tree (s, tree, max_code)+ deflate_state *s;+ ct_data *tree; /* the tree to be scanned */+ int max_code; /* and its largest code of non zero frequency */+{+ int n; /* iterates over all tree elements */+ int prevlen = -1; /* last emitted length */+ int curlen; /* length of current code */+ int nextlen = tree[0].Len; /* length of next code */+ int count = 0; /* repeat count of the current code */+ int max_count = 7; /* max repeat count */+ int min_count = 4; /* min repeat count */++ if (nextlen == 0) max_count = 138, min_count = 3;+ tree[max_code+1].Len = (ush)0xffff; /* guard */++ for (n = 0; n <= max_code; n++) {+ curlen = nextlen; nextlen = tree[n+1].Len;+ if (++count < max_count && curlen == nextlen) {+ continue;+ } else if (count < min_count) {+ s->bl_tree[curlen].Freq += count;+ } else if (curlen != 0) {+ if (curlen != prevlen) s->bl_tree[curlen].Freq++;+ s->bl_tree[REP_3_6].Freq++;+ } else if (count <= 10) {+ s->bl_tree[REPZ_3_10].Freq++;+ } else {+ s->bl_tree[REPZ_11_138].Freq++;+ }+ count = 0; prevlen = curlen;+ if (nextlen == 0) {+ max_count = 138, min_count = 3;+ } else if (curlen == nextlen) {+ max_count = 6, min_count = 3;+ } else {+ max_count = 7, min_count = 4;+ }+ }+}++/* ===========================================================================+ * Send a literal or distance tree in compressed form, using the codes in+ * bl_tree.+ */+local void send_tree (s, tree, max_code)+ deflate_state *s;+ ct_data *tree; /* the tree to be scanned */+ int max_code; /* and its largest code of non zero frequency */+{+ int n; /* iterates over all tree elements */+ int prevlen = -1; /* last emitted length */+ int curlen; /* length of current code */+ int nextlen = tree[0].Len; /* length of next code */+ int count = 0; /* repeat count of the current code */+ int max_count = 7; /* max repeat count */+ int min_count = 4; /* min repeat count */++ /* tree[max_code+1].Len = -1; */ /* guard already set */+ if (nextlen == 0) max_count = 138, min_count = 3;++ for (n = 0; n <= max_code; n++) {+ curlen = nextlen; nextlen = tree[n+1].Len;+ if (++count < max_count && curlen == nextlen) {+ continue;+ } else if (count < min_count) {+ do { send_code(s, curlen, s->bl_tree); } while (--count != 0);++ } else if (curlen != 0) {+ if (curlen != prevlen) {+ send_code(s, curlen, s->bl_tree); count--;+ }+ Assert(count >= 3 && count <= 6, " 3_6?");+ send_code(s, REP_3_6, s->bl_tree); send_bits(s, count-3, 2);++ } else if (count <= 10) {+ send_code(s, REPZ_3_10, s->bl_tree); send_bits(s, count-3, 3);++ } else {+ send_code(s, REPZ_11_138, s->bl_tree); send_bits(s, count-11, 7);+ }+ count = 0; prevlen = curlen;+ if (nextlen == 0) {+ max_count = 138, min_count = 3;+ } else if (curlen == nextlen) {+ max_count = 6, min_count = 3;+ } else {+ max_count = 7, min_count = 4;+ }+ }+}++/* ===========================================================================+ * Construct the Huffman tree for the bit lengths and return the index in+ * bl_order of the last bit length code to send.+ */+local int build_bl_tree(s)+ deflate_state *s;+{+ int max_blindex; /* index of last bit length code of non zero freq */++ /* Determine the bit length frequencies for literal and distance trees */+ scan_tree(s, (ct_data *)s->dyn_ltree, s->l_desc.max_code);+ scan_tree(s, (ct_data *)s->dyn_dtree, s->d_desc.max_code);++ /* Build the bit length tree: */+ build_tree(s, (tree_desc *)(&(s->bl_desc)));+ /* opt_len now includes the length of the tree representations, except+ * the lengths of the bit lengths codes and the 5+5+4 bits for the counts.+ */++ /* Determine the number of bit length codes to send. The pkzip format+ * requires that at least 4 bit length codes be sent. (appnote.txt says+ * 3 but the actual value used is 4.)+ */+ for (max_blindex = BL_CODES-1; max_blindex >= 3; max_blindex--) {+ if (s->bl_tree[bl_order[max_blindex]].Len != 0) break;+ }+ /* Update opt_len to include the bit length tree and counts */+ s->opt_len += 3*(max_blindex+1) + 5+5+4;+ Tracev((stderr, "\ndyn trees: dyn %ld, stat %ld",+ s->opt_len, s->static_len));++ return max_blindex;+}++/* ===========================================================================+ * Send the header for a block using dynamic Huffman trees: the counts, the+ * lengths of the bit length codes, the literal tree and the distance tree.+ * IN assertion: lcodes >= 257, dcodes >= 1, blcodes >= 4.+ */+local void send_all_trees(s, lcodes, dcodes, blcodes)+ deflate_state *s;+ int lcodes, dcodes, blcodes; /* number of codes for each tree */+{+ int rank; /* index in bl_order */++ Assert (lcodes >= 257 && dcodes >= 1 && blcodes >= 4, "not enough codes");+ Assert (lcodes <= L_CODES && dcodes <= D_CODES && blcodes <= BL_CODES,+ "too many codes");+ Tracev((stderr, "\nbl counts: "));+ send_bits(s, lcodes-257, 5); /* not +255 as stated in appnote.txt */+ send_bits(s, dcodes-1, 5);+ send_bits(s, blcodes-4, 4); /* not -3 as stated in appnote.txt */+ for (rank = 0; rank < blcodes; rank++) {+ Tracev((stderr, "\nbl code %2d ", bl_order[rank]));+ send_bits(s, s->bl_tree[bl_order[rank]].Len, 3);+ }+ Tracev((stderr, "\nbl tree: sent %ld", s->bits_sent));++ send_tree(s, (ct_data *)s->dyn_ltree, lcodes-1); /* literal tree */+ Tracev((stderr, "\nlit tree: sent %ld", s->bits_sent));++ send_tree(s, (ct_data *)s->dyn_dtree, dcodes-1); /* distance tree */+ Tracev((stderr, "\ndist tree: sent %ld", s->bits_sent));+}++/* ===========================================================================+ * Send a stored block+ */+void _tr_stored_block(s, buf, stored_len, eof)+ deflate_state *s;+ charf *buf; /* input block */+ ulg stored_len; /* length of input block */+ int eof; /* true if this is the last block for a file */+{+ send_bits(s, (STORED_BLOCK<<1)+eof, 3); /* send block type */+#ifdef DEBUG+ s->compressed_len = (s->compressed_len + 3 + 7) & (ulg)~7L;+ s->compressed_len += (stored_len + 4) << 3;+#endif+ copy_block(s, buf, (unsigned)stored_len, 1); /* with header */+}++/* ===========================================================================+ * Send one empty static block to give enough lookahead for inflate.+ * This takes 10 bits, of which 7 may remain in the bit buffer.+ * The current inflate code requires 9 bits of lookahead. If the+ * last two codes for the previous block (real code plus EOB) were coded+ * on 5 bits or less, inflate may have only 5+3 bits of lookahead to decode+ * the last real code. In this case we send two empty static blocks instead+ * of one. (There are no problems if the previous block is stored or fixed.)+ * To simplify the code, we assume the worst case of last real code encoded+ * on one bit only.+ */+void _tr_align(s)+ deflate_state *s;+{+ send_bits(s, STATIC_TREES<<1, 3);+ send_code(s, END_BLOCK, static_ltree);+#ifdef DEBUG+ s->compressed_len += 10L; /* 3 for block type, 7 for EOB */+#endif+ bi_flush(s);+ /* Of the 10 bits for the empty block, we have already sent+ * (10 - bi_valid) bits. The lookahead for the last real code (before+ * the EOB of the previous block) was thus at least one plus the length+ * of the EOB plus what we have just sent of the empty static block.+ */+ if (1 + s->last_eob_len + 10 - s->bi_valid < 9) {+ send_bits(s, STATIC_TREES<<1, 3);+ send_code(s, END_BLOCK, static_ltree);+#ifdef DEBUG+ s->compressed_len += 10L;+#endif+ bi_flush(s);+ }+ s->last_eob_len = 7;+}++/* ===========================================================================+ * Determine the best encoding for the current block: dynamic trees, static+ * trees or store, and output the encoded block to the zip file.+ */+void _tr_flush_block(s, buf, stored_len, eof)+ deflate_state *s;+ charf *buf; /* input block, or NULL if too old */+ ulg stored_len; /* length of input block */+ int eof; /* true if this is the last block for a file */+{+ ulg opt_lenb, static_lenb; /* opt_len and static_len in bytes */+ int max_blindex = 0; /* index of last bit length code of non zero freq */++ /* Build the Huffman trees unless a stored block is forced */+ if (s->level > 0) {++ /* Check if the file is binary or text */+ if (stored_len > 0 && s->strm->data_type == Z_UNKNOWN)+ set_data_type(s);++ /* Construct the literal and distance trees */+ build_tree(s, (tree_desc *)(&(s->l_desc)));+ Tracev((stderr, "\nlit data: dyn %ld, stat %ld", s->opt_len,+ s->static_len));++ build_tree(s, (tree_desc *)(&(s->d_desc)));+ Tracev((stderr, "\ndist data: dyn %ld, stat %ld", s->opt_len,+ s->static_len));+ /* At this point, opt_len and static_len are the total bit lengths of+ * the compressed block data, excluding the tree representations.+ */++ /* Build the bit length tree for the above two trees, and get the index+ * in bl_order of the last bit length code to send.+ */+ max_blindex = build_bl_tree(s);++ /* Determine the best encoding. Compute the block lengths in bytes. */+ opt_lenb = (s->opt_len+3+7)>>3;+ static_lenb = (s->static_len+3+7)>>3;++ Tracev((stderr, "\nopt %lu(%lu) stat %lu(%lu) stored %lu lit %u ",+ opt_lenb, s->opt_len, static_lenb, s->static_len, stored_len,+ s->last_lit));++ if (static_lenb <= opt_lenb) opt_lenb = static_lenb;++ } else {+ Assert(buf != (char*)0, "lost buf");+ opt_lenb = static_lenb = stored_len + 5; /* force a stored block */+ }++#ifdef FORCE_STORED+ if (buf != (char*)0) { /* force stored block */+#else+ if (stored_len+4 <= opt_lenb && buf != (char*)0) {+ /* 4: two words for the lengths */+#endif+ /* The test buf != NULL is only necessary if LIT_BUFSIZE > WSIZE.+ * Otherwise we can't have processed more than WSIZE input bytes since+ * the last block flush, because compression would have been+ * successful. If LIT_BUFSIZE <= WSIZE, it is never too late to+ * transform a block into a stored block.+ */+ _tr_stored_block(s, buf, stored_len, eof);++#ifdef FORCE_STATIC+ } else if (static_lenb >= 0) { /* force static trees */+#else+ } else if (s->strategy == Z_FIXED || static_lenb == opt_lenb) {+#endif+ send_bits(s, (STATIC_TREES<<1)+eof, 3);+ compress_block(s, (ct_data *)static_ltree, (ct_data *)static_dtree);+#ifdef DEBUG+ s->compressed_len += 3 + s->static_len;+#endif+ } else {+ send_bits(s, (DYN_TREES<<1)+eof, 3);+ send_all_trees(s, s->l_desc.max_code+1, s->d_desc.max_code+1,+ max_blindex+1);+ compress_block(s, (ct_data *)s->dyn_ltree, (ct_data *)s->dyn_dtree);+#ifdef DEBUG+ s->compressed_len += 3 + s->opt_len;+#endif+ }+ Assert (s->compressed_len == s->bits_sent, "bad compressed size");+ /* The above check is made mod 2^32, for files larger than 512 MB+ * and uLong implemented on 32 bits.+ */+ init_block(s);++ if (eof) {+ bi_windup(s);+#ifdef DEBUG+ s->compressed_len += 7; /* align on byte boundary */+#endif+ }+ Tracev((stderr,"\ncomprlen %lu(%lu) ", s->compressed_len>>3,+ s->compressed_len-7*eof));+}++/* ===========================================================================+ * Save the match info and tally the frequency counts. Return true if+ * the current block must be flushed.+ */+int _tr_tally (s, dist, lc)+ deflate_state *s;+ unsigned dist; /* distance of matched string */+ unsigned lc; /* match length-MIN_MATCH or unmatched char (if dist==0) */+{+ s->d_buf[s->last_lit] = (ush)dist;+ s->l_buf[s->last_lit++] = (uch)lc;+ if (dist == 0) {+ /* lc is the unmatched char */+ s->dyn_ltree[lc].Freq++;+ } else {+ s->matches++;+ /* Here, lc is the match length - MIN_MATCH */+ dist--; /* dist = match distance - 1 */+ Assert((ush)dist < (ush)MAX_DIST(s) &&+ (ush)lc <= (ush)(MAX_MATCH-MIN_MATCH) &&+ (ush)d_code(dist) < (ush)D_CODES, "_tr_tally: bad match");++ s->dyn_ltree[_length_code[lc]+LITERALS+1].Freq++;+ s->dyn_dtree[d_code(dist)].Freq++;+ }++#ifdef TRUNCATE_BLOCK+ /* Try to guess if it is profitable to stop the current block here */+ if ((s->last_lit & 0x1fff) == 0 && s->level > 2) {+ /* Compute an upper bound for the compressed length */+ ulg out_length = (ulg)s->last_lit*8L;+ ulg in_length = (ulg)((long)s->strstart - s->block_start);+ int dcode;+ for (dcode = 0; dcode < D_CODES; dcode++) {+ out_length += (ulg)s->dyn_dtree[dcode].Freq *+ (5L+extra_dbits[dcode]);+ }+ out_length >>= 3;+ Tracev((stderr,"\nlast_lit %u, in %ld, out ~%ld(%ld%%) ",+ s->last_lit, in_length, out_length,+ 100L - out_length*100L/in_length));+ if (s->matches < s->last_lit/2 && out_length < in_length/2) return 1;+ }+#endif+ return (s->last_lit == s->lit_bufsize-1);+ /* We avoid equality with lit_bufsize because of wraparound at 64K+ * on 16 bit machines and because stored blocks are restricted to+ * 64K-1 bytes.+ */+}++/* ===========================================================================+ * Send the block data compressed using the given Huffman trees+ */+local void compress_block(s, ltree, dtree)+ deflate_state *s;+ ct_data *ltree; /* literal tree */+ ct_data *dtree; /* distance tree */+{+ unsigned dist; /* distance of matched string */+ int lc; /* match length or unmatched char (if dist == 0) */+ unsigned lx = 0; /* running index in l_buf */+ unsigned code; /* the code to send */+ int extra; /* number of extra bits to send */++ if (s->last_lit != 0) do {+ dist = s->d_buf[lx];+ lc = s->l_buf[lx++];+ if (dist == 0) {+ send_code(s, lc, ltree); /* send a literal byte */+ Tracecv(isgraph(lc), (stderr," '%c' ", lc));+ } else {+ /* Here, lc is the match length - MIN_MATCH */+ code = _length_code[lc];+ send_code(s, code+LITERALS+1, ltree); /* send the length code */+ extra = extra_lbits[code];+ if (extra != 0) {+ lc -= base_length[code];+ send_bits(s, lc, extra); /* send the extra length bits */+ }+ dist--; /* dist is now the match distance - 1 */+ code = d_code(dist);+ Assert (code < D_CODES, "bad d_code");++ send_code(s, code, dtree); /* send the distance code */+ extra = extra_dbits[code];+ if (extra != 0) {+ dist -= base_dist[code];+ send_bits(s, dist, extra); /* send the extra distance bits */+ }+ } /* literal or match pair ? */++ /* Check that the overlay between pending_buf and d_buf+l_buf is ok: */+ Assert((uInt)(s->pending) < s->lit_bufsize + 2*lx,+ "pendingBuf overflow");++ } while (lx < s->last_lit);++ send_code(s, END_BLOCK, ltree);+ s->last_eob_len = ltree[END_BLOCK].Len;+}++/* ===========================================================================+ * Set the data type to BINARY or TEXT, using a crude approximation:+ * set it to Z_TEXT if all symbols are either printable characters (33 to 255)+ * or white spaces (9 to 13, or 32); or set it to Z_BINARY otherwise.+ * IN assertion: the fields Freq of dyn_ltree are set.+ */+local void set_data_type(s)+ deflate_state *s;+{+ int n;++ for (n = 0; n < 9; n++)+ if (s->dyn_ltree[n].Freq != 0)+ break;+ if (n == 9)+ for (n = 14; n < 32; n++)+ if (s->dyn_ltree[n].Freq != 0)+ break;+ s->strm->data_type = (n == 32) ? Z_TEXT : Z_BINARY;+}++/* ===========================================================================+ * Reverse the first len bits of a code, using straightforward code (a faster+ * method would use a table)+ * IN assertion: 1 <= len <= 15+ */+local unsigned bi_reverse(code, len)+ unsigned code; /* the value to invert */+ int len; /* its bit length */+{+ register unsigned res = 0;+ do {+ res |= code & 1;+ code >>= 1, res <<= 1;+ } while (--len > 0);+ return res >> 1;+}++/* ===========================================================================+ * Flush the bit buffer, keeping at most 7 bits in it.+ */+local void bi_flush(s)+ deflate_state *s;+{+ if (s->bi_valid == 16) {+ put_short(s, s->bi_buf);+ s->bi_buf = 0;+ s->bi_valid = 0;+ } else if (s->bi_valid >= 8) {+ put_byte(s, (Byte)s->bi_buf);+ s->bi_buf >>= 8;+ s->bi_valid -= 8;+ }+}++/* ===========================================================================+ * Flush the bit buffer and align the output on a byte boundary+ */+local void bi_windup(s)+ deflate_state *s;+{+ if (s->bi_valid > 8) {+ put_short(s, s->bi_buf);+ } else if (s->bi_valid > 0) {+ put_byte(s, (Byte)s->bi_buf);+ }+ s->bi_buf = 0;+ s->bi_valid = 0;+#ifdef DEBUG+ s->bits_sent = (s->bits_sent+7) & ~7;+#endif+}++/* ===========================================================================+ * Copy a stored block, storing first the length and its+ * one's complement if requested.+ */+local void copy_block(s, buf, len, header)+ deflate_state *s;+ charf *buf; /* the input data */+ unsigned len; /* its length */+ int header; /* true if block header must be written */+{+ bi_windup(s); /* align on byte boundary */+ s->last_eob_len = 8; /* enough lookahead for inflate */++ if (header) {+ put_short(s, (ush)len);+ put_short(s, (ush)~len);+#ifdef DEBUG+ s->bits_sent += 2*16;+#endif+ }+#ifdef DEBUG+ s->bits_sent += (ulg)len<<3;+#endif+ while (len--) {+ put_byte(s, *buf++);+ }+}
+ cbits/uncompr.c view
@@ -0,0 +1,61 @@+/* uncompr.c -- decompress a memory buffer+ * Copyright (C) 1995-2003 Jean-loup Gailly.+ * For conditions of distribution and use, see copyright notice in zlib.h+ */++/* @(#) $Id$ */++#define ZLIB_INTERNAL+#include "zlib.h"++/* ===========================================================================+ 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.+*/+int ZEXPORT uncompress (dest, destLen, source, sourceLen)+ Bytef *dest;+ uLongf *destLen;+ const Bytef *source;+ uLong sourceLen;+{+ z_stream stream;+ int err;++ stream.next_in = (Bytef*)source;+ stream.avail_in = (uInt)sourceLen;+ /* Check for source > 64K on 16-bit machine: */+ if ((uLong)stream.avail_in != sourceLen) return Z_BUF_ERROR;++ stream.next_out = dest;+ stream.avail_out = (uInt)*destLen;+ if ((uLong)stream.avail_out != *destLen) return Z_BUF_ERROR;++ stream.zalloc = (alloc_func)0;+ stream.zfree = (free_func)0;++ err = inflateInit(&stream);+ if (err != Z_OK) return err;++ err = inflate(&stream, Z_FINISH);+ if (err != Z_STREAM_END) {+ inflateEnd(&stream);+ if (err == Z_NEED_DICT || (err == Z_BUF_ERROR && stream.avail_in == 0))+ return Z_DATA_ERROR;+ return err;+ }+ *destLen = stream.total_out;++ err = inflateEnd(&stream);+ return err;+}
+ cbits/zlib.h view
@@ -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 */
+ cbits/zutil.c view
@@ -0,0 +1,318 @@+/* zutil.c -- target dependent utility functions for the compression library+ * Copyright (C) 1995-2005 Jean-loup Gailly.+ * For conditions of distribution and use, see copyright notice in zlib.h+ */++/* @(#) $Id$ */++#include "zutil.h"++#ifndef NO_DUMMY_DECL+struct internal_state {int dummy;}; /* for buggy compilers */+#endif++const char * const z_errmsg[10] = {+"need dictionary", /* Z_NEED_DICT 2 */+"stream end", /* Z_STREAM_END 1 */+"", /* Z_OK 0 */+"file error", /* Z_ERRNO (-1) */+"stream error", /* Z_STREAM_ERROR (-2) */+"data error", /* Z_DATA_ERROR (-3) */+"insufficient memory", /* Z_MEM_ERROR (-4) */+"buffer error", /* Z_BUF_ERROR (-5) */+"incompatible version",/* Z_VERSION_ERROR (-6) */+""};+++const char * ZEXPORT zlibVersion()+{+ return ZLIB_VERSION;+}++uLong ZEXPORT zlibCompileFlags()+{+ uLong flags;++ flags = 0;+ switch (sizeof(uInt)) {+ case 2: break;+ case 4: flags += 1; break;+ case 8: flags += 2; break;+ default: flags += 3;+ }+ switch (sizeof(uLong)) {+ case 2: break;+ case 4: flags += 1 << 2; break;+ case 8: flags += 2 << 2; break;+ default: flags += 3 << 2;+ }+ switch (sizeof(voidpf)) {+ case 2: break;+ case 4: flags += 1 << 4; break;+ case 8: flags += 2 << 4; break;+ default: flags += 3 << 4;+ }+ switch (sizeof(z_off_t)) {+ case 2: break;+ case 4: flags += 1 << 6; break;+ case 8: flags += 2 << 6; break;+ default: flags += 3 << 6;+ }+#ifdef DEBUG+ flags += 1 << 8;+#endif+#if defined(ASMV) || defined(ASMINF)+ flags += 1 << 9;+#endif+#ifdef ZLIB_WINAPI+ flags += 1 << 10;+#endif+#ifdef BUILDFIXED+ flags += 1 << 12;+#endif+#ifdef DYNAMIC_CRC_TABLE+ flags += 1 << 13;+#endif+#ifdef NO_GZCOMPRESS+ flags += 1L << 16;+#endif+#ifdef NO_GZIP+ flags += 1L << 17;+#endif+#ifdef PKZIP_BUG_WORKAROUND+ flags += 1L << 20;+#endif+#ifdef FASTEST+ flags += 1L << 21;+#endif+#ifdef STDC+# ifdef NO_vsnprintf+ flags += 1L << 25;+# ifdef HAS_vsprintf_void+ flags += 1L << 26;+# endif+# else+# ifdef HAS_vsnprintf_void+ flags += 1L << 26;+# endif+# endif+#else+ flags += 1L << 24;+# ifdef NO_snprintf+ flags += 1L << 25;+# ifdef HAS_sprintf_void+ flags += 1L << 26;+# endif+# else+# ifdef HAS_snprintf_void+ flags += 1L << 26;+# endif+# endif+#endif+ return flags;+}++#ifdef DEBUG++# ifndef verbose+# define verbose 0+# endif+int z_verbose = verbose;++void z_error (m)+ char *m;+{+ fprintf(stderr, "%s\n", m);+ exit(1);+}+#endif++/* exported to allow conversion of error code to string for compress() and+ * uncompress()+ */+const char * ZEXPORT zError(err)+ int err;+{+ return ERR_MSG(err);+}++#if defined(_WIN32_WCE)+ /* The Microsoft C Run-Time Library for Windows CE doesn't have+ * errno. We define it as a global variable to simplify porting.+ * Its value is always 0 and should not be used.+ */+ int errno = 0;+#endif++#ifndef HAVE_MEMCPY++void zmemcpy(dest, source, len)+ Bytef* dest;+ const Bytef* source;+ uInt len;+{+ if (len == 0) return;+ do {+ *dest++ = *source++; /* ??? to be unrolled */+ } while (--len != 0);+}++int zmemcmp(s1, s2, len)+ const Bytef* s1;+ const Bytef* s2;+ uInt len;+{+ uInt j;++ for (j = 0; j < len; j++) {+ if (s1[j] != s2[j]) return 2*(s1[j] > s2[j])-1;+ }+ return 0;+}++void zmemzero(dest, len)+ Bytef* dest;+ uInt len;+{+ if (len == 0) return;+ do {+ *dest++ = 0; /* ??? to be unrolled */+ } while (--len != 0);+}+#endif+++#ifdef SYS16BIT++#ifdef __TURBOC__+/* Turbo C in 16-bit mode */++# define MY_ZCALLOC++/* Turbo C malloc() does not allow dynamic allocation of 64K bytes+ * and farmalloc(64K) returns a pointer with an offset of 8, so we+ * must fix the pointer. Warning: the pointer must be put back to its+ * original form in order to free it, use zcfree().+ */++#define MAX_PTR 10+/* 10*64K = 640K */++local int next_ptr = 0;++typedef struct ptr_table_s {+ voidpf org_ptr;+ voidpf new_ptr;+} ptr_table;++local ptr_table table[MAX_PTR];+/* This table is used to remember the original form of pointers+ * to large buffers (64K). Such pointers are normalized with a zero offset.+ * Since MSDOS is not a preemptive multitasking OS, this table is not+ * protected from concurrent access. This hack doesn't work anyway on+ * a protected system like OS/2. Use Microsoft C instead.+ */++voidpf zcalloc (voidpf opaque, unsigned items, unsigned size)+{+ voidpf buf = opaque; /* just to make some compilers happy */+ ulg bsize = (ulg)items*size;++ /* If we allocate less than 65520 bytes, we assume that farmalloc+ * will return a usable pointer which doesn't have to be normalized.+ */+ if (bsize < 65520L) {+ buf = farmalloc(bsize);+ if (*(ush*)&buf != 0) return buf;+ } else {+ buf = farmalloc(bsize + 16L);+ }+ if (buf == NULL || next_ptr >= MAX_PTR) return NULL;+ table[next_ptr].org_ptr = buf;++ /* Normalize the pointer to seg:0 */+ *((ush*)&buf+1) += ((ush)((uch*)buf-0) + 15) >> 4;+ *(ush*)&buf = 0;+ table[next_ptr++].new_ptr = buf;+ return buf;+}++void zcfree (voidpf opaque, voidpf ptr)+{+ int n;+ if (*(ush*)&ptr != 0) { /* object < 64K */+ farfree(ptr);+ return;+ }+ /* Find the original pointer */+ for (n = 0; n < next_ptr; n++) {+ if (ptr != table[n].new_ptr) continue;++ farfree(table[n].org_ptr);+ while (++n < next_ptr) {+ table[n-1] = table[n];+ }+ next_ptr--;+ return;+ }+ ptr = opaque; /* just to make some compilers happy */+ Assert(0, "zcfree: ptr not found");+}++#endif /* __TURBOC__ */+++#ifdef M_I86+/* Microsoft C in 16-bit mode */++# define MY_ZCALLOC++#if (!defined(_MSC_VER) || (_MSC_VER <= 600))+# define _halloc halloc+# define _hfree hfree+#endif++voidpf zcalloc (voidpf opaque, unsigned items, unsigned size)+{+ if (opaque) opaque = 0; /* to make compiler happy */+ return _halloc((long)items, size);+}++void zcfree (voidpf opaque, voidpf ptr)+{+ if (opaque) opaque = 0; /* to make compiler happy */+ _hfree(ptr);+}++#endif /* M_I86 */++#endif /* SYS16BIT */+++#ifndef MY_ZCALLOC /* Any system without a special alloc function */++#ifndef STDC+extern voidp malloc OF((uInt size));+extern voidp calloc OF((uInt items, uInt size));+extern void free OF((voidpf ptr));+#endif++voidpf zcalloc (opaque, items, size)+ voidpf opaque;+ unsigned items;+ unsigned size;+{+ if (opaque) items += size - size; /* make compiler happy */+ return sizeof(uInt) > 2 ? (voidpf)malloc(items * size) :+ (voidpf)calloc(items, size);+}++void zcfree (opaque, ptr)+ voidpf opaque;+ voidpf ptr;+{+ free(ptr);+ if (opaque) return; /* make compiler happy */+}++#endif /* MY_ZCALLOC */
zlib.cabal view
@@ -1,17 +1,43 @@-name: zlib-version: 0.3-copyright: (c) 2006 Duncan Coutts-build-depends: base-license: BSD3-author: Duncan Coutts <duncan.coutts@worc.ox.ac.uk>-maintainer: Duncan Coutts <duncan.coutts@worc.ox.ac.uk>-synopsis: Compression and decompression in the gzip and zlib formats-exposed-modules: Codec.Compression.GZip,- Codec.Compression.Zlib,- Codec.Compression.Zlib.Raw,- Codec.Compression.Zlib.Internal-other-modules: Codec.Compression.Zlib.Stream-extensions: ForeignFunctionInterface-includes: zlib.h-extra-libraries: z-ghc-options: -O -fvia-C -Wall+name: zlib+version: 0.4+copyright: (c) 2006-2007 Duncan Coutts+license: BSD3+license-file: LICENSE+author: Duncan Coutts <duncan@haskell.org>+maintainer: Duncan Coutts <duncan@haskell.org>+synopsis: Compression and decompression in the gzip and zlib formats+stability: provisional+build-type: Simple+cabal-version: >= 1.2.1++flag bytestring-in-base+ description: In the ghc-6.6 era the bytestring modules were+ included in the base package.++library+ exposed-modules: Codec.Compression.GZip,+ Codec.Compression.Zlib,+ Codec.Compression.Zlib.Raw,+ Codec.Compression.Zlib.Internal+ other-modules: Codec.Compression.Zlib.Stream+ extensions: CPP, ForeignFunctionInterface+ if flag(bytestring-in-base)+ -- bytestring was in base-2.0 and 2.1.1+ build-depends: base >= 2.0 && < 2.2+ cpp-options: -DBYTESTRING_IN_BASE+ else+ build-depends: base < 2.0 || >= 2.2, bytestring >= 0.9+ includes: zlib.h+ ghc-options: -fvia-C+ if !os(windows)+ -- Normally we use the the standard system zlib:+ extra-libraries: z+ else+ -- However for the benefit of users of Windows (which does not have zlib+ -- by default) we bundle a complete copy of the C sources of zlib-1.2.3+ c-sources: cbits/adler32.c cbits/compress.c cbits/crc32.c+ cbits/deflate.c cbits/gzio.c cbits/infback.c+ cbits/inffast.c cbits/inflate.c cbits/inftrees.c+ cbits/trees.c cbits/uncompr.c cbits/zutil.c+ include-dirs: cbits+ install-includes: zlib.h