pull/2/head v1.0.9
Mark Adler 13 years ago
parent 6759211ad8
commit b8c9ecb076
  1. 24
      ChangeLog
  2. 12
      Makefile
  3. 12
      Makefile.in
  4. 38
      README
  5. 2
      adler32.c
  6. 4
      compress.c
  7. 11
      configure
  8. 360
      contrib/asm386/gvmat32.asm
  9. 61
      contrib/asm386/gvmat32c.c
  10. 612
      contrib/asm386/zlibvc.dsp
  11. 29
      contrib/asm386/zlibvc.dsw
  12. 781
      contrib/asm386/zlibvc.mak
  13. 4
      crc32.c
  14. 36
      deflate.c
  15. 17
      example.c
  16. 90
      gzio.c
  17. 40
      infblock.c
  18. 30
      inflate.c
  19. 161
      inftrees.c
  20. 23
      inftrees.h
  21. 3
      infutil.h
  22. 6
      minigzip.c
  23. 5
      msdos/zlib.def
  24. 6
      msdos/zlib.rc
  25. 3
      nt/zlib.dnt
  26. 2
      test.c
  27. 2
      uncompr.c
  28. 44
      zconf.h
  29. 6
      zlib.3
  30. 114
      zlib.h
  31. 1
      ztest28975.c
  32. 4
      zutil.c
  33. 2
      zutil.h

@ -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)

@ -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 [ ! $(exec_prefix)/lib ]; then mkdir $(exec_prefix)/lib; fi
-@if [ ! -d $(prefix)/include ]; then mkdir $(prefix)/include; 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; \

@ -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 [ ! $(exec_prefix)/lib ]; then mkdir $(exec_prefix)/lib; fi
-@if [ ! -d $(prefix)/include ]; then mkdir $(prefix)/include; 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; \

@ -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 main changes since 1.0.7 are:
The changes made in version 1.0.9 are documented in the file ChangeLog.
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
accepting the -O option). It works with the other cc compiler.
- zlib doesn't work on HP-UX 9.05 with some versions of /bin/cc. It works
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

@ -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;

@ -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;

11
configure vendored

@ -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

@ -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.
; -----------------------------------------------------------------------
; Set match_start to the longest match starting at the given string and
; return its length. Matches shorter or equal to prev_length are discarded,
; in which case the result is equal to prev_length and match_start is
; garbage.
; IN assertions: cur_match is the head of the hash chain for the current
; string (strstart) and its distance is <= MAX_DIST, and prev_length >= 1
; int longest_match(cur_match)
IFDEF NOUNDERLINE
;match_init proc near
; ret
;match_init endp
ELSE
;_match_init proc near
; ret
;_match_init endp
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
mov ebp,eax
; initialize or check the variables used in match.asm.
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 edx,[ebp+dep_lookahead]
cmp edx,edi
mov chain_length,edx
mov eax,[ebp+dep_lookahead]
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 ax,word ptr [esi]
mov scan,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 eax,[ebp+dep_prev]
mov prev,eax
mov ebx,dword ptr [ebp+dep_match_start]
;
mov edx,dword ptr [ebp+dep_match_start]
mov bp,scan_start
mov edx,cur_match
mov match_start,ebx
mov eax,cur_match
mov match_start,edx
mov bx,scan_end
mov eax,window
mov edi,eax
mov edx,window
mov edi,edx
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
; edx = dx = cur_match
; eax = ax = 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
je normalbeg2
and edx,7fffh
mov dx,word ptr[esi+edx*2]
cmp ecx,edx
cmp word ptr[edi+eax],bx
je normalbeg2noroll
rcontlabnoroll:
; cur_match = prev[cur_match & wmask]
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
mov dx,word ptr[esi+edx*2]
and eax,7fffh
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
mov dx,word ptr[esi+edx*2]
cmp ecx,edx
and eax,7fffh
mov ax,word ptr[esi+eax*2]
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
mov dx,word ptr[esi+edx*2]
cmp ecx,edx
jnb short exitloopshort
and eax,7fffh
mov ax,word ptr[esi+eax*2]
cmp ecx,eax
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
normalbeg2dc11:
normbeg rcontloop11,11
normalbeg2dc12:
normbeg rcontloop12,12
normbeg short rcontloop12,12
normalbeg2dc13:
normbeg rcontloop13,13
normbeg short rcontloop13,13
normalbeg2dc14:
normbeg rcontloop14,14
normbeg short rcontloop14,14
normalbeg2dc15:
normbeg rcontloop15,15
normalbeg2dc11:
normbeg rcontloop11,11
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 esi,scanrp ; esi = scan
add edi,edx ; edi = window + cur_match = match
mov edi,edx
mov esi,scan ; esi = scan
add edi,eax ; edi = window + cur_match = match
mov eax,[esi+3] ; compare manually dword at match+3
xor eax,[edi+3] ; and scan +3
mov edx,[esi+3] ; compare manually dword at match+3
xor edx,[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
repe cmpsd ;//; loop until mismatch
mov ecx,(MAX_MATCH-(2+4))/4 ; scan for at most MAX_MATCH bytes
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]
xor eax,[esi]
or al,al
mov edx,[edi-4]
xor edx,[esi]
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
jbe contloop2
; here we have finised compare, and esi contain len of equal string
cmp esi,best_len ; if len > best_len, go newbestlen
ja short newbestlen
; now we restore edx, ecx and esi, for the big loop
mov esi,prev
mov ecx,limit
mov edx,window
jmp contloop3
newbestlen:
mov best_len,esi ; len become best_len
mov match_start,edx
cmp esi,nice_match ;//; if esi >= nice_match, exit
mov ecx,scanrp
mov match_start,eax ; save new position as match_start
cmp esi,nice_match ; if best_len >= nice_match, exit
jae exitloop
add esi,window
add ecx,best_len
dec esi
mov windowlen,esi
mov bx,[ecx-1]
mov ecx,scan
mov edx,window ; restore edx=window
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 eax, ecx and esi, for the big loop :
contloop2:
; 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]
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
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
_longest_match_asm7fff endp
IFDEF NOUNDERLINE
cpudetect32 endp
ELSE
_cpudetect32 endp
ENDIF
_TEXT ends
end

