gzip cleanup part #9

1 files changed, 84 insertions, 105 deletions

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