zlib 0.92

zlib 0.91
2011-09-09 23:08:07 -07:00 · 2011-09-09 23:07:35 -07:00
29 changed files with 992 additions and 994 deletions
--- a/19
+++ b/19
@@ -1,5 +1,23 @@
 		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
+- added "make install"
+- fix sync search logic in inflateSync
+- deflate(Z_FULL_FLUSH) now works even if output buffer too short
+- after inflateSync, don't scare people with just "lo world"
+- added support for DJGPP
+
 Changes in 0.9 (1 May 95)
 - don't assume that zalloc clears the allocated memory (the TurboC bug
  was Mark's bug after all :)
@@ -10,6 +28,7 @@ Changes in 0.9 (1 May 95)
 - document explicitly that zalloc(64K) on MSDOS must return a normalized
  pointer (zero offset)
 - added Makefiles for Microsoft C, Turbo C, Borland C++
+- faster crc32()

 Changes in 0.8 (29 April 95)
 - added fast inflate (inffast.c)
--- a/26
+++ b/26
@@ -1,21 +1,37 @@
+# Makefile for zlib
+# Copyright (C) 1995 Jean-loup Gailly.
+# For conditions of distribution and use, see copyright notice in zlib.h 
+
 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

 RANLIB=ranlib

+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
 	echo hello world | ./minigzip | ./minigzip -d 

+install: libgz.a
+	-@mkdir $(prefix)/include
+	-@mkdir $(prefix)/lib
+	cp zlib.h zconf.h $(prefix)/include
+	chmod 644 $(prefix)/include/zlib.h $(prefix)/include/zconf.h
+	cp libgz.a $(prefix)/lib
+	chmod 644 $(prefix)/lib/libgz.a
+
 libgz.a: $(OBJS)
 	ar rc $@ $(OBJS)
 	$(RANLIB) $@
@@ -26,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]
@@ -51,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
--- a/Makefile.bak
+++ b/Makefile.bak
@@ -1,59 +0,0 @@
-CC=gcc
-CFLAGS=-O2
-#CFLAGS=-g -DDEBUG
-LDFLAGS=-L. -lgz
-
-RANLIB=ranlib
-
-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
-
-all: example minigzip inftest
-
-test: all
-	./example
-	echo hello world | ./minigzip | ./minigzip -d 
-
-libgz.a: $(OBJS)
-	ar rc $@ $(OBJS)
-	$(RANLIB) $@
-
-example: example.o libgz.a
-	$(CC) $(CFLAGS) -o $@ example.o $(LDFLAGS)
-
-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
-
-zip:
-	zip -ul9 zlib README ChangeLog Makefile *.[ch]
-
-tgz:
-	cd ..; tar cfz zlib/zlib.tgz zlib/README zlib/ChangeLog zlib/Makefile \
-		zlib/*.[ch]
-
-# DO NOT DELETE THIS LINE -- make depend depends on it.
-
-adler32.o: zutil.h zlib.h zconf.h
-compress.o: zlib.h zconf.h
-crc32.o: zutil.h zlib.h zconf.h
-deflate.o: deflate.h zutil.h zlib.h zconf.h
-example.o: zlib.h zconf.h
-gzio.o: zutil.h zlib.h zconf.h
-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
-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
-trees.o: deflate.h zutil.h zlib.h zconf.h
-uncompr.o: zlib.h zconf.h
-zutil.o: zutil.h zlib.h zconf.h
--- a/Makefile.bor
+++ b/Makefile.bor
@@ -4,7 +4,10 @@
 # To use, do "make -fmakefile.bor"

 # WARNING: the small model is supported but only for small values of
-# MAX_WBITS and MAX_MEM_LEVEL
+# MAX_WBITS and MAX_MEM_LEVEL. If you wish to reduce the memory
+# requirements (default 256K for big objects plus a few K), you can add
+# to CFLAGS below: -DMAX_MEM_LEVEL=7 -DMAX_WBITS=14
+# See zconf.h for details about the memory requirements.

 # ------------- Turbo C++, Borland C++ -------------
 MODEL=-ml
--- a/Makefile.msc
+++ b/Makefile.msc
@@ -4,7 +4,10 @@
 # To use, do "make makefile.msc"

 # WARNING: the small model is supported but only for small values of
-# MAX_WBITS and MAX_MEM_LEVEL
+# MAX_WBITS and MAX_MEM_LEVEL. If you wish to reduce the memory
+# requirements (default 256K for big objects plus a few K), you can add
+# to CFLAGS below: -DMAX_MEM_LEVEL=7 -DMAX_WBITS=14
+# See zconf.h for details about the memory requirements.

 # ------------- Microsoft C 5.1 and later -------------
 MODEL=-AL
--- a/Makefile.tc
+++ b/Makefile.tc
@@ -4,7 +4,10 @@
 # To use, do "make -fmakefile.tc"

 # WARNING: the small model is supported but only for small values of
-# MAX_WBITS and MAX_MEM_LEVEL
+# MAX_WBITS and MAX_MEM_LEVEL. If you wish to reduce the memory
+# requirements (default 256K for big objects plus a few K), you can add
+# to CFLAGS below: -DMAX_MEM_LEVEL=7 -DMAX_WBITS=14
+# See zconf.h for details about the memory requirements.

 # ------------- Turbo C 2.0 -------------
 MODEL=-ml
--- a/33
+++ b/33
@@ -1,25 +1,34 @@
-zlib 0.9 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
-file zlib-3.1.doc, deflate-1.1.doc and gzip-4.1.doc, available
+files zlib-3.1.doc, deflate-1.1.doc and gzip-4.1.doc, available
 in ftp.uu.net:/pub/archiving/zip/doc.

 All functions of the compression library are documented in the file
 zlib.h. A usage example of the library is given in the file example.c
 which also tests that the library is working correctly.
-To compile all files and run the test program, just type: make test

-The changes made in version 0.9 are documented in the file ChangeLog.
-The main changes since 0.8 are:
- don't assume that zalloc clears the allocated memory
- let again gzread copy uncompressed data unchanged (was working in 0.71)
- deflate(Z_FULL_FLUSH), inflateReset and inflateSync are now fully implemented
+To compile all files and run the test program, just type: make test
+(For MSDOS, use one of the special makefiles such as Makefile.msc.)
+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.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 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 MEM_LEVEL and
-WBITS (see zutil.h). Small model decompression should work up to WBITS=15.
-This version of zlib does not support small or medium model with far
-allocation of big objects.
+small model compression works only for small values of MAX_MEM_LEVEL
+and MAX_WBITS (see zconf.h). Small model decompression should work up
+to MAX_WBITS=15.  This version of zlib does not support small or
+medium model with far allocation of big objects.


  Copyright (C) 1995 Jean-loup Gailly and Mark Adler
--- 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;
 }
--- 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;

--- a/deflate.c
+++ b/deflate.c
@@ -47,7 +47,7 @@
 *
 */

