mirrors/zlib
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

zlib 1.0.9

Browse Source
This commit is contained in:
Mark Adler 2011-09-09 23:19:21 -07:00
parent 6759211ad8
commit b8c9ecb076
33 changed files with 1454 additions and 1459 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

24
ChangeLog
View File

@ -1,6 +1,30 @@
ChangeLog file for zlib 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) Changes in 1.0.8 (27 Jan 1998)
- fixed offsets in contrib/asm386/gvmat32.asm (Gilles Vollant) - fixed offsets in contrib/asm386/gvmat32.asm (Gilles Vollant)
- fix gzgetc and gzputc for big endian systems (Markus Oberhumer) - fix gzgetc and gzputc for big endian systems (Markus Oberhumer)

12
Makefile
View File

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

12
Makefile.in
View File

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

38
README
View File

@ -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 thread safe. The data format used by the zlib library
is described by RFCs (Request for Comments) 1950 to 1952 in the files 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 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 Dr. Dobb's Journal; a copy of the article is available in
http://web2.airmail.net/markn/articles/zlibtool/zlibtool.htm http://web2.airmail.net/markn/articles/zlibtool/zlibtool.htm
The changes made in version 1.0.8 are documented in the file ChangeLog. The changes made in version 1.0.9 are documented in the file ChangeLog.
The main changes since 1.0.7 are: The main changes since 1.0.8 are:
- added gzputs and gzgets functions
- do not clear eof flag in gzseek (Mark Diekhans)
- fix gzseek for files in transparent mode (Mark Diekhans)
- do not assume that vsprintf returns the number of bytes written (Jens Krinke)
- replace EXPORT with ZEXPORT to avoid conflict with other programs
- added compress2 in zconf.h, zlib.def, zlib.dnt
- new asm code from Gilles Vollant in contrib/asm386
- simplify the inflate code (Mark):
. Replace ZALLOC's in huft_build() with single ZALLOC in inflate_blocks_new()
. ZALLOC the length list in inflate_trees_fixed() instead of using stack
. ZALLOC the value area for huft_build() instead of using stack
. Simplify Z_FINISH check in inflate()
- fixed offsets in contrib/asm386/gvmat32.asm (Gilles Vollant)
- fix gzgetc and gzputc for big endian systems (Markus Oberhumer)
- added compress2() to allow setting the compression level
- include sys/types.h to get off_t on some systems (Marc Lehmann & QingLong)
- use constant arrays for the static trees in trees.c instead of computing
them at run time (thanks to Ken Raeburn for this suggestion). To create
trees.h, compile with GEN_TREES_H and run "make test".
- check return code of example in "make test" and display result
- pass minigzip command line options to file_compress
Unsupported third party contributions are provided in directory "contrib". 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. See contrib/visual-basic.txt for more information.
I don't know how to handle structures in Visual Basic, sorry. 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. - 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 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. 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 - 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. it works when compiled with cc.
- zlib doesn't work on HP-UX 9.05 with one cc compiler (the one not - zlib doesn't work on HP-UX 9.05 with some versions of /bin/cc. It works
accepting the -O option). It works with the other cc compiler. with other compilers. Use "make test" to check your compiler.
- For shared memory multiprocessors, the decompression code assumes that - 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 - gzdopen is not supported on RISCOS, BEOS and Mac

2
adler32.c
View File

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

4
compress.c
View File

@ -18,7 +18,7 @@
memory, Z_BUF_ERROR if there was not enough room in the output buffer, memory, Z_BUF_ERROR if there was not enough room in the output buffer,
Z_STREAM_ERROR if the level parameter is invalid. 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; Bytef *dest;
uLongf *destLen; uLongf *destLen;
const Bytef *source; 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; Bytef *dest;
uLongf *destLen; uLongf *destLen;
const Bytef *source; const Bytef *source;

11
configure vendored
View File

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

678
contrib/asm386/gvmat32.asm
View File

