zlib 1.0.9

ChangeLog

@@ -1,6 +1,30 @@
 
 		ChangeLog file for zlib
 
+Changes in 1.0.9 (17 Feb 1998)
+- added gzputs and gzgets functions
+- do not clear eof flag in gzseek (Mark Diekhans)
+- fix gzseek for files in transparent mode (Mark Diekhans)
+- do not assume that vsprintf returns the number of bytes written (Jens Krinke)
+- replace EXPORT with ZEXPORT to avoid conflict with other programs
+- added compress2 in zconf.h, zlib.def, zlib.dnt
+- new asm code from Gilles Vollant in contrib/asm386
+- simplify the inflate code (Mark):
+ . Replace ZALLOC's in huft_build() with single ZALLOC in inflate_blocks_new()
+ . ZALLOC the length list in inflate_trees_fixed() instead of using stack
+ . ZALLOC the value area for huft_build() instead of using stack
+ . Simplify Z_FINISH check in inflate()
+
+- Avoid gcc 2.8.0 comparison bug a little differently than zlib 1.0.8
+- in inftrees.c, avoid cc -O bug on HP (Farshid Elahi)
+- in zconf.h move the ZLIB_DLL stuff earlier to avoid problems with
+  the declaration of FAR (Gilles VOllant)
+- install libz.so* with mode 755 (executable) instead of 644 (Marc Lehmann)
+- read_buf buf parameter of type Bytef* instead of charf*
+- zmemcpy parameters are of type Bytef*, not charf* (Joseph Strout)
+- do not redeclare unlink in minigzip.c for WIN32 (John Bowler)
+- fix check for presence of directories in "make install" (Ian Willis)
+
 Changes in 1.0.8 (27 Jan 1998)
 - fixed offsets in contrib/asm386/gvmat32.asm (Gilles Vollant)
 - fix gzgetc and gzputc for big endian systems (Markus Oberhumer)

Makefile

@@ -23,7 +23,7 @@ CFLAGS=-O
 LDFLAGS=-L. -lz
 LDSHARED=$(CC)
 
-VER=1.0.8
+VER=1.0.9
 LIBS=libz.a
 SHAREDLIB=libz.so
 
@@ -44,7 +44,7 @@ DISTFILES = README INDEX ChangeLog configure Make*[a-z0-9] *.[ch] descrip.mms \
   algorithm.txt zlib.3 msdos/Make*[a-z0-9] msdos/zlib.def msdos/zlib.rc \
   nt/Makefile.nt nt/zlib.dnt  contrib/README.contrib contrib/*.txt \
   contrib/asm386/*.asm contrib/asm386/*.c \
-  contrib/asm386/*.bat contrib/asm386/*.mak contrib/iostream/*.cpp \
+  contrib/asm386/*.bat contrib/asm386/zlibvc.d?? contrib/iostream/*.cpp \
   contrib/iostream/*.h  contrib/iostream2/*.h contrib/iostream2/*.cpp \
   contrib/untgz/Makefile contrib/untgz/*.c contrib/untgz/*.w32
 
@@ -77,12 +77,12 @@ minigzip: minigzip.o $(LIBS)
 	$(CC) $(CFLAGS) -o $@ minigzip.o $(LDFLAGS)
 
 install: $(LIBS)
-	-@if [ ! $(prefix)/include  ]; then mkdir $(prefix)/include; fi
+	-@if [ ! -d $(prefix)/include  ]; then mkdir $(prefix)/include; fi
-	-@if [ ! $(exec_prefix)/lib ]; then mkdir $(exec_prefix)/lib; fi
+	-@if [ ! -d $(exec_prefix)/lib ]; then mkdir $(exec_prefix)/lib; fi
 	cp zlib.h zconf.h $(prefix)/include
 	chmod 644 $(prefix)/include/zlib.h $(prefix)/include/zconf.h
 	cp $(LIBS) $(exec_prefix)/lib
-	cd $(exec_prefix)/lib; chmod 644 $(LIBS)
+	cd $(exec_prefix)/lib; chmod 755 $(LIBS)
 	-@(cd $(exec_prefix)/lib; $(RANLIB) libz.a || true) >/dev/null 2>&1
 	cd $(exec_prefix)/lib; if test -f $(SHAREDLIB).$(VER); then \
 	  rm -f $(SHAREDLIB) $(SHAREDLIB).1; \
@@ -112,12 +112,14 @@ distclean:	clean
 
 zip:
 	mv Makefile Makefile~; cp -p Makefile.in Makefile
+	rm -f test.c ztest*.c
 	v=`sed -n -e 's/\.//g' -e '/VERSION "/s/.*"\(.*\)".*/\1/p' < zlib.h`;\
 	zip -ul9 zlib$$v $(DISTFILES)
 	mv Makefile~ Makefile
 
 dist:
 	mv Makefile Makefile~; cp -p Makefile.in Makefile
+	rm -f test.c ztest*.c
 	d=zlib-`sed -n '/VERSION "/s/.*"\(.*\)".*/\1/p' < zlib.h`;\
 	rm -f $$d.tar.gz; \
 	if test ! -d ../$$d; then rm -f ../$$d; ln -s `pwd` ../$$d; fi; \

Makefile.in

@@ -23,7 +23,7 @@ CFLAGS=-O
 LDFLAGS=-L. -lz
 LDSHARED=$(CC)
 
-VER=1.0.8
+VER=1.0.9
 LIBS=libz.a
 SHAREDLIB=libz.so
 
@@ -44,7 +44,7 @@ DISTFILES = README INDEX ChangeLog configure Make*[a-z0-9] *.[ch] descrip.mms \
   algorithm.txt zlib.3 msdos/Make*[a-z0-9] msdos/zlib.def msdos/zlib.rc \
   nt/Makefile.nt nt/zlib.dnt  contrib/README.contrib contrib/*.txt \
   contrib/asm386/*.asm contrib/asm386/*.c \
-  contrib/asm386/*.bat contrib/asm386/*.mak contrib/iostream/*.cpp \
+  contrib/asm386/*.bat contrib/asm386/zlibvc.d?? contrib/iostream/*.cpp \
   contrib/iostream/*.h  contrib/iostream2/*.h contrib/iostream2/*.cpp \
   contrib/untgz/Makefile contrib/untgz/*.c contrib/untgz/*.w32
 
@@ -77,12 +77,12 @@ minigzip: minigzip.o $(LIBS)
 	$(CC) $(CFLAGS) -o $@ minigzip.o $(LDFLAGS)
 
 install: $(LIBS)
-	-@if [ ! $(prefix)/include  ]; then mkdir $(prefix)/include; fi
+	-@if [ ! -d $(prefix)/include  ]; then mkdir $(prefix)/include; fi
-	-@if [ ! $(exec_prefix)/lib ]; then mkdir $(exec_prefix)/lib; fi
+	-@if [ ! -d $(exec_prefix)/lib ]; then mkdir $(exec_prefix)/lib; fi
 	cp zlib.h zconf.h $(prefix)/include
 	chmod 644 $(prefix)/include/zlib.h $(prefix)/include/zconf.h
 	cp $(LIBS) $(exec_prefix)/lib
-	cd $(exec_prefix)/lib; chmod 644 $(LIBS)
+	cd $(exec_prefix)/lib; chmod 755 $(LIBS)
 	-@(cd $(exec_prefix)/lib; $(RANLIB) libz.a || true) >/dev/null 2>&1
 	cd $(exec_prefix)/lib; if test -f $(SHAREDLIB).$(VER); then \
 	  rm -f $(SHAREDLIB) $(SHAREDLIB).1; \
@@ -112,12 +112,14 @@ distclean:	clean
 
 zip:
 	mv Makefile Makefile~; cp -p Makefile.in Makefile
+	rm -f test.c ztest*.c
 	v=`sed -n -e 's/\.//g' -e '/VERSION "/s/.*"\(.*\)".*/\1/p' < zlib.h`;\
 	zip -ul9 zlib$$v $(DISTFILES)
 	mv Makefile~ Makefile
 
 dist:
 	mv Makefile Makefile~; cp -p Makefile.in Makefile
+	rm -f test.c ztest*.c
 	d=zlib-`sed -n '/VERSION "/s/.*"\(.*\)".*/\1/p' < zlib.h`;\
 	rm -f $$d.tar.gz; \
 	if test ! -d ../$$d; then rm -f ../$$d; ln -s `pwd` ../$$d; fi; \

README

@@ -1,4 +1,4 @@
-zlib 1.0.8 is a general purpose data compression library.  All the code
+zlib 1.0.9 is a general purpose data compression library.  All the code
 is thread safe.  The data format used by the zlib library
 is described by RFCs (Request for Comments) 1950 to 1952 in the files 
 ftp://ds.internic.net/rfc/rfc1950.txt (zlib format), rfc1951.txt (deflate
@@ -25,18 +25,22 @@ Mark Nelson wrote an article about zlib for the Jan. 1997 issue of
 Dr. Dobb's Journal; a copy of the article is available in
 http://web2.airmail.net/markn/articles/zlibtool/zlibtool.htm
 
-The changes made in version 1.0.8 are documented in the file ChangeLog.
+The changes made in version 1.0.9 are documented in the file ChangeLog.
-The main changes since 1.0.7 are:
+The main changes since 1.0.8 are:
+
+- added gzputs and gzgets functions
+- do not clear eof flag in gzseek (Mark Diekhans)
+- fix gzseek for files in transparent mode (Mark Diekhans)
+- do not assume that vsprintf returns the number of bytes written (Jens Krinke)
+- replace EXPORT with ZEXPORT to avoid conflict with other programs
+- added compress2 in zconf.h, zlib.def, zlib.dnt
+- new asm code from Gilles Vollant in contrib/asm386
+- simplify the inflate code (Mark):
+ . Replace ZALLOC's in huft_build() with single ZALLOC in inflate_blocks_new()
+ . ZALLOC the length list in inflate_trees_fixed() instead of using stack
+ . ZALLOC the value area for huft_build() instead of using stack
+ . Simplify Z_FINISH check in inflate()
 
-- fixed offsets in contrib/asm386/gvmat32.asm (Gilles Vollant)
-- fix gzgetc and gzputc for big endian systems (Markus Oberhumer)
-- added compress2() to allow setting the compression level
-- include sys/types.h to get off_t on some systems (Marc Lehmann & QingLong)
-- use constant arrays for the static trees in trees.c instead of computing
-  them at run time (thanks to Ken Raeburn for this suggestion). To create
-  trees.h, compile with GEN_TREES_H and run "make test".
-- check return code of example in "make test" and display result
-- pass minigzip command line options to file_compress
 
 Unsupported third party contributions are provided in directory "contrib".
 
@@ -65,9 +69,6 @@ Notes for some targets:
   See contrib/visual-basic.txt for more information.
   I don't know how to handle structures in Visual Basic, sorry.
 
-- "make test" fails on Solaris 2.6 with gcc 2.8.0. It works with cc and
-   with gcc 2.7.2.1.
-
 - For 64-bit Irix, deflate.c must be compiled without any optimization.
   With -O, one libpng test fails. The test works in 32 bit mode (with
   the -n32 compiler flag). The compiler bug has been reported to SGI.
@@ -75,11 +76,12 @@ Notes for some targets:
 - zlib doesn't work with gcc 2.6.3 on a DEC 3000/300LX under OSF/1 2.1   
   it works when compiled with cc.
 
-- zlib doesn't work on HP-UX 9.05 with one cc compiler (the one not
+- zlib doesn't work on HP-UX 9.05 with some versions of /bin/cc. It works
-  accepting the -O option). It works with the other cc compiler.
+  with other compilers. Use "make test" to check your compiler.
 
 - For shared memory multiprocessors, the decompression code assumes that
-  writes to pointers are atomic.
+  writes to pointers are atomic. Also the functions zalloc and zfree passed
+  to deflateInit must be multi-threaded in this case.
 
 - gzdopen is not supported on RISCOS, BEOS and Mac
 

adler32.c

@@ -18,7 +18,7 @@
 #define DO16(buf)   DO8(buf,0); DO8(buf,8);
 
 /* ========================================================================= */
-uLong EXPORT adler32(adler, buf, len)
+uLong ZEXPORT adler32(adler, buf, len)
     uLong adler;
     const Bytef *buf;
     uInt len;

compress.c

@@ -18,7 +18,7 @@
    memory, Z_BUF_ERROR if there was not enough room in the output buffer,
    Z_STREAM_ERROR if the level parameter is invalid.
 */
-int EXPORT compress2 (dest, destLen, source, sourceLen, level)
+int ZEXPORT compress2 (dest, destLen, source, sourceLen, level)
     Bytef *dest;
     uLongf *destLen;
     const Bytef *source;
@@ -58,7 +58,7 @@ int EXPORT compress2 (dest, destLen, source, sourceLen, level)
 
 /* ===========================================================================
  */
-int EXPORT compress (dest, destLen, source, sourceLen)
+int ZEXPORT compress (dest, destLen, source, sourceLen)
     Bytef *dest;
     uLongf *destLen;
     const Bytef *source;

configure

@@ -14,6 +14,10 @@
 #    (setenv prefix $HOME; setenv CC cc; setenv CFLAGS "-O4"; ./configure)
 # LDSHARED is the command to be used to create a shared library
 
+# Incorrect settings of CC or CFLAGS may prevent creating a shared library.
+# If you have problems, try without defining CC and CFLAGS before reporting
+# an error.
+
 LIBS=libz.a
 SHAREDLIB=libz.so
 VER=`sed -n -e '/VERSION "/s/.*"\(.*\)".*/\1/p' < zlib.h`
@@ -23,6 +27,8 @@ prefix=${prefix-/usr/local}
 exec_prefix=${exec_prefix-$prefix}
 shared_ext='.so'
 shared=0
+old_cc="$CC"
+old_cflags="$CFLAGS"
 
 case "$1" in
   -s* | --s*) shared=1; shift;;
@@ -96,9 +102,12 @@ if test $shared -eq 1; then
     CFLAGS="$SFLAGS"
     LIBS="$SHAREDLIB.$VER"
     echo Building shared library $SHAREDLIB.$VER with $CC.
-  else
+  elif test -z "$old_cc" -a -z "$old_cflags"; then
     echo No shared library suppport.
     shared=0;
+  else
+    echo 'No shared library suppport; try without defining CC and CFLAGS'
+    shared=0;
   fi
 fi
 if test $shared -eq 0; then

contrib/asm386/gvmat32.asm

@@ -9,12 +9,8 @@
 ; For Visual C++ 4.2 and ML 6.11c (version in directory \MASM611C of Win95 DDK)
 ;   I compile with : "ml /coff /Zi /c gvmat32.asm"
 ;
-; uInt longest_match_gvasm(IPos cur_match,int* match_start_ptr,uInt scan_end,
-;                          uInt scan_start,ush* prev,uch* window,int best_len,
-;                          IPos limit,uInt chain_length,uch* scanrp,
-;                          uInt nice_match);
 
-;uInt longest_match(s, cur_match)
+;uInt longest_match_7fff(s, cur_match)
 ;    deflate_state *s;
 ;    IPos cur_match;                             /* current match */
 
@@ -34,15 +30,15 @@
         window          equ     dword ptr [esp+NbStack-40]
         prev            equ     dword ptr [esp+NbStack-44]
         scan_start      equ      word ptr [esp+NbStack-48]
-	scan_end        equ  word ptr [esp+NbStack-52]
+        wmask           equ     dword ptr [esp+NbStack-52]
         match_start_ptr equ     dword ptr [esp+NbStack-56]
         nice_match      equ     dword ptr [esp+NbStack-60]
-	scanrp          equ dword ptr [esp+NbStack-64]
+        scan            equ     dword ptr [esp+NbStack-64]
 
         windowlen       equ     dword ptr [esp+NbStack-68]
         match_start     equ     dword ptr [esp+NbStack-72]
         strend          equ     dword ptr [esp+NbStack-76]
-	NbStackAdd		equ	(76-24)
+        NbStackAdd      equ     (NbStack-24)
 
     .386p
 
@@ -50,11 +46,11 @@
     .MODEL  FLAT
 
 
-@lmtype				TYPEDEF         PROTO C :PTR , :SDWORD
-longest_match_c		PROTO           @lmtype
 
