Lines Matching refs:s
73 typedef block_state (*compress_func) OF((deflate_state *s, int flush));
77 local void slide_hash OF((deflate_state *s));
78 local void fill_window OF((deflate_state *s));
79 local block_state deflate_stored OF((deflate_state *s, int flush));
80 local block_state deflate_fast OF((deflate_state *s, int flush));
82 local block_state deflate_slow OF((deflate_state *s, int flush));
84 local block_state deflate_rle OF((deflate_state *s, int flush));
85 local block_state deflate_huff OF((deflate_state *s, int flush));
86 local void lm_init OF((deflate_state *s));
87 local void putShortMSB OF((deflate_state *s, uInt b));
93 uInt longest_match OF((deflate_state *s, IPos cur_match));
95 local uInt longest_match OF((deflate_state *s, IPos cur_match));
99 local void check_match OF((deflate_state *s, IPos start, IPos match,
163 #define UPDATE_HASH(s,h,c) (h = (((h)<<s->hash_shift) ^ (c)) & s->hash_mask) argument
177 #define INSERT_STRING(s, str, match_head) \ argument
178 (UPDATE_HASH(s, s->ins_h, s->window[(str) + (MIN_MATCH-1)]), \
179 match_head = s->head[s->ins_h], \
180 s->head[s->ins_h] = (Pos)(str))
182 #define INSERT_STRING(s, str, match_head) \ argument
183 (UPDATE_HASH(s, s->ins_h, s->window[(str) + (MIN_MATCH-1)]), \
184 match_head = s->prev[(str) & s->w_mask] = s->head[s->ins_h], \
185 s->head[s->ins_h] = (Pos)(str))
192 #define CLEAR_HASH(s) \ argument
193 s->head[s->hash_size-1] = NIL; \
194 zmemzero((Bytef *)s->head, (unsigned)(s->hash_size-1)*sizeof(*s->head));
201 local void slide_hash(s) in slide_hash() argument
202 deflate_state *s; in slide_hash()
206 uInt wsize = s->w_size;
208 n = s->hash_size;
209 p = &s->head[n];
216 p = &s->prev[n];
251 deflate_state *s; local
304 s = (deflate_state *) ZALLOC(strm, 1, sizeof(deflate_state));
305 if (s == Z_NULL) return Z_MEM_ERROR;
306 strm->state = (struct internal_state FAR *)s;
307 s->strm = strm;
308 s->status = INIT_STATE; /* to pass state test in deflateReset() */
310 s->wrap = wrap;
311 s->gzhead = Z_NULL;
312 s->w_bits = (uInt)windowBits;
313 s->w_size = 1 << s->w_bits;
314 s->w_mask = s->w_size - 1;
316 s->hash_bits = (uInt)memLevel + 7;
317 s->hash_size = 1 << s->hash_bits;
318 s->hash_mask = s->hash_size - 1;
319 s->hash_shift = ((s->hash_bits+MIN_MATCH-1)/MIN_MATCH);
321 s->window = (Bytef *) ZALLOC(strm, s->w_size, 2*sizeof(Byte));
322 s->prev = (Posf *) ZALLOC(strm, s->w_size, sizeof(Pos));
323 s->head = (Posf *) ZALLOC(strm, s->hash_size, sizeof(Pos));
325 s->high_water = 0; /* nothing written to s->window yet */
327 s->lit_bufsize = 1 << (memLevel + 6); /* 16K elements by default */
329 overlay = (ushf *) ZALLOC(strm, s->lit_bufsize, sizeof(ush)+2);
330 s->pending_buf = (uchf *) overlay;
331 s->pending_buf_size = (ulg)s->lit_bufsize * (sizeof(ush)+2L);
333 if (s->window == Z_NULL || s->prev == Z_NULL || s->head == Z_NULL ||
334 s->pending_buf == Z_NULL) {
335 s->status = FINISH_STATE;
340 s->d_buf = overlay + s->lit_bufsize/sizeof(ush);
341 s->l_buf = s->pending_buf + (1+sizeof(ush))*s->lit_bufsize;
343 s->level = level;
344 s->strategy = strategy;
345 s->method = (Byte)method;
356 deflate_state *s; local
360 s = strm->state;
361 if (s == Z_NULL || s->strm != strm || (s->status != INIT_STATE &&
363 s->status != GZIP_STATE &&
365 s->status != EXTRA_STATE &&
366 s->status != NAME_STATE &&
367 s->status != COMMENT_STATE &&
368 s->status != HCRC_STATE &&
369 s->status != BUSY_STATE &&
370 s->status != FINISH_STATE))
381 deflate_state *s; local
389 s = strm->state;
390 wrap = s->wrap;
391 if (wrap == 2 || (wrap == 1 && s->status != INIT_STATE) || s->lookahead)
397 s->wrap = 0; /* avoid computing Adler-32 in read_buf */
400 if (dictLength >= s->w_size) {
402 CLEAR_HASH(s);
403 s->strstart = 0;
404 s->block_start = 0L;
405 s->insert = 0;
407 dictionary += dictLength - s->w_size; /* use the tail */
408 dictLength = s->w_size;
416 fill_window(s);
417 while (s->lookahead >= MIN_MATCH) {
418 str = s->strstart;
419 n = s->lookahead - (MIN_MATCH-1);
421 UPDATE_HASH(s, s->ins_h, s->window[str + MIN_MATCH-1]);
423 s->prev[str & s->w_mask] = s->head[s->ins_h];
425 s->head[s->ins_h] = (Pos)str;
428 s->strstart = str;
429 s->lookahead = MIN_MATCH-1;
430 fill_window(s);
432 s->strstart += s->lookahead;
433 s->block_start = (long)s->strstart;
434 s->insert = s->lookahead;
435 s->lookahead = 0;
436 s->match_length = s->prev_length = MIN_MATCH-1;
437 s->match_available = 0;
440 s->wrap = wrap;
450 deflate_state *s; local
455 s = strm->state;
456 len = s->strstart + s->lookahead;
457 if (len > s->w_size)
458 len = s->w_size;
460 zmemcpy(dictionary, s->window + s->strstart + s->lookahead - len, len);
470 deflate_state *s; local
480 s = (deflate_state *)strm->state;
481 s->pending = 0;
482 s->pending_out = s->pending_buf;
484 if (s->wrap < 0) {
485 s->wrap = -s->wrap; /* was made negative by deflate(..., Z_FINISH); */
487 s->status =
489 s->wrap == 2 ? GZIP_STATE :
491 s->wrap ? INIT_STATE : BUSY_STATE;
494 s->wrap == 2 ? crc32(0L, Z_NULL, 0) :
497 s->last_flush = Z_NO_FLUSH;
499 _tr_init(s);
547 deflate_state *s; local
551 s = strm->state;
552 if ((Bytef *)(s->d_buf) < s->pending_out + ((Buf_size + 7) >> 3))
555 put = Buf_size - s->bi_valid;
558 s->bi_buf |= (ush)((value & ((1 << put) - 1)) << s->bi_valid);
559 s->bi_valid += put;
560 _tr_flush_bits(s);
573 deflate_state *s; local
577 s = strm->state;
587 func = configuration_table[s->level].func;
589 if ((strategy != s->strategy || func != configuration_table[level].func) &&
590 s->high_water) {
598 if (s->level != level) {
599 if (s->level == 0 && s->matches != 0) {
600 if (s->matches == 1)
601 slide_hash(s);
603 CLEAR_HASH(s);
604 s->matches = 0;
606 s->level = level;
607 s->max_lazy_match = configuration_table[level].max_lazy;
608 s->good_match = configuration_table[level].good_length;
609 s->nice_match = configuration_table[level].nice_length;
610 s->max_chain_length = configuration_table[level].max_chain;
612 s->strategy = strategy;
624 deflate_state *s; local
627 s = strm->state;
628 s->good_match = (uInt)good_length;
629 s->max_lazy_match = (uInt)max_lazy;
630 s->nice_match = nice_length;
631 s->max_chain_length = (uInt)max_chain;
656 deflate_state *s; local
668 s = strm->state;
669 switch (s->wrap) {
674 wraplen = 6 + (s->strstart ? 4 : 0);
679 if (s->gzhead != Z_NULL) { /* user-supplied gzip header */
681 if (s->gzhead->extra != Z_NULL)
682 wraplen += 2 + s->gzhead->extra_len;
683 str = s->gzhead->name;
688 str = s->gzhead->comment;
693 if (s->gzhead->hcrc)
703 if (s->w_bits != 15 || s->hash_bits != 8 + 7)
716 local void putShortMSB (s, b) in putShortMSB() argument
717 deflate_state *s; in putShortMSB()
720 put_byte(s, (Byte)(b >> 8));
721 put_byte(s, (Byte)(b & 0xff));
734 deflate_state *s = strm->state; local
736 _tr_flush_bits(s);
737 len = s->pending;
741 zmemcpy(strm->next_out, s->pending_out, len);
743 s->pending_out += len;
746 s->pending -= len;
747 if (s->pending == 0) {
748 s->pending_out = s->pending_buf;
757 if (s->gzhead->hcrc && s->pending > (beg)) \
758 strm->adler = crc32(strm->adler, s->pending_buf + (beg), \
759 s->pending - (beg)); \
768 deflate_state *s; local
773 s = strm->state;
777 (s->status == FINISH_STATE && flush != Z_FINISH)) {
782 old_flush = s->last_flush;
783 s->last_flush = flush;
786 if (s->pending != 0) {
795 s->last_flush = -1;
809 if (s->status == FINISH_STATE && strm->avail_in != 0) {
814 if (s->status == INIT_STATE) {
816 uInt header = (Z_DEFLATED + ((s->w_bits-8)<<4)) << 8;
819 if (s->strategy >= Z_HUFFMAN_ONLY || s->level < 2)
821 else if (s->level < 6)
823 else if (s->level == 6)
828 if (s->strstart != 0) header |= PRESET_DICT;
831 putShortMSB(s, header);
834 if (s->strstart != 0) {
835 putShortMSB(s, (uInt)(strm->adler >> 16));
836 putShortMSB(s, (uInt)(strm->adler & 0xffff));
839 s->status = BUSY_STATE;
843 if (s->pending != 0) {
844 s->last_flush = -1;
849 if (s->status == GZIP_STATE) {
852 put_byte(s, 31);
853 put_byte(s, 139);
854 put_byte(s, 8);
855 if (s->gzhead == Z_NULL) {
856 put_byte(s, 0);
857 put_byte(s, 0);
858 put_byte(s, 0);
859 put_byte(s, 0);
860 put_byte(s, 0);
861 put_byte(s, s->level == 9 ? 2 :
862 (s->strategy >= Z_HUFFMAN_ONLY || s->level < 2 ?
864 put_byte(s, OS_CODE);
865 s->status = BUSY_STATE;
869 if (s->pending != 0) {
870 s->last_flush = -1;
875 put_byte(s, (s->gzhead->text ? 1 : 0) +
876 (s->gzhead->hcrc ? 2 : 0) +
877 (s->gzhead->extra == Z_NULL ? 0 : 4) +
878 (s->gzhead->name == Z_NULL ? 0 : 8) +
879 (s->gzhead->comment == Z_NULL ? 0 : 16)
881 put_byte(s, (Byte)(s->gzhead->time & 0xff));
882 put_byte(s, (Byte)((s->gzhead->time >> 8) & 0xff));
883 put_byte(s, (Byte)((s->gzhead->time >> 16) & 0xff));
884 put_byte(s, (Byte)((s->gzhead->time >> 24) & 0xff));
885 put_byte(s, s->level == 9 ? 2 :
886 (s->strategy >= Z_HUFFMAN_ONLY || s->level < 2 ?
888 put_byte(s, s->gzhead->os & 0xff);
889 if (s->gzhead->extra != Z_NULL) {
890 put_byte(s, s->gzhead->extra_len & 0xff);
891 put_byte(s, (s->gzhead->extra_len >> 8) & 0xff);
893 if (s->gzhead->hcrc)
894 strm->adler = crc32(strm->adler, s->pending_buf,
895 s->pending);
896 s->gzindex = 0;
897 s->status = EXTRA_STATE;
900 if (s->status == EXTRA_STATE) {
901 if (s->gzhead->extra != Z_NULL) {
902 ulg beg = s->pending; /* start of bytes to update crc */
903 uInt left = (s->gzhead->extra_len & 0xffff) - s->gzindex;
904 while (s->pending + left > s->pending_buf_size) {
905 uInt copy = s->pending_buf_size - s->pending;
906 zmemcpy(s->pending_buf + s->pending,
907 s->gzhead->extra + s->gzindex, copy);
908 s->pending = s->pending_buf_size;
910 s->gzindex += copy;
912 if (s->pending != 0) {
913 s->last_flush = -1;
919 zmemcpy(s->pending_buf + s->pending,
920 s->gzhead->extra + s->gzindex, left);
921 s->pending += left;
923 s->gzindex = 0;
925 s->status = NAME_STATE;
927 if (s->status == NAME_STATE) {
928 if (s->gzhead->name != Z_NULL) {
929 ulg beg = s->pending; /* start of bytes to update crc */
932 if (s->pending == s->pending_buf_size) {
935 if (s->pending != 0) {
936 s->last_flush = -1;
941 val = s->gzhead->name[s->gzindex++];
942 put_byte(s, val);
945 s->gzindex = 0;
947 s->status = COMMENT_STATE;
949 if (s->status == COMMENT_STATE) {
950 if (s->gzhead->comment != Z_NULL) {
951 ulg beg = s->pending; /* start of bytes to update crc */
954 if (s->pending == s->pending_buf_size) {
957 if (s->pending != 0) {
958 s->last_flush = -1;
963 val = s->gzhead->comment[s->gzindex++];
964 put_byte(s, val);
968 s->status = HCRC_STATE;
970 if (s->status == HCRC_STATE) {
971 if (s->gzhead->hcrc) {
972 if (s->pending + 2 > s->pending_buf_size) {
974 if (s->pending != 0) {
975 s->last_flush = -1;
979 put_byte(s, (Byte)(strm->adler & 0xff));
980 put_byte(s, (Byte)((strm->adler >> 8) & 0xff));
983 s->status = BUSY_STATE;
987 if (s->pending != 0) {
988 s->last_flush = -1;
996 if (strm->avail_in != 0 || s->lookahead != 0 ||
997 (flush != Z_NO_FLUSH && s->status != FINISH_STATE)) {
1000 bstate = s->level == 0 ? deflate_stored(s, flush) :
1001 s->strategy == Z_HUFFMAN_ONLY ? deflate_huff(s, flush) :
1002 s->strategy == Z_RLE ? deflate_rle(s, flush) :
1003 (*(configuration_table[s->level].func))(s, flush);
1006 s->status = FINISH_STATE;
1010 s->last_flush = -1; /* avoid BUF_ERROR next call, see above */
1023 _tr_align(s);
1025 _tr_stored_block(s, (char*)0, 0L, 0);
1030 CLEAR_HASH(s); /* forget history */
1031 if (s->lookahead == 0) {
1032 s->strstart = 0;
1033 s->block_start = 0L;
1034 s->insert = 0;
1040 s->last_flush = -1; /* avoid BUF_ERROR at next call, see above */
1047 if (s->wrap <= 0) return Z_STREAM_END;
1051 if (s->wrap == 2) {
1052 put_byte(s, (Byte)(strm->adler & 0xff));
1053 put_byte(s, (Byte)((strm->adler >> 8) & 0xff));
1054 put_byte(s, (Byte)((strm->adler >> 16) & 0xff));
1055 put_byte(s, (Byte)((strm->adler >> 24) & 0xff));
1056 put_byte(s, (Byte)(strm->total_in & 0xff));
1057 put_byte(s, (Byte)((strm->total_in >> 8) & 0xff));
1058 put_byte(s, (Byte)((strm->total_in >> 16) & 0xff));
1059 put_byte(s, (Byte)((strm->total_in >> 24) & 0xff));
1064 putShortMSB(s, (uInt)(strm->adler >> 16));
1065 putShortMSB(s, (uInt)(strm->adler & 0xffff));
1071 if (s->wrap > 0) s->wrap = -s->wrap; /* write the trailer only once! */
1072 return s->pending != 0 ? Z_OK : Z_STREAM_END;
1194 local void lm_init (s) in lm_init() argument
1195 deflate_state *s; in lm_init()
1197 s->window_size = (ulg)2L*s->w_size;
1199 CLEAR_HASH(s);
1203 s->max_lazy_match = configuration_table[s->level].max_lazy;
1204 s->good_match = configuration_table[s->level].good_length;
1205 s->nice_match = configuration_table[s->level].nice_length;
1206 s->max_chain_length = configuration_table[s->level].max_chain;
1208 s->strstart = 0;
1209 s->block_start = 0L;
1210 s->lookahead = 0;
1211 s->insert = 0;
1212 s->match_length = s->prev_length = MIN_MATCH-1;
1213 s->match_available = 0;
1214 s->ins_h = 0;
1236 local uInt longest_match(s, cur_match) in longest_match() argument
1237 deflate_state *s; in longest_match()
1240 unsigned chain_length = s->max_chain_length;/* max hash chain length */
1241 register Bytef *scan = s->window + s->strstart; /* current string */
1244 int best_len = (int)s->prev_length; /* best match length so far */
1245 int nice_match = s->nice_match; /* stop if match long enough */
1246 IPos limit = s->strstart > (IPos)MAX_DIST(s) ?
1247 s->strstart - (IPos)MAX_DIST(s) : NIL;
1251 Posf *prev = s->prev;
1252 uInt wmask = s->w_mask;
1258 register Bytef *strend = s->window + s->strstart + MAX_MATCH - 1;
1262 register Bytef *strend = s->window + s->strstart + MAX_MATCH;
1270 Assert(s->hash_bits >= 8 && MAX_MATCH == 258, "Code too clever");
1273 if (s->prev_length >= s->good_match) {
1279 if ((uInt)nice_match > s->lookahead) nice_match = (int)s->lookahead;
1281 Assert((ulg)s->strstart <= s->window_size-MIN_LOOKAHEAD, "need lookahead");
1284 Assert(cur_match < s->strstart, "no future");
1285 match = s->window + cur_match;
1322 Assert(scan <= s->window+(unsigned)(s->window_size-1), "wild scan");
1354 Assert(scan <= s->window+(unsigned)(s->window_size-1), "wild scan");
1362 s->match_start = cur_match;
1375 if ((uInt)best_len <= s->lookahead) return (uInt)best_len;
1376 return s->lookahead;
1385 local uInt longest_match(s, cur_match) in longest_match() argument
1386 deflate_state *s; in longest_match()
1389 register Bytef *scan = s->window + s->strstart; /* current string */
1392 register Bytef *strend = s->window + s->strstart + MAX_MATCH;
1397 Assert(s->hash_bits >= 8 && MAX_MATCH == 258, "Code too clever");
1399 Assert((ulg)s->strstart <= s->window_size-MIN_LOOKAHEAD, "need lookahead");
1401 Assert(cur_match < s->strstart, "no future");
1403 match = s->window + cur_match;
1428 Assert(scan <= s->window+(unsigned)(s->window_size-1), "wild scan");
1434 s->match_start = cur_match;
1435 return (uInt)len <= s->lookahead ? (uInt)len : s->lookahead;
1448 local void check_match(s, start, match, length) in check_match() argument
1449 deflate_state *s; in check_match()
1454 if (zmemcmp(s->window + match,
1455 s->window + start, length) != EQUAL) {
1459 fprintf(stderr, "%c%c", s->window[match++], s->window[start++]);
1465 do { putc(s->window[start++], stderr); } while (--length != 0);
1469 # define check_match(s, start, match, length) argument
1482 local void fill_window(s) in fill_window() argument
1483 deflate_state *s; in fill_window()
1487 uInt wsize = s->w_size;
1489 Assert(s->lookahead < MIN_LOOKAHEAD, "already enough lookahead");
1492 more = (unsigned)(s->window_size -(ulg)s->lookahead -(ulg)s->strstart);
1496 if (more == 0 && s->strstart == 0 && s->lookahead == 0) {
1510 if (s->strstart >= wsize+MAX_DIST(s)) {
1512 zmemcpy(s->window, s->window+wsize, (unsigned)wsize - more);
1513 s->match_start -= wsize;
1514 s->strstart -= wsize; /* we now have strstart >= MAX_DIST */
1515 s->block_start -= (long) wsize;
1516 slide_hash(s);
1519 if (s->strm->avail_in == 0) break;
1534 n = read_buf(s->strm, s->window + s->strstart + s->lookahead, more);
1535 s->lookahead += n;
1538 if (s->lookahead + s->insert >= MIN_MATCH) {
1539 uInt str = s->strstart - s->insert;
1540 s->ins_h = s->window[str];
1541 UPDATE_HASH(s, s->ins_h, s->window[str + 1]);
1545 while (s->insert) {
1546 UPDATE_HASH(s, s->ins_h, s->window[str + MIN_MATCH-1]);
1548 s->prev[str & s->w_mask] = s->head[s->ins_h];
1550 s->head[s->ins_h] = (Pos)str;
1552 s->insert--;
1553 if (s->lookahead + s->insert < MIN_MATCH)
1561 } while (s->lookahead < MIN_LOOKAHEAD && s->strm->avail_in != 0);
1570 if (s->high_water < s->window_size) {
1571 ulg curr = s->strstart + (ulg)(s->lookahead);
1574 if (s->high_water < curr) {
1578 init = s->window_size - curr;
1581 zmemzero(s->window + curr, (unsigned)init);
1582 s->high_water = curr + init;
1584 else if (s->high_water < (ulg)curr + WIN_INIT) {
1589 init = (ulg)curr + WIN_INIT - s->high_water;
1590 if (init > s->window_size - s->high_water)
1591 init = s->window_size - s->high_water;
1592 zmemzero(s->window + s->high_water, (unsigned)init);
1593 s->high_water += init;
1597 Assert((ulg)s->strstart <= s->window_size - MIN_LOOKAHEAD,
1605 #define FLUSH_BLOCK_ONLY(s, last) { \ argument
1606 _tr_flush_block(s, (s->block_start >= 0L ? \
1607 (charf *)&s->window[(unsigned)s->block_start] : \
1609 (ulg)((long)s->strstart - s->block_start), \
1611 s->block_start = s->strstart; \
1612 flush_pending(s->strm); \
1617 #define FLUSH_BLOCK(s, last) { \ argument
1618 FLUSH_BLOCK_ONLY(s, last); \
1619 if (s->strm->avail_out == 0) return (last) ? finish_started : need_more; \
1643 local block_state deflate_stored(s, flush) in deflate_stored() argument
1644 deflate_state *s; in deflate_stored()
1651 unsigned min_block = MIN(s->pending_buf_size - 5, s->w_size);
1658 unsigned used = s->strm->avail_in;
1665 have = (s->bi_valid + 42) >> 3; /* number of header bytes */
1666 if (s->strm->avail_out < have) /* need room for header */
1669 have = s->strm->avail_out - have;
1670 left = s->strstart - s->block_start; /* bytes left in window */
1671 if (len > (ulg)left + s->strm->avail_in)
1672 len = left + s->strm->avail_in; /* limit len to the input */
1683 len != left + s->strm->avail_in))
1689 last = flush == Z_FINISH && len == left + s->strm->avail_in ? 1 : 0;
1690 _tr_stored_block(s, (char *)0, 0L, last);
1693 s->pending_buf[s->pending - 4] = len;
1694 s->pending_buf[s->pending - 3] = len >> 8;
1695 s->pending_buf[s->pending - 2] = ~len;
1696 s->pending_buf[s->pending - 1] = ~len >> 8;
1699 flush_pending(s->strm);
1703 s->compressed_len += len << 3;
1704 s->bits_sent += len << 3;
1711 zmemcpy(s->strm->next_out, s->window + s->block_start, left);
1712 s->strm->next_out += left;
1713 s->strm->avail_out -= left;
1714 s->strm->total_out += left;
1715 s->block_start += left;
1723 read_buf(s->strm, s->strm->next_out, len);
1724 s->strm->next_out += len;
1725 s->strm->avail_out -= len;
1726 s->strm->total_out += len;
1736 used -= s->strm->avail_in; /* number of input bytes directly copied */
1741 if (used >= s->w_size) { /* supplant the previous history */
1742 s->matches = 2; /* clear hash */
1743 zmemcpy(s->window, s->strm->next_in - s->w_size, s->w_size);
1744 s->strstart = s->w_size;
1747 if (s->window_size - s->strstart <= used) {
1749 s->strstart -= s->w_size;
1750 zmemcpy(s->window, s->window + s->w_size, s->strstart);
1751 if (s->matches < 2)
1752 s->matches++; /* add a pending slide_hash() */
1754 zmemcpy(s->window + s->strstart, s->strm->next_in - used, used);
1755 s->strstart += used;
1757 s->block_start = s->strstart;
1758 s->insert += MIN(used, s->w_size - s->insert);
1760 if (s->high_water < s->strstart)
1761 s->high_water = s->strstart;
1769 s->strm->avail_in == 0 && (long)s->strstart == s->block_start)
1773 have = s->window_size - s->strstart - 1;
1774 if (s->strm->avail_in > have && s->block_start >= (long)s->w_size) {
1776 s->block_start -= s->w_size;
1777 s->strstart -= s->w_size;
1778 zmemcpy(s->window, s->window + s->w_size, s->strstart);
1779 if (s->matches < 2)
1780 s->matches++; /* add a pending slide_hash() */
1781 have += s->w_size; /* more space now */
1783 if (have > s->strm->avail_in)
1784 have = s->strm->avail_in;
1786 read_buf(s->strm, s->window + s->strstart, have);
1787 s->strstart += have;
1789 if (s->high_water < s->strstart)
1790 s->high_water = s->strstart;
1797 have = (s->bi_valid + 42) >> 3; /* number of header bytes */
1799 have = MIN(s->pending_buf_size - have, MAX_STORED);
1800 min_block = MIN(have, s->w_size);
1801 left = s->strstart - s->block_start;
1804 s->strm->avail_in == 0 && left <= have)) {
1806 last = flush == Z_FINISH && s->strm->avail_in == 0 &&
1808 _tr_stored_block(s, (charf *)s->window + s->block_start, len, last);
1809 s->block_start += len;
1810 flush_pending(s->strm);
1824 local block_state deflate_fast(s, flush) in deflate_fast() argument
1825 deflate_state *s; in deflate_fast()
1837 if (s->lookahead < MIN_LOOKAHEAD) {
1838 fill_window(s);
1839 if (s->lookahead < MIN_LOOKAHEAD && flush == Z_NO_FLUSH) {
1842 if (s->lookahead == 0) break; /* flush the current block */
1849 if (s->lookahead >= MIN_MATCH) {
1850 INSERT_STRING(s, s->strstart, hash_head);
1856 if (hash_head != NIL && s->strstart - hash_head <= MAX_DIST(s)) {
1861 s->match_length = longest_match (s, hash_head);
1864 if (s->match_length >= MIN_MATCH) {
1865 check_match(s, s->strstart, s->match_start, s->match_length);
1867 _tr_tally_dist(s, s->strstart - s->match_start,
1868 s->match_length - MIN_MATCH, bflush);
1870 s->lookahead -= s->match_length;
1876 if (s->match_length <= s->max_insert_length &&
1877 s->lookahead >= MIN_MATCH) {
1878 s->match_length--; /* string at strstart already in table */
1880 s->strstart++;
1881 INSERT_STRING(s, s->strstart, hash_head);
1885 } while (--s->match_length != 0);
1886 s->strstart++;
1890 s->strstart += s->match_length;
1891 s->match_length = 0;
1892 s->ins_h = s->window[s->strstart];
1893 UPDATE_HASH(s, s->ins_h, s->window[s->strstart+1]);
1903 Tracevv((stderr,"%c", s->window[s->strstart]));
1904 _tr_tally_lit (s, s->window[s->strstart], bflush);
1905 s->lookahead--;
1906 s->strstart++;
1908 if (bflush) FLUSH_BLOCK(s, 0);
1910 s->insert = s->strstart < MIN_MATCH-1 ? s->strstart : MIN_MATCH-1;
1912 FLUSH_BLOCK(s, 1);
1915 if (s->last_lit)
1916 FLUSH_BLOCK(s, 0);
1926 local block_state deflate_slow(s, flush) in deflate_slow() argument
1927 deflate_state *s; in deflate_slow()
1940 if (s->lookahead < MIN_LOOKAHEAD) {
1941 fill_window(s);
1942 if (s->lookahead < MIN_LOOKAHEAD && flush == Z_NO_FLUSH) {
1945 if (s->lookahead == 0) break; /* flush the current block */
1952 if (s->lookahead >= MIN_MATCH) {
1953 INSERT_STRING(s, s->strstart, hash_head);
1958 s->prev_length = s->match_length, s->prev_match = s->match_start;
1959 s->match_length = MIN_MATCH-1;
1961 if (hash_head != NIL && s->prev_length < s->max_lazy_match &&
1962 s->strstart - hash_head <= MAX_DIST(s)) {
1967 s->match_length = longest_match (s, hash_head);
1970 if (s->match_length <= 5 && (s->strategy == Z_FILTERED
1972 || (s->match_length == MIN_MATCH &&
1973 s->strstart - s->match_start > TOO_FAR)
1980 s->match_length = MIN_MATCH-1;
1986 if (s->prev_length >= MIN_MATCH && s->match_length <= s->prev_length) {
1987 uInt max_insert = s->strstart + s->lookahead - MIN_MATCH;
1990 check_match(s, s->strstart-1, s->prev_match, s->prev_length);
1992 _tr_tally_dist(s, s->strstart -1 - s->prev_match,
1993 s->prev_length - MIN_MATCH, bflush);
2000 s->lookahead -= s->prev_length-1;
2001 s->prev_length -= 2;
2003 if (++s->strstart <= max_insert) {
2004 INSERT_STRING(s, s->strstart, hash_head);
2006 } while (--s->prev_length != 0);
2007 s->match_available = 0;
2008 s->match_length = MIN_MATCH-1;
2009 s->strstart++;
2011 if (bflush) FLUSH_BLOCK(s, 0);
2013 } else if (s->match_available) {
2018 Tracevv((stderr,"%c", s->window[s->strstart-1]));
2019 _tr_tally_lit(s, s->window[s->strstart-1], bflush);
2021 FLUSH_BLOCK_ONLY(s, 0);
2023 s->strstart++;
2024 s->lookahead--;
2025 if (s->strm->avail_out == 0) return need_more;
2030 s->match_available = 1;
2031 s->strstart++;
2032 s->lookahead--;
2036 if (s->match_available) {
2037 Tracevv((stderr,"%c", s->window[s->strstart-1]));
2038 _tr_tally_lit(s, s->window[s->strstart-1], bflush);
2039 s->match_available = 0;
2041 s->insert = s->strstart < MIN_MATCH-1 ? s->strstart : MIN_MATCH-1;
2043 FLUSH_BLOCK(s, 1);
2046 if (s->last_lit)
2047 FLUSH_BLOCK(s, 0);
2057 local block_state deflate_rle(s, flush) in deflate_rle() argument
2058 deflate_state *s; in deflate_rle()
2070 if (s->lookahead <= MAX_MATCH) {
2071 fill_window(s);
2072 if (s->lookahead <= MAX_MATCH && flush == Z_NO_FLUSH) {
2075 if (s->lookahead == 0) break; /* flush the current block */
2079 s->match_length = 0;
2080 if (s->lookahead >= MIN_MATCH && s->strstart > 0) {
2081 scan = s->window + s->strstart - 1;
2084 strend = s->window + s->strstart + MAX_MATCH;
2091 s->match_length = MAX_MATCH - (uInt)(strend - scan);
2092 if (s->match_length > s->lookahead)
2093 s->match_length = s->lookahead;
2095 Assert(scan <= s->window+(uInt)(s->window_size-1), "wild scan");
2099 if (s->match_length >= MIN_MATCH) {
2100 check_match(s, s->strstart, s->strstart - 1, s->match_length);
2102 _tr_tally_dist(s, 1, s->match_length - MIN_MATCH, bflush);
2104 s->lookahead -= s->match_length;
2105 s->strstart += s->match_length;
2106 s->match_length = 0;
2109 Tracevv((stderr,"%c", s->window[s->strstart]));
2110 _tr_tally_lit (s, s->window[s->strstart], bflush);
2111 s->lookahead--;
2112 s->strstart++;
2114 if (bflush) FLUSH_BLOCK(s, 0);
2116 s->insert = 0;
2118 FLUSH_BLOCK(s, 1);
2121 if (s->last_lit)
2122 FLUSH_BLOCK(s, 0);
2130 local block_state deflate_huff(s, flush) in deflate_huff() argument
2131 deflate_state *s; in deflate_huff()
2138 if (s->lookahead == 0) {
2139 fill_window(s);
2140 if (s->lookahead == 0) {
2148 s->match_length = 0;
2149 Tracevv((stderr,"%c", s->window[s->strstart]));
2150 _tr_tally_lit (s, s->window[s->strstart], bflush);
2151 s->lookahead--;
2152 s->strstart++;
2153 if (bflush) FLUSH_BLOCK(s, 0);
2155 s->insert = 0;
2157 FLUSH_BLOCK(s, 1);
2160 if (s->last_lit)
2161 FLUSH_BLOCK(s, 0);