@ -9,40 +9,36 @@
; For Visual C++ 4.2 and ML 6.11c (version in directory \MASM611C of Win95 DDK) ; 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" ; 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; ; deflate_state *s;
; IPos cur_match; /* current match */ ; IPos cur_match; /* current match */
NbStack equ 76 NbStack equ 76
cur_match equ dword ptr[esp+NbStack-0] cur_match equ dword ptr[esp+NbStack-0]
str_s equ dword ptr[esp+NbStack-4] str_s equ dword ptr[esp+NbStack-4]
; 5 dword on top (ret,ebp,esi,edi,ebx) ; 5 dword on top (ret,ebp,esi,edi,ebx)
adrret equ dword ptr[esp+NbStack-8] adrret equ dword ptr[esp+NbStack-8]
pushebp equ dword ptr[esp+NbStack-12] pushebp equ dword ptr[esp+NbStack-12]
pushedi equ dword ptr[esp+NbStack-16] pushedi equ dword ptr[esp+NbStack-16]
pushesi equ dword ptr[esp+NbStack-20] pushesi equ dword ptr[esp+NbStack-20]
pushebx equ dword ptr[esp+NbStack-24] pushebx equ dword ptr[esp+NbStack-24]
chain_length equ dword ptr [esp+NbStack-28] chain_length equ dword ptr [esp+NbStack-28]
limit equ dword ptr [esp+NbStack-32] limit equ dword ptr [esp+NbStack-32]
best_len equ dword ptr [esp+NbStack-36] best_len equ dword ptr [esp+NbStack-36]
window equ dword ptr [esp+NbStack-40] window equ dword ptr [esp+NbStack-40]
prev equ dword ptr [esp+NbStack-44] prev equ dword ptr [esp+NbStack-44]
scan_start equ word ptr [esp+NbStack-48] 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] match_start_ptr equ dword ptr [esp+NbStack-56]
nice_match equ dword ptr [esp+NbStack-60] 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] windowlen equ dword ptr [esp+NbStack-68]
match_start equ dword ptr [esp+NbStack-72] match_start equ dword ptr [esp+NbStack-72]
strend equ dword ptr [esp+NbStack-76] strend equ dword ptr [esp+NbStack-76]
NbStackAdd equ (76-24) NbStackAdd equ (NbStack-24)
.386p .386p
@ -50,11 +46,11 @@
.MODEL FLAT .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 ; 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_chain_length equ 70h+4
dep_window equ 2ch+4 dep_window equ 2ch+4
dep_strstart equ 60h+4 dep_strstart equ 60h+4
@ -68,398 +64,496 @@ longest_match_c PROTO @lmtype
dep_lookahead equ 68h+4 dep_lookahead equ 68h+4
_TEXT segment _TEXT segment
public _longest_match_asm7fff
MAX_MATCH equ 258 IFDEF NOUNDERLINE
MIN_MATCH equ 3 public longest_match_7fff
MIN_LOOKAHEAD equ (MAX_MATCH+MIN_MATCH+1) ; 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)
IFDEF NOUNDERLINE
;match_init proc near
; ret
;match_init endp
ELSE
;_match_init proc near
; ret
;_match_init endp
ENDIF
IFDEF NOUNDERLINE
longest_match_7fff proc near
ELSE
_longest_match_7fff proc near
ENDIF
mov edx,[esp+4]
push ebp
push edi
push esi
push ebx
sub esp,NbStackAdd
; initialize or check the variables used in match.asm. ; initialize or check the variables used in match.asm.
mov ebp,edx
; chain_length = s->max_chain_length
; ----------------------------------------------------------------------- ; if (prev_length>=good_match) chain_length >>= 2
; Set match_start to the longest match starting at the given string and mov edx,[ebp+dep_chain_length]
; return its length. Matches shorter or equal to prev_length are discarded, mov ebx,[ebp+dep_prev_length]
; in which case the result is equal to prev_length and match_start is cmp [ebp+dep_good_match],ebx
; garbage. ja noshr
; IN assertions: cur_match is the head of the hash chain for the current shr edx,2
; string (strstart) and its distance is <= MAX_DIST, and prev_length >= 1
; int longest_match(cur_match)
_longest_match_asm7fff proc near
; return address
mov eax,[esp+4]
mov bx,[eax+dep_w_mask]
cmp bx,7fffh
jnz longest_match_c
push ebp
push edi
push esi
push ebx
sub esp,NbStackAdd
;//mov ebp,str_s
mov ebp,eax
mov eax,[ebp+dep_max_chain_length]
mov ebx,[ebp+dep_prev_length]
cmp [ebp+dep_good_match],ebx ; if prev_length>=good_match chain_length >>= 2
ja noshr
shr eax,2
noshr: noshr:
mov edi,[ebp+dep_nice_match] ; we increment chain_length because in the asm, the --chain_lenght is in the beginning of the loop
mov chain_length,eax inc edx
mov edx,[ebp+dep_lookahead] mov edi,[ebp+dep_nice_match]
cmp edx,edi mov chain_length,edx
;if ((uInt)nice_match > s->lookahead) nice_match = s->lookahead; mov eax,[ebp+dep_lookahead]
jae nolookaheadnicematch cmp eax,edi
mov edi,edx ; if ((uInt)nice_match > s->lookahead) nice_match = s->lookahead;
jae nolookaheadnicematch
mov edi,eax
nolookaheadnicematch: nolookaheadnicematch:
mov best_len,ebx ; 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 esi,[ebp+dep_window] mov nice_match,edi
mov ecx,[ebp+dep_strstart] ; scan = window + strstart
mov window,esi add esi,ecx
mov scan,esi
mov nice_match,edi ; dx = *window
add esi,ecx mov dx,word ptr [esi]
mov scanrp,esi ; bx = *(window+best_len-1)
mov ax,word ptr [esi] mov bx,word ptr [esi+ebx-1]
mov bx,word ptr [esi+ebx-1] add esi,MAX_MATCH-1
add esi,MAX_MATCH-1 ; scan_start = *scan
mov scan_start,ax mov scan_start,dx
mov strend,esi ; strend = scan + MAX_MATCH-1
mov scan_end,bx mov strend,esi
; bx = scan_end = *(window+best_len-1)
; IPos limit = s->strstart > (IPos)MAX_DIST(s) ? ; IPos limit = s->strstart > (IPos)MAX_DIST(s) ?
; s->strstart - (IPos)MAX_DIST(s) : NIL; ; s->strstart - (IPos)MAX_DIST(s) : NIL;
mov esi,[ebp+dep_w_size] mov esi,[ebp+dep_w_size]
sub esi,MIN_LOOKAHEAD sub esi,MIN_LOOKAHEAD
; here esi = MAX_DIST(s) ; here esi = MAX_DIST(s)
sub ecx,esi sub ecx,esi
ja nodist ja nodist
xor ecx,ecx xor ecx,ecx
nodist: nodist:
mov limit,ecx mov limit,ecx
; prev = s->prev
mov edx,[ebp+dep_prev]
mov prev,edx
;
mov edx,dword ptr [ebp+dep_match_start]
mov bp,scan_start
mov eax,cur_match
mov match_start,edx
mov edx,window
mov edi,edx
add edi,best_len
mov esi,prev
dec edi
; windowlen = window + best_len -1
mov windowlen,edi
mov eax,[ebp+dep_prev] jmp beginloop2
mov prev,eax align 4
mov ebx,dword ptr [ebp+dep_match_start]
mov bp,scan_start
mov edx,cur_match
mov match_start,ebx
mov bx,scan_end
mov eax,window
mov edi,eax
add edi,best_len
mov esi,prev
dec edi
mov windowlen,edi
jmp beginloop2
align 4
; here, in the loop ; here, in the loop
;;;; eax = chain_length ; eax = ax = cur_match
; edx = dx = cur_match
; ecx = limit ; ecx = limit
; bx = scan_end ; bx = scan_end
; bp = scan_start ; bp = scan_start
; edi = windowlen (window + best_len) ; edi = windowlen (window + best_len -1)
; esi = prev ; esi = prev
;// here; eax <=16 ;// here; chain_length <=16
normalbeg0add16: normalbeg0add16:
add chain_length,16 add chain_length,16
jz exitloop jz exitloop
normalbeg0: normalbeg0:
cmp word ptr[edi+edx-0],bx cmp word ptr[edi+eax],bx
je normalbeg2 je normalbeg2noroll
and edx,7fffh rcontlabnoroll:
mov dx,word ptr[esi+edx*2] ; cur_match = prev[cur_match & wmask]
cmp ecx,edx and eax,7fffh
jnb exitloop mov ax,word ptr[esi+eax*2]
dec chain_length ; if cur_match > limit, go to exitloop
jnz normalbeg0 cmp ecx,eax
;jnbexitloopshort1: jnb exitloop
jmp exitloop ; if --chain_length != 0, go to exitloop
dec chain_length
jnz normalbeg0
jmp exitloop
normalbeg2noroll:
; if (scan_start==*(cur_match+window)) goto normalbeg2
cmp bp,word ptr[edx+eax]
jne rcontlabnoroll
jmp normalbeg2
contloop3: contloop3:
mov edi,windowlen mov edi,windowlen
; cur_match = prev[cur_match & wmask] ; cur_match = prev[cur_match & wmask]
and edx,7fffh and eax,7fffh
mov dx,word ptr[esi+edx*2] mov ax,word ptr[esi+eax*2]
; if cur_match > limit, go to exitloop ; if cur_match > limit, go to exitloop
cmp ecx,edx cmp ecx,eax
jnbexitloopshort1: jnbexitloopshort1:
jnb exitloop jnb exitloop
; if --chain_length != 0, go to exitloop ; if --chain_length != 0, go to exitloop
; begin the main loop
beginloop2: beginloop2:
sub chain_length,16+1 sub chain_length,16+1
jna normalbeg0add16 ; if chain_length <=16, don't use the unrolled loop
jna normalbeg0add16
do16: do16:
cmp word ptr[edi+edx],bx cmp word ptr[edi+eax],bx
je normalbeg2dc0 je normalbeg2dc0
maccn MACRO lab maccn MACRO lab
and edx,7fffh and eax,7fffh
mov dx,word ptr[esi+edx*2] mov ax,word ptr[esi+eax*2]
cmp ecx,edx cmp ecx,eax
jnb exitloop jnb exitloop
cmp word ptr[edi+edx-0],bx cmp word ptr[edi+eax],bx
je lab je lab
ENDM ENDM
rcontloop0: rcontloop0:
maccn normalbeg2dc1 maccn normalbeg2dc1
rcontloop1: rcontloop1:
maccn normalbeg2dc2 maccn normalbeg2dc2
rcontloop2: rcontloop2:
maccn normalbeg2dc3 maccn normalbeg2dc3
rcontloop3: rcontloop3:
maccn normalbeg2dc4 maccn normalbeg2dc4
rcontloop4: rcontloop4:
maccn normalbeg2dc5 maccn normalbeg2dc5
rcontloop5: rcontloop5:
maccn normalbeg2dc6 maccn normalbeg2dc6
rcontloop6: rcontloop6:
maccn normalbeg2dc7 maccn normalbeg2dc7
rcontloop7: rcontloop7:
maccn normalbeg2dc8 maccn normalbeg2dc8
rcontloop8: rcontloop8:
maccn normalbeg2dc9 maccn normalbeg2dc9
rcontloop9: rcontloop9:
maccn normalbeg2dc10 maccn normalbeg2dc10
rcontloop10: rcontloop10:
maccn normalbeg2dc11 maccn short normalbeg2dc11
rcontloop11: rcontloop11:
maccn short normalbeg2dc12 maccn short normalbeg2dc12
rcontloop12: rcontloop12:
maccn short normalbeg2dc13 maccn short normalbeg2dc13
rcontloop13: rcontloop13:
maccn short normalbeg2dc14 maccn short normalbeg2dc14
rcontloop14: rcontloop14:
maccn short normalbeg2dc15 maccn short normalbeg2dc15
rcontloop15: rcontloop15:
and edx,7fffh and eax,7fffh
mov dx,word ptr[esi+edx*2] mov ax,word ptr[esi+eax*2]
cmp ecx,edx cmp ecx,eax
jnb short exitloopshort jnb exitloop
sub chain_length,16 sub chain_length,16
ja do16 ja do16
jmp normalbeg0add16 jmp normalbeg0add16
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
exitloopshort: normbeg MACRO rcontlab,valsub
jmp exitloop ; 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
normbeg MACRO rcontlab,valsub
cmp bp,word ptr[eax+edx]
jne rcontlab
add chain_length,16-valsub
jmp iseq
ENDM
normalbeg2dc12:
normbeg rcontloop12,12
normalbeg2dc13:
normbeg rcontloop13,13
normalbeg2dc14:
normbeg rcontloop14,14
normalbeg2dc15:
normbeg rcontloop15,15
normalbeg2dc11: normalbeg2dc11:
normbeg rcontloop11,11 normbeg rcontloop11,11
normalbeg2dc12:
normbeg short rcontloop12,12
normalbeg2dc13:
normbeg short rcontloop13,13
normalbeg2dc14:
normbeg short rcontloop14,14
normalbeg2dc15:
normbeg short rcontloop15,15
normalbeg2dc10: normalbeg2dc10:
normbeg rcontloop10,10 normbeg rcontloop10,10
normalbeg2dc9: normalbeg2dc9:
normbeg rcontloop9,9 normbeg rcontloop9,9
normalbeg2dc8: normalbeg2dc8:
normbeg rcontloop8,8 normbeg rcontloop8,8
normalbeg2dc7: normalbeg2dc7:
normbeg rcontloop7,7 normbeg rcontloop7,7
normalbeg2dc5:
normbeg rcontloop5,5
normalbeg2dc6: normalbeg2dc6:
normbeg rcontloop6,6 normbeg rcontloop6,6
normalbeg2dc5:
normbeg rcontloop5,5
normalbeg2dc4: normalbeg2dc4:
normbeg rcontloop4,4 normbeg rcontloop4,4
normalbeg2dc3: normalbeg2dc3:
normbeg rcontloop3,3 normbeg rcontloop3,3
normalbeg2dc2: normalbeg2dc2:
normbeg rcontloop2,2 normbeg rcontloop2,2
normalbeg2dc1: normalbeg2dc1:
normbeg rcontloop1,1 normbeg rcontloop1,1
normalbeg2dc0: normalbeg2dc0:
normbeg rcontloop0,0 normbeg rcontloop0,0
; we go in normalbeg2 because *(ushf*)(match+best_len-1) == scan_end ; we go in normalbeg2 because *(ushf*)(match+best_len-1) == scan_end
normalbeg2: normalbeg2:
mov edi,window
; 10 nop here take 10% time cmp bp,word ptr[edi+eax]
mov edi,window jne contloop3 ; if *(ushf*)match != scan_start, continue
;mov chain_length,eax ; now, we need eax...
cmp bp,word ptr[edi+edx]
jne contloop3 ; if *(ushf*)match != scan_start, continue
iseq: iseq:
; if we are here, we know that *(match+best_len-1) == scan_end
; and (match == scan_start)
mov edi,eax mov edi,edx
mov esi,scanrp ; esi = scan mov esi,scan ; esi = scan
add edi,edx ; edi = window + cur_match = match add edi,eax ; edi = window + cur_match = match
mov edx,[esi+3] ; compare manually dword at match+3
xor edx,[edi+3] ; and scan +3
mov eax,[esi+3] ; compare manually dword at match+3 jz begincompare ; if equal, go to long compare
xor eax,[edi+3] ; and scan +3
jz begincompare ; if equal, go to long compare ; we will determine the unmatch byte and calculate len (in esi)
or dl,dl
; we will determine the unmatch byte and calculate len (in esi) je eq1rr
or al,al mov esi,3
je eq1rr jmp trfinval
mov esi,3
jmp trfinval
eq1rr: eq1rr:
or ax,ax or dx,dx
je eq1 je eq1
mov esi,4 mov esi,4
jmp trfinval jmp trfinval
eq1: eq1:
shl eax,8 and edx,0ffffffh
jz eq11 jz eq11
mov esi,5 mov esi,5
jmp trfinval jmp trfinval
eq11: eq11:
mov esi,6 mov esi,6
jmp trfinval jmp trfinval
begincompare: begincompare:
; here we now scan and match begin same ; here we now scan and match begin same
add edi,6 add edi,6
add esi,6 add esi,6
mov ecx,(MAX_MATCH-(2+4))/4 ;//; scan for at most MAX_MATCH bytes mov ecx,(MAX_MATCH-(2+4))/4 ; scan for at most MAX_MATCH bytes
repe cmpsd ;//; loop until mismatch repe cmpsd ; loop until mismatch
je trfin ; go to trfin if not unmatch je trfin ; go to trfin if not unmatch
; we determine the unmatch byte ; we determine the unmatch byte
sub esi,4 sub esi,4
mov eax,[edi-4] mov edx,[edi-4]
xor eax,[esi] xor edx,[esi]
or al,al
jnz trfin or dl,dl
inc esi jnz trfin
inc esi
or ax,ax or dx,dx
jnz trfin jnz trfin
inc esi inc esi
shl eax,8 and edx,0ffffffh
jnz trfin jnz trfin
inc esi inc esi
trfin: trfin:
sub esi,scanrp ; esi = len sub esi,scan ; esi = len
trfinval: trfinval:
cmp esi,best_len ; if len <= best_len, go contloop2 ; here we have finised compare, and esi contain len of equal string
jbe contloop2 cmp esi,best_len ; if len > best_len, go newbestlen
ja short newbestlen
; now we restore edx, ecx and esi, for the big loop
mov esi,prev
mov ecx,limit
mov edx,window
jmp contloop3
mov best_len,esi ; len become best_len newbestlen:
mov best_len,esi ; len become best_len
mov match_start,edx mov match_start,eax ; save new position as match_start
cmp esi,nice_match ;//; if esi >= nice_match, exit cmp esi,nice_match ; if best_len >= nice_match, exit
mov ecx,scanrp jae exitloop
jae exitloop mov ecx,scan
add esi,window mov edx,window ; restore edx=window
add ecx,best_len add ecx,esi
dec esi add esi,edx
mov windowlen,esi
mov bx,[ecx-1]
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 : ; now we restore ecx and esi, for the big loop :
contloop2: mov esi,prev
mov esi,prev mov ecx,limit
mov ecx,limit jmp contloop3
;mov eax,chain_length
mov eax,window
jmp contloop3
exitloop: exitloop:
mov ebx,match_start ; exit : s->match_start=match_start
mov ebp,str_s mov ebx,match_start
mov dword ptr [ebp+dep_match_start],ebx mov ebp,str_s
mov eax,best_len mov ecx,best_len
add esp,NbStackAdd mov dword ptr [ebp+dep_match_start],ebx
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
pop ebx
pop esi
pop edi
pop ebp
ret
_longest_match_asm7fff endp IFDEF NOUNDERLINE
longest_match_7fff endp
ELSE
_longest_match_7fff endp
ENDIF
IFDEF NOUNDERLINE
cpudetect32 proc near
ELSE
_cpudetect32 proc near
ENDIF
pushfd ; push original EFLAGS
pop eax ; get original EFLAGS
mov ecx, eax ; save original EFLAGS
xor eax, 40000h ; flip AC bit in EFLAGS
push eax ; save new EFLAGS value on stack
popfd ; replace current EFLAGS value
pushfd ; get new EFLAGS
pop eax ; store new EFLAGS in EAX
xor eax, ecx ; can’t toggle AC bit, processor=80386
jz end_cpu_is_386 ; jump if 80386 processor
push ecx
popfd ; restore AC bit in EFLAGS first
pushfd
pushfd
pop ecx
mov eax, ecx ; get original EFLAGS
xor eax, 200000h ; flip ID bit in EFLAGS
push eax ; save new EFLAGS value on stack
popfd ; replace current EFLAGS value
pushfd ; get new EFLAGS
pop eax ; store new EFLAGS in EAX
popfd ; restore original EFLAGS
xor eax, ecx ; can’t toggle ID bit,
je is_old_486 ; processor=old
mov eax,1
db 0fh,0a2h ;CPUID
exitcpudetect:
ret
end_cpu_is_386:
mov eax,0300h
jmp exitcpudetect
is_old_486:
mov eax,0400h
jmp exitcpudetect
IFDEF NOUNDERLINE
cpudetect32 endp
ELSE
_cpudetect32 endp
ENDIF
_TEXT ends _TEXT ends
end end

