CbC/CbC_gcc: zlib/deflate.c comparison

comparison zlib/deflate.c @ 111:04ced10e8804

gcc 7

author	kono
date	Fri, 27 Oct 2017 22:46:09 +0900
parents	ae3a4bfb450b
children

comparison

equal deleted inserted replaced

-:561a7518be6b
+:04ced10e8804
 /* deflate.c -- compress data using the deflation algorithm
-* Copyright (C) 1995-2005 Jean-loup Gailly.
+* Copyright (C) 1995-2017 Jean-loup Gailly and Mark Adler
 * For conditions of distribution and use, see copyright notice in zlib.h
 */
 /*
 *  ALGORITHM
 *      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
+*      Available in http://tools.ietf.org/html/rfc1951
 *
 *      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.
 /* @(#) $Id: deflate.c,v 1.1.1.2 2002/03/11 21:53:23 tromey Exp $ */
 #include "deflate.h"
 const char deflate_copyright[] =
-" deflate 1.2.3 Copyright 1995-2005 Jean-loup Gailly ";
+" deflate 1.2.11 Copyright 1995-2017 Jean-loup Gailly and 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.
 } block_state;
 typedef block_state (*compress_func) OF((deflate_state *s, int flush));
 /* Compression function. Returns the block state after the call. */
+local int deflateStateCheck      OF((z_streamp strm));
+local void slide_hash     OF((deflate_state *s));
 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 block_state deflate_rle    OF((deflate_state *s, int flush));
+local block_state deflate_huff   OF((deflate_state *s, int flush));
 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));
+local unsigned read_buf   OF((z_streamp strm, Bytef *buf, unsigned size));
-#ifndef FASTEST
 #ifdef ASMV
+#  pragma message("Assembler code may have bugs -- use at your own risk")
 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 ZLIB_DEBUG
-#ifdef DEBUG
 local  void check_match OF((deflate_state *s, IPos start, IPos match,
 int length));
 #endif
 /* ===========================================================================
 #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.
 /* 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
+/* rank Z_BLOCK between Z_NO_FLUSH and Z_PARTIAL_FLUSH */
-/* result of memcmp for equal strings */
+#define RANK(f) (((f) * 2) - ((f) > 4 ? 9 : 0))
-#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
+* IN  assertion: all calls to UPDATE_HASH are made with consecutive input
-*    input characters, so that a running hash key can be computed from the
+*    characters, so that a running hash key can be computed from the previous
-*    previous key instead of complete recalculation each time.
+*    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
+* IN  assertion: all calls to INSERT_STRING are made with consecutive input
-*    input characters and the first MIN_MATCH bytes of str are valid
+*    characters and the first MIN_MATCH bytes of str are valid (except for
-*    (except for the last MIN_MATCH-1 bytes of the input file).
+*    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], \
 * 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));
+/* ===========================================================================
+* Slide the hash table when sliding the window down (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.
+*/
+local void slide_hash(s)
+deflate_state *s;
+{
+unsigned n, m;
+Posf *p;
+uInt wsize = s->w_size;
+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
+}
 /* ========================================================================= */
 int ZEXPORT deflateInit_(strm, level, version, stream_size)
 z_streamp strm;
 int level;
 }
 if (strm == Z_NULL) return Z_STREAM_ERROR;
 strm->msg = Z_NULL;
 if (strm->zalloc == (alloc_func)0) {
+#ifdef Z_SOLO
+return Z_STREAM_ERROR;
+#else
 strm->zalloc = zcalloc;
 strm->opaque = (voidpf)0;
-}
+#endif
-if (strm->zfree == (free_func)0) strm->zfree = zcfree;
+}
+if (strm->zfree == (free_func)0)
+#ifdef Z_SOLO
+return Z_STREAM_ERROR;
+#else
+strm->zfree = zcfree;
+#endif
 #ifdef FASTEST
 if (level != 0) level = 1;
 #else
 if (level == Z_DEFAULT_COMPRESSION) level = 6;
 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) {
+strategy < 0 || strategy > Z_FIXED || (windowBits == 8 && wrap != 1)) {
 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->status = INIT_STATE;     /* to pass state test in deflateReset() */
 s->wrap = wrap;
 s->gzhead = Z_NULL;
-s->w_bits = windowBits;
+s->w_bits = (uInt)windowBits;
 s->w_size = 1 << s->w_bits;
 s->w_mask = s->w_size - 1;
-s->hash_bits = memLevel + 7;
+s->hash_bits = (uInt)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->high_water = 0;      /* nothing written to s->window yet */
 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);
