![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to deflate.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [MW Coherent from dump] / coherent / g / usr / bin / gzip|
Return to deflate.c CVS log | Up to [MW Coherent from dump] / coherent / g / usr / bin / gzip |
1.1 ! root 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 "tailor.h" ! 65: #include "gzip.h" ! 66: #include "lzw.h" /* just for consistency checking */ ! 67: ! 68: #include <stdio.h> ! 69: ! 70: #ifndef lint ! 71: static char rcsid[] = "$Id: deflate.c,v 0.11 1993/02/24 18:23:13 jloup Exp $"; ! 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: ! 128: typedef ush Pos; ! 129: typedef 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: ! 154: ulg 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: ! 159: long block_start; ! 160: /* window position at the beginning of the current output block. Gets ! 161: * negative when the window is moved backwards. ! 162: */ ! 163: ! 164: local 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: ! 173: unsigned 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 */ ! 180: local int eofile; /* flag set at end of input file */ ! 181: local unsigned lookahead; /* number of valid bytes ahead in window */ ! 182: ! 183: unsigned 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: ! 188: local unsigned int max_lazy_match; ! 189: /* Attempt to find a better match only when the current match is strictly ! 190: * smaller than this value. ! 191: */ ! 192: ! 193: int near good_match; ! 194: /* Use a faster search when the previous match is longer than this */ ! 195: ! 196: ! 197: /* Values for max_lazy_match, good_match and max_chain_length, depending on ! 198: * the desired pack level (0..9). The values given below have been tuned to ! 199: * exclude worst case performance for pathological files. Better values may be ! 200: * found for specific files. ! 201: */ ! 202: ! 203: typedef struct config { ! 204: ush good_length; /* reduce lazy search above this match length */ ! 205: ush max_lazy; /* do not perform lazy search above this match length */ ! 206: ush nice_length; /* quit search above this match length */ ! 207: ush max_chain; ! 208: } config; ! 209: ! 210: #ifdef FULL_SEARCH ! 211: # define nice_match MAX_MATCH ! 212: #else ! 213: int near nice_match; /* Stop searching when current match exceeds this */ ! 214: #endif ! 215: ! 216: local config configuration_table[10] = { ! 217: /* good lazy nice chain */ ! 218: /* 0 */ {0, 0, 0, 0}, /* store only */ ! 219: /* 1 */ {4, 4, 16, 16}, /* maximum speed */ ! 220: /* 2 */ {6, 8, 16, 16}, ! 221: /* 3 */ {8, 16, 32, 32}, ! 222: /* 4 */ {8, 16, 64, 64}, ! 223: /* 5 */ {8, 16, 128, 128}, ! 224: /* 6 */ {8, 32, 128, 256}, ! 225: /* 7 */ {8, 64, 128, 512}, ! 226: /* 8 */ {32, 128, 258, 1024}, ! 227: /* 9 */ {32, 258, 258, 4096}}; /* maximum compression */ ! 228: ! 229: /* Note: the current code requires max_lazy >= MIN_MATCH and max_chain >= 4 ! 230: * but these restrictions can easily be removed at a small cost. ! 231: */ ! 232: ! 233: #define EQUAL 0 ! 234: /* result of memcmp for equal strings */ ! 235: ! 236: /* =========================================================================== ! 237: * Prototypes for local functions. ! 238: */ ! 239: local void fill_window OF((void)); ! 240: int longest_match OF((IPos cur_match)); ! 241: #ifdef ASMV ! 242: void match_init OF((void)); /* asm code initialization */ ! 243: #endif ! 244: ! 245: #ifdef DEBUG ! 246: local void check_match OF((IPos start, IPos match, int length)); ! 247: #endif ! 248: ! 249: /* =========================================================================== ! 250: * Update a hash value with the given input byte ! 251: * IN assertion: all calls to to UPDATE_HASH are made with consecutive ! 252: * input characters, so that a running hash key can be computed from the ! 253: * previous key instead of complete recalculation each time. ! 254: */ ! 255: #define UPDATE_HASH(h,c) (h = (((h)<<H_SHIFT) ^ (c)) & HASH_MASK) ! 256: ! 257: /* =========================================================================== ! 258: * Insert string s in the dictionary and set match_head to the previous head ! 259: * of the hash chain (the most recent string with same hash key). Return ! 260: * the previous length of the hash chain. ! 261: * IN assertion: all calls to to INSERT_STRING are made with consecutive ! 262: * input characters and the first MIN_MATCH bytes of s are valid ! 263: * (except for the last MIN_MATCH-1 bytes of the input file). ! 264: */ ! 265: #define INSERT_STRING(s, match_head) \ ! 266: (UPDATE_HASH(ins_h, window[(s) + MIN_MATCH-1]), \ ! 267: prev[(s) & WMASK] = match_head = head[ins_h], \ ! 268: head[ins_h] = (s)) ! 269: ! 270: /* =========================================================================== ! 271: * Initialize the "longest match" routines for a new file ! 272: */ ! 273: void lm_init (pack_level, flags) ! 274: int pack_level; /* 0: store, 1: best speed, 9: best compression */ ! 275: ush *flags; /* general purpose bit flag */ ! 276: { ! 277: register unsigned j; ! 278: ! 279: if (pack_level < 1 || pack_level > 9) error("bad pack level"); ! 280: ! 281: /* Initialize the hash table. */ ! 282: #if defined(MAXSEG_64K) && HASH_BITS == 15 ! 283: for (j = 0; j < HASH_SIZE; j++) head[j] = NIL; ! 284: #else ! 285: memzero(head, HASH_SIZE*sizeof(*head)); ! 286: #endif ! 287: /* prev will be initialized on the fly */ ! 288: ! 289: /* Set the default configuration parameters: ! 290: */ ! 291: max_lazy_match = configuration_table[pack_level].max_lazy; ! 292: good_match = configuration_table[pack_level].good_length; ! 293: #ifndef FULL_SEARCH ! 294: nice_match = configuration_table[pack_level].nice_length; ! 295: #endif ! 296: max_chain_length = configuration_table[pack_level].max_chain; ! 297: if (pack_level == 1) { ! 298: *flags |= FAST; ! 299: } else if (pack_level == 9) { ! 300: *flags |= SLOW; ! 301: } ! 302: /* ??? reduce max_chain_length for binary files */ ! 303: ! 304: strstart = 0; ! 305: block_start = 0L; ! 306: #ifdef ASMV ! 307: match_init(); /* initialize the asm code */ ! 308: #endif ! 309: ! 310: #ifdef MAXSEG_64K ! 311: /* Can't read a 64K block */ ! 312: lookahead = read_buf((char*)window, (unsigned)WSIZE); ! 313: #else ! 314: lookahead = read_buf((char*)window, 2*WSIZE); ! 315: #endif ! 316: if (lookahead == 0 || lookahead == (unsigned)EOF) { ! 317: eofile = 1, lookahead = 0; ! 318: return; ! 319: } ! 320: eofile = 0; ! 321: /* Make sure that we always have enough lookahead. This is important ! 322: * if input comes from a device such as a tty. ! 323: */ ! 324: while (lookahead < MIN_LOOKAHEAD && !eofile) fill_window(); ! 325: ! 326: ins_h = 0; ! 327: for (j=0; j<MIN_MATCH-1; j++) UPDATE_HASH(ins_h, window[j]); ! 328: /* If lookahead < MIN_MATCH, ins_h is garbage, but this is ! 329: * not important since only literal bytes will be emitted. ! 330: */ ! 331: } ! 332: ! 333: /* =========================================================================== ! 334: * Set match_start to the longest match starting at the given string and ! 335: * return its length. Matches shorter or equal to prev_length are discarded, ! 336: * in which case the result is equal to prev_length and match_start is ! 337: * garbage. ! 338: * IN assertions: cur_match is the head of the hash chain for the current ! 339: * string (strstart) and its distance is <= MAX_DIST, and prev_length >= 1 ! 340: */ ! 341: #ifndef ASMV ! 342: /* For MSDOS, OS/2 and 386 Unix, an optimized version is in match.asm or ! 343: * match.s. The code is functionally equivalent, so you can use the C version ! 344: * if desired. ! 345: */ ! 346: int longest_match(cur_match) ! 347: IPos cur_match; /* current match */ ! 348: { ! 349: unsigned chain_length = max_chain_length; /* max hash chain length */ ! 350: register uch *scan = window + strstart; /* current string */ ! 351: register uch *match; /* matched string */ ! 352: register int len; /* length of current match */ ! 353: int best_len = prev_length; /* best match length so far */ ! 354: IPos limit = strstart > (IPos)MAX_DIST ? strstart - (IPos)MAX_DIST : NIL; ! 355: /* Stop when cur_match becomes <= limit. To simplify the code, ! 356: * we prevent matches with the string of window index 0. ! 357: */ ! 358: ! 359: /* The code is optimized for HASH_BITS >= 8 and MAX_MATCH-2 multiple of 16. ! 360: * It is easy to get rid of this optimization if necessary. ! 361: */ ! 362: #if HASH_BITS < 8 || MAX_MATCH != 258 ! 363: error: Code too clever ! 364: #endif ! 365: ! 366: #ifdef UNALIGNED_OK ! 367: /* Compare two bytes at a time. Note: this is not always beneficial. ! 368: * Try with and without -DUNALIGNED_OK to check. ! 369: */ ! 370: register uch *strend = window + strstart + MAX_MATCH - 1; ! 371: register ush scan_start = *(ush*)scan; ! 372: register ush scan_end = *(ush*)(scan+best_len-1); ! 373: #else ! 374: register uch *strend = window + strstart + MAX_MATCH; ! 375: register uch scan_end1 = scan[best_len-1]; ! 376: register uch scan_end = scan[best_len]; ! 377: #endif ! 378: ! 379: /* Do not waste too much time if we already have a good match: */ ! 380: if (prev_length >= good_match) { ! 381: chain_length >>= 2; ! 382: } ! 383: Assert(strstart <= window_size-MIN_LOOKAHEAD, "insufficient lookahead"); ! 384: ! 385: do { ! 386: Assert(cur_match < strstart, "no future"); ! 387: match = window + cur_match; ! 388: ! 389: /* Skip to next match if the match length cannot increase ! 390: * or if the match length is less than 2: ! 391: */ ! 392: #if (defined(UNALIGNED_OK) && MAX_MATCH == 258) ! 393: /* This code assumes sizeof(unsigned short) == 2. Do not use ! 394: * UNALIGNED_OK if your compiler uses a different size. ! 395: */ ! 396: if (*(ush*)(match+best_len-1) != scan_end || ! 397: *(ush*)match != scan_start) continue; ! 398: ! 399: /* It is not necessary to compare scan[2] and match[2] since they are ! 400: * always equal when the other bytes match, given that the hash keys ! 401: * are equal and that HASH_BITS >= 8. Compare 2 bytes at a time at ! 402: * strstart+3, +5, ... up to strstart+257. We check for insufficient ! 403: * lookahead only every 4th comparison; the 128th check will be made ! 404: * at strstart+257. If MAX_MATCH-2 is not a multiple of 8, it is ! 405: * necessary to put more guard bytes at the end of the window, or ! 406: * to check more often for insufficient lookahead. ! 407: */ ! 408: scan++, match++; ! 409: do { ! 410: } while (*(ush*)(scan+=2) == *(ush*)(match+=2) && ! 411: *(ush*)(scan+=2) == *(ush*)(match+=2) && ! 412: *(ush*)(scan+=2) == *(ush*)(match+=2) && ! 413: *(ush*)(scan+=2) == *(ush*)(match+=2) && ! 414: scan < strend); ! 415: /* The funny "do {}" generates better code on most compilers */ ! 416: ! 417: /* Here, scan <= window+strstart+257 */ ! 418: Assert(scan <= window+(unsigned)(window_size-1), "wild scan"); ! 419: if (*scan == *match) scan++; ! 420: ! 421: len = (MAX_MATCH - 1) - (int)(strend-scan); ! 422: scan = strend - (MAX_MATCH-1); ! 423: ! 424: #else /* UNALIGNED_OK */ ! 425: ! 426: if (match[best_len] != scan_end || ! 427: match[best_len-1] != scan_end1 || ! 428: *match != *scan || ! 429: *++match != scan[1]) continue; ! 430: ! 431: /* The check at best_len-1 can be removed because it will be made ! 432: * again later. (This heuristic is not always a win.) ! 433: * It is not necessary to compare scan[2] and match[2] since they ! 434: * are always equal when the other bytes match, given that ! 435: * the hash keys are equal and that HASH_BITS >= 8. ! 436: */ ! 437: scan += 2, match++; ! 438: ! 439: /* We check for insufficient lookahead only every 8th comparison; ! 440: * the 256th check will be made at strstart+258. ! 441: */ ! 442: do { ! 443: } while (*++scan == *++match && *++scan == *++match && ! 444: *++scan == *++match && *++scan == *++match && ! 445: *++scan == *++match && *++scan == *++match && ! 446: *++scan == *++match && *++scan == *++match && ! 447: scan < strend); ! 448: ! 449: len = MAX_MATCH - (int)(strend - scan); ! 450: scan = strend - MAX_MATCH; ! 451: ! 452: #endif /* UNALIGNED_OK */ ! 453: ! 454: if (len > best_len) { ! 455: match_start = cur_match; ! 456: best_len = len; ! 457: if (len >= nice_match) break; ! 458: #ifdef UNALIGNED_OK ! 459: scan_end = *(ush*)(scan+best_len-1); ! 460: #else ! 461: scan_end1 = scan[best_len-1]; ! 462: scan_end = scan[best_len]; ! 463: #endif ! 464: } ! 465: } while ((cur_match = prev[cur_match & WMASK]) > limit ! 466: && --chain_length != 0); ! 467: ! 468: return best_len; ! 469: } ! 470: #endif /* ASMV */ ! 471: ! 472: #ifdef DEBUG ! 473: /* =========================================================================== ! 474: * Check that the match at match_start is indeed a match. ! 475: */ ! 476: local void check_match(start, match, length) ! 477: IPos start, match; ! 478: int length; ! 479: { ! 480: /* check that the match is indeed a match */ ! 481: if (memcmp((char*)window + match, ! 482: (char*)window + start, length) != EQUAL) { ! 483: fprintf(stderr, ! 484: " start %d, match %d, length %d\n", ! 485: start, match, length); ! 486: error("invalid match"); ! 487: } ! 488: if (verbose > 1) { ! 489: fprintf(stderr,"\\[%d,%d]", start-match, length); ! 490: do { putc(window[start++], stderr); } while (--length != 0); ! 491: } ! 492: } ! 493: #else ! 494: # define check_match(start, match, length) ! 495: #endif ! 496: ! 497: /* =========================================================================== ! 498: * Fill the window when the lookahead becomes insufficient. ! 499: * Updates strstart and lookahead, and sets eofile if end of input file. ! 500: * IN assertion: lookahead < MIN_LOOKAHEAD && strstart + lookahead > 0 ! 501: * OUT assertions: at least one byte has been read, or eofile is set; ! 502: * file reads are performed for at least two bytes (required for the ! 503: * translate_eol option). ! 504: */ ! 505: local void fill_window() ! 506: { ! 507: register unsigned n, m; ! 508: unsigned more = (unsigned)(window_size - (ulg)lookahead - (ulg)strstart); ! 509: /* Amount of free space at the end of the window. */ ! 510: ! 511: /* If the window is almost full and there is insufficient lookahead, ! 512: * move the upper half to the lower one to make room in the upper half. ! 513: */ ! 514: if (more == (unsigned)EOF) { ! 515: /* Very unlikely, but possible on 16 bit machine if strstart == 0 ! 516: * and lookahead == 1 (input done one byte at time) ! 517: */ ! 518: more--; ! 519: } else if (strstart >= WSIZE+MAX_DIST) { ! 520: /* By the IN assertion, the window is not empty so we can't confuse ! 521: * more == 0 with more == 64K on a 16 bit machine. ! 522: */ ! 523: Assert(window_size == (ulg)2*WSIZE, "no sliding with BIG_MEM"); ! 524: ! 525: memcpy((char*)window, (char*)window+WSIZE, (unsigned)WSIZE); ! 526: match_start -= WSIZE; ! 527: strstart -= WSIZE; /* we now have strstart >= MAX_DIST: */ ! 528: ! 529: block_start -= (long) WSIZE; ! 530: ! 531: for (n = 0; n < HASH_SIZE; n++) { ! 532: m = head[n]; ! 533: head[n] = (Pos)(m >= WSIZE ? m-WSIZE : NIL); ! 534: } ! 535: for (n = 0; n < WSIZE; n++) { ! 536: m = prev[n]; ! 537: prev[n] = (Pos)(m >= WSIZE ? m-WSIZE : NIL); ! 538: /* If n is not on any hash chain, prev[n] is garbage but ! 539: * its value will never be used. ! 540: */ ! 541: } ! 542: more += WSIZE; ! 543: } ! 544: /* At this point, more >= 2 */ ! 545: if (!eofile) { ! 546: n = read_buf((char*)window+strstart+lookahead, more); ! 547: if (n == 0 || n == (unsigned)EOF) { ! 548: eofile = 1; ! 549: } else { ! 550: lookahead += n; ! 551: } ! 552: } ! 553: } ! 554: ! 555: /* =========================================================================== ! 556: * Flush the current block, with given end-of-file flag. ! 557: * IN assertion: strstart is set to the end of the current match. ! 558: */ ! 559: #define FLUSH_BLOCK(eof) \ ! 560: flush_block(block_start >= 0L ? (char*)&window[(unsigned)block_start] : \ ! 561: (char*)NULL, (long)strstart - block_start, (eof)) ! 562: ! 563: /* =========================================================================== ! 564: * Processes a new input file and return its compressed length. ! 565: */ ! 566: #ifdef NO_LAZY ! 567: ulg deflate() ! 568: { ! 569: IPos hash_head; /* head of the hash chain */ ! 570: int flush; /* set if current block must be flushed */ ! 571: unsigned match_length = 0; /* length of best match */ ! 572: ! 573: prev_length = MIN_MATCH-1; ! 574: while (lookahead != 0) { ! 575: /* Insert the string window[strstart .. strstart+2] in the ! 576: * dictionary, and set hash_head to the head of the hash chain: ! 577: */ ! 578: INSERT_STRING(strstart, hash_head); ! 579: ! 580: /* Find the longest match, discarding those <= prev_length. ! 581: * At this point we have always match_length < MIN_MATCH ! 582: */ ! 583: if (hash_head != NIL && strstart - hash_head <= MAX_DIST) { ! 584: /* To simplify the code, we prevent matches with the string ! 585: * of window index 0 (in particular we have to avoid a match ! 586: * of the string with itself at the start of the input file). ! 587: */ ! 588: match_length = longest_match (hash_head); ! 589: /* longest_match() sets match_start */ ! 590: if (match_length > lookahead) match_length = lookahead; ! 591: } ! 592: if (match_length >= MIN_MATCH) { ! 593: check_match(strstart, match_start, match_length); ! 594: ! 595: flush = ct_tally(strstart-match_start, match_length - MIN_MATCH); ! 596: ! 597: lookahead -= match_length; ! 598: match_length--; /* string at strstart already in hash table */ ! 599: do { ! 600: strstart++; ! 601: INSERT_STRING(strstart, hash_head); ! 602: /* strstart never exceeds WSIZE-MAX_MATCH, so there are ! 603: * always MIN_MATCH bytes ahead. If lookahead < MIN_MATCH ! 604: * these bytes are garbage, but it does not matter since the ! 605: * next lookahead bytes will always be emitted as literals. ! 606: */ ! 607: } while (--match_length != 0); ! 608: } else { ! 609: /* No match, output a literal byte */ ! 610: flush = ct_tally (0, window[strstart]); ! 611: lookahead--; ! 612: } ! 613: strstart++; ! 614: if (flush) FLUSH_BLOCK(0), block_start = strstart; ! 615: ! 616: /* Make sure that we always have enough lookahead, except ! 617: * at the end of the input file. We need MAX_MATCH bytes ! 618: * for the next match, plus MIN_MATCH bytes to insert the ! 619: * string following the next match. ! 620: */ ! 621: while (lookahead < MIN_LOOKAHEAD && !eofile) fill_window(); ! 622: ! 623: } ! 624: return FLUSH_BLOCK(1); /* eof */ ! 625: } ! 626: #else /* LAZY */ ! 627: /* =========================================================================== ! 628: * Same as above, but achieves better compression. We use a lazy ! 629: * evaluation for matches: a match is finally adopted only if there is ! 630: * no better match at the next window position. ! 631: */ ! 632: ulg deflate() ! 633: { ! 634: IPos hash_head; /* head of hash chain */ ! 635: IPos prev_match; /* previous match */ ! 636: int flush; /* set if current block must be flushed */ ! 637: int match_available = 0; /* set if previous match exists */ ! 638: register unsigned match_length = MIN_MATCH-1; /* length of best match */ ! 639: #ifdef DEBUG ! 640: extern long isize; /* byte length of input file, for debug only */ ! 641: #endif ! 642: ! 643: /* Process the input block. */ ! 644: while (lookahead != 0) { ! 645: /* Insert the string window[strstart .. strstart+2] in the ! 646: * dictionary, and set hash_head to the head of the hash chain: ! 647: */ ! 648: INSERT_STRING(strstart, hash_head); ! 649: ! 650: /* Find the longest match, discarding those <= prev_length. ! 651: */ ! 652: prev_length = match_length, prev_match = match_start; ! 653: match_length = MIN_MATCH-1; ! 654: ! 655: if (hash_head != NIL && prev_length < max_lazy_match && ! 656: strstart - hash_head <= MAX_DIST) { ! 657: /* To simplify the code, we prevent matches with the string ! 658: * of window index 0 (in particular we have to avoid a match ! 659: * of the string with itself at the start of the input file). ! 660: */ ! 661: match_length = longest_match (hash_head); ! 662: /* longest_match() sets match_start */ ! 663: if (match_length > lookahead) match_length = lookahead; ! 664: ! 665: /* Ignore a length 3 match if it is too distant: */ ! 666: if (match_length == MIN_MATCH && strstart-match_start > TOO_FAR){ ! 667: /* If prev_match is also MIN_MATCH, match_start is garbage ! 668: * but we will ignore the current match anyway. ! 669: */ ! 670: match_length--; ! 671: } ! 672: } ! 673: /* If there was a match at the previous step and the current ! 674: * match is not better, output the previous match: ! 675: */ ! 676: if (prev_length >= MIN_MATCH && match_length <= prev_length) { ! 677: ! 678: check_match(strstart-1, prev_match, prev_length); ! 679: ! 680: flush = ct_tally(strstart-1-prev_match, prev_length - MIN_MATCH); ! 681: ! 682: /* Insert in hash table all strings up to the end of the match. ! 683: * strstart-1 and strstart are already inserted. ! 684: */ ! 685: lookahead -= prev_length-1; ! 686: prev_length -= 2; ! 687: do { ! 688: strstart++; ! 689: INSERT_STRING(strstart, hash_head); ! 690: /* strstart never exceeds WSIZE-MAX_MATCH, so there are ! 691: * always MIN_MATCH bytes ahead. If lookahead < MIN_MATCH ! 692: * these bytes are garbage, but it does not matter since the ! 693: * next lookahead bytes will always be emitted as literals. ! 694: */ ! 695: } while (--prev_length != 0); ! 696: match_available = 0; ! 697: match_length = MIN_MATCH-1; ! 698: strstart++; ! 699: if (flush) FLUSH_BLOCK(0), block_start = strstart; ! 700: ! 701: } else if (match_available) { ! 702: /* If there was no match at the previous position, output a ! 703: * single literal. If there was a match but the current match ! 704: * is longer, truncate the previous match to a single literal. ! 705: */ ! 706: Tracevv((stderr,"%c",window[strstart-1])); ! 707: if (ct_tally (0, window[strstart-1])) { ! 708: FLUSH_BLOCK(0), block_start = strstart; ! 709: } ! 710: strstart++; ! 711: lookahead--; ! 712: } else { ! 713: /* There is no previous match to compare with, wait for ! 714: * the next step to decide. ! 715: */ ! 716: match_available = 1; ! 717: strstart++; ! 718: lookahead--; ! 719: } ! 720: Assert (strstart <= isize && lookahead <= isize, "a bit too far"); ! 721: ! 722: /* Make sure that we always have enough lookahead, except ! 723: * at the end of the input file. We need MAX_MATCH bytes ! 724: * for the next match, plus MIN_MATCH bytes to insert the ! 725: * string following the next match. ! 726: */ ! 727: while (lookahead < MIN_LOOKAHEAD && !eofile) fill_window(); ! 728: } ! 729: if (match_available) ct_tally (0, window[strstart-1]); ! 730: ! 731: return FLUSH_BLOCK(1); /* eof */ ! 732: } ! 733: #endif /* LAZY */
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.