generic-library/z
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

zlib 1.2.3

Browse Source
This commit is contained in:
Mark Adler
2011-09-09 23:25:17 -07:00
parent 9c3a583021
commit fda0e6578b
65 changed files with 11148 additions and 6736 deletions
Download Patch File Download Diff File Expand all files Collapse all files

5
ChangeLog
View File

@@ -1,6 +1,11 @@
ChangeLog file for zlib ChangeLog file for zlib
Changes in 1.2.3 (18 July 2005)
- Apply security vulnerability fixes to contrib/infback9 as well
- Clean up some text files (carriage returns, trailing space)
- Update testzlib, vstudio, masmx64, and masmx86 in contrib [Vollant]
Changes in 1.2.2.4 (11 July 2005) Changes in 1.2.2.4 (11 July 2005)
- Add inflatePrime() function for starting inflation at bit boundary - Add inflatePrime() function for starting inflation at bit boundary
- Avoid some Visual C warnings in deflate.c - Avoid some Visual C warnings in deflate.c

2
Makefile
View File

@@ -30,7 +30,7 @@ CPP=$(CC) -E
LIBS=libz.a LIBS=libz.a
SHAREDLIB=libz.so SHAREDLIB=libz.so
SHAREDLIBV=libz.so.1.2.2.4 SHAREDLIBV=libz.so.1.2.3
SHAREDLIBM=libz.so.1 SHAREDLIBM=libz.so.1
AR=ar rc AR=ar rc

2
Makefile.in
View File

@@ -30,7 +30,7 @@ CPP=$(CC) -E
LIBS=libz.a LIBS=libz.a
SHAREDLIB=libz.so SHAREDLIB=libz.so
SHAREDLIBV=libz.so.1.2.2.4 SHAREDLIBV=libz.so.1.2.3
SHAREDLIBM=libz.so.1 SHAREDLIBM=libz.so.1
AR=ar rc AR=ar rc

4
README
View File

@@ -1,6 +1,6 @@
ZLIB DATA COMPRESSION LIBRARY ZLIB DATA COMPRESSION LIBRARY
zlib 1.2.2.4 is a general purpose data compression library. All the code is zlib 1.2.3 is a general purpose data compression library. All the code is
thread safe. The data format used by the zlib library is described by RFCs thread safe. The data format used by the zlib library is described by RFCs
(Request for Comments) 1950 to 1952 in the files (Request for Comments) 1950 to 1952 in the files
http://www.ietf.org/rfc/rfc1950.txt (zlib format), rfc1951.txt (deflate format) http://www.ietf.org/rfc/rfc1950.txt (zlib format), rfc1951.txt (deflate format)
@@ -33,7 +33,7 @@ Mark Nelson <markn@ieee.org> wrote an article about zlib for the Jan. 1997
issue of Dr. Dobb's Journal; a copy of the article is available in issue of Dr. Dobb's Journal; a copy of the article is available in
http://dogma.net/markn/articles/zlibtool/zlibtool.htm http://dogma.net/markn/articles/zlibtool/zlibtool.htm
The changes made in version 1.2.2.4 are documented in the file ChangeLog. The changes made in version 1.2.3 are documented in the file ChangeLog.
Unsupported third party contributions are provided in directory "contrib". Unsupported third party contributions are provided in directory "contrib".

2
amiga/Makefile.sas
View File

@@ -23,7 +23,7 @@ all: SCOPTIONS example minigzip
check: test check: test
test: all test: all
example example
echo hello world | minigzip | minigzip -d echo hello world | minigzip | minigzip -d
install: z.lib install: z.lib
copy clone zlib.h zconf.h INCLUDE: copy clone zlib.h zconf.h INCLUDE:

2
as400/compile.clp
View File

@@ -118,6 +118,6 @@
&MODLIB/INFTREES &MODLIB/TREES + &MODLIB/INFTREES &MODLIB/TREES +
&MODLIB/UNCOMPR &MODLIB/ZUTIL) + &MODLIB/UNCOMPR &MODLIB/ZUTIL) +
SRCFILE(&SRCLIB/&CTLFILE) SRCMBR(BNDSRC) + SRCFILE(&SRCLIB/&CTLFILE) SRCMBR(BNDSRC) +
TEXT('ZLIB 1.2.2') TGTRLS(V4R4M0) TEXT('ZLIB 1.2.3') TGTRLS(V4R4M0)
ENDPGM ENDPGM

2
as400/readme.txt
View File

@@ -1,4 +1,4 @@
ZLIB version 1.2.2 for AS400 installation instructions ZLIB version 1.2.3 for AS400 installation instructions
I) From an AS400 *SAVF file: I) From an AS400 *SAVF file:

6
as400/zlib.inc
View File

@@ -1,7 +1,7 @@
* ZLIB.INC - Interface to the general purpose compression library * ZLIB.INC - Interface to the general purpose compression library
* *
* ILE RPG400 version by Patrick Monnerat, DATASPHERE. * ILE RPG400 version by Patrick Monnerat, DATASPHERE.
* Version 1.2.2.4 * Version 1.2.3
* *
* *
* WARNING: * WARNING:
@@ -22,8 +22,8 @@
* *
* Versioning information. * Versioning information.
* *
D ZLIB_VERSION C '1.2.2.4' D ZLIB_VERSION C '1.2.3'
D ZLIB_VERNUM C X'1224' D ZLIB_VERNUM C X'1230'
* *
* Other equates. * Other equates.
* *

728
contrib/asm586/match.S
View File

@@ -1,364 +1,364 @@
/* match.s -- Pentium-optimized version of longest_match() /* match.s -- Pentium-optimized version of longest_match()
* Written for zlib 1.1.2 * Written for zlib 1.1.2
* Copyright (C) 1998 Brian Raiter <breadbox@muppetlabs.com> * Copyright (C) 1998 Brian Raiter <breadbox@muppetlabs.com>
* *
* This is free software; you can redistribute it and/or modify it * This is free software; you can redistribute it and/or modify it
* under the terms of the GNU General Public License. * under the terms of the GNU General Public License.
*/ */
#ifndef NO_UNDERLINE #ifndef NO_UNDERLINE
#define match_init _match_init #define match_init _match_init
#define longest_match _longest_match #define longest_match _longest_match
#endif #endif
#define MAX_MATCH (258) #define MAX_MATCH (258)
#define MIN_MATCH (3) #define MIN_MATCH (3)
#define MIN_LOOKAHEAD (MAX_MATCH + MIN_MATCH + 1) #define MIN_LOOKAHEAD (MAX_MATCH + MIN_MATCH + 1)
#define MAX_MATCH_8 ((MAX_MATCH + 7) & ~7) #define MAX_MATCH_8 ((MAX_MATCH + 7) & ~7)
/* stack frame offsets */ /* stack frame offsets */
#define wmask 0 /* local copy of s->wmask */ #define wmask 0 /* local copy of s->wmask */
#define window 4 /* local copy of s->window */ #define window 4 /* local copy of s->window */
#define windowbestlen 8 /* s->window + bestlen */ #define windowbestlen 8 /* s->window + bestlen */
#define chainlenscanend 12 /* high word: current chain len */ #define chainlenscanend 12 /* high word: current chain len */
/* low word: last bytes sought */ /* low word: last bytes sought */
#define scanstart 16 /* first two bytes of string */ #define scanstart 16 /* first two bytes of string */
#define scanalign 20 /* dword-misalignment of string */ #define scanalign 20 /* dword-misalignment of string */
#define nicematch 24 /* a good enough match size */ #define nicematch 24 /* a good enough match size */
#define bestlen 28 /* size of best match so far */ #define bestlen 28 /* size of best match so far */
#define scan 32 /* ptr to string wanting match */ #define scan 32 /* ptr to string wanting match */
#define LocalVarsSize (36) #define LocalVarsSize (36)
/* saved ebx 36 */ /* saved ebx 36 */
/* saved edi 40 */ /* saved edi 40 */
/* saved esi 44 */ /* saved esi 44 */
/* saved ebp 48 */ /* saved ebp 48 */
/* return address 52 */ /* return address 52 */
#define deflatestate 56 /* the function arguments */ #define deflatestate 56 /* the function arguments */
#define curmatch 60 #define curmatch 60
/* Offsets for fields in the deflate_state structure. These numbers /* Offsets for fields in the deflate_state structure. These numbers
* are calculated from the definition of deflate_state, with the * are calculated from the definition of deflate_state, with the
* assumption that the compiler will dword-align the fields. (Thus, * assumption that the compiler will dword-align the fields. (Thus,
* changing the definition of deflate_state could easily cause this * changing the definition of deflate_state could easily cause this
* program to crash horribly, without so much as a warning at * program to crash horribly, without so much as a warning at
* compile time. Sigh.) * compile time. Sigh.)
*/ */
/* All the +zlib1222add offsets are due to the addition of fields /* All the +zlib1222add offsets are due to the addition of fields
* in zlib in the deflate_state structure since the asm code was first written * in zlib in the deflate_state structure since the asm code was first written
* (if you compile with zlib 1.0.4 or older, use "zlib1222add equ (-4)"). * (if you compile with zlib 1.0.4 or older, use "zlib1222add equ (-4)").
* (if you compile with zlib between 1.0.5 and 1.2.2.1, use "zlib1222add equ 0"). * (if you compile with zlib between 1.0.5 and 1.2.2.1, use "zlib1222add equ 0").
* if you compile with zlib 1.2.2.2 or later , use "zlib1222add equ 8"). * if you compile with zlib 1.2.2.2 or later , use "zlib1222add equ 8").
*/ */
#define zlib1222add (8) #define zlib1222add (8)
#define dsWSize (36+zlib1222add) #define dsWSize (36+zlib1222add)
#define dsWMask (44+zlib1222add) #define dsWMask (44+zlib1222add)
#define dsWindow (48+zlib1222add) #define dsWindow (48+zlib1222add)
#define dsPrev (56+zlib1222add) #define dsPrev (56+zlib1222add)
#define dsMatchLen (88+zlib1222add) #define dsMatchLen (88+zlib1222add)
#define dsPrevMatch (92+zlib1222add) #define dsPrevMatch (92+zlib1222add)
#define dsStrStart (100+zlib1222add) #define dsStrStart (100+zlib1222add)
#define dsMatchStart (104+zlib1222add) #define dsMatchStart (104+zlib1222add)
#define dsLookahead (108+zlib1222add) #define dsLookahead (108+zlib1222add)
#define dsPrevLen (112+zlib1222add) #define dsPrevLen (112+zlib1222add)
#define dsMaxChainLen (116+zlib1222add) #define dsMaxChainLen (116+zlib1222add)
#define dsGoodMatch (132+zlib1222add) #define dsGoodMatch (132+zlib1222add)
#define dsNiceMatch (136+zlib1222add) #define dsNiceMatch (136+zlib1222add)
.file "match.S" .file "match.S"
.globl match_init, longest_match .globl match_init, longest_match
.text .text
/* uInt longest_match(deflate_state *deflatestate, IPos curmatch) */ /* uInt longest_match(deflate_state *deflatestate, IPos curmatch) */
longest_match: longest_match:
/* Save registers that the compiler may be using, and adjust %esp to */ /* Save registers that the compiler may be using, and adjust %esp to */
/* make room for our stack frame. */ /* make room for our stack frame. */
pushl %ebp pushl %ebp
pushl %edi pushl %edi
pushl %esi pushl %esi
pushl %ebx pushl %ebx
subl $LocalVarsSize, %esp subl $LocalVarsSize, %esp
/* Retrieve the function arguments. %ecx will hold cur_match */ /* Retrieve the function arguments. %ecx will hold cur_match */
/* throughout the entire function. %edx will hold the pointer to the */ /* throughout the entire function. %edx will hold the pointer to the */
/* deflate_state structure during the function's setup (before */ /* deflate_state structure during the function's setup (before */
/* entering the main loop). */ /* entering the main loop). */
movl deflatestate(%esp), %edx movl deflatestate(%esp), %edx
movl curmatch(%esp), %ecx movl curmatch(%esp), %ecx
/* if ((uInt)nice_match > s->lookahead) nice_match = s->lookahead; */ /* if ((uInt)nice_match > s->lookahead) nice_match = s->lookahead; */
movl dsNiceMatch(%edx), %eax movl dsNiceMatch(%edx), %eax
movl dsLookahead(%edx), %ebx movl dsLookahead(%edx), %ebx
cmpl %eax, %ebx cmpl %eax, %ebx
jl LookaheadLess jl LookaheadLess
movl %eax, %ebx movl %eax, %ebx
LookaheadLess: movl %ebx, nicematch(%esp) LookaheadLess: movl %ebx, nicematch(%esp)
/* register Bytef *scan = s->window + s->strstart; */ /* register Bytef *scan = s->window + s->strstart; */
movl dsWindow(%edx), %esi movl dsWindow(%edx), %esi
movl %esi, window(%esp) movl %esi, window(%esp)
movl dsStrStart(%edx), %ebp movl dsStrStart(%edx), %ebp
lea (%esi,%ebp), %edi lea (%esi,%ebp), %edi
movl %edi, scan(%esp) movl %edi, scan(%esp)
/* Determine how many bytes the scan ptr is off from being */ /* Determine how many bytes the scan ptr is off from being */
/* dword-aligned. */ /* dword-aligned. */
movl %edi, %eax movl %edi, %eax
negl %eax negl %eax
andl $3, %eax andl $3, %eax
movl %eax, scanalign(%esp) movl %eax, scanalign(%esp)
/* 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; */
movl dsWSize(%edx), %eax movl dsWSize(%edx), %eax
subl $MIN_LOOKAHEAD, %eax subl $MIN_LOOKAHEAD, %eax
subl %eax, %ebp subl %eax, %ebp
jg LimitPositive jg LimitPositive
xorl %ebp, %ebp xorl %ebp, %ebp
LimitPositive: LimitPositive:
/* unsigned chain_length = s->max_chain_length; */ /* unsigned chain_length = s->max_chain_length; */
/* if (s->prev_length >= s->good_match) { */ /* if (s->prev_length >= s->good_match) { */
/* chain_length >>= 2; */ /* chain_length >>= 2; */
/* } */ /* } */
movl dsPrevLen(%edx), %eax movl dsPrevLen(%edx), %eax
movl dsGoodMatch(%edx), %ebx movl dsGoodMatch(%edx), %ebx
cmpl %ebx, %eax cmpl %ebx, %eax
movl dsMaxChainLen(%edx), %ebx movl dsMaxChainLen(%edx), %ebx
jl LastMatchGood jl LastMatchGood
shrl $2, %ebx shrl $2, %ebx
LastMatchGood: LastMatchGood:
/* chainlen is decremented once beforehand so that the function can */ /* chainlen is decremented once beforehand so that the function can */
/* use the sign flag instead of the zero flag for the exit test. */ /* use the sign flag instead of the zero flag for the exit test. */
/* It is then shifted into the high word, to make room for the scanend */ /* It is then shifted into the high word, to make room for the scanend */
/* scanend value, which it will always accompany. */ /* scanend value, which it will always accompany. */
decl %ebx decl %ebx
shll $16, %ebx shll $16, %ebx
/* int best_len = s->prev_length; */ /* int best_len = s->prev_length; */
movl dsPrevLen(%edx), %eax movl dsPrevLen(%edx), %eax
movl %eax, bestlen(%esp) movl %eax, bestlen(%esp)
/* Store the sum of s->window + best_len in %esi locally, and in %esi. */ /* Store the sum of s->window + best_len in %esi locally, and in %esi. */
addl %eax, %esi addl %eax, %esi
movl %esi, windowbestlen(%esp) movl %esi, windowbestlen(%esp)
/* register ush scan_start = *(ushf*)scan; */ /* register ush scan_start = *(ushf*)scan; */
/* register ush scan_end = *(ushf*)(scan+best_len-1); */ /* register ush scan_end = *(ushf*)(scan+best_len-1); */
movw (%edi), %bx movw (%edi), %bx
movw %bx, scanstart(%esp) movw %bx, scanstart(%esp)
movw -1(%edi,%eax), %bx movw -1(%edi,%eax), %bx
movl %ebx, chainlenscanend(%esp) movl %ebx, chainlenscanend(%esp)
/* Posf *prev = s->prev; */ /* Posf *prev = s->prev; */
/* uInt wmask = s->w_mask; */ /* uInt wmask = s->w_mask; */
movl dsPrev(%edx), %edi movl dsPrev(%edx), %edi
movl dsWMask(%edx), %edx movl dsWMask(%edx), %edx
mov %edx, wmask(%esp) mov %edx, wmask(%esp)
/* Jump into the main loop. */ /* Jump into the main loop. */
jmp LoopEntry jmp LoopEntry
.balign 16 .balign 16
/* do { /* do {
* match = s->window + cur_match; * match = s->window + cur_match;
* if (*(ushf*)(match+best_len-1) != scan_end || * if (*(ushf*)(match+best_len-1) != scan_end ||
* *(ushf*)match != scan_start) continue; * *(ushf*)match != scan_start) continue;
* [...] * [...]
* } while ((cur_match = prev[cur_match & wmask]) > limit * } while ((cur_match = prev[cur_match & wmask]) > limit
* && --chain_length != 0); * && --chain_length != 0);
* *
* Here is the inner loop of the function. The function will spend the * Here is the inner loop of the function. The function will spend the
* majority of its time in this loop, and majority of that time will * majority of its time in this loop, and majority of that time will
* be spent in the first ten instructions. * be spent in the first ten instructions.
* *
* Within this loop: * Within this loop:
* %ebx = chainlenscanend - i.e., ((chainlen << 16) | scanend) * %ebx = chainlenscanend - i.e., ((chainlen << 16) | scanend)
* %ecx = curmatch * %ecx = curmatch
* %edx = curmatch & wmask * %edx = curmatch & wmask
* %esi = windowbestlen - i.e., (window + bestlen) * %esi = windowbestlen - i.e., (window + bestlen)
* %edi = prev * %edi = prev
* %ebp = limit * %ebp = limit
* *
* Two optimization notes on the choice of instructions: * Two optimization notes on the choice of instructions:
* *
* The first instruction uses a 16-bit address, which costs an extra, * The first instruction uses a 16-bit address, which costs an extra,
* unpairable cycle. This is cheaper than doing a 32-bit access and * unpairable cycle. This is cheaper than doing a 32-bit access and
* zeroing the high word, due to the 3-cycle misalignment penalty which * zeroing the high word, due to the 3-cycle misalignment penalty which
* would occur half the time. This also turns out to be cheaper than * would occur half the time. This also turns out to be cheaper than
* doing two separate 8-bit accesses, as the memory is so rarely in the * doing two separate 8-bit accesses, as the memory is so rarely in the
* L1 cache. * L1 cache.
* *
* The window buffer, however, apparently spends a lot of time in the * The window buffer, however, apparently spends a lot of time in the
* cache, and so it is faster to retrieve the word at the end of the * cache, and so it is faster to retrieve the word at the end of the
* match string with two 8-bit loads. The instructions that test the * match string with two 8-bit loads. The instructions that test the
* word at the beginning of the match string, however, are executed * word at the beginning of the match string, however, are executed
* much less frequently, and there it was cheaper to use 16-bit * much less frequently, and there it was cheaper to use 16-bit
* instructions, which avoided the necessity of saving off and * instructions, which avoided the necessity of saving off and
* subsequently reloading one of the other registers. * subsequently reloading one of the other registers.
*/ */
LookupLoop: LookupLoop:
/* 1 U & V */ /* 1 U & V */
movw (%edi,%edx,2), %cx /* 2 U pipe */ movw (%edi,%edx,2), %cx /* 2 U pipe */
movl wmask(%esp), %edx /* 2 V pipe */ movl wmask(%esp), %edx /* 2 V pipe */
cmpl %ebp, %ecx /* 3 U pipe */ cmpl %ebp, %ecx /* 3 U pipe */
jbe LeaveNow /* 3 V pipe */ jbe LeaveNow /* 3 V pipe */
subl $0x00010000, %ebx /* 4 U pipe */ subl $0x00010000, %ebx /* 4 U pipe */
js LeaveNow /* 4 V pipe */ js LeaveNow /* 4 V pipe */
LoopEntry: movb -1(%esi,%ecx), %al /* 5 U pipe */ LoopEntry: movb -1(%esi,%ecx), %al /* 5 U pipe */
andl %ecx, %edx /* 5 V pipe */ andl %ecx, %edx /* 5 V pipe */
cmpb %bl, %al /* 6 U pipe */ cmpb %bl, %al /* 6 U pipe */
jnz LookupLoop /* 6 V pipe */ jnz LookupLoop /* 6 V pipe */
movb (%esi,%ecx), %ah movb (%esi,%ecx), %ah
cmpb %bh, %ah cmpb %bh, %ah
jnz LookupLoop jnz LookupLoop
movl window(%esp), %eax movl window(%esp), %eax
movw (%eax,%ecx), %ax movw (%eax,%ecx), %ax
cmpw scanstart(%esp), %ax cmpw scanstart(%esp), %ax
jnz LookupLoop jnz LookupLoop
/* Store the current value of chainlen. */ /* Store the current value of chainlen. */
movl %ebx, chainlenscanend(%esp) movl %ebx, chainlenscanend(%esp)
/* Point %edi to the string under scrutiny, and %esi to the string we */ /* Point %edi to the string under scrutiny, and %esi to the string we */
/* are hoping to match it up with. In actuality, %esi and %edi are */ /* are hoping to match it up with. In actuality, %esi and %edi are */
/* both pointed (MAX_MATCH_8 - scanalign) bytes ahead, and %edx is */ /* both pointed (MAX_MATCH_8 - scanalign) bytes ahead, and %edx is */
/* initialized to -(MAX_MATCH_8 - scanalign). */ /* initialized to -(MAX_MATCH_8 - scanalign). */
movl window(%esp), %esi movl window(%esp), %esi
movl scan(%esp), %edi movl scan(%esp), %edi
addl %ecx, %esi addl %ecx, %esi
movl scanalign(%esp), %eax movl scanalign(%esp), %eax
movl $(-MAX_MATCH_8), %edx movl $(-MAX_MATCH_8), %edx
lea MAX_MATCH_8(%edi,%eax), %edi lea MAX_MATCH_8(%edi,%eax), %edi
lea MAX_MATCH_8(%esi,%eax), %esi lea MAX_MATCH_8(%esi,%eax), %esi
/* Test the strings for equality, 8 bytes at a time. At the end, /* Test the strings for equality, 8 bytes at a time. At the end,
* adjust %edx so that it is offset to the exact byte that mismatched. * adjust %edx so that it is offset to the exact byte that mismatched.
* *
* We already know at this point that the first three bytes of the * We already know at this point that the first three bytes of the
* strings match each other, and they can be safely passed over before * strings match each other, and they can be safely passed over before
* starting the compare loop. So what this code does is skip over 0-3 * starting the compare loop. So what this code does is skip over 0-3
* bytes, as much as necessary in order to dword-align the %edi * bytes, as much as necessary in order to dword-align the %edi
* pointer. (%esi will still be misaligned three times out of four.) * pointer. (%esi will still be misaligned three times out of four.)
* *
* It should be confessed that this loop usually does not represent * It should be confessed that this loop usually does not represent
* much of the total running time. Replacing it with a more * much of the total running time. Replacing it with a more
* straightforward "rep cmpsb" would not drastically degrade * straightforward "rep cmpsb" would not drastically degrade
* performance. * performance.
*/ */
LoopCmps: LoopCmps:
movl (%esi,%edx), %eax movl (%esi,%edx), %eax
movl (%edi,%edx), %ebx movl (%edi,%edx), %ebx
xorl %ebx, %eax xorl %ebx, %eax
jnz LeaveLoopCmps jnz LeaveLoopCmps
movl 4(%esi,%edx), %eax movl 4(%esi,%edx), %eax
movl 4(%edi,%edx), %ebx movl 4(%edi,%edx), %ebx
xorl %ebx, %eax xorl %ebx, %eax
jnz LeaveLoopCmps4 jnz LeaveLoopCmps4
addl $8, %edx addl $8, %edx
jnz LoopCmps jnz LoopCmps
jmp LenMaximum jmp LenMaximum
LeaveLoopCmps4: addl $4, %edx LeaveLoopCmps4: addl $4, %edx
LeaveLoopCmps: testl $0x0000FFFF, %eax LeaveLoopCmps: testl $0x0000FFFF, %eax
jnz LenLower jnz LenLower
addl $2, %edx addl $2, %edx
shrl $16, %eax shrl $16, %eax
LenLower: subb $1, %al LenLower: subb $1, %al
adcl $0, %edx adcl $0, %edx
/* Calculate the length of the match. If it is longer than MAX_MATCH, */ /* Calculate the length of the match. If it is longer than MAX_MATCH, */
/* then automatically accept it as the best possible match and leave. */ /* then automatically accept it as the best possible match and leave. */
lea (%edi,%edx), %eax lea (%edi,%edx), %eax
movl scan(%esp), %edi movl scan(%esp), %edi
subl %edi, %eax subl %edi, %eax
cmpl $MAX_MATCH, %eax cmpl $MAX_MATCH, %eax
jge LenMaximum jge LenMaximum
/* If the length of the match is not longer than the best match we */ /* If the length of the match is not longer than the best match we */
/* have so far, then forget it and return to the lookup loop. */ /* have so far, then forget it and return to the lookup loop. */
movl deflatestate(%esp), %edx movl deflatestate(%esp), %edx
movl bestlen(%esp), %ebx movl bestlen(%esp), %ebx
cmpl %ebx, %eax cmpl %ebx, %eax
jg LongerMatch jg LongerMatch
movl chainlenscanend(%esp), %ebx movl chainlenscanend(%esp), %ebx
movl windowbestlen(%esp), %esi movl windowbestlen(%esp), %esi
movl dsPrev(%edx), %edi movl dsPrev(%edx), %edi
movl wmask(%esp), %edx movl wmask(%esp), %edx
andl %ecx, %edx andl %ecx, %edx
jmp LookupLoop jmp LookupLoop
/* s->match_start = cur_match; */ /* s->match_start = cur_match; */
/* best_len = len; */ /* best_len = len; */
/* if (len >= nice_match) break; */ /* if (len >= nice_match) break; */
/* scan_end = *(ushf*)(scan+best_len-1); */ /* scan_end = *(ushf*)(scan+best_len-1); */
LongerMatch: movl nicematch(%esp), %ebx LongerMatch: movl nicematch(%esp), %ebx
movl %eax, bestlen(%esp) movl %eax, bestlen(%esp)
movl %ecx, dsMatchStart(%edx) movl %ecx, dsMatchStart(%edx)
cmpl %ebx, %eax cmpl %ebx, %eax
jge LeaveNow jge LeaveNow
movl window(%esp), %esi movl window(%esp), %esi
addl %eax, %esi addl %eax, %esi
movl %esi, windowbestlen(%esp) movl %esi, windowbestlen(%esp)
movl chainlenscanend(%esp), %ebx movl chainlenscanend(%esp), %ebx
movw -1(%edi,%eax), %bx movw -1(%edi,%eax), %bx
movl dsPrev(%edx), %edi movl dsPrev(%edx), %edi
movl %ebx, chainlenscanend(%esp) movl %ebx, chainlenscanend(%esp)
movl wmask(%esp), %edx movl wmask(%esp), %edx
andl %ecx, %edx andl %ecx, %edx
jmp LookupLoop jmp LookupLoop
/* Accept the current string, with the maximum possible length. */ /* Accept the current string, with the maximum possible length. */
LenMaximum: movl deflatestate(%esp), %edx LenMaximum: movl deflatestate(%esp), %edx
movl $MAX_MATCH, bestlen(%esp) movl $MAX_MATCH, bestlen(%esp)
movl %ecx, dsMatchStart(%edx) movl %ecx, dsMatchStart(%edx)
/* if ((uInt)best_len <= s->lookahead) return (uInt)best_len; */ /* if ((uInt)best_len <= s->lookahead) return (uInt)best_len; */
/* return s->lookahead; */ /* return s->lookahead; */
LeaveNow: LeaveNow:
movl deflatestate(%esp), %edx movl deflatestate(%esp), %edx
movl bestlen(%esp), %ebx movl bestlen(%esp), %ebx
movl dsLookahead(%edx), %eax movl dsLookahead(%edx), %eax
cmpl %eax, %ebx cmpl %eax, %ebx
jg LookaheadRet jg LookaheadRet
movl %ebx, %eax movl %ebx, %eax
LookaheadRet: LookaheadRet:
/* Restore the stack and return from whence we came. */ /* Restore the stack and return from whence we came. */
addl $LocalVarsSize, %esp addl $LocalVarsSize, %esp
popl %ebx popl %ebx
popl %esi popl %esi
popl %edi popl %edi
popl %ebp popl %ebp
match_init: ret match_init: ret

658
contrib/asm686/match.S
View File

@@ -1,329 +1,329 @@
/* match.s -- Pentium-Pro-optimized version of longest_match() /* match.s -- Pentium-Pro-optimized version of longest_match()
* Written for zlib 1.1.2 * Written for zlib 1.1.2
* Copyright (C) 1998 Brian Raiter <breadbox@muppetlabs.com> * Copyright (C) 1998 Brian Raiter <breadbox@muppetlabs.com>
* *
* This is free software; you can redistribute it and/or modify it * This is free software; you can redistribute it and/or modify it
* under the terms of the GNU General Public License. * under the terms of the GNU General Public License.
*/ */
#ifndef NO_UNDERLINE #ifndef NO_UNDERLINE
#define match_init _match_init #define match_init _match_init
#define longest_match _longest_match #define longest_match _longest_match
#endif #endif
#define MAX_MATCH (258) #define MAX_MATCH (258)
#define MIN_MATCH (3) #define MIN_MATCH (3)
#define MIN_LOOKAHEAD (MAX_MATCH + MIN_MATCH + 1) #define MIN_LOOKAHEAD (MAX_MATCH + MIN_MATCH + 1)
#define MAX_MATCH_8 ((MAX_MATCH + 7) & ~7) #define MAX_MATCH_8 ((MAX_MATCH + 7) & ~7)
/* stack frame offsets */ /* stack frame offsets */
#define chainlenwmask 0 /* high word: current chain len */ #define chainlenwmask 0 /* high word: current chain len */
/* low word: s->wmask */ /* low word: s->wmask */
#define window 4 /* local copy of s->window */ #define window 4 /* local copy of s->window */
#define windowbestlen 8 /* s->window + bestlen */ #define windowbestlen 8 /* s->window + bestlen */
#define scanstart 16 /* first two bytes of string */ #define scanstart 16 /* first two bytes of string */
#define scanend 12 /* last two bytes of string */ #define scanend 12 /* last two bytes of string */
#define scanalign 20 /* dword-misalignment of string */ #define scanalign 20 /* dword-misalignment of string */
#define nicematch 24 /* a good enough match size */ #define nicematch 24 /* a good enough match size */
#define bestlen 28 /* size of best match so far */ #define bestlen 28 /* size of best match so far */
#define scan 32 /* ptr to string wanting match */ #define scan 32 /* ptr to string wanting match */
#define LocalVarsSize (36) #define LocalVarsSize (36)
/* saved ebx 36 */ /* saved ebx 36 */
/* saved edi 40 */ /* saved edi 40 */
/* saved esi 44 */ /* saved esi 44 */
/* saved ebp 48 */ /* saved ebp 48 */
/* return address 52 */ /* return address 52 */
#define deflatestate 56 /* the function arguments */ #define deflatestate 56 /* the function arguments */
#define curmatch 60 #define curmatch 60
/* All the +zlib1222add offsets are due to the addition of fields /* All the +zlib1222add offsets are due to the addition of fields
* in zlib in the deflate_state structure since the asm code was first written * in zlib in the deflate_state structure since the asm code was first written
* (if you compile with zlib 1.0.4 or older, use "zlib1222add equ (-4)"). * (if you compile with zlib 1.0.4 or older, use "zlib1222add equ (-4)").
* (if you compile with zlib between 1.0.5 and 1.2.2.1, use "zlib1222add equ 0"). * (if you compile with zlib between 1.0.5 and 1.2.2.1, use "zlib1222add equ 0").
* if you compile with zlib 1.2.2.2 or later , use "zlib1222add equ 8"). * if you compile with zlib 1.2.2.2 or later , use "zlib1222add equ 8").
*/ */
#define zlib1222add (8) #define zlib1222add (8)
#define dsWSize (36+zlib1222add) #define dsWSize (36+zlib1222add)
#define dsWMask (44+zlib1222add) #define dsWMask (44+zlib1222add)
#define dsWindow (48+zlib1222add) #define dsWindow (48+zlib1222add)
#define dsPrev (56+zlib1222add) #define dsPrev (56+zlib1222add)
#define dsMatchLen (88+zlib1222add) #define dsMatchLen (88+zlib1222add)
#define dsPrevMatch (92+zlib1222add) #define dsPrevMatch (92+zlib1222add)
#define dsStrStart (100+zlib1222add) #define dsStrStart (100+zlib1222add)
#define dsMatchStart (104+zlib1222add) #define dsMatchStart (104+zlib1222add)
#define dsLookahead (108+zlib1222add) #define dsLookahead (108+zlib1222add)
#define dsPrevLen (112+zlib1222add) #define dsPrevLen (112+zlib1222add)
#define dsMaxChainLen (116+zlib1222add) #define dsMaxChainLen (116+zlib1222add)
#define dsGoodMatch (132+zlib1222add) #define dsGoodMatch (132+zlib1222add)
#define dsNiceMatch (136+zlib1222add) #define dsNiceMatch (136+zlib1222add)
.file "match.S" .file "match.S"
.globl match_init, longest_match .globl match_init, longest_match
.text .text
/* uInt longest_match(deflate_state *deflatestate, IPos curmatch) */ /* uInt longest_match(deflate_state *deflatestate, IPos curmatch) */
longest_match: longest_match:
/* Save registers that the compiler may be using, and adjust %esp to */ /* Save registers that the compiler may be using, and adjust %esp to */
/* make room for our stack frame. */ /* make room for our stack frame. */
pushl %ebp pushl %ebp
pushl %edi pushl %edi
pushl %esi pushl %esi
pushl %ebx pushl %ebx
subl $LocalVarsSize, %esp subl $LocalVarsSize, %esp
/* Retrieve the function arguments. %ecx will hold cur_match */ /* Retrieve the function arguments. %ecx will hold cur_match */
/* throughout the entire function. %edx will hold the pointer to the */ /* throughout the entire function. %edx will hold the pointer to the */
/* deflate_state structure during the function's setup (before */ /* deflate_state structure during the function's setup (before */
/* entering the main loop). */ /* entering the main loop). */
movl deflatestate(%esp), %edx movl deflatestate(%esp), %edx
movl curmatch(%esp), %ecx movl curmatch(%esp), %ecx
/* uInt wmask = s->w_mask; */ /* uInt wmask = s->w_mask; */
/* unsigned chain_length = s->max_chain_length; */ /* unsigned chain_length = s->max_chain_length; */
/* if (s->prev_length >= s->good_match) { */ /* if (s->prev_length >= s->good_match) { */
/* chain_length >>= 2; */ /* chain_length >>= 2; */
/* } */ /* } */
movl dsPrevLen(%edx), %eax movl dsPrevLen(%edx), %eax
movl dsGoodMatch(%edx), %ebx movl dsGoodMatch(%edx), %ebx
cmpl %ebx, %eax cmpl %ebx, %eax
movl dsWMask(%edx), %eax movl dsWMask(%edx), %eax
movl dsMaxChainLen(%edx), %ebx movl dsMaxChainLen(%edx), %ebx
jl LastMatchGood jl LastMatchGood
shrl $2, %ebx shrl $2, %ebx
LastMatchGood: LastMatchGood:
/* chainlen is decremented once beforehand so that the function can */ /* chainlen is decremented once beforehand so that the function can */
/* use the sign flag instead of the zero flag for the exit test. */ /* use the sign flag instead of the zero flag for the exit test. */
/* It is then shifted into the high word, to make room for the wmask */ /* It is then shifted into the high word, to make room for the wmask */
/* value, which it will always accompany. */ /* value, which it will always accompany. */
decl %ebx decl %ebx
shll $16, %ebx shll $16, %ebx
orl %eax, %ebx orl %eax, %ebx
movl %ebx, chainlenwmask(%esp) movl %ebx, chainlenwmask(%esp)
/* if ((uInt)nice_match > s->lookahead) nice_match = s->lookahead; */ /* if ((uInt)nice_match > s->lookahead) nice_match = s->lookahead; */
movl dsNiceMatch(%edx), %eax movl dsNiceMatch(%edx), %eax
movl dsLookahead(%edx), %ebx movl dsLookahead(%edx), %ebx
cmpl %eax, %ebx cmpl %eax, %ebx
jl LookaheadLess jl LookaheadLess
movl %eax, %ebx movl %eax, %ebx
LookaheadLess: movl %ebx, nicematch(%esp) LookaheadLess: movl %ebx, nicematch(%esp)
/* register Bytef *scan = s->window + s->strstart; */ /* register Bytef *scan = s->window + s->strstart; */
movl dsWindow(%edx), %esi movl dsWindow(%edx), %esi
movl %esi, window(%esp) movl %esi, window(%esp)
movl dsStrStart(%edx), %ebp movl dsStrStart(%edx), %ebp
lea (%esi,%ebp), %edi lea (%esi,%ebp), %edi
movl %edi, scan(%esp) movl %edi, scan(%esp)
/* Determine how many bytes the scan ptr is off from being */ /* Determine how many bytes the scan ptr is off from being */
/* dword-aligned. */ /* dword-aligned. */
movl %edi, %eax movl %edi, %eax
negl %eax negl %eax
andl $3, %eax andl $3, %eax
movl %eax, scanalign(%esp) movl %eax, scanalign(%esp)
/* 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; */
movl dsWSize(%edx), %eax movl dsWSize(%edx), %eax
subl $MIN_LOOKAHEAD, %eax subl $MIN_LOOKAHEAD, %eax
subl %eax, %ebp subl %eax, %ebp
jg LimitPositive jg LimitPositive
xorl %ebp, %ebp xorl %ebp, %ebp
LimitPositive: LimitPositive:
/* int best_len = s->prev_length; */ /* int best_len = s->prev_length; */
movl dsPrevLen(%edx), %eax movl dsPrevLen(%edx), %eax
movl %eax, bestlen(%esp) movl %eax, bestlen(%esp)
/* Store the sum of s->window + best_len in %esi locally, and in %esi. */ /* Store the sum of s->window + best_len in %esi locally, and in %esi. */
addl %eax, %esi addl %eax, %esi
movl %esi, windowbestlen(%esp) movl %esi, windowbestlen(%esp)
/* register ush scan_start = *(ushf*)scan; */ /* register ush scan_start = *(ushf*)scan; */
/* register ush scan_end = *(ushf*)(scan+best_len-1); */ /* register ush scan_end = *(ushf*)(scan+best_len-1); */
/* Posf *prev = s->prev; */ /* Posf *prev = s->prev; */
movzwl (%edi), %ebx movzwl (%edi), %ebx
movl %ebx, scanstart(%esp) movl %ebx, scanstart(%esp)
movzwl -1(%edi,%eax), %ebx movzwl -1(%edi,%eax), %ebx
movl %ebx, scanend(%esp) movl %ebx, scanend(%esp)
movl dsPrev(%edx), %edi movl dsPrev(%edx), %edi
/* Jump into the main loop. */ /* Jump into the main loop. */
movl chainlenwmask(%esp), %edx movl chainlenwmask(%esp), %edx
jmp LoopEntry jmp LoopEntry
.balign 16 .balign 16
/* do { /* do {
* match = s->window + cur_match; * match = s->window + cur_match;
* if (*(ushf*)(match+best_len-1) != scan_end || * if (*(ushf*)(match+best_len-1) != scan_end ||
* *(ushf*)match != scan_start) continue; * *(ushf*)match != scan_start) continue;
* [...] * [...]
* } while ((cur_match = prev[cur_match & wmask]) > limit * } while ((cur_match = prev[cur_match & wmask]) > limit
* && --chain_length != 0); * && --chain_length != 0);
* *
* Here is the inner loop of the function. The function will spend the * Here is the inner loop of the function. The function will spend the
* majority of its time in this loop, and majority of that time will * majority of its time in this loop, and majority of that time will
* be spent in the first ten instructions. * be spent in the first ten instructions.
* *
* Within this loop: * Within this loop:
* %ebx = scanend * %ebx = scanend
* %ecx = curmatch * %ecx = curmatch
* %edx = chainlenwmask - i.e., ((chainlen << 16) | wmask) * %edx = chainlenwmask - i.e., ((chainlen << 16) | wmask)
* %esi = windowbestlen - i.e., (window + bestlen) * %esi = windowbestlen - i.e., (window + bestlen)
* %edi = prev * %edi = prev
* %ebp = limit * %ebp = limit
*/ */
LookupLoop: LookupLoop:
andl %edx, %ecx andl %edx, %ecx
movzwl (%edi,%ecx,2), %ecx movzwl (%edi,%ecx,2), %ecx
cmpl %ebp, %ecx cmpl %ebp, %ecx
jbe LeaveNow jbe LeaveNow
subl $0x00010000, %edx subl $0x00010000, %edx
js LeaveNow js LeaveNow
LoopEntry: movzwl -1(%esi,%ecx), %eax LoopEntry: movzwl -1(%esi,%ecx), %eax
cmpl %ebx, %eax cmpl %ebx, %eax
jnz LookupLoop jnz LookupLoop
movl window(%esp), %eax movl window(%esp), %eax
movzwl (%eax,%ecx), %eax movzwl (%eax,%ecx), %eax
cmpl scanstart(%esp), %eax cmpl scanstart(%esp), %eax
jnz LookupLoop jnz LookupLoop
/* Store the current value of chainlen. */ /* Store the current value of chainlen. */
movl %edx, chainlenwmask(%esp) movl %edx, chainlenwmask(%esp)
/* Point %edi to the string under scrutiny, and %esi to the string we */ /* Point %edi to the string under scrutiny, and %esi to the string we */
/* are hoping to match it up with. In actuality, %esi and %edi are */ /* are hoping to match it up with. In actuality, %esi and %edi are */
/* both pointed (MAX_MATCH_8 - scanalign) bytes ahead, and %edx is */ /* both pointed (MAX_MATCH_8 - scanalign) bytes ahead, and %edx is */
/* initialized to -(MAX_MATCH_8 - scanalign). */ /* initialized to -(MAX_MATCH_8 - scanalign). */
movl window(%esp), %esi movl window(%esp), %esi
movl scan(%esp), %edi movl scan(%esp), %edi
addl %ecx, %esi addl %ecx, %esi
movl scanalign(%esp), %eax movl scanalign(%esp), %eax
movl $(-MAX_MATCH_8), %edx movl $(-MAX_MATCH_8), %edx
lea MAX_MATCH_8(%edi,%eax), %edi lea MAX_MATCH_8(%edi,%eax), %edi
lea MAX_MATCH_8(%esi,%eax), %esi lea MAX_MATCH_8(%esi,%eax), %esi
/* Test the strings for equality, 8 bytes at a time. At the end, /* Test the strings for equality, 8 bytes at a time. At the end,
* adjust %edx so that it is offset to the exact byte that mismatched. * adjust %edx so that it is offset to the exact byte that mismatched.
* *
* We already know at this point that the first three bytes of the * We already know at this point that the first three bytes of the
* strings match each other, and they can be safely passed over before * strings match each other, and they can be safely passed over before
* starting the compare loop. So what this code does is skip over 0-3 * starting the compare loop. So what this code does is skip over 0-3
* bytes, as much as necessary in order to dword-align the %edi * bytes, as much as necessary in order to dword-align the %edi
* pointer. (%esi will still be misaligned three times out of four.) * pointer. (%esi will still be misaligned three times out of four.)
* *
* It should be confessed that this loop usually does not represent * It should be confessed that this loop usually does not represent
* much of the total running time. Replacing it with a more * much of the total running time. Replacing it with a more
* straightforward "rep cmpsb" would not drastically degrade * straightforward "rep cmpsb" would not drastically degrade
* performance. * performance.
*/ */
LoopCmps: LoopCmps:
movl (%esi,%edx), %eax movl (%esi,%edx), %eax
xorl (%edi,%edx), %eax xorl (%edi,%edx), %eax
jnz LeaveLoopCmps jnz LeaveLoopCmps
movl 4(%esi,%edx), %eax movl 4(%esi,%edx), %eax
xorl 4(%edi,%edx), %eax xorl 4(%edi,%edx), %eax
jnz LeaveLoopCmps4 jnz LeaveLoopCmps4
addl $8, %edx addl $8, %edx
jnz LoopCmps jnz LoopCmps
jmp LenMaximum jmp LenMaximum
LeaveLoopCmps4: addl $4, %edx LeaveLoopCmps4: addl $4, %edx
LeaveLoopCmps: testl $0x0000FFFF, %eax LeaveLoopCmps: testl $0x0000FFFF, %eax
jnz LenLower jnz LenLower
addl $2, %edx addl $2, %edx
shrl $16, %eax shrl $16, %eax
LenLower: subb $1, %al LenLower: subb $1, %al
adcl $0, %edx adcl $0, %edx
/* Calculate the length of the match. If it is longer than MAX_MATCH, */ /* Calculate the length of the match. If it is longer than MAX_MATCH, */
/* then automatically accept it as the best possible match and leave. */ /* then automatically accept it as the best possible match and leave. */
lea (%edi,%edx), %eax lea (%edi,%edx), %eax
movl scan(%esp), %edi movl scan(%esp), %edi
subl %edi, %eax subl %edi, %eax
cmpl $MAX_MATCH, %eax cmpl $MAX_MATCH, %eax
jge LenMaximum jge LenMaximum
/* If the length of the match is not longer than the best match we */ /* If the length of the match is not longer than the best match we */
/* have so far, then forget it and return to the lookup loop. */ /* have so far, then forget it and return to the lookup loop. */
movl deflatestate(%esp), %edx movl deflatestate(%esp), %edx
movl bestlen(%esp), %ebx movl bestlen(%esp), %ebx
cmpl %ebx, %eax cmpl %ebx, %eax
jg LongerMatch jg LongerMatch
movl windowbestlen(%esp), %esi movl windowbestlen(%esp), %esi
movl dsPrev(%edx), %edi movl dsPrev(%edx), %edi
movl scanend(%esp), %ebx movl scanend(%esp), %ebx
movl chainlenwmask(%esp), %edx movl chainlenwmask(%esp), %edx
jmp LookupLoop jmp LookupLoop
/* s->match_start = cur_match; */ /* s->match_start = cur_match; */
/* best_len = len; */ /* best_len = len; */
/* if (len >= nice_match) break; */ /* if (len >= nice_match) break; */
/* scan_end = *(ushf*)(scan+best_len-1); */ /* scan_end = *(ushf*)(scan+best_len-1); */
LongerMatch: movl nicematch(%esp), %ebx LongerMatch: movl nicematch(%esp), %ebx
movl %eax, bestlen(%esp) movl %eax, bestlen(%esp)
movl %ecx, dsMatchStart(%edx) movl %ecx, dsMatchStart(%edx)
cmpl %ebx, %eax cmpl %ebx, %eax
jge LeaveNow jge LeaveNow
movl window(%esp), %esi movl window(%esp), %esi
addl %eax, %esi addl %eax, %esi
movl %esi, windowbestlen(%esp) movl %esi, windowbestlen(%esp)
movzwl -1(%edi,%eax), %ebx movzwl -1(%edi,%eax), %ebx
movl dsPrev(%edx), %edi movl dsPrev(%edx), %edi
movl %ebx, scanend(%esp) movl %ebx, scanend(%esp)
movl chainlenwmask(%esp), %edx movl chainlenwmask(%esp), %edx
jmp LookupLoop jmp LookupLoop
/* Accept the current string, with the maximum possible length. */ /* Accept the current string, with the maximum possible length. */
LenMaximum: movl deflatestate(%esp), %edx LenMaximum: movl deflatestate(%esp), %edx
movl $MAX_MATCH, bestlen(%esp) movl $MAX_MATCH, bestlen(%esp)
movl %ecx, dsMatchStart(%edx) movl %ecx, dsMatchStart(%edx)
/* if ((uInt)best_len <= s->lookahead) return (uInt)best_len; */ /* if ((uInt)best_len <= s->lookahead) return (uInt)best_len; */
/* return s->lookahead; */ /* return s->lookahead; */
LeaveNow: LeaveNow:
movl deflatestate(%esp), %edx movl deflatestate(%esp), %edx
movl bestlen(%esp), %ebx movl bestlen(%esp), %ebx
movl dsLookahead(%edx), %eax movl dsLookahead(%edx), %eax
cmpl %eax, %ebx cmpl %eax, %ebx
jg LookaheadRet jg LookaheadRet
movl %ebx, %eax movl %ebx, %eax
LookaheadRet: LookaheadRet:
/* Restore the stack and return from whence we came. */ /* Restore the stack and return from whence we came. */
addl $LocalVarsSize, %esp addl $LocalVarsSize, %esp
popl %ebx popl %ebx
popl %esi popl %esi
popl %edi popl %edi
popl %ebp popl %ebp
match_init: ret match_init: ret

2
contrib/delphi/ZLib.pas
View File

@@ -152,7 +152,7 @@ procedure DecompressToUserBuf(const InBuf: Pointer; InBytes: Integer;
const OutBuf: Pointer; BufSize: Integer); const OutBuf: Pointer; BufSize: Integer);
const const
zlib_version = '1.2.2'; zlib_version = '1.2.3';
type type
EZlibError = class(Exception); EZlibError = class(Exception);

2
contrib/dotzlib/DotZLib/UnitTests.cs
View File

@@ -156,7 +156,7 @@ namespace DotZLibTests
public void Info_Version() public void Info_Version()
{ {
Info info = new Info(); Info info = new Info();
Assert.AreEqual("1.2.2", Info.Version); Assert.AreEqual("1.2.3", Info.Version);
Assert.AreEqual(32, info.SizeOfUInt); Assert.AreEqual(32, info.SizeOfUInt);
Assert.AreEqual(32, info.SizeOfULong); Assert.AreEqual(32, info.SizeOfULong);
Assert.AreEqual(32, info.SizeOfPointer); Assert.AreEqual(32, info.SizeOfPointer);

6
contrib/infback9/inftree9.c
View File

@@ -9,7 +9,7 @@
#define MAXBITS 15 #define MAXBITS 15
const char inflate9_copyright[] = const char inflate9_copyright[] =
" inflate9 1.2.2.4 Copyright 1995-2005 Mark Adler "; " inflate9 1.2.3 Copyright 1995-2005 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
@@ -64,7 +64,7 @@ unsigned short FAR *work;
static const unsigned short lext[31] = { /* Length codes 257..285 extra */ static const unsigned short lext[31] = { /* Length codes 257..285 extra */
128, 128, 128, 128, 128, 128, 128, 128, 129, 129, 129, 129, 128, 128, 128, 128, 128, 128, 128, 128, 129, 129, 129, 129,
130, 130, 130, 130, 131, 131, 131, 131, 132, 132, 132, 132, 130, 130, 130, 130, 131, 131, 131, 131, 132, 132, 132, 132,
133, 133, 133, 133, 144, 206, 69}; 133, 133, 133, 133, 144, 201, 196};
static const unsigned short dbase[32] = { /* Distance codes 0..31 base */ static const unsigned short dbase[32] = { /* Distance codes 0..31 base */
1, 2, 3, 4, 5, 7, 9, 13, 17, 25, 33, 49, 1, 2, 3, 4, 5, 7, 9, 13, 17, 25, 33, 49,
65, 97, 129, 193, 257, 385, 513, 769, 1025, 1537, 2049, 3073, 65, 97, 129, 193, 257, 385, 513, 769, 1025, 1537, 2049, 3073,
@@ -128,7 +128,7 @@ unsigned short FAR *work;
left -= count[len]; left -= count[len];
if (left < 0) return -1; /* over-subscribed */ if (left < 0) return -1; /* over-subscribed */
} }
if (left > 0 && (type == CODES || (codes - count[0] != 1))) if (left > 0 && (type == CODES || max != 1))
return -1; /* incomplete set */ return -1; /* incomplete set */
/* generate offsets into symbol table for each length for sorting */ /* generate offsets into symbol table for each length for sorting */

8
contrib/infback9/inftree9.h
View File

@@ -36,12 +36,12 @@ typedef struct {
*/ */
/* Maximum size of dynamic tree. The maximum found in a long but non- /* Maximum size of dynamic tree. The maximum found in a long but non-
exhaustive search was 1004 code structures (850 for length/literals exhaustive search was 1444 code structures (852 for length/literals
and 154 for distances, the latter actually the result of an and 592 for distances, the latter actually the result of an
exhaustive search). The true maximum is not known, but the value exhaustive search). The true maximum is not known, but the value
below is more than safe. */ below is more than safe. */
#define ENOUGH 1440 #define ENOUGH 2048
#define MAXD 154 #define MAXD 592
/* Type of code to build for inftable() */ /* Type of code to build for inftable() */
typedef enum { typedef enum {

161
contrib/masmx64/gvmat64.asm
View File

@@ -4,24 +4,33 @@
; gvmat64.asm -- Asm portion of the optimized longest_match for 32 bits x86 ; gvmat64.asm -- Asm portion of the optimized longest_match for 32 bits x86
; Copyright (C) 1995-2005 Jean-loup Gailly, Brian Raiter and Gilles Vollant. ; Copyright (C) 1995-2005 Jean-loup Gailly, Brian Raiter and Gilles Vollant.
; File written by Gilles Vollant, by modifiying the longest_match ;
; from Jean-loup Gailly in deflate.c ; File written by Gilles Vollant, by converting to assembly the longest_match
; and modifying asm686 with masm, optimised assembly code from Brian Raiter, ; from Jean-loup Gailly in deflate.c of zLib and infoZip zip.
; written 1998 ;
; and by taking inspiration on asm686 with masm, optimised assembly code
; from Brian Raiter, written 1998
;
; http://www.zlib.net ; http://www.zlib.net
; http://www.winimage.com/zLibDll ; http://www.winimage.com/zLibDll
; http://www.muppetlabs.com/~breadbox/software/assembly.html ; http://www.muppetlabs.com/~breadbox/software/assembly.html
; ;
; to compile this file, I use option ; to compile this file for infozip Zip, I use option:
; ml64.exe /Flgvmat64 /c /Zi gvmat64.asm ; ml64.exe /Flgvmat64 /c /Zi /DINFOZIP gvmat64.asm
; with Microsoft Macro Assembler (x64) for AMD64
; ;
; ml64.exe is given with Visual Studio 2005, Windows 2003 server DDK ; to compile this file for zLib, I use option:
; ml64.exe /Flgvmat64 /c /Zi gvmat64.asm
; Be carrefull to adapt zlib1222add below to your version of zLib
; (if you use a version of zLib before 1.0.4 or after 1.2.2.2, change
; value of zlib1222add later)
;
; This file compile with Microsoft Macro Assembler (x64) for AMD64
;
; ml64.exe is given with Visual Studio 2005 and Windows 2003 server DDK
; ;
; (you can get Windows 2003 server DDK with ml64 and cl for AMD64 from ; (you can get Windows 2003 server DDK with ml64 and cl for AMD64 from
; http://www.microsoft.com/whdc/devtools/ddk/default.mspx for low price) ; http://www.microsoft.com/whdc/devtools/ddk/default.mspx for low price)
; ;
; Be carrefull to adapt zlib1222add below to your version of zLib
;uInt longest_match(s, cur_match) ;uInt longest_match(s, cur_match)
@@ -47,7 +56,10 @@ longest_match PROC
;scanalign equ rsp + xx - LocalVarsSize ; dword-misalignment of string r13 ;scanalign equ rsp + xx - LocalVarsSize ; dword-misalignment of string r13
;bestlen equ rsp + xx - LocalVarsSize ; size of best match so far -> r11d ;bestlen equ rsp + xx - LocalVarsSize ; size of best match so far -> r11d
;scan equ rsp + xx - LocalVarsSize ; ptr to string wanting match -> r9 ;scan equ rsp + xx - LocalVarsSize ; ptr to string wanting match -> r9
nicematch equ rsp + 16 - LocalVarsSize ; a good enough match size -> r14 IFDEF INFOZIP
ELSE
nicematch equ (rsp + 16 - LocalVarsSize) ; a good enough match size
ENDIF
save_rdi equ rsp + 24 - LocalVarsSize save_rdi equ rsp + 24 - LocalVarsSize
save_rsi equ rsp + 32 - LocalVarsSize save_rsi equ rsp + 32 - LocalVarsSize
@@ -84,8 +96,34 @@ save_r13 equ rsp + 64 - LocalVarsSize
; (if you compile with zlib between 1.0.5 and 1.2.2.1, use "zlib1222add equ 0"). ; (if you compile with zlib between 1.0.5 and 1.2.2.1, use "zlib1222add equ 0").
; if you compile with zlib 1.2.2.2 or later , use "zlib1222add equ 8"). ; if you compile with zlib 1.2.2.2 or later , use "zlib1222add equ 8").
zlib1222add equ 8
IFDEF INFOZIP
_DATA SEGMENT
COMM window_size:DWORD
; WMask ; 7fff
COMM window:BYTE:010040H
COMM prev:WORD:08000H
; MatchLen : unused
; PrevMatch : unused
COMM strstart:DWORD
COMM match_start:DWORD
; Lookahead : ignore
COMM prev_length:DWORD ; PrevLen
COMM max_chain_length:DWORD
COMM good_match:DWORD
COMM nice_match:DWORD
prev_ad equ OFFSET prev
window_ad equ OFFSET window
nicematch equ nice_match
_DATA ENDS
WMask equ 07fffh
ELSE
IFNDEF zlib1222add
zlib1222add equ 8
ENDIF
dsWSize equ 56+zlib1222add+(zlib1222add/2) dsWSize equ 56+zlib1222add+(zlib1222add/2)
dsWMask equ 64+zlib1222add+(zlib1222add/2) dsWMask equ 64+zlib1222add+(zlib1222add/2)
dsWindow equ 72+zlib1222add dsWindow equ 72+zlib1222add
@@ -100,6 +138,18 @@ dsMaxChainLen equ 156+zlib1222add
dsGoodMatch equ 172+zlib1222add dsGoodMatch equ 172+zlib1222add
dsNiceMatch equ 176+zlib1222add dsNiceMatch equ 176+zlib1222add
window_size equ [ rcx + dsWSize]
WMask equ [ rcx + dsWMask]
window_ad equ [ rcx + dsWindow]
prev_ad equ [ rcx + dsPrev]
strstart equ [ rcx + dsStrStart]
match_start equ [ rcx + dsMatchStart]
Lookahead equ [ rcx + dsLookahead] ; 0ffffffffh on infozip
prev_length equ [ rcx + dsPrevLen]
max_chain_length equ [ rcx + dsMaxChainLen]
good_match equ [ rcx + dsGoodMatch]
nice_match equ [ rcx + dsNiceMatch]
ENDIF
; parameter 1 in r8(deflate state s), param 2 in rdx (cur match) ; parameter 1 in r8(deflate state s), param 2 in rdx (cur match)
@@ -107,7 +157,7 @@ dsNiceMatch equ 176+zlib1222add
; http://msdn.microsoft.com/library/en-us/kmarch/hh/kmarch/64bitAMD_8e951dd2-ee77-4728-8702-55ce4b5dd24a.xml.asp ; http://msdn.microsoft.com/library/en-us/kmarch/hh/kmarch/64bitAMD_8e951dd2-ee77-4728-8702-55ce4b5dd24a.xml.asp
; ;
; All registers must be preserved across the call, except for ; All registers must be preserved across the call, except for
; rax, rcx, rdx, r8, r-9, r10, and r11, which are scratch. ; rax, rcx, rdx, r8, r9, r10, and r11, which are scratch.
@@ -124,12 +174,15 @@ dsNiceMatch equ 176+zlib1222add
; this clear high 32 bits of r8, which can be garbage in both r8 and rdx ; this clear high 32 bits of r8, which can be garbage in both r8 and rdx
mov [save_rdi],rdi mov [save_rdi],rdi
mov [save_rsi],rsi mov [save_rsi],rsi
mov [save_rbx],rbx mov [save_rbx],rbx
mov [save_rbp],rbp mov [save_rbp],rbp
IFDEF INFOZIP
mov r8d,ecx
ELSE
mov r8d,edx mov r8d,edx
ENDIF
mov [save_r12],r12 mov [save_r12],r12
mov [save_r13],r13 mov [save_r13],r13
; mov [save_r14],r14 ; mov [save_r14],r14
@@ -142,10 +195,10 @@ dsNiceMatch equ 176+zlib1222add
;;; chain_length >>= 2; ;;; chain_length >>= 2;
;;; } ;;; }
mov edi, [rcx + dsPrevLen] mov edi, prev_length
mov esi, [rcx + dsGoodMatch] mov esi, good_match
mov eax, [rcx + dsWMask] mov eax, WMask
mov ebx, [rcx + dsMaxChainLen] mov ebx, max_chain_length
cmp edi, esi cmp edi, esi
jl LastMatchGood jl LastMatchGood
shr ebx, 2 shr ebx, 2
@@ -159,21 +212,25 @@ LastMatchGood:
dec ebx dec ebx
shl ebx, 16 shl ebx, 16
or ebx, eax or ebx, eax
mov [chainlenwmask], ebx
;;; on zlib only
;;; if ((uInt)nice_match > s->lookahead) nice_match = s->lookahead; ;;; if ((uInt)nice_match > s->lookahead) nice_match = s->lookahead;
mov eax, [rcx + dsNiceMatch] IFDEF INFOZIP
mov r10d, [rcx + dsLookahead] mov [chainlenwmask], ebx
; on infozip nice_match = [nice_match]
ELSE
mov eax, nice_match
mov [chainlenwmask], ebx
mov r10d, Lookahead
cmp r10d, eax cmp r10d, eax
cmovnl r10d, eax cmovnl r10d, eax
mov [nicematch],r10d mov [nicematch],r10d
LookaheadLess: ENDIF
;;; register Bytef *scan = s->window + s->strstart; ;;; register Bytef *scan = s->window + s->strstart;
mov r10, window_ad
mov r10, [rcx + dsWindow] mov ebp, strstart
mov ebp, [rcx + dsStrStart]
lea r13, [r10 + rbp] lea r13, [r10 + rbp]
;;; Determine how many bytes the scan ptr is off from being ;;; Determine how many bytes the scan ptr is off from being
@@ -185,13 +242,16 @@ LookaheadLess:
;;; 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;
IFDEF INFOZIP
mov eax, [rcx + dsWSize] mov eax,07efah ; MAX_DIST = (WSIZE-MIN_LOOKAHEAD) (0x8000-(3+8+1))
ELSE
mov eax, window_size
sub eax, MIN_LOOKAHEAD sub eax, MIN_LOOKAHEAD
ENDIF
xor edi,edi xor edi,edi
sub ebp, eax sub ebp, eax
mov r11d, [rcx + dsPrevLen] mov r11d, prev_length
cmovng ebp,edi cmovng ebp,edi
@@ -207,8 +267,9 @@ LookaheadLess:
;;; Posf *prev = s->prev; ;;; Posf *prev = s->prev;
movzx r12d,word ptr [r9] movzx r12d,word ptr [r9]
movzx ebx, word ptr [r9 + r11 - 1] movzx ebx, word ptr [r9 + r11 - 1]
mov rdi, [rcx + dsPrev]
mov rdi, prev_ad
;;; Jump into the main loop. ;;; Jump into the main loop.
@@ -312,38 +373,22 @@ LookupLoopIsZero:
prefetcht1 [rsi+rdx] prefetcht1 [rsi+rdx]
prefetcht1 [rdi+rdx] prefetcht1 [rdi+rdx]
;;; Test the strings for equality, 8 bytes at a time. At the end, ;;; Test the strings for equality, 8 bytes at a time. At the end,
;;; adjust edx so that it is offset to the exact byte that mismatched. ;;; adjust rdx so that it is offset to the exact byte that mismatched.
;;; ;;;
;;; We already know at this point that the first three bytes of the ;;; We already know at this point that the first three bytes of the
;;; strings match each other, and they can be safely passed over before ;;; strings match each other, and they can be safely passed over before
;;; starting the compare loop. So what this code does is skip over 0-3 ;;; starting the compare loop. So what this code does is skip over 0-3
;;; bytes, as much as necessary in order to dword-align the edi ;;; bytes, as much as necessary in order to dword-align the edi
;;; pointer. (esi will still be misaligned three times out of four.) ;;; pointer. (rsi will still be misaligned three times out of four.)
;;; ;;;
;;; It should be confessed that this loop usually does not represent ;;; It should be confessed that this loop usually does not represent
;;; much of the total running time. Replacing it with a more ;;; much of the total running time. Replacing it with a more
;;; straightforward "rep cmpsb" would not drastically degrade ;;; straightforward "rep cmpsb" would not drastically degrade
;;; performance. ;;; performance.
;LoopCmps:
; mov eax, [rsi + rdx]
; xor eax, [rdi + rdx]
; jnz LeaveLoopCmps
; mov eax, [rsi + rdx + 4]
; xor eax, [rdi + rdx + 4]
; jnz LeaveLoopCmps4
; add rdx, 8
; jnz LoopCmps
; jmp LenMaximum
;LeaveLoopCmps4: add rdx, 4
;LeaveLoopCmps: test eax, 0000FFFFh
; jnz LenLower
; add rdx, 2
; shr eax, 16
;LenLower: sub al, 1
; adc rdx, 0
LoopCmps: LoopCmps:
mov rax, [rsi + rdx] mov rax, [rsi + rdx]
@@ -400,7 +445,7 @@ LenLower: sub al, 1
lea rsi,[r10+r11] lea rsi,[r10+r11]
mov rdi, [rcx + dsPrev] mov rdi, prev_ad
mov edx, [chainlenwmask] mov edx, [chainlenwmask]
jmp LookupLoop jmp LookupLoop
@@ -411,14 +456,14 @@ LenLower: sub al, 1
LongerMatch: LongerMatch:
mov r11d, eax mov r11d, eax
mov [rcx + dsMatchStart], r8d mov match_start, r8d
cmp eax, [nicematch] cmp eax, [nicematch]
jge LeaveNow jge LeaveNow
lea rsi,[r10+rax] lea rsi,[r10+rax]
movzx ebx, word ptr [r9 + rax - 1] movzx ebx, word ptr [r9 + rax - 1]
mov rdi, [rcx + dsPrev] mov rdi, prev_ad
mov edx, [chainlenwmask] mov edx, [chainlenwmask]
jmp LookupLoop jmp LookupLoop
@@ -426,16 +471,19 @@ LongerMatch:
LenMaximum: LenMaximum:
mov r11d,MAX_MATCH mov r11d,MAX_MATCH
mov [rcx + dsMatchStart], r8d mov match_start, r8d
;;; if ((uInt)best_len <= s->lookahead) return (uInt)best_len; ;;; if ((uInt)best_len <= s->lookahead) return (uInt)best_len;
;;; return s->lookahead; ;;; return s->lookahead;
LeaveNow: LeaveNow:
mov eax, [rcx + dsLookahead] IFDEF INFOZIP
mov eax,r11d
ELSE
mov eax, Lookahead
cmp r11d, eax cmp r11d, eax
cmovng eax, r11d cmovng eax, r11d
ENDIF
;;; Restore the stack and return from whence we came. ;;; Restore the stack and return from whence we came.
@@ -452,7 +500,8 @@ LeaveNow:
ret 0 ret 0
; please don't remove this string ! ; please don't remove this string !
; Your can freely use gvmat32 in any free or commercial app if you don't remove the string in the binary! ; Your can freely use gvmat64 in any free or commercial app
; but it is far better don't remove the string in the binary!
db 0dh,0ah,"asm686 with masm, optimised assembly code from Brian Raiter, written 1998, converted to amd 64 by Gilles Vollant 2005",0dh,0ah,0 db 0dh,0ah,"asm686 with masm, optimised assembly code from Brian Raiter, written 1998, converted to amd 64 by Gilles Vollant 2005",0dh,0ah,0
longest_match ENDP longest_match ENDP

BIN
contrib/masmx64/gvmat64.obj
View File

Binary file not shown.

0
contrib/vstudio/vc7/gvmat32.obj → contrib/masmx86/gvmat32.obj
View File

0
contrib/vstudio/vc7/inffas32.obj → contrib/masmx86/inffas32.obj
View File

134
contrib/minizip/ChangeLogUnzip
View File

@@ -1,67 +1,67 @@
Change in 1.01e (12 feb 05) Change in 1.01e (12 feb 05)
- Fix in zipOpen2 for globalcomment (Rolf Kalbermatter) - Fix in zipOpen2 for globalcomment (Rolf Kalbermatter)
- Fix possible memory leak in unzip.c (Zoran Stevanovic) - Fix possible memory leak in unzip.c (Zoran Stevanovic)
Change in 1.01b (20 may 04) Change in 1.01b (20 may 04)
- Integrate patch from Debian package (submited by Mark Brown) - Integrate patch from Debian package (submited by Mark Brown)
- Add tools mztools from Xavier Roche - Add tools mztools from Xavier Roche
Change in 1.01 (8 may 04) Change in 1.01 (8 may 04)
- fix buffer overrun risk in unzip.c (Xavier Roche) - fix buffer overrun risk in unzip.c (Xavier Roche)
- fix a minor buffer insecurity in minizip.c (Mike Whittaker) - fix a minor buffer insecurity in minizip.c (Mike Whittaker)
Change in 1.00: (10 sept 03) Change in 1.00: (10 sept 03)
- rename to 1.00 - rename to 1.00
- cosmetic code change - cosmetic code change
Change in 0.22: (19 May 03) Change in 0.22: (19 May 03)
- crypting support (unless you define NOCRYPT) - crypting support (unless you define NOCRYPT)
- append file in existing zipfile - append file in existing zipfile
Change in 0.21: (10 Mar 03) Change in 0.21: (10 Mar 03)
- bug fixes - bug fixes
Change in 0.17: (27 Jan 02) Change in 0.17: (27 Jan 02)
- bug fixes - bug fixes
Change in 0.16: (19 Jan 02) Change in 0.16: (19 Jan 02)
- Support of ioapi for virtualize zip file access - Support of ioapi for virtualize zip file access
Change in 0.15: (19 Mar 98) Change in 0.15: (19 Mar 98)
- fix memory leak in minizip.c - fix memory leak in minizip.c
Change in 0.14: (10 Mar 98) Change in 0.14: (10 Mar 98)
- fix bugs in minizip.c sample for zipping big file - fix bugs in minizip.c sample for zipping big file
- fix problem in month in date handling - fix problem in month in date handling
- fix bug in unzlocal_GetCurrentFileInfoInternal in unzip.c for - fix bug in unzlocal_GetCurrentFileInfoInternal in unzip.c for
comment handling comment handling
Change in 0.13: (6 Mar 98) Change in 0.13: (6 Mar 98)
- fix bugs in zip.c - fix bugs in zip.c
- add real minizip sample - add real minizip sample
Change in 0.12: (4 Mar 98) Change in 0.12: (4 Mar 98)
- add zip.c and zip.h for creates .zip file - add zip.c and zip.h for creates .zip file
- fix change_file_date in miniunz.c for Unix (Jean-loup Gailly) - fix change_file_date in miniunz.c for Unix (Jean-loup Gailly)
- fix miniunz.c for file without specific record for directory - fix miniunz.c for file without specific record for directory
Change in 0.11: (3 Mar 98) Change in 0.11: (3 Mar 98)
- fix bug in unzGetCurrentFileInfo for get extra field and comment - fix bug in unzGetCurrentFileInfo for get extra field and comment
- enhance miniunz sample, remove the bad unztst.c sample - enhance miniunz sample, remove the bad unztst.c sample
Change in 0.10: (2 Mar 98) Change in 0.10: (2 Mar 98)
- fix bug in unzReadCurrentFile - fix bug in unzReadCurrentFile
- rename unzip* to unz* function and structure - rename unzip* to unz* function and structure
- remove Windows-like hungary notation variable name - remove Windows-like hungary notation variable name
- modify some structure in unzip.h - modify some structure in unzip.h
- add somes comment in source - add somes comment in source
- remove unzipGetcCurrentFile function - remove unzipGetcCurrentFile function
- replace ZUNZEXPORT by ZEXPORT - replace ZUNZEXPORT by ZEXPORT
- add unzGetLocalExtrafield for get the local extrafield info - add unzGetLocalExtrafield for get the local extrafield info
- add a new sample, miniunz.c - add a new sample, miniunz.c
Change in 0.4: (25 Feb 98) Change in 0.4: (25 Feb 98)
- suppress the type unzipFileInZip. - suppress the type unzipFileInZip.
Only on file in the zipfile can be open at the same time Only on file in the zipfile can be open at the same time
- fix somes typo in code - fix somes typo in code
- added tm_unz structure in unzip_file_info (date/time in readable format) - added tm_unz structure in unzip_file_info (date/time in readable format)

50
contrib/minizip/Makefile
View File

@@ -1,25 +1,25 @@
CC=cc CC=cc
CFLAGS=-O -I../.. CFLAGS=-O -I../..
UNZ_OBJS = miniunz.o unzip.o ioapi.o ../../libz.a UNZ_OBJS = miniunz.o unzip.o ioapi.o ../../libz.a
ZIP_OBJS = minizip.o zip.o ioapi.o ../../libz.a ZIP_OBJS = minizip.o zip.o ioapi.o ../../libz.a
.c.o: .c.o:
$(CC) -c $(CFLAGS) $*.c $(CC) -c $(CFLAGS) $*.c
all: miniunz minizip all: miniunz minizip
miniunz: $(UNZ_OBJS) miniunz: $(UNZ_OBJS)
$(CC) $(CFLAGS) -o $@ $(UNZ_OBJS) $(CC) $(CFLAGS) -o $@ $(UNZ_OBJS)
minizip: $(ZIP_OBJS) minizip: $(ZIP_OBJS)
$(CC) $(CFLAGS) -o $@ $(ZIP_OBJS) $(CC) $(CFLAGS) -o $@ $(ZIP_OBJS)
test: miniunz minizip test: miniunz minizip
./minizip test readme.txt ./minizip test readme.txt
./miniunz -l test.zip ./miniunz -l test.zip
mv readme.txt readme.old mv readme.txt readme.old
./miniunz test.zip ./miniunz test.zip
clean: clean:
/bin/rm -f *.o *~ minizip miniunz /bin/rm -f *.o *~ minizip miniunz

264
contrib/minizip/crypt.h
View File

@@ -1,132 +1,132 @@
/* crypt.h -- base code for crypt/uncrypt ZIPfile /* crypt.h -- base code for crypt/uncrypt ZIPfile
Version 1.01e, February 12th, 2005 Version 1.01e, February 12th, 2005
Copyright (C) 1998-2005 Gilles Vollant Copyright (C) 1998-2005 Gilles Vollant
This code is a modified version of crypting code in Infozip distribution This code is a modified version of crypting code in Infozip distribution
The encryption/decryption parts of this source code (as opposed to the The encryption/decryption parts of this source code (as opposed to the
non-echoing password parts) were originally written in Europe. The non-echoing password parts) were originally written in Europe. The
whole source package can be freely distributed, including from the USA. whole source package can be freely distributed, including from the USA.
(Prior to January 2000, re-export from the US was a violation of US law.) (Prior to January 2000, re-export from the US was a violation of US law.)
This encryption code is a direct transcription of the algorithm from This encryption code is a direct transcription of the algorithm from
Roger Schlafly, described by Phil Katz in the file appnote.txt. This Roger Schlafly, described by Phil Katz in the file appnote.txt. This
file (appnote.txt) is distributed with the PKZIP program (even in the file (appnote.txt) is distributed with the PKZIP program (even in the
version without encryption capabilities). version without encryption capabilities).
If you don't need crypting in your application, just define symbols If you don't need crypting in your application, just define symbols
NOCRYPT and NOUNCRYPT. NOCRYPT and NOUNCRYPT.
This code support the "Traditional PKWARE Encryption". This code support the "Traditional PKWARE Encryption".
The new AES encryption added on Zip format by Winzip (see the page The new AES encryption added on Zip format by Winzip (see the page
http://www.winzip.com/aes_info.htm ) and PKWare PKZip 5.x Strong http://www.winzip.com/aes_info.htm ) and PKWare PKZip 5.x Strong
Encryption is not supported. Encryption is not supported.
*/ */
#define CRC32(c, b) ((*(pcrc_32_tab+(((int)(c) ^ (b)) & 0xff))) ^ ((c) >> 8)) #define CRC32(c, b) ((*(pcrc_32_tab+(((int)(c) ^ (b)) & 0xff))) ^ ((c) >> 8))
/*********************************************************************** /***********************************************************************
* Return the next byte in the pseudo-random sequence * Return the next byte in the pseudo-random sequence
*/ */
static int decrypt_byte(unsigned long* pkeys, const unsigned long* pcrc_32_tab) static int decrypt_byte(unsigned long* pkeys, const unsigned long* pcrc_32_tab)
{ {
unsigned temp; /* POTENTIAL BUG: temp*(temp^1) may overflow in an unsigned temp; /* POTENTIAL BUG: temp*(temp^1) may overflow in an
* unpredictable manner on 16-bit systems; not a problem * unpredictable manner on 16-bit systems; not a problem
* with any known compiler so far, though */ * with any known compiler so far, though */
temp = ((unsigned)(*(pkeys+2)) & 0xffff) | 2; temp = ((unsigned)(*(pkeys+2)) & 0xffff) | 2;
return (int)(((temp * (temp ^ 1)) >> 8) & 0xff); return (int)(((temp * (temp ^ 1)) >> 8) & 0xff);
} }
/*********************************************************************** /***********************************************************************
* Update the encryption keys with the next byte of plain text * Update the encryption keys with the next byte of plain text
*/ */
static int update_keys(unsigned long* pkeys,const unsigned long* pcrc_32_tab,int c) static int update_keys(unsigned long* pkeys,const unsigned long* pcrc_32_tab,int c)
{ {
(*(pkeys+0)) = CRC32((*(pkeys+0)), c); (*(pkeys+0)) = CRC32((*(pkeys+0)), c);
(*(pkeys+1)) += (*(pkeys+0)) & 0xff; (*(pkeys+1)) += (*(pkeys+0)) & 0xff;
(*(pkeys+1)) = (*(pkeys+1)) * 134775813L + 1; (*(pkeys+1)) = (*(pkeys+1)) * 134775813L + 1;
{ {
register int keyshift = (int)((*(pkeys+1)) >> 24); register int keyshift = (int)((*(pkeys+1)) >> 24);
(*(pkeys+2)) = CRC32((*(pkeys+2)), keyshift); (*(pkeys+2)) = CRC32((*(pkeys+2)), keyshift);
} }
return c; return c;
} }
/*********************************************************************** /***********************************************************************
* Initialize the encryption keys and the random header according to * Initialize the encryption keys and the random header according to
* the given password. * the given password.
*/ */
static void init_keys(const char* passwd,unsigned long* pkeys,const unsigned long* pcrc_32_tab) static void init_keys(const char* passwd,unsigned long* pkeys,const unsigned long* pcrc_32_tab)
{ {
*(pkeys+0) = 305419896L; *(pkeys+0) = 305419896L;
*(pkeys+1) = 591751049L; *(pkeys+1) = 591751049L;
*(pkeys+2) = 878082192L; *(pkeys+2) = 878082192L;
while (*passwd != '\0') { while (*passwd != '\0') {
update_keys(pkeys,pcrc_32_tab,(int)*passwd); update_keys(pkeys,pcrc_32_tab,(int)*passwd);
passwd++; passwd++;
} }
} }
#define zdecode(pkeys,pcrc_32_tab,c) \ #define zdecode(pkeys,pcrc_32_tab,c) \
(update_keys(pkeys,pcrc_32_tab,c ^= decrypt_byte(pkeys,pcrc_32_tab))) (update_keys(pkeys,pcrc_32_tab,c ^= decrypt_byte(pkeys,pcrc_32_tab)))
#define zencode(pkeys,pcrc_32_tab,c,t) \ #define zencode(pkeys,pcrc_32_tab,c,t) \
(t=decrypt_byte(pkeys,pcrc_32_tab), update_keys(pkeys,pcrc_32_tab,c), t^(c)) (t=decrypt_byte(pkeys,pcrc_32_tab), update_keys(pkeys,pcrc_32_tab,c), t^(c))
#ifdef INCLUDECRYPTINGCODE_IFCRYPTALLOWED #ifdef INCLUDECRYPTINGCODE_IFCRYPTALLOWED
#define RAND_HEAD_LEN 12 #define RAND_HEAD_LEN 12
/* "last resort" source for second part of crypt seed pattern */ /* "last resort" source for second part of crypt seed pattern */
# ifndef ZCR_SEED2 # ifndef ZCR_SEED2
# define ZCR_SEED2 3141592654UL /* use PI as default pattern */ # define ZCR_SEED2 3141592654UL /* use PI as default pattern */
# endif # endif
static int crypthead(passwd, buf, bufSize, pkeys, pcrc_32_tab, crcForCrypting) static int crypthead(passwd, buf, bufSize, pkeys, pcrc_32_tab, crcForCrypting)
const char *passwd; /* password string */ const char *passwd; /* password string */
unsigned char *buf; /* where to write header */ unsigned char *buf; /* where to write header */
int bufSize; int bufSize;
unsigned long* pkeys; unsigned long* pkeys;
const unsigned long* pcrc_32_tab; const unsigned long* pcrc_32_tab;
unsigned long crcForCrypting; unsigned long crcForCrypting;
{ {
int n; /* index in random header */ int n; /* index in random header */
int t; /* temporary */ int t; /* temporary */
int c; /* random byte */ int c; /* random byte */
unsigned char header[RAND_HEAD_LEN-2]; /* random header */ unsigned char header[RAND_HEAD_LEN-2]; /* random header */
static unsigned calls = 0; /* ensure different random header each time */ static unsigned calls = 0; /* ensure different random header each time */
if (bufSize<RAND_HEAD_LEN) if (bufSize<RAND_HEAD_LEN)
return 0; return 0;
/* First generate RAND_HEAD_LEN-2 random bytes. We encrypt the /* First generate RAND_HEAD_LEN-2 random bytes. We encrypt the
* output of rand() to get less predictability, since rand() is * output of rand() to get less predictability, since rand() is
* often poorly implemented. * often poorly implemented.
*/ */
if (++calls == 1) if (++calls == 1)
{ {
srand((unsigned)(time(NULL) ^ ZCR_SEED2)); srand((unsigned)(time(NULL) ^ ZCR_SEED2));
} }
init_keys(passwd, pkeys, pcrc_32_tab); init_keys(passwd, pkeys, pcrc_32_tab);
for (n = 0; n < RAND_HEAD_LEN-2; n++) for (n = 0; n < RAND_HEAD_LEN-2; n++)
{ {
c = (rand() >> 7) & 0xff; c = (rand() >> 7) & 0xff;
header[n] = (unsigned char)zencode(pkeys, pcrc_32_tab, c, t); header[n] = (unsigned char)zencode(pkeys, pcrc_32_tab, c, t);
} }
/* Encrypt random header (last two bytes is high word of crc) */ /* Encrypt random header (last two bytes is high word of crc) */
init_keys(passwd, pkeys, pcrc_32_tab); init_keys(passwd, pkeys, pcrc_32_tab);
for (n = 0; n < RAND_HEAD_LEN-2; n++) for (n = 0; n < RAND_HEAD_LEN-2; n++)
{ {
buf[n] = (unsigned char)zencode(pkeys, pcrc_32_tab, header[n], t); buf[n] = (unsigned char)zencode(pkeys, pcrc_32_tab, header[n], t);
} }
buf[n++] = zencode(pkeys, pcrc_32_tab, (int)(crcForCrypting >> 16) & 0xff, t); buf[n++] = zencode(pkeys, pcrc_32_tab, (int)(crcForCrypting >> 16) & 0xff, t);
buf[n++] = zencode(pkeys, pcrc_32_tab, (int)(crcForCrypting >> 24) & 0xff, t); buf[n++] = zencode(pkeys, pcrc_32_tab, (int)(crcForCrypting >> 24) & 0xff, t);
return n; return n;
} }
#endif #endif

354
contrib/minizip/ioapi.c
View File

@@ -1,177 +1,177 @@
/* ioapi.c -- IO base function header for compress/uncompress .zip /* ioapi.c -- IO base function header for compress/uncompress .zip
files using zlib + zip or unzip API files using zlib + zip or unzip API
Version 1.01e, February 12th, 2005 Version 1.01e, February 12th, 2005
Copyright (C) 1998-2005 Gilles Vollant Copyright (C) 1998-2005 Gilles Vollant
*/ */
#include <stdio.h> #include <stdio.h>
#include <stdlib.h> #include <stdlib.h>
#include <string.h> #include <string.h>
#include "zlib.h" #include "zlib.h"
#include "ioapi.h" #include "ioapi.h"
/* I've found an old Unix (a SunOS 4.1.3_U1) without all SEEK_* defined.... */ /* I've found an old Unix (a SunOS 4.1.3_U1) without all SEEK_* defined.... */
#ifndef SEEK_CUR #ifndef SEEK_CUR
#define SEEK_CUR 1 #define SEEK_CUR 1
#endif #endif
#ifndef SEEK_END #ifndef SEEK_END
#define SEEK_END 2 #define SEEK_END 2
#endif #endif
#ifndef SEEK_SET #ifndef SEEK_SET
#define SEEK_SET 0 #define SEEK_SET 0
#endif #endif
voidpf ZCALLBACK fopen_file_func OF(( voidpf ZCALLBACK fopen_file_func OF((
voidpf opaque, voidpf opaque,
const char* filename, const char* filename,
int mode)); int mode));
uLong ZCALLBACK fread_file_func OF(( uLong ZCALLBACK fread_file_func OF((
voidpf opaque, voidpf opaque,
voidpf stream, voidpf stream,
void* buf, void* buf,
uLong size)); uLong size));
uLong ZCALLBACK fwrite_file_func OF(( uLong ZCALLBACK fwrite_file_func OF((
voidpf opaque, voidpf opaque,
voidpf stream, voidpf stream,
const void* buf, const void* buf,
uLong size)); uLong size));
long ZCALLBACK ftell_file_func OF(( long ZCALLBACK ftell_file_func OF((
voidpf opaque, voidpf opaque,
voidpf stream)); voidpf stream));
long ZCALLBACK fseek_file_func OF(( long ZCALLBACK fseek_file_func OF((
voidpf opaque, voidpf opaque,
voidpf stream, voidpf stream,
uLong offset, uLong offset,
int origin)); int origin));
int ZCALLBACK fclose_file_func OF(( int ZCALLBACK fclose_file_func OF((
voidpf opaque, voidpf opaque,
voidpf stream)); voidpf stream));
int ZCALLBACK ferror_file_func OF(( int ZCALLBACK ferror_file_func OF((
voidpf opaque, voidpf opaque,
voidpf stream)); voidpf stream));
voidpf ZCALLBACK fopen_file_func (opaque, filename, mode) voidpf ZCALLBACK fopen_file_func (opaque, filename, mode)
voidpf opaque; voidpf opaque;
const char* filename; const char* filename;
int mode; int mode;
{ {
FILE* file = NULL; FILE* file = NULL;
const char* mode_fopen = NULL; const char* mode_fopen = NULL;
if ((mode & ZLIB_FILEFUNC_MODE_READWRITEFILTER)==ZLIB_FILEFUNC_MODE_READ) if ((mode & ZLIB_FILEFUNC_MODE_READWRITEFILTER)==ZLIB_FILEFUNC_MODE_READ)
mode_fopen = "rb"; mode_fopen = "rb";
else else
if (mode & ZLIB_FILEFUNC_MODE_EXISTING) if (mode & ZLIB_FILEFUNC_MODE_EXISTING)
mode_fopen = "r+b"; mode_fopen = "r+b";
else else
if (mode & ZLIB_FILEFUNC_MODE_CREATE) if (mode & ZLIB_FILEFUNC_MODE_CREATE)
mode_fopen = "wb"; mode_fopen = "wb";
if ((filename!=NULL) && (mode_fopen != NULL)) if ((filename!=NULL) && (mode_fopen != NULL))
file = fopen(filename, mode_fopen); file = fopen(filename, mode_fopen);
return file; return file;
} }
uLong ZCALLBACK fread_file_func (opaque, stream, buf, size) uLong ZCALLBACK fread_file_func (opaque, stream, buf, size)
voidpf opaque; voidpf opaque;
voidpf stream; voidpf stream;
void* buf; void* buf;
uLong size; uLong size;
{ {
uLong ret; uLong ret;
ret = (uLong)fread(buf, 1, (size_t)size, (FILE *)stream); ret = (uLong)fread(buf, 1, (size_t)size, (FILE *)stream);
return ret; return ret;
} }
uLong ZCALLBACK fwrite_file_func (opaque, stream, buf, size) uLong ZCALLBACK fwrite_file_func (opaque, stream, buf, size)
voidpf opaque; voidpf opaque;
voidpf stream; voidpf stream;
const void* buf; const void* buf;
uLong size; uLong size;
{ {
uLong ret; uLong ret;
ret = (uLong)fwrite(buf, 1, (size_t)size, (FILE *)stream); ret = (uLong)fwrite(buf, 1, (size_t)size, (FILE *)stream);
return ret; return ret;
} }
long ZCALLBACK ftell_file_func (opaque, stream) long ZCALLBACK ftell_file_func (opaque, stream)
voidpf opaque; voidpf opaque;
voidpf stream; voidpf stream;
{ {
long ret; long ret;
ret = ftell((FILE *)stream); ret = ftell((FILE *)stream);
return ret; return ret;
} }
long ZCALLBACK fseek_file_func (opaque, stream, offset, origin) long ZCALLBACK fseek_file_func (opaque, stream, offset, origin)
voidpf opaque; voidpf opaque;
voidpf stream; voidpf stream;
uLong offset; uLong offset;
int origin; int origin;
{ {
int fseek_origin=0; int fseek_origin=0;
long ret; long ret;
switch (origin) switch (origin)
{ {
case ZLIB_FILEFUNC_SEEK_CUR : case ZLIB_FILEFUNC_SEEK_CUR :
fseek_origin = SEEK_CUR; fseek_origin = SEEK_CUR;
break; break;
case ZLIB_FILEFUNC_SEEK_END : case ZLIB_FILEFUNC_SEEK_END :
fseek_origin = SEEK_END; fseek_origin = SEEK_END;
break; break;
case ZLIB_FILEFUNC_SEEK_SET : case ZLIB_FILEFUNC_SEEK_SET :
fseek_origin = SEEK_SET; fseek_origin = SEEK_SET;
break; break;
default: return -1; default: return -1;
} }
ret = 0; ret = 0;
fseek((FILE *)stream, offset, fseek_origin); fseek((FILE *)stream, offset, fseek_origin);
return ret; return ret;
} }
int ZCALLBACK fclose_file_func (opaque, stream) int ZCALLBACK fclose_file_func (opaque, stream)
voidpf opaque; voidpf opaque;
voidpf stream; voidpf stream;
{ {
int ret; int ret;
ret = fclose((FILE *)stream); ret = fclose((FILE *)stream);
return ret; return ret;
} }
int ZCALLBACK ferror_file_func (opaque, stream) int ZCALLBACK ferror_file_func (opaque, stream)
voidpf opaque; voidpf opaque;
voidpf stream; voidpf stream;
{ {
int ret; int ret;
ret = ferror((FILE *)stream); ret = ferror((FILE *)stream);
return ret; return ret;
} }
void fill_fopen_filefunc (pzlib_filefunc_def) void fill_fopen_filefunc (pzlib_filefunc_def)
zlib_filefunc_def* pzlib_filefunc_def; zlib_filefunc_def* pzlib_filefunc_def;
{ {
pzlib_filefunc_def->zopen_file = fopen_file_func; pzlib_filefunc_def->zopen_file = fopen_file_func;
pzlib_filefunc_def->zread_file = fread_file_func; pzlib_filefunc_def->zread_file = fread_file_func;
pzlib_filefunc_def->zwrite_file = fwrite_file_func; pzlib_filefunc_def->zwrite_file = fwrite_file_func;
pzlib_filefunc_def->ztell_file = ftell_file_func; pzlib_filefunc_def->ztell_file = ftell_file_func;
pzlib_filefunc_def->zseek_file = fseek_file_func; pzlib_filefunc_def->zseek_file = fseek_file_func;
pzlib_filefunc_def->zclose_file = fclose_file_func; pzlib_filefunc_def->zclose_file = fclose_file_func;
pzlib_filefunc_def->zerror_file = ferror_file_func; pzlib_filefunc_def->zerror_file = ferror_file_func;
pzlib_filefunc_def->opaque = NULL; pzlib_filefunc_def->opaque = NULL;
} }

150
contrib/minizip/ioapi.h
View File

@@ -1,75 +1,75 @@
/* ioapi.h -- IO base function header for compress/uncompress .zip /* ioapi.h -- IO base function header for compress/uncompress .zip
files using zlib + zip or unzip API files using zlib + zip or unzip API
Version 1.01e, February 12th, 2005 Version 1.01e, February 12th, 2005
Copyright (C) 1998-2005 Gilles Vollant Copyright (C) 1998-2005 Gilles Vollant
*/ */
#ifndef _ZLIBIOAPI_H #ifndef _ZLIBIOAPI_H
#define _ZLIBIOAPI_H #define _ZLIBIOAPI_H
#define ZLIB_FILEFUNC_SEEK_CUR (1) #define ZLIB_FILEFUNC_SEEK_CUR (1)
#define ZLIB_FILEFUNC_SEEK_END (2) #define ZLIB_FILEFUNC_SEEK_END (2)
#define ZLIB_FILEFUNC_SEEK_SET (0) #define ZLIB_FILEFUNC_SEEK_SET (0)
#define ZLIB_FILEFUNC_MODE_READ (1) #define ZLIB_FILEFUNC_MODE_READ (1)
#define ZLIB_FILEFUNC_MODE_WRITE (2) #define ZLIB_FILEFUNC_MODE_WRITE (2)
#define ZLIB_FILEFUNC_MODE_READWRITEFILTER (3) #define ZLIB_FILEFUNC_MODE_READWRITEFILTER (3)
#define ZLIB_FILEFUNC_MODE_EXISTING (4) #define ZLIB_FILEFUNC_MODE_EXISTING (4)
#define ZLIB_FILEFUNC_MODE_CREATE (8) #define ZLIB_FILEFUNC_MODE_CREATE (8)
#ifndef ZCALLBACK #ifndef ZCALLBACK
#if (defined(WIN32) || defined (WINDOWS) || defined (_WINDOWS)) && defined(CALLBACK) && defined (USEWINDOWS_CALLBACK) #if (defined(WIN32) || defined (WINDOWS) || defined (_WINDOWS)) && defined(CALLBACK) && defined (USEWINDOWS_CALLBACK)
#define ZCALLBACK CALLBACK #define ZCALLBACK CALLBACK
#else #else
#define ZCALLBACK #define ZCALLBACK
#endif #endif
#endif #endif
#ifdef __cplusplus #ifdef __cplusplus
extern "C" { extern "C" {
#endif #endif
typedef voidpf (ZCALLBACK *open_file_func) OF((voidpf opaque, const char* filename, int mode)); typedef voidpf (ZCALLBACK *open_file_func) OF((voidpf opaque, const char* filename, int mode));
typedef uLong (ZCALLBACK *read_file_func) OF((voidpf opaque, voidpf stream, void* buf, uLong size)); typedef uLong (ZCALLBACK *read_file_func) OF((voidpf opaque, voidpf stream, void* buf, uLong size));
typedef uLong (ZCALLBACK *write_file_func) OF((voidpf opaque, voidpf stream, const void* buf, uLong size)); typedef uLong (ZCALLBACK *write_file_func) OF((voidpf opaque, voidpf stream, const void* buf, uLong size));
typedef long (ZCALLBACK *tell_file_func) OF((voidpf opaque, voidpf stream)); typedef long (ZCALLBACK *tell_file_func) OF((voidpf opaque, voidpf stream));
typedef long (ZCALLBACK *seek_file_func) OF((voidpf opaque, voidpf stream, uLong offset, int origin)); typedef long (ZCALLBACK *seek_file_func) OF((voidpf opaque, voidpf stream, uLong offset, int origin));
typedef int (ZCALLBACK *close_file_func) OF((voidpf opaque, voidpf stream)); typedef int (ZCALLBACK *close_file_func) OF((voidpf opaque, voidpf stream));
typedef int (ZCALLBACK *testerror_file_func) OF((voidpf opaque, voidpf stream)); typedef int (ZCALLBACK *testerror_file_func) OF((voidpf opaque, voidpf stream));
typedef struct zlib_filefunc_def_s typedef struct zlib_filefunc_def_s
{ {
open_file_func zopen_file; open_file_func zopen_file;
read_file_func zread_file; read_file_func zread_file;
write_file_func zwrite_file; write_file_func zwrite_file;
tell_file_func ztell_file; tell_file_func ztell_file;
seek_file_func zseek_file; seek_file_func zseek_file;
close_file_func zclose_file; close_file_func zclose_file;
testerror_file_func zerror_file; testerror_file_func zerror_file;
voidpf opaque; voidpf opaque;
} zlib_filefunc_def; } zlib_filefunc_def;
void fill_fopen_filefunc OF((zlib_filefunc_def* pzlib_filefunc_def)); void fill_fopen_filefunc OF((zlib_filefunc_def* pzlib_filefunc_def));
#define ZREAD(filefunc,filestream,buf,size) ((*((filefunc).zread_file))((filefunc).opaque,filestream,buf,size)) #define ZREAD(filefunc,filestream,buf,size) ((*((filefunc).zread_file))((filefunc).opaque,filestream,buf,size))
#define ZWRITE(filefunc,filestream,buf,size) ((*((filefunc).zwrite_file))((filefunc).opaque,filestream,buf,size)) #define ZWRITE(filefunc,filestream,buf,size) ((*((filefunc).zwrite_file))((filefunc).opaque,filestream,buf,size))
#define ZTELL(filefunc,filestream) ((*((filefunc).ztell_file))((filefunc).opaque,filestream)) #define ZTELL(filefunc,filestream) ((*((filefunc).ztell_file))((filefunc).opaque,filestream))
#define ZSEEK(filefunc,filestream,pos,mode) ((*((filefunc).zseek_file))((filefunc).opaque,filestream,pos,mode)) #define ZSEEK(filefunc,filestream,pos,mode) ((*((filefunc).zseek_file))((filefunc).opaque,filestream,pos,mode))
#define ZCLOSE(filefunc,filestream) ((*((filefunc).zclose_file))((filefunc).opaque,filestream)) #define ZCLOSE(filefunc,filestream) ((*((filefunc).zclose_file))((filefunc).opaque,filestream))
#define ZERROR(filefunc,filestream) ((*((filefunc).zerror_file))((filefunc).opaque,filestream)) #define ZERROR(filefunc,filestream) ((*((filefunc).zerror_file))((filefunc).opaque,filestream))
#ifdef __cplusplus #ifdef __cplusplus
} }
#endif #endif
#endif #endif

540
contrib/minizip/iowin32.c
View File

@@ -1,270 +1,270 @@
/* iowin32.c -- IO base function header for compress/uncompress .zip /* iowin32.c -- IO base function header for compress/uncompress .zip
files using zlib + zip or unzip API files using zlib + zip or unzip API
This IO API version uses the Win32 API (for Microsoft Windows) This IO API version uses the Win32 API (for Microsoft Windows)
Version 1.01e, February 12th, 2005 Version 1.01e, February 12th, 2005
Copyright (C) 1998-2005 Gilles Vollant Copyright (C) 1998-2005 Gilles Vollant
*/ */
#include <stdlib.h> #include <stdlib.h>
#include "zlib.h" #include "zlib.h"
#include "ioapi.h" #include "ioapi.h"
#include "iowin32.h" #include "iowin32.h"
#ifndef INVALID_HANDLE_VALUE #ifndef INVALID_HANDLE_VALUE
#define INVALID_HANDLE_VALUE (0xFFFFFFFF) #define INVALID_HANDLE_VALUE (0xFFFFFFFF)
#endif #endif
#ifndef INVALID_SET_FILE_POINTER #ifndef INVALID_SET_FILE_POINTER
#define INVALID_SET_FILE_POINTER ((DWORD)-1) #define INVALID_SET_FILE_POINTER ((DWORD)-1)
#endif #endif
voidpf ZCALLBACK win32_open_file_func OF(( voidpf ZCALLBACK win32_open_file_func OF((
voidpf opaque, voidpf opaque,
const char* filename, const char* filename,
int mode)); int mode));
uLong ZCALLBACK win32_read_file_func OF(( uLong ZCALLBACK win32_read_file_func OF((
voidpf opaque, voidpf opaque,
voidpf stream, voidpf stream,
void* buf, void* buf,
uLong size)); uLong size));
uLong ZCALLBACK win32_write_file_func OF(( uLong ZCALLBACK win32_write_file_func OF((
voidpf opaque, voidpf opaque,
voidpf stream, voidpf stream,
const void* buf, const void* buf,
uLong size)); uLong size));
long ZCALLBACK win32_tell_file_func OF(( long ZCALLBACK win32_tell_file_func OF((
voidpf opaque, voidpf opaque,
voidpf stream)); voidpf stream));
long ZCALLBACK win32_seek_file_func OF(( long ZCALLBACK win32_seek_file_func OF((
voidpf opaque, voidpf opaque,
voidpf stream, voidpf stream,
uLong offset, uLong offset,
int origin)); int origin));
int ZCALLBACK win32_close_file_func OF(( int ZCALLBACK win32_close_file_func OF((
voidpf opaque, voidpf opaque,
voidpf stream)); voidpf stream));
int ZCALLBACK win32_error_file_func OF(( int ZCALLBACK win32_error_file_func OF((
voidpf opaque, voidpf opaque,
voidpf stream)); voidpf stream));
typedef struct typedef struct
{ {
HANDLE hf; HANDLE hf;
int error; int error;
} WIN32FILE_IOWIN; } WIN32FILE_IOWIN;
voidpf ZCALLBACK win32_open_file_func (opaque, filename, mode) voidpf ZCALLBACK win32_open_file_func (opaque, filename, mode)
voidpf opaque; voidpf opaque;
const char* filename; const char* filename;
int mode; int mode;
{ {
const char* mode_fopen = NULL; const char* mode_fopen = NULL;
DWORD dwDesiredAccess,dwCreationDisposition,dwShareMode,dwFlagsAndAttributes ; DWORD dwDesiredAccess,dwCreationDisposition,dwShareMode,dwFlagsAndAttributes ;
HANDLE hFile = 0; HANDLE hFile = 0;
voidpf ret=NULL; voidpf ret=NULL;
dwDesiredAccess = dwShareMode = dwFlagsAndAttributes = 0; dwDesiredAccess = dwShareMode = dwFlagsAndAttributes = 0;
if ((mode & ZLIB_FILEFUNC_MODE_READWRITEFILTER)==ZLIB_FILEFUNC_MODE_READ) if ((mode & ZLIB_FILEFUNC_MODE_READWRITEFILTER)==ZLIB_FILEFUNC_MODE_READ)
{ {
dwDesiredAccess = GENERIC_READ; dwDesiredAccess = GENERIC_READ;
dwCreationDisposition = OPEN_EXISTING; dwCreationDisposition = OPEN_EXISTING;
dwShareMode = FILE_SHARE_READ; dwShareMode = FILE_SHARE_READ;
} }
else else
if (mode & ZLIB_FILEFUNC_MODE_EXISTING) if (mode & ZLIB_FILEFUNC_MODE_EXISTING)
{ {
dwDesiredAccess = GENERIC_WRITE | GENERIC_READ; dwDesiredAccess = GENERIC_WRITE | GENERIC_READ;
dwCreationDisposition = OPEN_EXISTING; dwCreationDisposition = OPEN_EXISTING;
} }
else else
if (mode & ZLIB_FILEFUNC_MODE_CREATE) if (mode & ZLIB_FILEFUNC_MODE_CREATE)
{ {
dwDesiredAccess = GENERIC_WRITE | GENERIC_READ; dwDesiredAccess = GENERIC_WRITE | GENERIC_READ;
dwCreationDisposition = CREATE_ALWAYS; dwCreationDisposition = CREATE_ALWAYS;
} }
if ((filename!=NULL) && (dwDesiredAccess != 0)) if ((filename!=NULL) && (dwDesiredAccess != 0))
hFile = CreateFile((LPCTSTR)filename, dwDesiredAccess, dwShareMode, NULL, hFile = CreateFile((LPCTSTR)filename, dwDesiredAccess, dwShareMode, NULL,
dwCreationDisposition, dwFlagsAndAttributes, NULL); dwCreationDisposition, dwFlagsAndAttributes, NULL);
if (hFile == INVALID_HANDLE_VALUE) if (hFile == INVALID_HANDLE_VALUE)
hFile = NULL; hFile = NULL;
if (hFile != NULL) if (hFile != NULL)
{ {
WIN32FILE_IOWIN w32fiow; WIN32FILE_IOWIN w32fiow;
w32fiow.hf = hFile; w32fiow.hf = hFile;
w32fiow.error = 0; w32fiow.error = 0;
ret = malloc(sizeof(WIN32FILE_IOWIN)); ret = malloc(sizeof(WIN32FILE_IOWIN));
if (ret==NULL) if (ret==NULL)
CloseHandle(hFile); CloseHandle(hFile);
else *((WIN32FILE_IOWIN*)ret) = w32fiow; else *((WIN32FILE_IOWIN*)ret) = w32fiow;
} }
return ret; return ret;
} }
uLong ZCALLBACK win32_read_file_func (opaque, stream, buf, size) uLong ZCALLBACK win32_read_file_func (opaque, stream, buf, size)
voidpf opaque; voidpf opaque;
voidpf stream; voidpf stream;
void* buf; void* buf;
uLong size; uLong size;
{ {
uLong ret=0; uLong ret=0;
HANDLE hFile = NULL; HANDLE hFile = NULL;
if (stream!=NULL) if (stream!=NULL)
hFile = ((WIN32FILE_IOWIN*)stream) -> hf; hFile = ((WIN32FILE_IOWIN*)stream) -> hf;
if (hFile != NULL) if (hFile != NULL)
if (!ReadFile(hFile, buf, size, &ret, NULL)) if (!ReadFile(hFile, buf, size, &ret, NULL))
{ {
DWORD dwErr = GetLastError(); DWORD dwErr = GetLastError();
if (dwErr == ERROR_HANDLE_EOF) if (dwErr == ERROR_HANDLE_EOF)
dwErr = 0; dwErr = 0;
((WIN32FILE_IOWIN*)stream) -> error=(int)dwErr; ((WIN32FILE_IOWIN*)stream) -> error=(int)dwErr;
} }
return ret; return ret;
} }
uLong ZCALLBACK win32_write_file_func (opaque, stream, buf, size) uLong ZCALLBACK win32_write_file_func (opaque, stream, buf, size)
voidpf opaque; voidpf opaque;
voidpf stream; voidpf stream;
const void* buf; const void* buf;
uLong size; uLong size;
{ {
uLong ret=0; uLong ret=0;
HANDLE hFile = NULL; HANDLE hFile = NULL;
if (stream!=NULL) if (stream!=NULL)
hFile = ((WIN32FILE_IOWIN*)stream) -> hf; hFile = ((WIN32FILE_IOWIN*)stream) -> hf;
if (hFile !=NULL) if (hFile !=NULL)
if (!WriteFile(hFile, buf, size, &ret, NULL)) if (!WriteFile(hFile, buf, size, &ret, NULL))
{ {
DWORD dwErr = GetLastError(); DWORD dwErr = GetLastError();
if (dwErr == ERROR_HANDLE_EOF) if (dwErr == ERROR_HANDLE_EOF)
dwErr = 0; dwErr = 0;
((WIN32FILE_IOWIN*)stream) -> error=(int)dwErr; ((WIN32FILE_IOWIN*)stream) -> error=(int)dwErr;
} }
return ret; return ret;
} }
long ZCALLBACK win32_tell_file_func (opaque, stream) long ZCALLBACK win32_tell_file_func (opaque, stream)
voidpf opaque; voidpf opaque;
voidpf stream; voidpf stream;
{ {
long ret=-1; long ret=-1;
HANDLE hFile = NULL; HANDLE hFile = NULL;
if (stream!=NULL) if (stream!=NULL)
hFile = ((WIN32FILE_IOWIN*)stream) -> hf; hFile = ((WIN32FILE_IOWIN*)stream) -> hf;
if (hFile != NULL) if (hFile != NULL)
{ {
DWORD dwSet = SetFilePointer(hFile, 0, NULL, FILE_CURRENT); DWORD dwSet = SetFilePointer(hFile, 0, NULL, FILE_CURRENT);
if (dwSet == INVALID_SET_FILE_POINTER) if (dwSet == INVALID_SET_FILE_POINTER)
{ {
DWORD dwErr = GetLastError(); DWORD dwErr = GetLastError();
((WIN32FILE_IOWIN*)stream) -> error=(int)dwErr; ((WIN32FILE_IOWIN*)stream) -> error=(int)dwErr;
ret = -1; ret = -1;
} }
else else
ret=(long)dwSet; ret=(long)dwSet;
} }
return ret; return ret;
} }
long ZCALLBACK win32_seek_file_func (opaque, stream, offset, origin) long ZCALLBACK win32_seek_file_func (opaque, stream, offset, origin)
voidpf opaque; voidpf opaque;
voidpf stream; voidpf stream;
uLong offset; uLong offset;
int origin; int origin;
{ {
DWORD dwMoveMethod=0xFFFFFFFF; DWORD dwMoveMethod=0xFFFFFFFF;
HANDLE hFile = NULL; HANDLE hFile = NULL;
long ret=-1; long ret=-1;
if (stream!=NULL) if (stream!=NULL)
hFile = ((WIN32FILE_IOWIN*)stream) -> hf; hFile = ((WIN32FILE_IOWIN*)stream) -> hf;
switch (origin) switch (origin)
{ {
case ZLIB_FILEFUNC_SEEK_CUR : case ZLIB_FILEFUNC_SEEK_CUR :
dwMoveMethod = FILE_CURRENT; dwMoveMethod = FILE_CURRENT;
break; break;
case ZLIB_FILEFUNC_SEEK_END : case ZLIB_FILEFUNC_SEEK_END :
dwMoveMethod = FILE_END; dwMoveMethod = FILE_END;
break; break;
case ZLIB_FILEFUNC_SEEK_SET : case ZLIB_FILEFUNC_SEEK_SET :
dwMoveMethod = FILE_BEGIN; dwMoveMethod = FILE_BEGIN;
break; break;
default: return -1; default: return -1;
} }
if (hFile != NULL) if (hFile != NULL)
{ {
DWORD dwSet = SetFilePointer(hFile, offset, NULL, dwMoveMethod); DWORD dwSet = SetFilePointer(hFile, offset, NULL, dwMoveMethod);
if (dwSet == INVALID_SET_FILE_POINTER) if (dwSet == INVALID_SET_FILE_POINTER)
{ {
DWORD dwErr = GetLastError(); DWORD dwErr = GetLastError();
((WIN32FILE_IOWIN*)stream) -> error=(int)dwErr; ((WIN32FILE_IOWIN*)stream) -> error=(int)dwErr;
ret = -1; ret = -1;
} }
else else
ret=0; ret=0;
} }
return ret; return ret;
} }
int ZCALLBACK win32_close_file_func (opaque, stream) int ZCALLBACK win32_close_file_func (opaque, stream)
voidpf opaque; voidpf opaque;
voidpf stream; voidpf stream;
{ {
int ret=-1; int ret=-1;
if (stream!=NULL) if (stream!=NULL)
{ {
HANDLE hFile; HANDLE hFile;
hFile = ((WIN32FILE_IOWIN*)stream) -> hf; hFile = ((WIN32FILE_IOWIN*)stream) -> hf;
if (hFile != NULL) if (hFile != NULL)
{ {
CloseHandle(hFile); CloseHandle(hFile);
ret=0; ret=0;
} }
free(stream); free(stream);
} }
return ret; return ret;
} }
int ZCALLBACK win32_error_file_func (opaque, stream) int ZCALLBACK win32_error_file_func (opaque, stream)
voidpf opaque; voidpf opaque;
voidpf stream; voidpf stream;
{ {
int ret=-1; int ret=-1;
if (stream!=NULL) if (stream!=NULL)
{ {
ret = ((WIN32FILE_IOWIN*)stream) -> error; ret = ((WIN32FILE_IOWIN*)stream) -> error;
} }
return ret; return ret;
} }
void fill_win32_filefunc (pzlib_filefunc_def) void fill_win32_filefunc (pzlib_filefunc_def)
zlib_filefunc_def* pzlib_filefunc_def; zlib_filefunc_def* pzlib_filefunc_def;
{ {
pzlib_filefunc_def->zopen_file = win32_open_file_func; pzlib_filefunc_def->zopen_file = win32_open_file_func;
pzlib_filefunc_def->zread_file = win32_read_file_func; pzlib_filefunc_def->zread_file = win32_read_file_func;
pzlib_filefunc_def->zwrite_file = win32_write_file_func; pzlib_filefunc_def->zwrite_file = win32_write_file_func;
pzlib_filefunc_def->ztell_file = win32_tell_file_func; pzlib_filefunc_def->ztell_file = win32_tell_file_func;
pzlib_filefunc_def->zseek_file = win32_seek_file_func; pzlib_filefunc_def->zseek_file = win32_seek_file_func;
pzlib_filefunc_def->zclose_file = win32_close_file_func; pzlib_filefunc_def->zclose_file = win32_close_file_func;
pzlib_filefunc_def->zerror_file = win32_error_file_func; pzlib_filefunc_def->zerror_file = win32_error_file_func;
pzlib_filefunc_def->opaque=NULL; pzlib_filefunc_def->opaque=NULL;
} }

42
contrib/minizip/iowin32.h
View File

@@ -1,21 +1,21 @@
/* iowin32.h -- IO base function header for compress/uncompress .zip /* iowin32.h -- IO base function header for compress/uncompress .zip
files using zlib + zip or unzip API files using zlib + zip or unzip API
This IO API version uses the Win32 API (for Microsoft Windows) This IO API version uses the Win32 API (for Microsoft Windows)
Version 1.01e, February 12th, 2005 Version 1.01e, February 12th, 2005
Copyright (C) 1998-2005 Gilles Vollant Copyright (C) 1998-2005 Gilles Vollant
*/ */
#include <windows.h> #include <windows.h>
#ifdef __cplusplus #ifdef __cplusplus
extern "C" { extern "C" {
#endif #endif
void fill_win32_filefunc OF((zlib_filefunc_def* pzlib_filefunc_def)); void fill_win32_filefunc OF((zlib_filefunc_def* pzlib_filefunc_def));
#ifdef __cplusplus #ifdef __cplusplus
} }
#endif #endif

1170
contrib/minizip/miniunz.c
View File

File diff suppressed because it is too large Load Diff

840
contrib/minizip/minizip.c
View File

@@ -1,420 +1,420 @@
/* /*
minizip.c minizip.c
Version 1.01e, February 12th, 2005 Version 1.01e, February 12th, 2005
Copyright (C) 1998-2005 Gilles Vollant Copyright (C) 1998-2005 Gilles Vollant
*/ */
#include <stdio.h> #include <stdio.h>
#include <stdlib.h> #include <stdlib.h>
#include <string.h> #include <string.h>
#include <time.h> #include <time.h>
#include <errno.h> #include <errno.h>
#include <fcntl.h> #include <fcntl.h>
#ifdef unix #ifdef unix
# include <unistd.h> # include <unistd.h>
# include <utime.h> # include <utime.h>
# include <sys/types.h> # include <sys/types.h>
# include <sys/stat.h> # include <sys/stat.h>
#else #else
# include <direct.h> # include <direct.h>
# include <io.h> # include <io.h>
#endif #endif
#include "zip.h" #include "zip.h"
#ifdef WIN32 #ifdef WIN32
#define USEWIN32IOAPI #define USEWIN32IOAPI
#include "iowin32.h" #include "iowin32.h"
#endif #endif
#define WRITEBUFFERSIZE (16384) #define WRITEBUFFERSIZE (16384)
#define MAXFILENAME (256) #define MAXFILENAME (256)
#ifdef WIN32 #ifdef WIN32
uLong filetime(f, tmzip, dt) uLong filetime(f, tmzip, dt)
char *f; /* name of file to get info on */ char *f; /* name of file to get info on */
tm_zip *tmzip; /* return value: access, modific. and creation times */ tm_zip *tmzip; /* return value: access, modific. and creation times */
uLong *dt; /* dostime */ uLong *dt; /* dostime */
{ {
int ret = 0; int ret = 0;
{ {
FILETIME ftLocal; FILETIME ftLocal;
HANDLE hFind; HANDLE hFind;
WIN32_FIND_DATA ff32; WIN32_FIND_DATA ff32;
hFind = FindFirstFile(f,&ff32); hFind = FindFirstFile(f,&ff32);
if (hFind != INVALID_HANDLE_VALUE) if (hFind != INVALID_HANDLE_VALUE)
{ {
FileTimeToLocalFileTime(&(ff32.ftLastWriteTime),&ftLocal); FileTimeToLocalFileTime(&(ff32.ftLastWriteTime),&ftLocal);
FileTimeToDosDateTime(&ftLocal,((LPWORD)dt)+1,((LPWORD)dt)+0); FileTimeToDosDateTime(&ftLocal,((LPWORD)dt)+1,((LPWORD)dt)+0);
FindClose(hFind); FindClose(hFind);
ret = 1; ret = 1;
} }
} }
return ret; return ret;
} }
#else #else
#ifdef unix #ifdef unix
uLong filetime(f, tmzip, dt) uLong filetime(f, tmzip, dt)
char *f; /* name of file to get info on */ char *f; /* name of file to get info on */
tm_zip *tmzip; /* return value: access, modific. and creation times */ tm_zip *tmzip; /* return value: access, modific. and creation times */
uLong *dt; /* dostime */ uLong *dt; /* dostime */
{ {
int ret=0; int ret=0;
struct stat s; /* results of stat() */ struct stat s; /* results of stat() */
struct tm* filedate; struct tm* filedate;
time_t tm_t=0; time_t tm_t=0;
if (strcmp(f,"-")!=0) if (strcmp(f,"-")!=0)
{ {
char name[MAXFILENAME+1]; char name[MAXFILENAME+1];
int len = strlen(f); int len = strlen(f);
if (len > MAXFILENAME) if (len > MAXFILENAME)
len = MAXFILENAME; len = MAXFILENAME;
strncpy(name, f,MAXFILENAME-1); strncpy(name, f,MAXFILENAME-1);
/* strncpy doesnt append the trailing NULL, of the string is too long. */ /* strncpy doesnt append the trailing NULL, of the string is too long. */
name[ MAXFILENAME ] = '\0'; name[ MAXFILENAME ] = '\0';
if (name[len - 1] == '/') if (name[len - 1] == '/')
name[len - 1] = '\0'; name[len - 1] = '\0';
/* not all systems allow stat'ing a file with / appended */ /* not all systems allow stat'ing a file with / appended */
if (stat(name,&s)==0) if (stat(name,&s)==0)
{ {
tm_t = s.st_mtime; tm_t = s.st_mtime;
ret = 1; ret = 1;
} }
} }
filedate = localtime(&tm_t); filedate = localtime(&tm_t);
tmzip->tm_sec = filedate->tm_sec; tmzip->tm_sec = filedate->tm_sec;
tmzip->tm_min = filedate->tm_min; tmzip->tm_min = filedate->tm_min;
tmzip->tm_hour = filedate->tm_hour; tmzip->tm_hour = filedate->tm_hour;
tmzip->tm_mday = filedate->tm_mday; tmzip->tm_mday = filedate->tm_mday;
tmzip->tm_mon = filedate->tm_mon ; tmzip->tm_mon = filedate->tm_mon ;
tmzip->tm_year = filedate->tm_year; tmzip->tm_year = filedate->tm_year;
return ret; return ret;
} }
#else #else
uLong filetime(f, tmzip, dt) uLong filetime(f, tmzip, dt)
char *f; /* name of file to get info on */ char *f; /* name of file to get info on */
tm_zip *tmzip; /* return value: access, modific. and creation times */ tm_zip *tmzip; /* return value: access, modific. and creation times */
uLong *dt; /* dostime */ uLong *dt; /* dostime */
{ {
return 0; return 0;
} }
#endif #endif
#endif #endif
int check_exist_file(filename) int check_exist_file(filename)
const char* filename; const char* filename;
{ {
FILE* ftestexist; FILE* ftestexist;
int ret = 1; int ret = 1;
ftestexist = fopen(filename,"rb"); ftestexist = fopen(filename,"rb");
if (ftestexist==NULL) if (ftestexist==NULL)
ret = 0; ret = 0;
else else
fclose(ftestexist); fclose(ftestexist);
return ret; return ret;
} }
void do_banner() void do_banner()
{ {
printf("MiniZip 1.01b, demo of zLib + Zip package written by Gilles Vollant\n"); printf("MiniZip 1.01b, demo of zLib + Zip package written by Gilles Vollant\n");
printf("more info at http://www.winimage.com/zLibDll/unzip.html\n\n"); printf("more info at http://www.winimage.com/zLibDll/unzip.html\n\n");
} }
void do_help() void do_help()
{ {
printf("Usage : minizip [-o] [-a] [-0 to -9] [-p password] file.zip [files_to_add]\n\n" \ printf("Usage : minizip [-o] [-a] [-0 to -9] [-p password] file.zip [files_to_add]\n\n" \
" -o Overwrite existing file.zip\n" \ " -o Overwrite existing file.zip\n" \
" -a Append to existing file.zip\n" \ " -a Append to existing file.zip\n" \
" -0 Store only\n" \ " -0 Store only\n" \
" -1 Compress faster\n" \ " -1 Compress faster\n" \
" -9 Compress better\n\n"); " -9 Compress better\n\n");
} }
/* calculate the CRC32 of a file, /* calculate the CRC32 of a file,
because to encrypt a file, we need known the CRC32 of the file before */ because to encrypt a file, we need known the CRC32 of the file before */
int getFileCrc(const char* filenameinzip,void*buf,unsigned long size_buf,unsigned long* result_crc) int getFileCrc(const char* filenameinzip,void*buf,unsigned long size_buf,unsigned long* result_crc)
{ {
unsigned long calculate_crc=0; unsigned long calculate_crc=0;
int err=ZIP_OK; int err=ZIP_OK;
FILE * fin = fopen(filenameinzip,"rb"); FILE * fin = fopen(filenameinzip,"rb");
unsigned long size_read = 0; unsigned long size_read = 0;
unsigned long total_read = 0; unsigned long total_read = 0;
if (fin==NULL) if (fin==NULL)
{ {
err = ZIP_ERRNO; err = ZIP_ERRNO;
} }
if (err == ZIP_OK) if (err == ZIP_OK)
do do
{ {
err = ZIP_OK; err = ZIP_OK;
size_read = (int)fread(buf,1,size_buf,fin); size_read = (int)fread(buf,1,size_buf,fin);
if (size_read < size_buf) if (size_read < size_buf)
if (feof(fin)==0) if (feof(fin)==0)
{ {
printf("error in reading %s\n",filenameinzip); printf("error in reading %s\n",filenameinzip);
err = ZIP_ERRNO; err = ZIP_ERRNO;
} }
if (size_read>0) if (size_read>0)
calculate_crc = crc32(calculate_crc,buf,size_read); calculate_crc = crc32(calculate_crc,buf,size_read);
total_read += size_read; total_read += size_read;
} while ((err == ZIP_OK) && (size_read>0)); } while ((err == ZIP_OK) && (size_read>0));
if (fin) if (fin)
fclose(fin); fclose(fin);
*result_crc=calculate_crc; *result_crc=calculate_crc;
printf("file %s crc %x\n",filenameinzip,calculate_crc); printf("file %s crc %x\n",filenameinzip,calculate_crc);
return err; return err;
} }
int main(argc,argv) int main(argc,argv)
int argc; int argc;
char *argv[]; char *argv[];
{ {
int i; int i;
int opt_overwrite=0; int opt_overwrite=0;
int opt_compress_level=Z_DEFAULT_COMPRESSION; int opt_compress_level=Z_DEFAULT_COMPRESSION;
int zipfilenamearg = 0; int zipfilenamearg = 0;
char filename_try[MAXFILENAME+16]; char filename_try[MAXFILENAME+16];
int zipok; int zipok;
int err=0; int err=0;
int size_buf=0; int size_buf=0;
void* buf=NULL; void* buf=NULL;
const char* password=NULL; const char* password=NULL;
do_banner(); do_banner();
if (argc==1) if (argc==1)
{ {
do_help(); do_help();
return 0; return 0;
} }
else else
{ {
for (i=1;i<argc;i++) for (i=1;i<argc;i++)
{ {
if ((*argv[i])=='-') if ((*argv[i])=='-')
{ {
const char *p=argv[i]+1; const char *p=argv[i]+1;
while ((*p)!='\0') while ((*p)!='\0')
{ {
char c=*(p++);; char c=*(p++);;
if ((c=='o') || (c=='O')) if ((c=='o') || (c=='O'))
opt_overwrite = 1; opt_overwrite = 1;
if ((c=='a') || (c=='A')) if ((c=='a') || (c=='A'))
opt_overwrite = 2; opt_overwrite = 2;
if ((c>='0') && (c<='9')) if ((c>='0') && (c<='9'))
opt_compress_level = c-'0'; opt_compress_level = c-'0';
if (((c=='p') || (c=='P')) && (i+1<argc)) if (((c=='p') || (c=='P')) && (i+1<argc))
{ {
password=argv[i+1]; password=argv[i+1];
i++; i++;
} }
} }
} }
else else
if (zipfilenamearg == 0) if (zipfilenamearg == 0)
zipfilenamearg = i ; zipfilenamearg = i ;
} }
} }
size_buf = WRITEBUFFERSIZE; size_buf = WRITEBUFFERSIZE;
buf = (void*)malloc(size_buf); buf = (void*)malloc(size_buf);
if (buf==NULL) if (buf==NULL)
{ {
printf("Error allocating memory\n"); printf("Error allocating memory\n");
return ZIP_INTERNALERROR; return ZIP_INTERNALERROR;
} }
if (zipfilenamearg==0) if (zipfilenamearg==0)
zipok=0; zipok=0;
else else
{ {
int i,len; int i,len;
int dot_found=0; int dot_found=0;
zipok = 1 ; zipok = 1 ;
strncpy(filename_try, argv[zipfilenamearg],MAXFILENAME-1); strncpy(filename_try, argv[zipfilenamearg],MAXFILENAME-1);
/* strncpy doesnt append the trailing NULL, of the string is too long. */ /* strncpy doesnt append the trailing NULL, of the string is too long. */
filename_try[ MAXFILENAME ] = '\0'; filename_try[ MAXFILENAME ] = '\0';
len=(int)strlen(filename_try); len=(int)strlen(filename_try);
for (i=0;i<len;i++) for (i=0;i<len;i++)
if (filename_try[i]=='.') if (filename_try[i]=='.')
dot_found=1; dot_found=1;
if (dot_found==0) if (dot_found==0)
strcat(filename_try,".zip"); strcat(filename_try,".zip");
if (opt_overwrite==2) if (opt_overwrite==2)
{ {
/* if the file don't exist, we not append file */ /* if the file don't exist, we not append file */
if (check_exist_file(filename_try)==0) if (check_exist_file(filename_try)==0)
opt_overwrite=1; opt_overwrite=1;
} }
else else
if (opt_overwrite==0) if (opt_overwrite==0)
if (check_exist_file(filename_try)!=0) if (check_exist_file(filename_try)!=0)
{ {
char rep=0; char rep=0;
do do
{ {
char answer[128]; char answer[128];
int ret; int ret;
printf("The file %s exists. Overwrite ? [y]es, [n]o, [a]ppend : ",filename_try); printf("The file %s exists. Overwrite ? [y]es, [n]o, [a]ppend : ",filename_try);
ret = scanf("%1s",answer); ret = scanf("%1s",answer);
if (ret != 1) if (ret != 1)
{ {
exit(EXIT_FAILURE); exit(EXIT_FAILURE);
} }
rep = answer[0] ; rep = answer[0] ;
if ((rep>='a') && (rep<='z')) if ((rep>='a') && (rep<='z'))
rep -= 0x20; rep -= 0x20;
} }
while ((rep!='Y') && (rep!='N') && (rep!='A')); while ((rep!='Y') && (rep!='N') && (rep!='A'));
if (rep=='N') if (rep=='N')
zipok = 0; zipok = 0;
if (rep=='A') if (rep=='A')
opt_overwrite = 2; opt_overwrite = 2;
} }
} }
if (zipok==1) if (zipok==1)
{ {
zipFile zf; zipFile zf;
int errclose; int errclose;
# ifdef USEWIN32IOAPI # ifdef USEWIN32IOAPI
zlib_filefunc_def ffunc; zlib_filefunc_def ffunc;
fill_win32_filefunc(&ffunc); fill_win32_filefunc(&ffunc);
zf = zipOpen2(filename_try,(opt_overwrite==2) ? 2 : 0,NULL,&ffunc); zf = zipOpen2(filename_try,(opt_overwrite==2) ? 2 : 0,NULL,&ffunc);
# else # else
zf = zipOpen(filename_try,(opt_overwrite==2) ? 2 : 0); zf = zipOpen(filename_try,(opt_overwrite==2) ? 2 : 0);
# endif # endif
if (zf == NULL) if (zf == NULL)
{ {
printf("error opening %s\n",filename_try); printf("error opening %s\n",filename_try);
err= ZIP_ERRNO; err= ZIP_ERRNO;
} }
else else
printf("creating %s\n",filename_try); printf("creating %s\n",filename_try);
for (i=zipfilenamearg+1;(i<argc) && (err==ZIP_OK);i++) for (i=zipfilenamearg+1;(i<argc) && (err==ZIP_OK);i++)
{ {
if (!((((*(argv[i]))=='-') || ((*(argv[i]))=='/')) && if (!((((*(argv[i]))=='-') || ((*(argv[i]))=='/')) &&
((argv[i][1]=='o') || (argv[i][1]=='O') || ((argv[i][1]=='o') || (argv[i][1]=='O') ||
(argv[i][1]=='a') || (argv[i][1]=='A') || (argv[i][1]=='a') || (argv[i][1]=='A') ||
(argv[i][1]=='p') || (argv[i][1]=='P') || (argv[i][1]=='p') || (argv[i][1]=='P') ||
((argv[i][1]>='0') || (argv[i][1]<='9'))) && ((argv[i][1]>='0') || (argv[i][1]<='9'))) &&
(strlen(argv[i]) == 2))) (strlen(argv[i]) == 2)))
{ {
FILE * fin; FILE * fin;
int size_read; int size_read;
const char* filenameinzip = argv[i]; const char* filenameinzip = argv[i];
zip_fileinfo zi; zip_fileinfo zi;
unsigned long crcFile=0; unsigned long crcFile=0;
zi.tmz_date.tm_sec = zi.tmz_date.tm_min = zi.tmz_date.tm_hour = zi.tmz_date.tm_sec = zi.tmz_date.tm_min = zi.tmz_date.tm_hour =
zi.tmz_date.tm_mday = zi.tmz_date.tm_mon = zi.tmz_date.tm_year = 0; zi.tmz_date.tm_mday = zi.tmz_date.tm_mon = zi.tmz_date.tm_year = 0;
zi.dosDate = 0; zi.dosDate = 0;
zi.internal_fa = 0; zi.internal_fa = 0;
zi.external_fa = 0; zi.external_fa = 0;
filetime(filenameinzip,&zi.tmz_date,&zi.dosDate); filetime(filenameinzip,&zi.tmz_date,&zi.dosDate);
/* /*
err = zipOpenNewFileInZip(zf,filenameinzip,&zi, err = zipOpenNewFileInZip(zf,filenameinzip,&zi,
NULL,0,NULL,0,NULL / * comment * /, NULL,0,NULL,0,NULL / * comment * /,
(opt_compress_level != 0) ? Z_DEFLATED : 0, (opt_compress_level != 0) ? Z_DEFLATED : 0,
opt_compress_level); opt_compress_level);
*/ */
if ((password != NULL) && (err==ZIP_OK)) if ((password != NULL) && (err==ZIP_OK))
err = getFileCrc(filenameinzip,buf,size_buf,&crcFile); err = getFileCrc(filenameinzip,buf,size_buf,&crcFile);
err = zipOpenNewFileInZip3(zf,filenameinzip,&zi, err = zipOpenNewFileInZip3(zf,filenameinzip,&zi,
NULL,0,NULL,0,NULL /* comment*/, NULL,0,NULL,0,NULL /* comment*/,
(opt_compress_level != 0) ? Z_DEFLATED : 0, (opt_compress_level != 0) ? Z_DEFLATED : 0,
opt_compress_level,0, opt_compress_level,0,
/* -MAX_WBITS, DEF_MEM_LEVEL, Z_DEFAULT_STRATEGY, */ /* -MAX_WBITS, DEF_MEM_LEVEL, Z_DEFAULT_STRATEGY, */
-MAX_WBITS, DEF_MEM_LEVEL, Z_DEFAULT_STRATEGY, -MAX_WBITS, DEF_MEM_LEVEL, Z_DEFAULT_STRATEGY,
password,crcFile); password,crcFile);
if (err != ZIP_OK) if (err != ZIP_OK)
printf("error in opening %s in zipfile\n",filenameinzip); printf("error in opening %s in zipfile\n",filenameinzip);
else else
{ {
fin = fopen(filenameinzip,"rb"); fin = fopen(filenameinzip,"rb");
if (fin==NULL) if (fin==NULL)
{ {
err=ZIP_ERRNO; err=ZIP_ERRNO;
printf("error in opening %s for reading\n",filenameinzip); printf("error in opening %s for reading\n",filenameinzip);
} }
} }
if (err == ZIP_OK) if (err == ZIP_OK)
do do
{ {
err = ZIP_OK; err = ZIP_OK;
size_read = (int)fread(buf,1,size_buf,fin); size_read = (int)fread(buf,1,size_buf,fin);
if (size_read < size_buf) if (size_read < size_buf)
if (feof(fin)==0) if (feof(fin)==0)
{ {
printf("error in reading %s\n",filenameinzip); printf("error in reading %s\n",filenameinzip);
err = ZIP_ERRNO; err = ZIP_ERRNO;
} }
if (size_read>0) if (size_read>0)
{ {
err = zipWriteInFileInZip (zf,buf,size_read); err = zipWriteInFileInZip (zf,buf,size_read);
if (err<0) if (err<0)
{ {
printf("error in writing %s in the zipfile\n", printf("error in writing %s in the zipfile\n",
filenameinzip); filenameinzip);
} }
} }
} while ((err == ZIP_OK) && (size_read>0)); } while ((err == ZIP_OK) && (size_read>0));
if (fin) if (fin)
fclose(fin); fclose(fin);
if (err<0) if (err<0)
err=ZIP_ERRNO; err=ZIP_ERRNO;
else else
{ {
err = zipCloseFileInZip(zf); err = zipCloseFileInZip(zf);
if (err!=ZIP_OK) if (err!=ZIP_OK)
printf("error in closing %s in the zipfile\n", printf("error in closing %s in the zipfile\n",
filenameinzip); filenameinzip);
} }
} }
} }
errclose = zipClose(zf,NULL); errclose = zipClose(zf,NULL);
if (errclose != ZIP_OK) if (errclose != ZIP_OK)
printf("error in closing %s\n",filename_try); printf("error in closing %s\n",filename_try);
} }
else else
{ {
do_help(); do_help();
} }
free(buf); free(buf);
return 0; return 0;
} }

562
contrib/minizip/mztools.c
View File

@@ -1,281 +1,281 @@
/* /*
Additional tools for Minizip Additional tools for Minizip
Code: Xavier Roche '2004 Code: Xavier Roche '2004
License: Same as ZLIB (www.gzip.org) License: Same as ZLIB (www.gzip.org)
*/ */
/* Code */ /* Code */
#include <stdio.h> #include <stdio.h>
#include <stdlib.h> #include <stdlib.h>
#include <string.h> #include <string.h>
#include "zlib.h" #include "zlib.h"
#include "unzip.h" #include "unzip.h"
#define READ_8(adr) ((unsigned char)*(adr)) #define READ_8(adr) ((unsigned char)*(adr))
#define READ_16(adr) ( READ_8(adr) | (READ_8(adr+1) << 8) ) #define READ_16(adr) ( READ_8(adr) | (READ_8(adr+1) << 8) )
#define READ_32(adr) ( READ_16(adr) | (READ_16((adr)+2) << 16) ) #define READ_32(adr) ( READ_16(adr) | (READ_16((adr)+2) << 16) )
#define WRITE_8(buff, n) do { \ #define WRITE_8(buff, n) do { \
*((unsigned char*)(buff)) = (unsigned char) ((n) & 0xff); \ *((unsigned char*)(buff)) = (unsigned char) ((n) & 0xff); \
} while(0) } while(0)
#define WRITE_16(buff, n) do { \ #define WRITE_16(buff, n) do { \
WRITE_8((unsigned char*)(buff), n); \ WRITE_8((unsigned char*)(buff), n); \
WRITE_8(((unsigned char*)(buff)) + 1, (n) >> 8); \ WRITE_8(((unsigned char*)(buff)) + 1, (n) >> 8); \
} while(0) } while(0)
#define WRITE_32(buff, n) do { \ #define WRITE_32(buff, n) do { \
WRITE_16((unsigned char*)(buff), (n) & 0xffff); \ WRITE_16((unsigned char*)(buff), (n) & 0xffff); \
WRITE_16((unsigned char*)(buff) + 2, (n) >> 16); \ WRITE_16((unsigned char*)(buff) + 2, (n) >> 16); \
} while(0) } while(0)
extern int ZEXPORT unzRepair(file, fileOut, fileOutTmp, nRecovered, bytesRecovered) extern int ZEXPORT unzRepair(file, fileOut, fileOutTmp, nRecovered, bytesRecovered)
const char* file; const char* file;
const char* fileOut; const char* fileOut;
const char* fileOutTmp; const char* fileOutTmp;
uLong* nRecovered; uLong* nRecovered;
uLong* bytesRecovered; uLong* bytesRecovered;
{ {
int err = Z_OK; int err = Z_OK;
FILE* fpZip = fopen(file, "rb"); FILE* fpZip = fopen(file, "rb");
FILE* fpOut = fopen(fileOut, "wb"); FILE* fpOut = fopen(fileOut, "wb");
FILE* fpOutCD = fopen(fileOutTmp, "wb"); FILE* fpOutCD = fopen(fileOutTmp, "wb");
if (fpZip != NULL && fpOut != NULL) { if (fpZip != NULL && fpOut != NULL) {
int entries = 0; int entries = 0;
uLong totalBytes = 0; uLong totalBytes = 0;
char header[30]; char header[30];
char filename[256]; char filename[256];
char extra[1024]; char extra[1024];
int offset = 0; int offset = 0;
int offsetCD = 0; int offsetCD = 0;
while ( fread(header, 1, 30, fpZip) == 30 ) { while ( fread(header, 1, 30, fpZip) == 30 ) {
int currentOffset = offset; int currentOffset = offset;
/* File entry */ /* File entry */
if (READ_32(header) == 0x04034b50) { if (READ_32(header) == 0x04034b50) {
unsigned int version = READ_16(header + 4); unsigned int version = READ_16(header + 4);
unsigned int gpflag = READ_16(header + 6); unsigned int gpflag = READ_16(header + 6);
unsigned int method = READ_16(header + 8); unsigned int method = READ_16(header + 8);
unsigned int filetime = READ_16(header + 10); unsigned int filetime = READ_16(header + 10);
unsigned int filedate = READ_16(header + 12); unsigned int filedate = READ_16(header + 12);
unsigned int crc = READ_32(header + 14); /* crc */ unsigned int crc = READ_32(header + 14); /* crc */
unsigned int cpsize = READ_32(header + 18); /* compressed size */ unsigned int cpsize = READ_32(header + 18); /* compressed size */
unsigned int uncpsize = READ_32(header + 22); /* uncompressed sz */ unsigned int uncpsize = READ_32(header + 22); /* uncompressed sz */
unsigned int fnsize = READ_16(header + 26); /* file name length */ unsigned int fnsize = READ_16(header + 26); /* file name length */
unsigned int extsize = READ_16(header + 28); /* extra field length */ unsigned int extsize = READ_16(header + 28); /* extra field length */
filename[0] = extra[0] = '\0'; filename[0] = extra[0] = '\0';
/* Header */ /* Header */
if (fwrite(header, 1, 30, fpOut) == 30) { if (fwrite(header, 1, 30, fpOut) == 30) {
offset += 30; offset += 30;
} else { } else {
err = Z_ERRNO; err = Z_ERRNO;
break; break;
} }
/* Filename */ /* Filename */
if (fnsize > 0) { if (fnsize > 0) {
if (fread(filename, 1, fnsize, fpZip) == fnsize) { if (fread(filename, 1, fnsize, fpZip) == fnsize) {
if (fwrite(filename, 1, fnsize, fpOut) == fnsize) { if (fwrite(filename, 1, fnsize, fpOut) == fnsize) {
offset += fnsize; offset += fnsize;
} else { } else {
err = Z_ERRNO; err = Z_ERRNO;
break; break;
} }
} else { } else {
err = Z_ERRNO; err = Z_ERRNO;
break; break;
} }
} else { } else {
err = Z_STREAM_ERROR; err = Z_STREAM_ERROR;
break; break;
} }
/* Extra field */ /* Extra field */
if (extsize > 0) { if (extsize > 0) {
if (fread(extra, 1, extsize, fpZip) == extsize) { if (fread(extra, 1, extsize, fpZip) == extsize) {
if (fwrite(extra, 1, extsize, fpOut) == extsize) { if (fwrite(extra, 1, extsize, fpOut) == extsize) {
offset += extsize; offset += extsize;
} else { } else {
err = Z_ERRNO; err = Z_ERRNO;
break; break;
} }
} else { } else {
err = Z_ERRNO; err = Z_ERRNO;
break; break;
} }
} }
/* Data */ /* Data */
{ {
int dataSize = cpsize; int dataSize = cpsize;
if (dataSize == 0) { if (dataSize == 0) {
dataSize = uncpsize; dataSize = uncpsize;
} }
if (dataSize > 0) { if (dataSize > 0) {
char* data = malloc(dataSize); char* data = malloc(dataSize);
if (data != NULL) { if (data != NULL) {
if ((int)fread(data, 1, dataSize, fpZip) == dataSize) { if ((int)fread(data, 1, dataSize, fpZip) == dataSize) {
if ((int)fwrite(data, 1, dataSize, fpOut) == dataSize) { if ((int)fwrite(data, 1, dataSize, fpOut) == dataSize) {
offset += dataSize; offset += dataSize;
totalBytes += dataSize; totalBytes += dataSize;
} else { } else {
err = Z_ERRNO; err = Z_ERRNO;
} }
} else { } else {
err = Z_ERRNO; err = Z_ERRNO;
} }
free(data); free(data);
if (err != Z_OK) { if (err != Z_OK) {
break; break;
} }
} else { } else {
err = Z_MEM_ERROR; err = Z_MEM_ERROR;
break; break;
} }
} }
} }
/* Central directory entry */ /* Central directory entry */
{ {
char header[46]; char header[46];
char* comment = ""; char* comment = "";
int comsize = (int) strlen(comment); int comsize = (int) strlen(comment);
WRITE_32(header, 0x02014b50); WRITE_32(header, 0x02014b50);
WRITE_16(header + 4, version); WRITE_16(header + 4, version);
WRITE_16(header + 6, version); WRITE_16(header + 6, version);
WRITE_16(header + 8, gpflag); WRITE_16(header + 8, gpflag);
WRITE_16(header + 10, method); WRITE_16(header + 10, method);
WRITE_16(header + 12, filetime); WRITE_16(header + 12, filetime);
WRITE_16(header + 14, filedate); WRITE_16(header + 14, filedate);
WRITE_32(header + 16, crc); WRITE_32(header + 16, crc);
WRITE_32(header + 20, cpsize); WRITE_32(header + 20, cpsize);
WRITE_32(header + 24, uncpsize); WRITE_32(header + 24, uncpsize);
WRITE_16(header + 28, fnsize); WRITE_16(header + 28, fnsize);
WRITE_16(header + 30, extsize); WRITE_16(header + 30, extsize);
WRITE_16(header + 32, comsize); WRITE_16(header + 32, comsize);
WRITE_16(header + 34, 0); /* disk # */ WRITE_16(header + 34, 0); /* disk # */
WRITE_16(header + 36, 0); /* int attrb */ WRITE_16(header + 36, 0); /* int attrb */
WRITE_32(header + 38, 0); /* ext attrb */ WRITE_32(header + 38, 0); /* ext attrb */
WRITE_32(header + 42, currentOffset); WRITE_32(header + 42, currentOffset);
/* Header */ /* Header */
if (fwrite(header, 1, 46, fpOutCD) == 46) { if (fwrite(header, 1, 46, fpOutCD) == 46) {
offsetCD += 46; offsetCD += 46;
/* Filename */ /* Filename */
if (fnsize > 0) { if (fnsize > 0) {
if (fwrite(filename, 1, fnsize, fpOutCD) == fnsize) { if (fwrite(filename, 1, fnsize, fpOutCD) == fnsize) {
offsetCD += fnsize; offsetCD += fnsize;
} else { } else {
err = Z_ERRNO; err = Z_ERRNO;
break; break;
} }
} else { } else {
err = Z_STREAM_ERROR; err = Z_STREAM_ERROR;
break; break;
} }
/* Extra field */ /* Extra field */
if (extsize > 0) { if (extsize > 0) {
if (fwrite(extra, 1, extsize, fpOutCD) == extsize) { if (fwrite(extra, 1, extsize, fpOutCD) == extsize) {
offsetCD += extsize; offsetCD += extsize;
} else { } else {
err = Z_ERRNO; err = Z_ERRNO;
break; break;
} }
} }
/* Comment field */ /* Comment field */
if (comsize > 0) { if (comsize > 0) {
if ((int)fwrite(comment, 1, comsize, fpOutCD) == comsize) { if ((int)fwrite(comment, 1, comsize, fpOutCD) == comsize) {
offsetCD += comsize; offsetCD += comsize;
} else { } else {
err = Z_ERRNO; err = Z_ERRNO;
break; break;
} }
} }
} else { } else {
err = Z_ERRNO; err = Z_ERRNO;
break; break;
} }
} }
/* Success */ /* Success */
entries++; entries++;
} else { } else {
break; break;
} }
} }
/* Final central directory */ /* Final central directory */
{ {
int entriesZip = entries; int entriesZip = entries;
char header[22]; char header[22];
char* comment = ""; // "ZIP File recovered by zlib/minizip/mztools"; char* comment = ""; // "ZIP File recovered by zlib/minizip/mztools";
int comsize = (int) strlen(comment); int comsize = (int) strlen(comment);
if (entriesZip > 0xffff) { if (entriesZip > 0xffff) {
entriesZip = 0xffff; entriesZip = 0xffff;
} }
WRITE_32(header, 0x06054b50); WRITE_32(header, 0x06054b50);
WRITE_16(header + 4, 0); /* disk # */ WRITE_16(header + 4, 0); /* disk # */
WRITE_16(header + 6, 0); /* disk # */ WRITE_16(header + 6, 0); /* disk # */
WRITE_16(header + 8, entriesZip); /* hack */ WRITE_16(header + 8, entriesZip); /* hack */
WRITE_16(header + 10, entriesZip); /* hack */ WRITE_16(header + 10, entriesZip); /* hack */
WRITE_32(header + 12, offsetCD); /* size of CD */ WRITE_32(header + 12, offsetCD); /* size of CD */
WRITE_32(header + 16, offset); /* offset to CD */ WRITE_32(header + 16, offset); /* offset to CD */
WRITE_16(header + 20, comsize); /* comment */ WRITE_16(header + 20, comsize); /* comment */
/* Header */ /* Header */
if (fwrite(header, 1, 22, fpOutCD) == 22) { if (fwrite(header, 1, 22, fpOutCD) == 22) {
/* Comment field */ /* Comment field */
if (comsize > 0) { if (comsize > 0) {
if ((int)fwrite(comment, 1, comsize, fpOutCD) != comsize) { if ((int)fwrite(comment, 1, comsize, fpOutCD) != comsize) {
err = Z_ERRNO; err = Z_ERRNO;
} }
} }
} else { } else {
err = Z_ERRNO; err = Z_ERRNO;
} }
} }
/* Final merge (file + central directory) */ /* Final merge (file + central directory) */
fclose(fpOutCD); fclose(fpOutCD);
if (err == Z_OK) { if (err == Z_OK) {
fpOutCD = fopen(fileOutTmp, "rb"); fpOutCD = fopen(fileOutTmp, "rb");
if (fpOutCD != NULL) { if (fpOutCD != NULL) {
int nRead; int nRead;
char buffer[8192]; char buffer[8192];
while ( (nRead = (int)fread(buffer, 1, sizeof(buffer), fpOutCD)) > 0) { while ( (nRead = (int)fread(buffer, 1, sizeof(buffer), fpOutCD)) > 0) {
if ((int)fwrite(buffer, 1, nRead, fpOut) != nRead) { if ((int)fwrite(buffer, 1, nRead, fpOut) != nRead) {
err = Z_ERRNO; err = Z_ERRNO;
break; break;
} }
} }
fclose(fpOutCD); fclose(fpOutCD);
} }
} }
/* Close */ /* Close */
fclose(fpZip); fclose(fpZip);
fclose(fpOut); fclose(fpOut);
/* Wipe temporary file */ /* Wipe temporary file */
(void)remove(fileOutTmp); (void)remove(fileOutTmp);
/* Number of recovered entries */ /* Number of recovered entries */
if (err == Z_OK) { if (err == Z_OK) {
if (nRecovered != NULL) { if (nRecovered != NULL) {
*nRecovered = entries; *nRecovered = entries;
} }
if (bytesRecovered != NULL) { if (bytesRecovered != NULL) {
*bytesRecovered = totalBytes; *bytesRecovered = totalBytes;
} }
} }
} else { } else {
err = Z_STREAM_ERROR; err = Z_STREAM_ERROR;
} }
return err; return err;
} }

62
contrib/minizip/mztools.h
View File

@@ -1,31 +1,31 @@
/* /*
Additional tools for Minizip Additional tools for Minizip
Code: Xavier Roche '2004 Code: Xavier Roche '2004
License: Same as ZLIB (www.gzip.org) License: Same as ZLIB (www.gzip.org)
*/ */
#ifndef _zip_tools_H #ifndef _zip_tools_H
#define _zip_tools_H #define _zip_tools_H
#ifdef __cplusplus #ifdef __cplusplus
extern "C" { extern "C" {
#endif #endif
#ifndef _ZLIB_H #ifndef _ZLIB_H
#include "zlib.h" #include "zlib.h"
#endif #endif
#include "unzip.h" #include "unzip.h"
/* Repair a ZIP file (missing central directory) /* Repair a ZIP file (missing central directory)
file: file to recover file: file to recover
fileOut: output file after recovery fileOut: output file after recovery
fileOutTmp: temporary file name used for recovery fileOutTmp: temporary file name used for recovery
*/ */
extern int ZEXPORT unzRepair(const char* file, extern int ZEXPORT unzRepair(const char* file,
const char* fileOut, const char* fileOut,
const char* fileOutTmp, const char* fileOutTmp,
uLong* nRecovered, uLong* nRecovered,
uLong* bytesRecovered); uLong* bytesRecovered);
#endif #endif

3196
contrib/minizip/unzip.c
View File

File diff suppressed because it is too large Load Diff

708
contrib/minizip/unzip.h
View File

@@ -1,354 +1,354 @@
/* unzip.h -- IO for uncompress .zip files using zlib /* unzip.h -- IO for uncompress .zip files using zlib
Version 1.01e, February 12th, 2005 Version 1.01e, February 12th, 2005
Copyright (C) 1998-2005 Gilles Vollant Copyright (C) 1998-2005 Gilles Vollant
This unzip package allow extract file from .ZIP file, compatible with PKZip 2.04g This unzip package allow extract file from .ZIP file, compatible with PKZip 2.04g
WinZip, InfoZip tools and compatible. WinZip, InfoZip tools and compatible.
Multi volume ZipFile (span) are not supported. Multi volume ZipFile (span) are not supported.
Encryption compatible with pkzip 2.04g only supported Encryption compatible with pkzip 2.04g only supported
Old compressions used by old PKZip 1.x are not supported Old compressions used by old PKZip 1.x are not supported
I WAIT FEEDBACK at mail info@winimage.com I WAIT FEEDBACK at mail info@winimage.com
Visit also http://www.winimage.com/zLibDll/unzip.htm for evolution Visit also http://www.winimage.com/zLibDll/unzip.htm for evolution
Condition of use and distribution are the same than zlib : Condition of use and distribution are the same than zlib :
This software is provided 'as-is', without any express or implied This software is provided 'as-is', without any express or implied
warranty. In no event will the authors be held liable for any damages warranty. In no event will the authors be held liable for any damages
arising from the use of this software. arising from the use of this software.
Permission is granted to anyone to use this software for any purpose, Permission is granted to anyone to use this software for any purpose,
including commercial applications, and to alter it and redistribute it including commercial applications, and to alter it and redistribute it
freely, subject to the following restrictions: freely, subject to the following restrictions:
1. The origin of this software must not be misrepresented; you must not 1. The origin of this software must not be misrepresented; you must not
claim that you wrote the original software. If you use this software claim that you wrote the original software. If you use this software
in a product, an acknowledgment in the product documentation would be in a product, an acknowledgment in the product documentation would be
appreciated but is not required. appreciated but is not required.
2. Altered source versions must be plainly marked as such, and must not be 2. Altered source versions must be plainly marked as such, and must not be
misrepresented as being the original software. misrepresented as being the original software.
3. This notice may not be removed or altered from any source distribution. 3. This notice may not be removed or altered from any source distribution.
*/ */
/* for more info about .ZIP format, see /* for more info about .ZIP format, see
http://www.info-zip.org/pub/infozip/doc/appnote-981119-iz.zip http://www.info-zip.org/pub/infozip/doc/appnote-981119-iz.zip
http://www.info-zip.org/pub/infozip/doc/ http://www.info-zip.org/pub/infozip/doc/
PkWare has also a specification at : PkWare has also a specification at :
ftp://ftp.pkware.com/probdesc.zip ftp://ftp.pkware.com/probdesc.zip
*/ */
#ifndef _unz_H #ifndef _unz_H
#define _unz_H #define _unz_H
#ifdef __cplusplus #ifdef __cplusplus
extern "C" { extern "C" {
#endif #endif
#ifndef _ZLIB_H #ifndef _ZLIB_H
#include "zlib.h" #include "zlib.h"
#endif #endif
#ifndef _ZLIBIOAPI_H #ifndef _ZLIBIOAPI_H
#include "ioapi.h" #include "ioapi.h"
#endif #endif
#if defined(STRICTUNZIP) || defined(STRICTZIPUNZIP) #if defined(STRICTUNZIP) || defined(STRICTZIPUNZIP)
/* like the STRICT of WIN32, we define a pointer that cannot be converted /* like the STRICT of WIN32, we define a pointer that cannot be converted
from (void*) without cast */ from (void*) without cast */
typedef struct TagunzFile__ { int unused; } unzFile__; typedef struct TagunzFile__ { int unused; } unzFile__;
typedef unzFile__ *unzFile; typedef unzFile__ *unzFile;
#else #else
typedef voidp unzFile; typedef voidp unzFile;
#endif #endif
#define UNZ_OK (0) #define UNZ_OK (0)
#define UNZ_END_OF_LIST_OF_FILE (-100) #define UNZ_END_OF_LIST_OF_FILE (-100)
#define UNZ_ERRNO (Z_ERRNO) #define UNZ_ERRNO (Z_ERRNO)
#define UNZ_EOF (0) #define UNZ_EOF (0)
#define UNZ_PARAMERROR (-102) #define UNZ_PARAMERROR (-102)
#define UNZ_BADZIPFILE (-103) #define UNZ_BADZIPFILE (-103)
#define UNZ_INTERNALERROR (-104) #define UNZ_INTERNALERROR (-104)
#define UNZ_CRCERROR (-105) #define UNZ_CRCERROR (-105)
/* tm_unz contain date/time info */ /* tm_unz contain date/time info */
typedef struct tm_unz_s typedef struct tm_unz_s
{ {
uInt tm_sec; /* seconds after the minute - [0,59] */ uInt tm_sec; /* seconds after the minute - [0,59] */
uInt tm_min; /* minutes after the hour - [0,59] */ uInt tm_min; /* minutes after the hour - [0,59] */
uInt tm_hour; /* hours since midnight - [0,23] */ uInt tm_hour; /* hours since midnight - [0,23] */
uInt tm_mday; /* day of the month - [1,31] */ uInt tm_mday; /* day of the month - [1,31] */
uInt tm_mon; /* months since January - [0,11] */ uInt tm_mon; /* months since January - [0,11] */
uInt tm_year; /* years - [1980..2044] */ uInt tm_year; /* years - [1980..2044] */
} tm_unz; } tm_unz;
/* unz_global_info structure contain global data about the ZIPfile /* unz_global_info structure contain global data about the ZIPfile
These data comes from the end of central dir */ These data comes from the end of central dir */
typedef struct unz_global_info_s typedef struct unz_global_info_s
{ {
uLong number_entry; /* total number of entries in uLong number_entry; /* total number of entries in
the central dir on this disk */ the central dir on this disk */
uLong size_comment; /* size of the global comment of the zipfile */ uLong size_comment; /* size of the global comment of the zipfile */
} unz_global_info; } unz_global_info;
/* unz_file_info contain information about a file in the zipfile */ /* unz_file_info contain information about a file in the zipfile */
typedef struct unz_file_info_s typedef struct unz_file_info_s
{ {
uLong version; /* version made by 2 bytes */ uLong version; /* version made by 2 bytes */
uLong version_needed; /* version needed to extract 2 bytes */ uLong version_needed; /* version needed to extract 2 bytes */
uLong flag; /* general purpose bit flag 2 bytes */ uLong flag; /* general purpose bit flag 2 bytes */
uLong compression_method; /* compression method 2 bytes */ uLong compression_method; /* compression method 2 bytes */
uLong dosDate; /* last mod file date in Dos fmt 4 bytes */ uLong dosDate; /* last mod file date in Dos fmt 4 bytes */
uLong crc; /* crc-32 4 bytes */ uLong crc; /* crc-32 4 bytes */
uLong compressed_size; /* compressed size 4 bytes */ uLong compressed_size; /* compressed size 4 bytes */
uLong uncompressed_size; /* uncompressed size 4 bytes */ uLong uncompressed_size; /* uncompressed size 4 bytes */
uLong size_filename; /* filename length 2 bytes */ uLong size_filename; /* filename length 2 bytes */
uLong size_file_extra; /* extra field length 2 bytes */ uLong size_file_extra; /* extra field length 2 bytes */
uLong size_file_comment; /* file comment length 2 bytes */ uLong size_file_comment; /* file comment length 2 bytes */
uLong disk_num_start; /* disk number start 2 bytes */ uLong disk_num_start; /* disk number start 2 bytes */
uLong internal_fa; /* internal file attributes 2 bytes */ uLong internal_fa; /* internal file attributes 2 bytes */
uLong external_fa; /* external file attributes 4 bytes */ uLong external_fa; /* external file attributes 4 bytes */
tm_unz tmu_date; tm_unz tmu_date;
} unz_file_info; } unz_file_info;
extern int ZEXPORT unzStringFileNameCompare OF ((const char* fileName1, extern int ZEXPORT unzStringFileNameCompare OF ((const char* fileName1,
const char* fileName2, const char* fileName2,
int iCaseSensitivity)); int iCaseSensitivity));
/* /*
Compare two filename (fileName1,fileName2). Compare two filename (fileName1,fileName2).
If iCaseSenisivity = 1, comparision is case sensitivity (like strcmp) If iCaseSenisivity = 1, comparision is case sensitivity (like strcmp)
If iCaseSenisivity = 2, comparision is not case sensitivity (like strcmpi If iCaseSenisivity = 2, comparision is not case sensitivity (like strcmpi
or strcasecmp) or strcasecmp)
If iCaseSenisivity = 0, case sensitivity is defaut of your operating system If iCaseSenisivity = 0, case sensitivity is defaut of your operating system
(like 1 on Unix, 2 on Windows) (like 1 on Unix, 2 on Windows)
*/ */
extern unzFile ZEXPORT unzOpen OF((const char *path)); extern unzFile ZEXPORT unzOpen OF((const char *path));
/* /*
Open a Zip file. path contain the full pathname (by example, Open a Zip file. path contain the full pathname (by example,
on a Windows XP computer "c:\\zlib\\zlib113.zip" or on an Unix computer on a Windows XP computer "c:\\zlib\\zlib113.zip" or on an Unix computer
"zlib/zlib113.zip". "zlib/zlib113.zip".
If the zipfile cannot be opened (file don't exist or in not valid), the If the zipfile cannot be opened (file don't exist or in not valid), the
return value is NULL. return value is NULL.
Else, the return value is a unzFile Handle, usable with other function Else, the return value is a unzFile Handle, usable with other function
of this unzip package. of this unzip package.
*/ */
extern unzFile ZEXPORT unzOpen2 OF((const char *path, extern unzFile ZEXPORT unzOpen2 OF((const char *path,
zlib_filefunc_def* pzlib_filefunc_def)); zlib_filefunc_def* pzlib_filefunc_def));
/* /*
Open a Zip file, like unzOpen, but provide a set of file low level API Open a Zip file, like unzOpen, but provide a set of file low level API
for read/write the zip file (see ioapi.h) for read/write the zip file (see ioapi.h)
*/ */
extern int ZEXPORT unzClose OF((unzFile file)); extern int ZEXPORT unzClose OF((unzFile file));
/* /*
Close a ZipFile opened with unzipOpen. Close a ZipFile opened with unzipOpen.
If there is files inside the .Zip opened with unzOpenCurrentFile (see later), If there is files inside the .Zip opened with unzOpenCurrentFile (see later),
these files MUST be closed with unzipCloseCurrentFile before call unzipClose. these files MUST be closed with unzipCloseCurrentFile before call unzipClose.
return UNZ_OK if there is no problem. */ return UNZ_OK if there is no problem. */
extern int ZEXPORT unzGetGlobalInfo OF((unzFile file, extern int ZEXPORT unzGetGlobalInfo OF((unzFile file,
unz_global_info *pglobal_info)); unz_global_info *pglobal_info));
/* /*
Write info about the ZipFile in the *pglobal_info structure. Write info about the ZipFile in the *pglobal_info structure.
No preparation of the structure is needed No preparation of the structure is needed
return UNZ_OK if there is no problem. */ return UNZ_OK if there is no problem. */
extern int ZEXPORT unzGetGlobalComment OF((unzFile file, extern int ZEXPORT unzGetGlobalComment OF((unzFile file,
char *szComment, char *szComment,
uLong uSizeBuf)); uLong uSizeBuf));
/* /*
Get the global comment string of the ZipFile, in the szComment buffer. Get the global comment string of the ZipFile, in the szComment buffer.
uSizeBuf is the size of the szComment buffer. uSizeBuf is the size of the szComment buffer.
return the number of byte copied or an error code <0 return the number of byte copied or an error code <0
*/ */
/***************************************************************************/ /***************************************************************************/
/* Unzip package allow you browse the directory of the zipfile */ /* Unzip package allow you browse the directory of the zipfile */
extern int ZEXPORT unzGoToFirstFile OF((unzFile file)); extern int ZEXPORT unzGoToFirstFile OF((unzFile file));
/* /*
Set the current file of the zipfile to the first file. Set the current file of the zipfile to the first file.
return UNZ_OK if there is no problem return UNZ_OK if there is no problem
*/ */
extern int ZEXPORT unzGoToNextFile OF((unzFile file)); extern int ZEXPORT unzGoToNextFile OF((unzFile file));
/* /*
Set the current file of the zipfile to the next file. Set the current file of the zipfile to the next file.
return UNZ_OK if there is no problem return UNZ_OK if there is no problem
return UNZ_END_OF_LIST_OF_FILE if the actual file was the latest. return UNZ_END_OF_LIST_OF_FILE if the actual file was the latest.
*/ */
extern int ZEXPORT unzLocateFile OF((unzFile file, extern int ZEXPORT unzLocateFile OF((unzFile file,
const char *szFileName, const char *szFileName,
int iCaseSensitivity)); int iCaseSensitivity));
/* /*
Try locate the file szFileName in the zipfile. Try locate the file szFileName in the zipfile.
For the iCaseSensitivity signification, see unzStringFileNameCompare For the iCaseSensitivity signification, see unzStringFileNameCompare
return value : return value :
UNZ_OK if the file is found. It becomes the current file. UNZ_OK if the file is found. It becomes the current file.
UNZ_END_OF_LIST_OF_FILE if the file is not found UNZ_END_OF_LIST_OF_FILE if the file is not found
*/ */
/* ****************************************** */ /* ****************************************** */
/* Ryan supplied functions */ /* Ryan supplied functions */
/* unz_file_info contain information about a file in the zipfile */ /* unz_file_info contain information about a file in the zipfile */
typedef struct unz_file_pos_s typedef struct unz_file_pos_s
{ {
uLong pos_in_zip_directory; /* offset in zip file directory */ uLong pos_in_zip_directory; /* offset in zip file directory */
uLong num_of_file; /* # of file */ uLong num_of_file; /* # of file */
} unz_file_pos; } unz_file_pos;
extern int ZEXPORT unzGetFilePos( extern int ZEXPORT unzGetFilePos(
unzFile file, unzFile file,
unz_file_pos* file_pos); unz_file_pos* file_pos);
extern int ZEXPORT unzGoToFilePos( extern int ZEXPORT unzGoToFilePos(
unzFile file, unzFile file,
unz_file_pos* file_pos); unz_file_pos* file_pos);
/* ****************************************** */ /* ****************************************** */
extern int ZEXPORT unzGetCurrentFileInfo OF((unzFile file, extern int ZEXPORT unzGetCurrentFileInfo OF((unzFile file,
unz_file_info *pfile_info, unz_file_info *pfile_info,
char *szFileName, char *szFileName,
uLong fileNameBufferSize, uLong fileNameBufferSize,
void *extraField, void *extraField,
uLong extraFieldBufferSize, uLong extraFieldBufferSize,
char *szComment, char *szComment,
uLong commentBufferSize)); uLong commentBufferSize));
/* /*
Get Info about the current file Get Info about the current file
if pfile_info!=NULL, the *pfile_info structure will contain somes info about if pfile_info!=NULL, the *pfile_info structure will contain somes info about
the current file the current file
if szFileName!=NULL, the filemane string will be copied in szFileName if szFileName!=NULL, the filemane string will be copied in szFileName
(fileNameBufferSize is the size of the buffer) (fileNameBufferSize is the size of the buffer)
if extraField!=NULL, the extra field information will be copied in extraField if extraField!=NULL, the extra field information will be copied in extraField
(extraFieldBufferSize is the size of the buffer). (extraFieldBufferSize is the size of the buffer).
This is the Central-header version of the extra field This is the Central-header version of the extra field
if szComment!=NULL, the comment string of the file will be copied in szComment if szComment!=NULL, the comment string of the file will be copied in szComment
(commentBufferSize is the size of the buffer) (commentBufferSize is the size of the buffer)
*/ */
/***************************************************************************/ /***************************************************************************/
/* for reading the content of the current zipfile, you can open it, read data /* for reading the content of the current zipfile, you can open it, read data
from it, and close it (you can close it before reading all the file) from it, and close it (you can close it before reading all the file)
*/ */
extern int ZEXPORT unzOpenCurrentFile OF((unzFile file)); extern int ZEXPORT unzOpenCurrentFile OF((unzFile file));
/* /*
Open for reading data the current file in the zipfile. Open for reading data the current file in the zipfile.
If there is no error, the return value is UNZ_OK. If there is no error, the return value is UNZ_OK.
*/ */
extern int ZEXPORT unzOpenCurrentFilePassword OF((unzFile file, extern int ZEXPORT unzOpenCurrentFilePassword OF((unzFile file,
const char* password)); const char* password));
/* /*
Open for reading data the current file in the zipfile. Open for reading data the current file in the zipfile.
password is a crypting password password is a crypting password
If there is no error, the return value is UNZ_OK. If there is no error, the return value is UNZ_OK.
*/ */
extern int ZEXPORT unzOpenCurrentFile2 OF((unzFile file, extern int ZEXPORT unzOpenCurrentFile2 OF((unzFile file,
int* method, int* method,
int* level, int* level,
int raw)); int raw));
/* /*
Same than unzOpenCurrentFile, but open for read raw the file (not uncompress) Same than unzOpenCurrentFile, but open for read raw the file (not uncompress)
if raw==1 if raw==1
*method will receive method of compression, *level will receive level of *method will receive method of compression, *level will receive level of
compression compression
note : you can set level parameter as NULL (if you did not want known level, note : you can set level parameter as NULL (if you did not want known level,
but you CANNOT set method parameter as NULL but you CANNOT set method parameter as NULL
*/ */
extern int ZEXPORT unzOpenCurrentFile3 OF((unzFile file, extern int ZEXPORT unzOpenCurrentFile3 OF((unzFile file,
int* method, int* method,
int* level, int* level,
int raw, int raw,
const char* password)); const char* password));
/* /*
Same than unzOpenCurrentFile, but open for read raw the file (not uncompress) Same than unzOpenCurrentFile, but open for read raw the file (not uncompress)
if raw==1 if raw==1
*method will receive method of compression, *level will receive level of *method will receive method of compression, *level will receive level of
compression compression
note : you can set level parameter as NULL (if you did not want known level, note : you can set level parameter as NULL (if you did not want known level,
but you CANNOT set method parameter as NULL but you CANNOT set method parameter as NULL
*/ */
extern int ZEXPORT unzCloseCurrentFile OF((unzFile file)); extern int ZEXPORT unzCloseCurrentFile OF((unzFile file));
/* /*
Close the file in zip opened with unzOpenCurrentFile Close the file in zip opened with unzOpenCurrentFile
Return UNZ_CRCERROR if all the file was read but the CRC is not good Return UNZ_CRCERROR if all the file was read but the CRC is not good
*/ */
extern int ZEXPORT unzReadCurrentFile OF((unzFile file, extern int ZEXPORT unzReadCurrentFile OF((unzFile file,
voidp buf, voidp buf,
unsigned len)); unsigned len));
/* /*
Read bytes from the current file (opened by unzOpenCurrentFile) Read bytes from the current file (opened by unzOpenCurrentFile)
buf contain buffer where data must be copied buf contain buffer where data must be copied
len the size of buf. len the size of buf.
return the number of byte copied if somes bytes are copied return the number of byte copied if somes bytes are copied
return 0 if the end of file was reached return 0 if the end of file was reached
return <0 with error code if there is an error return <0 with error code if there is an error
(UNZ_ERRNO for IO error, or zLib error for uncompress error) (UNZ_ERRNO for IO error, or zLib error for uncompress error)
*/ */
extern z_off_t ZEXPORT unztell OF((unzFile file)); extern z_off_t ZEXPORT unztell OF((unzFile file));
/* /*
Give the current position in uncompressed data Give the current position in uncompressed data
*/ */
extern int ZEXPORT unzeof OF((unzFile file)); extern int ZEXPORT unzeof OF((unzFile file));
/* /*
return 1 if the end of file was reached, 0 elsewhere return 1 if the end of file was reached, 0 elsewhere
*/ */
extern int ZEXPORT unzGetLocalExtrafield OF((unzFile file, extern int ZEXPORT unzGetLocalExtrafield OF((unzFile file,
voidp buf, voidp buf,
unsigned len)); unsigned len));
/* /*
Read extra field from the current file (opened by unzOpenCurrentFile) Read extra field from the current file (opened by unzOpenCurrentFile)
This is the local-header version of the extra field (sometimes, there is This is the local-header version of the extra field (sometimes, there is
more info in the local-header version than in the central-header) more info in the local-header version than in the central-header)
if buf==NULL, it return the size of the local extra field if buf==NULL, it return the size of the local extra field
if buf!=NULL, len is the size of the buffer, the extra header is copied in if buf!=NULL, len is the size of the buffer, the extra header is copied in
buf. buf.
the return value is the number of bytes copied in buf, or (if <0) the return value is the number of bytes copied in buf, or (if <0)
the error code the error code
*/ */
/***************************************************************************/ /***************************************************************************/
/* Get the current file offset */ /* Get the current file offset */
extern uLong ZEXPORT unzGetOffset (unzFile file); extern uLong ZEXPORT unzGetOffset (unzFile file);
/* Set the current file offset */ /* Set the current file offset */
extern int ZEXPORT unzSetOffset (unzFile file, uLong pos); extern int ZEXPORT unzSetOffset (unzFile file, uLong pos);
#ifdef __cplusplus #ifdef __cplusplus
} }
#endif #endif
#endif /* _unz_H */ #endif /* _unz_H */

2438
contrib/minizip/zip.c
View File

File diff suppressed because it is too large Load Diff

470
contrib/minizip/zip.h
View File

@@ -1,235 +1,235 @@
/* zip.h -- IO for compress .zip files using zlib /* zip.h -- IO for compress .zip files using zlib
Version 1.01e, February 12th, 2005 Version 1.01e, February 12th, 2005
Copyright (C) 1998-2005 Gilles Vollant Copyright (C) 1998-2005 Gilles Vollant
This unzip package allow creates .ZIP file, compatible with PKZip 2.04g This unzip package allow creates .ZIP file, compatible with PKZip 2.04g
WinZip, InfoZip tools and compatible. WinZip, InfoZip tools and compatible.
Multi volume ZipFile (span) are not supported. Multi volume ZipFile (span) are not supported.
Encryption compatible with pkzip 2.04g only supported Encryption compatible with pkzip 2.04g only supported
Old compressions used by old PKZip 1.x are not supported Old compressions used by old PKZip 1.x are not supported
For uncompress .zip file, look at unzip.h For uncompress .zip file, look at unzip.h
I WAIT FEEDBACK at mail info@winimage.com I WAIT FEEDBACK at mail info@winimage.com
Visit also http://www.winimage.com/zLibDll/unzip.html for evolution Visit also http://www.winimage.com/zLibDll/unzip.html for evolution
Condition of use and distribution are the same than zlib : Condition of use and distribution are the same than zlib :
This software is provided 'as-is', without any express or implied This software is provided 'as-is', without any express or implied
warranty. In no event will the authors be held liable for any damages warranty. In no event will the authors be held liable for any damages
arising from the use of this software. arising from the use of this software.
Permission is granted to anyone to use this software for any purpose, Permission is granted to anyone to use this software for any purpose,
including commercial applications, and to alter it and redistribute it including commercial applications, and to alter it and redistribute it
freely, subject to the following restrictions: freely, subject to the following restrictions:
1. The origin of this software must not be misrepresented; you must not 1. The origin of this software must not be misrepresented; you must not
claim that you wrote the original software. If you use this software claim that you wrote the original software. If you use this software
in a product, an acknowledgment in the product documentation would be in a product, an acknowledgment in the product documentation would be
appreciated but is not required. appreciated but is not required.
2. Altered source versions must be plainly marked as such, and must not be 2. Altered source versions must be plainly marked as such, and must not be
misrepresented as being the original software. misrepresented as being the original software.
3. This notice may not be removed or altered from any source distribution. 3. This notice may not be removed or altered from any source distribution.
*/ */
/* for more info about .ZIP format, see /* for more info about .ZIP format, see
http://www.info-zip.org/pub/infozip/doc/appnote-981119-iz.zip http://www.info-zip.org/pub/infozip/doc/appnote-981119-iz.zip
http://www.info-zip.org/pub/infozip/doc/ http://www.info-zip.org/pub/infozip/doc/
PkWare has also a specification at : PkWare has also a specification at :
ftp://ftp.pkware.com/probdesc.zip ftp://ftp.pkware.com/probdesc.zip
*/ */
#ifndef _zip_H #ifndef _zip_H
#define _zip_H #define _zip_H
#ifdef __cplusplus #ifdef __cplusplus
extern "C" { extern "C" {
#endif #endif
#ifndef _ZLIB_H #ifndef _ZLIB_H
#include "zlib.h" #include "zlib.h"
#endif #endif
#ifndef _ZLIBIOAPI_H #ifndef _ZLIBIOAPI_H
#include "ioapi.h" #include "ioapi.h"
#endif #endif
#if defined(STRICTZIP) || defined(STRICTZIPUNZIP) #if defined(STRICTZIP) || defined(STRICTZIPUNZIP)
/* like the STRICT of WIN32, we define a pointer that cannot be converted /* like the STRICT of WIN32, we define a pointer that cannot be converted
from (void*) without cast */ from (void*) without cast */
typedef struct TagzipFile__ { int unused; } zipFile__; typedef struct TagzipFile__ { int unused; } zipFile__;
typedef zipFile__ *zipFile; typedef zipFile__ *zipFile;
#else #else
typedef voidp zipFile; typedef voidp zipFile;
#endif #endif
#define ZIP_OK (0) #define ZIP_OK (0)
#define ZIP_EOF (0) #define ZIP_EOF (0)
#define ZIP_ERRNO (Z_ERRNO) #define ZIP_ERRNO (Z_ERRNO)
#define ZIP_PARAMERROR (-102) #define ZIP_PARAMERROR (-102)
#define ZIP_BADZIPFILE (-103) #define ZIP_BADZIPFILE (-103)
#define ZIP_INTERNALERROR (-104) #define ZIP_INTERNALERROR (-104)
#ifndef DEF_MEM_LEVEL #ifndef DEF_MEM_LEVEL
# if MAX_MEM_LEVEL >= 8 # if MAX_MEM_LEVEL >= 8
# define DEF_MEM_LEVEL 8 # define DEF_MEM_LEVEL 8
# else # else
# define DEF_MEM_LEVEL MAX_MEM_LEVEL # define DEF_MEM_LEVEL MAX_MEM_LEVEL
# endif # endif
#endif #endif
/* default memLevel */ /* default memLevel */
/* tm_zip contain date/time info */ /* tm_zip contain date/time info */
typedef struct tm_zip_s typedef struct tm_zip_s
{ {
uInt tm_sec; /* seconds after the minute - [0,59] */ uInt tm_sec; /* seconds after the minute - [0,59] */
uInt tm_min; /* minutes after the hour - [0,59] */ uInt tm_min; /* minutes after the hour - [0,59] */
uInt tm_hour; /* hours since midnight - [0,23] */ uInt tm_hour; /* hours since midnight - [0,23] */
uInt tm_mday; /* day of the month - [1,31] */ uInt tm_mday; /* day of the month - [1,31] */
uInt tm_mon; /* months since January - [0,11] */ uInt tm_mon; /* months since January - [0,11] */
uInt tm_year; /* years - [1980..2044] */ uInt tm_year; /* years - [1980..2044] */
} tm_zip; } tm_zip;
typedef struct typedef struct
{ {
tm_zip tmz_date; /* date in understandable format */ tm_zip tmz_date; /* date in understandable format */
uLong dosDate; /* if dos_date == 0, tmu_date is used */ uLong dosDate; /* if dos_date == 0, tmu_date is used */
/* uLong flag; */ /* general purpose bit flag 2 bytes */ /* uLong flag; */ /* general purpose bit flag 2 bytes */
uLong internal_fa; /* internal file attributes 2 bytes */ uLong internal_fa; /* internal file attributes 2 bytes */
uLong external_fa; /* external file attributes 4 bytes */ uLong external_fa; /* external file attributes 4 bytes */
} zip_fileinfo; } zip_fileinfo;
typedef const char* zipcharpc; typedef const char* zipcharpc;
#define APPEND_STATUS_CREATE (0) #define APPEND_STATUS_CREATE (0)
#define APPEND_STATUS_CREATEAFTER (1) #define APPEND_STATUS_CREATEAFTER (1)
#define APPEND_STATUS_ADDINZIP (2) #define APPEND_STATUS_ADDINZIP (2)
extern zipFile ZEXPORT zipOpen OF((const char *pathname, int append)); extern zipFile ZEXPORT zipOpen OF((const char *pathname, int append));
/* /*
Create a zipfile. Create a zipfile.
pathname contain on Windows XP a filename like "c:\\zlib\\zlib113.zip" or on pathname contain on Windows XP a filename like "c:\\zlib\\zlib113.zip" or on
an Unix computer "zlib/zlib113.zip". an Unix computer "zlib/zlib113.zip".
if the file pathname exist and append==APPEND_STATUS_CREATEAFTER, the zip if the file pathname exist and append==APPEND_STATUS_CREATEAFTER, the zip
will be created at the end of the file. will be created at the end of the file.
(useful if the file contain a self extractor code) (useful if the file contain a self extractor code)
if the file pathname exist and append==APPEND_STATUS_ADDINZIP, we will if the file pathname exist and append==APPEND_STATUS_ADDINZIP, we will
add files in existing zip (be sure you don't add file that doesn't exist) add files in existing zip (be sure you don't add file that doesn't exist)
If the zipfile cannot be opened, the return value is NULL. If the zipfile cannot be opened, the return value is NULL.
Else, the return value is a zipFile Handle, usable with other function Else, the return value is a zipFile Handle, usable with other function
of this zip package. of this zip package.
*/ */
/* Note : there is no delete function into a zipfile. /* Note : there is no delete function into a zipfile.
If you want delete file into a zipfile, you must open a zipfile, and create another If you want delete file into a zipfile, you must open a zipfile, and create another
Of couse, you can use RAW reading and writing to copy the file you did not want delte Of couse, you can use RAW reading and writing to copy the file you did not want delte
*/ */
extern zipFile ZEXPORT zipOpen2 OF((const char *pathname, extern zipFile ZEXPORT zipOpen2 OF((const char *pathname,
int append, int append,
zipcharpc* globalcomment, zipcharpc* globalcomment,
zlib_filefunc_def* pzlib_filefunc_def)); zlib_filefunc_def* pzlib_filefunc_def));
extern int ZEXPORT zipOpenNewFileInZip OF((zipFile file, extern int ZEXPORT zipOpenNewFileInZip OF((zipFile file,
const char* filename, const char* filename,
const zip_fileinfo* zipfi, const zip_fileinfo* zipfi,
const void* extrafield_local, const void* extrafield_local,
uInt size_extrafield_local, uInt size_extrafield_local,
const void* extrafield_global, const void* extrafield_global,
uInt size_extrafield_global, uInt size_extrafield_global,
const char* comment, const char* comment,
int method, int method,
int level)); int level));
/* /*
Open a file in the ZIP for writing. Open a file in the ZIP for writing.
filename : the filename in zip (if NULL, '-' without quote will be used filename : the filename in zip (if NULL, '-' without quote will be used
*zipfi contain supplemental information *zipfi contain supplemental information
if extrafield_local!=NULL and size_extrafield_local>0, extrafield_local if extrafield_local!=NULL and size_extrafield_local>0, extrafield_local
contains the extrafield data the the local header contains the extrafield data the the local header
if extrafield_global!=NULL and size_extrafield_global>0, extrafield_global if extrafield_global!=NULL and size_extrafield_global>0, extrafield_global
contains the extrafield data the the local header contains the extrafield data the the local header
if comment != NULL, comment contain the comment string if comment != NULL, comment contain the comment string
method contain the compression method (0 for store, Z_DEFLATED for deflate) method contain the compression method (0 for store, Z_DEFLATED for deflate)
level contain the level of compression (can be Z_DEFAULT_COMPRESSION) level contain the level of compression (can be Z_DEFAULT_COMPRESSION)
*/ */
extern int ZEXPORT zipOpenNewFileInZip2 OF((zipFile file, extern int ZEXPORT zipOpenNewFileInZip2 OF((zipFile file,
const char* filename, const char* filename,
const zip_fileinfo* zipfi, const zip_fileinfo* zipfi,
const void* extrafield_local, const void* extrafield_local,
uInt size_extrafield_local, uInt size_extrafield_local,
const void* extrafield_global, const void* extrafield_global,
uInt size_extrafield_global, uInt size_extrafield_global,
const char* comment, const char* comment,
int method, int method,
int level, int level,
int raw)); int raw));
/* /*
Same than zipOpenNewFileInZip, except if raw=1, we write raw file Same than zipOpenNewFileInZip, except if raw=1, we write raw file
*/ */
extern int ZEXPORT zipOpenNewFileInZip3 OF((zipFile file, extern int ZEXPORT zipOpenNewFileInZip3 OF((zipFile file,
const char* filename, const char* filename,
const zip_fileinfo* zipfi, const zip_fileinfo* zipfi,
const void* extrafield_local, const void* extrafield_local,
uInt size_extrafield_local, uInt size_extrafield_local,
const void* extrafield_global, const void* extrafield_global,
uInt size_extrafield_global, uInt size_extrafield_global,
const char* comment, const char* comment,
int method, int method,
int level, int level,
int raw, int raw,
int windowBits, int windowBits,
int memLevel, int memLevel,
int strategy, int strategy,
const char* password, const char* password,
uLong crcForCtypting)); uLong crcForCtypting));
/* /*
Same than zipOpenNewFileInZip2, except Same than zipOpenNewFileInZip2, except
windowBits,memLevel,,strategy : see parameter strategy in deflateInit2 windowBits,memLevel,,strategy : see parameter strategy in deflateInit2
password : crypting password (NULL for no crypting) password : crypting password (NULL for no crypting)
crcForCtypting : crc of file to compress (needed for crypting) crcForCtypting : crc of file to compress (needed for crypting)
*/ */
extern int ZEXPORT zipWriteInFileInZip OF((zipFile file, extern int ZEXPORT zipWriteInFileInZip OF((zipFile file,
const void* buf, const void* buf,
unsigned len)); unsigned len));
/* /*
Write data in the zipfile Write data in the zipfile
*/ */
extern int ZEXPORT zipCloseFileInZip OF((zipFile file)); extern int ZEXPORT zipCloseFileInZip OF((zipFile file));
/* /*
Close the current file in the zipfile Close the current file in the zipfile
*/ */
extern int ZEXPORT zipCloseFileInZipRaw OF((zipFile file, extern int ZEXPORT zipCloseFileInZipRaw OF((zipFile file,
uLong uncompressed_size, uLong uncompressed_size,
uLong crc32)); uLong crc32));
/* /*
Close the current file in the zipfile, for fiel opened with Close the current file in the zipfile, for fiel opened with
parameter raw=1 in zipOpenNewFileInZip2 parameter raw=1 in zipOpenNewFileInZip2
uncompressed_size and crc32 are value for the uncompressed size uncompressed_size and crc32 are value for the uncompressed size
*/ */
extern int ZEXPORT zipClose OF((zipFile file, extern int ZEXPORT zipClose OF((zipFile file,
const char* global_comment)); const char* global_comment));
/* /*
Close the zipfile Close the zipfile
*/ */
#ifdef __cplusplus #ifdef __cplusplus
} }
#endif #endif
#endif /* _zip_H */ #endif /* _zip_H */

2
contrib/pascal/zlibpas.pas
View File

@@ -10,7 +10,7 @@ unit zlibpas;
interface interface
const const
ZLIB_VERSION = '1.2.2'; ZLIB_VERSION = '1.2.3';
type type
alloc_func = function(opaque: Pointer; items, size: Integer): Pointer; alloc_func = function(opaque: Pointer; items, size: Integer): Pointer;

18
contrib/testzlib/rdtsc64.asm
View File

@@ -1,18 +0,0 @@
; rdtsc64.asm
;
; unsigned _int64 myrdtsc();
;
; return the performance rdtsc value, on AMD64/Intel EM64T
;
; compile with :
; ml64.exe" /Flrdtsc64 /c /Zi rdtsc64.asm
;
.code
myrdtsc PROC
rdtsc
shl rdx,32
or rax,rdx
ret
myrdtsc ENDP
END

BIN
contrib/testzlib/rdtsc64.obj
View File

Binary file not shown.

33
contrib/testzlib/testzlib.c
View File

@@ -1,7 +1,7 @@
#include <stdio.h> #include <stdio.h>
#include <stdlib.h> #include <stdlib.h>
#include <windows.h> #include <windows.h>
#include "zlib.h" #include "zlib.h"
@@ -17,23 +17,25 @@ void MyDoMinus64(LARGE_INTEGER *R,LARGE_INTEGER A,LARGE_INTEGER B)
} }
} }
#ifdef _AMD64_ #ifdef _M_X64
unsigned _int64 myrdtsc(); // see http://msdn2.microsoft.com/library/twchhe95(en-us,vs.80).aspx for __rdtsc
unsigned __int64 __rdtsc(void);
void BeginCountRdtsc(LARGE_INTEGER * pbeginTime64) void BeginCountRdtsc(LARGE_INTEGER * pbeginTime64)
{ {
// printf("rdtsc = %I64x\n",myrdtsc()); // printf("rdtsc = %I64x\n",__rdtsc());
pbeginTime64->QuadPart=myrdtsc(); pbeginTime64->QuadPart=__rdtsc();
} }
LARGE_INTEGER GetResRdtsc(LARGE_INTEGER beginTime64,BOOL fComputeTimeQueryPerf) LARGE_INTEGER GetResRdtsc(LARGE_INTEGER beginTime64,BOOL fComputeTimeQueryPerf)
{ {
LARGE_INTEGER LIres; LARGE_INTEGER LIres;
unsigned _int64 res=myrdtsc()-((unsigned _int64)(beginTime64.QuadPart)); unsigned _int64 res=__rdtsc()-((unsigned _int64)(beginTime64.QuadPart));
LIres.QuadPart=res; LIres.QuadPart=res;
// printf("rdtsc = %I64x\n",myrdtsc()); // printf("rdtsc = %I64x\n",__rdtsc());
return LIres; return LIres;
} }
#else #else
#ifdef _M_IX86
void myGetRDTSC32(LARGE_INTEGER * pbeginTime64) void myGetRDTSC32(LARGE_INTEGER * pbeginTime64)
{ {
DWORD dwEdx,dwEax; DWORD dwEdx,dwEax;
@@ -61,8 +63,23 @@ LARGE_INTEGER GetResRdtsc(LARGE_INTEGER beginTime64,BOOL fComputeTimeQueryPerf)
MyDoMinus64(&LIres,endTime64,beginTime64); MyDoMinus64(&LIres,endTime64,beginTime64);
return LIres; return LIres;
} }
#endif #else
void myGetRDTSC32(LARGE_INTEGER * pbeginTime64)
{
}
void BeginCountRdtsc(LARGE_INTEGER * pbeginTime64)
{
}
LARGE_INTEGER GetResRdtsc(LARGE_INTEGER beginTime64,BOOL fComputeTimeQueryPerf)
{
LARGE_INTEGER lr;
lr.QuadPart=0;
return lr;
}
#endif
#endif
void BeginCountPerfCounter(LARGE_INTEGER * pbeginTime64,BOOL fComputeTimeQueryPerf) void BeginCountPerfCounter(LARGE_INTEGER * pbeginTime64,BOOL fComputeTimeQueryPerf)
{ {

21
contrib/testzlib/testzlib.sln
View File

@@ -1,21 +0,0 @@
Microsoft Visual Studio Solution File, Format Version 7.00
Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "testzlib", "testzlib.vcproj", "{AA6666AA-E09F-4135-9C0C-4FE50C3C654B}"
EndProject
Global
GlobalSection(SolutionConfiguration) = preSolution
ConfigName.0 = Debug
ConfigName.1 = Release
EndGlobalSection
GlobalSection(ProjectDependencies) = postSolution
EndGlobalSection
GlobalSection(ProjectConfiguration) = postSolution
{AA6666AA-E09F-4135-9C0C-4FE50C3C654B}.Debug.ActiveCfg = Debug|Win32
{AA6666AA-E09F-4135-9C0C-4FE50C3C654B}.Debug.Build.0 = Debug|Win32
{AA6666AA-E09F-4135-9C0C-4FE50C3C654B}.Release.ActiveCfg = Release|Win32
{AA6666AA-E09F-4135-9C0C-4FE50C3C654B}.Release.Build.0 = Release|Win32
EndGlobalSection
GlobalSection(ExtensibilityGlobals) = postSolution
EndGlobalSection
GlobalSection(ExtensibilityAddIns) = postSolution
EndGlobalSection
EndGlobal

32
contrib/testzlib/testzlib8.sln
View File

@@ -1,32 +0,0 @@

Microsoft Visual Studio Solution File, Format Version 9.00
# Visual Studio 2005
Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "testzlib8", "testzlib8.vcproj", "{AA6666AA-E09F-4135-9C0C-4FE50C3C654B}"
EndProject
Global
GlobalSection(SolutionConfigurationPlatforms) = preSolution
Debug|Win32 = Debug|Win32
Debug|Win64 (AMD64) = Debug|Win64 (AMD64)
Release|Win32 = Release|Win32
Release|Win64 (AMD64) = Release|Win64 (AMD64)
ReleaseAsm|Win32 = ReleaseAsm|Win32
ReleaseAsm|Win64 (AMD64) = ReleaseAsm|Win64 (AMD64)
EndGlobalSection
GlobalSection(ProjectConfigurationPlatforms) = postSolution
{AA6666AA-E09F-4135-9C0C-4FE50C3C654B}.Debug|Win32.ActiveCfg = Debug|Win32
{AA6666AA-E09F-4135-9C0C-4FE50C3C654B}.Debug|Win32.Build.0 = Debug|Win32
{AA6666AA-E09F-4135-9C0C-4FE50C3C654B}.Debug|Win64 (AMD64).ActiveCfg = Debug|Win64 (AMD64)
{AA6666AA-E09F-4135-9C0C-4FE50C3C654B}.Debug|Win64 (AMD64).Build.0 = Debug|Win64 (AMD64)
{AA6666AA-E09F-4135-9C0C-4FE50C3C654B}.Release|Win32.ActiveCfg = Release|Win32
{AA6666AA-E09F-4135-9C0C-4FE50C3C654B}.Release|Win32.Build.0 = Release|Win32
{AA6666AA-E09F-4135-9C0C-4FE50C3C654B}.Release|Win64 (AMD64).ActiveCfg = Release|Win64 (AMD64)
{AA6666AA-E09F-4135-9C0C-4FE50C3C654B}.Release|Win64 (AMD64).Build.0 = Release|Win64 (AMD64)
{AA6666AA-E09F-4135-9C0C-4FE50C3C654B}.ReleaseAsm|Win32.ActiveCfg = ReleaseAsm|Win32
{AA6666AA-E09F-4135-9C0C-4FE50C3C654B}.ReleaseAsm|Win32.Build.0 = ReleaseAsm|Win32
{AA6666AA-E09F-4135-9C0C-4FE50C3C654B}.ReleaseAsm|Win64 (AMD64).ActiveCfg = ReleaseAsm|Win64 (AMD64)
{AA6666AA-E09F-4135-9C0C-4FE50C3C654B}.ReleaseAsm|Win64 (AMD64).Build.0 = ReleaseAsm|Win64 (AMD64)
EndGlobalSection
GlobalSection(SolutionProperties) = preSolution
HideSolutionNode = FALSE
EndGlobalSection
EndGlobal

40
contrib/vstudio/readme.txt
View File

@@ -1,8 +1,8 @@
Building instructions for the DLL versions of Zlib 1.2.x Building instructions for the DLL versions of Zlib 1.2.3
======================================================= ========================================================
This directory contains projects that build zlib and minizip using This directory contains projects that build zlib and minizip using
Microsoft Visual C++ 7.0/7.1. Microsoft Visual C++ 7.0/7.1, and Visual C++ .
You don't need to build these projects yourself. You can download the You don't need to build these projects yourself. You can download the
binaries from: binaries from:
@@ -11,18 +11,36 @@ binaries from:
More information can be found at this site. More information can be found at this site.
Build instructions Build instructions for Visual Studio 7.x (32 bits)
------------------ --------------------------------------------------
- Unzip zlib*.zip and copy the files from contrib\vstudio\vc7, - Uncompress current zlib, including all contrib/* files
from contrib\vstudio\masmx86 and from contrib\minizip into the same
directory.
- Download the crtdll library from - Download the crtdll library from
http://www.winimage.com/zLibDll/crtdll.zip http://www.winimage.com/zLibDll/crtdll.zip
Unzip crtdll.zip to extract crtdll.lib. Unzip crtdll.zip to extract crtdll.lib on contrib\vstudio\vc7.
- If you are using x86, use the Release target. - Open contrib\vstudio\vc7\zlibvc.sln with Microsoft Visual C++ 7.x
- Open zlibvc.sln with Microsoft Visual C++ 7.0 or 7.1
(Visual Studio .Net 2002 or 2003). (Visual Studio .Net 2002 or 2003).
Build instructions for Visual Studio 2005 (32 bits or 64 bits)
--------------------------------------------------------------
- Uncompress current zlib, including all contrib/* files
- For 32 bits only: download the crtdll library from
http://www.winimage.com/zLibDll/crtdll.zip
Unzip crtdll.zip to extract crtdll.lib on contrib\vstudio\vc8.
- Open contrib\vstudio\vc8\zlibvc.sln with Microsoft Visual C++ 8.0
Build instructions for Visual Studio 2005 64 bits, PSDK compiler
----------------------------------------------------------------
at the time of writing this text file, Visual Studio 2005 (and
Microsoft Visual C++ 8.0) is on the beta 2 stage.
Using you can get the free 64 bits compiler from Platform SDK,
which is NOT a beta, and compile using the Visual studio 2005 IDE
see http://www.winimage.com/misc/sdk64onvs2005/ for instruction
- Uncompress current zlib, including all contrib/* files
- start Visual Studio 2005 from a platform SDK command prompt, using
the /useenv switch
- Open contrib\vstudio\vc8\zlibvc.sln with Microsoft Visual C++ 8.0
Important Important
--------- ---------

6
contrib/vstudio/vc7/miniunz.vcproj
View File

@@ -19,6 +19,7 @@
<Tool <Tool
Name="VCCLCompilerTool" Name="VCCLCompilerTool"
Optimization="0" Optimization="0"
AdditionalIncludeDirectories="..\..\..;..\..\minizip"
PreprocessorDefinitions="WIN32;ZLIB_WINAPI;_DEBUG;_CONSOLE" PreprocessorDefinitions="WIN32;ZLIB_WINAPI;_DEBUG;_CONSOLE"
MinimalRebuild="TRUE" MinimalRebuild="TRUE"
BasicRuntimeChecks="3" BasicRuntimeChecks="3"
@@ -63,6 +64,7 @@
Optimization="2" Optimization="2"
InlineFunctionExpansion="1" InlineFunctionExpansion="1"
OmitFramePointers="TRUE" OmitFramePointers="TRUE"
AdditionalIncludeDirectories="..\..\..;..\..\minizip"
PreprocessorDefinitions="WIN32;ZLIB_WINAPI;NDEBUG;_CONSOLE" PreprocessorDefinitions="WIN32;ZLIB_WINAPI;NDEBUG;_CONSOLE"
StringPooling="TRUE" StringPooling="TRUE"
RuntimeLibrary="4" RuntimeLibrary="4"
@@ -104,7 +106,7 @@
Name="Source Files" Name="Source Files"
Filter="cpp;c;cxx;def;odl;idl;hpj;bat;asm"> Filter="cpp;c;cxx;def;odl;idl;hpj;bat;asm">
<File <File
RelativePath="miniunz.c"> RelativePath="..\..\minizip\miniunz.c">
</File> </File>
</Filter> </Filter>
<Filter <Filter
@@ -116,7 +118,7 @@
Filter="rc;ico;cur;bmp;dlg;rc2;rct;bin;rgs;gif;jpg;jpeg;jpe"> Filter="rc;ico;cur;bmp;dlg;rc2;rct;bin;rgs;gif;jpg;jpeg;jpe">
</Filter> </Filter>
<File <File
RelativePath="zlibwapi.lib"> RelativePath="ReleaseDll\zlibwapi.lib">
</File> </File>
</Files> </Files>
<Globals> <Globals>

6
contrib/vstudio/vc7/minizip.vcproj
View File

@@ -19,6 +19,7 @@
<Tool <Tool
Name="VCCLCompilerTool" Name="VCCLCompilerTool"
Optimization="0" Optimization="0"
AdditionalIncludeDirectories="..\..\..;..\..\minizip"
PreprocessorDefinitions="WIN32;ZLIB_WINAPI;_DEBUG;_CONSOLE" PreprocessorDefinitions="WIN32;ZLIB_WINAPI;_DEBUG;_CONSOLE"
MinimalRebuild="TRUE" MinimalRebuild="TRUE"
BasicRuntimeChecks="3" BasicRuntimeChecks="3"
@@ -63,6 +64,7 @@
Optimization="2" Optimization="2"
InlineFunctionExpansion="1" InlineFunctionExpansion="1"
OmitFramePointers="TRUE" OmitFramePointers="TRUE"
AdditionalIncludeDirectories="..\..\..;..\..\minizip"
PreprocessorDefinitions="WIN32;ZLIB_WINAPI;NDEBUG;_CONSOLE" PreprocessorDefinitions="WIN32;ZLIB_WINAPI;NDEBUG;_CONSOLE"
StringPooling="TRUE" StringPooling="TRUE"
RuntimeLibrary="4" RuntimeLibrary="4"
@@ -104,7 +106,7 @@
Name="Source Files" Name="Source Files"
Filter="cpp;c;cxx;def;odl;idl;hpj;bat;asm"> Filter="cpp;c;cxx;def;odl;idl;hpj;bat;asm">
<File <File
RelativePath="minizip.c"> RelativePath="..\..\minizip\minizip.c">
</File> </File>
</Filter> </Filter>
<Filter <Filter
@@ -116,7 +118,7 @@
Filter="rc;ico;cur;bmp;dlg;rc2;rct;bin;rgs;gif;jpg;jpeg;jpe"> Filter="rc;ico;cur;bmp;dlg;rc2;rct;bin;rgs;gif;jpg;jpeg;jpe">
</Filter> </Filter>
<File <File
RelativePath="zlibwapi.lib"> RelativePath="ReleaseDll\zlibwapi.lib">
</File> </File>
</Files> </Files>
<Globals> <Globals>

10
contrib/testzlib/testzlib.vcproj → contrib/vstudio/vc7/testzlib.vcproj
View File

@@ -2,8 +2,8 @@
<VisualStudioProject <VisualStudioProject
ProjectType="Visual C++" ProjectType="Visual C++"
Version="7.00" Version="7.00"
Name="testzlib" Name="testZlibDll"
ProjectGUID="{AA6666AA-E09F-4135-9C0C-4FE50C3C654B}" ProjectGUID="{AA6666AA-E09F-4135-9C0C-4FE50C3C654C}"
Keyword="Win32Proj"> Keyword="Win32Proj">
<Platforms> <Platforms>
<Platform <Platform
@@ -19,6 +19,7 @@
<Tool <Tool
Name="VCCLCompilerTool" Name="VCCLCompilerTool"
Optimization="0" Optimization="0"
AdditionalIncludeDirectories="..\..\.."
PreprocessorDefinitions="WIN32;ZLIB_WINAPI;_DEBUG;_CONSOLE" PreprocessorDefinitions="WIN32;ZLIB_WINAPI;_DEBUG;_CONSOLE"
MinimalRebuild="TRUE" MinimalRebuild="TRUE"
BasicRuntimeChecks="3" BasicRuntimeChecks="3"
@@ -63,6 +64,7 @@
Optimization="2" Optimization="2"
InlineFunctionExpansion="1" InlineFunctionExpansion="1"
OmitFramePointers="TRUE" OmitFramePointers="TRUE"
AdditionalIncludeDirectories="..\..\.."
PreprocessorDefinitions="WIN32;ZLIB_WINAPI;NDEBUG;_CONSOLE" PreprocessorDefinitions="WIN32;ZLIB_WINAPI;NDEBUG;_CONSOLE"
StringPooling="TRUE" StringPooling="TRUE"
RuntimeLibrary="4" RuntimeLibrary="4"
@@ -104,7 +106,7 @@
Name="Source Files" Name="Source Files"
Filter="cpp;c;cxx;def;odl;idl;hpj;bat;asm"> Filter="cpp;c;cxx;def;odl;idl;hpj;bat;asm">
<File <File
RelativePath="testzlib.c"> RelativePath="..\..\testzlib\testzlib.c">
</File> </File>
</Filter> </Filter>
<Filter <Filter
@@ -116,7 +118,7 @@
Filter="rc;ico;cur;bmp;dlg;rc2;rct;bin;rgs;gif;jpg;jpeg;jpe"> Filter="rc;ico;cur;bmp;dlg;rc2;rct;bin;rgs;gif;jpg;jpeg;jpe">
</Filter> </Filter>
<File <File
RelativePath="zlibwapi.lib"> RelativePath="ReleaseDll\zlibwapi.lib">
</File> </File>
</Files> </Files>
<Globals> <Globals>

6
contrib/vstudio/vc7/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,2,2,4 FILEVERSION 1,2,3,0
PRODUCTVERSION 1,2,2,4 PRODUCTVERSION 1,2,3,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.2.2.4\0" VALUE "FileVersion", "1.2.3.0\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"

38
contrib/vstudio/vc7/zlibstat.vcproj
View File

@@ -20,6 +20,7 @@
<Tool <Tool
Name="VCCLCompilerTool" Name="VCCLCompilerTool"
Optimization="0" Optimization="0"
AdditionalIncludeDirectories="..\..\..;..\..\masmx86"
PreprocessorDefinitions="WIN32;ZLIB_WINAPI" PreprocessorDefinitions="WIN32;ZLIB_WINAPI"
ExceptionHandling="FALSE" ExceptionHandling="FALSE"
RuntimeLibrary="5" RuntimeLibrary="5"
@@ -61,6 +62,7 @@
<Tool <Tool
Name="VCCLCompilerTool" Name="VCCLCompilerTool"
InlineFunctionExpansion="1" InlineFunctionExpansion="1"
AdditionalIncludeDirectories="..\..\..;..\..\masmx86"
PreprocessorDefinitions="WIN32;ZLIB_WINAPI" PreprocessorDefinitions="WIN32;ZLIB_WINAPI"
StringPooling="TRUE" StringPooling="TRUE"
ExceptionHandling="FALSE" ExceptionHandling="FALSE"
@@ -102,6 +104,7 @@
<Tool <Tool
Name="VCCLCompilerTool" Name="VCCLCompilerTool"
InlineFunctionExpansion="1" InlineFunctionExpansion="1"
AdditionalIncludeDirectories="..\..\..;..\..\masmx86"
PreprocessorDefinitions="WIN32;ZLIB_WINAPI;ASMV;ASMINF" PreprocessorDefinitions="WIN32;ZLIB_WINAPI;ASMV;ASMINF"
StringPooling="TRUE" StringPooling="TRUE"
ExceptionHandling="FALSE" ExceptionHandling="FALSE"
@@ -117,7 +120,7 @@
Name="VCCustomBuildTool"/> Name="VCCustomBuildTool"/>
<Tool <Tool
Name="VCLibrarianTool" Name="VCLibrarianTool"
AdditionalOptions="gvmat32.obj inffas32.obj /NODEFAULTLIB " AdditionalOptions="..\..\masmx86\gvmat32.obj ..\..\masmx86\inffas32.obj /NODEFAULTLIB "
OutputFile=".\zlibstat\zlibstat.lib" OutputFile=".\zlibstat\zlibstat.lib"
SuppressStartupBanner="TRUE"/> SuppressStartupBanner="TRUE"/>
<Tool <Tool
@@ -144,6 +147,7 @@
<Tool <Tool
Name="VCCLCompilerTool" Name="VCCLCompilerTool"
InlineFunctionExpansion="1" InlineFunctionExpansion="1"
AdditionalIncludeDirectories="..\..\..;..\..\masmx86"
PreprocessorDefinitions="WIN32;ZLIB_WINAPI" PreprocessorDefinitions="WIN32;ZLIB_WINAPI"
StringPooling="TRUE" StringPooling="TRUE"
ExceptionHandling="FALSE" ExceptionHandling="FALSE"
@@ -182,49 +186,49 @@
Name="Source Files" Name="Source Files"
Filter=""> Filter="">
<File <File
RelativePath=".\adler32.c"> RelativePath="..\..\..\adler32.c">
</File> </File>
<File <File
RelativePath=".\compress.c"> RelativePath="..\..\..\compress.c">
</File> </File>
<File <File
RelativePath=".\crc32.c"> RelativePath="..\..\..\crc32.c">
</File> </File>
<File <File
RelativePath=".\deflate.c"> RelativePath="..\..\..\deflate.c">
</File> </File>
<File <File
RelativePath=".\gvmat32c.c"> RelativePath="..\..\masmx86\gvmat32c.c">
</File> </File>
<File <File
RelativePath=".\gzio.c"> RelativePath="..\..\..\gzio.c">
</File> </File>
<File <File
RelativePath=".\infback.c"> RelativePath="..\..\..\infback.c">
</File> </File>
<File <File
RelativePath=".\inffast.c"> RelativePath="..\..\..\inffast.c">
</File> </File>
<File <File
RelativePath=".\inflate.c"> RelativePath="..\..\..\inflate.c">
</File> </File>
<File <File
RelativePath=".\inftrees.c"> RelativePath="..\..\..\inftrees.c">
</File> </File>
<File <File
RelativePath=".\ioapi.c"> RelativePath="..\..\minizip\ioapi.c">
</File> </File>
<File <File
RelativePath=".\trees.c"> RelativePath="..\..\..\trees.c">
</File> </File>
<File <File
RelativePath=".\uncompr.c"> RelativePath="..\..\..\uncompr.c">
</File> </File>
<File <File
RelativePath=".\unzip.c"> RelativePath="..\..\minizip\unzip.c">
</File> </File>
<File <File
RelativePath=".\zip.c"> RelativePath="..\..\minizip\zip.c">
</File> </File>
<File <File
RelativePath=".\zlib.rc"> RelativePath=".\zlib.rc">
@@ -233,7 +237,7 @@
RelativePath=".\zlibvc.def"> RelativePath=".\zlibvc.def">
</File> </File>
<File <File
RelativePath=".\zutil.c"> RelativePath="..\..\..\zutil.c">
</File> </File>
</Filter> </Filter>
</Files> </Files>

4
contrib/vstudio/vc7/zlibvc.def
View File

@@ -1,5 +1,5 @@
VERSION 1.21 VERSION 1.23
HEAPSIZE 1048576,8192 HEAPSIZE 1048576,8192
@@ -53,7 +53,7 @@ EXPORTS
deflateBound @47 deflateBound @47
gzclearerr @48 gzclearerr @48
gzungetc @49 gzungetc @49
zlibCompileFlags @50 zlibCompileFlags @50
deflatePrime @51 deflatePrime @51
unzOpen @61 unzOpen @61

12
contrib/vstudio/vc7/zlibvc.sln
View File

@@ -7,6 +7,8 @@ Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "minizip", "minizip.vcproj",
EndProject EndProject
Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "miniunz", "miniunz.vcproj", "{C52F9E7B-498A-42BE-8DB4-85A15694382A}" Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "miniunz", "miniunz.vcproj", "{C52F9E7B-498A-42BE-8DB4-85A15694382A}"
EndProject EndProject
Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "testZlibDll", "testzlib.vcproj", "{AA6666AA-E09F-4135-9C0C-4FE50C3C654C}"
EndProject
Global Global
GlobalSection(SolutionConfiguration) = preSolution GlobalSection(SolutionConfiguration) = preSolution
ConfigName.0 = Debug ConfigName.0 = Debug
@@ -58,6 +60,16 @@ Global
{C52F9E7B-498A-42BE-8DB4-85A15694382A}.ReleaseWithoutAsm.Build.0 = Release|Win32 {C52F9E7B-498A-42BE-8DB4-85A15694382A}.ReleaseWithoutAsm.Build.0 = Release|Win32
{C52F9E7B-498A-42BE-8DB4-85A15694382A}.ReleaseWithoutCrtdll.ActiveCfg = Release|Win32 {C52F9E7B-498A-42BE-8DB4-85A15694382A}.ReleaseWithoutCrtdll.ActiveCfg = Release|Win32
{C52F9E7B-498A-42BE-8DB4-85A15694382A}.ReleaseWithoutCrtdll.Build.0 = Release|Win32 {C52F9E7B-498A-42BE-8DB4-85A15694382A}.ReleaseWithoutCrtdll.Build.0 = Release|Win32
{AA6666AA-E09F-4135-9C0C-4FE50C3C654C}.Debug.ActiveCfg = Debug|Win32
{AA6666AA-E09F-4135-9C0C-4FE50C3C654C}.Debug.Build.0 = Debug|Win32
{AA6666AA-E09F-4135-9C0C-4FE50C3C654C}.Release.ActiveCfg = Release|Win32
{AA6666AA-E09F-4135-9C0C-4FE50C3C654C}.Release.Build.0 = Release|Win32
{AA6666AA-E09F-4135-9C0C-4FE50C3C654C}.ReleaseAxp.ActiveCfg = Release|Win32
{AA6666AA-E09F-4135-9C0C-4FE50C3C654C}.ReleaseAxp.Build.0 = Release|Win32
{AA6666AA-E09F-4135-9C0C-4FE50C3C654C}.ReleaseWithoutAsm.ActiveCfg = Release|Win32
{AA6666AA-E09F-4135-9C0C-4FE50C3C654C}.ReleaseWithoutAsm.Build.0 = Release|Win32
{AA6666AA-E09F-4135-9C0C-4FE50C3C654C}.ReleaseWithoutCrtdll.ActiveCfg = Release|Win32
{AA6666AA-E09F-4135-9C0C-4FE50C3C654C}.ReleaseWithoutCrtdll.Build.0 = Release|Win32
EndGlobalSection EndGlobalSection
GlobalSection(ExtensibilityGlobals) = postSolution GlobalSection(ExtensibilityGlobals) = postSolution
EndGlobalSection EndGlobalSection

75
contrib/vstudio/vc7/zlibvc.vcproj
View File

@@ -20,6 +20,7 @@
<Tool <Tool
Name="VCCLCompilerTool" Name="VCCLCompilerTool"
Optimization="0" Optimization="0"
AdditionalIncludeDirectories="..\..\..;..\..\masmx86"
PreprocessorDefinitions="WIN32,ZLIB_WINAPI,ASMV,ASMINF" PreprocessorDefinitions="WIN32,ZLIB_WINAPI,ASMV,ASMINF"
ExceptionHandling="FALSE" ExceptionHandling="FALSE"
RuntimeLibrary="1" RuntimeLibrary="1"
@@ -35,7 +36,7 @@
<Tool <Tool
Name="VCLinkerTool" Name="VCLinkerTool"
AdditionalOptions="/MACHINE:I386" AdditionalOptions="/MACHINE:I386"
AdditionalDependencies="gvmat32.obj inffas32.obj" AdditionalDependencies="..\..\masmx86\gvmat32.obj ..\..\masmx86\inffas32.obj"
OutputFile=".\DebugDll\zlibwapi.dll" OutputFile=".\DebugDll\zlibwapi.dll"
LinkIncremental="2" LinkIncremental="2"
SuppressStartupBanner="TRUE" SuppressStartupBanner="TRUE"
@@ -72,10 +73,12 @@
IntermediateDirectory=".\zlibDllWithoutAsm" IntermediateDirectory=".\zlibDllWithoutAsm"
ConfigurationType="2" ConfigurationType="2"
UseOfMFC="0" UseOfMFC="0"
ATLMinimizesCRunTimeLibraryUsage="FALSE"> ATLMinimizesCRunTimeLibraryUsage="FALSE"
WholeProgramOptimization="TRUE">
<Tool <Tool
Name="VCCLCompilerTool" Name="VCCLCompilerTool"
InlineFunctionExpansion="1" InlineFunctionExpansion="1"
AdditionalIncludeDirectories="..\..\..;..\..\masmx86"
PreprocessorDefinitions="WIN32,ZLIB_WINAPI" PreprocessorDefinitions="WIN32,ZLIB_WINAPI"
StringPooling="TRUE" StringPooling="TRUE"
ExceptionHandling="FALSE" ExceptionHandling="FALSE"
@@ -134,10 +137,12 @@
IntermediateDirectory=".\zlibDllWithoutCrtDll" IntermediateDirectory=".\zlibDllWithoutCrtDll"
ConfigurationType="2" ConfigurationType="2"
UseOfMFC="0" UseOfMFC="0"
ATLMinimizesCRunTimeLibraryUsage="FALSE"> ATLMinimizesCRunTimeLibraryUsage="FALSE"
WholeProgramOptimization="TRUE">
<Tool <Tool
Name="VCCLCompilerTool" Name="VCCLCompilerTool"
InlineFunctionExpansion="1" InlineFunctionExpansion="1"
AdditionalIncludeDirectories="..\..\..;..\..\masmx86"
PreprocessorDefinitions="WIN32,ZLIB_WINAPI,ASMV,ASMINF" PreprocessorDefinitions="WIN32,ZLIB_WINAPI,ASMV,ASMINF"
StringPooling="TRUE" StringPooling="TRUE"
ExceptionHandling="FALSE" ExceptionHandling="FALSE"
@@ -156,7 +161,7 @@
<Tool <Tool
Name="VCLinkerTool" Name="VCLinkerTool"
AdditionalOptions="/MACHINE:I386" AdditionalOptions="/MACHINE:I386"
AdditionalDependencies="gvmat32.obj inffas32.obj " AdditionalDependencies="..\..\masmx86\gvmat32.obj ..\..\masmx86\inffas32.obj "
OutputFile=".\zlibDllWithoutCrtDll\zlibwapi.dll" OutputFile=".\zlibDllWithoutCrtDll\zlibwapi.dll"
LinkIncremental="1" LinkIncremental="1"
SuppressStartupBanner="TRUE" SuppressStartupBanner="TRUE"
@@ -196,10 +201,12 @@
IntermediateDirectory=".\zlibvc__" IntermediateDirectory=".\zlibvc__"
ConfigurationType="2" ConfigurationType="2"
UseOfMFC="0" UseOfMFC="0"
ATLMinimizesCRunTimeLibraryUsage="FALSE"> ATLMinimizesCRunTimeLibraryUsage="FALSE"
WholeProgramOptimization="TRUE">
<Tool <Tool
Name="VCCLCompilerTool" Name="VCCLCompilerTool"
InlineFunctionExpansion="1" InlineFunctionExpansion="1"
AdditionalIncludeDirectories="..\..\..;..\..\masmx86"
PreprocessorDefinitions="WIN32,ZLIB_WINAPI" PreprocessorDefinitions="WIN32,ZLIB_WINAPI"
StringPooling="TRUE" StringPooling="TRUE"
ExceptionHandling="FALSE" ExceptionHandling="FALSE"
@@ -256,10 +263,12 @@
IntermediateDirectory=".\ReleaseDll" IntermediateDirectory=".\ReleaseDll"
ConfigurationType="2" ConfigurationType="2"
UseOfMFC="0" UseOfMFC="0"
ATLMinimizesCRunTimeLibraryUsage="FALSE"> ATLMinimizesCRunTimeLibraryUsage="FALSE"
WholeProgramOptimization="TRUE">
<Tool <Tool
Name="VCCLCompilerTool" Name="VCCLCompilerTool"
InlineFunctionExpansion="1" InlineFunctionExpansion="1"
AdditionalIncludeDirectories="..\..\..;..\..\masmx86"
PreprocessorDefinitions="WIN32,ZLIB_WINAPI,ASMV,ASMINF" PreprocessorDefinitions="WIN32,ZLIB_WINAPI,ASMV,ASMINF"
StringPooling="TRUE" StringPooling="TRUE"
ExceptionHandling="FALSE" ExceptionHandling="FALSE"
@@ -278,7 +287,7 @@
<Tool <Tool
Name="VCLinkerTool" Name="VCLinkerTool"
AdditionalOptions="/MACHINE:I386" AdditionalOptions="/MACHINE:I386"
AdditionalDependencies="gvmat32.obj inffas32.obj crtdll.lib" AdditionalDependencies="..\..\masmx86\gvmat32.obj ..\..\masmx86\inffas32.obj crtdll.lib"
OutputFile=".\ReleaseDll\zlibwapi.dll" OutputFile=".\ReleaseDll\zlibwapi.dll"
LinkIncremental="1" LinkIncremental="1"
SuppressStartupBanner="TRUE" SuppressStartupBanner="TRUE"
@@ -318,19 +327,19 @@
Name="Source Files" Name="Source Files"
Filter="cpp;c;cxx;rc;def;r;odl;hpj;bat;for;f90"> Filter="cpp;c;cxx;rc;def;r;odl;hpj;bat;for;f90">
<File <File
RelativePath=".\adler32.c"> RelativePath="..\..\..\adler32.c">
</File> </File>
<File <File
RelativePath=".\compress.c"> RelativePath="..\..\..\compress.c">
</File> </File>
<File <File
RelativePath=".\crc32.c"> RelativePath="..\..\..\crc32.c">
</File> </File>
<File <File
RelativePath=".\deflate.c"> RelativePath="..\..\..\deflate.c">
</File> </File>
<File <File
RelativePath=".\gvmat32c.c"> RelativePath="..\..\masmx86\gvmat32c.c">
<FileConfiguration <FileConfiguration
Name="ReleaseWithoutAsm|Win32" Name="ReleaseWithoutAsm|Win32"
ExcludedFromBuild="TRUE"> ExcludedFromBuild="TRUE">
@@ -339,34 +348,34 @@
</FileConfiguration> </FileConfiguration>
</File> </File>
<File <File
RelativePath=".\gzio.c"> RelativePath="..\..\..\gzio.c">
</File> </File>
<File <File
RelativePath=".\infback.c"> RelativePath="..\..\..\infback.c">
</File> </File>
<File <File
RelativePath=".\inffast.c"> RelativePath="..\..\..\inffast.c">
</File> </File>
<File <File
RelativePath=".\inflate.c"> RelativePath="..\..\..\inflate.c">
</File> </File>
<File <File
RelativePath=".\inftrees.c"> RelativePath="..\..\..\inftrees.c">
</File> </File>
<File <File
RelativePath=".\ioapi.c"> RelativePath="..\..\minizip\ioapi.c">
</File> </File>
<File <File
RelativePath=".\iowin32.c"> RelativePath="..\..\minizip\iowin32.c">
</File> </File>
<File <File
RelativePath=".\trees.c"> RelativePath="..\..\..\trees.c">
</File> </File>
<File <File
RelativePath=".\uncompr.c"> RelativePath="..\..\..\uncompr.c">
</File> </File>
<File <File
RelativePath=".\unzip.c"> RelativePath="..\..\minizip\unzip.c">
<FileConfiguration <FileConfiguration
Name="Release|Win32"> Name="Release|Win32">
<Tool <Tool
@@ -376,7 +385,7 @@
</FileConfiguration> </FileConfiguration>
</File> </File>
<File <File
RelativePath=".\zip.c"> RelativePath="..\..\minizip\zip.c">
<FileConfiguration <FileConfiguration
Name="Release|Win32"> Name="Release|Win32">
<Tool <Tool
@@ -392,38 +401,38 @@
RelativePath=".\zlibvc.def"> RelativePath=".\zlibvc.def">
</File> </File>
<File <File
RelativePath=".\zutil.c"> RelativePath="..\..\..\zutil.c">
</File> </File>
</Filter> </Filter>
<Filter <Filter
Name="Header Files" Name="Header Files"
Filter="h;hpp;hxx;hm;inl;fi;fd"> Filter="h;hpp;hxx;hm;inl;fi;fd">
<File <File
RelativePath=".\deflate.h"> RelativePath="..\..\..\deflate.h">
</File> </File>
<File <File
RelativePath=".\infblock.h"> RelativePath="..\..\..\infblock.h">
</File> </File>
<File <File
RelativePath=".\infcodes.h"> RelativePath="..\..\..\infcodes.h">
</File> </File>
<File <File
RelativePath=".\inffast.h"> RelativePath="..\..\..\inffast.h">
</File> </File>
<File <File
RelativePath=".\inftrees.h"> RelativePath="..\..\..\inftrees.h">
</File> </File>
<File <File
RelativePath=".\infutil.h"> RelativePath="..\..\..\infutil.h">
</File> </File>
<File <File
RelativePath=".\zconf.h"> RelativePath="..\..\..\zconf.h">
</File> </File>
<File <File
RelativePath=".\zlib.h"> RelativePath="..\..\..\zlib.h">
</File> </File>
<File <File
RelativePath=".\zutil.h"> RelativePath="..\..\..\zutil.h">
</File> </File>
</Filter> </Filter>
<Filter <Filter

566
contrib/vstudio/vc8/miniunz.vcproj Normal file
View File

@@ -0,0 +1,566 @@
<?xml version="1.0" encoding="Windows-1252"?>
<VisualStudioProject
ProjectType="Visual C++"
Version="8,00"
Name="miniunz"
ProjectGUID="{C52F9E7B-498A-42BE-8DB4-85A15694382A}"
Keyword="Win32Proj"
>
<Platforms>
<Platform
Name="Win32"
/>
<Platform
Name="x64"
/>
<Platform
Name="Itanium"
/>
</Platforms>
<ToolFiles>
</ToolFiles>
<Configurations>
<Configuration
Name="Debug|Win32"
OutputDirectory="x86\MiniUnzip$(ConfigurationName)"
IntermediateDirectory="x86\MiniUnzip$(ConfigurationName)\Tmp"
ConfigurationType="1"
InheritedPropertySheets="UpgradeFromVC70.vsprops"
CharacterSet="2"
>
<Tool
Name="VCPreBuildEventTool"
/>
<Tool
Name="VCCustomBuildTool"
/>
<Tool
Name="VCXMLDataGeneratorTool"
/>
<Tool
Name="VCWebServiceProxyGeneratorTool"
/>
<Tool
Name="VCMIDLTool"
/>
<Tool
Name="VCCLCompilerTool"
Optimization="0"
AdditionalIncludeDirectories="..\..\..;..\..\minizip"
PreprocessorDefinitions="WIN32;_CRT_NONSTDC_NO_DEPRECATE;_CRT_SECURE_NO_DEPRECATE;ZLIB_WINAPI;_DEBUG;_CONSOLE"
MinimalRebuild="true"
BasicRuntimeChecks="0"
RuntimeLibrary="1"
BufferSecurityCheck="false"
UsePrecompiledHeader="0"
AssemblerListingLocation="$(IntDir)\"
WarningLevel="3"
Detect64BitPortabilityProblems="true"
DebugInformationFormat="4"
/>
<Tool
Name="VCManagedResourceCompilerTool"
/>
<Tool
Name="VCResourceCompilerTool"
/>
<Tool
Name="VCPreLinkEventTool"
/>
<Tool
Name="VCLinkerTool"
AdditionalDependencies="x86\ZlibDllDebug\zlibwapi.lib"
OutputFile="$(OutDir)/miniunz.exe"
LinkIncremental="2"
GenerateManifest="false"
GenerateDebugInformation="true"
ProgramDatabaseFile="$(OutDir)/miniunz.pdb"
SubSystem="1"
TargetMachine="1"
/>
<Tool
Name="VCALinkTool"
/>
<Tool
Name="VCManifestTool"
/>
<Tool
Name="VCXDCMakeTool"
/>
<Tool
Name="VCBscMakeTool"
/>
<Tool
Name="VCFxCopTool"
/>
<Tool
Name="VCAppVerifierTool"
/>
<Tool
Name="VCWebDeploymentTool"
/>
<Tool
Name="VCPostBuildEventTool"
/>
</Configuration>
<Configuration
Name="Debug|x64"
OutputDirectory="x64\MiniUnzip$(ConfigurationName)"
IntermediateDirectory="x64\MiniUnzip$(ConfigurationName)\Tmp"
ConfigurationType="1"
InheritedPropertySheets="UpgradeFromVC70.vsprops"
CharacterSet="2"
>
<Tool
Name="VCPreBuildEventTool"
/>
<Tool
Name="VCCustomBuildTool"
/>
<Tool
Name="VCXMLDataGeneratorTool"
/>
<Tool
Name="VCWebServiceProxyGeneratorTool"
/>
<Tool
Name="VCMIDLTool"
TargetEnvironment="3"
/>
<Tool
Name="VCCLCompilerTool"
Optimization="0"
AdditionalIncludeDirectories="..\..\..;..\..\minizip"
PreprocessorDefinitions="_CRT_NONSTDC_NO_DEPRECATE;_CRT_SECURE_NO_DEPRECATE;ZLIB_WINAPI;_DEBUG;_CONSOLE;WIN64"
MinimalRebuild="true"
BasicRuntimeChecks="0"
RuntimeLibrary="3"
BufferSecurityCheck="false"
UsePrecompiledHeader="0"
AssemblerListingLocation="$(IntDir)\"
WarningLevel="3"
Detect64BitPortabilityProblems="true"
DebugInformationFormat="3"
/>
<Tool
Name="VCManagedResourceCompilerTool"
/>
<Tool
Name="VCResourceCompilerTool"
/>
<Tool
Name="VCPreLinkEventTool"
/>
<Tool
Name="VCLinkerTool"
AdditionalDependencies="x64\ZlibDllDebug\zlibwapi.lib"
OutputFile="$(OutDir)/miniunz.exe"
LinkIncremental="2"
GenerateManifest="false"
GenerateDebugInformation="true"
ProgramDatabaseFile="$(OutDir)/miniunz.pdb"
SubSystem="1"
TargetMachine="17"
/>
<Tool
Name="VCALinkTool"
/>
<Tool
Name="VCManifestTool"
/>
<Tool
Name="VCXDCMakeTool"
/>
<Tool
Name="VCBscMakeTool"
/>
<Tool
Name="VCFxCopTool"
/>
<Tool
Name="VCAppVerifierTool"
/>
<Tool
Name="VCWebDeploymentTool"
/>
<Tool
Name="VCPostBuildEventTool"
/>
</Configuration>
<Configuration
Name="Debug|Itanium"
OutputDirectory="ia64\MiniUnzip$(ConfigurationName)"
IntermediateDirectory="ia64\MiniUnzip$(ConfigurationName)\Tmp"
ConfigurationType="1"
InheritedPropertySheets="UpgradeFromVC70.vsprops"
CharacterSet="2"
>
<Tool
Name="VCPreBuildEventTool"
/>
<Tool
Name="VCCustomBuildTool"
/>
<Tool
Name="VCXMLDataGeneratorTool"
/>
<Tool
Name="VCWebServiceProxyGeneratorTool"
/>
<Tool
Name="VCMIDLTool"
TargetEnvironment="2"
/>
<Tool
Name="VCCLCompilerTool"
Optimization="0"
AdditionalIncludeDirectories="..\..\..;..\..\minizip"
PreprocessorDefinitions="_CRT_NONSTDC_NO_DEPRECATE;_CRT_SECURE_NO_DEPRECATE;ZLIB_WINAPI;_DEBUG;_CONSOLE;WIN64"
MinimalRebuild="true"
BasicRuntimeChecks="0"
RuntimeLibrary="3"
BufferSecurityCheck="false"
UsePrecompiledHeader="0"
AssemblerListingLocation="$(IntDir)\"
WarningLevel="3"
Detect64BitPortabilityProblems="true"
DebugInformationFormat="3"
/>
<Tool
Name="VCManagedResourceCompilerTool"
/>
<Tool
Name="VCResourceCompilerTool"
/>
<Tool
Name="VCPreLinkEventTool"
/>
<Tool
Name="VCLinkerTool"
AdditionalDependencies="ia64\ZlibDllDebug\zlibwapi.lib"
OutputFile="$(OutDir)/miniunz.exe"
LinkIncremental="2"
GenerateManifest="false"
GenerateDebugInformation="true"
ProgramDatabaseFile="$(OutDir)/miniunz.pdb"
SubSystem="1"
TargetMachine="5"
/>
<Tool
Name="VCALinkTool"
/>
<Tool
Name="VCManifestTool"
/>
<Tool
Name="VCXDCMakeTool"
/>
<Tool
Name="VCBscMakeTool"
/>
<Tool
Name="VCFxCopTool"
/>
<Tool
Name="VCAppVerifierTool"
/>
<Tool
Name="VCWebDeploymentTool"
/>
<Tool
Name="VCPostBuildEventTool"
/>
</Configuration>
<Configuration
Name="Release|Win32"
OutputDirectory="x86\MiniUnzip$(ConfigurationName)"
IntermediateDirectory="x86\MiniUnzip$(ConfigurationName)\Tmp"
ConfigurationType="1"
InheritedPropertySheets="UpgradeFromVC70.vsprops"
CharacterSet="2"
>
<Tool
Name="VCPreBuildEventTool"
/>
<Tool
Name="VCCustomBuildTool"
/>
<Tool
Name="VCXMLDataGeneratorTool"
/>
<Tool
Name="VCWebServiceProxyGeneratorTool"
/>
<Tool
Name="VCMIDLTool"
/>
<Tool
Name="VCCLCompilerTool"
Optimization="2"
InlineFunctionExpansion="1"
OmitFramePointers="true"
AdditionalIncludeDirectories="..\..\..;..\..\minizip"
PreprocessorDefinitions="WIN32;_CRT_NONSTDC_NO_DEPRECATE;_CRT_SECURE_NO_DEPRECATE;ZLIB_WINAPI;NDEBUG;_CONSOLE"
StringPooling="true"
BasicRuntimeChecks="0"
RuntimeLibrary="0"
BufferSecurityCheck="false"
EnableFunctionLevelLinking="true"
UsePrecompiledHeader="0"
AssemblerListingLocation="$(IntDir)\"
WarningLevel="3"
Detect64BitPortabilityProblems="true"
DebugInformationFormat="3"
/>
<Tool
Name="VCManagedResourceCompilerTool"
/>
<Tool
Name="VCResourceCompilerTool"
/>
<Tool
Name="VCPreLinkEventTool"
/>
<Tool
Name="VCLinkerTool"
AdditionalDependencies="x86\ZlibDllRelease\zlibwapi.lib"
OutputFile="$(OutDir)/miniunz.exe"
LinkIncremental="1"
GenerateManifest="false"
GenerateDebugInformation="true"
SubSystem="1"
OptimizeReferences="2"
EnableCOMDATFolding="2"
OptimizeForWindows98="1"
TargetMachine="1"
/>
<Tool
Name="VCALinkTool"
/>
<Tool
Name="VCManifestTool"
/>
<Tool
Name="VCXDCMakeTool"
/>
<Tool
Name="VCBscMakeTool"
/>
<Tool
Name="VCFxCopTool"
/>
<Tool
Name="VCAppVerifierTool"
/>
<Tool
Name="VCWebDeploymentTool"
/>
<Tool
Name="VCPostBuildEventTool"
/>
</Configuration>
<Configuration
Name="Release|x64"
OutputDirectory="x64\MiniUnzip$(ConfigurationName)"
IntermediateDirectory="x64\MiniUnzip$(ConfigurationName)\Tmp"
ConfigurationType="1"
InheritedPropertySheets="UpgradeFromVC70.vsprops"
CharacterSet="2"
>
<Tool
Name="VCPreBuildEventTool"
/>
<Tool
Name="VCCustomBuildTool"
/>
<Tool
Name="VCXMLDataGeneratorTool"
/>
<Tool
Name="VCWebServiceProxyGeneratorTool"
/>
<Tool
Name="VCMIDLTool"
TargetEnvironment="3"
/>
<Tool
Name="VCCLCompilerTool"
Optimization="2"
InlineFunctionExpansion="1"
OmitFramePointers="true"
AdditionalIncludeDirectories="..\..\..;..\..\minizip"
PreprocessorDefinitions="_CRT_NONSTDC_NO_DEPRECATE;_CRT_SECURE_NO_DEPRECATE;ZLIB_WINAPI;NDEBUG;_CONSOLE;WIN64"
StringPooling="true"
BasicRuntimeChecks="0"
RuntimeLibrary="2"
BufferSecurityCheck="false"
EnableFunctionLevelLinking="true"
UsePrecompiledHeader="0"
AssemblerListingLocation="$(IntDir)\"
WarningLevel="3"
Detect64BitPortabilityProblems="true"
DebugInformationFormat="3"
/>
<Tool
Name="VCManagedResourceCompilerTool"
/>
<Tool
Name="VCResourceCompilerTool"
/>
<Tool
Name="VCPreLinkEventTool"
/>
<Tool
Name="VCLinkerTool"
AdditionalDependencies="x64\ZlibDllRelease\zlibwapi.lib"
OutputFile="$(OutDir)/miniunz.exe"
LinkIncremental="1"
GenerateManifest="false"
GenerateDebugInformation="true"
SubSystem="1"
OptimizeReferences="2"
EnableCOMDATFolding="2"
OptimizeForWindows98="1"
TargetMachine="17"
/>
<Tool
Name="VCALinkTool"
/>
<Tool
Name="VCManifestTool"
/>
<Tool
Name="VCXDCMakeTool"
/>
<Tool
Name="VCBscMakeTool"
/>
<Tool
Name="VCFxCopTool"
/>
<Tool
Name="VCAppVerifierTool"
/>
<Tool
Name="VCWebDeploymentTool"
/>
<Tool
Name="VCPostBuildEventTool"
/>
</Configuration>
<Configuration
Name="Release|Itanium"
OutputDirectory="ia64\MiniUnzip$(ConfigurationName)"
IntermediateDirectory="ia64\MiniUnzip$(ConfigurationName)\Tmp"
ConfigurationType="1"
InheritedPropertySheets="UpgradeFromVC70.vsprops"
CharacterSet="2"
>
<Tool
Name="VCPreBuildEventTool"
/>
<Tool
Name="VCCustomBuildTool"
/>
<Tool
Name="VCXMLDataGeneratorTool"
/>
<Tool
Name="VCWebServiceProxyGeneratorTool"
/>
<Tool
Name="VCMIDLTool"
TargetEnvironment="2"
/>
<Tool
Name="VCCLCompilerTool"
Optimization="2"
InlineFunctionExpansion="1"
OmitFramePointers="true"
AdditionalIncludeDirectories="..\..\..;..\..\minizip"
PreprocessorDefinitions="_CRT_NONSTDC_NO_DEPRECATE;_CRT_SECURE_NO_DEPRECATE;ZLIB_WINAPI;NDEBUG;_CONSOLE;WIN64"
StringPooling="true"
BasicRuntimeChecks="0"
RuntimeLibrary="2"
BufferSecurityCheck="false"
EnableFunctionLevelLinking="true"
UsePrecompiledHeader="0"
AssemblerListingLocation="$(IntDir)\"
WarningLevel="3"
Detect64BitPortabilityProblems="true"
DebugInformationFormat="3"
/>
<Tool
Name="VCManagedResourceCompilerTool"
/>
<Tool
Name="VCResourceCompilerTool"
/>
<Tool
Name="VCPreLinkEventTool"
/>
<Tool
Name="VCLinkerTool"
AdditionalDependencies="ia64\ZlibDllRelease\zlibwapi.lib"
OutputFile="$(OutDir)/miniunz.exe"
LinkIncremental="1"
GenerateManifest="false"
GenerateDebugInformation="true"
SubSystem="1"
OptimizeReferences="2"
EnableCOMDATFolding="2"
OptimizeForWindows98="1"
TargetMachine="5"
/>
<Tool
Name="VCALinkTool"
/>
<Tool
Name="VCManifestTool"
/>
<Tool
Name="VCXDCMakeTool"
/>
<Tool
Name="VCBscMakeTool"
/>
<Tool
Name="VCFxCopTool"
/>
<Tool
Name="VCAppVerifierTool"
/>
<Tool
Name="VCWebDeploymentTool"
/>
<Tool
Name="VCPostBuildEventTool"
/>
</Configuration>
</Configurations>
<References>
</References>
<Files>
<Filter
Name="Source Files"
Filter="cpp;c;cxx;def;odl;idl;hpj;bat;asm"
>
<File
RelativePath="..\..\minizip\miniunz.c"
>
</File>
</Filter>
<Filter
Name="Header Files"
Filter="h;hpp;hxx;hm;inl;inc"
>
</Filter>
<Filter
Name="Resource Files"
Filter="rc;ico;cur;bmp;dlg;rc2;rct;bin;rgs;gif;jpg;jpeg;jpe"
>
</Filter>
</Files>
<Globals>
</Globals>
</VisualStudioProject>

563
contrib/vstudio/vc8/minizip.vcproj Normal file
View File

@@ -0,0 +1,563 @@
<?xml version="1.0" encoding="Windows-1252"?>
<VisualStudioProject
ProjectType="Visual C++"
Version="8,00"
Name="minizip"
ProjectGUID="{48CDD9DC-E09F-4135-9C0C-4FE50C3C654B}"
Keyword="Win32Proj"
>
<Platforms>
<Platform
Name="Win32"
/>
<Platform
Name="x64"
/>
<Platform
Name="Itanium"
/>
</Platforms>
<ToolFiles>
</ToolFiles>
<Configurations>
<Configuration
Name="Debug|Win32"
OutputDirectory="x86\MiniZip$(ConfigurationName)"
IntermediateDirectory="x86\MiniZip$(ConfigurationName)\Tmp"
ConfigurationType="1"
InheritedPropertySheets="UpgradeFromVC70.vsprops"
CharacterSet="2"
>
<Tool
Name="VCPreBuildEventTool"
/>
<Tool
Name="VCCustomBuildTool"
/>
<Tool
Name="VCXMLDataGeneratorTool"
/>
<Tool
Name="VCWebServiceProxyGeneratorTool"
/>
<Tool
Name="VCMIDLTool"
/>
<Tool
Name="VCCLCompilerTool"
Optimization="0"
AdditionalIncludeDirectories="..\..\..;..\..\minizip"
PreprocessorDefinitions="WIN32;_CRT_NONSTDC_NO_DEPRECATE;_CRT_SECURE_NO_DEPRECATE;ZLIB_WINAPI;_DEBUG;_CONSOLE"
MinimalRebuild="true"
BasicRuntimeChecks="0"
RuntimeLibrary="1"
BufferSecurityCheck="false"
UsePrecompiledHeader="0"
AssemblerListingLocation="$(IntDir)\"
WarningLevel="3"
Detect64BitPortabilityProblems="true"
DebugInformationFormat="4"
/>
<Tool
Name="VCManagedResourceCompilerTool"
/>
<Tool
Name="VCResourceCompilerTool"
/>
<Tool
Name="VCPreLinkEventTool"
/>
<Tool
Name="VCLinkerTool"
AdditionalDependencies="x86\ZlibDllDebug\zlibwapi.lib"
OutputFile="$(OutDir)/minizip.exe"
LinkIncremental="2"
GenerateManifest="false"
GenerateDebugInformation="true"
ProgramDatabaseFile="$(OutDir)/minizip.pdb"
SubSystem="1"
TargetMachine="1"
/>
<Tool
Name="VCALinkTool"
/>
<Tool
Name="VCManifestTool"
/>
<Tool
Name="VCXDCMakeTool"
/>
<Tool
Name="VCBscMakeTool"
/>
<Tool
Name="VCFxCopTool"
/>
<Tool
Name="VCAppVerifierTool"
/>
<Tool
Name="VCWebDeploymentTool"
/>
<Tool
Name="VCPostBuildEventTool"
/>
</Configuration>
<Configuration
Name="Debug|x64"
OutputDirectory="x64\$(ConfigurationName)"
IntermediateDirectory="x64\$(ConfigurationName)"
ConfigurationType="1"
InheritedPropertySheets="UpgradeFromVC70.vsprops"
CharacterSet="2"
>
<Tool
Name="VCPreBuildEventTool"
/>
<Tool
Name="VCCustomBuildTool"
/>
<Tool
Name="VCXMLDataGeneratorTool"
/>
<Tool
Name="VCWebServiceProxyGeneratorTool"
/>
<Tool
Name="VCMIDLTool"
TargetEnvironment="3"
/>
<Tool
Name="VCCLCompilerTool"
Optimization="0"
AdditionalIncludeDirectories="..\..\..;..\..\minizip"
PreprocessorDefinitions="_CRT_NONSTDC_NO_DEPRECATE;_CRT_SECURE_NO_DEPRECATE;ZLIB_WINAPI;_DEBUG;_CONSOLE;WIN64"
MinimalRebuild="true"
BasicRuntimeChecks="0"
RuntimeLibrary="3"
BufferSecurityCheck="false"
UsePrecompiledHeader="0"
AssemblerListingLocation="$(IntDir)\"
WarningLevel="3"
Detect64BitPortabilityProblems="true"
DebugInformationFormat="3"
/>
<Tool
Name="VCManagedResourceCompilerTool"
/>
<Tool
Name="VCResourceCompilerTool"
/>
<Tool
Name="VCPreLinkEventTool"
/>
<Tool
Name="VCLinkerTool"
AdditionalDependencies="x64\ZlibDllDebug\zlibwapi.lib"
OutputFile="$(OutDir)/minizip.exe"
LinkIncremental="2"
GenerateManifest="false"
GenerateDebugInformation="true"
ProgramDatabaseFile="$(OutDir)/minizip.pdb"
SubSystem="1"
TargetMachine="17"
/>
<Tool
Name="VCALinkTool"
/>
<Tool
Name="VCManifestTool"
/>
<Tool
Name="VCXDCMakeTool"
/>
<Tool
Name="VCBscMakeTool"
/>
<Tool
Name="VCFxCopTool"
/>
<Tool
Name="VCAppVerifierTool"
/>
<Tool
Name="VCWebDeploymentTool"
/>
<Tool
Name="VCPostBuildEventTool"
/>
</Configuration>
<Configuration
Name="Debug|Itanium"
OutputDirectory="ia64\$(ConfigurationName)"
IntermediateDirectory="ia64\$(ConfigurationName)"
ConfigurationType="1"
InheritedPropertySheets="UpgradeFromVC70.vsprops"
CharacterSet="2"
>
<Tool
Name="VCPreBuildEventTool"
/>
<Tool
Name="VCCustomBuildTool"
/>
<Tool
Name="VCXMLDataGeneratorTool"
/>
<Tool
Name="VCWebServiceProxyGeneratorTool"
/>
<Tool
Name="VCMIDLTool"
TargetEnvironment="2"
/>
<Tool
Name="VCCLCompilerTool"
Optimization="0"
AdditionalIncludeDirectories="..\..\..;..\..\minizip"
PreprocessorDefinitions="_CRT_NONSTDC_NO_DEPRECATE;_CRT_SECURE_NO_DEPRECATE;ZLIB_WINAPI;_DEBUG;_CONSOLE;WIN64"
MinimalRebuild="true"
BasicRuntimeChecks="0"
RuntimeLibrary="3"
BufferSecurityCheck="false"
UsePrecompiledHeader="0"
AssemblerListingLocation="$(IntDir)\"
WarningLevel="3"
Detect64BitPortabilityProblems="true"
DebugInformationFormat="3"
/>
<Tool
Name="VCManagedResourceCompilerTool"
/>
<Tool
Name="VCResourceCompilerTool"
/>
<Tool
Name="VCPreLinkEventTool"
/>
<Tool
Name="VCLinkerTool"
AdditionalDependencies="ia64\ZlibDllDebug\zlibwapi.lib"
OutputFile="$(OutDir)/minizip.exe"
LinkIncremental="2"
GenerateManifest="false"
GenerateDebugInformation="true"
ProgramDatabaseFile="$(OutDir)/minizip.pdb"
SubSystem="1"
TargetMachine="5"
/>
<Tool
Name="VCALinkTool"
/>
<Tool
Name="VCManifestTool"
/>
<Tool
Name="VCXDCMakeTool"
/>
<Tool
Name="VCBscMakeTool"
/>
<Tool
Name="VCFxCopTool"
/>
<Tool
Name="VCAppVerifierTool"
/>
<Tool
Name="VCWebDeploymentTool"
/>
<Tool
Name="VCPostBuildEventTool"
/>
</Configuration>
<Configuration
Name="Release|Win32"
OutputDirectory="x86\MiniZip$(ConfigurationName)"
IntermediateDirectory="x86\MiniZip$(ConfigurationName)\Tmp"
ConfigurationType="1"
InheritedPropertySheets="UpgradeFromVC70.vsprops"
CharacterSet="2"
>
<Tool
Name="VCPreBuildEventTool"
/>
<Tool
Name="VCCustomBuildTool"
/>
<Tool
Name="VCXMLDataGeneratorTool"
/>
<Tool
Name="VCWebServiceProxyGeneratorTool"
/>
<Tool
Name="VCMIDLTool"
/>
<Tool
Name="VCCLCompilerTool"
Optimization="2"
InlineFunctionExpansion="1"
OmitFramePointers="true"
AdditionalIncludeDirectories="..\..\..;..\..\minizip"
PreprocessorDefinitions="WIN32;_CRT_NONSTDC_NO_DEPRECATE;_CRT_SECURE_NO_DEPRECATE;ZLIB_WINAPI;NDEBUG;_CONSOLE"
StringPooling="true"
BasicRuntimeChecks="0"
RuntimeLibrary="0"
BufferSecurityCheck="false"
EnableFunctionLevelLinking="true"
UsePrecompiledHeader="0"
AssemblerListingLocation="$(IntDir)\"
WarningLevel="3"
Detect64BitPortabilityProblems="true"
DebugInformationFormat="3"
/>
<Tool
Name="VCManagedResourceCompilerTool"
/>
<Tool
Name="VCResourceCompilerTool"
/>
<Tool
Name="VCPreLinkEventTool"
/>
<Tool
Name="VCLinkerTool"
AdditionalDependencies="x86\ZlibDllRelease\zlibwapi.lib"
OutputFile="$(OutDir)/minizip.exe"
LinkIncremental="1"
GenerateDebugInformation="true"
SubSystem="1"
OptimizeReferences="2"
EnableCOMDATFolding="2"
OptimizeForWindows98="1"
TargetMachine="1"
/>
<Tool
Name="VCALinkTool"
/>
<Tool
Name="VCManifestTool"
/>
<Tool
Name="VCXDCMakeTool"
/>
<Tool
Name="VCBscMakeTool"
/>
<Tool
Name="VCFxCopTool"
/>
<Tool
Name="VCAppVerifierTool"
/>
<Tool
Name="VCWebDeploymentTool"
/>
<Tool
Name="VCPostBuildEventTool"
/>
</Configuration>
<Configuration
Name="Release|x64"
OutputDirectory="x64\$(ConfigurationName)"
IntermediateDirectory="x64\$(ConfigurationName)"
ConfigurationType="1"
InheritedPropertySheets="UpgradeFromVC70.vsprops"
CharacterSet="2"
>
<Tool
Name="VCPreBuildEventTool"
/>
<Tool
Name="VCCustomBuildTool"
/>
<Tool
Name="VCXMLDataGeneratorTool"
/>
<Tool
Name="VCWebServiceProxyGeneratorTool"
/>
<Tool
Name="VCMIDLTool"
TargetEnvironment="3"
/>
<Tool
Name="VCCLCompilerTool"
Optimization="2"
InlineFunctionExpansion="1"
OmitFramePointers="true"
AdditionalIncludeDirectories="..\..\..;..\..\minizip"
PreprocessorDefinitions="_CRT_NONSTDC_NO_DEPRECATE;_CRT_SECURE_NO_DEPRECATE;ZLIB_WINAPI;NDEBUG;_CONSOLE;WIN64"
StringPooling="true"
BasicRuntimeChecks="0"
RuntimeLibrary="2"
BufferSecurityCheck="false"
EnableFunctionLevelLinking="true"
UsePrecompiledHeader="0"
AssemblerListingLocation="$(IntDir)\"
WarningLevel="3"
Detect64BitPortabilityProblems="true"
DebugInformationFormat="3"
/>
<Tool
Name="VCManagedResourceCompilerTool"
/>
<Tool
Name="VCResourceCompilerTool"
/>
<Tool
Name="VCPreLinkEventTool"
/>
<Tool
Name="VCLinkerTool"
AdditionalDependencies="x64\ZlibDllRelease\zlibwapi.lib"
OutputFile="$(OutDir)/minizip.exe"
LinkIncremental="1"
GenerateDebugInformation="true"
SubSystem="1"
OptimizeReferences="2"
EnableCOMDATFolding="2"
OptimizeForWindows98="1"
TargetMachine="17"
/>
<Tool
Name="VCALinkTool"
/>
<Tool
Name="VCManifestTool"
/>
<Tool
Name="VCXDCMakeTool"
/>
<Tool
Name="VCBscMakeTool"
/>
<Tool
Name="VCFxCopTool"
/>
<Tool
Name="VCAppVerifierTool"
/>
<Tool
Name="VCWebDeploymentTool"
/>
<Tool
Name="VCPostBuildEventTool"
/>
</Configuration>
<Configuration
Name="Release|Itanium"
OutputDirectory="ia64\$(ConfigurationName)"
IntermediateDirectory="ia64\$(ConfigurationName)"
ConfigurationType="1"
InheritedPropertySheets="UpgradeFromVC70.vsprops"
CharacterSet="2"
>
<Tool
Name="VCPreBuildEventTool"
/>
<Tool
Name="VCCustomBuildTool"
/>
<Tool
Name="VCXMLDataGeneratorTool"
/>
<Tool
Name="VCWebServiceProxyGeneratorTool"
/>
<Tool
Name="VCMIDLTool"
TargetEnvironment="2"
/>
<Tool
Name="VCCLCompilerTool"
Optimization="2"
InlineFunctionExpansion="1"
OmitFramePointers="true"
AdditionalIncludeDirectories="..\..\..;..\..\minizip"
PreprocessorDefinitions="_CRT_NONSTDC_NO_DEPRECATE;_CRT_SECURE_NO_DEPRECATE;ZLIB_WINAPI;NDEBUG;_CONSOLE;WIN64"
StringPooling="true"
BasicRuntimeChecks="0"
RuntimeLibrary="2"
BufferSecurityCheck="false"
EnableFunctionLevelLinking="true"
UsePrecompiledHeader="0"
AssemblerListingLocation="$(IntDir)\"
WarningLevel="3"
Detect64BitPortabilityProblems="true"
DebugInformationFormat="3"
/>
<Tool
Name="VCManagedResourceCompilerTool"
/>
<Tool
Name="VCResourceCompilerTool"
/>
<Tool
Name="VCPreLinkEventTool"
/>
<Tool
Name="VCLinkerTool"
AdditionalDependencies="ia64\ZlibDllRelease\zlibwapi.lib"
OutputFile="$(OutDir)/minizip.exe"
LinkIncremental="1"
GenerateDebugInformation="true"
SubSystem="1"
OptimizeReferences="2"
EnableCOMDATFolding="2"
OptimizeForWindows98="1"
TargetMachine="5"
/>
<Tool
Name="VCALinkTool"
/>
<Tool
Name="VCManifestTool"
/>
<Tool
Name="VCXDCMakeTool"
/>
<Tool
Name="VCBscMakeTool"
/>
<Tool
Name="VCFxCopTool"
/>
<Tool
Name="VCAppVerifierTool"
/>
<Tool
Name="VCWebDeploymentTool"
/>
<Tool
Name="VCPostBuildEventTool"
/>
</Configuration>
</Configurations>
<References>
</References>
<Files>
<Filter
Name="Source Files"
Filter="cpp;c;cxx;def;odl;idl;hpj;bat;asm"
>
<File
RelativePath="..\..\minizip\minizip.c"
>
</File>
</Filter>
<Filter
Name="Header Files"
Filter="h;hpp;hxx;hm;inl;inc"
>
</Filter>
<Filter
Name="Resource Files"
Filter="rc;ico;cur;bmp;dlg;rc2;rct;bin;rgs;gif;jpg;jpeg;jpe"
>
</Filter>
</Files>
<Globals>
</Globals>
</VisualStudioProject>

948
contrib/vstudio/vc8/testzlib.vcproj Normal file
View File

@@ -0,0 +1,948 @@
<?xml version="1.0" encoding="Windows-1252"?>
<VisualStudioProject
ProjectType="Visual C++"
Version="8,00"
Name="testzlib"
ProjectGUID="{AA6666AA-E09F-4135-9C0C-4FE50C3C654B}"
RootNamespace="testzlib"
Keyword="Win32Proj"
>
<Platforms>
<Platform
Name="Win32"
/>
<Platform
Name="x64"
/>
<Platform
Name="Itanium"
/>
</Platforms>
<ToolFiles>
</ToolFiles>
<Configurations>
<Configuration
Name="Debug|Win32"
OutputDirectory="x86\TestZlib$(ConfigurationName)"
IntermediateDirectory="x86\TestZlib$(ConfigurationName)\Tmp"
ConfigurationType="1"
CharacterSet="2"
>
<Tool
Name="VCPreBuildEventTool"
/>
<Tool
Name="VCCustomBuildTool"
/>
<Tool
Name="VCXMLDataGeneratorTool"
/>
<Tool
Name="VCWebServiceProxyGeneratorTool"
/>
<Tool
Name="VCMIDLTool"
/>
<Tool
Name="VCCLCompilerTool"
Optimization="0"
AdditionalIncludeDirectories="..\..\.."
PreprocessorDefinitions="ASMV;ASMINF;WIN32;ZLIB_WINAPI;_DEBUG;_CONSOLE;_CRT_NONSTDC_NO_DEPRECATE;_CRT_SECURE_NO_DEPRECATE"
MinimalRebuild="true"
BasicRuntimeChecks="0"
RuntimeLibrary="1"
BufferSecurityCheck="false"
UsePrecompiledHeader="0"
AssemblerOutput="4"
AssemblerListingLocation="$(IntDir)\"
WarningLevel="3"
Detect64BitPortabilityProblems="true"
DebugInformationFormat="4"
/>
<Tool
Name="VCManagedResourceCompilerTool"
/>
<Tool
Name="VCResourceCompilerTool"
/>
<Tool
Name="VCPreLinkEventTool"
/>
<Tool
Name="VCLinkerTool"
AdditionalDependencies="..\..\masmx86\gvmat32.obj ..\..\masmx86\inffas32.obj"
OutputFile="$(OutDir)/testzlib.exe"
LinkIncremental="2"
GenerateManifest="false"
GenerateDebugInformation="true"
ProgramDatabaseFile="$(OutDir)/testzlib.pdb"
SubSystem="1"
TargetMachine="1"
/>
<Tool
Name="VCALinkTool"
/>
<Tool
Name="VCManifestTool"
/>
<Tool
Name="VCXDCMakeTool"
/>
<Tool
Name="VCBscMakeTool"
/>
<Tool
Name="VCFxCopTool"
/>
<Tool
Name="VCAppVerifierTool"
/>
<Tool
Name="VCWebDeploymentTool"
/>
<Tool
Name="VCPostBuildEventTool"
/>
</Configuration>
<Configuration
Name="Debug|x64"
OutputDirectory="x64\TestZlib$(ConfigurationName)"
IntermediateDirectory="x64\TestZlib$(ConfigurationName)\Tmp"
ConfigurationType="1"
>
<Tool
Name="VCPreBuildEventTool"
/>
<Tool
Name="VCCustomBuildTool"
/>
<Tool
Name="VCXMLDataGeneratorTool"
/>
<Tool
Name="VCWebServiceProxyGeneratorTool"
/>
<Tool
Name="VCMIDLTool"
/>
<Tool
Name="VCCLCompilerTool"
AdditionalIncludeDirectories="..\..\.."
PreprocessorDefinitions="ASMV;ASMINF;WIN32;ZLIB_WINAPI;_DEBUG;_CONSOLE;_CRT_NONSTDC_NO_DEPRECATE;_CRT_SECURE_NO_DEPRECATE"
BasicRuntimeChecks="0"
RuntimeLibrary="3"
BufferSecurityCheck="false"
AssemblerListingLocation="$(IntDir)\"
/>
<Tool
Name="VCManagedResourceCompilerTool"
/>
<Tool
Name="VCResourceCompilerTool"
/>
<Tool
Name="VCPreLinkEventTool"
/>
<Tool
Name="VCLinkerTool"
AdditionalDependencies="..\..\masmx64\gvmat64.obj ..\..\masmx64\inffasx64.obj"
GenerateManifest="false"
/>
<Tool
Name="VCALinkTool"
/>
<Tool
Name="VCManifestTool"
/>
<Tool
Name="VCXDCMakeTool"
/>
<Tool
Name="VCBscMakeTool"
/>
<Tool
Name="VCFxCopTool"
/>
<Tool
Name="VCAppVerifierTool"
/>
<Tool
Name="VCWebDeploymentTool"
/>
<Tool
Name="VCPostBuildEventTool"
/>
</Configuration>
<Configuration
Name="Debug|Itanium"
OutputDirectory="ia64\TestZlib$(ConfigurationName)"
IntermediateDirectory="ia64\TestZlib$(ConfigurationName)\Tmp"
ConfigurationType="1"
CharacterSet="2"
>
<Tool
Name="VCPreBuildEventTool"
/>
<Tool
Name="VCCustomBuildTool"
/>
<Tool
Name="VCXMLDataGeneratorTool"
/>
<Tool
Name="VCWebServiceProxyGeneratorTool"
/>
<Tool
Name="VCMIDLTool"
TargetEnvironment="2"
/>
<Tool
Name="VCCLCompilerTool"
Optimization="0"
AdditionalIncludeDirectories="..\..\.."
PreprocessorDefinitions="ZLIB_WINAPI;_DEBUG;_CONSOLE;_CRT_NONSTDC_NO_DEPRECATE;_CRT_SECURE_NO_DEPRECATE;WIN64"
MinimalRebuild="true"
BasicRuntimeChecks="0"
RuntimeLibrary="3"
BufferSecurityCheck="false"
UsePrecompiledHeader="0"
AssemblerOutput="4"
AssemblerListingLocation="$(IntDir)\"
WarningLevel="3"
Detect64BitPortabilityProblems="true"
DebugInformationFormat="3"
/>
<Tool
Name="VCManagedResourceCompilerTool"
/>
<Tool
Name="VCResourceCompilerTool"
/>
<Tool
Name="VCPreLinkEventTool"
/>
<Tool
Name="VCLinkerTool"
OutputFile="$(OutDir)/testzlib.exe"
LinkIncremental="2"
GenerateManifest="false"
GenerateDebugInformation="true"
ProgramDatabaseFile="$(OutDir)/testzlib.pdb"
SubSystem="1"
TargetMachine="5"
/>
<Tool
Name="VCALinkTool"
/>
<Tool
Name="VCManifestTool"
/>
<Tool
Name="VCXDCMakeTool"
/>
<Tool
Name="VCBscMakeTool"
/>
<Tool
Name="VCFxCopTool"
/>
<Tool
Name="VCAppVerifierTool"
/>
<Tool
Name="VCWebDeploymentTool"
/>
<Tool
Name="VCPostBuildEventTool"
/>
</Configuration>
<Configuration
Name="ReleaseWithoutAsm|Win32"
OutputDirectory="x86\TestZlib$(ConfigurationName)"
IntermediateDirectory="x86\TestZlib$(ConfigurationName)\Tmp"
ConfigurationType="1"
CharacterSet="2"
WholeProgramOptimization="1"
>
<Tool
Name="VCPreBuildEventTool"
/>
<Tool
Name="VCCustomBuildTool"
/>
<Tool
Name="VCXMLDataGeneratorTool"
/>
<Tool
Name="VCWebServiceProxyGeneratorTool"
/>
<Tool
Name="VCMIDLTool"
/>
<Tool
Name="VCCLCompilerTool"
Optimization="2"
InlineFunctionExpansion="1"
OmitFramePointers="true"
AdditionalIncludeDirectories="..\..\.."
PreprocessorDefinitions="WIN32;ZLIB_WINAPI;NDEBUG;_CONSOLE;_CRT_NONSTDC_NO_DEPRECATE;_CRT_SECURE_NO_DEPRECATE"
StringPooling="true"
BasicRuntimeChecks="0"
RuntimeLibrary="0"
BufferSecurityCheck="false"
EnableFunctionLevelLinking="true"
UsePrecompiledHeader="0"
AssemblerListingLocation="$(IntDir)\"
WarningLevel="3"
Detect64BitPortabilityProblems="true"
DebugInformationFormat="3"
/>
<Tool
Name="VCManagedResourceCompilerTool"
/>
<Tool
Name="VCResourceCompilerTool"
/>
<Tool
Name="VCPreLinkEventTool"
/>
<Tool
Name="VCLinkerTool"
OutputFile="$(OutDir)/testzlib.exe"
LinkIncremental="1"
GenerateManifest="false"
GenerateDebugInformation="true"
SubSystem="1"
OptimizeReferences="2"
EnableCOMDATFolding="2"
OptimizeForWindows98="1"
TargetMachine="1"
/>
<Tool
Name="VCALinkTool"
/>
<Tool
Name="VCManifestTool"
/>
<Tool
Name="VCXDCMakeTool"
/>
<Tool
Name="VCBscMakeTool"
/>
<Tool
Name="VCFxCopTool"
/>
<Tool
Name="VCAppVerifierTool"
/>
<Tool
Name="VCWebDeploymentTool"
/>
<Tool
Name="VCPostBuildEventTool"
/>
</Configuration>
<Configuration
Name="ReleaseWithoutAsm|x64"
OutputDirectory="x64\TestZlib$(ConfigurationName)"
IntermediateDirectory="x64\TestZlib$(ConfigurationName)\Tmp"
ConfigurationType="1"
WholeProgramOptimization="1"
>
<Tool
Name="VCPreBuildEventTool"
/>
<Tool
Name="VCCustomBuildTool"
/>
<Tool
Name="VCXMLDataGeneratorTool"
/>
<Tool
Name="VCWebServiceProxyGeneratorTool"
/>
<Tool
Name="VCMIDLTool"
/>
<Tool
Name="VCCLCompilerTool"
AdditionalIncludeDirectories="..\..\.."
PreprocessorDefinitions="WIN32;ZLIB_WINAPI;NDEBUG;_CONSOLE;_CRT_NONSTDC_NO_DEPRECATE;_CRT_SECURE_NO_DEPRECATE"
BasicRuntimeChecks="0"
RuntimeLibrary="2"
BufferSecurityCheck="false"
AssemblerListingLocation="$(IntDir)\"
/>
<Tool
Name="VCManagedResourceCompilerTool"
/>
<Tool
Name="VCResourceCompilerTool"
/>
<Tool
Name="VCPreLinkEventTool"
/>
<Tool
Name="VCLinkerTool"
AdditionalDependencies=""
GenerateManifest="false"
/>
<Tool
Name="VCALinkTool"
/>
<Tool
Name="VCManifestTool"
/>
<Tool
Name="VCXDCMakeTool"
/>
<Tool
Name="VCBscMakeTool"
/>
<Tool
Name="VCFxCopTool"
/>
<Tool
Name="VCAppVerifierTool"
/>
<Tool
Name="VCWebDeploymentTool"
/>
<Tool
Name="VCPostBuildEventTool"
/>
</Configuration>
<Configuration
Name="ReleaseWithoutAsm|Itanium"
OutputDirectory="ia64\TestZlib$(ConfigurationName)"
IntermediateDirectory="ia64\TestZlib$(ConfigurationName)\Tmp"
ConfigurationType="1"
CharacterSet="2"
WholeProgramOptimization="1"
>
<Tool
Name="VCPreBuildEventTool"
/>
<Tool
Name="VCCustomBuildTool"
/>
<Tool
Name="VCXMLDataGeneratorTool"
/>
<Tool
Name="VCWebServiceProxyGeneratorTool"
/>
<Tool
Name="VCMIDLTool"
TargetEnvironment="2"
/>
<Tool
Name="VCCLCompilerTool"
Optimization="2"
InlineFunctionExpansion="1"
OmitFramePointers="true"
AdditionalIncludeDirectories="..\..\.."
PreprocessorDefinitions="ZLIB_WINAPI;NDEBUG;_CONSOLE;_CRT_NONSTDC_NO_DEPRECATE;_CRT_SECURE_NO_DEPRECATE;WIN64"
StringPooling="true"
BasicRuntimeChecks="0"
RuntimeLibrary="2"
BufferSecurityCheck="false"
EnableFunctionLevelLinking="true"
UsePrecompiledHeader="0"
AssemblerListingLocation="$(IntDir)\"
WarningLevel="3"
Detect64BitPortabilityProblems="true"
DebugInformationFormat="3"
/>
<Tool
Name="VCManagedResourceCompilerTool"
/>
<Tool
Name="VCResourceCompilerTool"
/>
<Tool
Name="VCPreLinkEventTool"
/>
<Tool
Name="VCLinkerTool"
OutputFile="$(OutDir)/testzlib.exe"
LinkIncremental="1"
GenerateManifest="false"
GenerateDebugInformation="true"
SubSystem="1"
OptimizeReferences="2"
EnableCOMDATFolding="2"
OptimizeForWindows98="1"
TargetMachine="5"
/>
<Tool
Name="VCALinkTool"
/>
<Tool
Name="VCManifestTool"
/>
<Tool
Name="VCXDCMakeTool"
/>
<Tool
Name="VCBscMakeTool"
/>
<Tool
Name="VCFxCopTool"
/>
<Tool
Name="VCAppVerifierTool"
/>
<Tool
Name="VCWebDeploymentTool"
/>
<Tool
Name="VCPostBuildEventTool"
/>
</Configuration>
<Configuration
Name="Release|Win32"
OutputDirectory="x86\TestZlib$(ConfigurationName)"
IntermediateDirectory="x86\TestZlib$(ConfigurationName)\Tmp"
ConfigurationType="1"
CharacterSet="2"
WholeProgramOptimization="1"
>
<Tool
Name="VCPreBuildEventTool"
/>
<Tool
Name="VCCustomBuildTool"
/>
<Tool
Name="VCXMLDataGeneratorTool"
/>
<Tool
Name="VCWebServiceProxyGeneratorTool"
/>
<Tool
Name="VCMIDLTool"
/>
<Tool
Name="VCCLCompilerTool"
Optimization="2"
InlineFunctionExpansion="1"
OmitFramePointers="true"
AdditionalIncludeDirectories="..\..\.."
PreprocessorDefinitions="ASMV;ASMINF;WIN32;ZLIB_WINAPI;NDEBUG;_CONSOLE;_CRT_NONSTDC_NO_DEPRECATE;_CRT_SECURE_NO_DEPRECATE"
StringPooling="true"
BasicRuntimeChecks="0"
RuntimeLibrary="0"
BufferSecurityCheck="false"
EnableFunctionLevelLinking="true"
UsePrecompiledHeader="0"
AssemblerListingLocation="$(IntDir)\"
WarningLevel="3"
Detect64BitPortabilityProblems="true"
DebugInformationFormat="3"
/>
<Tool
Name="VCManagedResourceCompilerTool"
/>
<Tool
Name="VCResourceCompilerTool"
/>
<Tool
Name="VCPreLinkEventTool"
/>
<Tool
Name="VCLinkerTool"
AdditionalDependencies="..\..\masmx86\gvmat32.obj ..\..\masmx86\inffas32.obj"
OutputFile="$(OutDir)/testzlib.exe"
LinkIncremental="1"
GenerateManifest="false"
GenerateDebugInformation="true"
SubSystem="1"
OptimizeReferences="2"
EnableCOMDATFolding="2"
OptimizeForWindows98="1"
TargetMachine="1"
/>
<Tool
Name="VCALinkTool"
/>
<Tool
Name="VCManifestTool"
/>
<Tool
Name="VCXDCMakeTool"
/>
<Tool
Name="VCBscMakeTool"
/>
<Tool
Name="VCFxCopTool"
/>
<Tool
Name="VCAppVerifierTool"
/>
<Tool
Name="VCWebDeploymentTool"
/>
<Tool
Name="VCPostBuildEventTool"
/>
</Configuration>
<Configuration
Name="Release|x64"
OutputDirectory="x64\TestZlib$(ConfigurationName)"
IntermediateDirectory="x64\TestZlib$(ConfigurationName)\Tmp"
ConfigurationType="1"
WholeProgramOptimization="1"
>
<Tool
Name="VCPreBuildEventTool"
/>
<Tool
Name="VCCustomBuildTool"
/>
<Tool
Name="VCXMLDataGeneratorTool"
/>
<Tool
Name="VCWebServiceProxyGeneratorTool"
/>
<Tool
Name="VCMIDLTool"
/>
<Tool
Name="VCCLCompilerTool"
AdditionalIncludeDirectories="..\..\.."
PreprocessorDefinitions="ASMV;ASMINF;WIN32;ZLIB_WINAPI;NDEBUG;_CONSOLE;_CRT_NONSTDC_NO_DEPRECATE;_CRT_SECURE_NO_DEPRECATE"
BasicRuntimeChecks="0"
RuntimeLibrary="2"
BufferSecurityCheck="false"
AssemblerListingLocation="$(IntDir)\"
/>
<Tool
Name="VCManagedResourceCompilerTool"
/>
<Tool
Name="VCResourceCompilerTool"
/>
<Tool
Name="VCPreLinkEventTool"
/>
<Tool
Name="VCLinkerTool"
AdditionalDependencies="..\..\masmx64\gvmat64.obj ..\..\masmx64\inffasx64.obj"
GenerateManifest="false"
/>
<Tool
Name="VCALinkTool"
/>
<Tool
Name="VCManifestTool"
/>
<Tool
Name="VCXDCMakeTool"
/>
<Tool
Name="VCBscMakeTool"
/>
<Tool
Name="VCFxCopTool"
/>
<Tool
Name="VCAppVerifierTool"
/>
<Tool
Name="VCWebDeploymentTool"
/>
<Tool
Name="VCPostBuildEventTool"
/>
</Configuration>
<Configuration
Name="Release|Itanium"
OutputDirectory="ia64\TestZlib$(ConfigurationName)"
IntermediateDirectory="ia64\TestZlib$(ConfigurationName)\Tmp"
ConfigurationType="1"
CharacterSet="2"
WholeProgramOptimization="1"
>
<Tool
Name="VCPreBuildEventTool"
/>
<Tool
Name="VCCustomBuildTool"
/>
<Tool
Name="VCXMLDataGeneratorTool"
/>
<Tool
Name="VCWebServiceProxyGeneratorTool"
/>
<Tool
Name="VCMIDLTool"
TargetEnvironment="2"
/>
<Tool
Name="VCCLCompilerTool"
Optimization="2"
InlineFunctionExpansion="1"
OmitFramePointers="true"
AdditionalIncludeDirectories="..\..\.."
PreprocessorDefinitions="ZLIB_WINAPI;NDEBUG;_CONSOLE;_CRT_NONSTDC_NO_DEPRECATE;_CRT_SECURE_NO_DEPRECATE;WIN64"
StringPooling="true"
BasicRuntimeChecks="0"
RuntimeLibrary="2"
BufferSecurityCheck="false"
EnableFunctionLevelLinking="true"
UsePrecompiledHeader="0"
AssemblerListingLocation="$(IntDir)\"
WarningLevel="3"
Detect64BitPortabilityProblems="true"
DebugInformationFormat="3"
/>
<Tool
Name="VCManagedResourceCompilerTool"
/>
<Tool
Name="VCResourceCompilerTool"
/>
<Tool
Name="VCPreLinkEventTool"
/>
<Tool
Name="VCLinkerTool"
OutputFile="$(OutDir)/testzlib.exe"
LinkIncremental="1"
GenerateManifest="false"
GenerateDebugInformation="true"
SubSystem="1"
OptimizeReferences="2"
EnableCOMDATFolding="2"
OptimizeForWindows98="1"
TargetMachine="5"
/>
<Tool
Name="VCALinkTool"
/>
<Tool
Name="VCManifestTool"
/>
<Tool
Name="VCXDCMakeTool"
/>
<Tool
Name="VCBscMakeTool"
/>
<Tool
Name="VCFxCopTool"
/>
<Tool
Name="VCAppVerifierTool"
/>
<Tool
Name="VCWebDeploymentTool"
/>
<Tool
Name="VCPostBuildEventTool"
/>
</Configuration>
</Configurations>
<References>
</References>
<Files>
<Filter
Name="Source Files"
Filter="cpp;c;cxx;def;odl;idl;hpj;bat;asm"
>
<File
RelativePath="..\..\..\adler32.c"
>
</File>
<File
RelativePath="..\..\..\compress.c"
>
</File>
<File
RelativePath="..\..\..\crc32.c"
>
</File>
<File
RelativePath="..\..\..\deflate.c"
>
</File>
<File
RelativePath="..\..\masmx86\gvmat32c.c"
>
<FileConfiguration
Name="Debug|x64"
ExcludedFromBuild="true"
>
<Tool
Name="VCCLCompilerTool"
/>
</FileConfiguration>
<FileConfiguration
Name="Debug|Itanium"
ExcludedFromBuild="true"
>
<Tool
Name="VCCLCompilerTool"
/>
</FileConfiguration>
<FileConfiguration
Name="ReleaseWithoutAsm|x64"
ExcludedFromBuild="true"
>
<Tool
Name="VCCLCompilerTool"
/>
</FileConfiguration>
<FileConfiguration
Name="ReleaseWithoutAsm|Itanium"
ExcludedFromBuild="true"
>
<Tool
Name="VCCLCompilerTool"
/>
</FileConfiguration>
<FileConfiguration
Name="Release|x64"
ExcludedFromBuild="true"
>
<Tool
Name="VCCLCompilerTool"
/>
</FileConfiguration>
<FileConfiguration
Name="Release|Itanium"
ExcludedFromBuild="true"
>
<Tool
Name="VCCLCompilerTool"
/>
</FileConfiguration>
<FileConfiguration
Name="Debug|Win64 (AMD64)"
ExcludedFromBuild="TRUE"
>
<Tool
Name="VCCLCompilerTool"
/>
</FileConfiguration>
<FileConfiguration
Name="Release|Win64 (AMD64)"
ExcludedFromBuild="TRUE"
>
<Tool
Name="VCCLCompilerTool"
/>
</FileConfiguration>
<FileConfiguration
Name="ReleaseAsm|Win64 (AMD64)"
ExcludedFromBuild="TRUE"
>
<Tool
Name="VCCLCompilerTool"
/>
</FileConfiguration>
</File>
<File
RelativePath="..\..\..\infback.c"
>
</File>
<File
RelativePath="..\..\masmx64\inffas8664.c"
>
<FileConfiguration
Name="Debug|Win32"
ExcludedFromBuild="true"
>
<Tool
Name="VCCLCompilerTool"
/>
</FileConfiguration>
<FileConfiguration
Name="Debug|Itanium"
ExcludedFromBuild="true"
>
<Tool
Name="VCCLCompilerTool"
/>
</FileConfiguration>
<FileConfiguration
Name="ReleaseWithoutAsm|Win32"
ExcludedFromBuild="true"
>
<Tool
Name="VCCLCompilerTool"
/>
</FileConfiguration>
<FileConfiguration
Name="ReleaseWithoutAsm|Itanium"
ExcludedFromBuild="true"
>
<Tool
Name="VCCLCompilerTool"
/>
</FileConfiguration>
<FileConfiguration
Name="Release|Win32"
ExcludedFromBuild="true"
>
<Tool
Name="VCCLCompilerTool"
/>
</FileConfiguration>
<FileConfiguration
Name="Release|Itanium"
ExcludedFromBuild="true"
>
<Tool
Name="VCCLCompilerTool"
/>
</FileConfiguration>
</File>
<File
RelativePath="..\..\..\inffast.c"
>
</File>
<File
RelativePath="..\..\..\inflate.c"
>
</File>
<File
RelativePath="..\..\..\inftrees.c"
>
</File>
<File
RelativePath="..\..\testzlib\testzlib.c"
>
</File>
<File
RelativePath="..\..\..\trees.c"
>
</File>
<File
RelativePath="..\..\..\uncompr.c"
>
</File>
<File
RelativePath="..\..\..\zutil.c"
>
</File>
</Filter>
<Filter
Name="Header Files"
Filter="h;hpp;hxx;hm;inl;inc"
>
</Filter>
<Filter
Name="Resource Files"
Filter="rc;ico;cur;bmp;dlg;rc2;rct;bin;rgs;gif;jpg;jpeg;jpe"
>
</Filter>
</Files>
<Globals>
</Globals>
</VisualStudioProject>

451
contrib/testzlib/testzlib8.vcproj → contrib/vstudio/vc8/testzlibdll.vcproj
View File

@@ -2,29 +2,31 @@
<VisualStudioProject <VisualStudioProject
ProjectType="Visual C++" ProjectType="Visual C++"
Version="8,00" Version="8,00"
Name="testzlib8" Name="TestZlibDll"
ProjectGUID="{AA6666AA-E09F-4135-9C0C-4FE50C3C654B}" ProjectGUID="{C52F9E7B-498A-42BE-8DB4-85A15694366A}"
Keyword="Win32Proj" Keyword="Win32Proj"
SignManifests="true"
> >
<Platforms> <Platforms>
<Platform <Platform
Name="Win32" Name="Win32"
/> />
<Platform <Platform
Name="Win64 (AMD64)" Name="x64"
/>
<Platform
Name="Itanium"
/> />
</Platforms> </Platforms>
<ToolFiles> <ToolFiles>
<DefaultToolFile
FileName="masm.tool"
/>
</ToolFiles> </ToolFiles>
<Configurations> <Configurations>
<Configuration <Configuration
Name="Debug|Win32" Name="Debug|Win32"
OutputDirectory="x86\$(ConfigurationName)" OutputDirectory="x86\TestZlibDll$(ConfigurationName)"
IntermediateDirectory="x86\$(ConfigurationName)" IntermediateDirectory="x86\TestZlibDll$(ConfigurationName)\Tmp"
ConfigurationType="1" ConfigurationType="1"
InheritedPropertySheets="UpgradeFromVC70.vsprops"
CharacterSet="2" CharacterSet="2"
> >
<Tool <Tool
@@ -33,9 +35,6 @@
<Tool <Tool
Name="VCCustomBuildTool" Name="VCCustomBuildTool"
/> />
<Tool
Name="MASM"
/>
<Tool <Tool
Name="VCXMLDataGeneratorTool" Name="VCXMLDataGeneratorTool"
/> />
@@ -48,14 +47,16 @@
<Tool <Tool
Name="VCCLCompilerTool" Name="VCCLCompilerTool"
Optimization="0" Optimization="0"
PreprocessorDefinitions="ASMV;ASMINF;WIN32;ZLIB_WINAPI;_DEBUG;_CONSOLE;_CRT_SECURE_NO_DEPRECATE" AdditionalIncludeDirectories="..\..\..;..\..\minizip"
MinimalRebuild="TRUE" PreprocessorDefinitions="WIN32;_CRT_NONSTDC_NO_DEPRECATE;_CRT_SECURE_NO_DEPRECATE;ZLIB_WINAPI;_DEBUG;_CONSOLE"
BasicRuntimeChecks="3" MinimalRebuild="true"
BasicRuntimeChecks="0"
RuntimeLibrary="1" RuntimeLibrary="1"
BufferSecurityCheck="false"
UsePrecompiledHeader="0" UsePrecompiledHeader="0"
AssemblerOutput="4" AssemblerListingLocation="$(IntDir)\"
WarningLevel="3" WarningLevel="3"
Detect64BitPortabilityProblems="TRUE" Detect64BitPortabilityProblems="true"
DebugInformationFormat="4" DebugInformationFormat="4"
/> />
<Tool <Tool
@@ -69,10 +70,11 @@
/> />
<Tool <Tool
Name="VCLinkerTool" Name="VCLinkerTool"
AdditionalDependencies="gvmat32.obj inffas32.obj" AdditionalDependencies="x86\ZlibDllDebug\zlibwapi.lib"
OutputFile="$(OutDir)/testzlib.exe" OutputFile="$(OutDir)/testzlib.exe"
LinkIncremental="2" LinkIncremental="2"
GenerateDebugInformation="TRUE" GenerateManifest="false"
GenerateDebugInformation="true"
ProgramDatabaseFile="$(OutDir)/testzlib.pdb" ProgramDatabaseFile="$(OutDir)/testzlib.pdb"
SubSystem="1" SubSystem="1"
TargetMachine="1" TargetMachine="1"
@@ -89,6 +91,9 @@
<Tool <Tool
Name="VCBscMakeTool" Name="VCBscMakeTool"
/> />
<Tool
Name="VCFxCopTool"
/>
<Tool <Tool
Name="VCAppVerifierTool" Name="VCAppVerifierTool"
/> />
@@ -100,10 +105,11 @@
/> />
</Configuration> </Configuration>
<Configuration <Configuration
Name="Debug|Win64 (AMD64)" Name="Debug|x64"
OutputDirectory="amd64\$(ConfigurationName)" OutputDirectory="x64\TestZlibDll$(ConfigurationName)"
IntermediateDirectory="amd64\$(ConfigurationName)" IntermediateDirectory="x64\TestZlibDll$(ConfigurationName)\Tmp"
ConfigurationType="1" ConfigurationType="1"
InheritedPropertySheets="UpgradeFromVC70.vsprops"
CharacterSet="2" CharacterSet="2"
> >
<Tool <Tool
@@ -112,9 +118,6 @@
<Tool <Tool
Name="VCCustomBuildTool" Name="VCCustomBuildTool"
/> />
<Tool
Name="MASM"
/>
<Tool <Tool
Name="VCXMLDataGeneratorTool" Name="VCXMLDataGeneratorTool"
/> />
@@ -128,14 +131,16 @@
<Tool <Tool
Name="VCCLCompilerTool" Name="VCCLCompilerTool"
Optimization="0" Optimization="0"
PreprocessorDefinitions="ASMV;ASMINF;WIN32;ZLIB_WINAPI;_DEBUG;_CONSOLE;_CRT_SECURE_NO_DEPRECATE" AdditionalIncludeDirectories="..\..\..;..\..\minizip"
MinimalRebuild="TRUE" PreprocessorDefinitions="_CRT_NONSTDC_NO_DEPRECATE;_CRT_SECURE_NO_DEPRECATE;ZLIB_WINAPI;_DEBUG;_CONSOLE;WIN64"
BasicRuntimeChecks="3" MinimalRebuild="true"
RuntimeLibrary="1" BasicRuntimeChecks="0"
RuntimeLibrary="3"
BufferSecurityCheck="false"
UsePrecompiledHeader="0" UsePrecompiledHeader="0"
AssemblerOutput="4" AssemblerListingLocation="$(IntDir)\"
WarningLevel="3" WarningLevel="3"
Detect64BitPortabilityProblems="TRUE" Detect64BitPortabilityProblems="true"
DebugInformationFormat="3" DebugInformationFormat="3"
/> />
<Tool <Tool
@@ -146,14 +151,14 @@
/> />
<Tool <Tool
Name="VCPreLinkEventTool" Name="VCPreLinkEventTool"
CommandLine=""
/> />
<Tool <Tool
Name="VCLinkerTool" Name="VCLinkerTool"
AdditionalDependencies="gvmat64.obj inffasx64.obj rdtsc64.obj" AdditionalDependencies="x64\ZlibDllDebug\zlibwapi.lib"
OutputFile="$(OutDir)/testzlib.exe" OutputFile="$(OutDir)/testzlib.exe"
LinkIncremental="2" LinkIncremental="2"
GenerateDebugInformation="TRUE" GenerateManifest="false"
GenerateDebugInformation="true"
ProgramDatabaseFile="$(OutDir)/testzlib.pdb" ProgramDatabaseFile="$(OutDir)/testzlib.pdb"
SubSystem="1" SubSystem="1"
TargetMachine="17" TargetMachine="17"
@@ -170,6 +175,96 @@
<Tool <Tool
Name="VCBscMakeTool" Name="VCBscMakeTool"
/> />
<Tool
Name="VCFxCopTool"
/>
<Tool
Name="VCAppVerifierTool"
/>
<Tool
Name="VCWebDeploymentTool"
/>
<Tool
Name="VCPostBuildEventTool"
/>
</Configuration>
<Configuration
Name="Debug|Itanium"
OutputDirectory="ia64\TestZlibDll$(ConfigurationName)"
IntermediateDirectory="ia64\TestZlibDll$(ConfigurationName)\Tmp"
ConfigurationType="1"
InheritedPropertySheets="UpgradeFromVC70.vsprops"
CharacterSet="2"
>
<Tool
Name="VCPreBuildEventTool"
/>
<Tool
Name="VCCustomBuildTool"
/>
<Tool
Name="VCXMLDataGeneratorTool"
/>
<Tool
Name="VCWebServiceProxyGeneratorTool"
/>
<Tool
Name="VCMIDLTool"
TargetEnvironment="2"
/>
<Tool
Name="VCCLCompilerTool"
Optimization="0"
AdditionalIncludeDirectories="..\..\..;..\..\minizip"
PreprocessorDefinitions="_CRT_NONSTDC_NO_DEPRECATE;_CRT_SECURE_NO_DEPRECATE;ZLIB_WINAPI;_DEBUG;_CONSOLE;WIN64"
MinimalRebuild="true"
BasicRuntimeChecks="0"
RuntimeLibrary="3"
BufferSecurityCheck="false"
UsePrecompiledHeader="0"
AssemblerListingLocation="$(IntDir)\"
WarningLevel="3"
Detect64BitPortabilityProblems="true"
DebugInformationFormat="3"
/>
<Tool
Name="VCManagedResourceCompilerTool"
/>
<Tool
Name="VCResourceCompilerTool"
/>
<Tool
Name="VCPreLinkEventTool"
/>
<Tool
Name="VCLinkerTool"
AdditionalDependencies="ia64\ZlibDllDebug\zlibwapi.lib"
OutputFile="$(OutDir)/testzlib.exe"
LinkIncremental="2"
GenerateManifest="false"
GenerateDebugInformation="true"
ProgramDatabaseFile="$(OutDir)/testzlib.pdb"
SubSystem="1"
TargetMachine="5"
/>
<Tool
Name="VCALinkTool"
/>
<Tool
Name="VCManifestTool"
/>
<Tool
Name="VCXDCMakeTool"
/>
<Tool
Name="VCBscMakeTool"
/>
<Tool
Name="VCFxCopTool"
/>
<Tool
Name="VCAppVerifierTool"
/>
<Tool <Tool
Name="VCWebDeploymentTool" Name="VCWebDeploymentTool"
/> />
@@ -179,9 +274,10 @@
</Configuration> </Configuration>
<Configuration <Configuration
Name="Release|Win32" Name="Release|Win32"
OutputDirectory="x86\$(ConfigurationName)" OutputDirectory="x86\TestZlibDll$(ConfigurationName)"
IntermediateDirectory="x86\$(ConfigurationName)" IntermediateDirectory="x86\TestZlibDll$(ConfigurationName)\Tmp"
ConfigurationType="1" ConfigurationType="1"
InheritedPropertySheets="UpgradeFromVC70.vsprops"
CharacterSet="2" CharacterSet="2"
> >
<Tool <Tool
@@ -190,9 +286,6 @@
<Tool <Tool
Name="VCCustomBuildTool" Name="VCCustomBuildTool"
/> />
<Tool
Name="MASM"
/>
<Tool <Tool
Name="VCXMLDataGeneratorTool" Name="VCXMLDataGeneratorTool"
/> />
@@ -206,14 +299,18 @@
Name="VCCLCompilerTool" Name="VCCLCompilerTool"
Optimization="2" Optimization="2"
InlineFunctionExpansion="1" InlineFunctionExpansion="1"
OmitFramePointers="TRUE" OmitFramePointers="true"
PreprocessorDefinitions="WIN32;ZLIB_WINAPI;NDEBUG;_CONSOLE;_CRT_SECURE_NO_DEPRECATE" AdditionalIncludeDirectories="..\..\..;..\..\minizip"
StringPooling="TRUE" PreprocessorDefinitions="WIN32;_CRT_NONSTDC_NO_DEPRECATE;_CRT_SECURE_NO_DEPRECATE;ZLIB_WINAPI;NDEBUG;_CONSOLE"
StringPooling="true"
BasicRuntimeChecks="0"
RuntimeLibrary="0" RuntimeLibrary="0"
EnableFunctionLevelLinking="TRUE" BufferSecurityCheck="false"
EnableFunctionLevelLinking="true"
UsePrecompiledHeader="0" UsePrecompiledHeader="0"
AssemblerListingLocation="$(IntDir)\"
WarningLevel="3" WarningLevel="3"
Detect64BitPortabilityProblems="TRUE" Detect64BitPortabilityProblems="true"
DebugInformationFormat="3" DebugInformationFormat="3"
/> />
<Tool <Tool
@@ -227,9 +324,11 @@
/> />
<Tool <Tool
Name="VCLinkerTool" Name="VCLinkerTool"
AdditionalDependencies="x86\ZlibDllRelease\zlibwapi.lib"
OutputFile="$(OutDir)/testzlib.exe" OutputFile="$(OutDir)/testzlib.exe"
LinkIncremental="1" LinkIncremental="1"
GenerateDebugInformation="TRUE" GenerateManifest="false"
GenerateDebugInformation="true"
SubSystem="1" SubSystem="1"
OptimizeReferences="2" OptimizeReferences="2"
EnableCOMDATFolding="2" EnableCOMDATFolding="2"
@@ -248,6 +347,9 @@
<Tool <Tool
Name="VCBscMakeTool" Name="VCBscMakeTool"
/> />
<Tool
Name="VCFxCopTool"
/>
<Tool <Tool
Name="VCAppVerifierTool" Name="VCAppVerifierTool"
/> />
@@ -259,10 +361,11 @@
/> />
</Configuration> </Configuration>
<Configuration <Configuration
Name="Release|Win64 (AMD64)" Name="Release|x64"
OutputDirectory="amd64\$(ConfigurationName)" OutputDirectory="x64\TestZlibDll$(ConfigurationName)"
IntermediateDirectory="amd64\$(ConfigurationName)" IntermediateDirectory="x64\TestZlibDll$(ConfigurationName)\Tmp"
ConfigurationType="1" ConfigurationType="1"
InheritedPropertySheets="UpgradeFromVC70.vsprops"
CharacterSet="2" CharacterSet="2"
> >
<Tool <Tool
@@ -271,9 +374,6 @@
<Tool <Tool
Name="VCCustomBuildTool" Name="VCCustomBuildTool"
/> />
<Tool
Name="MASM"
/>
<Tool <Tool
Name="VCXMLDataGeneratorTool" Name="VCXMLDataGeneratorTool"
/> />
@@ -288,14 +388,18 @@
Name="VCCLCompilerTool" Name="VCCLCompilerTool"
Optimization="2" Optimization="2"
InlineFunctionExpansion="1" InlineFunctionExpansion="1"
OmitFramePointers="TRUE" OmitFramePointers="true"
PreprocessorDefinitions="WIN32;ZLIB_WINAPI;NDEBUG;_CONSOLE;_CRT_SECURE_NO_DEPRECATE" AdditionalIncludeDirectories="..\..\..;..\..\minizip"
StringPooling="TRUE" PreprocessorDefinitions="_CRT_NONSTDC_NO_DEPRECATE;_CRT_SECURE_NO_DEPRECATE;ZLIB_WINAPI;NDEBUG;_CONSOLE;WIN64"
RuntimeLibrary="0" StringPooling="true"
EnableFunctionLevelLinking="TRUE" BasicRuntimeChecks="0"
RuntimeLibrary="2"
BufferSecurityCheck="false"
EnableFunctionLevelLinking="true"
UsePrecompiledHeader="0" UsePrecompiledHeader="0"
AssemblerListingLocation="$(IntDir)\"
WarningLevel="3" WarningLevel="3"
Detect64BitPortabilityProblems="TRUE" Detect64BitPortabilityProblems="true"
DebugInformationFormat="3" DebugInformationFormat="3"
/> />
<Tool <Tool
@@ -309,10 +413,11 @@
/> />
<Tool <Tool
Name="VCLinkerTool" Name="VCLinkerTool"
AdditionalDependencies="rdtsc64.obj" AdditionalDependencies="x64\ZlibDllRelease\zlibwapi.lib"
OutputFile="$(OutDir)/testzlib.exe" OutputFile="$(OutDir)/testzlib.exe"
LinkIncremental="1" LinkIncremental="1"
GenerateDebugInformation="TRUE" GenerateManifest="false"
GenerateDebugInformation="true"
SubSystem="1" SubSystem="1"
OptimizeReferences="2" OptimizeReferences="2"
EnableCOMDATFolding="2" EnableCOMDATFolding="2"
@@ -332,83 +437,7 @@
Name="VCBscMakeTool" Name="VCBscMakeTool"
/> />
<Tool <Tool
Name="VCWebDeploymentTool" Name="VCFxCopTool"
/>
<Tool
Name="VCPostBuildEventTool"
/>
</Configuration>
<Configuration
Name="ReleaseAsm|Win32"
OutputDirectory="x86\$(ConfigurationName)"
IntermediateDirectory="x86\$(ConfigurationName)"
ConfigurationType="1"
CharacterSet="2"
>
<Tool
Name="VCPreBuildEventTool"
/>
<Tool
Name="VCCustomBuildTool"
/>
<Tool
Name="MASM"
/>
<Tool
Name="VCXMLDataGeneratorTool"
/>
<Tool
Name="VCWebServiceProxyGeneratorTool"
/>
<Tool
Name="VCMIDLTool"
/>
<Tool
Name="VCCLCompilerTool"
Optimization="2"
InlineFunctionExpansion="1"
OmitFramePointers="TRUE"
PreprocessorDefinitions="ASMV;ASMINF;WIN32;ZLIB_WINAPI;NDEBUG;_CONSOLE;_CRT_SECURE_NO_DEPRECATE"
StringPooling="TRUE"
RuntimeLibrary="0"
EnableFunctionLevelLinking="TRUE"
UsePrecompiledHeader="0"
WarningLevel="3"
Detect64BitPortabilityProblems="TRUE"
DebugInformationFormat="3"
/>
<Tool
Name="VCManagedResourceCompilerTool"
/>
<Tool
Name="VCResourceCompilerTool"
/>
<Tool
Name="VCPreLinkEventTool"
/>
<Tool
Name="VCLinkerTool"
AdditionalDependencies="gvmat32.obj inffas32.obj"
OutputFile="$(OutDir)/testzlib.exe"
LinkIncremental="1"
GenerateDebugInformation="TRUE"
SubSystem="1"
OptimizeReferences="2"
EnableCOMDATFolding="2"
OptimizeForWindows98="1"
TargetMachine="1"
/>
<Tool
Name="VCALinkTool"
/>
<Tool
Name="VCManifestTool"
/>
<Tool
Name="VCXDCMakeTool"
/>
<Tool
Name="VCBscMakeTool"
/> />
<Tool <Tool
Name="VCAppVerifierTool" Name="VCAppVerifierTool"
@@ -421,22 +450,19 @@
/> />
</Configuration> </Configuration>
<Configuration <Configuration
Name="ReleaseAsm|Win64 (AMD64)" Name="Release|Itanium"
OutputDirectory="amd64\$(ConfigurationName)" OutputDirectory="ia64\TestZlibDll$(ConfigurationName)"
IntermediateDirectory="amd64\$(ConfigurationName)" IntermediateDirectory="ia64\TestZlibDll$(ConfigurationName)\Tmp"
ConfigurationType="1" ConfigurationType="1"
InheritedPropertySheets="UpgradeFromVC70.vsprops"
CharacterSet="2" CharacterSet="2"
> >
<Tool <Tool
Name="VCPreBuildEventTool" Name="VCPreBuildEventTool"
CommandLine=""
/> />
<Tool <Tool
Name="VCCustomBuildTool" Name="VCCustomBuildTool"
/> />
<Tool
Name="MASM"
/>
<Tool <Tool
Name="VCXMLDataGeneratorTool" Name="VCXMLDataGeneratorTool"
/> />
@@ -445,21 +471,24 @@
/> />
<Tool <Tool
Name="VCMIDLTool" Name="VCMIDLTool"
TargetEnvironment="3" TargetEnvironment="2"
/> />
<Tool <Tool
Name="VCCLCompilerTool" Name="VCCLCompilerTool"
Optimization="2" Optimization="2"
InlineFunctionExpansion="1" InlineFunctionExpansion="1"
OmitFramePointers="TRUE" OmitFramePointers="true"
PreprocessorDefinitions="ASMV;ASMINF;WIN32;ZLIB_WINAPI;NDEBUG;_CONSOLE;_CRT_SECURE_NO_DEPRECATE" AdditionalIncludeDirectories="..\..\..;..\..\minizip"
StringPooling="TRUE" PreprocessorDefinitions="_CRT_NONSTDC_NO_DEPRECATE;_CRT_SECURE_NO_DEPRECATE;ZLIB_WINAPI;NDEBUG;_CONSOLE;WIN64"
RuntimeLibrary="0" StringPooling="true"
EnableFunctionLevelLinking="TRUE" BasicRuntimeChecks="0"
RuntimeLibrary="2"
BufferSecurityCheck="false"
EnableFunctionLevelLinking="true"
UsePrecompiledHeader="0" UsePrecompiledHeader="0"
AssemblerOutput="4" AssemblerListingLocation="$(IntDir)\"
WarningLevel="3" WarningLevel="3"
Detect64BitPortabilityProblems="TRUE" Detect64BitPortabilityProblems="true"
DebugInformationFormat="3" DebugInformationFormat="3"
/> />
<Tool <Tool
@@ -470,19 +499,19 @@
/> />
<Tool <Tool
Name="VCPreLinkEventTool" Name="VCPreLinkEventTool"
CommandLine=""
/> />
<Tool <Tool
Name="VCLinkerTool" Name="VCLinkerTool"
AdditionalDependencies="gvmat64.obj inffasx64.obj rdtsc64.obj" AdditionalDependencies="ia64\ZlibDllRelease\zlibwapi.lib"
OutputFile="$(OutDir)/testzlib.exe" OutputFile="$(OutDir)/testzlib.exe"
LinkIncremental="1" LinkIncremental="1"
GenerateDebugInformation="TRUE" GenerateManifest="false"
GenerateDebugInformation="true"
SubSystem="1" SubSystem="1"
OptimizeReferences="2" OptimizeReferences="2"
EnableCOMDATFolding="2" EnableCOMDATFolding="2"
OptimizeForWindows98="1" OptimizeForWindows98="1"
TargetMachine="17" TargetMachine="5"
/> />
<Tool <Tool
Name="VCALinkTool" Name="VCALinkTool"
@@ -496,6 +525,12 @@
<Tool <Tool
Name="VCBscMakeTool" Name="VCBscMakeTool"
/> />
<Tool
Name="VCFxCopTool"
/>
<Tool
Name="VCAppVerifierTool"
/>
<Tool <Tool
Name="VCWebDeploymentTool" Name="VCWebDeploymentTool"
/> />
@@ -512,113 +547,7 @@
Filter="cpp;c;cxx;def;odl;idl;hpj;bat;asm" Filter="cpp;c;cxx;def;odl;idl;hpj;bat;asm"
> >
<File <File
RelativePath=".\adler32.c" RelativePath="..\..\testzlib\testzlib.c"
>
</File>
<File
RelativePath=".\compress.c"
>
</File>
<File
RelativePath=".\crc32.c"
>
</File>
<File
RelativePath=".\deflate.c"
>
</File>
<File
RelativePath=".\gvmat32c.c"
>
<FileConfiguration
Name="Debug|Win64 (AMD64)"
ExcludedFromBuild="TRUE"
>
<Tool
Name="VCCLCompilerTool"
/>
</FileConfiguration>
<FileConfiguration
Name="Release|Win64 (AMD64)"
ExcludedFromBuild="TRUE"
>
<Tool
Name="VCCLCompilerTool"
/>
</FileConfiguration>
<FileConfiguration
Name="ReleaseAsm|Win32"
>
<Tool
Name="VCCLCompilerTool"
/>
</FileConfiguration>
<FileConfiguration
Name="ReleaseAsm|Win64 (AMD64)"
ExcludedFromBuild="TRUE"
>
<Tool
Name="VCCLCompilerTool"
/>
</FileConfiguration>
</File>
<File
RelativePath=".\infback.c"
>
</File>
<File
RelativePath=".\inffas8664.c"
>
<FileConfiguration
Name="Debug|Win32"
ExcludedFromBuild="TRUE"
>
<Tool
Name="VCCLCompilerTool"
/>
</FileConfiguration>
<FileConfiguration
Name="Release|Win32"
>
<Tool
Name="VCCLCompilerTool"
/>
</FileConfiguration>
<FileConfiguration
Name="ReleaseAsm|Win32"
ExcludedFromBuild="TRUE"
>
<Tool
Name="VCCLCompilerTool"
/>
</FileConfiguration>
</File>
<File
RelativePath=".\inffast.c"
>
</File>
<File
RelativePath=".\inflate.c"
>
</File>
<File
RelativePath=".\inftrees.c"
>
</File>
<File
RelativePath="testzlib.c"
>
</File>
<File
RelativePath=".\trees.c"
>
</File>
<File
RelativePath=".\uncompr.c"
>
</File>
<File
RelativePath=".\zutil.c"
> >
</File> </File>
</Filter> </Filter>

32
contrib/vstudio/vc8/zlib.rc Normal file
View File

@@ -0,0 +1,32 @@
#include <windows.h>
#define IDR_VERSION1 1
IDR_VERSION1 VERSIONINFO MOVEABLE IMPURE LOADONCALL DISCARDABLE
FILEVERSION 1,2,3,0
PRODUCTVERSION 1,2,3,0
FILEFLAGSMASK VS_FFI_FILEFLAGSMASK
FILEFLAGS 0
FILEOS VOS_DOS_WINDOWS32
FILETYPE VFT_DLL
FILESUBTYPE 0 // not used
BEGIN
BLOCK "StringFileInfo"
BEGIN
BLOCK "040904E4"
//language ID = U.S. English, char set = Windows, Multilingual
BEGIN
VALUE "FileDescription", "zlib data compression library\0"
VALUE "FileVersion", "1.2.3.0\0"
VALUE "InternalName", "zlib\0"
VALUE "OriginalFilename", "zlib.dll\0"
VALUE "ProductName", "ZLib.DLL\0"
VALUE "Comments","DLL support by Alessandro Iacopetti & Gilles Vollant\0"
VALUE "LegalCopyright", "(C) 1995-2003 Jean-loup Gailly & Mark Adler\0"
END
END
BLOCK "VarFileInfo"
BEGIN
VALUE "Translation", 0x0409, 1252
END
END

870
contrib/vstudio/vc8/zlibstat.vcproj Normal file
View File

@@ -0,0 +1,870 @@
<?xml version="1.0" encoding="Windows-1252"?>
<VisualStudioProject
ProjectType="Visual C++"
Version="8,00"
Name="zlibstat"
ProjectGUID="{745DEC58-EBB3-47A9-A9B8-4C6627C01BF8}"
>
<Platforms>
<Platform
Name="Win32"
/>
<Platform
Name="x64"
/>
<Platform
Name="Itanium"
/>
</Platforms>
<ToolFiles>
</ToolFiles>
<Configurations>
<Configuration
Name="Debug|Win32"
OutputDirectory="x86\ZlibStat$(ConfigurationName)"
IntermediateDirectory="x86\ZlibStat$(ConfigurationName)\Tmp"
ConfigurationType="4"
InheritedPropertySheets="UpgradeFromVC70.vsprops"
UseOfMFC="0"
ATLMinimizesCRunTimeLibraryUsage="false"
>
<Tool
Name="VCPreBuildEventTool"
/>
<Tool
Name="VCCustomBuildTool"
/>
<Tool
Name="VCXMLDataGeneratorTool"
/>
<Tool
Name="VCWebServiceProxyGeneratorTool"
/>
<Tool
Name="VCMIDLTool"
/>
<Tool
Name="VCCLCompilerTool"
Optimization="0"
AdditionalIncludeDirectories="..\..\..;..\..\masmx86"
PreprocessorDefinitions="WIN32;ZLIB_WINAPI;_CRT_NONSTDC_NO_DEPRECATE;_CRT_SECURE_NO_DEPRECATE"
ExceptionHandling="0"
RuntimeLibrary="1"
BufferSecurityCheck="false"
PrecompiledHeaderFile="$(IntDir)/zlibstat.pch"
AssemblerListingLocation="$(IntDir)\"
ObjectFile="$(IntDir)\"
ProgramDataBaseFileName="$(OutDir)\"
WarningLevel="3"
SuppressStartupBanner="true"
Detect64BitPortabilityProblems="true"
DebugInformationFormat="1"
/>
<Tool
Name="VCManagedResourceCompilerTool"
/>
<Tool
Name="VCResourceCompilerTool"
Culture="1036"
/>
<Tool
Name="VCPreLinkEventTool"
/>
<Tool
Name="VCLibrarianTool"
AdditionalOptions="/MACHINE:X86 /NODEFAULTLIB"
OutputFile="$(OutDir)\zlibstat.lib"
SuppressStartupBanner="true"
/>
<Tool
Name="VCALinkTool"
/>
<Tool
Name="VCXDCMakeTool"
/>
<Tool
Name="VCBscMakeTool"
/>
<Tool
Name="VCFxCopTool"
/>
<Tool
Name="VCPostBuildEventTool"
/>
</Configuration>
<Configuration
Name="Debug|x64"
OutputDirectory="x64\ZlibStat$(ConfigurationName)"
IntermediateDirectory="x64\ZlibStat$(ConfigurationName)\Tmp"
ConfigurationType="4"
InheritedPropertySheets="UpgradeFromVC70.vsprops"
UseOfMFC="0"
ATLMinimizesCRunTimeLibraryUsage="false"
>
<Tool
Name="VCPreBuildEventTool"
/>
<Tool
Name="VCCustomBuildTool"
/>
<Tool
Name="VCXMLDataGeneratorTool"
/>
<Tool
Name="VCWebServiceProxyGeneratorTool"
/>
<Tool
Name="VCMIDLTool"
TargetEnvironment="3"
/>
<Tool
Name="VCCLCompilerTool"
Optimization="0"
AdditionalIncludeDirectories="..\..\..;..\..\masmx86"
PreprocessorDefinitions="ZLIB_WINAPI;_CRT_NONSTDC_NO_DEPRECATE;_CRT_SECURE_NO_DEPRECATE;WIN64"
ExceptionHandling="0"
RuntimeLibrary="3"
BufferSecurityCheck="false"
PrecompiledHeaderFile="$(IntDir)/zlibstat.pch"
AssemblerListingLocation="$(IntDir)\"
ObjectFile="$(IntDir)\"
ProgramDataBaseFileName="$(OutDir)\"
WarningLevel="3"
SuppressStartupBanner="true"
Detect64BitPortabilityProblems="true"
DebugInformationFormat="1"
/>
<Tool
Name="VCManagedResourceCompilerTool"
/>
<Tool
Name="VCResourceCompilerTool"
Culture="1036"
/>
<Tool
Name="VCPreLinkEventTool"
/>
<Tool
Name="VCLibrarianTool"
AdditionalOptions="/MACHINE:AMD64 /NODEFAULTLIB"
OutputFile="$(OutDir)\zlibstat.lib"
SuppressStartupBanner="true"
/>
<Tool
Name="VCALinkTool"
/>
<Tool
Name="VCXDCMakeTool"
/>
<Tool
Name="VCBscMakeTool"
/>
<Tool
Name="VCFxCopTool"
/>
<Tool
Name="VCPostBuildEventTool"
/>
</Configuration>
<Configuration
Name="Debug|Itanium"
OutputDirectory="ia64\ZlibStat$(ConfigurationName)"
IntermediateDirectory="ia64\ZlibStat$(ConfigurationName)\Tmp"
ConfigurationType="4"
InheritedPropertySheets="UpgradeFromVC70.vsprops"
UseOfMFC="0"
ATLMinimizesCRunTimeLibraryUsage="false"
>
<Tool
Name="VCPreBuildEventTool"
/>
<Tool
Name="VCCustomBuildTool"
/>
<Tool
Name="VCXMLDataGeneratorTool"
/>
<Tool
Name="VCWebServiceProxyGeneratorTool"
/>
<Tool
Name="VCMIDLTool"
TargetEnvironment="2"
/>
<Tool
Name="VCCLCompilerTool"
Optimization="0"
AdditionalIncludeDirectories="..\..\..;..\..\masmx86"
PreprocessorDefinitions="ZLIB_WINAPI;_CRT_NONSTDC_NO_DEPRECATE;_CRT_SECURE_NO_DEPRECATE;WIN64"
ExceptionHandling="0"
RuntimeLibrary="3"
BufferSecurityCheck="false"
PrecompiledHeaderFile="$(IntDir)/zlibstat.pch"
AssemblerListingLocation="$(IntDir)\"
ObjectFile="$(IntDir)\"
ProgramDataBaseFileName="$(OutDir)\"
WarningLevel="3"
SuppressStartupBanner="true"
Detect64BitPortabilityProblems="true"
DebugInformationFormat="1"
/>
<Tool
Name="VCManagedResourceCompilerTool"
/>
<Tool
Name="VCResourceCompilerTool"
Culture="1036"
/>
<Tool
Name="VCPreLinkEventTool"
/>
<Tool
Name="VCLibrarianTool"
AdditionalOptions="/MACHINE:IA64 /NODEFAULTLIB"
OutputFile="$(OutDir)\zlibstat.lib"
SuppressStartupBanner="true"
/>
<Tool
Name="VCALinkTool"
/>
<Tool
Name="VCXDCMakeTool"
/>
<Tool
Name="VCBscMakeTool"
/>
<Tool
Name="VCFxCopTool"
/>
<Tool
Name="VCPostBuildEventTool"
/>
</Configuration>
<Configuration
Name="Release|Win32"
OutputDirectory="x86\ZlibStat$(ConfigurationName)"
IntermediateDirectory="x86\ZlibStat$(ConfigurationName)\Tmp"
ConfigurationType="4"
InheritedPropertySheets="UpgradeFromVC70.vsprops"
UseOfMFC="0"
ATLMinimizesCRunTimeLibraryUsage="false"
>
<Tool
Name="VCPreBuildEventTool"
/>
<Tool
Name="VCCustomBuildTool"
/>
<Tool
Name="VCXMLDataGeneratorTool"
/>
<Tool
Name="VCWebServiceProxyGeneratorTool"
/>
<Tool
Name="VCMIDLTool"
/>
<Tool
Name="VCCLCompilerTool"
InlineFunctionExpansion="1"
AdditionalIncludeDirectories="..\..\..;..\..\masmx86"
PreprocessorDefinitions="WIN32;ZLIB_WINAPI;_CRT_NONSTDC_NO_DEPRECATE;_CRT_SECURE_NO_DEPRECATE;ASMV;ASMINF"
StringPooling="true"
ExceptionHandling="0"
RuntimeLibrary="0"
BufferSecurityCheck="false"
EnableFunctionLevelLinking="true"
PrecompiledHeaderFile="$(IntDir)/zlibstat.pch"
AssemblerListingLocation="$(IntDir)\"
ObjectFile="$(IntDir)\"
ProgramDataBaseFileName="$(OutDir)\"
WarningLevel="3"
SuppressStartupBanner="true"
/>
<Tool
Name="VCManagedResourceCompilerTool"
/>
<Tool
Name="VCResourceCompilerTool"
Culture="1036"
/>
<Tool
Name="VCPreLinkEventTool"
/>
<Tool
Name="VCLibrarianTool"
AdditionalOptions="/MACHINE:X86 /NODEFAULTLIB"
AdditionalDependencies="..\..\masmx86\gvmat32.obj ..\..\masmx86\inffas32.obj "
OutputFile="$(OutDir)\zlibstat.lib"
SuppressStartupBanner="true"
/>
<Tool
Name="VCALinkTool"
/>
<Tool
Name="VCXDCMakeTool"
/>
<Tool
Name="VCBscMakeTool"
/>
<Tool
Name="VCFxCopTool"
/>
<Tool
Name="VCPostBuildEventTool"
/>
</Configuration>
<Configuration
Name="Release|x64"
OutputDirectory="x64\ZlibStat$(ConfigurationName)"
IntermediateDirectory="x64\ZlibStat$(ConfigurationName)\Tmp"
ConfigurationType="4"
InheritedPropertySheets="UpgradeFromVC70.vsprops"
UseOfMFC="0"
ATLMinimizesCRunTimeLibraryUsage="false"
>
<Tool
Name="VCPreBuildEventTool"
/>
<Tool
Name="VCCustomBuildTool"
/>
<Tool
Name="VCXMLDataGeneratorTool"
/>
<Tool
Name="VCWebServiceProxyGeneratorTool"
/>
<Tool
Name="VCMIDLTool"
TargetEnvironment="3"
/>
<Tool
Name="VCCLCompilerTool"
InlineFunctionExpansion="1"
AdditionalIncludeDirectories="..\..\..;..\..\masmx86"
PreprocessorDefinitions="ZLIB_WINAPI;_CRT_NONSTDC_NO_DEPRECATE;_CRT_SECURE_NO_DEPRECATE;ASMV;ASMINF;WIN64"
StringPooling="true"
ExceptionHandling="0"
RuntimeLibrary="2"
BufferSecurityCheck="false"
EnableFunctionLevelLinking="true"
PrecompiledHeaderFile="$(IntDir)/zlibstat.pch"
AssemblerListingLocation="$(IntDir)\"
ObjectFile="$(IntDir)\"
ProgramDataBaseFileName="$(OutDir)\"
WarningLevel="3"
SuppressStartupBanner="true"
/>
<Tool
Name="VCManagedResourceCompilerTool"
/>
<Tool
Name="VCResourceCompilerTool"
Culture="1036"
/>
<Tool
Name="VCPreLinkEventTool"
/>
<Tool
Name="VCLibrarianTool"
AdditionalOptions="/MACHINE:AMD64 /NODEFAULTLIB"
AdditionalDependencies="..\..\masmx64\gvmat64.obj ..\..\masmx64\inffasx64.obj "
OutputFile="$(OutDir)\zlibstat.lib"
SuppressStartupBanner="true"
/>
<Tool
Name="VCALinkTool"
/>
<Tool
Name="VCXDCMakeTool"
/>
<Tool
Name="VCBscMakeTool"
/>
<Tool
Name="VCFxCopTool"
/>
<Tool
Name="VCPostBuildEventTool"
/>
</Configuration>
<Configuration
Name="Release|Itanium"
OutputDirectory="ia64\ZlibStat$(ConfigurationName)"
IntermediateDirectory="ia64\ZlibStat$(ConfigurationName)\Tmp"
ConfigurationType="4"
InheritedPropertySheets="UpgradeFromVC70.vsprops"
UseOfMFC="0"
ATLMinimizesCRunTimeLibraryUsage="false"
>
<Tool
Name="VCPreBuildEventTool"
/>
<Tool
Name="VCCustomBuildTool"
/>
<Tool
Name="VCXMLDataGeneratorTool"
/>
<Tool
Name="VCWebServiceProxyGeneratorTool"
/>
<Tool
Name="VCMIDLTool"
TargetEnvironment="2"
/>
<Tool
Name="VCCLCompilerTool"
InlineFunctionExpansion="1"
AdditionalIncludeDirectories="..\..\..;..\..\masmx86"
PreprocessorDefinitions="ZLIB_WINAPI;_CRT_NONSTDC_NO_DEPRECATE;_CRT_SECURE_NO_DEPRECATE;WIN64"
StringPooling="true"
ExceptionHandling="0"
RuntimeLibrary="2"
BufferSecurityCheck="false"
EnableFunctionLevelLinking="true"
PrecompiledHeaderFile="$(IntDir)/zlibstat.pch"
AssemblerListingLocation="$(IntDir)\"
ObjectFile="$(IntDir)\"
ProgramDataBaseFileName="$(OutDir)\"
WarningLevel="3"
SuppressStartupBanner="true"
/>
<Tool
Name="VCManagedResourceCompilerTool"
/>
<Tool
Name="VCResourceCompilerTool"
Culture="1036"
/>
<Tool
Name="VCPreLinkEventTool"
/>
<Tool
Name="VCLibrarianTool"
AdditionalOptions="/MACHINE:IA64 /NODEFAULTLIB"
OutputFile="$(OutDir)\zlibstat.lib"
SuppressStartupBanner="true"
/>
<Tool
Name="VCALinkTool"
/>
<Tool
Name="VCXDCMakeTool"
/>
<Tool
Name="VCBscMakeTool"
/>
<Tool
Name="VCFxCopTool"
/>
<Tool
Name="VCPostBuildEventTool"
/>
</Configuration>
<Configuration
Name="ReleaseWithoutAsm|Win32"
OutputDirectory="x86\ZlibStat$(ConfigurationName)"
IntermediateDirectory="x86\ZlibStat$(ConfigurationName)\Tmp"
ConfigurationType="4"
InheritedPropertySheets="UpgradeFromVC70.vsprops"
UseOfMFC="0"
ATLMinimizesCRunTimeLibraryUsage="false"
>
<Tool
Name="VCPreBuildEventTool"
/>
<Tool
Name="VCCustomBuildTool"
/>
<Tool
Name="VCXMLDataGeneratorTool"
/>
<Tool
Name="VCWebServiceProxyGeneratorTool"
/>
<Tool
Name="VCMIDLTool"
/>
<Tool
Name="VCCLCompilerTool"
InlineFunctionExpansion="1"
AdditionalIncludeDirectories="..\..\..;..\..\masmx86"
PreprocessorDefinitions="WIN32;ZLIB_WINAPI;_CRT_NONSTDC_NO_DEPRECATE;_CRT_SECURE_NO_DEPRECATE"
StringPooling="true"
ExceptionHandling="0"
RuntimeLibrary="0"
BufferSecurityCheck="false"
EnableFunctionLevelLinking="true"
PrecompiledHeaderFile="$(IntDir)/zlibstat.pch"
AssemblerListingLocation="$(IntDir)\"
ObjectFile="$(IntDir)\"
ProgramDataBaseFileName="$(OutDir)\"
WarningLevel="3"
SuppressStartupBanner="true"
/>
<Tool
Name="VCManagedResourceCompilerTool"
/>
<Tool
Name="VCResourceCompilerTool"
Culture="1036"
/>
<Tool
Name="VCPreLinkEventTool"
/>
<Tool
Name="VCLibrarianTool"
AdditionalOptions="/MACHINE:X86 /NODEFAULTLIB"
OutputFile="$(OutDir)\zlibstat.lib"
SuppressStartupBanner="true"
/>
<Tool
Name="VCALinkTool"
/>
<Tool
Name="VCXDCMakeTool"
/>
<Tool
Name="VCBscMakeTool"
/>
<Tool
Name="VCFxCopTool"
/>
<Tool
Name="VCPostBuildEventTool"
/>
</Configuration>
<Configuration
Name="ReleaseWithoutAsm|x64"
OutputDirectory="x64\ZlibStat$(ConfigurationName)"
IntermediateDirectory="x64\ZlibStat$(ConfigurationName)\Tmp"
ConfigurationType="4"
InheritedPropertySheets="UpgradeFromVC70.vsprops"
UseOfMFC="0"
ATLMinimizesCRunTimeLibraryUsage="false"
>
<Tool
Name="VCPreBuildEventTool"
/>
<Tool
Name="VCCustomBuildTool"
/>
<Tool
Name="VCXMLDataGeneratorTool"
/>
<Tool
Name="VCWebServiceProxyGeneratorTool"
/>
<Tool
Name="VCMIDLTool"
TargetEnvironment="3"
/>
<Tool
Name="VCCLCompilerTool"
InlineFunctionExpansion="1"
AdditionalIncludeDirectories="..\..\..;..\..\masmx86"
PreprocessorDefinitions="ZLIB_WINAPI;_CRT_NONSTDC_NO_DEPRECATE;_CRT_SECURE_NO_DEPRECATE;WIN64"
StringPooling="true"
ExceptionHandling="0"
RuntimeLibrary="2"
BufferSecurityCheck="false"
EnableFunctionLevelLinking="true"
PrecompiledHeaderFile="$(IntDir)/zlibstat.pch"
AssemblerListingLocation="$(IntDir)\"
ObjectFile="$(IntDir)\"
ProgramDataBaseFileName="$(OutDir)\"
WarningLevel="3"
SuppressStartupBanner="true"
/>
<Tool
Name="VCManagedResourceCompilerTool"
/>
<Tool
Name="VCResourceCompilerTool"
Culture="1036"
/>
<Tool
Name="VCPreLinkEventTool"
/>
<Tool
Name="VCLibrarianTool"
AdditionalOptions="/MACHINE:AMD64 /NODEFAULTLIB"
OutputFile="$(OutDir)\zlibstat.lib"
SuppressStartupBanner="true"
/>
<Tool
Name="VCALinkTool"
/>
<Tool
Name="VCXDCMakeTool"
/>
<Tool
Name="VCBscMakeTool"
/>
<Tool
Name="VCFxCopTool"
/>
<Tool
Name="VCPostBuildEventTool"
/>
</Configuration>
<Configuration
Name="ReleaseWithoutAsm|Itanium"
OutputDirectory="ia64\ZlibStat$(ConfigurationName)"
IntermediateDirectory="ia64\ZlibStat$(ConfigurationName)\Tmp"
ConfigurationType="4"
InheritedPropertySheets="UpgradeFromVC70.vsprops"
UseOfMFC="0"
ATLMinimizesCRunTimeLibraryUsage="false"
>
<Tool
Name="VCPreBuildEventTool"
/>
<Tool
Name="VCCustomBuildTool"
/>
<Tool
Name="VCXMLDataGeneratorTool"
/>
<Tool
Name="VCWebServiceProxyGeneratorTool"
/>
<Tool
Name="VCMIDLTool"
TargetEnvironment="2"
/>
<Tool
Name="VCCLCompilerTool"
InlineFunctionExpansion="1"
AdditionalIncludeDirectories="..\..\..;..\..\masmx86"
PreprocessorDefinitions="ZLIB_WINAPI;_CRT_NONSTDC_NO_DEPRECATE;_CRT_SECURE_NO_DEPRECATE;WIN64"
StringPooling="true"
ExceptionHandling="0"
RuntimeLibrary="2"
BufferSecurityCheck="false"
EnableFunctionLevelLinking="true"
PrecompiledHeaderFile="$(IntDir)/zlibstat.pch"
AssemblerListingLocation="$(IntDir)\"
ObjectFile="$(IntDir)\"
ProgramDataBaseFileName="$(OutDir)\"
WarningLevel="3"
SuppressStartupBanner="true"
/>
<Tool
Name="VCManagedResourceCompilerTool"
/>
<Tool
Name="VCResourceCompilerTool"
Culture="1036"
/>
<Tool
Name="VCPreLinkEventTool"
/>
<Tool
Name="VCLibrarianTool"
AdditionalOptions="/MACHINE:IA64 /NODEFAULTLIB"
OutputFile="$(OutDir)\zlibstat.lib"
SuppressStartupBanner="true"
/>
<Tool
Name="VCALinkTool"
/>
<Tool
Name="VCXDCMakeTool"
/>
<Tool
Name="VCBscMakeTool"
/>
<Tool
Name="VCFxCopTool"
/>
<Tool
Name="VCPostBuildEventTool"
/>
</Configuration>
</Configurations>
<References>
</References>
<Files>
<Filter
Name="Source Files"
>
<File
RelativePath="..\..\..\adler32.c"
>
</File>
<File
RelativePath="..\..\..\compress.c"
>
</File>
<File
RelativePath="..\..\..\crc32.c"
>
</File>
<File
RelativePath="..\..\..\deflate.c"
>
</File>
<File
RelativePath="..\..\masmx86\gvmat32c.c"
>
<FileConfiguration
Name="Debug|x64"
ExcludedFromBuild="true"
>
<Tool
Name="VCCLCompilerTool"
/>
</FileConfiguration>
<FileConfiguration
Name="Debug|Itanium"
ExcludedFromBuild="true"
>
<Tool
Name="VCCLCompilerTool"
/>
</FileConfiguration>
<FileConfiguration
Name="Release|x64"
ExcludedFromBuild="true"
>
<Tool
Name="VCCLCompilerTool"
/>
</FileConfiguration>
<FileConfiguration
Name="Release|Itanium"
ExcludedFromBuild="true"
>
<Tool
Name="VCCLCompilerTool"
/>
</FileConfiguration>
<FileConfiguration
Name="ReleaseWithoutAsm|x64"
ExcludedFromBuild="true"
>
<Tool
Name="VCCLCompilerTool"
/>
</FileConfiguration>
<FileConfiguration
Name="ReleaseWithoutAsm|Itanium"
ExcludedFromBuild="true"
>
<Tool
Name="VCCLCompilerTool"
/>
</FileConfiguration>
</File>
<File
RelativePath="..\..\..\gzio.c"
>
</File>
<File
RelativePath="..\..\..\infback.c"
>
</File>
<File
RelativePath="..\..\masmx64\inffas8664.c"
>
<FileConfiguration
Name="Debug|Win32"
ExcludedFromBuild="true"
>
<Tool
Name="VCCLCompilerTool"
/>
</FileConfiguration>
<FileConfiguration
Name="Debug|Itanium"
ExcludedFromBuild="true"
>
<Tool
Name="VCCLCompilerTool"
/>
</FileConfiguration>
<FileConfiguration
Name="Release|Win32"
ExcludedFromBuild="true"
>
<Tool
Name="VCCLCompilerTool"
/>
</FileConfiguration>
<FileConfiguration
Name="Release|Itanium"
ExcludedFromBuild="true"
>
<Tool
Name="VCCLCompilerTool"
/>
</FileConfiguration>
<FileConfiguration
Name="ReleaseWithoutAsm|Win32"
ExcludedFromBuild="true"
>
<Tool
Name="VCCLCompilerTool"
/>
</FileConfiguration>
<FileConfiguration
Name="ReleaseWithoutAsm|Itanium"
ExcludedFromBuild="true"
>
<Tool
Name="VCCLCompilerTool"
/>
</FileConfiguration>
</File>
<File
RelativePath="..\..\..\inffast.c"
>
</File>
<File
RelativePath="..\..\..\inflate.c"
>
</File>
<File
RelativePath="..\..\..\inftrees.c"
>
</File>
<File
RelativePath="..\..\minizip\ioapi.c"
>
</File>
<File
RelativePath="..\..\..\trees.c"
>
</File>
<File
RelativePath="..\..\..\uncompr.c"
>
</File>
<File
RelativePath="..\..\minizip\unzip.c"
>
</File>
<File
RelativePath="..\..\minizip\zip.c"
>
</File>
<File
RelativePath=".\zlib.rc"
>
</File>
<File
RelativePath=".\zlibvc.def"
>
</File>
<File
RelativePath="..\..\..\zutil.c"
>
</File>
</Filter>
</Files>
<Globals>
</Globals>
</VisualStudioProject>

92
contrib/vstudio/vc8/zlibvc.def Normal file
View File

@@ -0,0 +1,92 @@
VERSION 1.23
HEAPSIZE 1048576,8192
EXPORTS
adler32 @1
compress @2
crc32 @3
deflate @4
deflateCopy @5
deflateEnd @6
deflateInit2_ @7
deflateInit_ @8
deflateParams @9
deflateReset @10
deflateSetDictionary @11
gzclose @12
gzdopen @13
gzerror @14
gzflush @15
gzopen @16
gzread @17
gzwrite @18
inflate @19
inflateEnd @20
inflateInit2_ @21
inflateInit_ @22
inflateReset @23
inflateSetDictionary @24
inflateSync @25
uncompress @26
zlibVersion @27
gzprintf @28
gzputc @29
gzgetc @30
gzseek @31
gzrewind @32
gztell @33
gzeof @34
gzsetparams @35
zError @36
inflateSyncPoint @37
get_crc_table @38
compress2 @39
gzputs @40
gzgets @41
inflateCopy @42
inflateBackInit_ @43
inflateBack @44
inflateBackEnd @45
compressBound @46
deflateBound @47
gzclearerr @48
gzungetc @49
zlibCompileFlags @50
deflatePrime @51
unzOpen @61
unzClose @62
unzGetGlobalInfo @63
unzGetCurrentFileInfo @64
unzGoToFirstFile @65
unzGoToNextFile @66
unzOpenCurrentFile @67
unzReadCurrentFile @68
unzOpenCurrentFile3 @69
unztell @70
unzeof @71
unzCloseCurrentFile @72
unzGetGlobalComment @73
unzStringFileNameCompare @74
unzLocateFile @75
unzGetLocalExtrafield @76
unzOpen2 @77
unzOpenCurrentFile2 @78
unzOpenCurrentFilePassword @79
zipOpen @80
zipOpenNewFileInZip @81
zipWriteInFileInZip @82
zipCloseFileInZip @83
zipClose @84
zipOpenNewFileInZip2 @86
zipCloseFileInZipRaw @87
zipOpen2 @88
zipOpenNewFileInZip3 @89
unzGetFilePos @100
unzGoToFilePos @101
fill_win32_filefunc @110

144
contrib/vstudio/vc8/zlibvc.sln Normal file
View File

@@ -0,0 +1,144 @@

Microsoft Visual Studio Solution File, Format Version 9.00
# Visual Studio 2005
Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "zlibvc", "zlibvc.vcproj", "{8FD826F8-3739-44E6-8CC8-997122E53B8D}"
EndProject
Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "zlibstat", "zlibstat.vcproj", "{745DEC58-EBB3-47A9-A9B8-4C6627C01BF8}"
EndProject
Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "testzlib", "testzlib.vcproj", "{AA6666AA-E09F-4135-9C0C-4FE50C3C654B}"
EndProject
Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "TestZlibDll", "testzlibdll.vcproj", "{C52F9E7B-498A-42BE-8DB4-85A15694366A}"
ProjectSection(ProjectDependencies) = postProject
{8FD826F8-3739-44E6-8CC8-997122E53B8D} = {8FD826F8-3739-44E6-8CC8-997122E53B8D}
EndProjectSection
EndProject
Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "minizip", "minizip.vcproj", "{48CDD9DC-E09F-4135-9C0C-4FE50C3C654B}"
ProjectSection(ProjectDependencies) = postProject
{8FD826F8-3739-44E6-8CC8-997122E53B8D} = {8FD826F8-3739-44E6-8CC8-997122E53B8D}
EndProjectSection
EndProject
Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "miniunz", "miniunz.vcproj", "{C52F9E7B-498A-42BE-8DB4-85A15694382A}"
ProjectSection(ProjectDependencies) = postProject
{8FD826F8-3739-44E6-8CC8-997122E53B8D} = {8FD826F8-3739-44E6-8CC8-997122E53B8D}
EndProjectSection
EndProject
Global
GlobalSection(SolutionConfigurationPlatforms) = preSolution
Debug|Itanium = Debug|Itanium
Debug|Win32 = Debug|Win32
Debug|x64 = Debug|x64
Release|Itanium = Release|Itanium
Release|Win32 = Release|Win32
Release|x64 = Release|x64
ReleaseWithoutAsm|Itanium = ReleaseWithoutAsm|Itanium
ReleaseWithoutAsm|Win32 = ReleaseWithoutAsm|Win32
ReleaseWithoutAsm|x64 = ReleaseWithoutAsm|x64
EndGlobalSection
GlobalSection(ProjectConfigurationPlatforms) = postSolution
{8FD826F8-3739-44E6-8CC8-997122E53B8D}.Debug|Itanium.ActiveCfg = Debug|Itanium
{8FD826F8-3739-44E6-8CC8-997122E53B8D}.Debug|Itanium.Build.0 = Debug|Itanium
{8FD826F8-3739-44E6-8CC8-997122E53B8D}.Debug|Win32.ActiveCfg = Debug|Win32
{8FD826F8-3739-44E6-8CC8-997122E53B8D}.Debug|Win32.Build.0 = Debug|Win32
{8FD826F8-3739-44E6-8CC8-997122E53B8D}.Debug|x64.ActiveCfg = Debug|x64
{8FD826F8-3739-44E6-8CC8-997122E53B8D}.Debug|x64.Build.0 = Debug|x64
{8FD826F8-3739-44E6-8CC8-997122E53B8D}.Release|Itanium.ActiveCfg = Release|Itanium
{8FD826F8-3739-44E6-8CC8-997122E53B8D}.Release|Itanium.Build.0 = Release|Itanium
{8FD826F8-3739-44E6-8CC8-997122E53B8D}.Release|Win32.ActiveCfg = Release|Win32
{8FD826F8-3739-44E6-8CC8-997122E53B8D}.Release|Win32.Build.0 = Release|Win32
{8FD826F8-3739-44E6-8CC8-997122E53B8D}.Release|x64.ActiveCfg = ReleaseWithoutAsm|x64
{8FD826F8-3739-44E6-8CC8-997122E53B8D}.Release|x64.Build.0 = ReleaseWithoutAsm|x64
{8FD826F8-3739-44E6-8CC8-997122E53B8D}.ReleaseWithoutAsm|Itanium.ActiveCfg = ReleaseWithoutAsm|Itanium
{8FD826F8-3739-44E6-8CC8-997122E53B8D}.ReleaseWithoutAsm|Itanium.Build.0 = ReleaseWithoutAsm|Itanium
{8FD826F8-3739-44E6-8CC8-997122E53B8D}.ReleaseWithoutAsm|Win32.ActiveCfg = ReleaseWithoutAsm|Win32
{8FD826F8-3739-44E6-8CC8-997122E53B8D}.ReleaseWithoutAsm|Win32.Build.0 = ReleaseWithoutAsm|Win32
{8FD826F8-3739-44E6-8CC8-997122E53B8D}.ReleaseWithoutAsm|x64.ActiveCfg = ReleaseWithoutAsm|x64
{8FD826F8-3739-44E6-8CC8-997122E53B8D}.ReleaseWithoutAsm|x64.Build.0 = ReleaseWithoutAsm|x64
{745DEC58-EBB3-47A9-A9B8-4C6627C01BF8}.Debug|Itanium.ActiveCfg = Debug|Itanium
{745DEC58-EBB3-47A9-A9B8-4C6627C01BF8}.Debug|Itanium.Build.0 = Debug|Itanium
{745DEC58-EBB3-47A9-A9B8-4C6627C01BF8}.Debug|Win32.ActiveCfg = Debug|Win32
{745DEC58-EBB3-47A9-A9B8-4C6627C01BF8}.Debug|Win32.Build.0 = Debug|Win32
{745DEC58-EBB3-47A9-A9B8-4C6627C01BF8}.Debug|x64.ActiveCfg = Debug|x64
{745DEC58-EBB3-47A9-A9B8-4C6627C01BF8}.Debug|x64.Build.0 = Debug|x64
{745DEC58-EBB3-47A9-A9B8-4C6627C01BF8}.Release|Itanium.ActiveCfg = Release|Itanium
{745DEC58-EBB3-47A9-A9B8-4C6627C01BF8}.Release|Itanium.Build.0 = Release|Itanium
{745DEC58-EBB3-47A9-A9B8-4C6627C01BF8}.Release|Win32.ActiveCfg = Release|Win32
{745DEC58-EBB3-47A9-A9B8-4C6627C01BF8}.Release|Win32.Build.0 = Release|Win32
{745DEC58-EBB3-47A9-A9B8-4C6627C01BF8}.Release|x64.ActiveCfg = Release|x64
{745DEC58-EBB3-47A9-A9B8-4C6627C01BF8}.Release|x64.Build.0 = Release|x64
{745DEC58-EBB3-47A9-A9B8-4C6627C01BF8}.ReleaseWithoutAsm|Itanium.ActiveCfg = ReleaseWithoutAsm|Itanium
{745DEC58-EBB3-47A9-A9B8-4C6627C01BF8}.ReleaseWithoutAsm|Itanium.Build.0 = ReleaseWithoutAsm|Itanium
{745DEC58-EBB3-47A9-A9B8-4C6627C01BF8}.ReleaseWithoutAsm|Win32.ActiveCfg = ReleaseWithoutAsm|Win32
{745DEC58-EBB3-47A9-A9B8-4C6627C01BF8}.ReleaseWithoutAsm|Win32.Build.0 = ReleaseWithoutAsm|Win32
{745DEC58-EBB3-47A9-A9B8-4C6627C01BF8}.ReleaseWithoutAsm|x64.ActiveCfg = ReleaseWithoutAsm|x64
{745DEC58-EBB3-47A9-A9B8-4C6627C01BF8}.ReleaseWithoutAsm|x64.Build.0 = ReleaseWithoutAsm|x64
{AA6666AA-E09F-4135-9C0C-4FE50C3C654B}.Debug|Itanium.ActiveCfg = Debug|Itanium
{AA6666AA-E09F-4135-9C0C-4FE50C3C654B}.Debug|Itanium.Build.0 = Debug|Itanium
{AA6666AA-E09F-4135-9C0C-4FE50C3C654B}.Debug|Win32.ActiveCfg = Debug|Win32
{AA6666AA-E09F-4135-9C0C-4FE50C3C654B}.Debug|Win32.Build.0 = Debug|Win32
{AA6666AA-E09F-4135-9C0C-4FE50C3C654B}.Debug|x64.ActiveCfg = Debug|x64
{AA6666AA-E09F-4135-9C0C-4FE50C3C654B}.Debug|x64.Build.0 = Debug|x64
{AA6666AA-E09F-4135-9C0C-4FE50C3C654B}.Release|Itanium.ActiveCfg = Release|Itanium
{AA6666AA-E09F-4135-9C0C-4FE50C3C654B}.Release|Itanium.Build.0 = Release|Itanium
{AA6666AA-E09F-4135-9C0C-4FE50C3C654B}.Release|Win32.ActiveCfg = Release|Win32
{AA6666AA-E09F-4135-9C0C-4FE50C3C654B}.Release|Win32.Build.0 = Release|Win32
{AA6666AA-E09F-4135-9C0C-4FE50C3C654B}.Release|x64.ActiveCfg = Release|x64
{AA6666AA-E09F-4135-9C0C-4FE50C3C654B}.Release|x64.Build.0 = Release|x64
{AA6666AA-E09F-4135-9C0C-4FE50C3C654B}.ReleaseWithoutAsm|Itanium.ActiveCfg = ReleaseWithoutAsm|Itanium
{AA6666AA-E09F-4135-9C0C-4FE50C3C654B}.ReleaseWithoutAsm|Itanium.Build.0 = ReleaseWithoutAsm|Itanium
{AA6666AA-E09F-4135-9C0C-4FE50C3C654B}.ReleaseWithoutAsm|Win32.ActiveCfg = ReleaseWithoutAsm|Win32
{AA6666AA-E09F-4135-9C0C-4FE50C3C654B}.ReleaseWithoutAsm|Win32.Build.0 = ReleaseWithoutAsm|Win32
{AA6666AA-E09F-4135-9C0C-4FE50C3C654B}.ReleaseWithoutAsm|x64.ActiveCfg = ReleaseWithoutAsm|x64
{AA6666AA-E09F-4135-9C0C-4FE50C3C654B}.ReleaseWithoutAsm|x64.Build.0 = ReleaseWithoutAsm|x64
{C52F9E7B-498A-42BE-8DB4-85A15694366A}.Debug|Itanium.ActiveCfg = Debug|Itanium
{C52F9E7B-498A-42BE-8DB4-85A15694366A}.Debug|Itanium.Build.0 = Debug|Itanium
{C52F9E7B-498A-42BE-8DB4-85A15694366A}.Debug|Win32.ActiveCfg = Debug|Win32
{C52F9E7B-498A-42BE-8DB4-85A15694366A}.Debug|Win32.Build.0 = Debug|Win32
{C52F9E7B-498A-42BE-8DB4-85A15694366A}.Debug|x64.ActiveCfg = Debug|x64
{C52F9E7B-498A-42BE-8DB4-85A15694366A}.Debug|x64.Build.0 = Debug|x64
{C52F9E7B-498A-42BE-8DB4-85A15694366A}.Release|Itanium.ActiveCfg = Release|Itanium
{C52F9E7B-498A-42BE-8DB4-85A15694366A}.Release|Itanium.Build.0 = Release|Itanium
{C52F9E7B-498A-42BE-8DB4-85A15694366A}.Release|Win32.ActiveCfg = Release|Win32
{C52F9E7B-498A-42BE-8DB4-85A15694366A}.Release|Win32.Build.0 = Release|Win32
{C52F9E7B-498A-42BE-8DB4-85A15694366A}.Release|x64.ActiveCfg = Release|x64
{C52F9E7B-498A-42BE-8DB4-85A15694366A}.Release|x64.Build.0 = Release|x64
{C52F9E7B-498A-42BE-8DB4-85A15694366A}.ReleaseWithoutAsm|Itanium.ActiveCfg = Release|Itanium
{C52F9E7B-498A-42BE-8DB4-85A15694366A}.ReleaseWithoutAsm|Itanium.Build.0 = Release|Itanium
{C52F9E7B-498A-42BE-8DB4-85A15694366A}.ReleaseWithoutAsm|Win32.ActiveCfg = Release|Itanium
{C52F9E7B-498A-42BE-8DB4-85A15694366A}.ReleaseWithoutAsm|x64.ActiveCfg = Release|Itanium
{48CDD9DC-E09F-4135-9C0C-4FE50C3C654B}.Debug|Itanium.ActiveCfg = Debug|Itanium
{48CDD9DC-E09F-4135-9C0C-4FE50C3C654B}.Debug|Itanium.Build.0 = Debug|Itanium
{48CDD9DC-E09F-4135-9C0C-4FE50C3C654B}.Debug|Win32.ActiveCfg = Debug|Win32
{48CDD9DC-E09F-4135-9C0C-4FE50C3C654B}.Debug|Win32.Build.0 = Debug|Win32
{48CDD9DC-E09F-4135-9C0C-4FE50C3C654B}.Debug|x64.ActiveCfg = Debug|x64
{48CDD9DC-E09F-4135-9C0C-4FE50C3C654B}.Debug|x64.Build.0 = Debug|x64
{48CDD9DC-E09F-4135-9C0C-4FE50C3C654B}.Release|Itanium.ActiveCfg = Release|Itanium
{48CDD9DC-E09F-4135-9C0C-4FE50C3C654B}.Release|Itanium.Build.0 = Release|Itanium
{48CDD9DC-E09F-4135-9C0C-4FE50C3C654B}.Release|Win32.ActiveCfg = Release|Win32
{48CDD9DC-E09F-4135-9C0C-4FE50C3C654B}.Release|Win32.Build.0 = Release|Win32
{48CDD9DC-E09F-4135-9C0C-4FE50C3C654B}.Release|x64.ActiveCfg = Release|x64
{48CDD9DC-E09F-4135-9C0C-4FE50C3C654B}.Release|x64.Build.0 = Release|x64
{48CDD9DC-E09F-4135-9C0C-4FE50C3C654B}.ReleaseWithoutAsm|Itanium.ActiveCfg = Release|Itanium
{48CDD9DC-E09F-4135-9C0C-4FE50C3C654B}.ReleaseWithoutAsm|Itanium.Build.0 = Release|Itanium
{48CDD9DC-E09F-4135-9C0C-4FE50C3C654B}.ReleaseWithoutAsm|Win32.ActiveCfg = Release|Itanium
{48CDD9DC-E09F-4135-9C0C-4FE50C3C654B}.ReleaseWithoutAsm|x64.ActiveCfg = Release|Itanium
{C52F9E7B-498A-42BE-8DB4-85A15694382A}.Debug|Itanium.ActiveCfg = Debug|Itanium
{C52F9E7B-498A-42BE-8DB4-85A15694382A}.Debug|Itanium.Build.0 = Debug|Itanium
{C52F9E7B-498A-42BE-8DB4-85A15694382A}.Debug|Win32.ActiveCfg = Debug|Win32
{C52F9E7B-498A-42BE-8DB4-85A15694382A}.Debug|Win32.Build.0 = Debug|Win32
{C52F9E7B-498A-42BE-8DB4-85A15694382A}.Debug|x64.ActiveCfg = Debug|x64
{C52F9E7B-498A-42BE-8DB4-85A15694382A}.Debug|x64.Build.0 = Debug|x64
{C52F9E7B-498A-42BE-8DB4-85A15694382A}.Release|Itanium.ActiveCfg = Release|Itanium
{C52F9E7B-498A-42BE-8DB4-85A15694382A}.Release|Itanium.Build.0 = Release|Itanium
{C52F9E7B-498A-42BE-8DB4-85A15694382A}.Release|Win32.ActiveCfg = Release|Win32
{C52F9E7B-498A-42BE-8DB4-85A15694382A}.Release|Win32.Build.0 = Release|Win32
{C52F9E7B-498A-42BE-8DB4-85A15694382A}.Release|x64.ActiveCfg = Release|x64
{C52F9E7B-498A-42BE-8DB4-85A15694382A}.Release|x64.Build.0 = Release|x64
{C52F9E7B-498A-42BE-8DB4-85A15694382A}.ReleaseWithoutAsm|Itanium.ActiveCfg = Release|Itanium
{C52F9E7B-498A-42BE-8DB4-85A15694382A}.ReleaseWithoutAsm|Itanium.Build.0 = Release|Itanium
{C52F9E7B-498A-42BE-8DB4-85A15694382A}.ReleaseWithoutAsm|Win32.ActiveCfg = Release|Itanium
{C52F9E7B-498A-42BE-8DB4-85A15694382A}.ReleaseWithoutAsm|x64.ActiveCfg = Release|Itanium
EndGlobalSection
GlobalSection(SolutionProperties) = preSolution
HideSolutionNode = FALSE
EndGlobalSection
EndGlobal

1219
contrib/vstudio/vc8/zlibvc.vcproj Normal file
View File

File diff suppressed because it is too large Load Diff

2
deflate.c
View File

@@ -52,7 +52,7 @@
#include "deflate.h" #include "deflate.h"
const char deflate_copyright[] = const char deflate_copyright[] =
" deflate 1.2.2.4 Copyright 1995-2005 Jean-loup Gailly "; " deflate 1.2.3 Copyright 1995-2005 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

4
inftrees.c
View File

@@ -9,7 +9,7 @@
#define MAXBITS 15 #define MAXBITS 15
const char inflate_copyright[] = const char inflate_copyright[] =
" inflate 1.2.2.4 Copyright 1995-2005 Mark Adler "; " inflate 1.2.3 Copyright 1995-2005 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
@@ -62,7 +62,7 @@ unsigned short FAR *work;
35, 43, 51, 59, 67, 83, 99, 115, 131, 163, 195, 227, 258, 0, 0}; 35, 43, 51, 59, 67, 83, 99, 115, 131, 163, 195, 227, 258, 0, 0};
static const unsigned short lext[31] = { /* Length codes 257..285 extra */ static const unsigned short lext[31] = { /* Length codes 257..285 extra */
16, 16, 16, 16, 16, 16, 16, 16, 17, 17, 17, 17, 18, 18, 18, 18, 16, 16, 16, 16, 16, 16, 16, 16, 17, 17, 17, 17, 18, 18, 18, 18,
19, 19, 19, 19, 20, 20, 20, 20, 21, 21, 21, 21, 16, 206, 69}; 19, 19, 19, 19, 20, 20, 20, 20, 21, 21, 21, 21, 16, 201, 196};
static const unsigned short dbase[32] = { /* Distance codes 0..29 base */ static const unsigned short dbase[32] = { /* Distance codes 0..29 base */
1, 2, 3, 4, 5, 7, 9, 13, 17, 25, 33, 49, 65, 97, 129, 193, 1, 2, 3, 4, 5, 7, 9, 13, 17, 25, 33, 49, 65, 97, 129, 193,
257, 385, 513, 769, 1025, 1537, 2049, 3073, 4097, 6145, 257, 385, 513, 769, 1025, 1537, 2049, 3073, 4097, 6145,

68
make_vms.com
View File

@@ -1,5 +1,5 @@
$! make libz under VMS written by $! make libz under VMS written by
$! Martin P.J. Zinser $! Martin P.J. Zinser
$! <zinser@zinser.no-ip.info or zinser@sysdev.deutsche-boerse.com> $! <zinser@zinser.no-ip.info or zinser@sysdev.deutsche-boerse.com>
$! $!
$ on error then goto err_exit $ on error then goto err_exit
@@ -46,8 +46,8 @@ $ then
$ ccopt = "/prefix=all" + ccopt $ ccopt = "/prefix=all" + ccopt
$ if f$trnlnm("SYS") .eqs. "" $ if f$trnlnm("SYS") .eqs. ""
$ then $ then
$ if axp $ if axp
$ then $ then
$ define sys sys$library: $ define sys sys$library:
$ else $ else
$ ccopt = "/decc" + ccopt $ ccopt = "/decc" + ccopt
@@ -58,7 +58,7 @@ $ endif
$ if its_vaxc .or. its_gnuc $ if its_vaxc .or. its_gnuc
$ then $ then
$ if f$trnlnm("SYS").eqs."" then define sys sys$library: $ if f$trnlnm("SYS").eqs."" then define sys sys$library:
$ endif $ endif
$! $!
$! Build the thing plain or with mms $! Build the thing plain or with mms
$! $!
@@ -101,8 +101,8 @@ $ then
$ write sys$output "Building minigzip..." $ write sys$output "Building minigzip..."
$ CALL MAKE minigzip.OBJ "CC ''CCOPT' minigzip" - $ CALL MAKE minigzip.OBJ "CC ''CCOPT' minigzip" -
minigzip.c zlib.h zconf.h minigzip.c zlib.h zconf.h
$ call make minigzip.exe - $ call make minigzip.exe -
"LINK minigzip,libz.olb/lib,x11vms:xvmsutils.olb/lib" - "LINK minigzip,libz.olb/lib,x11vms:xvmsutils.olb/lib" -
minigzip.obj libz.olb minigzip.obj libz.olb
$ endif $ endif
$ else $ else
@@ -118,7 +118,7 @@ $ Then
$ gosub crea_olist $ gosub crea_olist
$ write sys$output "Creating libzshr.exe" $ write sys$output "Creating libzshr.exe"
$ call anal_obj_axp modules.opt _link.opt $ call anal_obj_axp modules.opt _link.opt
$ if s_case $ if s_case
$ then $ then
$ open/append optf modules.opt $ open/append optf modules.opt
$ write optf "case_sensitive=YES" $ write optf "case_sensitive=YES"
@@ -200,41 +200,41 @@ $ if f$locate("AS_IS",f$edit(ccopt,"UPCASE")) .lt. f$length(ccopt) -
then s_case = true then s_case = true
$ endif $ endif
$ if cparm .eqs. "LINK" then linkonly = true $ if cparm .eqs. "LINK" then linkonly = true
$ if f$locate("LOPTS=",cparm) .lt. f$length(cparm) $ if f$locate("LOPTS=",cparm) .lt. f$length(cparm)
$ then $ then
$ start = f$locate("=",cparm) + 1 $ start = f$locate("=",cparm) + 1
$ len = f$length(cparm) - start $ len = f$length(cparm) - start
$ lopts = lopts + f$extract(start,len,cparm) $ lopts = lopts + f$extract(start,len,cparm)
$ endif $ endif
$ if f$locate("CC=",cparm) .lt. f$length(cparm) $ if f$locate("CC=",cparm) .lt. f$length(cparm)
$ then $ then
$ start = f$locate("=",cparm) + 1 $ start = f$locate("=",cparm) + 1
$ len = f$length(cparm) - start $ len = f$length(cparm) - start
$ cc_com = f$extract(start,len,cparm) $ cc_com = f$extract(start,len,cparm)
if (cc_com .nes. "DECC") .and. - if (cc_com .nes. "DECC") .and. -
(cc_com .nes. "VAXC") .and. - (cc_com .nes. "VAXC") .and. -
(cc_com .nes. "GNUC") (cc_com .nes. "GNUC")
$ then $ then
$ write sys$output "Unsupported compiler choice ''cc_com' ignored" $ write sys$output "Unsupported compiler choice ''cc_com' ignored"
$ write sys$output "Use DECC, VAXC, or GNUC instead" $ write sys$output "Use DECC, VAXC, or GNUC instead"
$ else $ else
$ if cc_com .eqs. "DECC" then its_decc = true $ if cc_com .eqs. "DECC" then its_decc = true
$ if cc_com .eqs. "VAXC" then its_vaxc = true $ if cc_com .eqs. "VAXC" then its_vaxc = true
$ if cc_com .eqs. "GNUC" then its_gnuc = true $ if cc_com .eqs. "GNUC" then its_gnuc = true
$ endif $ endif
$ endif $ endif
$ if f$locate("MAKE=",cparm) .lt. f$length(cparm) $ if f$locate("MAKE=",cparm) .lt. f$length(cparm)
$ then $ then
$ start = f$locate("=",cparm) + 1 $ start = f$locate("=",cparm) + 1
$ len = f$length(cparm) - start $ len = f$length(cparm) - start
$ mmks = f$extract(start,len,cparm) $ mmks = f$extract(start,len,cparm)
$ if (mmks .eqs. "MMK") .or. (mmks .eqs. "MMS") $ if (mmks .eqs. "MMK") .or. (mmks .eqs. "MMS")
$ then $ then
$ make = mmks $ make = mmks
$ else $ else
$ write sys$output "Unsupported make choice ''mmks' ignored" $ write sys$output "Unsupported make choice ''mmks' ignored"
$ write sys$output "Use MMK or MMS instead" $ write sys$output "Use MMK or MMS instead"
$ endif $ endif
$ endif $ endif
$ i = i + 1 $ i = i + 1
$ goto opt_loop $ goto opt_loop
@@ -242,7 +242,7 @@ $ endif
$ return $ return
$!------------------------------------------------------------------------------ $!------------------------------------------------------------------------------
$! $!
$! Look for the compiler used $! Look for the compiler used
$! $!
$CHECK_COMPILER: $CHECK_COMPILER:
$ if (.not. (its_decc .or. its_vaxc .or. its_gnuc)) $ if (.not. (its_decc .or. its_vaxc .or. its_gnuc))
@@ -254,7 +254,7 @@ $ endif
$! $!
$! Exit if no compiler available $! Exit if no compiler available
$! $!
$ if (.not. (its_decc .or. its_vaxc .or. its_gnuc)) $ if (.not. (its_decc .or. its_vaxc .or. its_gnuc))
$ then goto CC_ERR $ then goto CC_ERR
$ else $ else
$ if its_decc then write sys$output "CC compiler check ... Compaq C" $ if its_decc then write sys$output "CC compiler check ... Compaq C"
@@ -273,7 +273,7 @@ $ open/append out descrip.mms
$ copy sys$input: out $ copy sys$input: out
$ deck $ deck
# descrip.mms: MMS description file for building zlib on VMS # descrip.mms: MMS description file for building zlib on VMS
# written by Martin P.J. Zinser # written by Martin P.J. Zinser
# <zinser@zinser.no-ip.info or zinser@sysdev.deutsche-boerse.com> # <zinser@zinser.no-ip.info or zinser@sysdev.deutsche-boerse.com>
OBJS = adler32.obj, compress.obj, crc32.obj, gzio.obj, uncompr.obj, infback.obj\ OBJS = adler32.obj, compress.obj, crc32.obj, gzio.obj, uncompr.obj, infback.obj\
@@ -281,7 +281,7 @@ OBJS = adler32.obj, compress.obj, crc32.obj, gzio.obj, uncompr.obj, infback.obj\
inftrees.obj, inffast.obj inftrees.obj, inffast.obj
$ eod $ eod
$ write out "CFLAGS=", ccopt $ write out "CFLAGS=", ccopt
$ write out "LOPTS=", lopts $ write out "LOPTS=", lopts
$ copy sys$input: out $ copy sys$input: out
$ deck $ deck
@@ -298,7 +298,7 @@ example.exe : example.obj libz.olb
minigzip.exe : minigzip.obj libz.olb minigzip.exe : minigzip.obj libz.olb
link $(LOPTS) minigzip,libz.olb/lib,x11vms:xvmsutils.olb/lib link $(LOPTS) minigzip,libz.olb/lib,x11vms:xvmsutils.olb/lib
clean : clean :
delete *.obj;*,libz.olb;*,*.opt;*,*.exe;* delete *.obj;*,libz.olb;*,*.opt;*,*.exe;*
@@ -310,7 +310,7 @@ deflate.obj : deflate.c deflate.h zutil.h zlib.h zconf.h
example.obj : example.c zlib.h zconf.h example.obj : example.c zlib.h zconf.h
gzio.obj : gzio.c zutil.h zlib.h zconf.h gzio.obj : gzio.c zutil.h zlib.h zconf.h
inffast.obj : inffast.c zutil.h zlib.h zconf.h inftrees.h inffast.h inffast.obj : inffast.c zutil.h zlib.h zconf.h inftrees.h inffast.h
inflate.obj : inflate.c zutil.h zlib.h zconf.h inflate.obj : inflate.c zutil.h zlib.h zconf.h
inftrees.obj : inftrees.c zutil.h zlib.h zconf.h inftrees.h inftrees.obj : inftrees.c zutil.h zlib.h zconf.h inftrees.h
minigzip.obj : minigzip.c zlib.h zconf.h minigzip.obj : minigzip.c zlib.h zconf.h
trees.obj : trees.c deflate.h zutil.h zlib.h zconf.h trees.obj : trees.c deflate.h zutil.h zlib.h zconf.h
@@ -332,12 +332,12 @@ $ src_check = "OBJS ="
$MRLOOP: $MRLOOP:
$ read/end=mrdone min rec $ read/end=mrdone min rec
$ if (f$extract(0,6,rec) .nes. src_check) then goto mrloop $ if (f$extract(0,6,rec) .nes. src_check) then goto mrloop
$ rec = rec - src_check $ rec = rec - src_check
$ gosub extra_filnam $ gosub extra_filnam
$ if (f$element(1,"\",rec) .eqs. "\") then goto mrdone $ if (f$element(1,"\",rec) .eqs. "\") then goto mrdone
$MRSLOOP: $MRSLOOP:
$ read/end=mrdone min rec $ read/end=mrdone min rec
$ gosub extra_filnam $ gosub extra_filnam
$ if (f$element(1,"\",rec) .nes. "\") then goto mrsloop $ if (f$element(1,"\",rec) .nes. "\") then goto mrsloop
$MRDONE: $MRDONE:
$ close min $ close min
@@ -356,7 +356,7 @@ $ if (srcfil .nes. " ")
$ then $ then
$ write mod f$parse(srcfil,,,"NAME"), ".obj" $ write mod f$parse(srcfil,,,"NAME"), ".obj"
$ i = i + 1 $ i = i + 1
$ goto feloop $ goto feloop
$ endif $ endif
$ return $ return
$!------------------------------------------------------------------------------ $!------------------------------------------------------------------------------
@@ -382,17 +382,17 @@ $ close h_in
$ return $ return
$!------------------------------------------------------------------------------ $!------------------------------------------------------------------------------
$! $!
$! Analyze Object files for OpenVMS AXP to extract Procedure and Data $! Analyze Object files for OpenVMS AXP to extract Procedure and Data
$! information to build a symbol vector for a shareable image $! information to build a symbol vector for a shareable image
$! All the "brains" of this logic was suggested by Hartmut Becker $! All the "brains" of this logic was suggested by Hartmut Becker
$! (Hartmut.Becker@compaq.com). All the bugs were introduced by me $! (Hartmut.Becker@compaq.com). All the bugs were introduced by me
$! (zinser@decus.de), so if you do have problem reports please do not $! (zinser@decus.de), so if you do have problem reports please do not
$! bother Hartmut/HP, but get in touch with me $! bother Hartmut/HP, but get in touch with me
$! $!
$ ANAL_OBJ_AXP: Subroutine $ ANAL_OBJ_AXP: Subroutine
$ V = 'F$Verify(0) $ V = 'F$Verify(0)
$ SAY := "WRITE_ SYS$OUTPUT" $ SAY := "WRITE_ SYS$OUTPUT"
$ $
$ IF F$SEARCH("''P1'") .EQS. "" $ IF F$SEARCH("''P1'") .EQS. ""
$ THEN $ THEN
$ SAY "ANAL_OBJ_AXP-E-NOSUCHFILE: Error, inputfile ''p1' not available" $ SAY "ANAL_OBJ_AXP-E-NOSUCHFILE: Error, inputfile ''p1' not available"
@@ -457,5 +457,5 @@ $ if f$search("x.tmp") .nes. "" -
$! $!
$ EXIT_AA: $ EXIT_AA:
$ if V then set verify $ if V then set verify
$ endsubroutine $ endsubroutine
$!------------------------------------------------------------------------------ $!------------------------------------------------------------------------------

18
old/Makefile.riscos
View File

@@ -3,12 +3,12 @@
# test works out-of-the-box, installs `somewhere' on demand # test works out-of-the-box, installs `somewhere' on demand
# Toolflags: # Toolflags:
CCflags = -c -depend !Depend -IC: -g -throwback -DRISCOS -fah CCflags = -c -depend !Depend -IC: -g -throwback -DRISCOS -fah
C++flags = -c -depend !Depend -IC: -throwback C++flags = -c -depend !Depend -IC: -throwback
Linkflags = -aif -c++ -o $@ Linkflags = -aif -c++ -o $@
ObjAsmflags = -throwback -NoCache -depend !Depend ObjAsmflags = -throwback -NoCache -depend !Depend
CMHGflags = CMHGflags =
LibFileflags = -c -l -o $@ LibFileflags = -c -l -o $@
Squeezeflags = -o $@ Squeezeflags = -o $@
# change the line below to where _you_ want the library installed. # change the line below to where _you_ want the library installed.
@@ -17,10 +17,10 @@ libdest = lib:zlib
# Final targets: # Final targets:
@.lib: @.o.adler32 @.o.compress @.o.crc32 @.o.deflate @.o.gzio \ @.lib: @.o.adler32 @.o.compress @.o.crc32 @.o.deflate @.o.gzio \
@.o.infblock @.o.infcodes @.o.inffast @.o.inflate @.o.inftrees @.o.infutil @.o.trees \ @.o.infblock @.o.infcodes @.o.inffast @.o.inflate @.o.inftrees @.o.infutil @.o.trees \
@.o.uncompr @.o.zutil @.o.uncompr @.o.zutil
LibFile $(LibFileflags) @.o.adler32 @.o.compress @.o.crc32 @.o.deflate \ LibFile $(LibFileflags) @.o.adler32 @.o.compress @.o.crc32 @.o.deflate \
@.o.gzio @.o.infblock @.o.infcodes @.o.inffast @.o.inflate @.o.inftrees @.o.infutil \ @.o.gzio @.o.infblock @.o.infcodes @.o.inffast @.o.inflate @.o.inftrees @.o.infutil \
@.o.trees @.o.uncompr @.o.zutil @.o.trees @.o.uncompr @.o.zutil
test: @.minigzip @.example @.lib test: @.minigzip @.example @.lib
@copy @.lib @.libc A~C~DF~L~N~P~Q~RS~TV @copy @.lib @.libc A~C~DF~L~N~P~Q~RS~TV
@echo running tests: hang on. @echo running tests: hang on.
@@ -41,9 +41,9 @@ test: @.minigzip @.example @.lib
@/@.example @.fred @.fred @/@.example @.fred @.fred
@echo that will have given lots of hello!'s. @echo that will have given lots of hello!'s.
@.minigzip: @.o.minigzip @.lib C:o.Stubs @.minigzip: @.o.minigzip @.lib C:o.Stubs
Link $(Linkflags) @.o.minigzip @.lib C:o.Stubs Link $(Linkflags) @.o.minigzip @.lib C:o.Stubs
@.example: @.o.example @.lib C:o.Stubs @.example: @.o.example @.lib C:o.Stubs
Link $(Linkflags) @.o.example @.lib C:o.Stubs Link $(Linkflags) @.o.example @.lib C:o.Stubs
install: @.lib install: @.lib

16
qnx/package.qpg
View File

@@ -25,10 +25,10 @@
<QPG:Files> <QPG:Files>
<QPG:Add file="../zconf.h" install="/opt/include/" user="root:sys" permission="644"/> <QPG:Add file="../zconf.h" install="/opt/include/" user="root:sys" permission="644"/>
<QPG:Add file="../zlib.h" install="/opt/include/" user="root:sys" permission="644"/> <QPG:Add file="../zlib.h" install="/opt/include/" user="root:sys" permission="644"/>
<QPG:Add file="../libz.so.1.2.2.4" install="/opt/lib/" user="root:bin" permission="644"/> <QPG:Add file="../libz.so.1.2.3" install="/opt/lib/" user="root:bin" permission="644"/>
<QPG:Add file="libz.so" install="/opt/lib/" component="dev" filetype="symlink" linkto="libz.so.1.2.2.4"/> <QPG:Add file="libz.so" install="/opt/lib/" component="dev" filetype="symlink" linkto="libz.so.1.2.3"/>
<QPG:Add file="libz.so.1" install="/opt/lib/" filetype="symlink" linkto="libz.so.1.2.2.4"/> <QPG:Add file="libz.so.1" install="/opt/lib/" filetype="symlink" linkto="libz.so.1.2.3"/>
<QPG:Add file="../libz.so.1.2.2.4" install="/opt/lib/" component="slib"/> <QPG:Add file="../libz.so.1.2.3" install="/opt/lib/" component="slib"/>
</QPG:Files> </QPG:Files>
<QPG:PackageFilter> <QPG:PackageFilter>
@@ -63,7 +63,7 @@
</QPM:ProductDescription> </QPM:ProductDescription>
<QPM:ReleaseDescription> <QPM:ReleaseDescription>
<QPM:ReleaseVersion>1.2.2.4</QPM:ReleaseVersion> <QPM:ReleaseVersion>1.2.3</QPM:ReleaseVersion>
<QPM:ReleaseUrgency>Medium</QPM:ReleaseUrgency> <QPM:ReleaseUrgency>Medium</QPM:ReleaseUrgency>
<QPM:ReleaseStability>Stable</QPM:ReleaseStability> <QPM:ReleaseStability>Stable</QPM:ReleaseStability>
<QPM:ReleaseNoteMinor></QPM:ReleaseNoteMinor> <QPM:ReleaseNoteMinor></QPM:ReleaseNoteMinor>
@@ -105,7 +105,7 @@
</QPM:Script> </QPM:Script>
</QPM:ProductInstallationProcedure> </QPM:ProductInstallationProcedure>
</QPM:PackageManifest> </QPM:PackageManifest>
<QPM:Launch> <QPM:Launch>
</QPM:Launch> </QPM:Launch>
</QPG:PackageFilter> </QPG:PackageFilter>
@@ -119,7 +119,7 @@
</QPM:OrderDependency> </QPM:OrderDependency>
</QPM:ProductInstallationProcedure> </QPM:ProductInstallationProcedure>
</QPM:PackageManifest> </QPM:PackageManifest>
<QPM:Launch> <QPM:Launch>
</QPM:Launch> </QPM:Launch>
</QPG:PackageFilter> </QPG:PackageFilter>
@@ -133,7 +133,7 @@
</QPM:OrderDependency> </QPM:OrderDependency>
</QPM:ProductInstallationProcedure> </QPM:ProductInstallationProcedure>
</QPM:PackageManifest> </QPM:PackageManifest>
<QPM:Launch> <QPM:Launch>
</QPM:Launch> </QPM:Launch>
</QPG:PackageFilter> </QPG:PackageFilter>

8
win32/zlib1.rc
View File

@@ -5,8 +5,8 @@ VS_VERSION_INFO VERSIONINFO
#else #else
VS_VERSION_INFO VERSIONINFO MOVEABLE IMPURE LOADONCALL DISCARDABLE VS_VERSION_INFO VERSIONINFO MOVEABLE IMPURE LOADONCALL DISCARDABLE
#endif #endif
FILEVERSION 1,2,2,4 FILEVERSION 1,2,2,0
PRODUCTVERSION 1,2,2,4 PRODUCTVERSION 1,2,2,0
FILEFLAGSMASK VS_FFI_FILEFLAGSMASK FILEFLAGSMASK VS_FFI_FILEFLAGSMASK
#ifdef _DEBUG #ifdef _DEBUG
FILEFLAGS 1 FILEFLAGS 1
@@ -23,12 +23,12 @@ BEGIN
//language ID = U.S. English, char set = Windows, Multilingual //language ID = U.S. English, char set = Windows, Multilingual
BEGIN BEGIN
VALUE "FileDescription", "zlib data compression library\0" VALUE "FileDescription", "zlib data compression library\0"
VALUE "FileVersion", "1.2.2.4\0" VALUE "FileVersion", "1.2.3\0"
VALUE "InternalName", "zlib1.dll\0" VALUE "InternalName", "zlib1.dll\0"
VALUE "LegalCopyright", "(C) 1995-2004 Jean-loup Gailly & Mark Adler\0" VALUE "LegalCopyright", "(C) 1995-2004 Jean-loup Gailly & Mark Adler\0"
VALUE "OriginalFilename", "zlib1.dll\0" VALUE "OriginalFilename", "zlib1.dll\0"
VALUE "ProductName", "zlib\0" VALUE "ProductName", "zlib\0"
VALUE "ProductVersion", "1.2.2.4\0" VALUE "ProductVersion", "1.2.3\0"
VALUE "Comments","DLL support by Alessandro Iacopetti & Gilles Vollant\0" VALUE "Comments","DLL support by Alessandro Iacopetti & Gilles Vollant\0"
END END
END END

4
zlib.3
View File

@@ -1,4 +1,4 @@
.TH ZLIB 3 "11 July 2005" .TH ZLIB 3 "18 July 2005"
.SH NAME .SH NAME
zlib \- compression/decompression library zlib \- compression/decompression library
.SH SYNOPSIS .SH SYNOPSIS
@@ -133,7 +133,7 @@ before asking for help.
Send questions and/or comments to zlib@gzip.org, Send questions and/or comments to zlib@gzip.org,
or (for the Windows DLL version) to Gilles Vollant (info@winimage.com). or (for the Windows DLL version) to Gilles Vollant (info@winimage.com).
.SH AUTHORS .SH AUTHORS
Version 1.2.2.4 Version 1.2.3
Copyright (C) 1995-2005 Jean-loup Gailly (jloup@gzip.org) Copyright (C) 1995-2005 Jean-loup Gailly (jloup@gzip.org)
and Mark Adler (madler@alumni.caltech.edu). and Mark Adler (madler@alumni.caltech.edu).
.LP .LP

6
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.2.2.4, July 11th, 2005 version 1.2.3, July 18th, 2005
Copyright (C) 1995-2005 Jean-loup Gailly and Mark Adler Copyright (C) 1995-2005 Jean-loup Gailly and Mark Adler
@@ -37,8 +37,8 @@
extern "C" { extern "C" {
#endif #endif
#define ZLIB_VERSION "1.2.2.4" #define ZLIB_VERSION "1.2.3"
#define ZLIB_VERNUM 0x1224 #define ZLIB_VERNUM 0x1230
/* /*
The 'zlib' compression library provides in-memory compression and The 'zlib' compression library provides in-memory compression and