From bdde4e09d21edff02ea5093b7f6eccbf166b272f Mon Sep 17 00:00:00 2001 From: Mark Adler Date: Fri, 9 Sep 2011 23:08:07 -0700 Subject: [PATCH] zlib 0.92 --- ChangeLog | 9 ++ Makefile | 11 +-- README | 9 +- adler32.c | 24 ++--- compress.c | 6 +- deflate.c | 195 +++++++++++++++++++----------------- deflate.h | 10 +- example.c | 60 +++++------ gzio.c | 284 ++++++++++++++++++++++++++--------------------------- infblock.c | 264 +++++++++++++++++++++++++------------------------ infblock.h | 2 +- infcodes.c | 184 +++++++++++++++++----------------- inffast.c | 136 ++++++++++++------------- inflate.c | 80 +++++++-------- inftest.c | 69 ------------- inftrees.c | 160 +++++++++++++++--------------- inftrees.h | 46 +++++---- infutil.h | 56 +++++------ minigzip.c | 90 ++++++++--------- trees.c | 42 ++++---- uncompr.c | 6 +- zconf.h | 4 +- zlib.h | 12 +-- zutil.c | 32 +++--- zutil.h | 19 +++- 25 files changed, 892 insertions(+), 918 deletions(-) delete mode 100644 inftest.c diff --git a/ChangeLog b/ChangeLog index e97948e9..57f99861 100644 --- a/ChangeLog +++ b/ChangeLog @@ -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 diff --git a/Makefile b/Makefile index 9a48249a..2d0cdc75 100644 --- a/Makefile +++ b/Makefile @@ -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 diff --git a/README b/README index caeccb96..bc4a663d 100644 --- a/README +++ b/README @@ -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 diff --git a/adler32.c b/adler32.c index 0b2b820e..0ad9bec5 100644 --- a/adler32.c +++ b/adler32.c @@ -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; } diff --git a/compress.c b/compress.c index 762a9dfc..98ced3ec 100644 --- a/compress.c +++ b/compress.c @@ -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; diff --git a/deflate.c b/deflate.c index b65ba251..6c0cd0aa 100644 --- a/deflate.c +++ b/deflate.c @@ -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; diff --git a/deflate.h b/deflate.h index 1f8068e5..c292fc79 100644 --- a/deflate.h +++ b/deflate.h @@ -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)); diff --git a/example.c b/example.c index 5c34733d..a2213e0d 100644 --- a/example.c +++ b/example.c @@ -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 #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); diff --git a/gzio.c b/gzio.c index 7a3d05a1..d323fbca 100644 --- a/gzio.c +++ b/gzio.c @@ -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 @@ -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); + /* 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: + /* 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); - - 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; - } + 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); + + 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) { - - 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->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); + + 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; - - 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); + 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); /* 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++; }; - - 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; - } + /* 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) { + + 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 ""; diff --git a/infblock.c b/infblock.c index 538fa625..3a9cf85c 100644 --- a/infblock.c +++ b/infblock.c @@ -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: diff --git a/infblock.h b/infblock.h index 33e16961..c0712c13 100644 --- a/infblock.h +++ b/infblock.h @@ -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 *, diff --git a/infcodes.c b/infcodes.c index fc565477..87e661bb 100644 --- a/infcodes.c +++ b/infcodes.c @@ -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: diff --git a/inffast.c b/inffast.c index 980a9256..2fd707e2 100644 --- a/inffast.c +++ b/inffast.c @@ -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); diff --git a/inflate.c b/inflate.c index 0b0ee873..1c58d982 100644 --- a/inflate.c +++ b/inflate.c @@ -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) diff --git a/inftest.c b/inftest.c deleted file mode 100644 index d711bfa1..00000000 --- a/inftest.c +++ /dev/null @@ -1,69 +0,0 @@ -#include -#include -#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); -} diff --git a/inftrees.c b/inftrees.c index ab0ed2c8..98589276 100644 --- a/inftrees.c +++ b/inftrees.c @@ -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. */ diff --git a/inftrees.h b/inftrees.h index 6001a4e4..27e7222f 100644 --- a/inftrees.h +++ b/inftrees.h @@ -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 */ diff --git a/infutil.h b/infutil.h index f468f1ac..f234e9b1 100644 --- a/infutil.h +++ b/infutil.h @@ -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 */ }; diff --git a/minigzip.c b/minigzip.c index 8f580802..017c3e4f 100644 --- a/minigzip.c +++ b/minigzip.c @@ -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 #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; - - if (gzwrite(out, buf, len) != len) error(gzerror(out, &err)); + 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)); } 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); } diff --git a/trees.c b/trees.c index eb69d49a..f85716ea 100644 --- a/trees.c +++ b/trees.c @@ -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++); } } diff --git a/uncompr.c b/uncompr.c index 4c8b3af0..c76286cd 100644 --- a/uncompr.c +++ b/uncompr.c @@ -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; diff --git a/zconf.h b/zconf.h index 1abb0ea3..ce93061e 100644 --- a/zconf.h +++ b/zconf.h @@ -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 diff --git a/zlib.h b/zlib.h index 17122091..00a4394d 100644 --- a/zlib.h +++ b/zlib.h @@ -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)); diff --git a/zutil.c b/zutil.c index 508ad62b..2cddcff8 100644 --- a/zutil.c +++ b/zutil.c @@ -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 @@ -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; - - farfree(table[n].org_ptr); - while (++n < next_ptr) { - table[n-1] = table[n]; - } - next_ptr--; - return; + if (ptr != table[n].new_ptr) continue; + + 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"); diff --git a/zutil.h b/zutil.h index 503a4454..bc8af52d 100644 --- a/zutil.h +++ b/zutil.h @@ -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 # include @@ -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