-/* $Id: deflate.c,v 1.6 1995/05/01 17:23:57 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


@@ -165,7 +165,7 @@ int deflateInit (strm, level)
    z_stream *strm;
    int level;
 {
-    return deflateInit2 (strm, level, DEFLATED, MAX_WBITS, MAX_MEM_LEVEL, 0);
+    return deflateInit2 (strm, level, DEFLATED, MAX_WBITS, DEF_MEM_LEVEL, 0);
    /* To do: ignore strm->next_in if we use it as window */
 }

@@ -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,48 +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)) {
+        (flush == Z_FINISH && strm->state->status != FINISH_STATE)) {
+        int quit;
        
-	if (flush == Z_FINISH) {
-	    strm->state->status = FINISH_STATE;
-	}
+        if (flush == Z_FINISH) {
+            strm->state->status = FINISH_STATE;
+        }
        if (strm->state->level <= 3) {
-	    if (deflate_fast(strm->state, flush)) return Z_OK;
-	} else {
-	    if (deflate_slow(strm->state, flush)) return Z_OK;
-	}
-	/* ??? remember Z_FULL_FLUSH if we didn't have enough space */
-	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;
-	}
+            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");

@@ -400,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);
@@ -431,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;
@@ -487,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 */
 {
@@ -497,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.
@@ -608,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;
@@ -633,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
@@ -655,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)
@@ -672,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;

@@ -713,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);
 }
@@ -725,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); \
@@ -760,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:
@@ -779,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;
@@ -790,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;

@@ -851,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:
@@ -873,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.
@@ -897,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.
@@ -926,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.
@@ -941,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;
--- 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));
--- 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.7 1995/05/01 16:57:22 jloup Exp $ */
+/* $Id: example.c,v 1.9 1995/05/03 17:27:09 jloup Exp $ */

 #include <stdio.h>
 #include "zlib.h"
@@ -12,7 +12,9 @@
 #  include <string.h>
 #endif

