Lines Matching refs:s
73 typedef block_state (*compress_func) OF((deflate_state *s, int flush));
76 local void fill_window OF((deflate_state *s));
77 local block_state deflate_stored OF((deflate_state *s, int flush));
78 local block_state deflate_fast OF((deflate_state *s, int flush));
80 local block_state deflate_slow OF((deflate_state *s, int flush));
82 local void lm_init OF((deflate_state *s));
83 local void putShortMSB OF((deflate_state *s, uInt b));
89 uInt longest_match OF((deflate_state *s, IPos cur_match));
91 local uInt longest_match OF((deflate_state *s, IPos cur_match));
94 local uInt longest_match_fast OF((deflate_state *s, IPos cur_match));
97 local void check_match OF((deflate_state *s, IPos start, IPos match,
170 #define UPDATE_HASH(s,h,c) (h = (((h)<<s->hash_shift) ^ (c)) & s->hash_mask) argument
184 #define INSERT_STRING(s, str, match_head) \ argument
185 (UPDATE_HASH(s, s->ins_h, s->window[(str) + (MIN_MATCH-1)]), \
186 match_head = s->head[s->ins_h], \
187 s->head[s->ins_h] = (Pos)(str))
189 #define INSERT_STRING(s, str, match_head) \ argument
190 (UPDATE_HASH(s, s->ins_h, s->window[(str) + (MIN_MATCH-1)]), \
191 match_head = s->prev[(str) & s->w_mask] = s->head[s->ins_h], \
192 s->head[s->ins_h] = (Pos)(str))
199 #define CLEAR_HASH(s) \ argument
200 s->head[s->hash_size-1] = NIL; \
201 zmemzero((Bytef *)s->head, (unsigned)(s->hash_size-1)*sizeof(*s->head));
227 deflate_state *s; local
271 s = (deflate_state *) ZALLOC(strm, 1, sizeof(deflate_state));
272 if (s == Z_NULL) return Z_MEM_ERROR;
273 strm->state = (struct internal_state FAR *)s;
274 s->strm = strm;
276 s->wrap = wrap;
277 s->gzhead = Z_NULL;
278 s->w_bits = windowBits;
279 s->w_size = 1 << s->w_bits;
280 s->w_mask = s->w_size - 1;
282 s->hash_bits = memLevel + 7;
283 s->hash_size = 1 << s->hash_bits;
284 s->hash_mask = s->hash_size - 1;
285 s->hash_shift = ((s->hash_bits+MIN_MATCH-1)/MIN_MATCH);
287 s->window = (Bytef *) ZALLOC(strm, s->w_size, 2*sizeof(Byte));
288 s->prev = (Posf *) ZALLOC(strm, s->w_size, sizeof(Pos));
289 s->head = (Posf *) ZALLOC(strm, s->hash_size, sizeof(Pos));
291 s->lit_bufsize = 1 << (memLevel + 6); /* 16K elements by default */
293 overlay = (ushf *) ZALLOC(strm, s->lit_bufsize, sizeof(ush)+2);
294 s->pending_buf = (uchf *) overlay;
295 s->pending_buf_size = (ulg)s->lit_bufsize * (sizeof(ush)+2L);
297 if (s->window == Z_NULL || s->prev == Z_NULL || s->head == Z_NULL ||
298 s->pending_buf == Z_NULL) {
299 s->status = FINISH_STATE;
304 s->d_buf = overlay + s->lit_bufsize/sizeof(ush);
305 s->l_buf = s->pending_buf + (1+sizeof(ush))*s->lit_bufsize;
307 s->level = level;
308 s->strategy = strategy;
309 s->method = (Byte)method;
320 deflate_state *s; local
330 s = strm->state;
331 if (s->wrap)
335 if (length > MAX_DIST(s)) {
336 length = MAX_DIST(s);
339 zmemcpy(s->window, dictionary, length);
340 s->strstart = length;
341 s->block_start = (long)length;
347 s->ins_h = s->window[0];
348 UPDATE_HASH(s, s->ins_h, s->window[1]);
350 INSERT_STRING(s, n, hash_head);
360 deflate_state *s; local
371 s = (deflate_state *)strm->state;
372 s->pending = 0;
373 s->pending_out = s->pending_buf;
375 if (s->wrap < 0) {
376 s->wrap = -s->wrap; /* was made negative by deflate(..., Z_FINISH); */
378 s->status = s->wrap ? INIT_STATE : BUSY_STATE;
381 s->wrap == 2 ? crc32(0L, Z_NULL, 0) :
384 s->last_flush = Z_NO_FLUSH;
386 _tr_init(s);
387 lm_init(s);
421 deflate_state *s; local
426 s = strm->state;
436 func = configuration_table[s->level].func;
442 if (s->level != level) {
443 s->level = level;
444 s->max_lazy_match = configuration_table[level].max_lazy;
445 s->good_match = configuration_table[level].good_length;
446 s->nice_match = configuration_table[level].nice_length;
447 s->max_chain_length = configuration_table[level].max_chain;
449 s->strategy = strategy;
461 deflate_state *s; local
464 s = strm->state;
465 s->good_match = good_length;
466 s->max_lazy_match = max_lazy;
467 s->nice_match = nice_length;
468 s->max_chain_length = max_chain;
493 deflate_state *s; local
505 s = strm->state;
506 if (s->w_bits != 15 || s->hash_bits != 8 + 7)
518 local void putShortMSB (s, b) in putShortMSB() argument
519 deflate_state *s; in putShortMSB()
522 put_byte(s, (Byte)(b >> 8));
523 put_byte(s, (Byte)(b & 0xff));
557 deflate_state *s; local
563 s = strm->state;
567 (s->status == FINISH_STATE && flush != Z_FINISH)) {
572 s->strm = strm; /* just in case */
573 old_flush = s->last_flush;
574 s->last_flush = flush;
577 if (s->status == INIT_STATE) {
579 if (s->wrap == 2) {
581 put_byte(s, 31);
582 put_byte(s, 139);
583 put_byte(s, 8);
584 if (s->gzhead == NULL) {
585 put_byte(s, 0);
586 put_byte(s, 0);
587 put_byte(s, 0);
588 put_byte(s, 0);
589 put_byte(s, 0);
590 put_byte(s, s->level == 9 ? 2 :
591 (s->strategy >= Z_HUFFMAN_ONLY || s->level < 2 ?
593 put_byte(s, OS_CODE);
594 s->status = BUSY_STATE;
597 put_byte(s, (s->gzhead->text ? 1 : 0) +
598 (s->gzhead->hcrc ? 2 : 0) +
599 (s->gzhead->extra == Z_NULL ? 0 : 4) +
600 (s->gzhead->name == Z_NULL ? 0 : 8) +
601 (s->gzhead->comment == Z_NULL ? 0 : 16)
603 put_byte(s, (Byte)(s->gzhead->time & 0xff));
604 put_byte(s, (Byte)((s->gzhead->time >> 8) & 0xff));
605 put_byte(s, (Byte)((s->gzhead->time >> 16) & 0xff));
606 put_byte(s, (Byte)((s->gzhead->time >> 24) & 0xff));
607 put_byte(s, s->level == 9 ? 2 :
608 (s->strategy >= Z_HUFFMAN_ONLY || s->level < 2 ?
610 put_byte(s, s->gzhead->os & 0xff);
611 if (s->gzhead->extra != NULL) {
612 put_byte(s, s->gzhead->extra_len & 0xff);
613 put_byte(s, (s->gzhead->extra_len >> 8) & 0xff);
615 if (s->gzhead->hcrc)
616 strm->adler = crc32(strm->adler, s->pending_buf,
617 s->pending);
618 s->gzindex = 0;
619 s->status = EXTRA_STATE;
625 uInt header = (Z_DEFLATED + ((s->w_bits-8)<<4)) << 8;
628 if (s->strategy >= Z_HUFFMAN_ONLY || s->level < 2)
630 else if (s->level < 6)
632 else if (s->level == 6)
637 if (s->strstart != 0) header |= PRESET_DICT;
640 s->status = BUSY_STATE;
641 putShortMSB(s, header);
644 if (s->strstart != 0) {
645 putShortMSB(s, (uInt)(strm->adler >> 16));
646 putShortMSB(s, (uInt)(strm->adler & 0xffff));
652 if (s->status == EXTRA_STATE) {
653 if (s->gzhead->extra != NULL) {
654 uInt beg = s->pending; /* start of bytes to update crc */
656 while (s->gzindex < (s->gzhead->extra_len & 0xffff)) {
657 if (s->pending == s->pending_buf_size) {
658 if (s->gzhead->hcrc && s->pending > beg)
659 strm->adler = crc32(strm->adler, s->pending_buf + beg,
660 s->pending - beg);
662 beg = s->pending;
663 if (s->pending == s->pending_buf_size)
666 put_byte(s, s->gzhead->extra[s->gzindex]);
667 s->gzindex++;
669 if (s->gzhead->hcrc && s->pending > beg)
670 strm->adler = crc32(strm->adler, s->pending_buf + beg,
671 s->pending - beg);
672 if (s->gzindex == s->gzhead->extra_len) {
673 s->gzindex = 0;
674 s->status = NAME_STATE;
678 s->status = NAME_STATE;
680 if (s->status == NAME_STATE) {
681 if (s->gzhead->name != NULL) {
682 uInt beg = s->pending; /* start of bytes to update crc */
686 if (s->pending == s->pending_buf_size) {
687 if (s->gzhead->hcrc && s->pending > beg)
688 strm->adler = crc32(strm->adler, s->pending_buf + beg,
689 s->pending - beg);
691 beg = s->pending;
692 if (s->pending == s->pending_buf_size) {
697 val = s->gzhead->name[s->gzindex++];
698 put_byte(s, val);
700 if (s->gzhead->hcrc && s->pending > beg)
701 strm->adler = crc32(strm->adler, s->pending_buf + beg,
702 s->pending - beg);
704 s->gzindex = 0;
705 s->status = COMMENT_STATE;
709 s->status = COMMENT_STATE;
711 if (s->status == COMMENT_STATE) {
712 if (s->gzhead->comment != NULL) {
713 uInt beg = s->pending; /* start of bytes to update crc */
717 if (s->pending == s->pending_buf_size) {
718 if (s->gzhead->hcrc && s->pending > beg)
719 strm->adler = crc32(strm->adler, s->pending_buf + beg,
720 s->pending - beg);
722 beg = s->pending;
723 if (s->pending == s->pending_buf_size) {
728 val = s->gzhead->comment[s->gzindex++];
729 put_byte(s, val);
731 if (s->gzhead->hcrc && s->pending > beg)
732 strm->adler = crc32(strm->adler, s->pending_buf + beg,
733 s->pending - beg);
735 s->status = HCRC_STATE;
738 s->status = HCRC_STATE;
740 if (s->status == HCRC_STATE) {
741 if (s->gzhead->hcrc) {
742 if (s->pending + 2 > s->pending_buf_size)
744 if (s->pending + 2 <= s->pending_buf_size) {
745 put_byte(s, (Byte)(strm->adler & 0xff));
746 put_byte(s, (Byte)((strm->adler >> 8) & 0xff));
748 s->status = BUSY_STATE;
752 s->status = BUSY_STATE;
757 if (s->pending != 0) {
766 s->last_flush = -1;
780 if (s->status == FINISH_STATE && strm->avail_in != 0) {
786 if (strm->avail_in != 0 || s->lookahead != 0 ||
787 (flush != Z_NO_FLUSH && s->status != FINISH_STATE)) {
790 bstate = (*(configuration_table[s->level].func))(s, flush);
793 s->status = FINISH_STATE;
797 s->last_flush = -1; /* avoid BUF_ERROR next call, see above */
810 _tr_align(s);
812 _tr_stored_block(s, (char*)0, 0L, 0);
817 CLEAR_HASH(s); /* forget history */
822 s->last_flush = -1; /* avoid BUF_ERROR at next call, see above */
830 if (s->wrap <= 0) return Z_STREAM_END;
834 if (s->wrap == 2) {
835 put_byte(s, (Byte)(strm->adler & 0xff));
836 put_byte(s, (Byte)((strm->adler >> 8) & 0xff));
837 put_byte(s, (Byte)((strm->adler >> 16) & 0xff));
838 put_byte(s, (Byte)((strm->adler >> 24) & 0xff));
839 put_byte(s, (Byte)(strm->total_in & 0xff));
840 put_byte(s, (Byte)((strm->total_in >> 8) & 0xff));
841 put_byte(s, (Byte)((strm->total_in >> 16) & 0xff));
842 put_byte(s, (Byte)((strm->total_in >> 24) & 0xff));
847 putShortMSB(s, (uInt)(strm->adler >> 16));
848 putShortMSB(s, (uInt)(strm->adler & 0xffff));
854 if (s->wrap > 0) s->wrap = -s->wrap; /* write the trailer only once! */
855 return s->pending != 0 ? Z_OK : Z_STREAM_END;
986 local void lm_init (s) in lm_init() argument
987 deflate_state *s; in lm_init()
989 s->window_size = (ulg)2L*s->w_size;
991 CLEAR_HASH(s);
995 s->max_lazy_match = configuration_table[s->level].max_lazy;
996 s->good_match = configuration_table[s->level].good_length;
997 s->nice_match = configuration_table[s->level].nice_length;
998 s->max_chain_length = configuration_table[s->level].max_chain;
1000 s->strstart = 0;
1001 s->block_start = 0L;
1002 s->lookahead = 0;
1003 s->match_length = s->prev_length = MIN_MATCH-1;
1004 s->match_available = 0;
1005 s->ins_h = 0;
1027 local uInt longest_match(s, cur_match) in longest_match() argument
1028 deflate_state *s; in longest_match()
1031 unsigned chain_length = s->max_chain_length;/* max hash chain length */
1032 register Bytef *scan = s->window + s->strstart; /* current string */
1035 int best_len = s->prev_length; /* best match length so far */
1036 int nice_match = s->nice_match; /* stop if match long enough */
1037 IPos limit = s->strstart > (IPos)MAX_DIST(s) ?
1038 s->strstart - (IPos)MAX_DIST(s) : NIL;
1042 Posf *prev = s->prev;
1043 uInt wmask = s->w_mask;
1049 register Bytef *strend = s->window + s->strstart + MAX_MATCH - 1;
1053 register Bytef *strend = s->window + s->strstart + MAX_MATCH;
1061 Assert(s->hash_bits >= 8 && MAX_MATCH == 258, "Code too clever");
1064 if (s->prev_length >= s->good_match) {
1070 if ((uInt)nice_match > s->lookahead) nice_match = s->lookahead;
1072 Assert((ulg)s->strstart <= s->window_size-MIN_LOOKAHEAD, "need lookahead");
1075 Assert(cur_match < s->strstart, "no future");
1076 match = s->window + cur_match;
1113 Assert(scan <= s->window+(unsigned)(s->window_size-1), "wild scan");
1145 Assert(scan <= s->window+(unsigned)(s->window_size-1), "wild scan");
1153 s->match_start = cur_match;
1166 if ((uInt)best_len <= s->lookahead) return (uInt)best_len;
1167 return s->lookahead;
1175 local uInt longest_match_fast(s, cur_match) in longest_match_fast() argument
1176 deflate_state *s; in longest_match_fast()
1179 register Bytef *scan = s->window + s->strstart; /* current string */
1182 register Bytef *strend = s->window + s->strstart + MAX_MATCH;
1187 Assert(s->hash_bits >= 8 && MAX_MATCH == 258, "Code too clever");
1189 Assert((ulg)s->strstart <= s->window_size-MIN_LOOKAHEAD, "need lookahead");
1191 Assert(cur_match < s->strstart, "no future");
1193 match = s->window + cur_match;
1218 Assert(scan <= s->window+(unsigned)(s->window_size-1), "wild scan");
1224 s->match_start = cur_match;
1225 return (uInt)len <= s->lookahead ? (uInt)len : s->lookahead;
1232 local void check_match(s, start, match, length) in check_match() argument
1233 deflate_state *s; in check_match()
1238 if (zmemcmp(s->window + match,
1239 s->window + start, length) != EQUAL) {
1243 fprintf(stderr, "%c%c", s->window[match++], s->window[start++]);
1249 do { putc(s->window[start++], stderr); } while (--length != 0);
1253 # define check_match(s, start, match, length) argument
1266 local void fill_window(s) in fill_window() argument
1267 deflate_state *s; in fill_window()
1272 uInt wsize = s->w_size;
1275 more = (unsigned)(s->window_size -(ulg)s->lookahead -(ulg)s->strstart);
1279 if (more == 0 && s->strstart == 0 && s->lookahead == 0) {
1293 if (s->strstart >= wsize+MAX_DIST(s)) {
1295 zmemcpy(s->window, s->window+wsize, (unsigned)wsize);
1296 s->match_start -= wsize;
1297 s->strstart -= wsize; /* we now have strstart >= MAX_DIST */
1298 s->block_start -= (long) wsize;
1307 n = s->hash_size;
1308 p = &s->head[n];
1316 p = &s->prev[n];
1327 if (s->strm->avail_in == 0) return;
1342 n = read_buf(s->strm, s->window + s->strstart + s->lookahead, more);
1343 s->lookahead += n;
1346 if (s->lookahead >= MIN_MATCH) {
1347 s->ins_h = s->window[s->strstart];
1348 UPDATE_HASH(s, s->ins_h, s->window[s->strstart+1]);
1357 } while (s->lookahead < MIN_LOOKAHEAD && s->strm->avail_in != 0);
1364 #define FLUSH_BLOCK_ONLY(s, eof) { \ argument
1365 _tr_flush_block(s, (s->block_start >= 0L ? \
1366 (charf *)&s->window[(unsigned)s->block_start] : \
1368 (ulg)((long)s->strstart - s->block_start), \
1370 s->block_start = s->strstart; \
1371 flush_pending(s->strm); \
1376 #define FLUSH_BLOCK(s, eof) { \ argument
1377 FLUSH_BLOCK_ONLY(s, eof); \
1378 if (s->strm->avail_out == 0) return (eof) ? finish_started : need_more; \
1390 local block_state deflate_stored(s, flush) in deflate_stored() argument
1391 deflate_state *s; in deflate_stored()
1400 if (max_block_size > s->pending_buf_size - 5) {
1401 max_block_size = s->pending_buf_size - 5;
1407 if (s->lookahead <= 1) {
1409 Assert(s->strstart < s->w_size+MAX_DIST(s) ||
1410 s->block_start >= (long)s->w_size, "slide too late");
1412 fill_window(s);
1413 if (s->lookahead == 0 && flush == Z_NO_FLUSH) return need_more;
1415 if (s->lookahead == 0) break; /* flush the current block */
1417 Assert(s->block_start >= 0L, "block gone");
1419 s->strstart += s->lookahead;
1420 s->lookahead = 0;
1423 max_start = s->block_start + max_block_size;
1424 if (s->strstart == 0 || (ulg)s->strstart >= max_start) {
1426 s->lookahead = (uInt)(s->strstart - max_start);
1427 s->strstart = (uInt)max_start;
1428 FLUSH_BLOCK(s, 0);
1433 if (s->strstart - (uInt)s->block_start >= MAX_DIST(s)) {
1434 FLUSH_BLOCK(s, 0);
1437 FLUSH_BLOCK(s, flush == Z_FINISH);
1448 local block_state deflate_fast(s, flush) in deflate_fast() argument
1449 deflate_state *s; in deflate_fast()
1461 if (s->lookahead < MIN_LOOKAHEAD) {
1462 fill_window(s);
1463 if (s->lookahead < MIN_LOOKAHEAD && flush == Z_NO_FLUSH) {
1466 if (s->lookahead == 0) break; /* flush the current block */
1472 if (s->lookahead >= MIN_MATCH) {
1473 INSERT_STRING(s, s->strstart, hash_head);
1479 if (hash_head != NIL && s->strstart - hash_head <= MAX_DIST(s)) {
1485 if ((s->strategy != Z_HUFFMAN_ONLY && s->strategy != Z_RLE) ||
1486 (s->strategy == Z_RLE && s->strstart - hash_head == 1)) {
1487 s->match_length = longest_match_fast (s, hash_head);
1490 if (s->strategy != Z_HUFFMAN_ONLY && s->strategy != Z_RLE) {
1491 s->match_length = longest_match (s, hash_head);
1492 } else if (s->strategy == Z_RLE && s->strstart - hash_head == 1) {
1493 s->match_length = longest_match_fast (s, hash_head);
1498 if (s->match_length >= MIN_MATCH) {
1499 check_match(s, s->strstart, s->match_start, s->match_length);
1501 _tr_tally_dist(s, s->strstart - s->match_start,
1502 s->match_length - MIN_MATCH, bflush);
1504 s->lookahead -= s->match_length;
1510 if (s->match_length <= s->max_insert_length &&
1511 s->lookahead >= MIN_MATCH) {
1512 s->match_length--; /* string at strstart already in table */
1514 s->strstart++;
1515 INSERT_STRING(s, s->strstart, hash_head);
1519 } while (--s->match_length != 0);
1520 s->strstart++;
1524 s->strstart += s->match_length;
1525 s->match_length = 0;
1526 s->ins_h = s->window[s->strstart];
1527 UPDATE_HASH(s, s->ins_h, s->window[s->strstart+1]);
1537 Tracevv((stderr,"%c", s->window[s->strstart]));
1538 _tr_tally_lit (s, s->window[s->strstart], bflush);
1539 s->lookahead--;
1540 s->strstart++;
1542 if (bflush) FLUSH_BLOCK(s, 0);
1544 FLUSH_BLOCK(s, flush == Z_FINISH);
1554 local block_state deflate_slow(s, flush) in deflate_slow() argument
1555 deflate_state *s; in deflate_slow()
1568 if (s->lookahead < MIN_LOOKAHEAD) {
1569 fill_window(s);
1570 if (s->lookahead < MIN_LOOKAHEAD && flush == Z_NO_FLUSH) {
1573 if (s->lookahead == 0) break; /* flush the current block */
1579 if (s->lookahead >= MIN_MATCH) {
1580 INSERT_STRING(s, s->strstart, hash_head);
1585 s->prev_length = s->match_length, s->prev_match = s->match_start;
1586 s->match_length = MIN_MATCH-1;
1588 if (hash_head != NIL && s->prev_length < s->max_lazy_match &&
1589 s->strstart - hash_head <= MAX_DIST(s)) {
1594 if (s->strategy != Z_HUFFMAN_ONLY && s->strategy != Z_RLE) {
1595 s->match_length = longest_match (s, hash_head);
1596 } else if (s->strategy == Z_RLE && s->strstart - hash_head == 1) {
1597 s->match_length = longest_match_fast (s, hash_head);
1601 if (s->match_length <= 5 && (s->strategy == Z_FILTERED
1603 || (s->match_length == MIN_MATCH &&
1604 s->strstart - s->match_start > TOO_FAR)
1611 s->match_length = MIN_MATCH-1;
1617 if (s->prev_length >= MIN_MATCH && s->match_length <= s->prev_length) {
1618 uInt max_insert = s->strstart + s->lookahead - MIN_MATCH;
1621 check_match(s, s->strstart-1, s->prev_match, s->prev_length);
1623 _tr_tally_dist(s, s->strstart -1 - s->prev_match,
1624 s->prev_length - MIN_MATCH, bflush);
1631 s->lookahead -= s->prev_length-1;
1632 s->prev_length -= 2;
1634 if (++s->strstart <= max_insert) {
1635 INSERT_STRING(s, s->strstart, hash_head);
1637 } while (--s->prev_length != 0);
1638 s->match_available = 0;
1639 s->match_length = MIN_MATCH-1;
1640 s->strstart++;
1642 if (bflush) FLUSH_BLOCK(s, 0);
1644 } else if (s->match_available) {
1649 Tracevv((stderr,"%c", s->window[s->strstart-1]));
1650 _tr_tally_lit(s, s->window[s->strstart-1], bflush);
1652 FLUSH_BLOCK_ONLY(s, 0);
1654 s->strstart++;
1655 s->lookahead--;
1656 if (s->strm->avail_out == 0) return need_more;
1661 s->match_available = 1;
1662 s->strstart++;
1663 s->lookahead--;
1667 if (s->match_available) {
1668 Tracevv((stderr,"%c", s->window[s->strstart-1]));
1669 _tr_tally_lit(s, s->window[s->strstart-1], bflush);
1670 s->match_available = 0;
1672 FLUSH_BLOCK(s, flush == Z_FINISH);
1683 local block_state deflate_rle(s, flush)
1684 deflate_state *s;
1698 if (s->lookahead < MAX_MATCH) {
1699 fill_window(s);
1700 if (s->lookahead < MAX_MATCH && flush == Z_NO_FLUSH) {
1703 if (s->lookahead == 0) break; /* flush the current block */
1708 if (s->strstart > 0) { /* if there is a previous byte, that is */
1709 max = s->lookahead < MAX_MATCH ? s->lookahead : MAX_MATCH;
1710 scan = s->window + s->strstart - 1;
1720 check_match(s, s->strstart, s->strstart - 1, run);
1721 _tr_tally_dist(s, 1, run - MIN_MATCH, bflush);
1722 s->lookahead -= run;
1723 s->strstart += run;
1726 Tracevv((stderr,"%c", s->window[s->strstart]));
1727 _tr_tally_lit (s, s->window[s->strstart], bflush);
1728 s->lookahead--;
1729 s->strstart++;
1731 if (bflush) FLUSH_BLOCK(s, 0);
1733 FLUSH_BLOCK(s, flush == Z_FINISH);