X-Git-Url: https://git.librecmc.org/?a=blobdiff_plain;f=archival%2Fgzip.c;h=05f6cb5821fbc637255053e0989ab0d40811c740;hb=03721973851afbe02bbc1cdc56ee6002631c4df6;hp=fed93907bdab8ea02488b7b848839e487b61cff0;hpb=9bd49d6a22a31bd3b5e3e3dcaacdb8a019630506;p=oweals%2Fbusybox.git

diff --git a/archival/gzip.c b/archival/gzip.c
index fed93907b..05f6cb582 100644
--- a/archival/gzip.c
+++ b/archival/gzip.c
@@ -9,31 +9,14 @@
  *		only standard in to standard out with -9 compression.  It also requires
  *		the zcat module for some important functions."
  *
- * Adjusted further by Erik Andersen <andersen@lineo.com>, <andersee@debian.org>
- * to support files as well as stdin/stdout, and to generally behave itself wrt
+ * Adjusted further by Erik Andersen <andersen@codepoet.org> to support
+ * files as well as stdin/stdout, and to generally behave itself wrt
  * command line handling.
  *
- * This program is free software; you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation; either version 2 of the License, or
- * (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
- * General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program; if not, write to the Free Software
- * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
- *
+ * Licensed under GPLv2 or later, see file LICENSE in this tarball for details.
  */
 
-/* These defines are very important for BusyBox.  Without these,
- * huge chunks of ram are pre-allocated making the BusyBox bss 
- * size Freaking Huge(tm), which is a bad thing.*/
 #define SMALL_MEM
-#define DYN_ALLOC
 
 #include <stdlib.h>
 #include <stdio.h>
@@ -51,12 +34,6 @@
 #include <time.h>
 #include "busybox.h"
 
-#define memzero(s, n)     memset ((void *)(s), 0, (n))
-
-#ifndef RETSIGTYPE
-#  define RETSIGTYPE void
-#endif
-
 typedef unsigned char uch;
 typedef unsigned short ush;
 typedef unsigned long ulg;
@@ -71,7 +48,6 @@ typedef unsigned long ulg;
 #define STORED      0
 /* methods 4 to 7 reserved */
 #define DEFLATED    8
-static int method;				/* compression method */
 
 /* To save memory for 16 bit systems, some arrays are overlaid between
  * the various modules:
@@ -88,7 +64,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 +73,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
@@ -107,30 +83,24 @@ static int method;				/* compression method */
 #  endif
 #endif
 
-#ifdef DYN_ALLOC
 #  define DECLARE(type, array, size)  static type * array
 #  define ALLOC(type, array, size) { \
-      array = (type*)xcalloc((size_t)(((size)+1L)/2), 2*sizeof(type)); \
+      array = (type*)xzalloc((size_t)(((size)+1L)/2) * 2*sizeof(type)); \
    }
-#  define FREE(array) {if (array != NULL) free(array), array=NULL;}
-#else
-#  define DECLARE(type, array, size)  static type array[size]
-#  define ALLOC(type, array, size)
-#  define FREE(array)
-#endif
+#  define FREE(array) {free(array), array=NULL;}
 
 #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 +110,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 +123,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
@@ -174,21 +144,12 @@ typedef int file_t;				/* Do not use stdio */
 #define put_byte(c) {outbuf[outcnt++]=(uch)(c); if (outcnt==OUTBUFSIZ)\
    flush_outbuf();}
 
-
-/* Output a 32 bit value to the bit stream, lsb first */
-#if 0
-#define put_long(n) { \
-    put_short((n) & 0xffff); \
-    put_short(((ulg)(n)) >> 16); \
-}
-#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
-#  define Assert(cond,msg) {if(!(cond)) error_msg(msg);}
+#  define Assert(cond,msg) {if(!(cond)) bb_error_msg(msg);}
 #  define Trace(x) fprintf x
 #  define Tracev(x) {if (verbose) fprintf x ;}
 #  define Tracevv(x) {if (verbose>1) fprintf x ;}
@@ -212,31 +173,28 @@ 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);
-
-	/* from gzip.c */
-static RETSIGTYPE abort_gzip (void);
+static int zip(int in, int out);
+static int file_read(char *buf, unsigned size);
 
 		/* 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.
@@ -244,16 +202,12 @@ static void flush_outbuf (void);
  * terms of the GNU General Public License, see the file COPYING.
  */
 
-#if !defined(OF) && defined(lint)
-#  include "gzip.h"
-#endif
-
 #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 +231,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
