mirrors/zlib
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

zlib 0.92

Browse Source
This commit is contained in:
Mark Adler 2011-09-09 23:08:07 -07:00
parent 1c71d8b13b
commit bdde4e09d2
25 changed files with 884 additions and 910 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

9
ChangeLog
View File

@ -1,5 +1,14 @@
ChangeLog file for zlib
Changes in 0.92 (3 May 95)
- don't assume that char is signed (problem on SGI)
- Clear bit buffer when starting a stored block
- no memcpy on Pyramid
- suppressed inftest.c
- optimized fill_window, put longest_match inline for gcc
- optimized inflate on stored blocks.
- untabify all sources to simplify patches
Changes in 0.91 (2 May 95)
- Default MEM_LEVEL is 8 (not 9 for Unix) as documented in zlib.h
- Document the memory requirements in zconf.h

11
Makefile
View File

@ -4,6 +4,7 @@
CC=cc
CFLAGS=-O
#use -O3 for gcc to take advantage of inlining
#CFLAGS="-O -DMAX_WBITS=14 -DMAX_MEM_LEVEL=7"
#CFLAGS=-g -DDEBUG
LDFLAGS=-L. -lgz
@ -15,9 +16,9 @@ prefix=/usr/local
OBJS = adler32.o compress.o crc32.o gzio.o uncompr.o deflate.o trees.o \
zutil.o inflate.o infblock.o inftrees.o infcodes.o infutil.o inffast.o
TEST_OBJS = example.o minigzip.o inftest.o
TEST_OBJS = example.o minigzip.o
all: example minigzip inftest
all: example minigzip
test: all
./example
@ -41,11 +42,8 @@ example: example.o libgz.a
minigzip: minigzip.o libgz.a
$(CC) $(CFLAGS) -o $@ minigzip.o $(LDFLAGS)
inftest: inftest.o libgz.a
$(CC) $(CFLAGS) -o $@ inftest.o $(LDFLAGS)
clean:
rm -f *.o example minigzip inftest libgz.a foo.gz
rm -f *.o example minigzip libgz.a foo.gz
zip:
zip -ul9 zlib README ChangeLog Makefile Makefile.??? Makefile.?? *.[ch]
@ -66,7 +64,6 @@ infblock.o: zutil.h zlib.h zconf.h infblock.h inftrees.h infcodes.h infutil.h
infcodes.o: zutil.h zlib.h zconf.h inftrees.h infutil.h infcodes.h inffast.h
inffast.o: zutil.h zlib.h zconf.h inftrees.h infutil.h inffast.h
inflate.o: zutil.h zlib.h zconf.h infblock.h
inftest.o: zutil.h zlib.h zconf.h
inftrees.o: zutil.h zlib.h zconf.h inftrees.h
infutil.o: zutil.h zlib.h zconf.h inftrees.h infutil.h
minigzip.o: zlib.h zconf.h

9
README
View File

@ -1,4 +1,4 @@
zlib 0.91 is a beta version of a general purpose compression library.
zlib 0.92 is a beta version of a general purpose compression library.
The data format used by the zlib library is described in the
files zlib-3.1.doc, deflate-1.1.doc and gzip-4.1.doc, available
@ -14,12 +14,15 @@ To install the zlib library (libgz.a) in /usr/local/lib, type: make install
To install in a different directory, use for example: make install prefix=$HOME
This will install in $HOME/lib instead of /usr/local/lib.
The changes made in version 0.91 are documented in the file ChangeLog.
The changes made in version 0.92 are documented in the file ChangeLog.
The main changes since 0.9 are:
- don't assume that char is signed (problem on SGI)
- Default MEM_LEVEL is 8 (not 9 for Unix) as documented in zlib.h
- Document the memory requirements in zconf.h
- added "make install"
- added support for DJGPP
- added support for DJGPP and Pyramid
- fix an inflate bug for stored blocks.
- various speedups
On MSDOS, this version works in both large and small model. However
small model compression works only for small values of MAX_MEM_LEVEL

24
adler32.c
View File

@ -3,7 +3,7 @@
* For conditions of distribution and use, see copyright notice in zlib.h
*/
/* $Id: adler32.c,v 1.5 1995/04/14 14:49:51 jloup Exp $ */
/* $Id: adler32.c,v 1.6 1995/05/03 17:27:08 jloup Exp $ */
#include "zutil.h"
@ -30,17 +30,17 @@ uLong adler32(adler, buf, len)
if (buf == Z_NULL) return 1L;
while (len > 0) {
k = len < NMAX ? len : NMAX;
len -= k;
while (k >= 16) {
DO16(buf);
k -= 16;
}
if (k != 0) do {
DO1(buf);
} while (--k);
s1 %= BASE;
s2 %= BASE;
k = len < NMAX ? len : NMAX;
len -= k;
while (k >= 16) {
DO16(buf);
k -= 16;
}
if (k != 0) do {
DO1(buf);
} while (--k);
s1 %= BASE;
s2 %= BASE;
}
return (s2 << 16) | s1;
}

6
compress.c
View File

@ -3,7 +3,7 @@
* For conditions of distribution and use, see copyright notice in zlib.h
*/
/* $Id: compress.c,v 1.5 1995/04/29 17:18:43 jloup Exp $ */
/* $Id: compress.c,v 1.6 1995/05/03 17:27:08 jloup Exp $ */
#include "zlib.h"
@ -45,8 +45,8 @@ int compress (dest, destLen, source, sourceLen)
err = deflate(&stream, Z_FINISH);
if (err != Z_STREAM_END) {
deflateEnd(&stream);
return err == Z_OK ? Z_BUF_ERROR : err;
deflateEnd(&stream);
return err == Z_OK ? Z_BUF_ERROR : err;
}
*destLen = stream.total_out;

195
deflate.c
View File