-    ;  all the +4 offsets are due to the addition of pending_buf_size
+;  all the +4 offsets are due to the addition of pending_buf_size (in zlib
 ;  in the deflate_state structure since the asm code was first written
+;  (if you compile with zlib 1.0.4 or older, remove the +4).
+;  Note : these value are good with a 8 bytes boundary pack structure
     dep_chain_length    equ     70h+4
     dep_window          equ     2ch+4
     dep_strstart        equ     60h+4
@@ -69,35 +65,41 @@ longest_match_c		PROTO           @lmtype
 
 
 _TEXT                   segment
-    public  _longest_match_asm7fff
+
+IFDEF NOUNDERLINE
+                        public  longest_match_7fff
+;                        public  match_init
+ELSE
+                        public  _longest_match_7fff
+;                        public  _match_init
+ENDIF
 
     MAX_MATCH           equ     258
     MIN_MATCH           equ     3
     MIN_LOOKAHEAD       equ     (MAX_MATCH+MIN_MATCH+1)
 
-; initialize or check the variables used in match.asm.
 
 
-; -----------------------------------------------------------------------
+IFDEF NOUNDERLINE
-; Set match_start to the longest match starting at the given string and
+;match_init      proc near
-; return its length. Matches shorter or equal to prev_length are discarded,
+;                ret
-; in which case the result is equal to prev_length and match_start is
+;match_init      endp
-; garbage.
+ELSE
-; IN assertions: cur_match is the head of the hash chain for the current
+;_match_init     proc near
-;   string (strstart) and its distance is <= MAX_DIST, and prev_length >= 1
+;                ret
-
+;_match_init     endp
-; int longest_match(cur_match)
+ENDIF
-
-_longest_match_asm7fff proc near
 
 
+IFDEF NOUNDERLINE
+longest_match_7fff   proc near
+ELSE
+_longest_match_7fff  proc near
+ENDIF
+
+        mov     edx,[esp+4]
 
-	    ; return address
 
-		mov		eax,[esp+4]
-		mov		bx,[eax+dep_w_mask]
-		cmp		bx,7fffh
-		jnz		longest_match_c
 
         push    ebp
         push    edi
@@ -106,39 +108,49 @@ _longest_match_asm7fff proc near
 
         sub     esp,NbStackAdd
 
-		;//mov		ebp,str_s
+; initialize or check the variables used in match.asm.
-		mov		ebp,eax
+        mov     ebp,edx
 
-		mov		eax,[ebp+dep_max_chain_length]
+; chain_length = s->max_chain_length
+; if (prev_length>=good_match) chain_length >>= 2
+        mov     edx,[ebp+dep_chain_length]
         mov     ebx,[ebp+dep_prev_length]
-		cmp		[ebp+dep_good_match],ebx	; if prev_length>=good_match chain_length >>= 2
+        cmp     [ebp+dep_good_match],ebx
         ja      noshr
-		shr		eax,2
+        shr     edx,2
 noshr:
+; we increment chain_length because in the asm, the --chain_lenght is in the beginning of the loop
+        inc     edx
         mov     edi,[ebp+dep_nice_match]
-		mov		chain_length,eax
+        mov     chain_length,edx
-		mov		edx,[ebp+dep_lookahead]
+        mov     eax,[ebp+dep_lookahead]
-		cmp		edx,edi
+        cmp     eax,edi
 ; if ((uInt)nice_match > s->lookahead) nice_match = s->lookahead;
         jae     nolookaheadnicematch
-		mov		edi,edx
+        mov     edi,eax
 nolookaheadnicematch:
+; best_len = s->prev_length
         mov     best_len,ebx
 
-
+; window = s->window
         mov     esi,[ebp+dep_window]
         mov     ecx,[ebp+dep_strstart]
         mov     window,esi
 
         mov     nice_match,edi
+; scan = window + strstart
         add     esi,ecx
-		mov		scanrp,esi
+        mov     scan,esi
-		mov		ax,word ptr [esi]
+; dx = *window
+        mov     dx,word ptr [esi]
+; bx = *(window+best_len-1)
         mov     bx,word ptr [esi+ebx-1]
         add     esi,MAX_MATCH-1
-		mov		scan_start,ax
+; scan_start = *scan
+        mov     scan_start,dx
+; strend = scan + MAX_MATCH-1
         mov     strend,esi
-		mov		scan_end,bx
+; bx = scan_end = *(window+best_len-1)
 
 ;    IPos limit = s->strstart > (IPos)MAX_DIST(s) ?
 ;        s->strstart - (IPos)MAX_DIST(s) : NIL;
@@ -152,80 +164,90 @@ nolookaheadnicematch:
 nodist:
         mov     limit,ecx
 
+; prev = s->prev
+        mov     edx,[ebp+dep_prev]
+        mov     prev,edx
 
-
+;
-
+        mov     edx,dword ptr [ebp+dep_match_start]
-		mov		eax,[ebp+dep_prev]
-		mov		prev,eax
-
-	    mov     ebx,dword ptr [ebp+dep_match_start]
         mov     bp,scan_start
-	    mov     edx,cur_match
+        mov     eax,cur_match
-	    mov     match_start,ebx
+        mov     match_start,edx
 
-	    mov     bx,scan_end
+        mov     edx,window
-	    mov     eax,window
+        mov     edi,edx
-		mov		edi,eax
         add     edi,best_len
         mov     esi,prev
         dec     edi
+; windowlen = window + best_len -1
         mov     windowlen,edi
 
         jmp     beginloop2
         align   4
 
 ; here, in the loop
-;;;;       eax = chain_length
+;       eax = ax = cur_match
-;       edx = dx = cur_match
 ;       ecx = limit
 ;        bx = scan_end
 ;        bp = scan_start
-;       edi = windowlen (window + best_len)
+;       edi = windowlen (window + best_len -1)
 ;       esi = prev
 
 
-;// here; eax <=16
+;// here; chain_length <=16
 normalbeg0add16:
         add     chain_length,16
         jz      exitloop
 normalbeg0:
-	    cmp     word ptr[edi+edx-0],bx
+        cmp     word ptr[edi+eax],bx
-	    je      normalbeg2
+        je      normalbeg2noroll
-	    and     edx,7fffh
+rcontlabnoroll:
-	    mov     dx,word ptr[esi+edx*2]
+; cur_match = prev[cur_match & wmask]
-	    cmp     ecx,edx
+        and     eax,7fffh
+        mov     ax,word ptr[esi+eax*2]
+; if cur_match > limit, go to exitloop
+        cmp     ecx,eax
         jnb     exitloop
+; if --chain_length != 0, go to exitloop
         dec     chain_length
         jnz     normalbeg0
-;jnbexitloopshort1:
         jmp     exitloop
 
+normalbeg2noroll:
+; if (scan_start==*(cur_match+window)) goto normalbeg2
+        cmp     bp,word ptr[edx+eax]
+        jne     rcontlabnoroll
+        jmp     normalbeg2
+
 contloop3:
         mov     edi,windowlen
 
 ; cur_match = prev[cur_match & wmask]
-	    and		edx,7fffh
+        and     eax,7fffh
-	    mov     dx,word ptr[esi+edx*2]
+        mov     ax,word ptr[esi+eax*2]
 ; if cur_match > limit, go to exitloop
-	    cmp     ecx,edx
+        cmp     ecx,eax
 jnbexitloopshort1:
         jnb     exitloop
 ; if --chain_length != 0, go to exitloop
 
+
+; begin the main loop
 beginloop2:
         sub     chain_length,16+1
+; if chain_length <=16, don't use the unrolled loop
         jna     normalbeg0add16
 
 do16:
-	    cmp     word ptr[edi+edx],bx
+        cmp     word ptr[edi+eax],bx
         je      normalbeg2dc0
 
 maccn   MACRO   lab
-	    and     edx,7fffh
+        and     eax,7fffh
-	    mov     dx,word ptr[esi+edx*2]
+        mov     ax,word ptr[esi+eax*2]
-	    cmp     ecx,edx
+        cmp     ecx,eax
         jnb     exitloop
-	    cmp     word ptr[edi+edx-0],bx
+        cmp     word ptr[edi+eax],bx
         je      lab
         ENDM
 
@@ -260,7 +282,7 @@ rcontloop9:
         maccn   normalbeg2dc10
 
 rcontloop10:
-		maccn normalbeg2dc11
+        maccn   short normalbeg2dc11
 
 rcontloop11:
         maccn   short normalbeg2dc12
@@ -275,10 +297,10 @@ rcontloop14:
         maccn   short normalbeg2dc15
 
 rcontloop15:
-	    and     edx,7fffh
+        and     eax,7fffh
-	    mov     dx,word ptr[esi+edx*2]
+        mov     ax,word ptr[esi+eax*2]
-	    cmp     ecx,edx
+        cmp     ecx,eax
-	    jnb     short exitloopshort
+        jnb     exitloop
 
         sub     chain_length,16
         ja      do16
@@ -286,35 +308,35 @@ rcontloop15:
 
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
-exitloopshort:
-		jmp		exitloop                  
-
 normbeg MACRO   rcontlab,valsub
-	    cmp     bp,word ptr[eax+edx]
+; if we are here, we know that *(match+best_len-1) == scan_end
+        cmp     bp,word ptr[edx+eax]
+; if (match != scan_start) goto rcontlab
         jne     rcontlab
+; calculate the good chain_length, and we'll compare scan and match string
         add     chain_length,16-valsub
         jmp     iseq
         ENDM
 
-normalbeg2dc12:
-		normbeg	rcontloop12,12
-
-normalbeg2dc13:
-		normbeg	rcontloop13,13
-
-normalbeg2dc14:
-		normbeg	rcontloop14,14
-
-normalbeg2dc15:
-		normbeg	rcontloop15,15
 
 normalbeg2dc11:
         normbeg rcontloop11,11
 
+normalbeg2dc12:
+        normbeg short rcontloop12,12
+
+normalbeg2dc13:
+        normbeg short rcontloop13,13
+
+normalbeg2dc14:
+        normbeg short rcontloop14,14
+
+normalbeg2dc15:
+        normbeg short rcontloop15,15
+
 normalbeg2dc10:
         normbeg rcontloop10,10
 
-
 normalbeg2dc9:
         normbeg rcontloop9,9
 
@@ -324,16 +346,12 @@ normalbeg2dc8:
 normalbeg2dc7:
         normbeg rcontloop7,7
 
-normalbeg2dc5:
-		normbeg	rcontloop5,5
-
-
-
-
-
 normalbeg2dc6:
         normbeg rcontloop6,6
 
+normalbeg2dc5:
+        normbeg rcontloop5,5
+
 normalbeg2dc4:
         normbeg rcontloop4,4
 
@@ -353,39 +371,37 @@ normalbeg2dc0:
 ; we go in normalbeg2 because *(ushf*)(match+best_len-1) == scan_end
 
 normalbeg2:
-
-			 ; 10 nop here take 10% time
         mov     edi,window
-		  ;mov     chain_length,eax    ; now, we need eax...
 
-	    cmp     bp,word ptr[edi+edx]
+        cmp     bp,word ptr[edi+eax]
         jne     contloop3                   ; if *(ushf*)match != scan_start, continue
 
 iseq:
+; if we are here, we know that *(match+best_len-1) == scan_end
+; and (match == scan_start)
 
-		mov		edi,eax
+        mov     edi,edx
-	    mov     esi,scanrp                  ; esi = scan    
+        mov     esi,scan                    ; esi = scan
-	    add     edi,edx				; edi = window + cur_match = match
+        add     edi,eax                     ; edi = window + cur_match = match
 
-		       
+        mov     edx,[esi+3]                 ; compare manually dword at match+3
-	    mov     eax,[esi+3]					; compare manually dword at match+3
+        xor     edx,[edi+3]                 ; and scan +3
-	    xor     eax,[edi+3]                 ;       and scan +3
 
         jz      begincompare                ; if equal, go to long compare
 
 ; we will determine the unmatch byte and calculate len (in esi)
-		or		al,al
+        or      dl,dl
         je      eq1rr
         mov     esi,3
         jmp     trfinval
 eq1rr:
-	    or      ax,ax                               
+        or      dx,dx
         je      eq1
 
         mov     esi,4
         jmp     trfinval
 eq1:
-	    shl     eax,8
+        and     edx,0ffffffh
         jz      eq11
         mov     esi,5
         jmp     trfinval
@@ -397,69 +413,147 @@ begincompare:
         ; here we now scan and match begin same
         add     edi,6
         add     esi,6
-	    mov     ecx,(MAX_MATCH-(2+4))/4     ;//; scan for at most MAX_MATCH bytes
+        mov     ecx,(MAX_MATCH-(2+4))/4     ; scan for at most MAX_MATCH bytes
-	    repe    cmpsd                                               ;//; loop until mismatch
+        repe    cmpsd                       ; loop until mismatch
 
         je      trfin                       ; go to trfin if not unmatch
 ; we determine the unmatch byte
         sub     esi,4
-	    mov     eax,[edi-4]
+        mov     edx,[edi-4]
-	    xor     eax,[esi]
+        xor     edx,[esi]
-	    or      al,al
 
+        or      dl,dl
         jnz     trfin
         inc     esi
 
-	    or      ax,ax
+        or      dx,dx
         jnz     trfin
         inc     esi
 
-	    shl     eax,8           
+        and     edx,0ffffffh
         jnz     trfin
         inc     esi
 
 trfin:
-	    sub     esi,scanrp          ; esi = len
+        sub     esi,scan          ; esi = len
 trfinval:
-	    cmp     esi,best_len        ; if len <= best_len, go contloop2
+; here we have finised compare, and esi contain len of equal string
-	    jbe     contloop2
+        cmp     esi,best_len        ; if len > best_len, go newbestlen
-
+        ja      short newbestlen
-	    mov     best_len,esi        ; len become best_len
+; now we restore edx, ecx and esi, for the big loop
-
+        mov     esi,prev
-	    mov     match_start,edx
+        mov     ecx,limit
-	    cmp     esi,nice_match ;//; if esi >= nice_match, exit
+        mov     edx,window
-	    mov     ecx,scanrp
+        jmp     contloop3
-	    jae     exitloop
+
-	    add     esi,window
+newbestlen:
-	    add     ecx,best_len
+        mov     best_len,esi        ; len become best_len
-			dec             esi
+
-	    mov     windowlen,esi
+        mov     match_start,eax     ; save new position as match_start
-	    mov     bx,[ecx-1]
+        cmp     esi,nice_match      ; if best_len >= nice_match, exit
-
+        jae     exitloop
-
+        mov     ecx,scan
-; now we restore eax, ecx and esi, for the big loop :
+        mov     edx,window          ; restore edx=window
-contloop2:
+        add     ecx,esi
+        add     esi,edx
+
+        dec     esi
+        mov     windowlen,esi       ; windowlen = window + best_len-1
+        mov     bx,[ecx-1]          ; bx = *(scan+best_len-1) = scan_end
+
+; now we restore ecx and esi, for the big loop :
         mov     esi,prev
         mov     ecx,limit
-	    ;mov     eax,chain_length
-		mov		eax,window
         jmp     contloop3
 
 exitloop:
+; exit : s->match_start=match_start
         mov     ebx,match_start
         mov     ebp,str_s
+        mov     ecx,best_len
         mov     dword ptr [ebp+dep_match_start],ebx        
-	    mov     eax,best_len
+        mov     eax,dword ptr [ebp+dep_lookahead]
-	    add     esp,NbStackAdd
+        cmp     ecx,eax
+        ja      minexlo
+        mov     eax,ecx
+minexlo:
+; return min(best_len,s->lookahead)
         
+; restore stack and register ebx,esi,edi,ebp
+        add     esp,NbStackAdd
 
         pop     ebx
         pop     esi
         pop     edi
         pop     ebp
         ret
+InfoAuthor:
+; please don't remove this string !
+; Your are free use gvmat32 in any fre or commercial apps if you don't remove the string in the binary!
+        db     0dh,0ah,"GVMat32 optimised assembly code written 1996-98 by Gilles Vollant",0dh,0ah
 
-_longest_match_asm7fff endp
+
+
+IFDEF NOUNDERLINE
+longest_match_7fff   endp
+ELSE
+_longest_match_7fff  endp
+ENDIF
+
+
+IFDEF NOUNDERLINE
+cpudetect32     proc near
+ELSE
+_cpudetect32    proc near
+ENDIF
+
+
+	pushfd                  ; push original EFLAGS
+	pop     eax             ; get original EFLAGS
+	mov     ecx, eax        ; save original EFLAGS
+	xor     eax, 40000h     ; flip AC bit in EFLAGS
+	push    eax             ; save new EFLAGS value on stack
+	popfd                   ; replace current EFLAGS value
+	pushfd                  ; get new EFLAGS
+	pop     eax             ; store new EFLAGS in EAX
+	xor     eax, ecx        ; can’t toggle AC bit, processor=80386
+	jz      end_cpu_is_386  ; jump if 80386 processor
+	push    ecx
+	popfd                   ; restore AC bit in EFLAGS first
+
+	pushfd
+	pushfd
+	pop     ecx
+			
+	mov     eax, ecx        ; get original EFLAGS
+	xor     eax, 200000h    ; flip ID bit in EFLAGS
+	push    eax             ; save new EFLAGS value on stack
+	popfd                   ; replace current EFLAGS value
+	pushfd                  ; get new EFLAGS
+	pop		eax	            ; store new EFLAGS in EAX
+	popfd                   ; restore original EFLAGS
+	xor		eax, ecx        ; can’t toggle ID bit,
+	je		is_old_486		; processor=old
+
+	mov     eax,1
+	db      0fh,0a2h        ;CPUID   
+
+exitcpudetect:
+	ret
+
+end_cpu_is_386:
+	mov     eax,0300h
+	jmp     exitcpudetect
+
+is_old_486:
+	mov     eax,0400h
+	jmp     exitcpudetect
+
+IFDEF NOUNDERLINE
+cpudetect32     endp
+ELSE
+_cpudetect32    endp
+ENDIF
 
 _TEXT   ends
 end

contrib/asm386/gvmat32c.c

@@ -7,7 +7,6 @@
  *     (assembly code is faster with a fixed wmask)
  *
  */
-//#pragma optimize("agt",on)
 
 #include "deflate.h"
 
@@ -15,65 +14,31 @@
 #include <windows.h>
 
 #ifdef ASMV
-
 #define NIL 0
 
-static unsigned int tot=0;
-static unsigned int totl0=0;
-static unsigned int totl0p0=0;
-static unsigned int ba0=0;
-static unsigned int ba1=0;
-static unsigned int cpta=0;
-static unsigned int cptb=0;
-
 #define UNALIGNED_OK
-#define gvshow(a,b,c,d)
-/*
-void gvshow(int chain_length,int len,int limit,ushf* prev)
-{
-static int ival=0;
-char sz[80];
-unsigned long i;
-int prev0=*prev;
-	ival++;
-	//wsprintf(sz,"call %u, len=%u, chain_length=%u\n",ival,len,chain_length);
-	//OutputDebugString(sz);
-	tot++;
-	if (limit==NIL)
-		totl0++;
-	if ((limit==NIL) && (prev0==0))
-		totl0p0++;
-	for (i=limit+1;i<32768;i++)
-	{
-		ush va=*(prev+i);
-		if (ba0>4000000000)
-		{
-			ba0+=10;
-		}
-		ba0++;
-		if ((va>limit) || (va==0))
-			continue;
-		ba1++;
-	}
-}
-*/
 
 
 /* if your C compiler don't add underline before function name,
 		define ADD_UNDERLINE_ASMFUNC */
 #ifdef ADD_UNDERLINE_ASMFUNC
-#define longest_match_asm7fff _longest_match_asm7fff
+#define longest_match_7fff _longest_match_7fff
 #endif
+
+
+
 void match_init()
 {
 }
 
+unsigned long cpudetect32();
+
 uInt longest_match_c(
     deflate_state *s,
     IPos cur_match);                             /* current match */
 
 
-uInt longest_match_asm7fff(
+uInt longest_match_7fff(
     deflate_state *s,
     IPos cur_match);                             /* current match */
 
@@ -81,8 +46,14 @@ uInt longest_match(
     deflate_state *s,
     IPos cur_match)                             /* current match */
 {
-    if (s->w_mask == 0x7fff)
+	static uInt iIsPPro=2;
-        return longest_match_asm7fff(s,cur_match);
+
+    if ((s->w_mask == 0x7fff) && (iIsPPro==0))
+        return longest_match_7fff(s,cur_match);
+
+	if (iIsPPro==2)
+		iIsPPro = (((cpudetect32()/0x100)&0xf)>=6) ? 1 : 0;
+
 	return longest_match_c(s,cur_match);
 }
 
@@ -222,7 +193,7 @@ uInt longest_match_c(s, cur_match)
     } while ((cur_match = prev[cur_match & wmask]) > limit
              && --chain_length != 0);
 
-    if ((uInt)best_len <= s->lookahead) return best_len;
+    if ((uInt)best_len <= s->lookahead) return (uInt)best_len;
     return s->lookahead;
 }
 

contrib/asm386/zlibvc.dsp

