ZipInflate Class Reference

The inflater for the file compressor and decompressor. Allows the CCDiskFile to offer compression of files. At present just used to compress the native file format. More...

#include <zinflate.h>

List of all members.

Public Member Functions
	ZipInflate ()
	ZipInflate constructor.
	~ZipInflate ()
	ZipInflate destructor.
INT32	Init (z_stream *strm)
	Initializes the internal stream state for decompression. The fields zalloc and zfree must be initialized before by the caller. If zalloc and zfree are set to Z_NULL, deflateInit updates them to use default allocation functions.
INT32	inflate (z_stream *strm, INT32 flush)
INT32	SetDictionary (z_stream *z, const Bytef *dictionary, uInt dictLength)
	Set the same dictionary on loading that was used on saving. For comments see:-.
INT32	End (z_stream *strm)
	All dynamically allocated data structures for this stream are freed. This function discards any unprocessed input and does not flush any pending output.
INT32	Init (z_stream *strm, INT32 windowBits)
	This is another version of inflate Init with more compression options. The fields next_out, zalloc and zfree must be initialized before by the caller.
INT32	Sync (z_stream *strm)
	Skips invalid compressed data until the special marker (see deflate() above) can be found, or until all available input is skipped. No output is provided.
INT32	Reset (z_stream *strm)
	This function is equivalent to inflateEnd followed by inflateInit, but does not free and reallocate all the internal decompression state. The stream will keep attributes that may have been set by inflateInit2.
Protected Member Functions
INT32	inflate_flush (inflate_blocks_state *, z_stream *, INT32)
	copy as much as possible from the sliding window to the output area
inflate_blocks_state *	inflate_blocks_new (z_stream *, check_func, uInt)
INT32	inflate_blocks (inflate_blocks_state *, z_stream *, INT32)
void	inflate_blocks_reset (inflate_blocks_state *, z_stream *, uLongf *)
INT32	inflate_blocks_free (inflate_blocks_state *, z_stream *, uLongf *)
void	inflate_set_dictionary (inflate_blocks_state *s, const Bytef *d, uInt n)
INT32	inflate_trees_bits (uIntf *, uIntf *, inflate_huft *FAR *, z_stream *)
INT32	inflate_trees_dynamic (uInt, uInt, uIntf *, uIntf *, uIntf *, inflate_huft *FAR *, inflate_huft *FAR *, z_stream *)
	build literal/length tree
INT32	inflate_trees_fixed (uIntf *, uIntf *, inflate_huft *FAR *, inflate_huft *FAR *)
	build fixed tables if not built already--lock out other instances
INT32	inflate_trees_free (inflate_huft *, z_stream *)
	Free the malloc'ed tables built by huft_build(), which makes a linked list of the tables it made, with the links in a dummy first entry of each table.
INT32	huft_build (uIntf *, uInt, uInt, uIntf *, uIntf *, inflate_huft *FAR *, uIntf *, z_stream *)
INT32	inflate_fast (uInt, uInt, inflate_huft *, inflate_huft *, inflate_blocks_state *, z_stream *)
	Called with number of bytes left to write in window at least 258 (the maximum string length) and number of input bytes available at least ten. The ten bytes are six bytes for the longest length/ distance pair plus four bytes for overloading the bit buffer.
inflate_codes_state *	inflate_codes_new (uInt, uInt, inflate_huft *, inflate_huft *, z_stream *)
INT32	inflate_codes (inflate_blocks_state *, z_stream *, INT32)
void	inflate_codes_free (inflate_codes_state *, z_stream *)
Private Member Functions
	CC_DECLARE_MEMDUMP (ZipInflate)

---

Detailed Description

The inflater for the file compressor and decompressor. Allows the CCDiskFile to offer compression of files. At present just used to compress the native file format.

Author:

Neville_Humphrys (Xara Group Ltd) <camelotdev@xara.com> Humprhys

Date:

23/5/95

Definition at line 391 of file zinflate.h.

---

Constructor & Destructor Documentation

ZipInflate::ZipInflate (   )

ZipInflate constructor. Author: Neville_Humphrys (Xara Group Ltd) <camelotdev@xara.com> Date: 24/05/95 Definition at line 147 of file zinflate.cpp. { }

ZipInflate::~ZipInflate (   )