+strm->msg = 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);
+}
+/* =========================================================================
+* Check for a valid deflate stream state. Return 0 if ok, 1 if not.
+*/
+local int deflateStateCheck (strm)
+z_streamp strm;
+{
+deflate_state *s;
+if (strm == Z_NULL ||
+strm->zalloc == (alloc_func)0 || strm->zfree == (free_func)0)
+return 1;
+s = strm->state;
+if (s == Z_NULL || s->strm != strm || (s->status != INIT_STATE &&
+#ifdef GZIP
+s->status != GZIP_STATE &&
+#endif
+s->status != EXTRA_STATE &&
+s->status != NAME_STATE &&
+s->status != COMMENT_STATE &&
+s->status != HCRC_STATE &&
+s->status != BUSY_STATE &&
+s->status != FINISH_STATE))
+return 1;
+return 0;
 }
 /* ========================================================================= */
 int ZEXPORT deflateSetDictionary (strm, dictionary, dictLength)
 z_streamp strm;
 const Bytef *dictionary;
 uInt  dictLength;
 {
 deflate_state *s;
-uInt length = dictLength;
+uInt str, n;
-uInt n;
+int wrap;
-IPos hash_head = 0;
+unsigned avail;
+z_const unsigned char *next;
-if (strm == Z_NULL || strm->state == Z_NULL || dictionary == Z_NULL ||
-strm->state->wrap == 2 ||
+if (deflateStateCheck(strm) || dictionary == Z_NULL)
-(strm->state->wrap == 1 && strm->state->status != INIT_STATE))
 return Z_STREAM_ERROR;
 s = strm->state;
-if (s->wrap)
+wrap = s->wrap;
+if (wrap == 2 || (wrap == 1 && s->status != INIT_STATE) || s->lookahead)
+return Z_STREAM_ERROR;
+/* when using zlib wrappers, compute Adler-32 for provided dictionary */
+if (wrap == 1)
 strm->adler = adler32(strm->adler, dictionary, dictLength);
+s->wrap = 0;                    /* avoid computing Adler-32 in read_buf */
-if (length < MIN_MATCH) return Z_OK;
-if (length > MAX_DIST(s)) {
+/* if dictionary would fill window, just replace the history */
-length = MAX_DIST(s);
+if (dictLength >= s->w_size) {
-dictionary += dictLength - length; /* use the tail of the dictionary */
+if (wrap == 0) {            /* already empty otherwise */
-}
+CLEAR_HASH(s);
-zmemcpy(s->window, dictionary, length);
+s->strstart = 0;
-s->strstart = length;
+s->block_start = 0L;
-s->block_start = (long)length;
+s->insert = 0;
+}
-/* Insert all strings in the hash table (except for the last two bytes).
+dictionary += dictLength - s->w_size;  /* use the tail */
-* s->lookahead stays null, so s->ins_h will be recomputed at the next
+dictLength = s->w_size;
-* call of fill_window.
+}
-*/
-s->ins_h = s->window[0];
+/* insert dictionary into window and hash */
-UPDATE_HASH(s, s->ins_h, s->window[1]);
+avail = strm->avail_in;
-for (n = 0; n <= length - MIN_MATCH; n++) {
+next = strm->next_in;
-INSERT_STRING(s, n, hash_head);
+strm->avail_in = dictLength;
-}
+strm->next_in = (z_const Bytef *)dictionary;
-if (hash_head) hash_head = 0;  /* to make compiler happy */
+fill_window(s);
+while (s->lookahead >= MIN_MATCH) {
+str = s->strstart;
+n = s->lookahead - (MIN_MATCH-1);
+do {
+UPDATE_HASH(s, s->ins_h, s->window[str + MIN_MATCH-1]);
+#ifndef FASTEST
+s->prev[str & s->w_mask] = s->head[s->ins_h];
+#endif
+s->head[s->ins_h] = (Pos)str;
+str++;
+} while (--n);
+s->strstart = str;
+s->lookahead = MIN_MATCH-1;
+fill_window(s);
+}
+s->strstart += s->lookahead;
+s->block_start = (long)s->strstart;
+s->insert = s->lookahead;
+s->lookahead = 0;
+s->match_length = s->prev_length = MIN_MATCH-1;
+s->match_available = 0;
+strm->next_in = next;
+strm->avail_in = avail;
+s->wrap = wrap;
+return Z_OK;
+}
+/* ========================================================================= */
+int ZEXPORT deflateGetDictionary (strm, dictionary, dictLength)
+z_streamp strm;
+Bytef *dictionary;
+uInt  *dictLength;
+{
+deflate_state *s;
+uInt len;
+if (deflateStateCheck(strm))
+return Z_STREAM_ERROR;
+s = strm->state;
+len = s->strstart + s->lookahead;
+if (len > s->w_size)
+len = s->w_size;
+if (dictionary != Z_NULL && len)
+zmemcpy(dictionary, s->window + s->strstart + s->lookahead - len, len);
+if (dictLength != Z_NULL)
+*dictLength = len;
+return Z_OK;
+}
+/* ========================================================================= */
+int ZEXPORT deflateResetKeep (strm)
+z_streamp strm;
+{
+deflate_state *s;
+if (deflateStateCheck(strm)) {
+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 =
+#ifdef GZIP
+s->wrap == 2 ? GZIP_STATE :
+#endif
+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);
 return Z_OK;
 }
 /* ========================================================================= */
 int ZEXPORT deflateReset (strm)
 z_streamp strm;
 {
-deflate_state *s;
+int ret;
-if (strm == Z_NULL || strm->state == Z_NULL ||
+ret = deflateResetKeep(strm);
-strm->zalloc == (alloc_func)0 || strm->zfree == (free_func)0) {
+if (ret == Z_OK)
-return Z_STREAM_ERROR;
+lm_init(strm->state);
-}
+return ret;
-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 (deflateStateCheck(strm) || strm->state->wrap != 2)
-if (strm->state->wrap != 2) return Z_STREAM_ERROR;
+return Z_STREAM_ERROR;
 strm->state->gzhead = head;
+return Z_OK;
+}
+/* ========================================================================= */
+int ZEXPORT deflatePending (strm, pending, bits)
+unsigned *pending;
+int *bits;
+z_streamp strm;
+{
+if (deflateStateCheck(strm)) return Z_STREAM_ERROR;
+if (pending != Z_NULL)
+*pending = strm->state->pending;
+if (bits != Z_NULL)
+*bits = strm->state->bi_valid;
 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;
+deflate_state *s;
-strm->state->bi_valid = bits;
+int put;
-strm->state->bi_buf = (ush)(value & ((1 << bits) - 1));
+if (deflateStateCheck(strm)) return Z_STREAM_ERROR;
+s = strm->state;
+if ((Bytef *)(s->d_buf) < s->pending_out + ((Buf_size + 7) >> 3))
+return Z_BUF_ERROR;
+do {
+put = Buf_size - s->bi_valid;
+if (put > bits)
+put = bits;
+s->bi_buf |= (ush)((value & ((1 << put) - 1)) << s->bi_valid);
+s->bi_valid += put;
+_tr_flush_bits(s);
+value >>= put;
+bits -= put;
+} while (bits);
 return Z_OK;
 }
 /* ========================================================================= */
 int ZEXPORT deflateParams(strm, level, strategy)
 int level;
 int strategy;
 {
 deflate_state *s;
 compress_func func;
-int err = Z_OK;
+if (deflateStateCheck(strm)) return Z_STREAM_ERROR;
-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 < 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) {
+if ((strategy != s->strategy || func != configuration_table[level].func) &&
+s->high_water) {
 /* Flush the last buffer: */
-err = deflate(strm, Z_PARTIAL_FLUSH);
+int err = deflate(strm, Z_BLOCK);
+if (err == Z_STREAM_ERROR)
+return err;
+if (strm->avail_out == 0)
+return Z_BUF_ERROR;
 }
 if (s->level != level) {
+if (s->level == 0 && s->matches != 0) {
+if (s->matches == 1)
+slide_hash(s);
+else
+CLEAR_HASH(s);
+s->matches = 0;
+}
 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;
+return Z_OK;
 }
 /* ========================================================================= */
 int ZEXPORT deflateTune(strm, good_length, max_lazy, nice_length, max_chain)
 z_streamp strm;
 int nice_length;
 int max_chain;
 {
 deflate_state *s;
-if (strm == Z_NULL || strm->state == Z_NULL) return Z_STREAM_ERROR;
+if (deflateStateCheck(strm)) return Z_STREAM_ERROR;
 s = strm->state;
-s->good_match = good_length;
+s->good_match = (uInt)good_length;
-s->max_lazy_match = max_lazy;
+s->max_lazy_match = (uInt)max_lazy;
 s->nice_match = nice_length;
-s->max_chain_length = max_chain;
+s->max_chain_length = (uInt)max_chain;
 return Z_OK;
 }
 /* =========================================================================
 * For the default windowBits of 15 and memLevel of 8, this function returns
 * 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
+* This function could be more sophisticated to provide closer upper bounds for
-* for every combination of windowBits and memLevel, as well as wrap.
+* every combination of windowBits and memLevel.  But even the conservative
-* But even the conservative upper bound of about 14% expansion does not
+* upper bound of about 14% expansion does not seem onerous for output buffer
-* seem onerous for output buffer allocation.
+* allocation.
 */
 uLong ZEXPORT deflateBound(strm, sourceLen)
 z_streamp strm;
 uLong sourceLen;
 {
 deflate_state *s;
-uLong destLen;
+uLong complen, wraplen;
-/* conservative upper bound */
+/* conservative upper bound for compressed data */
-destLen = sourceLen +
+complen = sourceLen +
-((sourceLen + 7) >> 3) + ((sourceLen + 63) >> 6) + 11;
+((sourceLen + 7) >> 3) + ((sourceLen + 63) >> 6) + 5;
-/* if can't get parameters, return conservative bound */
+/* if can't get parameters, return conservative bound plus zlib wrapper */
-if (strm == Z_NULL || strm->state == Z_NULL)
+if (deflateStateCheck(strm))
-return destLen;
+return complen + 6;
+/* compute wrapper length */
+s = strm->state;
+switch (s->wrap) {
+case 0:                                 /* raw deflate */
+wraplen = 0;
+break;
+case 1:                                 /* zlib wrapper */
+wraplen = 6 + (s->strstart ? 4 : 0);
+break;
+#ifdef GZIP
+case 2:                                 /* gzip wrapper */
+wraplen = 18;
+if (s->gzhead != Z_NULL) {          /* user-supplied gzip header */
+Bytef *str;
+if (s->gzhead->extra != Z_NULL)
+wraplen += 2 + s->gzhead->extra_len;
+str = s->gzhead->name;
+if (str != Z_NULL)
+do {
+wraplen++;
+} while (*str++);
+str = s->gzhead->comment;
+if (str != Z_NULL)
+do {
+wraplen++;
+} while (*str++);
+if (s->gzhead->hcrc)
+wraplen += 2;
+}
+break;
+#endif
+default:                                /* for compiler happiness */
+wraplen = 6;
+}
 /* if not default parameters, return conservative bound */
-s = strm->state;
 if (s->w_bits != 15 || s->hash_bits != 8 + 7)
-return destLen;
+return complen + wraplen;
 /* default settings: return tight bound for that case */
-return compressBound(sourceLen);
+return sourceLen + (sourceLen >> 12) + (sourceLen >> 14) +
+(sourceLen >> 25) + 13 - 6 + wraplen;
 }
 /* =========================================================================
 * 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
 put_byte(s, (Byte)(b >> 8));
 put_byte(s, (Byte)(b & 0xff));
 }
 /* =========================================================================
-* Flush as much pending output as possible. All deflate() output goes
+* Flush as much pending output as possible. All deflate() output, except for
-* through this function so some applications may wish to modify it
+* some deflate_stored() output, goes through this function so some
-* to avoid allocating a large strm->next_out buffer and copying into it.
+* applications may wish to modify it to avoid allocating a large
-* (See also read_buf()).
+* 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;
+unsigned len;
+deflate_state *s = strm->state;
+_tr_flush_bits(s);
+len = s->pending;
 if (len > strm->avail_out) len = strm->avail_out;
 if (len == 0) return;
-zmemcpy(strm->next_out, strm->state->pending_out, len);
+zmemcpy(strm->next_out, s->pending_out, len);
 strm->next_out  += len;
-strm->state->pending_out  += len;
+s->pending_out  += len;
 strm->total_out += len;
-strm->avail_out  -= len;
+strm->avail_out -= len;
-strm->state->pending -= len;
+s->pending      -= len;
-if (strm->state->pending == 0) {
+if (s->pending == 0) {
-strm->state->pending_out = strm->state->pending_buf;
+s->pending_out = s->pending_buf;
 }
 }
+/* ===========================================================================
+* Update the header CRC with the bytes s->pending_buf[beg..s->pending - 1].
+*/
+#define HCRC_UPDATE(beg) \
+do { \
+if (s->gzhead->hcrc && s->pending > (beg)) \
+strm->adler = crc32(strm->adler, s->pending_buf + (beg), \
+s->pending - (beg)); \
+} while (0)
 /* ========================================================================= */
 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 ||
+if (deflateStateCheck(strm) || flush > Z_BLOCK || flush < 0) {
-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) ||
+(strm->avail_in != 0 && strm->next_in == Z_NULL) ||
 (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) {
 /* 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 &&
+} else if (strm->avail_in == 0 && RANK(flush) <= RANK(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);
 }
+/* Write the header */
+if (s->status == INIT_STATE) {
+/* zlib header */
+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);
+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);
+s->status = BUSY_STATE;
+/* Compression must start with an empty pending buffer */
+flush_pending(strm);
+if (s->pending != 0) {
+s->last_flush = -1;
+return Z_OK;
+}
+}
+#ifdef GZIP
+if (s->status == GZIP_STATE) {
+/* gzip header */
+strm->adler = crc32(0L, Z_NULL, 0);
+put_byte(s, 31);
+put_byte(s, 139);
+put_byte(s, 8);
+if (s->gzhead == Z_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;
+/* Compression must start with an empty pending buffer */
+flush_pending(strm);
+if (s->pending != 0) {
+s->last_flush = -1;
+return Z_OK;
+}
+}
+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 != Z_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;
+}
+}
+if (s->status == EXTRA_STATE) {
+if (s->gzhead->extra != Z_NULL) {
+ulg beg = s->pending;   /* start of bytes to update crc */
+uInt left = (s->gzhead->extra_len & 0xffff) - s->gzindex;
+while (s->pending + left > s->pending_buf_size) {
+uInt copy = s->pending_buf_size - s->pending;
+zmemcpy(s->pending_buf + s->pending,
+s->gzhead->extra + s->gzindex, copy);
+s->pending = s->pending_buf_size;
+HCRC_UPDATE(beg);
+s->gzindex += copy;
+flush_pending(strm);
+if (s->pending != 0) {
+s->last_flush = -1;
+return Z_OK;
+}
+beg = 0;
+left -= copy;
+}
+zmemcpy(s->pending_buf + s->pending,
+s->gzhead->extra + s->gzindex, left);
+s->pending += left;
+HCRC_UPDATE(beg);
+s->gzindex = 0;
+}
+s->status = NAME_STATE;
+}
+if (s->status == NAME_STATE) {
+if (s->gzhead->name != Z_NULL) {
+ulg beg = s->pending;   /* start of bytes to update crc */
+int val;
+do {
+if (s->pending == s->pending_buf_size) {
+HCRC_UPDATE(beg);
+flush_pending(strm);
+if (s->pending != 0) {
+s->last_flush = -1;
+return Z_OK;
+}
+beg = 0;
+}
+val = s->gzhead->name[s->gzindex++];
+put_byte(s, val);
+} while (val != 0);
+HCRC_UPDATE(beg);
+s->gzindex = 0;
+}
+s->status = COMMENT_STATE;
+}
+if (s->status == COMMENT_STATE) {
+if (s->gzhead->comment != Z_NULL) {
+ulg beg = s->pending;   /* start of bytes to update crc */
+int val;
+do {
+if (s->pending == s->pending_buf_size) {
+HCRC_UPDATE(beg);
+flush_pending(strm);
+if (s->pending != 0) {
+s->last_flush = -1;
+return Z_OK;
+}
+beg = 0;
+}
+val = s->gzhead->comment[s->gzindex++];
+put_byte(s, val);
+} while (val != 0);
+HCRC_UPDATE(beg);
+}
+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 != 0) {
+s->last_flush = -1;
+return Z_OK;
+}
+}
+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;
+/* Compression must start with an empty pending buffer */
+flush_pending(strm);
+if (s->pending != 0) {
+s->last_flush = -1;
+return Z_OK;
+}
+}
+#endif
 /* 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);
+bstate = s->level == 0 ? deflate_stored(s, flush) :
+s->strategy == Z_HUFFMAN_ONLY ? deflate_huff(s, flush) :
+s->strategy == Z_RLE ? deflate_rle(s, flush) :
+(*(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 (bstate == block_done) {
 if (flush == Z_PARTIAL_FLUSH) {
 _tr_align(s);
-} else { /* FULL_FLUSH or SYNC_FLUSH */
+} else if (flush != Z_BLOCK) { /* 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 */
+if (s->lookahead == 0) {
+s->strstart = 0;
+s->block_start = 0L;
+s->insert = 0;
+}
 }
 }
 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 */
 int ZEXPORT deflateEnd (strm)
 z_streamp strm;
 {
 int status;
-if (strm == Z_NULL || strm->state == Z_NULL) return Z_STREAM_ERROR;
+if (deflateStateCheck(strm)) 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);
 deflate_state *ds;
 deflate_state *ss;
 ushf *overlay;
