emo/busybox
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

gzip cleanup part #9

Browse Source
This commit is contained in:
Denis Vlasenko 2007-01-07 19:40:34 +00:00
parent 52933d47bd
commit 89af56b3e5
1 changed files with 84 additions and 105 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

189
archival/gzip.c
View File

@ -67,6 +67,7 @@ aa: 85.1% -- replaced with aa.gz
# endif # endif
#endif #endif
//remove??
#define INBUF_EXTRA 64 /* required by unlzw() */ #define INBUF_EXTRA 64 /* required by unlzw() */
#ifndef OUTBUFSIZ #ifndef OUTBUFSIZ
@ -76,6 +77,7 @@ aa: 85.1% -- replaced with aa.gz
# define OUTBUFSIZ 16384 /* output buffer size */ # define OUTBUFSIZ 16384 /* output buffer size */
# endif # endif
#endif #endif
//remove??
#define OUTBUF_EXTRA 2048 /* required by unlzw() */ #define OUTBUF_EXTRA 2048 /* required by unlzw() */
#ifndef DIST_BUFSIZE #ifndef DIST_BUFSIZE
@ -166,15 +168,6 @@ aa: 85.1% -- replaced with aa.gz
/* For portability to 16 bit machines, do not use values above 15. */ /* For portability to 16 bit machines, do not use values above 15. */
#endif #endif
/* To save space (see unlzw.c), we overlay prev+head with tab_prefix and
* window with tab_suffix. Check that we can do this:
*/
#if (WSIZE<<1) > (1<<BITS)
# error cannot overlay window with tab_suffix and prev with tab_prefix0
#endif
#if HASH_BITS > BITS-1
# error cannot overlay head with tab_prefix1
#endif
#define HASH_SIZE (unsigned)(1<<HASH_BITS) #define HASH_SIZE (unsigned)(1<<HASH_BITS)
#define HASH_MASK (HASH_SIZE-1) #define HASH_MASK (HASH_SIZE-1)
#define WMASK (WSIZE-1) #define WMASK (WSIZE-1)
@ -213,26 +206,6 @@ typedef unsigned IPos;
array = NULL; \ array = NULL; \
} }
/* DECLARE(uch, window, 2L*WSIZE); */
/* Sliding window. Input bytes are read into the second half of the window,
* and move to the first half later to keep a dictionary of at least WSIZE
* bytes. With this organization, matches are limited to a distance of
* WSIZE-MAX_MATCH bytes, but this ensures that IO is always
* performed with a length multiple of the block size. Also, it limits
* the window size to 64K, which is quite useful on MSDOS.
* To do: limit the window size to WSIZE+BSZ if SMALL_MEM (the code would
* be less efficient).
*/
/* DECLARE(Pos, prev, WSIZE); */
/* Link to older string with same hash index. To limit the size of this
* array to 64K, this link is maintained only for the last 32K strings.
* An index in this array is thus a window index modulo 32K.
*/
/* DECLARE(Pos, head, 1<<HASH_BITS); */
/* Heads of the hash chains or 0. */
static long block_start; static long block_start;
/* window position at the beginning of the current output block. Gets /* window position at the beginning of the current output block. Gets
@ -300,7 +273,6 @@ enum {
/* =========================================================================== /* ===========================================================================
* Prototypes for local functions.
*/ */
static void fill_window(void); static void fill_window(void);
@ -311,41 +283,59 @@ static void check_match(IPos start, IPos match, int length);
#endif #endif
/* from deflate.c */
static void lm_init(ush * flags);
static ulg deflate(void);
/* from trees.c */ /* from trees.c */
static void ct_init(ush * attr, int *methodp);
static int ct_tally(int dist, int lc); static int ct_tally(int dist, int lc);
static ulg flush_block(char *buf, ulg stored_len, int eof); static ulg flush_block(char *buf, ulg stored_len, int eof);
/* from bits.c */
static void bi_init(int zipfile);
static void send_bits(int value, int length);
static unsigned bi_reverse(unsigned value, int length);
static void bi_windup(void);
static void copy_block(char *buf, unsigned len, int header);
/* global buffers */ /* global buffers */
/* To save memory for 16 bit systems, some arrays are overlaid between /* To save memory for 16 bit systems, some arrays are overlaid between
* the various modules: * the various modules:
* deflate: prev+head window d_buf l_buf outbuf * deflate: prev+head window d_buf l_buf outbuf
* unlzw: tab_prefix tab_suffix stack inbuf outbuf * unlzw: tab_prefix tab_suffix stack inbuf outbuf
//remove unlzw??
* For compression, input is done in window[]. For decompression, output * For compression, input is done in window[]. For decompression, output
* is done in window except for unlzw. * is done in window except for unlzw.
*/ */
/* To save space (see unlzw.c), we overlay prev+head with tab_prefix and
* window with tab_suffix. Check that we can do this:
*/
#if (WSIZE<<1) > (1<<BITS)
# error cannot overlay window with tab_suffix and prev with tab_prefix0
#endif
#if HASH_BITS > BITS-1
# error cannot overlay head with tab_prefix1
#endif
#define tab_suffix window //#define tab_suffix window
#define tab_prefix prev /* hash link (see deflate.c) */ //#define tab_prefix prev /* hash link (see deflate.c) */
#define head (prev+WSIZE) /* hash head (see deflate.c) */ #define head (prev+WSIZE) /* hash head (see deflate.c) */
DECLARE(uch, inbuf, INBUFSIZ + INBUF_EXTRA); /* DECLARE(uch, window, 2L*WSIZE); */
/* Sliding window. Input bytes are read into the second half of the window,
* and move to the first half later to keep a dictionary of at least WSIZE
* bytes. With this organization, matches are limited to a distance of
* WSIZE-MAX_MATCH bytes, but this ensures that IO is always
* performed with a length multiple of the block size. Also, it limits
* the window size to 64K, which is quite useful on MSDOS.
* To do: limit the window size to WSIZE+BSZ if SMALL_MEM (the code would
* be less efficient).
*/
/* DECLARE(Pos, prev, WSIZE); */
/* Link to older string with same hash index. To limit the size of this
* array to 64K, this link is maintained only for the last 32K strings.
* An index in this array is thus a window index modulo 32K.
*/
/* DECLARE(Pos, head, 1<<HASH_BITS); */
/* Heads of the hash chains or 0. */
DECLARE(uch, inbuf, INBUFSIZ + INBUF_EXTRA); //remove + XX_EXTRA (unlzw)??
DECLARE(uch, outbuf, OUTBUFSIZ + OUTBUF_EXTRA); DECLARE(uch, outbuf, OUTBUFSIZ + OUTBUF_EXTRA);
DECLARE(ush, d_buf, DIST_BUFSIZE); DECLARE(ush, d_buf, DIST_BUFSIZE);
DECLARE(uch, window, 2L * WSIZE); DECLARE(uch, window, 2L * WSIZE);
DECLARE(ush, tab_prefix, 1L << BITS); DECLARE(ush, prev, 1L << BITS);
static long isize; /* number of input bytes */ static long isize; /* number of input bytes */
@ -544,11 +534,12 @@ static unsigned bi_reverse(unsigned code, int len)
{ {
unsigned res = 0; unsigned res = 0;
do { while (1) {
res |= code & 1; res |= code & 1;
code >>= 1, res <<= 1; if (--len <= 0) return res;
} while (--len > 0); code >>= 1;
return res >> 1; res <<= 1;
}
} }
@ -957,14 +948,11 @@ static ulg deflate(void)
* terms of the GNU General Public License, see the file COPYING. * terms of the GNU General Public License, see the file COPYING.
*/ */
/* /* PURPOSE
* PURPOSE
*
* Encode various sets of source values using variable-length * Encode various sets of source values using variable-length
* binary code trees. * binary code trees.
* *
* DISCUSSION * DISCUSSION
*
* The PKZIP "deflation" process uses several Huffman trees. The more * The PKZIP "deflation" process uses several Huffman trees. The more
* common source values are represented by shorter bit sequences. * common source values are represented by shorter bit sequences.
* *
@ -976,7 +964,6 @@ static ulg deflate(void)
* (APPNOTE.TXT) distributed as part of PKWARE's PKZIP program. * (APPNOTE.TXT) distributed as part of PKWARE's PKZIP program.
* *
* REFERENCES * REFERENCES
*
* Lynch, Thomas J. * Lynch, Thomas J.
* Data Compression: Techniques and Applications, pp. 53-55. * Data Compression: Techniques and Applications, pp. 53-55.
* Lifetime Learning Publications, 1985. ISBN 0-534-03418-7. * Lifetime Learning Publications, 1985. ISBN 0-534-03418-7.
@ -990,7 +977,6 @@ static ulg deflate(void)
* Addison-Wesley, 1983. ISBN 0-201-06672-6. * Addison-Wesley, 1983. ISBN 0-201-06672-6.
* *
* INTERFACE * INTERFACE
*
* void ct_init(ush *attr, int *methodp) * void ct_init(ush *attr, int *methodp)
* Allocate the match buffer, initialize the various tables and save * Allocate the match buffer, initialize the various tables and save
* the location of the internal file attribute (ascii/binary) and * the location of the internal file attribute (ascii/binary) and
@ -1003,7 +989,6 @@ static ulg deflate(void)
* Determine the best encoding for the current block: dynamic trees, * Determine the best encoding for the current block: dynamic trees,
* static trees or store, and output the encoded block to the zip * static trees or store, and output the encoded block to the zip
* file. Returns the total compressed length for the file so far. * file. Returns the total compressed length for the file so far.
*
*/ */
/* =========================================================================== /* ===========================================================================
@ -1037,20 +1022,20 @@ static ulg deflate(void)
typedef uch extra_bits_t; typedef uch extra_bits_t;
/* extra bits for each length code */ /* extra bits for each length code */
static const extra_bits_t extra_lbits[LENGTH_CODES] static const extra_bits_t extra_lbits[LENGTH_CODES]= {
= { 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 2, 2, 2, 2, 3, 3, 3, 3, 4, 4, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 2, 2, 2, 2, 3, 3, 3, 3, 4, 4,
4, 4, 5, 5, 5, 5, 0 4, 4, 5, 5, 5, 5, 0
}; };
/* extra bits for each distance code */ /* extra bits for each distance code */
static const extra_bits_t extra_dbits[D_CODES] static const extra_bits_t extra_dbits[D_CODES] = {
= { 0, 0, 0, 0, 1, 1, 2, 2, 3, 3, 4, 4, 5, 5, 6, 6, 7, 7, 8, 8, 9, 9, 0, 0, 0, 0, 1, 1, 2, 2, 3, 3, 4, 4, 5, 5, 6, 6, 7, 7, 8, 8, 9, 9,
10, 10, 11, 11, 12, 12, 13, 13 10, 10, 11, 11, 12, 12, 13, 13
}; };
/* extra bits for each bit length code */ /* extra bits for each bit length code */
static const extra_bits_t extra_blbits[BL_CODES] static const extra_bits_t extra_blbits[BL_CODES] = {
= { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 3, 7 }; 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 3, 7 };
#define STORED_BLOCK 0 #define STORED_BLOCK 0
#define STATIC_TREES 1 #define STATIC_TREES 1
@ -1245,11 +1230,8 @@ static ush *file_type; /* pointer to UNKNOWN, BINARY or ASCII */
static int *file_method; /* pointer to DEFLATE or STORE */ static int *file_method; /* pointer to DEFLATE or STORE */
/* =========================================================================== /* ===========================================================================
* Local (static) routines in this file.
*/ */
static void init_block(void); static void init_block(void);
static void pqdownheap(ct_data * tree, int k);
static void gen_bitlen(tree_desc * desc); static void gen_bitlen(tree_desc * desc);
static void gen_codes(ct_data * tree, int max_code); static void gen_codes(ct_data * tree, int max_code);
static void build_tree(tree_desc * desc); static void build_tree(tree_desc * desc);
@ -1263,16 +1245,16 @@ static void set_file_type(void);
#ifndef DEBUG #ifndef DEBUG
/* Send a code of the given tree. c and tree must not have side effects */ /* Send a code of the given tree. c and tree must not have side effects */
# define send_code(c, tree) send_bits(tree[c].Code, tree[c].Len) # define SEND_CODE(c, tree) send_bits(tree[c].Code, tree[c].Len)
#else /* DEBUG */ #else
# define send_code(c, tree) \ # define SEND_CODE(c, tree) \
{ \ { \
if (verbose > 1) bb_error_msg("\ncd %3d ",(c)); \ if (verbose > 1) bb_error_msg("\ncd %3d ",(c)); \
send_bits(tree[c].Code, tree[c].Len); \ send_bits(tree[c].Code, tree[c].Len); \
} }
#endif #endif
#define d_code(dist) \ #define D_CODE(dist) \
((dist) < 256 ? dist_code[dist] : dist_code[256 + ((dist)>>7)]) ((dist) < 256 ? dist_code[dist] : dist_code[256 + ((dist)>>7)])
/* Mapping from a distance to a distance code. dist is the distance - 1 and /* Mapping from a distance to a distance code. dist is the distance - 1 and
* must not have side effects. dist_code[256] and dist_code[257] are never * must not have side effects. dist_code[256] and dist_code[257] are never
@ -1396,22 +1378,6 @@ static void init_block(void)
} }
/* ===========================================================================
* Remove the smallest element from the heap and recreate the heap with
* one less element. Updates heap and heap_len.
*/
#define SMALLEST 1
/* Index within the heap array of least frequent node in the Huffman tree */
#define pqremove(tree, top) \
{ \
top = heap[SMALLEST]; \
heap[SMALLEST] = heap[heap_len--]; \
pqdownheap(tree, SMALLEST); \
}
/* =========================================================================== /* ===========================================================================
* Restore the heap property by moving down the tree starting at node k, * Restore the heap property by moving down the tree starting at node k,
* exchanging a node with the smallest of its two sons if necessary, stopping * exchanging a node with the smallest of its two sons if necessary, stopping
@ -1420,9 +1386,8 @@ static void init_block(void)
*/ */
/* Compares to subtrees, using the tree depth as tie breaker when /* Compares to subtrees, using the tree depth as tie breaker when
* the subtrees have equal frequency. This minimizes the worst case length. * the subtrees have equal frequency. This minimizes the worst case length. */
*/ #define SMALLER(tree, n, m) \
#define smaller(tree, n, m) \
(tree[n].Freq < tree[m].Freq \ (tree[n].Freq < tree[m].Freq \
|| (tree[n].Freq == tree[m].Freq && depth[n] <= depth[m])) || (tree[n].Freq == tree[m].Freq && depth[n] <= depth[m]))
@ -1433,11 +1398,11 @@ static void pqdownheap(ct_data * tree, int k)
while (j <= heap_len) { while (j <= heap_len) {
/* Set j to the smallest of the two sons: */ /* Set j to the smallest of the two sons: */
if (j < heap_len && smaller(tree, heap[j + 1], heap[j])) if (j < heap_len && SMALLER(tree, heap[j + 1], heap[j]))
j++; j++;
/* Exit if v is smaller than both sons */ /* Exit if v is smaller than both sons */
if (smaller(tree, v, heap[j])) if (SMALLER(tree, v, heap[j]))
break; break;
/* Exchange v with the smallest son */ /* Exchange v with the smallest son */
@ -1599,6 +1564,20 @@ static void gen_codes(ct_data * tree, int max_code)
* and corresponding code. The length opt_len is updated; static_len is * and corresponding code. The length opt_len is updated; static_len is
* also updated if stree is not null. The field max_code is set. * also updated if stree is not null. The field max_code is set.
*/ */
/* Remove the smallest element from the heap and recreate the heap with
* one less element. Updates heap and heap_len. */
#define SMALLEST 1
/* Index within the heap array of least frequent node in the Huffman tree */
#define PQREMOVE(tree, top) \
{ \
top = heap[SMALLEST]; \
heap[SMALLEST] = heap[heap_len--]; \
pqdownheap(tree, SMALLEST); \
}
static void build_tree(tree_desc * desc) static void build_tree(tree_desc * desc)
{ {
ct_data *tree = desc->dyn_tree; ct_data *tree = desc->dyn_tree;
@ -1650,7 +1629,7 @@ static void build_tree(tree_desc * desc)
* frequent nodes. * frequent nodes.
*/ */
do { do {
pqremove(tree, n); /* n = node of least frequency */ PQREMOVE(tree, n); /* n = node of least frequency */
m = heap[SMALLEST]; /* m = node of next least frequency */ m = heap[SMALLEST]; /* m = node of next least frequency */
heap[--heap_max] = n; /* keep the nodes sorted by frequency */ heap[--heap_max] = n; /* keep the nodes sorted by frequency */
@ -1761,21 +1740,21 @@ static void send_tree(ct_data * tree, int max_code)
continue; continue;
} else if (count < min_count) { } else if (count < min_count) {
do { do {
send_code(curlen, bl_tree); SEND_CODE(curlen, bl_tree);
} while (--count); } while (--count);
} else if (curlen != 0) { } else if (curlen != 0) {
if (curlen != prevlen) { if (curlen != prevlen) {
send_code(curlen, bl_tree); SEND_CODE(curlen, bl_tree);
count--; count--;
} }
Assert(count >= 3 && count <= 6, " 3_6?"); Assert(count >= 3 && count <= 6, " 3_6?");
send_code(REP_3_6, bl_tree); SEND_CODE(REP_3_6, bl_tree);
send_bits(count - 3, 2); send_bits(count - 3, 2);
} else if (count <= 10) { } else if (count <= 10) {
send_code(REPZ_3_10, bl_tree); SEND_CODE(REPZ_3_10, bl_tree);
send_bits(count - 3, 3); send_bits(count - 3, 3);
} else { } else {
send_code(REPZ_11_138, bl_tree); SEND_CODE(REPZ_11_138, bl_tree);
send_bits(count - 11, 7); send_bits(count - 11, 7);
} }
count = 0; count = 0;
@ -1964,11 +1943,11 @@ static int ct_tally(int dist, int lc)
dist--; /* dist = match distance - 1 */ dist--; /* dist = match distance - 1 */
Assert((ush) dist < (ush) MAX_DIST Assert((ush) dist < (ush) MAX_DIST
&& (ush) lc <= (ush) (MAX_MATCH - MIN_MATCH) && (ush) lc <= (ush) (MAX_MATCH - MIN_MATCH)
&& (ush) d_code(dist) < (ush) D_CODES, "ct_tally: bad match" && (ush) D_CODE(dist) < (ush) D_CODES, "ct_tally: bad match"
); );
dyn_ltree[length_code[lc] + LITERALS + 1].Freq++; dyn_ltree[length_code[lc] + LITERALS + 1].Freq++;
dyn_dtree[d_code(dist)].Freq++; dyn_dtree[D_CODE(dist)].Freq++;
d_buf[last_dist++] = dist; d_buf[last_dist++] = dist;
flags |= flag_bit; flags |= flag_bit;
@ -2025,12 +2004,12 @@ static void compress_block(ct_data * ltree, ct_data * dtree)
flag = flag_buf[fx++]; flag = flag_buf[fx++];
lc = l_buf[lx++]; lc = l_buf[lx++];
if ((flag & 1) == 0) { if ((flag & 1) == 0) {
send_code(lc, ltree); /* send a literal byte */ SEND_CODE(lc, ltree); /* send a literal byte */
Tracecv(isgraph(lc), (stderr, " '%c' ", lc)); Tracecv(isgraph(lc), (stderr, " '%c' ", lc));
} else { } else {
/* Here, lc is the match length - MIN_MATCH */ /* Here, lc is the match length - MIN_MATCH */
code = length_code[lc]; code = length_code[lc];
send_code(code + LITERALS + 1, ltree); /* send the length code */ SEND_CODE(code + LITERALS + 1, ltree); /* send the length code */
extra = extra_lbits[code]; extra = extra_lbits[code];
if (extra != 0) { if (extra != 0) {
lc -= base_length[code]; lc -= base_length[code];
@ -2038,10 +2017,10 @@ static void compress_block(ct_data * ltree, ct_data * dtree)
} }
dist = d_buf[dx++]; dist = d_buf[dx++];
/* Here, dist is the match distance - 1 */ /* Here, dist is the match distance - 1 */
code = d_code(dist); code = D_CODE(dist);
Assert(code < D_CODES, "bad d_code"); Assert(code < D_CODES, "bad d_code");
send_code(code, dtree); /* send the distance code */ SEND_CODE(code, dtree); /* send the distance code */
extra = extra_dbits[code]; extra = extra_dbits[code];
if (extra != 0) { if (extra != 0) {
dist -= base_dist[code]; dist -= base_dist[code];
@ -2052,7 +2031,7 @@ static void compress_block(ct_data * ltree, ct_data * dtree)
} while (lx < last_lit); } while (lx < last_lit);
} }
send_code(END_BLOCK, ltree); SEND_CODE(END_BLOCK, ltree);
} }
/* =========================================================================== /* ===========================================================================
@ -2192,7 +2171,7 @@ int gzip_main(int argc, char **argv)
ALLOC(uch, outbuf, OUTBUFSIZ + OUTBUF_EXTRA); ALLOC(uch, outbuf, OUTBUFSIZ + OUTBUF_EXTRA);
ALLOC(ush, d_buf, DIST_BUFSIZE); ALLOC(ush, d_buf, DIST_BUFSIZE);
ALLOC(uch, window, 2L * WSIZE); ALLOC(uch, window, 2L * WSIZE);
ALLOC(ush, tab_prefix, 1L << BITS); ALLOC(ush, prev, 1L << BITS);
/* Initialise the CRC32 table */ /* Initialise the CRC32 table */
crc_32_tab = crc32_filltable(0); crc_32_tab = crc32_filltable(0);