+#ifndef __GO32__
 extern void exit  __P((int));
+#endif

 #define BUFLEN 4096

@@ -25,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); \
    } \
 }

@@ -58,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);
    }
 }

@@ -79,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);
    }
 }

@@ -127,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);
@@ -165,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);
    }
 }

@@ -209,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");
@@ -248,12 +250,12 @@ 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");

-    printf("after inflateSync(): %s\n", uncompr);
+    printf("after inflateSync(): hel%s\n", uncompr);
 }

 /* ===========================================================================
@@ -267,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);
--- 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.6 1995/04/30 19:52:21 jloup Exp $ */
+/* $Id: gzio.c,v 1.8 1995/05/03 17:27:09 jloup Exp $ */

 #include <stdio.h>

@@ -68,13 +68,13 @@ local int destroy (s)

    if (s->stream.state != NULL) {
       if (s->mode == 'w') {
-	   err = deflateEnd(&(s->stream));
+           err = deflateEnd(&(s->stream));
       } else if (s->mode == 'r') {
-	   err = inflateEnd(&(s->stream));
+           err = inflateEnd(&(s->stream));
       }
    }
    if (s->file != NULL && fclose(s->file)) {
-	err = Z_ERRNO;
+        err = Z_ERRNO;
    }
    if (s->z_err < 0) err = s->z_err;
    zcfree((voidp)0, s);
@@ -115,34 +115,34 @@ local gzFile gz_open (path, mode, fd)

    s->path = (char*)ALLOC(strlen(path)+1);
    if (s->path == NULL) {
-	return destroy(s), (gzFile)Z_NULL;
+        return destroy(s), (gzFile)Z_NULL;
    }
    strcpy(s->path, path); /* do this early for debugging */

    s->mode = '\0';
    do {
-	if (*p == 'r') s->mode = 'r';
-	if (*p == 'w') s->mode = 'w';
+        if (*p == 'r') s->mode = 'r';
+        if (*p == 'w') s->mode = 'w';
    } while (*p++);
    if (s->mode == '\0') return destroy(s), (gzFile)Z_NULL;
    
    if (s->mode == 'w') {
-	err = deflateInit2(&(s->stream), Z_DEFAULT_COMPRESSION,
-			   DEFLATED, -MAX_WBITS, MAX_MEM_LEVEL, 0);
-	/* windowBits is passed < 0 to suppress zlib header */
+        err = deflateInit2(&(s->stream), Z_DEFAULT_COMPRESSION,
+                           DEFLATED, -MAX_WBITS, DEF_MEM_LEVEL, 0);
+        /* windowBits is passed < 0 to suppress zlib header */

-	s->stream.next_out = s->outbuf = ALLOC(Z_BUFSIZE);
+        s->stream.next_out = s->outbuf = ALLOC(Z_BUFSIZE);

-	if (err != Z_OK || s->outbuf == Z_NULL) {
-	    return destroy(s), (gzFile)Z_NULL;
-	}
+        if (err != Z_OK || s->outbuf == Z_NULL) {
+            return destroy(s), (gzFile)Z_NULL;
+        }
    } else {
-	err = inflateInit2(&(s->stream), -MAX_WBITS);
-	s->stream.next_in  = s->inbuf = ALLOC(Z_BUFSIZE);
+        err = inflateInit2(&(s->stream), -MAX_WBITS);
+        s->stream.next_in  = s->inbuf = ALLOC(Z_BUFSIZE);

-	if (err != Z_OK || s->inbuf == Z_NULL) {
-	    return destroy(s), (gzFile)Z_NULL;
-	}
+        if (err != Z_OK || s->inbuf == Z_NULL) {
+            return destroy(s), (gzFile)Z_NULL;
+        }
    }
    s->stream.avail_out = Z_BUFSIZE;