@ -47,7 +47,7 @@
*
*/
/* $Id: deflate.c,v 1.7 1995/05/02 13:28:18 jloup Exp $ */
/* $Id: deflate.c,v 1.8 1995/05/03 17:27:08 jloup Exp $ */
#include "deflate.h"
@ -127,7 +127,7 @@ local int read_buf __P((z_stream *strm, char *buf, unsigned size));
#ifdef DEBUG
local void check_match __P((deflate_state *s, IPos start, IPos match,
int length));
int length));
#endif
@ -190,12 +190,12 @@ int deflateInit2 (strm, level, method, windowBits, memLevel, strategy)
if (level == Z_DEFAULT_COMPRESSION) level = 6;
if (windowBits < 0) { /* undocumented feature: suppress zlib header */
noheader = 1;
windowBits = -windowBits;
noheader = 1;
windowBits = -windowBits;
}
if (memLevel < 1 || memLevel > MAX_MEM_LEVEL || method != DEFLATED ||
windowBits < 8 || windowBits > 15 || level < 1 || level > 9) {
return Z_STREAM_ERROR;
windowBits < 8 || windowBits > 15 || level < 1 || level > 9) {
return Z_STREAM_ERROR;
}
s = (deflate_state *) ZALLOC(strm, 1, sizeof(deflate_state));
if (s == Z_NULL) return Z_MEM_ERROR;
@ -221,10 +221,10 @@ int deflateInit2 (strm, level, method, windowBits, memLevel, strategy)
s->pending_buf = (uch*) ZALLOC(strm, s->lit_bufsize, 2*sizeof(ush));
if (s->window == Z_NULL || s->prev == Z_NULL || s->head == Z_NULL ||
s->pending_buf == Z_NULL) {
strm->msg = z_errmsg[1-Z_MEM_ERROR];
deflateEnd (strm);
return Z_MEM_ERROR;
s->pending_buf == Z_NULL) {
strm->msg = z_errmsg[1-Z_MEM_ERROR];
deflateEnd (strm);
return Z_MEM_ERROR;
}
s->d_buf = (ush*) &(s->pending_buf[s->lit_bufsize]);
s->l_buf = (uch*) &(s->pending_buf[3*s->lit_bufsize]);
@ -247,7 +247,7 @@ int deflateReset (strm)
deflate_state *s;
if (strm == Z_NULL || strm->state == Z_NULL ||
strm->zalloc == Z_NULL || strm->zfree == Z_NULL) return Z_STREAM_ERROR;
strm->zalloc == Z_NULL || strm->zfree == Z_NULL) return Z_STREAM_ERROR;
strm->total_in = strm->total_out = 0;
strm->msg = Z_NULL; /* use zfree if we ever allocate msg dynamically */
@ -297,7 +297,7 @@ local void flush_pending(strm)
strm->avail_out -= len;
strm->state->pending -= len;
if (strm->state->pending == 0) {
strm->state->pending_out = strm->state->pending_buf;
strm->state->pending_out = strm->state->pending_buf;
}
}
@ -309,7 +309,7 @@ int deflate (strm, flush)
if (strm == Z_NULL || strm->state == Z_NULL) return Z_STREAM_ERROR;
if (strm->next_out == Z_NULL || strm->next_in == Z_NULL) {
ERR_RETURN(strm, Z_STREAM_ERROR);
ERR_RETURN(strm, Z_STREAM_ERROR);
}
if (strm->avail_out == 0) ERR_RETURN(strm, Z_BUF_ERROR);
@ -318,49 +318,49 @@ int deflate (strm, flush)
/* Write the zlib header */
if (strm->state->status == INIT_STATE) {
uInt header = (DEFLATED + ((strm->state->w_bits-8)<<4)) << 8;
uInt header = (DEFLATED + ((strm->state->w_bits-8)<<4)) << 8;
uInt level_flags = (strm->state->level-1) >> 1;
if (level_flags > 3) level_flags = 3;
header |= (level_flags << 6);
header += 31 - (header % 31);
if (level_flags > 3) level_flags = 3;
header |= (level_flags << 6);
header += 31 - (header % 31);
strm->state->status = BUSY_STATE;
putShortMSB(strm->state, header);
strm->state->status = BUSY_STATE;
putShortMSB(strm->state, header);
}
/* Flush as much pending output as possible */
if (strm->state->pending != 0) {
flush_pending(strm);
if (strm->avail_out == 0) return Z_OK;
flush_pending(strm);
if (strm->avail_out == 0) return Z_OK;
}
/* User must not provide more input after the first FINISH: */
if (strm->state->status == FINISH_STATE && strm->avail_in != 0) {
ERR_RETURN(strm, Z_BUF_ERROR);
ERR_RETURN(strm, Z_BUF_ERROR);
}
/* Start a new block or continue the current one.
*/
if (strm->avail_in != 0 ||
(flush == Z_FINISH && strm->state->status != FINISH_STATE)) {
int quit;
if (flush == Z_FINISH) {
strm->state->status = FINISH_STATE;
}
(flush == Z_FINISH && strm->state->status != FINISH_STATE)) {
int quit;
if (flush == Z_FINISH) {
strm->state->status = FINISH_STATE;
}
if (strm->state->level <= 3) {
quit = deflate_fast(strm->state, flush);
} else {
quit = deflate_slow(strm->state, flush);
}
if (flush == Z_FULL_FLUSH) {
ct_stored_block(strm->state, (char*)0, 0L, 0); /* special marker */
flush_pending(strm);
CLEAR_HASH(strm->state); /* forget history */
if (strm->avail_out == 0) return Z_OK;
}
if (quit) return Z_OK;
quit = deflate_fast(strm->state, flush);
} else {
quit = deflate_slow(strm->state, flush);
}
if (flush == Z_FULL_FLUSH) {
ct_stored_block(strm->state, (char*)0, 0L, 0); /* special marker */
flush_pending(strm);
CLEAR_HASH(strm->state); /* forget history */
if (strm->avail_out == 0) return Z_OK;
}
if (quit) return Z_OK;
}
Assert(strm->avail_out > 0, "bug2");
@ -401,13 +401,13 @@ int deflateCopy (dest, source)
z_stream *source;
{
if (source == Z_NULL || dest == Z_NULL || source->state == Z_NULL) {
return Z_STREAM_ERROR;
return Z_STREAM_ERROR;
}
*dest = *source;
return Z_STREAM_ERROR; /* to be implemented */
#if 0
dest->state = (struct internal_state *)
(*dest->zalloc)(1, sizeof(deflate_state));
(*dest->zalloc)(1, sizeof(deflate_state));
if (dest->state == Z_NULL) return Z_MEM_ERROR;
*(dest->state) = *(source->state);
@ -432,7 +432,7 @@ local int read_buf(strm, buf, size)
strm->avail_in -= len;
if (!strm->state->noheader) {
strm->state->adler = adler32(strm->state->adler, strm->next_in, len);
strm->state->adler = adler32(strm->state->adler, strm->next_in, len);
}
zmemcpy(buf, strm->next_in, len);
strm->next_in += len;
@ -488,7 +488,7 @@ local void lm_init (s)
/* For 80x86 and 680x0, an optimized version will be provided in match.asm or
* match.S. The code will be functionally equivalent.
*/
local int longest_match(s, cur_match)
local INLINE int longest_match(s, cur_match)
deflate_state *s;
IPos cur_match; /* current match */
{
@ -498,10 +498,12 @@ local int longest_match(s, cur_match)
register int len; /* length of current match */
int best_len = s->prev_length; /* best match length so far */
IPos limit = s->strstart > (IPos)MAX_DIST(s) ?
s->strstart - (IPos)MAX_DIST(s) : NIL;
s->strstart - (IPos)MAX_DIST(s) : NIL;
/* Stop when cur_match becomes <= limit. To simplify the code,
* we prevent matches with the string of window index 0.
*/
Pos *prev = s->prev;
uInt wmask = s->w_mask;
#ifdef UNALIGNED_OK
/* Compare two bytes at a time. Note: this is not always beneficial.
@ -609,7 +611,7 @@ local int longest_match(s, cur_match)
scan_end = scan[best_len];
#endif
}
} while ((cur_match = s->prev[cur_match & s->w_mask]) > limit
} while ((cur_match = prev[cur_match & wmask]) > limit
&& --chain_length != 0);
return best_len;
@ -634,8 +636,8 @@ local void check_match(s, start, match, length)
z_error("invalid match");
}
if (verbose > 1) {
fprintf(stderr,"\\[%d,%d]", start-match, length);
do { putc(s->window[start++], stderr); } while (--length != 0);
fprintf(stderr,"\\[%d,%d]", start-match, length);
do { putc(s->window[start++], stderr); } while (--length != 0);
}
}
#else
@ -656,14 +658,16 @@ local void fill_window(s)
deflate_state *s;
{
register unsigned n, m;
register Pos *p;
unsigned more; /* Amount of free space at the end of the window. */
uInt wsize = s->w_size;
do {
more = (unsigned)(s->window_size -(ulg)s->lookahead -(ulg)s->strstart);
more = (unsigned)(s->window_size -(ulg)s->lookahead -(ulg)s->strstart);
/* Deal with !@#$% 64K limit: */
if (more == 0 && s->strstart == 0 && s->lookahead == 0) {
more = s->w_size;
/* Deal with !@#$% 64K limit: */
if (more == 0 && s->strstart == 0 && s->lookahead == 0) {
more = wsize;
} else if (more == (unsigned)(-1)) {
/* Very unlikely, but possible on 16 bit machine if strstart == 0
* and lookahead == 1 (input done one byte at time)
@ -673,30 +677,39 @@ local void fill_window(s)
/* If the window is almost full and there is insufficient lookahead,
* move the upper half to the lower one to make room in the upper half.
*/
} else if (s->strstart >= s->w_size+MAX_DIST(s)) {
} else if (s->strstart >= wsize+MAX_DIST(s)) {
/* By the IN assertion, the window is not empty so we can't confuse
* more == 0 with more == 64K on a 16 bit machine.
*/
memcpy((char*)s->window, (char*)s->window+s->w_size,
(unsigned)s->w_size);
s->match_start -= s->w_size;
s->strstart -= s->w_size; /* we now have strstart >= MAX_DIST */
zmemcpy((char*)s->window, (char*)s->window+wsize,
(unsigned)wsize);
s->match_start -= wsize;
s->strstart -= wsize; /* we now have strstart >= MAX_DIST */
s->block_start -= (long) s->w_size;
s->block_start -= (long) wsize;
for (n = 0; n < s->hash_size; n++) {
m = s->head[n];
s->head[n] = (Pos)(m >= s->w_size ? m-s->w_size : NIL);
}
for (n = 0; n < s->w_size; n++) {
m = s->prev[n];
s->prev[n] = (Pos)(m >= s->w_size ? m-s->w_size : NIL);
/* Slide the hash table (could be avoided with 32 bit values
at the expense of memory usage):
*/
n = s->hash_size;
p = &s->head[n-1];
do {
m = *p;
*p-- = (Pos)(m >= wsize ? m-wsize : NIL);
} while (--n);
n = wsize;
p = &s->prev[n-1];
do {
m = *p;
*p-- = (Pos)(m >= wsize ? m-wsize : NIL);
/* If n is not on any hash chain, prev[n] is garbage but
* its value will never be used.
*/
}
more += s->w_size;
} while (--n);
more += wsize;
}
if (s->strm->avail_in == 0) return;
@ -714,8 +727,8 @@ local void fill_window(s)
Assert(more >= 2, "more < 2");
n = read_buf(s->strm, (char*)s->window + s->strstart + s->lookahead,
more);
s->lookahead += n;
more);
s->lookahead += n;
} while (s->lookahead < MIN_LOOKAHEAD && s->strm->avail_in != 0);
}
@ -726,7 +739,7 @@ local void fill_window(s)
*/
#define FLUSH_BLOCK_ONLY(s, eof) { \
ct_flush_block(s, (s->block_start >= 0L ? \
(char*)&s->window[(unsigned)s->block_start] : \
(char*)&s->window[(unsigned)s->block_start] : \
(char*)Z_NULL), (long)s->strstart - s->block_start, (eof)); \
s->block_start = s->strstart; \
flush_pending(s->strm); \
@ -761,11 +774,11 @@ local int deflate_fast(s, flush)
* string following the next match.
*/
if (s->lookahead < MIN_LOOKAHEAD) {
fill_window(s);
if (s->lookahead < MIN_LOOKAHEAD && flush == Z_NO_FLUSH) return 1;
fill_window(s);
if (s->lookahead < MIN_LOOKAHEAD && flush == Z_NO_FLUSH) return 1;
if (s->lookahead == 0) break; /* flush the current block */
}
if (s->lookahead == 0) break; /* flush the current block */
}
/* Insert the string window[strstart .. strstart+2] in the
* dictionary, and set hash_head to the head of the hash chain:
@ -780,9 +793,9 @@ local int deflate_fast(s, flush)
* of window index 0 (in particular we have to avoid a match
* of the string with itself at the start of the input file).
*/
if (s->strategy != Z_HUFFMAN_ONLY) {
s->match_length = longest_match (s, hash_head);
}
if (s->strategy != Z_HUFFMAN_ONLY) {
s->match_length = longest_match (s, hash_head);
}
/* longest_match() sets match_start */
if (s->match_length > s->lookahead) s->match_length = s->lookahead;
@ -791,7 +804,7 @@ local int deflate_fast(s, flush)
check_match(s, s->strstart, s->match_start, s->match_length);
bflush = ct_tally(s, s->strstart - s->match_start,
s->match_length - MIN_MATCH);
s->match_length - MIN_MATCH);
s->lookahead -= s->match_length;
@ -852,11 +865,11 @@ local int deflate_slow(s, flush)
* string following the next match.
*/
if (s->lookahead < MIN_LOOKAHEAD) {
fill_window(s);
if (s->lookahead < MIN_LOOKAHEAD && flush == Z_NO_FLUSH) return 1;
fill_window(s);
if (s->lookahead < MIN_LOOKAHEAD && flush == Z_NO_FLUSH) return 1;
if (s->lookahead == 0) break; /* flush the current block */
}
if (s->lookahead == 0) break; /* flush the current block */
}
/* Insert the string window[strstart .. strstart+2] in the
* dictionary, and set hash_head to the head of the hash chain:
@ -874,15 +887,15 @@ local int deflate_slow(s, flush)
* of window index 0 (in particular we have to avoid a match
* of the string with itself at the start of the input file).
*/
if (s->strategy != Z_HUFFMAN_ONLY) {
s->match_length = longest_match (s, hash_head);
}
if (s->strategy != Z_HUFFMAN_ONLY) {
s->match_length = longest_match (s, hash_head);
}
/* longest_match() sets match_start */
if (s->match_length > s->lookahead) s->match_length = s->lookahead;
if (s->match_length <= 5 && (s->strategy == Z_FILTERED ||
(s->match_length == MIN_MATCH &&
s->strstart - s->match_start > TOO_FAR))) {
(s->match_length == MIN_MATCH &&
s->strstart - s->match_start > TOO_FAR))) {
/* If prev_match is also MIN_MATCH, match_start is garbage
* but we will ignore the current match anyway.
@ -898,7 +911,7 @@ local int deflate_slow(s, flush)
check_match(s, s->strstart-1, s->prev_match, s->prev_length);
bflush = ct_tally(s, s->strstart -1 - s->prev_match,
s->prev_length - MIN_MATCH);
s->prev_length - MIN_MATCH);
/* Insert in hash table all strings up to the end of the match.
* strstart-1 and strstart are already inserted.
@ -927,11 +940,11 @@ local int deflate_slow(s, flush)
*/
Tracevv((stderr,"%c", s->window[s->strstart-1]));
if (ct_tally (s, 0, s->window[s->strstart-1])) {
FLUSH_BLOCK_ONLY(s, 0);
FLUSH_BLOCK_ONLY(s, 0);
}
s->strstart++;
s->lookahead--;
if (s->strm->avail_out == 0) return 1;
if (s->strm->avail_out == 0) return 1;
} else {
/* There is no previous match to compare with, wait for
* the next step to decide.
@ -942,8 +955,8 @@ local int deflate_slow(s, flush)
}
}
if (s->match_available) {
ct_tally (s, 0, s->window[s->strstart-1]);
s->match_available = 0;
ct_tally (s, 0, s->window[s->strstart-1]);
s->match_available = 0;
}
FLUSH_BLOCK(s, flush == Z_FINISH);
return 0;

10
deflate.h
View File

@ -8,7 +8,7 @@
subject to change. Applications should only use zlib.h.
*/
/* $Id: deflate.h,v 1.4 1995/05/01 15:08:45 jloup Exp $ */
/* $Id: deflate.h,v 1.5 1995/05/03 17:27:09 jloup Exp $ */
#include "zutil.h"
@ -90,7 +90,7 @@ typedef struct internal_state {
Byte data_type; /* UNKNOWN, BINARY or ASCII */
Byte method; /* STORED (for zip only) or DEFLATED */
/* used by deflate.c: */
/* used by deflate.c: */
uInt w_size; /* LZ77 window size (32K by default) */
uInt w_bits; /* log2(w_size) (8..16) */
@ -173,7 +173,7 @@ typedef struct internal_state {
int nice_match; /* Stop searching when current match exceeds this */
/* used by trees.c: */
/* used by trees.c: */
ct_data dyn_ltree[HEAP_SIZE]; /* literal and length tree */
ct_data dyn_dtree[2*D_CODES+1]; /* distance tree */
@ -264,9 +264,9 @@ typedef struct internal_state {
* distances are limited to MAX_DIST instead of WSIZE.
*/
/* in trees.c */
/* in trees.c */
void ct_init __P((deflate_state *s));
int ct_tally __P((deflate_state *s, int dist, int lc));
ulg ct_flush_block __P((deflate_state *s, char *buf, ulg stored_len, int eof));
void ct_stored_block __P((deflate_state *s, char *buf, ulg stored_len,
int eof));
int eof));

60
example.c
View File

@ -3,7 +3,7 @@
* For conditions of distribution and use, see copyright notice in zlib.h
*/
/* $Id: example.c,v 1.8 1995/05/02 15:52:32 jloup Exp $ */
/* $Id: example.c,v 1.9 1995/05/03 17:27:09 jloup Exp $ */
#include <stdio.h>
#include "zlib.h"
@ -27,7 +27,7 @@ extern void exit __P((int));
#define CHECK_ERR(err, msg) { \
if (err != Z_OK) { \
fprintf(stderr, "%s error: %d\n", msg, err); \
exit(1); \
exit(1); \
} \
}
@ -60,9 +60,9 @@ void test_compress()
CHECK_ERR(err, "uncompress");
if (strcmp((char*)uncompr, hello)) {
fprintf(stderr, "bad uncompress\n");
fprintf(stderr, "bad uncompress\n");
} else {
printf("uncompress(): %s\n", uncompr);
printf("uncompress(): %s\n", uncompr);
}
}
@ -81,31 +81,31 @@ void test_gzio(out, in)
file = gzopen(out, "wb");
if (file == NULL) {
fprintf(stderr, "gzopen error\n");
exit(1);
fprintf(stderr, "gzopen error\n");
exit(1);
}
if (gzwrite(file, hello, len) != len) {
fprintf(stderr, "gzwrite err: %s\n", gzerror(file, &err));
fprintf(stderr, "gzwrite err: %s\n", gzerror(file, &err));
}
gzclose(file);
file = gzopen(in, "rb");
if (file == NULL) {
fprintf(stderr, "gzopen error\n");
fprintf(stderr, "gzopen error\n");
}
strcpy((char*)uncompr, "garbage");
uncomprLen = gzread(file, uncompr, uncomprLen);
if (uncomprLen != len) {
fprintf(stderr, "gzread err: %s\n", gzerror(file, &err));
fprintf(stderr, "gzread err: %s\n", gzerror(file, &err));
}
gzclose(file);
if (strcmp((char*)uncompr, hello)) {
fprintf(stderr, "bad gzread\n");
fprintf(stderr, "bad gzread\n");
} else {
printf("gzread(): %s\n", uncompr);
printf("gzread(): %s\n", uncompr);
}
}
@ -129,16 +129,16 @@ void test_deflate(compr)
c_stream.next_out = compr;
while (c_stream.total_in != (uLong)len) {
c_stream.avail_in = c_stream.avail_out = 1; /* force small buffers */
err = deflate(&c_stream, Z_NO_FLUSH);
CHECK_ERR(err, "deflate");
c_stream.avail_in = c_stream.avail_out = 1; /* force small buffers */
err = deflate(&c_stream, Z_NO_FLUSH);
CHECK_ERR(err, "deflate");
}
/* Finish the stream, still forcing small buffers: */
for (;;) {
c_stream.avail_out = 1;
err = deflate(&c_stream, Z_FINISH);
if (err == Z_STREAM_END) break;
CHECK_ERR(err, "deflate");
c_stream.avail_out = 1;
err = deflate(&c_stream, Z_FINISH);
if (err == Z_STREAM_END) break;
CHECK_ERR(err, "deflate");
}
err = deflateEnd(&c_stream);
@ -167,19 +167,19 @@ void test_inflate(compr)
d_stream.next_out = uncompr;
for (;;) {
d_stream.avail_in = d_stream.avail_out = 1; /* force small buffers */
err = inflate(&d_stream, Z_NO_FLUSH);
if (err == Z_STREAM_END) break;
CHECK_ERR(err, "inflate");
d_stream.avail_in = d_stream.avail_out = 1; /* force small buffers */
err = inflate(&d_stream, Z_NO_FLUSH);
if (err == Z_STREAM_END) break;
CHECK_ERR(err, "inflate");
}
err = inflateEnd(&d_stream);
CHECK_ERR(err, "inflateEnd");
if (strcmp((char*)uncompr, hello)) {
fprintf(stderr, "bad inflate\n");
fprintf(stderr, "bad inflate\n");
} else {
printf("inflate(): %s\n", uncompr);
printf("inflate(): %s\n", uncompr);
}
}
@ -211,7 +211,7 @@ void test_flush(compr)
err = deflate(&c_stream, Z_FINISH);
if (err != Z_STREAM_END) {
CHECK_ERR(err, "deflate");
CHECK_ERR(err, "deflate");
}
err = deflateEnd(&c_stream);
CHECK_ERR(err, "deflateEnd");
@ -250,7 +250,7 @@ void test_sync(compr)
err = inflate(&d_stream, Z_FINISH);
if (err != Z_DATA_ERROR) {
fprintf(stderr, "inflate should report DATA_ERROR\n");
/* Because of incorrect adler32 */
/* Because of incorrect adler32 */
}
err = inflateEnd(&d_stream);
CHECK_ERR(err, "inflateEnd");
@ -269,16 +269,16 @@ void main(argc, argv)
local Byte compr[BUFLEN];
if (zlib_version[0] != ZLIB_VERSION[0]) {
fprintf(stderr, "incompatible zlib version\n");
exit(1);
fprintf(stderr, "incompatible zlib version\n");
exit(1);
} else if (strcmp(zlib_version, ZLIB_VERSION) != 0) {
fprintf(stderr, "warning: different zlib version\n");
fprintf(stderr, "warning: different zlib version\n");
}
test_compress();
test_gzio((argc > 1 ? argv[1] : "foo.gz"),
(argc > 2 ? argv[2] : "foo.gz"));
(argc > 2 ? argv[2] : "foo.gz"));
test_deflate(compr);
test_inflate(compr);