@@ -0,0 +1,612 @@
+# Microsoft Developer Studio Project File - Name="zlibvc" - Package Owner=<4>
+# Microsoft Developer Studio Generated Build File, Format Version 5.00
+# ** DO NOT EDIT **
+
+# TARGTYPE "Win32 (x86) Dynamic-Link Library" 0x0102
+# TARGTYPE "Win32 (ALPHA) Dynamic-Link Library" 0x0602
+
+CFG=zlibvc - Win32 Release
+!MESSAGE This is not a valid makefile. To build this project using NMAKE,
+!MESSAGE use the Export Makefile command and run
+!MESSAGE 
+!MESSAGE NMAKE /f "zlibvc.mak".
+!MESSAGE 
+!MESSAGE You can specify a configuration when running NMAKE
+!MESSAGE by defining the macro CFG on the command line. For example:
+!MESSAGE 
+!MESSAGE NMAKE /f "zlibvc.mak" CFG="zlibvc - Win32 Release"
+!MESSAGE 
+!MESSAGE Possible choices for configuration are:
+!MESSAGE 
+!MESSAGE "zlibvc - Win32 Release" (based on "Win32 (x86) Dynamic-Link Library")
+!MESSAGE "zlibvc - Win32 Debug" (based on "Win32 (x86) Dynamic-Link Library")
+!MESSAGE "zlibvc - Win32 ReleaseAxp" (based on\
+ "Win32 (ALPHA) Dynamic-Link Library")
+!MESSAGE "zlibvc - Win32 ReleaseWithoutAsm" (based on\
+ "Win32 (x86) Dynamic-Link Library")
+!MESSAGE "zlibvc - Win32 ReleaseWithoutCrtdll" (based on\
+ "Win32 (x86) Dynamic-Link Library")
+!MESSAGE 
+
+# Begin Project
+# PROP Scc_ProjName ""
+# PROP Scc_LocalPath ""
+
+!IF  "$(CFG)" == "zlibvc - Win32 Release"
+
+# PROP BASE Use_MFC 0
+# PROP BASE Use_Debug_Libraries 0
+# PROP BASE Output_Dir ".\Release"
+# PROP BASE Intermediate_Dir ".\Release"
+# PROP BASE Target_Dir ""
+# PROP Use_MFC 0
+# PROP Use_Debug_Libraries 0
+# PROP Output_Dir ".\Release"
+# PROP Intermediate_Dir ".\Release"
+# PROP Ignore_Export_Lib 0
+# PROP Target_Dir ""
+CPP=cl.exe
+# ADD BASE CPP /nologo /MT /W3 /GX /O2 /D "WIN32" /D "NDEBUG" /D "_WINDOWS" /YX /c
+# ADD CPP /nologo /MT /W3 /GX /O2 /D "NDEBUG" /D "WIN32" /D "_WINDOWS" /D "_WINDLL" /D "_WIN32" /D "BUILD_ZLIBDLL" /D "ZLIB_DLL" /D "DYNAMIC_CRC_TABLE" /D "ASMV" /FAcs /FR /YX /FD /c
+MTL=midl.exe
+# ADD BASE MTL /nologo /D "NDEBUG" /win32
+# ADD MTL /nologo /D "NDEBUG" /mktyplib203 /win32
+RSC=rc.exe
+# ADD BASE RSC /l 0x40c /d "NDEBUG"
+# ADD RSC /l 0x40c /d "NDEBUG"
+BSC32=bscmake.exe
+# ADD BASE BSC32 /nologo
+# ADD BSC32 /nologo
+LINK32=link.exe
+# ADD BASE LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /subsystem:windows /dll /machine:I386
+# ADD LINK32 gvmat32.obj kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib crtdll.lib /nologo /subsystem:windows /dll /map /machine:I386 /nodefaultlib /out:".\Release\zlib.dll"
+# SUBTRACT LINK32 /pdb:none
+
+!ELSEIF  "$(CFG)" == "zlibvc - Win32 Debug"
+
+# PROP BASE Use_MFC 0
+# PROP BASE Use_Debug_Libraries 1
+# PROP BASE Output_Dir ".\Debug"
+# PROP BASE Intermediate_Dir ".\Debug"
+# PROP BASE Target_Dir ""
+# PROP Use_MFC 0
+# PROP Use_Debug_Libraries 1
+# PROP Output_Dir ".\Debug"
+# PROP Intermediate_Dir ".\Debug"
+# PROP Target_Dir ""
+CPP=cl.exe
+# ADD BASE CPP /nologo /MTd /W3 /Gm /GX /Zi /Od /D "WIN32" /D "_DEBUG" /D "_WINDOWS" /YX /c
+# ADD CPP /nologo /MTd /W3 /Gm /GX /Zi /Od /D "_DEBUG" /D "WIN32" /D "_WINDOWS" /D "_WINDLL" /D "_WIN32" /D "BUILD_ZLIBDLL" /D "ZLIB_DLL" /YX /FD /c
+MTL=midl.exe
+# ADD BASE MTL /nologo /D "_DEBUG" /win32
+# ADD MTL /nologo /D "_DEBUG" /mktyplib203 /win32
+RSC=rc.exe
+# ADD BASE RSC /l 0x40c /d "_DEBUG"
+# ADD RSC /l 0x40c /d "_DEBUG"
+BSC32=bscmake.exe
+# ADD BASE BSC32 /nologo
+# ADD BSC32 /nologo
+LINK32=link.exe
+# ADD BASE LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /subsystem:windows /dll /debug /machine:I386
+# ADD LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib /nologo /subsystem:windows /dll /debug /machine:I386 /out:".\Debug\zlib.dll"
+
+!ELSEIF  "$(CFG)" == "zlibvc - Win32 ReleaseAxp"
+
+# PROP BASE Use_MFC 0
+# PROP BASE Use_Debug_Libraries 0
+# PROP BASE Output_Dir "zlibvc__"
+# PROP BASE Intermediate_Dir "zlibvc__"
+# PROP BASE Ignore_Export_Lib 0
+# PROP BASE Target_Dir ""
+# PROP Use_MFC 0
+# PROP Use_Debug_Libraries 0
+# PROP Output_Dir "zlibvc__"
+# PROP Intermediate_Dir "zlibvc__"
+# PROP Ignore_Export_Lib 0
+# PROP Target_Dir ""
+MTL=midl.exe
+# ADD BASE MTL /nologo /D "NDEBUG" /mktyplib203 /win32
+# ADD MTL /nologo /D "NDEBUG" /mktyplib203 /win32
+CPP=cl.exe
+# ADD BASE CPP /nologo /MT /Gt0 /W3 /GX /O2 /D "WIN32" /D "NDEBUG" /D "_WINDOWS" /D "_WIN32" /D "BUILD_ZLIBDLL" /D "ZLIB_DLL" /D "DYNAMIC_CRC_TABLE" /FAcs /FR /YX /FD /c
+# ADD CPP /nologo /MT /Gt0 /W3 /GX /O2 /D "WIN32" /D "NDEBUG" /D "_WINDOWS" /D "_WIN32" /D "BUILD_ZLIBDLL" /D "ZLIB_DLL" /D "DYNAMIC_CRC_TABLE" /FAcs /FR /YX /FD /c
+RSC=rc.exe
+# ADD BASE RSC /l 0x40c /d "NDEBUG"
+# ADD RSC /l 0x40c /d "NDEBUG"
+BSC32=bscmake.exe
+# ADD BASE BSC32 /nologo
+# ADD BSC32 /nologo
+LINK32=link.exe
+# ADD BASE LINK32 crtdll.lib kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib /nologo /subsystem:windows /dll /map /machine:ALPHA /nodefaultlib /out:".\Release\zlib.dll"
+# SUBTRACT BASE LINK32 /pdb:none
+# ADD LINK32 crtdll.lib kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib /nologo /subsystem:windows /dll /map /machine:ALPHA /nodefaultlib /out:"zlibvc__\zlib.dll"
+# SUBTRACT LINK32 /pdb:none
+
+!ELSEIF  "$(CFG)" == "zlibvc - Win32 ReleaseWithoutAsm"
+
+# PROP BASE Use_MFC 0
+# PROP BASE Use_Debug_Libraries 0
+# PROP BASE Output_Dir "zlibvc_0"
+# PROP BASE Intermediate_Dir "zlibvc_0"
+# PROP BASE Ignore_Export_Lib 0
+# PROP BASE Target_Dir ""
+# PROP Use_MFC 0
+# PROP Use_Debug_Libraries 0
+# PROP Output_Dir "zlibvc_0"
+# PROP Intermediate_Dir "zlibvc_0"
+# PROP Ignore_Export_Lib 0
+# PROP Target_Dir ""
+CPP=cl.exe
+# ADD BASE CPP /nologo /MT /W3 /GX /O2 /D "NDEBUG" /D "WIN32" /D "_WINDOWS" /D "_WINDLL" /D "_WIN32" /D "BUILD_ZLIBDLL" /D "ZLIB_DLL" /D "DYNAMIC_CRC_TABLE" /FAcs /FR /YX /FD /c
+# ADD CPP /nologo /MT /W3 /GX /O2 /D "NDEBUG" /D "WIN32" /D "_WINDOWS" /D "_WINDLL" /D "_WIN32" /D "BUILD_ZLIBDLL" /D "ZLIB_DLL" /D "DYNAMIC_CRC_TABLE" /FAcs /FR /YX /FD /c
+MTL=midl.exe
+# ADD BASE MTL /nologo /D "NDEBUG" /mktyplib203 /win32
+# ADD MTL /nologo /D "NDEBUG" /mktyplib203 /win32
+RSC=rc.exe
+# ADD BASE RSC /l 0x40c /d "NDEBUG"
+# ADD RSC /l 0x40c /d "NDEBUG"
+BSC32=bscmake.exe
+# ADD BASE BSC32 /nologo
+# ADD BSC32 /nologo
+LINK32=link.exe
+# ADD BASE LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib crtdll.lib /nologo /subsystem:windows /dll /map /machine:I386 /nodefaultlib /out:".\Release\zlib.dll"
+# SUBTRACT BASE LINK32 /pdb:none
+# ADD LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib crtdll.lib /nologo /subsystem:windows /dll /map /machine:I386 /nodefaultlib /out:".\zlibvc_0\zlib.dll"
+# SUBTRACT LINK32 /pdb:none
+
+!ELSEIF  "$(CFG)" == "zlibvc - Win32 ReleaseWithoutCrtdll"
+
+# PROP BASE Use_MFC 0
+# PROP BASE Use_Debug_Libraries 0
+# PROP BASE Output_Dir "zlibvc_1"
+# PROP BASE Intermediate_Dir "zlibvc_1"
+# PROP BASE Ignore_Export_Lib 0
+# PROP BASE Target_Dir ""
+# PROP Use_MFC 0
+# PROP Use_Debug_Libraries 0
+# PROP Output_Dir "zlibvc_1"
+# PROP Intermediate_Dir "zlibvc_1"
+# PROP Ignore_Export_Lib 0
+# PROP Target_Dir ""
+CPP=cl.exe
+# ADD BASE CPP /nologo /MT /W3 /GX /O2 /D "NDEBUG" /D "WIN32" /D "_WINDOWS" /D "_WINDLL" /D "_WIN32" /D "BUILD_ZLIBDLL" /D "ZLIB_DLL" /D "DYNAMIC_CRC_TABLE" /D "ASMV" /FAcs /FR /YX /FD /c
+# ADD CPP /nologo /MT /W3 /GX /O2 /D "NDEBUG" /D "WIN32" /D "_WINDOWS" /D "_WINDLL" /D "_WIN32" /D "BUILD_ZLIBDLL" /D "ZLIB_DLL" /D "DYNAMIC_CRC_TABLE" /D "ASMV" /FAcs /FR /YX /FD /c
+MTL=midl.exe
+# ADD BASE MTL /nologo /D "NDEBUG" /mktyplib203 /win32
+# ADD MTL /nologo /D "NDEBUG" /mktyplib203 /win32
+RSC=rc.exe
+# ADD BASE RSC /l 0x40c /d "NDEBUG"
+# ADD RSC /l 0x40c /d "NDEBUG"
+BSC32=bscmake.exe
+# ADD BASE BSC32 /nologo
+# ADD BSC32 /nologo
+LINK32=link.exe
+# ADD BASE LINK32 gvmat32.obj kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib crtdll.lib /nologo /subsystem:windows /dll /map /machine:I386 /nodefaultlib /out:".\Release\zlib.dll"
+# SUBTRACT BASE LINK32 /pdb:none
+# ADD LINK32 gvmat32.obj kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib crtdll.lib /nologo /subsystem:windows /dll /map /machine:I386 /nodefaultlib /out:".\zlibvc_1\zlib.dll"
+# SUBTRACT LINK32 /pdb:none
+
+!ENDIF 
+
+# Begin Target
+
+# Name "zlibvc - Win32 Release"
+# Name "zlibvc - Win32 Debug"
+# Name "zlibvc - Win32 ReleaseAxp"
+# Name "zlibvc - Win32 ReleaseWithoutAsm"
+# Name "zlibvc - Win32 ReleaseWithoutCrtdll"
+# Begin Group "Source Files"
+
+# PROP Default_Filter "cpp;c;cxx;rc;def;r;odl;hpj;bat;for;f90"
+# Begin Source File
+
+SOURCE=.\adler32.c
+
+!IF  "$(CFG)" == "zlibvc - Win32 Release"
+
+!ELSEIF  "$(CFG)" == "zlibvc - Win32 Debug"
+
+!ELSEIF  "$(CFG)" == "zlibvc - Win32 ReleaseAxp"
+
+DEP_CPP_ADLER=\
+	".\zconf.h"\
+	".\zlib.h"\
+	
+
+!ELSEIF  "$(CFG)" == "zlibvc - Win32 ReleaseWithoutAsm"
+
+!ELSEIF  "$(CFG)" == "zlibvc - Win32 ReleaseWithoutCrtdll"
+
+!ENDIF 
+
+# End Source File
+# Begin Source File
+
+SOURCE=.\compress.c
+
+!IF  "$(CFG)" == "zlibvc - Win32 Release"
+
+!ELSEIF  "$(CFG)" == "zlibvc - Win32 Debug"
+
+!ELSEIF  "$(CFG)" == "zlibvc - Win32 ReleaseAxp"
+
+DEP_CPP_COMPR=\
+	".\zconf.h"\
+	".\zlib.h"\
+	
+
+!ELSEIF  "$(CFG)" == "zlibvc - Win32 ReleaseWithoutAsm"
+
+!ELSEIF  "$(CFG)" == "zlibvc - Win32 ReleaseWithoutCrtdll"
+
+!ENDIF 
+
+# End Source File
+# Begin Source File
+
+SOURCE=.\crc32.c
+
+!IF  "$(CFG)" == "zlibvc - Win32 Release"
+
+!ELSEIF  "$(CFG)" == "zlibvc - Win32 Debug"
+
+!ELSEIF  "$(CFG)" == "zlibvc - Win32 ReleaseAxp"
+
+DEP_CPP_CRC32=\
+	".\zconf.h"\
+	".\zlib.h"\
+	
+
+!ELSEIF  "$(CFG)" == "zlibvc - Win32 ReleaseWithoutAsm"
+
+!ELSEIF  "$(CFG)" == "zlibvc - Win32 ReleaseWithoutCrtdll"
+
+!ENDIF 
+
+# End Source File
+# Begin Source File
+
+SOURCE=.\deflate.c
+
+!IF  "$(CFG)" == "zlibvc - Win32 Release"
+
+!ELSEIF  "$(CFG)" == "zlibvc - Win32 Debug"
+
+!ELSEIF  "$(CFG)" == "zlibvc - Win32 ReleaseAxp"
+
+DEP_CPP_DEFLA=\
+	".\deflate.h"\
+	".\zconf.h"\
+	".\zlib.h"\
+	".\zutil.h"\
+	
+
+!ELSEIF  "$(CFG)" == "zlibvc - Win32 ReleaseWithoutAsm"
+
+!ELSEIF  "$(CFG)" == "zlibvc - Win32 ReleaseWithoutCrtdll"
+
+!ENDIF 
+
+# End Source File
+# Begin Source File
+
+SOURCE=.\gvmat32c.c
+
+!IF  "$(CFG)" == "zlibvc - Win32 Release"
+
+!ELSEIF  "$(CFG)" == "zlibvc - Win32 Debug"
+
+!ELSEIF  "$(CFG)" == "zlibvc - Win32 ReleaseAxp"
+
+!ELSEIF  "$(CFG)" == "zlibvc - Win32 ReleaseWithoutAsm"
+
+!ELSEIF  "$(CFG)" == "zlibvc - Win32 ReleaseWithoutCrtdll"
+
+!ENDIF 
+
+# End Source File
+# Begin Source File
+
+SOURCE=.\gzio.c
+
+!IF  "$(CFG)" == "zlibvc - Win32 Release"
+
+!ELSEIF  "$(CFG)" == "zlibvc - Win32 Debug"
+
+!ELSEIF  "$(CFG)" == "zlibvc - Win32 ReleaseAxp"
+
+DEP_CPP_GZIO_=\
+	".\zconf.h"\
+	".\zlib.h"\
+	".\zutil.h"\
+	
+
+!ELSEIF  "$(CFG)" == "zlibvc - Win32 ReleaseWithoutAsm"
+
+!ELSEIF  "$(CFG)" == "zlibvc - Win32 ReleaseWithoutCrtdll"
+
+!ENDIF 
+
+# End Source File
+# Begin Source File
+
+SOURCE=.\infblock.c
+
+!IF  "$(CFG)" == "zlibvc - Win32 Release"
+
+!ELSEIF  "$(CFG)" == "zlibvc - Win32 Debug"
+
+!ELSEIF  "$(CFG)" == "zlibvc - Win32 ReleaseAxp"
+
+DEP_CPP_INFBL=\
+	".\infblock.h"\
+	".\infcodes.h"\
+	".\inftrees.h"\
+	".\infutil.h"\
+	".\zconf.h"\
+	".\zlib.h"\
+	".\zutil.h"\
+	
+
+!ELSEIF  "$(CFG)" == "zlibvc - Win32 ReleaseWithoutAsm"
+
+!ELSEIF  "$(CFG)" == "zlibvc - Win32 ReleaseWithoutCrtdll"
+
+!ENDIF 
+
+# End Source File
+# Begin Source File
+
+SOURCE=.\infcodes.c
+
+!IF  "$(CFG)" == "zlibvc - Win32 Release"
+
+!ELSEIF  "$(CFG)" == "zlibvc - Win32 Debug"
+
+!ELSEIF  "$(CFG)" == "zlibvc - Win32 ReleaseAxp"
+
+DEP_CPP_INFCO=\
+	".\infblock.h"\
+	".\infcodes.h"\
+	".\inffast.h"\
+	".\inftrees.h"\
+	".\infutil.h"\
+	".\zconf.h"\
+	".\zlib.h"\
+	".\zutil.h"\
+	
+
+!ELSEIF  "$(CFG)" == "zlibvc - Win32 ReleaseWithoutAsm"
+
+!ELSEIF  "$(CFG)" == "zlibvc - Win32 ReleaseWithoutCrtdll"
+
+!ENDIF 
+
+# End Source File
+# Begin Source File
+
+SOURCE=.\inffast.c
+
+!IF  "$(CFG)" == "zlibvc - Win32 Release"
+
+!ELSEIF  "$(CFG)" == "zlibvc - Win32 Debug"
+
+!ELSEIF  "$(CFG)" == "zlibvc - Win32 ReleaseAxp"
+
+DEP_CPP_INFFA=\
+	".\infblock.h"\
+	".\infcodes.h"\
+	".\inffast.h"\
+	".\inftrees.h"\
+	".\infutil.h"\
+	".\zconf.h"\
+	".\zlib.h"\
+	".\zutil.h"\
+	
+
+!ELSEIF  "$(CFG)" == "zlibvc - Win32 ReleaseWithoutAsm"
+
+!ELSEIF  "$(CFG)" == "zlibvc - Win32 ReleaseWithoutCrtdll"
+
+!ENDIF 
+
+# End Source File
+# Begin Source File
+
+SOURCE=.\inflate.c
+
+!IF  "$(CFG)" == "zlibvc - Win32 Release"
+
+!ELSEIF  "$(CFG)" == "zlibvc - Win32 Debug"
+
+!ELSEIF  "$(CFG)" == "zlibvc - Win32 ReleaseAxp"
+
+DEP_CPP_INFLA=\
+	".\infblock.h"\
+	".\zconf.h"\
+	".\zlib.h"\
+	".\zutil.h"\
+	
+
+!ELSEIF  "$(CFG)" == "zlibvc - Win32 ReleaseWithoutAsm"
+
+!ELSEIF  "$(CFG)" == "zlibvc - Win32 ReleaseWithoutCrtdll"
+
+!ENDIF 
+
+# End Source File
+# Begin Source File
+
+SOURCE=.\inftrees.c
+
+!IF  "$(CFG)" == "zlibvc - Win32 Release"
+
+!ELSEIF  "$(CFG)" == "zlibvc - Win32 Debug"
+
+!ELSEIF  "$(CFG)" == "zlibvc - Win32 ReleaseAxp"
+
+DEP_CPP_INFTR=\
+	".\inftrees.h"\
+	".\zconf.h"\
+	".\zlib.h"\
+	".\zutil.h"\
+	
+
+!ELSEIF  "$(CFG)" == "zlibvc - Win32 ReleaseWithoutAsm"
+
+!ELSEIF  "$(CFG)" == "zlibvc - Win32 ReleaseWithoutCrtdll"
+
+!ENDIF 
+
+# End Source File
+# Begin Source File
+
+SOURCE=.\infutil.c
+
+!IF  "$(CFG)" == "zlibvc - Win32 Release"
+
+!ELSEIF  "$(CFG)" == "zlibvc - Win32 Debug"
+
+!ELSEIF  "$(CFG)" == "zlibvc - Win32 ReleaseAxp"
+
+DEP_CPP_INFUT=\
+	".\infblock.h"\
+	".\infcodes.h"\
+	".\inftrees.h"\
+	".\infutil.h"\
+	".\zconf.h"\
+	".\zlib.h"\
+	".\zutil.h"\
+	
+
+!ELSEIF  "$(CFG)" == "zlibvc - Win32 ReleaseWithoutAsm"
+
+!ELSEIF  "$(CFG)" == "zlibvc - Win32 ReleaseWithoutCrtdll"
+
+!ENDIF 
+
+# End Source File
+# Begin Source File
+
+SOURCE=.\trees.c
+
+!IF  "$(CFG)" == "zlibvc - Win32 Release"
+
+!ELSEIF  "$(CFG)" == "zlibvc - Win32 Debug"
+
+!ELSEIF  "$(CFG)" == "zlibvc - Win32 ReleaseAxp"
+
+DEP_CPP_TREES=\
+	".\deflate.h"\
+	".\zconf.h"\
+	".\zlib.h"\
+	".\zutil.h"\
+	
+
+!ELSEIF  "$(CFG)" == "zlibvc - Win32 ReleaseWithoutAsm"
+
+!ELSEIF  "$(CFG)" == "zlibvc - Win32 ReleaseWithoutCrtdll"
+
+!ENDIF 
+
+# End Source File
+# Begin Source File
+
+SOURCE=.\uncompr.c
+
+!IF  "$(CFG)" == "zlibvc - Win32 Release"
+
+!ELSEIF  "$(CFG)" == "zlibvc - Win32 Debug"
+
+!ELSEIF  "$(CFG)" == "zlibvc - Win32 ReleaseAxp"
+
+DEP_CPP_UNCOM=\
+	".\zconf.h"\
+	".\zlib.h"\
+	
+
+!ELSEIF  "$(CFG)" == "zlibvc - Win32 ReleaseWithoutAsm"
+
+!ELSEIF  "$(CFG)" == "zlibvc - Win32 ReleaseWithoutCrtdll"
+
+!ENDIF 
+
+# End Source File
+# Begin Source File
+
+SOURCE=.\zlib.rc
+# End Source File
+# Begin Source File
+
+SOURCE=.\zlibvc.def
+# End Source File
+# Begin Source File
+
+SOURCE=.\zutil.c
+
+!IF  "$(CFG)" == "zlibvc - Win32 Release"
+
+!ELSEIF  "$(CFG)" == "zlibvc - Win32 Debug"
+
+!ELSEIF  "$(CFG)" == "zlibvc - Win32 ReleaseAxp"
+
+DEP_CPP_ZUTIL=\
+	".\zconf.h"\
+	".\zlib.h"\
+	".\zutil.h"\
+	
+
+!ELSEIF  "$(CFG)" == "zlibvc - Win32 ReleaseWithoutAsm"
+
+!ELSEIF  "$(CFG)" == "zlibvc - Win32 ReleaseWithoutCrtdll"
+
+!ENDIF 
+
+# End Source File
+# End Group
+# Begin Group "Header Files"
+
+# PROP Default_Filter "h;hpp;hxx;hm;inl;fi;fd"
+# Begin Source File
+
+SOURCE=.\deflate.h
+# End Source File
+# Begin Source File
+
+SOURCE=.\infblock.h
+# End Source File
+# Begin Source File
+
+SOURCE=.\infcodes.h
+# End Source File
+# Begin Source File
+
+SOURCE=.\inffast.h
+# End Source File
+# Begin Source File
+
+SOURCE=.\inftrees.h
+# End Source File
+# Begin Source File
+
+SOURCE=.\infutil.h
+# End Source File
+# Begin Source File
+
+SOURCE=.\zconf.h
+# End Source File
+# Begin Source File
+
+SOURCE=.\zlib.h
+# End Source File
+# Begin Source File
+
+SOURCE=.\zutil.h
+# End Source File
+# End Group
+# Begin Group "Resource Files"
+
+# PROP Default_Filter "ico;cur;bmp;dlg;rc2;rct;bin;cnt;rtf;gif;jpg;jpeg;jpe"
+# End Group
+# End Target
+# End Project

