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 the sliding window to the output area Author: Neville_Humphrys (Xara Group Ltd) <camelotdev@xara.com> Date: 24/05/95 Parameters: s  current inflate state [INPUTS] z zip stream we are to use r Definition at line 653 of file zinflate.cpp. { uInt n; Bytef *p, *q; /* local copies of source and destination pointers */ p = z->next_out; q = s->read; /* compute number of bytes to copy as far as end of window */ n = (uInt)((q <= s->write ? s->write : s->end) - q); if (n > z->avail_out) n = z->avail_out; if (n && r == Z_BUF_ERROR) r = Z_OK; /* update counters */ z->avail_out -= n; z->total_out += n; /* update check information */ if (s->checkfn != Z_NULL) z->adler = s->check = (*s->checkfn)(s->check, q, n); /* copy as far as end of window */ zmemcpy(p, q, n); p += n; q += n; /* see if more to copy at beginning of window */ if (q == s->end) { /* wrap pointers */ q = s->window; if (s->write == s->end) s->write = s->window; /* compute bytes to copy */ n = (uInt)(s->write - q); if (n > z->avail_out) n = z->avail_out; if (n && r == Z_BUF_ERROR) r = Z_OK; /* update counters */ z->avail_out -= n; z->total_out += n; /* update check information */ if (s->checkfn != Z_NULL) z->adler = s->check = (*s->checkfn)(s->check, q, n); /* copy */ zmemcpy(p, q, n); p += n; q += n; } /* update pointers */ z->next_out = p; s->read = q; /* done */ return r; }

void ZipInflate::inflate_set_dictionary (  inflate_blocks_state *  s, const Bytef *  d, uInt  n )  [protected]

Author: Neville_Humphrys (Xara Group Ltd) <camelotdev@xara.com> Date: 25/05/95 Parameters: s  [INPUTS] z d n Definition at line 1106 of file ziftrees.cpp. { zmemcpy((charf *)s->window, d, n); s->read = s->write = s->window + n; }

INT32 ZipInflate::inflate_trees_bits (  uIntf *  c, uIntf *  bb, inflate_huft *FAR *  tb, z_stream *  z )  [protected]

Author: Neville_Humphrys (Xara Group Ltd) <camelotdev@xara.com> Date: 25/05/95 Parameters: c  19 code lengths [INPUTS] bb bits tree desired/actual depth tb bits tree result z for zfree function Definition at line 487 of file ziftrees.cpp. { INT32 r; r = huft_build(c, 19, 19, (uIntf*)Z_NULL, (uIntf*)Z_NULL, tb, bb, z); if (r == Z_DATA_ERROR) z->msg = (char*)"oversubscribed dynamic bit lengths tree"; else if (r == Z_BUF_ERROR) { inflate_trees_free(*tb, z); z->msg = (char*)"incomplete dynamic bit lengths tree"; r = Z_DATA_ERROR; } return r; }

INT32 ZipInflate::inflate_trees_dynamic (  uInt  nl, uInt  nd, uIntf *  c, uIntf *  bl, uIntf *  bd, inflate_huft *FAR *  tl, inflate_huft *FAR *  td, z_stream *  z )  [protected]

