diff options
Diffstat (limited to 'archival')
| -rw-r--r-- | archival/gzip.c | 479 |
1 files changed, 238 insertions, 241 deletions
diff --git a/archival/gzip.c b/archival/gzip.c index 44b5fe386..60ff1f311 100644 --- a/archival/gzip.c +++ b/archival/gzip.c @@ -71,7 +71,7 @@ typedef unsigned long ulg; #define STORED 0 /* methods 4 to 7 reserved */ #define DEFLATED 8 -static int method; /* compression method */ +static int method; /* compression method */ /* To save memory for 16 bit systems, some arrays are overlaid between * the various modules: @@ -88,7 +88,7 @@ static int method; /* compression method */ # define INBUFSIZ 0x8000 /* input buffer size */ # endif #endif -#define INBUF_EXTRA 64 /* required by unlzw() */ +#define INBUF_EXTRA 64 /* required by unlzw() */ #ifndef OUTBUFSIZ # ifdef SMALL_MEM @@ -97,7 +97,7 @@ static int method; /* compression method */ # define OUTBUFSIZ 16384 /* output buffer size */ # endif #endif -#define OUTBUF_EXTRA 2048 /* required by unlzw() */ +#define OUTBUF_EXTRA 2048 /* required by unlzw() */ #ifndef DIST_BUFSIZE # ifdef SMALL_MEM @@ -120,17 +120,17 @@ static int method; /* compression method */ #endif #define tab_suffix window -#define tab_prefix prev /* hash link (see deflate.c) */ -#define head (prev+WSIZE) /* hash head (see deflate.c) */ +#define tab_prefix prev /* hash link (see deflate.c) */ +#define head (prev+WSIZE) /* hash head (see deflate.c) */ -static long bytes_in; /* number of input bytes */ +static long bytes_in; /* number of input bytes */ #define isize bytes_in /* for compatibility with old zip sources (to be cleaned) */ -typedef int file_t; /* Do not use stdio */ +typedef int file_t; /* Do not use stdio */ -#define NO_FILE (-1) /* in memory compression */ +#define NO_FILE (-1) /* in memory compression */ #define PACK_MAGIC "\037\036" /* Magic header for packed files */ @@ -140,12 +140,12 @@ typedef int file_t; /* Do not use stdio */ #define PKZIP_MAGIC "\120\113\003\004" /* Magic header for pkzip files */ /* gzip flag byte */ -#define ASCII_FLAG 0x01 /* bit 0 set: file probably ascii text */ -#define CONTINUATION 0x02 /* bit 1 set: continuation of multi-part gzip file */ -#define EXTRA_FIELD 0x04 /* bit 2 set: extra field present */ -#define ORIG_NAME 0x08 /* bit 3 set: original file name present */ -#define COMMENT 0x10 /* bit 4 set: file comment present */ -#define RESERVED 0xC0 /* bit 6,7: reserved */ +#define ASCII_FLAG 0x01 /* bit 0 set: file probably ascii text */ +#define CONTINUATION 0x02 /* bit 1 set: continuation of multi-part gzip file */ +#define EXTRA_FIELD 0x04 /* bit 2 set: extra field present */ +#define ORIG_NAME 0x08 /* bit 3 set: original file name present */ +#define COMMENT 0x10 /* bit 4 set: file comment present */ +#define RESERVED 0xC0 /* bit 6,7: reserved */ /* internal file attribute */ #define UNKNOWN 0xffff @@ -153,7 +153,7 @@ typedef int file_t; /* Do not use stdio */ #define ASCII 1 #ifndef WSIZE -# define WSIZE 0x8000 /* window size--must be a power of two, and */ +# define WSIZE 0x8000 /* window size--must be a power of two, and */ #endif /* at least 32K for zip's deflate method */ #define MIN_MATCH 3 @@ -183,8 +183,8 @@ typedef int file_t; /* Do not use stdio */ } #endif -#define seekable() 0 /* force sequential output */ -#define translate_eol 0 /* no option -a yet */ +#define seekable() 0 /* force sequential output */ +#define translate_eol 0 /* no option -a yet */ /* Diagnostic functions */ #ifdef DEBUG @@ -212,31 +212,31 @@ typedef int file_t; /* Do not use stdio */ /* from zip.c: */ -static int zip (int in, int out); -static int file_read (char *buf, unsigned size); +static int zip(int in, int out); +static int file_read(char *buf, unsigned size); /* from gzip.c */ -static RETSIGTYPE abort_gzip (void); +static RETSIGTYPE abort_gzip(void); /* from deflate.c */ -static void lm_init (ush * flags); -static ulg deflate (void); +static void lm_init(ush * flags); +static ulg deflate(void); /* from trees.c */ -static void ct_init (ush * attr, int *methodp); -static int ct_tally (int dist, int lc); -static ulg flush_block (char *buf, ulg stored_len, int eof); +static void ct_init(ush * attr, int *methodp); +static int ct_tally(int dist, int lc); +static ulg flush_block(char *buf, ulg stored_len, int eof); /* from bits.c */ -static void bi_init (file_t 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); +static void bi_init(file_t 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); static int (*read_buf) (char *buf, unsigned size); /* from util.c: */ -static void flush_outbuf (void); +static void flush_outbuf(void); /* lzw.h -- define the lzw functions. * Copyright (C) 1992-1993 Jean-loup Gailly. @@ -251,9 +251,9 @@ static void flush_outbuf (void); #ifndef BITS # define BITS 16 #endif -#define INIT_BITS 9 /* Initial number of bits per code */ +#define INIT_BITS 9 /* Initial number of bits per code */ -#define BIT_MASK 0x1f /* Mask for 'number of compression bits' */ +#define BIT_MASK 0x1f /* Mask for 'number of compression bits' */ /* Mask 0x20 is reserved to mean a fourth header byte, and 0x40 is free. * It's a pity that old uncompress does not check bit 0x20. That makes * extension of the format actually undesirable because old compress @@ -277,7 +277,7 @@ static void flush_outbuf (void); /* Common defaults */ #ifndef OS_CODE -# define OS_CODE 0x03 /* assume Unix */ +# define OS_CODE 0x03 /* assume Unix */ #endif #ifndef PATH_SEP @@ -308,31 +308,31 @@ DECLARE(ush, tab_prefix, 1L << BITS); static int crc_table_empty = 1; -static int foreground; /* set if program run in foreground */ +static int foreground; /* set if program run in foreground */ static int method = DEFLATED; /* compression method */ -static int exit_code = OK; /* program exit code */ -static int part_nb; /* number of parts in .gz file */ -static long time_stamp; /* original time stamp (modification time) */ -static long ifile_size; /* input file size, -1 for devices (debug only) */ +static int exit_code = OK; /* program exit code */ +static int part_nb; /* number of parts in .gz file */ +static long time_stamp; /* original time stamp (modification time) */ +static long ifile_size; /* input file size, -1 for devices (debug only) */ static char z_suffix[MAX_SUFFIX + 1]; /* default suffix (can be set with --suffix) */ -static int z_len; /* strlen(z_suffix) */ +static int z_len; /* strlen(z_suffix) */ -static int ifd; /* input file descriptor */ -static int ofd; /* output file descriptor */ -static unsigned insize; /* valid bytes in inbuf */ -static unsigned outcnt; /* bytes in output buffer */ +static int ifd; /* input file descriptor */ +static int ofd; /* output file descriptor */ +static unsigned insize; /* valid bytes in inbuf */ +static unsigned outcnt; /* bytes in output buffer */ /* Output a 16 bit value, lsb first */ static void put_short(ush w) { - if (outcnt < OUTBUFSIZ-2) { - outbuf[outcnt++] = (uch) ((w) & 0xff); - outbuf[outcnt++] = (uch) ((ush)(w) >> 8); - } else { - put_byte((uch)((w) & 0xff)); - put_byte((uch)((ush)(w) >> 8)); - } + if (outcnt < OUTBUFSIZ - 2) { + outbuf[outcnt++] = (uch) ((w) & 0xff); + outbuf[outcnt++] = (uch) ((ush) (w) >> 8); + } else { + put_byte((uch) ((w) & 0xff)); + put_byte((uch) ((ush) (w) >> 8)); + } } /* ======================================================================== @@ -382,27 +382,28 @@ static void write_buf(int fd, void *buf, unsigned cnt) * pointer, then initialize the crc shift register contents instead. * Return the current crc in either case. */ -static ulg updcrc(uch *s, unsigned n) +static ulg updcrc(uch * s, unsigned n) { static ulg crc = (ulg) 0xffffffffL; /* shift register contents */ - register ulg c; /* temporary variable */ + register ulg c; /* temporary variable */ static unsigned long crc_32_tab[256]; + if (crc_table_empty) { - unsigned long csr; /* crc shift register */ + unsigned long csr; /* crc shift register */ const unsigned long e = 0xedb88320L; /* polynomial exclusive-or pattern */ - int i; /* counter for all possible eight bit values */ - int k; /* byte being shifted into crc apparatus */ + int i; /* counter for all possible eight bit values */ + int k; /* byte being shifted into crc apparatus */ /* Compute table of CRC's. */ crc_32_tab[0] = 0x00000000L; for (i = 1; i < 256; i++) { csr = i; - /* The idea to initialize the register with the byte instead of - * zero was stolen from Haruhiko Okumura's ar002 - */ + /* The idea to initialize the register with the byte instead of + * zero was stolen from Haruhiko Okumura's ar002 + */ for (k = 8; k; k--) csr = csr & 1 ? (csr >> 1) ^ e : csr >> 1; - crc_32_tab[i]=csr; + crc_32_tab[i] = csr; } } @@ -416,7 +417,7 @@ static ulg updcrc(uch *s, unsigned n) } while (--n); } crc = c; - return c ^ 0xffffffffL; /* (instead of ~c for 64-bit machines) */ + return c ^ 0xffffffffL; /* (instead of ~c for 64-bit machines) */ } /* bits.c -- output variable-length bit strings @@ -476,7 +477,7 @@ static ulg updcrc(uch *s, unsigned n) * Local data used by the "bit string" routines. */ -static file_t zfile; /* output gzip file */ +static file_t zfile; /* output gzip file */ static unsigned short bi_buf; @@ -494,7 +495,7 @@ static int bi_valid; /* Current input function. Set to mem_read for in-memory compression */ #ifdef DEBUG -ulg bits_sent; /* bit length of the compressed data */ +ulg bits_sent; /* bit length of the compressed data */ #endif /* =========================================================================== @@ -582,7 +583,7 @@ static void bi_windup() */ static void copy_block(char *buf, unsigned len, int header) { - bi_windup(); /* align on byte boundary */ + bi_windup(); /* align on byte boundary */ if (header) { put_short((ush) len); @@ -676,7 +677,7 @@ static void copy_block(char *buf, unsigned len, int header) */ #ifdef SMALL_MEM -# define HASH_BITS 13 /* Number of bits used to hash strings */ +# define HASH_BITS 13 /* Number of bits used to hash strings */ #endif #ifdef MEDIUM_MEM # define HASH_BITS 14 @@ -750,7 +751,7 @@ static long block_start; * negative when the window is moved backwards. */ -static unsigned ins_h; /* hash index of string to be inserted */ +static unsigned ins_h; /* hash index of string to be inserted */ #define H_SHIFT ((HASH_BITS+MIN_MATCH-1)/MIN_MATCH) /* Number of bits by which ins_h and del_h must be shifted at each @@ -765,18 +766,18 @@ static unsigned int prev_length; * are discarded. This is used in the lazy match evaluation. */ -static unsigned strstart; /* start of string to insert */ -static unsigned match_start; /* start of matching string */ -static int eofile; /* flag set at end of input file */ -static unsigned lookahead; /* number of valid bytes ahead in window */ +static unsigned strstart; /* start of string to insert */ +static unsigned match_start; /* start of matching string */ +static int eofile; /* flag set at end of input file */ +static unsigned lookahead; /* number of valid bytes ahead in window */ -static const unsigned max_chain_length=4096; +static const unsigned max_chain_length = 4096; /* To speed up deflation, hash chains are never searched beyond this length. * A higher limit improves compression ratio but degrades the speed. */ -static const unsigned int max_lazy_match=258; +static const unsigned int max_lazy_match = 258; /* Attempt to find a better match only when the current match is strictly * smaller than this value. This mechanism is used only for compression @@ -788,7 +789,7 @@ static const unsigned int max_lazy_match=258; * max_insert_length is used only for compression levels <= 3. */ -static const unsigned good_match=32; +static const unsigned good_match = 32; /* Use a faster search when the previous match is longer than this */ @@ -799,7 +800,7 @@ static const unsigned good_match=32; * found for specific files. */ -static const int nice_match=258; /* Stop searching when current match exceeds this */ +static const int nice_match = 258; /* Stop searching when current match exceeds this */ /* Note: the deflate() code requires max_lazy >= MIN_MATCH and max_chain >= 4 * For deflate_fast() (levels <= 3) good is ignored and lazy has a different @@ -812,12 +813,12 @@ static const int nice_match=258; /* Stop searching when current match exceeds /* =========================================================================== * Prototypes for local functions. */ -static void fill_window (void); +static void fill_window(void); -static int longest_match (IPos cur_match); +static int longest_match(IPos cur_match); #ifdef DEBUG -static void check_match (IPos start, IPos match, int length); +static void check_match(IPos start, IPos match, int length); #endif /* =========================================================================== @@ -844,7 +845,7 @@ static void check_match (IPos start, IPos match, int length); /* =========================================================================== * Initialize the "longest match" routines for a new file */ -static void lm_init(ush *flags) +static void lm_init(ush * flags) { register unsigned j; @@ -897,11 +898,10 @@ static int longest_match(IPos cur_match) { unsigned chain_length = max_chain_length; /* max hash chain length */ register uch *scan = window + strstart; /* current string */ - register uch *match; /* matched string */ - register int len; /* length of current match */ + register uch *match; /* matched string */ + register int len; /* length of current match */ int best_len = prev_length; /* best match length so far */ IPos limit = - strstart > (IPos) MAX_DIST ? strstart - (IPos) MAX_DIST : NIL; /* Stop when cur_match becomes <= limit. To simplify the code, * we prevent matches with the string of window index 0. @@ -921,8 +921,7 @@ static int longest_match(IPos cur_match) if (prev_length >= good_match) { chain_length >>= 2; } - Assert(strstart <= window_size - MIN_LOOKAHEAD, - "insufficient lookahead"); + Assert(strstart <= window_size - MIN_LOOKAHEAD, "insufficient lookahead"); do { Assert(cur_match < strstart, "no future"); @@ -951,8 +950,7 @@ static int longest_match(IPos cur_match) } while (*++scan == *++match && *++scan == *++match && *++scan == *++match && *++scan == *++match && *++scan == *++match && *++scan == *++match && - *++scan == *++match && *++scan == *++match && - scan < strend); + *++scan == *++match && *++scan == *++match && scan < strend); len = MAX_MATCH - (int) (strend - scan); scan = strend - MAX_MATCH; @@ -1007,7 +1005,6 @@ static void fill_window() { register unsigned n, m; unsigned more = - (unsigned) (window_size - (ulg) lookahead - (ulg) strstart); /* Amount of free space at the end of the window. */ @@ -1027,7 +1024,7 @@ static void fill_window() memcpy((char *) window, (char *) window + WSIZE, (unsigned) WSIZE); match_start -= WSIZE; - strstart -= WSIZE; /* we now have strstart >= MAX_DIST: */ + strstart -= WSIZE; /* we now have strstart >= MAX_DIST: */ block_start -= (long) WSIZE; @@ -1070,9 +1067,9 @@ static void fill_window() */ static ulg deflate() { - IPos hash_head; /* head of hash chain */ - IPos prev_match; /* previous match */ - int flush; /* set if current block must be flushed */ + IPos hash_head; /* head of hash chain */ + IPos prev_match; /* previous match */ + int flush; /* set if current block must be flushed */ int match_available = 0; /* set if previous match exists */ register unsigned match_length = MIN_MATCH - 1; /* length of best match */ @@ -1100,8 +1097,7 @@ static ulg deflate() match_length = lookahead; /* Ignore a length 3 match if it is too distant: */ - if (match_length == MIN_MATCH - && strstart - match_start > TOO_FAR) { + if (match_length == MIN_MATCH && strstart - match_start > TOO_FAR) { /* If prev_match is also MIN_MATCH, match_start is garbage * but we will ignore the current match anyway. */ @@ -1116,8 +1112,7 @@ static ulg deflate() check_match(strstart - 1, prev_match, prev_length); flush = - ct_tally(strstart - 1 - prev_match, - prev_length - MIN_MATCH); + ct_tally(strstart - 1 - prev_match, prev_length - MIN_MATCH); /* Insert in hash table all strings up to the end of the match. * strstart-1 and strstart are already inserted. @@ -1171,7 +1166,7 @@ static ulg deflate() if (match_available) ct_tally(0, window[strstart - 1]); - return FLUSH_BLOCK(1); /* eof */ + return FLUSH_BLOCK(1); /* eof */ } /* gzip (GNU zip) -- compress files with zip algorithm and 'compress' interface @@ -1201,9 +1196,6 @@ typedef struct dirent dir_type; typedef RETSIGTYPE(*sig_type) (int); /* ======================================================================== */ -// int main (argc, argv) -// int argc; -// char **argv; int gzip_main(int argc, char **argv) { int result; @@ -1223,9 +1215,16 @@ int gzip_main(int argc, char **argv) case 'f': force = 1; break; - /* Ignore 1-9 (compression level) options */ - case '1': case '2': case '3': case '4': case '5': - case '6': case '7': case '8': case '9': + /* Ignore 1-9 (compression level) options */ + case '1': + case '2': + case '3': + case '4': + case '5': + case '6': + case '7': + case '8': + case '9': break; case 'q': break; @@ -1284,7 +1283,7 @@ int gzip_main(int argc, char **argv) outFileNum = STDOUT_FILENO; } else { inFileNum = open(argv[i], O_RDONLY); - if (inFileNum < 0 || fstat (inFileNum, &statBuf) < 0) + if (inFileNum < 0 || fstat(inFileNum, &statBuf) < 0) perror_msg_and_die("%s", argv[i]); time_stamp = statBuf.st_ctime; ifile_size = statBuf.st_size; @@ -1296,7 +1295,8 @@ int gzip_main(int argc, char **argv) /* Open output file */ #if (__GLIBC__ >= 2) && (__GLIBC_MINOR__ >= 1) - outFileNum = open(path, O_RDWR | O_CREAT | O_EXCL | O_NOFOLLOW); + outFileNum = + open(path, O_RDWR | O_CREAT | O_EXCL | O_NOFOLLOW); #else outFileNum = open(path, O_RDWR | O_CREAT | O_EXCL); #endif @@ -1313,7 +1313,8 @@ int gzip_main(int argc, char **argv) } if (path == NULL && isatty(outFileNum) && force == 0) { - error_msg("compressed data not written to a terminal. Use -f to force compression."); + error_msg + ("compressed data not written to a terminal. Use -f to force compression."); free(path); continue; } @@ -1321,8 +1322,8 @@ int gzip_main(int argc, char **argv) result = zip(inFileNum, outFileNum); if (path != NULL) { - close (inFileNum); - close (outFileNum); + close(inFileNum); + close(outFileNum); /* Delete the original file */ if (result == OK) @@ -1338,7 +1339,7 @@ int gzip_main(int argc, char **argv) } } - return(exit_code); + return (exit_code); } /* trees.c -- output deflated data using Huffman coding @@ -1427,17 +1428,19 @@ int gzip_main(int argc, char **argv) typedef uch extra_bits_t; /* 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, - 4, 4, 5, 5, 5, 5, 0 }; + 4, 4, 5, 5, 5, 5, 0 +}; /* 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, - 10, 10, 11, 11, 12, 12, 13, 13 }; + 10, 10, 11, 11, 12, 12, 13, 13 +}; /* 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 }; #define STORED_BLOCK 0 @@ -1487,16 +1490,21 @@ static const extra_bits_t extra_blbits[BL_CODES] #define REPZ_3_10 17 /* repeat a zero length 3-10 times (3 bits of repeat count) */ #define REPZ_11_138 18 -/* repeat a zero length 11-138 times (7 bits of repeat count) *//* =========================================================================== +/* repeat a zero length 11-138 times (7 bits of repeat count) */ + +/* =========================================================================== * Local data - *//* Data structure describing a single value and its code string. */ typedef struct ct_data { + */ + +/* Data structure describing a single value and its code string. */ +typedef struct ct_data { union { - ush freq; /* frequency count */ - ush code; /* bit string */ + ush freq; /* frequency count */ + ush code; /* bit string */ } fc; union { - ush dad; /* father node in Huffman tree */ - ush len; /* length of bit string */ + ush dad; /* father node in Huffman tree */ + ush len; /* length of bit string */ } dl; } ct_data; @@ -1530,25 +1538,27 @@ static ct_data bl_tree[2 * BL_CODES + 1]; /* Huffman tree for the bit lengths */ typedef struct tree_desc { - ct_data *dyn_tree; /* the dynamic tree */ + ct_data *dyn_tree; /* the dynamic tree */ ct_data *static_tree; /* corresponding static tree or NULL */ - const extra_bits_t *extra_bits; /* extra bits for each code or NULL */ - int extra_base; /* base index for extra_bits */ - int elems; /* max number of elements in the tree */ - int max_length; /* max bit length for the codes */ - int max_code; /* largest code with non zero frequency */ + const extra_bits_t *extra_bits; /* extra bits for each code or NULL */ + int extra_base; /* base index for extra_bits */ + int elems; /* max number of elements in the tree */ + int max_length; /* max bit length for the codes */ + int max_code; /* largest code with non zero frequency */ } tree_desc; static tree_desc l_desc = { dyn_ltree, static_ltree, extra_lbits, LITERALS + 1, L_CODES, - MAX_BITS, 0 }; + MAX_BITS, 0 +}; static tree_desc d_desc = { dyn_dtree, static_dtree, extra_dbits, 0, D_CODES, MAX_BITS, 0 }; static tree_desc bl_desc = { bl_tree, (ct_data *) 0, extra_blbits, 0, BL_CODES, MAX_BL_BITS, - 0 }; + 0 +}; static ush bl_count[MAX_BITS + 1]; @@ -1563,8 +1573,8 @@ static const uch bl_order[BL_CODES] */ static int heap[2 * L_CODES + 1]; /* heap used to build the Huffman trees */ -static int heap_len; /* number of elements in the heap */ -static int heap_max; /* element of largest frequency */ +static int heap_len; /* number of elements in the heap */ +static int heap_max; /* element of largest frequency */ /* The sons of heap[n] are heap[2*n] and heap[2*n+1]. heap[0] is not used. * The same heap array is used to build all trees. @@ -1604,41 +1614,41 @@ static uch flag_buf[(LIT_BUFSIZE / 8)]; * l_buf, thus indicating the presence or absence of a distance. */ -static unsigned last_lit; /* running index in l_buf */ -static unsigned last_dist; /* running index in d_buf */ -static unsigned last_flags; /* running index in flag_buf */ -static uch flags; /* current flags not yet saved in flag_buf */ -static uch flag_bit; /* current bit used in flags */ +static unsigned last_lit; /* running index in l_buf */ +static unsigned last_dist; /* running index in d_buf */ +static unsigned last_flags; /* running index in flag_buf */ +static uch flags; /* current flags not yet saved in flag_buf */ +static uch flag_bit; /* current bit used in flags */ /* bits are filled in flags starting at bit 0 (least significant). * Note: these flags are overkill in the current code since we don't * take advantage of DIST_BUFSIZE == LIT_BUFSIZE. */ -static ulg opt_len; /* bit length of current block with optimal trees */ -static ulg static_len; /* bit length of current block with static trees */ +static ulg opt_len; /* bit length of current block with optimal trees */ +static ulg static_len; /* bit length of current block with static trees */ -static ulg compressed_len; /* total bit length of compressed file */ +static ulg compressed_len; /* total bit length of compressed file */ -static ush *file_type; /* pointer to UNKNOWN, BINARY or ASCII */ -static int *file_method; /* pointer to DEFLATE or STORE */ +static ush *file_type; /* pointer to UNKNOWN, BINARY or ASCII */ +static int *file_method; /* pointer to DEFLATE or STORE */ /* =========================================================================== * Local (static) routines in this file. */ -static void init_block (void); -static void pqdownheap (ct_data * tree, int k); -static void gen_bitlen (tree_desc * desc); -static void gen_codes (ct_data * tree, int max_code); -static void build_tree (tree_desc * desc); -static void scan_tree (ct_data * tree, int max_code); -static void send_tree (ct_data * tree, int max_code); -static int build_bl_tree (void); -static void send_all_trees (int lcodes, int dcodes, int blcodes); -static void compress_block (ct_data * ltree, ct_data * dtree); -static void set_file_type (void); +static void init_block(void); +static void pqdownheap(ct_data * tree, int k); +static void gen_bitlen(tree_desc * desc); +static void gen_codes(ct_data * tree, int max_code); +static void build_tree(tree_desc * desc); +static void scan_tree(ct_data * tree, int max_code); +static void send_tree(ct_data * tree, int max_code); +static int build_bl_tree(void); +static void send_all_trees(int lcodes, int dcodes, int blcodes); +static void compress_block(ct_data * ltree, ct_data * dtree); +static void set_file_type(void); #ifndef DEBUG @@ -1665,20 +1675,20 @@ static void set_file_type (void); * location of the internal file attribute (ascii/binary) and method * (DEFLATE/STORE). */ -static void ct_init(ush *attr, int *methodp) +static void ct_init(ush * attr, int *methodp) { - int n; /* iterates over tree elements */ - int bits; /* bit counter */ - int length; /* length value */ - int code; /* code value */ - int dist; /* distance index */ + int n; /* iterates over tree elements */ + int bits; /* bit counter */ + int length; /* length value */ + int code; /* code value */ + int dist; /* distance index */ file_type = attr; file_method = methodp; compressed_len = 0L; if (static_dtree[0].Len != 0) - return; /* ct_init already called */ + return; /* ct_init already called */ /* Initialize the mapping length (0..255) -> length code (0..28) */ length = 0; @@ -1704,7 +1714,7 @@ static void ct_init(ush *attr, int *methodp) } } Assert(dist == 256, "ct_init: dist != 256"); - dist >>= 7; /* from now on, all distances are divided by 128 */ + dist >>= 7; /* from now on, all distances are divided by 128 */ for (; code < D_CODES; code++) { base_dist[code] = dist << 7; for (n = 0; n < (1 << (extra_dbits[code] - 7)); n++) { @@ -1746,7 +1756,7 @@ static void ct_init(ush *attr, int *methodp) */ static void init_block() { - int n; /* iterates over tree elements */ + int n; /* iterates over tree elements */ /* Initialize the trees. */ for (n = 0; n < L_CODES; n++) @@ -1792,10 +1802,10 @@ static void init_block() * when the heap property is re-established (each father smaller than its * two sons). */ -static void pqdownheap(ct_data *tree, int k) +static void pqdownheap(ct_data * tree, int k) { int v = heap[k]; - int j = k << 1; /* left son of k */ + int j = k << 1; /* left son of k */ while (j <= heap_len) { /* Set j to the smallest of the two sons: */ @@ -1826,7 +1836,7 @@ static void pqdownheap(ct_data *tree, int k) * The length opt_len is updated; static_len is also updated if stree is * not null. */ -static void gen_bitlen(tree_desc *desc) +static void gen_bitlen(tree_desc * desc) { ct_data *tree = desc->dyn_tree; const extra_bits_t *extra = desc->extra_bits; @@ -1834,12 +1844,12 @@ static void gen_bitlen(tree_desc *desc) int max_code = desc->max_code; int max_length = desc->max_length; ct_data *stree = desc->static_tree; - int h; /* heap index */ - int n, m; /* iterate over the tree elements */ - int bits; /* bit length */ - int xbits; /* extra bits */ - ush f; /* frequency */ - int overflow = 0; /* number of elements with bit length too large */ + int h; /* heap index */ + int n, m; /* iterate over the tree elements */ + int bits; /* bit length */ + int xbits; /* extra bits */ + ush f; /* frequency */ + int overflow = 0; /* number of elements with bit length too large */ for (bits = 0; bits <= MAX_BITS; bits++) bl_count[bits] = 0; @@ -1858,7 +1868,7 @@ static void gen_bitlen(tree_desc *desc) /* We overwrite tree[n].Dad which is no longer needed */ if (n > max_code) - continue; /* not a leaf node */ + continue; /* not a leaf node */ bl_count[bits]++; xbits = 0; @@ -1881,7 +1891,7 @@ static void gen_bitlen(tree_desc *desc) bits = max_length - 1; while (bl_count[bits] == 0) bits--; - bl_count[bits]--; /* move one leaf down the tree */ + bl_count[bits]--; /* move one leaf down the tree */ bl_count[bits + 1] += 2; /* move one overflow item as its brother */ bl_count[max_length]--; /* The brother of the overflow item also moves one step up, @@ -1902,12 +1912,10 @@ static void gen_bitlen(tree_desc *desc) if (m > max_code) continue; if (tree[m].Len != (unsigned) bits) { - Trace( - (stderr, "code %d bits %d->%d\n", m, tree[m].Len, + Trace((stderr, "code %d bits %d->%d\n", m, tree[m].Len, bits)); opt_len += - ((long) bits - - (long) tree[m].Len) * (long) tree[m].Freq; + ((long) bits - (long) tree[m].Len) * (long) tree[m].Freq; tree[m].Len = (ush) bits; } n--; @@ -1923,12 +1931,12 @@ static void gen_bitlen(tree_desc *desc) * OUT assertion: the field code is set for all tree elements of non * zero code length. */ -static void gen_codes(ct_data *tree, int max_code) +static void gen_codes(ct_data * tree, int max_code) { ush next_code[MAX_BITS + 1]; /* next code value for each bit length */ - ush code = 0; /* running code value */ - int bits; /* bit index */ - int n; /* code index */ + ush code = 0; /* running code value */ + int bits; /* bit index */ + int n; /* code index */ /* The distribution counts are first used to generate the code values * without bit reversal. @@ -1966,14 +1974,14 @@ static void gen_codes(ct_data *tree, int max_code) * 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. */ -static void build_tree(tree_desc *desc) +static void build_tree(tree_desc * desc) { ct_data *tree = desc->dyn_tree; ct_data *stree = desc->static_tree; int elems = desc->elems; - int n, m; /* iterate over heap elements */ - int max_code = -1; /* largest code with non zero frequency */ - int node = elems; /* next internal node of the tree */ + int n, m; /* iterate over heap elements */ + int max_code = -1; /* largest code with non zero frequency */ + int node = elems; /* next internal node of the tree */ /* Construct the initial heap, with least frequent element in * heap[SMALLEST]. The sons of heap[n] are heap[2*n] and heap[2*n+1]. @@ -2017,8 +2025,8 @@ static void build_tree(tree_desc *desc) * frequent nodes. */ do { - pqremove(tree, n); /* n = node of least frequency */ - m = heap[SMALLEST]; /* m = node of next least frequency */ + pqremove(tree, n); /* n = node of least frequency */ + m = heap[SMALLEST]; /* m = node of next least frequency */ heap[--heap_max] = n; /* keep the nodes sorted by frequency */ heap[--heap_max] = m; @@ -2030,8 +2038,7 @@ static void build_tree(tree_desc *desc) #ifdef DUMP_BL_TREE if (tree == bl_tree) { fprintf(stderr, "\nnode %d(%d), sons %d(%d) %d(%d)", - node, tree[node].Freq, n, tree[n].Freq, m, - tree[m].Freq); + node, tree[node].Freq, n, tree[n].Freq, m, tree[m].Freq); } #endif /* and insert the new node in the heap */ @@ -2057,15 +2064,15 @@ static void build_tree(tree_desc *desc) * counts. (The contribution of the bit length codes will be added later * during the construction of bl_tree.) */ -static void scan_tree(ct_data *tree, int max_code) +static void scan_tree(ct_data * tree, int max_code) { - int n; /* iterates over all tree elements */ - int prevlen = -1; /* last emitted length */ - int curlen; /* length of current code */ + int n; /* iterates over all tree elements */ + int prevlen = -1; /* last emitted length */ + int curlen; /* length of current code */ int nextlen = tree[0].Len; /* length of next code */ - int count = 0; /* repeat count of the current code */ - int max_count = 7; /* max repeat count */ - int min_count = 4; /* min repeat count */ + int count = 0; /* repeat count of the current code */ + int max_count = 7; /* max repeat count */ + int min_count = 4; /* min repeat count */ if (nextlen == 0) max_count = 138, min_count = 3; @@ -2103,15 +2110,15 @@ static void scan_tree(ct_data *tree, int max_code) * Send a literal or distance tree in compressed form, using the codes in * bl_tree. */ -static void send_tree(ct_data *tree, int max_code) +static void send_tree(ct_data * tree, int max_code) { - int n; /* iterates over all tree elements */ - int prevlen = -1; /* last emitted length */ - int curlen; /* length of current code */ + int n; /* iterates over all tree elements */ + int prevlen = -1; /* last emitted length */ + int curlen; /* length of current code */ int nextlen = tree[0].Len; /* length of next code */ - int count = 0; /* repeat count of the current code */ - int max_count = 7; /* max repeat count */ - int min_count = 4; /* min repeat count */ + int count = 0; /* repeat count of the current code */ + int max_count = 7; /* max repeat count */ + int min_count = 4; /* min repeat count */ /* tree[max_code+1].Len = -1; *//* guard already set */ if (nextlen == 0) @@ -2162,7 +2169,7 @@ static void send_tree(ct_data *tree, int max_code) */ static const int build_bl_tree() { - int max_blindex; /* index of last bit length code of non zero freq */ + int max_blindex; /* index of last bit length code of non zero freq */ /* Determine the bit length frequencies for literal and distance trees */ scan_tree((ct_data *) dyn_ltree, l_desc.max_code); @@ -2184,9 +2191,7 @@ static const int build_bl_tree() } /* Update opt_len to include the bit length tree and counts */ opt_len += 3 * (max_blindex + 1) + 5 + 5 + 4; - Tracev( - (stderr, "\ndyn trees: dyn %ld, stat %ld", opt_len, - static_len)); + Tracev((stderr, "\ndyn trees: dyn %ld, stat %ld", opt_len, static_len)); return max_blindex; } @@ -2198,10 +2203,9 @@ static const int build_bl_tree() */ static void send_all_trees(int lcodes, int dcodes, int blcodes) { - int rank; /* index in bl_order */ + int rank; /* index in bl_order */ - Assert(lcodes >= 257 && dcodes >= 1 - && blcodes >= 4, "not enough codes"); + Assert(lcodes >= 257 && dcodes >= 1 && blcodes >= 4, "not enough codes"); Assert(lcodes <= L_CODES && dcodes <= D_CODES && blcodes <= BL_CODES, "too many codes"); Tracev((stderr, "\nbl counts: ")); @@ -2229,7 +2233,7 @@ static void send_all_trees(int lcodes, int dcodes, int blcodes) static ulg flush_block(char *buf, ulg stored_len, int eof) { ulg opt_lenb, static_lenb; /* opt_len and static_len in bytes */ - int max_blindex; /* index of last bit length code of non zero freq */ + int max_blindex; /* index of last bit length code of non zero freq */ flag_buf[last_flags] = flags; /* Save the flags for the last 8 items */ @@ -2242,9 +2246,7 @@ static ulg flush_block(char *buf, ulg stored_len, int eof) Tracev((stderr, "\nlit data: dyn %ld, stat %ld", opt_len, static_len)); build_tree((tree_desc *) (&d_desc)); - Tracev( - (stderr, "\ndist data: dyn %ld, stat %ld", opt_len, - static_len)); + Tracev((stderr, "\ndist data: dyn %ld, stat %ld", opt_len, static_len)); /* At this point, opt_len and static_len are the total bit lengths of * the compressed block data, excluding the tree representations. */ @@ -2258,8 +2260,7 @@ static ulg flush_block(char *buf, ulg stored_len, int eof) opt_lenb = (opt_len + 3 + 7) >> 3; static_lenb = (static_len + 3 + 7) >> 3; - Trace( - (stderr, + Trace((stderr, "\nopt %lu(%lu) stat %lu(%lu) stored %lu lit %u dist %u ", opt_lenb, opt_len, static_lenb, static_len, stored_len, last_lit, last_dist)); @@ -2271,8 +2272,7 @@ static ulg flush_block(char *buf, ulg stored_len, int eof) * and if the zip file can be seeked (to rewrite the local header), * the whole file is transformed into a stored file: */ - if (stored_len <= opt_lenb && eof && compressed_len == 0L - && seekable()) { + if (stored_len <= opt_lenb && eof && compressed_len == 0L && seekable()) { /* Since LIT_BUFSIZE <= 2*WSIZE, the input data must be there: */ if (buf == (char *) 0) error_msg("block vanished"); @@ -2297,15 +2297,13 @@ static ulg flush_block(char *buf, ulg stored_len, int eof) } else if (static_lenb == opt_lenb) { send_bits((STATIC_TREES << 1) + eof, 3); - compress_block((ct_data *) static_ltree, - (ct_data *) static_dtree); + compress_block((ct_data *) static_ltree, (ct_data *) static_dtree); compressed_len += 3 + static_len; } else { send_bits((DYN_TREES << 1) + eof, 3); send_all_trees(l_desc.max_code + 1, d_desc.max_code + 1, max_blindex + 1); - compress_block((ct_data *) dyn_ltree, - (ct_data *) dyn_dtree); + compress_block((ct_data *) dyn_ltree, (ct_data *) dyn_dtree); compressed_len += 3 + opt_len; } Assert(compressed_len == bits_sent, "bad compressed size"); @@ -2333,7 +2331,7 @@ static int ct_tally(int dist, int lc) dyn_ltree[lc].Freq++; } else { /* Here, lc is the match length - MIN_MATCH */ - dist--; /* dist = match distance - 1 */ + dist--; /* dist = match distance - 1 */ Assert((ush) dist < (ush) MAX_DIST && (ush) lc <= (ush) (MAX_MATCH - MIN_MATCH) && (ush) d_code(dist) < (ush) D_CODES, "ct_tally: bad match"); @@ -2363,8 +2361,7 @@ static int ct_tally(int dist, int lc) (ulg) dyn_dtree[dcode].Freq * (5L + extra_dbits[dcode]); } out_length >>= 3; - Trace( - (stderr, + Trace((stderr, "\nlast_lit %u, last_dist %u, in %ld, out ~%ld(%ld%%) ", last_lit, last_dist, in_length, out_length, 100L - out_length * 100L / in_length)); @@ -2381,16 +2378,16 @@ static int ct_tally(int dist, int lc) /* =========================================================================== * Send the block data compressed using the given Huffman trees */ -static void compress_block(ct_data *ltree, ct_data *dtree) +static void compress_block(ct_data * ltree, ct_data * dtree) { - unsigned dist; /* distance of matched string */ - int lc; /* match length or unmatched char (if dist == 0) */ - unsigned lx = 0; /* running index in l_buf */ - unsigned dx = 0; /* running index in d_buf */ - unsigned fx = 0; /* running index in flag_buf */ - uch flag = 0; /* current flags */ - unsigned code; /* the code to send */ - int extra; /* number of extra bits to send */ + unsigned dist; /* distance of matched string */ + int lc; /* match length or unmatched char (if dist == 0) */ + unsigned lx = 0; /* running index in l_buf */ + unsigned dx = 0; /* running index in d_buf */ + unsigned fx = 0; /* running index in flag_buf */ + uch flag = 0; /* current flags */ + unsigned code; /* the code to send */ + int extra; /* number of extra bits to send */ if (last_lit != 0) do { @@ -2420,7 +2417,7 @@ static void compress_block(ct_data *ltree, ct_data *dtree) dist -= base_dist[code]; send_bits(dist, extra); /* send the extra distance bits */ } - } /* literal or match pair ? */ + } /* literal or match pair ? */ flag >>= 1; } while (lx < last_lit); @@ -2458,13 +2455,13 @@ static void set_file_type() */ -static ulg crc; /* crc on uncompressed file data */ -static long header_bytes; /* number of bytes in gzip header */ +static ulg crc; /* crc on uncompressed file data */ +static long header_bytes; /* number of bytes in gzip header */ static void put_long(ulg n) { put_short((n) & 0xffff); - put_short(((ulg)(n)) >> 16); + put_short(((ulg) (n)) >> 16); } /* put_header_byte is used for the compressed output @@ -2479,9 +2476,9 @@ static void put_long(ulg n) */ static int zip(int in, int out) { - uch my_flags = 0; /* general purpose bit flags */ - ush attr = 0; /* ascii/binary flag */ - ush deflate_flags = 0; /* pkzip -es, -en or -ex equivalent */ + uch my_flags = 0; /* general purpose bit flags */ + ush attr = 0; /* ascii/binary flag */ + ush deflate_flags = 0; /* pkzip -es, -en or -ex equivalent */ ifd = in; ofd = out; @@ -2491,11 +2488,11 @@ static int zip(int in, int out) method = DEFLATED; - put_header_byte(GZIP_MAGIC[0]); /* magic header */ + put_header_byte(GZIP_MAGIC[0]); /* magic header */ put_header_byte(GZIP_MAGIC[1]); - put_header_byte(DEFLATED); /* compression method */ + put_header_byte(DEFLATED); /* compression method */ - put_header_byte(my_flags); /* general flags */ + put_header_byte(my_flags); /* general flags */ put_long(time_stamp); /* Write deflated file to zip file */ @@ -2506,7 +2503,7 @@ static int zip(int in, int out) lm_init(&deflate_flags); put_byte((uch) deflate_flags); /* extra flags */ - put_byte(OS_CODE); /* OS identifier */ + put_byte(OS_CODE); /* OS identifier */ header_bytes = (long) outcnt; |