-if (source == Z_NULL || dest == Z_NULL || source->state == Z_NULL) {
+if (deflateStateCheck(source) || dest == Z_NULL) {
 return Z_STREAM_ERROR;
 }
 ss = source->state;
-zmemcpy(dest, source, sizeof(z_stream));
+zmemcpy((voidpf)dest, (voidpf)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));
+zmemcpy((voidpf)ds, (voidpf)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));
 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((voidpf)ds->prev, (voidpf)ss->prev, ds->w_size * sizeof(Pos));
-zmemcpy(ds->head, ss->head, ds->hash_size * sizeof(Pos));
+zmemcpy((voidpf)ds->head, (voidpf)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;
 * 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)
+local unsigned 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;
+zmemcpy(buf, strm->next_in, len);
 if (strm->state->wrap == 1) {
-strm->adler = adler32(strm->adler, strm->next_in, len);
+strm->adler = adler32(strm->adler, buf, len);
 }
 #ifdef GZIP
 else if (strm->state->wrap == 2) {
-strm->adler = crc32(strm->adler, strm->next_in, len);
+strm->adler = crc32(strm->adler, buf, len);
 }
 #endif
-zmemcpy(buf, strm->next_in, len);
 strm->next_in  += len;
 strm->total_in += len;
-return (int)len;
+return len;
 }
 /* ===========================================================================
 * Initialize the "longest match" routines for a new zlib stream
 */
 s->max_chain_length = configuration_table[s->level].max_chain;
 s->strstart = 0;
 s->block_start = 0L;
 s->lookahead = 0;