contrib/asm386/zlibvc.dsw

@@ -0,0 +1,29 @@
+Microsoft Developer Studio Workspace File, Format Version 5.00
+# WARNING: DO NOT EDIT OR DELETE THIS WORKSPACE FILE!
+
+###############################################################################
+
+Project: "zlibvc"=".\zlibvc.dsp" - Package Owner=<4>
+
+Package=<5>
+{{{
+}}}
+
+Package=<4>
+{{{
+}}}
+
+###############################################################################
+
+Global:
+
+Package=<5>
+{{{
+}}}
+
+Package=<3>
+{{{
+}}}
+
+###############################################################################
+

contrib/asm386/zlibvc.mak

@@ -1,781 +0,0 @@
-# Microsoft Developer Studio Generated NMAKE File, Format Version 4.20
-# ** DO NOT EDIT **
-
-# TARGTYPE "Win32 (x86) Dynamic-Link Library" 0x0102
-
-!IF "$(CFG)" == ""
-CFG=zlibvc - Win32 Debug
-!MESSAGE No configuration specified.  Defaulting to zlibvc - Win32 Debug.
-!ENDIF 
-
-!IF "$(CFG)" != "zlibvc - Win32 Release" && "$(CFG)" != "zlibvc - Win32 Debug"
-!MESSAGE Invalid configuration "$(CFG)" specified.
-!MESSAGE You can specify a configuration when running NMAKE on this makefile
-!MESSAGE by defining the macro CFG on the command line.  For example:
-!MESSAGE 
-!MESSAGE NMAKE /f "zlibvc.mak" CFG="zlibvc - Win32 Debug"
-!MESSAGE 
-!MESSAGE Possible choices for configuration are:
-!MESSAGE 
-!MESSAGE "zlibvc - Win32 Release" (based on "Win32 (x86) Dynamic-Link Library")
-!MESSAGE "zlibvc - Win32 Debug" (based on "Win32 (x86) Dynamic-Link Library")
-!MESSAGE 
-!ERROR An invalid configuration is specified.
-!ENDIF 
-
-!IF "$(OS)" == "Windows_NT"
-NULL=
-!ELSE 
-NULL=nul
-!ENDIF 
-################################################################################
-# Begin Project
-# PROP Target_Last_Scanned "zlibvc - Win32 Debug"
-CPP=cl.exe
-RSC=rc.exe
-MTL=mktyplib.exe
-
-!IF  "$(CFG)" == "zlibvc - Win32 Release"
-
-# PROP BASE Use_MFC 0
-# PROP BASE Use_Debug_Libraries 0
-# PROP BASE Output_Dir "Release"
-# PROP BASE Intermediate_Dir "Release"
-# PROP BASE Target_Dir ""
-# PROP Use_MFC 0
-# PROP Use_Debug_Libraries 0
-# PROP Output_Dir "Release"
-# PROP Intermediate_Dir "Release"
-# PROP Target_Dir ""
-OUTDIR=.\Release
-INTDIR=.\Release
-
-ALL : "$(OUTDIR)\zlib.dll" "$(OUTDIR)\zlibvc.bsc"
-
-CLEAN : 
-	-@erase "$(INTDIR)\adler32.obj"
-	-@erase "$(INTDIR)\adler32.sbr"
-	-@erase "$(INTDIR)\compress.obj"
-	-@erase "$(INTDIR)\compress.sbr"
-	-@erase "$(INTDIR)\crc32.obj"
-	-@erase "$(INTDIR)\crc32.sbr"
-	-@erase "$(INTDIR)\deflate.obj"
-	-@erase "$(INTDIR)\deflate.sbr"
-	-@erase "$(INTDIR)\gvmat32c.obj"
-	-@erase "$(INTDIR)\gvmat32c.sbr"
-	-@erase "$(INTDIR)\gzio.obj"
-	-@erase "$(INTDIR)\gzio.sbr"
-	-@erase "$(INTDIR)\infblock.obj"
-	-@erase "$(INTDIR)\infblock.sbr"
-	-@erase "$(INTDIR)\infcodes.obj"
-	-@erase "$(INTDIR)\infcodes.sbr"
-	-@erase "$(INTDIR)\inffast.obj"
-	-@erase "$(INTDIR)\inffast.sbr"
-	-@erase "$(INTDIR)\inflate.obj"
-	-@erase "$(INTDIR)\inflate.sbr"
-	-@erase "$(INTDIR)\inftrees.obj"
-	-@erase "$(INTDIR)\inftrees.sbr"
-	-@erase "$(INTDIR)\infutil.obj"
-	-@erase "$(INTDIR)\infutil.sbr"
-	-@erase "$(INTDIR)\trees.obj"
-	-@erase "$(INTDIR)\trees.sbr"
-	-@erase "$(INTDIR)\uncompr.obj"
-	-@erase "$(INTDIR)\uncompr.sbr"
-	-@erase "$(INTDIR)\zlib.res"
-	-@erase "$(INTDIR)\zutil.obj"
-	-@erase "$(INTDIR)\zutil.sbr"
-	-@erase "$(OUTDIR)\zlib.dll"
-	-@erase "$(OUTDIR)\zlib.exp"
-	-@erase "$(OUTDIR)\zlib.lib"
-	-@erase "$(OUTDIR)\zlib.map"
-	-@erase "$(OUTDIR)\zlibvc.bsc"
-
-"$(OUTDIR)" :
-    if not exist "$(OUTDIR)/$(NULL)" mkdir "$(OUTDIR)"
-
-# ADD BASE CPP /nologo /MT /W3 /GX /O2 /D "WIN32" /D "NDEBUG" /D "_WINDOWS" /YX /c
-# ADD CPP /nologo /MT /W3 /GX /O2 /D "NDEBUG" /D fdopen=_fdopen /D "WIN32" /D "_WINDOWS" /D "_WINDLL" /D "_WIN32" /D "BUILD_ZLIBDLL" /D "ZLIB_DLL" /D "ASMV" /FR /YX /c
-CPP_PROJ=/nologo /MT /W3 /GX /O2 /D "NDEBUG" /D fdopen=_fdopen /D "WIN32" /D\
- "_WINDOWS" /D "_WINDLL" /D "_WIN32" /D "BUILD_ZLIBDLL" /D "ZLIB_DLL" /D "ASMV"\
- /FR"$(INTDIR)/" /Fp"$(INTDIR)/zlibvc.pch" /YX /Fo"$(INTDIR)/" /c 
-CPP_OBJS=.\Release/
-CPP_SBRS=.\Release/
-# ADD BASE MTL /nologo /D "NDEBUG" /win32
-# ADD MTL /nologo /D "NDEBUG" /win32
-MTL_PROJ=/nologo /D "NDEBUG" /win32 
-# ADD BASE RSC /l 0x40c /d "NDEBUG"
-# ADD RSC /l 0x40c /d "NDEBUG"
-RSC_PROJ=/l 0x40c /fo"$(INTDIR)/zlib.res" /d "NDEBUG" 
-BSC32=bscmake.exe
-# ADD BASE BSC32 /nologo
-# ADD BSC32 /nologo
-BSC32_FLAGS=/nologo /o"$(OUTDIR)/zlibvc.bsc" 
-BSC32_SBRS= \
-	"$(INTDIR)\adler32.sbr" \
-	"$(INTDIR)\compress.sbr" \
-	"$(INTDIR)\crc32.sbr" \
-	"$(INTDIR)\deflate.sbr" \
-	"$(INTDIR)\gvmat32c.sbr" \
-	"$(INTDIR)\gzio.sbr" \
-	"$(INTDIR)\infblock.sbr" \
-	"$(INTDIR)\infcodes.sbr" \
-	"$(INTDIR)\inffast.sbr" \
-	"$(INTDIR)\inflate.sbr" \
-	"$(INTDIR)\inftrees.sbr" \
-	"$(INTDIR)\infutil.sbr" \
-	"$(INTDIR)\trees.sbr" \
-	"$(INTDIR)\uncompr.sbr" \
-	"$(INTDIR)\zutil.sbr"
-
-"$(OUTDIR)\zlibvc.bsc" : "$(OUTDIR)" $(BSC32_SBRS)
-    $(BSC32) @<<
-  $(BSC32_FLAGS) $(BSC32_SBRS)
-<<
-
-LINK32=link.exe
-# ADD BASE LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /subsystem:windows /dll /machine:I386
-# ADD LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib crtdll.lib /nologo /subsystem:windows /dll /map /machine:I386 /nodefaultlib /out:"Release/zlib.dll"
-LINK32_FLAGS=kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib\
- advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib crtdll.lib /nologo\
- /subsystem:windows /dll /incremental:no /pdb:"$(OUTDIR)/zlib.pdb"\
- /map:"$(INTDIR)/zlib.map" /machine:I386 /nodefaultlib /def:".\zlib.def"\
- /out:"$(OUTDIR)/zlib.dll" /implib:"$(OUTDIR)/zlib.lib" 
-DEF_FILE= \
-	".\zlib.def"
-LINK32_OBJS= \
-	"$(INTDIR)\adler32.obj" \
-	"$(INTDIR)\compress.obj" \
-	"$(INTDIR)\crc32.obj" \
-	"$(INTDIR)\deflate.obj" \
-	"$(INTDIR)\gvmat32c.obj" \
-	"$(INTDIR)\gzio.obj" \
-	"$(INTDIR)\infblock.obj" \
-	"$(INTDIR)\infcodes.obj" \
-	"$(INTDIR)\inffast.obj" \
-	"$(INTDIR)\inflate.obj" \
-	"$(INTDIR)\inftrees.obj" \
-	"$(INTDIR)\infutil.obj" \
-	"$(INTDIR)\trees.obj" \
-	"$(INTDIR)\uncompr.obj" \
-	"$(INTDIR)\zlib.res" \
-	"$(INTDIR)\zutil.obj" \
-	".\GVMAT32.obj"
-
-"$(OUTDIR)\zlib.dll" : "$(OUTDIR)" $(DEF_FILE) $(LINK32_OBJS)
-    $(LINK32) @<<
-  $(LINK32_FLAGS) $(LINK32_OBJS)
-<<
-
-!ELSEIF  "$(CFG)" == "zlibvc - Win32 Debug"
-
-# PROP BASE Use_MFC 0
-# PROP BASE Use_Debug_Libraries 1
-# PROP BASE Output_Dir "Debug"
-# PROP BASE Intermediate_Dir "Debug"
-# PROP BASE Target_Dir ""
-# PROP Use_MFC 0
-# PROP Use_Debug_Libraries 1
-# PROP Output_Dir "Debug"
-# PROP Intermediate_Dir "Debug"
-# PROP Target_Dir ""
-OUTDIR=.\Debug
-INTDIR=.\Debug
-
-ALL : "$(OUTDIR)\zlib.dll"
-
-CLEAN : 
-	-@erase "$(INTDIR)\adler32.obj"
-	-@erase "$(INTDIR)\compress.obj"
-	-@erase "$(INTDIR)\crc32.obj"
-	-@erase "$(INTDIR)\deflate.obj"
-	-@erase "$(INTDIR)\gvmat32c.obj"
-	-@erase "$(INTDIR)\gzio.obj"
-	-@erase "$(INTDIR)\infblock.obj"
-	-@erase "$(INTDIR)\infcodes.obj"
-	-@erase "$(INTDIR)\inffast.obj"
-	-@erase "$(INTDIR)\inflate.obj"
-	-@erase "$(INTDIR)\inftrees.obj"
-	-@erase "$(INTDIR)\infutil.obj"
-	-@erase "$(INTDIR)\trees.obj"
-	-@erase "$(INTDIR)\uncompr.obj"
-	-@erase "$(INTDIR)\vc40.idb"
-	-@erase "$(INTDIR)\vc40.pdb"
-	-@erase "$(INTDIR)\zlib.res"
-	-@erase "$(INTDIR)\zutil.obj"
-	-@erase "$(OUTDIR)\zlib.dll"
-	-@erase "$(OUTDIR)\zlib.exp"
-	-@erase "$(OUTDIR)\zlib.ilk"
-	-@erase "$(OUTDIR)\zlib.lib"
-	-@erase "$(OUTDIR)\zlib.pdb"
-
-"$(OUTDIR)" :
-    if not exist "$(OUTDIR)/$(NULL)" mkdir "$(OUTDIR)"
-
-# ADD BASE CPP /nologo /MTd /W3 /Gm /GX /Zi /Od /D "WIN32" /D "_DEBUG" /D "_WINDOWS" /YX /c
-# ADD CPP /nologo /MTd /W3 /Gm /GX /Zi /Od /D "_DEBUG" /D "WIN32" /D "_WINDOWS" /D "_WINDLL" /D "_WIN32" /D "BUILD_ZLIBDLL" /D "ZLIB_DLL" /YX /c
-CPP_PROJ=/nologo /MTd /W3 /Gm /GX /Zi /Od /D "_DEBUG" /D "WIN32" /D "_WINDOWS"\
- /D "_WINDLL" /D "_WIN32" /D "BUILD_ZLIBDLL" /D "ZLIB_DLL"\
- /Fp"$(INTDIR)/zlibvc.pch" /YX /Fo"$(INTDIR)/" /Fd"$(INTDIR)/" /c 
-CPP_OBJS=.\Debug/
-CPP_SBRS=.\.
-# ADD BASE MTL /nologo /D "_DEBUG" /win32
-# ADD MTL /nologo /D "_DEBUG" /win32
-MTL_PROJ=/nologo /D "_DEBUG" /win32 
-# ADD BASE RSC /l 0x40c /d "_DEBUG"
-# ADD RSC /l 0x40c /d "_DEBUG"
-RSC_PROJ=/l 0x40c /fo"$(INTDIR)/zlib.res" /d "_DEBUG" 
-BSC32=bscmake.exe
-# ADD BASE BSC32 /nologo
-# ADD BSC32 /nologo
-BSC32_FLAGS=/nologo /o"$(OUTDIR)/zlibvc.bsc" 
-BSC32_SBRS= \
-	
-LINK32=link.exe
-# ADD BASE LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /subsystem:windows /dll /debug /machine:I386
-# ADD LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib /nologo /subsystem:windows /dll /debug /machine:I386 /out:"Debug/zlib.dll"
-LINK32_FLAGS=kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib\
- advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib /nologo\
- /subsystem:windows /dll /incremental:yes /pdb:"$(OUTDIR)/zlib.pdb" /debug\
- /machine:I386 /def:".\zlib.def" /out:"$(OUTDIR)/zlib.dll"\
- /implib:"$(OUTDIR)/zlib.lib" 
-DEF_FILE= \
-	".\zlib.def"
-LINK32_OBJS= \
-	"$(INTDIR)\adler32.obj" \
-	"$(INTDIR)\compress.obj" \
-	"$(INTDIR)\crc32.obj" \
-	"$(INTDIR)\deflate.obj" \
-	"$(INTDIR)\gvmat32c.obj" \
-	"$(INTDIR)\gzio.obj" \
-	"$(INTDIR)\infblock.obj" \
-	"$(INTDIR)\infcodes.obj" \
-	"$(INTDIR)\inffast.obj" \
-	"$(INTDIR)\inflate.obj" \
-	"$(INTDIR)\inftrees.obj" \
-	"$(INTDIR)\infutil.obj" \
-	"$(INTDIR)\trees.obj" \
-	"$(INTDIR)\uncompr.obj" \
-	"$(INTDIR)\zlib.res" \
-	"$(INTDIR)\zutil.obj" \
-	".\GVMAT32.obj"
-
-"$(OUTDIR)\zlib.dll" : "$(OUTDIR)" $(DEF_FILE) $(LINK32_OBJS)
-    $(LINK32) @<<
-  $(LINK32_FLAGS) $(LINK32_OBJS)
-<<
-
-!ENDIF 
-
-.c{$(CPP_OBJS)}.obj:
-   $(CPP) $(CPP_PROJ) $<  
-
-.cpp{$(CPP_OBJS)}.obj:
-   $(CPP) $(CPP_PROJ) $<  
-
-.cxx{$(CPP_OBJS)}.obj:
-   $(CPP) $(CPP_PROJ) $<  
-
-.c{$(CPP_SBRS)}.sbr:
-   $(CPP) $(CPP_PROJ) $<  
-
-.cpp{$(CPP_SBRS)}.sbr:
-   $(CPP) $(CPP_PROJ) $<  
-
-.cxx{$(CPP_SBRS)}.sbr:
-   $(CPP) $(CPP_PROJ) $<  
-
-################################################################################
-# Begin Target
-
-# Name "zlibvc - Win32 Release"
-# Name "zlibvc - Win32 Debug"
-
-!IF  "$(CFG)" == "zlibvc - Win32 Release"
-
-!ELSEIF  "$(CFG)" == "zlibvc - Win32 Debug"
-
-!ENDIF 
-
-################################################################################
-# Begin Source File
-
-SOURCE=.\adler32.c
-DEP_CPP_ADLER=\
-	".\zconf.h"\
-	".\zlib.h"\
-	
-
-!IF  "$(CFG)" == "zlibvc - Win32 Release"
-
-
-"$(INTDIR)\adler32.obj" : $(SOURCE) $(DEP_CPP_ADLER) "$(INTDIR)"
-
-"$(INTDIR)\adler32.sbr" : $(SOURCE) $(DEP_CPP_ADLER) "$(INTDIR)"
-
-
-!ELSEIF  "$(CFG)" == "zlibvc - Win32 Debug"
-
-
-"$(INTDIR)\adler32.obj" : $(SOURCE) $(DEP_CPP_ADLER) "$(INTDIR)"
-
-
-!ENDIF 
-
-# End Source File
-################################################################################
-# Begin Source File
-
-SOURCE=.\compress.c
-DEP_CPP_COMPR=\
-	".\zconf.h"\
-	".\zlib.h"\
-	
-
-!IF  "$(CFG)" == "zlibvc - Win32 Release"
-
-
-"$(INTDIR)\compress.obj" : $(SOURCE) $(DEP_CPP_COMPR) "$(INTDIR)"
-
-"$(INTDIR)\compress.sbr" : $(SOURCE) $(DEP_CPP_COMPR) "$(INTDIR)"
-
-
-!ELSEIF  "$(CFG)" == "zlibvc - Win32 Debug"
-
-
-"$(INTDIR)\compress.obj" : $(SOURCE) $(DEP_CPP_COMPR) "$(INTDIR)"
-
-
-!ENDIF 
-
-# End Source File
-################################################################################
-# Begin Source File
-
-SOURCE=.\crc32.c
-DEP_CPP_CRC32=\
-	".\zconf.h"\
-	".\zlib.h"\
-	
-
-!IF  "$(CFG)" == "zlibvc - Win32 Release"
-
-
-"$(INTDIR)\crc32.obj" : $(SOURCE) $(DEP_CPP_CRC32) "$(INTDIR)"
-
-"$(INTDIR)\crc32.sbr" : $(SOURCE) $(DEP_CPP_CRC32) "$(INTDIR)"
-
-
-!ELSEIF  "$(CFG)" == "zlibvc - Win32 Debug"
-
-
-"$(INTDIR)\crc32.obj" : $(SOURCE) $(DEP_CPP_CRC32) "$(INTDIR)"
-
-
-!ENDIF 
-
-# End Source File
-################################################################################
-# Begin Source File
-
-SOURCE=.\deflate.c
-
-!IF  "$(CFG)" == "zlibvc - Win32 Release"
-
-DEP_CPP_DEFLA=\
-	".\deflate.h"\
-	".\zconf.h"\
-	".\zlib.h"\
-	".\zutil.h"\
-	
-
-"$(INTDIR)\deflate.obj" : $(SOURCE) $(DEP_CPP_DEFLA) "$(INTDIR)"
-
-"$(INTDIR)\deflate.sbr" : $(SOURCE) $(DEP_CPP_DEFLA) "$(INTDIR)"
-
-
-!ELSEIF  "$(CFG)" == "zlibvc - Win32 Debug"
-
-DEP_CPP_DEFLA=\
-	".\deflate.h"\
-	".\zconf.h"\
-	".\zlib.h"\
-	".\zutil.h"\
-	
-NODEP_CPP_DEFLA=\
-	".\local"\
-	
-
-"$(INTDIR)\deflate.obj" : $(SOURCE) $(DEP_CPP_DEFLA) "$(INTDIR)"
-
-
-!ENDIF 
-
-# End Source File
-################################################################################
-# Begin Source File
-
-SOURCE=.\gzio.c
-DEP_CPP_GZIO_=\
-	".\zconf.h"\
-	".\zlib.h"\
-	".\zutil.h"\
-	
-
-!IF  "$(CFG)" == "zlibvc - Win32 Release"
-
-
-"$(INTDIR)\gzio.obj" : $(SOURCE) $(DEP_CPP_GZIO_) "$(INTDIR)"
-
-"$(INTDIR)\gzio.sbr" : $(SOURCE) $(DEP_CPP_GZIO_) "$(INTDIR)"
-
-
-!ELSEIF  "$(CFG)" == "zlibvc - Win32 Debug"
-
-
-"$(INTDIR)\gzio.obj" : $(SOURCE) $(DEP_CPP_GZIO_) "$(INTDIR)"
-
-
-!ENDIF 
-
-# End Source File
-################################################################################
-# Begin Source File
-
-SOURCE=.\infblock.c
-DEP_CPP_INFBL=\
-	".\infblock.h"\
-	".\infcodes.h"\
-	".\inftrees.h"\
-	".\infutil.h"\
-	".\zconf.h"\
-	".\zlib.h"\
-	".\zutil.h"\
-	
-
-!IF  "$(CFG)" == "zlibvc - Win32 Release"
-
-
-"$(INTDIR)\infblock.obj" : $(SOURCE) $(DEP_CPP_INFBL) "$(INTDIR)"
-
-"$(INTDIR)\infblock.sbr" : $(SOURCE) $(DEP_CPP_INFBL) "$(INTDIR)"
-
-
-!ELSEIF  "$(CFG)" == "zlibvc - Win32 Debug"
-
-
-"$(INTDIR)\infblock.obj" : $(SOURCE) $(DEP_CPP_INFBL) "$(INTDIR)"
-
-
-!ENDIF 
-
-# End Source File
-################################################################################
-# Begin Source File
-
-SOURCE=.\infcodes.c
-DEP_CPP_INFCO=\
-	".\infblock.h"\
-	".\infcodes.h"\
-	".\inffast.h"\
-	".\inftrees.h"\
-	".\infutil.h"\
-	".\zconf.h"\
-	".\zlib.h"\
-	".\zutil.h"\
-	
-
-!IF  "$(CFG)" == "zlibvc - Win32 Release"
-
-
-"$(INTDIR)\infcodes.obj" : $(SOURCE) $(DEP_CPP_INFCO) "$(INTDIR)"
-
-"$(INTDIR)\infcodes.sbr" : $(SOURCE) $(DEP_CPP_INFCO) "$(INTDIR)"
-
-
-!ELSEIF  "$(CFG)" == "zlibvc - Win32 Debug"
-
-
-"$(INTDIR)\infcodes.obj" : $(SOURCE) $(DEP_CPP_INFCO) "$(INTDIR)"
-
-
-!ENDIF 
-
-# End Source File
-################################################################################
-# Begin Source File
-
-SOURCE=.\inffast.c
-DEP_CPP_INFFA=\
-	".\infblock.h"\
-	".\infcodes.h"\
-	".\inffast.h"\
-	".\inftrees.h"\
-	".\infutil.h"\
-	".\zconf.h"\
-	".\zlib.h"\
-	".\zutil.h"\
-	
-
-!IF  "$(CFG)" == "zlibvc - Win32 Release"
-
-
-"$(INTDIR)\inffast.obj" : $(SOURCE) $(DEP_CPP_INFFA) "$(INTDIR)"
-
-"$(INTDIR)\inffast.sbr" : $(SOURCE) $(DEP_CPP_INFFA) "$(INTDIR)"
-
-
-!ELSEIF  "$(CFG)" == "zlibvc - Win32 Debug"
-
-
-"$(INTDIR)\inffast.obj" : $(SOURCE) $(DEP_CPP_INFFA) "$(INTDIR)"
-
-
-!ENDIF 
-
-# End Source File
-################################################################################
-# Begin Source File
-
-SOURCE=.\inflate.c
-DEP_CPP_INFLA=\
-	".\infblock.h"\
-	".\zconf.h"\
-	".\zlib.h"\
-	".\zutil.h"\
-	
-
-!IF  "$(CFG)" == "zlibvc - Win32 Release"
-
-
-"$(INTDIR)\inflate.obj" : $(SOURCE) $(DEP_CPP_INFLA) "$(INTDIR)"
-
-"$(INTDIR)\inflate.sbr" : $(SOURCE) $(DEP_CPP_INFLA) "$(INTDIR)"
-
-
-!ELSEIF  "$(CFG)" == "zlibvc - Win32 Debug"
-
-
-"$(INTDIR)\inflate.obj" : $(SOURCE) $(DEP_CPP_INFLA) "$(INTDIR)"
-
-
-!ENDIF 
-
-# End Source File
-################################################################################
-# Begin Source File
-
-SOURCE=.\inftrees.c
-DEP_CPP_INFTR=\
-	".\inftrees.h"\
-	".\zconf.h"\
-	".\zlib.h"\
-	".\zutil.h"\
-	
-
-!IF  "$(CFG)" == "zlibvc - Win32 Release"
-
-
-"$(INTDIR)\inftrees.obj" : $(SOURCE) $(DEP_CPP_INFTR) "$(INTDIR)"
-
-"$(INTDIR)\inftrees.sbr" : $(SOURCE) $(DEP_CPP_INFTR) "$(INTDIR)"
-
-
-!ELSEIF  "$(CFG)" == "zlibvc - Win32 Debug"
-
-
-"$(INTDIR)\inftrees.obj" : $(SOURCE) $(DEP_CPP_INFTR) "$(INTDIR)"
-
-
-!ENDIF 
-
-# End Source File
-################################################################################
-# Begin Source File
-
-SOURCE=.\infutil.c
-DEP_CPP_INFUT=\
-	".\infblock.h"\
-	".\infcodes.h"\
-	".\inftrees.h"\
-	".\infutil.h"\
-	".\zconf.h"\
-	".\zlib.h"\
-	".\zutil.h"\
-	
-
-!IF  "$(CFG)" == "zlibvc - Win32 Release"
-
-
-"$(INTDIR)\infutil.obj" : $(SOURCE) $(DEP_CPP_INFUT) "$(INTDIR)"
-
-"$(INTDIR)\infutil.sbr" : $(SOURCE) $(DEP_CPP_INFUT) "$(INTDIR)"
-
-
-!ELSEIF  "$(CFG)" == "zlibvc - Win32 Debug"
-
-
-"$(INTDIR)\infutil.obj" : $(SOURCE) $(DEP_CPP_INFUT) "$(INTDIR)"
-
-
-!ENDIF 
-
-# End Source File
-################################################################################
-# Begin Source File
-
-SOURCE=.\trees.c
-DEP_CPP_TREES=\
-	".\deflate.h"\
-	".\zconf.h"\
-	".\zlib.h"\
-	".\zutil.h"\
-	
-
-!IF  "$(CFG)" == "zlibvc - Win32 Release"
-
-
-"$(INTDIR)\trees.obj" : $(SOURCE) $(DEP_CPP_TREES) "$(INTDIR)"
-
-"$(INTDIR)\trees.sbr" : $(SOURCE) $(DEP_CPP_TREES) "$(INTDIR)"
-
-
-!ELSEIF  "$(CFG)" == "zlibvc - Win32 Debug"
-
-
-"$(INTDIR)\trees.obj" : $(SOURCE) $(DEP_CPP_TREES) "$(INTDIR)"
-
-
-!ENDIF 
-
-# End Source File
-################################################################################
-# Begin Source File
-
-SOURCE=.\uncompr.c
-
-!IF  "$(CFG)" == "zlibvc - Win32 Release"
-
-DEP_CPP_UNCOM=\
-	".\zconf.h"\
-	".\zlib.h"\
-	
-
-"$(INTDIR)\uncompr.obj" : $(SOURCE) $(DEP_CPP_UNCOM) "$(INTDIR)"
-
-"$(INTDIR)\uncompr.sbr" : $(SOURCE) $(DEP_CPP_UNCOM) "$(INTDIR)"
-
-
-!ELSEIF  "$(CFG)" == "zlibvc - Win32 Debug"
-
-DEP_CPP_UNCOM=\
-	".\zconf.h"\
-	".\zlib.h"\
-	
-NODEP_CPP_UNCOM=\
-	".\uncompress"\
-	
-
-"$(INTDIR)\uncompr.obj" : $(SOURCE) $(DEP_CPP_UNCOM) "$(INTDIR)"
-
-
-!ENDIF 
-
-# End Source File
-################################################################################
-# Begin Source File
-
-SOURCE=.\zutil.c
-DEP_CPP_ZUTIL=\
-	".\zconf.h"\
-	".\zlib.h"\
-	".\zutil.h"\
-	
-
-!IF  "$(CFG)" == "zlibvc - Win32 Release"
-
-
-"$(INTDIR)\zutil.obj" : $(SOURCE) $(DEP_CPP_ZUTIL) "$(INTDIR)"
-
-"$(INTDIR)\zutil.sbr" : $(SOURCE) $(DEP_CPP_ZUTIL) "$(INTDIR)"
-
-
-!ELSEIF  "$(CFG)" == "zlibvc - Win32 Debug"
-
-
-"$(INTDIR)\zutil.obj" : $(SOURCE) $(DEP_CPP_ZUTIL) "$(INTDIR)"
-
-
-!ENDIF 
-
-# End Source File
-################################################################################
-# Begin Source File
-
-SOURCE=.\zlib.rc
-
-"$(INTDIR)\zlib.res" : $(SOURCE) "$(INTDIR)"
-   $(RSC) $(RSC_PROJ) $(SOURCE)
-
-
-# End Source File
-################################################################################
-# Begin Source File
-
-SOURCE=.\zlib.def
-
-!IF  "$(CFG)" == "zlibvc - Win32 Release"
-
-!ELSEIF  "$(CFG)" == "zlibvc - Win32 Debug"
-
-!ENDIF 
-
-# End Source File
-################################################################################
-# Begin Source File
-
-SOURCE=.\GVMAT32.obj
-
-!IF  "$(CFG)" == "zlibvc - Win32 Release"
-
-!ELSEIF  "$(CFG)" == "zlibvc - Win32 Debug"
-
-!ENDIF 
-
-# End Source File
-################################################################################
-# Begin Source File
-
-SOURCE=.\gvmat32c.c
-
-!IF  "$(CFG)" == "zlibvc - Win32 Release"
-
-DEP_CPP_GVMAT=\
-	".\deflate.h"\
-	".\zconf.h"\
-	".\zlib.h"\
-	".\zutil.h"\
-	
-
-"$(INTDIR)\gvmat32c.obj" : $(SOURCE) $(DEP_CPP_GVMAT) "$(INTDIR)"
-
-"$(INTDIR)\gvmat32c.sbr" : $(SOURCE) $(DEP_CPP_GVMAT) "$(INTDIR)"
-
-
-!ELSEIF  "$(CFG)" == "zlibvc - Win32 Debug"
-
-DEP_CPP_GVMAT=\
-	".\deflate.h"\
-	".\zconf.h"\
-	".\zlib.h"\
-	".\zutil.h"\
-	
-
-"$(INTDIR)\gvmat32c.obj" : $(SOURCE) $(DEP_CPP_GVMAT) "$(INTDIR)"
-
-
-!ENDIF 
-
-# End Source File
-# End Target
-# End Project
-################################################################################

