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

zlib 1.0.7

Browse Source
This commit is contained in:
Mark Adler
2011-09-09 23:17:33 -07:00
parent ebd3c2c0e7
commit 7850e4e406
58 changed files with 4608 additions and 519 deletions
Download Patch File Download Diff File Expand all files Collapse all files

464
contrib/asm386/gvmat32.asm Normal file
View File

@@ -0,0 +1,464 @@
;
; gvmat32.asm -- Asm portion of the optimized longest_match for 32 bits x86
; Copyright (C) 1995-1996 Jean-loup Gailly and Gilles Vollant.
; File written by Gilles Vollant, by modifiying the longest_match
; from Jean-loup Gailly in deflate.c
; It need wmask == 0x7fff
; (assembly code is faster with a fixed wmask)
;
; For Visual C++ 4.2 and ML 6.11c (version in directory \MASM611C of Win95 DDK)
; I compile with : "ml /coff /Zi /c gvmat32.asm"
;
; uInt longest_match_gvasm(IPos cur_match,int* match_start_ptr,uInt scan_end,
; uInt scan_start,ush* prev,uch* window,int best_len,
; IPos limit,uInt chain_length,uch* scanrp,
; uInt nice_match);
;uInt longest_match(s, cur_match)
; deflate_state *s;
; IPos cur_match; /* current match */
NbStack equ 76
cur_match equ dword ptr[esp+NbStack-0]
str_s equ dword ptr[esp+NbStack-4]
; 5 dword on top (ret,ebp,esi,edi,ebx)
adrret equ dword ptr[esp+NbStack-8]
pushebp equ dword ptr[esp+NbStack-12]
pushedi equ dword ptr[esp+NbStack-16]
pushesi equ dword ptr[esp+NbStack-20]
pushebx equ dword ptr[esp+NbStack-24]
chain_length equ dword ptr [esp+NbStack-28]
limit equ dword ptr [esp+NbStack-32]
best_len equ dword ptr [esp+NbStack-36]
window equ dword ptr [esp+NbStack-40]
prev equ dword ptr [esp+NbStack-44]
scan_start equ word ptr [esp+NbStack-48]
scan_end equ word ptr [esp+NbStack-52]
match_start_ptr equ dword ptr [esp+NbStack-56]
nice_match equ dword ptr [esp+NbStack-60]
scanrp equ dword ptr [esp+NbStack-64]
windowlen equ dword ptr [esp+NbStack-68]
match_start equ dword ptr [esp+NbStack-72]
strend equ dword ptr [esp+NbStack-76]
NbStackAdd equ (76-24)
.386p
name gvmatch
.MODEL FLAT
@lmtype TYPEDEF PROTO C :PTR , :SDWORD
longest_match_c PROTO @lmtype
dep_max_chain_length equ 70h
dep_window equ 2ch
dep_strstart equ 60h
dep_prev_length equ 6ch
dep_nice_match equ 84h
dep_w_size equ 20h
dep_prev equ 34h
dep_w_mask equ 28h
dep_good_match equ 80h
dep_match_start equ 64h
dep_lookahead equ 68h
_TEXT segment
public _longest_match_asm7fff
MAX_MATCH equ 258
MIN_MATCH equ 3
MIN_LOOKAHEAD equ (MAX_MATCH+MIN_MATCH+1)
; initialize or check the variables used in match.asm.
; -----------------------------------------------------------------------
; Set match_start to the longest match starting at the given string and
; return its length. Matches shorter or equal to prev_length are discarded,
; in which case the result is equal to prev_length and match_start is
; garbage.
; IN assertions: cur_match is the head of the hash chain for the current
; string (strstart) and its distance is <= MAX_DIST, and prev_length >= 1
; int longest_match(cur_match)
_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:
mov edi,[ebp+dep_nice_match]
mov chain_length,eax
mov edx,[ebp+dep_lookahead]
cmp edx,edi
;if ((uInt)nice_match > s->lookahead) nice_match = s->lookahead;
jae nolookaheadnicematch
mov edi,edx
nolookaheadnicematch:
mov best_len,ebx
mov esi,[ebp+dep_window]
mov ecx,[ebp+dep_strstart]
mov window,esi
mov nice_match,edi
add esi,ecx
mov scanrp,esi
mov ax,word ptr [esi]
mov bx,word ptr [esi+ebx-1]
add esi,MAX_MATCH-1
mov scan_start,ax
mov strend,esi
mov scan_end,bx
; IPos limit = s->strstart > (IPos)MAX_DIST(s) ?
; s->strstart - (IPos)MAX_DIST(s) : NIL;
mov esi,[ebp+dep_w_size]
sub esi,MIN_LOOKAHEAD
; here esi = MAX_DIST(s)
sub ecx,esi
ja nodist
xor ecx,ecx
nodist:
mov limit,ecx
mov eax,[ebp+dep_prev]
mov prev,eax
mov ebx,dword ptr [ebp+dep_match_start]
mov bp,scan_start
mov edx,cur_match
mov 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
;;;; eax = chain_length
; edx = dx = cur_match
; ecx = limit
; bx = scan_end
; bp = scan_start
; edi = windowlen (window + best_len)
; esi = prev
;// here; eax <=16
normalbeg0add16:
add chain_length,16
jz exitloop
normalbeg0:
cmp word ptr[edi+edx-0],bx
je normalbeg2
and edx,7fffh
mov dx,word ptr[esi+edx*2]
cmp ecx,edx
jnb exitloop
dec chain_length
jnz normalbeg0
;jnbexitloopshort1:
jmp exitloop
contloop3:
mov edi,windowlen
; cur_match = prev[cur_match & wmask]
and edx,7fffh
mov dx,word ptr[esi+edx*2]
; if cur_match > limit, go to exitloop
cmp ecx,edx
jnbexitloopshort1:
jnb exitloop
; if --chain_length != 0, go to exitloop
beginloop2:
sub chain_length,16+1
jna normalbeg0add16
do16:
cmp word ptr[edi+edx],bx
je normalbeg2dc0
maccn MACRO lab
and edx,7fffh
mov dx,word ptr[esi+edx*2]
cmp ecx,edx
jnb exitloop
cmp word ptr[edi+edx-0],bx
je lab
ENDM
rcontloop0:
maccn normalbeg2dc1
rcontloop1:
maccn normalbeg2dc2
rcontloop2:
maccn normalbeg2dc3
rcontloop3:
maccn normalbeg2dc4
rcontloop4:
maccn normalbeg2dc5
rcontloop5:
maccn normalbeg2dc6
rcontloop6:
maccn normalbeg2dc7
rcontloop7:
maccn normalbeg2dc8
rcontloop8:
maccn normalbeg2dc9
rcontloop9:
maccn normalbeg2dc10
rcontloop10:
maccn normalbeg2dc11
rcontloop11:
maccn short normalbeg2dc12
rcontloop12:
maccn short normalbeg2dc13
rcontloop13:
maccn short normalbeg2dc14
rcontloop14:
maccn short normalbeg2dc15
rcontloop15:
and edx,7fffh
mov dx,word ptr[esi+edx*2]
cmp ecx,edx
jnb short exitloopshort
sub chain_length,16
ja do16
jmp normalbeg0add16
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
exitloopshort:
jmp exitloop
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:
normbeg rcontloop11,11
normalbeg2dc10:
normbeg rcontloop10,10
normalbeg2dc9:
normbeg rcontloop9,9
normalbeg2dc8:
normbeg rcontloop8,8
normalbeg2dc7:
normbeg rcontloop7,7
normalbeg2dc5:
normbeg rcontloop5,5
normalbeg2dc6:
normbeg rcontloop6,6
normalbeg2dc4:
normbeg rcontloop4,4
normalbeg2dc3:
normbeg rcontloop3,3
normalbeg2dc2:
normbeg rcontloop2,2
normalbeg2dc1:
normbeg rcontloop1,1
normalbeg2dc0:
normbeg rcontloop0,0
; we go in normalbeg2 because *(ushf*)(match+best_len-1) == scan_end
normalbeg2:
; 10 nop here take 10% time
mov edi,window
;mov chain_length,eax ; now, we need eax...
cmp bp,word ptr[edi+edx]
jne contloop3 ; if *(ushf*)match != scan_start, continue
iseq:
mov edi,eax
mov esi,scanrp ; esi = scan
add edi,edx ; edi = window + cur_match = match
mov eax,[esi+3] ; compare manually dword at match+3
xor eax,[edi+3] ; and scan +3
jz begincompare ; if equal, go to long compare
; we will determine the unmatch byte and calculate len (in esi)
or al,al
je eq1rr
mov esi,3
jmp trfinval
eq1rr:
or ax,ax
je eq1
mov esi,4
jmp trfinval
eq1:
shl eax,8
jz eq11
mov esi,5
jmp trfinval
eq11:
mov esi,6
jmp trfinval
begincompare:
; here we now scan and match begin same
add edi,6
add esi,6
mov ecx,(MAX_MATCH-(2+4))/4 ;//; scan for at most MAX_MATCH bytes
repe cmpsd ;//; loop until mismatch
je trfin ; go to trfin if not unmatch
; we determine the unmatch byte
sub esi,4
mov eax,[edi-4]
xor eax,[esi]
or al,al
jnz trfin
inc esi
or ax,ax
jnz trfin
inc esi
shl eax,8
jnz trfin
inc esi
trfin:
sub esi,scanrp ; esi = len
trfinval:
cmp esi,best_len ; if len <= best_len, go contloop2
jbe contloop2
mov best_len,esi ; len become best_len
mov match_start,edx
cmp esi,nice_match ;//; if esi >= nice_match, exit
mov ecx,scanrp
jae exitloop
add esi,window
add ecx,best_len
dec esi
mov windowlen,esi
mov bx,[ecx-1]
; now we restore eax, ecx and esi, for the big loop :
contloop2:
mov esi,prev
mov ecx,limit
;mov eax,chain_length
mov eax,window
jmp contloop3
exitloop:
mov ebx,match_start
mov ebp,str_s
mov dword ptr [ebp+dep_match_start],ebx
mov eax,best_len
add esp,NbStackAdd
pop ebx
pop esi
pop edi
pop ebp
ret
_longest_match_asm7fff endp
_TEXT ends
end

