Remove mixed-source.patch from zlib.

third_party/zlib/deflate.c

 /* deflate.c -- compress data using the deflation algorithm
  * Copyright (C) 1995-2013 Jean-loup Gailly and Mark Adler
  * 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
@@ skipping 53 matching lines @@
 /* ===========================================================================
  *  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,
-                                         int clas));
+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, int clas));
-local block_state deflate_fast   OF((deflate_state *s, int flush, int clas));
+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, int clas));
+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));
 
 #ifdef ASMV
       void match_init OF((void)); /* asm code initialization */
-      uInt longest_match  OF((deflate_state *s, IPos cur_match, int clas));
+      uInt longest_match  OF((deflate_state *s, IPos cur_match));
 #else
-local uInt longest_match  OF((deflate_state *s, IPos cur_match, int clas));
+local uInt longest_match  OF((deflate_state *s, IPos cur_match));
 #endif
 
 #ifdef DEBUG
 local  void check_match OF((deflate_state *s, IPos start, IPos match,
                             int length));
 #endif
 
 /* For fill_window_sse.c to use */
 ZLIB_INTERNAL int read_buf OF((z_streamp strm, Bytef *buf, unsigned size));
 
@@ skipping 218 matching lines @@
         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 + window_padding, 2*sizeof(Byte));
     s->prev   = (Posf *)  ZALLOC(strm, s->w_size, sizeof(Pos));
     s->head   = (Posf *)  ZALLOC(strm, s->hash_size, sizeof(Pos));
-    s->class_bitmap = NULL;
-    zmemzero(&s->cookie_locations, sizeof(s->cookie_locations));
-    strm->clas = 0;
 
     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 ||
@@ skipping 89 matching lines @@
         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;
-    TRY_FREE(strm, s->class_bitmap);
-    s->class_bitmap = NULL;
 
     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);
@@ skipping 474 matching lines @@
     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;
 
-        if (strm->clas && s->class_bitmap == NULL) {
-            /* This is the first time that we have seen alternative class
-             * data. All data up till this point has been standard class. */
-            s->class_bitmap = (Bytef*) ZALLOC(strm, s->w_size/4, sizeof(Byte));
-            zmemzero(s->class_bitmap, s->w_size/4);
-        }
-
-        if (strm->clas && s->strategy == Z_RLE) {
-            /* We haven't patched deflate_rle. */
-            ERR_RETURN(strm, Z_BUF_ERROR);
-        }
-
-        if (s->strategy == Z_HUFFMAN_ONLY) {
-            bstate = deflate_huff(s, flush);
-        } else if (s->strategy == Z_RLE) {
-            bstate = deflate_rle(s, flush);
-        } else {
-            bstate = (*(configuration_table[s->level].func))
-                (s, flush, strm->clas);
-        }
+        bstate = 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 (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
@@ skipping 77 matching lines @@
         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);
-    TRY_FREE(strm, strm->state->class_bitmap);
 
     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
@@ skipping 113 matching lines @@
     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
 }
 
-/* class_set sets bits [offset,offset+len) in s->class_bitmap to either 1 (if
- * class != 0) or 0 (otherwise). */
-local void class_set(s, offset, len, clas)
-    deflate_state *s;
-    IPos offset;
-    uInt len;
-    int clas;
-{
-    IPos byte = offset >> 3;
-    IPos bit = offset & 7;
-    Bytef class_byte_value = clas ? 0xff : 0x00;
-    Bytef class_bit_value = clas ? 1 : 0;
-    static const Bytef mask[8] = {0xfe, 0xfd, 0xfb, 0xf7,
-                                  0xef, 0xdf, 0xbf, 0x7f};
-
-    if (bit) {
-        while (len) {
-            s->class_bitmap[byte] &= mask[bit];
-            s->class_bitmap[byte] |= class_bit_value << bit;
-            bit++;
-            len--;
-            if (bit == 8) {
-                bit = 0;
-                byte++;
-                break;
-            }
-        }
-    }
-
-    while (len >= 8) {
-        s->class_bitmap[byte++] = class_byte_value;
-        len -= 8;
-    }
-
-    while (len) {
-            s->class_bitmap[byte] &= mask[bit];
-            s->class_bitmap[byte] |= class_bit_value << bit;
-            bit++;
-            len--;
-    }
-}
-
-local int class_at(s, window_offset)
-    deflate_state *s;
-    IPos window_offset;
-{
-    IPos byte = window_offset >> 3;
-    IPos bit = window_offset & 7;
-    return (s->class_bitmap[byte] >> bit) & 1;
-}
-
 #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, clas)
