1 /* vi: set sw=4 ts=4: */
3 * Gzip implementation for busybox
5 * Based on GNU gzip Copyright (C) 1992-1993 Jean-loup Gailly.
7 * Originally adjusted for busybox by Charles P. Wright <cpw@unix.asb.com>
8 * "this is a stripped down version of gzip I put into busybox, it does
9 * only standard in to standard out with -9 compression. It also requires
10 * the zcat module for some important functions."
12 * Adjusted further by Erik Andersen <andersen@codepoet.org> to support
13 * files as well as stdin/stdout, and to generally behave itself wrt
14 * command line handling.
16 * Licensed under GPLv2 or later, see file LICENSE in this tarball for details.
19 /* big objects in bss:
21 * 00000074 b base_length
22 * 00000078 b base_dist
23 * 00000078 b static_dtree
25 * 000000f4 b dyn_dtree
26 * 00000100 b length_code
27 * 00000200 b dist_code
30 * 00000480 b static_ltree
31 * 000008f4 b dyn_ltree
35 /* TODO: full support for -v for DESKTOP
36 /usr/bin/gzip -v a bogus aa
37 a: 85.1% -- replaced with a.gz
38 gzip: bogus: No such file or directory
39 aa: 85.1% -- replaced with aa.gz
45 /* ===========================================================================
48 /* Diagnostic functions */
50 # define Assert(cond,msg) {if(!(cond)) bb_error_msg(msg);}
51 # define Trace(x) fprintf x
52 # define Tracev(x) {if (verbose) fprintf x ;}
53 # define Tracevv(x) {if (verbose > 1) fprintf x ;}
54 # define Tracec(c,x) {if (verbose && (c)) fprintf x ;}
55 # define Tracecv(c,x) {if (verbose > 1 && (c)) fprintf x ;}
57 # define Assert(cond,msg)
66 /* ===========================================================================
70 /* Compression methods (see algorithm.doc) */
71 /* Only STORED and DEFLATED are supported by this BusyBox module */
73 /* methods 4 to 7 reserved */
78 # define INBUFSIZ 0x2000 /* input buffer size */
80 # define INBUFSIZ 0x8000 /* input buffer size */
85 #define INBUF_EXTRA 64 /* required by unlzw() */
89 # define OUTBUFSIZ 8192 /* output buffer size */
91 # define OUTBUFSIZ 16384 /* output buffer size */
95 #define OUTBUF_EXTRA 2048 /* required by unlzw() */
99 # define DIST_BUFSIZE 0x2000 /* buffer for distances, see trees.c */
101 # define DIST_BUFSIZE 0x8000 /* buffer for distances, see trees.c */
106 #define ASCII_FLAG 0x01 /* bit 0 set: file probably ascii text */
107 #define CONTINUATION 0x02 /* bit 1 set: continuation of multi-part gzip file */
108 #define EXTRA_FIELD 0x04 /* bit 2 set: extra field present */
109 #define ORIG_NAME 0x08 /* bit 3 set: original file name present */
110 #define COMMENT 0x10 /* bit 4 set: file comment present */
111 #define RESERVED 0xC0 /* bit 6,7: reserved */
113 /* internal file attribute */
114 #define UNKNOWN 0xffff
119 # define WSIZE 0x8000 /* window size--must be a power of two, and */
120 #endif /* at least 32K for zip's deflate method */
123 #define MAX_MATCH 258
124 /* The minimum and maximum match lengths */
126 #define MIN_LOOKAHEAD (MAX_MATCH+MIN_MATCH+1)
127 /* Minimum amount of lookahead, except at the end of the input file.
128 * See deflate.c for comments about the MIN_MATCH+1.
131 #define MAX_DIST (WSIZE-MIN_LOOKAHEAD)
132 /* In order to simplify the code, particularly on 16 bit machines, match
133 * distances are limited to MAX_DIST instead of WSIZE.
137 # define MAX_PATH_LEN 1024 /* max pathname length */
140 #define seekable() 0 /* force sequential output */
141 #define translate_eol 0 /* no option -a yet */
146 #define INIT_BITS 9 /* Initial number of bits per code */
148 #define BIT_MASK 0x1f /* Mask for 'number of compression bits' */
149 /* Mask 0x20 is reserved to mean a fourth header byte, and 0x40 is free.
150 * It's a pity that old uncompress does not check bit 0x20. That makes
151 * extension of the format actually undesirable because old compress
152 * would just crash on the new format instead of giving a meaningful
153 * error message. It does check the number of bits, but it's more
154 * helpful to say "unsupported format, get a new version" than
155 * "can only handle 16 bits".
159 # define MAX_SUFFIX MAX_EXT_CHARS
161 # define MAX_SUFFIX 30
165 /* ===========================================================================
166 * Compile with MEDIUM_MEM to reduce the memory requirements or
167 * with SMALL_MEM to use as little memory as possible. Use BIG_MEM if the
168 * entire input file can be held in memory (not possible on 16 bit systems).
169 * Warning: defining these symbols affects HASH_BITS (see below) and thus
170 * affects the compression ratio. The compressed output
171 * is still correct, and might even be smaller in some cases.
175 # define HASH_BITS 13 /* Number of bits used to hash strings */
178 # define HASH_BITS 14
181 # define HASH_BITS 15
182 /* For portability to 16 bit machines, do not use values above 15. */
185 #define HASH_SIZE (unsigned)(1<<HASH_BITS)
186 #define HASH_MASK (HASH_SIZE-1)
187 #define WMASK (WSIZE-1)
188 /* HASH_SIZE and WSIZE must be powers of two */
190 # define TOO_FAR 4096
192 /* Matches of length 3 are discarded if their distance exceeds TOO_FAR */
195 /* ===========================================================================
196 * These types are not really 'char', 'short' and 'long'
199 typedef uint16_t ush;
200 typedef uint32_t ulg;
201 typedef uint32_t lng;
204 /* ===========================================================================
205 * Local data used by the "longest match" routines.
208 typedef unsigned IPos;
210 /* A Pos is an index in the character window. We use short instead of int to
211 * save space in the various tables. IPos is used only for parameter passing.
214 #define DECLARE(type, array, size) \
216 #define ALLOC(type, array, size) { \
217 array = xzalloc((size_t)(((size)+1L)/2) * 2*sizeof(type)); \
220 #define FREE(array) \
226 static lng block_start;
228 /* window position at the beginning of the current output block. Gets
229 * negative when the window is moved backwards.
232 static unsigned ins_h; /* hash index of string to be inserted */
234 #define H_SHIFT ((HASH_BITS+MIN_MATCH-1)/MIN_MATCH)
235 /* Number of bits by which ins_h and del_h must be shifted at each
236 * input step. It must be such that after MIN_MATCH steps, the oldest
237 * byte no longer takes part in the hash key, that is:
238 * H_SHIFT * MIN_MATCH >= HASH_BITS
241 static unsigned int prev_length;
243 /* Length of the best match at previous step. Matches not greater than this
244 * are discarded. This is used in the lazy match evaluation.
247 static unsigned strstart; /* start of string to insert */
248 static unsigned match_start; /* start of matching string */
249 static int eofile; /* flag set at end of input file */
250 static unsigned lookahead; /* number of valid bytes ahead in window */
253 WINDOW_SIZE = 2 * WSIZE,
254 /* window size, 2*WSIZE except for MMAP or BIG_MEM, where it is the
255 * input file length plus MIN_LOOKAHEAD.
258 max_chain_length = 4096,
259 /* To speed up deflation, hash chains are never searched beyond this length.
260 * A higher limit improves compression ratio but degrades the speed.
263 max_lazy_match = 258,
264 /* Attempt to find a better match only when the current match is strictly
265 * smaller than this value. This mechanism is used only for compression
269 max_insert_length = max_lazy_match,
270 /* Insert new strings in the hash table only if the match length
271 * is not greater than this length. This saves time but degrades compression.
272 * max_insert_length is used only for compression levels <= 3.
276 /* Use a faster search when the previous match is longer than this */
278 /* Values for max_lazy_match, good_match and max_chain_length, depending on
279 * the desired pack level (0..9). The values given below have been tuned to
280 * exclude worst case performance for pathological files. Better values may be
281 * found for specific files.
284 nice_match = 258 /* Stop searching when current match exceeds this */
285 /* Note: the deflate() code requires max_lazy >= MIN_MATCH and max_chain >= 4
286 * For deflate_fast() (levels <= 3) good is ignored and lazy has a different
294 /* To save memory for 16 bit systems, some arrays are overlaid between
295 * the various modules:
296 * deflate: prev+head window d_buf l_buf outbuf
297 * unlzw: tab_prefix tab_suffix stack inbuf outbuf
299 * For compression, input is done in window[]. For decompression, output
300 * is done in window except for unlzw.
302 /* To save space (see unlzw.c), we overlay prev+head with tab_prefix and
303 * window with tab_suffix. Check that we can do this:
305 #if (WSIZE<<1) > (1<<BITS)
306 # error cannot overlay window with tab_suffix and prev with tab_prefix0
308 #if HASH_BITS > BITS-1
309 # error cannot overlay head with tab_prefix1
312 //#define tab_suffix window
313 //#define tab_prefix prev /* hash link (see deflate.c) */
314 #define head (prev+WSIZE) /* hash head (see deflate.c) */
316 /* DECLARE(uch, window, 2L*WSIZE); */
317 /* Sliding window. Input bytes are read into the second half of the window,
318 * and move to the first half later to keep a dictionary of at least WSIZE
319 * bytes. With this organization, matches are limited to a distance of
320 * WSIZE-MAX_MATCH bytes, but this ensures that IO is always
321 * performed with a length multiple of the block size. Also, it limits
322 * the window size to 64K, which is quite useful on MSDOS.
323 * To do: limit the window size to WSIZE+BSZ if SMALL_MEM (the code would
324 * be less efficient).
327 /* DECLARE(Pos, prev, WSIZE); */
328 /* Link to older string with same hash index. To limit the size of this
329 * array to 64K, this link is maintained only for the last 32K strings.
330 * An index in this array is thus a window index modulo 32K.
333 /* DECLARE(Pos, head, 1<<HASH_BITS); */
334 /* Heads of the hash chains or 0. */
336 DECLARE(uch, inbuf, INBUFSIZ + INBUF_EXTRA); //remove + XX_EXTRA (unlzw)??
337 DECLARE(uch, outbuf, OUTBUFSIZ + OUTBUF_EXTRA);
338 DECLARE(ush, d_buf, DIST_BUFSIZE);
339 DECLARE(uch, window, 2L * WSIZE);
340 DECLARE(ush, prev, 1L << BITS);
342 /* number of input bytes */
343 static ulg isize; /* only 32 bits stored in .gz file */
345 static int foreground; /* set if program run in foreground */
346 static int method = DEFLATED; /* compression method */
347 static int exit_code; /* program exit code */
349 /* original time stamp (modification time) */
350 static ulg time_stamp; /* only 32 bits stored in .gz file */
351 ////static char z_suffix[MAX_SUFFIX + 1]; /* default suffix (can be set with --suffix) */
353 static int ifd; /* input file descriptor */
354 static int ofd; /* output file descriptor */
356 static unsigned insize; /* valid bytes in inbuf */
358 static unsigned outcnt; /* bytes in output buffer */
360 static uint32_t *crc_32_tab;
363 /* ===========================================================================
364 * Local data used by the "bit string" routines.
367 static int zfile; /* output gzip file */
369 static unsigned short bi_buf;
371 /* Output buffer. bits are inserted starting at the bottom (least significant
376 #define BUF_SIZE (8 * sizeof(bi_buf))
377 /* Number of bits used within bi_buf. (bi_buf might be implemented on
378 * more than 16 bits on some systems.)
383 /* Current input function. Set to mem_read for in-memory compression */
386 static ulg bits_sent; /* bit length of the compressed data */
390 /* ===========================================================================
391 * Write the output buffer outbuf[0..outcnt-1] and update bytes_out.
392 * (used for the compressed data only)
394 static void flush_outbuf(void)
399 xwrite(ofd, (char *) outbuf, outcnt);
404 /* ===========================================================================
406 /* put_8bit is used for the compressed output */
407 #define put_8bit(c) \
409 outbuf[outcnt++] = (c); \
410 if (outcnt == OUTBUFSIZ) flush_outbuf(); \
413 /* Output a 16 bit value, lsb first */
414 static void put_16bit(ush w)
416 if (outcnt < OUTBUFSIZ - 2) {
417 outbuf[outcnt++] = w;
418 outbuf[outcnt++] = w >> 8;
425 static void put_32bit(ulg n)
431 /* ===========================================================================
432 * Clear input and output buffers
434 static void clear_bufs(void)
444 /* ===========================================================================
445 * Run a set of bytes through the crc shift register. If s is a NULL
446 * pointer, then initialize the crc shift register contents instead.
447 * Return the current crc in either case.
449 static uint32_t crc; /* shift register contents */
450 static uint32_t updcrc(uch * s, unsigned n)
454 c = crc_32_tab[(uch)(c ^ *s++)] ^ (c >> 8);
462 /* ===========================================================================
463 * Read a new buffer from the current input file, perform end-of-line
464 * translation, and update the crc and input file size.
465 * IN assertion: size >= 2 (for end-of-line translation)
467 static unsigned file_read(void *buf, unsigned size)
471 Assert(insize == 0, "inbuf not empty");
473 len = safe_read(ifd, buf, size);
474 if (len == (unsigned)(-1) || len == 0)
483 /* ===========================================================================
484 * Send a value on a given number of bits.
485 * IN assertion: length <= 16 and value fits in length bits.
487 static void send_bits(int value, int length)
490 Tracev((stderr, " l %2d v %4x ", length, value));
491 Assert(length > 0 && length <= 15, "invalid length");
494 /* If not enough room in bi_buf, use (valid) bits from bi_buf and
495 * (16 - bi_valid) bits from value, leaving (width - (16-bi_valid))
496 * unused bits in value.
498 if (bi_valid > (int) BUF_SIZE - length) {
499 bi_buf |= (value << bi_valid);
501 bi_buf = (ush) value >> (BUF_SIZE - bi_valid);
502 bi_valid += length - BUF_SIZE;
504 bi_buf |= value << bi_valid;
510 /* ===========================================================================
511 * Reverse the first len bits of a code, using straightforward code (a faster
512 * method would use a table)
513 * IN assertion: 1 <= len <= 15
515 static unsigned bi_reverse(unsigned code, int len)
521 if (--len <= 0) return res;
528 /* ===========================================================================
529 * Write out any remaining bits in an incomplete byte.
531 static void bi_windup(void)
535 } else if (bi_valid > 0) {
541 bits_sent = (bits_sent + 7) & ~7;
546 /* ===========================================================================
547 * Copy a stored block to the zip file, storing first the length and its
548 * one's complement if requested.
550 static void copy_block(char *buf, unsigned len, int header)
552 bi_windup(); /* align on byte boundary */
562 bits_sent += (ulg) len << 3;
570 /* ===========================================================================
571 * Fill the window when the lookahead becomes insufficient.
572 * Updates strstart and lookahead, and sets eofile if end of input file.
573 * IN assertion: lookahead < MIN_LOOKAHEAD && strstart + lookahead > 0
574 * OUT assertions: at least one byte has been read, or eofile is set;
575 * file reads are performed for at least two bytes (required for the
576 * translate_eol option).
578 static void fill_window(void)
581 unsigned more = WINDOW_SIZE - lookahead - strstart;
582 /* Amount of free space at the end of the window. */
584 /* If the window is almost full and there is insufficient lookahead,
585 * move the upper half to the lower one to make room in the upper half.
587 if (more == (unsigned) -1) {
588 /* Very unlikely, but possible on 16 bit machine if strstart == 0
589 * and lookahead == 1 (input done one byte at time)
592 } else if (strstart >= WSIZE + MAX_DIST) {
593 /* By the IN assertion, the window is not empty so we can't confuse
594 * more == 0 with more == 64K on a 16 bit machine.
596 Assert(WINDOW_SIZE == 2 * WSIZE, "no sliding with BIG_MEM");
598 memcpy(window, window + WSIZE, WSIZE);
599 match_start -= WSIZE;
600 strstart -= WSIZE; /* we now have strstart >= MAX_DIST: */
602 block_start -= WSIZE;
604 for (n = 0; n < HASH_SIZE; n++) {
606 head[n] = (Pos) (m >= WSIZE ? m - WSIZE : 0);
608 for (n = 0; n < WSIZE; n++) {
610 prev[n] = (Pos) (m >= WSIZE ? m - WSIZE : 0);
611 /* If n is not on any hash chain, prev[n] is garbage but
612 * its value will never be used.
617 /* At this point, more >= 2 */
619 n = file_read(window + strstart + lookahead, more);
620 if (n == 0 || n == (unsigned) -1) {
629 /* ===========================================================================
630 * Set match_start to the longest match starting at the given string and
631 * return its length. Matches shorter or equal to prev_length are discarded,
632 * in which case the result is equal to prev_length and match_start is
634 * IN assertions: cur_match is the head of the hash chain for the current
635 * string (strstart) and its distance is <= MAX_DIST, and prev_length >= 1
638 /* For MSDOS, OS/2 and 386 Unix, an optimized version is in match.asm or
639 * match.s. The code is functionally equivalent, so you can use the C version
642 static int longest_match(IPos cur_match)
644 unsigned chain_length = max_chain_length; /* max hash chain length */
645 uch *scan = window + strstart; /* current string */
646 uch *match; /* matched string */
647 int len; /* length of current match */
648 int best_len = prev_length; /* best match length so far */
649 IPos limit = strstart > (IPos) MAX_DIST ? strstart - (IPos) MAX_DIST : 0;
650 /* Stop when cur_match becomes <= limit. To simplify the code,
651 * we prevent matches with the string of window index 0.
654 /* The code is optimized for HASH_BITS >= 8 and MAX_MATCH-2 multiple of 16.
655 * It is easy to get rid of this optimization if necessary.
657 #if HASH_BITS < 8 || MAX_MATCH != 258
658 # error Code too clever
660 uch *strend = window + strstart + MAX_MATCH;
661 uch scan_end1 = scan[best_len - 1];
662 uch scan_end = scan[best_len];
664 /* Do not waste too much time if we already have a good match: */
665 if (prev_length >= good_match) {
668 Assert(strstart <= WINDOW_SIZE - MIN_LOOKAHEAD, "insufficient lookahead");
671 Assert(cur_match < strstart, "no future");
672 match = window + cur_match;
674 /* Skip to next match if the match length cannot increase
675 * or if the match length is less than 2:
677 if (match[best_len] != scan_end ||
678 match[best_len - 1] != scan_end1 ||
679 *match != *scan || *++match != scan[1])
682 /* The check at best_len-1 can be removed because it will be made
683 * again later. (This heuristic is not always a win.)
684 * It is not necessary to compare scan[2] and match[2] since they
685 * are always equal when the other bytes match, given that
686 * the hash keys are equal and that HASH_BITS >= 8.
690 /* We check for insufficient lookahead only every 8th comparison;
691 * the 256th check will be made at strstart+258.
694 } while (*++scan == *++match && *++scan == *++match &&
695 *++scan == *++match && *++scan == *++match &&
696 *++scan == *++match && *++scan == *++match &&
697 *++scan == *++match && *++scan == *++match && scan < strend);
699 len = MAX_MATCH - (int) (strend - scan);
700 scan = strend - MAX_MATCH;
702 if (len > best_len) {
703 match_start = cur_match;
705 if (len >= nice_match)
707 scan_end1 = scan[best_len - 1];
708 scan_end = scan[best_len];
710 } while ((cur_match = prev[cur_match & WMASK]) > limit
711 && --chain_length != 0);
718 /* ===========================================================================
719 * Check that the match at match_start is indeed a match.
721 static void check_match(IPos start, IPos match, int length)
723 /* check that the match is indeed a match */
724 if (memcmp(window + match, window + start, length) != 0) {
725 bb_error_msg(" start %d, match %d, length %d", start, match, length);
726 bb_error_msg("invalid match");
729 bb_error_msg("\\[%d,%d]", start - match, length);
731 putc(window[start++], stderr);
732 } while (--length != 0);
736 # define check_match(start, match, length) ((void)0)
740 /* trees.c -- output deflated data using Huffman coding
741 * Copyright (C) 1992-1993 Jean-loup Gailly
742 * This is free software; you can redistribute it and/or modify it under the
743 * terms of the GNU General Public License, see the file COPYING.
747 * Encode various sets of source values using variable-length
751 * The PKZIP "deflation" process uses several Huffman trees. The more
752 * common source values are represented by shorter bit sequences.
754 * Each code tree is stored in the ZIP file in a compressed form
755 * which is itself a Huffman encoding of the lengths of
756 * all the code strings (in ascending order by source values).
757 * The actual code strings are reconstructed from the lengths in
758 * the UNZIP process, as described in the "application note"
759 * (APPNOTE.TXT) distributed as part of PKWARE's PKZIP program.
763 * Data Compression: Techniques and Applications, pp. 53-55.
764 * Lifetime Learning Publications, 1985. ISBN 0-534-03418-7.
767 * Data Compression: Methods and Theory, pp. 49-50.
768 * Computer Science Press, 1988. ISBN 0-7167-8156-5.
772 * Addison-Wesley, 1983. ISBN 0-201-06672-6.
775 * void ct_init(ush *attr, int *methodp)
776 * Allocate the match buffer, initialize the various tables and save
777 * the location of the internal file attribute (ascii/binary) and
778 * method (DEFLATE/STORE)
780 * void ct_tally(int dist, int lc);
781 * Save the match info and tally the frequency counts.
783 * ulg flush_block(char *buf, ulg stored_len, int eof)
784 * Determine the best encoding for the current block: dynamic trees,
785 * static trees or store, and output the encoded block to the zip
786 * file. Returns the total compressed length for the file so far.
790 /* All codes must not exceed MAX_BITS bits */
792 #define MAX_BL_BITS 7
793 /* Bit length codes must not exceed MAX_BL_BITS bits */
795 #define LENGTH_CODES 29
796 /* number of length codes, not counting the special END_BLOCK code */
799 /* number of literal bytes 0..255 */
801 #define END_BLOCK 256
802 /* end of block literal code */
804 #define L_CODES (LITERALS+1+LENGTH_CODES)
805 /* number of Literal or Length codes, including the END_BLOCK code */
808 /* number of distance codes */
811 /* number of codes used to transfer the bit lengths */
813 typedef uch extra_bits_t;
815 /* extra bits for each length code */
816 static const extra_bits_t extra_lbits[LENGTH_CODES]= {
817 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 2, 2, 2, 2, 3, 3, 3, 3, 4, 4,
821 /* extra bits for each distance code */
822 static const extra_bits_t extra_dbits[D_CODES] = {
823 0, 0, 0, 0, 1, 1, 2, 2, 3, 3, 4, 4, 5, 5, 6, 6, 7, 7, 8, 8, 9, 9,
824 10, 10, 11, 11, 12, 12, 13, 13
827 /* extra bits for each bit length code */
828 static const extra_bits_t extra_blbits[BL_CODES] = {
829 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 3, 7 };
831 #define STORED_BLOCK 0
832 #define STATIC_TREES 1
834 /* The three kinds of block type */
838 # define LIT_BUFSIZE 0x2000
841 # define LIT_BUFSIZE 0x4000
843 # define LIT_BUFSIZE 0x8000
848 # define DIST_BUFSIZE LIT_BUFSIZE
850 /* Sizes of match buffers for literals/lengths and distances. There are
851 * 4 reasons for limiting LIT_BUFSIZE to 64K:
852 * - frequencies can be kept in 16 bit counters
853 * - if compression is not successful for the first block, all input data is
854 * still in the window so we can still emit a stored block even when input
855 * comes from standard input. (This can also be done for all blocks if
856 * LIT_BUFSIZE is not greater than 32K.)
857 * - if compression is not successful for a file smaller than 64K, we can
858 * even emit a stored file instead of a stored block (saving 5 bytes).
859 * - creating new Huffman trees less frequently may not provide fast
860 * adaptation to changes in the input data statistics. (Take for
861 * example a binary file with poorly compressible code followed by
862 * a highly compressible string table.) Smaller buffer sizes give
863 * fast adaptation but have of course the overhead of transmitting trees
865 * - I can't count above 4
866 * The current code is general and allows DIST_BUFSIZE < LIT_BUFSIZE (to save
867 * memory at the expense of compression). Some optimizations would be possible
868 * if we rely on DIST_BUFSIZE == LIT_BUFSIZE.
870 #if LIT_BUFSIZE > INBUFSIZ
871 #error cannot overlay l_buf and inbuf
874 /* repeat previous bit length 3-6 times (2 bits of repeat count) */
876 /* repeat a zero length 3-10 times (3 bits of repeat count) */
877 #define REPZ_11_138 18
878 /* repeat a zero length 11-138 times (7 bits of repeat count) */
880 /* ===========================================================================
882 /* Data structure describing a single value and its code string. */
883 typedef struct ct_data {
885 ush freq; /* frequency count */
886 ush code; /* bit string */
889 ush dad; /* father node in Huffman tree */
890 ush len; /* length of bit string */
899 #define HEAP_SIZE (2*L_CODES+1)
900 /* maximum heap size */
902 static ct_data dyn_ltree[HEAP_SIZE]; /* literal and length tree */
903 static ct_data dyn_dtree[2 * D_CODES + 1]; /* distance tree */
905 static ct_data static_ltree[L_CODES + 2];
907 /* The static literal tree. Since the bit lengths are imposed, there is no
908 * need for the L_CODES extra codes used during heap construction. However
909 * The codes 286 and 287 are needed to build a canonical tree (see ct_init
913 static ct_data static_dtree[D_CODES];
915 /* The static distance tree. (Actually a trivial tree since all codes use
919 static ct_data bl_tree[2 * BL_CODES + 1];
921 /* Huffman tree for the bit lengths */
923 typedef struct tree_desc {
924 ct_data *dyn_tree; /* the dynamic tree */
925 ct_data *static_tree; /* corresponding static tree or NULL */
926 const extra_bits_t *extra_bits; /* extra bits for each code or NULL */
927 int extra_base; /* base index for extra_bits */
928 int elems; /* max number of elements in the tree */
929 int max_length; /* max bit length for the codes */
930 int max_code; /* largest code with non zero frequency */
933 static tree_desc l_desc = {
934 dyn_ltree, static_ltree, extra_lbits,
935 LITERALS + 1, L_CODES, MAX_BITS, 0
938 static tree_desc d_desc = {
939 dyn_dtree, static_dtree, extra_dbits, 0, D_CODES, MAX_BITS, 0
942 static tree_desc bl_desc = {
943 bl_tree, NULL, extra_blbits, 0, BL_CODES, MAX_BL_BITS, 0
947 static ush bl_count[MAX_BITS + 1];
949 /* number of codes at each bit length for an optimal tree */
951 static const uch bl_order[BL_CODES] = {
952 16, 17, 18, 0, 8, 7, 9, 6, 10, 5, 11, 4, 12, 3, 13, 2, 14, 1, 15
955 /* The lengths of the bit length codes are sent in order of decreasing
956 * probability, to avoid transmitting the lengths for unused bit length codes.
959 static int heap[2 * L_CODES + 1]; /* heap used to build the Huffman trees */
960 static int heap_len; /* number of elements in the heap */
961 static int heap_max; /* element of largest frequency */
963 /* The sons of heap[n] are heap[2*n] and heap[2*n+1]. heap[0] is not used.
964 * The same heap array is used to build all trees.
967 static uch depth[2 * L_CODES + 1];
969 /* Depth of each subtree used as tie breaker for trees of equal frequency */
971 static uch length_code[MAX_MATCH - MIN_MATCH + 1];
973 /* length code for each normalized match length (0 == MIN_MATCH) */
975 static uch dist_code[512];
977 /* distance codes. The first 256 values correspond to the distances
978 * 3 .. 258, the last 256 values correspond to the top 8 bits of
979 * the 15 bit distances.
982 static int base_length[LENGTH_CODES];
984 /* First normalized length for each code (0 = MIN_MATCH) */
986 static int base_dist[D_CODES];
988 /* First normalized distance for each code (0 = distance of 1) */
991 /* DECLARE(uch, l_buf, LIT_BUFSIZE); buffer for literals or lengths */
993 /* DECLARE(ush, d_buf, DIST_BUFSIZE); buffer for distances */
995 static uch flag_buf[LIT_BUFSIZE / 8];
997 /* flag_buf is a bit array distinguishing literals from lengths in
998 * l_buf, thus indicating the presence or absence of a distance.
1001 static unsigned last_lit; /* running index in l_buf */
1002 static unsigned last_dist; /* running index in d_buf */
1003 static unsigned last_flags; /* running index in flag_buf */
1004 static uch flags; /* current flags not yet saved in flag_buf */
1005 static uch flag_bit; /* current bit used in flags */
1007 /* bits are filled in flags starting at bit 0 (least significant).
1008 * Note: these flags are overkill in the current code since we don't
1009 * take advantage of DIST_BUFSIZE == LIT_BUFSIZE.
1012 static ulg opt_len; /* bit length of current block with optimal trees */
1013 static ulg static_len; /* bit length of current block with static trees */
1015 static ulg compressed_len; /* total bit length of compressed file */
1017 static ush *file_type; /* pointer to UNKNOWN, BINARY or ASCII */
1018 static int *file_method; /* pointer to DEFLATE or STORE */
1020 /* ===========================================================================
1022 static void gen_codes(ct_data * tree, int max_code);
1023 static void build_tree(tree_desc * desc);
1024 static void scan_tree(ct_data * tree, int max_code);
1025 static void send_tree(ct_data * tree, int max_code);
1026 static int build_bl_tree(void);
1027 static void send_all_trees(int lcodes, int dcodes, int blcodes);
1028 static void compress_block(ct_data * ltree, ct_data * dtree);
1032 /* Send a code of the given tree. c and tree must not have side effects */
1033 # define SEND_CODE(c, tree) send_bits(tree[c].Code, tree[c].Len)
1035 # define SEND_CODE(c, tree) \
1037 if (verbose > 1) bb_error_msg("\ncd %3d ",(c)); \
1038 send_bits(tree[c].Code, tree[c].Len); \
1042 #define D_CODE(dist) \
1043 ((dist) < 256 ? dist_code[dist] : dist_code[256 + ((dist)>>7)])
1044 /* Mapping from a distance to a distance code. dist is the distance - 1 and
1045 * must not have side effects. dist_code[256] and dist_code[257] are never
1047 * The arguments must not have side effects.
1051 /* ===========================================================================
1052 * Initialize a new block.
1054 static void init_block(void)
1056 int n; /* iterates over tree elements */
1058 /* Initialize the trees. */
1059 for (n = 0; n < L_CODES; n++)
1060 dyn_ltree[n].Freq = 0;
1061 for (n = 0; n < D_CODES; n++)
1062 dyn_dtree[n].Freq = 0;
1063 for (n = 0; n < BL_CODES; n++)
1064 bl_tree[n].Freq = 0;
1066 dyn_ltree[END_BLOCK].Freq = 1;
1067 opt_len = static_len = 0;
1068 last_lit = last_dist = last_flags = 0;
1074 /* ===========================================================================
1075 * Restore the heap property by moving down the tree starting at node k,
1076 * exchanging a node with the smallest of its two sons if necessary, stopping
1077 * when the heap property is re-established (each father smaller than its
1081 /* Compares to subtrees, using the tree depth as tie breaker when
1082 * the subtrees have equal frequency. This minimizes the worst case length. */
1083 #define SMALLER(tree, n, m) \
1084 (tree[n].Freq < tree[m].Freq \
1085 || (tree[n].Freq == tree[m].Freq && depth[n] <= depth[m]))
1087 static void pqdownheap(ct_data * tree, int k)
1090 int j = k << 1; /* left son of k */
1092 while (j <= heap_len) {
1093 /* Set j to the smallest of the two sons: */
1094 if (j < heap_len && SMALLER(tree, heap[j + 1], heap[j]))
1097 /* Exit if v is smaller than both sons */
1098 if (SMALLER(tree, v, heap[j]))
1101 /* Exchange v with the smallest son */
1105 /* And continue down the tree, setting j to the left son of k */
1112 /* ===========================================================================
1113 * Compute the optimal bit lengths for a tree and update the total bit length
1114 * for the current block.
1115 * IN assertion: the fields freq and dad are set, heap[heap_max] and
1116 * above are the tree nodes sorted by increasing frequency.
1117 * OUT assertions: the field len is set to the optimal bit length, the
1118 * array bl_count contains the frequencies for each bit length.
1119 * The length opt_len is updated; static_len is also updated if stree is
1122 static void gen_bitlen(tree_desc * desc)
1124 ct_data *tree = desc->dyn_tree;
1125 const extra_bits_t *extra = desc->extra_bits;
1126 int base = desc->extra_base;
1127 int max_code = desc->max_code;
1128 int max_length = desc->max_length;
1129 ct_data *stree = desc->static_tree;
1130 int h; /* heap index */
1131 int n, m; /* iterate over the tree elements */
1132 int bits; /* bit length */
1133 int xbits; /* extra bits */
1134 ush f; /* frequency */
1135 int overflow = 0; /* number of elements with bit length too large */
1137 for (bits = 0; bits <= MAX_BITS; bits++)
1140 /* In a first pass, compute the optimal bit lengths (which may
1141 * overflow in the case of the bit length tree).
1143 tree[heap[heap_max]].Len = 0; /* root of the heap */
1145 for (h = heap_max + 1; h < HEAP_SIZE; h++) {
1147 bits = tree[tree[n].Dad].Len + 1;
1148 if (bits > max_length) {
1152 tree[n].Len = (ush) bits;
1153 /* We overwrite tree[n].Dad which is no longer needed */
1156 continue; /* not a leaf node */
1161 xbits = extra[n - base];
1163 opt_len += (ulg) f *(bits + xbits);
1166 static_len += (ulg) f * (stree[n].Len + xbits);
1171 Trace((stderr, "\nbit length overflow\n"));
1172 /* This happens for example on obj2 and pic of the Calgary corpus */
1174 /* Find the first bit length which could increase: */
1176 bits = max_length - 1;
1177 while (bl_count[bits] == 0)
1179 bl_count[bits]--; /* move one leaf down the tree */
1180 bl_count[bits + 1] += 2; /* move one overflow item as its brother */
1181 bl_count[max_length]--;
1182 /* The brother of the overflow item also moves one step up,
1183 * but this does not affect bl_count[max_length]
1186 } while (overflow > 0);
1188 /* Now recompute all bit lengths, scanning in increasing frequency.
1189 * h is still equal to HEAP_SIZE. (It is simpler to reconstruct all
1190 * lengths instead of fixing only the wrong ones. This idea is taken
1191 * from 'ar' written by Haruhiko Okumura.)
1193 for (bits = max_length; bits != 0; bits--) {
1199 if (tree[m].Len != (unsigned) bits) {
1200 Trace((stderr, "code %d bits %d->%d\n", m, tree[m].Len, bits));
1201 opt_len += ((int32_t) bits - tree[m].Len) * tree[m].Freq;
1210 /* ===========================================================================
1211 * Generate the codes for a given tree and bit counts (which need not be
1213 * IN assertion: the array bl_count contains the bit length statistics for
1214 * the given tree and the field len is set for all tree elements.
1215 * OUT assertion: the field code is set for all tree elements of non
1218 static void gen_codes(ct_data * tree, int max_code)
1220 ush next_code[MAX_BITS + 1]; /* next code value for each bit length */
1221 ush code = 0; /* running code value */
1222 int bits; /* bit index */
1223 int n; /* code index */
1225 /* The distribution counts are first used to generate the code values
1226 * without bit reversal.
1228 for (bits = 1; bits <= MAX_BITS; bits++) {
1229 next_code[bits] = code = (code + bl_count[bits - 1]) << 1;
1231 /* Check that the bit counts in bl_count are consistent. The last code
1234 Assert(code + bl_count[MAX_BITS] - 1 == (1 << MAX_BITS) - 1,
1235 "inconsistent bit counts");
1236 Tracev((stderr, "\ngen_codes: max_code %d ", max_code));
1238 for (n = 0; n <= max_code; n++) {
1239 int len = tree[n].Len;
1243 /* Now reverse the bits */
1244 tree[n].Code = bi_reverse(next_code[len]++, len);
1246 Tracec(tree != static_ltree,
1247 (stderr, "\nn %3d %c l %2d c %4x (%x) ", n,
1248 (isgraph(n) ? n : ' '), len, tree[n].Code,
1249 next_code[len] - 1));
1254 /* ===========================================================================
1255 * Construct one Huffman tree and assigns the code bit strings and lengths.
1256 * Update the total bit length for the current block.
1257 * IN assertion: the field freq is set for all tree elements.
1258 * OUT assertions: the fields len and code are set to the optimal bit length
1259 * and corresponding code. The length opt_len is updated; static_len is
1260 * also updated if stree is not null. The field max_code is set.
1263 /* Remove the smallest element from the heap and recreate the heap with
1264 * one less element. Updates heap and heap_len. */
1267 /* Index within the heap array of least frequent node in the Huffman tree */
1269 #define PQREMOVE(tree, top) \
1271 top = heap[SMALLEST]; \
1272 heap[SMALLEST] = heap[heap_len--]; \
1273 pqdownheap(tree, SMALLEST); \
1276 static void build_tree(tree_desc * desc)
1278 ct_data *tree = desc->dyn_tree;
1279 ct_data *stree = desc->static_tree;
1280 int elems = desc->elems;
1281 int n, m; /* iterate over heap elements */
1282 int max_code = -1; /* largest code with non zero frequency */
1283 int node = elems; /* next internal node of the tree */
1285 /* Construct the initial heap, with least frequent element in
1286 * heap[SMALLEST]. The sons of heap[n] are heap[2*n] and heap[2*n+1].
1287 * heap[0] is not used.
1289 heap_len = 0, heap_max = HEAP_SIZE;
1291 for (n = 0; n < elems; n++) {
1292 if (tree[n].Freq != 0) {
1293 heap[++heap_len] = max_code = n;
1300 /* The pkzip format requires that at least one distance code exists,
1301 * and that at least one bit should be sent even if there is only one
1302 * possible code. So to avoid special checks later on we force at least
1303 * two codes of non zero frequency.
1305 while (heap_len < 2) {
1306 int new = heap[++heap_len] = (max_code < 2 ? ++max_code : 0);
1312 static_len -= stree[new].Len;
1313 /* new is 0 or 1 so it does not have extra bits */
1315 desc->max_code = max_code;
1317 /* The elements heap[heap_len/2+1 .. heap_len] are leaves of the tree,
1318 * establish sub-heaps of increasing lengths:
1320 for (n = heap_len / 2; n >= 1; n--)
1321 pqdownheap(tree, n);
1323 /* Construct the Huffman tree by repeatedly combining the least two
1327 PQREMOVE(tree, n); /* n = node of least frequency */
1328 m = heap[SMALLEST]; /* m = node of next least frequency */
1330 heap[--heap_max] = n; /* keep the nodes sorted by frequency */
1331 heap[--heap_max] = m;
1333 /* Create a new node father of n and m */
1334 tree[node].Freq = tree[n].Freq + tree[m].Freq;
1335 depth[node] = MAX(depth[n], depth[m]) + 1;
1336 tree[n].Dad = tree[m].Dad = (ush) node;
1338 if (tree == bl_tree) {
1339 bb_error_msg("\nnode %d(%d), sons %d(%d) %d(%d)",
1340 node, tree[node].Freq, n, tree[n].Freq, m, tree[m].Freq);
1343 /* and insert the new node in the heap */
1344 heap[SMALLEST] = node++;
1345 pqdownheap(tree, SMALLEST);
1347 } while (heap_len >= 2);
1349 heap[--heap_max] = heap[SMALLEST];
1351 /* At this point, the fields freq and dad are set. We can now
1352 * generate the bit lengths.
1354 gen_bitlen((tree_desc *) desc);
1356 /* The field len is now set, we can generate the bit codes */
1357 gen_codes((ct_data *) tree, max_code);
1361 /* ===========================================================================
1362 * Scan a literal or distance tree to determine the frequencies of the codes
1363 * in the bit length tree. Updates opt_len to take into account the repeat
1364 * counts. (The contribution of the bit length codes will be added later
1365 * during the construction of bl_tree.)
1367 static void scan_tree(ct_data * tree, int max_code)
1369 int n; /* iterates over all tree elements */
1370 int prevlen = -1; /* last emitted length */
1371 int curlen; /* length of current code */
1372 int nextlen = tree[0].Len; /* length of next code */
1373 int count = 0; /* repeat count of the current code */
1374 int max_count = 7; /* max repeat count */
1375 int min_count = 4; /* min repeat count */
1381 tree[max_code + 1].Len = 0xffff; /* guard */
1383 for (n = 0; n <= max_code; n++) {
1385 nextlen = tree[n + 1].Len;
1386 if (++count < max_count && curlen == nextlen)
1389 if (count < min_count) {
1390 bl_tree[curlen].Freq += count;
1391 } else if (curlen != 0) {
1392 if (curlen != prevlen)
1393 bl_tree[curlen].Freq++;
1394 bl_tree[REP_3_6].Freq++;
1395 } else if (count <= 10) {
1396 bl_tree[REPZ_3_10].Freq++;
1398 bl_tree[REPZ_11_138].Freq++;
1408 } else if (curlen == nextlen) {
1416 /* ===========================================================================
1417 * Send a literal or distance tree in compressed form, using the codes in
1420 static void send_tree(ct_data * tree, int max_code)
1422 int n; /* iterates over all tree elements */
1423 int prevlen = -1; /* last emitted length */
1424 int curlen; /* length of current code */
1425 int nextlen = tree[0].Len; /* length of next code */
1426 int count = 0; /* repeat count of the current code */
1427 int max_count = 7; /* max repeat count */
1428 int min_count = 4; /* min repeat count */
1430 /* tree[max_code+1].Len = -1; *//* guard already set */
1432 max_count = 138, min_count = 3;
1434 for (n = 0; n <= max_code; n++) {
1436 nextlen = tree[n + 1].Len;
1437 if (++count < max_count && curlen == nextlen) {
1439 } else if (count < min_count) {
1441 SEND_CODE(curlen, bl_tree);
1443 } else if (curlen != 0) {
1444 if (curlen != prevlen) {
1445 SEND_CODE(curlen, bl_tree);
1448 Assert(count >= 3 && count <= 6, " 3_6?");
1449 SEND_CODE(REP_3_6, bl_tree);
1450 send_bits(count - 3, 2);
1451 } else if (count <= 10) {
1452 SEND_CODE(REPZ_3_10, bl_tree);
1453 send_bits(count - 3, 3);
1455 SEND_CODE(REPZ_11_138, bl_tree);
1456 send_bits(count - 11, 7);
1463 } else if (curlen == nextlen) {
1474 /* ===========================================================================
1475 * Construct the Huffman tree for the bit lengths and return the index in
1476 * bl_order of the last bit length code to send.
1478 static int build_bl_tree(void)
1480 int max_blindex; /* index of last bit length code of non zero freq */
1482 /* Determine the bit length frequencies for literal and distance trees */
1483 scan_tree((ct_data *) dyn_ltree, l_desc.max_code);
1484 scan_tree((ct_data *) dyn_dtree, d_desc.max_code);
1486 /* Build the bit length tree: */
1487 build_tree((tree_desc *) (&bl_desc));
1488 /* opt_len now includes the length of the tree representations, except
1489 * the lengths of the bit lengths codes and the 5+5+4 bits for the counts.
1492 /* Determine the number of bit length codes to send. The pkzip format
1493 * requires that at least 4 bit length codes be sent. (appnote.txt says
1494 * 3 but the actual value used is 4.)
1496 for (max_blindex = BL_CODES - 1; max_blindex >= 3; max_blindex--) {
1497 if (bl_tree[bl_order[max_blindex]].Len != 0)
1500 /* Update opt_len to include the bit length tree and counts */
1501 opt_len += 3 * (max_blindex + 1) + 5 + 5 + 4;
1502 Tracev((stderr, "\ndyn trees: dyn %ld, stat %ld", opt_len, static_len));
1508 /* ===========================================================================
1509 * Send the header for a block using dynamic Huffman trees: the counts, the
1510 * lengths of the bit length codes, the literal tree and the distance tree.
1511 * IN assertion: lcodes >= 257, dcodes >= 1, blcodes >= 4.
1513 static void send_all_trees(int lcodes, int dcodes, int blcodes)
1515 int rank; /* index in bl_order */
1517 Assert(lcodes >= 257 && dcodes >= 1 && blcodes >= 4, "not enough codes");
1518 Assert(lcodes <= L_CODES && dcodes <= D_CODES
1519 && blcodes <= BL_CODES, "too many codes");
1520 Tracev((stderr, "\nbl counts: "));
1521 send_bits(lcodes - 257, 5); /* not +255 as stated in appnote.txt */
1522 send_bits(dcodes - 1, 5);
1523 send_bits(blcodes - 4, 4); /* not -3 as stated in appnote.txt */
1524 for (rank = 0; rank < blcodes; rank++) {
1525 Tracev((stderr, "\nbl code %2d ", bl_order[rank]));
1526 send_bits(bl_tree[bl_order[rank]].Len, 3);
1528 Tracev((stderr, "\nbl tree: sent %ld", bits_sent));
1530 send_tree((ct_data *) dyn_ltree, lcodes - 1); /* send the literal tree */
1531 Tracev((stderr, "\nlit tree: sent %ld", bits_sent));
1533 send_tree((ct_data *) dyn_dtree, dcodes - 1); /* send the distance tree */
1534 Tracev((stderr, "\ndist tree: sent %ld", bits_sent));
1538 /* ===========================================================================
1539 * Set the file type to ASCII or BINARY, using a crude approximation:
1540 * binary if more than 20% of the bytes are <= 6 or >= 128, ascii otherwise.
1541 * IN assertion: the fields freq of dyn_ltree are set and the total of all
1542 * frequencies does not exceed 64K (to fit in an int on 16 bit machines).
1544 static void set_file_type(void)
1547 unsigned ascii_freq = 0;
1548 unsigned bin_freq = 0;
1551 bin_freq += dyn_ltree[n++].Freq;
1553 ascii_freq += dyn_ltree[n++].Freq;
1554 while (n < LITERALS)
1555 bin_freq += dyn_ltree[n++].Freq;
1556 *file_type = (bin_freq > (ascii_freq >> 2)) ? BINARY : ASCII;
1557 if (*file_type == BINARY && translate_eol) {
1558 bb_error_msg("-l used on binary file");
1563 /* ===========================================================================
1564 * Save the match info and tally the frequency counts. Return true if
1565 * the current block must be flushed.
1567 static int ct_tally(int dist, int lc)
1569 l_buf[last_lit++] = lc;
1571 /* lc is the unmatched char */
1572 dyn_ltree[lc].Freq++;
1574 /* Here, lc is the match length - MIN_MATCH */
1575 dist--; /* dist = match distance - 1 */
1576 Assert((ush) dist < (ush) MAX_DIST
1577 && (ush) lc <= (ush) (MAX_MATCH - MIN_MATCH)
1578 && (ush) D_CODE(dist) < (ush) D_CODES, "ct_tally: bad match"
1581 dyn_ltree[length_code[lc] + LITERALS + 1].Freq++;
1582 dyn_dtree[D_CODE(dist)].Freq++;
1584 d_buf[last_dist++] = dist;
1589 /* Output the flags if they fill a byte: */
1590 if ((last_lit & 7) == 0) {
1591 flag_buf[last_flags++] = flags;
1592 flags = 0, flag_bit = 1;
1594 /* Try to guess if it is profitable to stop the current block here */
1595 if ((last_lit & 0xfff) == 0) {
1596 /* Compute an upper bound for the compressed length */
1597 ulg out_length = last_lit * 8L;
1598 ulg in_length = (ulg) strstart - block_start;
1601 for (dcode = 0; dcode < D_CODES; dcode++) {
1602 out_length += dyn_dtree[dcode].Freq * (5L + extra_dbits[dcode]);
1606 "\nlast_lit %u, last_dist %u, in %ld, out ~%ld(%ld%%) ",
1607 last_lit, last_dist, in_length, out_length,
1608 100L - out_length * 100L / in_length));
1609 if (last_dist < last_lit / 2 && out_length < in_length / 2)
1612 return (last_lit == LIT_BUFSIZE - 1 || last_dist == DIST_BUFSIZE);
1613 /* We avoid equality with LIT_BUFSIZE because of wraparound at 64K
1614 * on 16 bit machines and because stored blocks are restricted to
1619 /* ===========================================================================
1620 * Send the block data compressed using the given Huffman trees
1622 static void compress_block(ct_data * ltree, ct_data * dtree)
1624 unsigned dist; /* distance of matched string */
1625 int lc; /* match length or unmatched char (if dist == 0) */
1626 unsigned lx = 0; /* running index in l_buf */
1627 unsigned dx = 0; /* running index in d_buf */
1628 unsigned fx = 0; /* running index in flag_buf */
1629 uch flag = 0; /* current flags */
1630 unsigned code; /* the code to send */
1631 int extra; /* number of extra bits to send */
1633 if (last_lit != 0) {
1636 flag = flag_buf[fx++];
1638 if ((flag & 1) == 0) {
1639 SEND_CODE(lc, ltree); /* send a literal byte */
1640 Tracecv(isgraph(lc), (stderr, " '%c' ", lc));
1642 /* Here, lc is the match length - MIN_MATCH */
1643 code = length_code[lc];
1644 SEND_CODE(code + LITERALS + 1, ltree); /* send the length code */
1645 extra = extra_lbits[code];
1647 lc -= base_length[code];
1648 send_bits(lc, extra); /* send the extra length bits */
1651 /* Here, dist is the match distance - 1 */
1652 code = D_CODE(dist);
1653 Assert(code < D_CODES, "bad d_code");
1655 SEND_CODE(code, dtree); /* send the distance code */
1656 extra = extra_dbits[code];
1658 dist -= base_dist[code];
1659 send_bits(dist, extra); /* send the extra distance bits */
1661 } /* literal or match pair ? */
1663 } while (lx < last_lit);
1666 SEND_CODE(END_BLOCK, ltree);
1670 /* ===========================================================================
1671 * Determine the best encoding for the current block: dynamic trees, static
1672 * trees or store, and output the encoded block to the zip file. This function
1673 * returns the total compressed length for the file so far.
1675 static ulg flush_block(char *buf, ulg stored_len, int eof)
1677 ulg opt_lenb, static_lenb; /* opt_len and static_len in bytes */
1678 int max_blindex; /* index of last bit length code of non zero freq */
1680 flag_buf[last_flags] = flags; /* Save the flags for the last 8 items */
1682 /* Check if the file is ascii or binary */
1683 if (*file_type == (ush) UNKNOWN)
1686 /* Construct the literal and distance trees */
1687 build_tree((tree_desc *) (&l_desc));
1688 Tracev((stderr, "\nlit data: dyn %ld, stat %ld", opt_len, static_len));
1690 build_tree((tree_desc *) (&d_desc));
1691 Tracev((stderr, "\ndist data: dyn %ld, stat %ld", opt_len, static_len));
1692 /* At this point, opt_len and static_len are the total bit lengths of
1693 * the compressed block data, excluding the tree representations.
1696 /* Build the bit length tree for the above two trees, and get the index
1697 * in bl_order of the last bit length code to send.
1699 max_blindex = build_bl_tree();
1701 /* Determine the best encoding. Compute first the block length in bytes */
1702 opt_lenb = (opt_len + 3 + 7) >> 3;
1703 static_lenb = (static_len + 3 + 7) >> 3;
1706 "\nopt %lu(%lu) stat %lu(%lu) stored %lu lit %u dist %u ",
1707 opt_lenb, opt_len, static_lenb, static_len, stored_len,
1708 last_lit, last_dist));
1710 if (static_lenb <= opt_lenb)
1711 opt_lenb = static_lenb;
1713 /* If compression failed and this is the first and last block,
1714 * and if the zip file can be seeked (to rewrite the local header),
1715 * the whole file is transformed into a stored file:
1717 if (stored_len <= opt_lenb && eof && compressed_len == 0L && seekable()) {
1718 /* Since LIT_BUFSIZE <= 2*WSIZE, the input data must be there: */
1720 bb_error_msg("block vanished");
1722 copy_block(buf, (unsigned) stored_len, 0); /* without header */
1723 compressed_len = stored_len << 3;
1724 *file_method = STORED;
1726 } else if (stored_len + 4 <= opt_lenb && buf != NULL) {
1727 /* 4: two words for the lengths */
1728 /* The test buf != NULL is only necessary if LIT_BUFSIZE > WSIZE.
1729 * Otherwise we can't have processed more than WSIZE input bytes since
1730 * the last block flush, because compression would have been
1731 * successful. If LIT_BUFSIZE <= WSIZE, it is never too late to
1732 * transform a block into a stored block.
1734 send_bits((STORED_BLOCK << 1) + eof, 3); /* send block type */
1735 compressed_len = (compressed_len + 3 + 7) & ~7L;
1736 compressed_len += (stored_len + 4) << 3;
1738 copy_block(buf, (unsigned) stored_len, 1); /* with header */
1740 } else if (static_lenb == opt_lenb) {
1741 send_bits((STATIC_TREES << 1) + eof, 3);
1742 compress_block((ct_data *) static_ltree, (ct_data *) static_dtree);
1743 compressed_len += 3 + static_len;
1745 send_bits((DYN_TREES << 1) + eof, 3);
1746 send_all_trees(l_desc.max_code + 1, d_desc.max_code + 1,
1748 compress_block((ct_data *) dyn_ltree, (ct_data *) dyn_dtree);
1749 compressed_len += 3 + opt_len;
1751 Assert(compressed_len == bits_sent, "bad compressed size");
1756 compressed_len += 7; /* align on byte boundary */
1758 Tracev((stderr, "\ncomprlen %lu(%lu) ", compressed_len >> 3,
1759 compressed_len - 7 * eof));
1761 return compressed_len >> 3;
1765 /* ===========================================================================
1766 * Update a hash value with the given input byte
1767 * IN assertion: all calls to to UPDATE_HASH are made with consecutive
1768 * input characters, so that a running hash key can be computed from the
1769 * previous key instead of complete recalculation each time.
1771 #define UPDATE_HASH(h, c) (h = (((h)<<H_SHIFT) ^ (c)) & HASH_MASK)
1774 /* ===========================================================================
1775 * Same as above, but achieves better compression. We use a lazy
1776 * evaluation for matches: a match is finally adopted only if there is
1777 * no better match at the next window position.
1779 * Processes a new input file and return its compressed length. Sets
1780 * the compressed length, crc, deflate flags and internal file
1784 /* Flush the current block, with given end-of-file flag.
1785 * IN assertion: strstart is set to the end of the current match. */
1786 #define FLUSH_BLOCK(eof) \
1789 ? (char*)&window[(unsigned)block_start] \
1791 (ulg)strstart - block_start, \
1795 /* Insert string s in the dictionary and set match_head to the previous head
1796 * of the hash chain (the most recent string with same hash key). Return
1797 * the previous length of the hash chain.
1798 * IN assertion: all calls to to INSERT_STRING are made with consecutive
1799 * input characters and the first MIN_MATCH bytes of s are valid
1800 * (except for the last MIN_MATCH-1 bytes of the input file). */
1801 #define INSERT_STRING(s, match_head) \
1803 UPDATE_HASH(ins_h, window[(s) + MIN_MATCH-1]); \
1804 prev[(s) & WMASK] = match_head = head[ins_h]; \
1805 head[ins_h] = (s); \
1808 static ulg deflate(void)
1810 IPos hash_head; /* head of hash chain */
1811 IPos prev_match; /* previous match */
1812 int flush; /* set if current block must be flushed */
1813 int match_available = 0; /* set if previous match exists */
1814 unsigned match_length = MIN_MATCH - 1; /* length of best match */
1816 /* Process the input block. */
1817 while (lookahead != 0) {
1818 /* Insert the string window[strstart .. strstart+2] in the
1819 * dictionary, and set hash_head to the head of the hash chain:
1821 INSERT_STRING(strstart, hash_head);
1823 /* Find the longest match, discarding those <= prev_length.
1825 prev_length = match_length, prev_match = match_start;
1826 match_length = MIN_MATCH - 1;
1828 if (hash_head != 0 && prev_length < max_lazy_match
1829 && strstart - hash_head <= MAX_DIST
1831 /* To simplify the code, we prevent matches with the string
1832 * of window index 0 (in particular we have to avoid a match
1833 * of the string with itself at the start of the input file).
1835 match_length = longest_match(hash_head);
1836 /* longest_match() sets match_start */
1837 if (match_length > lookahead)
1838 match_length = lookahead;
1840 /* Ignore a length 3 match if it is too distant: */
1841 if (match_length == MIN_MATCH && strstart - match_start > TOO_FAR) {
1842 /* If prev_match is also MIN_MATCH, match_start is garbage
1843 * but we will ignore the current match anyway.
1848 /* If there was a match at the previous step and the current
1849 * match is not better, output the previous match:
1851 if (prev_length >= MIN_MATCH && match_length <= prev_length) {
1852 check_match(strstart - 1, prev_match, prev_length);
1853 flush = ct_tally(strstart - 1 - prev_match, prev_length - MIN_MATCH);
1855 /* Insert in hash table all strings up to the end of the match.
1856 * strstart-1 and strstart are already inserted.
1858 lookahead -= prev_length - 1;
1862 INSERT_STRING(strstart, hash_head);
1863 /* strstart never exceeds WSIZE-MAX_MATCH, so there are
1864 * always MIN_MATCH bytes ahead. If lookahead < MIN_MATCH
1865 * these bytes are garbage, but it does not matter since the
1866 * next lookahead bytes will always be emitted as literals.
1868 } while (--prev_length != 0);
1869 match_available = 0;
1870 match_length = MIN_MATCH - 1;
1874 block_start = strstart;
1876 } else if (match_available) {
1877 /* If there was no match at the previous position, output a
1878 * single literal. If there was a match but the current match
1879 * is longer, truncate the previous match to a single literal.
1881 Tracevv((stderr, "%c", window[strstart - 1]));
1882 if (ct_tally(0, window[strstart - 1])) {
1884 block_start = strstart;
1889 /* There is no previous match to compare with, wait for
1890 * the next step to decide.
1892 match_available = 1;
1896 Assert(strstart <= isize && lookahead <= isize, "a bit too far");
1898 /* Make sure that we always have enough lookahead, except
1899 * at the end of the input file. We need MAX_MATCH bytes
1900 * for the next match, plus MIN_MATCH bytes to insert the
1901 * string following the next match.
1903 while (lookahead < MIN_LOOKAHEAD && !eofile)
1906 if (match_available)
1907 ct_tally(0, window[strstart - 1]);
1909 return FLUSH_BLOCK(1); /* eof */
1913 /* ===========================================================================
1914 * Initialize the bit string routines.
1916 static void bi_init(int zipfile)
1927 /* ===========================================================================
1928 * Initialize the "longest match" routines for a new file
1930 static void lm_init(ush * flags)
1934 /* Initialize the hash table. */
1935 memset(head, 0, HASH_SIZE * sizeof(*head));
1936 /* prev will be initialized on the fly */
1938 /*speed options for the general purpose bit flag */
1939 *flags |= 2; /* FAST 4, SLOW 2 */
1940 /* ??? reduce max_chain_length for binary files */
1945 lookahead = file_read(window,
1946 sizeof(int) <= 2 ? (unsigned) WSIZE : 2 * WSIZE);
1948 if (lookahead == 0 || lookahead == (unsigned) -1) {
1954 /* Make sure that we always have enough lookahead. This is important
1955 * if input comes from a device such as a tty.
1957 while (lookahead < MIN_LOOKAHEAD && !eofile)
1961 for (j = 0; j < MIN_MATCH - 1; j++)
1962 UPDATE_HASH(ins_h, window[j]);
1963 /* If lookahead < MIN_MATCH, ins_h is garbage, but this is
1964 * not important since only literal bytes will be emitted.
1969 /* ===========================================================================
1970 * Allocate the match buffer, initialize the various tables and save the
1971 * location of the internal file attribute (ascii/binary) and method
1973 * One callsite in zip()
1975 static void ct_init(ush * attr, int *methodp)
1977 int n; /* iterates over tree elements */
1978 int bits; /* bit counter */
1979 int length; /* length value */
1980 int code; /* code value */
1981 int dist; /* distance index */
1984 file_method = methodp;
1985 compressed_len = 0L;
1988 if (static_dtree[0].Len != 0)
1989 return; /* ct_init already called */
1992 /* Initialize the mapping length (0..255) -> length code (0..28) */
1994 for (code = 0; code < LENGTH_CODES - 1; code++) {
1995 base_length[code] = length;
1996 for (n = 0; n < (1 << extra_lbits[code]); n++) {
1997 length_code[length++] = code;
2000 Assert(length == 256, "ct_init: length != 256");
2001 /* Note that the length 255 (match length 258) can be represented
2002 * in two different ways: code 284 + 5 bits or code 285, so we
2003 * overwrite length_code[255] to use the best encoding:
2005 length_code[length - 1] = code;
2007 /* Initialize the mapping dist (0..32K) -> dist code (0..29) */
2009 for (code = 0; code < 16; code++) {
2010 base_dist[code] = dist;
2011 for (n = 0; n < (1 << extra_dbits[code]); n++) {
2012 dist_code[dist++] = code;
2015 Assert(dist == 256, "ct_init: dist != 256");
2016 dist >>= 7; /* from now on, all distances are divided by 128 */
2017 for (; code < D_CODES; code++) {
2018 base_dist[code] = dist << 7;
2019 for (n = 0; n < (1 << (extra_dbits[code] - 7)); n++) {
2020 dist_code[256 + dist++] = code;
2023 Assert(dist == 256, "ct_init: 256+dist != 512");
2025 /* Construct the codes of the static literal tree */
2026 /* already zeroed - it's in bss
2027 for (bits = 0; bits <= MAX_BITS; bits++)
2028 bl_count[bits] = 0; */
2032 static_ltree[n++].Len = 8;
2036 static_ltree[n++].Len = 9;
2040 static_ltree[n++].Len = 7;
2044 static_ltree[n++].Len = 8;
2047 /* Codes 286 and 287 do not exist, but we must include them in the
2048 * tree construction to get a canonical Huffman tree (longest code
2051 gen_codes((ct_data *) static_ltree, L_CODES + 1);
2053 /* The static distance tree is trivial: */
2054 for (n = 0; n < D_CODES; n++) {
2055 static_dtree[n].Len = 5;
2056 static_dtree[n].Code = bi_reverse(n, 5);
2059 /* Initialize the first block of the first file: */
2064 /* ===========================================================================
2065 * Deflate in to out.
2066 * IN assertions: the input and output buffers are cleared.
2067 * The variables time_stamp and save_orig_name are initialized.
2070 /* put_header_byte is used for the compressed output
2071 * - for the initial 4 bytes that can't overflow the buffer. */
2072 #define put_header_byte(c) outbuf[outcnt++] = (c)
2074 static int zip(int in, int out)
2076 uch my_flags = 0; /* general purpose bit flags */
2077 ush attr = 0; /* ascii/binary flag */
2078 ush deflate_flags = 0; /* pkzip -es, -en or -ex equivalent */
2084 /* Write the header to the gzip file. See algorithm.doc for the format */
2087 put_header_byte(0x1f); /* magic header for gzip files, 1F 8B */
2088 put_header_byte(0x8b);
2089 put_header_byte(DEFLATED); /* compression method */
2090 put_header_byte(my_flags); /* general flags */
2091 put_32bit(time_stamp);
2093 /* Write deflated file to zip file */
2097 ct_init(&attr, &method);
2098 lm_init(&deflate_flags);
2100 put_8bit(deflate_flags); /* extra flags */
2101 put_8bit(3); /* OS identifier = 3 (Unix) */
2105 /* Write the crc and uncompressed size */
2114 /* ======================================================================== */
2115 static void abort_gzip(int ATTRIBUTE_UNUSED ignored)
2120 int gzip_main(int argc, char **argv)
2132 struct stat statBuf;
2135 opt = getopt32(argc, argv, "cf123456789qv" USE_GUNZIP("d"));
2136 //if (opt & 0x1) // -c
2137 //if (opt & 0x2) // -f
2138 /* Ignore 1-9 (compression level) options */
2139 //if (opt & 0x4) // -1
2140 //if (opt & 0x8) // -2
2141 //if (opt & 0x10) // -3
2142 //if (opt & 0x20) // -4
2143 //if (opt & 0x40) // -5
2144 //if (opt & 0x80) // -6
2145 //if (opt & 0x100) // -7
2146 //if (opt & 0x200) // -8
2147 //if (opt & 0x400) // -9
2148 //if (opt & 0x800) // -q
2149 //if (opt & 0x1000) // -v
2150 #if ENABLE_GUNZIP /* gunzip_main may not be visible... */
2151 if (opt & 0x2000) { // -d
2152 /* FIXME: getopt32 should not depend on optind */
2154 return gunzip_main(argc, argv);
2158 foreground = signal(SIGINT, SIG_IGN) != SIG_IGN;
2160 signal(SIGINT, abort_gzip);
2163 if (signal(SIGTERM, SIG_IGN) != SIG_IGN) {
2164 signal(SIGTERM, abort_gzip);
2168 if (signal(SIGHUP, SIG_IGN) != SIG_IGN) {
2169 signal(SIGHUP, abort_gzip);
2173 //// strncpy(z_suffix, ".gz", sizeof(z_suffix) - 1);
2175 /* Allocate all global buffers (for DYN_ALLOC option) */
2176 ALLOC(uch, inbuf, INBUFSIZ + INBUF_EXTRA);
2177 ALLOC(uch, outbuf, OUTBUFSIZ + OUTBUF_EXTRA);
2178 ALLOC(ush, d_buf, DIST_BUFSIZE);
2179 ALLOC(uch, window, 2L * WSIZE);
2180 ALLOC(ush, prev, 1L << BITS);
2182 /* Initialise the CRC32 table */
2183 crc_32_tab = crc32_filltable(0);
2187 if (optind == argc) {
2189 zip(STDIN_FILENO, STDOUT_FILENO);
2193 for (i = optind; i < argc; i++) {
2197 if (LONE_DASH(argv[i])) {
2199 inFileNum = STDIN_FILENO;
2200 outFileNum = STDOUT_FILENO;
2202 inFileNum = xopen(argv[i], O_RDONLY);
2203 if (fstat(inFileNum, &statBuf) < 0)
2204 bb_perror_msg_and_die("%s", argv[i]);
2205 time_stamp = statBuf.st_ctime;
2207 if (!(opt & OPT_tostdout)) {
2208 path = xasprintf("%s.gz", argv[i]);
2210 /* Open output file */
2211 #if defined(__GLIBC__) && __GLIBC__ >= 2 && __GLIBC_MINOR__ >= 1 && defined(O_NOFOLLOW)
2212 outFileNum = open(path, O_RDWR | O_CREAT | O_EXCL | O_NOFOLLOW);
2214 outFileNum = open(path, O_RDWR | O_CREAT | O_EXCL);
2216 if (outFileNum < 0) {
2217 bb_perror_msg("%s", path);
2222 /* Set permissions on the file */
2223 fchmod(outFileNum, statBuf.st_mode);
2225 outFileNum = STDOUT_FILENO;
2228 if (path == NULL && isatty(outFileNum) && !(opt & OPT_force)) {
2229 bb_error_msg("compressed data not written "
2230 "to a terminal. Use -f to force compression.");
2235 result = zip(inFileNum, outFileNum);
2241 /* Delete the original file */
2243 delFileName = argv[i];
2247 if (unlink(delFileName) < 0)
2248 bb_perror_msg("%s", delFileName);