Run through indent

1 files changed, 238 insertions, 241 deletions

diff --git a/archival/gzip.c b/archival/gzip.c
index 44b5fe3..60ff1f3 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;