@@ -150,55 +150,55 @@ local gzFile gz_open (path, mode, fd)
    s->file = fd < 0 ? FOPEN(path, mode) : fdopen(fd, mode);

    if (s->file == NULL) {
-	return destroy(s), (gzFile)Z_NULL;
+        return destroy(s), (gzFile)Z_NULL;
    }
    if (s->mode == 'w') {
-	/* Write a very simple .gz header:
-	 */
-	fprintf(s->file, "%c%c%c%c%c%c%c%c%c%c", GZ_MAGIC_1, GZ_MAGIC_2,
-	       DEFLATED, 0 /*flags*/, 0,0,0,0 /*time*/, 0 /*xflags*/, OS_CODE);
-    } else {
-	/* Check and skip the header:
+        /* Write a very simple .gz header:
         */
-	Byte c1 = 0, c2 = 0;
-	Byte method = 0;
-	Byte flags = 0;
-	Byte xflags = 0;
-	Byte time[4];
-	Byte osCode;
-	int c;
+        fprintf(s->file, "%c%c%c%c%c%c%c%c%c%c", GZ_MAGIC_1, GZ_MAGIC_2,
+               DEFLATED, 0 /*flags*/, 0,0,0,0 /*time*/, 0 /*xflags*/, OS_CODE);
+    } else {
+        /* Check and skip the header:
+         */
+        Byte c1 = 0, c2 = 0;
+        Byte method = 0;
+        Byte flags = 0;
+        Byte xflags = 0;
+        Byte time[4];
+        Byte osCode;
+        int c;

-	s->stream.avail_in = fread(s->inbuf, 1, 2, s->file);
-	if (s->stream.avail_in != 2 || s->inbuf[0] != GZ_MAGIC_1
-	    || s->inbuf[1] != GZ_MAGIC_2) {
-	    s->transparent = 1;
-	    return (gzFile)s;
-	}
-	s->stream.avail_in = 0;
-	fscanf(s->file,"%c%c%4c%c%c", &method, &flags, time, &xflags, &osCode);
+        s->stream.avail_in = fread(s->inbuf, 1, 2, s->file);
+        if (s->stream.avail_in != 2 || s->inbuf[0] != GZ_MAGIC_1
+            || s->inbuf[1] != GZ_MAGIC_2) {
+            s->transparent = 1;
+            return (gzFile)s;
+        }
+        s->stream.avail_in = 0;
+        fscanf(s->file,"%c%c%4c%c%c", &method, &flags, time, &xflags, &osCode);

-	if (method != DEFLATED || feof(s->file) || (flags & RESERVED) != 0) {
-	    s->z_err = Z_DATA_ERROR;
-	    return (gzFile)s;
-	}
-	if ((flags & EXTRA_FIELD) != 0) { /* skip the extra field */
-	    long len;
-	    fscanf(s->file, "%c%c", &c1, &c2);
-	    len = c1 + ((long)c2<<8);
-	    fseek(s->file, len, SEEK_CUR);
-	}
-	if ((flags & ORIG_NAME) != 0) { /* skip the original file name */
-	    while ((c = getc(s->file)) != 0 && c != EOF) ;
-	}
-	if ((flags & COMMENT) != 0) {   /* skip the .gz file comment */
-	    while ((c = getc(s->file)) != 0 && c != EOF) ;
-	}
-	if ((flags & HEAD_CRC) != 0) {  /* skip the header crc */
-	    fscanf(s->file, "%c%c", &c1, &c2);
-	}
-	if (feof(s->file)) {
-	    s->z_err = Z_DATA_ERROR;
-	}
+        if (method != DEFLATED || feof(s->file) || (flags & RESERVED) != 0) {
+            s->z_err = Z_DATA_ERROR;
+            return (gzFile)s;
+        }
+        if ((flags & EXTRA_FIELD) != 0) { /* skip the extra field */
+            long len;
+            fscanf(s->file, "%c%c", &c1, &c2);
+            len = c1 + ((long)c2<<8);
+            fseek(s->file, len, SEEK_CUR);
+        }
+        if ((flags & ORIG_NAME) != 0) { /* skip the original file name */
+            while ((c = getc(s->file)) != 0 && c != EOF) ;
+        }
+        if ((flags & COMMENT) != 0) {   /* skip the .gz file comment */
+            while ((c = getc(s->file)) != 0 && c != EOF) ;
+        }
+        if ((flags & HEAD_CRC) != 0) {  /* skip the header crc */
+            fscanf(s->file, "%c%c", &c1, &c2);
+        }
+        if (feof(s->file)) {
+            s->z_err = Z_DATA_ERROR;
+        }
    }
    return (gzFile)s;
 }
@@ -221,7 +221,7 @@ gzFile gzdopen (fd, mode)
    char *mode;
 {
    char name[20];
-    sprintf(name, "_fd:%d_", fd); /* for debugging */
+    sprintf(name, "<fd:%d>", fd); /* for debugging */

    return gz_open (name, mode, fd);
 }