crc32.c

@@ -124,7 +124,7 @@ local const uLongf crc_table[256] = {
 /* =========================================================================
  * This function can be used by asm versions of crc32()
  */
-const uLongf * EXPORT get_crc_table()
+const uLongf * ZEXPORT get_crc_table()
 {
 #ifdef DYNAMIC_CRC_TABLE
   if (crc_table_empty) make_crc_table();
@@ -139,7 +139,7 @@ const uLongf * EXPORT get_crc_table()
 #define DO8(buf)  DO4(buf); DO4(buf);
 
 /* ========================================================================= */
-uLong EXPORT crc32(crc, buf, len)
+uLong ZEXPORT crc32(crc, buf, len)
     uLong crc;
     const Bytef *buf;
     uInt len;

deflate.c

@@ -52,7 +52,7 @@
 #include "deflate.h"
 
 const char deflate_copyright[] =
-   " deflate 1.0.8 Copyright 1995-1998 Jean-loup Gailly ";
+   " deflate 1.0.9 Copyright 1995-1998 Jean-loup Gailly ";
 /*
   If you use the zlib library in a product, an acknowledgment is welcome
   in the documentation of your product. If for some reason you cannot
@@ -80,7 +80,7 @@ local block_state deflate_slow   OF((deflate_state *s, int flush));
 local void lm_init        OF((deflate_state *s));
 local void putShortMSB    OF((deflate_state *s, uInt b));
 local void flush_pending  OF((z_streamp strm));
-local int read_buf        OF((z_streamp strm, charf *buf, unsigned size));
+local int read_buf        OF((z_streamp strm, Bytef *buf, unsigned size));
 #ifdef ASMV
       void match_init OF((void)); /* asm code initialization */
       uInt longest_match  OF((deflate_state *s, IPos cur_match));
@@ -175,10 +175,10 @@ struct static_tree_desc_s {int dummy;}; /* for buggy compilers */
  */
 #define CLEAR_HASH(s) \
     s->head[s->hash_size-1] = NIL; \
-    zmemzero((charf *)s->head, (unsigned)(s->hash_size-1)*sizeof(*s->head));
+    zmemzero((Bytef *)s->head, (unsigned)(s->hash_size-1)*sizeof(*s->head));
 
 /* ========================================================================= */
-int EXPORT deflateInit_(strm, level, version, stream_size)
+int ZEXPORT deflateInit_(strm, level, version, stream_size)
     z_streamp strm;
     int level;
     const char *version;
@@ -190,7 +190,7 @@ int EXPORT deflateInit_(strm, level, version, stream_size)
 }
 
 /* ========================================================================= */
-int EXPORT deflateInit2_(strm, level, method, windowBits, memLevel, strategy,
+int ZEXPORT deflateInit2_(strm, level, method, windowBits, memLevel, strategy,
 		  version, stream_size)
     z_streamp strm;
     int  level;
@@ -276,7 +276,7 @@ int EXPORT deflateInit2_(strm, level, method, windowBits, memLevel, strategy,
 }
 
 /* ========================================================================= */
-int EXPORT deflateSetDictionary (strm, dictionary, dictLength)
+int ZEXPORT deflateSetDictionary (strm, dictionary, dictLength)
     z_streamp strm;
     const Bytef *dictionary;
     uInt  dictLength;
@@ -299,7 +299,7 @@ int EXPORT deflateSetDictionary (strm, dictionary, dictLength)
 	dictionary += dictLength - length; /* use the tail of the dictionary */
 #endif
     }
-    zmemcpy((charf *)s->window, dictionary, length);
+    zmemcpy(s->window, dictionary, length);
     s->strstart = length;
     s->block_start = (long)length;
 
@@ -317,7 +317,7 @@ int EXPORT deflateSetDictionary (strm, dictionary, dictLength)
 }
 
 /* ========================================================================= */
-int EXPORT deflateReset (strm)
+int ZEXPORT deflateReset (strm)
     z_streamp strm;
 {
     deflate_state *s;
@@ -347,7 +347,7 @@ int EXPORT deflateReset (strm)
 }
 
 /* ========================================================================= */
-int EXPORT deflateParams(strm, level, strategy)
+int ZEXPORT deflateParams(strm, level, strategy)
     z_streamp strm;
     int level;
     int strategy;
@@ -421,7 +421,7 @@ local void flush_pending(strm)
 }
 
 /* ========================================================================= */
-int EXPORT deflate (strm, flush)
+int ZEXPORT deflate (strm, flush)
     z_streamp strm;
     int flush;
 {
@@ -555,7 +555,7 @@ int EXPORT deflate (strm, flush)
 }
 
 /* ========================================================================= */