272
gzio.c
View File

@ -3,7 +3,7 @@
* For conditions of distribution and use, see copyright notice in zlib.h
*/
/* $Id: gzio.c,v 1.7 1995/05/02 12:22:08 jloup Exp $ */
/* $Id: gzio.c,v 1.8 1995/05/03 17:27:09 jloup Exp $ */
#include <stdio.h>
@ -68,13 +68,13 @@ local int destroy (s)
if (s->stream.state != NULL) {
if (s->mode == 'w') {
err = deflateEnd(&(s->stream));
err = deflateEnd(&(s->stream));
} else if (s->mode == 'r') {
err = inflateEnd(&(s->stream));
err = inflateEnd(&(s->stream));
}
}
if (s->file != NULL && fclose(s->file)) {
err = Z_ERRNO;
err = Z_ERRNO;
}
if (s->z_err < 0) err = s->z_err;
zcfree((voidp)0, s);
@ -115,34 +115,34 @@ local gzFile gz_open (path, mode, fd)
s->path = (char*)ALLOC(strlen(path)+1);
if (s->path == NULL) {
return destroy(s), (gzFile)Z_NULL;
return destroy(s), (gzFile)Z_NULL;
}
strcpy(s->path, path); /* do this early for debugging */
s->mode = '\0';
do {
if (*p == 'r') s->mode = 'r';
if (*p == 'w') s->mode = 'w';
if (*p == 'r') s->mode = 'r';
if (*p == 'w') s->mode = 'w';
} while (*p++);
if (s->mode == '\0') return destroy(s), (gzFile)Z_NULL;
if (s->mode == 'w') {
err = deflateInit2(&(s->stream), Z_DEFAULT_COMPRESSION,
DEFLATED, -MAX_WBITS, DEF_MEM_LEVEL, 0);
/* windowBits is passed < 0 to suppress zlib header */
err = deflateInit2(&(s->stream), Z_DEFAULT_COMPRESSION,
DEFLATED, -MAX_WBITS, DEF_MEM_LEVEL, 0);
/* windowBits is passed < 0 to suppress zlib header */
s->stream.next_out = s->outbuf = ALLOC(Z_BUFSIZE);
s->stream.next_out = s->outbuf = ALLOC(Z_BUFSIZE);
if (err != Z_OK || s->outbuf == Z_NULL) {
return destroy(s), (gzFile)Z_NULL;
}
if (err != Z_OK || s->outbuf == Z_NULL) {
return destroy(s), (gzFile)Z_NULL;
}
} else {
err = inflateInit2(&(s->stream), -MAX_WBITS);
s->stream.next_in = s->inbuf = ALLOC(Z_BUFSIZE);
err = inflateInit2(&(s->stream), -MAX_WBITS);
s->stream.next_in = s->inbuf = ALLOC(Z_BUFSIZE);
if (err != Z_OK || s->inbuf == Z_NULL) {
return destroy(s), (gzFile)Z_NULL;
}
if (err != Z_OK || s->inbuf == Z_NULL) {
return destroy(s), (gzFile)Z_NULL;
}
}
s->stream.avail_out = Z_BUFSIZE;
@ -150,55 +150,55 @@ local gzFile gz_open (path, mode, fd)
s->file = fd < 0 ? FOPEN(path, mode) : fdopen(fd, mode);
if (s->file == NULL) {
return destroy(s), (gzFile)Z_NULL;
return destroy(s), (gzFile)Z_NULL;
}
if (s->mode == 'w') {
/* Write a very simple .gz header:
*/
fprintf(s->file, "%c%c%c%c%c%c%c%c%c%c", GZ_MAGIC_1, GZ_MAGIC_2,
DEFLATED, 0 /*flags*/, 0,0,0,0 /*time*/, 0 /*xflags*/, OS_CODE);
} else {
/* Check and skip the header:
/* Write a very simple .gz header:
*/
Byte c1 = 0, c2 = 0;
Byte method = 0;
Byte flags = 0;
Byte xflags = 0;
Byte time[4];
Byte osCode;
int c;
fprintf(s->file, "%c%c%c%c%c%c%c%c%c%c", GZ_MAGIC_1, GZ_MAGIC_2,
DEFLATED, 0 /*flags*/, 0,0,0,0 /*time*/, 0 /*xflags*/, OS_CODE);
} else {
/* Check and skip the header:
*/
Byte c1 = 0, c2 = 0;
Byte method = 0;
Byte flags = 0;
Byte xflags = 0;
Byte time[4];
Byte osCode;
int c;
s->stream.avail_in = fread(s->inbuf, 1, 2, s->file);
if (s->stream.avail_in != 2 || s->inbuf[0] != GZ_MAGIC_1
|| s->inbuf[1] != GZ_MAGIC_2) {
s->transparent = 1;
return (gzFile)s;
}
s->stream.avail_in = 0;
fscanf(s->file,"%c%c%4c%c%c", &method, &flags, time, &xflags, &osCode);
s->stream.avail_in = fread(s->inbuf, 1, 2, s->file);
if (s->stream.avail_in != 2 || s->inbuf[0] != GZ_MAGIC_1
|| s->inbuf[1] != GZ_MAGIC_2) {
s->transparent = 1;
return (gzFile)s;
}
s->stream.avail_in = 0;
fscanf(s->file,"%c%c%4c%c%c", &method, &flags, time, &xflags, &osCode);
if (method != DEFLATED || feof(s->file) || (flags & RESERVED) != 0) {
s->z_err = Z_DATA_ERROR;
return (gzFile)s;
}
if ((flags & EXTRA_FIELD) != 0) { /* skip the extra field */
long len;
fscanf(s->file, "%c%c", &c1, &c2);
len = c1 + ((long)c2<<8);
fseek(s->file, len, SEEK_CUR);
}
if ((flags & ORIG_NAME) != 0) { /* skip the original file name */
while ((c = getc(s->file)) != 0 && c != EOF) ;
}
if ((flags & COMMENT) != 0) { /* skip the .gz file comment */
while ((c = getc(s->file)) != 0 && c != EOF) ;
}
if ((flags & HEAD_CRC) != 0) { /* skip the header crc */
fscanf(s->file, "%c%c", &c1, &c2);
}
if (feof(s->file)) {
s->z_err = Z_DATA_ERROR;
}
if (method != DEFLATED || feof(s->file) || (flags & RESERVED) != 0) {
s->z_err = Z_DATA_ERROR;
return (gzFile)s;
}
if ((flags & EXTRA_FIELD) != 0) { /* skip the extra field */
long len;
fscanf(s->file, "%c%c", &c1, &c2);
len = c1 + ((long)c2<<8);
fseek(s->file, len, SEEK_CUR);
}
if ((flags & ORIG_NAME) != 0) { /* skip the original file name */
while ((c = getc(s->file)) != 0 && c != EOF) ;
}
if ((flags & COMMENT) != 0) { /* skip the .gz file comment */
while ((c = getc(s->file)) != 0 && c != EOF) ;
}
if ((flags & HEAD_CRC) != 0) { /* skip the header crc */
fscanf(s->file, "%c%c", &c1, &c2);
}
if (feof(s->file)) {
s->z_err = Z_DATA_ERROR;
}
}
return (gzFile)s;
}
@ -240,16 +240,16 @@ int gzread (file, buf, len)
if (s == NULL || s->mode != 'r') return Z_STREAM_ERROR;
if (s->transparent) {
unsigned n = 0;
Byte *b = (Byte*)buf;
/* Copy the first two (non-magic) bytes if not done already */
while (s->stream.avail_in > 0 && len > 0) {
*b++ = *s->stream.next_in++;
s->stream.avail_in--;
len--; n++;
}
if (len == 0) return n;
return n + fread(b, 1, len, s->file);
unsigned n = 0;
Byte *b = (Byte*)buf;
/* Copy the first two (non-magic) bytes if not done already */
while (s->stream.avail_in > 0 && len > 0) {
*b++ = *s->stream.next_in++;
s->stream.avail_in--;
len--; n++;
}
if (len == 0) return n;
return n + fread(b, 1, len, s->file);
}
if (s->z_err == Z_DATA_ERROR) return -1; /* bad .gz file */
if (s->z_err == Z_STREAM_END) return 0; /* don't read crc as data */
@ -259,24 +259,24 @@ int gzread (file, buf, len)
while (s->stream.avail_out != 0) {
if (s->stream.avail_in == 0 && !s->z_eof) {
if (s->stream.avail_in == 0 && !s->z_eof) {
errno = 0;
s->stream.avail_in =
fread(s->inbuf, 1, Z_BUFSIZE, s->file);
if (s->stream.avail_in == 0) {
s->z_eof = 1;
} else if (s->stream.avail_in == (uInt)EOF) {
s->stream.avail_in = 0;
s->z_eof = 1;
s->z_err = Z_ERRNO;
break;
}
s->stream.next_in = s->inbuf;
}
s->z_err = inflate(&(s->stream), Z_NO_FLUSH);
errno = 0;
s->stream.avail_in =
fread(s->inbuf, 1, Z_BUFSIZE, s->file);
if (s->stream.avail_in == 0) {
s->z_eof = 1;
} else if (s->stream.avail_in == (uInt)EOF) {
s->stream.avail_in = 0;
s->z_eof = 1;
s->z_err = Z_ERRNO;
break;
}
s->stream.next_in = s->inbuf;
}
s->z_err = inflate(&(s->stream), Z_NO_FLUSH);
if (s->z_err == Z_STREAM_END ||
if (s->z_err == Z_STREAM_END ||
s->z_err != Z_OK || s->z_eof) break;
}
len -= s->stream.avail_out;
@ -302,18 +302,18 @@ int gzwrite (file, buf, len)
while (s->stream.avail_in != 0) {
if (s->stream.avail_out == 0) {
if (s->stream.avail_out == 0) {
s->stream.next_out = s->outbuf;
if (fwrite(s->outbuf, 1, Z_BUFSIZE, s->file) != Z_BUFSIZE) {
s->z_err = Z_ERRNO;
break;
}
s->stream.avail_out = Z_BUFSIZE;
}
s->z_err = deflate(&(s->stream), Z_NO_FLUSH);
s->stream.next_out = s->outbuf;
if (fwrite(s->outbuf, 1, Z_BUFSIZE, s->file) != Z_BUFSIZE) {
s->z_err = Z_ERRNO;
break;
}
s->stream.avail_out = Z_BUFSIZE;
}
s->z_err = deflate(&(s->stream), Z_NO_FLUSH);
if (s->z_err != Z_OK) break;
if (s->z_err != Z_OK) break;
}
s->crc = crc32(s->crc, buf, len);
@ -339,25 +339,25 @@ int gzflush (file, flush)
s->stream.avail_in = 0; /* should be zero already anyway */
for (;;) {
len = Z_BUFSIZE - s->stream.avail_out;
len = Z_BUFSIZE - s->stream.avail_out;
if (len != 0) {
if (fwrite(s->outbuf, 1, len, s->file) != len) {
s->z_err = Z_ERRNO;
return Z_ERRNO;
}
s->stream.next_out = s->outbuf;
s->stream.avail_out = Z_BUFSIZE;
}
if (done) break;
s->z_err = deflate(&(s->stream), flush);
if (len != 0) {
if (fwrite(s->outbuf, 1, len, s->file) != len) {
s->z_err = Z_ERRNO;
return Z_ERRNO;
}
s->stream.next_out = s->outbuf;
s->stream.avail_out = Z_BUFSIZE;
}
if (done) break;
s->z_err = deflate(&(s->stream), flush);
/* deflate has finished flushing only when it hasn't used up
* all the available space in the output buffer:
*/
done = (s->stream.avail_out != 0 || s->z_err == Z_STREAM_END);
if (s->z_err != Z_OK && s->z_err != Z_STREAM_END) break;
if (s->z_err != Z_OK && s->z_err != Z_STREAM_END) break;
}
return s->z_err == Z_STREAM_END ? Z_OK : s->z_err;
}
@ -371,8 +371,8 @@ local void putLong (file, x)
{
int n;
for (n = 0; n < 4; n++) {
fputc((int)(x & 0xff), file);
x >>= 8;
fputc((int)(x & 0xff), file);
x >>= 8;
}
}
@ -386,8 +386,8 @@ local uLong getLong (buf)
Byte *p = buf+4;
do {
x <<= 8;
x |= *--p;
x <<= 8;
x |= *--p;
} while (p != buf);
return x;
}
@ -406,31 +406,31 @@ int gzclose (file)
if (s == NULL) return Z_STREAM_ERROR;
if (s->mode == 'w') {
err = gzflush (file, Z_FINISH);
if (err != Z_OK) return destroy(file);
err = gzflush (file, Z_FINISH);
if (err != Z_OK) return destroy(file);
putLong (s->file, s->crc);
putLong (s->file, s->stream.total_in);
putLong (s->file, s->crc);
putLong (s->file, s->stream.total_in);
} else if (s->mode == 'r' && s->z_err == Z_STREAM_END) {
/* slide CRC and original size if they are at the end of inbuf */
if ((n = s->stream.avail_in) < 8 && !s->z_eof) {
Byte *p = s->inbuf;
Byte *q = s->stream.next_in;
while (n--) { *p++ = *q++; };
/* slide CRC and original size if they are at the end of inbuf */
if ((n = s->stream.avail_in) < 8 && !s->z_eof) {
Byte *p = s->inbuf;
Byte *q = s->stream.next_in;
while (n--) { *p++ = *q++; };
n = s->stream.avail_in;
n += fread(p, 1, 8, s->file);
s->stream.next_in = s->inbuf;
}
/* check CRC and original size */
if (n < 8 ||
getLong(s->stream.next_in) != s->crc ||
getLong(s->stream.next_in + 4) != s->stream.total_out) {
n = s->stream.avail_in;
n += fread(p, 1, 8, s->file);
s->stream.next_in = s->inbuf;
}
/* check CRC and original size */
if (n < 8 ||
getLong(s->stream.next_in) != s->crc ||
getLong(s->stream.next_in + 4) != s->stream.total_out) {
s->z_err = Z_DATA_ERROR;
}
s->z_err = Z_DATA_ERROR;
}
}
return destroy(file);
}
@ -450,8 +450,8 @@ char* gzerror (file, errnum)
gz_stream *s = (gz_stream*)file;
if (s == NULL) {
*errnum = Z_STREAM_ERROR;
return z_errmsg[1-Z_STREAM_ERROR];
*errnum = Z_STREAM_ERROR;
return z_errmsg[1-Z_STREAM_ERROR];
}
*errnum = s->z_err;
if (*errnum == Z_OK) return "";