@@ -240,16 +240,16 @@ int gzread (file, buf, len)
    if (s == NULL || s->mode != 'r') return Z_STREAM_ERROR;

    if (s->transparent) {
-	unsigned n = 0;
-	Byte *b = (Byte*)buf;
-	/* Copy the first two (non-magic) bytes if not done already */
-	while (s->stream.avail_in > 0 && len > 0) {
-	    *b++ = *s->stream.next_in++;
-	    s->stream.avail_in--;
-	    len--; n++;
-	}
-	if (len == 0) return n;
-	return n + fread(b, 1, len, s->file);
+        unsigned n = 0;
+        Byte *b = (Byte*)buf;
+        /* Copy the first two (non-magic) bytes if not done already */
+        while (s->stream.avail_in > 0 && len > 0) {
+            *b++ = *s->stream.next_in++;
+            s->stream.avail_in--;
+            len--; n++;
+        }
+        if (len == 0) return n;
+        return n + fread(b, 1, len, s->file);
    }
    if (s->z_err == Z_DATA_ERROR) return -1; /* bad .gz file */
    if (s->z_err == Z_STREAM_END) return 0;  /* don't read crc as data */
@@ -259,24 +259,24 @@ int gzread (file, buf, len)

    while (s->stream.avail_out != 0) {

-	if (s->stream.avail_in == 0 && !s->z_eof) {
+        if (s->stream.avail_in == 0 && !s->z_eof) {

-	    errno = 0;
-	    s->stream.avail_in =
-		fread(s->inbuf, 1, Z_BUFSIZE, s->file);
-	    if (s->stream.avail_in == 0) {
-		s->z_eof = 1;
-	    } else if (s->stream.avail_in == (uInt)EOF) {
-		s->stream.avail_in = 0;
-		s->z_eof = 1;
-		s->z_err = Z_ERRNO;
-		break;
-	    }
-	    s->stream.next_in = s->inbuf;
-	}
-	s->z_err = inflate(&(s->stream), Z_NO_FLUSH);
+            errno = 0;
+            s->stream.avail_in =
+                fread(s->inbuf, 1, Z_BUFSIZE, s->file);
+            if (s->stream.avail_in == 0) {
+                s->z_eof = 1;
+            } else if (s->stream.avail_in == (uInt)EOF) {
+                s->stream.avail_in = 0;
+                s->z_eof = 1;
+                s->z_err = Z_ERRNO;
+                break;
+            }
+            s->stream.next_in = s->inbuf;
+        }
+        s->z_err = inflate(&(s->stream), Z_NO_FLUSH);

-	if (s->z_err == Z_STREAM_END ||
+        if (s->z_err == Z_STREAM_END ||
            s->z_err != Z_OK  || s->z_eof) break;
    }
    len -= s->stream.avail_out;
@@ -302,18 +302,18 @@ int gzwrite (file, buf, len)

    while (s->stream.avail_in != 0) {

-	if (s->stream.avail_out == 0) {
+        if (s->stream.avail_out == 0) {

-	    s->stream.next_out = s->outbuf;
-	    if (fwrite(s->outbuf, 1, Z_BUFSIZE, s->file) != Z_BUFSIZE) {
-		s->z_err = Z_ERRNO;
-		break;
-	    }
-	    s->stream.avail_out = Z_BUFSIZE;
-	}
-	s->z_err = deflate(&(s->stream), Z_NO_FLUSH);
+            s->stream.next_out = s->outbuf;
+            if (fwrite(s->outbuf, 1, Z_BUFSIZE, s->file) != Z_BUFSIZE) {
+                s->z_err = Z_ERRNO;
+                break;
+            }
+            s->stream.avail_out = Z_BUFSIZE;
+        }
+        s->z_err = deflate(&(s->stream), Z_NO_FLUSH);

-	if (s->z_err != Z_OK) break;
+        if (s->z_err != Z_OK) break;
    }
    s->crc = crc32(s->crc, buf, len);

@@ -339,25 +339,25 @@ int gzflush (file, flush)
    s->stream.avail_in = 0; /* should be zero already anyway */

    for (;;) {
-	len = Z_BUFSIZE - s->stream.avail_out;
+        len = Z_BUFSIZE - s->stream.avail_out;

-	if (len != 0) {
-	    if (fwrite(s->outbuf, 1, len, s->file) != len) {
-		s->z_err = Z_ERRNO;
-		return Z_ERRNO;
-	    }
-	    s->stream.next_out = s->outbuf;
-	    s->stream.avail_out = Z_BUFSIZE;
-	}
-	if (done) break;
-	s->z_err = deflate(&(s->stream), flush);
+        if (len != 0) {
+            if (fwrite(s->outbuf, 1, len, s->file) != len) {
+                s->z_err = Z_ERRNO;
+                return Z_ERRNO;
+            }
+            s->stream.next_out = s->outbuf;
+            s->stream.avail_out = Z_BUFSIZE;
+        }
+        if (done) break;
+        s->z_err = deflate(&(s->stream), flush);

        /* deflate has finished flushing only when it hasn't used up
         * all the available space in the output buffer: 
         */
        done = (s->stream.avail_out != 0 || s->z_err == Z_STREAM_END);
 
-	if (s->z_err != Z_OK && s->z_err != Z_STREAM_END) break;
+        if (s->z_err != Z_OK && s->z_err != Z_STREAM_END) break;
    }
    return  s->z_err == Z_STREAM_END ? Z_OK : s->z_err;
 }
