Update Zlib to version 1.2.8

third_party/zlib/mixed-source.patch

 diff --git a/third_party/zlib/deflate.c b/third_party/zlib/deflate.c
-index 5c4022f..88b2ec0 100644
+index 6969577..7c95b30 100644
 --- a/third_party/zlib/deflate.c
 +++ b/third_party/zlib/deflate.c
 @@ -70,14 +70,15 @@ typedef enum {
      finish_done     /* finish done, accept no more input or output */
  } block_state;
  
 -typedef block_state (*compress_func) OF((deflate_state *s, int flush));
 +typedef block_state (*compress_func) OF((deflate_state *s, int flush,
 +                                         int clas));
  /* Compression function. Returns the block state after the call. */
@@ skipping 14 matching lines @@
  #ifdef ASMV
        void match_init OF((void)); /* asm code initialization */
 -      uInt longest_match  OF((deflate_state *s, IPos cur_match));
 +      uInt longest_match  OF((deflate_state *s, IPos cur_match, int clas));
  #else
 -local uInt longest_match  OF((deflate_state *s, IPos cur_match));
 +local uInt longest_match  OF((deflate_state *s, IPos cur_match, int clas));
  #endif
  
  #ifdef DEBUG
-@@ -281,6 +282,9 @@ int ZEXPORT deflateInit2_(strm, level, method, windowBits, memLevel, strategy,
+@@ -293,6 +294,9 @@ int ZEXPORT deflateInit2_(strm, level, method, windowBits, memLevel, strategy,
      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->class_bitmap = NULL;
 +    zmemzero(&s->cookie_locations, sizeof(s->cookie_locations));
 +    strm->clas = 0;
  
      s->high_water = 0;      /* nothing written to s->window yet */
  
-@@ -367,6 +371,8 @@ int ZEXPORT deflateReset (strm)
+@@ -406,6 +410,8 @@ int ZEXPORT deflateResetKeep (strm)
      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); */
-@@ -817,9 +823,26 @@ int ZEXPORT deflate (strm, flush)
+@@ -900,9 +906,26 @@ int ZEXPORT deflate (strm, flush)
          (flush != Z_NO_FLUSH && s->status != FINISH_STATE)) {
          block_state bstate;
  
 -        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 (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);
 +        }
  
          if (bstate == finish_started || bstate == finish_done) {
              s->status = FINISH_STATE;
-@@ -915,6 +938,7 @@ int ZEXPORT deflateEnd (strm)
+@@ -999,6 +1022,7 @@ int ZEXPORT deflateEnd (strm)
      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;
-@@ -1046,6 +1070,57 @@ local void lm_init (s)
+@@ -1131,6 +1155,57 @@ local void lm_init (s)
  #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;
@@ skipping 37 matching lines @@
 +    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
-@@ -1060,9 +1135,10 @@ local void lm_init (s)
+@@ -1145,9 +1220,10 @@ local void lm_init (s)
  /* 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)
 +local uInt longest_match(s, cur_match, clas)
      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 */
-@@ -1110,6 +1186,9 @@ local uInt longest_match(s, cur_match)
+@@ -1195,6 +1271,9 @@ local uInt longest_match(s, cur_match)
      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
-@@ -1152,6 +1231,8 @@ local uInt longest_match(s, cur_match)
+@@ -1237,6 +1316,8 @@ local uInt longest_match(s, cur_match)
          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  ||
-@@ -1168,15 +1249,23 @@ local uInt longest_match(s, cur_match)
+@@ -1253,15 +1334,23 @@ local uInt longest_match(s, cur_match)
          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 &&
@@ skipping 12 matching lines @@
 +        } 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);
 +        }
  
          Assert(scan <= s->window+(unsigned)(s->window_size-1), "wild scan");
  
-@@ -1204,20 +1293,74 @@ local uInt longest_match(s, cur_match)
+@@ -1289,20 +1378,74 @@ local uInt longest_match(s, cur_match)
  }
  #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)
@@ skipping 55 matching lines @@
      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.
       */
-@@ -1360,6 +1503,21 @@ local void fill_window(s)
+@@ -1447,6 +1590,20 @@ local void fill_window(s)
                   */
              } 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) return;
-@@ -1378,6 +1536,9 @@ local void fill_window(s)
+         if (s->strm->avail_in == 0) break;
+@@ -1465,6 +1622,9 @@ local void fill_window(s)
          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: */
-@@ -1459,9 +1620,10 @@ local void fill_window(s)
+@@ -1561,9 +1721,10 @@ local void fill_window(s)
   * NOTE: this function should be optimized to avoid extra copying from
   * window to pending_buf.
   */
 -local block_state deflate_stored(s, flush)
 +local block_state deflate_stored(s, flush, clas)
      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:
-@@ -1517,13 +1679,19 @@ local block_state deflate_stored(s, flush)
+@@ -1625,13 +1786,19 @@ local block_state deflate_stored(s, flush)
   * 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)
 +local block_state deflate_fast(s, flush, clas)
      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