@@ -306,39 +260,37 @@ DECLARE(ush, d_buf, DIST_BUFSIZE);
 DECLARE(uch, window, 2L * WSIZE);
 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 long time_stamp;	/* original time stamp (modification time) */
 static char z_suffix[MAX_SUFFIX + 1];	/* default suffix (can be set with --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 */
+#ifdef DEBUG
+static unsigned insize;	/* valid bytes in inbuf */
+#endif
+static unsigned outcnt;	/* bytes in output buffer */
 
+static uint32_t *crc_32_tab;
 
 /* 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));
+	}
 }
 
 /* ========================================================================
  * Signal and error handler.
  */
-static void abort_gzip()
+static void abort_gzip(int ATTRIBUTE_UNUSED ignored)
 {
 	exit(ERROR);
 }
@@ -349,17 +301,12 @@ static void abort_gzip()
 static void clear_bufs(void)
 {
 	outcnt = 0;
+#ifdef DEBUG
 	insize = 0;
+#endif
 	bytes_in = 0L;
 }
 
-static void write_error_msg(void)
-{
-	fprintf(stderr, "\n");
-	perror("");
-	abort_gzip();
-}
-
 /* ===========================================================================
  * Does the same as write(), but also handles partial pipe writes and checks
  * for error return.
@@ -369,9 +316,7 @@ static void write_buf(int fd, void *buf, unsigned cnt)
 	unsigned n;
 
 	while ((n = write(fd, buf, cnt)) != cnt) {
-		if (n == (unsigned) (-1)) {
-			write_error_msg();
-		}
+		if (n == (unsigned) (-1)) bb_error_msg_and_die(bb_msg_write_error);
 		cnt -= n;
 		buf = (void *) ((char *) buf + n);
 	}
@@ -382,32 +327,13 @@ 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 uint32_t updcrc(uch * s, unsigned n)
 {
-	static ulg crc = (ulg) 0xffffffffL;	/* shift register contents */
-	register ulg c;				/* temporary variable */
-	static unsigned long crc_32_tab[256];
-	if (crc_table_empty) {
-		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 */
-
-		/* 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
-		     */
-			for (k = 8; k; k--)
-				csr = csr & 1 ? (csr >> 1) ^ e : csr >> 1;
-			crc_32_tab[i]=csr;
-		}
-	}
+	static uint32_t crc = ~0;	/* shift register contents */
+	uint32_t c;		/* temporary variable */
 
 	if (s == NULL) {
-		c = 0xffffffffL;
+		c = ~0;
 	} else {
 		c = crc;
 		if (n)
@@ -416,7 +342,7 @@ static ulg updcrc(uch *s, unsigned n)
 			} while (--n);
 	}
 	crc = c;