@@ -371,8 +371,8 @@ local void putLong (file, x)
 {
    int n;
    for (n = 0; n < 4; n++) {
-	fputc((int)(x & 0xff), file);
-	x >>= 8;
+        fputc((int)(x & 0xff), file);
+        x >>= 8;
    }
 }

@@ -386,8 +386,8 @@ local uLong getLong (buf)
    Byte *p = buf+4;

    do {
-	x <<= 8;
-	x |= *--p; 
+        x <<= 8;
+        x |= *--p; 
    } while (p != buf);
    return x;
 }
@@ -406,31 +406,31 @@ int gzclose (file)
    if (s == NULL) return Z_STREAM_ERROR;

    if (s->mode == 'w') {
-	err = gzflush (file, Z_FINISH);
-	if (err != Z_OK) return destroy(file);
+        err = gzflush (file, Z_FINISH);
+        if (err != Z_OK) return destroy(file);

-	putLong (s->file, s->crc);
-	putLong (s->file, s->stream.total_in);
+        putLong (s->file, s->crc);
+        putLong (s->file, s->stream.total_in);

    } else if (s->mode == 'r' && s->z_err == Z_STREAM_END) {

-	/* slide CRC and original size if they are at the end of inbuf */
-	if ((n = s->stream.avail_in) < 8  && !s->z_eof) {
-	    Byte *p = s->inbuf;
-	    Byte *q = s->stream.next_in;
-	    while (n--) { *p++ = *q++; };
+        /* slide CRC and original size if they are at the end of inbuf */
+        if ((n = s->stream.avail_in) < 8  && !s->z_eof) {
+            Byte *p = s->inbuf;
+            Byte *q = s->stream.next_in;
+            while (n--) { *p++ = *q++; };

-	    n = s->stream.avail_in;
-	    n += fread(p, 1, 8, s->file);
-	    s->stream.next_in = s->inbuf;
-	}
-	/* check CRC and original size */
-	if (n < 8 ||
-	    getLong(s->stream.next_in) != s->crc ||
-	    getLong(s->stream.next_in + 4) != s->stream.total_out) {
+            n = s->stream.avail_in;
+            n += fread(p, 1, 8, s->file);
+            s->stream.next_in = s->inbuf;
+        }
+        /* check CRC and original size */
+        if (n < 8 ||
+            getLong(s->stream.next_in) != s->crc ||
+            getLong(s->stream.next_in + 4) != s->stream.total_out) {

-	    s->z_err = Z_DATA_ERROR;
-	}
+            s->z_err = Z_DATA_ERROR;
+        }
    }
    return destroy(file);
 }
@@ -450,8 +450,8 @@ char*  gzerror (file, errnum)
    gz_stream *s = (gz_stream*)file;

    if (s == NULL) {
-	*errnum = Z_STREAM_ERROR;
-	return z_errmsg[1-Z_STREAM_ERROR];
+        *errnum = Z_STREAM_ERROR;
+        return z_errmsg[1-Z_STREAM_ERROR];
    }
    *errnum = s->z_err;
    if (*errnum == Z_OK) return "";
--- 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:
--- 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 *,
--- 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:
--- 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);
--- 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)
@@ -145,19 +145,19 @@ int f;
  {
    case METHOD:
      NEEDBYTE
-      if (((z->state->sub.method = NEXTBYTE) & 0xf != DEFLATED))
+      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,16 +234,19 @@ 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)
    return Z_STREAM_ERROR;
  if (z->state->mode != BAD)