+s->insert = 0;
 s->match_length = s->prev_length = MIN_MATCH-1;
 s->match_available = 0;
 s->ins_h = 0;
 #ifndef FASTEST
 #ifdef ASMV
 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 Bytef *match;                      /* matched string */
 register int len;                           /* length of current match */
-int best_len = s->prev_length;              /* best match length so far */
+int best_len = (int)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.
 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;
+if ((uInt)nice_match > s->lookahead) nice_match = (int)s->lookahead;
 Assert((ulg)s->strstart <= s->window_size-MIN_LOOKAHEAD, "need lookahead");
 do {
 Assert(cur_match < s->strstart, "no future");
 if ((uInt)best_len <= s->lookahead) return (uInt)best_len;
 return s->lookahead;
 }
 #endif /* ASMV */
-#endif /* FASTEST */
+#else /* FASTEST */
 /* ---------------------------------------------------------------------------
-* Optimized version for level == 1 or strategy == Z_RLE only
+* Optimized version for FASTEST only
 */
-local uInt longest_match_fast(s, cur_match)
+local uInt longest_match(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 */
 s->match_start = cur_match;
 return (uInt)len <= s->lookahead ? (uInt)len : s->lookahead;
 }
-#ifdef DEBUG
+#endif /* FASTEST */
+#ifdef ZLIB_DEBUG
+#define EQUAL 0
+/* result of memcmp for equal strings */
 /* ===========================================================================
 * Check that the match at match_start is indeed a match.
 */
 local void check_match(s, start, match, length)
 deflate_state *s;
 do { putc(s->window[start++], stderr); } while (--length != 0);
 }
 }
 #else
 #  define check_match(s, start, match, length)