63
contrib/asm386/gvmat32c.c
View File

@ -7,7 +7,6 @@
* (assembly code is faster with a fixed wmask) * (assembly code is faster with a fixed wmask)
* *
*/ */
//#pragma optimize("agt",on)
#include "deflate.h" #include "deflate.h"
@ -15,65 +14,31 @@
#include <windows.h> #include <windows.h>
#ifdef ASMV #ifdef ASMV
#define NIL 0 #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 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, /* if your C compiler don't add underline before function name,
define ADD_UNDERLINE_ASMFUNC */ define ADD_UNDERLINE_ASMFUNC */
#ifdef ADD_UNDERLINE_ASMFUNC #ifdef ADD_UNDERLINE_ASMFUNC
#define longest_match_asm7fff _longest_match_asm7fff #define longest_match_7fff _longest_match_7fff
#endif #endif
void match_init() void match_init()
{ {
} }
unsigned long cpudetect32();
uInt longest_match_c( uInt longest_match_c(
deflate_state *s, deflate_state *s,
IPos cur_match); /* current match */ IPos cur_match); /* current match */
uInt longest_match_asm7fff( uInt longest_match_7fff(
deflate_state *s, deflate_state *s,
IPos cur_match); /* current match */ IPos cur_match); /* current match */
@ -81,9 +46,15 @@ uInt longest_match(
deflate_state *s, deflate_state *s,
IPos cur_match) /* current match */ IPos cur_match) /* current match */
{ {
if (s->w_mask == 0x7fff) static uInt iIsPPro=2;
return longest_match_asm7fff(s,cur_match);
return longest_match_c(s,cur_match); if ((s->w_mask == 0x7fff) && (iIsPPro==0))
return longest_match_7fff(s,cur_match);
if (iIsPPro==2)
iIsPPro = (((cpudetect32()/0x100)&0xf)>=6) ? 1 : 0;
return longest_match_c(s,cur_match);
} }
@ -222,7 +193,7 @@ uInt longest_match_c(s, cur_match)
} while ((cur_match = prev[cur_match & wmask]) > limit } while ((cur_match = prev[cur_match & wmask]) > limit
&& --chain_length != 0); && --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; return s->lookahead;
} }

