zlib 0.92
diff --git a/ChangeLog b/ChangeLog
index e97948e..57f9986 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 9a48249..2d0cdc7 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 @@
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 @@
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 @@
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 caeccb9..bc4a663 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 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 0b2b820..0ad9bec 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 @@
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 762a9df..98ced3e 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 @@
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 b65ba25..6c0cd0a 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 @@
#ifdef DEBUG
local void check_match __P((deflate_state *s, IPos start, IPos match,
- int length));
+ int length));
#endif
@@ -190,12 +190,12 @@
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 @@
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 @@
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 @@
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 @@
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 @@
/* 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 @@
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 @@
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 @@
/* 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 @@
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 @@
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 @@
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 @@
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 @@
/* 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 @@
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 @@
*/
#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 @@
* 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 @@
* 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 @@
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 @@
* 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 @@
* 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 @@
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 @@
*/
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 @@
}
}
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 1f8068e..c292fc7 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 @@
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 @@
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 @@
* 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 5c34733..a2213e0 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 <stdio.h>
#include "zlib.h"
@@ -27,7 +27,7 @@
#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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
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 7a3d05a..d323fbc 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 <stdio.h>
@@ -68,13 +68,13 @@
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 @@
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 @@
s->file = fd < 0 ? FOPEN(path, mode) : fdopen(fd, mode);
if (s->file == NULL) {
- return destroy(s), (gzFile)Z_NULL;
+ return destroy(s), (gzFile)Z_NULL;
}
if (s->mode == 'w') {
- /* Write a very simple .gz header:
- */
- fprintf(s->file, "%c%c%c%c%c%c%c%c%c%c", GZ_MAGIC_1, GZ_MAGIC_2,
- DEFLATED, 0 /*flags*/, 0,0,0,0 /*time*/, 0 /*xflags*/, OS_CODE);
- } else {
- /* Check and skip the header:
+ /* Write a very simple .gz header:
*/
- Byte c1 = 0, c2 = 0;
- Byte method = 0;
- Byte flags = 0;
- Byte xflags = 0;
- Byte time[4];
- Byte osCode;
- int c;
+ fprintf(s->file, "%c%c%c%c%c%c%c%c%c%c", GZ_MAGIC_1, GZ_MAGIC_2,
+ DEFLATED, 0 /*flags*/, 0,0,0,0 /*time*/, 0 /*xflags*/, OS_CODE);
+ } else {
+ /* Check and skip the header:
+ */
+ Byte c1 = 0, c2 = 0;
+ Byte method = 0;
+ Byte flags = 0;
+ Byte xflags = 0;
+ Byte time[4];
+ Byte osCode;
+ int c;
- s->stream.avail_in = fread(s->inbuf, 1, 2, s->file);
- if (s->stream.avail_in != 2 || s->inbuf[0] != GZ_MAGIC_1
- || s->inbuf[1] != GZ_MAGIC_2) {
- s->transparent = 1;
- return (gzFile)s;
- }
- s->stream.avail_in = 0;
- fscanf(s->file,"%c%c%4c%c%c", &method, &flags, time, &xflags, &osCode);
+ s->stream.avail_in = fread(s->inbuf, 1, 2, s->file);
+ if (s->stream.avail_in != 2 || s->inbuf[0] != GZ_MAGIC_1
+ || s->inbuf[1] != GZ_MAGIC_2) {
+ s->transparent = 1;
+ return (gzFile)s;
+ }
+ s->stream.avail_in = 0;
+ fscanf(s->file,"%c%c%4c%c%c", &method, &flags, time, &xflags, &osCode);
- if (method != DEFLATED || feof(s->file) || (flags & RESERVED) != 0) {
- s->z_err = Z_DATA_ERROR;
- return (gzFile)s;
- }
- if ((flags & EXTRA_FIELD) != 0) { /* skip the extra field */
- long len;
- fscanf(s->file, "%c%c", &c1, &c2);
- len = c1 + ((long)c2<<8);
- fseek(s->file, len, SEEK_CUR);
- }
- if ((flags & ORIG_NAME) != 0) { /* skip the original file name */
- while ((c = getc(s->file)) != 0 && c != EOF) ;
- }
- if ((flags & COMMENT) != 0) { /* skip the .gz file comment */
- while ((c = getc(s->file)) != 0 && c != EOF) ;
- }
- if ((flags & HEAD_CRC) != 0) { /* skip the header crc */
- fscanf(s->file, "%c%c", &c1, &c2);
- }
- if (feof(s->file)) {
- s->z_err = Z_DATA_ERROR;
- }
+ if (method != DEFLATED || feof(s->file) || (flags & RESERVED) != 0) {
+ s->z_err = Z_DATA_ERROR;
+ return (gzFile)s;
+ }
+ if ((flags & EXTRA_FIELD) != 0) { /* skip the extra field */
+ long len;
+ fscanf(s->file, "%c%c", &c1, &c2);
+ len = c1 + ((long)c2<<8);
+ fseek(s->file, len, SEEK_CUR);
+ }
+ if ((flags & ORIG_NAME) != 0) { /* skip the original file name */
+ while ((c = getc(s->file)) != 0 && c != EOF) ;
+ }
+ if ((flags & COMMENT) != 0) { /* skip the .gz file comment */
+ while ((c = getc(s->file)) != 0 && c != EOF) ;
+ }
+ if ((flags & HEAD_CRC) != 0) { /* skip the header crc */
+ fscanf(s->file, "%c%c", &c1, &c2);
+ }
+ if (feof(s->file)) {
+ s->z_err = Z_DATA_ERROR;
+ }
}
return (gzFile)s;
}
@@ -240,16 +240,16 @@
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 @@
while (s->stream.avail_out != 0) {
- if (s->stream.avail_in == 0 && !s->z_eof) {
+ if (s->stream.avail_in == 0 && !s->z_eof) {
- errno = 0;
- s->stream.avail_in =
- fread(s->inbuf, 1, Z_BUFSIZE, s->file);
- if (s->stream.avail_in == 0) {
- s->z_eof = 1;
- } else if (s->stream.avail_in == (uInt)EOF) {
- s->stream.avail_in = 0;
- s->z_eof = 1;
- s->z_err = Z_ERRNO;
- break;
- }
- s->stream.next_in = s->inbuf;
- }
- s->z_err = inflate(&(s->stream), Z_NO_FLUSH);
+ errno = 0;
+ s->stream.avail_in =
+ fread(s->inbuf, 1, Z_BUFSIZE, s->file);
+ if (s->stream.avail_in == 0) {
+ s->z_eof = 1;
+ } else if (s->stream.avail_in == (uInt)EOF) {
+ s->stream.avail_in = 0;
+ s->z_eof = 1;
+ s->z_err = Z_ERRNO;
+ break;
+ }
+ s->stream.next_in = s->inbuf;
+ }
+ s->z_err = inflate(&(s->stream), Z_NO_FLUSH);
- if (s->z_err == Z_STREAM_END ||
+ if (s->z_err == Z_STREAM_END ||
s->z_err != Z_OK || s->z_eof) break;
}
len -= s->stream.avail_out;
@@ -302,18 +302,18 @@
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 @@
s->stream.avail_in = 0; /* should be zero already anyway */
for (;;) {
- len = Z_BUFSIZE - s->stream.avail_out;
+ len = Z_BUFSIZE - s->stream.avail_out;
- if (len != 0) {
- if (fwrite(s->outbuf, 1, len, s->file) != len) {
- s->z_err = Z_ERRNO;
- return Z_ERRNO;
- }
- s->stream.next_out = s->outbuf;
- s->stream.avail_out = Z_BUFSIZE;
- }
- if (done) break;
- s->z_err = deflate(&(s->stream), flush);
+ if (len != 0) {
+ if (fwrite(s->outbuf, 1, len, s->file) != len) {
+ s->z_err = Z_ERRNO;
+ return Z_ERRNO;
+ }
+ s->stream.next_out = s->outbuf;
+ s->stream.avail_out = Z_BUFSIZE;
+ }
+ if (done) break;
+ s->z_err = deflate(&(s->stream), flush);
/* deflate has finished flushing only when it hasn't used up
* all the available space in the output buffer:
*/
done = (s->stream.avail_out != 0 || s->z_err == Z_STREAM_END);
- if (s->z_err != Z_OK && s->z_err != Z_STREAM_END) break;
+ if (s->z_err != Z_OK && s->z_err != Z_STREAM_END) break;
}
return s->z_err == Z_STREAM_END ? Z_OK : s->z_err;
}
@@ -371,8 +371,8 @@
{
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 @@
Byte *p = buf+4;
do {
- x <<= 8;
- x |= *--p;
+ x <<= 8;
+ x |= *--p;
} while (p != buf);
return x;
}
@@ -406,31 +406,31 @@
if (s == NULL) return Z_STREAM_ERROR;
if (s->mode == 'w') {
- err = gzflush (file, Z_FINISH);
- if (err != Z_OK) return destroy(file);
+ err = gzflush (file, Z_FINISH);
+ if (err != Z_OK) return destroy(file);
- putLong (s->file, s->crc);
- putLong (s->file, s->stream.total_in);
+ putLong (s->file, s->crc);
+ putLong (s->file, s->stream.total_in);
} else if (s->mode == 'r' && s->z_err == Z_STREAM_END) {
- /* slide CRC and original size if they are at the end of inbuf */
- if ((n = s->stream.avail_in) < 8 && !s->z_eof) {
- Byte *p = s->inbuf;
- Byte *q = s->stream.next_in;
- while (n--) { *p++ = *q++; };
+ /* slide CRC and original size if they are at the end of inbuf */
+ if ((n = s->stream.avail_in) < 8 && !s->z_eof) {
+ Byte *p = s->inbuf;
+ Byte *q = s->stream.next_in;
+ while (n--) { *p++ = *q++; };
- n = s->stream.avail_in;
- n += fread(p, 1, 8, s->file);
- s->stream.next_in = s->inbuf;
- }
- /* check CRC and original size */
- if (n < 8 ||
- getLong(s->stream.next_in) != s->crc ||
- getLong(s->stream.next_in + 4) != s->stream.total_out) {
+ n = s->stream.avail_in;
+ n += fread(p, 1, 8, s->file);
+ s->stream.next_in = s->inbuf;
+ }
+ /* check CRC and original size */
+ if (n < 8 ||
+ getLong(s->stream.next_in) != s->crc ||
+ getLong(s->stream.next_in + 4) != s->stream.total_out) {
- s->z_err = Z_DATA_ERROR;
- }
+ s->z_err = Z_DATA_ERROR;
+ }
}
return destroy(file);
}
@@ -450,8 +450,8 @@
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 538fa62..3a9cf85 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 @@
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 @@
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 @@
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 @@
{
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 @@
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 @@
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 33e1696..c0712c1 100644
--- a/infblock.h
+++ b/infblock.h
@@ -18,7 +18,7 @@
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 fc56547..87e661b 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 @@
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 @@
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 @@
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 @@
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 980a925..2fd707e 100644
--- a/inffast.c
+++ b/inffast.c
@@ -35,19 +35,19 @@
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 @@
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 @@
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 0b0ee87..1c58d98 100644
--- a/inflate.c
+++ b/inflate.c
@@ -13,32 +13,32 @@
/* 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 @@
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 @@
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 @@
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 @@
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 @@
{
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 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 d711bfa..0000000
--- a/inftest.c
+++ /dev/null
@@ -1,69 +0,0 @@
-#include <stdio.h>
-#include <stdlib.h>
-#include "zutil.h"
-
-void main __P((void));
-
-/* This test is in honor of Ed Hamrick who suggested that the interface
- to inflate be a byte at a time--this implements that, and is, of course,
- monumentally slow. It has the virtue though of stressing the push-pull
- interface for testing purposes. */
-
-void main()
-{
- int a, r;
- char c;
- z_stream z;
-
- z.zalloc = Z_NULL;
- z.zfree = Z_NULL;
- r = inflateInit(&z);
- if (r != Z_OK)
- fprintf(stderr, "init error: %s\n", z_errmsg[1 - r]);
- while ((a = getchar()) != EOF)
- {
- /* feed one byte of input */
- z.avail_out = 0;
- c = (char)a;
- z.next_in = (Byte*)&c;
- z.avail_in = 1;
- r = inflate(&z, 0);
- if (r == Z_STREAM_END)
- break;
- if (r != Z_OK)
- {
- fprintf(stderr, "inflate error: %s\n", z_errmsg[1 - r]);
- break;
- }
- if (z.avail_in != 0)
- {
- fprintf(stderr, "inflate didn't eat byte and didn't say buf err!\n");
- break;
- }
-
- /* empty output one byte at a time */
- while (1)
- {
- z.next_out = (Byte*)&c;
- z.avail_out = 1;
- r = inflate(&z, 0);
- if (r == Z_STREAM_END)
- break;
- if (r != Z_OK && r != Z_BUF_ERROR)
- {
- fprintf(stderr, "inflate error: %s\n", z_errmsg[1 - r]);
- break;
- }
- if (z.avail_out == 0)
- putchar(c);
- else
- break;
- }
- if (r != Z_OK && r != Z_BUF_ERROR)
- break;
- }
- inflateEnd(&z);
- fprintf(stderr, "%ld bytes in, %ld bytes out\n", z.total_in, z.total_out);
- if (z.msg != NULL)
- fprintf(stderr, "msg is <%s>\n", z.msg);
-}
diff --git a/inftrees.c b/inftrees.c
index ab0ed2c..9858927 100644
--- a/inftrees.c
+++ b/inftrees.c
@@ -16,37 +16,37 @@
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 *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 @@
#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 @@
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 @@
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 @@
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 @@
}
/* 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 @@
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 @@
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 @@
/* 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 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 @@
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 @@
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 6001a4e..27e7222 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 @@
#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 f468f1a..f234e9b 100644
--- a/infutil.h
+++ b/infutil.h
@@ -13,42 +13,42 @@
/* 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 8f58080..017c3e4 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 <stdio.h>
#include "zlib.h"
@@ -75,14 +75,14 @@
int err;
for (;;) {
- len = fread(buf, 1, sizeof(buf), in);
- if (ferror(in)) {
- perror("fread");
- exit(1);
- }
- if (len == 0) break;
+ len = fread(buf, 1, sizeof(buf), in);
+ if (ferror(in)) {
+ perror("fread");
+ exit(1);
+ }
+ if (len == 0) break;
- if (gzwrite(out, buf, len) != len) error(gzerror(out, &err));
+ if (gzwrite(out, buf, len) != len) error(gzerror(out, &err));
}
fclose(in);
if (gzclose(out) != Z_OK) error("failed gzclose");
@@ -100,11 +100,11 @@
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 @@
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 @@
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 @@
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 eb69d49..f85716e 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 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 @@
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 @@
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 @@
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 @@
/* 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 @@
/* 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 @@
* 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 @@
} 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 @@
/* 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 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 @@
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 @@
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 @@
}
} /* 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 @@
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 4c8b3af..c76286c 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 @@
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 1abb0ea..ce93061 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 1712209..00a4394 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 @@
a single step).
*/
- /* constants */
+ /* constants */
#define Z_NO_FLUSH 0
#define Z_PARTIAL_FLUSH 1
@@ -142,7 +142,7 @@
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 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 508ad62..2cddcff 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 <stdio.h>
@@ -42,7 +42,7 @@
{
if (len == 0) return;
do {
- *dest++ = *source++; /* ??? to be unrolled */
+ *dest++ = *source++; /* ??? to be unrolled */
} while (--len != 0);
}
@@ -52,7 +52,7 @@
{
if (len == 0) return;
do {
- *dest++ = 0; /* ??? to be unrolled */
+ *dest++ = 0; /* ??? to be unrolled */
} while (--len != 0);
}
#endif
@@ -91,10 +91,10 @@
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 @@
{
int n;
if (*(ush*)&ptr != 0) { /* object < 64K */
- farfree(ptr);
- return;
+ farfree(ptr);
+ return;
}
/* Find the original pointer */
for (n = 0; n < next_ptr; n++) {
- if (ptr != table[n].new_ptr) continue;
+ if (ptr != table[n].new_ptr) continue;
- farfree(table[n].org_ptr);
- while (++n < next_ptr) {
- table[n-1] = table[n];
- }
- next_ptr--;
- return;
+ farfree(table[n].org_ptr);
+ while (++n < next_ptr) {
+ table[n-1] = table[n];
+ }
+ next_ptr--;
+ return;
}
ptr = opaque; /* just to make some compilers happy */
z_error("zcfree: ptr not found");
diff --git a/zutil.h b/zutil.h
index 503a445..bc8af52 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 <stddef.h>
# include <errno.h>
@@ -39,7 +45,7 @@
#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 @@
#define MAX_MATCH 258
/* The minimum and maximum match lengths */
- /* target dependencies */
+ /* target dependencies */
#ifdef MSDOS
# define OS_CODE 0x00
@@ -107,7 +113,7 @@
# define OS_CODE 0x0a
#endif
- /* Common defaults */
+ /* Common defaults */
#ifndef OS_CODE
# define OS_CODE 0x03 /* assume Unix */
@@ -126,7 +132,10 @@
# 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
