📄 inflate.c
字号:
#endif /* ?FUNZIP */
break;
if (G.dstrm.avail_in <= 0) {
if (fillinbuf(__G) == 0)
return 2; /* no "END-condition" yet, but no more data */
G.dstrm.next_in = G.inptr;
G.dstrm.avail_in = G.incnt;
}
Trace((stderr, " avail_in = %d\n", G.dstrm.avail_in));
}
FLUSH(wsize - G.dstrm.avail_out); /* flush slide[] */
Trace((stderr, "inside loop: flushing %ld bytes (ptr diff = %ld)\n",
(long)(wsize - G.dstrm.avail_out),
(long)(G.dstrm.next_out-(Bytef *)redirSlide)));
G.dstrm.next_out = redirSlide;
G.dstrm.avail_out = wsize;
}
/* no more input, so loop until we have all output */
Trace((stderr, "beginning final loop: err = %d\n", err));
while (err != Z_STREAM_END) {
err = inflate(&G.dstrm, Z_PARTIAL_FLUSH);
if (err == Z_DATA_ERROR)
return 2;
else if (err == Z_MEM_ERROR)
return 3;
else if (err == Z_BUF_ERROR) { /* DEBUG */
Trace((stderr, "zlib inflate() did not detect stream end (%s, %s)\n"
, G.zipfn, G.filename));
break;
} else if (err != Z_OK && err != Z_STREAM_END) {
Trace((stderr, "oops! (inflate(final loop) err = %d)\n", err));
DESTROYGLOBALS()
EXIT(PK_MEM3);
}
FLUSH(wsize - G.dstrm.avail_out); /* final flush of slide[] */
Trace((stderr, "final loop: flushing %ld bytes (ptr diff = %ld)\n",
(long)(wsize - G.dstrm.avail_out),
(long)(G.dstrm.next_out-(Bytef *)redirSlide)));
G.dstrm.next_out = redirSlide;
G.dstrm.avail_out = wsize;
}
Trace((stderr, "total in = %ld, total out = %ld\n", G.dstrm.total_in,
G.dstrm.total_out));
G.inptr = (uch *)G.dstrm.next_in;
G.incnt = (G.inbuf + INBUFSIZ) - G.inptr; /* reset for other routines */
err = inflateReset(&G.dstrm);
if (err != Z_OK)
Trace((stderr, "oops! (inflateReset() err = %d)\n", err));
return 0;
}
/*---------------------------------------------------------------------------*/
#else /* !USE_ZLIB */
/* Function prototypes */
#ifndef OF
# ifdef __STDC__
# define OF(a) a
# else
# define OF(a) ()
# endif
#endif /* !OF */
int inflate_codes OF((__GPRO__ struct huft *tl, struct huft *td,
int bl, int bd));
static int inflate_stored OF((__GPRO));
static int inflate_fixed OF((__GPRO));
static int inflate_dynamic OF((__GPRO));
static int inflate_block OF((__GPRO__ int *e));
/* The inflate algorithm uses a sliding 32K byte window on the uncompressed
stream to find repeated byte strings. This is implemented here as a
circular buffer. The index is updated simply by incrementing and then
and'ing with 0x7fff (32K-1). */
/* It is left to other modules to supply the 32K area. It is assumed
to be usable as if it were declared "uch slide[32768];" or as just
"uch *slide;" and then malloc'ed in the latter case. The definition
must be in unzip.h, included above. */
/* unsigned wp; moved to globals.h */ /* current position in slide */
/* Tables for deflate from PKZIP's appnote.txt. */
static ZCONST unsigned border[] = { /* Order of the bit length code lengths */
16, 17, 18, 0, 8, 7, 9, 6, 10, 5, 11, 4, 12, 3, 13, 2, 14, 1, 15};
static ZCONST ush cplens[] = { /* Copy lengths for literal codes 257..285 */
3, 4, 5, 6, 7, 8, 9, 10, 11, 13, 15, 17, 19, 23, 27, 31,
35, 43, 51, 59, 67, 83, 99, 115, 131, 163, 195, 227, 258, 0, 0};
/* note: see note #13 above about the 258 in this list. */
static ZCONST ush cplext[] = { /* Extra bits for literal codes 257..285 */
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, 99, 99}; /* 99==invalid */
static ZCONST ush cpdist[] = { /* Copy offsets for distance codes 0..29 */
1, 2, 3, 4, 5, 7, 9, 13, 17, 25, 33, 49, 65, 97, 129, 193,
257, 385, 513, 769, 1025, 1537, 2049, 3073, 4097, 6145,
8193, 12289, 16385, 24577};
static ZCONST ush cpdext[] = { /* Extra bits for distance 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};
/* moved to consts.h (included in unzip.c), resp. funzip.c */
#if 1
/* And'ing with mask_bits[n] masks the lower n bits */
ZCONST ush near mask_bits[] = {
0x0000,
0x0001, 0x0003, 0x0007, 0x000f, 0x001f, 0x003f, 0x007f, 0x00ff,
0x01ff, 0x03ff, 0x07ff, 0x0fff, 0x1fff, 0x3fff, 0x7fff, 0xffff
};
#endif /* 0 */
/* Macros for inflate() bit peeking and grabbing.
The usage is:
NEEDBITS(j)
x = b & mask_bits[j];
DUMPBITS(j)
where NEEDBITS makes sure that b has at least j bits in it, and
DUMPBITS removes the bits from b. The macros use the variable k
for the number of bits in b. Normally, b and k are register
variables for speed and are initialized at the begining of a
routine that uses these macros from a global bit buffer and count.
In order to not ask for more bits than there are in the compressed
stream, the Huffman tables are constructed to only ask for just
enough bits to make up the end-of-block code (value 256). Then no
bytes need to be "returned" to the buffer at the end of the last
block. See the huft_build() routine.
*/
/* These have been moved to globals.h */
#if 0
ulg bb; /* bit buffer */
unsigned bk; /* bits in bit buffer */
#endif
#ifndef CHECK_EOF
# define CHECK_EOF /* default as of 5.13/5.2 */
#endif
#ifndef CHECK_EOF
# define NEEDBITS(n) {while(k<(n)){b|=((ulg)NEXTBYTE)<<k;k+=8;}}
#else
# define NEEDBITS(n) {while(k<(n)){int c=NEXTBYTE;if(c==EOF)return 1;\
b|=((ulg)c)<<k;k+=8;}}
#endif /* Piet Plomp: change "return 1" to "break" */
#define DUMPBITS(n) {b>>=(n);k-=(n);}
/*
Huffman code decoding is performed using a multi-level table lookup.
The fastest way to decode is to simply build a lookup table whose
size is determined by the longest code. However, the time it takes
to build this table can also be a factor if the data being decoded
are not very long. The most common codes are necessarily the
shortest codes, so those codes dominate the decoding time, and hence
the speed. The idea is you can have a shorter table that decodes the
shorter, more probable codes, and then point to subsidiary tables for
the longer codes. The time it costs to decode the longer codes is
then traded against the time it takes to make longer tables.
This results of this trade are in the variables lbits and dbits
below. lbits is the number of bits the first level table for literal/
length codes can decode in one step, and dbits is the same thing for
the distance codes. Subsequent tables are also less than or equal to
those sizes. These values may be adjusted either when all of the
codes are shorter than that, in which case the longest code length in
bits is used, or when the shortest code is *longer* than the requested
table size, in which case the length of the shortest code in bits is
used.
There are two different values for the two tables, since they code a
different number of possibilities each. The literal/length table
codes 286 possible values, or in a flat code, a little over eight
bits. The distance table codes 30 possible values, or a little less
than five bits, flat. The optimum values for speed end up being
about one bit more than those, so lbits is 8+1 and dbits is 5+1.
The optimum values may differ though from machine to machine, and
possibly even between compilers. Your mileage may vary.
*/
static ZCONST int lbits = 9; /* bits in base literal/length lookup table */
static ZCONST int dbits = 6; /* bits in base distance lookup table */
#ifndef ASM_INFLATECODES
int inflate_codes(__G__ tl, td, bl, bd)
__GDEF
struct huft *tl, *td; /* literal/length and distance decoder tables */
int bl, bd; /* number of bits decoded by tl[] and td[] */
/* inflate (decompress) the codes in a deflated (compressed) block.
Return an error code or zero if it all goes ok. */
{
register unsigned e; /* table entry flag/number of extra bits */
unsigned n, d; /* length and index for copy */
unsigned w; /* current window position */
struct huft *t; /* pointer to table entry */
unsigned ml, md; /* masks for bl and bd bits */
register ulg b; /* bit buffer */
register unsigned k; /* number of bits in bit buffer */
/* make local copies of globals */
b = G.bb; /* initialize bit buffer */
k = G.bk;
w = G.wp; /* initialize window position */
/* inflate the coded data */
ml = mask_bits[bl]; /* precompute masks for speed */
md = mask_bits[bd];
while (1) /* do until end of block */
{
NEEDBITS((unsigned)bl)
if ((e = (t = tl + ((unsigned)b & ml))->e) > 16)
do {
if (e == 99)
return 1;
DUMPBITS(t->b)
e -= 16;
NEEDBITS(e)
} while ((e = (t = t->v.t + ((unsigned)b & mask_bits[e]))->e) > 16);
DUMPBITS(t->b)
if (e == 16) /* then it's a literal */
{
redirSlide[w++] = (uch)t->v.n;
if (w == wsize)
{
FLUSH(w);
w = 0;
}
}
else /* it's an EOB or a length */
{
/* exit if end of block */
if (e == 15)
break;
/* get length of block to copy */
NEEDBITS(e)
n = t->v.n + ((unsigned)b & mask_bits[e]);
DUMPBITS(e);
/* decode distance of block to copy */
NEEDBITS((unsigned)bd)
if ((e = (t = td + ((unsigned)b & md))->e) > 16)
do {
if (e == 99)
return 1;
DUMPBITS(t->b)
e -= 16;
NEEDBITS(e)
} while ((e = (t = t->v.t + ((unsigned)b & mask_bits[e]))->e) > 16);
DUMPBITS(t->b)
NEEDBITS(e)
d = w - t->v.n - ((unsigned)b & mask_bits[e]);
DUMPBITS(e)
/* do the copy */
do {
#if (defined(DLL) && !defined(NO_SLIDE_REDIR))
if (G.redirect_slide) {/* &= w/ wsize unnecessary & wrong if redirect */
if (d >= wsize)
return 1; /* invalid compressed data */
n -= (e = (e = wsize - (d > w ? d : w)) > n ? n : e);
}
else
#endif
n -= (e = (e = wsize - ((d &= wsize-1) > w ? d : w)) > n ? n : e);
#ifndef NOMEMCPY
if (w - d >= e) /* (this test assumes unsigned comparison) */
{
memcpy(redirSlide + w, redirSlide + d, e);
w += e;
d += e;
}
else /* do it slowly to avoid memcpy() overlap */
#endif /* !NOMEMCPY */
do {
redirSlide[w++] = redirSlide[d++];
} while (--e);
if (w == wsize)
{
FLUSH(w);
w = 0;
}
} while (n);
}
}
/* restore the globals from the locals */
G.wp = w; /* restore global window pointer */
G.bb = b; /* restore global bit buffer */
G.bk = k;
/* done */
return 0;
}
#endif /* ASM_INFLATECODES */
static int inflate_stored(__G)
__GDEF
/* "decompress" an inflated type 0 (stored) block. */
{
unsigned n; /* number of bytes in block */
unsigned w; /* current window position */
register ulg b; /* bit buffer */
register unsigned k; /* number of bits in bit buffer */
⌨️ 快捷键说明
复制代码
Ctrl + C
搜索代码
Ctrl + F
全屏模式
F11
切换主题
Ctrl + Shift + D
显示快捷键
?
增大字号
Ctrl + =
减小字号
Ctrl + -