1 /* deflate.c -- compress data using the deflation algorithm
2 * Copyright (C) 1992-1993 Jean-loup Gailly
3 * This is free software; you can redistribute it and/or modify it under the
4 * terms of the GNU General Public License, see the file COPYING.
10 * Identify new text as repetitions of old text within a fixed-
11 * length sliding window trailing behind the new text.
15 * The "deflation" process depends on being able to identify portions
16 * of the input text which are identical to earlier input (within a
17 * sliding window trailing behind the input currently being processed).
19 * The most straightforward technique turns out to be the fastest for
20 * most input files: try all possible matches and select the longest.
21 * The key feature of this algorithm is that insertions into the string
22 * dictionary are very simple and thus fast, and deletions are avoided
23 * completely. Insertions are performed at each input character, whereas
24 * string matches are performed only when the previous match ends. So it
25 * is preferable to spend more time in matches to allow very fast string
26 * insertions and avoid deletions. The matching algorithm for small
27 * strings is inspired from that of Rabin & Karp. A brute force approach
28 * is used to find longer strings when a small match has been found.
29 * A similar algorithm is used in comic (by Jan-Mark Wams) and freeze
30 * (by Leonid Broukhis).
31 * A previous version of this file used a more sophisticated algorithm
32 * (by Fiala and Greene) which is guaranteed to run in linear amortized
33 * time, but has a larger average cost, uses more memory and is patented.
34 * However the F&G algorithm may be faster for some highly redundant
35 * files if the parameter max_chain_length (described below) is too large.
39 * The idea of lazy evaluation of matches is due to Jan-Mark Wams, and
40 * I found it in 'freeze' written by Leonid Broukhis.
41 * Thanks to many info-zippers for bug reports and testing.
45 * APPNOTE.TXT documentation file in PKZIP 1.93a distribution.
47 * A description of the Rabin and Karp algorithm is given in the book
48 * "Algorithms" by R. Sedgewick, Addison-Wesley, p252.
50 * Fiala,E.R., and Greene,D.H.
51 * Data Compression with Finite Windows, Comm.ACM, 32,4 (1989) 490-595
55 * void lm_init (int pack_level, ush *flags)
56 * Initialize the "longest match" routines for a new file
58 * off_t deflate (void)
59 * Processes a new input file and return its compressed length. Sets
60 * the compressed length, crc, deflate flags and internal file
69 #include "lzw.h" /* just for consistency checking */
72 static char rcsid[] = "$Id: deflate.c,v 0.15 1993/06/24 10:53:53 jloup Exp $";
75 /* ===========================================================================
76 * Configuration parameters
79 /* Compile with MEDIUM_MEM to reduce the memory requirements or
80 * with SMALL_MEM to use as little memory as possible. Use BIG_MEM if the
81 * entire input file can be held in memory (not possible on 16 bit systems).
82 * Warning: defining these symbols affects HASH_BITS (see below) and thus
83 * affects the compression ratio. The compressed output
84 * is still correct, and might even be smaller in some cases.
88 # define HASH_BITS 13 /* Number of bits used to hash strings */
95 /* For portability to 16 bit machines, do not use values above 15. */
98 /* To save space (see unlzw.c), we overlay prev+head with tab_prefix and
99 * window with tab_suffix. Check that we can do this:
101 #if (WSIZE<<1) > (1<<BITS)
102 error: cannot overlay window with tab_suffix and prev with tab_prefix0
104 #if HASH_BITS > BITS-1
105 error: cannot overlay head with tab_prefix1
108 #define HASH_SIZE (unsigned)(1<<HASH_BITS)
109 #define HASH_MASK (HASH_SIZE-1)
110 #define WMASK (WSIZE-1)
111 /* HASH_SIZE and WSIZE must be powers of two */
114 /* Tail of hash chains */
118 /* speed options for the general purpose bit flag */
121 # define TOO_FAR 4096
123 /* Matches of length 3 are discarded if their distance exceeds TOO_FAR */
126 # define RSYNC_WIN 4096
128 /* Size of rsync window, must be < MAX_DIST */
130 #define RSYNC_SUM_MATCH(sum) ((sum) % RSYNC_WIN == 0)
131 /* Whether window sum matches magic value */
133 /* ===========================================================================
134 * Local data used by the "longest match" routines.
138 typedef unsigned IPos;
139 /* A Pos is an index in the character window. We use short instead of int to
140 * save space in the various tables. IPos is used only for parameter passing.
143 /* DECLARE(uch, window, 2L*WSIZE); */
144 /* Sliding window. Input bytes are read into the second half of the window,
145 * and move to the first half later to keep a dictionary of at least WSIZE
146 * bytes. With this organization, matches are limited to a distance of
147 * WSIZE-MAX_MATCH bytes, but this ensures that IO is always
148 * performed with a length multiple of the block size. Also, it limits
149 * the window size to 64K, which is quite useful on MSDOS.
150 * To do: limit the window size to WSIZE+BSZ if SMALL_MEM (the code would
151 * be less efficient).
154 /* DECLARE(Pos, prev, WSIZE); */
155 /* Link to older string with same hash index. To limit the size of this
156 * array to 64K, this link is maintained only for the last 32K strings.
157 * An index in this array is thus a window index modulo 32K.
160 /* DECLARE(Pos, head, 1<<HASH_BITS); */
161 /* Heads of the hash chains or NIL. */
163 ulg window_size = (ulg)2*WSIZE;
164 /* window size, 2*WSIZE except for MMAP or BIG_MEM, where it is the
165 * input file length plus MIN_LOOKAHEAD.
169 /* window position at the beginning of the current output block. Gets
170 * negative when the window is moved backwards.
173 local unsigned ins_h; /* hash index of string to be inserted */
175 #define H_SHIFT ((HASH_BITS+MIN_MATCH-1)/MIN_MATCH)
176 /* Number of bits by which ins_h and del_h must be shifted at each
177 * input step. It must be such that after MIN_MATCH steps, the oldest
178 * byte no longer takes part in the hash key, that is:
179 * H_SHIFT * MIN_MATCH >= HASH_BITS
182 unsigned int near prev_length;
183 /* Length of the best match at previous step. Matches not greater than this
184 * are discarded. This is used in the lazy match evaluation.
187 unsigned near strstart; /* start of string to insert */
188 unsigned near match_start; /* start of matching string */
189 local int eofile; /* flag set at end of input file */
190 local unsigned lookahead; /* number of valid bytes ahead in window */
192 unsigned near max_chain_length;
193 /* To speed up deflation, hash chains are never searched beyond this length.
194 * A higher limit improves compression ratio but degrades the speed.
197 local unsigned int max_lazy_match;
198 /* Attempt to find a better match only when the current match is strictly
199 * smaller than this value. This mechanism is used only for compression
202 #define max_insert_length max_lazy_match
203 /* Insert new strings in the hash table only if the match length
204 * is not greater than this length. This saves time but degrades compression.
205 * max_insert_length is used only for compression levels <= 3.
208 local int compr_level;
209 /* compression level (1..9) */
211 unsigned near good_match;
212 /* Use a faster search when the previous match is longer than this */
214 local ulg rsync_sum; /* rolling sum of rsync window */
215 local ulg rsync_chunk_end; /* next rsync sequence point */
217 /* Values for max_lazy_match, good_match and max_chain_length, depending on
218 * the desired pack level (0..9). The values given below have been tuned to
219 * exclude worst case performance for pathological files. Better values may be
220 * found for specific files.
223 typedef struct config {
224 ush good_length; /* reduce lazy search above this match length */
225 ush max_lazy; /* do not perform lazy search above this match length */
226 ush nice_length; /* quit search above this match length */
231 # define nice_match MAX_MATCH
233 int near nice_match; /* Stop searching when current match exceeds this */
236 local config configuration_table[10] = {
237 /* good lazy nice chain */
238 /* 0 */ {0, 0, 0, 0}, /* store only */
239 /* 1 */ {4, 4, 8, 4}, /* maximum speed, no lazy matches */
240 /* 2 */ {4, 5, 16, 8},
241 /* 3 */ {4, 6, 32, 32},
243 /* 4 */ {4, 4, 16, 16}, /* lazy matches */
244 /* 5 */ {8, 16, 32, 32},
245 /* 6 */ {8, 16, 128, 128},
246 /* 7 */ {8, 32, 128, 256},
247 /* 8 */ {32, 128, 258, 1024},
248 /* 9 */ {32, 258, 258, 4096}}; /* maximum compression */
250 /* Note: the deflate() code requires max_lazy >= MIN_MATCH and max_chain >= 4
251 * For deflate_fast() (levels <= 3) good is ignored and lazy has a different
256 /* result of memcmp for equal strings */
258 /* ===========================================================================
259 * Prototypes for local functions.
261 local void fill_window OF((void));
262 local off_t deflate_fast OF((void));
264 int longest_match OF((IPos cur_match));
266 void match_init OF((void)); /* asm code initialization */
270 local void check_match OF((IPos start, IPos match, int length));
273 /* ===========================================================================
274 * Update a hash value with the given input byte
275 * IN assertion: all calls to to UPDATE_HASH are made with consecutive
276 * input characters, so that a running hash key can be computed from the
277 * previous key instead of complete recalculation each time.
279 #define UPDATE_HASH(h,c) (h = (((h)<<H_SHIFT) ^ (c)) & HASH_MASK)
281 /* ===========================================================================
282 * Insert string s in the dictionary and set match_head to the previous head
283 * of the hash chain (the most recent string with same hash key). Return
284 * the previous length of the hash chain.
285 * IN assertion: all calls to to INSERT_STRING are made with consecutive
286 * input characters and the first MIN_MATCH bytes of s are valid
287 * (except for the last MIN_MATCH-1 bytes of the input file).
289 #define INSERT_STRING(s, match_head) \
290 (UPDATE_HASH(ins_h, window[(s) + MIN_MATCH-1]), \
291 prev[(s) & WMASK] = match_head = head[ins_h], \
294 /* ===========================================================================
295 * Initialize the "longest match" routines for a new file
297 void lm_init (pack_level, flags)
298 int pack_level; /* 0: store, 1: best speed, 9: best compression */
299 ush *flags; /* general purpose bit flag */
303 if (pack_level < 1 || pack_level > 9) error("bad pack level");
304 compr_level = pack_level;
306 /* Initialize the hash table. */
307 #if defined(MAXSEG_64K) && HASH_BITS == 15
308 for (j = 0; j < HASH_SIZE; j++) head[j] = NIL;
310 memzero((char*)head, HASH_SIZE*sizeof(*head));
312 /* prev will be initialized on the fly */
315 rsync_chunk_end = 0xFFFFFFFFUL;
318 /* Set the default configuration parameters:
320 max_lazy_match = configuration_table[pack_level].max_lazy;
321 good_match = configuration_table[pack_level].good_length;
323 nice_match = configuration_table[pack_level].nice_length;
325 max_chain_length = configuration_table[pack_level].max_chain;
326 if (pack_level == 1) {
328 } else if (pack_level == 9) {
331 /* ??? reduce max_chain_length for binary files */
336 match_init(); /* initialize the asm code */
339 lookahead = read_buf((char*)window,
340 sizeof(int) <= 2 ? (unsigned)WSIZE : 2*WSIZE);
342 if (lookahead == 0 || lookahead == (unsigned)EOF) {
343 eofile = 1, lookahead = 0;
347 /* Make sure that we always have enough lookahead. This is important
348 * if input comes from a device such as a tty.
350 while (lookahead < MIN_LOOKAHEAD && !eofile) fill_window();
353 for (j=0; j<MIN_MATCH-1; j++) UPDATE_HASH(ins_h, window[j]);
354 /* If lookahead < MIN_MATCH, ins_h is garbage, but this is
355 * not important since only literal bytes will be emitted.
359 /* ===========================================================================
360 * Set match_start to the longest match starting at the given string and
361 * return its length. Matches shorter or equal to prev_length are discarded,
362 * in which case the result is equal to prev_length and match_start is
364 * IN assertions: cur_match is the head of the hash chain for the current
365 * string (strstart) and its distance is <= MAX_DIST, and prev_length >= 1
368 /* For MSDOS, OS/2 and 386 Unix, an optimized version is in match.asm or
369 * match.s. The code is functionally equivalent, so you can use the C version
372 int longest_match(cur_match)
373 IPos cur_match; /* current match */
375 unsigned chain_length = max_chain_length; /* max hash chain length */
376 register uch *scan = window + strstart; /* current string */
377 register uch *match; /* matched string */
378 register int len; /* length of current match */
379 int best_len = prev_length; /* best match length so far */
380 IPos limit = strstart > (IPos)MAX_DIST ? strstart - (IPos)MAX_DIST : NIL;
381 /* Stop when cur_match becomes <= limit. To simplify the code,
382 * we prevent matches with the string of window index 0.
385 /* The code is optimized for HASH_BITS >= 8 and MAX_MATCH-2 multiple of 16.
386 * It is easy to get rid of this optimization if necessary.
388 #if HASH_BITS < 8 || MAX_MATCH != 258
389 error: Code too clever
393 /* Compare two bytes at a time. Note: this is not always beneficial.
394 * Try with and without -DUNALIGNED_OK to check.
396 register uch *strend = window + strstart + MAX_MATCH - 1;
397 register ush scan_start = *(ush*)scan;
398 register ush scan_end = *(ush*)(scan+best_len-1);
400 register uch *strend = window + strstart + MAX_MATCH;
401 register uch scan_end1 = scan[best_len-1];
402 register uch scan_end = scan[best_len];
405 /* Do not waste too much time if we already have a good match: */
406 if (prev_length >= good_match) {
409 Assert(strstart <= window_size-MIN_LOOKAHEAD, "insufficient lookahead");
412 Assert(cur_match < strstart, "no future");
413 match = window + cur_match;
415 /* Skip to next match if the match length cannot increase
416 * or if the match length is less than 2:
418 #if (defined(UNALIGNED_OK) && MAX_MATCH == 258)
419 /* This code assumes sizeof(unsigned short) == 2. Do not use
420 * UNALIGNED_OK if your compiler uses a different size.
422 if (*(ush*)(match+best_len-1) != scan_end ||
423 *(ush*)match != scan_start) continue;
425 /* It is not necessary to compare scan[2] and match[2] since they are
426 * always equal when the other bytes match, given that the hash keys
427 * are equal and that HASH_BITS >= 8. Compare 2 bytes at a time at
428 * strstart+3, +5, ... up to strstart+257. We check for insufficient
429 * lookahead only every 4th comparison; the 128th check will be made
430 * at strstart+257. If MAX_MATCH-2 is not a multiple of 8, it is
431 * necessary to put more guard bytes at the end of the window, or
432 * to check more often for insufficient lookahead.
436 } while (*(ush*)(scan+=2) == *(ush*)(match+=2) &&
437 *(ush*)(scan+=2) == *(ush*)(match+=2) &&
438 *(ush*)(scan+=2) == *(ush*)(match+=2) &&
439 *(ush*)(scan+=2) == *(ush*)(match+=2) &&
441 /* The funny "do {}" generates better code on most compilers */
443 /* Here, scan <= window+strstart+257 */
444 Assert(scan <= window+(unsigned)(window_size-1), "wild scan");
445 if (*scan == *match) scan++;
447 len = (MAX_MATCH - 1) - (int)(strend-scan);
448 scan = strend - (MAX_MATCH-1);
450 #else /* UNALIGNED_OK */
452 if (match[best_len] != scan_end ||
453 match[best_len-1] != scan_end1 ||
455 *++match != scan[1]) continue;
457 /* The check at best_len-1 can be removed because it will be made
458 * again later. (This heuristic is not always a win.)
459 * It is not necessary to compare scan[2] and match[2] since they
460 * are always equal when the other bytes match, given that
461 * the hash keys are equal and that HASH_BITS >= 8.
465 /* We check for insufficient lookahead only every 8th comparison;
466 * the 256th check will be made at strstart+258.
469 } while (*++scan == *++match && *++scan == *++match &&
470 *++scan == *++match && *++scan == *++match &&
471 *++scan == *++match && *++scan == *++match &&
472 *++scan == *++match && *++scan == *++match &&
475 len = MAX_MATCH - (int)(strend - scan);
476 scan = strend - MAX_MATCH;
478 #endif /* UNALIGNED_OK */
480 if (len > best_len) {
481 match_start = cur_match;
483 if (len >= nice_match) break;
485 scan_end = *(ush*)(scan+best_len-1);
487 scan_end1 = scan[best_len-1];
488 scan_end = scan[best_len];
491 } while ((cur_match = prev[cur_match & WMASK]) > limit
492 && --chain_length != 0);
499 /* ===========================================================================
500 * Check that the match at match_start is indeed a match.
502 local void check_match(start, match, length)
506 /* check that the match is indeed a match */
507 if (memcmp((char*)window + match,
508 (char*)window + start, length) != EQUAL) {
510 " start %d, match %d, length %d\n",
511 start, match, length);
512 error("invalid match");
515 fprintf(stderr,"\\[%d,%d]", start-match, length);
516 do { putc(window[start++], stderr); } while (--length != 0);
520 # define check_match(start, match, length)
523 /* ===========================================================================
524 * Fill the window when the lookahead becomes insufficient.
525 * Updates strstart and lookahead, and sets eofile if end of input file.
526 * IN assertion: lookahead < MIN_LOOKAHEAD && strstart + lookahead > 0
527 * OUT assertions: at least one byte has been read, or eofile is set;
528 * file reads are performed for at least two bytes (required for the
529 * translate_eol option).
531 local void fill_window()
533 register unsigned n, m;
534 unsigned more = (unsigned)(window_size - (ulg)lookahead - (ulg)strstart);
535 /* Amount of free space at the end of the window. */
537 /* If the window is almost full and there is insufficient lookahead,
538 * move the upper half to the lower one to make room in the upper half.
540 if (more == (unsigned)EOF) {
541 /* Very unlikely, but possible on 16 bit machine if strstart == 0
542 * and lookahead == 1 (input done one byte at time)
545 } else if (strstart >= WSIZE+MAX_DIST) {
546 /* By the IN assertion, the window is not empty so we can't confuse
547 * more == 0 with more == 64K on a 16 bit machine.
549 Assert(window_size == (ulg)2*WSIZE, "no sliding with BIG_MEM");
551 memcpy((char*)window, (char*)window+WSIZE, (unsigned)WSIZE);
552 match_start -= WSIZE;
553 strstart -= WSIZE; /* we now have strstart >= MAX_DIST: */
554 if (rsync_chunk_end != 0xFFFFFFFFUL)
555 rsync_chunk_end -= WSIZE;
557 block_start -= (long) WSIZE;
559 for (n = 0; n < HASH_SIZE; n++) {
561 head[n] = (Pos)(m >= WSIZE ? m-WSIZE : NIL);
563 for (n = 0; n < WSIZE; n++) {
565 prev[n] = (Pos)(m >= WSIZE ? m-WSIZE : NIL);
566 /* If n is not on any hash chain, prev[n] is garbage but
567 * its value will never be used.
572 /* At this point, more >= 2 */
574 n = read_buf((char*)window+strstart+lookahead, more);
575 if (n == 0 || n == (unsigned)EOF) {
583 local void rsync_roll(start, num)
589 if (start < RSYNC_WIN) {
590 /* before window fills. */
591 for (i = start; i < RSYNC_WIN; i++) {
592 if (i == start + num) return;
593 rsync_sum += (ulg)window[i];
595 num -= (RSYNC_WIN - start);
599 /* buffer after window full */
600 for (i = start; i < start+num; i++) {
601 /* New character in */
602 rsync_sum += (ulg)window[i];
603 /* Old character out */
604 rsync_sum -= (ulg)window[i - RSYNC_WIN];
605 if (rsync_chunk_end == 0xFFFFFFFFUL && RSYNC_SUM_MATCH(rsync_sum))
610 /* ===========================================================================
611 * Set rsync_chunk_end if window sum matches magic value.
613 #define RSYNC_ROLL(s, n) \
614 do { if (rsync) rsync_roll((s), (n)); } while(0)
616 /* ===========================================================================
617 * Flush the current block, with given end-of-file flag.
618 * IN assertion: strstart is set to the end of the current match.
620 #define FLUSH_BLOCK(eof) \
621 flush_block(block_start >= 0L ? (char*)&window[(unsigned)block_start] : \
622 (char*)NULL, (long)strstart - block_start, flush-1, (eof))
624 /* ===========================================================================
625 * Processes a new input file and return its compressed length. This
626 * function does not perform lazy evaluationof matches and inserts
627 * new strings in the dictionary only for unmatched strings or for short
628 * matches. It is used only for the fast compression options.
630 local off_t deflate_fast()
632 IPos hash_head; /* head of the hash chain */
633 int flush; /* set if current block must be flushed, 2=>and padded */
634 unsigned match_length = 0; /* length of best match */
636 prev_length = MIN_MATCH-1;
637 while (lookahead != 0) {
638 /* Insert the string window[strstart .. strstart+2] in the
639 * dictionary, and set hash_head to the head of the hash chain:
641 INSERT_STRING(strstart, hash_head);
643 /* Find the longest match, discarding those <= prev_length.
644 * At this point we have always match_length < MIN_MATCH
646 if (hash_head != NIL && strstart - hash_head <= MAX_DIST &&
647 strstart <= window_size - MIN_LOOKAHEAD) {
648 /* To simplify the code, we prevent matches with the string
649 * of window index 0 (in particular we have to avoid a match
650 * of the string with itself at the start of the input file).
652 match_length = longest_match (hash_head);
653 /* longest_match() sets match_start */
654 if (match_length > lookahead) match_length = lookahead;
656 if (match_length >= MIN_MATCH) {
657 check_match(strstart, match_start, match_length);
659 flush = ct_tally(strstart-match_start, match_length - MIN_MATCH);
661 lookahead -= match_length;
663 RSYNC_ROLL(strstart, match_length);
664 /* Insert new strings in the hash table only if the match length
665 * is not too large. This saves time but degrades compression.
667 if (match_length <= max_insert_length) {
668 match_length--; /* string at strstart already in hash table */
671 INSERT_STRING(strstart, hash_head);
672 /* strstart never exceeds WSIZE-MAX_MATCH, so there are
673 * always MIN_MATCH bytes ahead. If lookahead < MIN_MATCH
674 * these bytes are garbage, but it does not matter since
675 * the next lookahead bytes will be emitted as literals.
677 } while (--match_length != 0);
680 strstart += match_length;
682 ins_h = window[strstart];
683 UPDATE_HASH(ins_h, window[strstart+1]);
685 Call UPDATE_HASH() MIN_MATCH-3 more times
689 /* No match, output a literal byte */
690 Tracevv((stderr,"%c",window[strstart]));
691 flush = ct_tally (0, window[strstart]);
692 RSYNC_ROLL(strstart, 1);
696 if (rsync && strstart > rsync_chunk_end) {
697 rsync_chunk_end = 0xFFFFFFFFUL;
700 if (flush) FLUSH_BLOCK(0), block_start = strstart;
702 /* Make sure that we always have enough lookahead, except
703 * at the end of the input file. We need MAX_MATCH bytes
704 * for the next match, plus MIN_MATCH bytes to insert the
705 * string following the next match.
707 while (lookahead < MIN_LOOKAHEAD && !eofile) fill_window();
710 return FLUSH_BLOCK(1); /* eof */
713 /* ===========================================================================
714 * Same as above, but achieves better compression. We use a lazy
715 * evaluation for matches: a match is finally adopted only if there is
716 * no better match at the next window position.
720 IPos hash_head; /* head of hash chain */
721 IPos prev_match; /* previous match */
722 int flush; /* set if current block must be flushed */
723 int match_available = 0; /* set if previous match exists */
724 register unsigned match_length = MIN_MATCH-1; /* length of best match */
726 if (compr_level <= 3) return deflate_fast(); /* optimized for speed */
728 /* Process the input block. */
729 while (lookahead != 0) {
730 /* Insert the string window[strstart .. strstart+2] in the
731 * dictionary, and set hash_head to the head of the hash chain:
733 INSERT_STRING(strstart, hash_head);
735 /* Find the longest match, discarding those <= prev_length.
737 prev_length = match_length, prev_match = match_start;
738 match_length = MIN_MATCH-1;
740 if (hash_head != NIL && prev_length < max_lazy_match &&
741 strstart - hash_head <= MAX_DIST &&
742 strstart <= window_size - MIN_LOOKAHEAD) {
743 /* To simplify the code, we prevent matches with the string
744 * of window index 0 (in particular we have to avoid a match
745 * of the string with itself at the start of the input file).
747 match_length = longest_match (hash_head);
748 /* longest_match() sets match_start */
749 if (match_length > lookahead) match_length = lookahead;
751 /* Ignore a length 3 match if it is too distant: */
752 if (match_length == MIN_MATCH && strstart-match_start > TOO_FAR){
753 /* If prev_match is also MIN_MATCH, match_start is garbage
754 * but we will ignore the current match anyway.
759 /* If there was a match at the previous step and the current
760 * match is not better, output the previous match:
762 if (prev_length >= MIN_MATCH && match_length <= prev_length) {
764 check_match(strstart-1, prev_match, prev_length);
766 flush = ct_tally(strstart-1-prev_match, prev_length - MIN_MATCH);
768 /* Insert in hash table all strings up to the end of the match.
769 * strstart-1 and strstart are already inserted.
771 lookahead -= prev_length-1;
773 RSYNC_ROLL(strstart, prev_length+1);
776 INSERT_STRING(strstart, hash_head);
777 /* strstart never exceeds WSIZE-MAX_MATCH, so there are
778 * always MIN_MATCH bytes ahead. If lookahead < MIN_MATCH
779 * these bytes are garbage, but it does not matter since the
780 * next lookahead bytes will always be emitted as literals.
782 } while (--prev_length != 0);
784 match_length = MIN_MATCH-1;
787 if (rsync && strstart > rsync_chunk_end) {
788 rsync_chunk_end = 0xFFFFFFFFUL;
791 if (flush) FLUSH_BLOCK(0), block_start = strstart;
792 } else if (match_available) {
793 /* If there was no match at the previous position, output a
794 * single literal. If there was a match but the current match
795 * is longer, truncate the previous match to a single literal.
797 Tracevv((stderr,"%c",window[strstart-1]));
798 flush = ct_tally (0, window[strstart-1]);
799 if (rsync && strstart > rsync_chunk_end) {
800 rsync_chunk_end = 0xFFFFFFFFUL;
803 if (flush) FLUSH_BLOCK(0), block_start = strstart;
804 RSYNC_ROLL(strstart, 1);
808 /* There is no previous match to compare with, wait for
809 * the next step to decide.
811 if (rsync && strstart > rsync_chunk_end) {
812 /* Reset huffman tree */
813 rsync_chunk_end = 0xFFFFFFFFUL;
815 FLUSH_BLOCK(0), block_start = strstart;
818 RSYNC_ROLL(strstart, 1);
822 Assert (strstart <= bytes_in && lookahead <= bytes_in, "a bit too far");
824 /* Make sure that we always have enough lookahead, except
825 * at the end of the input file. We need MAX_MATCH bytes
826 * for the next match, plus MIN_MATCH bytes to insert the
827 * string following the next match.
829 while (lookahead < MIN_LOOKAHEAD && !eofile) fill_window();
831 if (match_available) ct_tally (0, window[strstart-1]);
833 return FLUSH_BLOCK(1); /* eof */