-@@ -1554,7 +1722,7 @@ local block_state deflate_fast(s, flush)
+@@ -1662,7 +1829,7 @@ local block_state deflate_fast(s, flush)
               * 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);
 +            s->match_length = longest_match (s, hash_head, clas);
              /* longest_match() sets match_start */
          }
          if (s->match_length >= MIN_MATCH) {
-@@ -1613,12 +1781,25 @@ local block_state deflate_fast(s, flush)
+@@ -1727,12 +1894,25 @@ local block_state deflate_fast(s, flush)
   * 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)
 +local block_state deflate_slow(s, flush, clas)
      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 (;;) {
-@@ -1648,13 +1829,18 @@ local block_state deflate_slow(s, flush)
+@@ -1762,13 +1942,18 @@ local block_state deflate_slow(s, flush)
          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)) {
 +        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)) {
              /* 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);
 +            s->match_length = longest_match (s, hash_head, clas);
 +
              /* longest_match() sets match_start */
  
              if (s->match_length <= 5 && (s->strategy == Z_FILTERED
-@@ -1673,7 +1859,20 @@ local block_state deflate_slow(s, flush)
+@@ -1787,7 +1972,20 @@ local block_state deflate_slow(s, flush)
          /* 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) {
 +        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) == ';')))) {
              uInt max_insert = s->strstart + s->lookahead - MIN_MATCH;
              /* Do not insert strings in hash table beyond this. */
  
 diff --git a/third_party/zlib/deflate.h b/third_party/zlib/deflate.h
-index cbf0d1e..2fe6fd6 100644
+index ce0299e..c795034 100644
 --- a/third_party/zlib/deflate.h
 +++ b/third_party/zlib/deflate.h
-@@ -91,6 +91,9 @@ typedef unsigned IPos;
+@@ -94,6 +94,9 @@ typedef unsigned IPos;
   * save space in the various tables. IPos is used only for parameter passing.
   */
  
 +#define Z_COOKIE_HASH_SIZE 256
 +#define Z_COOKIE_HASH_MASK (Z_COOKIE_HASH_SIZE-1)
 +
  typedef struct internal_state {
      z_streamp strm;      /* pointer back to this zlib stream */
      int   status;        /* as the name implies */
-@@ -139,6 +142,8 @@ typedef struct internal_state {
+@@ -142,6 +145,8 @@ typedef struct internal_state {
      uInt  hash_mask;      /* hash_size-1 */
  
      uInt  hash_shift;
 +    Bytef *class_bitmap;  /* bitmap of class for each byte in window */
 +    IPos cookie_locations[Z_COOKIE_HASH_SIZE];
      /* Number of bits by which ins_h must be shifted at each input
       * step. It must be such that after MIN_MATCH steps, the oldest
       * byte no longer takes part in the hash key, that is:
 diff --git a/third_party/zlib/zlib.h b/third_party/zlib/zlib.h
-index 4d54af9..da7e971 100644
+index 36c73af..5544c88 100644
 --- a/third_party/zlib/zlib.h
 +++ b/third_party/zlib/zlib.h
 @@ -101,6 +101,7 @@ typedef struct z_stream_s {
      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 */
 +    int     clas;
  } z_stream;
  
  typedef z_stream FAR *z_streamp;
 @@ -207,6 +208,10 @@ typedef gz_header FAR *gz_headerp;
  
  #define Z_NULL  0  /* for initializing zalloc, zfree, opaque */
  
 +#define Z_CLASS_STANDARD 0
 +#define Z_CLASS_COOKIE 1
 +#define Z_CLASS_HUFFMAN_ONLY 2
 +
  #define zlib_version zlibVersion()
  /* for compatibility with versions < 1.0.2 */
  
-@@ -1587,6 +1592,13 @@ ZEXTERN int ZEXPORT inflateBackInit_ OF((z_streamp strm, int windowBits,
+@@ -1744,6 +1749,13 @@ ZEXTERN int ZEXPORT gzgetc_ OF((gzFile file));  /* backward compatibility */
       ZEXTERN z_off_t ZEXPORT gzoffset64 OF((gzFile));
       ZEXTERN uLong ZEXPORT adler32_combine64 OF((uLong, uLong, z_off_t));
       ZEXTERN uLong ZEXPORT crc32_combine64 OF((uLong, uLong, z_off_t));
 +#  else
 +     ZEXTERN gzFile ZEXPORT gzopen OF((const char *, const char *));
 +     ZEXTERN z_off_t ZEXPORT gzseek OF((gzFile, z_off_t, int));
 +     ZEXTERN z_off_t ZEXPORT gztell OF((gzFile));
 +     ZEXTERN z_off_t ZEXPORT gzoffset OF((gzFile));
 +     ZEXTERN uLong ZEXPORT adler32_combine OF((uLong, uLong, z_off_t));
 +     ZEXTERN uLong ZEXPORT crc32_combine OF((uLong, uLong, z_off_t));
  #  endif
  #else
     ZEXTERN gzFile ZEXPORT gzopen OF((const char *, const char *));
+-- 
+2.7.4
+