229
contrib/asm386/gvmat32c.c Normal file
View File

@@ -0,0 +1,229 @@
/* gvmat32.c -- C portion of the optimized longest_match for 32 bits x86
* Copyright (C) 1995-1996 Jean-loup Gailly and Gilles Vollant.
* File written by Gilles Vollant, by modifiying the longest_match
* from Jean-loup Gailly in deflate.c
* it prepare all parameters and call the assembly longest_match_gvasm
* longest_match execute standard C code is wmask != 0x7fff
* (assembly code is faster with a fixed wmask)
*
*/
//#pragma optimize("agt",on)
#include "deflate.h"
#undef FAR
#include <windows.h>
#ifdef ASMV
#define NIL 0
static unsigned int tot=0;
static unsigned int totl0=0;
static unsigned int totl0p0=0;
static unsigned int ba0=0;
static unsigned int ba1=0;
static unsigned int cpta=0;
static unsigned int cptb=0;
#define UNALIGNED_OK
#define gvshow(a,b,c,d)
/*
void gvshow(int chain_length,int len,int limit,ushf* prev)
{
static int ival=0;
char sz[80];
unsigned long i;
int prev0=*prev;
ival++;
//wsprintf(sz,"call %u, len=%u, chain_length=%u\n",ival,len,chain_length);
//OutputDebugString(sz);
tot++;
if (limit==NIL)
totl0++;
if ((limit==NIL) && (prev0==0))
totl0p0++;
for (i=limit+1;i<32768;i++)
{
ush va=*(prev+i);
if (ba0>4000000000)
{
ba0+=10;
}
ba0++;
if ((va>limit) || (va==0))
continue;
ba1++;
}
}
*/
/* if your C compiler don't add underline before function name,
define ADD_UNDERLINE_ASMFUNC */
#ifdef ADD_UNDERLINE_ASMFUNC
#define longest_match_asm7fff _longest_match_asm7fff
#endif
void match_init()
{
}
uInt longest_match_c(
deflate_state *s,
IPos cur_match); /* current match */
uInt longest_match_asm7fff(
deflate_state *s,
IPos cur_match); /* current match */
uInt longest_match(
deflate_state *s,
IPos cur_match) /* current match */
{
if (s->w_mask == 0x7fff)
return longest_match_asm7fff(s,cur_match);
return longest_match_c(s,cur_match);
}
uInt longest_match_c(s, cur_match)
deflate_state *s;
IPos cur_match; /* current match */
{
unsigned chain_length = s->max_chain_length;/* max hash chain length */
register Bytef *scan = s->window + s->strstart; /* current string */
register Bytef *match; /* matched string */
register int len; /* length of current match */
int best_len = s->prev_length; /* best match length so far */
int nice_match = s->nice_match; /* stop if match long enough */
IPos limit = s->strstart > (IPos)MAX_DIST(s) ?
s->strstart - (IPos)MAX_DIST(s) : NIL;
/* Stop when cur_match becomes <= limit. To simplify the code,
* we prevent matches with the string of window index 0.
*/
Posf *prev = s->prev;
uInt wmask = s->w_mask;
#ifdef UNALIGNED_OK
/* Compare two bytes at a time. Note: this is not always beneficial.
* Try with and without -DUNALIGNED_OK to check.
*/
register Bytef *strend = s->window + s->strstart + MAX_MATCH - 1;
register ush scan_start = *(ushf*)scan;
register ush scan_end = *(ushf*)(scan+best_len-1);
#else
register Bytef *strend = s->window + s->strstart + MAX_MATCH;
register Byte scan_end1 = scan[best_len-1];
register Byte scan_end = scan[best_len];
#endif
/* The code is optimized for HASH_BITS >= 8 and MAX_MATCH-2 multiple of 16.
* It is easy to get rid of this optimization if necessary.
*/
Assert(s->hash_bits >= 8 && MAX_MATCH == 258, "Code too clever");
/* Do not waste too much time if we already have a good match: */
if (s->prev_length >= s->good_match) {
chain_length >>= 2;
}
/* Do not look for matches beyond the end of the input. This is necessary
* to make deflate deterministic.
*/
if ((uInt)nice_match > s->lookahead) nice_match = s->lookahead;
Assert((ulg)s->strstart <= s->window_size-MIN_LOOKAHEAD, "need lookahead");
do {
Assert(cur_match < s->strstart, "no future");
match = s->window + cur_match;
/* Skip to next match if the match length cannot increase
* or if the match length is less than 2:
*/
#if (defined(UNALIGNED_OK) && MAX_MATCH == 258)
/* This code assumes sizeof(unsigned short) == 2. Do not use
* UNALIGNED_OK if your compiler uses a different size.
*/
if (*(ushf*)(match+best_len-1) != scan_end ||
*(ushf*)match != scan_start) continue;
/* It is not necessary to compare scan[2] and match[2] since they are
* always equal when the other bytes match, given that the hash keys
* are equal and that HASH_BITS >= 8. Compare 2 bytes at a time at
* strstart+3, +5, ... up to strstart+257. We check for insufficient
* lookahead only every 4th comparison; the 128th check will be made
* at strstart+257. If MAX_MATCH-2 is not a multiple of 8, it is
* necessary to put more guard bytes at the end of the window, or
* to check more often for insufficient lookahead.
*/
Assert(scan[2] == match[2], "scan[2]?");
scan++, match++;
do {
} while (*(ushf*)(scan+=2) == *(ushf*)(match+=2) &&
*(ushf*)(scan+=2) == *(ushf*)(match+=2) &&
*(ushf*)(scan+=2) == *(ushf*)(match+=2) &&
*(ushf*)(scan+=2) == *(ushf*)(match+=2) &&
scan < strend);
/* The funny "do {}" generates better code on most compilers */
/* Here, scan <= window+strstart+257 */
Assert(scan <= s->window+(unsigned)(s->window_size-1), "wild scan");
if (*scan == *match) scan++;
len = (MAX_MATCH - 1) - (int)(strend-scan);
scan = strend - (MAX_MATCH-1);
#else /* UNALIGNED_OK */
if (match[best_len] != scan_end ||
match[best_len-1] != scan_end1 ||
*match != *scan ||
*++match != scan[1]) continue;
/* The check at best_len-1 can be removed because it will be made
* again later. (This heuristic is not always a win.)
* It is not necessary to compare scan[2] and match[2] since they
* are always equal when the other bytes match, given that
* the hash keys are equal and that HASH_BITS >= 8.
*/
scan += 2, match++;
Assert(*scan == *match, "match[2]?");
/* We check for insufficient lookahead only every 8th comparison;
* the 256th check will be made at strstart+258.
*/
do {
} while (*++scan == *++match && *++scan == *++match &&
*++scan == *++match && *++scan == *++match &&
*++scan == *++match && *++scan == *++match &&
*++scan == *++match && *++scan == *++match &&
scan < strend);
Assert(scan <= s->window+(unsigned)(s->window_size-1), "wild scan");
len = MAX_MATCH - (int)(strend - scan);
scan = strend - MAX_MATCH;
#endif /* UNALIGNED_OK */
if (len > best_len) {
s->match_start = cur_match;
best_len = len;
if (len >= nice_match) break;
#ifdef UNALIGNED_OK
scan_end = *(ushf*)(scan+best_len-1);
#else
scan_end1 = scan[best_len-1];
scan_end = scan[best_len];
#endif
}
} while ((cur_match = prev[cur_match & wmask]) > limit
&& --chain_length != 0);
if ((uInt)best_len <= s->lookahead) return best_len;
return s->lookahead;
}
#endif /* ASMV */

1
contrib/asm386/mkgvmt32.bat Normal file
View File

@@ -0,0 +1 @@
c:\masm611\bin\ml /coff /Zi /c /Flgvmat32.lst gvmat32.asm

781
contrib/asm386/zlibvc.mak Normal file
View File

@@ -0,0 +1,781 @@
# 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
################################################################################