264
infblock.c
View File

@ -12,7 +12,7 @@
struct inflate_codes_state {int dummy;}; /* for buggy compilers */
/* Table for deflate from PKZIP's appnote.txt. */
local uInt border[] = { /* Order of the bit length code lengths */
local uInt 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};
/*
@ -111,13 +111,13 @@ struct inflate_blocks_state *s;
z_stream *z;
int r;
{
uInt t; /* temporary storage */
uLong b; /* bit buffer */
uInt k; /* bits in bit buffer */
Byte *p; /* input data pointer */
uInt n; /* bytes available there */
Byte *q; /* output window write pointer */
uInt m; /* bytes to end of window or read pointer */
uInt t; /* temporary storage */
uLong b; /* bit buffer */
uInt k; /* bits in bit buffer */
Byte *p; /* input data pointer */
uInt n; /* bytes available there */
Byte *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
@ -131,44 +131,44 @@ int r;
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;
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.codes = inflate_codes_new(bl, bd, tl, td, z);
if (s->sub.codes == Z_NULL)
{
r = Z_MEM_ERROR;
LEAVE
}
}
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 = BAD;
z->msg = "invalid block type";
r = Z_DATA_ERROR;
LEAVE
inflate_trees_fixed(&bl, &bd, &tl, &td);
s->sub.codes = inflate_codes_new(bl, bd, tl, td, z);
if (s->sub.codes == Z_NULL)
{
r = Z_MEM_ERROR;
LEAVE
}
}
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 = BAD;
z->msg = "invalid block type";
r = Z_DATA_ERROR;
LEAVE
}
break;
case LENS:
@ -176,24 +176,30 @@ int r;
if ((~b) >> 16 != (b & 0xffff))
{
s->mode = BAD;
z->msg = "invalid stored block lengths";
r = Z_DATA_ERROR;
LEAVE
z->msg = "invalid stored block lengths";
r = Z_DATA_ERROR;
LEAVE
}
k = 0; /* dump bits */
s->sub.left = (uInt)b & 0xffff;
k = b = 0; /* dump bits */
Tracev((stderr, "inflate: stored length %u\n", s->sub.left));
s->mode = s->sub.left ? STORED : TYPE;
break;
case STORED:
do {
NEEDBYTE
NEEDOUT
OUTBYTE(NEXTBYTE)
} while (--s->sub.left);
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))));
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:
@ -204,8 +210,8 @@ int r;
{
s->mode = BAD;
z->msg = "too many length or distance symbols";
r = Z_DATA_ERROR;
LEAVE
r = Z_DATA_ERROR;
LEAVE
}
#endif
t = 258 + (t & 0x1f) + ((t >> 5) & 0x1f);
@ -214,7 +220,7 @@ int r;
if ((s->sub.trees.blens = (uInt*)ZALLOC(z, t, sizeof(uInt))) == Z_NULL)
{
r = Z_MEM_ERROR;
LEAVE
LEAVE
}
DUMPBITS(14)
s->sub.trees.index = 0;
@ -224,118 +230,118 @@ int r;
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)
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);
&s->sub.trees.tb, z);
if (t != Z_OK)
{
r = t;
if (r == Z_DATA_ERROR)
s->mode = BAD;
LEAVE
if (r == Z_DATA_ERROR)
s->mode = BAD;
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))
s->sub.trees.index < 258 + (t & 0x1f) + ((t >> 5) & 0x1f))
{
inflate_huft *h;
uInt i, j, c;
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 = BAD;
z->msg = "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;
}
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 = BAD;
z->msg = "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;
struct inflate_codes_state *c;
uInt bl, bd;
inflate_huft *tl, *td;
struct inflate_codes_state *c;
bl = 9;
bd = 6;
t = s->sub.trees.table;
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 = BAD;
r = t;
LEAVE
}
bl = 9;
bd = 6;
t = s->sub.trees.table;
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 = BAD;
r = t;
LEAVE
}
Tracev((stderr, "inflate: trees ok\n"));
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.codes = c;
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.codes = c;
}
s->mode = CODES;
case CODES:
UPDATE
if ((r = inflate_codes(s, z, r)) != Z_STREAM_END)
return inflate_flush(s, z, r);
return inflate_flush(s, z, r);
r = Z_OK;
inflate_codes_free(s->sub.codes, 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))));
z->total_out + (q >= s->read ? q - s->read :
(s->end - s->read) + (q - s->window))));
if (!s->last)
{
s->mode = TYPE;
break;
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 */
n++;
p--; /* can always return one */
}
s->mode = DRY;
case DRY:

2
infblock.h
View File

