* pointer, then initialize the crc shift register contents instead.
* Return the current crc in either case.
*/
-static void updcrc(uch * s, unsigned n)
+static void updcrc(uch *s, unsigned n)
{
G1.crc = crc32_block_endian0(G1.crc, s, n, global_crc32_table /*G1.crc_32_tab*/);
}
* Copy a stored block to the zip file, storing first the length and its
* one's complement if requested.
*/
-static void copy_block(char *buf, unsigned len, int header)
+static void copy_block(const char *buf, unsigned len, int header)
{
bi_windup(); /* align on byte boundary */
tree_desc d_desc;
tree_desc bl_desc;
- ush bl_count[MAX_BITS + 1];
+ /* was "ush", but "unsigned" results in smaller code */
+ unsigned bl_count[MAX_BITS + 1];
/* The lengths of the bit length codes are sent in order of decreasing
* probability, to avoid transmitting the lengths for unused bit length codes.
(tree[n].Freq < tree[m].Freq \
|| (tree[n].Freq == tree[m].Freq && G2.depth[n] <= G2.depth[m]))
-static void pqdownheap(ct_data * tree, int k)
+static void pqdownheap(const ct_data *tree, int k)
{
int v = G2.heap[k];
int j = k << 1; /* left son of 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(const tree_desc *desc)
{
- ct_data *tree = desc->dyn_tree;
- const uint8_t *extra = desc->extra_bits;
- int base = desc->extra_base;
- 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 */
-
- for (bits = 0; bits <= MAX_BITS; bits++)
+#define tree desc->dyn_tree
+ int h; /* heap index */
+ int n, m; /* iterate over the tree elements */
+ int bits; /* bit length */
+ int overflow; /* number of elements with bit length too large */
+
+ for (bits = 0; bits < ARRAY_SIZE(G2.bl_count); bits++)
G2.bl_count[bits] = 0;
/* In a first pass, compute the optimal bit lengths (which may
*/
tree[G2.heap[G2.heap_max]].Len = 0; /* root of the heap */
+ overflow = 0;
for (h = G2.heap_max + 1; h < HEAP_SIZE; h++) {
+ ulg f; /* frequency */
+ int xbits; /* extra bits */
+
n = G2.heap[h];
bits = tree[tree[n].Dad].Len + 1;
- if (bits > max_length) {
- bits = max_length;
+ if (bits > desc->max_length) {
+ bits = desc->max_length;
overflow++;
}
tree[n].Len = (ush) bits;
/* We overwrite tree[n].Dad which is no longer needed */
- if (n > max_code)
+ if (n > desc->max_code)
continue; /* not a leaf node */
G2.bl_count[bits]++;
xbits = 0;
- if (n >= base)
- xbits = extra[n - base];
+ if (n >= desc->extra_base)
+ xbits = desc->extra_bits[n - desc->extra_base];
f = tree[n].Freq;
- G2.opt_len += (ulg) f *(bits + xbits);
+ G2.opt_len += f * (bits + xbits);
- if (stree)
- G2.static_len += (ulg) f * (stree[n].Len + xbits);
+ if (desc->static_tree)
+ G2.static_len += f * (desc->static_tree[n].Len + xbits);
}
if (overflow == 0)
return;
/* Find the first bit length which could increase: */
do {
- bits = max_length - 1;
+ bits = desc->max_length - 1;
while (G2.bl_count[bits] == 0)
bits--;
G2.bl_count[bits]--; /* move one leaf down the tree */
G2.bl_count[bits + 1] += 2; /* move one overflow item as its brother */
- G2.bl_count[max_length]--;
+ G2.bl_count[desc->max_length]--;
/* The brother of the overflow item also moves one step up,
- * but this does not affect bl_count[max_length]
+ * but this does not affect bl_count[desc->max_length]
*/
overflow -= 2;
} while (overflow > 0);
* lengths instead of fixing only the wrong ones. This idea is taken
* from 'ar' written by Haruhiko Okumura.)
*/
- for (bits = max_length; bits != 0; bits--) {
+ for (bits = desc->max_length; bits != 0; bits--) {
n = G2.bl_count[bits];
while (n != 0) {
m = G2.heap[--h];
- if (m > max_code)
+ if (m > desc->max_code)
continue;
if (tree[m].Len != (unsigned) bits) {
Trace((stderr, "code %d bits %d->%d\n", m, tree[m].Len, bits));
n--;
}
}
+#undef tree
}
/* ===========================================================================
* 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 */
+ /* next_code[] and code used to be "ush", but "unsigned" results in smaller code */
+ unsigned next_code[MAX_BITS + 1]; /* next code value for each bit length */
+ unsigned 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.
pqdownheap(tree, SMALLEST); \
} while (0)
-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;
/* At this point, the fields freq and dad are set. We can now
* generate the bit lengths.
*/
- gen_bitlen((tree_desc *) desc);
+ gen_bitlen(desc);
/* The field len is now set, we can generate the bit codes */
- gen_codes((ct_data *) tree, max_code);
+ gen_codes(tree, max_code);
}
/* ===========================================================================
* 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 */
* 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(const ct_data *tree, int max_code)
{
int n; /* iterates over all tree elements */
int prevlen = -1; /* last emitted length */
/* ===========================================================================
* Send the block data compressed using the given Huffman trees
*/
-static void compress_block(ct_data * ltree, ct_data * dtree)
+static void compress_block(const ct_data *ltree, const ct_data *dtree)
{
unsigned dist; /* distance of matched string */
int lc; /* match length or unmatched char (if dist == 0) */
* trees or store, and output the encoded block to the zip file. This function
* returns the total compressed length for the file so far.
*/
-static void flush_block(char *buf, ulg stored_len, int eof)
+static void flush_block(const 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 */
projects / oweals / busybox.git / commitdiff