+  {
+    z->state->mode = BAD;
    z->state->sub.marker = 0;
+  }
  if ((n = z->avail_in) == 0)
    return Z_BUF_ERROR;
  p = z->next_in;
@@ -252,10 +255,12 @@ z_stream *z;
  /* search */
  while (n && m < 4)
  {
-    if (*p == (m < 2 ? 0 : 0xff))
+    if (*p == (Byte)(m < 2 ? 0 : 0xff))
      m++;
-    else if (*p || m > 2)
+    else if (*p)
      m = 0;
+    else
+      m = 4 - m;
    p++, n--;
  }

--- a/inftest.c
+++ b/inftest.c
@@ -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);
-}
--- 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. */
--- 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 */
--- 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 */

 };

--- a/minigzip.c
+++ b/minigzip.c
@@ -13,12 +13,14 @@
 * or in pipe mode.
 */

-/* $Id: minigzip.c,v 1.3 1995/04/29 14:27:21 jloup Exp $ */
+/* $Id: minigzip.c,v 1.5 1995/05/03 17:27:11 jloup Exp $ */

 #include <stdio.h>
 #include "zlib.h"

+#ifndef __GO32__
 extern void exit  __P((int));
+#endif
 extern int unlink __P((const char *));

 #ifdef STDC
@@ -73,14 +75,14 @@ void gz_compress(in, out)
    int err;

    for (;;) {
-	len = fread(buf, 1, sizeof(buf), in);
-	if (ferror(in)) {
-	    perror("fread");
-	    exit(1);
-	}
-	if (len == 0) break;
+        len = fread(buf, 1, sizeof(buf), in);
+        if (ferror(in)) {
+            perror("fread");
+            exit(1);
+        }
+        if (len == 0) break;

-	if (gzwrite(out, buf, len) != len) error(gzerror(out, &err));
+        if (gzwrite(out, buf, len) != len) error(gzerror(out, &err));
    }
    fclose(in);
    if (gzclose(out) != Z_OK) error("failed gzclose");
@@ -98,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");

@@ -126,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);

@@ -155,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);
@@ -195,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);
 }
--- 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++);
    }
 }
--- 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;

--- 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.10 1995/04/30 19:27:14 jloup Exp $ */
+/* $Id: zconf.h,v 1.12 1995/05/03 17:27:12 jloup Exp $ */

 #ifndef _ZCONF_H
 #define _ZCONF_H
@@ -32,6 +32,7 @@
 #  define STDC
 #endif

+/* Maximum value for memLevel in deflateInit2 */
 #ifndef MAX_MEM_LEVEL
 #  ifdef MAXSEG_64K
 #    define MAX_MEM_LEVEL 8
@@ -40,11 +41,25 @@
 #  endif
 #endif

+/* Maximum value for windowBits in deflateInit2 and inflateInit2 */
 #ifndef MAX_WBITS
 #  define MAX_WBITS   15 /* 32K LZ77 window */
 #endif

-			/* Type declarations */
+/* The memory requirements for deflate are (in bytes):
+            1 << (windowBits+2)   +  1 << (memLevel+9)
+ that is: 128K for windowBits=15  +  128K for memLevel = 8  (default values)
+ plus a few kilobytes for small objects. For example, if you want to reduce
+ the default memory requirements from 256K to 128K, compile with
+     make CFLAGS="-O -DMAX_WBITS=14 -DMAX_MEM_LEVEL=7"
+ Of course this will generally degrade compression (there's no free lunch).
+
+   The memory requirements for inflate are (in bytes) 1 << windowBits
+ that is, 32K for windowBits=15 (default value) plus a few kilobytes
+ for small objects.
+*/
+
+                        /* Type declarations */

 #ifndef __P /* function prototypes */
 #  ifdef STDC
--- a/zlib.h
+++ b/zlib.h
@@ -1,5 +1,5 @@
 /* zlib.h -- interface of the 'zlib' general purpose compression library
-  version 0.9 April 30th, 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.9"
+#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));
@@ -335,7 +335,8 @@ extern int deflateInit2 __P((z_stream *strm,
    The memLevel parameter specifies how much memory should be allocated
   for the internal compression state. memLevel=1 uses minimum memory but
   is slow and reduces compression ratio; memLevel=9 uses maximum memory
-   for optimal speed. The default value is 8.
+   for optimal speed. The default value is 8. See zconf.h for total memory
+   usage as a function of windowBits and memLevel.

     The strategy parameter is used to tune the compression algorithm. Use
   the value Z_DEFAULT_STRATEGY for normal data, Z_FILTERED for data
--- a/zutil.c
+++ b/zutil.c
@@ -3,13 +3,15 @@
 * For conditions of distribution and use, see copyright notice in zlib.h 
 */