@ -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)
return longest_match_asm7fff(s,cur_match);
static uInt iIsPPro=2;
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;
}

@ -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

@ -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>
{{{
}}}
###############################################################################

@ -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
################################################################################

@ -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;

@ -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,
(charf *)s->window + start, length) != EQUAL) {
if (zmemcmp(s->window + match,
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,
(unsigned)wsize);
zmemcpy(s->window, s->window+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,
more);
n = read_buf(s->strm, s->window + s->strstart + s->lookahead, more);
s->lookahead += n;
/* Initialize the hash value now that we have some input: */

@ -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);
if (uncomprLen != 7) {
fprintf(stderr, "gzread err after gzseek: %s\n", gzerror(file, &err));
gzgets(file, (char*)uncompr, uncomprLen);
uncomprLen = strlen((char*)uncompr);
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);

@ -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;
s->z_err = Z_OK;
s->z_eof = 0;
if (s == NULL || whence == SEEK_END ||
s->z_err == Z_ERRNO || s->z_err == Z_DATA_ERROR) {
return -1L;
}
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;
{

@ -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",
inflate_hufts, sizeof(inflate_huft)));
Tracev((stderr, "inflate: trees ok\n"));
if ((c = inflate_codes_new(bl, bd, tl, td, z)) == Z_NULL)
{
inflate_trees_free(td, z);
inflate_trees_free(tl, z);
r = Z_MEM_ERROR;
LEAVE
}
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;
}

@ -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;
r = Z_OK;
return r;
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 == mark[m])
if (*p == (Byte)(m < 2 ? 0 : (Byte)0xff))
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)

@ -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 */
local voidpf falloc OF((
voidpf, /* opaque pointer (not used) */
uInt, /* number of items */
uInt)); /* size of item */
inflate_huft *, /* space for trees */
uInt *, /* hufts used in space */
uIntf * )); /* space for values */
/* 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
uInt inflate_hufts;
#endif
local int huft_build(b, n, s, d, e, t, m, zs)
local int huft_build(b, n, s, d, e, t, m, hp, hn, v)
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 */
if ((q = (inflate_huft *)ZALLOC
(zs,z + 1,sizeof(inflate_huft))) == Z_NULL)
{
if (h)
inflate_trees_free(u[0], zs);
/* allocate new table */
if (*hn + z > MANY) /* (note: doesn't matter for fixed) */
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)
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)
int inflate_trees_fixed(bl, bd, tl, td, z)
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 */
z_stream z; /* for falloc function */
int f = FIXEDH; /* number of hufts left in fixed_mem */
/* set up fake z_stream for memory routines */
z.zalloc = falloc;
z.zfree = Z_NULL;
z.opaque = (voidpf)&f;
uInt f = 0; /* number of hufts used in fixed_mem */
uIntf *c; /* length list for huft_build */
uIntf *v; /* work area for huft_build */
/* allocate memory */
if ((c = (uIntf*)ZALLOC(z, 288, sizeof(uInt))) == Z_NULL)
return Z_MEM_ERROR;
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;
}

@ -27,15 +27,19 @@ struct inflate_huft_s {
} more;
};
#ifdef DEBUG
extern uInt inflate_hufts;
#endif
/* Maximum size of dynamic tree. The maximum found in a long but non-
exhaustive search was 1041 huft structures (875 for length/literals
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 */
extern int inflate_trees_free OF((
inflate_huft *, /* tables to free */
z_streamp )); /* for zfree function */
inflate_huft * FAR *, /* distance tree result */
z_streamp)); /* for memory allocation */

@ -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 */

@ -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

@ -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

@ -2,8 +2,8 @@
#define IDR_VERSION1 1
IDR_VERSION1 VERSIONINFO MOVEABLE IMPURE LOADONCALL DISCARDABLE
FILEVERSION 1,0,8,0
PRODUCTVERSION 1,0,8,0
FILEVERSION 1,0,9,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"

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

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

@ -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;

@ -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")

@ -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

114
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,
const char *version, int stream_size));
extern int EXPORT inflateInit_ OF((z_streamp strm,
extern int ZEXPORT deflateInit_ OF((z_streamp strm, int level,
const char *version, int stream_size));
extern int EXPORT deflateInit2_ OF((z_streamp strm, int level, int method,
int windowBits, int memLevel, int strategy,
extern int ZEXPORT inflateInit_ OF((z_streamp strm,
const char *version, int stream_size));
extern int EXPORT inflateInit2_ OF((z_streamp strm, int windowBits,
extern int ZEXPORT deflateInit2_ OF((z_streamp strm, int level, int method,
int windowBits, int memLevel,
int strategy, const char *version,
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 int EXPORT inflateSyncPoint OF((z_streamp z));
extern const uLongf * EXPORT get_crc_table OF((void));
extern const char * ZEXPORT zError OF((int err));
extern int ZEXPORT inflateSyncPoint OF((z_streamp z));
extern const uLongf * ZEXPORT get_crc_table OF((void));
#ifdef __cplusplus
}

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

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

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

Loading…
Cancel
Save