@ -18,7 +18,7 @@ extern struct inflate_blocks_state * inflate_blocks_new __P((
extern int inflate_blocks __P((
struct inflate_blocks_state *,
z_stream *,
int)); /* initial return code */
int)); /* initial return code */
extern void inflate_blocks_reset __P((
struct inflate_blocks_state *,

184
infcodes.c
View File

@ -19,38 +19,38 @@
struct inflate_codes_state {
/* mode */
enum { /* waiting for "i:"=input, "o:"=output, "x:"=nothing */
START, /* x: set up for LEN */
LEN, /* i: get length/literal/eob next */
LENEXT, /* i: getting length extra (have base) */
DIST, /* i: get distance next */
DISTEXT, /* i: getting distance extra */
COPY, /* o: copying bytes in window, waiting for space */
LIT, /* o: got literal, waiting for output space */
WASH, /* o: got eob, possibly still output waiting */
END, /* x: got eob and all data flushed */
BADCODE} /* x: got error */
mode; /* current inflate_codes mode */
enum { /* waiting for "i:"=input, "o:"=output, "x:"=nothing */
START, /* x: set up for LEN */
LEN, /* i: get length/literal/eob next */
LENEXT, /* i: getting length extra (have base) */
DIST, /* i: get distance next */
DISTEXT, /* i: getting distance extra */
COPY, /* o: copying bytes in window, waiting for space */
LIT, /* o: got literal, waiting for output space */
WASH, /* o: got eob, possibly still output waiting */
END, /* x: got eob and all data flushed */
BADCODE} /* x: got error */
mode; /* current inflate_codes mode */
/* mode dependent information */
uInt len;
union {
struct {
inflate_huft *tree; /* pointer into tree */
uInt need; /* bits needed */
} code; /* if LEN or DIST, where in tree */
uInt lit; /* if LIT, literal */
inflate_huft *tree; /* pointer into tree */
uInt need; /* bits needed */
} code; /* if LEN or DIST, where in tree */
uInt lit; /* if LIT, literal */
struct {
uInt get; /* bits to get for extra */
uInt dist; /* distance back to copy from */
} copy; /* if EXT or COPY, where and how much */
} sub; /* submode */
uInt get; /* bits to get for extra */
uInt dist; /* distance back to copy from */
} copy; /* if EXT or COPY, where and how much */
} sub; /* submode */
/* mode independent information */
Byte lbits; /* ltree bits decoded per branch */
Byte dbits; /* dtree bits decoder per branch */
inflate_huft *ltree; /* literal/length/eob tree */
inflate_huft *dtree; /* distance tree */
Byte lbits; /* ltree bits decoded per branch */
Byte dbits; /* dtree bits decoder per branch */
inflate_huft *ltree; /* literal/length/eob tree */
inflate_huft *dtree; /* distance tree */
};
@ -81,79 +81,79 @@ struct inflate_blocks_state *s;
z_stream *z;
int r;
{
uInt j; /* temporary storage */
inflate_huft *t; /* temporary pointer */
int e; /* extra bits or operation */
uLong b; /* bit buffer */
uInt k; /* bits in bit buffer */
Byte *p; /* input data pointer */
uInt n; /* bytes available there */
Byte *q; /* output window write pointer */
uInt m; /* bytes to end of window or read pointer */
Byte *f; /* pointer to copy strings from */
struct inflate_codes_state *c = s->sub.codes; /* codes state */
uInt j; /* temporary storage */
inflate_huft *t; /* temporary pointer */
int e; /* extra bits or operation */
uLong b; /* bit buffer */
uInt k; /* bits in bit buffer */
Byte *p; /* input data pointer */
uInt n; /* bytes available there */
Byte *q; /* output window write pointer */
uInt m; /* bytes to end of window or read pointer */
Byte *f; /* pointer to copy strings from */
struct inflate_codes_state *c = s->sub.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 */
{ /* 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;
}
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 */
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)
if ((e = (int)(t->exop)) < 0)
{
if (e == -128) /* invalid code */
{
c->mode = BADCODE;
z->msg = "invalid literal/length code";
r = Z_DATA_ERROR;
LEAVE
}
e = -e;
if (e & 64) /* end of block */
{
Tracevv((stderr, "inflate: end of block\n"));
c->mode = WASH;
break;
}
c->sub.code.need = e;
c->sub.code.tree = t->next;
break;
if (e == -128) /* invalid code */
{
c->mode = BADCODE;
z->msg = "invalid literal/length code";
r = Z_DATA_ERROR;
LEAVE
}
e = -e;
if (e & 64) /* end of block */
{
Tracevv((stderr, "inflate: end of block\n"));
c->mode = WASH;
break;
}
c->sub.code.need = e;
c->sub.code.tree = t->next;
break;
}
if (e & 16) /* literal */
if (e & 16) /* 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;
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;
}
c->sub.copy.get = e;
c->len = t->base;
c->mode = LENEXT;
case LENEXT: /* i: getting length extra (have base) */
case LENEXT: /* i: getting length extra (have base) */
j = c->sub.copy.get;
NEEDBITS(j)
c->len += (uInt)b & inflate_mask[j];
@ -162,7 +162,7 @@ int r;
c->sub.code.tree = c->dtree;
Tracevv((stderr, "inflate: length %u\n", c->len));
c->mode = DIST;
case DIST: /* i: get distance next */
case DIST: /* i: get distance next */
j = c->sub.code.need;
NEEDBITS(j)
t = c->sub.code.tree + ((uInt)b & inflate_mask[j]);
@ -170,46 +170,46 @@ int r;
if ((e = (int)(t->exop)) < 0)
{
if (e == -128)
{
c->mode = BADCODE;
z->msg = "invalid distance code";
r = Z_DATA_ERROR;
LEAVE
}
c->sub.code.need = -e;
c->sub.code.tree = t->next;
break;
{
c->mode = BADCODE;
z->msg = "invalid distance code";
r = Z_DATA_ERROR;
LEAVE
}
c->sub.code.need = -e;
c->sub.code.tree = t->next;
break;
}
c->sub.copy.dist = t->base;
c->sub.copy.get = e;
c->mode = DISTEXT;
case DISTEXT: /* i: getting distance extra */
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 */
case COPY: /* o: copying bytes in window, waiting for space */
f = (uInt)(q - s->window) < c->sub.copy.dist ?
s->end - (c->sub.copy.dist - (q - s->window)) :
q - c->sub.copy.dist;
s->end - (c->sub.copy.dist - (q - s->window)) :
q - c->sub.copy.dist;
while (c->len)
{
NEEDOUT
OUTBYTE(*f++)
if (f == s->end)
f = s->window;
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 */
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 */
case WASH: /* o: got eob, possibly more output */
FLUSH
if (s->read != s->write)
LEAVE
@ -217,7 +217,7 @@ int r;
case END:
r = Z_STREAM_END;
LEAVE
case BADCODE: /* x: got error */
case BADCODE: /* x: got error */
r = Z_DATA_ERROR;
LEAVE
default:

136
inffast.c
View File

@ -35,19 +35,19 @@ inflate_huft *tl, *td;
struct inflate_blocks_state *s;
z_stream *z;
{
inflate_huft *t; /* temporary pointer */
int e; /* extra bits or operation */
uLong b; /* bit buffer */
uInt k; /* bits in bit buffer */
Byte *p; /* input data pointer */
uInt n; /* bytes available there */
Byte *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 */
Byte *r; /* copy source pointer */
inflate_huft *t; /* temporary pointer */
int e; /* extra bits or operation */
uLong b; /* bit buffer */
uInt k; /* bits in bit buffer */
Byte *p; /* input data pointer */
uInt n; /* bytes available there */
Byte *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 */
Byte *r; /* copy source pointer */
/* load input, output, bit values */
LOAD
@ -57,40 +57,40 @@ z_stream *z;
md = inflate_mask[bd];
/* do until not enough input or output space for fast loop */
do { /* assume called with m >= 258 && n >= 10 */
do { /* assume called with m >= 258 && n >= 10 */
/* get literal/length code */
GRABBITS(20) /* max bits for literal/length code */
GRABBITS(20) /* max bits for literal/length code */
if ((e = (t = tl + ((uInt)b & ml))->exop) < 0)
do {
if (e == -128)
{
z->msg = "invalid literal/length code";
if (e == -128)
{
z->msg = "invalid literal/length code";
UNGRAB
UPDATE
return Z_DATA_ERROR;
}
DUMPBITS(t->bits)
e = -e;
if (e & 64) /* end of block */
{
Tracevv((stderr, "inflate: * end of block\n"));
UPDATE
return Z_DATA_ERROR;
}
DUMPBITS(t->bits)
e = -e;
if (e & 64) /* end of block */
{
Tracevv((stderr, "inflate: * end of block\n"));
UNGRAB
UPDATE
return Z_STREAM_END;
}
UPDATE
return Z_STREAM_END;
}
} while ((e = (t = t->next + ((uInt)b & inflate_mask[e]))->exop) < 0);
DUMPBITS(t->bits)
/* process literal or length (end of block already trapped) */
if (e & 16) /* then it's a literal */
if (e & 16) /* then it's a literal */
{
Tracevv((stderr, t->base >= 0x20 && t->base < 0x7f ?
"inflate: * literal '%c'\n" :
"inflate: * literal 0x%02x\n", t->base));
"inflate: * literal '%c'\n" :
"inflate: * literal 0x%02x\n", t->base));
*q++ = (Byte)t->base;
m--;
}
else /* it's a length */
else /* it's a length */
{
/* get length of block to copy (already have extra bits) */
c = t->base + ((uInt)b & inflate_mask[e]);
@ -98,53 +98,53 @@ z_stream *z;
Tracevv((stderr, "inflate: * length %u\n", c));
/* decode distance base of block to copy */
GRABBITS(15); /* max bits for distance code */
GRABBITS(15); /* max bits for distance code */
if ((e = (t = td + ((uInt)b & md))->exop) < 0)
do {
if (e == -128)
{
z->msg = "invalid distance code";
UNGRAB
UPDATE
return Z_DATA_ERROR;
}
DUMPBITS(t->bits)
e = -e;
} while ((e = (t = t->next + ((uInt)b & inflate_mask[e]))->exop) < 0);
do {
if (e == -128)
{
z->msg = "invalid distance code";
UNGRAB
UPDATE
return Z_DATA_ERROR;
}
DUMPBITS(t->bits)
e = -e;
} while ((e = (t = t->next + ((uInt)b & inflate_mask[e]))->exop) < 0);
DUMPBITS(t->bits)
/* get extra bits to add to distance base */
GRABBITS((uInt)e) /* get extra bits (up to 13) */
GRABBITS((uInt)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) /* if offset before destination, */
{ /* just copy */
r = q - d;
*q++ = *r++; c--; /* minimum count is three, */
*q++ = *r++; c--; /* so unroll loop a little */
do {
*q++ = *r++;
} while (--c);
if ((uInt)(q - s->window) >= d) /* if offset before destination, */
{ /* just copy */
r = q - d;
*q++ = *r++; c--; /* minimum count is three, */
*q++ = *r++; c--; /* so unroll loop a little */
do {
*q++ = *r++;
} while (--c);
}
else /* else offset after destination */
else /* else offset after destination */
{
e = d - (q - s->window); /* bytes from offset to end */
r = s->end - e; /* pointer to offset */
if (c > (uInt)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);
e = d - (q - s->window); /* bytes from offset to end */
r = s->end - e; /* pointer to offset */
if (c > (uInt)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);
}
}
} while (m >= 258 && n >= 10);

80
inflate.c
View File

@ -13,32 +13,32 @@ struct internal_state {
/* mode */
enum {
METHOD, /* waiting for method byte */
FLAG, /* waiting for flag byte */
BLOCKS, /* decompressing blocks */
CHECK4, /* four check bytes to go */
CHECK3, /* three check bytes to go */
CHECK2, /* two check bytes to go */
CHECK1, /* one check byte to go */
DONE, /* finished check, done */
BAD} /* got an error--stay here */
mode; /* current inflate mode */
METHOD, /* waiting for method byte */
FLAG, /* waiting for flag byte */
BLOCKS, /* decompressing blocks */
CHECK4, /* four check bytes to go */
CHECK3, /* three check bytes to go */
CHECK2, /* two check bytes to go */
CHECK1, /* one check byte to go */
DONE, /* finished check, done */
BAD} /* got an error--stay here */
mode; /* current inflate mode */
/* mode dependent information */
union {
uInt method; /* if FLAGS, method byte */
uInt method; /* if FLAGS, method byte */
struct {
uLong was; /* computed check value */
uLong need; /* stream check value */
} check; /* if CHECK, check values to compare */
uInt marker; /* if BAD, inflateSync's marker bytes count */
} sub; /* submode */
uInt marker; /* if BAD, inflateSync's marker bytes count */
} sub; /* submode */
/* mode independent information */
int nowrap; /* flag for no wrapper */
uInt wbits; /* log2(window size) (8..15, defaults to 15) */
int nowrap; /* flag for no wrapper */
uInt wbits; /* log2(window size) (8..15, defaults to 15) */
struct inflate_blocks_state
*blocks; /* current inflate_blocks state */
*blocks; /* current inflate_blocks state */
};
@ -135,7 +135,7 @@ int inflate(z, f)
z_stream *z;
int f;
{
int r = f; /* to avoid warning about unused f */
int r = f; /* to avoid warning about unused f */
uInt b;
if (z == Z_NULL || z->next_in == Z_NULL)
@ -148,16 +148,16 @@ int f;
if (((z->state->sub.method = NEXTBYTE) & 0xf) != DEFLATED)
{
z->state->mode = BAD;
z->msg = "unknown compression method";
z->state->sub.marker = 5; /* can't try inflateSync */
break;
z->msg = "unknown compression method";
z->state->sub.marker = 5; /* can't try inflateSync */
break;
}
if ((z->state->sub.method >> 4) + 8 > z->state->wbits)
{
z->state->mode = BAD;
z->msg = "invalid window size";
z->state->sub.marker = 5; /* can't try inflateSync */
break;
z->msg = "invalid window size";
z->state->sub.marker = 5; /* can't try inflateSync */
break;
}
z->state->mode = FLAG;
case FLAG:
@ -165,16 +165,16 @@ int f;
if ((b = NEXTBYTE) & 0x20)
{
z->state->mode = BAD;
z->msg = "invalid reserved bit";
z->state->sub.marker = 5; /* can't try inflateSync */
break;
z->msg = "invalid reserved bit";
z->state->sub.marker = 5; /* can't try inflateSync */
break;
}
if (((z->state->sub.method << 8) + b) % 31)
{
z->state->mode = BAD;
z->msg = "incorrect header check";
z->state->sub.marker = 5; /* can't try inflateSync */
break;
z->msg = "incorrect header check";
z->state->sub.marker = 5; /* can't try inflateSync */
break;
}
Trace((stderr, "inflate: zlib header ok\n"));
z->state->mode = BLOCKS;
@ -183,17 +183,17 @@ int f;
if (r == Z_DATA_ERROR)
{
z->state->mode = BAD;
z->state->sub.marker = 0; /* can try inflateSync */
break;
z->state->sub.marker = 0; /* can try inflateSync */
break;
}
if (r != Z_STREAM_END)
return r;
return r;
r = Z_OK;
inflate_blocks_reset(z->state->blocks, z, &z->state->sub.check.was);
if (z->state->nowrap)
{
z->state->mode = DONE;
break;
z->state->mode = DONE;
break;
}
z->state->mode = CHECK4;
case CHECK4:
@ -216,8 +216,8 @@ int f;
{
z->state->mode = BAD;
z->msg = "incorrect data check";
z->state->sub.marker = 5; /* can't try inflateSync */
break;
z->state->sub.marker = 5; /* can't try inflateSync */
break;
}
Trace((stderr, "inflate: zlib check ok\n"));
z->state->mode = DONE;
@ -234,10 +234,10 @@ int f;
int inflateSync(z)
z_stream *z;
{
uInt n; /* number of bytes to look at */
Byte *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 */
uInt n; /* number of bytes to look at */
Byte *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->state == Z_NULL)

69
inftest.c
View File

@ -1,69 +0,0 @@
#include <stdio.h>
#include <stdlib.h>
#include "zutil.h"
void main __P((void));
/* This test is in honor of Ed Hamrick who suggested that the interface
to inflate be a byte at a time--this implements that, and is, of course,
monumentally slow. It has the virtue though of stressing the push-pull
interface for testing purposes. */
void main()
{
int a, r;
char c;
z_stream z;
z.zalloc = Z_NULL;
z.zfree = Z_NULL;
r = inflateInit(&z);
if (r != Z_OK)
fprintf(stderr, "init error: %s\n", z_errmsg[1 - r]);
while ((a = getchar()) != EOF)
{
/* feed one byte of input */
z.avail_out = 0;
c = (char)a;
z.next_in = (Byte*)&c;
z.avail_in = 1;
r = inflate(&z, 0);
if (r == Z_STREAM_END)
break;
if (r != Z_OK)
{
fprintf(stderr, "inflate error: %s\n", z_errmsg[1 - r]);
break;
}
if (z.avail_in != 0)
{
fprintf(stderr, "inflate didn't eat byte and didn't say buf err!\n");
break;
}
/* empty output one byte at a time */
while (1)
{
z.next_out = (Byte*)&c;
z.avail_out = 1;
r = inflate(&z, 0);
if (r == Z_STREAM_END)
break;
if (r != Z_OK && r != Z_BUF_ERROR)
{
fprintf(stderr, "inflate error: %s\n", z_errmsg[1 - r]);
break;
}
if (z.avail_out == 0)
putchar(c);
else
break;
}
if (r != Z_OK && r != Z_BUF_ERROR)
break;
}
inflateEnd(&z);
fprintf(stderr, "%ld bytes in, %ld bytes out\n", z.total_in, z.total_out);
if (z.msg != NULL)
fprintf(stderr, "msg is <%s>\n", z.msg);
}

160
inftrees.c
View File

@ -16,37 +16,37 @@ struct internal_state {int dummy;}; /* for buggy compilers */
local int huft_build __P((
uInt *, /* code lengths in bits */
uInt, /* number of codes */
uInt, /* number of "simple" codes */
uInt *, /* list of base values for non-simple codes */
uInt *, /* list of extra bits for non-simple codes */
inflate_huft **, /* result: starting table */
uInt *, /* maximum lookup bits (returns actual) */
z_stream *)); /* for zalloc function */
uInt *, /* code lengths in bits */
uInt, /* number of codes */
uInt, /* number of "simple" codes */
uInt *, /* list of base values for non-simple codes */
uInt *, /* list of extra bits for non-simple codes */
inflate_huft **, /* result: starting table */
uInt *, /* maximum lookup bits (returns actual) */
z_stream *)); /* for zalloc function */
local voidp falloc __P((
voidp, /* opaque pointer (not used) */
uInt, /* number of items */
uInt)); /* size of item */
voidp, /* opaque pointer (not used) */
uInt, /* number of items */
uInt)); /* size of item */
local void ffree __P((
voidp q, /* opaque pointer (not used) */
voidp p)); /* what to free (not used) */
voidp q, /* opaque pointer (not used) */
voidp p)); /* what to free (not used) */
/* Tables for deflate from PKZIP's appnote.txt. */
local uInt cplens[] = { /* Copy lengths for literal codes 257..285 */
local uInt 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};
/* actually lengths - 2; also see note #13 above about 258 */
local uInt cplext[] = { /* Extra bits for literal codes 257..285 */
local uInt 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, 128, 128}; /* 128==invalid */
local uInt cpdist[] = { /* Copy offsets for distance codes 0..29 */
local uInt 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};
local uInt cpdext[] = { /* Extra bits for distance codes */
local uInt 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};
@ -100,32 +100,32 @@ uInt *d; /* list of base values for non-simple codes */
uInt *e; /* list of extra bits for non-simple codes */
inflate_huft **t; /* result: starting table */
uInt *m; /* maximum lookup bits, returns actual */
z_stream *zs; /* for zalloc function */
z_stream *zs; /* for zalloc function */
/* Given a list of code lengths and a maximum table size, make a set of
tables to decode that set of codes. Return Z_OK on success, Z_BUF_ERROR
if the given code set is incomplete (the tables are still built in this
case), Z_DATA_ERROR if the input is invalid (all zero length codes or an
over-subscribed set of lengths), or Z_MEM_ERROR if not enough memory. */
{
uInt a; /* counter for codes of length k */
uInt c[BMAX+1]; /* bit length count table */
uInt f; /* i repeats in table every f entries */
int g; /* maximum code length */
int h; /* table level */
register uInt i; /* counter, current code */
register uInt j; /* counter */
register int k; /* number of bits in current code */
int l; /* bits per table (returned in m) */
register uInt *p; /* pointer into c[], b[], or v[] */
register inflate_huft *q; /* points to current table */
inflate_huft r; /* table entry for structure assignment */
inflate_huft *u[BMAX]; /* table stack */
uInt v[N_MAX]; /* values in order of bit length */
register int w; /* bits before this table == (l * h) */
uInt x[BMAX+1]; /* bit offsets, then code stack */
uInt *xp; /* pointer into x */
int y; /* number of dummy codes added */
uInt z; /* number of entries in current table */
uInt a; /* counter for codes of length k */
uInt c[BMAX+1]; /* bit length count table */
uInt f; /* i repeats in table every f entries */
int g; /* maximum code length */
int h; /* table level */
register uInt i; /* counter, current code */
register uInt j; /* counter */
register int k; /* number of bits in current code */
int l; /* bits per table (returned in m) */
register uInt *p; /* pointer into c[], b[], or v[] */
register inflate_huft *q; /* points to current table */
inflate_huft r; /* table entry for structure assignment */
inflate_huft *u[BMAX]; /* table stack */
uInt v[N_MAX]; /* values in order of bit length */
register int w; /* bits before this table == (l * h) */
uInt x[BMAX+1]; /* bit offsets, then code stack */
uInt *xp; /* pointer into x */
int y; /* number of dummy codes added */
uInt z; /* number of entries in current table */
/* Generate counts for each bit length */
@ -133,7 +133,7 @@ z_stream *zs; /* for zalloc function */
#define C0 *p++ = 0;
#define C2 C0 C0 C0 C0
#define C4 C2 C2 C2 C2
C4 /* clear c[]--assume BMAX+1 is 16 */
C4 /* clear c[]--assume BMAX+1 is 16 */
p = b; i = n;
do {
c[*p++]++; /* assume all entries <= BMAX */
@ -193,8 +193,8 @@ z_stream *zs; /* for zalloc function */
p = v; /* grab values in bit order */
h = -1; /* no tables yet--level -1 */
w = -l; /* bits decoded == (l * h) */
u[0] = (inflate_huft *)Z_NULL; /* just to keep compilers happy */
q = (inflate_huft *)Z_NULL; /* ditto */
u[0] = (inflate_huft *)Z_NULL; /* just to keep compilers happy */
q = (inflate_huft *)Z_NULL; /* ditto */
z = 0; /* ditto */
/* go through the bit lengths (k already is bits in shortest code) */
@ -217,25 +217,25 @@ z_stream *zs; /* for zalloc function */
f -= a + 1; /* deduct codes from patterns left */
xp = c + k;
if (j < z)
while (++j < z) /* try smaller tables up to z bits */
{
if ((f <<= 1) <= *++xp)
break; /* enough codes to use up j bits */
f -= *xp; /* else deduct codes from patterns */
}
while (++j < z) /* try smaller tables up to z bits */
{
if ((f <<= 1) <= *++xp)
break; /* enough codes to use up j bits */
f -= *xp; /* else deduct codes from patterns */
}
}
z = 1 << j; /* table entries for j-bit table */
/* allocate and link in new table */
if ((q = (inflate_huft *)ZALLOC
(zs,z + 1,sizeof(inflate_huft))) == Z_NULL)
(zs,z + 1,sizeof(inflate_huft))) == Z_NULL)
{
if (h)
inflate_trees_free(u[0], zs);
return Z_MEM_ERROR; /* not enough memory */
return Z_MEM_ERROR; /* not enough memory */
}
#ifdef DEBUG
inflate_hufts += z + 1;
inflate_hufts += z + 1;
#endif
*t = q + 1; /* link to list for huft_free() */
*(t = &(q->next)) = (inflate_huft *)Z_NULL;
@ -245,8 +245,8 @@ z_stream *zs; /* for zalloc function */
if (h)
{
x[h] = i; /* save pattern for backing up */
r.bits = (char)l; /* bits to dump before this table */
r.exop = -(char)j; /* bits in this table */
r.bits = (Byte)l; /* bits to dump before this table */
r.exop = -(Char)j; /* bits in this table */
r.next = q; /* pointer to this table */
j = i >> (w - l); /* (get around Turbo C bug) */
u[h-1][j] = r; /* connect to last table */
@ -254,17 +254,17 @@ z_stream *zs; /* for zalloc function */
}
/* set up table entry in r */
r.bits = (char)(k - w);
r.bits = (Byte)(k - w);
if (p >= v + n)
r.exop = -128; /* out of values--invalid code */
r.exop = (Char)(-128); /* out of values--invalid code */
else if (*p < s)
{
r.exop = (char)(*p < 256 ? 16 : -64); /* 256 is end-of-block code */
r.exop = (Char)(*p < 256 ? 16 : -64); /* 256 is end-of-block code */
r.base = *p++; /* simple code is just the value */
}
else
{
r.exop = (char)e[*p - s]; /* non-simple--look up in lists */
r.exop = (Char)e[*p - s]; /* non-simple--look up in lists */
r.base = d[*p++ - s];
}
@ -294,10 +294,10 @@ z_stream *zs; /* for zalloc function */
int inflate_trees_bits(c, bb, tb, z)
uInt *c; /* 19 code lengths */
uInt *bb; /* bits tree desired/actual depth */
inflate_huft **tb; /* bits tree result */
z_stream *z; /* for zfree function */
uInt *c; /* 19 code lengths */
uInt *bb; /* bits tree desired/actual depth */
inflate_huft **tb; /* bits tree result */
z_stream *z; /* for zfree function */
{
int r;
@ -315,14 +315,14 @@ z_stream *z; /* for zfree function */
int inflate_trees_dynamic(nl, nd, c, bl, bd, tl, td, z)
uInt nl; /* number of literal/length codes */
uInt nd; /* number of distance codes */
uInt *c; /* that many (total) code lengths */
uInt *bl; /* literal desired/actual bit depth */
uInt *bd; /* distance desired/actual bit depth */
inflate_huft **tl; /* literal/length tree result */
inflate_huft **td; /* distance tree result */
z_stream *z; /* for zfree function */
uInt nl; /* number of literal/length codes */
uInt nd; /* number of distance codes */
uInt *c; /* that many (total) code lengths */
uInt *bl; /* literal desired/actual bit depth */
uInt *bd; /* distance desired/actual bit depth */
inflate_huft **tl; /* literal/length tree result */
inflate_huft **td; /* distance tree result */
z_stream *z; /* for zfree function */
{
int r;
@ -367,7 +367,7 @@ z_stream *z; /* for zfree function */
/* build fixed tables only once--keep them here */
local int fixed_lock = 0;
local int fixed_built = 0;
#define FIXEDH 530 /* number of hufts used by fixed tables */
#define FIXEDH 530 /* number of hufts used by fixed tables */
local uInt fixed_left = FIXEDH;
local inflate_huft fixed_mem[FIXEDH];
local uInt fixed_bl;
@ -377,9 +377,9 @@ local inflate_huft *fixed_td;
local voidp falloc(q, n, s)
voidp q; /* opaque pointer (not used) */
uInt n; /* number of items */
uInt s; /* size of item */
voidp q; /* opaque pointer (not used) */
uInt n; /* number of items */
uInt s; /* size of item */
{
Assert(s == sizeof(inflate_huft) && n <= fixed_left,
"inflate_trees falloc overflow");
@ -399,19 +399,19 @@ voidp p;
int inflate_trees_fixed(bl, bd, tl, td)
uInt *bl; /* literal desired/actual bit depth */
uInt *bd; /* distance desired/actual bit depth */
inflate_huft **tl; /* literal/length tree result */
inflate_huft **td; /* distance tree result */
uInt *bl; /* literal desired/actual bit depth */
uInt *bd; /* distance desired/actual bit depth */
inflate_huft **tl; /* literal/length tree result */
inflate_huft **td; /* distance tree result */
{
/* build fixed tables if not built already--lock out other instances */
while (++fixed_lock > 1)
fixed_lock--;
if (!fixed_built)
{
int k; /* temporary variable */
unsigned c[288]; /* length list for huft_build */
z_stream z; /* for falloc function */
int k; /* temporary variable */
unsigned c[288]; /* length list for huft_build */
z_stream z; /* for falloc function */
/* set up fake z_stream for memory routines */
z.zalloc = falloc;
@ -449,8 +449,8 @@ inflate_huft **td; /* distance tree result */
int inflate_trees_free(t, z)
inflate_huft *t; /* table to free */
z_stream *z; /* for zfree function */
inflate_huft *t; /* table to free */
z_stream *z; /* for zfree function */
/* 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. */

46
inftrees.h
View File

@ -16,12 +16,18 @@
indicates an unused code. If a code with exop == -128 is looked up,
this implies an error in the data. */
#if defined(STDC) || defined(sgi)
typedef signed char Char;
#else
typedef char Char; /* just hope that char is signed */
#endif
typedef struct inflate_huft_s inflate_huft;
struct inflate_huft_s {
union {
struct {
char Exop; /* number of extra bits or operation */
char Bits; /* number of bits in this code or subcode */
Char Exop; /* number of extra bits or operation */
Byte Bits; /* number of bits in this code or subcode */
} what;
Byte *pad; /* pad structure to a power of 2 (4 bytes for */
} word; /* 16-bit, 8 bytes for 32-bit machines) */
@ -36,27 +42,27 @@ struct inflate_huft_s {
#endif
extern int inflate_trees_bits __P((
uInt *, /* 19 code lengths */
uInt *, /* bits tree desired/actual depth */
inflate_huft **, /* bits tree result */
z_stream *)); /* for zalloc, zfree functions */
uInt *, /* 19 code lengths */
uInt *, /* bits tree desired/actual depth */
inflate_huft **, /* bits tree result */
z_stream *)); /* for zalloc, zfree functions */
extern int inflate_trees_dynamic __P((
uInt, /* number of literal/length codes */
uInt, /* number of distance codes */
uInt *, /* that many (total) code lengths */
uInt *, /* literal desired/actual bit depth */
uInt *, /* distance desired/actual bit depth */
inflate_huft **, /* literal/length tree result */
inflate_huft **, /* distance tree result */
z_stream *)); /* for zalloc, zfree functions */
uInt, /* number of literal/length codes */
uInt, /* number of distance codes */
uInt *, /* that many (total) code lengths */
uInt *, /* literal desired/actual bit depth */
uInt *, /* distance desired/actual bit depth */
inflate_huft **, /* literal/length tree result */
inflate_huft **, /* distance tree result */
z_stream *)); /* for zalloc, zfree functions */
extern int inflate_trees_fixed __P((
uInt *, /* literal desired/actual bit depth */
uInt *, /* distance desired/actual bit depth */
inflate_huft **, /* literal/length tree result */
inflate_huft **)); /* distance tree result */
uInt *, /* literal desired/actual bit depth */
uInt *, /* distance desired/actual bit depth */
inflate_huft **, /* literal/length tree result */
inflate_huft **)); /* distance tree result */
extern int inflate_trees_free __P((
inflate_huft *, /* tables to free */
z_stream *)); /* for zfree function */
inflate_huft *, /* tables to free */
z_stream *)); /* for zfree function */