-	return c ^ 0xffffffffL;		/* (instead of ~c for 64-bit machines) */
+	return ~c;
 }
 
 /* bits.c -- output variable-length bit strings
@@ -476,7 +402,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 +420,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
 
 /* ===========================================================================
@@ -550,7 +476,7 @@ static void send_bits(int value, int length)
  */
 static unsigned bi_reverse(unsigned code, int len)
 {
-	register unsigned res = 0;
+	unsigned res = 0;
 
 	do {
 		res |= code & 1;
@@ -562,7 +488,7 @@ static unsigned bi_reverse(unsigned code, int len)
 /* ===========================================================================
  * Write out any remaining bits in an incomplete byte.
  */
-static void bi_windup()
+static void bi_windup(void)
 {
 	if (bi_valid > 8) {
 		put_short(bi_buf);
@@ -582,7 +508,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);
@@ -635,7 +561,7 @@ static void copy_block(char *buf, unsigned len, int header)
  *      However the F&G algorithm may be faster for some highly redundant
  *      files if the parameter max_chain_length (described below) is too large.
  *
- *  ACKNOWLEDGEMENTS
+ *  ACKNOWLEDGMENTS
  *
  *      The idea of lazy evaluation of matches is due to Jan-Mark Wams, and
  *      I found it in 'freeze' written by Leonid Broukhis.
@@ -676,7 +602,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 +676,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,30 +691,31 @@ 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;
+enum {
+	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;
+	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
  * levels >= 4.
  */
-#define max_insert_length  max_lazy_match
+	max_insert_length = max_lazy_match,
 /* Insert new strings in the hash table only if the match length
  * is not greater than this length. This saves time but degrades compression.
  * max_insert_length is used only for compression levels <= 3.
  */
 
-static const unsigned good_match=32;
+	good_match = 32,
 
 /* Use a faster search when the previous match is longer than this */
 
@@ -799,12 +726,13 @@ static const unsigned good_match=32;
  * found for specific files.
  */
 
-static const int nice_match=258;			/* Stop searching when current match exceeds this */
+	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
  * meaning.
  */
+};
 
 #define EQUAL 0
 /* result of memcmp for equal strings */
@@ -812,12 +740,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,12 +772,12 @@ 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;
+	unsigned j;
 
 	/* Initialize the hash table. */
-	memzero((char *) head, HASH_SIZE * sizeof(*head));
+	memset(head, 0, HASH_SIZE * sizeof(*head));
 	/* prev will be initialized on the fly */
 
 	*flags |= SLOW;
@@ -896,12 +824,11 @@ static void lm_init(ush *flags)
 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 */
+	uch *scan = window + strstart;	/* current string */
+	uch *match;	/* matched string */
+	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.
@@ -913,16 +840,15 @@ static int longest_match(IPos cur_match)
 #if HASH_BITS < 8 || MAX_MATCH != 258
 #  error Code too clever
 #endif
-	register uch *strend = window + strstart + MAX_MATCH;
-	register uch scan_end1 = scan[best_len - 1];
-	register uch scan_end = scan[best_len];
+	uch *strend = window + strstart + MAX_MATCH;
+	uch scan_end1 = scan[best_len - 1];
+	uch scan_end = scan[best_len];
 
 	/* Do not waste too much time if we already have a good 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 +877,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;
@@ -980,12 +905,11 @@ static void check_match(IPos start, IPos match, int length)
 	/* check that the match is indeed a match */
 	if (memcmp((char *) window + match,
 			   (char *) window + start, length) != EQUAL) {
-		fprintf(stderr,
-				" start %d, match %d, length %d\n", start, match, length);
-		error_msg("invalid match");
+		bb_error_msg(" start %d, match %d, length %d", start, match, length);
+		bb_error_msg("invalid match");
 	}
 	if (verbose > 1) {
-		fprintf(stderr, "\\[%d,%d]", start - match, length);
+		bb_error_msg("\\[%d,%d]", start - match, length);
 		do {
 			putc(window[start++], stderr);
 		} while (--length != 0);
@@ -1003,11 +927,10 @@ static void check_match(IPos start, IPos match, int length)
  *    file reads are performed for at least two bytes (required for the
  *    translate_eol option).
  */
-static void fill_window()
+static void fill_window(void)
 {
-	register unsigned n, m;
+	unsigned n, m;
 	unsigned more =
-
 		(unsigned) (window_size - (ulg) lookahead - (ulg) strstart);
 	/* Amount of free space at the end of the window. */
 
@@ -1027,7 +950,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;
 
@@ -1061,20 +984,20 @@ static void fill_window()
  */
 #define FLUSH_BLOCK(eof) \
    flush_block(block_start >= 0L ? (char*)&window[(unsigned)block_start] : \
-                (char*)NULL, (long)strstart - block_start, (eof))
+		(char*)NULL, (long)strstart - block_start, (eof))
 
 /* ===========================================================================
  * Same as above, but achieves better compression. We use a lazy
  * evaluation for matches: a match is finally adopted only if there is
  * no better match at the next window position.
  */
-static ulg deflate()
+static ulg deflate(void)
 {
-	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 */
+	unsigned match_length = MIN_MATCH - 1;	/* length of best match */
 
 	/* Process the input block. */
 	while (lookahead != 0) {
@@ -1100,8 +1023,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 +1038,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 +1092,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
@@ -1198,64 +1119,57 @@ static ulg deflate()
 
 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)
 {
+	enum {
+		OPT_tostdout = 0x1,
+		OPT_force = 0x2,
+	};
+
+	unsigned long opt;
 	int result;
 	int inFileNum;
 	int outFileNum;
 	struct stat statBuf;
 	char *delFileName;
-	int tostdout = 0;
-	int force = 0;
-	int opt;
-
-	while ((opt = getopt(argc, argv, "cf123456789dq")) != -1) {
-		switch (opt) {
-		case 'c':
-			tostdout = 1;
-			break;
-		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':
-			break;
-		case 'q':
-			break;
-#ifdef CONFIG_GUNZIP
-		case 'd':
-			optind = 1;
-			return gunzip_main(argc, argv);
-#endif
-		default:
-			show_usage();
-		}
+
+	opt = bb_getopt_ulflags(argc, argv, "cf123456789q" USE_GUNZIP("d"));
+	//if (opt & 0x1) // -c
+	//if (opt & 0x2) // -f
+	/* Ignore 1-9 (compression level) options */
+	//if (opt & 0x4) // -1
+	//if (opt & 0x8) // -2
+	//if (opt & 0x10) // -3
+	//if (opt & 0x20) // -4
+	//if (opt & 0x40) // -5
+	//if (opt & 0x80) // -6
+	//if (opt & 0x100) // -7
+	//if (opt & 0x200) // -8
+	//if (opt & 0x400) // -9
+	//if (opt & 0x800) // -q
+	if (ENABLE_GUNZIP && (opt & 0x1000)) { // -d
+		/* FIXME: bb_getopt_ulflags should not depend on optind */
+		optind = 1;
+		return gunzip_main(argc, argv);
 	}
 
 	foreground = signal(SIGINT, SIG_IGN) != SIG_IGN;
 	if (foreground) {
-		(void) signal(SIGINT, (sig_type) abort_gzip);
+		(void) signal(SIGINT, abort_gzip);
 	}
 #ifdef SIGTERM
 	if (signal(SIGTERM, SIG_IGN) != SIG_IGN) {
-		(void) signal(SIGTERM, (sig_type) abort_gzip);
+		(void) signal(SIGTERM, abort_gzip);
 	}
 #endif
 #ifdef SIGHUP
 	if (signal(SIGHUP, SIG_IGN) != SIG_IGN) {
-		(void) signal(SIGHUP, (sig_type) abort_gzip);
+		(void) signal(SIGHUP, abort_gzip);
 	}
 #endif
 
 	strncpy(z_suffix, Z_SUFFIX, sizeof(z_suffix) - 1);
-	z_len = strlen(z_suffix);
 
 	/* Allocate all global buffers (for DYN_ALLOC option) */
 	ALLOC(uch, inbuf, INBUFSIZ + INBUF_EXTRA);
@@ -1264,12 +1178,13 @@ int gzip_main(int argc, char **argv)
 	ALLOC(uch, window, 2L * WSIZE);
 	ALLOC(ush, tab_prefix, 1L << BITS);
 
+	/* Initialise the CRC32 table */
+	crc_32_tab = crc32_filltable(0);
+
 	clear_bufs();
-	part_nb = 0;
 
 	if (optind == argc) {
 		time_stamp = 0;
-		ifile_size = -1L;
 		zip(STDIN_FILENO, STDOUT_FILENO);
 	} else {
 		int i;
@@ -1277,31 +1192,29 @@ int gzip_main(int argc, char **argv)
 		for (i = optind; i < argc; i++) {
 			char *path = NULL;
 
+			clear_bufs();
 			if (strcmp(argv[i], "-") == 0) {
 				time_stamp = 0;
-				ifile_size = -1L;
 				inFileNum = STDIN_FILENO;
 				outFileNum = STDOUT_FILENO;
 			} else {
-				inFileNum = open(argv[i], O_RDONLY);
-				if (inFileNum < 0 || fstat (inFileNum, &statBuf) < 0)
-					perror_msg_and_die("%s", argv[i]);
+				inFileNum = xopen(argv[i], O_RDONLY);
+				if (fstat(inFileNum, &statBuf) < 0)
+					bb_perror_msg_and_die("%s", argv[i]);
 				time_stamp = statBuf.st_ctime;
-				ifile_size = statBuf.st_size;
 
-				if (!tostdout) {
-					path = xmalloc(strlen(argv[i]) + 4);
-					strcpy(path, argv[i]);
-					strcat(path, ".gz");
+				if (!(opt & OPT_tostdout)) {
+					path = xasprintf("%s.gz", argv[i]);
 
 					/* Open output file */
-#if (__GLIBC__ >= 2) && (__GLIBC_MINOR__ >= 1)
-					outFileNum = open(path, O_RDWR | O_CREAT | O_EXCL | O_NOFOLLOW);
+#if (__GLIBC__ >= 2) && (__GLIBC_MINOR__ >= 1) && defined O_NOFOLLOW
+					outFileNum =
+						open(path, O_RDWR | O_CREAT | O_EXCL | O_NOFOLLOW);
 #else
 					outFileNum = open(path, O_RDWR | O_CREAT | O_EXCL);
 #endif
 					if (outFileNum < 0) {
-						perror_msg("%s", path);
+						bb_perror_msg("%s", path);
 						free(path);
 						continue;
 					}
@@ -1312,8 +1225,9 @@ int gzip_main(int argc, char **argv)
 					outFileNum = STDOUT_FILENO;
 			}
 
-			if (path == NULL && force == 0) {
-				perror_msg("compressed data not written to a terminal. Use -f to force compression.");
+			if (path == NULL && isatty(outFileNum) && !(opt & OPT_force)) {
+				bb_error_msg
+					("compressed data not written to a terminal. Use -f to force compression.");
 				free(path);
 				continue;
 			}
@@ -1321,8 +1235,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)
@@ -1331,14 +1245,14 @@ int gzip_main(int argc, char **argv)
 					delFileName = path;
 
 				if (unlink(delFileName) < 0)
-					perror_msg("%s", delFileName);
+					bb_perror_msg("%s", delFileName);
 			}
 
 			free(path);
 		}
 	}
 
-	return(exit_code);
+	return (exit_code);
 }
 
 /* trees.c -- output deflated data using Huffman coding
@@ -1427,17 +1341,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 +1403,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 +1451,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 +1486,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 +1527,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
@@ -1647,7 +1570,7 @@ static void set_file_type (void);
 
 #else							/* DEBUG */
 #  define send_code(c, tree) \
-     { if (verbose>1) fprintf(stderr,"\ncd %3d ",(c)); \
+     { if (verbose>1) bb_error_msg("\ncd %3d ",(c)); \
        send_bits(tree[c].Code, tree[c].Len); }
 #endif
 
@@ -1665,20 +1588,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 +1627,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++) {
@@ -1744,9 +1667,9 @@ static void ct_init(ush *attr, int *methodp)
 /* ===========================================================================
  * Initialize a new block.
  */
-static void init_block()
+static void init_block(void)
 {
-	int n;						/* iterates over tree elements */
+	int n;				/* iterates over tree elements */
 
 	/* Initialize the trees. */
 	for (n = 0; n < L_CODES; n++)
@@ -1792,10 +1715,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 +1749,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 +1757,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 +1781,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 +1804,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 +1825,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 +1844,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 +1887,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 +1938,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;
@@ -2029,9 +1950,8 @@ static void build_tree(tree_desc *desc)
 		tree[n].Dad = tree[m].Dad = (ush) node;
 #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);
+			bb_error_msg("\nnode %d(%d), sons %d(%d) %d(%d)",
+					node, tree[node].Freq, n, tree[n].Freq, m, tree[m].Freq);
 		}
 #endif
 		/* and insert the new node in the heap */
@@ -2057,15 +1977,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 +2023,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)
@@ -2160,9 +2080,9 @@ static void send_tree(ct_data *tree, int max_code)
  * Construct the Huffman tree for the bit lengths and return the index in
  * bl_order of the last bit length code to send.
  */
-static const int build_bl_tree()
+static int build_bl_tree(void)
 {
-	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 +2104,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 +2116,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 +2146,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 +2159,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 +2173,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,11 +2185,10 @@ 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");
+			bb_error_msg("block vanished");
 
 		copy_block(buf, (unsigned) stored_len, 0);	/* without header */
 		compressed_len = stored_len << 3;
@@ -2297,15 +2210,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 +2244,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 +2274,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 +2291,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 +2330,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);
 
@@ -2433,7 +2343,7 @@ static void compress_block(ct_data *ltree, ct_data *dtree)
  * IN assertion: the fields freq of dyn_ltree are set and the total of all
  * frequencies does not exceed 64K (to fit in an int on 16 bit machines).
  */
-static void set_file_type()
+static void set_file_type(void)
 {
 	int n = 0;
 	unsigned ascii_freq = 0;
@@ -2447,7 +2357,7 @@ static void set_file_type()
 		bin_freq += dyn_ltree[n++].Freq;
 	*file_type = bin_freq > (ascii_freq >> 2) ? BINARY : ASCII;
 	if (*file_type == BINARY && translate_eol) {
-		error_msg("-l used on binary file");
+		bb_error_msg("-l used on binary file");
 	}
 }
 
@@ -2458,13 +2368,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 uint32_t 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 +2389,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 +2401,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 +2416,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;
 
@@ -2546,7 +2456,7 @@ static int file_read(char *buf, unsigned size)
  * Write the output buffer outbuf[0..outcnt-1] and update bytes_out.
  * (used for the compressed data only)
  */
-static void flush_outbuf()
+static void flush_outbuf(void)
 {
 	if (outcnt == 0)
 		return;