ZipInflate destructor. Author: Neville_Humphrys (Xara Group Ltd) <camelotdev@xara.com> Date: 24/05/95 Definition at line 161 of file zinflate.cpp. { }

---

Member Function Documentation

ZipInflate::CC_DECLARE_MEMDUMP (  ZipInflate   )  [private]

INT32 ZipInflate::End (  z_stream *  z  )

All dynamically allocated data structures for this stream are freed. This function discards any unprocessed input and does not flush any pending output. Author: Neville_Humphrys (Xara Group Ltd) <camelotdev@xara.com> Date: 24/05/95 Parameters: s  the zip strema to use [INPUTS] inflate End returns Z_OK if success, Z_STREAM_ERROR if the stream state was inconsistent. In the error case, msg may be set but then points to a static string (which must not be deallocated). Definition at line 215 of file zinflate.cpp. { uLong c; if (z == NULL || z->In_state == NULL || z->zfree == Z_NULL) // || z->zfree == NULL) return Z_STREAM_ERROR; if (z->In_state->blocks != NULL) inflate_blocks_free(z->In_state->blocks, z, &c); delete z->In_state; z->In_state = NULL; Trace((stderr, "inflate: end\n")); return Z_OK; }

INT32 ZipInflate::huft_build (  uIntf *  , uInt  , uInt  , uIntf *  , uIntf *  , inflate_huft *FAR *  , uIntf *  , z_stream *  )  [protected]

INT32 ZipInflate::inflate (  z_stream *  strm, INT32  flush )

Definition at line 414 of file zinflate.cpp. { INT32 r; uInt b; if (z == Z_NULL || z->In_state == Z_NULL || z->next_in == Z_NULL || f < 0) return Z_STREAM_ERROR; r = Z_BUF_ERROR; while (1) switch (z->In_state->mode) { case METHOD: NEEDBYTE if (((z->In_state->sub.method = NEXTBYTE) & 0xf) != Z_DEFLATED) { z->In_state->mode = BAD; z->msg = (char*)"unknown compression method"; z->In_state->sub.marker = 5; /* can't try inflateSync */ break; } if ((z->In_state->sub.method >> 4) + 8 > z->In_state->wbits) { z->In_state->mode = BAD; z->msg = (char*)"invalid window size"; z->In_state->sub.marker = 5; /* can't try inflateSync */ break; } z->In_state->mode = FLAG; case FLAG: NEEDBYTE b = NEXTBYTE; if (((z->In_state->sub.method << 8) + b) % 31) { z->In_state->mode = BAD; z->msg = (char*)"incorrect header check"; z->In_state->sub.marker = 5; /* can't try inflateSync */ break; } Trace((stderr, "inflate: zlib header ok\n")); if (!(b & PRESET_DICT)) { z->In_state->mode = BLOCKS; break; } z->In_state->mode = DICT4; case DICT4: NEEDBYTE z->In_state->sub.check.need = (uLong)NEXTBYTE << 24; z->In_state->mode = DICT3; case DICT3: NEEDBYTE z->In_state->sub.check.need += (uLong)NEXTBYTE << 16; z->In_state->mode = DICT2; case DICT2: NEEDBYTE z->In_state->sub.check.need += (uLong)NEXTBYTE << 8; z->In_state->mode = DICT1; case DICT1: NEEDBYTE z->In_state->sub.check.need += (uLong)NEXTBYTE; z->adler = z->In_state->sub.check.need; z->In_state->mode = DICT0; return Z_NEED_DICT; case DICT0: z->In_state->mode = BAD; z->msg = (char*)"need dictionary"; z->In_state->sub.marker = 0; /* can try inflateSync */ return Z_STREAM_ERROR; case BLOCKS: r = inflate_blocks(z->In_state->blocks, z, r); if (r == Z_DATA_ERROR) { z->In_state->mode = BAD; z->In_state->sub.marker = 0; /* can try inflateSync */ break; } if (r != Z_STREAM_END) return r; r = Z_OK; inflate_blocks_reset(z->In_state->blocks, z, &z->In_state->sub.check.was); if (z->In_state->nowrap) { z->In_state->mode = DONE; break; } z->In_state->mode = CHECK4; case CHECK4: NEEDBYTE z->In_state->sub.check.need = (uLong)NEXTBYTE << 24; z->In_state->mode = CHECK3; case CHECK3: NEEDBYTE z->In_state->sub.check.need += (uLong)NEXTBYTE << 16; z->In_state->mode = CHECK2; case CHECK2: NEEDBYTE z->In_state->sub.check.need += (uLong)NEXTBYTE << 8; z->In_state->mode = CHECK1; case CHECK1: NEEDBYTE z->In_state->sub.check.need += (uLong)NEXTBYTE; if (z->In_state->sub.check.was != z->In_state->sub.check.need) { z->In_state->mode = BAD; z->msg = (char*)"incorrect data check"; z->In_state->sub.marker = 5; /* can't try inflateSync */ break; } Trace((stderr, "inflate: zlib check ok\n")); z->In_state->mode = DONE; case DONE: return Z_STREAM_END; case BAD: return Z_DATA_ERROR; default: return Z_STREAM_ERROR; } }

INT32 ZipInflate::inflate_blocks (  inflate_blocks_state *  s, z_stream *  z, INT32  r )  [protected]

Author: Neville_Humphrys (Xara Group Ltd) <camelotdev@xara.com> Date: 25/05/95 Parameters: s  [INPUTS] z r Definition at line 807 of file ziftrees.cpp. { uInt t; /* temporary storage */ uLong b; /* bit buffer */ uInt k; /* bits in bit buffer */ Bytef *p; /* input data pointer */ uInt n; /* bytes available there */ Bytef *q; /* output window write pointer */ uInt m; /* bytes to end of window or read pointer */ /* copy input/output information to locals (UPDATE macro restores) */ LOAD /* process input based on current state */ while (1) switch (s->mode) { case TYPE: NEEDBITS(3) t = (uInt)b & 7; s->last = t & 1; switch (t >> 1) { case 0: /* stored */ Trace((stderr, "inflate: stored block%s\n", s->last ? " (last)" : "")); DUMPBITS(3) t = k & 7; /* go to byte boundary */ DUMPBITS(t) s->mode = LENS; /* get length of stored block */ break; case 1: /* fixed */ Trace((stderr, "inflate: fixed codes block%s\n", s->last ? " (last)" : "")); { uInt bl, bd; inflate_huft *tl, *td; inflate_trees_fixed(&bl, &bd, &tl, &td); s->sub.decode.codes = inflate_codes_new(bl, bd, tl, td, z); if (s->sub.decode.codes == Z_NULL) { r = Z_MEM_ERROR; LEAVE } s->sub.decode.tl = Z_NULL; /* don't try to free these */ s->sub.decode.td = Z_NULL; } DUMPBITS(3) s->mode = CODES; break; case 2: /* dynamic */ Trace((stderr, "inflate: dynamic codes block%s\n", s->last ? " (last)" : "")); DUMPBITS(3) s->mode = TABLE; break; case 3: /* illegal */ DUMPBITS(3) s->mode = BLOCKBAD; z->msg = (char*)"invalid block type"; r = Z_DATA_ERROR; LEAVE } break; case LENS: NEEDBITS(32) if ((((~b) >> 16) & 0xffff) != (b & 0xffff)) { s->mode = BLOCKBAD; z->msg = (char*)"invalid stored block lengths"; r = Z_DATA_ERROR; LEAVE } s->sub.left = (uInt)b & 0xffff; b = k = 0; /* dump bits */ Tracev((stderr, "inflate: stored length %u\n", s->sub.left)); s->mode = s->sub.left ? STORED : (s->last ? DRY : TYPE); break; case STORED: if (n == 0) LEAVE NEEDOUT t = s->sub.left; if (t > n) t = n; if (t > m) t = m; zmemcpy(q, p, t); p += t; n -= t; q += t; m -= t; if ((s->sub.left -= t) != 0) break; Tracev((stderr, "inflate: stored end, %lu total out\n", z->total_out + (q >= s->read ? q - s->read : (s->end - s->read) + (q - s->window)))); s->mode = s->last ? DRY : TYPE; break; case TABLE: NEEDBITS(14) s->sub.trees.table = t = (uInt)b & 0x3fff; #ifndef PKZIP_BUG_WORKAROUND if ((t & 0x1f) > 29 || ((t >> 5) & 0x1f) > 29) { s->mode = BLOCKBAD; z->msg = (char*)"too many length or distance symbols"; r = Z_DATA_ERROR; LEAVE } #endif t = 258 + (t & 0x1f) + ((t >> 5) & 0x1f); if (t < 19) t = 19; if ((s->sub.trees.blens = (uIntf*)ZALLOC(z, t, sizeof(uInt))) == Z_NULL) { r = Z_MEM_ERROR; LEAVE } DUMPBITS(14) s->sub.trees.index = 0; Tracev((stderr, "inflate: table sizes ok\n")); s->mode = BTREE; case BTREE: while (s->sub.trees.index < 4 + (s->sub.trees.table >> 10)) { NEEDBITS(3) s->sub.trees.blens[border[s->sub.trees.index++]] = (uInt)b & 7; DUMPBITS(3) } while (s->sub.trees.index < 19) s->sub.trees.blens[border[s->sub.trees.index++]] = 0; s->sub.trees.bb = 7; t = inflate_trees_bits(s->sub.trees.blens, &s->sub.trees.bb, &s->sub.trees.tb, z); if (t != Z_OK) { r = t; if (r == Z_DATA_ERROR) s->mode = BLOCKBAD; LEAVE } s->sub.trees.index = 0; Tracev((stderr, "inflate: bits tree ok\n")); s->mode = DTREE; case DTREE: while (t = s->sub.trees.table, s->sub.trees.index < 258 + (t & 0x1f) + ((t >> 5) & 0x1f)) { inflate_huft *h; uInt i, j, c; t = s->sub.trees.bb; NEEDBITS(t) h = s->sub.trees.tb + ((uInt)b & inflate_mask[t]); t = h->word.what.Bits; c = h->more.Base; if (c < 16) { DUMPBITS(t) s->sub.trees.blens[s->sub.trees.index++] = c; } else /* c == 16..18 */ { i = c == 18 ? 7 : c - 14; j = c == 18 ? 11 : 3; NEEDBITS(t + i) DUMPBITS(t) j += (uInt)b & inflate_mask[i]; DUMPBITS(i) i = s->sub.trees.index; t = s->sub.trees.table; if (i + j > 258 + (t & 0x1f) + ((t >> 5) & 0x1f) || (c == 16 && i < 1)) { s->mode = BLOCKBAD; z->msg = (char*)"invalid bit length repeat"; r = Z_DATA_ERROR; LEAVE } c = c == 16 ? s->sub.trees.blens[i - 1] : 0; do { s->sub.trees.blens[i++] = c; } while (--j); s->sub.trees.index = i; } } inflate_trees_free(s->sub.trees.tb, z); s->sub.trees.tb = Z_NULL; { uInt bl, bd; inflate_huft *tl, *td; inflate_codes_state *c; bl = 9; /* must be <= 9 for lookahead assumptions */ bd = 6; /* must be <= 9 for lookahead assumptions */ t = s->sub.trees.table; #ifdef DEBUG inflate_hufts = 0; #endif t = inflate_trees_dynamic(257 + (t & 0x1f), 1 + ((t >> 5) & 0x1f), s->sub.trees.blens, &bl, &bd, &tl, &td, z); if (t != Z_OK) { if (t == (uInt)Z_DATA_ERROR) s->mode = BLOCKBAD; r = t; LEAVE } Tracev((stderr, "inflate: trees ok, %d * %d bytes used\n", inflate_hufts, sizeof(inflate_huft))); if ((c = inflate_codes_new(bl, bd, tl, td, z)) == Z_NULL) { inflate_trees_free(td, z); inflate_trees_free(tl, z); r = Z_MEM_ERROR; LEAVE } ZFREE(z, s->sub.trees.blens); s->sub.decode.codes = c; s->sub.decode.tl = tl; s->sub.decode.td = td; } s->mode = CODES; case CODES: UPDATE if ((r = inflate_codes(s, z, r)) != Z_STREAM_END) return inflate_flush(s, z, r); r = Z_OK; inflate_codes_free(s->sub.decode.codes, z); inflate_trees_free(s->sub.decode.td, z); inflate_trees_free(s->sub.decode.tl, z); LOAD Tracev((stderr, "inflate: codes end, %lu total out\n", z->total_out + (q >= s->read ? q - s->read : (s->end - s->read) + (q - s->window)))); if (!s->last) { s->mode = TYPE; break; } if (k > 7) /* return unused byte, if any */ { Assert(k < 16, "inflate_codes grabbed too many bytes") k -= 8; n++; p--; /* can always return one */ } s->mode = DRY; case DRY: FLUSH if (s->read != s->write) LEAVE s->mode = BLOCKDONE; case BLOCKDONE: r = Z_STREAM_END; LEAVE case BLOCKBAD: r = Z_DATA_ERROR; LEAVE default: r = Z_STREAM_ERROR; LEAVE } }

INT32 ZipInflate::inflate_blocks_free (  inflate_blocks_state *  s, z_stream *  z, uLongf *  c )  [protected]

Author: Neville_Humphrys (Xara Group Ltd) <camelotdev@xara.com> Date: 25/05/95 Parameters: s  [INPUTS] z c Definition at line 1083 of file ziftrees.cpp. { inflate_blocks_reset(s, z, c); ZFREE(z, s->window); delete s; Trace((stderr, "inflate: blocks freed\n")); return Z_OK; }

inflate_blocks_state * ZipInflate::inflate_blocks_new (  z_stream *  z, check_func  c, uInt  w )  [protected]

Author: Neville_Humphrys (Xara Group Ltd) <camelotdev@xara.com> Date: 25/05/95 Parameters: z  [INPUTS] c w Returns: NULL if problem Definition at line 768 of file ziftrees.cpp. { inflate_blocks_state *s; s = new inflate_blocks_state; if (s == NULL) return s; if ((s->window = (Byte *)ZALLOC(z, 1, w)) == NULL) { delete s; return NULL; } s->end = s->window + w; s->checkfn = c; s->mode = TYPE; Trace((stderr, "inflate: blocks allocated\n")); inflate_blocks_reset(s, z, &s->check); return s; }

void ZipInflate::inflate_blocks_reset (  inflate_blocks_state *  , z_stream *  , uLongf *  )  [protected]

Definition at line 732 of file ziftrees.cpp. { if (s->checkfn != Z_NULL) *c = s->check; if (s->mode == BTREE || s->mode == DTREE) ZFREE(z, s->sub.trees.blens); if (s->mode == CODES) { inflate_codes_free(s->sub.decode.codes, z); inflate_trees_free(s->sub.decode.td, z); inflate_trees_free(s->sub.decode.tl, z); } s->mode = TYPE; s->bitk = 0; s->bitb = 0; s->read = s->write = s->window; if (s->checkfn != Z_NULL) z->adler = s->check = (*s->checkfn)(0L, Z_NULL, 0); Trace((stderr, "inflate: blocks reset\n")); }

INT32 ZipInflate::inflate_codes (  inflate_blocks_state *  s, z_stream *  z, INT32  r )  [protected]

Author: Neville_Humphrys (Xara Group Ltd) <camelotdev@xara.com> Date: 25/05/95 Parameters: s  [INPUTS] z r Definition at line 1330 of file ziftrees.cpp. { uInt j; /* temporary storage */ inflate_huft *t; /* temporary pointer */ uInt e; /* extra bits or operation */ uLong b; /* bit buffer */ uInt k; /* bits in bit buffer */ Bytef *p; /* input data pointer */ uInt n; /* bytes available there */ Bytef *q; /* output window write pointer */ uInt m; /* bytes to end of window or read pointer */ Bytef *f; /* pointer to copy strings from */ inflate_codes_state *c = s->sub.decode.codes; /* codes state */ /* copy input/output information to locals (UPDATE macro restores) */ LOAD /* process input and output based on current state */ while (1) switch (c->mode) { /* waiting for "i:"=input, "o:"=output, "x:"=nothing */ case START: /* x: set up for LEN */ #ifndef SLOW if (m >= 258 && n >= 10) { UPDATE r = inflate_fast(c->lbits, c->dbits, c->ltree, c->dtree, s, z); LOAD if (r != Z_OK) { c->mode = r == Z_STREAM_END ? WASH : BADCODE; break; } } #endif /* !SLOW */ c->sub.code.need = c->lbits; c->sub.code.tree = c->ltree; c->mode = LEN; case LEN: /* i: get length/literal/eob next */ j = c->sub.code.need; NEEDBITS(j) t = c->sub.code.tree + ((uInt)b & inflate_mask[j]); DUMPBITS(t->bits) e = (uInt)(t->exop); if (e == 0) /* literal */ { c->sub.lit = t->base; Tracevv((stderr, t->base >= 0x20 && t->base < 0x7f ? "inflate: literal '%c'\n" : "inflate: literal 0x%02x\n", t->base)); c->mode = LIT; break; } if (e & 16) /* length */ { c->sub.copy.get = e & 15; c->len = t->base; c->mode = LENEXT; break; } if ((e & 64) == 0) /* next table */ { c->sub.code.need = e; c->sub.code.tree = t->next; break; } if (e & 32) /* end of block */ { Tracevv((stderr, "inflate: end of block\n")); c->mode = WASH; break; } c->mode = BADCODE; /* invalid code */ z->msg = (char*)"invalid literal/length code"; r = Z_DATA_ERROR; LEAVE case LENEXT: /* i: getting length extra (have base) */ j = c->sub.copy.get; NEEDBITS(j) c->len += (uInt)b & inflate_mask[j]; DUMPBITS(j) c->sub.code.need = c->dbits; c->sub.code.tree = c->dtree; Tracevv((stderr, "inflate: length %u\n", c->len)); c->mode = DIST; case DIST: /* i: get distance next */ j = c->sub.code.need; NEEDBITS(j) t = c->sub.code.tree + ((uInt)b & inflate_mask[j]); DUMPBITS(t->bits) e = (uInt)(t->exop); if (e & 16) /* distance */ { c->sub.copy.get = e & 15; c->sub.copy.dist = t->base; c->mode = DISTEXT; break; } if ((e & 64) == 0) /* next table */ { c->sub.code.need = e; c->sub.code.tree = t->next; break; } c->mode = BADCODE; /* invalid code */ z->msg = (char*)"invalid distance code"; r = Z_DATA_ERROR; LEAVE case DISTEXT: /* i: getting distance extra */ j = c->sub.copy.get; NEEDBITS(j) c->sub.copy.dist += (uInt)b & inflate_mask[j]; DUMPBITS(j) Tracevv((stderr, "inflate: distance %u\n", c->sub.copy.dist)); c->mode = COPY; case COPY: /* o: copying bytes in window, waiting for space */ #ifndef __TURBOC__ /* Turbo C bug for following expression */ f = (uInt)(q - s->window) < c->sub.copy.dist ? s->end - (c->sub.copy.dist - (q - s->window)) : q - c->sub.copy.dist; #else f = q - c->sub.copy.dist; if ((uInt)(q - s->window) < c->sub.copy.dist) f = s->end - (c->sub.copy.dist - (uInt)(q - s->window)); #endif while (c->len) { NEEDOUT OUTBYTE(*f++) if (f == s->end) f = s->window; c->len--; } c->mode = START; break; case LIT: /* o: got literal, waiting for output space */ NEEDOUT OUTBYTE(c->sub.lit) c->mode = START; break; case WASH: /* o: got eob, possibly more output */ FLUSH if (s->read != s->write) LEAVE c->mode = END; case END: r = Z_STREAM_END; LEAVE case BADCODE: /* x: got error */ r = Z_DATA_ERROR; LEAVE default: r = Z_STREAM_ERROR; LEAVE } }

void ZipInflate::inflate_codes_free (  inflate_codes_state *  c, z_stream *  z )  [protected]

Author: Neville_Humphrys (Xara Group Ltd) <camelotdev@xara.com> Date: 25/05/95 Parameters: c  [INPUTS] z Definition at line 1498 of file ziftrees.cpp. { //ZFREE(z, c); if (c) delete c; Tracev((stderr, "inflate: codes free\n")); }

inflate_codes_state * ZipInflate::inflate_codes_new (  uInt  bl, uInt  bd, inflate_huft *  tl, inflate_huft *  td, z_stream *  z )  [protected]

Author: Neville_Humphrys (Xara Group Ltd) <camelotdev@xara.com> Date: 25/05/95 Parameters: bl  [INPUTS] bd tl td z Definition at line 1298 of file ziftrees.cpp. { inflate_codes_state *c; c = new inflate_codes_state; if (c != NULL) { c->mode = START; c->lbits = (Byte)bl; c->dbits = (Byte)bd; c->ltree = tl; c->dtree = td; Tracev((stderr, "inflate: codes new\n")); } return c; }

INT32 ZipInflate::inflate_fast (  uInt  bl, uInt  bd, inflate_huft *  tl, inflate_huft *  td, inflate_blocks_state *  s, z_stream *  z )  [protected]

Called with number of bytes left to write in window at least 258 (the maximum string length) and number of input bytes available at least ten. The ten bytes are six bytes for the longest length/ distance pair plus four bytes for overloading the bit buffer. Author: Neville_Humphrys (Xara Group Ltd) <camelotdev@xara.com> Date: 25/05/95 Parameters: bl  [INPUTS] bd tl td s z Definition at line 1142 of file ziftrees.cpp. { inflate_huft *t; /* temporary pointer */ uInt e; /* extra bits or operation */ uLong b; /* bit buffer */ uInt k; /* bits in bit buffer */ Bytef *p; /* input data pointer */ uInt n; /* bytes available there */ Bytef *q; /* output window write pointer */ uInt m; /* bytes to end of window or read pointer */ uInt ml; /* mask for literal/length tree */ uInt md; /* mask for distance tree */ uInt c; /* bytes to copy */ uInt d; /* distance back to copy from */ Bytef *r; /* copy source pointer */ /* load input, output, bit values */ LOAD /* initialize masks */ ml = inflate_mask[bl]; md = inflate_mask[bd]; /* do until not enough input or output space for fast loop */ do { /* assume called with m >= 258 && n >= 10 */ /* get literal/length code */ GRABBITS(20) /* max bits for literal/length code */ if ((e = (t = tl + ((uInt)b & ml))->exop) == 0) { DUMPBITS(t->bits) Tracevv((stderr, t->base >= 0x20 && t->base < 0x7f ? "inflate: * literal '%c'\n" : "inflate: * literal 0x%02x\n", t->base)); *q++ = (Byte)t->base; m--; continue; } do { DUMPBITS(t->bits) if (e & 16) { /* get extra bits for length */ e &= 15; c = t->base + ((uInt)b & inflate_mask[e]); DUMPBITS(e) Tracevv((stderr, "inflate: * length %u\n", c)); /* decode distance base of block to copy */ GRABBITS(15); /* max bits for distance code */ e = (t = td + ((uInt)b & md))->exop; do { DUMPBITS(t->bits) if (e & 16) { /* get extra bits to add to distance base */ e &= 15; GRABBITS(e) /* get extra bits (up to 13) */ d = t->base + ((uInt)b & inflate_mask[e]); DUMPBITS(e) Tracevv((stderr, "inflate: * distance %u\n", d)); /* do the copy */ m -= c; if ((uInt)(q - s->window) >= d) /* offset before dest */ { /* just copy */ r = q - d; *q++ = *r++; c--; /* minimum count is three, */ *q++ = *r++; c--; /* so unroll loop a little */ } else /* else offset after destination */ { e = d - (uInt)(q - s->window); /* bytes from offset to end */ r = s->end - e; /* pointer to offset */ if (c > e) /* if source crosses, */ { c -= e; /* copy to end of window */ do { *q++ = *r++; } while (--e); r = s->window; /* copy rest from start of window */ } } do { /* copy all or what's left */ *q++ = *r++; } while (--c); break; } else if ((e & 64) == 0) e = (t = t->next + ((uInt)b & inflate_mask[e]))->exop; else { z->msg = (char*)"invalid distance code"; UNGRAB UPDATE return Z_DATA_ERROR; } } while (1); break; } if ((e & 64) == 0) { if ((e = (t = t->next + ((uInt)b & inflate_mask[e]))->exop) == 0) { DUMPBITS(t->bits) Tracevv((stderr, t->base >= 0x20 && t->base < 0x7f ? "inflate: * literal '%c'\n" : "inflate: * literal 0x%02x\n", t->base)); *q++ = (Byte)t->base; m--; break; } } else if (e & 32) { Tracevv((stderr, "inflate: * end of block\n")); UNGRAB UPDATE return Z_STREAM_END; } else { z->msg = (char*)"invalid literal/length code"; UNGRAB UPDATE return Z_DATA_ERROR; } } while (1); } while (m >= 258 && n >= 10); /* not enough input or output--restore pointers and return */ UNGRAB UPDATE return Z_OK; }

INT32 ZipInflate::inflate_flush (  inflate_blocks_state *  s, z_stream *  z, INT32  r )  [protected]

copy as much as possible from th