![[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.