+local uInt longest_match(s, cur_match)
     deflate_state *s;
     IPos cur_match;                             /* current match */
-    int clas;
 {
     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,
@@ skipping 27 matching lines @@
     /* 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;
-        /* If the matched data is in the wrong class, skip it. */
-        if (s->class_bitmap && class_at(s, cur_match) != clas)
-            continue;
 
         /* 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)
@@ skipping 22 matching lines @@
                  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);
 
-#error "UNALIGNED_OK hasn't been patched."
-
 #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]?");
 
-        if (!s->class_bitmap) {
-            /* 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);
-        } else {
-            /* We have to be mindful of the class of the data and not stray. */
-            do {
-            } while (*++scan == *++match &&
-                     class_at(s, match - s->window) == clas &&
-                     scan < strend);
-        }
+        /* 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 */
 
-/* cookie_match is a replacement for longest_match in the case of cookie data.
- * Here we only wish to match the entire value so trying the partial matches in
- * longest_match is both wasteful and often fails to find the correct match.
- *
- * So we take the djb2 hash of the cookie and look up the last position for a
- * match in a special hash table. */
-local uInt cookie_match(s, start, len)
-    deflate_state *s;
-    IPos start;
-    unsigned len;
-{
-    unsigned hash = 5381;
-    Bytef *str = s->window + start;
-    unsigned i;
-    IPos cookie_location;
-
-    if (len >= MAX_MATCH || len == 0)
-        return 0;
-
-    for (i = 0; i < len; i++)
-        hash = ((hash << 5) + hash) + str[i];
-
-    hash &= Z_COOKIE_HASH_MASK;
-    cookie_location = s->cookie_locations[hash];
-    s->cookie_locations[hash] = start;
-    s->match_start = 0;
-    if (cookie_location &&
-        (start - cookie_location) > len &&
-        (start - cookie_location) < MAX_DIST(s) &&
-        len <= s->lookahead) {
-        for (i = 0; i < len; i++) {
-            if (s->window[start+i] != s->window[cookie_location+i] ||
-                class_at(s, cookie_location+i) != 1) {
-                return 0;
-            }
-        }
-        /* Check that we aren't matching a prefix of another cookie by ensuring
-         * that the final byte is either a semicolon (which cannot appear in a
-         * cookie value), or non-cookie data. */
-        if (s->window[cookie_location+len-1] != ';' &&
-            class_at(s, cookie_location+len) != 0) {
-          return 0;
-        }
-        s->match_start = cookie_location;
-        return len;
-    }
-
-    return 0;
-}
-
-
 #else /* FASTEST */
 
 /* ---------------------------------------------------------------------------
  * Optimized version for FASTEST only
  */
-local uInt longest_match(s, cur_match, clas)
+local uInt longest_match(s, cur_match)
     deflate_state *s;
     IPos cur_match;                             /* current match */