-#endif /* DEBUG */
+#endif /* ZLIB_DEBUG */
 /* ===========================================================================
 * Fill the window when the lookahead becomes insufficient.
 * Updates strstart and lookahead.
 *
 *    option -- not supported here).
 */
 local void fill_window(s)
 deflate_state *s;
 {
-register unsigned n, m;
+unsigned n;
-register Posf *p;
 unsigned more;    /* Amount of free space at the end of the window. */
 uInt wsize = s->w_size;
+Assert(s->lookahead < MIN_LOOKAHEAD, "already enough lookahead");
 do {
 more = (unsigned)(s->window_size -(ulg)s->lookahead -(ulg)s->strstart);
 /* Deal with !@#$% 64K limit: */
 /* 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);
+zmemcpy(s->window, s->window+wsize, (unsigned)wsize - more);
 s->match_start -= wsize;
 s->strstart    -= wsize; /* we now have strstart >= MAX_DIST */
 s->block_start -= (long) wsize;
+slide_hash(s);
-/* 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 (s->strm->avail_in == 0) break;
 /* 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)
 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) {
+if (s->lookahead + s->insert >= MIN_MATCH) {
-s->ins_h = s->window[s->strstart];
+uInt str = s->strstart - s->insert;
-UPDATE_HASH(s, s->ins_h, s->window[s->strstart+1]);
+s->ins_h = s->window[str];
+UPDATE_HASH(s, s->ins_h, s->window[str + 1]);
 #if MIN_MATCH != 3
 Call UPDATE_HASH() MIN_MATCH-3 more times
 #endif
+while (s->insert) {
+UPDATE_HASH(s, s->ins_h, s->window[str + MIN_MATCH-1]);
+#ifndef FASTEST
+s->prev[str & s->w_mask] = s->head[s->ins_h];
+#endif
+s->head[s->ins_h] = (Pos)str;
+str++;
+s->insert--;
+if (s->lookahead + s->insert < MIN_MATCH)
+break;
+}
 }
 /* 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);
+/* If the WIN_INIT bytes after the end of the current data have never been
+* written, then zero those bytes in order to avoid memory check reports of
+* the use of uninitialized (or uninitialised as Julian writes) bytes by
+* the longest match routines.  Update the high water mark for the next
+* time through here.  WIN_INIT is set to MAX_MATCH since the longest match
+* routines allow scanning to strstart + MAX_MATCH, ignoring lookahead.
+*/
+if (s->high_water < s->window_size) {
+ulg curr = s->strstart + (ulg)(s->lookahead);
+ulg init;
+if (s->high_water < curr) {
+/* Previous high water mark below current data -- zero WIN_INIT
+* bytes or up to end of window, whichever is less.
+*/
+init = s->window_size - curr;
+if (init > WIN_INIT)
+init = WIN_INIT;
+zmemzero(s->window + curr, (unsigned)init);
+s->high_water = curr + init;
+}
+else if (s->high_water < (ulg)curr + WIN_INIT) {
+/* High water mark at or above current data, but below current data
+* plus WIN_INIT -- zero out to current data plus WIN_INIT, or up
+* to end of window, whichever is less.
+*/
+init = (ulg)curr + WIN_INIT - s->high_water;
+if (init > s->window_size - s->high_water)
+init = s->window_size - s->high_water;
+zmemzero(s->window + s->high_water, (unsigned)init);
+s->high_water += init;
+}
+}
+Assert((ulg)s->strstart <= s->window_size - MIN_LOOKAHEAD,
+"not enough room for search");
 }
 /* ===========================================================================
 * 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) { \
+#define FLUSH_BLOCK_ONLY(s, last) { \
 _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)); \
+(last)); \
 s->block_start = s->strstart; \
 flush_pending(s->strm); \
 Tracev((stderr,"[FLUSH]")); \
 }
 /* Same but force premature exit if necessary. */
-#define FLUSH_BLOCK(s, eof) { \
+#define FLUSH_BLOCK(s, last) { \
-FLUSH_BLOCK_ONLY(s, eof); \
+FLUSH_BLOCK_ONLY(s, last); \
-if (s->strm->avail_out == 0) return (eof) ? finish_started : need_more; \
+if (s->strm->avail_out == 0) return (last) ? finish_started : need_more; \
 }
