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. 5 */ 6 7/* 8 * PURPOSE 9 * 10 * Identify new text as repetitions of old text within a fixed- 11 * length sliding window trailing behind the new text. 12 * 13 * DISCUSSION 14 * 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). 18 * 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. 36 * 37 * ACKNOWLEDGEMENTS 38 * 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. 42 * 43 * REFERENCES 44 * 45 * APPNOTE.TXT documentation file in PKZIP 1.93a distribution. 46 * 47 * A description of the Rabin and Karp algorithm is given in the book 48 * "Algorithms" by R. Sedgewick, Addison-Wesley, p252. 49 * 50 * Fiala,E.R., and Greene,D.H. 51 * Data Compression with Finite Windows, Comm.ACM, 32,4 (1989) 490-595 52 * 53 * INTERFACE 54 * 55 * void lm_init (int pack_level, ush *flags) 56 * Initialize the "longest match" routines for a new file 57 * 58 * ulg deflate (void) 59 * Processes a new input file and return its compressed length. Sets 60 * the compressed length, crc, deflate flags and internal file 61 * attributes. 62 */ 63 64#include <stdio.h> 65 66#include "tailor.h" 67#include "gzip.h" 68#include "lzw.h" /* just for consistency checking */ 69 70#ifdef RCSID 71static char rcsid[] = "$Id: deflate.c 3476 2003-06-11 15:56:10Z darkwyrm $"; 72#endif 73 74/* =========================================================================== 75 * Configuration parameters 76 */ 77 78/* Compile with MEDIUM_MEM to reduce the memory requirements or 79 * with SMALL_MEM to use as little memory as possible. Use BIG_MEM if the 80 * entire input file can be held in memory (not possible on 16 bit systems). 81 * Warning: defining these symbols affects HASH_BITS (see below) and thus 82 * affects the compression ratio. The compressed output 83 * is still correct, and might even be smaller in some cases. 84 */ 85 86#ifdef SMALL_MEM 87# define HASH_BITS 13 /* Number of bits used to hash strings */ 88#endif 89#ifdef MEDIUM_MEM 90# define HASH_BITS 14 91#endif 92#ifndef HASH_BITS 93# define HASH_BITS 15 94 /* For portability to 16 bit machines, do not use values above 15. */ 95#endif 96 97/* To save space (see unlzw.c), we overlay prev+head with tab_prefix and 98 * window with tab_suffix. Check that we can do this: 99 */ 100#if (WSIZE<<1) > (1<<BITS) 101 error: cannot overlay window with tab_suffix and prev with tab_prefix0 102#endif 103#if HASH_BITS > BITS-1 104 error: cannot overlay head with tab_prefix1 105#endif 106 107#define HASH_SIZE (unsigned)(1<<HASH_BITS) 108#define HASH_MASK (HASH_SIZE-1) 109#define WMASK (WSIZE-1) 110/* HASH_SIZE and WSIZE must be powers of two */ 111 112#define NIL 0 113/* Tail of hash chains */ 114 115#define FAST 4 116#define SLOW 2 117/* speed options for the general purpose bit flag */ 118 119#ifndef TOO_FAR 120# define TOO_FAR 4096 121#endif 122/* Matches of length 3 are discarded if their distance exceeds TOO_FAR */ 123 124/* =========================================================================== 125 * Local data used by the "longest match" routines. 126 */ 127 128typedef ush Pos; 129typedef unsigned IPos; 130/* A Pos is an index in the character window. We use short instead of int to 131 * save space in the various tables. IPos is used only for parameter passing. 132 */ 133 134/* DECLARE(uch, window, 2L*WSIZE); */ 135/* Sliding window. Input bytes are read into the second half of the window, 136 * and move to the first half later to keep a dictionary of at least WSIZE 137 * bytes. With this organization, matches are limited to a distance of 138 * WSIZE-MAX_MATCH bytes, but this ensures that IO is always 139 * performed with a length multiple of the block size. Also, it limits 140 * the window size to 64K, which is quite useful on MSDOS. 141 * To do: limit the window size to WSIZE+BSZ if SMALL_MEM (the code would 142 * be less efficient). 143 */ 144 145/* DECLARE(Pos, prev, WSIZE); */ 146/* Link to older string with same hash index. To limit the size of this 147 * array to 64K, this link is maintained only for the last 32K strings. 148 * An index in this array is thus a window index modulo 32K. 149 */ 150 151/* DECLARE(Pos, head, 1<<HASH_BITS); */ 152/* Heads of the hash chains or NIL. */ 153 154ulg window_size = (ulg)2*WSIZE; 155/* window size, 2*WSIZE except for MMAP or BIG_MEM, where it is the 156 * input file length plus MIN_LOOKAHEAD. 157 */ 158 159long block_start; 160/* window position at the beginning of the current output block. Gets 161 * negative when the window is moved backwards. 162 */ 163 164local unsigned ins_h; /* hash index of string to be inserted */ 165 166#define H_SHIFT ((HASH_BITS+MIN_MATCH-1)/MIN_MATCH) 167/* Number of bits by which ins_h and del_h must be shifted at each 168 * input step. It must be such that after MIN_MATCH steps, the oldest 169 * byte no longer takes part in the hash key, that is: 170 * H_SHIFT * MIN_MATCH >= HASH_BITS 171 */ 172 173unsigned int near prev_length; 174/* Length of the best match at previous step. Matches not greater than this 175 * are discarded. This is used in the lazy match evaluation. 176 */ 177 178 unsigned near strstart; /* start of string to insert */ 179 unsigned near match_start; /* start of matching string */ 180local int eofile; /* flag set at end of input file */ 181local unsigned lookahead; /* number of valid bytes ahead in window */ 182 183unsigned near max_chain_length; 184/* To speed up deflation, hash chains are never searched beyond this length. 185 * A higher limit improves compression ratio but degrades the speed. 186 */ 187 188local unsigned int max_lazy_match; 189/* Attempt to find a better match only when the current match is strictly 190 * smaller than this value. This mechanism is used only for compression 191 * levels >= 4. 192 */ 193#define max_insert_length max_lazy_match 194/* Insert new strings in the hash table only if the match length 195 * is not greater than this length. This saves time but degrades compression. 196 * max_insert_length is used only for compression levels <= 3. 197 */ 198 199local int compr_level; 200/* compression level (1..9) */ 201 202unsigned near good_match; 203/* Use a faster search when the previous match is longer than this */ 204 205 206/* Values for max_lazy_match, good_match and max_chain_length, depending on 207 * the desired pack level (0..9). The values given below have been tuned to 208 * exclude worst case performance for pathological files. Better values may be 209 * found for specific files. 210 */ 211 212typedef struct config { 213 ush good_length; /* reduce lazy search above this match length */ 214 ush max_lazy; /* do not perform lazy search above this match length */ 215 ush nice_length; /* quit search above this match length */ 216 ush max_chain; 217} config; 218 219#ifdef FULL_SEARCH 220# define nice_match MAX_MATCH 221#else 222 int near nice_match; /* Stop searching when current match exceeds this */ 223#endif 224 225local config configuration_table[10] = { 226/* good lazy nice chain */ 227/* 0 */ {0, 0, 0, 0}, /* store only */ 228/* 1 */ {4, 4, 8, 4}, /* maximum speed, no lazy matches */ 229/* 2 */ {4, 5, 16, 8}, 230/* 3 */ {4, 6, 32, 32}, 231 232/* 4 */ {4, 4, 16, 16}, /* lazy matches */ 233/* 5 */ {8, 16, 32, 32}, 234/* 6 */ {8, 16, 128, 128}, 235/* 7 */ {8, 32, 128, 256}, 236/* 8 */ {32, 128, 258, 1024}, 237/* 9 */ {32, 258, 258, 4096}}; /* maximum compression */ 238 239/* Note: the deflate() code requires max_lazy >= MIN_MATCH and max_chain >= 4 240 * For deflate_fast() (levels <= 3) good is ignored and lazy has a different 241 * meaning. 242 */ 243 244#define EQUAL 0 245/* result of memcmp for equal strings */ 246 247/* =========================================================================== 248 * Prototypes for local functions. 249 */ 250local void fill_window OF((void)); 251local ulg deflate_fast OF((void)); 252 253 int longest_match OF((IPos cur_match)); 254#ifdef ASMV 255 void match_init OF((void)); /* asm code initialization */ 256#endif 257 258#ifdef DEBUG 259local void check_match OF((IPos start, IPos match, int length)); 260#endif 261 262/* =========================================================================== 263 * Update a hash value with the given input byte 264 * IN assertion: all calls to to UPDATE_HASH are made with consecutive 265 * input characters, so that a running hash key can be computed from the 266 * previous key instead of complete recalculation each time. 267 */ 268#define UPDATE_HASH(h,c) (h = (((h)<<H_SHIFT) ^ (c)) & HASH_MASK) 269 270/* =========================================================================== 271 * Insert string s in the dictionary and set match_head to the previous head 272 * of the hash chain (the most recent string with same hash key). Return 273 * the previous length of the hash chain. 274 * IN assertion: all calls to to INSERT_STRING are made with consecutive 275 * input characters and the first MIN_MATCH bytes of s are valid 276 * (except for the last MIN_MATCH-1 bytes of the input file). 277 */ 278#define INSERT_STRING(s, match_head) \ 279 (UPDATE_HASH(ins_h, window[(s) + MIN_MATCH-1]), \ 280 prev[(s) & WMASK] = match_head = head[ins_h], \ 281 head[ins_h] = (s)) 282 283/* =========================================================================== 284 * Initialize the "longest match" routines for a new file 285 */ 286void lm_init (pack_level, flags) 287 int pack_level; /* 0: store, 1: best speed, 9: best compression */ 288 ush *flags; /* general purpose bit flag */ 289{ 290 register unsigned j; 291 292 if (pack_level < 1 || pack_level > 9) error("bad pack level"); 293 compr_level = pack_level; 294 295 /* Initialize the hash table. */ 296#if defined(MAXSEG_64K) && HASH_BITS == 15 297 for (j = 0; j < HASH_SIZE; j++) head[j] = NIL; 298#else 299 memzero((char*)head, HASH_SIZE*sizeof(*head)); 300#endif 301 /* prev will be initialized on the fly */ 302 303 /* Set the default configuration parameters: 304 */ 305 max_lazy_match = configuration_table[pack_level].max_lazy; 306 good_match = configuration_table[pack_level].good_length; 307#ifndef FULL_SEARCH 308 nice_match = configuration_table[pack_level].nice_length; 309#endif 310 max_chain_length = configuration_table[pack_level].max_chain; 311 if (pack_level == 1) { 312 *flags |= FAST; 313 } else if (pack_level == 9) { 314 *flags |= SLOW; 315 } 316 /* ??? reduce max_chain_length for binary files */ 317 318 strstart = 0; 319 block_start = 0L; 320#ifdef ASMV 321 match_init(); /* initialize the asm code */ 322#endif 323 324 lookahead = read_buf((char*)window, 325 sizeof(int) <= 2 ? (unsigned)WSIZE : 2*WSIZE); 326 327 if (lookahead == 0 || lookahead == (unsigned)EOF) { 328 eofile = 1, lookahead = 0; 329 return; 330 } 331 eofile = 0; 332 /* Make sure that we always have enough lookahead. This is important 333 * if input comes from a device such as a tty. 334 */ 335 while (lookahead < MIN_LOOKAHEAD && !eofile) fill_window(); 336 337 ins_h = 0; 338 for (j=0; j<MIN_MATCH-1; j++) UPDATE_HASH(ins_h, window[j]); 339 /* If lookahead < MIN_MATCH, ins_h is garbage, but this is 340 * not important since only literal bytes will be emitted. 341 */ 342} 343 344/* =========================================================================== 345 * Set match_start to the longest match starting at the given string and 346 * return its length. Matches shorter or equal to prev_length are discarded, 347 * in which case the result is equal to prev_length and match_start is 348 * garbage. 349 * IN assertions: cur_match is the head of the hash chain for the current 350 * string (strstart) and its distance is <= MAX_DIST, and prev_length >= 1 351 */ 352#ifndef ASMV 353/* For MSDOS, OS/2 and 386 Unix, an optimized version is in match.asm or 354 * match.s. The code is functionally equivalent, so you can use the C version 355 * if desired. 356 */ 357int longest_match(cur_match) 358 IPos cur_match; /* current match */ 359{ 360 unsigned chain_length = max_chain_length; /* max hash chain length */ 361 register uch *scan = window + strstart; /* current string */ 362 register uch *match; /* matched string */ 363 register int len; /* length of current match */ 364 int best_len = prev_length; /* best match length so far */ 365 IPos limit = strstart > (IPos)MAX_DIST ? strstart - (IPos)MAX_DIST : NIL; 366 /* Stop when cur_match becomes <= limit. To simplify the code, 367 * we prevent matches with the string of window index 0. 368 */ 369 370/* The code is optimized for HASH_BITS >= 8 and MAX_MATCH-2 multiple of 16. 371 * It is easy to get rid of this optimization if necessary. 372 */ 373#if HASH_BITS < 8 || MAX_MATCH != 258 374 error: Code too clever 375#endif 376 377#ifdef UNALIGNED_OK 378 /* Compare two bytes at a time. Note: this is not always beneficial. 379 * Try with and without -DUNALIGNED_OK to check. 380 */ 381 register uch *strend = window + strstart + MAX_MATCH - 1; 382 register ush scan_start = *(ush*)scan; 383 register ush scan_end = *(ush*)(scan+best_len-1); 384#else 385 register uch *strend = window + strstart + MAX_MATCH; 386 register uch scan_end1 = scan[best_len-1]; 387 register uch scan_end = scan[best_len]; 388#endif 389 390 /* Do not waste too much time if we already have a good match: */ 391 if (prev_length >= good_match) { 392 chain_length >>= 2; 393 } 394 Assert(strstart <= window_size-MIN_LOOKAHEAD, "insufficient lookahead"); 395 396 do { 397 Assert(cur_match < strstart, "no future"); 398 match = window + cur_match; 399 400 /* Skip to next match if the match length cannot increase 401 * or if the match length is less than 2: 402 */ 403#if (defined(UNALIGNED_OK) && MAX_MATCH == 258) 404 /* This code assumes sizeof(unsigned short) == 2. Do not use 405 * UNALIGNED_OK if your compiler uses a different size. 406 */ 407 if (*(ush*)(match+best_len-1) != scan_end || 408 *(ush*)match != scan_start) continue; 409 410 /* It is not necessary to compare scan[2] and match[2] since they are 411 * always equal when the other bytes match, given that the hash keys 412 * are equal and that HASH_BITS >= 8. Compare 2 bytes at a time at 413 * strstart+3, +5, ... up to strstart+257. We check for insufficient 414 * lookahead only every 4th comparison; the 128th check will be made 415 * at strstart+257. If MAX_MATCH-2 is not a multiple of 8, it is 416 * necessary to put more guard bytes at the end of the window, or 417 * to check more often for insufficient lookahead. 418 */ 419 scan++, match++; 420 do { 421 } while (*(ush*)(scan+=2) == *(ush*)(match+=2) && 422 *(ush*)(scan+=2) == *(ush*)(match+=2) && 423 *(ush*)(scan+=2) == *(ush*)(match+=2) && 424 *(ush*)(scan+=2) == *(ush*)(match+=2) && 425 scan < strend); 426 /* The funny "do {}" generates better code on most compilers */ 427 428 /* Here, scan <= window+strstart+257 */ 429 Assert(scan <= window+(unsigned)(window_size-1), "wild scan"); 430 if (*scan == *match) scan++; 431 432 len = (MAX_MATCH - 1) - (int)(strend-scan); 433 scan = strend - (MAX_MATCH-1); 434 435#else /* UNALIGNED_OK */ 436 437 if (match[best_len] != scan_end || 438 match[best_len-1] != scan_end1 || 439 *match != *scan || 440 *++match != scan[1]) continue; 441 442 /* The check at best_len-1 can be removed because it will be made 443 * again later. (This heuristic is not always a win.) 444 * It is not necessary to compare scan[2] and match[2] since they 445 * are always equal when the other bytes match, given that 446 * the hash keys are equal and that HASH_BITS >= 8. 447 */ 448 scan += 2, match++; 449 450 /* We check for insufficient lookahead only every 8th comparison; 451 * the 256th check will be made at strstart+258. 452 */ 453 do { 454 } while (*++scan == *++match && *++scan == *++match && 455 *++scan == *++match && *++scan == *++match && 456 *++scan == *++match && *++scan == *++match && 457 *++scan == *++match && *++scan == *++match && 458 scan < strend); 459 460 len = MAX_MATCH - (int)(strend - scan); 461 scan = strend - MAX_MATCH; 462 463#endif /* UNALIGNED_OK */ 464 465 if (len > best_len) { 466 match_start = cur_match; 467 best_len = len; 468 if (len >= nice_match) break; 469#ifdef UNALIGNED_OK 470 scan_end = *(ush*)(scan+best_len-1); 471#else 472 scan_end1 = scan[best_len-1]; 473 scan_end = scan[best_len]; 474#endif 475 } 476 } while ((cur_match = prev[cur_match & WMASK]) > limit 477 && --chain_length != 0); 478 479 return best_len; 480} 481#endif /* ASMV */ 482 483#ifdef DEBUG 484/* =========================================================================== 485 * Check that the match at match_start is indeed a match. 486 */ 487local void check_match(start, match, length) 488 IPos start, match; 489 int length; 490{ 491 /* check that the match is indeed a match */ 492 if (memcmp((char*)window + match, 493 (char*)window + start, length) != EQUAL) { 494 fprintf(stderr, 495 " start %d, match %d, length %d\n", 496 start, match, length); 497 error("invalid match"); 498 } 499 if (verbose > 1) { 500 fprintf(stderr,"\\[%d,%d]", start-match, length); 501 do { putc(window[start++], stderr); } while (--length != 0); 502 } 503} 504#else 505# define check_match(start, match, length) 506#endif 507 508/* =========================================================================== 509 * Fill the window when the lookahead becomes insufficient. 510 * Updates strstart and lookahead, and sets eofile if end of input file. 511 * IN assertion: lookahead < MIN_LOOKAHEAD && strstart + lookahead > 0 512 * OUT assertions: at least one byte has been read, or eofile is set; 513 * file reads are performed for at least two bytes (required for the 514 * translate_eol option). 515 */ 516local void fill_window() 517{ 518 register unsigned n, m; 519 unsigned more = (unsigned)(window_size - (ulg)lookahead - (ulg)strstart); 520 /* Amount of free space at the end of the window. */ 521 522 /* If the window is almost full and there is insufficient lookahead, 523 * move the upper half to the lower one to make room in the upper half. 524 */ 525 if (more == (unsigned)EOF) { 526 /* Very unlikely, but possible on 16 bit machine if strstart == 0 527 * and lookahead == 1 (input done one byte at time) 528 */ 529 more--; 530 } else if (strstart >= WSIZE+MAX_DIST) { 531 /* By the IN assertion, the window is not empty so we can't confuse 532 * more == 0 with more == 64K on a 16 bit machine. 533 */ 534 Assert(window_size == (ulg)2*WSIZE, "no sliding with BIG_MEM"); 535 536 memcpy((char*)window, (char*)window+WSIZE, (unsigned)WSIZE); 537 match_start -= WSIZE; 538 strstart -= WSIZE; /* we now have strstart >= MAX_DIST: */ 539 540 block_start -= (long) WSIZE; 541 542 for (n = 0; n < HASH_SIZE; n++) { 543 m = head[n]; 544 head[n] = (Pos)(m >= WSIZE ? m-WSIZE : NIL); 545 } 546 for (n = 0; n < WSIZE; n++) { 547 m = prev[n]; 548 prev[n] = (Pos)(m >= WSIZE ? m-WSIZE : NIL); 549 /* If n is not on any hash chain, prev[n] is garbage but 550 * its value will never be used. 551 */ 552 } 553 more += WSIZE; 554 } 555 /* At this point, more >= 2 */ 556 if (!eofile) { 557 n = read_buf((char*)window+strstart+lookahead, more); 558 if (n == 0 || n == (unsigned)EOF) { 559 eofile = 1; 560 } else { 561 lookahead += n; 562 } 563 } 564} 565 566/* =========================================================================== 567 * Flush the current block, with given end-of-file flag. 568 * IN assertion: strstart is set to the end of the current match. 569 */ 570#define FLUSH_BLOCK(eof) \ 571 flush_block(block_start >= 0L ? (char*)&window[(unsigned)block_start] : \ 572 (char*)NULL, (long)strstart - block_start, (eof)) 573 574/* =========================================================================== 575 * Processes a new input file and return its compressed length. This 576 * function does not perform lazy evaluationof matches and inserts 577 * new strings in the dictionary only for unmatched strings or for short 578 * matches. It is used only for the fast compression options. 579 */ 580local ulg deflate_fast() 581{ 582 IPos hash_head; /* head of the hash chain */ 583 int flush; /* set if current block must be flushed */ 584 unsigned match_length = 0; /* length of best match */ 585 586 prev_length = MIN_MATCH-1; 587 while (lookahead != 0) { 588 /* Insert the string window[strstart .. strstart+2] in the 589 * dictionary, and set hash_head to the head of the hash chain: 590 */ 591 INSERT_STRING(strstart, hash_head); 592 593 /* Find the longest match, discarding those <= prev_length. 594 * At this point we have always match_length < MIN_MATCH 595 */ 596 if (hash_head != NIL && strstart - hash_head <= MAX_DIST) { 597 /* To simplify the code, we prevent matches with the string 598 * of window index 0 (in particular we have to avoid a match 599 * of the string with itself at the start of the input file). 600 */ 601 match_length = longest_match (hash_head); 602 /* longest_match() sets match_start */ 603 if (match_length > lookahead) match_length = lookahead; 604 } 605 if (match_length >= MIN_MATCH) { 606 check_match(strstart, match_start, match_length); 607 608 flush = ct_tally(strstart-match_start, match_length - MIN_MATCH); 609 610 lookahead -= match_length; 611 612 /* Insert new strings in the hash table only if the match length 613 * is not too large. This saves time but degrades compression. 614 */ 615 if (match_length <= max_insert_length) { 616 match_length--; /* string at strstart already in hash table */ 617 do { 618 strstart++; 619 INSERT_STRING(strstart, hash_head); 620 /* strstart never exceeds WSIZE-MAX_MATCH, so there are 621 * always MIN_MATCH bytes ahead. If lookahead < MIN_MATCH 622 * these bytes are garbage, but it does not matter since 623 * the next lookahead bytes will be emitted as literals. 624 */ 625 } while (--match_length != 0); 626 strstart++; 627 } else { 628 strstart += match_length; 629 match_length = 0; 630 ins_h = window[strstart]; 631 UPDATE_HASH(ins_h, window[strstart+1]); 632#if MIN_MATCH != 3 633 Call UPDATE_HASH() MIN_MATCH-3 more times 634#endif 635 } 636 } else { 637 /* No match, output a literal byte */ 638 Tracevv((stderr,"%c",window[strstart])); 639 flush = ct_tally (0, window[strstart]); 640 lookahead--; 641 strstart++; 642 } 643 if (flush) FLUSH_BLOCK(0), block_start = strstart; 644 645 /* Make sure that we always have enough lookahead, except 646 * at the end of the input file. We need MAX_MATCH bytes 647 * for the next match, plus MIN_MATCH bytes to insert the 648 * string following the next match. 649 */ 650 while (lookahead < MIN_LOOKAHEAD && !eofile) fill_window(); 651 652 } 653 return FLUSH_BLOCK(1); /* eof */ 654} 655 656/* =========================================================================== 657 * Same as above, but achieves better compression. We use a lazy 658 * evaluation for matches: a match is finally adopted only if there is 659 * no better match at the next window position. 660 */ 661ulg deflate() 662{ 663 IPos hash_head; /* head of hash chain */ 664 IPos prev_match; /* previous match */ 665 int flush; /* set if current block must be flushed */ 666 int match_available = 0; /* set if previous match exists */ 667 register unsigned match_length = MIN_MATCH-1; /* length of best match */ 668#ifdef DEBUG 669 extern long isize; /* byte length of input file, for debug only */ 670#endif 671 672 if (compr_level <= 3) return deflate_fast(); /* optimized for speed */ 673 674 /* Process the input block. */ 675 while (lookahead != 0) { 676 /* Insert the string window[strstart .. strstart+2] in the 677 * dictionary, and set hash_head to the head of the hash chain: 678 */ 679 INSERT_STRING(strstart, hash_head); 680 681 /* Find the longest match, discarding those <= prev_length. 682 */ 683 prev_length = match_length, prev_match = match_start; 684 match_length = MIN_MATCH-1; 685 686 if (hash_head != NIL && prev_length < max_lazy_match && 687 strstart - hash_head <= MAX_DIST) { 688 /* To simplify the code, we prevent matches with the string 689 * of window index 0 (in particular we have to avoid a match 690 * of the string with itself at the start of the input file). 691 */ 692 match_length = longest_match (hash_head); 693 /* longest_match() sets match_start */ 694 if (match_length > lookahead) match_length = lookahead; 695 696 /* Ignore a length 3 match if it is too distant: */ 697 if (match_length == MIN_MATCH && strstart-match_start > TOO_FAR){ 698 /* If prev_match is also MIN_MATCH, match_start is garbage 699 * but we will ignore the current match anyway. 700 */ 701 match_length--; 702 } 703 } 704 /* If there was a match at the previous step and the current 705 * match is not better, output the previous match: 706 */ 707 if (prev_length >= MIN_MATCH && match_length <= prev_length) { 708 709 check_match(strstart-1, prev_match, prev_length); 710 711 flush = ct_tally(strstart-1-prev_match, prev_length - MIN_MATCH); 712 713 /* Insert in hash table all strings up to the end of the match. 714 * strstart-1 and strstart are already inserted. 715 */ 716 lookahead -= prev_length-1; 717 prev_length -= 2; 718 do { 719 strstart++; 720 INSERT_STRING(strstart, hash_head); 721 /* strstart never exceeds WSIZE-MAX_MATCH, so there are 722 * always MIN_MATCH bytes ahead. If lookahead < MIN_MATCH 723 * these bytes are garbage, but it does not matter since the 724 * next lookahead bytes will always be emitted as literals. 725 */ 726 } while (--prev_length != 0); 727 match_available = 0; 728 match_length = MIN_MATCH-1; 729 strstart++; 730 if (flush) FLUSH_BLOCK(0), block_start = strstart; 731 732 } else if (match_available) { 733 /* If there was no match at the previous position, output a 734 * single literal. If there was a match but the current match 735 * is longer, truncate the previous match to a single literal. 736 */ 737 Tracevv((stderr,"%c",window[strstart-1])); 738 if (ct_tally (0, window[strstart-1])) { 739 FLUSH_BLOCK(0), block_start = strstart; 740 } 741 strstart++; 742 lookahead--; 743 } else { 744 /* There is no previous match to compare with, wait for 745 * the next step to decide. 746 */ 747 match_available = 1; 748 strstart++; 749 lookahead--; 750 } 751 Assert (strstart <= isize && lookahead <= isize, "a bit too far"); 752 753 /* Make sure that we always have enough lookahead, except 754 * at the end of the input file. We need MAX_MATCH bytes 755 * for the next match, plus MIN_MATCH bytes to insert the 756 * string following the next match. 757 */ 758 while (lookahead < MIN_LOOKAHEAD && !eofile) fill_window(); 759 } 760 if (match_available) ct_tally (0, window[strstart-1]); 761 762 return FLUSH_BLOCK(1); /* eof */ 763} 764