| blob | ed54802c097852509b8e3a28b464770f8f25fabc |
1 diff --git a/third_party/zlib/deflate.c b/third_party/zlib/deflate.c
2 index 5c4022f..88b2ec0 100644
3 --- a/third_party/zlib/deflate.c
4 +++ b/third_party/zlib/deflate.c
5 @@ -70,14 +70,15 @@ typedef enum {
6 finish_done /* finish done, accept no more input or output */
7 } block_state;
9 -typedef block_state (*compress_func) OF((deflate_state *s, int flush));
10 +typedef block_state (*compress_func) OF((deflate_state *s, int flush,
11 + int clas));
12 /* Compression function. Returns the block state after the call. */
14 local void fill_window OF((deflate_state *s));
15 -local block_state deflate_stored OF((deflate_state *s, int flush));
16 -local block_state deflate_fast OF((deflate_state *s, int flush));
17 +local block_state deflate_stored OF((deflate_state *s, int flush, int clas));
18 +local block_state deflate_fast OF((deflate_state *s, int flush, int clas));
19 #ifndef FASTEST
20 -local block_state deflate_slow OF((deflate_state *s, int flush));
21 +local block_state deflate_slow OF((deflate_state *s, int flush, int clas));
22 #endif
23 local block_state deflate_rle OF((deflate_state *s, int flush));
24 local block_state deflate_huff OF((deflate_state *s, int flush));
25 @@ -87,9 +88,9 @@ local void flush_pending OF((z_streamp strm));
26 local int read_buf OF((z_streamp strm, Bytef *buf, unsigned size));
27 #ifdef ASMV
28 void match_init OF((void)); /* asm code initialization */
29 - uInt longest_match OF((deflate_state *s, IPos cur_match));
30 + uInt longest_match OF((deflate_state *s, IPos cur_match, int clas));
31 #else
32 -local uInt longest_match OF((deflate_state *s, IPos cur_match));
33 +local uInt longest_match OF((deflate_state *s, IPos cur_match, int clas));
34 #endif
36 #ifdef DEBUG
37 @@ -281,6 +282,9 @@ int ZEXPORT deflateInit2_(strm, level, method, windowBits, memLevel, strategy,
38 s->window = (Bytef *) ZALLOC(strm, s->w_size, 2*sizeof(Byte));
39 s->prev = (Posf *) ZALLOC(strm, s->w_size, sizeof(Pos));
40 s->head = (Posf *) ZALLOC(strm, s->hash_size, sizeof(Pos));
41 + s->class_bitmap = NULL;
42 + zmemzero(&s->cookie_locations, sizeof(s->cookie_locations));
43 + strm->clas = 0;
45 s->high_water = 0; /* nothing written to s->window yet */
47 @@ -367,6 +371,8 @@ int ZEXPORT deflateReset (strm)
48 s = (deflate_state *)strm->state;
49 s->pending = 0;
50 s->pending_out = s->pending_buf;
51 + TRY_FREE(strm, s->class_bitmap);
52 + s->class_bitmap = NULL;
54 if (s->wrap < 0) {
55 s->wrap = -s->wrap; /* was made negative by deflate(..., Z_FINISH); */
56 @@ -817,9 +823,26 @@ int ZEXPORT deflate (strm, flush)
57 (flush != Z_NO_FLUSH && s->status != FINISH_STATE)) {
58 block_state bstate;
60 - bstate = s->strategy == Z_HUFFMAN_ONLY ? deflate_huff(s, flush) :
61 - (s->strategy == Z_RLE ? deflate_rle(s, flush) :
62 - (*(configuration_table[s->level].func))(s, flush));
63 + if (strm->clas && s->class_bitmap == NULL) {
64 + /* This is the first time that we have seen alternative class
65 + * data. All data up till this point has been standard class. */
66 + s->class_bitmap = (Bytef*) ZALLOC(strm, s->w_size/4, sizeof(Byte));
67 + zmemzero(s->class_bitmap, s->w_size/4);
68 + }
69 +
70 + if (strm->clas && s->strategy == Z_RLE) {
71 + /* We haven't patched deflate_rle. */
72 + ERR_RETURN(strm, Z_BUF_ERROR);
73 + }
74 +
75 + if (s->strategy == Z_HUFFMAN_ONLY) {
76 + bstate = deflate_huff(s, flush);
77 + } else if (s->strategy == Z_RLE) {
78 + bstate = deflate_rle(s, flush);
79 + } else {
80 + bstate = (*(configuration_table[s->level].func))
81 + (s, flush, strm->clas);
82 + }
84 if (bstate == finish_started || bstate == finish_done) {
85 s->status = FINISH_STATE;
86 @@ -915,6 +938,7 @@ int ZEXPORT deflateEnd (strm)
87 TRY_FREE(strm, strm->state->head);
88 TRY_FREE(strm, strm->state->prev);
89 TRY_FREE(strm, strm->state->window);
90 + TRY_FREE(strm, strm->state->class_bitmap);
92 ZFREE(strm, strm->state);
93 strm->state = Z_NULL;
94 @@ -1046,6 +1070,57 @@ local void lm_init (s)
95 #endif
96 }
98 +/* class_set sets bits [offset,offset+len) in s->class_bitmap to either 1 (if
99 + * class != 0) or 0 (otherwise). */
100 +local void class_set(s, offset, len, clas)
101 + deflate_state *s;
102 + IPos offset;
103 + uInt len;
104 + int clas;
105 +{
106 + IPos byte = offset >> 3;
107 + IPos bit = offset & 7;
108 + Bytef class_byte_value = clas ? 0xff : 0x00;
109 + Bytef class_bit_value = clas ? 1 : 0;
110 + static const Bytef mask[8] = {0xfe, 0xfd, 0xfb, 0xf7,
111 + 0xef, 0xdf, 0xbf, 0x7f};
112 +
113 + if (bit) {
114 + while (len) {
115 + s->class_bitmap[byte] &= mask[bit];
116 + s->class_bitmap[byte] |= class_bit_value << bit;
117 + bit++;
118 + len--;
119 + if (bit == 8) {
120 + bit = 0;
121 + byte++;
122 + break;
123 + }
124 + }
125 + }
126 +
127 + while (len >= 8) {
128 + s->class_bitmap[byte++] = class_byte_value;
129 + len -= 8;
130 + }
131 +
132 + while (len) {
133 + s->class_bitmap[byte] &= mask[bit];
134 + s->class_bitmap[byte] |= class_bit_value << bit;
135 + bit++;
136 + len--;
137 + }
138 +}
139 +
140 +local int class_at(s, window_offset)
141 + deflate_state *s;
142 + IPos window_offset;
143 +{
144 + IPos byte = window_offset >> 3;
145 + IPos bit = window_offset & 7;
146 + return (s->class_bitmap[byte] >> bit) & 1;
147 +}
148 +
149 #ifndef FASTEST
150 /* ===========================================================================
151 * Set match_start to the longest match starting at the given string and
152 @@ -1060,9 +1135,10 @@ local void lm_init (s)
153 /* For 80x86 and 680x0, an optimized version will be provided in match.asm or
154 * match.S. The code will be functionally equivalent.
155 */
156 -local uInt longest_match(s, cur_match)
157 +local uInt longest_match(s, cur_match, clas)
158 deflate_state *s;
159 IPos cur_match; /* current match */
160 + int clas;
161 {
162 unsigned chain_length = s->max_chain_length;/* max hash chain length */
163 register Bytef *scan = s->window + s->strstart; /* current string */
164 @@ -1110,6 +1186,9 @@ local uInt longest_match(s, cur_match)
165 do {
166 Assert(cur_match < s->strstart, "no future");
167 match = s->window + cur_match;
168 + /* If the matched data is in the wrong class, skip it. */
169 + if (s->class_bitmap && class_at(s, cur_match) != clas)
170 + continue;
172 /* Skip to next match if the match length cannot increase
173 * or if the match length is less than 2. Note that the checks below
174 @@ -1152,6 +1231,8 @@ local uInt longest_match(s, cur_match)
175 len = (MAX_MATCH - 1) - (int)(strend-scan);
176 scan = strend - (MAX_MATCH-1);
178 +#error "UNALIGNED_OK hasn't been patched."
179 +
180 #else /* UNALIGNED_OK */
182 if (match[best_len] != scan_end ||
183 @@ -1168,15 +1249,23 @@ local uInt longest_match(s, cur_match)
184 scan += 2, match++;
185 Assert(*scan == *match, "match[2]?");
187 - /* We check for insufficient lookahead only every 8th comparison;
188 - * the 256th check will be made at strstart+258.
189 - */
190 - do {
191 - } while (*++scan == *++match && *++scan == *++match &&
192 - *++scan == *++match && *++scan == *++match &&
193 - *++scan == *++match && *++scan == *++match &&
194 - *++scan == *++match && *++scan == *++match &&
195 - scan < strend);
196 + if (!s->class_bitmap) {
197 + /* We check for insufficient lookahead only every 8th comparison;
198 + * the 256th check will be made at strstart+258.
199 + */
200 + do {
201 + } while (*++scan == *++match && *++scan == *++match &&
202 + *++scan == *++match && *++scan == *++match &&
203 + *++scan == *++match && *++scan == *++match &&
204 + *++scan == *++match && *++scan == *++match &&
205 + scan < strend);
206 + } else {
207 + /* We have to be mindful of the class of the data and not stray. */
208 + do {
209 + } while (*++scan == *++match &&
210 + class_at(s, match - s->window) == clas &&
211 + scan < strend);
212 + }
214 Assert(scan <= s->window+(unsigned)(s->window_size-1), "wild scan");
216 @@ -1204,20 +1293,74 @@ local uInt longest_match(s, cur_match)
217 }
218 #endif /* ASMV */
220 +/* cookie_match is a replacement for longest_match in the case of cookie data.
221 + * Here we only wish to match the entire value so trying the partial matches in
222 + * longest_match is both wasteful and often fails to find the correct match.
223 + *
224 + * So we take the djb2 hash of the cookie and look up the last position for a
225 + * match in a special hash table. */
226 +local uInt cookie_match(s, start, len)
227 + deflate_state *s;
228 + IPos start;
229 + unsigned len;
230 +{
231 + unsigned hash = 5381;
232 + Bytef *str = s->window + start;
233 + unsigned i;
234 + IPos cookie_location;
235 +
236 + if (len >= MAX_MATCH || len == 0)
237 + return 0;
238 +
239 + for (i = 0; i < len; i++)
240 + hash = ((hash << 5) + hash) + str[i];
241 +
242 + hash &= Z_COOKIE_HASH_MASK;
243 + cookie_location = s->cookie_locations[hash];
244 + s->cookie_locations[hash] = start;
245 + s->match_start = 0;
246 + if (cookie_location &&
247 + (start - cookie_location) > len &&
248 + (start - cookie_location) < MAX_DIST(s) &&
249 + len <= s->lookahead) {
250 + for (i = 0; i < len; i++) {
251 + if (s->window[start+i] != s->window[cookie_location+i] ||
252 + class_at(s, cookie_location+i) != 1) {
253 + return 0;
254 + }
255 + }
256 + /* Check that we aren't matching a prefix of another cookie by ensuring
257 + * that the final byte is either a semicolon (which cannot appear in a
258 + * cookie value), or non-cookie data. */
259 + if (s->window[cookie_location+len-1] != ';' &&
260 + class_at(s, cookie_location+len) != 0) {
261 + return 0;
262 + }
263 + s->match_start = cookie_location;
264 + return len;
265 + }
266 +
267 + return 0;
268 +}
269 +
270 +
271 #else /* FASTEST */
273 /* ---------------------------------------------------------------------------
274 * Optimized version for FASTEST only
275 */
276 -local uInt longest_match(s, cur_match)
277 +local uInt longest_match(s, cur_match, clas)
278 deflate_state *s;
279 IPos cur_match; /* current match */
280 + int clas;
281 {
282 register Bytef *scan = s->window + s->strstart; /* current string */
283 register Bytef *match; /* matched string */
284 register int len; /* length of current match */
285 register Bytef *strend = s->window + s->strstart + MAX_MATCH;
287 +#error "This code not patched"
288 +
289 /* The code is optimized for HASH_BITS >= 8 and MAX_MATCH-2 multiple of 16.
290 * It is easy to get rid of this optimization if necessary.
291 */
292 @@ -1360,6 +1503,21 @@ local void fill_window(s)
293 */
294 } while (--n);
295 #endif
296 +
297 + for (n = 0; n < Z_COOKIE_HASH_SIZE; n++) {
298 + if (s->cookie_locations[n] > wsize) {
299 + s->cookie_locations[n] -= wsize;
300 + } else {
301 + s->cookie_locations[n] = 0;
302 + }
303 + }
304 +
305 + if (s->class_bitmap) {
306 + zmemcpy(s->class_bitmap, s->class_bitmap + s->w_size/8,
307 + s->w_size/8);
308 + zmemzero(s->class_bitmap + s->w_size/8, s->w_size/8);
309 + }
310 +
311 more += wsize;
312 }
313 if (s->strm->avail_in == 0) return;
314 @@ -1378,6 +1536,9 @@ local void fill_window(s)
315 Assert(more >= 2, "more < 2");
317 n = read_buf(s->strm, s->window + s->strstart + s->lookahead, more);
318 + if (s->class_bitmap != NULL) {
319 + class_set(s, s->strstart + s->lookahead, n, s->strm->clas);
320 + }
321 s->lookahead += n;
323 /* Initialize the hash value now that we have some input: */
324 @@ -1459,9 +1620,10 @@ local void fill_window(s)
325 * NOTE: this function should be optimized to avoid extra copying from
326 * window to pending_buf.
327 */
328 -local block_state deflate_stored(s, flush)
329 +local block_state deflate_stored(s, flush, clas)
330 deflate_state *s;
331 int flush;
332 + int clas;
333 {
334 /* Stored blocks are limited to 0xffff bytes, pending_buf is limited
335 * to pending_buf_size, and each stored block has a 5 byte header:
336 @@ -1517,13 +1679,19 @@ local block_state deflate_stored(s, flush)
337 * new strings in the dictionary only for unmatched strings or for short
338 * matches. It is used only for the fast compression options.
339 */
340 -local block_state deflate_fast(s, flush)
341 +local block_state deflate_fast(s, flush, clas)
342 deflate_state *s;
343 int flush;
344 + int clas;
345 {
346 IPos hash_head; /* head of the hash chain */
347 int bflush; /* set if current block must be flushed */
349 + if (clas != 0) {
350 + /* We haven't patched this code for alternative class data. */
351 + return Z_BUF_ERROR;
352 + }
353 +
354 for (;;) {
355 /* Make sure that we always have enough lookahead, except
356 * at the end of the input file. We need MAX_MATCH bytes
357 @@ -1554,7 +1722,7 @@ local block_state deflate_fast(s, flush)
358 * of window index 0 (in particular we have to avoid a match
359 * of the string with itself at the start of the input file).
360 */
361 - s->match_length = longest_match (s, hash_head);
362 + s->match_length = longest_match (s, hash_head, clas);
363 /* longest_match() sets match_start */
364 }
365 if (s->match_length >= MIN_MATCH) {
366 @@ -1613,12 +1781,25 @@ local block_state deflate_fast(s, flush)
367 * evaluation for matches: a match is finally adopted only if there is
368 * no better match at the next window position.
369 */
370 -local block_state deflate_slow(s, flush)
371 +local block_state deflate_slow(s, flush, clas)
372 deflate_state *s;
373 int flush;
374 + int clas;
375 {
376 IPos hash_head; /* head of hash chain */
377 int bflush; /* set if current block must be flushed */
378 + uInt input_length ;
379 + int first = 1; /* first says whether this is the first iteration
380 + of the loop, below. */
381 +
382 + if (clas == Z_CLASS_COOKIE) {
383 + if (s->lookahead) {
384 + /* Alternative class data must always be presented at the beginning
385 + * of a block. */
386 + return Z_BUF_ERROR;
387 + }
388 + input_length = s->strm->avail_in;
389 + }
391 /* Process the input block. */
392 for (;;) {
393 @@ -1648,13 +1829,18 @@ local block_state deflate_slow(s, flush)
394 s->prev_length = s->match_length, s->prev_match = s->match_start;
395 s->match_length = MIN_MATCH-1;
397 - if (hash_head != NIL && s->prev_length < s->max_lazy_match &&
398 - s->strstart - hash_head <= MAX_DIST(s)) {
399 + if (clas == Z_CLASS_COOKIE && first) {
400 + s->match_length = cookie_match(s, s->strstart, input_length);
401 + } else if (clas == Z_CLASS_STANDARD &&
402 + hash_head != NIL &&
403 + s->prev_length < s->max_lazy_match &&
404 + s->strstart - hash_head <= MAX_DIST(s)) {
405 /* To simplify the code, we prevent matches with the string
406 * of window index 0 (in particular we have to avoid a match
407 * of the string with itself at the start of the input file).
408 */
409 - s->match_length = longest_match (s, hash_head);
410 + s->match_length = longest_match (s, hash_head, clas);
411 +
412 /* longest_match() sets match_start */
414 if (s->match_length <= 5 && (s->strategy == Z_FILTERED
415 @@ -1673,7 +1859,20 @@ local block_state deflate_slow(s, flush)
416 /* If there was a match at the previous step and the current
417 * match is not better, output the previous match:
418 */
419 - if (s->prev_length >= MIN_MATCH && s->match_length <= s->prev_length) {
420 + first = 0;
421 + if (s->prev_length >= MIN_MATCH && s->match_length <= s->prev_length &&
422 + /* We will only accept an exact match for Z_CLASS_COOKIE data and
423 + * we won't match Z_CLASS_HUFFMAN_ONLY data at all. */
424 + (clas == Z_CLASS_STANDARD || (clas == Z_CLASS_COOKIE &&
425 + s->prev_length == input_length &&
426 + s->prev_match > 0 &&
427 + /* We require that a Z_CLASS_COOKIE match be
428 + * preceded by either a semicolon (which cannot be
429 + * part of a cookie), or non-cookie data. This is
430 + * to prevent a cookie from being a suffix of
431 + * another. */
432 + (class_at(s, s->prev_match-1) == Z_CLASS_STANDARD ||
433 + *(s->window + s->prev_match-1) == ';')))) {
434 uInt max_insert = s->strstart + s->lookahead - MIN_MATCH;
435 /* Do not insert strings in hash table beyond this. */
437 diff --git a/third_party/zlib/deflate.h b/third_party/zlib/deflate.h
438 index cbf0d1e..2fe6fd6 100644
439 --- a/third_party/zlib/deflate.h
440 +++ b/third_party/zlib/deflate.h
441 @@ -91,6 +91,9 @@ typedef unsigned IPos;
442 * save space in the various tables. IPos is used only for parameter passing.
443 */
445 +#define Z_COOKIE_HASH_SIZE 256
446 +#define Z_COOKIE_HASH_MASK (Z_COOKIE_HASH_SIZE-1)
447 +
448 typedef struct internal_state {
449 z_streamp strm; /* pointer back to this zlib stream */
450 int status; /* as the name implies */
451 @@ -139,6 +142,8 @@ typedef struct internal_state {
452 uInt hash_mask; /* hash_size-1 */
454 uInt hash_shift;
455 + Bytef *class_bitmap; /* bitmap of class for each byte in window */
456 + IPos cookie_locations[Z_COOKIE_HASH_SIZE];
457 /* Number of bits by which ins_h must be shifted at each input
458 * step. It must be such that after MIN_MATCH steps, the oldest
459 * byte no longer takes part in the hash key, that is:
460 diff --git a/third_party/zlib/zlib.h b/third_party/zlib/zlib.h
461 index 4d54af9..da7e971 100644
462 --- a/third_party/zlib/zlib.h
463 +++ b/third_party/zlib/zlib.h
464 @@ -101,6 +101,7 @@ typedef struct z_stream_s {
465 int data_type; /* best guess about the data type: binary or text */
466 uLong adler; /* adler32 value of the uncompressed data */
467 uLong reserved; /* reserved for future use */
468 + int clas;
469 } z_stream;
471 typedef z_stream FAR *z_streamp;
472 @@ -207,6 +208,10 @@ typedef gz_header FAR *gz_headerp;
474 #define Z_NULL 0 /* for initializing zalloc, zfree, opaque */
476 +#define Z_CLASS_STANDARD 0
477 +#define Z_CLASS_COOKIE 1
478 +#define Z_CLASS_HUFFMAN_ONLY 2
479 +
480 #define zlib_version zlibVersion()
481 /* for compatibility with versions < 1.0.2 */
483 @@ -1587,6 +1592,13 @@ ZEXTERN int ZEXPORT inflateBackInit_ OF((z_streamp strm, int windowBits,
484 ZEXTERN z_off_t ZEXPORT gzoffset64 OF((gzFile));
485 ZEXTERN uLong ZEXPORT adler32_combine64 OF((uLong, uLong, z_off_t));
486 ZEXTERN uLong ZEXPORT crc32_combine64 OF((uLong, uLong, z_off_t));
487 +# else
488 + ZEXTERN gzFile ZEXPORT gzopen OF((const char *, const char *));
489 + ZEXTERN z_off_t ZEXPORT gzseek OF((gzFile, z_off_t, int));
490 + ZEXTERN z_off_t ZEXPORT gztell OF((gzFile));
491 + ZEXTERN z_off_t ZEXPORT gzoffset OF((gzFile));
492 + ZEXTERN uLong ZEXPORT adler32_combine OF((uLong, uLong, z_off_t));
493 + ZEXTERN uLong ZEXPORT crc32_combine OF((uLong, uLong, z_off_t));
494 # endif
495 #else
496 ZEXTERN gzFile ZEXPORT gzopen OF((const char *, const char *));