56
infutil.h
View File

@ -13,42 +13,42 @@ struct inflate_blocks_state {
/* mode */
enum {
TYPE, /* get type bits (3, including end bit) */
LENS, /* get lengths for stored */
STORED, /* processing stored block */
TABLE, /* get table lengths */
BTREE, /* get bit lengths tree for a dynamic block */
DTREE, /* get length, distance trees for a dynamic block */
CODES, /* processing fixed or dynamic block */
DRY, /* output remaining window bytes */
DONE, /* finished last block, done */
BAD} /* got a data error--stuck here */
mode; /* current inflate_block mode */
TYPE, /* get type bits (3, including end bit) */
LENS, /* get lengths for stored */
STORED, /* processing stored block */
TABLE, /* get table lengths */
BTREE, /* get bit lengths tree for a dynamic block */
DTREE, /* get length, distance trees for a dynamic block */
CODES, /* processing fixed or dynamic block */
DRY, /* output remaining window bytes */
DONE, /* finished last block, done */
BAD} /* got a data error--stuck here */
mode; /* current inflate_block mode */
/* mode dependent information */
union {
uInt left; /* if STORED, bytes left to copy */
uInt left; /* if STORED, bytes left to copy */
struct {
uInt table; /* table lengths (14 bits) */
uInt index; /* index into blens (or border) */
uInt *blens; /* bit lengths of codes */
uInt bb; /* bit length tree depth */
inflate_huft *tb; /* bit length decoding tree */
} trees; /* if DTREE, decoding info for trees */
uInt table; /* table lengths (14 bits) */
uInt index; /* index into blens (or border) */
uInt *blens; /* bit lengths of codes */
uInt bb; /* bit length tree depth */
inflate_huft *tb; /* bit length decoding tree */
} trees; /* if DTREE, decoding info for trees */
struct inflate_codes_state
*codes; /* if CODES, current state */
} sub; /* submode */
uInt last; /* true if this block is the last block */
*codes; /* if CODES, current state */
} sub; /* submode */
uInt last; /* true if this block is the last block */
/* mode independent information */
uInt bitk; /* bits in bit buffer */
uLong bitb; /* bit buffer */
Byte *window; /* sliding window */
Byte *end; /* one byte after sliding window */
Byte *read; /* window read pointer */
Byte *write; /* window write pointer */
uInt bitk; /* bits in bit buffer */
uLong bitb; /* bit buffer */
Byte *window; /* sliding window */
Byte *end; /* one byte after sliding window */
Byte *read; /* window read pointer */
Byte *write; /* window write pointer */
check_func checkfn; /* check function */
uLong check; /* check on output */
uLong check; /* check on output */
};