-    int clas;
 {
     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;
 
-#error "This code not patched"
-
     /* 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;
@@ skipping 136 matching lines @@
 #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
-            for (n = 0; n < Z_COOKIE_HASH_SIZE; n++) {
-                if (s->cookie_locations[n] > wsize) {
-                    s->cookie_locations[n] -= wsize;
-                } else {
-                    s->cookie_locations[n] = 0;
-                }
-            }
-
-            if (s->class_bitmap) {
-                zmemcpy(s->class_bitmap, s->class_bitmap + s->w_size/8,
-                        s->w_size/8);
-                zmemzero(s->class_bitmap + s->w_size/8, s->w_size/8);
-            }
-
             more += wsize;
         }
         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)
          * => 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);
-        if (s->class_bitmap != NULL) {
-            class_set(s, s->strstart + s->lookahead, n, s->strm->clas);
-        }
         s->lookahead += n;
 
         /* Initialize the hash value now that we have some input: */
         if (s->lookahead + s->insert >= MIN_MATCH) {
             uInt str = s->strstart - s->insert;
             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
@@ skipping 76 matching lines @@
 
 /* ===========================================================================
  * 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, clas)
+local block_state deflate_stored(s, flush)
     deflate_state *s;
     int flush;
-    int clas;
 {
     /* 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;
     }
@@ skipping 41 matching lines @@
     return 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, clas)
+local block_state deflate_fast(s, flush)
     deflate_state *s;
     int flush;
-    int clas;
 {
     IPos hash_head;       /* head of the hash chain */
     int bflush;           /* set if current block must be flushed */
 
-    if (clas != 0) {
-        /* We haven't patched this code for alternative class data. */
-        return Z_BUF_ERROR;
-    }
-
     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;
@@ skipping 10 matching lines @@
         }
 
         /* 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).
              */
-            s->match_length = longest_match (s, hash_head, clas);
+            s->match_length = longest_match (s, hash_head);
             /* longest_match() 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;
 
@@ skipping 44 matching lines @@
         FLUSH_BLOCK(s, 0);
     return 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, clas)
+local block_state deflate_slow(s, flush)
     deflate_state *s;
     int flush;
-    int clas;
 {
     IPos hash_head;          /* head of hash chain */
     int bflush;              /* set if current block must be flushed */
-    uInt input_length ;
-    int first = 1;           /* first says whether this is the first iteration
-                                of the loop, below. */
-
-    if (clas == Z_CLASS_COOKIE) {
-        if (s->lookahead) {
-            /* Alternative class data must always be presented at the beginning
-             * of a block. */
-            return Z_BUF_ERROR;
-        }
-        input_length = s->strm->avail_in;
-    }
 
     /* 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:
          */
         hash_head = NIL;
         if (s->lookahead >= MIN_MATCH) {
             hash_head = insert_string(s, s->strstart);
         }
 
         /* 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 (clas == Z_CLASS_COOKIE && first) {
-            s->match_length = cookie_match(s, s->strstart, input_length);
-        } else if (clas == Z_CLASS_STANDARD &&
-                   hash_head != NIL &&
-                   s->prev_length < s->max_lazy_match &&
-                   s->strstart - hash_head <= MAX_DIST(s)) {
+        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).
              */
-            s->match_length = longest_match (s, hash_head, clas);
-
+            s->match_length = longest_match (s, hash_head);
             /* longest_match() 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:
          */
-        first = 0;
-        if (s->prev_length >= MIN_MATCH && s->match_length <= s->prev_length &&
-            /* We will only accept an exact match for Z_CLASS_COOKIE data and
-             * we won't match Z_CLASS_HUFFMAN_ONLY data at all. */
-            (clas == Z_CLASS_STANDARD || (clas == Z_CLASS_COOKIE &&
-                            s->prev_length == input_length &&
-                            s->prev_match > 0 &&
-                            /* We require that a Z_CLASS_COOKIE match be
-                             * preceded by either a semicolon (which cannot be
-                             * part of a cookie), or non-cookie data. This is
-                             * to prevent a cookie from being a suffix of
-                             * another. */
-                            (class_at(s, s->prev_match-1) == Z_CLASS_STANDARD ||
-                             *(s->window + s->prev_match-1) == ';')))) {
+        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
@@ skipping 191 matching lines @@
 #else
     /* This should never happen */
     assert(0);
 #endif
 
     ret = s->head[h & s->hash_mask];
     s->head[h & s->hash_mask] = str;
     s->prev[str & s->w_mask] = ret;
     return ret;
 }