build literal/length tree Author: Neville_Humphrys (Xara Group Ltd) <camelotdev@xara.com> Date: 25/05/95 Parameters: nl  number of literal/length codes [INPUTS] nd number of distance codes c that many (total) code lengths bl literal desired/actual bit depth bd distance desired/actual bit depth tl literal/length tree result td distance tree result z for zfree function Definition at line 522 of file ziftrees.cpp. { INT32 r; /* build literal/length tree */ if ((r = huft_build(c, nl, 257, cplens, cplext, tl, bl, z)) != Z_OK) { if (r == Z_DATA_ERROR) z->msg = (char*)"oversubscribed literal/length tree"; else if (r == Z_BUF_ERROR) { inflate_trees_free(*tl, z); z->msg = (char*)"incomplete literal/length tree"; r = Z_DATA_ERROR; } return r; } /* build distance tree */ if ((r = huft_build(c + nl, nd, 0, cpdist, cpdext, td, bd, z)) != Z_OK) { if (r == Z_DATA_ERROR) z->msg = (char*)"oversubscribed literal/length tree"; else if (r == Z_BUF_ERROR) { #ifdef PKZIP_BUG_WORKAROUND r = Z_OK; } #else inflate_trees_free(*td, z); z->msg = (char*)"incomplete literal/length tree"; r = Z_DATA_ERROR; } inflate_trees_free(*tl, z); return r; #endif } /* done */ return Z_OK; }

INT32 ZipInflate::inflate_trees_fixed (  uIntf *  bl, uIntf *  bd, inflate_huft *FAR *  tl, inflate_huft *FAR *  td )  [protected]

build fixed tables if not built already--lock out other instances Author: Neville_Humphrys (Xara Group Ltd) <camelotdev@xara.com> Date: 25/05/95 Parameters: bl  literal desired/actual bit depth [INPUTS] bd distance desired/actual bit depth tl literal/length tree result td distance tree result Definition at line 628 of file ziftrees.cpp. { /* build fixed tables if not already (multiple overlapped executions ok) */ if (!fixed_built) { INT32 k; /* temporary variable */ unsigned c[288]; /* length list for huft_build */ ZStream z; /* for falloc function */ INT32 f = FIXEDH; /* number of hufts left in fixed_mem */ /* set up fake z_stream for memory routines */ z.zalloc = falloc; z.zfree = Z_NULL; z.opaque = (voidpf)&f; /* literal table */ for (k = 0; k < 144; k++) c[k] = 8; for (; k < 256; k++) c[k] = 9; for (; k < 280; k++) c[k] = 7; for (; k < 288; k++) c[k] = 8; fixed_bl = 7; huft_build(c, 288, 257, cplens, cplext, &fixed_tl, &fixed_bl, &z); /* distance table */ for (k = 0; k < 30; k++) c[k] = 5; fixed_bd = 5; huft_build(c, 30, 0, cpdist, cpdext, &fixed_td, &fixed_bd, &z); /* done */ Assert(f == 0, "invalid build of fixed tables"); fixed_built = 1; } *bl = fixed_bl; *bd = fixed_bd; *tl = fixed_tl; *td = fixed_td; return Z_OK; }

INT32 ZipInflate::inflate_trees_free (  inflate_huft *  t, z_stream *  z )  [protected]

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. Author: Neville_Humphrys (Xara Group Ltd) <camelotdev@xara.com> Date: 25/05/95 Parameters: t  table to free [INPUTS] z for zfree function Definition at line 686 of file ziftrees.cpp. { register inflate_huft *p, *q, *r; /* Reverse linked list */ p = Z_NULL; q = t; while (q != Z_NULL) { r = (q - 1)->next; (q - 1)->next = p; p = q; q = r; } /* Go through linked list, freeing from the malloced (t[-1]) address. */ while (p != Z_NULL) { q = (--p)->next; ZFREE(z,p); p = q; } return Z_OK; }

INT32 ZipInflate::Init (  z_stream *  z, INT32  w )

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. Author: Neville_Humphrys (Xara Group Ltd) <camelotdev@xara.com> Date: 24/05/95 Parameters: s  the zip strema to use [INPUTS] w base two logarithm of the maximum window size, in the range 8..15 The windowBits parameter is the base two logarithm of the maximum window size (the size of the history buffer). It should be in the range 8..15 for this version of the library (the value 16 will be allowed soon). The default value is 15 if inflateInit is used instead. If a compressed stream with a larger window size is given as input, inflate() will return with the error code Z_DATA_ERROR instead of trying to allocate a larger window. If next_out is not null, the library will use this buffer for the history buffer; the buffer must either be large enough to hold the entire output data, or have at least 1<<windowBits bytes. If next_out is null, the library will allocate its own buffer (and leave next_out null). next_in need not be provided here but must be provided by the application for the next call of inflate(). If the history buffer is provided by the application, next_out must never be changed by the application since the decompressor maintains history information inside this buffer from call to call; the application can only reset next_out to the beginning of the history buffer when avail_out is zero and all output has been consumed. inflateInit2 returns Z_OK if success, Z_MEM_ERROR if there was not enough memory, Z_STREAM_ERROR if a parameter is invalid (such as windowBits < 8). msg is set to null if there is no error message. inflateInit2 does not perform any compression: this will be done by inflate(). Definition at line 272 of file zinflate.cpp. { //if (version == Z_NULL || version[0] != ZLIB_VERSION[0] || // stream_size != sizeof(z_stream)) // return Z_VERSION_ERROR; /* initialize state */ if (z == NULL) return Z_STREAM_ERROR; z->msg = Z_NULL; if (z->zalloc == NULL) { z->zalloc = GZipFile::zcalloc; z->opaque = 0; } if (z->zfree == NULL) z->zfree = GZipFile::zcfree; // if ((z->In_state = (struct InflateState *) // ZALLOC(z,1,sizeof(struct InflateState))) == NULL) // return Z_MEM_ERROR; z->In_state = new InflateState; if ((z->In_state) == NULL) return Z_MEM_ERROR; z->In_state->blocks = NULL; /* handle undocumented nowrap option (no zlib header or check) */ z->In_state->nowrap = 0; if (w < 0) { w = - w; z->In_state->nowrap = 1; } /* set window size */ if (w < 8 || w > 15) { End(z); return Z_STREAM_ERROR; } z->In_state->wbits = (uInt)w; /* create inflate_blocks state */ z->In_state->blocks = inflate_blocks_new(z, z->In_state->nowrap ? Z_NULL : GZipFile::adler32, (uInt)1 << w); if (z->In_state->blocks == NULL) { End(z); return Z_MEM_ERROR; } Trace((stderr, "inflate: allocated\n")); /* reset state */ Reset(z); return Z_OK; }

INT32 ZipInflate::Init (  z_stream *  z  )

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. Author: Neville_Humphrys (Xara Group Ltd) <camelotdev@xara.com> Date: 24/05/95 Parameters: s  the zip strema to use [INPUTS] inflate Init returns Z_OK if success, Z_MEM_ERROR if there was not enough memory. msg is set to null if there is no error message. inflateInit does not perform any decompression: this will be done by inflate(). Definition at line 350 of file zinflate.cpp. { return Init(z, DEF_WBITS); }

INT32 ZipInflate::Reset (  z_stream *  z  )

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. Author: Neville_Humphrys (Xara Group Ltd) <camelotdev@xara.com> Date: 24/05/95 Parameters: s  the zip strema to use [INPUTS] inflate Reset returns Z_OK if success, or Z_STREAM_ERROR if the source stream state was inconsistent (such as zalloc or state being NULL). Definition at line 182 of file zinflate.cpp. { uLong c; if (z == NULL || z->In_state == NULL) return Z_STREAM_ERROR; z->total_in = z->total_out = 0; z->msg = Z_NULL; z->In_state->mode = z->In_state->nowrap ? BLOCKS : METHOD; inflate_blocks_reset(z->In_state->blocks, z, &c); Trace((stderr, "inflate: reset\n")); return Z_OK; }

INT32 ZipInflate::SetDictionary (  z_stream *  z, const Bytef *  dictionary, uInt  dictLength )

Set the same dictionary on loading that was used on saving. For comments see:-. Author: Neville_Humphrys (Xara Group Ltd) <camelotdev@xara.com> Date: 24/05/95 Parameters: z  the zip stream to use [INPUTS] dictionary dictLength See also: ZipDeflate::SetDictionary Definition at line 547 of file zinflate.cpp. { uInt length = dictLength; if (z == Z_NULL || z->In_state == Z_NULL || z->In_state->mode != DICT0) return Z_STREAM_ERROR; if (GZipFile::adler32(1L, dictionary, dictLength) != z->adler) return Z_DATA_ERROR; z->adler = 1L; if (length >= ((uInt)1<<z->In_state->wbits)) { length = (1<<z->In_state->wbits)-1; dictionary += dictLength - length; } inflate_set_dictionary(z->In_state->blocks, dictionary, length); z->In_state->mode = BLOCKS; return Z_OK; }

INT32 ZipInflate::Sync (  z_stream *  z  )

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. Author: Neville_Humphrys (Xara Group Ltd) <camelotdev@xara.com> Date: 24/05/95 Parameters: s  the zip stream to use [INPUTS] inflate Sync returns Z_OK if the special marker has been found, Z_BUF_ERROR if no more input was provided, Z_DATA_ERROR if no marker has been found, or Z_STREAM_ERROR if the stream structure was inconsistent. In the success case, the application may save the current current value of total_in which indicates where valid compressed data was found. In the error case, the application may repeatedly call inflateSync, providing more input each time, until success or end of the input data. Definition at line 588 of file zinflate.cpp. { uInt n; /* number of bytes to look at */ Bytef *p; /* pointer to bytes */ uInt m; /* number of marker bytes found in a row */ uLong r, w; /* temporaries to save total_in and total_out */ /* set up */ if (z == Z_NULL || z->In_state == Z_NULL) return Z_STREAM_ERROR; if (z->In_state->mode != BAD) { z->In_state->mode = BAD; z->In_state->sub.marker = 0; } if ((n = z->avail_in) == 0) return Z_BUF_ERROR; p = z->next_in; m = z->In_state->sub.marker; /* search */ while (n && m < 4) { if (*p == (Byte)(m < 2 ? 0 : 0xff)) m++; else if (*p) m = 0; else m = 4 - m; p++, n--; } /* restore */ z->total_in += p - z->next_in; z->next_in = p; z->avail_in = n; z->In_state->sub.marker = m; /* return no joy or set up to restart on a new block */ if (m != 4) return Z_DATA_ERROR; r = z->total_in; w = z->total_out; Reset(z); z->total_in = r; z->total_out = w; z->In_state->mode = BLOCKS; return Z_OK; }

---

The documentation for this class was generated from the following files:

• Kernel/zinflate.h (r1785/r751)
• Kernel/ziftrees.cpp (r1785/r1282)
• Kernel/zinflate.cpp (r1785/r1282)

---