+/* Maximum stored block length in deflate format (not including header). */
+#define MAX_STORED 65535
+/* Minimum of a and b. */
+#define MIN(a, b) ((a) > (b) ? (b) : (a))
 /* ===========================================================================
 * 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
+* In case deflateParams() is used to later switch to a non-zero compression
-* only for the level=0 compression option.
+* level, s->matches (otherwise unused when storing) keeps track of the number
-* NOTE: this function should be optimized to avoid extra copying from
+* of hash table slides to perform. If s->matches is 1, then one hash table
-* window to pending_buf.
+* slide will be done when switching. If s->matches is 2, the maximum value
+* allowed here, then the hash table will be cleared, since two or more slides
+* is the same as a clear.
+*
+* deflate_stored() is written to minimize the number of times an input byte is
+* copied. It is most efficient with large input and output buffers, which
+* maximizes the opportunites to have a single copy from next_in to next_out.
 */
 local block_state deflate_stored(s, flush)
 deflate_state *s;
 int flush;
 {
-/* Stored blocks are limited to 0xffff bytes, pending_buf is limited
+/* Smallest worthy block size when not flushing or finishing. By default
-* to pending_buf_size, and each stored block has a 5 byte header:
+* this is 32K. This can be as small as 507 bytes for memLevel == 1. For
+* large input and output buffers, the stored block size will be larger.
 */
-ulg max_block_size = 0xffff;
+unsigned min_block = MIN(s->pending_buf_size - 5, s->w_size);
-ulg max_start;
+/* Copy as many min_block or larger stored blocks directly to next_out as
-if (max_block_size > s->pending_buf_size - 5) {
+* possible. If flushing, copy the remaining available input to next_out as
-max_block_size = s->pending_buf_size - 5;
+* stored blocks, if there is enough space.
-}
+*/
+unsigned len, left, have, last = 0;
-/* Copy as much as possible from input to output: */
+unsigned used = s->strm->avail_in;
-for (;;) {
+do {
-/* Fill the window as much as possible: */
+/* Set len to the maximum size block that we can copy directly with the
-if (s->lookahead <= 1) {
+* available input data and output space. Set left to how much of that
+* would be copied from what's left in the window.
-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)) {
+len = MAX_STORED;       /* maximum deflate stored block length */
-FLUSH_BLOCK(s, 0);
+have = (s->bi_valid + 42) >> 3;         /* number of header bytes */
-}
+if (s->strm->avail_out < have)          /* need room for header */
-}
+break;
-FLUSH_BLOCK(s, flush == Z_FINISH);
+/* maximum stored block length that will fit in avail_out: */
-return flush == Z_FINISH ? finish_done : block_done;
+have = s->strm->avail_out - have;
+left = s->strstart - s->block_start;    /* bytes left in window */
+if (len > (ulg)left + s->strm->avail_in)
+len = left + s->strm->avail_in;     /* limit len to the input */
+if (len > have)
+len = have;                         /* limit len to the output */
+/* If the stored block would be less than min_block in length, or if
+* unable to copy all of the available input when flushing, then try
+* copying to the window and the pending buffer instead. Also don't
+* write an empty block when flushing -- deflate() does that.
+*/
+if (len < min_block && ((len == 0 && flush != Z_FINISH) ||
+flush == Z_NO_FLUSH ||
+len != left + s->strm->avail_in))
+break;
+/* Make a dummy stored block in pending to get the header bytes,
+* including any pending bits. This also updates the debugging counts.
+*/
+last = flush == Z_FINISH && len == left + s->strm->avail_in ? 1 : 0;
+_tr_stored_block(s, (char *)0, 0L, last);
+/* Replace the lengths in the dummy stored block with len. */
+s->pending_buf[s->pending - 4] = len;
+s->pending_buf[s->pending - 3] = len >> 8;
+s->pending_buf[s->pending - 2] = ~len;
+s->pending_buf[s->pending - 1] = ~len >> 8;
+/* Write the stored block header bytes. */
+flush_pending(s->strm);
+#ifdef ZLIB_DEBUG
+/* Update debugging counts for the data about to be copied. */
+s->compressed_len += len << 3;
+s->bits_sent += len << 3;
+#endif
+/* Copy uncompressed bytes from the window to next_out. */
+if (left) {
+if (left > len)
+left = len;
+zmemcpy(s->strm->next_out, s->window + s->block_start, left);
+s->strm->next_out += left;
+s->strm->avail_out -= left;
+s->strm->total_out += left;
+s->block_start += left;
+len -= left;
+}
+/* Copy uncompressed bytes directly from next_in to next_out, updating
+* the check value.
+*/
+if (len) {
+read_buf(s->strm, s->strm->next_out, len);
+s->strm->next_out += len;
+s->strm->avail_out -= len;
+s->strm->total_out += len;
+}
+} while (last == 0);
+/* Update the sliding window with the last s->w_size bytes of the copied
+* data, or append all of the copied data to the existing window if less
+* than s->w_size bytes were copied. Also update the number of bytes to
+* insert in the hash tables, in the event that deflateParams() switches to
+* a non-zero compression level.
+*/
+used -= s->strm->avail_in;      /* number of input bytes directly copied */
+if (used) {
+/* If any input was used, then no unused input remains in the window,
+* therefore s->block_start == s->strstart.
+*/
+if (used >= s->w_size) {    /* supplant the previous history */
+s->matches = 2;         /* clear hash */
+zmemcpy(s->window, s->strm->next_in - s->w_size, s->w_size);
+s->strstart = s->w_size;
+}
+else {
+if (s->window_size - s->strstart <= used) {
+/* Slide the window down. */
+s->strstart -= s->w_size;
+zmemcpy(s->window, s->window + s->w_size, s->strstart);
+if (s->matches < 2)
+s->matches++;   /* add a pending slide_hash() */
+}
+zmemcpy(s->window + s->strstart, s->strm->next_in - used, used);
+s->strstart += used;
+}
+s->block_start = s->strstart;
+s->insert += MIN(used, s->w_size - s->insert);
+}
+if (s->high_water < s->strstart)
+s->high_water = s->strstart;
+/* If the last block was written to next_out, then done. */
+if (last)
+return finish_done;
+/* If flushing and all input has been consumed, then done. */
+if (flush != Z_NO_FLUSH && flush != Z_FINISH &&
+s->strm->avail_in == 0 && (long)s->strstart == s->block_start)
+return block_done;
+/* Fill the window with any remaining input. */
+have = s->window_size - s->strstart - 1;
+if (s->strm->avail_in > have && s->block_start >= (long)s->w_size) {
+/* Slide the window down. */
+s->block_start -= s->w_size;
+s->strstart -= s->w_size;
+zmemcpy(s->window, s->window + s->w_size, s->strstart);
+if (s->matches < 2)
+s->matches++;           /* add a pending slide_hash() */
+have += s->w_size;          /* more space now */
+}
+if (have > s->strm->avail_in)
+have = s->strm->avail_in;
+if (have) {
+read_buf(s->strm, s->window + s->strstart, have);
+s->strstart += have;
+}
+if (s->high_water < s->strstart)
+s->high_water = s->strstart;
+/* There was not enough avail_out to write a complete worthy or flushed
+* stored block to next_out. Write a stored block to pending instead, if we
+* have enough input for a worthy block, or if flushing and there is enough
+* room for the remaining input as a stored block in the pending buffer.
+*/
+have = (s->bi_valid + 42) >> 3;         /* number of header bytes */
+/* maximum stored block length that will fit in pending: */
+have = MIN(s->pending_buf_size - have, MAX_STORED);
+min_block = MIN(have, s->w_size);
+left = s->strstart - s->block_start;
+if (left >= min_block ||
+((left || flush == Z_FINISH) && flush != Z_NO_FLUSH &&
+s->strm->avail_in == 0 && left <= have)) {
+len = MIN(left, have);
+last = flush == Z_FINISH && s->strm->avail_in == 0 &&
+len == left ? 1 : 0;
+_tr_stored_block(s, (charf *)s->window + s->block_start, len, last);
+s->block_start += len;
+flush_pending(s->strm);
+}
+/* We've done all we can with the available input and output. */
+return last ? finish_started : need_more;
 }
 /* ===========================================================================
 * Compress as much as possible from the input stream, return the current
 * block state.
 */
 local block_state deflate_fast(s, flush)
 deflate_state *s;
 int flush;
 {
-IPos hash_head = NIL; /* head of the hash chain */
+IPos hash_head;       /* 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
 }
 /* Insert the string window[strstart .. strstart+2] in the
 * dictionary, and set hash_head to the head of the hash chain:
 */
+hash_head = NIL;
 if (s->lookahead >= MIN_MATCH) {
 INSERT_STRING(s, s->strstart, hash_head);
 }
 /* Find the longest match, discarding those <= prev_length.
 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
+s->match_length = longest_match (s, hash_head);
-if ((s->strategy != Z_HUFFMAN_ONLY && s->strategy != Z_RLE) ||
+/* longest_match() sets match_start */
-(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->lookahead--;
 s->strstart++;
 }
 if (bflush) FLUSH_BLOCK(s, 0);
 }
