gzip cleanup part #4

1 files changed, 39 insertions, 35 deletions

diff --git a/archival/gzip.c b/archival/gzip.c
index dcbcae0b3..4f47a2782 100644
--- a/archival/gzip.c
+++ b/archival/gzip.c
@@ -61,12 +61,6 @@ aa:      85.1% -- replaced with aa.gz
 #  endif
 #endif
 
-#define PACK_MAGIC     "\037\036"       /* Magic header for packed files */
-#define GZIP_MAGIC     "\037\213"       /* Magic header for gzip files, 1F 8B */
-#define OLD_GZIP_MAGIC "\037\236"       /* Magic header for gzip 0.5 = freeze 1.x */
-#define LZH_MAGIC      "\037\240"       /* Magic header for SCO LZH Compress files */
-#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 */
@@ -142,9 +136,9 @@ aa:      85.1% -- replaced with aa.gz
 #  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 ;}
+#  define Tracevv(x) {if (verbose > 1) fprintf x ;}
 #  define Tracec(c,x) {if (verbose && (c)) fprintf x ;}
-#  define Tracecv(c,x) {if (verbose>1 && (c)) fprintf x ;}
+#  define Tracecv(c,x) {if (verbose > 1 && (c)) fprintf x ;}
 #else
 #  define Assert(cond,msg)
 #  define Trace(x)
@@ -313,7 +307,7 @@ static void clear_bufs(void)
  * pointer, then initialize the crc shift register contents instead.
  * Return the current crc in either case.
  */
-static uint32_t crc = ~0;       /* shift register contents */
+static uint32_t crc;    /* shift register contents */
 static uint32_t updcrc(uch * s, unsigned n)
 {
         uint32_t c;             /* temporary variable */
@@ -1414,17 +1408,18 @@ 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)
-   /* Send a code of the given tree. c and tree must not have side effects */
-
 #else                                                   /* DEBUG */
 #  define send_code(c, tree) \
-     { if (verbose>1) bb_error_msg("\ncd %3d ",(c)); \
-       send_bits(tree[c].Code, tree[c].Len); }
+{ \
+        if (verbose > 1) bb_error_msg("\ncd %3d ",(c)); \
+        send_bits(tree[c].Code, tree[c].Len); \
+}
 #endif
 
 #define d_code(dist) \
-   ((dist) < 256 ? dist_code[dist] : dist_code[256+((dist)>>7)])
+        ((dist) < 256 ? dist_code[dist] : dist_code[256 + ((dist)>>7)])
 /* Mapping from a distance to a distance code. dist is the distance - 1 and
  * must not have side effects. dist_code[256] and dist_code[257] are never
  * used.
@@ -1432,6 +1427,7 @@ static void set_file_type(void);
 
 /* the arguments must not have side effects */
 
+
 /* ===========================================================================
  * Allocate the match buffer, initialize the various tables and save the
  * location of the internal file attribute (ascii/binary) and method
@@ -1513,12 +1509,13 @@ static void ct_init(ush * attr, int *methodp)
         init_block();
 }
 
+
 /* ===========================================================================
  * Initialize a new 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++)
@@ -1535,28 +1532,22 @@ static void init_block(void)
         flag_bit = 1;
 }
 
-#define SMALLEST 1
-/* Index within the heap array of least frequent node in the Huffman tree */
-
 
 /* ===========================================================================
  * 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); \
+{ \
+        top = heap[SMALLEST]; \
+        heap[SMALLEST] = heap[heap_len--]; \
+        pqdownheap(tree, SMALLEST); \
 }
 
-/* ===========================================================================
- * 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) \
-   (tree[n].Freq < tree[m].Freq || \
-   (tree[n].Freq == tree[m].Freq && depth[n] <= depth[m]))
 
 /* ===========================================================================
  * Restore the heap property by moving down the tree starting at node k,
@@ -1564,6 +1555,14 @@ static void init_block(void)
  * when the heap property is re-established (each father smaller than its
  * two sons).
  */
+
+/* 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) \
+        (tree[n].Freq < tree[m].Freq \
+        || (tree[n].Freq == tree[m].Freq && depth[n] <= depth[m]))
+
 static void pqdownheap(ct_data * tree, int k)
 {
         int v = heap[k];
@@ -1588,6 +1587,7 @@ static void pqdownheap(ct_data * tree, int k)
         heap[k] = v;
 }
 
+
 /* ===========================================================================
  * Compute the optimal bit lengths for a tree and update the total bit length
  * for the current block.
@@ -1624,8 +1624,10 @@ static void gen_bitlen(tree_desc * desc)
         for (h = heap_max + 1; h < HEAP_SIZE; h++) {
                 n = heap[h];
                 bits = tree[tree[n].Dad].Len + 1;
-                if (bits > max_length)
-                        bits = max_length, overflow++;
+                if (bits > max_length) {
+                        bits = max_length;
+                        overflow++;
+                }
                 tree[n].Len = (ush) bits;
                 /* We overwrite tree[n].Dad which is no longer needed */
 
@@ -2151,7 +2153,7 @@ static void compress_block(ct_data * ltree, ct_data * dtree)
         unsigned code;          /* the code to send */
         int extra;                      /* number of extra bits to send */
 
-        if (last_lit != 0)
+        if (last_lit != 0) {
                 do {
                         if ((lx & 7) == 0)
                                 flag = flag_buf[fx++];
@@ -2182,6 +2184,7 @@ static void compress_block(ct_data * ltree, ct_data * dtree)
                         }                       /* literal or match pair ? */
                         flag >>= 1;
                 } while (lx < last_lit);
+        }
 
         send_code(END_BLOCK, ltree);
 }
@@ -2204,7 +2207,7 @@ static void set_file_type(void)
                 ascii_freq += dyn_ltree[n++].Freq;
         while (n < LITERALS)
                 bin_freq += dyn_ltree[n++].Freq;
-        *file_type = bin_freq > (ascii_freq >> 2) ? BINARY : ASCII;
+        *file_type = (bin_freq > (ascii_freq >> 2)) ? BINARY : ASCII;
         if (*file_type == BINARY && translate_eol) {
                 bb_error_msg("-l used on binary file");
         }
@@ -2228,8 +2231,9 @@ static int zip(int in, int out)
         /* Write the header to the gzip file. See algorithm.doc for the format */
 
         method = DEFLATED;
-        put_header_byte(GZIP_MAGIC[0]); /* magic header */
-        put_header_byte(GZIP_MAGIC[1]);
+        put_header_byte(0x1f);  /* magic header for gzip files, 1F 8B */
+        put_header_byte(0x8b);
+
         put_header_byte(DEFLATED);      /* compression method */
 
         put_header_byte(my_flags);      /* general flags */