612
contrib/asm386/zlibvc.dsp Normal file
View File

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

29
contrib/asm386/zlibvc.dsw Normal file
View File

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

781
contrib/asm386/zlibvc.mak
View File

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

4
crc32.c
View File

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

36
deflate.c
View File

@ -52,7 +52,7 @@
#include "deflate.h" #include "deflate.h"
const char deflate_copyright[] = 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 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 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 lm_init OF((deflate_state *s));
local void putShortMSB OF((deflate_state *s, uInt b)); local void putShortMSB OF((deflate_state *s, uInt b));
local void flush_pending OF((z_streamp strm)); 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 #ifdef ASMV
void match_init OF((void)); /* asm code initialization */ void match_init OF((void)); /* asm code initialization */
uInt longest_match OF((deflate_state *s, IPos cur_match)); 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) \ #define CLEAR_HASH(s) \
s->head[s->hash_size-1] = NIL; \ 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; z_streamp strm;
int level; int level;
const char *version; 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) version, stream_size)
z_streamp strm; z_streamp strm;
int level; 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; z_streamp strm;
const Bytef *dictionary; const Bytef *dictionary;
uInt dictLength; uInt dictLength;
@ -299,7 +299,7 @@ int EXPORT deflateSetDictionary (strm, dictionary, dictLength)
dictionary += dictLength - length; /* use the tail of the dictionary */ dictionary += dictLength - length; /* use the tail of the dictionary */
#endif #endif
} }
zmemcpy((charf *)s->window, dictionary, length); zmemcpy(s->window, dictionary, length);
s->strstart = length; s->strstart = length;
s->block_start = (long)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; z_streamp strm;
{ {
deflate_state *s; 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; z_streamp strm;
int level; int level;
int strategy; int strategy;
@ -421,7 +421,7 @@ local void flush_pending(strm)
} }
/* ========================================================================= */ /* ========================================================================= */
int EXPORT deflate (strm, flush) int ZEXPORT deflate (strm, flush)
z_streamp strm; z_streamp strm;
int flush; int flush;
{ {
@ -555,7 +555,7 @@ int EXPORT deflate (strm, flush)
} }
/* ========================================================================= */ /* ========================================================================= */
int EXPORT deflateEnd (strm) int ZEXPORT deflateEnd (strm)
z_streamp strm; z_streamp strm;
{ {
int status; int status;
@ -585,7 +585,7 @@ int EXPORT deflateEnd (strm)
* To simplify the source, this is not supported for 16-bit MSDOS (which * To simplify the source, this is not supported for 16-bit MSDOS (which
* doesn't have enough memory anyway to duplicate compression states). * 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 dest;
z_streamp source; z_streamp source;
{ {
@ -647,7 +647,7 @@ int EXPORT deflateCopy (dest, source)
*/ */
local int read_buf(strm, buf, size) local int read_buf(strm, buf, size)
z_streamp strm; z_streamp strm;
charf *buf; Bytef *buf;
unsigned size; unsigned size;
{ {
unsigned len = strm->avail_in; unsigned len = strm->avail_in;
@ -857,8 +857,8 @@ local void check_match(s, start, match, length)
int length; int length;
{ {
/* check that the match is indeed a match */ /* check that the match is indeed a match */
if (zmemcmp((charf *)s->window + match, if (zmemcmp(s->window + match,
(charf *)s->window + start, length) != EQUAL) { s->window + start, length) != EQUAL) {
fprintf(stderr, " start %u, match %u, length %d\n", fprintf(stderr, " start %u, match %u, length %d\n",
start, match, length); start, match, length);
do { do {
@ -911,8 +911,7 @@ local void fill_window(s)
*/ */
} else if (s->strstart >= wsize+MAX_DIST(s)) { } else if (s->strstart >= wsize+MAX_DIST(s)) {
zmemcpy((charf *)s->window, (charf *)s->window+wsize, zmemcpy(s->window, s->window+wsize, (unsigned)wsize);
(unsigned)wsize);
s->match_start -= wsize; s->match_start -= wsize;
s->strstart -= wsize; /* we now have strstart >= MAX_DIST */ s->strstart -= wsize; /* we now have strstart >= MAX_DIST */
s->block_start -= (long) wsize; s->block_start -= (long) wsize;
@ -956,8 +955,7 @@ local void fill_window(s)
*/ */
Assert(more >= 2, "more < 2"); Assert(more >= 2, "more < 2");
n = read_buf(s->strm, (charf *)s->window + s->strstart + s->lookahead, n = read_buf(s->strm, s->window + s->strstart + s->lookahead, more);
more);
s->lookahead += n; s->lookahead += n;
/* Initialize the hash value now that we have some input: */ /* Initialize the hash value now that we have some input: */

17
example.c
View File

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

92
gzio.c
View File

@ -167,7 +167,7 @@ local gzFile gz_open (path, mode, fd)
/* =========================================================================== /* ===========================================================================
Opens a gzip (.gz) file for reading or writing. Opens a gzip (.gz) file for reading or writing.
*/ */
gzFile EXPORT gzopen (path, mode) gzFile ZEXPORT gzopen (path, mode)
const char *path; const char *path;
const char *mode; 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 Associate a gzFile with the file descriptor fd. fd is not dup'ed here
to mimic the behavio(u)r of fdopen. to mimic the behavio(u)r of fdopen.
*/ */
gzFile EXPORT gzdopen (fd, mode) gzFile ZEXPORT gzdopen (fd, mode)
int fd; int fd;
const char *mode; const char *mode;
{ {
@ -193,7 +193,7 @@ gzFile EXPORT gzdopen (fd, mode)
/* =========================================================================== /* ===========================================================================
* Update the compression level and strategy * Update the compression level and strategy
*/ */
int EXPORT gzsetparams (file, level, strategy) int ZEXPORT gzsetparams (file, level, strategy)
gzFile file; gzFile file;
int level; int level;
int strategy; int strategy;
@ -339,7 +339,7 @@ local int destroy (s)
Reads the given number of uncompressed bytes from the compressed file. Reads the given number of uncompressed bytes from the compressed file.
gzread returns the number of bytes actually read (0 for end of 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; gzFile file;
voidp buf; voidp buf;
unsigned len; 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->stream.avail_out -= fread(next_out, 1, s->stream.avail_out,
s->file); 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) { 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 Reads one byte from the compressed file. gzgetc returns this byte
or -1 in case of end of file or error. or -1 in case of end of file or error.
*/ */
int EXPORT gzgetc(file) int ZEXPORT gzgetc(file)
gzFile file; gzFile file;
{ {
unsigned char c; 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 #ifndef NO_DEFLATE
/* =========================================================================== /* ===========================================================================
Writes the given number of uncompressed bytes into the compressed file. Writes the given number of uncompressed bytes into the compressed file.
gzwrite returns the number of bytes actually written (0 in case of error). 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; gzFile file;
const voidp buf; const voidp buf;
unsigned len; unsigned len;
@ -478,7 +504,7 @@ int EXPORT gzwrite (file, buf, len)
#ifdef STDC #ifdef STDC
#include <stdarg.h> #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]; char buf[Z_BUFSIZE];
va_list va; va_list va;
@ -486,18 +512,19 @@ int EXPORTVA gzprintf (gzFile file, const char *format, /* args */ ...)
va_start(va, format); va_start(va, format);
#ifdef HAS_vsnprintf #ifdef HAS_vsnprintf
len = vsnprintf(buf, sizeof(buf), format, va); (void)vsnprintf(buf, sizeof(buf), format, va);
#else #else
len = vsprintf(buf, format, va); (void)vsprintf(buf, format, va);
#endif #endif
va_end(va); va_end(va);
len = strlen(buf); /* some *sprintf don't return the nb of bytes written */
if (len <= 0) return 0; if (len <= 0) return 0;
return gzwrite(file, buf, (unsigned)len); return gzwrite(file, buf, (unsigned)len);
} }
#else /* not ANSI C */ #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) a11, a12, a13, a14, a15, a16, a17, a18, a19, a20)
gzFile file; gzFile file;
const char *format; 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. Writes c, converted to an unsigned char, into the compressed file.
gzputc returns the value that was written, or -1 in case of error. 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; gzFile file;
int c; 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 Flushes all pending output into the compressed file. The parameter
flush is as in the deflate() function. 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; return s->z_err == Z_STREAM_END ? Z_OK : s->z_err;
} }
int EXPORT gzflush (file, flush) int ZEXPORT gzflush (file, flush)
gzFile file; gzFile file;
int flush; int flush;
{ {
@ -599,17 +639,17 @@ int EXPORT gzflush (file, flush)
SEEK_END is not implemented, returns error. SEEK_END is not implemented, returns error.
In this version of the library, gzseek can be extremely slow. 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; gzFile file;
z_off_t offset; z_off_t offset;
int whence; int whence;
{ {
gz_stream *s = (gz_stream*)file; gz_stream *s = (gz_stream*)file;
if (s == NULL || whence == SEEK_END || s->z_err == Z_ERRNO) return -1L; if (s == NULL || whence == SEEK_END ||
s->z_err == Z_ERRNO || s->z_err == Z_DATA_ERROR) {
s->z_err = Z_OK; return -1L;
s->z_eof = 0; }
if (s->mode == 'w') { if (s->mode == 'w') {
#ifdef NO_DEFLATE #ifdef NO_DEFLATE
@ -639,8 +679,6 @@ z_off_t EXPORT gzseek (file, offset, whence)
} }
/* Rest of function is for reading only */ /* Rest of function is for reading only */
if (s->z_err == Z_DATA_ERROR) return -1L;
/* compute absolute position */ /* compute absolute position */
if (whence == SEEK_CUR) { if (whence == SEEK_CUR) {
offset += s->stream.total_out; offset += s->stream.total_out;
@ -651,7 +689,9 @@ z_off_t EXPORT gzseek (file, offset, whence)
/* map to fseek */ /* map to fseek */
s->stream.avail_in = 0; s->stream.avail_in = 0;
s->stream.next_in = s->inbuf; s->stream.next_in = s->inbuf;
if (fseek(s->file, offset, SEEK_SET) < 0) return -1L; if (fseek(s->file, offset, SEEK_SET) < 0) return -1L;
s->stream.total_in = s->stream.total_out = (uLong)offset;
return offset; return offset;
} }
@ -680,7 +720,7 @@ z_off_t EXPORT gzseek (file, offset, whence)
/* =========================================================================== /* ===========================================================================
Rewinds input file. Rewinds input file.
*/ */
int EXPORT gzrewind (file) int ZEXPORT gzrewind (file)
gzFile file; gzFile file;
{ {
gz_stream *s = (gz_stream*)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 given compressed file. This position represents a number of bytes in the
uncompressed data stream. uncompressed data stream.
*/ */
z_off_t EXPORT gztell (file) z_off_t ZEXPORT gztell (file)
gzFile file; gzFile file;
{ {
return gzseek(file, 0L, SEEK_CUR); 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 Returns 1 when EOF has previously been detected reading the given
input stream, otherwise zero. input stream, otherwise zero.
*/ */
int EXPORT gzeof (file) int ZEXPORT gzeof (file)
gzFile file; gzFile file;
{ {
gz_stream *s = (gz_stream*)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 Flushes all pending output if necessary, closes the compressed file
and deallocates all the (de)compression state. and deallocates all the (de)compression state.
*/ */
int EXPORT gzclose (file) int ZEXPORT gzclose (file)
gzFile file; gzFile file;
{ {
int err; int err;
@ -788,7 +828,7 @@ int EXPORT gzclose (file)
errnum is set to Z_ERRNO and the application may consult errno errnum is set to Z_ERRNO and the application may consult errno
to get the exact error code. to get the exact error code.
*/ */
const char* EXPORT gzerror (file, errnum) const char* ZEXPORT gzerror (file, errnum)
gzFile file; gzFile file;
int *errnum; int *errnum;
{ {

40
infblock.c
View File

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

32
inflate.c
View File

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

159
inftrees.c
View File

@ -7,7 +7,7 @@
#include "inftrees.h" #include "inftrees.h"
const char inflate_copyright[] = 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 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 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 */ const uIntf *, /* list of extra bits for non-simple codes */
inflate_huft * FAR*,/* result: starting table */ inflate_huft * FAR*,/* result: starting table */
uIntf *, /* maximum lookup bits (returns actual) */ uIntf *, /* maximum lookup bits (returns actual) */
z_streamp )); /* for zalloc function */ inflate_huft *, /* space for trees */
uInt *, /* hufts used in space */
local voidpf falloc OF(( uIntf * )); /* space for values */
voidpf, /* opaque pointer (not used) */
uInt, /* number of items */
uInt)); /* size of item */
/* Tables for deflate from PKZIP's appnote.txt. */ /* Tables for deflate from PKZIP's appnote.txt. */
local const uInt cplens[31] = { /* Copy lengths for literal codes 257..285 */ 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. */ /* 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 BMAX 15 /* maximum bit length of any code */
#define N_MAX 288 /* maximum number of codes in any set */
#ifdef DEBUG local int huft_build(b, n, s, d, e, t, m, hp, hn, v)
uInt inflate_hufts;
#endif
local int huft_build(b, n, s, d, e, t, m, zs)
uIntf *b; /* code lengths in bits (all assumed <= BMAX) */ 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) */ uInt s; /* number of simple-valued codes (0..s-1) */
const uIntf *d; /* list of base values for non-simple codes */ const uIntf *d; /* list of base values for non-simple codes */
const uIntf *e; /* list of extra bits for non-simple codes */ const uIntf *e; /* list of extra bits for non-simple codes */
inflate_huft * FAR *t; /* result: starting table */ inflate_huft * FAR *t; /* result: starting table */
uIntf *m; /* maximum lookup bits, returns actual */ 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 /* 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 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 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 uInt j; /* counter */
register int k; /* number of bits in current code */ register int k; /* number of bits in current code */
int l; /* bits per table (returned in m) */ 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[] */ register uIntf *p; /* pointer into c[], b[], or v[] */
inflate_huft *q; /* points to current table */ inflate_huft *q; /* points to current table */
struct inflate_huft_s r; /* table entry for structure assignment */ struct inflate_huft_s r; /* table entry for structure assignment */
inflate_huft *u[BMAX]; /* table stack */ 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) */ register int w; /* bits before this table == (l * h) */
uInt x[BMAX+1]; /* bit offsets, then code stack */ uInt x[BMAX+1]; /* bit offsets, then code stack */
uIntf *xp; /* pointer into x */ uIntf *xp; /* pointer into x */
@ -233,20 +227,16 @@ z_streamp zs; /* for zalloc function */
} }
z = 1 << j; /* table entries for j-bit table */ z = 1 << j; /* table entries for j-bit table */
/* allocate and link in new table */ /* allocate new table */
if ((q = (inflate_huft *)ZALLOC if (*hn + z > MANY) /* (note: doesn't matter for fixed) */
(zs,z + 1,sizeof(inflate_huft))) == Z_NULL)
{
if (h)
inflate_trees_free(u[0], zs);
return Z_MEM_ERROR; /* not enough memory */ 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 */ /* connect to last table, if there is one */
if (h) if (h)
@ -286,10 +276,12 @@ z_streamp zs; /* for zalloc function */
i ^= j; i ^= j;
/* backup over finished tables */ /* 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 */ h--; /* don't need to update q */
w -= l; 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 *c; /* 19 code lengths */
uIntf *bb; /* bits tree desired/actual depth */ uIntf *bb; /* bits tree desired/actual depth */
inflate_huft * FAR *tb; /* bits tree result */ 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; 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) if (r == Z_DATA_ERROR)
z->msg = (char*)"oversubscribed dynamic bit lengths tree"; z->msg = (char*)"oversubscribed dynamic bit lengths tree";
else if (r == Z_BUF_ERROR || *bb == 0) else if (r == Z_BUF_ERROR || *bb == 0)
{ {
inflate_trees_free(*tb, z);
z->msg = (char*)"incomplete dynamic bit lengths tree"; z->msg = (char*)"incomplete dynamic bit lengths tree";
r = Z_DATA_ERROR; r = Z_DATA_ERROR;
} }
ZFREE(z, v);
return r; 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 nl; /* number of literal/length codes */
uInt nd; /* number of distance codes */ uInt nd; /* number of distance codes */
uIntf *c; /* that many (total) code lengths */ 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 */ uIntf *bd; /* distance desired/actual bit depth */
inflate_huft * FAR *tl; /* literal/length tree result */ inflate_huft * FAR *tl; /* literal/length tree result */
inflate_huft * FAR *td; /* distance 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; 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 */ /* 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_OK || *bl == 0)
{ {
if (r == Z_DATA_ERROR) if (r == Z_DATA_ERROR)
z->msg = (char*)"oversubscribed literal/length tree"; z->msg = (char*)"oversubscribed literal/length tree";
else if (r != Z_MEM_ERROR) else if (r != Z_MEM_ERROR)
{ {
inflate_trees_free(*tl, z);
z->msg = (char*)"incomplete literal/length tree"; z->msg = (char*)"incomplete literal/length tree";
r = Z_DATA_ERROR; r = Z_DATA_ERROR;
} }
ZFREE(z, v);
return r; return r;
} }
/* build distance tree */ /* 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_OK || (*bd == 0 && nl > 257))
{ {
if (r == Z_DATA_ERROR) if (r == Z_DATA_ERROR)
@ -359,7 +364,6 @@ z_streamp z; /* for zfree function */
r = Z_OK; r = Z_OK;
} }
#else #else
inflate_trees_free(*td, z);
z->msg = (char*)"incomplete distance tree"; z->msg = (char*)"incomplete distance tree";
r = Z_DATA_ERROR; r = Z_DATA_ERROR;
} }
@ -368,19 +372,20 @@ z_streamp z; /* for zfree function */
z->msg = (char*)"empty distance tree with lengths"; z->msg = (char*)"empty distance tree with lengths";
r = Z_DATA_ERROR; r = Z_DATA_ERROR;
} }
inflate_trees_free(*tl, z); ZFREE(z, v);
return r; return r;
#endif #endif
} }
/* done */ /* done */
ZFREE(z, v);
return Z_OK; return Z_OK;
} }
/* build fixed tables only once--keep them here */ /* build fixed tables only once--keep them here */
local int fixed_built = 0; 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 inflate_huft fixed_mem[FIXEDH];
local uInt fixed_bl; local uInt fixed_bl;
local uInt fixed_bd; local uInt fixed_bd;
@ -388,36 +393,29 @@ local inflate_huft *fixed_tl;
local inflate_huft *fixed_td; local inflate_huft *fixed_td;
local voidpf falloc(q, n, s) int inflate_trees_fixed(bl, bd, tl, td, z)
voidpf q; /* opaque pointer */
uInt n; /* number of items */
uInt s; /* size of item */
{
Assert(s == sizeof(inflate_huft) && n <= *(intf *)q,
"inflate_trees falloc overflow");
*(intf *)q -= n+s-s; /* s-s to avoid warning */
return (voidpf)(fixed_mem + *(intf *)q);
}
int inflate_trees_fixed(bl, bd, tl, td)
uIntf *bl; /* literal desired/actual bit depth */ uIntf *bl; /* literal desired/actual bit depth */
uIntf *bd; /* distance desired/actual bit depth */ uIntf *bd; /* distance desired/actual bit depth */
inflate_huft * FAR *tl; /* literal/length tree result */ inflate_huft * FAR *tl; /* literal/length tree result */
inflate_huft * FAR *td; /* distance 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) */ /* build fixed tables if not already (multiple overlapped executions ok) */
if (!fixed_built) if (!fixed_built)
{ {
int k; /* temporary variable */ int k; /* temporary variable */
unsigned c[288]; /* length list for huft_build */ uInt f = 0; /* number of hufts used in fixed_mem */
z_stream z; /* for falloc function */ uIntf *c; /* length list for huft_build */
int f = FIXEDH; /* number of hufts left in fixed_mem */ uIntf *v; /* work area for huft_build */
/* set up fake z_stream for memory routines */ /* allocate memory */
z.zalloc = falloc; if ((c = (uIntf*)ZALLOC(z, 288, sizeof(uInt))) == Z_NULL)
z.zfree = Z_NULL; return Z_MEM_ERROR;
z.opaque = (voidpf)&f; if ((v = (uIntf*)ZALLOC(z, 288, sizeof(uInt))) == Z_NULL)
{
ZFREE(z, c);
return Z_MEM_ERROR;
}
/* literal table */ /* literal table */
for (k = 0; k < 144; k++) for (k = 0; k < 144; k++)
@ -429,16 +427,19 @@ inflate_huft * FAR *td; /* distance tree result */
for (; k < 288; k++) for (; k < 288; k++)
c[k] = 8; c[k] = 8;
fixed_bl = 7; 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 */ /* distance table */
for (k = 0; k < 30; k++) for (k = 0; k < 30; k++)
c[k] = 5; c[k] = 5;
fixed_bd = 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 */ /* done */
Assert(f == 0, "invalid build of fixed tables"); ZFREE(z, v);
ZFREE(z, c);
fixed_built = 1; fixed_built = 1;
} }
*bl = fixed_bl; *bl = fixed_bl;
@ -447,33 +448,3 @@ inflate_huft * FAR *td; /* distance tree result */
*td = fixed_td; *td = fixed_td;
return Z_OK; 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;
}

23
inftrees.h
View File

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

3
infutil.h
View File

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

6
minigzip.c
View File

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

5
msdos/zlib.def
View File

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

6
msdos/zlib.rc
View File

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

3
nt/zlib.dnt
View File

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

2
test.c
View File

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

2
uncompr.c
View File

@ -22,7 +22,7 @@
enough memory, Z_BUF_ERROR if there was not enough room in the output 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. 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; Bytef *dest;
uLongf *destLen; uLongf *destLen;
const Bytef *source; const Bytef *source;

44
zconf.h
View File

@ -30,6 +30,7 @@
# define inflateSyncPoint z_inflateSyncPoint # define inflateSyncPoint z_inflateSyncPoint
# define inflateReset z_inflateReset # define inflateReset z_inflateReset
# define compress z_compress # define compress z_compress
# define compress2 z_compress2
# define uncompress z_uncompress # define uncompress z_uncompress
# define adler32 z_adler32 # define adler32 z_adler32
# define crc32 z_crc32 # define crc32 z_crc32
@ -158,6 +159,29 @@
# define FAR __far # define FAR __far
# endif # endif
#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 #ifndef FAR
# define FAR # define FAR
#endif #endif
@ -198,26 +222,6 @@ typedef uLong FAR uLongf;
# define z_off_t long # define z_off_t long
#endif #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 */ /* MVS linker does not support external names larger than 8 bytes */
#if defined(__MVS__) #if defined(__MVS__)
# pragma map(deflateInit_,"DEIN") # pragma map(deflateInit_,"DEIN")

6
zlib.3
View File

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

152
zlib.h
View File

@ -1,5 +1,5 @@
/* zlib.h -- interface of the 'zlib' general purpose compression library /* 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 Copyright (C) 1995-1998 Jean-loup Gailly and Mark Adler
@ -37,7 +37,7 @@ extern "C" {
#include "zconf.h" #include "zconf.h"
#define ZLIB_VERSION "1.0.8" #define ZLIB_VERSION "1.0.9"
/* /*
The 'zlib' compression library provides in-memory compression and The 'zlib' compression library provides in-memory compression and
@ -101,6 +101,9 @@ typedef z_stream FAR *z_streamp;
opaque value. opaque value.
zalloc must return Z_NULL if there is not enough memory for the object. 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 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 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, 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 */ /* 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. /* The application can compare zlibVersion and ZLIB_VERSION for consistency.
If the first character differs, the library code actually used is If the first character differs, the library code actually used is
not compatible with the zlib.h header file used by the application. 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 Initializes the internal stream state for compression. The fields
zalloc, zfree and opaque must be initialized before by the caller. 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 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 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. All dynamically allocated data structures for this stream are freed.
This function discards any unprocessed input and does not flush any 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 Initializes the internal stream state for decompression. The fields
next_in, avail_in, zalloc, zfree and opaque must be initialized before by 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 inflate decompresses as much data as possible, and stops when the input
buffer becomes empty or the output buffer becomes full. It may some 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. All dynamically allocated data structures for this stream are freed.
This function discards any unprocessed input and does not flush any This function discards any unprocessed input and does not flush any
@ -394,12 +397,12 @@ 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 level,
int method, int method,
int windowBits, int windowBits,
int memLevel, int memLevel,
int strategy)); int strategy));
This is another version of deflateInit with more compression options. The This is another version of deflateInit with more compression options. The
fields next_in, zalloc, zfree and opaque must be initialized before by fields next_in, zalloc, zfree and opaque must be initialized before by
@ -437,9 +440,9 @@ extern int EXPORT deflateInit2 OF((z_streamp strm,
not perform any compression: this will be done by deflate(). 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, const Bytef *dictionary,
uInt dictLength)); uInt dictLength));
/* /*
Initializes the compression dictionary from the given byte sequence Initializes the compression dictionary from the given byte sequence
without producing any compressed output. This function must be called without producing any compressed output. This function must be called
@ -473,8 +476,8 @@ extern int EXPORT deflateSetDictionary OF((z_streamp strm,
perform any compression: this will be done by deflate(). 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)); z_streamp source));
/* /*
Sets the destination stream as a complete copy of the source stream. 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. 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, This function is equivalent to deflateEnd followed by deflateInit,
but does not free and reallocate all the internal compression state. 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). 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 Dynamically update the compression level and compression strategy. The
interpretation of level and strategy is as in deflateInit2. This can be interpretation of level and strategy is as in deflateInit2. This can be
@ -522,8 +525,8 @@ 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)); int windowBits));
This is another version of inflateInit with an extra parameter. The This is another version of inflateInit with an extra parameter. The
fields next_in, avail_in, zalloc, zfree and opaque must be initialized fields next_in, avail_in, zalloc, zfree and opaque must be initialized
@ -544,9 +547,9 @@ extern int EXPORT inflateInit2 OF((z_streamp strm,
modified, but next_out and avail_out are unchanged.) 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, const Bytef *dictionary,
uInt dictLength)); uInt dictLength));
/* /*
Initializes the decompression dictionary from the given uncompressed byte Initializes the decompression dictionary from the given uncompressed byte
sequence. This function must be called immediately after a call of inflate sequence. This function must be called immediately after a call of inflate
@ -563,7 +566,7 @@ extern int EXPORT inflateSetDictionary OF((z_streamp strm,
inflate(). 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 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 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. 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, This function is equivalent to inflateEnd followed by inflateInit,
but does not free and reallocate all the internal decompression state. but does not free and reallocate all the internal decompression state.
@ -599,8 +602,8 @@ extern int EXPORT inflateReset OF((z_streamp strm));
utility functions can easily be modified if you need special options. 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)); const Bytef *source, uLong sourceLen));
/* /*
Compresses the source buffer into the destination buffer. sourceLen is Compresses the source buffer into the destination buffer. sourceLen is
the byte length of the source buffer. Upon entry, destLen is the total the byte length of the source buffer. Upon entry, destLen is the total
@ -614,9 +617,9 @@ extern int EXPORT compress OF((Bytef *dest, uLongf *destLen,
buffer. buffer.
*/ */
extern int EXPORT compress2 OF((Bytef *dest, uLongf *destLen, extern int ZEXPORT compress2 OF((Bytef *dest, uLongf *destLen,
const Bytef *source, uLong sourceLen, const Bytef *source, uLong sourceLen,
int level)); int level));
/* /*
Compresses the source buffer into the destination buffer. The level Compresses the source buffer into the destination buffer. The level
parameter has the same meaning as in deflateInit. sourceLen is the byte parameter has the same meaning as in deflateInit. sourceLen is the byte
@ -629,8 +632,8 @@ extern int EXPORT compress2 OF((Bytef *dest, uLongf *destLen,
Z_STREAM_ERROR if the level parameter is invalid. 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)); const Bytef *source, uLong sourceLen));
/* /*
Decompresses the source buffer into the destination buffer. sourceLen is Decompresses the source buffer into the destination buffer. sourceLen is
the byte length of the source buffer. Upon entry, destLen is the total the byte length of the source buffer. Upon entry, destLen is the total
@ -650,7 +653,7 @@ extern int EXPORT uncompress OF((Bytef *dest, uLongf *destLen,
typedef voidp gzFile; 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 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 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 can be checked to distinguish the two cases (if errno is zero, the
zlib error is Z_MEM_ERROR). */ 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 gzdopen() associates a gzFile with the file descriptor fd. File
descriptors are obtained from calls like open, dup, creat, pipe or 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. 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 Dynamically update the compression level or strategy. See the description
of deflateInit2 for the meaning of these parameters. 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. 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. 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 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 gzread returns the number of uncompressed bytes actually read (0 for
end of file, -1 for error). */ 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. Writes the given number of uncompressed bytes into the compressed file.
gzwrite returns the number of uncompressed bytes actually written gzwrite returns the number of uncompressed bytes actually written
(0 in case of error). (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 Converts, formats, and writes the args to the compressed file under
control of the format string, as in fprintf. gzprintf returns the number of control of the format string, as in fprintf. gzprintf returns the number of
uncompressed bytes actually written (0 in case of error). 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. Writes c, converted to an unsigned char, into the compressed file.
gzputc returns the value that was written, or -1 in case of error. 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 Reads one byte from the compressed file. gzgetc returns this byte
or -1 in case of end of file or error. 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 Flushes all pending output into the compressed file. The parameter
flush is as in the deflate() function. The return value is the zlib 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. 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 Sets the starting position for the next gzread or gzwrite on the given
compressed file. The offset represents a number of bytes in the 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. 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. Rewinds the given file. This function is supported only for reading.
gzrewind(file) is equivalent to (int)gzseek(file, 0L, SEEK_SET) 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 Returns the starting position for the next gzread or gzwrite on the
given compressed file. This position represents a number of bytes in 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) 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 Returns 1 when EOF has previously been detected reading the given
input stream, otherwise zero. 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 Flushes all pending output if necessary, closes the compressed file
and deallocates all the (de)compression state. The return value is the zlib and deallocates all the (de)compression state. The return value is the zlib
error number (see function gzerror below). 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 Returns the error message for the last error which occurred on the
given compressed file. errnum is set to zlib error number. If an 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. 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 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(); 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 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 crc. If buf is NULL, this function returns the required initial value
@ -833,22 +852,23 @@ extern uLong EXPORT crc32 OF((uLong crc, const Bytef *buf, uInt len));
/* deflateInit and inflateInit are macros to allow checking the zlib version /* deflateInit and inflateInit are macros to allow checking the zlib version
* and the compiler's view of z_stream: * and the compiler's view of z_stream:
*/ */
extern int EXPORT deflateInit_ OF((z_streamp strm, int level, extern int ZEXPORT deflateInit_ OF((z_streamp strm, int level,
const char *version, int stream_size)); const char *version, int stream_size));
extern int EXPORT inflateInit_ OF((z_streamp strm, extern int ZEXPORT inflateInit_ OF((z_streamp strm,
const char *version, int stream_size)); const char *version, int stream_size));
extern int EXPORT deflateInit2_ OF((z_streamp strm, int level, int method, extern int ZEXPORT deflateInit2_ OF((z_streamp strm, int level, int method,
int windowBits, int memLevel, int strategy, int windowBits, int memLevel,
const char *version, int stream_size)); int strategy, const char *version,
extern int EXPORT inflateInit2_ OF((z_streamp strm, int windowBits, int stream_size));
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) \ #define deflateInit(strm, level) \
deflateInit_((strm), (level), ZLIB_VERSION, sizeof(z_stream)) deflateInit_((strm), (level), ZLIB_VERSION, sizeof(z_stream))
#define inflateInit(strm) \ #define inflateInit(strm) \
inflateInit_((strm), ZLIB_VERSION, sizeof(z_stream)) inflateInit_((strm), ZLIB_VERSION, sizeof(z_stream))
#define deflateInit2(strm, level, method, windowBits, memLevel, strategy) \ #define deflateInit2(strm, level, method, windowBits, memLevel, strategy) \
deflateInit2_((strm),(level),(method),(windowBits),(memLevel),\ deflateInit2_((strm),(level),(method),(windowBits),(memLevel),\
(strategy), ZLIB_VERSION, sizeof(z_stream)) (strategy), ZLIB_VERSION, sizeof(z_stream))
#define inflateInit2(strm, windowBits) \ #define inflateInit2(strm, windowBits) \
inflateInit2_((strm), (windowBits), ZLIB_VERSION, sizeof(z_stream)) inflateInit2_((strm), (windowBits), 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 */ struct internal_state {int dummy;}; /* hack for buggy compilers */
#endif #endif
extern const char * EXPORT zError OF((int err)); extern const char * ZEXPORT zError OF((int err));
extern int EXPORT inflateSyncPoint OF((z_streamp z)); extern int ZEXPORT inflateSyncPoint OF((z_streamp z));
extern const uLongf * EXPORT get_crc_table OF((void)); extern const uLongf * ZEXPORT get_crc_table OF((void));
#ifdef __cplusplus #ifdef __cplusplus
} }

1
ztest28975.c
View File

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

4
zutil.c
View File

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

2
zutil.h
View File

@ -208,7 +208,7 @@ extern const char *z_errmsg[10]; /* indexed by 2-zlib_error */
#endif #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)); uInt len));
voidpf zcalloc OF((voidpf opaque, unsigned items, unsigned size)); voidpf zcalloc OF((voidpf opaque, unsigned items, unsigned size));
void zcfree OF((voidpf opaque, voidpf ptr)); void zcfree OF((voidpf opaque, voidpf ptr));