-FLUSH_BLOCK(s, flush == Z_FINISH);
+s->insert = s->strstart < MIN_MATCH-1 ? s->strstart : MIN_MATCH-1;
-return flush == Z_FINISH ? finish_done : block_done;
+if (flush == Z_FINISH) {
+FLUSH_BLOCK(s, 1);
+return finish_done;
+}
+if (s->last_lit)
+FLUSH_BLOCK(s, 0);
+return block_done;
 }
 #ifndef FASTEST
 /* ===========================================================================
 * Same as above, but achieves better compression. We use a lazy
 */
 local block_state deflate_slow(s, flush)
 deflate_state *s;
 int flush;
 {
-IPos hash_head = NIL;    /* head of hash chain */
+IPos hash_head;          /* 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
 }
 /* Insert the string window[strstart .. strstart+2] in the
 * dictionary, and set hash_head to the head of the hash chain:
 */
+hash_head = NIL;
 if (s->lookahead >= MIN_MATCH) {
 INSERT_STRING(s, s->strstart, hash_head);
 }
 /* Find the longest match, discarding those <= prev_length.
 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);
-s->match_length = longest_match (s, hash_head);
+/* longest_match() sets match_start */
-} 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)
 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);
+s->insert = s->strstart < MIN_MATCH-1 ? s->strstart : MIN_MATCH-1;
-return flush == Z_FINISH ? finish_done : block_done;
+if (flush == Z_FINISH) {
+FLUSH_BLOCK(s, 1);
+return finish_done;
+}
+if (s->last_lit)
+FLUSH_BLOCK(s, 0);
+return 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 */
+int bflush;             /* set if current block must be flushed */
-uInt run;           /* length of run */
+uInt prev;              /* byte at distance one to match */
-uInt max;           /* maximum length of run */
+Bytef *scan, *strend;   /* scan goes up to strend for 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.
+* for the longest run, plus one for the unrolled loop.
 */