-/* $Id: zutil.c,v 1.6 1995/04/29 14:54:02 jloup Exp $ */
+/* $Id: zutil.c,v 1.8 1995/05/03 17:27:12 jloup Exp $ */

 #include <stdio.h>

 #include "zutil.h"

+#ifndef __GO32__
 extern void exit __P((int));
+#endif

 char *zlib_version = ZLIB_VERSION;

@@ -40,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);
 }

@@ -50,13 +52,14 @@ void zmemzero(dest, len)
 {
    if (len == 0) return;
    do {
-	*dest++ = 0;  /* ??? to be unrolled */
+        *dest++ = 0;  /* ??? to be unrolled */
    } while (--len != 0);
 }
 #endif

-#if defined(MSDOS) && !defined(__SMALL__) && !defined(M_I86SM)
-#  ifdef __TURBOC__
+#if defined(__TURBOC__) && !defined(__SMALL__)
+
+#  define MY_ZCALLOC

 /* Turbo C malloc() does not allow dynamic allocation of 64K bytes
 * and farmalloc(64K) returns a pointer with an offset of 8, so we
@@ -88,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;
@@ -107,25 +110,28 @@ void  zcfree (voidp opaque, voidp ptr)
 {
    int n;
    if (*(ush*)&ptr != 0) { /* object < 64K */
-	farfree(ptr);
-	return;
+        farfree(ptr);
+        return;
    }
    /* Find the original pointer */
    for (n = 0; n < next_ptr; n++) {
-	if (ptr != table[n].new_ptr) continue;
+        if (ptr != table[n].new_ptr) continue;

-	farfree(table[n].org_ptr);
-	while (++n < next_ptr) {
-	    table[n-1] = table[n];
-	}
-	next_ptr--;
-	return;
+        farfree(table[n].org_ptr);
+        while (++n < next_ptr) {
+            table[n-1] = table[n];
+        }
+        next_ptr--;
+        return;
    }
    ptr = opaque; /* just to make some compilers happy */
    z_error("zcfree: ptr not found");
 }
+#endif /* __TURBOC__ */

-#  else /* MSC */
+#if defined(M_I86CM) || defined(M_I86LM) /* MSC compact or large model */
+
+#  define MY_ZCALLOC

 #if (!defined(_MSC_VER) || (_MSC_VER < 600))
 #  define _halloc  halloc
@@ -144,12 +150,15 @@ void  zcfree (voidp opaque, voidp ptr)
    _hfree(ptr);
 }

-#  endif /* __TURBOC__ ? */
+#endif /* defined(M_I86CM) || defined(M_I86LM) */

-#else /* !MSDOS */

+#ifndef MY_ZCALLOC /* Any system without a special alloc function */
+
+#ifndef __GO32__
 extern voidp calloc __P((uInt items, uInt size));
 extern void  free   __P((voidp ptr));
+#endif

 voidp zcalloc (opaque, items, size)
    voidp opaque;
@@ -166,4 +175,4 @@ void  zcfree (opaque, ptr)
    free(ptr);
 }

-#endif /* MSDOS */
+#endif /* MY_ZCALLOC */
--- a/zutil.h
+++ b/zutil.h
@@ -8,15 +8,22 @@
   subject to change. Applications should only use zlib.h.
 */

-/* $Id: zutil.h,v 1.7 1995/04/30 10:55:33 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>
 #else
    extern int errno;
 #endif
@@ -38,12 +45,19 @@ 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

 #define DEF_WBITS 15
-/* default WBITS for decompression. MAX_WBITS is useful for compression only */
+/* default windowBits for decompression. MAX_WBITS is for compression only */
+
+#if MAX_MEM_LEVEL >= 8
+#  define DEF_MEM_LEVEL 8
+#else
+#  define DEF_MEM_LEVEL  MAX_MEM_LEVEL
+#endif
+/* default memLevel */

 #define STORED_BLOCK 0
 #define STATIC_TREES 1
@@ -54,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
@@ -99,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 */
@@ -118,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
Author	SHA1	Message	Date
Mark Adler	bdde4e09d2	zlib 0.92	2011-09-09 23:08:07 -07:00
Mark Adler	1c71d8b13b	zlib 0.91	2011-09-09 23:07:35 -07:00