zlib: clean up some dead code
Cleanup unused `if 0'-ed functions, which have been dead since 2006 (commits87c2ce3b93("lib/zlib*: cleanups") by Adrian Bunk and4f3865fb57("zlib_inflate: Upgrade library code to a recent version") by Richard Purdie): - zlib_deflateSetDictionary - zlib_deflateParams - zlib_deflateCopy - zlib_inflateSync - zlib_syncsearch - zlib_inflateSetDictionary - zlib_inflatePrime Signed-off-by: Sergey Senozhatsky <sergey.senozhatsky@gmail.com> Signed-off-by: Andrew Morton <akpm@linux-foundation.org> Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
This commit is contained in:
Sergey Senozhatsky
committed by
Linus Torvalds
Linus Torvalds
parent
0f9859ca92
commit
62e7ca5280
@@ -249,52 +249,6 @@ int zlib_deflateInit2(
|
||||
return zlib_deflateReset(strm);
|
||||
}
|
||||
|
||||
/* ========================================================================= */
|
||||
#if 0
|
||||
int zlib_deflateSetDictionary(
|
||||
z_streamp strm,
|
||||
const Byte *dictionary,
|
||||
uInt dictLength
|
||||
)
|
||||
{
|
||||
deflate_state *s;
|
||||
uInt length = dictLength;
|
||||
uInt n;
|
||||
IPos hash_head = 0;
|
||||
|
||||
if (strm == NULL || strm->state == NULL || dictionary == NULL)
|
||||
return Z_STREAM_ERROR;
|
||||
|
||||
s = (deflate_state *) strm->state;
|
||||
if (s->status != INIT_STATE) return Z_STREAM_ERROR;
|
||||
|
||||
strm->adler = zlib_adler32(strm->adler, dictionary, dictLength);
|
||||
|
||||
if (length < MIN_MATCH) return Z_OK;
|
||||
if (length > MAX_DIST(s)) {
|
||||
length = MAX_DIST(s);
|
||||
#ifndef USE_DICT_HEAD
|
||||
dictionary += dictLength - length; /* use the tail of the dictionary */
|
||||
#endif
|
||||
}
|
||||
memcpy((char *)s->window, dictionary, length);
|
||||
s->strstart = length;
|
||||
s->block_start = (long)length;
|
||||
|
||||
/* Insert all strings in the hash table (except for the last two bytes).
|
||||
* s->lookahead stays null, so s->ins_h will be recomputed at the next
|
||||
* call of fill_window.
|
||||
*/
|
||||
s->ins_h = s->window[0];
|
||||
UPDATE_HASH(s, s->ins_h, s->window[1]);
|
||||
for (n = 0; n <= length - MIN_MATCH; n++) {
|
||||
INSERT_STRING(s, n, hash_head);
|
||||
}
|
||||
if (hash_head) hash_head = 0; /* to make compiler happy */
|
||||
return Z_OK;
|
||||
}
|
||||
#endif /* 0 */
|
||||
|
||||
/* ========================================================================= */
|
||||
int zlib_deflateReset(
|
||||
z_streamp strm
|
||||
@@ -326,45 +280,6 @@ int zlib_deflateReset(
|
||||
return Z_OK;
|
||||
}
|
||||
|
||||
/* ========================================================================= */
|
||||
#if 0
|
||||
int zlib_deflateParams(
|
||||
z_streamp strm,
|
||||
int level,
|
||||
int strategy
|
||||
)
|
||||
{
|
||||
deflate_state *s;
|
||||
compress_func func;
|
||||
int err = Z_OK;
|
||||
|
||||
if (strm == NULL || strm->state == NULL) return Z_STREAM_ERROR;
|
||||
s = (deflate_state *) strm->state;
|
||||
|
||||
if (level == Z_DEFAULT_COMPRESSION) {
|
||||
level = 6;
|
||||
}
|
||||
if (level < 0 || level > 9 || strategy < 0 || strategy > Z_HUFFMAN_ONLY) {
|
||||
return Z_STREAM_ERROR;
|
||||
}
|
||||
func = configuration_table[s->level].func;
|
||||
|
||||
if (func != configuration_table[level].func && strm->total_in != 0) {
|
||||
/* Flush the last buffer: */
|
||||
err = zlib_deflate(strm, Z_PARTIAL_FLUSH);
|
||||
}
|
||||
if (s->level != level) {
|
||||
s->level = level;
|
||||
s->max_lazy_match = configuration_table[level].max_lazy;
|
||||
s->good_match = configuration_table[level].good_length;
|
||||
s->nice_match = configuration_table[level].nice_length;
|
||||
s->max_chain_length = configuration_table[level].max_chain;
|
||||
}
|
||||
s->strategy = strategy;
|
||||
return err;
|
||||
}
|
||||
#endif /* 0 */
|
||||
|
||||
/* =========================================================================
|
||||
* Put a short in the pending buffer. The 16-bit value is put in MSB order.
|
||||
* IN assertion: the stream state is correct and there is enough room in
|
||||
@@ -568,64 +483,6 @@ int zlib_deflateEnd(
|
||||
return status == BUSY_STATE ? Z_DATA_ERROR : Z_OK;
|
||||
}
|
||||
|
||||
/* =========================================================================
|
||||
* Copy the source state to the destination state.
|
||||
*/
|
||||
#if 0
|
||||
int zlib_deflateCopy (
|
||||
z_streamp dest,
|
||||
z_streamp source
|
||||
)
|
||||
{
|
||||
#ifdef MAXSEG_64K
|
||||
return Z_STREAM_ERROR;
|
||||
#else
|
||||
deflate_state *ds;
|
||||
deflate_state *ss;
|
||||
ush *overlay;
|
||||
deflate_workspace *mem;
|
||||
|
||||
|
||||
if (source == NULL || dest == NULL || source->state == NULL) {
|
||||
return Z_STREAM_ERROR;
|
||||
}
|
||||
|
||||
ss = (deflate_state *) source->state;
|
||||
|
||||
*dest = *source;
|
||||
|
||||
mem = (deflate_workspace *) dest->workspace;
|
||||
|
||||
ds = &(mem->deflate_memory);
|
||||
|
||||
dest->state = (struct internal_state *) ds;
|
||||
*ds = *ss;
|
||||
ds->strm = dest;
|
||||
|
||||
ds->window = (Byte *) mem->window_memory;
|
||||
ds->prev = (Pos *) mem->prev_memory;
|
||||
ds->head = (Pos *) mem->head_memory;
|
||||
overlay = (ush *) mem->overlay_memory;
|
||||
ds->pending_buf = (uch *) overlay;
|
||||
|
||||
memcpy(ds->window, ss->window, ds->w_size * 2 * sizeof(Byte));
|
||||
memcpy(ds->prev, ss->prev, ds->w_size * sizeof(Pos));
|
||||
memcpy(ds->head, ss->head, ds->hash_size * sizeof(Pos));
|
||||
memcpy(ds->pending_buf, ss->pending_buf, (uInt)ds->pending_buf_size);
|
||||
|
||||
ds->pending_out = ds->pending_buf + (ss->pending_out - ss->pending_buf);
|
||||
ds->d_buf = overlay + ds->lit_bufsize/sizeof(ush);
|
||||
ds->l_buf = ds->pending_buf + (1+sizeof(ush))*ds->lit_bufsize;
|
||||
|
||||
ds->l_desc.dyn_tree = ds->dyn_ltree;
|
||||
ds->d_desc.dyn_tree = ds->dyn_dtree;
|
||||
ds->bl_desc.dyn_tree = ds->bl_tree;
|
||||
|
||||
return Z_OK;
|
||||
#endif
|
||||
}
|
||||
#endif /* 0 */
|
||||
|
||||
/* ===========================================================================
|
||||
* Read a new buffer from the current input stream, update the adler32
|
||||
* and total number of bytes read. All deflate() input goes through
|
||||
|
||||
@@ -45,21 +45,6 @@ int zlib_inflateReset(z_streamp strm)
|
||||
return Z_OK;
|
||||
}
|
||||
|
||||
#if 0
|
||||
int zlib_inflatePrime(z_streamp strm, int bits, int value)
|
||||
{
|
||||
struct inflate_state *state;
|
||||
|
||||
if (strm == NULL || strm->state == NULL) return Z_STREAM_ERROR;
|
||||
state = (struct inflate_state *)strm->state;
|
||||
if (bits > 16 || state->bits + bits > 32) return Z_STREAM_ERROR;
|
||||
value &= (1L << bits) - 1;
|
||||
state->hold += value << state->bits;
|
||||
state->bits += bits;
|
||||
return Z_OK;
|
||||
}
|
||||
#endif
|
||||
|
||||
int zlib_inflateInit2(z_streamp strm, int windowBits)
|
||||
{
|
||||
struct inflate_state *state;
|
||||
@@ -761,123 +746,6 @@ int zlib_inflateEnd(z_streamp strm)
|
||||
return Z_OK;
|
||||
}
|
||||
|
||||
#if 0
|
||||
int zlib_inflateSetDictionary(z_streamp strm, const Byte *dictionary,
|
||||
uInt dictLength)
|
||||
{
|
||||
struct inflate_state *state;
|
||||
unsigned long id;
|
||||
|
||||
/* check state */
|
||||
if (strm == NULL || strm->state == NULL) return Z_STREAM_ERROR;
|
||||
state = (struct inflate_state *)strm->state;
|
||||
if (state->wrap != 0 && state->mode != DICT)
|
||||
return Z_STREAM_ERROR;
|
||||
|
||||
/* check for correct dictionary id */
|
||||
if (state->mode == DICT) {
|
||||
id = zlib_adler32(0L, NULL, 0);
|
||||
id = zlib_adler32(id, dictionary, dictLength);
|
||||
if (id != state->check)
|
||||
return Z_DATA_ERROR;
|
||||
}
|
||||
|
||||
/* copy dictionary to window */
|
||||
zlib_updatewindow(strm, strm->avail_out);
|
||||
|
||||
if (dictLength > state->wsize) {
|
||||
memcpy(state->window, dictionary + dictLength - state->wsize,
|
||||
state->wsize);
|
||||
state->whave = state->wsize;
|
||||
}
|
||||
else {
|
||||
memcpy(state->window + state->wsize - dictLength, dictionary,
|
||||
dictLength);
|
||||
state->whave = dictLength;
|
||||
}
|
||||
state->havedict = 1;
|
||||
return Z_OK;
|
||||
}
|
||||
#endif
|
||||
|
||||
#if 0
|
||||
/*
|
||||
Search buf[0..len-1] for the pattern: 0, 0, 0xff, 0xff. Return when found
|
||||
or when out of input. When called, *have is the number of pattern bytes
|
||||
found in order so far, in 0..3. On return *have is updated to the new
|
||||
state. If on return *have equals four, then the pattern was found and the
|
||||
return value is how many bytes were read including the last byte of the
|
||||
pattern. If *have is less than four, then the pattern has not been found
|
||||
yet and the return value is len. In the latter case, zlib_syncsearch() can be
|
||||
called again with more data and the *have state. *have is initialized to
|
||||
zero for the first call.
|
||||
*/
|
||||
static unsigned zlib_syncsearch(unsigned *have, unsigned char *buf,
|
||||
unsigned len)
|
||||
{
|
||||
unsigned got;
|
||||
unsigned next;
|
||||
|
||||
got = *have;
|
||||
next = 0;
|
||||
while (next < len && got < 4) {
|
||||
if ((int)(buf[next]) == (got < 2 ? 0 : 0xff))
|
||||
got++;
|
||||
else if (buf[next])
|
||||
got = 0;
|
||||
else
|
||||
got = 4 - got;
|
||||
next++;
|
||||
}
|
||||
*have = got;
|
||||
return next;
|
||||
}
|
||||
#endif
|
||||
|
||||
#if 0
|
||||
int zlib_inflateSync(z_streamp strm)
|
||||
{
|
||||
unsigned len; /* number of bytes to look at or looked at */
|
||||
unsigned long in, out; /* temporary to save total_in and total_out */
|
||||
unsigned char buf[4]; /* to restore bit buffer to byte string */
|
||||
struct inflate_state *state;
|
||||
|
||||
/* check parameters */
|
||||
if (strm == NULL || strm->state == NULL) return Z_STREAM_ERROR;
|
||||
state = (struct inflate_state *)strm->state;
|
||||
if (strm->avail_in == 0 && state->bits < 8) return Z_BUF_ERROR;
|
||||
|
||||
/* if first time, start search in bit buffer */
|
||||
if (state->mode != SYNC) {
|
||||
state->mode = SYNC;
|
||||
state->hold <<= state->bits & 7;
|
||||
state->bits -= state->bits & 7;
|
||||
len = 0;
|
||||
while (state->bits >= 8) {
|
||||
buf[len++] = (unsigned char)(state->hold);
|
||||
state->hold >>= 8;
|
||||
state->bits -= 8;
|
||||
}
|
||||
state->have = 0;
|
||||
zlib_syncsearch(&(state->have), buf, len);
|
||||
}
|
||||
|
||||
/* search available input */
|
||||
len = zlib_syncsearch(&(state->have), strm->next_in, strm->avail_in);
|
||||
strm->avail_in -= len;
|
||||
strm->next_in += len;
|
||||
strm->total_in += len;
|
||||
|
||||
/* return no joy or set up to restart inflate() on a new block */
|
||||
if (state->have != 4) return Z_DATA_ERROR;
|
||||
in = strm->total_in; out = strm->total_out;
|
||||
zlib_inflateReset(strm);
|
||||
strm->total_in = in; strm->total_out = out;
|
||||
state->mode = TYPE;
|
||||
return Z_OK;
|
||||
}
|
||||
#endif
|
||||
|
||||
/*
|
||||
* This subroutine adds the data at next_in/avail_in to the output history
|
||||
* without performing any output. The output buffer must be "caught up";
|
||||
|
||||
Reference in New Issue
Block a user