-if (s->lookahead < MAX_MATCH) {
+if (s->lookahead <= MAX_MATCH) {
 fill_window(s);
-if (s->lookahead < MAX_MATCH && flush == Z_NO_FLUSH) {
+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;
+s->match_length = 0;
-if (s->strstart > 0) {      /* if there is a previous byte, that is */
+if (s->lookahead >= MIN_MATCH && s->strstart > 0) {
-max = s->lookahead < MAX_MATCH ? s->lookahead : MAX_MATCH;
 scan = s->window + s->strstart - 1;
-prev = *scan++;
+prev = *scan;
-do {
+if (prev == *++scan && prev == *++scan && prev == *++scan) {
-if (*scan++ != prev)
+strend = s->window + s->strstart + MAX_MATCH;
-break;
+do {
-} while (++run < max);
+} while (prev == *++scan && prev == *++scan &&
+prev == *++scan && prev == *++scan &&
+prev == *++scan && prev == *++scan &&
+prev == *++scan && prev == *++scan &&
+scan < strend);
+s->match_length = MAX_MATCH - (uInt)(strend - scan);
+if (s->match_length > s->lookahead)
+s->match_length = s->lookahead;
+}
+Assert(scan <= s->window+(uInt)(s->window_size-1), "wild scan");
 }
 /* Emit match if have run of MIN_MATCH or longer, else emit literal */
-if (run >= MIN_MATCH) {
+if (s->match_length >= MIN_MATCH) {
-check_match(s, s->strstart, s->strstart - 1, run);
+check_match(s, s->strstart, s->strstart - 1, s->match_length);
-_tr_tally_dist(s, 1, run - MIN_MATCH, bflush);
-s->lookahead -= run;
+_tr_tally_dist(s, 1, s->match_length - MIN_MATCH, bflush);
-s->strstart += run;
+s->lookahead -= s->match_length;
+s->strstart += s->match_length;
+s->match_length = 0;
 } 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);
+s->insert = 0;
-return flush == Z_FINISH ? finish_done : block_done;
+if (flush == Z_FINISH) {
-}
+FLUSH_BLOCK(s, 1);
-#endif
+return finish_done;
+}
+if (s->last_lit)
+FLUSH_BLOCK(s, 0);
+return block_done;
+}
+/* ===========================================================================
+* For Z_HUFFMAN_ONLY, do not look for matches.  Do not maintain a hash table.
+* (It will be regenerated if this run of deflate switches away from Huffman.)
+*/
+local block_state deflate_huff(s, flush)
+deflate_state *s;
+int flush;
+{
+int bflush;             /* set if current block must be flushed */
+for (;;) {
+/* Make sure that we have a literal to write. */
+if (s->lookahead == 0) {
+fill_window(s);
+if (s->lookahead == 0) {
+if (flush == Z_NO_FLUSH)
+return need_more;
+break;      /* flush the current block */
+}
+}
+/* Output a literal byte */
+s->match_length = 0;
+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);
+}
+s->insert = 0;
+if (flush == Z_FINISH) {
+FLUSH_BLOCK(s, 1);
+return finish_done;
+}
+if (s->last_lit)
+FLUSH_BLOCK(s, 0);
+return block_done;
+}

Mercurial > hg > CbC > CbC_gcc

comparison zlib/deflate.c @ 111:04ced10e8804