88
minigzip.c
View File

@ -13,7 +13,7 @@
* or in pipe mode.
*/
/* $Id: minigzip.c,v 1.4 1995/05/02 15:54:22 jloup Exp $ */
/* $Id: minigzip.c,v 1.5 1995/05/03 17:27:11 jloup Exp $ */
#include <stdio.h>
#include "zlib.h"
@ -75,14 +75,14 @@ void gz_compress(in, out)
int err;
for (;;) {
len = fread(buf, 1, sizeof(buf), in);
if (ferror(in)) {
perror("fread");
exit(1);
}
if (len == 0) break;
len = fread(buf, 1, sizeof(buf), in);
if (ferror(in)) {
perror("fread");
exit(1);
}
if (len == 0) break;
if (gzwrite(out, buf, len) != len) error(gzerror(out, &err));
if (gzwrite(out, buf, len) != len) error(gzerror(out, &err));
}
fclose(in);
if (gzclose(out) != Z_OK) error("failed gzclose");
@ -100,11 +100,11 @@ void gz_uncompress(in, out)
int err;
for (;;) {
len = gzread(in, buf, sizeof(buf));
if (len < 0) error (gzerror(in, &err));
if (len == 0) break;
len = gzread(in, buf, sizeof(buf));
if (len < 0) error (gzerror(in, &err));
if (len == 0) break;
if (fwrite(buf, 1, len, out) != (uInt)len) error("failed fwrite");
if (fwrite(buf, 1, len, out) != (uInt)len) error("failed fwrite");
}
if (fclose(out)) error("failed fclose");
@ -128,13 +128,13 @@ void file_compress(file)
in = fopen(file, "rb");
if (in == NULL) {
perror(file);
exit(1);
perror(file);
exit(1);
}
out = gzopen(outfile, "wb");
if (out == NULL) {
fprintf(stderr, "%s: can't gzopen %s\n", prog, outfile);
exit(1);
fprintf(stderr, "%s: can't gzopen %s\n", prog, outfile);
exit(1);
}
gz_compress(in, out);
@ -157,23 +157,23 @@ void file_uncompress(file)
strcpy(buf, file);
if (len > 3 && strcmp(file+len-3, ".gz") == 0) {
infile = file;
outfile = buf;
outfile[len-3] = '\0';
infile = file;
outfile = buf;
outfile[len-3] = '\0';
} else {
outfile = file;
infile = buf;
strcat(infile, ".gz");
outfile = file;
infile = buf;
strcat(infile, ".gz");
}
in = gzopen(infile, "rb");
if (in == NULL) {
fprintf(stderr, "%s: can't gzopen %s\n", prog, infile);
exit(1);
fprintf(stderr, "%s: can't gzopen %s\n", prog, infile);
exit(1);
}
out = fopen(outfile, "wb");
if (out == NULL) {
perror(file);
exit(1);
perror(file);
exit(1);
}
gz_uncompress(in, out);
@ -197,31 +197,31 @@ void main(argc, argv)
argc--, argv++;
if (argc > 0) {
uncompr = (strcmp(*argv, "-d") == 0);
if (uncompr) {
argc--, argv++;
}
uncompr = (strcmp(*argv, "-d") == 0);
if (uncompr) {
argc--, argv++;
}
}
if (argc == 0) {
SET_BINARY_MODE(stdin);
SET_BINARY_MODE(stdout);
if (uncompr) {
file = gzdopen(fileno(stdin), "rb");
if (uncompr) {
file = gzdopen(fileno(stdin), "rb");
if (file == NULL) error("can't gzdopen stdin");
gz_uncompress(file, stdout);
} else {
file = gzdopen(fileno(stdout), "wb");
gz_uncompress(file, stdout);
} else {
file = gzdopen(fileno(stdout), "wb");
if (file == NULL) error("can't gzdopen stdout");
gz_compress(stdin, file);
}
gz_compress(stdin, file);
}
} else {
do {
if (uncompr) {
file_uncompress(*argv);
} else {
file_compress(*argv);
}
} while (argv++, --argc);
do {
if (uncompr) {
file_uncompress(*argv);
} else {
file_compress(*argv);
}
} while (argv++, --argc);
}
exit(0);
}

42
trees.c
View File