-int EXPORT deflateEnd (strm)
+int ZEXPORT deflateEnd (strm)
     z_streamp strm;
 {
     int status;
@@ -585,7 +585,7 @@ int EXPORT deflateEnd (strm)
  * To simplify the source, this is not supported for 16-bit MSDOS (which
  * doesn't have enough memory anyway to duplicate compression states).
  */
-int EXPORT deflateCopy (dest, source)
+int ZEXPORT deflateCopy (dest, source)
     z_streamp dest;
     z_streamp source;
 {
@@ -647,7 +647,7 @@ int EXPORT deflateCopy (dest, source)
  */
 local int read_buf(strm, buf, size)
     z_streamp strm;
-    charf *buf;
+    Bytef *buf;
     unsigned size;
 {
     unsigned len = strm->avail_in;
@@ -857,8 +857,8 @@ local void check_match(s, start, match, length)
     int length;
 {
     /* check that the match is indeed a match */
-    if (zmemcmp((charf *)s->window + match,
+    if (zmemcmp(s->window + match,
-                (charf *)s->window + start, length) != EQUAL) {
+                s->window + start, length) != EQUAL) {
         fprintf(stderr, " start %u, match %u, length %d\n",
 		start, match, length);
         do {
@@ -911,8 +911,7 @@ local void fill_window(s)
          */
         } else if (s->strstart >= wsize+MAX_DIST(s)) {
 
-            zmemcpy((charf *)s->window, (charf *)s->window+wsize,
+            zmemcpy(s->window, s->window+wsize, (unsigned)wsize);
-                   (unsigned)wsize);
             s->match_start -= wsize;
             s->strstart    -= wsize; /* we now have strstart >= MAX_DIST */
             s->block_start -= (long) wsize;
@@ -956,8 +955,7 @@ local void fill_window(s)
          */
         Assert(more >= 2, "more < 2");
 
-        n = read_buf(s->strm, (charf *)s->window + s->strstart + s->lookahead,
+        n = read_buf(s->strm, s->window + s->strstart + s->lookahead, more);
-                     more);
         s->lookahead += n;
 
         /* Initialize the hash value now that we have some input: */

example.c

@@ -95,7 +95,11 @@ void test_gzio(out, in, uncompr, uncomprLen)
         exit(1);
     }
     gzputc(file, 'h');
-    if (gzprintf(file, "%s, %s!", "ello", "hello") != len-2) {
+    if (gzputs(file, "ello") != 4) {
+        fprintf(stderr, "gzputs err: %s\n", gzerror(file, &err));
+	exit(1);
+    }
+    if (gzprintf(file, ", %s!", "hello") != 8) {
         fprintf(stderr, "gzprintf err: %s\n", gzerror(file, &err));
 	exit(1);
     }
@@ -132,16 +136,17 @@ void test_gzio(out, in, uncompr, uncomprLen)
 	exit(1);
     }
 
-    uncomprLen = gzread(file, uncompr, (unsigned)uncomprLen);
+    gzgets(file, (char*)uncompr, uncomprLen);
-    if (uncomprLen != 7) {
+    uncomprLen = strlen((char*)uncompr);
-        fprintf(stderr, "gzread err after gzseek: %s\n", gzerror(file, &err));
+    if (uncomprLen != 6) { /* "hello!" */
+        fprintf(stderr, "gzgets err after gzseek: %s\n", gzerror(file, &err));
 	exit(1);
     }
     if (strcmp((char*)uncompr, hello+7)) {
-        fprintf(stderr, "bad gzread after gzseek\n");
+        fprintf(stderr, "bad gzgets after gzseek\n");
 	exit(1);
     } else {
-        printf("gzread() after gzseek: %s\n", uncompr);
+        printf("gzgets() after gzseek: %s\n", uncompr);
     }
 
     gzclose(file);

gzio.c

@@ -167,7 +167,7 @@ local gzFile gz_open (path, mode, fd)
 /* ===========================================================================
      Opens a gzip (.gz) file for reading or writing.
 */
-gzFile EXPORT gzopen (path, mode)
+gzFile ZEXPORT gzopen (path, mode)
     const char *path;
     const char *mode;
 {
@@ -178,7 +178,7 @@ gzFile EXPORT gzopen (path, mode)
      Associate a gzFile with the file descriptor fd. fd is not dup'ed here
    to mimic the behavio(u)r of fdopen.
 */
-gzFile EXPORT gzdopen (fd, mode)
+gzFile ZEXPORT gzdopen (fd, mode)
     int fd;
     const char *mode;
 {
@@ -193,7 +193,7 @@ gzFile EXPORT gzdopen (fd, mode)
 /* ===========================================================================
  * Update the compression level and strategy
  */
-int EXPORT gzsetparams (file, level, strategy)
+int ZEXPORT gzsetparams (file, level, strategy)
     gzFile file;
     int level;
     int strategy;
@@ -339,7 +339,7 @@ local int destroy (s)
      Reads the given number of uncompressed bytes from the compressed file.
    gzread returns the number of bytes actually read (0 for end of file).
 */
-int EXPORT gzread (file, buf, len)
+int ZEXPORT gzread (file, buf, len)
     gzFile file;
     voidp buf;
     unsigned len;
@@ -375,7 +375,10 @@ int EXPORT gzread (file, buf, len)
 		s->stream.avail_out -= fread(next_out, 1, s->stream.avail_out,
 					     s->file);
 	    }
-	    return (int)(len - s->stream.avail_out);
+	    len -= s->stream.avail_out;
+	    s->stream.total_in  += (uLong)len;
+	    s->stream.total_out += (uLong)len;
+	    return (int)len;
 	}
         if (s->stream.avail_in == 0 && !s->z_eof) {
 
@@ -425,7 +428,7 @@ int EXPORT gzread (file, buf, len)
       Reads one byte from the compressed file. gzgetc returns this byte
    or -1 in case of end of file or error.
 */
-int EXPORT gzgetc(file)
+int ZEXPORT gzgetc(file)
     gzFile file;
 {
     unsigned char c;
@@ -434,12 +437,35 @@ int EXPORT gzgetc(file)
 }
 
 
+/* ===========================================================================
+      Reads bytes from the compressed file until len-1 characters are
+   read, or a newline character is read and transferred to buf, or an
+   end-of-file condition is encountered.  The string is then terminated
+   with a null character.
+      gzgets returns buf, or Z_NULL in case of error.
+
+      The current implementation is not optimized at all.
+*/
+char * ZEXPORT gzgets(file, buf, len)
+    gzFile file;
+    char *buf;
+    int len;
+{
+    char *b = buf;
+    if (buf == Z_NULL || len <= 0) return Z_NULL;
+
+    while (--len > 0 && gzread(file, buf, 1) == 1 && *buf++ != '\n') ;
+    *buf = '\0';
+    return b == buf && len > 0 ? Z_NULL : b;
+}
+
+
 #ifndef NO_DEFLATE
 /* ===========================================================================
      Writes the given number of uncompressed bytes into the compressed file.
    gzwrite returns the number of bytes actually written (0 in case of error).
 */
-int EXPORT gzwrite (file, buf, len)
+int ZEXPORT gzwrite (file, buf, len)
     gzFile file;
     const voidp buf;
     unsigned len;
@@ -478,7 +504,7 @@ int EXPORT gzwrite (file, buf, len)
 #ifdef STDC
 #include <stdarg.h>
 
-int EXPORTVA gzprintf (gzFile file, const char *format, /* args */ ...)
+int ZEXPORTVA gzprintf (gzFile file, const char *format, /* args */ ...)
 {
     char buf[Z_BUFSIZE];
     va_list va;
@@ -486,18 +512,19 @@ int EXPORTVA gzprintf (gzFile file, const char *format, /* args */ ...)
 
     va_start(va, format);
 #ifdef HAS_vsnprintf
-    len = vsnprintf(buf, sizeof(buf), format, va);
+    (void)vsnprintf(buf, sizeof(buf), format, va);
 #else
-    len = vsprintf(buf, format, va);
+    (void)vsprintf(buf, format, va);
 #endif
     va_end(va);
+    len = strlen(buf); /* some *sprintf don't return the nb of bytes written */
     if (len <= 0) return 0;
 
     return gzwrite(file, buf, (unsigned)len);
 }
 #else /* not ANSI C */
 
-int EXPORTVA gzprintf (file, format, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10,
+int ZEXPORTVA gzprintf (file, format, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10,
 	               a11, a12, a13, a14, a15, a16, a17, a18, a19, a20)
     gzFile file;
     const char *format;
@@ -525,7 +552,7 @@ int EXPORTVA gzprintf (file, format, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10,
       Writes c, converted to an unsigned char, into the compressed file.
    gzputc returns the value that was written, or -1 in case of error.
 */
-int EXPORT gzputc(file, c)
+int ZEXPORT gzputc(file, c)
     gzFile file;
     int c;
 {
@@ -535,6 +562,19 @@ int EXPORT gzputc(file, c)
 }
 
 
+/* ===========================================================================
+      Writes the given null-terminated string to the compressed file, excluding
+   the terminating null character.
+      gzputs returns the number of characters written, or -1 in case of error.
+*/
+int ZEXPORT gzputs(file, s)
+    gzFile file;
+    const char *s;
+{
+    return gzwrite(file, (const voidp)s, (unsigned)strlen(s));
+}
+
+
 /* ===========================================================================
      Flushes all pending output into the compressed file. The parameter
    flush is as in the deflate() function.
@@ -578,7 +618,7 @@ local int do_flush (file, flush)
     return  s->z_err == Z_STREAM_END ? Z_OK : s->z_err;
 }
 
-int EXPORT gzflush (file, flush)
+int ZEXPORT gzflush (file, flush)
      gzFile file;
      int flush;
 {
@@ -599,17 +639,17 @@ int EXPORT gzflush (file, flush)
       SEEK_END is not implemented, returns error.
       In this version of the library, gzseek can be extremely slow.
 */
-z_off_t EXPORT gzseek (file, offset, whence)
+z_off_t ZEXPORT gzseek (file, offset, whence)
     gzFile file;
     z_off_t offset;
     int whence;
 {
     gz_stream *s = (gz_stream*)file;
 
-    if (s == NULL || whence == SEEK_END || s->z_err == Z_ERRNO) return -1L;
+    if (s == NULL || whence == SEEK_END ||
-
+	s->z_err == Z_ERRNO || s->z_err == Z_DATA_ERROR) {
-    s->z_err = Z_OK;
+	return -1L;
-    s->z_eof = 0;
+    }
     
     if (s->mode == 'w') {
 #ifdef NO_DEFLATE
@@ -639,8 +679,6 @@ z_off_t EXPORT gzseek (file, offset, whence)
     }
     /* Rest of function is for reading only */
 
-    if (s->z_err == Z_DATA_ERROR) return -1L;
-
     /* compute absolute position */
     if (whence == SEEK_CUR) {
 	offset += s->stream.total_out;
@@ -652,6 +690,8 @@ z_off_t EXPORT gzseek (file, offset, whence)
 	s->stream.avail_in = 0;
 	s->stream.next_in = s->inbuf;
         if (fseek(s->file, offset, SEEK_SET) < 0) return -1L;
+
+	s->stream.total_in = s->stream.total_out = (uLong)offset;
 	return offset;
     }
 
@@ -680,7 +720,7 @@ z_off_t EXPORT gzseek (file, offset, whence)
 /* ===========================================================================
      Rewinds input file. 
 */
-int EXPORT gzrewind (file)
+int ZEXPORT gzrewind (file)
     gzFile file;
 {
     gz_stream *s = (gz_stream*)file;
@@ -706,7 +746,7 @@ int EXPORT gzrewind (file)
    given compressed file. This position represents a number of bytes in the
    uncompressed data stream.
 */
-z_off_t EXPORT gztell (file)
+z_off_t ZEXPORT gztell (file)
     gzFile file;
 {
     return gzseek(file, 0L, SEEK_CUR);
@@ -716,7 +756,7 @@ z_off_t EXPORT gztell (file)
      Returns 1 when EOF has previously been detected reading the given
    input stream, otherwise zero.
 */
-int EXPORT gzeof (file)
+int ZEXPORT gzeof (file)
     gzFile file;
 {
     gz_stream *s = (gz_stream*)file;
@@ -759,7 +799,7 @@ local uLong getLong (s)
      Flushes all pending output if necessary, closes the compressed file
    and deallocates all the (de)compression state.
 */
-int EXPORT gzclose (file)
+int ZEXPORT gzclose (file)
     gzFile file;
 {
     int err;
@@ -788,7 +828,7 @@ int EXPORT gzclose (file)
    errnum is set to Z_ERRNO and the application may consult errno
    to get the exact error code.
 */
-const char*  EXPORT gzerror (file, errnum)
+const char*  ZEXPORT gzerror (file, errnum)
     gzFile file;
     int *errnum;
 {

infblock.c

@@ -71,11 +71,7 @@ uLongf *c;
   if (s->mode == BTREE || s->mode == DTREE)
     ZFREE(z, s->sub.trees.blens);
   if (s->mode == CODES)
-  {
     inflate_codes_free(s->sub.decode.codes, z);
-    inflate_trees_free(s->sub.decode.td, z);
-    inflate_trees_free(s->sub.decode.tl, z);
-  }
   s->mode = TYPE;
   s->bitk = 0;
   s->bitb = 0;
@@ -96,8 +92,15 @@ uInt w;
   if ((s = (inflate_blocks_statef *)ZALLOC
        (z,1,sizeof(struct inflate_blocks_state))) == Z_NULL)
     return s;
+  if ((s->hufts =
+       (inflate_huft *)ZALLOC(z, sizeof(inflate_huft), MANY)) == Z_NULL)
+  {
+    ZFREE(z, s);
+    return Z_NULL;
+  }
   if ((s->window = (Bytef *)ZALLOC(z, 1, w)) == Z_NULL)
   {
+    ZFREE(z, s->hufts);
     ZFREE(z, s);
     return Z_NULL;
   }
@@ -110,9 +113,6 @@ uInt w;
 }
 
 
-#ifdef DEBUG
-  extern uInt inflate_hufts;
-#endif
 int inflate_blocks(s, z, r)
 inflate_blocks_statef *s;
 z_streamp z;
@@ -153,15 +153,13 @@ int r;
             uInt bl, bd;
             inflate_huft *tl, *td;
 
-            inflate_trees_fixed(&bl, &bd, &tl, &td);
+            inflate_trees_fixed(&bl, &bd, &tl, &td, z);
             s->sub.decode.codes = inflate_codes_new(bl, bd, tl, td, z);
             if (s->sub.decode.codes == Z_NULL)
             {
               r = Z_MEM_ERROR;
               LEAVE
             }
-            s->sub.decode.tl = Z_NULL;  /* don't try to free these */
-            s->sub.decode.td = Z_NULL;
           }
           DUMPBITS(3)
           s->mode = CODES;
@@ -244,7 +242,7 @@ int r;
         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, s->hufts, z);
       if (t != Z_OK)
       {
         ZFREE(z, s->sub.trees.blens);
@@ -286,7 +284,6 @@ int r;
           if (i + j > 258 + (t & 0x1f) + ((t >> 5) & 0x1f) ||
               (c == 16 && i < 1))
           {
-            inflate_trees_free(s->sub.trees.tb, z);
             ZFREE(z, s->sub.trees.blens);
             s->mode = BAD;
             z->msg = (char*)"invalid bit length repeat";
@@ -300,7 +297,6 @@ int r;
           s->sub.trees.index = i;
         }
       }
-      inflate_trees_free(s->sub.trees.tb, z);
       s->sub.trees.tb = Z_NULL;
       {
         uInt bl, bd;
@@ -310,11 +306,9 @@ int r;
         bl = 9;         /* must be <= 9 for lookahead assumptions */
         bd = 6;         /* must be <= 9 for lookahead assumptions */
         t = s->sub.trees.table;
-#ifdef DEBUG
-      inflate_hufts = 0;
-#endif
         t = inflate_trees_dynamic(257 + (t & 0x1f), 1 + ((t >> 5) & 0x1f),
-                                  s->sub.trees.blens, &bl, &bd, &tl, &td, z);
+                                  s->sub.trees.blens, &bl, &bd, &tl, &td,
+                                  s->hufts, z);
         ZFREE(z, s->sub.trees.blens);
         if (t != Z_OK)
         {
@@ -323,18 +317,13 @@ int r;
           r = t;
           LEAVE
         }
-        Tracev((stderr, "inflate:       trees ok, %d * %d bytes used\n",
+        Tracev((stderr, "inflate:       trees ok\n"));
-              inflate_hufts, sizeof(inflate_huft)));
         if ((c = inflate_codes_new(bl, bd, tl, td, z)) == Z_NULL)
         {
-          inflate_trees_free(td, z);
-          inflate_trees_free(tl, z);
           r = Z_MEM_ERROR;
           LEAVE
         }
         s->sub.decode.codes = c;
-        s->sub.decode.tl = tl;
-        s->sub.decode.td = td;
       }
       s->mode = CODES;
     case CODES:
@@ -343,8 +332,6 @@ int r;
         return inflate_flush(s, z, r);
       r = Z_OK;
       inflate_codes_free(s->sub.decode.codes, z);
-      inflate_trees_free(s->sub.decode.td, z);
-      inflate_trees_free(s->sub.decode.tl, z);
       LOAD
       Tracev((stderr, "inflate:       codes end, %lu total out\n",
               z->total_out + (q >= s->read ? q - s->read :
@@ -386,6 +373,7 @@ z_streamp z;
 {
   inflate_blocks_reset(s, z, Z_NULL);
   ZFREE(z, s->window);
+  ZFREE(z, s->hufts);
   ZFREE(z, s);
   Tracev((stderr, "inflate:   blocks freed\n"));
   return Z_OK;
@@ -397,7 +385,7 @@ inflate_blocks_statef *s;
 const Bytef *d;
 uInt  n;
 {
-  zmemcpy((charf *)s->window, d, n);
+  zmemcpy(s->window, d, n);
   s->read = s->write = s->window + n;
 }
 

inflate.c

@@ -50,7 +50,7 @@ struct internal_state {
 };
 
 
-int EXPORT inflateReset(z)
+int ZEXPORT inflateReset(z)
 z_streamp z;
 {
   if (z == Z_NULL || z->state == Z_NULL)
@@ -64,7 +64,7 @@ z_streamp z;
 }
 
 
-int EXPORT inflateEnd(z)
+int ZEXPORT inflateEnd(z)
 z_streamp z;
 {
   if (z == Z_NULL || z->state == Z_NULL || z->zfree == Z_NULL)
@@ -78,7 +78,7 @@ z_streamp z;
 }
 
 
-int EXPORT inflateInit2_(z, w, version, stream_size)
+int ZEXPORT inflateInit2_(z, w, version, stream_size)
 z_streamp z;
 int w;
 const char *version;
@@ -135,7 +135,7 @@ int stream_size;
 }
 
 
-int EXPORT inflateInit_(z, version, stream_size)
+int ZEXPORT inflateInit_(z, version, stream_size)
 z_streamp z;
 const char *version;
 int stream_size;
@@ -144,18 +144,19 @@ int stream_size;
 }
 
 
-#define NEEDBYTE {if(z->avail_in==0)return r; if (f != Z_FINISH) r = Z_OK;}
+#define NEEDBYTE {if(z->avail_in==0)return r;r=f;}
 #define NEXTBYTE (z->avail_in--,z->total_in++,*z->next_in++)
 
-int EXPORT inflate(z, f)
+int ZEXPORT inflate(z, f)
 z_streamp z;
 int f;
 {
   int r;
   uInt b;
 
-  if (z == Z_NULL || z->state == Z_NULL || z->next_in == Z_NULL || f < 0)
+  if (z == Z_NULL || z->state == Z_NULL || z->next_in == Z_NULL)
     return Z_STREAM_ERROR;
+  f = f == Z_FINISH ? Z_BUF_ERROR : Z_OK;
   r = Z_BUF_ERROR;
   while (1) switch (z->state->mode)
   {
@@ -224,9 +225,10 @@ int f;
         z->state->sub.marker = 0;       /* can try inflateSync */
         break;
       }
+      if (r == Z_OK)
+        r = f;
       if (r != Z_STREAM_END)
-        return f == Z_FINISH && r == Z_OK ? Z_BUF_ERROR : r;
+        return r;
-      r = Z_OK;
       inflate_blocks_reset(z->state->blocks, z, &z->state->sub.check.was);
       if (z->state->nowrap)
       {
@@ -234,7 +236,6 @@ int f;
         break;
       }
       z->state->mode = CHECK4;
-      if (f == Z_FINISH) r = Z_BUF_ERROR;
     case CHECK4:
       NEEDBYTE
       z->state->sub.check.need = (uLong)NEXTBYTE << 24;
@@ -273,7 +274,7 @@ int f;
 }
 
 
-int EXPORT inflateSetDictionary(z, dictionary, dictLength)
+int ZEXPORT inflateSetDictionary(z, dictionary, dictLength)
 z_streamp z;
 const Bytef *dictionary;
 uInt  dictLength;
@@ -297,7 +298,7 @@ uInt  dictLength;
 }
 
 
-int EXPORT inflateSync(z)
+int ZEXPORT inflateSync(z)
 z_streamp z;
 {
   uInt n;       /* number of bytes to look at */
@@ -321,8 +322,7 @@ z_streamp z;
   /* search */
   while (n && m < 4)
   {
-    static const Byte mark[4] = {0, 0, 0xff, 0xff};
+    if (*p == (Byte)(m < 2 ? 0 : (Byte)0xff))
-    if (*p == mark[m])
       m++;
     else if (*p)
       m = 0;
@@ -355,7 +355,7 @@ z_streamp z;
  * decompressing, PPP checks that at the end of input packet, inflate is
  * waiting for these length bytes.
  */
-int EXPORT inflateSyncPoint(z)
+int ZEXPORT inflateSyncPoint(z)
 z_streamp z;
 {
   if (z == Z_NULL || z->state == Z_NULL || z->state->blocks == Z_NULL)

inftrees.c

@@ -7,7 +7,7 @@
 #include "inftrees.h"
 
 const char inflate_copyright[] =
-   " inflate 1.0.8 Copyright 1995-1998 Mark Adler ";
+   " inflate 1.0.9 Copyright 1995-1998 Mark Adler ";
 /*
   If you use the zlib library in a product, an acknowledgment is welcome
   in the documentation of your product. If for some reason you cannot
@@ -31,12 +31,9 @@ local int huft_build OF((
     const uIntf *,      /* list of extra bits for non-simple codes */
     inflate_huft * FAR*,/* result: starting table */
     uIntf *,            /* maximum lookup bits (returns actual) */
-    z_streamp ));       /* for zalloc function */
+    inflate_huft *,     /* space for trees */
-
+    uInt *,             /* hufts used in space */
-local voidpf falloc OF((
+    uIntf * ));         /* space for values */
-    voidpf,             /* opaque pointer (not used) */
-    uInt,               /* number of items */
-    uInt));             /* size of item */
 
 /* Tables for deflate from PKZIP's appnote.txt. */
 local const uInt cplens[31] = { /* Copy lengths for literal codes 257..285 */
@@ -90,21 +87,18 @@ local const uInt cpdext[30] = { /* Extra bits for distance codes */
 
 /* If BMAX needs to be larger than 16, then h and x[] should be uLong. */
 #define BMAX 15         /* maximum bit length of any code */
-#define N_MAX 288       /* maximum number of codes in any set */
 
-#ifdef DEBUG
+local int huft_build(b, n, s, d, e, t, m, hp, hn, v)
-  uInt inflate_hufts;
-#endif
-
-local int huft_build(b, n, s, d, e, t, m, zs)
 uIntf *b;               /* code lengths in bits (all assumed <= BMAX) */
-uInt n;                 /* number of codes (assumed <= N_MAX) */
+uInt n;                 /* number of codes (assumed <= 288) */
 uInt s;                 /* number of simple-valued codes (0..s-1) */
 const uIntf *d;         /* list of base values for non-simple codes */
 const uIntf *e;         /* list of extra bits for non-simple codes */
 inflate_huft * FAR *t;  /* result: starting table */
 uIntf *m;               /* maximum lookup bits, returns actual */
-z_streamp zs;           /* for zalloc function */
+inflate_huft *hp;       /* space for trees */
+uInt *hn;               /* hufts used in space */
+uIntf *v;               /* working area: values in order of bit length */
 /* 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
@@ -121,11 +115,11 @@ z_streamp zs;           /* for zalloc function */
   register uInt j;              /* counter */
   register int k;               /* number of bits in current code */
   int l;                        /* bits per table (returned in m) */
+  uInt mask;                    /* (1 << w) - 1, to avoid cc -O bug on HP */
   register uIntf *p;            /* pointer into c[], b[], or v[] */
   inflate_huft *q;              /* points to current table */
   struct inflate_huft_s 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 */
   uIntf *xp;                    /* pointer into x */
@@ -233,20 +227,16 @@ z_streamp zs;           /* for zalloc function */
         }
         z = 1 << j;             /* table entries for j-bit table */
 
-        /* allocate and link in new table */
+        /* allocate new table */
-        if ((q = (inflate_huft *)ZALLOC
+        if (*hn + z > MANY)     /* (note: doesn't matter for fixed) */
-             (zs,z + 1,sizeof(inflate_huft))) == Z_NULL)
-        {
-          if (h)
-            inflate_trees_free(u[0], zs);
           return Z_MEM_ERROR;   /* not enough memory */
+        u[h] = q = hp + *hn;
+        *hn += z;
+        if (t != Z_NULL)        /* first table is returned result */
+        {
+          *t = q;
+          t = Z_NULL;
         }
-#ifdef DEBUG
-        inflate_hufts += z + 1;
-#endif
-        *t = q + 1;             /* link to list for huft_free() */
-        *(t = &(q->next)) = Z_NULL;
-        u[h] = ++q;             /* table starts after link */
 
         /* connect to last table, if there is one */
         if (h)
@@ -286,10 +276,12 @@ z_streamp zs;           /* for zalloc function */
       i ^= j;
 
       /* backup over finished tables */
-      while ((i & ((1 << w) - 1)) != x[h])
+      mask = (1 << w) - 1;      /* needed on HP, cc -O bug */
+      while ((i & mask) != x[h])
       {
         h--;                    /* don't need to update q */
         w -= l;
+        mask = (1 << w) - 1;
       }
     }
   }
@@ -300,28 +292,34 @@ z_streamp zs;           /* for zalloc function */
 }
 
 
-int inflate_trees_bits(c, bb, tb, z)
+int inflate_trees_bits(c, bb, tb, hp, z)
 uIntf *c;               /* 19 code lengths */
 uIntf *bb;              /* bits tree desired/actual depth */
 inflate_huft * FAR *tb; /* bits tree result */
-z_streamp z;            /* for zfree function */
+inflate_huft *hp;       /* space for trees */
+z_streamp z;            /* for messages */
 {
   int r;
+  uInt hn = 0;          /* hufts used in space */
+  uIntf *v;             /* work area for huft_build */
 
-  r = huft_build(c, 19, 19, (uIntf*)Z_NULL, (uIntf*)Z_NULL, tb, bb, z);
+  if ((v = (uIntf*)ZALLOC(z, 19, sizeof(uInt))) == Z_NULL)
+    return Z_MEM_ERROR;
+  r = huft_build(c, 19, 19, (uIntf*)Z_NULL, (uIntf*)Z_NULL,
+                 tb, bb, hp, &hn, v);
   if (r == Z_DATA_ERROR)
     z->msg = (char*)"oversubscribed dynamic bit lengths tree";
   else if (r == Z_BUF_ERROR || *bb == 0)
   {
-    inflate_trees_free(*tb, z);
     z->msg = (char*)"incomplete dynamic bit lengths tree";
     r = Z_DATA_ERROR;
   }
+  ZFREE(z, v);
   return r;
 }
 
 
-int inflate_trees_dynamic(nl, nd, c, bl, bd, tl, td, z)
+int inflate_trees_dynamic(nl, nd, c, bl, bd, tl, td, hp, z)
 uInt nl;                /* number of literal/length codes */
 uInt nd;                /* number of distance codes */
 uIntf *c;               /* that many (total) code lengths */
@@ -329,27 +327,34 @@ uIntf *bl;              /* literal desired/actual bit depth */
 uIntf *bd;              /* distance desired/actual bit depth */
 inflate_huft * FAR *tl; /* literal/length tree result */
 inflate_huft * FAR *td; /* distance tree result */
-z_streamp z;            /* for zfree function */
+inflate_huft *hp;       /* space for trees */
+z_streamp z;            /* for messages */
 {
   int r;
+  uInt hn = 0;          /* hufts used in space */
+  uIntf *v;             /* work area for huft_build */
+
+  /* allocate work area */
+  if ((v = (uIntf*)ZALLOC(z, 288, sizeof(uInt))) == Z_NULL)
+    return Z_MEM_ERROR;
 
   /* build literal/length tree */
-  r = huft_build(c, nl, 257, cplens, cplext, tl, bl, z);
+  r = huft_build(c, nl, 257, cplens, cplext, tl, bl, hp, &hn, v);
   if (r != Z_OK || *bl == 0)
   {
     if (r == Z_DATA_ERROR)
       z->msg = (char*)"oversubscribed literal/length tree";
     else if (r != Z_MEM_ERROR)
     {
-      inflate_trees_free(*tl, z);
       z->msg = (char*)"incomplete literal/length tree";
       r = Z_DATA_ERROR;
     }
+    ZFREE(z, v);
     return r;
   }
 
   /* build distance tree */
-  r = huft_build(c + nl, nd, 0, cpdist, cpdext, td, bd, z);
+  r = huft_build(c + nl, nd, 0, cpdist, cpdext, td, bd, hp, &hn, v);
   if (r != Z_OK || (*bd == 0 && nl > 257))
   {
     if (r == Z_DATA_ERROR)
@@ -359,7 +364,6 @@ z_streamp z;            /* for zfree function */
       r = Z_OK;
     }
 #else
-      inflate_trees_free(*td, z);
       z->msg = (char*)"incomplete distance tree";
       r = Z_DATA_ERROR;
     }
@@ -368,19 +372,20 @@ z_streamp z;            /* for zfree function */
       z->msg = (char*)"empty distance tree with lengths";
       r = Z_DATA_ERROR;
     }
-    inflate_trees_free(*tl, z);
+    ZFREE(z, v);
     return r;
 #endif
   }
 
   /* done */
+  ZFREE(z, v);
   return Z_OK;
 }
 
 
 /* build fixed tables only once--keep them here */
 local int fixed_built = 0;
-#define FIXEDH 530      /* number of hufts used by fixed tables */
+#define FIXEDH 424      /* number of hufts used by fixed tables */
 local inflate_huft fixed_mem[FIXEDH];
 local uInt fixed_bl;
 local uInt fixed_bd;
@@ -388,36 +393,29 @@ local inflate_huft *fixed_tl;
 local inflate_huft *fixed_td;
 
 
-local voidpf falloc(q, n, s)
+int inflate_trees_fixed(bl, bd, tl, td, z)
-voidpf q;       /* opaque pointer */
-uInt n;         /* number of items */
-uInt s;         /* size of item */
-{
-  Assert(s == sizeof(inflate_huft) && n <= *(intf *)q,
-         "inflate_trees falloc overflow");
-  *(intf *)q -= n+s-s; /* s-s to avoid warning */
-  return (voidpf)(fixed_mem + *(intf *)q);
-}
-
-
-int inflate_trees_fixed(bl, bd, tl, td)
 uIntf *bl;               /* literal desired/actual bit depth */
 uIntf *bd;               /* distance desired/actual bit depth */
 inflate_huft * FAR *tl;  /* literal/length tree result */
 inflate_huft * FAR *td;  /* distance tree result */
+z_streamp z;             /* for memory allocation */
 {
   /* build fixed tables if not already (multiple overlapped executions ok) */
   if (!fixed_built)
   {
     int k;              /* temporary variable */
-    unsigned c[288];    /* length list for huft_build */
+    uInt f = 0;         /* number of hufts used in fixed_mem */
-    z_stream z;         /* for falloc function */
+    uIntf *c;           /* length list for huft_build */
-    int f = FIXEDH;     /* number of hufts left in fixed_mem */
+    uIntf *v;           /* work area for huft_build */
 
-    /* set up fake z_stream for memory routines */
+    /* allocate memory */
-    z.zalloc = falloc;
+    if ((c = (uIntf*)ZALLOC(z, 288, sizeof(uInt))) == Z_NULL)
-    z.zfree = Z_NULL;
+      return Z_MEM_ERROR;
-    z.opaque = (voidpf)&f;
+    if ((v = (uIntf*)ZALLOC(z, 288, sizeof(uInt))) == Z_NULL)
+    {
+      ZFREE(z, c);
+      return Z_MEM_ERROR;
+    }
 
     /* literal table */
     for (k = 0; k < 144; k++)
@@ -429,16 +427,19 @@ inflate_huft * FAR *td;  /* distance tree result */
     for (; k < 288; k++)
       c[k] = 8;
     fixed_bl = 7;
-    huft_build(c, 288, 257, cplens, cplext, &fixed_tl, &fixed_bl, &z);
+    huft_build(c, 288, 257, cplens, cplext, &fixed_tl, &fixed_bl,
+               fixed_mem, &f, v);
 
     /* distance table */
     for (k = 0; k < 30; k++)
       c[k] = 5;
     fixed_bd = 5;
-    huft_build(c, 30, 0, cpdist, cpdext, &fixed_td, &fixed_bd, &z);
+    huft_build(c, 30, 0, cpdist, cpdext, &fixed_td, &fixed_bd,
+               fixed_mem, &f, v);
 
     /* done */
-    Assert(f == 0, "invalid build of fixed tables");
+    ZFREE(z, v);
+    ZFREE(z, c);
     fixed_built = 1;
   }
   *bl = fixed_bl;
@@ -447,33 +448,3 @@ inflate_huft * FAR *td;  /* distance tree result */
   *td = fixed_td;
   return Z_OK;
 }
-
-
-int inflate_trees_free(t, z)
-inflate_huft *t;        /* table to free */
-z_streamp 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. */
-{
-  register inflate_huft *p, *q, *r;
-
-  /* Reverse linked list */
-  p = Z_NULL;
-  q = t;
-  while (q != Z_NULL)
-  {
-    r = (q - 1)->next;
-    (q - 1)->next = p;
-    p = q;
-    q = r;
-  }
-  /* Go through linked list, freeing from the malloced (t[-1]) address. */
-  while (p != Z_NULL)
-  {
-    q = (--p)->next;
-    ZFREE(z,p);
-    p = q;
-  } 
-  return Z_OK;
-}

inftrees.h

@@ -27,15 +27,19 @@ struct inflate_huft_s {
   } more;
 };
 
-#ifdef DEBUG
+/* Maximum size of dynamic tree.  The maximum found in a long but non-
-  extern uInt inflate_hufts;
+   exhaustive search was 1041 huft structures (875 for length/literals
-#endif
+   and 166 for distances, the latter actually the result of an
+   exhaustive search).  The actual maximum is not known, but the
+   value below is more than safe. */
+#define MANY 1440
 
 extern int inflate_trees_bits OF((
     uIntf *,                    /* 19 code lengths */
     uIntf *,                    /* bits tree desired/actual depth */
     inflate_huft * FAR *,       /* bits tree result */
-    z_streamp ));               /* for zalloc, zfree functions */
+    inflate_huft *,             /* space for trees */
+    z_streamp));                /* for messages */
 
 extern int inflate_trees_dynamic OF((
     uInt,                       /* number of literal/length codes */
@@ -45,15 +49,12 @@ extern int inflate_trees_dynamic OF((
     uIntf *,                    /* distance desired/actual bit depth */
     inflate_huft * FAR *,       /* literal/length tree result */
     inflate_huft * FAR *,       /* distance tree result */
-    z_streamp ));               /* for zalloc, zfree functions */
+    inflate_huft *,             /* space for trees */
+    z_streamp));                /* for messages */
 
 extern int inflate_trees_fixed OF((
     uIntf *,                    /* literal desired/actual bit depth */
     uIntf *,                    /* distance desired/actual bit depth */
     inflate_huft * FAR *,       /* literal/length tree result */
-    inflate_huft * FAR *));     /* distance tree result */
+    inflate_huft * FAR *,       /* distance tree result */
-
+    z_streamp));                /* for memory allocation */
-extern int inflate_trees_free OF((
-    inflate_huft *,             /* tables to free */
-    z_streamp ));               /* for zfree function */
-

infutil.h

@@ -41,8 +41,6 @@ struct inflate_blocks_state {
       inflate_huft *tb;         /* bit length decoding tree */
     } trees;            /* if DTREE, decoding info for trees */
     struct {
-      inflate_huft *tl;
-      inflate_huft *td;         /* trees to free */
       inflate_codes_statef 
          *codes;
     } decode;           /* if CODES, current state */
@@ -52,6 +50,7 @@ struct inflate_blocks_state {
   /* mode independent information */
   uInt bitk;            /* bits in bit buffer */
   uLong bitb;           /* bit buffer */
+  inflate_huft *hufts;  /* single malloc for tree space */
   Bytef *window;        /* sliding window */
   Bytef *end;           /* one byte after sliding window */
   Bytef *read;          /* window read pointer */

minigzip.c

@@ -44,13 +44,15 @@
 #  define fileno(file) file->__file
 #endif
 
+#ifndef WIN32 /* unlink already in stdio.h for WIN32 */
+  extern int unlink OF((const char *));
+#endif
+
 #ifndef GZ_SUFFIX
 #  define GZ_SUFFIX ".gz"
 #endif
 #define SUFFIX_LEN (sizeof(GZ_SUFFIX)-1)
 
-extern int unlink OF((const char *));
-
 #define BUFLEN 4096
 #define MAX_NAME_LEN 1024
 

msdos/zlib.def

@@ -8,7 +8,7 @@ SUBSYSTEM	WINDOWS
 
 STUB		'WINSTUB.EXE'
 
-VERSION		1.08
+VERSION		1.09
 
 CODE		 EXECUTE READ
 
@@ -55,3 +55,6 @@ EXPORTS
     zError                         @36
     inflateSyncPoint               @37
     get_crc_table                  @38
+    compress2                      @39
+    gzputs                         @40
+    gzgets                         @41

msdos/zlib.rc

@@ -2,8 +2,8 @@
 
 #define IDR_VERSION1  1
 IDR_VERSION1	VERSIONINFO	MOVEABLE IMPURE LOADONCALL DISCARDABLE
-  FILEVERSION	 1,0,8,0
+  FILEVERSION	 1,0,9,0
-  PRODUCTVERSION 1,0,8,0
+  PRODUCTVERSION 1,0,9,0
   FILEFLAGSMASK	VS_FFI_FILEFLAGSMASK
   FILEFLAGS	0
   FILEOS	VOS_DOS_WINDOWS32
@@ -17,7 +17,7 @@ BEGIN
 
     BEGIN
       VALUE "FileDescription", "zlib data compression library\0"
-      VALUE "FileVersion",	"1.0.8\0"
+      VALUE "FileVersion",	"1.0.9\0"
       VALUE "InternalName",	"zlib\0"
       VALUE "OriginalFilename",	"zlib.dll\0"
       VALUE "ProductName",	"ZLib.DLL\0"

nt/zlib.dnt

@@ -42,3 +42,6 @@ EXPORTS
     zError                         @36
     inflateSyncPoint               @37
     get_crc_table                  @38
+    compress2                      @39
+    gzputs                         @40
+    gzgets                         @41

test.c

@@ -1,2 +0,0 @@
-extern int getchar();
-int hello() {return getchar();}

uncompr.c

@@ -22,7 +22,7 @@
    enough memory, Z_BUF_ERROR if there was not enough room in the output
    buffer, or Z_DATA_ERROR if the input data was corrupted.
 */
-int EXPORT uncompress (dest, destLen, source, sourceLen)
+int ZEXPORT uncompress (dest, destLen, source, sourceLen)
     Bytef *dest;
     uLongf *destLen;
     const Bytef *source;

zconf.h

@@ -30,6 +30,7 @@
 #  define inflateSyncPoint z_inflateSyncPoint
 #  define inflateReset	z_inflateReset
 #  define compress	z_compress
+#  define compress2	z_compress2
 #  define uncompress	z_uncompress
 #  define adler32	z_adler32
 #  define crc32		z_crc32
@@ -158,6 +159,29 @@
 #    define FAR __far
 #  endif
 #endif
+
+/* Compile with -DZLIB_DLL for Windows DLL support */
+#if (defined(_WINDOWS) || defined(WINDOWS)) && defined(ZLIB_DLL)
+#  ifdef FAR
+#    undef FAR
+#  endif
+#  include <windows.h>
+#  define ZEXPORT  WINAPI
+#  ifdef WIN32
+#    define ZEXPORTVA  WINAPIV
+#  else
+#    define ZEXPORTVA  FAR _cdecl _export
+#  endif
+#else
+#   if defined (__BORLANDC__) && defined (_Windows) && defined (__DLL__)
+#       define ZEXPORT _export
+#       define ZEXPORTVA _export
+#   else
+#       define ZEXPORT
+#       define ZEXPORTVA
+#   endif
+#endif
+
 #ifndef FAR
 #   define FAR
 #endif
@@ -198,26 +222,6 @@ typedef uLong FAR uLongf;
 #  define  z_off_t long
 #endif
 
-/* Compile with -DZLIB_DLL for Windows DLL support */
-#if (defined(_WINDOWS) || defined(WINDOWS)) && defined(ZLIB_DLL)
-#  undef FAR
-#  include <windows.h>
-#  define EXPORT  WINAPI
-#  ifdef WIN32
-#    define EXPORTVA  WINAPIV
-#  else
-#    define EXPORTVA  FAR _cdecl _export
-#  endif
-#else
-#   if defined (__BORLANDC__) && defined (_Windows) && defined (__DLL__)
-#       define EXPORT _export
-#       define EXPORTVA _export
-#   else
-#       define EXPORT
-#       define EXPORTVA
-#   endif
-#endif
-
 /* MVS linker does not support external names larger than 8 bytes */
 #if defined(__MVS__)
 #   pragma map(deflateInit_,"DEIN")

zlib.3

@@ -1,10 +1,10 @@
-.TH ZLIB 3 "26 January 1998"
+.TH ZLIB 3 "16 February 1998"
 .SH NAME
 zlib \- compression/decompression library
 .SH SYNOPSIS
 [see
 .I zlib.h
-for full descripton]
+for full description]
 .SH DESCRIPTION
 The
 .I zlib
@@ -81,7 +81,7 @@ These documents are also available in other formats from:
 .IP
 ftp://ftp.uu.net/graphics/png/documents/zlib/zdoc-index.html
 .SH AUTHORS
-Version 1.0.8.
+Version 1.0.9.
 Copyright (C) 1995-1998 Jean-loup Gailly (jloup@gzip.org)
 and Mark Adler (madler@alumni.caltech.edu).
 .LP

zlib.h

@@ -1,5 +1,5 @@
 /* zlib.h -- interface of the 'zlib' general purpose compression library
-  version 1.0.8, Jan 27th, 1998
+  version 1.0.9, Feb 16th, 1998
 
   Copyright (C) 1995-1998 Jean-loup Gailly and Mark Adler
 
@@ -37,7 +37,7 @@ extern "C" {
 
 #include "zconf.h"
 
-#define ZLIB_VERSION "1.0.8"
+#define ZLIB_VERSION "1.0.9"
 
 /* 
      The 'zlib' compression library provides in-memory compression and
@@ -101,6 +101,9 @@ typedef z_stream FAR *z_streamp;
    opaque value.
 
    zalloc must return Z_NULL if there is not enough memory for the object.
+   If zlib is used in a multi-threaded application, zalloc and zfree must be
+   thread safe.
+
    On 16-bit systems, the functions zalloc and zfree must be able to allocate
    exactly 65536 bytes, but will not be required to allocate more than this
    if the symbol MAXSEG_64K is defined (see zconf.h). WARNING: On MSDOS,
@@ -165,7 +168,7 @@ typedef z_stream FAR *z_streamp;
 
                         /* basic functions */
 
-extern const char * EXPORT zlibVersion OF((void));
+extern const char * ZEXPORT zlibVersion OF((void));
 /* The application can compare zlibVersion and ZLIB_VERSION for consistency.
    If the first character differs, the library code actually used is
    not compatible with the zlib.h header file used by the application.
@@ -173,7 +176,7 @@ extern const char * EXPORT zlibVersion OF((void));
  */
 
 /* 
-extern int EXPORT deflateInit OF((z_streamp strm, int level));
+extern int ZEXPORT deflateInit OF((z_streamp strm, int level));
 
      Initializes the internal stream state for compression. The fields
    zalloc, zfree and opaque must be initialized before by the caller.
@@ -195,7 +198,7 @@ extern int EXPORT deflateInit OF((z_streamp strm, int level));
 */
 
 
-extern int EXPORT deflate OF((z_streamp strm, int flush));
+extern int ZEXPORT deflate OF((z_streamp strm, int flush));
 /*
     deflate compresses as much data as possible, and stops when the input
   buffer becomes empty or the output buffer becomes full. It may introduce some
@@ -272,7 +275,7 @@ extern int EXPORT deflate OF((z_streamp strm, int flush));
 */
 
 
-extern int EXPORT deflateEnd OF((z_streamp strm));
+extern int ZEXPORT deflateEnd OF((z_streamp strm));
 /*
      All dynamically allocated data structures for this stream are freed.
    This function discards any unprocessed input and does not flush any
@@ -287,7 +290,7 @@ extern int EXPORT deflateEnd OF((z_streamp strm));
 
 
 /* 
-extern int EXPORT inflateInit OF((z_streamp strm));
+extern int ZEXPORT inflateInit OF((z_streamp strm));
 
      Initializes the internal stream state for decompression. The fields
    next_in, avail_in, zalloc, zfree and opaque must be initialized before by
@@ -307,7 +310,7 @@ extern int EXPORT inflateInit OF((z_streamp strm));
 */
 
 
-extern int EXPORT inflate OF((z_streamp strm, int flush));
+extern int ZEXPORT inflate OF((z_streamp strm, int flush));
 /*
     inflate decompresses as much data as possible, and stops when the input
   buffer becomes empty or the output buffer becomes full. It may some
@@ -376,7 +379,7 @@ extern int EXPORT inflate OF((z_streamp strm, int flush));
 */
 
 
-extern int EXPORT inflateEnd OF((z_streamp strm));
+extern int ZEXPORT inflateEnd OF((z_streamp strm));
 /*
      All dynamically allocated data structures for this stream are freed.
    This function discards any unprocessed input and does not flush any
@@ -394,7 +397,7 @@ extern int EXPORT inflateEnd OF((z_streamp strm));
 */
 
 /*   
-extern int EXPORT deflateInit2 OF((z_streamp strm,
+extern int ZEXPORT deflateInit2 OF((z_streamp strm,
                                     int  level,
                                     int  method,
                                     int  windowBits,
@@ -437,7 +440,7 @@ extern int EXPORT deflateInit2 OF((z_streamp strm,
    not perform any compression: this will be done by deflate().
 */
                             
-extern int EXPORT deflateSetDictionary OF((z_streamp strm,
+extern int ZEXPORT deflateSetDictionary OF((z_streamp strm,
                                             const Bytef *dictionary,
                                             uInt  dictLength));
 /*
@@ -473,7 +476,7 @@ extern int EXPORT deflateSetDictionary OF((z_streamp strm,
    perform any compression: this will be done by deflate().
 */
 
-extern int EXPORT deflateCopy OF((z_streamp dest,
+extern int ZEXPORT deflateCopy OF((z_streamp dest,
                                    z_streamp source));
 /*
      Sets the destination stream as a complete copy of the source stream.
@@ -491,7 +494,7 @@ extern int EXPORT deflateCopy OF((z_streamp dest,
    destination.
 */
 
-extern int EXPORT deflateReset OF((z_streamp strm));
+extern int ZEXPORT deflateReset OF((z_streamp strm));
 /*
      This function is equivalent to deflateEnd followed by deflateInit,
    but does not free and reallocate all the internal compression state.
@@ -502,7 +505,7 @@ extern int EXPORT deflateReset OF((z_streamp strm));
    stream state was inconsistent (such as zalloc or state being NULL).
 */
 
-extern int EXPORT deflateParams OF((z_streamp strm, int level, int strategy));
+extern int ZEXPORT deflateParams OF((z_streamp strm, int level, int strategy));
 /*
      Dynamically update the compression level and compression strategy.  The
    interpretation of level and strategy is as in deflateInit2.  This can be
@@ -522,7 +525,7 @@ extern int EXPORT deflateParams OF((z_streamp strm, int level, int strategy));
 */
 
 /*   
-extern int EXPORT inflateInit2 OF((z_streamp strm,
+extern int ZEXPORT inflateInit2 OF((z_streamp strm,
                                     int  windowBits));
 
      This is another version of inflateInit with an extra parameter. The
@@ -544,7 +547,7 @@ extern int EXPORT inflateInit2 OF((z_streamp strm,
    modified, but next_out and avail_out are unchanged.)
 */
 
-extern int EXPORT inflateSetDictionary OF((z_streamp strm,
+extern int ZEXPORT inflateSetDictionary OF((z_streamp strm,
                                             const Bytef *dictionary,
                                             uInt  dictLength));
 /*
@@ -563,7 +566,7 @@ extern int EXPORT inflateSetDictionary OF((z_streamp strm,
    inflate().
 */
 
-extern int EXPORT inflateSync OF((z_streamp strm));
+extern int ZEXPORT inflateSync OF((z_streamp strm));
 /* 
     Skips invalid compressed data until a full flush point (see above the
   description of deflate with Z_FULL_FLUSH) can be found, or until all
@@ -578,7 +581,7 @@ extern int EXPORT inflateSync OF((z_streamp strm));
   until success or end of the input data.
 */
 
-extern int EXPORT inflateReset OF((z_streamp strm));
+extern int ZEXPORT inflateReset OF((z_streamp strm));
 /*
      This function is equivalent to inflateEnd followed by inflateInit,
    but does not free and reallocate all the internal decompression state.
@@ -599,7 +602,7 @@ extern int EXPORT inflateReset OF((z_streamp strm));
    utility functions can easily be modified if you need special options.
 */
 
-extern int EXPORT compress OF((Bytef *dest,   uLongf *destLen,
+extern int ZEXPORT compress OF((Bytef *dest,   uLongf *destLen,
                                 const Bytef *source, uLong sourceLen));
 /*
      Compresses the source buffer into the destination buffer.  sourceLen is
@@ -614,7 +617,7 @@ extern int EXPORT compress OF((Bytef *dest,   uLongf *destLen,
    buffer.
 */
 
-extern int EXPORT compress2 OF((Bytef *dest,   uLongf *destLen,
+extern int ZEXPORT compress2 OF((Bytef *dest,   uLongf *destLen,
                                  const Bytef *source, uLong sourceLen,
                                  int level));
 /*
@@ -629,7 +632,7 @@ extern int EXPORT compress2 OF((Bytef *dest,   uLongf *destLen,
    Z_STREAM_ERROR if the level parameter is invalid.
 */
 
-extern int EXPORT uncompress OF((Bytef *dest,   uLongf *destLen,
+extern int ZEXPORT uncompress OF((Bytef *dest,   uLongf *destLen,
                                   const Bytef *source, uLong sourceLen));
 /*
      Decompresses the source buffer into the destination buffer.  sourceLen is
@@ -650,7 +653,7 @@ extern int EXPORT uncompress OF((Bytef *dest,   uLongf *destLen,
 
 typedef voidp gzFile;
 
-extern gzFile EXPORT gzopen  OF((const char *path, const char *mode));
+extern gzFile ZEXPORT gzopen  OF((const char *path, const char *mode));
 /*
      Opens a gzip (.gz) file for reading or writing. The mode parameter
    is as in fopen ("rb" or "wb") but can also include a compression level
@@ -666,7 +669,7 @@ extern gzFile EXPORT gzopen  OF((const char *path, const char *mode));
    can be checked to distinguish the two cases (if errno is zero, the
    zlib error is Z_MEM_ERROR).  */
 
-extern gzFile EXPORT gzdopen  OF((int fd, const char *mode));
+extern gzFile ZEXPORT gzdopen  OF((int fd, const char *mode));
 /*
      gzdopen() associates a gzFile with the file descriptor fd.  File
    descriptors are obtained from calls like open, dup, creat, pipe or
@@ -679,7 +682,7 @@ extern gzFile EXPORT gzdopen  OF((int fd, const char *mode));
    the (de)compression state.
 */
 
-extern int EXPORT gzsetparams OF((gzFile file, int level, int strategy));
+extern int ZEXPORT gzsetparams OF((gzFile file, int level, int strategy));
 /*
      Dynamically update the compression level or strategy. See the description
    of deflateInit2 for the meaning of these parameters.
@@ -687,7 +690,7 @@ extern int EXPORT gzsetparams OF((gzFile file, int level, int strategy));
    opened for writing.
 */
 
-extern int EXPORT    gzread  OF((gzFile file, voidp buf, unsigned len));
+extern int ZEXPORT    gzread  OF((gzFile file, voidp buf, unsigned len));
 /*
      Reads the given number of uncompressed bytes from the compressed file.
    If the input file was not in gzip format, gzread copies the given number
@@ -695,33 +698,49 @@ extern int EXPORT    gzread  OF((gzFile file, voidp buf, unsigned len));
      gzread returns the number of uncompressed bytes actually read (0 for
    end of file, -1 for error). */
 
-extern int EXPORT    gzwrite OF((gzFile file, const voidp buf, unsigned len));
+extern int ZEXPORT    gzwrite OF((gzFile file, const voidp buf, unsigned len));
 /*
      Writes the given number of uncompressed bytes into the compressed file.
    gzwrite returns the number of uncompressed bytes actually written
    (0 in case of error).
 */
 
-extern int EXPORTVA   gzprintf OF((gzFile file, const char *format, ...));
+extern int ZEXPORTVA   gzprintf OF((gzFile file, const char *format, ...));
 /*
      Converts, formats, and writes the args to the compressed file under
    control of the format string, as in fprintf. gzprintf returns the number of
    uncompressed bytes actually written (0 in case of error).
 */
 
-extern int EXPORT    gzputc OF((gzFile file, int c));
+extern int ZEXPORT gzputs OF((gzFile file, const char *s));
+/*
+      Writes the given null-terminated string to the compressed file, excluding
+   the terminating null character.
+      gzputs returns the number of characters written, or -1 in case of error.
+*/
+
+extern char * ZEXPORT gzgets OF((gzFile file, char *buf, int len));
+/*
+      Reads bytes from the compressed file until len-1 characters are read, or
+   a newline character is read and transferred to buf, or an end-of-file
+   condition is encountered.  The string is then terminated with a null
+   character.
+      gzgets returns buf, or Z_NULL in case of error.
+*/
+
+extern int ZEXPORT    gzputc OF((gzFile file, int c));
 /*
       Writes c, converted to an unsigned char, into the compressed file.
    gzputc returns the value that was written, or -1 in case of error.
 */
 
-extern int EXPORT    gzgetc OF((gzFile file));
+extern int ZEXPORT    gzgetc OF((gzFile file));
 /*
       Reads one byte from the compressed file. gzgetc returns this byte
    or -1 in case of end of file or error.
 */
 
-extern int EXPORT    gzflush OF((gzFile file, int flush));
+extern int ZEXPORT    gzflush OF((gzFile file, int flush));
 /*
      Flushes all pending output into the compressed file. The parameter
    flush is as in the deflate() function. The return value is the zlib
@@ -731,7 +750,7 @@ extern int EXPORT    gzflush OF((gzFile file, int flush));
    degrade compression.
 */
 
-extern z_off_t EXPORT    gzseek OF((gzFile file, z_off_t offset, int whence));
+extern z_off_t ZEXPORT    gzseek OF((gzFile file, z_off_t offset, int whence));
 /* 
       Sets the starting position for the next gzread or gzwrite on the given
    compressed file. The offset represents a number of bytes in the
@@ -748,14 +767,14 @@ extern z_off_t EXPORT    gzseek OF((gzFile file, z_off_t offset, int whence));
    would be before the current position.
 */
 
-extern int EXPORT    gzrewind OF((gzFile file));
+extern int ZEXPORT    gzrewind OF((gzFile file));
 /*
      Rewinds the given file. This function is supported only for reading.
 
    gzrewind(file) is equivalent to (int)gzseek(file, 0L, SEEK_SET)
 */
 
-extern z_off_t EXPORT    gztell OF((gzFile file));
+extern z_off_t ZEXPORT    gztell OF((gzFile file));
 /*
      Returns the starting position for the next gzread or gzwrite on the
    given compressed file. This position represents a number of bytes in the
@@ -764,20 +783,20 @@ extern z_off_t EXPORT    gztell OF((gzFile file));
    gztell(file) is equivalent to gzseek(file, 0L, SEEK_CUR)
 */
 
-extern int EXPORT gzeof OF((gzFile file));
+extern int ZEXPORT gzeof OF((gzFile file));
 /*
      Returns 1 when EOF has previously been detected reading the given
    input stream, otherwise zero.
 */
 
-extern int EXPORT    gzclose OF((gzFile file));
+extern int ZEXPORT    gzclose OF((gzFile file));
 /*
      Flushes all pending output if necessary, closes the compressed file
    and deallocates all the (de)compression state. The return value is the zlib
    error number (see function gzerror below).
 */
 
-extern const char * EXPORT gzerror OF((gzFile file, int *errnum));
+extern const char * ZEXPORT gzerror OF((gzFile file, int *errnum));
 /*
      Returns the error message for the last error which occurred on the
    given compressed file. errnum is set to zlib error number. If an
@@ -794,7 +813,7 @@ extern const char * EXPORT gzerror OF((gzFile file, int *errnum));
    compression library.
 */
 
-extern uLong EXPORT adler32 OF((uLong adler, const Bytef *buf, uInt len));
+extern uLong ZEXPORT adler32 OF((uLong adler, const Bytef *buf, uInt len));
 
 /*
      Update a running Adler-32 checksum with the bytes buf[0..len-1] and
@@ -811,7 +830,7 @@ extern uLong EXPORT adler32 OF((uLong adler, const Bytef *buf, uInt len));
      if (adler != original_adler) error();
 */
 
-extern uLong EXPORT crc32   OF((uLong crc, const Bytef *buf, uInt len));
+extern uLong ZEXPORT crc32   OF((uLong crc, const Bytef *buf, uInt len));
 /*
      Update a running crc with the bytes buf[0..len-1] and return the updated
    crc. If buf is NULL, this function returns the required initial value
@@ -833,14 +852,15 @@ extern uLong EXPORT crc32   OF((uLong crc, const Bytef *buf, uInt len));
 /* deflateInit and inflateInit are macros to allow checking the zlib version
  * and the compiler's view of z_stream:
  */
-extern int EXPORT deflateInit_ OF((z_streamp strm, int level,
+extern int ZEXPORT deflateInit_ OF((z_streamp strm, int level,
                                     const char *version, int stream_size));
-extern int EXPORT inflateInit_ OF((z_streamp strm,
+extern int ZEXPORT inflateInit_ OF((z_streamp strm,
                                     const char *version, int stream_size));
-extern int EXPORT deflateInit2_ OF((z_streamp strm, int  level, int  method,
+extern int ZEXPORT deflateInit2_ OF((z_streamp strm, int  level, int  method,
-				    int windowBits, int memLevel, int strategy,
+                                     int windowBits, int memLevel,
-				    const char *version, int stream_size));
+                                     int strategy, const char *version,
-extern int EXPORT inflateInit2_ OF((z_streamp strm, int  windowBits,
+                                     int stream_size));
+extern int ZEXPORT inflateInit2_ OF((z_streamp strm, int  windowBits,
                                      const char *version, int stream_size));
 #define deflateInit(strm, level) \
         deflateInit_((strm), (level),       ZLIB_VERSION, sizeof(z_stream))
@@ -857,9 +877,9 @@ extern int EXPORT inflateInit2_ OF((z_streamp strm, int  windowBits,
     struct internal_state {int dummy;}; /* hack for buggy compilers */
 #endif
 
-extern const char   * EXPORT zError           OF((int err));
+extern const char   * ZEXPORT zError           OF((int err));
-extern int            EXPORT inflateSyncPoint OF((z_streamp z));
+extern int            ZEXPORT inflateSyncPoint OF((z_streamp z));
-extern const uLongf * EXPORT get_crc_table    OF((void));
+extern const uLongf * ZEXPORT get_crc_table    OF((void));
 
 #ifdef __cplusplus
 }

ztest28975.c

@@ -1 +0,0 @@
-int hello() {return 0;}

zutil.c

@@ -26,7 +26,7 @@ const char *z_errmsg[10] = {
 ""};
 
 
-const char * EXPORT zlibVersion()
+const char * ZEXPORT zlibVersion()
 {
     return ZLIB_VERSION;
 }
@@ -49,7 +49,7 @@ void z_error (m)
 /* exported to allow conversion of error code to string for compress() and
  * uncompress()
  */
-const char * EXPORT zError(err)
+const char * ZEXPORT zError(err)
     int err;
 {
     return ERR_MSG(err);

zutil.h

@@ -208,7 +208,7 @@ extern const char *z_errmsg[10]; /* indexed by 2-zlib_error */
 #endif
 
 
-typedef uLong (EXPORT *check_func) OF((uLong check, const Bytef *buf,
+typedef uLong (ZEXPORT *check_func) OF((uLong check, const Bytef *buf,
 				       uInt len));
 voidpf zcalloc OF((voidpf opaque, unsigned items, unsigned size));
 void   zcfree  OF((voidpf opaque, voidpf ptr));