@ -29,7 +29,7 @@
* Addison-Wesley, 1983. ISBN 0-201-06672-6.
*/
/* $Id: trees.c,v 1.4 1995/05/01 16:53:44 jloup Exp $ */
/* $Id: trees.c,v 1.5 1995/05/03 17:27:12 jloup Exp $ */
#include "deflate.h"
@ -139,15 +139,15 @@ local void scan_tree __P((deflate_state *s, ct_data *tree, int max_code));
local void send_tree __P((deflate_state *s, ct_data *tree, int max_code));
local int build_bl_tree __P((deflate_state *s));
local void send_all_trees __P((deflate_state *s, int lcodes, int dcodes,
int blcodes));
int blcodes));
local void compress_block __P((deflate_state *s, ct_data *ltree,
ct_data *dtree));
ct_data *dtree));
local void set_data_type __P((deflate_state *s));
local void send_bits __P((deflate_state *s, int value, int length));
local unsigned bi_reverse __P((unsigned value, int length));
local void bi_windup __P((deflate_state *s));
local void copy_block __P((deflate_state *s, char *buf, unsigned len,
int header));
int header));
#ifndef DEBUG
# define send_code(s, c, tree) send_bits(s, tree[c].Code, tree[c].Len)
@ -243,7 +243,7 @@ void ct_init(s)
deflate_state *s;
{
if (static_dtree[0].Len == 0) {
ct_static_init(); /* To do: at compile time */
ct_static_init(); /* To do: at compile time */
}
s->compressed_len = 0L;
@ -324,9 +324,9 @@ local void pqdownheap(s, tree, k)
while (j <= s->heap_len) {
/* Set j to the smallest of the two sons: */
if (j < s->heap_len &&
smaller(tree, s->heap[j+1], s->heap[j], s->depth)) {
j++;
}
smaller(tree, s->heap[j+1], s->heap[j], s->depth)) {
j++;
}
/* Exit if v is smaller than both sons */
if (smaller(tree, v, s->heap[j], s->depth)) break;
@ -420,7 +420,7 @@ local void gen_bitlen(s, desc)
if (tree[m].Len != (unsigned) bits) {
Trace((stderr,"code %d bits %d->%d\n", m, tree[m].Len, bits));
s->opt_len += ((long)bits - (long)tree[m].Len)
*(long)tree[m].Freq;
*(long)tree[m].Freq;
tree[m].Len = (ush)bits;
}
n--;
@ -686,7 +686,7 @@ local int build_bl_tree(s)
/* Update opt_len to include the bit length tree and counts */
s->opt_len += 3*(max_blindex+1) + 5+5+4;
Tracev((stderr, "\ndyn trees: dyn %ld, stat %ld",
s->opt_len, s->static_len));
s->opt_len, s->static_len));
return max_blindex;
}
@ -758,11 +758,11 @@ ulg ct_flush_block(s, buf, stored_len, eof)
/* Construct the literal and distance trees */
build_tree(s, (tree_desc *)(&(s->l_desc)));
Tracev((stderr, "\nlit data: dyn %ld, stat %ld", s->opt_len,
s->static_len));
s->static_len));
build_tree(s, (tree_desc *)(&(s->d_desc)));
Tracev((stderr, "\ndist data: dyn %ld, stat %ld", s->opt_len,
s->static_len));
s->static_len));
/* At this point, opt_len and static_len are the total bit lengths of
* the compressed block data, excluding the tree representations.
*/
@ -813,7 +813,7 @@ ulg ct_flush_block(s, buf, stored_len, eof)
* successful. If LIT_BUFSIZE <= WSIZE, it is never too late to
* transform a block into a stored block.
*/
ct_stored_block(s, buf, stored_len, eof);
ct_stored_block(s, buf, stored_len, eof);
#ifdef FORCE_STATIC
} else if (static_lenb >= 0) { /* force static trees */
@ -826,7 +826,7 @@ ulg ct_flush_block(s, buf, stored_len, eof)
} else {
send_bits(s, (DYN_TREES<<1)+eof, 3);
send_all_trees(s, s->l_desc.max_code+1, s->d_desc.max_code+1,
max_blindex+1);
max_blindex+1);
compress_block(s, (ct_data *)s->dyn_ltree, (ct_data *)s->dyn_dtree);
s->compressed_len += 3 + s->opt_len;
}
@ -858,7 +858,7 @@ int ct_tally (s, dist, lc)
/* lc is the unmatched char */
s->dyn_ltree[lc].Freq++;
} else {
s->matches++;
s->matches++;
/* Here, lc is the match length - MIN_MATCH */
dist--; /* dist = match distance - 1 */
Assert((ush)dist < (ush)MAX_DIST(s) &&
@ -877,7 +877,7 @@ int ct_tally (s, dist, lc)
int dcode;
for (dcode = 0; dcode < D_CODES; dcode++) {
out_length += (ulg)s->dyn_dtree[dcode].Freq *
(5L+extra_dbits[dcode]);
(5L+extra_dbits[dcode]);
}
out_length >>= 3;
Tracev((stderr,"\nlast_lit %u, in %ld, out ~%ld(%ld%%) ",
@ -907,7 +907,7 @@ local void compress_block(s, ltree, dtree)
int extra; /* number of extra bits to send */
if (s->last_lit != 0) do {
dist = s->d_buf[lx];
dist = s->d_buf[lx];
lc = s->l_buf[lx++];
if (dist == 0) {
send_code(s, lc, ltree); /* send a literal byte */
@ -921,7 +921,7 @@ local void compress_block(s, ltree, dtree)
lc -= base_length[code];
send_bits(s, lc, extra); /* send the extra length bits */
}
dist--; /* dist is now the match distance - 1 */
dist--; /* dist is now the match distance - 1 */
code = d_code(dist);
Assert (code < D_CODES, "bad d_code");
@ -933,8 +933,8 @@ local void compress_block(s, ltree, dtree)
}
} /* literal or match pair ? */
/* Check that the overlay between pending_buf and d_buf+l_buf is ok: */
Assert(s->pending < s->lit_bufsize + 2*lx, "pendingBuf overflow");
/* Check that the overlay between pending_buf and d_buf+l_buf is ok: */
Assert(s->pending < s->lit_bufsize + 2*lx, "pendingBuf overflow");
} while (lx < s->last_lit);
@ -1055,6 +1055,6 @@ local void copy_block(s, buf, len, header)
s->bits_sent += (ulg)len<<3;
#endif
while (len--) {
put_byte(s, *buf++);
put_byte(s, *buf++);
}
}

6
uncompr.c
View File

@ -3,7 +3,7 @@
* For conditions of distribution and use, see copyright notice in zlib.h
*/
/* $Id: uncompr.c,v 1.4 1995/04/10 16:22:22 jloup Exp $ */
/* $Id: uncompr.c,v 1.5 1995/05/03 17:27:12 jloup Exp $ */
#include "zlib.h"
@ -48,8 +48,8 @@ int uncompress (dest, destLen, source, sourceLen)
err = inflate(&stream, Z_FINISH);
if (err != Z_STREAM_END) {
inflateEnd(&stream);
return err;
inflateEnd(&stream);
return err;
}
*destLen = stream.total_out;

4
zconf.h
View File

@ -3,7 +3,7 @@
* For conditions of distribution and use, see copyright notice in zlib.h
*/
/* $Id: zconf.h,v 1.11 1995/05/02 13:07:21 jloup Exp $ */
/* $Id: zconf.h,v 1.12 1995/05/03 17:27:12 jloup Exp $ */
#ifndef _ZCONF_H
#define _ZCONF_H
@ -59,7 +59,7 @@
for small objects.
*/
/* Type declarations */
/* Type declarations */
#ifndef __P /* function prototypes */
# ifdef STDC

12
zlib.h
View File

@ -1,5 +1,5 @@
/* zlib.h -- interface of the 'zlib' general purpose compression library
version 0.91 May 2nd, 1995.
version 0.92 May 3rd, 1995.
Copyright (C) 1995 Jean-loup Gailly and Mark Adler
@ -28,7 +28,7 @@
#include "zconf.h"
#define ZLIB_VERSION "0.91"
#define ZLIB_VERSION "0.92"
/*
The 'zlib' compression library provides in-memory compression and
@ -103,7 +103,7 @@ typedef struct z_stream_s {
a single step).
*/
/* constants */
/* constants */
#define Z_NO_FLUSH 0
#define Z_PARTIAL_FLUSH 1
@ -142,7 +142,7 @@ extern char *zlib_version;
not compatible with the zlib.h header file used by the application.
*/
/* basic functions */
/* basic functions */
extern int deflateInit __P((z_stream *strm, int level));
/*
@ -313,8 +313,8 @@ extern int inflateEnd __P((z_stream *strm));
*/
extern int deflateInit2 __P((z_stream *strm,
int level,
int method,
int level,
int method,
int windowBits,
int memLevel,
int strategy));

30
zutil.c
View File

@ -3,7 +3,7 @@
* For conditions of distribution and use, see copyright notice in zlib.h
*/
/* $Id: zutil.c,v 1.7 1995/05/02 15:54:47 jloup Exp $ */
/* $Id: zutil.c,v 1.8 1995/05/03 17:27:12 jloup Exp $ */
#include <stdio.h>
@ -42,7 +42,7 @@ void zmemcpy(dest, source, len)
{
if (len == 0) return;
do {
*dest++ = *source++; /* ??? to be unrolled */
*dest++ = *source++; /* ??? to be unrolled */
} while (--len != 0);
}
@ -52,7 +52,7 @@ void zmemzero(dest, len)
{
if (len == 0) return;
do {
*dest++ = 0; /* ??? to be unrolled */
*dest++ = 0; /* ??? to be unrolled */
} while (--len != 0);
}
#endif
@ -91,10 +91,10 @@ voidp zcalloc (voidp opaque, unsigned items, unsigned size)
ulg bsize = (ulg)items*size;
if (bsize < 65536L) {
buf = farmalloc(bsize);
if (*(ush*)&buf != 0) return buf;
buf = farmalloc(bsize);
if (*(ush*)&buf != 0) return buf;
} else {
buf = farmalloc(bsize + 16L);
buf = farmalloc(bsize + 16L);
}
if (buf == NULL || next_ptr >= MAX_PTR) return NULL;
table[next_ptr].org_ptr = buf;
@ -110,19 +110,19 @@ void zcfree (voidp opaque, voidp ptr)
{
int n;
if (*(ush*)&ptr != 0) { /* object < 64K */
farfree(ptr);
return;
farfree(ptr);
return;
}
/* Find the original pointer */
for (n = 0; n < next_ptr; n++) {
if (ptr != table[n].new_ptr) continue;
if (ptr != table[n].new_ptr) continue;
farfree(table[n].org_ptr);
while (++n < next_ptr) {
table[n-1] = table[n];
}
next_ptr--;
return;
farfree(table[n].org_ptr);
while (++n < next_ptr) {
table[n-1] = table[n];
}
next_ptr--;
return;
}
ptr = opaque; /* just to make some compilers happy */
z_error("zcfree: ptr not found");

19
zutil.h
View File

@ -8,13 +8,19 @@
subject to change. Applications should only use zlib.h.
*/
/* $Id: zutil.h,v 1.8 1995/05/02 15:44:46 jloup Exp $ */
/* $Id: zutil.h,v 1.9 1995/05/03 17:27:12 jloup Exp $ */
#ifndef _Z_UTIL_H
#define _Z_UTIL_H
#include "zlib.h"
#ifdef __GNUC__
# define INLINE inline
#else
# define INLINE
#endif
#ifdef MSDOS
# include <stddef.h>
# include <errno.h>
@ -39,7 +45,7 @@ extern char *z_errmsg[]; /* indexed by 1-zlib_error */
#define ERR_RETURN(strm,err) return (strm->msg=z_errmsg[1-err], err)
/* To be used only when the state is known to be valid */
/* common constants */
/* common constants */
#define DEFLATED 8
@ -62,7 +68,7 @@ extern char *z_errmsg[]; /* indexed by 1-zlib_error */
#define MAX_MATCH 258
/* The minimum and maximum match lengths */
/* target dependencies */
/* target dependencies */
#ifdef MSDOS
# define OS_CODE 0x00
@ -107,7 +113,7 @@ extern char *z_errmsg[]; /* indexed by 1-zlib_error */
# define OS_CODE 0x0a
#endif
/* Common defaults */
/* Common defaults */
#ifndef OS_CODE
# define OS_CODE 0x03 /* assume Unix */
@ -126,7 +132,10 @@ extern char *z_errmsg[]; /* indexed by 1-zlib_error */
# define zstrerror(errnum) ""
#endif
#if defined(STDC) && !defined(HAVE_MEMCPY)
#if defined(pyr) && !defined(NO_MEMCPY)
# define NO_MEMCPY
#endif
#if defined(STDC) && !defined(HAVE_MEMCPY) && !defined(NO_MEMCPY)
# define HAVE_MEMCPY
#endif
#ifdef HAVE_MEMCPY