- Updated internal zlib to version 1.2.7.

SVN r3652 (trunk)
2024-11-27 22:42:29 +00:00 · 2012-05-15 18:36:24 +00:00 · 2012-05-15 18:36:24 +00:00 · 1389bc08ca
commit 1389bc08ca
parent 0f8e2441a1
25 changed files with 1211 additions and 1986 deletions
--- a/zlib/CMakeLists.txt
+++ b/zlib/CMakeLists.txt
@ -3,6 +3,8 @@ set(CMAKE_ALLOW_LOOSE_LOOP_CONSTRUCTS ON)
 project(zlib C)
 set(VERSION "1.2.7")
 if(NOT DEFINED BUILD_SHARED_LIBS)
    option(BUILD_SHARED_LIBS "Build a shared library form of zlib" OFF)
 endif()
@ -58,6 +60,7 @@ if(MSVC)
    set(CMAKE_DEBUG_POSTFIX "d")
    add_definitions(-D_CRT_SECURE_NO_DEPRECATE)
    add_definitions(-D_CRT_NONSTDC_NO_DEPRECATE)
    include_directories(${CMAKE_CURRENT_SOURCE_DIR})
 endif()
 #if(NOT CMAKE_CURRENT_SOURCE_DIR STREQUAL CMAKE_CURRENT_BINARY_DIR)
@ -88,7 +91,7 @@ set(ZLIB_PUBLIC_HDRS
 set(ZLIB_PRIVATE_HDRS
    crc32.h
    deflate.h
-#   gzguts.h
+    gzguts.h
    inffast.h
    inffixed.h
    inflate.h
--- a/zlib/ChangeLog
+++ b/zlib/ChangeLog
@ -1,12 +1,213 @@
                ChangeLog file for zlib
 Changes in 1.2.7 (2 May 2012)
 - Replace use of memmove() with a simple copy for portability
 - Test for existence of strerror
 - Restore gzgetc_ for backward compatibility with 1.2.6
 - Fix build with non-GNU make on Solaris
 - Require gcc 4.0 or later on Mac OS X to use the hidden attribute
 - Include unistd.h for Watcom C
 - Use __WATCOMC__ instead of __WATCOM__
 - Do not use the visibility attribute if NO_VIZ defined
 - Improve the detection of no hidden visibility attribute
 - Avoid using __int64 for gcc or solo compilation
 - Cast to char * in gzprintf to avoid warnings [Zinser]
 - Fix make_vms.com for VAX [Zinser]
 - Don't use library or built-in byte swaps
 - Simplify test and use of gcc hidden attribute
 - Fix bug in gzclose_w() when gzwrite() fails to allocate memory
 - Add "x" (O_EXCL) and "e" (O_CLOEXEC) modes support to gzopen()
 - Fix bug in test/minigzip.c for configure --solo
 - Fix contrib/vstudio project link errors [Mohanathas]
 - Add ability to choose the builder in make_vms.com [Schweda]
 - Add DESTDIR support to mingw32 win32/Makefile.gcc
 - Fix comments in win32/Makefile.gcc for proper usage
 - Allow overriding the default install locations for cmake
 - Generate and install the pkg-config file with cmake
 - Build both a static and a shared version of zlib with cmake
 - Include version symbols for cmake builds
 - If using cmake with MSVC, add the source directory to the includes
 - Remove unneeded EXTRA_CFLAGS from win32/Makefile.gcc [Truta]
 - Move obsolete emx makefile to old [Truta]
 - Allow the use of -Wundef when compiling or using zlib
 - Avoid the use of the -u option with mktemp
 - Improve inflate() documentation on the use of Z_FINISH
 - Recognize clang as gcc
 - Add gzopen_w() in Windows for wide character path names
 - Rename zconf.h in CMakeLists.txt to move it out of the way
 - Add source directory in CMakeLists.txt for building examples
 - Look in build directory for zlib.pc in CMakeLists.txt
 - Remove gzflags from zlibvc.def in vc9 and vc10
 - Fix contrib/minizip compilation in the MinGW environment
 - Update ./configure for Solaris, support --64 [Mooney]
 - Remove -R. from Solaris shared build (possible security issue)
 - Avoid race condition for parallel make (-j) running example
 - Fix type mismatch between get_crc_table() and crc_table
 - Fix parsing of version with "-" in CMakeLists.txt [Snider, Ziegler]
 - Fix the path to zlib.map in CMakeLists.txt
 - Force the native libtool in Mac OS X to avoid GNU libtool [Beebe]
 - Add instructions to win32/Makefile.gcc for shared install [Torri]
 Changes in 1.2.6.1 (12 Feb 2012)
 - Avoid the use of the Objective-C reserved name "id"
 - Include io.h in gzguts.h for Microsoft compilers
 - Fix problem with ./configure --prefix and gzgetc macro
 - Include gz_header definition when compiling zlib solo
 - Put gzflags() functionality back in zutil.c
 - Avoid library header include in crc32.c for Z_SOLO
 - Use name in GCC_CLASSIC as C compiler for coverage testing, if set
 - Minor cleanup in contrib/minizip/zip.c [Vollant]
 - Update make_vms.com [Zinser]
 - Remove unnecessary gzgetc_ function
 - Use optimized byte swap operations for Microsoft and GNU [Snyder]
 - Fix minor typo in zlib.h comments [Rzesniowiecki]
 Changes in 1.2.6 (29 Jan 2012)
 - Update the Pascal interface in contrib/pascal
 - Fix function numbers for gzgetc_ in zlibvc.def files
 - Fix configure.ac for contrib/minizip [Schiffer]
 - Fix large-entry detection in minizip on 64-bit systems [Schiffer]
 - Have ./configure use the compiler return code for error indication
 - Fix CMakeLists.txt for cross compilation [McClure]
 - Fix contrib/minizip/zip.c for 64-bit architectures [Dalsnes]
 - Fix compilation of contrib/minizip on FreeBSD [Marquez]
 - Correct suggested usages in win32/Makefile.msc [Shachar, Horvath]
 - Include io.h for Turbo C / Borland C on all platforms [Truta]
 - Make version explicit in contrib/minizip/configure.ac [Bosmans]
 - Avoid warning for no encryption in contrib/minizip/zip.c [Vollant]
 - Minor cleanup up contrib/minizip/unzip.c [Vollant]
 - Fix bug when compiling minizip with C++ [Vollant]
 - Protect for long name and extra fields in contrib/minizip [Vollant]
 - Avoid some warnings in contrib/minizip [Vollant]
 - Add -I../.. -L../.. to CFLAGS for minizip and miniunzip
 - Add missing libs to minizip linker command
 - Add support for VPATH builds in contrib/minizip
 - Add an --enable-demos option to contrib/minizip/configure
 - Add the generation of configure.log by ./configure
 - Exit when required parameters not provided to win32/Makefile.gcc
 - Have gzputc return the character written instead of the argument
 - Use the -m option on ldconfig for BSD systems [Tobias]
 - Correct in zlib.map when deflateResetKeep was added
 Changes in 1.2.5.3 (15 Jan 2012)
 - Restore gzgetc function for binary compatibility
 - Do not use _lseeki64 under Borland C++ [Truta]
 - Update win32/Makefile.msc to build test/*.c [Truta]
 - Remove old/visualc6 given CMakefile and other alternatives
 - Update AS400 build files and documentation [Monnerat]
 - Update win32/Makefile.gcc to build test/*.c [Truta]
 - Permit stronger flushes after Z_BLOCK flushes
 - Avoid extraneous empty blocks when doing empty flushes
 - Permit Z_NULL arguments to deflatePending
 - Allow deflatePrime() to insert bits in the middle of a stream
 - Remove second empty static block for Z_PARTIAL_FLUSH
 - Write out all of the available bits when using Z_BLOCK
 - Insert the first two strings in the hash table after a flush
 Changes in 1.2.5.2 (17 Dec 2011)
 - fix ld error: unable to find version dependency 'ZLIB_1.2.5'
 - use relative symlinks for shared libs
 - Avoid searching past window for Z_RLE strategy
 - Assure that high-water mark initialization is always applied in deflate
 - Add assertions to fill_window() in deflate.c to match comments
 - Update python link in README
 - Correct spelling error in gzread.c
 - Fix bug in gzgets() for a concatenated empty gzip stream
 - Correct error in comment for gz_make()
 - Change gzread() and related to ignore junk after gzip streams
 - Allow gzread() and related to continue after gzclearerr()
 - Allow gzrewind() and gzseek() after a premature end-of-file
 - Simplify gzseek() now that raw after gzip is ignored
 - Change gzgetc() to a macro for speed (~40% speedup in testing)
 - Fix gzclose() to return the actual error last encountered
 - Always add large file support for windows
 - Include zconf.h for windows large file support
 - Include zconf.h.cmakein for windows large file support
 - Update zconf.h.cmakein on make distclean
 - Merge vestigial vsnprintf determination from zutil.h to gzguts.h
 - Clarify how gzopen() appends in zlib.h comments
 - Correct documentation of gzdirect() since junk at end now ignored
 - Add a transparent write mode to gzopen() when 'T' is in the mode
 - Update python link in zlib man page
 - Get inffixed.h and MAKEFIXED result to match
 - Add a ./config --solo option to make zlib subset with no libary use
 - Add undocumented inflateResetKeep() function for CAB file decoding
 - Add --cover option to ./configure for gcc coverage testing
 - Add #define ZLIB_CONST option to use const in the z_stream interface
 - Add comment to gzdopen() in zlib.h to use dup() when using fileno()
 - Note behavior of uncompress() to provide as much data as it can
 - Add files in contrib/minizip to aid in building libminizip
 - Split off AR options in Makefile.in and configure
 - Change ON macro to Z_ARG to avoid application conflicts
 - Facilitate compilation with Borland C++ for pragmas and vsnprintf
 - Include io.h for Turbo C / Borland C++
 - Move example.c and minigzip.c to test/
 - Simplify incomplete code table filling in inflate_table()
 - Remove code from inflate.c and infback.c that is impossible to execute
 - Test the inflate code with full coverage
 - Allow deflateSetDictionary, inflateSetDictionary at any time (in raw)
 - Add deflateResetKeep and fix inflateResetKeep to retain dictionary
 - Fix gzwrite.c to accommodate reduced memory zlib compilation
 - Have inflate() with Z_FINISH avoid the allocation of a window
 - Do not set strm->adler when doing raw inflate
 - Fix gzeof() to behave just like feof() when read is not past end of file
 - Fix bug in gzread.c when end-of-file is reached
 - Avoid use of Z_BUF_ERROR in gz* functions except for premature EOF
 - Document gzread() capability to read concurrently written files
 - Remove hard-coding of resource compiler in CMakeLists.txt [Blammo]
 Changes in 1.2.5.1 (10 Sep 2011)
 - Update FAQ entry on shared builds (#13)
 - Avoid symbolic argument to chmod in Makefile.in
 - Fix bug and add consts in contrib/puff [Oberhumer]
 - Update contrib/puff/zeros.raw test file to have all block types
 - Add full coverage test for puff in contrib/puff/Makefile
 - Fix static-only-build install in Makefile.in
 - Fix bug in unzGetCurrentFileInfo() in contrib/minizip [Kuno]
 - Add libz.a dependency to shared in Makefile.in for parallel builds
 - Spell out "number" (instead of "nb") in zlib.h for total_in, total_out
 - Replace $(...) with `...` in configure for non-bash sh [Bowler]
 - Add darwin* to Darwin* and solaris* to SunOS\ 5* in configure [Groffen]
 - Add solaris* to Linux* in configure to allow gcc use [Groffen]
 - Add *bsd* to Linux* case in configure [Bar-Lev]
 - Add inffast.obj to dependencies in win32/Makefile.msc
 - Correct spelling error in deflate.h [Kohler]
 - Change libzdll.a again to libz.dll.a (!) in win32/Makefile.gcc
 - Add test to configure for GNU C looking for gcc in output of $cc -v
 - Add zlib.pc generation to win32/Makefile.gcc [Weigelt]
 - Fix bug in zlib.h for _FILE_OFFSET_BITS set and _LARGEFILE64_SOURCE not
 - Add comment in zlib.h that adler32_combine with len2 < 0 makes no sense
 - Make NO_DIVIDE option in adler32.c much faster (thanks to John Reiser)
 - Make stronger test in zconf.h to include unistd.h for LFS
 - Apply Darwin patches for 64-bit file offsets to contrib/minizip [Slack]
 - Fix zlib.h LFS support when Z_PREFIX used
 - Add updated as400 support (removed from old) [Monnerat]
 - Avoid deflate sensitivity to volatile input data
 - Avoid division in adler32_combine for NO_DIVIDE
 - Clarify the use of Z_FINISH with deflateBound() amount of space
 - Set binary for output file in puff.c
 - Use u4 type for crc_table to avoid conversion warnings
 - Apply casts in zlib.h to avoid conversion warnings
 - Add OF to prototypes for adler32_combine_ and crc32_combine_ [Miller]
 - Improve inflateSync() documentation to note indeterminancy
 - Add deflatePending() function to return the amount of pending output
 - Correct the spelling of "specification" in FAQ [Randers-Pehrson]
 - Add a check in configure for stdarg.h, use for gzprintf()
 - Check that pointers fit in ints when gzprint() compiled old style
 - Add dummy name before $(SHAREDLIBV) in Makefile [Bar-Lev, Bowler]
 - Delete line in configure that adds -L. libz.a to LDFLAGS [Weigelt]
 - Add debug records in assmebler code [Londer]
 - Update RFC references to use http://tools.ietf.org/html/... [Li]
 - Add --archs option, use of libtool to configure for Mac OS X [Borstel]
 Changes in 1.2.5 (19 Apr 2010)
 - Disable visibility attribute in win32/Makefile.gcc [Bar-Lev]
 - Default to libdir as sharedlibdir in configure [Nieder]
 - Update copyright dates on modified source files
 - Update trees.c to be able to generate modified trees.h
 - Exit configure for MinGW, suggesting win32/Makefile.gcc
 - Check for NULL path in gz_open [Homurlu]
 Changes in 1.2.4.5 (18 Apr 2010)
 - Set sharedlibdir in configure [Torok]
@ -261,7 +462,7 @@ Changes in 1.2.3.4 (21 Dec 2009)
 - Clear bytes after deflate lookahead to avoid use of uninitialized data
 - Change a limit in inftrees.c to be more transparent to Coverity Prevent
 - Update win32/zlib.def with exported symbols from zlib.h
- Correct spelling error in zlib.h [Willem]
+- Correct spelling errors in zlib.h [Willem, Sobrado]
 - Allow Z_BLOCK for deflate() to force a new block
 - Allow negative bits in inflatePrime() to delete existing bit buffer
 - Add Z_TREES flush option to inflate() to return at end of trees
--- a/zlib/FAQ
+++ b/zlib/FAQ
@ -44,8 +44,8 @@ The lastest zlib FAQ is at http://zlib.net/zlib_faq.html
 6. Where's the zlib documentation (man pages, etc.)?
-    It's in zlib.h .  Examples of zlib usage are in the files example.c and
+    It's in zlib.h .  Examples of zlib usage are in the files test/example.c
-    minigzip.c, with more in examples/ .
+    and test/minigzip.c, with more in examples/ .
 7. Why don't you use GNU autoconf or libtool or ...?
@ -84,8 +84,10 @@ The lastest zlib FAQ is at http://zlib.net/zlib_faq.html
 13. How can I make a Unix shared library?
-    make clean
+    By default a shared (and a static) library is built for Unix.  So:
-    ./configure -s
+
    make distclean
    ./configure
    make
 14. How do I install a shared zlib library on Unix?
@ -325,7 +327,7 @@ The lastest zlib FAQ is at http://zlib.net/zlib_faq.html
    correctly points to the zlib specification in RFC 1950 for the "deflate"
    transfer encoding, there have been reports of servers and browsers that
    incorrectly produce or expect raw deflate data per the deflate
-    specficiation in RFC 1951, most notably Microsoft.  So even though the
+    specification in RFC 1951, most notably Microsoft.  So even though the
    "deflate" transfer encoding using the zlib format would be the more
    efficient approach (and in fact exactly what the zlib format was designed
    for), using the "gzip" transfer encoding is probably more reliable due to
--- a/zlib/INDEX
+++ b/zlib/INDEX
@ -7,6 +7,9 @@ Makefile.in     template for Unix Makefile
 README          guess what
 configure       configure script for Unix
 make_vms.com    makefile for VMS
 test/example.c  zlib usages examples for build testing
 test/minigzip.c minimal gzip-like functionality for build testing
 test/infcover.c inf*.c code coverage for build coverage testing
 treebuild.xml   XML description of source file dependencies
 zconf.h.cmakein zconf.h template for cmake
 zconf.h.in      zconf.h template for configure
@ -14,9 +17,11 @@ zlib.3          Man page for zlib
 zlib.3.pdf      Man page in PDF format
 zlib.map        Linux symbol information
 zlib.pc.in      Template for pkg-config descriptor
 zlib.pc.cmakein zlib.pc template for cmake
 zlib2ansi       perl script to convert source files for C++ compilation
 amiga/          makefiles for Amiga SAS C
 as400/          makefiles for AS/400
 doc/            documentation for formats and algorithms
 msdos/          makefiles for MSDOS
 nintendods/     makefile for Nintendo DS
@ -56,10 +61,8 @@ uncompr.c
 zutil.c
 zutil.h
-                source files for sample programs:
+                source files for sample programs
-example.c
+See examples/README.examples
 minigzip.c
 See examples/README.examples for more
-                unsupported contribution by third parties
+                unsupported contributions by third parties
 See contrib/README.contrib
--- a/zlib/adler32.c
+++ b/zlib/adler32.c
@ -1,5 +1,5 @@
 /* adler32.c -- compute the Adler-32 checksum of a data stream
- * Copyright (C) 1995-2007 Mark Adler
+ * Copyright (C) 1995-2011 Mark Adler
 * For conditions of distribution and use, see copyright notice in zlib.h
 */
@ -9,9 +9,9 @@
 #define local static
-local uLong adler32_combine_(uLong adler1, uLong adler2, z_off64_t len2);
+local uLong adler32_combine_ OF((uLong adler1, uLong adler2, z_off64_t len2));
-#define BASE 65521UL    /* largest prime smaller than 65536 */
+#define BASE 65521      /* largest prime smaller than 65536 */
 #define NMAX 5552
 /* NMAX is the largest n such that 255n(n+1)/2 + (n+1)(BASE-1) <= 2^32-1 */
@ -21,39 +21,44 @@ local uLong adler32_combine_(uLong adler1, uLong adler2, z_off64_t len2);
 #define DO8(buf,i)  DO4(buf,i); DO4(buf,i+4);
 #define DO16(buf)   DO8(buf,0); DO8(buf,8);
-/* use NO_DIVIDE if your processor does not do division in hardware */
+/* use NO_DIVIDE if your processor does not do division in hardware --
   try it both ways to see which is faster */
 #ifdef NO_DIVIDE
-#  define MOD(a) \
+/* note that this assumes BASE is 65521, where 65536 % 65521 == 15
   (thank you to John Reiser for pointing this out) */
 #  define CHOP(a) \
    do { \
-        if (a >= (BASE << 16)) a -= (BASE << 16); \
+        unsigned long tmp = a >> 16; \
-        if (a >= (BASE << 15)) a -= (BASE << 15); \
+        a &= 0xffffUL; \
-        if (a >= (BASE << 14)) a -= (BASE << 14); \
+        a += (tmp << 4) - tmp; \
-        if (a >= (BASE << 13)) a -= (BASE << 13); \
+    } while (0)
-        if (a >= (BASE << 12)) a -= (BASE << 12); \
+#  define MOD28(a) \
-        if (a >= (BASE << 11)) a -= (BASE << 11); \
+    do { \
-        if (a >= (BASE << 10)) a -= (BASE << 10); \
+        CHOP(a); \
        if (a >= (BASE << 9)) a -= (BASE << 9); \
        if (a >= (BASE << 8)) a -= (BASE << 8); \
        if (a >= (BASE << 7)) a -= (BASE << 7); \
        if (a >= (BASE << 6)) a -= (BASE << 6); \
        if (a >= (BASE << 5)) a -= (BASE << 5); \
        if (a >= (BASE << 4)) a -= (BASE << 4); \
        if (a >= (BASE << 3)) a -= (BASE << 3); \
        if (a >= (BASE << 2)) a -= (BASE << 2); \
        if (a >= (BASE << 1)) a -= (BASE << 1); \
        if (a >= BASE) a -= BASE; \
    } while (0)
-#  define MOD4(a) \
+#  define MOD(a) \
    do { \
-        if (a >= (BASE << 4)) a -= (BASE << 4); \
+        CHOP(a); \
-        if (a >= (BASE << 3)) a -= (BASE << 3); \
+        MOD28(a); \
-        if (a >= (BASE << 2)) a -= (BASE << 2); \
+    } while (0)
-        if (a >= (BASE << 1)) a -= (BASE << 1); \
+#  define MOD63(a) \
    do { /* this assumes a is not negative */ \
        z_off64_t tmp = a >> 32; \
        a &= 0xffffffffL; \
        a += (tmp << 8) - (tmp << 5) + tmp; \
        tmp = a >> 16; \
        a &= 0xffffL; \
        a += (tmp << 4) - tmp; \
        tmp = a >> 16; \
        a &= 0xffffL; \
        a += (tmp << 4) - tmp; \
        if (a >= BASE) a -= BASE; \
    } while (0)
 #else
 #  define MOD(a) a %= BASE
-#  define MOD4(a) a %= BASE
+#  define MOD28(a) a %= BASE
 #  define MOD63(a) a %= BASE
 #endif
 /* ========================================================================= */
@ -92,7 +97,7 @@ uLong ZEXPORT adler32(adler, buf, len)
        }
        if (adler >= BASE)
            adler -= BASE;
-        MOD4(sum2);             /* only added so many BASE's */
+        MOD28(sum2);            /* only added so many BASE's */
        return adler | (sum2 << 16);
    }
@ -137,8 +142,13 @@ local uLong adler32_combine_(adler1, adler2, len2)
    unsigned long sum2;
    unsigned rem;
    /* for negative len, return invalid adler32 as a clue for debugging */
    if (len2 < 0)
        return 0xffffffffUL;
    /* the derivation of this formula is left as an exercise for the reader */
-    rem = (unsigned)(len2 % BASE);
+    MOD63(len2);                /* assumes len2 >= 0 */
    rem = (unsigned)len2;
    sum1 = adler1 & 0xffff;
    sum2 = rem * sum1;
    MOD(sum2);
--- a/zlib/crc32.c
+++ b/zlib/crc32.c
@ -1,5 +1,5 @@
 /* crc32.c -- compute the CRC-32 of a data stream
- * Copyright (C) 1995-2006, 2010 Mark Adler
+ * Copyright (C) 1995-2006, 2010, 2011, 2012 Mark Adler
 * For conditions of distribution and use, see copyright notice in zlib.h
 *
 * Thanks to Rodney Brown <rbrown64@csc.com.au> for his contribution of faster
@ -17,6 +17,8 @@
  of the crc tables.  Therefore, if you #define DYNAMIC_CRC_TABLE, you should
  first call get_crc_table() to initialize the tables before allowing more than
  one thread to use crc32().
  DYNAMIC_CRC_TABLE and MAKECRCH can be #defined to write out crc32.h.
 */
 #ifdef MAKECRCH
@ -30,31 +32,11 @@
 #define local static
 /* Find a four-byte integer type for crc32_little() and crc32_big(). */
 #ifndef NOBYFOUR
 #  ifdef STDC           /* need ANSI C limits.h to determine sizes */
 #    include <limits.h>
 #    define BYFOUR
 #    if (UINT_MAX == 0xffffffffUL)
       typedef unsigned int u4;
 #    else
 #      if (ULONG_MAX == 0xffffffffUL)
         typedef unsigned long u4;
 #      else
 #        if (USHRT_MAX == 0xffffffffUL)
           typedef unsigned short u4;
 #        else
 #          undef BYFOUR     /* can't find a four-byte integer type! */
 #        endif
 #      endif
 #    endif
 #  endif /* STDC */
 #endif /* !NOBYFOUR */
 /* Definitions for doing the crc four data bytes at a time. */
 #if !defined(NOBYFOUR) && defined(Z_U4)
 #  define BYFOUR
 #endif
 #ifdef BYFOUR
 #  define REV(w) ((((w)>>24)&0xff)+(((w)>>8)&0xff00)+ \
                (((w)&0xff00)<<8)+(((w)&0xff)<<24))
   local unsigned long crc32_little OF((unsigned long,
                        const unsigned char FAR *, unsigned));
   local unsigned long crc32_big OF((unsigned long,
@ -68,16 +50,16 @@
 local unsigned long gf2_matrix_times OF((unsigned long *mat,
                                         unsigned long vec));
 local void gf2_matrix_square OF((unsigned long *square, unsigned long *mat));
-local uLong crc32_combine_(uLong crc1, uLong crc2, z_off64_t len2);
+local uLong crc32_combine_ OF((uLong crc1, uLong crc2, z_off64_t len2));
 #ifdef DYNAMIC_CRC_TABLE
 local volatile int crc_table_empty = 1;
-local unsigned long FAR crc_table[TBLS][256];
+local z_crc_t FAR crc_table[TBLS][256];
 local void make_crc_table OF((void));
 #ifdef MAKECRCH
-   local void write_table OF((FILE *, const unsigned long FAR *));
+   local void write_table OF((FILE *, const z_crc_t FAR *));
 #endif /* MAKECRCH */
 /*
  Generate tables for a byte-wise 32-bit CRC calculation on the polynomial:
@ -107,9 +89,9 @@ local void make_crc_table OF((void));
 */
 local void make_crc_table()
 {
-    unsigned long c;
+    z_crc_t c;
    int n, k;
-    unsigned long poly;                 /* polynomial exclusive-or pattern */
+    z_crc_t poly;                       /* polynomial exclusive-or pattern */
    /* terms of polynomial defining this crc (except x^32): */
    static volatile int first = 1;      /* flag to limit concurrent making */
    static const unsigned char p[] = {0,1,2,4,5,7,8,10,11,12,16,22,23,26};
@ -121,13 +103,13 @@ local void make_crc_table()
        first = 0;
        /* make exclusive-or pattern from polynomial (0xedb88320UL) */
-        poly = 0UL;
+        poly = 0;
-        for (n = 0; n < sizeof(p)/sizeof(unsigned char); n++)
+        for (n = 0; n < (int)(sizeof(p)/sizeof(unsigned char)); n++)
-            poly |= 1UL << (31 - p[n]);
+            poly |= (z_crc_t)1 << (31 - p[n]);
        /* generate a crc for every 8-bit value */
        for (n = 0; n < 256; n++) {
-            c = (unsigned long)n;
+            c = (z_crc_t)n;
            for (k = 0; k < 8; k++)
                c = c & 1 ? poly ^ (c >> 1) : c >> 1;
            crc_table[0][n] = c;
@ -138,11 +120,11 @@ local void make_crc_table()
           and then the byte reversal of those as well as the first table */
        for (n = 0; n < 256; n++) {
            c = crc_table[0][n];
-            crc_table[4][n] = REV(c);
+            crc_table[4][n] = ZSWAP32(c);
            for (k = 1; k < 4; k++) {
                c = crc_table[0][c & 0xff] ^ (c >> 8);
                crc_table[k][n] = c;
-                crc_table[k + 4][n] = REV(c);
+                crc_table[k + 4][n] = ZSWAP32(c);
            }
        }
 #endif /* BYFOUR */
@ -164,7 +146,7 @@ local void make_crc_table()
        if (out == NULL) return;
        fprintf(out, "/* crc32.h -- tables for rapid CRC calculation\n");
        fprintf(out, " * Generated automatically by crc32.c\n */\n\n");
-        fprintf(out, "local const unsigned long FAR ");
+        fprintf(out, "local const z_crc_t FAR ");
        fprintf(out, "crc_table[TBLS][256] =\n{\n  {\n");
        write_table(out, crc_table[0]);
 #  ifdef BYFOUR
@ -184,12 +166,13 @@ local void make_crc_table()
 #ifdef MAKECRCH
 local void write_table(out, table)
    FILE *out;
-    const unsigned long FAR *table;
+    const z_crc_t FAR *table;
 {
    int n;
    for (n = 0; n < 256; n++)
-        fprintf(out, "%s0x%08lxUL%s", n % 5 ? "" : "    ", table[n],
+        fprintf(out, "%s0x%08lxUL%s", n % 5 ? "" : "    ",
                (unsigned long)(table[n]),
                n == 255 ? "\n" : (n % 5 == 4 ? ",\n" : ", "));
 }
 #endif /* MAKECRCH */
@ -204,13 +187,13 @@ local void write_table(out, table)
 /* =========================================================================
 * This function can be used by asm versions of crc32()
 */
-const unsigned long FAR * ZEXPORT get_crc_table()
+const z_crc_t FAR * ZEXPORT get_crc_table()
 {
 #ifdef DYNAMIC_CRC_TABLE
    if (crc_table_empty)
        make_crc_table();
 #endif /* DYNAMIC_CRC_TABLE */
-    return (const unsigned long FAR *)crc_table;
+    return (const z_crc_t FAR *)crc_table;
 }
 /* ========================================================================= */
@ -232,7 +215,7 @@ unsigned long ZEXPORT crc32(crc, buf, len)
 #ifdef BYFOUR
    if (sizeof(void *) == sizeof(ptrdiff_t)) {
-        u4 endian;
+        z_crc_t endian;
        endian = 1;
        if (*((unsigned char *)(&endian)))
@ -266,17 +249,17 @@ local unsigned long crc32_little(crc, buf, len)
    const unsigned char FAR *buf;
    unsigned len;
 {
-    register u4 c;
+    register z_crc_t c;
-    register const u4 FAR *buf4;
+    register const z_crc_t FAR *buf4;
-    c = (u4)crc;
+    c = (z_crc_t)crc;
    c = ~c;
    while (len && ((ptrdiff_t)buf & 3)) {
        c = crc_table[0][(c ^ *buf++) & 0xff] ^ (c >> 8);
        len--;
    }
-    buf4 = (const u4 FAR *)(const void FAR *)buf;
+    buf4 = (const z_crc_t FAR *)(const void FAR *)buf;
    while (len >= 32) {
        DOLIT32;
        len -= 32;
@ -306,17 +289,17 @@ local unsigned long crc32_big(crc, buf, len)
    const unsigned char FAR *buf;
    unsigned len;
 {
-    register u4 c;
+    register z_crc_t c;
-    register const u4 FAR *buf4;
+    register const z_crc_t FAR *buf4;
-    c = REV((u4)crc);
+    c = ZSWAP32((z_crc_t)crc);
    c = ~c;
    while (len && ((ptrdiff_t)buf & 3)) {
        c = crc_table[4][(c >> 24) ^ *buf++] ^ (c << 8);
        len--;
    }
-    buf4 = (const u4 FAR *)(const void FAR *)buf;
+    buf4 = (const z_crc_t FAR *)(const void FAR *)buf;
    buf4--;
    while (len >= 32) {
        DOBIG32;
@ -333,7 +316,7 @@ local unsigned long crc32_big(crc, buf, len)
        c = crc_table[4][(c >> 24) ^ *buf++] ^ (c << 8);
    } while (--len);
    c = ~c;
-    return (unsigned long)(REV(c));
+    return (unsigned long)(ZSWAP32(c));
 }
 #endif /* BYFOUR */
--- a/zlib/crc32.h
+++ b/zlib/crc32.h
@ -2,7 +2,7 @@
 * Generated automatically by crc32.c
 */
-local const unsigned long FAR crc_table[TBLS][256] =
+local const z_crc_t FAR crc_table[TBLS][256] =
 {
  {
    0x00000000UL, 0x77073096UL, 0xee0e612cUL, 0x990951baUL, 0x076dc419UL,
--- a/zlib/deflate.c
+++ b/zlib/deflate.c
@ -1,5 +1,5 @@
 /* deflate.c -- compress data using the deflation algorithm
- * Copyright (C) 1995-2010 Jean-loup Gailly and Mark Adler
+ * Copyright (C) 1995-2012 Jean-loup Gailly and Mark Adler
 * For conditions of distribution and use, see copyright notice in zlib.h
 */
@ -37,7 +37,7 @@
 *  REFERENCES
 *
 *      Deutsch, L.P.,"DEFLATE Compressed Data Format Specification".
- *      Available in http://www.ietf.org/rfc/rfc1951.txt
+ *      Available in http://tools.ietf.org/html/rfc1951
 *
 *      A description of the Rabin and Karp algorithm is given in the book
 *         "Algorithms" by R. Sedgewick, Addison-Wesley, p252.
@ -52,7 +52,7 @@
 #include "deflate.h"
 const char deflate_copyright[] =
-   " deflate 1.2.5 Copyright 1995-2010 Jean-loup Gailly and Mark Adler ";
+   " deflate 1.2.7 Copyright 1995-2012 Jean-loup Gailly and Mark Adler ";
 /*
  If you use the zlib library in a product, an acknowledgment is welcome
  in the documentation of your product. If for some reason you cannot
@ -155,6 +155,9 @@ local const config configuration_table[10] = {
 struct static_tree_desc_s {int dummy;}; /* for buggy compilers */
 #endif
 /* rank Z_BLOCK between Z_NO_FLUSH and Z_PARTIAL_FLUSH */
 #define RANK(f) (((f) << 1) - ((f) > 4 ? 9 : 0))
 /* ===========================================================================
 * Update a hash value with the given input byte
 * IN  assertion: all calls to to UPDATE_HASH are made with consecutive
@ -235,10 +238,19 @@ int ZEXPORT deflateInit2_(strm, level, method, windowBits, memLevel, strategy,
    strm->msg = Z_NULL;
    if (strm->zalloc == (alloc_func)0) {
 #ifdef Z_SOLO
        return Z_STREAM_ERROR;
 #else
        strm->zalloc = zcalloc;
        strm->opaque = (voidpf)0;
 #endif
    }
-    if (strm->zfree == (free_func)0) strm->zfree = zcfree;
+    if (strm->zfree == (free_func)0)
 #ifdef Z_SOLO
        return Z_STREAM_ERROR;
 #else
        strm->zfree = zcfree;
 #endif
 #ifdef FASTEST
    if (level != 0) level = 1;
@ -314,43 +326,70 @@ int ZEXPORT deflateSetDictionary (strm, dictionary, dictLength)
    uInt  dictLength;
 {
    deflate_state *s;
-    uInt length = dictLength;
+    uInt str, n;
-    uInt n;
+    int wrap;
-    IPos hash_head = 0;
+    unsigned avail;
    unsigned char *next;
-    if (strm == Z_NULL || strm->state == Z_NULL || dictionary == Z_NULL ||
+    if (strm == Z_NULL || strm->state == Z_NULL || dictionary == Z_NULL)
-        strm->state->wrap == 2 ||
+        return Z_STREAM_ERROR;
-        (strm->state->wrap == 1 && strm->state->status != INIT_STATE))
+    s = strm->state;
    wrap = s->wrap;
    if (wrap == 2 || (wrap == 1 && s->status != INIT_STATE) || s->lookahead)
        return Z_STREAM_ERROR;
-    s = strm->state;
+    /* when using zlib wrappers, compute Adler-32 for provided dictionary */
-    if (s->wrap)
+    if (wrap == 1)
        strm->adler = adler32(strm->adler, dictionary, dictLength);
    s->wrap = 0;                    /* avoid computing Adler-32 in read_buf */
-    if (length < MIN_MATCH) return Z_OK;
+    /* if dictionary would fill window, just replace the history */
-    if (length > s->w_size) {
+    if (dictLength >= s->w_size) {
-        length = s->w_size;
+        if (wrap == 0) {            /* already empty otherwise */
-        dictionary += dictLength - length; /* use the tail of the dictionary */
+            CLEAR_HASH(s);
            s->strstart = 0;
            s->block_start = 0L;
            s->insert = 0;
        }
        dictionary += dictLength - s->w_size;  /* use the tail */
        dictLength = s->w_size;
    }
    zmemcpy(s->window, dictionary, length);
    s->strstart = length;
    s->block_start = (long)length;
-    /* Insert all strings in the hash table (except for the last two bytes).
+    /* insert dictionary into window and hash */
-     * s->lookahead stays null, so s->ins_h will be recomputed at the next
+    avail = strm->avail_in;
-     * call of fill_window.
+    next = strm->next_in;
-     */
+    strm->avail_in = dictLength;
-    s->ins_h = s->window[0];
+    strm->next_in = (Bytef *)dictionary;
-    UPDATE_HASH(s, s->ins_h, s->window[1]);
+    fill_window(s);
-    for (n = 0; n <= length - MIN_MATCH; n++) {
+    while (s->lookahead >= MIN_MATCH) {
-        INSERT_STRING(s, n, hash_head);
+        str = s->strstart;
        n = s->lookahead - (MIN_MATCH-1);
        do {
            UPDATE_HASH(s, s->ins_h, s->window[str + MIN_MATCH-1]);
 #ifndef FASTEST
            s->prev[str & s->w_mask] = s->head[s->ins_h];
 #endif
            s->head[s->ins_h] = (Pos)str;
            str++;
        } while (--n);
        s->strstart = str;
        s->lookahead = MIN_MATCH-1;
        fill_window(s);
    }
-    if (hash_head) hash_head = 0;  /* to make compiler happy */
+    s->strstart += s->lookahead;
    s->block_start = (long)s->strstart;
    s->insert = s->lookahead;
    s->lookahead = 0;
    s->match_length = s->prev_length = MIN_MATCH-1;
    s->match_available = 0;
    strm->next_in = next;
    strm->avail_in = avail;
    s->wrap = wrap;
    return Z_OK;
 }
 /* ========================================================================= */
-int ZEXPORT deflateReset (strm)
+int ZEXPORT deflateResetKeep (strm)
    z_streamp strm;
 {
    deflate_state *s;
@ -380,11 +419,22 @@ int ZEXPORT deflateReset (strm)
    s->last_flush = Z_NO_FLUSH;
    _tr_init(s);
    lm_init(s);
    return Z_OK;
 }
 /* ========================================================================= */
 int ZEXPORT deflateReset (strm)
    z_streamp strm;
 {
    int ret;
    ret = deflateResetKeep(strm);
    if (ret == Z_OK)
        lm_init(strm->state);
    return ret;
 }
 /* ========================================================================= */
 int ZEXPORT deflateSetHeader (strm, head)
    z_streamp strm;
@ -396,15 +446,43 @@ int ZEXPORT deflateSetHeader (strm, head)
    return Z_OK;
 }
 /* ========================================================================= */
 int ZEXPORT deflatePending (strm, pending, bits)
    unsigned *pending;
    int *bits;
    z_streamp strm;
 {
    if (strm == Z_NULL || strm->state == Z_NULL) return Z_STREAM_ERROR;
    if (pending != Z_NULL)
        *pending = strm->state->pending;
    if (bits != Z_NULL)
        *bits = strm->state->bi_valid;
    return Z_OK;
 }
 /* ========================================================================= */
 int ZEXPORT deflatePrime (strm, bits, value)
    z_streamp strm;
    int bits;
    int value;
 {
    deflate_state *s;
    int put;
    if (strm == Z_NULL || strm->state == Z_NULL) return Z_STREAM_ERROR;
-    strm->state->bi_valid = bits;
+    s = strm->state;
-    strm->state->bi_buf = (ush)(value & ((1 << bits) - 1));
+    if ((Bytef *)(s->d_buf) < s->pending_out + ((Buf_size + 7) >> 3))
        return Z_BUF_ERROR;
    do {
        put = Buf_size - s->bi_valid;
        if (put > bits)
            put = bits;
        s->bi_buf |= (ush)((value & ((1 << put) - 1)) << s->bi_valid);
        s->bi_valid += put;
        _tr_flush_bits(s);
        value >>= put;
        bits -= put;
    } while (bits);
    return Z_OK;
 }
@ -562,19 +640,22 @@ local void putShortMSB (s, b)
 local void flush_pending(strm)
    z_streamp strm;
 {
-    unsigned len = strm->state->pending;
+    unsigned len;
    deflate_state *s = strm->state;
    _tr_flush_bits(s);
    len = s->pending;
    if (len > strm->avail_out) len = strm->avail_out;
    if (len == 0) return;
-    zmemcpy(strm->next_out, strm->state->pending_out, len);
+    zmemcpy(strm->next_out, s->pending_out, len);
    strm->next_out  += len;
-    strm->state->pending_out  += len;
+    s->pending_out  += len;
    strm->total_out += len;
    strm->avail_out  -= len;
-    strm->state->pending -= len;
+    s->pending -= len;
-    if (strm->state->pending == 0) {
+    if (s->pending == 0) {
-        strm->state->pending_out = strm->state->pending_buf;
+        s->pending_out = s->pending_buf;
    }
 }
@ -801,7 +882,7 @@ int ZEXPORT deflate (strm, flush)
     * flushes. For repeated and useless calls with Z_FINISH, we keep
     * returning Z_STREAM_END instead of Z_BUF_ERROR.
     */
-    } else if (strm->avail_in == 0 && flush <= old_flush &&
+    } else if (strm->avail_in == 0 && RANK(flush) <= RANK(old_flush) &&
               flush != Z_FINISH) {
        ERR_RETURN(strm, Z_BUF_ERROR);
    }
@ -850,6 +931,7 @@ int ZEXPORT deflate (strm, flush)
                    if (s->lookahead == 0) {
                        s->strstart = 0;
                        s->block_start = 0L;
                        s->insert = 0;
                    }
                }
            }
@ -945,12 +1027,12 @@ int ZEXPORT deflateCopy (dest, source)
    ss = source->state;
-    zmemcpy(dest, source, sizeof(z_stream));
+    zmemcpy((voidpf)dest, (voidpf)source, sizeof(z_stream));
    ds = (deflate_state *) ZALLOC(dest, 1, sizeof(deflate_state));
    if (ds == Z_NULL) return Z_MEM_ERROR;
    dest->state = (struct internal_state FAR *) ds;
-    zmemcpy(ds, ss, sizeof(deflate_state));
+    zmemcpy((voidpf)ds, (voidpf)ss, sizeof(deflate_state));
    ds->strm = dest;
    ds->window = (Bytef *) ZALLOC(dest, ds->w_size, 2*sizeof(Byte));
@ -966,8 +1048,8 @@ int ZEXPORT deflateCopy (dest, source)
    }
    /* following zmemcpy do not work for 16-bit MSDOS */
    zmemcpy(ds->window, ss->window, ds->w_size * 2 * sizeof(Byte));
-    zmemcpy(ds->prev, ss->prev, ds->w_size * sizeof(Pos));
+    zmemcpy((voidpf)ds->prev, (voidpf)ss->prev, ds->w_size * sizeof(Pos));
-    zmemcpy(ds->head, ss->head, ds->hash_size * sizeof(Pos));
+    zmemcpy((voidpf)ds->head, (voidpf)ss->head, ds->hash_size * sizeof(Pos));
    zmemcpy(ds->pending_buf, ss->pending_buf, (uInt)ds->pending_buf_size);
    ds->pending_out = ds->pending_buf + (ss->pending_out - ss->pending_buf);
@ -1001,15 +1083,15 @@ local int read_buf(strm, buf, size)
    strm->avail_in  -= len;
    zmemcpy(buf, strm->next_in, len);
    if (strm->state->wrap == 1) {
-        strm->adler = adler32(strm->adler, strm->next_in, len);
+        strm->adler = adler32(strm->adler, buf, len);
    }
 #ifdef GZIP
    else if (strm->state->wrap == 2) {
-        strm->adler = crc32(strm->adler, strm->next_in, len);
+        strm->adler = crc32(strm->adler, buf, len);
    }
 #endif
    zmemcpy(buf, strm->next_in, len);
    strm->next_in  += len;
    strm->total_in += len;
@ -1036,6 +1118,7 @@ local void lm_init (s)
    s->strstart = 0;
    s->block_start = 0L;
    s->lookahead = 0;
    s->insert = 0;
    s->match_length = s->prev_length = MIN_MATCH-1;
    s->match_available = 0;
    s->ins_h = 0;
@ -1310,6 +1393,8 @@ local void fill_window(s)
    unsigned more;    /* Amount of free space at the end of the window. */
    uInt wsize = s->w_size;
    Assert(s->lookahead < MIN_LOOKAHEAD, "already enough lookahead");
    do {
        more = (unsigned)(s->window_size -(ulg)s->lookahead -(ulg)s->strstart);
@ -1362,7 +1447,7 @@ local void fill_window(s)
 #endif
            more += wsize;
        }
-        if (s->strm->avail_in == 0) return;
+        if (s->strm->avail_in == 0) break;
        /* If there was no sliding:
         *    strstart <= WSIZE+MAX_DIST-1 && lookahead <= MIN_LOOKAHEAD - 1 &&
@ -1381,12 +1466,24 @@ local void fill_window(s)
        s->lookahead += n;
        /* Initialize the hash value now that we have some input: */
-        if (s->lookahead >= MIN_MATCH) {
+        if (s->lookahead + s->insert >= MIN_MATCH) {
-            s->ins_h = s->window[s->strstart];
+            uInt str = s->strstart - s->insert;
-            UPDATE_HASH(s, s->ins_h, s->window[s->strstart+1]);
+            s->ins_h = s->window[str];
            UPDATE_HASH(s, s->ins_h, s->window[str + 1]);
 #if MIN_MATCH != 3
            Call UPDATE_HASH() MIN_MATCH-3 more times
 #endif
            while (s->insert) {
                UPDATE_HASH(s, s->ins_h, s->window[str + MIN_MATCH-1]);
 #ifndef FASTEST
                s->prev[str & s->w_mask] = s->head[s->ins_h];
 #endif
                s->head[s->ins_h] = (Pos)str;
                str++;
                s->insert--;
                if (s->lookahead + s->insert < MIN_MATCH)
                    break;
            }
        }
        /* If the whole input has less than MIN_MATCH bytes, ins_h is garbage,
         * but this is not important since only literal bytes will be emitted.
@ -1427,6 +1524,9 @@ local void fill_window(s)
            s->high_water += init;
        }
    }
    Assert((ulg)s->strstart <= s->window_size - MIN_LOOKAHEAD,
           "not enough room for search");
 }
 /* ===========================================================================
@ -1506,8 +1606,14 @@ local block_state deflate_stored(s, flush)
            FLUSH_BLOCK(s, 0);
        }
    }
-    FLUSH_BLOCK(s, flush == Z_FINISH);
+    s->insert = 0;
-    return flush == Z_FINISH ? finish_done : block_done;
+    if (flush == Z_FINISH) {
        FLUSH_BLOCK(s, 1);
        return finish_done;
    }
    if ((long)s->strstart > s->block_start)
        FLUSH_BLOCK(s, 0);
    return block_done;
 }
 /* ===========================================================================
@ -1603,8 +1709,14 @@ local block_state deflate_fast(s, flush)
        }
        if (bflush) FLUSH_BLOCK(s, 0);
    }
-    FLUSH_BLOCK(s, flush == Z_FINISH);
+    s->insert = s->strstart < MIN_MATCH-1 ? s->strstart : MIN_MATCH-1;
-    return flush == Z_FINISH ? finish_done : block_done;
+    if (flush == Z_FINISH) {
        FLUSH_BLOCK(s, 1);
        return finish_done;
    }
    if (s->last_lit)
        FLUSH_BLOCK(s, 0);
    return block_done;
 }
 #ifndef FASTEST
@ -1728,8 +1840,14 @@ local block_state deflate_slow(s, flush)
        _tr_tally_lit(s, s->window[s->strstart-1], bflush);
        s->match_available = 0;
    }
-    FLUSH_BLOCK(s, flush == Z_FINISH);
+    s->insert = s->strstart < MIN_MATCH-1 ? s->strstart : MIN_MATCH-1;
-    return flush == Z_FINISH ? finish_done : block_done;
+    if (flush == Z_FINISH) {
        FLUSH_BLOCK(s, 1);
        return finish_done;
    }
    if (s->last_lit)
        FLUSH_BLOCK(s, 0);
    return block_done;
 }
 #endif /* FASTEST */
@ -1749,11 +1867,11 @@ local block_state deflate_rle(s, flush)
    for (;;) {
        /* Make sure that we always have enough lookahead, except
         * at the end of the input file. We need MAX_MATCH bytes
-         * for the longest encodable run.
+         * for the longest run, plus one for the unrolled loop.
         */
-        if (s->lookahead < MAX_MATCH) {
+        if (s->lookahead <= MAX_MATCH) {
            fill_window(s);
-            if (s->lookahead < MAX_MATCH && flush == Z_NO_FLUSH) {
+            if (s->lookahead <= MAX_MATCH && flush == Z_NO_FLUSH) {
                return need_more;
            }
            if (s->lookahead == 0) break; /* flush the current block */
@ -1776,6 +1894,7 @@ local block_state deflate_rle(s, flush)
                if (s->match_length > s->lookahead)
                    s->match_length = s->lookahead;
            }
            Assert(scan <= s->window+(uInt)(s->window_size-1), "wild scan");
        }
        /* Emit match if have run of MIN_MATCH or longer, else emit literal */
@ -1796,8 +1915,14 @@ local block_state deflate_rle(s, flush)
        }
        if (bflush) FLUSH_BLOCK(s, 0);
    }
-    FLUSH_BLOCK(s, flush == Z_FINISH);
+    s->insert = 0;
-    return flush == Z_FINISH ? finish_done : block_done;
+    if (flush == Z_FINISH) {
        FLUSH_BLOCK(s, 1);
        return finish_done;
    }
    if (s->last_lit)
        FLUSH_BLOCK(s, 0);
    return block_done;
 }
 /* ===========================================================================
@ -1829,6 +1954,12 @@ local block_state deflate_huff(s, flush)
        s->strstart++;
        if (bflush) FLUSH_BLOCK(s, 0);
    }
-    FLUSH_BLOCK(s, flush == Z_FINISH);
+    s->insert = 0;
-    return flush == Z_FINISH ? finish_done : block_done;
+    if (flush == Z_FINISH) {
        FLUSH_BLOCK(s, 1);
        return finish_done;
    }
    if (s->last_lit)
        FLUSH_BLOCK(s, 0);
    return block_done;
 }
--- a/zlib/deflate.h
+++ b/zlib/deflate.h
@ -1,5 +1,5 @@
 /* deflate.h -- internal compression state
- * Copyright (C) 1995-2010 Jean-loup Gailly
+ * Copyright (C) 1995-2012 Jean-loup Gailly
 * For conditions of distribution and use, see copyright notice in zlib.h
 */
@ -48,6 +48,9 @@
 #define MAX_BITS 15
 /* All codes must not exceed MAX_BITS bits */
 #define Buf_size 16
 /* size of bit buffer in bi_buf */
 #define INIT_STATE    42
 #define EXTRA_STATE   69
 #define NAME_STATE    73
@ -188,7 +191,7 @@ typedef struct internal_state {
    int nice_match; /* Stop searching when current match exceeds this */
                /* used by trees.c: */
-    /* Didn't use ct_data typedef below to supress compiler warning */
+    /* Didn't use ct_data typedef below to suppress compiler warning */
    struct ct_data_s dyn_ltree[HEAP_SIZE];   /* literal and length tree */
    struct ct_data_s dyn_dtree[2*D_CODES+1]; /* distance tree */
    struct ct_data_s bl_tree[2*BL_CODES+1];  /* Huffman tree for bit lengths */
@ -244,7 +247,7 @@ typedef struct internal_state {
    ulg opt_len;        /* bit length of current block with optimal trees */
    ulg static_len;     /* bit length of current block with static trees */
    uInt matches;       /* number of string matches in current block */
-    int last_eob_len;   /* bit length of EOB code for last block */
+    uInt insert;        /* bytes at end of window left to insert */
 #ifdef DEBUG
    ulg compressed_len; /* total bit length of compressed file mod 2^32 */
@ -294,6 +297,7 @@ void ZLIB_INTERNAL _tr_init OF((deflate_state *s));
 int ZLIB_INTERNAL _tr_tally OF((deflate_state *s, unsigned dist, unsigned lc));
 void ZLIB_INTERNAL _tr_flush_block OF((deflate_state *s, charf *buf,
                        ulg stored_len, int last));
 void ZLIB_INTERNAL _tr_flush_bits OF((deflate_state *s));
 void ZLIB_INTERNAL _tr_align OF((deflate_state *s));
 void ZLIB_INTERNAL _tr_stored_block OF((deflate_state *s, charf *buf,
                        ulg stored_len, int last));
--- a/zlib/gzguts.h
+++ b/zlib/gzguts.h
@ -0,0 +1,193 @@
 /* gzguts.h -- zlib internal header definitions for gz* operations
 * Copyright (C) 2004, 2005, 2010, 2011, 2012 Mark Adler
 * For conditions of distribution and use, see copyright notice in zlib.h
 */
 #ifdef _LARGEFILE64_SOURCE
 #  ifndef _LARGEFILE_SOURCE
 #    define _LARGEFILE_SOURCE 1
 #  endif
 #  ifdef _FILE_OFFSET_BITS
 #    undef _FILE_OFFSET_BITS
 #  endif
 #endif
 #ifdef HAVE_HIDDEN
 #  define ZLIB_INTERNAL __attribute__((visibility ("hidden")))
 #else
 #  define ZLIB_INTERNAL
 #endif
 #include <stdio.h>
 #include "zlib.h"
 #ifdef STDC
 #  include <string.h>
 #  include <stdlib.h>
 #  include <limits.h>
 #endif
 #include <fcntl.h>
 #ifdef _WIN32
 #  include <stddef.h>
 #endif
 #if defined(__TURBOC__) || defined(_MSC_VER) || defined(_WIN32)
 #  include <io.h>
 #endif
 #ifdef NO_DEFLATE       /* for compatibility with old definition */
 #  define NO_GZCOMPRESS
 #endif
 #if defined(STDC99) || (defined(__TURBOC__) && __TURBOC__ >= 0x550)
 #  ifndef HAVE_VSNPRINTF
 #    define HAVE_VSNPRINTF
 #  endif
 #endif
 #if defined(__CYGWIN__)
 #  ifndef HAVE_VSNPRINTF
 #    define HAVE_VSNPRINTF
 #  endif
 #endif
 #if defined(MSDOS) && defined(__BORLANDC__) && (BORLANDC > 0x410)
 #  ifndef HAVE_VSNPRINTF
 #    define HAVE_VSNPRINTF
 #  endif
 #endif
 #ifndef HAVE_VSNPRINTF
 #  ifdef MSDOS
 /* vsnprintf may exist on some MS-DOS compilers (DJGPP?),
 but for now we just assume it doesn't. */
 #    define NO_vsnprintf
 #  endif
 #  ifdef __TURBOC__
 #    define NO_vsnprintf
 #  endif
 #  ifdef WIN32
 /* In Win32, vsnprintf is available as the "non-ANSI" _vsnprintf. */
 #    if !defined(vsnprintf) && !defined(NO_vsnprintf)
 #      if !defined(_MSC_VER) || ( defined(_MSC_VER) && _MSC_VER < 1500 )
 #         define vsnprintf _vsnprintf
 #      endif
 #    endif
 #  endif
 #  ifdef __SASC
 #    define NO_vsnprintf
 #  endif
 #  ifdef VMS
 #    define NO_vsnprintf
 #  endif
 #  ifdef __OS400__
 #    define NO_vsnprintf
 #  endif
 #  ifdef __MVS__
 #    define NO_vsnprintf
 #  endif
 #endif
 #ifndef local
 #  define local static
 #endif
 /* compile with -Dlocal if your debugger can't find static symbols */
 /* gz* functions always use library allocation functions */
 #ifndef STDC
  extern voidp  malloc OF((uInt size));
  extern void   free   OF((voidpf ptr));
 #endif
 /* get errno and strerror definition */
 #if defined UNDER_CE
 #  include <windows.h>
 #  define zstrerror() gz_strwinerror((DWORD)GetLastError())
 #else
 #  ifndef NO_STRERROR
 #    include <errno.h>
 #    define zstrerror() strerror(errno)
 #  else
 #    define zstrerror() "stdio error (consult errno)"
 #  endif
 #endif
 /* provide prototypes for these when building zlib without LFS */
 #if !defined(_LARGEFILE64_SOURCE) || _LFS64_LARGEFILE-0 == 0
    ZEXTERN gzFile ZEXPORT gzopen64 OF((const char *, const char *));
    ZEXTERN z_off64_t ZEXPORT gzseek64 OF((gzFile, z_off64_t, int));
    ZEXTERN z_off64_t ZEXPORT gztell64 OF((gzFile));
    ZEXTERN z_off64_t ZEXPORT gzoffset64 OF((gzFile));
 #endif
 /* default memLevel */
 #if MAX_MEM_LEVEL >= 8
 #  define DEF_MEM_LEVEL 8
 #else
 #  define DEF_MEM_LEVEL  MAX_MEM_LEVEL
 #endif
 /* default i/o buffer size -- double this for output when reading */
 #define GZBUFSIZE 8192
 /* gzip modes, also provide a little integrity check on the passed structure */
 #define GZ_NONE 0
 #define GZ_READ 7247
 #define GZ_WRITE 31153
 #define GZ_APPEND 1     /* mode set to GZ_WRITE after the file is opened */
 /* values for gz_state how */
 #define LOOK 0      /* look for a gzip header */
 #define COPY 1      /* copy input directly */
 #define GZIP 2      /* decompress a gzip stream */
 /* internal gzip file state data structure */
 typedef struct {
        /* exposed contents for gzgetc() macro */
    struct gzFile_s x;      /* "x" for exposed */
                            /* x.have: number of bytes available at x.next */
                            /* x.next: next output data to deliver or write */
                            /* x.pos: current position in uncompressed data */
        /* used for both reading and writing */
    int mode;               /* see gzip modes above */
    int fd;                 /* file descriptor */
    char *path;             /* path or fd for error messages */
    unsigned size;          /* buffer size, zero if not allocated yet */
    unsigned want;          /* requested buffer size, default is GZBUFSIZE */
    unsigned char *in;      /* input buffer */
    unsigned char *out;     /* output buffer (double-sized when reading) */
    int direct;             /* 0 if processing gzip, 1 if transparent */
        /* just for reading */
    int how;                /* 0: get header, 1: copy, 2: decompress */
    z_off64_t start;        /* where the gzip data started, for rewinding */
    int eof;                /* true if end of input file reached */
    int past;               /* true if read requested past end */
        /* just for writing */
    int level;              /* compression level */
    int strategy;           /* compression strategy */
        /* seek request */
    z_off64_t skip;         /* amount to skip (already rewound if backwards) */
    int seek;               /* true if seek request pending */
        /* error information */
    int err;                /* error code */
    char *msg;              /* error message */
        /* zlib inflate or deflate stream */
    z_stream strm;          /* stream structure in-place (not a pointer) */
 } gz_state;
 typedef gz_state FAR *gz_statep;
 /* shared functions */
 void ZLIB_INTERNAL gz_error OF((gz_statep, int, const char *));
 #if defined UNDER_CE
 char ZLIB_INTERNAL *gz_strwinerror OF((DWORD error));
 #endif
 /* GT_OFF(x), where x is an unsigned value, is true if x > maximum z_off64_t
   value -- needed when comparing unsigned to z_off64_t, which is signed
   (possible z_off64_t types off_t, off64_t, and long are all signed) */
 #ifdef INT_MAX
 #  define GT_OFF(x) (sizeof(int) == sizeof(z_off64_t) && (x) > INT_MAX)
 #else
 unsigned ZLIB_INTERNAL gz_intmax OF((void));
 #  define GT_OFF(x) (sizeof(int) == sizeof(z_off64_t) && (x) > gz_intmax())
 #endif
--- a/zlib/gzio.c
+++ b/zlib/gzio.c
--- a/zlib/infback.c
+++ b/zlib/infback.c
@ -1,5 +1,5 @@
 /* infback.c -- inflate using a call-back interface
- * Copyright (C) 1995-2009 Mark Adler
+ * Copyright (C) 1995-2011 Mark Adler
 * For conditions of distribution and use, see copyright notice in zlib.h
 */
@ -42,10 +42,19 @@ int stream_size;
        return Z_STREAM_ERROR;
    strm->msg = Z_NULL;                 /* in case we return an error */
    if (strm->zalloc == (alloc_func)0) {
 #ifdef Z_SOLO
        return Z_STREAM_ERROR;
 #else
        strm->zalloc = zcalloc;
        strm->opaque = (voidpf)0;
 #endif
    }
-    if (strm->zfree == (free_func)0) strm->zfree = zcfree;
+    if (strm->zfree == (free_func)0)
 #ifdef Z_SOLO
        return Z_STREAM_ERROR;
 #else
    strm->zfree = zcfree;
 #endif
    state = (struct inflate_state FAR *)ZALLOC(strm, 1,
                                               sizeof(struct inflate_state));
    if (state == Z_NULL) return Z_MEM_ERROR;
@ -394,7 +403,6 @@ void FAR *out_desc;
                    PULLBYTE();
                }
                if (here.val < 16) {
                    NEEDBITS(here.bits);
                    DROPBITS(here.bits);
                    state->lens[state->have++] = here.val;
                }
--- a/zlib/inffixed.h
+++ b/zlib/inffixed.h
@ -2,9 +2,9 @@
     * Generated automatically by makefixed().
     */
-    /* WARNING: this file should *not* be used by applications. It
+    /* WARNING: this file should *not* be used by applications.
-       is part of the implementation of the compression library and
+       It is part of the implementation of this library and is
-       is subject to change. Applications should only use zlib.h.
+       subject to change. Applications should only use zlib.h.
     */
    static const code lenfix[512] = {
--- a/zlib/inflate.c
+++ b/zlib/inflate.c
@ -1,5 +1,5 @@
 /* inflate.c -- zlib decompression
- * Copyright (C) 1995-2010 Mark Adler
+ * Copyright (C) 1995-2012 Mark Adler
 * For conditions of distribution and use, see copyright notice in zlib.h
 */
@ -100,7 +100,7 @@ local int updatewindow OF((z_streamp strm, unsigned out));
 local unsigned syncsearch OF((unsigned FAR *have, unsigned char FAR *buf,
                              unsigned len));
-int ZEXPORT inflateReset(strm)
+int ZEXPORT inflateResetKeep(strm)
 z_streamp strm;
 {
    struct inflate_state FAR *state;
@ -109,15 +109,13 @@ z_streamp strm;
    state = (struct inflate_state FAR *)strm->state;
    strm->total_in = strm->total_out = state->total = 0;
    strm->msg = Z_NULL;
-    strm->adler = 1;        /* to support ill-conceived Java test suite */
+    if (state->wrap)        /* to support ill-conceived Java test suite */
        strm->adler = state->wrap & 1;
    state->mode = HEAD;
    state->last = 0;
    state->havedict = 0;
    state->dmax = 32768U;
    state->head = Z_NULL;
    state->wsize = 0;
    state->whave = 0;
    state->wnext = 0;
    state->hold = 0;
    state->bits = 0;
    state->lencode = state->distcode = state->next = state->codes;
@ -127,6 +125,19 @@ z_streamp strm;
    return Z_OK;
 }
 int ZEXPORT inflateReset(strm)
 z_streamp strm;
 {
    struct inflate_state FAR *state;
    if (strm == Z_NULL || strm->state == Z_NULL) return Z_STREAM_ERROR;
    state = (struct inflate_state FAR *)strm->state;
    state->wsize = 0;
    state->whave = 0;
    state->wnext = 0;
    return inflateResetKeep(strm);
 }
 int ZEXPORT inflateReset2(strm, windowBits)
 z_streamp strm;
 int windowBits;
@ -180,10 +191,19 @@ int stream_size;
    if (strm == Z_NULL) return Z_STREAM_ERROR;
    strm->msg = Z_NULL;                 /* in case we return an error */
    if (strm->zalloc == (alloc_func)0) {
 #ifdef Z_SOLO
        return Z_STREAM_ERROR;
 #else
        strm->zalloc = zcalloc;
        strm->opaque = (voidpf)0;
 #endif
    }
-    if (strm->zfree == (free_func)0) strm->zfree = zcfree;
+    if (strm->zfree == (free_func)0)
 #ifdef Z_SOLO
        return Z_STREAM_ERROR;
 #else
        strm->zfree = zcfree;
 #endif
    state = (struct inflate_state FAR *)
            ZALLOC(strm, 1, sizeof(struct inflate_state));
    if (state == Z_NULL) return Z_MEM_ERROR;
@ -321,8 +341,8 @@ void makefixed()
    low = 0;
    for (;;) {
        if ((low % 7) == 0) printf("\n        ");
-        printf("{%u,%u,%d}", state.lencode[low].op, state.lencode[low].bits,
+        printf("{%u,%u,%d}", (low & 127) == 99 ? 64 : state.lencode[low].op,
-               state.lencode[low].val);
+               state.lencode[low].bits, state.lencode[low].val);
        if (++low == size) break;
        putchar(',');
    }
@ -499,11 +519,6 @@ unsigned out;
        bits -= bits & 7; \
    } while (0)
 /* Reverse the bytes in a 32-bit value */
 #define REVERSE(q) \
    ((((q) >> 24) & 0xff) + (((q) >> 8) & 0xff00) + \
     (((q) & 0xff00) << 8) + (((q) & 0xff) << 24))
 /*
   inflate() uses a state machine to process as much input data and generate as
   much output data as possible before returning.  The state machine is
@ -797,7 +812,7 @@ int flush;
 #endif
        case DICTID:
            NEEDBITS(32);
-            strm->adler = state->check = REVERSE(hold);
+            strm->adler = state->check = ZSWAP32(hold);
            INITBITS();
            state->mode = DICT;
        case DICT:
@ -925,7 +940,6 @@ int flush;
                    PULLBYTE();
                }
                if (here.val < 16) {
                    NEEDBITS(here.bits);
                    DROPBITS(here.bits);
                    state->lens[state->have++] = here.val;
                }
@ -1170,7 +1184,7 @@ int flush;
 #ifdef GUNZIP
                     state->flags ? hold :
 #endif
-                     REVERSE(hold)) != state->check) {
+                     ZSWAP32(hold)) != state->check) {
                    strm->msg = (char *)"incorrect data check";
                    state->mode = BAD;
                    break;
@ -1214,7 +1228,8 @@ int flush;
     */
  inf_leave:
    RESTORE();
-    if (state->wsize || (state->mode < CHECK && out != strm->avail_out))
+    if (state->wsize || (out != strm->avail_out && state->mode < BAD &&
            (state->mode < CHECK || flush != Z_FINISH)))
        if (updatewindow(strm, out)) {
            state->mode = MEM;
            return Z_MEM_ERROR;
@ -1255,7 +1270,10 @@ const Bytef *dictionary;
 uInt dictLength;
 {
    struct inflate_state FAR *state;
-    unsigned long id;
+    unsigned long dictid;
    unsigned char *next;
    unsigned avail;
    int ret;
    /* check state */
    if (strm == Z_NULL || strm->state == Z_NULL) return Z_STREAM_ERROR;
@ -1263,29 +1281,27 @@ uInt dictLength;
    if (state->wrap != 0 && state->mode != DICT)
        return Z_STREAM_ERROR;
-    /* check for correct dictionary id */
+    /* check for correct dictionary identifier */
    if (state->mode == DICT) {
-        id = adler32(0L, Z_NULL, 0);
+        dictid = adler32(0L, Z_NULL, 0);
-        id = adler32(id, dictionary, dictLength);
+        dictid = adler32(dictid, dictionary, dictLength);
-        if (id != state->check)
+        if (dictid != state->check)
            return Z_DATA_ERROR;
    }
-    /* copy dictionary to window */
+    /* copy dictionary to window using updatewindow(), which will amend the
-    if (updatewindow(strm, strm->avail_out)) {
+       existing dictionary if appropriate */
    next = strm->next_out;
    avail = strm->avail_out;
    strm->next_out = (Bytef *)dictionary + dictLength;
    strm->avail_out = 0;
    ret = updatewindow(strm, dictLength);
    strm->avail_out = avail;
    strm->next_out = next;
    if (ret) {
        state->mode = MEM;
        return Z_MEM_ERROR;
    }
    if (dictLength > state->wsize) {
        zmemcpy(state->window, dictionary + dictLength - state->wsize,
                state->wsize);
        state->whave = state->wsize;
    }
    else {
        zmemcpy(state->window + state->wsize - dictLength, dictionary,
                dictLength);
        state->whave = dictLength;
    }
    state->havedict = 1;
    Tracev((stderr, "inflate:   dictionary set\n"));
    return Z_OK;
@ -1433,8 +1449,8 @@ z_streamp source;
    }
    /* copy state */
-    zmemcpy(dest, source, sizeof(z_stream));
+    zmemcpy((voidpf)dest, (voidpf)source, sizeof(z_stream));
-    zmemcpy(copy, state, sizeof(struct inflate_state));
+    zmemcpy((voidpf)copy, (voidpf)state, sizeof(struct inflate_state));
    if (state->lencode >= state->codes &&
        state->lencode <= state->codes + ENOUGH - 1) {
        copy->lencode = copy->codes + (state->lencode - state->codes);
--- a/zlib/inftrees.c
+++ b/zlib/inftrees.c
@ -1,5 +1,5 @@
 /* inftrees.c -- generate Huffman trees for efficient decoding
- * Copyright (C) 1995-2010 Mark Adler
+ * Copyright (C) 1995-2012 Mark Adler
 * For conditions of distribution and use, see copyright notice in zlib.h
 */
@ -9,7 +9,7 @@
 #define MAXBITS 15
 const char inflate_copyright[] =
-   " inflate 1.2.5 Copyright 1995-2010 Mark Adler ";
+   " inflate 1.2.7 Copyright 1995-2012 Mark Adler ";
 /*
  If you use the zlib library in a product, an acknowledgment is welcome
  in the documentation of your product. If for some reason you cannot
@ -62,7 +62,7 @@ unsigned short FAR *work;
        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 */
        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, 73, 195};
+        19, 19, 19, 19, 20, 20, 20, 20, 21, 21, 21, 21, 16, 78, 68};
    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,
        257, 385, 513, 769, 1025, 1537, 2049, 3073, 4097, 6145,
@ -289,38 +289,14 @@ unsigned short FAR *work;
        }
    }
-    /*
+    /* fill in remaining table entry if code is incomplete (guaranteed to have
-       Fill in rest of table for incomplete codes.  This loop is similar to the
+       at most one remaining entry, since if the code is incomplete, the
-       loop above in incrementing huff for table indices.  It is assumed that
+       maximum code length that was allowed to get this far is one bit) */
-       len is equal to curr + drop, so there is no loop needed to increment
+    if (huff != 0) {
       through high index bits.  When the current sub-table is filled, the loop
       drops back to the root table to fill in any remaining entries there.
     */
        here.op = (unsigned char)64;            /* invalid code marker */
        here.bits = (unsigned char)(len - drop);
        here.val = (unsigned short)0;
-    while (huff != 0) {
+        next[huff] = here;
        /* when done with sub-table, drop back to root table */
        if (drop != 0 && (huff & mask) != low) {
            drop = 0;
            len = root;
            next = *table;
            here.bits = (unsigned char)len;
        }
        /* put invalid code marker in table */
        next[huff >> drop] = here;
        /* backwards increment the len-bit code huff */
        incr = 1U << (len - 1);
        while (huff & incr)
            incr >>= 1;
        if (incr != 0) {
            huff &= incr - 1;
            huff += incr;
        }
        else
            huff = 0;
    }
    /* set return parameters */
--- a/zlib/minigzip.c
+++ b/zlib/minigzip.c
@ -1,440 +0,0 @@
 /* minigzip.c -- simulate gzip using the zlib compression library
 * Copyright (C) 1995-2006, 2010 Jean-loup Gailly.
 * For conditions of distribution and use, see copyright notice in zlib.h
 */
 /*
 * minigzip is a minimal implementation of the gzip utility. This is
 * only an example of using zlib and isn't meant to replace the
 * full-featured gzip. No attempt is made to deal with file systems
 * limiting names to 14 or 8+3 characters, etc... Error checking is
 * very limited. So use minigzip only for testing; use gzip for the
 * real thing. On MSDOS, use only on file names without extension
 * or in pipe mode.
 */
 /* @(#) $Id$ */
 #include "zlib.h"
 #include <stdio.h>
 #ifdef STDC
 #  include <string.h>
 #  include <stdlib.h>
 #endif
 #ifdef USE_MMAP
 #  include <sys/types.h>
 #  include <sys/mman.h>
 #  include <sys/stat.h>
 #endif
 #if defined(MSDOS) || defined(OS2) || defined(WIN32) || defined(__CYGWIN__)
 #  include <fcntl.h>
 #  include <io.h>
 #  ifdef UNDER_CE
 #    include <stdlib.h>
 #  endif
 #  define SET_BINARY_MODE(file) setmode(fileno(file), O_BINARY)
 #else
 #  define SET_BINARY_MODE(file)
 #endif
 #ifdef VMS
 #  define unlink delete
 #  define GZ_SUFFIX "-gz"
 #endif
 #ifdef RISCOS
 #  define unlink remove
 #  define GZ_SUFFIX "-gz"
 #  define fileno(file) file->__file
 #endif
 #if defined(__MWERKS__) && __dest_os != __be_os && __dest_os != __win32_os
 #  include <unix.h> /* for fileno */
 #endif
 #if !defined(Z_HAVE_UNISTD_H) && !defined(_LARGEFILE64_SOURCE)
 #ifndef WIN32 /* unlink already in stdio.h for WIN32 */
  extern int unlink OF((const char *));
 #endif
 #endif
 #if defined(UNDER_CE)
 #  include <windows.h>
 #  define perror(s) pwinerror(s)
 /* Map the Windows error number in ERROR to a locale-dependent error
   message string and return a pointer to it.  Typically, the values
   for ERROR come from GetLastError.
   The string pointed to shall not be modified by the application,
   but may be overwritten by a subsequent call to strwinerror
   The strwinerror function does not change the current setting
   of GetLastError.  */
 static char *strwinerror (error)
     DWORD error;
 {
    static char buf[1024];
    wchar_t *msgbuf;
    DWORD lasterr = GetLastError();
    DWORD chars = FormatMessage(FORMAT_MESSAGE_FROM_SYSTEM
        | FORMAT_MESSAGE_ALLOCATE_BUFFER,
        NULL,
        error,
        0, /* Default language */
        (LPVOID)&msgbuf,
        0,
        NULL);
    if (chars != 0) {
        /* If there is an \r\n appended, zap it.  */
        if (chars >= 2
            && msgbuf[chars - 2] == '\r' && msgbuf[chars - 1] == '\n') {
            chars -= 2;
            msgbuf[chars] = 0;
        }
        if (chars > sizeof (buf) - 1) {
            chars = sizeof (buf) - 1;
            msgbuf[chars] = 0;
        }
        wcstombs(buf, msgbuf, chars + 1);
        LocalFree(msgbuf);
    }
    else {
        sprintf(buf, "unknown win32 error (%ld)", error);
    }
    SetLastError(lasterr);
    return buf;
 }
 static void pwinerror (s)
    const char *s;
 {
    if (s && *s)
        fprintf(stderr, "%s: %s\n", s, strwinerror(GetLastError ()));
    else
        fprintf(stderr, "%s\n", strwinerror(GetLastError ()));
 }
 #endif /* UNDER_CE */
 #ifndef GZ_SUFFIX
 #  define GZ_SUFFIX ".gz"
 #endif
 #define SUFFIX_LEN (sizeof(GZ_SUFFIX)-1)
 #define BUFLEN      16384
 #define MAX_NAME_LEN 1024
 #ifdef MAXSEG_64K
 #  define local static
   /* Needed for systems with limitation on stack size. */
 #else
 #  define local
 #endif
 char *prog;
 void error            OF((const char *msg));
 void gz_compress      OF((FILE   *in, gzFile out));
 #ifdef USE_MMAP
 int  gz_compress_mmap OF((FILE   *in, gzFile out));
 #endif
 void gz_uncompress    OF((gzFile in, FILE   *out));
 void file_compress    OF((char  *file, char *mode));
 void file_uncompress  OF((char  *file));
 int  main             OF((int argc, char *argv[]));
 /* ===========================================================================
 * Display error message and exit
 */
 void error(msg)
    const char *msg;
 {
    fprintf(stderr, "%s: %s\n", prog, msg);
    exit(1);
 }
 /* ===========================================================================
 * Compress input to output then close both files.
 */
 void gz_compress(in, out)
    FILE   *in;
    gzFile out;
 {
    local char buf[BUFLEN];
    int len;
    int err;
 #ifdef USE_MMAP
    /* Try first compressing with mmap. If mmap fails (minigzip used in a
     * pipe), use the normal fread loop.
     */
    if (gz_compress_mmap(in, out) == Z_OK) return;
 #endif
    for (;;) {
        len = (int)fread(buf, 1, sizeof(buf), in);
        if (ferror(in)) {
            perror("fread");
            exit(1);
        }
        if (len == 0) break;
        if (gzwrite(out, buf, (unsigned)len) != len) error(gzerror(out, &err));
    }
    fclose(in);
    if (gzclose(out) != Z_OK) error("failed gzclose");
 }
 #ifdef USE_MMAP /* MMAP version, Miguel Albrecht <malbrech@eso.org> */
 /* Try compressing the input file at once using mmap. Return Z_OK if
 * if success, Z_ERRNO otherwise.
 */
 int gz_compress_mmap(in, out)
    FILE   *in;
    gzFile out;
 {
    int len;
    int err;
    int ifd = fileno(in);
    caddr_t buf;    /* mmap'ed buffer for the entire input file */
    off_t buf_len;  /* length of the input file */
    struct stat sb;
    /* Determine the size of the file, needed for mmap: */
    if (fstat(ifd, &sb) < 0) return Z_ERRNO;
    buf_len = sb.st_size;
    if (buf_len <= 0) return Z_ERRNO;
    /* Now do the actual mmap: */
    buf = mmap((caddr_t) 0, buf_len, PROT_READ, MAP_SHARED, ifd, (off_t)0);
    if (buf == (caddr_t)(-1)) return Z_ERRNO;
    /* Compress the whole file at once: */
    len = gzwrite(out, (char *)buf, (unsigned)buf_len);
    if (len != (int)buf_len) error(gzerror(out, &err));
    munmap(buf, buf_len);
    fclose(in);
    if (gzclose(out) != Z_OK) error("failed gzclose");
    return Z_OK;
 }
 #endif /* USE_MMAP */
 /* ===========================================================================
 * Uncompress input to output then close both files.
 */
 void gz_uncompress(in, out)
    gzFile in;
    FILE   *out;
 {
    local char buf[BUFLEN];
    int len;
    int err;
    for (;;) {
        len = gzread(in, buf, sizeof(buf));
        if (len < 0) error (gzerror(in, &err));
        if (len == 0) break;
        if ((int)fwrite(buf, 1, (unsigned)len, out) != len) {
            error("failed fwrite");
        }
    }
    if (fclose(out)) error("failed fclose");
    if (gzclose(in) != Z_OK) error("failed gzclose");
 }
 /* ===========================================================================
 * Compress the given file: create a corresponding .gz file and remove the
 * original.
 */
 void file_compress(file, mode)
    char  *file;
    char  *mode;
 {
    local char outfile[MAX_NAME_LEN];
    FILE  *in;
    gzFile out;
    if (strlen(file) + strlen(GZ_SUFFIX) >= sizeof(outfile)) {
        fprintf(stderr, "%s: filename too long\n", prog);
        exit(1);
    }
    strcpy(outfile, file);
    strcat(outfile, GZ_SUFFIX);
    in = fopen(file, "rb");
    if (in == NULL) {
        perror(file);
        exit(1);
    }
    out = gzopen(outfile, mode);
    if (out == NULL) {
        fprintf(stderr, "%s: can't gzopen %s\n", prog, outfile);
        exit(1);
    }
    gz_compress(in, out);
    unlink(file);
 }
 /* ===========================================================================
 * Uncompress the given file and remove the original.
 */
 void file_uncompress(file)
    char  *file;
 {
    local char buf[MAX_NAME_LEN];
    char *infile, *outfile;
    FILE  *out;
    gzFile in;
    size_t len = strlen(file);
    if (len + strlen(GZ_SUFFIX) >= sizeof(buf)) {
        fprintf(stderr, "%s: filename too long\n", prog);
        exit(1);
    }
    strcpy(buf, file);
    if (len > SUFFIX_LEN && strcmp(file+len-SUFFIX_LEN, GZ_SUFFIX) == 0) {
        infile = file;
        outfile = buf;
        outfile[len-3] = '\0';
    } else {
        outfile = file;
        infile = buf;
        strcat(infile, GZ_SUFFIX);
    }
    in = gzopen(infile, "rb");
    if (in == NULL) {
        fprintf(stderr, "%s: can't gzopen %s\n", prog, infile);
        exit(1);
    }
    out = fopen(outfile, "wb");
    if (out == NULL) {
        perror(file);
        exit(1);
    }
    gz_uncompress(in, out);
    unlink(infile);
 }
 /* ===========================================================================
 * Usage:  minigzip [-c] [-d] [-f] [-h] [-r] [-1 to -9] [files...]
 *   -c : write to standard output
 *   -d : decompress
 *   -f : compress with Z_FILTERED
 *   -h : compress with Z_HUFFMAN_ONLY
 *   -r : compress with Z_RLE
 *   -1 to -9 : compression level
 */
 int main(argc, argv)
    int argc;
    char *argv[];
 {
    int copyout = 0;
    int uncompr = 0;
    gzFile file;
    char *bname, outmode[20];
    strcpy(outmode, "wb6 ");
    prog = argv[0];
    bname = strrchr(argv[0], '/');
    if (bname)
      bname++;
    else
      bname = argv[0];
    argc--, argv++;
    if (!strcmp(bname, "gunzip"))
      uncompr = 1;
    else if (!strcmp(bname, "zcat"))
      copyout = uncompr = 1;
    while (argc > 0) {
      if (strcmp(*argv, "-c") == 0)
        copyout = 1;
      else if (strcmp(*argv, "-d") == 0)
        uncompr = 1;
      else if (strcmp(*argv, "-f") == 0)
        outmode[3] = 'f';
      else if (strcmp(*argv, "-h") == 0)
        outmode[3] = 'h';
      else if (strcmp(*argv, "-r") == 0)
        outmode[3] = 'R';
      else if ((*argv)[0] == '-' && (*argv)[1] >= '1' && (*argv)[1] <= '9' &&
               (*argv)[2] == 0)
        outmode[2] = (*argv)[1];
      else
        break;
      argc--, argv++;
    }
    if (outmode[3] == ' ')
        outmode[3] = 0;
    if (argc == 0) {
        SET_BINARY_MODE(stdin);
        SET_BINARY_MODE(stdout);
        if (uncompr) {
            file = gzdopen(fileno(stdin), "rb");
            if (file == NULL) error("can't gzdopen stdin");
            gz_uncompress(file, stdout);
        } else {
            file = gzdopen(fileno(stdout), outmode);
            if (file == NULL) error("can't gzdopen stdout");
            gz_compress(stdin, file);
        }
    } else {
        if (copyout) {
            SET_BINARY_MODE(stdout);
        }
        do {
            if (uncompr) {
                if (copyout) {
                    file = gzopen(*argv, "rb");
                    if (file == NULL)
                        fprintf(stderr, "%s: can't gzopen %s\n", prog, *argv);
                    else
                        gz_uncompress(file, stdout);
                } else {
                    file_uncompress(*argv);
                }
            } else {
                if (copyout) {
                    FILE * in = fopen(*argv, "rb");
                    if (in == NULL) {
                        perror(*argv);
                    } else {
                        file = gzdopen(fileno(stdout), outmode);
                        if (file == NULL) error("can't gzdopen stdout");
                        gz_compress(in, file);
                    }
                } else {
                    file_compress(*argv, outmode);
                }
            }
        } while (argv++, --argc);
    }
    return 0;
 }
--- a/zlib/trees.c
+++ b/zlib/trees.c
@ -1,5 +1,5 @@
 /* trees.c -- output deflated data using Huffman coding
- * Copyright (C) 1995-2010 Jean-loup Gailly
+ * Copyright (C) 1995-2012 Jean-loup Gailly
 * detect_data_type() function provided freely by Cosmin Truta, 2006
 * For conditions of distribution and use, see copyright notice in zlib.h
 */
@ -74,11 +74,6 @@ local const uch bl_order[BL_CODES]
 * probability, to avoid transmitting the lengths for unused bit length codes.
 */
 #define Buf_size (8 * 2*sizeof(char))
 /* Number of bits used within bi_buf. (bi_buf might be implemented on
 * more than 16 bits on some systems.)
 */
 /* ===========================================================================
 * Local data. These are initialized only once.
 */
@ -399,7 +394,6 @@ void ZLIB_INTERNAL _tr_init(s)
    s->bi_buf = 0;
    s->bi_valid = 0;
    s->last_eob_len = 8; /* enough lookahead for inflate */
 #ifdef DEBUG
    s->compressed_len = 0L;
    s->bits_sent = 0L;
@ -882,16 +876,18 @@ void ZLIB_INTERNAL _tr_stored_block(s, buf, stored_len, last)
    copy_block(s, buf, (unsigned)stored_len, 1); /* with header */
 }
 /* ===========================================================================
 * Flush the bits in the bit buffer to pending output (leaves at most 7 bits)
 */
 void ZLIB_INTERNAL _tr_flush_bits(s)
    deflate_state *s;
 {
    bi_flush(s);
 }
 /* ===========================================================================
 * Send one empty static block to give enough lookahead for inflate.
 * This takes 10 bits, of which 7 may remain in the bit buffer.
 * The current inflate code requires 9 bits of lookahead. If the
 * last two codes for the previous block (real code plus EOB) were coded
 * on 5 bits or less, inflate may have only 5+3 bits of lookahead to decode
 * the last real code. In this case we send two empty static blocks instead
 * of one. (There are no problems if the previous block is stored or fixed.)
 * To simplify the code, we assume the worst case of last real code encoded
 * on one bit only.
 */
 void ZLIB_INTERNAL _tr_align(s)
    deflate_state *s;
@ -902,20 +898,6 @@ void ZLIB_INTERNAL _tr_align(s)
    s->compressed_len += 10L; /* 3 for block type, 7 for EOB */
 #endif
    bi_flush(s);
    /* Of the 10 bits for the empty block, we have already sent
     * (10 - bi_valid) bits. The lookahead for the last real code (before
     * the EOB of the previous block) was thus at least one plus the length
     * of the EOB plus what we have just sent of the empty static block.
     */
    if (1 + s->last_eob_len + 10 - s->bi_valid < 9) {
        send_bits(s, STATIC_TREES<<1, 3);
        send_code(s, END_BLOCK, static_ltree);
 #ifdef DEBUG
        s->compressed_len += 10L;
 #endif
        bi_flush(s);
    }
    s->last_eob_len = 7;
 }
 /* ===========================================================================
@ -1118,7 +1100,6 @@ local void compress_block(s, ltree, dtree)
    } while (lx < s->last_lit);
    send_code(s, END_BLOCK, ltree);
    s->last_eob_len = ltree[END_BLOCK].Len;
 }
 /* ===========================================================================
@ -1226,7 +1207,6 @@ local void copy_block(s, buf, len, header)
    int      header;  /* true if block header must be written */
 {
    bi_windup(s);        /* align on byte boundary */
    s->last_eob_len = 8; /* enough lookahead for inflate */
    if (header) {
        put_short(s, (ush)len);
--- a/zlib/win32/zlib.def
+++ b/zlib/win32/zlib.def
@ -1,6 +1,4 @@
 LIBRARY
 ; zlib data compression library
 EXPORTS
 ; basic functions
    zlibVersion
@ -15,6 +13,7 @@ EXPORTS
    deflateParams
    deflateTune
    deflateBound
    deflatePending
    deflatePrime
    deflateSetHeader
    inflateSetDictionary
@ -57,6 +56,13 @@ EXPORTS
    gzclose_w
    gzerror
    gzclearerr
 ; large file functions
    gzopen64
    gzseek64
    gztell64
    gzoffset64
    adler32_combine64
    crc32_combine64
 ; checksum functions
    adler32
    crc32
@ -68,7 +74,11 @@ EXPORTS
    inflateInit_
    inflateInit2_
    inflateBackInit_
    gzgetc_
    zError
    inflateSyncPoint
    get_crc_table
    inflateUndermine
    inflateResetKeep
    deflateResetKeep
    gzopen_w
--- a/zlib/zconf.h
+++ b/zlib/zconf.h
@ -1,5 +1,5 @@
 /* zconf.h -- configuration of the zlib compression library
- * Copyright (C) 1995-2010 Jean-loup Gailly.
+ * Copyright (C) 1995-2012 Jean-loup Gailly.
 * For conditions of distribution and use, see copyright notice in zlib.h
 */
@ -15,6 +15,7 @@
 * this permanently in zconf.h using "./configure --zprefix".
 */
 #ifdef Z_PREFIX     /* may be set to #if 1 by ./configure */
 #  define Z_PREFIX_SET
 /* all linked symbols */
 #  define _dist_code            z__dist_code
@ -27,9 +28,11 @@
 #  define adler32               z_adler32
 #  define adler32_combine       z_adler32_combine
 #  define adler32_combine64     z_adler32_combine64
 #  ifndef Z_SOLO
 #    define compress              z_compress
 #    define compress2             z_compress2
 #    define compressBound         z_compressBound
 #  endif
 #  define crc32                 z_crc32
 #  define crc32_combine         z_crc32_combine
 #  define crc32_combine64       z_crc32_combine64
@ -40,13 +43,16 @@
 #  define deflateInit2_         z_deflateInit2_
 #  define deflateInit_          z_deflateInit_
 #  define deflateParams         z_deflateParams
 #  define deflatePending        z_deflatePending
 #  define deflatePrime          z_deflatePrime
 #  define deflateReset          z_deflateReset
 #  define deflateResetKeep      z_deflateResetKeep
 #  define deflateSetDictionary  z_deflateSetDictionary
 #  define deflateSetHeader      z_deflateSetHeader
 #  define deflateTune           z_deflateTune
 #  define deflate_copyright     z_deflate_copyright
 #  define get_crc_table         z_get_crc_table
 #  ifndef Z_SOLO
 #    define gz_error              z_gz_error
 #    define gz_intmax             z_gz_intmax
 #    define gz_strwinerror        z_gz_strwinerror
@ -61,11 +67,15 @@
 #    define gzerror               z_gzerror
 #    define gzflush               z_gzflush
 #    define gzgetc                z_gzgetc
 #    define gzgetc_               z_gzgetc_
 #    define gzgets                z_gzgets
 #    define gzoffset              z_gzoffset
 #    define gzoffset64            z_gzoffset64
 #    define gzopen                z_gzopen
 #    define gzopen64              z_gzopen64
 #    ifdef _WIN32
 #      define gzopen_w              z_gzopen_w
 #    endif
 #    define gzprintf              z_gzprintf
 #    define gzputc                z_gzputc
 #    define gzputs                z_gzputs
@ -78,6 +88,7 @@
 #    define gztell64              z_gztell64
 #    define gzungetc              z_gzungetc
 #    define gzwrite               z_gzwrite
 #  endif
 #  define inflate               z_inflate
 #  define inflateBack           z_inflateBack
 #  define inflateBackEnd        z_inflateBackEnd
@ -95,13 +106,18 @@
 #  define inflateSync           z_inflateSync
 #  define inflateSyncPoint      z_inflateSyncPoint
 #  define inflateUndermine      z_inflateUndermine
 #  define inflateResetKeep      z_inflateResetKeep
 #  define inflate_copyright     z_inflate_copyright
 #  define inflate_fast          z_inflate_fast
 #  define inflate_table         z_inflate_table
 #  ifndef Z_SOLO
 #    define uncompress            z_uncompress
 #  endif
 #  define zError                z_zError
 #  ifndef Z_SOLO
 #    define zcalloc               z_zcalloc
 #    define zcfree                z_zcfree
 #  endif
 #  define zlibCompileFlags      z_zlibCompileFlags
 #  define zlibVersion           z_zlibVersion
@ -111,7 +127,9 @@
 #  define alloc_func            z_alloc_func
 #  define charf                 z_charf
 #  define free_func             z_free_func
 #  ifndef Z_SOLO
 #    define gzFile                z_gzFile
 #  endif
 #  define gz_header             z_gz_header
 #  define gz_headerp            z_gz_headerp
 #  define in_func               z_in_func
@ -197,6 +215,12 @@
 #  endif
 #endif
 #if defined(ZLIB_CONST) && !defined(z_const)
 #  define z_const const
 #else
 #  define z_const
 #endif
 /* Some Mac compilers merge all .h files incorrectly: */
 #if defined(__MWERKS__)||defined(applec)||defined(THINK_C)||defined(__SC__)
 #  define NO_DUMMY_DECL
@ -243,6 +267,14 @@
 #  endif
 #endif
 #ifndef Z_ARG /* function prototypes for stdarg */
 #  if defined(STDC) || defined(Z_HAVE_STDARG_H)
 #    define Z_ARG(args)  args
 #  else
 #    define Z_ARG(args)  ()
 #  endif
 #endif
 /* The following definitions for FAR are needed only for MSDOS mixed
 * model programming (small or medium model with some far allocations).
 * This was tested only with MSC; for other MSDOS compilers you may have
@ -356,12 +388,45 @@ typedef uLong FAR uLongf;
   typedef Byte       *voidp;
 #endif
 /* ./configure may #define Z_U4 here */
 #if !defined(Z_U4) && !defined(Z_SOLO) && defined(STDC)
 #  include <limits.h>
 #  if (UINT_MAX == 0xffffffffUL)
 #    define Z_U4 unsigned
 #  else
 #    if (ULONG_MAX == 0xffffffffUL)
 #      define Z_U4 unsigned long
 #    else
 #      if (USHRT_MAX == 0xffffffffUL)
 #        define Z_U4 unsigned short
 #      endif
 #    endif
 #  endif
 #endif
 #ifdef Z_U4
   typedef Z_U4 z_crc_t;
 #else
   typedef unsigned long z_crc_t;
 #endif
 #ifdef HAVE_UNISTD_H    /* may be set to #if 1 by ./configure */
 #  define Z_HAVE_UNISTD_H
 #endif
 #ifdef HAVE_STDARG_H    /* may be set to #if 1 by ./configure */
 #  define Z_HAVE_STDARG_H
 #endif
 #ifdef STDC
 #  ifndef Z_SOLO
 #    include <sys/types.h>      /* for off_t */
 #  endif
 #endif
 #ifdef _WIN32
 #  include <stddef.h>           /* for wchar_t */
 #endif
 /* a little trick to accommodate both "#define _LARGEFILE64_SOURCE" and
@ -370,21 +435,38 @@ typedef uLong FAR uLongf;
 * both "#undef _LARGEFILE64_SOURCE" and "#define _LARGEFILE64_SOURCE 0" as
 * equivalently requesting no 64-bit operations
 */
-#if -_LARGEFILE64_SOURCE - -1 == 1
+#if defined(LARGEFILE64_SOURCE) && -_LARGEFILE64_SOURCE - -1 == 1
 #  undef _LARGEFILE64_SOURCE
 #endif
-#if defined(Z_HAVE_UNISTD_H) || defined(_LARGEFILE64_SOURCE)
+#if defined(__WATCOMC__) && !defined(Z_HAVE_UNISTD_H)
-#  include <unistd.h>       /* for SEEK_* and off_t */
+#  define Z_HAVE_UNISTD_H
 #endif
 #ifndef Z_SOLO
 #  if defined(Z_HAVE_UNISTD_H) || defined(LARGEFILE64_SOURCE)
 #    include <unistd.h>         /* for SEEK_*, off_t, and _LFS64_LARGEFILE */
 #    ifdef VMS
 #      include <unixio.h>       /* for off_t */
 #    endif
 #    ifndef z_off_t
 #      define z_off_t off_t
 #    endif
 #  endif
 #endif
-#ifndef SEEK_SET
+#if defined(_LFS64_LARGEFILE) && _LFS64_LARGEFILE-0
 #  define Z_LFS64
 #endif
 #if defined(_LARGEFILE64_SOURCE) && defined(Z_LFS64)
 #  define Z_LARGE64
 #endif
 #if defined(_FILE_OFFSET_BITS) && _FILE_OFFSET_BITS-0 == 64 && defined(Z_LFS64)
 #  define Z_WANT64
 #endif
 #if !defined(SEEK_SET) && !defined(Z_SOLO)
 #  define SEEK_SET        0       /* Seek from beginning of file.  */
 #  define SEEK_CUR        1       /* Seek from current position.  */
 #  define SEEK_END        2       /* Set file pointer to EOF plus "offset" */
@ -394,18 +476,14 @@ typedef uLong FAR uLongf;
 #  define z_off_t long
 #endif
-#if defined(_LARGEFILE64_SOURCE) && _LFS64_LARGEFILE-0
+#if !defined(_WIN32) && defined(Z_LARGE64)
 #  define z_off64_t off64_t
 #else
 #  if defined(_WIN32) && !defined(__GNUC__) && !defined(Z_SOLO)
 #    define z_off64_t __int64
 #  else
 #    define z_off64_t z_off_t
-#endif
+#  endif
 #if defined(__OS400__)
 #  define NO_vsnprintf
 #endif
 #if defined(__MVS__)
 #  define NO_vsnprintf
 #endif
 /* MVS linker does not support external names larger than 8 bytes */
--- a/zlib/zlib.3
+++ b/zlib/zlib.3
@ -1,4 +1,4 @@
-.TH ZLIB 3 "19 Apr 2010"
+.TH ZLIB 3 "2 May 2012"
 .SH NAME
 zlib \- compression/decompression library
 .SH SYNOPSIS
@ -36,9 +36,9 @@ All functions of the compression library are documented in the file
 .IR zlib.h .
 The distribution source includes examples of use of the library
 in the files
-.I example.c
+.I test/example.c
 and
-.IR minigzip.c,
+.IR test/minigzip.c,
 as well as other examples in the
 .IR examples/
 directory.
@ -65,7 +65,7 @@ A Python interface to
 written by A.M. Kuchling (amk@magnet.com),
 is available in Python 1.5 and later versions:
 .IP
-http://www.python.org/doc/lib/module-zlib.html
+http://docs.python.org/library/zlib.html
 .LP
 .I zlib
 is built into
@ -95,11 +95,11 @@ http://zlib.net/
 The data format used by the zlib library is described by RFC
 (Request for Comments) 1950 to 1952 in the files:
 .IP
-http://www.ietf.org/rfc/rfc1950.txt (for the zlib header and trailer format)
+http://tools.ietf.org/html/rfc1950 (for the zlib header and trailer format)
 .br
-http://www.ietf.org/rfc/rfc1951.txt (for the deflate compressed data format)
+http://tools.ietf.org/html/rfc1951 (for the deflate compressed data format)
 .br
-http://www.ietf.org/rfc/rfc1952.txt (for the gzip header and trailer format)
+http://tools.ietf.org/html/rfc1952 (for the gzip header and trailer format)
 .LP
 Mark Nelson wrote an article about
 .I zlib
@ -125,8 +125,8 @@ before asking for help.
 Send questions and/or comments to zlib@gzip.org,
 or (for the Windows DLL version) to Gilles Vollant (info@winimage.com).
 .SH AUTHORS
-Version 1.2.5
+Version 1.2.7
-Copyright (C) 1995-2010 Jean-loup Gailly (jloup@gzip.org)
+Copyright (C) 1995-2012 Jean-loup Gailly (jloup@gzip.org)
 and Mark Adler (madler@alumni.caltech.edu).
 .LP
 This software is provided "as-is,"
--- a/zlib/zlib.3.pdf
+++ b/zlib/zlib.3.pdf
--- a/zlib/zlib.h
+++ b/zlib/zlib.h
@ -1,7 +1,7 @@
 /* zlib.h -- interface of the 'zlib' general purpose compression library
-  version 1.2.5, April 19th, 2010
+  version 1.2.7, May 2nd, 2012
-  Copyright (C) 1995-2010 Jean-loup Gailly and Mark Adler
+  Copyright (C) 1995-2012 Jean-loup Gailly and Mark Adler
  This software is provided 'as-is', without any express or implied
  warranty.  In no event will the authors be held liable for any damages
@ -24,8 +24,8 @@
  The data format used by the zlib library is described by RFCs (Request for
-  Comments) 1950 to 1952 in the files http://www.ietf.org/rfc/rfc1950.txt
+  Comments) 1950 to 1952 in the files http://tools.ietf.org/html/rfc1950
-  (zlib format), rfc1951.txt (deflate format) and rfc1952.txt (gzip format).
+  (zlib format), rfc1951 (deflate format) and rfc1952 (gzip format).
 */
 #ifndef ZLIB_H
@ -37,11 +37,11 @@
 extern "C" {
 #endif
-#define ZLIB_VERSION "1.2.5"
+#define ZLIB_VERSION "1.2.7"
-#define ZLIB_VERNUM 0x1250
+#define ZLIB_VERNUM 0x1270
 #define ZLIB_VER_MAJOR 1
 #define ZLIB_VER_MINOR 2
-#define ZLIB_VER_REVISION 5
+#define ZLIB_VER_REVISION 7
 #define ZLIB_VER_SUBREVISION 0
 /*
@ -83,15 +83,15 @@ typedef void   (*free_func)  OF((voidpf opaque, voidpf address));
 struct internal_state;
 typedef struct z_stream_s {
-    Bytef    *next_in;  /* next input byte */
+    z_const Bytef *next_in;     /* next input byte */
    uInt     avail_in;  /* number of bytes available at next_in */
-    uLong    total_in;  /* total nb of input bytes read so far */
+    uLong    total_in;  /* total number of input bytes read so far */
    Bytef    *next_out; /* next output byte should be put there */
    uInt     avail_out; /* remaining free space at next_out */
-    uLong    total_out; /* total nb of bytes output so far */
+    uLong    total_out; /* total number of bytes output so far */
-    char     *msg;      /* last error message, NULL if no error */
+    z_const char *msg;  /* last error message, NULL if no error */
    struct internal_state FAR *state; /* not visible by applications */
    alloc_func zalloc;  /* used to allocate the internal state */
@ -327,8 +327,9 @@ ZEXTERN int ZEXPORT deflate OF((z_streamp strm, int flush));
    Z_FINISH can be used immediately after deflateInit if all the compression
  is to be done in a single step.  In this case, avail_out must be at least the
-  value returned by deflateBound (see below).  If deflate does not return
+  value returned by deflateBound (see below).  Then deflate is guaranteed to
-  Z_STREAM_END, then it must be called again as described above.
+  return Z_STREAM_END.  If not enough output space is provided, deflate will
  not return Z_STREAM_END, and it must be called again as described above.
    deflate() sets strm->adler to the adler32 checksum of all input read
  so far (that is, total_in bytes).
@ -451,23 +452,29 @@ ZEXTERN int ZEXPORT inflate OF((z_streamp strm, int flush));
  error.  However if all decompression is to be performed in a single step (a
  single call of inflate), the parameter flush should be set to Z_FINISH.  In
  this case all pending input is processed and all pending output is flushed;
-  avail_out must be large enough to hold all the uncompressed data.  (The size
+  avail_out must be large enough to hold all of the uncompressed data for the
-  of the uncompressed data may have been saved by the compressor for this
+  operation to complete.  (The size of the uncompressed data may have been
-  purpose.) The next operation on this stream must be inflateEnd to deallocate
+  saved by the compressor for this purpose.) The use of Z_FINISH is not
-  the decompression state.  The use of Z_FINISH is never required, but can be
+  required to perform an inflation in one step.  However it may be used to
-  used to inform inflate that a faster approach may be used for the single
+  inform inflate that a faster approach can be used for the single inflate()
-  inflate() call.
+  call.  Z_FINISH also informs inflate to not maintain a sliding window if the
  stream completes, which reduces inflate's memory footprint.  If the stream
  does not complete, either because not all of the stream is provided or not
  enough output space is provided, then a sliding window will be allocated and
  inflate() can be called again to continue the operation as if Z_NO_FLUSH had
  been used.
     In this implementation, inflate() always flushes as much output as
  possible to the output buffer, and always uses the faster approach on the
-  first call.  So the only effect of the flush parameter in this implementation
+  first call.  So the effects of the flush parameter in this implementation are
-  is on the return value of inflate(), as noted below, or when it returns early
+  on the return value of inflate() as noted below, when inflate() returns early
-  because Z_BLOCK or Z_TREES is used.
+  when Z_BLOCK or Z_TREES is used, and when inflate() avoids the allocation of
  memory for a sliding window when Z_FINISH is used.
     If a preset dictionary is needed after this call (see inflateSetDictionary
-  below), inflate sets strm->adler to the adler32 checksum of the dictionary
+  below), inflate sets strm->adler to the Adler-32 checksum of the dictionary
  chosen by the compressor and returns Z_NEED_DICT; otherwise it sets
-  strm->adler to the adler32 checksum of all output produced so far (that is,
+  strm->adler to the Adler-32 checksum of all output produced so far (that is,
  total_out bytes) and returns Z_OK, Z_STREAM_END or an error code as described
  below.  At the end of the stream, inflate() checks that its computed adler32
  checksum is equal to that saved by the compressor and returns Z_STREAM_END
@ -478,7 +485,9 @@ ZEXTERN int ZEXPORT inflate OF((z_streamp strm, int flush));
  initializing with inflateInit2().  Any information contained in the gzip
  header is not retained, so applications that need that information should
  instead use raw inflate, see inflateInit2() below, or inflateBack() and
-  perform their own processing of the gzip header and trailer.
+  perform their own processing of the gzip header and trailer.  When processing
  gzip-wrapped deflate data, strm->adler32 is set to the CRC-32 of the output
  producted so far.  The CRC-32 is checked against the gzip trailer.
    inflate() returns Z_OK if some progress has been made (more input processed
  or more output produced), Z_STREAM_END if the end of the compressed data has
@ -580,10 +589,15 @@ ZEXTERN int ZEXPORT deflateSetDictionary OF((z_streamp strm,
                                             uInt  dictLength));
 /*
     Initializes the compression dictionary from the given byte sequence
-   without producing any compressed output.  This function must be called
+   without producing any compressed output.  When using the zlib format, this
-   immediately after deflateInit, deflateInit2 or deflateReset, before any call
+   function must be called immediately after deflateInit, deflateInit2 or
-   of deflate.  The compressor and decompressor must use exactly the same
+   deflateReset, and before any call of deflate.  When doing raw deflate, this
-   dictionary (see inflateSetDictionary).
+   function must be called either before any call of deflate, or immediately
   after the completion of a deflate block, i.e. after all input has been
   consumed and all output has been delivered when using any of the flush
   options Z_BLOCK, Z_PARTIAL_FLUSH, Z_SYNC_FLUSH, or Z_FULL_FLUSH.  The
   compressor and decompressor must use exactly the same dictionary (see
   inflateSetDictionary).
     The dictionary should consist of strings (byte sequences) that are likely
   to be encountered later in the data to be compressed, with the most commonly
@ -610,8 +624,8 @@ ZEXTERN int ZEXPORT deflateSetDictionary OF((z_streamp strm,
     deflateSetDictionary returns Z_OK if success, or Z_STREAM_ERROR if a
   parameter is invalid (e.g.  dictionary being Z_NULL) or the stream state is
   inconsistent (for example if deflate has already been called for this stream
-   or if the compression method is bsort).  deflateSetDictionary does not
+   or if not at a block boundary for raw deflate).  deflateSetDictionary does
-   perform any compression: this will be done by deflate().
+   not perform any compression: this will be done by deflate().
 */
 ZEXTERN int ZEXPORT deflateCopy OF((z_streamp dest,
@ -688,9 +702,29 @@ ZEXTERN uLong ZEXPORT deflateBound OF((z_streamp strm,
   deflation of sourceLen bytes.  It must be called after deflateInit() or
   deflateInit2(), and after deflateSetHeader(), if used.  This would be used
   to allocate an output buffer for deflation in a single pass, and so would be
-   called before deflate().
+   called before deflate().  If that first deflate() call is provided the
   sourceLen input bytes, an output buffer allocated to the size returned by
   deflateBound(), and the flush value Z_FINISH, then deflate() is guaranteed
   to return Z_STREAM_END.  Note that it is possible for the compressed size to
   be larger than the value returned by deflateBound() if flush options other
   than Z_FINISH or Z_NO_FLUSH are used.
 */
 ZEXTERN int ZEXPORT deflatePending OF((z_streamp strm,
                                       unsigned *pending,
                                       int *bits));
 /*
     deflatePending() returns the number of bytes and bits of output that have
   been generated, but not yet provided in the available output.  The bytes not
   provided would be due to the available output space having being consumed.
   The number of bits of output not provided are between 0 and 7, where they
   await more bits to join them in order to fill out a full byte.  If pending
   or bits are Z_NULL, then those values are not set.
     deflatePending returns Z_OK if success, or Z_STREAM_ERROR if the source
   stream state was inconsistent.
 */
 ZEXTERN int ZEXPORT deflatePrime OF((z_streamp strm,
                                     int bits,
                                     int value));
@ -703,8 +737,9 @@ ZEXTERN int ZEXPORT deflatePrime OF((z_streamp strm,
   than or equal to 16, and that many of the least significant bits of value
   will be inserted in the output.
-     deflatePrime returns Z_OK if success, or Z_STREAM_ERROR if the source
+     deflatePrime returns Z_OK if success, Z_BUF_ERROR if there was not enough
-   stream state was inconsistent.
+   room in the internal buffer to insert the bits, or Z_STREAM_ERROR if the
   source stream state was inconsistent.
 */
 ZEXTERN int ZEXPORT deflateSetHeader OF((z_streamp strm,
@ -790,10 +825,11 @@ ZEXTERN int ZEXPORT inflateSetDictionary OF((z_streamp strm,
   if that call returned Z_NEED_DICT.  The dictionary chosen by the compressor
   can be determined from the adler32 value returned by that call of inflate.
   The compressor and decompressor must use exactly the same dictionary (see
-   deflateSetDictionary).  For raw inflate, this function can be called
+   deflateSetDictionary).  For raw inflate, this function can be called at any
-   immediately after inflateInit2() or inflateReset() and before any call of
+   time to set the dictionary.  If the provided dictionary is smaller than the
-   inflate() to set the dictionary.  The application must insure that the
+   window and there is already data in the window, then the provided dictionary
-   dictionary that was used for compression is provided.
+   will amend what's there.  The application must insure that the dictionary
   that was used for compression is provided.
     inflateSetDictionary returns Z_OK if success, Z_STREAM_ERROR if a
   parameter is invalid (e.g.  dictionary being Z_NULL) or the stream state is
@ -805,17 +841,21 @@ ZEXTERN int ZEXPORT inflateSetDictionary OF((z_streamp strm,
 ZEXTERN int ZEXPORT inflateSync OF((z_streamp strm));
 /*
-     Skips invalid compressed data until a full flush point (see above the
+     Skips invalid compressed data until a possible full flush point (see above
-   description of deflate with Z_FULL_FLUSH) can be found, or until all
+   for the description of deflate with Z_FULL_FLUSH) can be found, or until all
   available input is skipped.  No output is provided.
-     inflateSync returns Z_OK if a full flush point has been found, Z_BUF_ERROR
+     inflateSync searches for a 00 00 FF FF pattern in the compressed data.
-   if no more input was provided, Z_DATA_ERROR if no flush point has been
+   All full flush points have this pattern, but not all occurences of this
-   found, or Z_STREAM_ERROR if the stream structure was inconsistent.  In the
+   pattern are full flush points.
-   success case, the application may save the current current value of total_in
+
-   which indicates where valid compressed data was found.  In the error case,
+     inflateSync returns Z_OK if a possible full flush point has been found,
-   the application may repeatedly call inflateSync, providing more input each
+   Z_BUF_ERROR if no more input was provided, Z_DATA_ERROR if no flush point
-   time, until success or end of the input data.
+   has been found, or Z_STREAM_ERROR if the stream structure was inconsistent.
   In the success case, the application may save the current current value of
   total_in which indicates where valid compressed data was found.  In the
   error case, the application may repeatedly call inflateSync, providing more
   input each time, until success or end of the input data.
 */
 ZEXTERN int ZEXPORT inflateCopy OF((z_streamp dest,
@ -962,7 +1002,7 @@ ZEXTERN int ZEXPORT inflateBackInit OF((z_streamp strm, int windowBits,
     See inflateBack() for the usage of these routines.
     inflateBackInit will return Z_OK on success, Z_STREAM_ERROR if any of
-   the paramaters are invalid, Z_MEM_ERROR if the internal state could not be
+   the parameters are invalid, Z_MEM_ERROR if the internal state could not be
   allocated, or Z_VERSION_ERROR if the version of the library does not match
   the version of the header file.
 */
@ -1088,6 +1128,7 @@ ZEXTERN uLong ZEXPORT zlibCompileFlags OF((void));
     27-31: 0 (reserved)
 */
 #ifndef Z_SOLO
                        /* utility functions */
@ -1149,10 +1190,11 @@ ZEXTERN int ZEXPORT uncompress OF((Bytef *dest,   uLongf *destLen,
     uncompress returns Z_OK if success, Z_MEM_ERROR if there was not
   enough memory, Z_BUF_ERROR if there was not enough room in the output
-   buffer, or Z_DATA_ERROR if the input data was corrupted or incomplete.
+   buffer, or Z_DATA_ERROR if the input data was corrupted or incomplete.  In
   the case where there is not enough room, uncompress() will fill the output
   buffer with the uncompressed data up to that point.
 */
                        /* gzip file access functions */
 /*
@ -1162,7 +1204,7 @@ ZEXTERN int ZEXPORT uncompress OF((Bytef *dest,   uLongf *destLen,
   wrapper, documented in RFC 1952, wrapped around a deflate stream.
 */
-typedef voidp gzFile;       /* opaque gzip file descriptor */
+typedef struct gzFile_s *gzFile;    /* semi-opaque gzip file descriptor */
 /*
 ZEXTERN gzFile ZEXPORT gzopen OF((const char *path, const char *mode));
@ -1172,13 +1214,28 @@ ZEXTERN gzFile ZEXPORT gzopen OF((const char *path, const char *mode));
   a strategy: 'f' for filtered data as in "wb6f", 'h' for Huffman-only
   compression as in "wb1h", 'R' for run-length encoding as in "wb1R", or 'F'
   for fixed code compression as in "wb9F".  (See the description of
-   deflateInit2 for more information about the strategy parameter.) Also "a"
+   deflateInit2 for more information about the strategy parameter.)  'T' will
-   can be used instead of "w" to request that the gzip stream that will be
+   request transparent writing or appending with no compression and not using
-   written be appended to the file.  "+" will result in an error, since reading
+   the gzip format.
-   and writing to the same gzip file is not supported.
+
     "a" can be used instead of "w" to request that the gzip stream that will
   be written be appended to the file.  "+" will result in an error, since
   reading and writing to the same gzip file is not supported.  The addition of
   "x" when writing will create the file exclusively, which fails if the file
   already exists.  On systems that support it, the addition of "e" when
   reading or writing will set the flag to close the file on an execve() call.
     These functions, as well as gzip, will read and decode a sequence of gzip
   streams in a file.  The append function of gzopen() can be used to create
   such a file.  (Also see gzflush() for another way to do this.)  When
   appending, gzopen does not test whether the file begins with a gzip stream,
   nor does it look for the end of the gzip streams to begin appending.  gzopen
   will simply append a gzip stream to the existing file.
     gzopen can be used to read a file which is not in gzip format; in this
-   case gzread will directly read from the file without decompression.
+   case gzread will directly read from the file without decompression.  When
   reading, this will be detected automatically by looking for the magic two-
   byte gzip header.
     gzopen returns NULL if the file could not be opened, if there was
   insufficient memory to allocate the gzFile state, or if an invalid mode was
@ -1197,7 +1254,11 @@ ZEXTERN gzFile ZEXPORT gzdopen OF((int fd, const char *mode));
   descriptor fd, just like fclose(fdopen(fd, mode)) closes the file descriptor
   fd.  If you want to keep fd open, use fd = dup(fd_keep); gz = gzdopen(fd,
   mode);.  The duplicated descriptor should be saved to avoid a leak, since
-   gzdopen does not close fd if it fails.
+   gzdopen does not close fd if it fails.  If you are using fileno() to get the
   file descriptor from a FILE *, then you will have to use dup() to avoid
   double-close()ing the file descriptor.  Both gzclose() and fclose() will
   close the associated file descriptor, so they need to have different file
   descriptors.
     gzdopen returns NULL if there was insufficient memory to allocate the
   gzFile state, if an invalid mode was specified (an 'r', 'w', or 'a' was not
@ -1235,14 +1296,26 @@ ZEXTERN int ZEXPORT gzsetparams OF((gzFile file, int level, int strategy));
 ZEXTERN int ZEXPORT gzread OF((gzFile file, voidp buf, unsigned len));
 /*
     Reads the given number of uncompressed bytes from the compressed file.  If
-   the input file was not in gzip format, gzread copies the given number of
+   the input file is not in gzip format, gzread copies the given number of
-   bytes into the buffer.
+   bytes into the buffer directly from the file.
     After reaching the end of a gzip stream in the input, gzread will continue
-   to read, looking for another gzip stream, or failing that, reading the rest
+   to read, looking for another gzip stream.  Any number of gzip streams may be
-   of the input file directly without decompression.  The entire input file
+   concatenated in the input file, and will all be decompressed by gzread().
-   will be read if gzread is called until it returns less than the requested
+   If something other than a gzip stream is encountered after a gzip stream,
-   len.
+   that remaining trailing garbage is ignored (and no error is returned).
     gzread can be used to read a gzip file that is being concurrently written.
   Upon reaching the end of the input, gzread will return with the available
   data.  If the error code returned by gzerror is Z_OK or Z_BUF_ERROR, then
   gzclearerr can be used to clear the end of file indicator in order to permit
   gzread to be tried again.  Z_OK indicates that a gzip stream was completed
   on the last gzread.  Z_BUF_ERROR indicates that the input file ended in the
   middle of a gzip stream.  Note that gzread does not return -1 in the event
   of an incomplete gzip stream.  This error is deferred until gzclose(), which
   will return Z_BUF_ERROR if the last gzread ended in the middle of a gzip
   stream.  Alternatively, gzerror can be used before gzclose to detect this
   case.
     gzread returns the number of uncompressed bytes actually read, less than
   len for end of file, or -1 for error.
@ -1256,7 +1329,7 @@ ZEXTERN int ZEXPORT gzwrite OF((gzFile file,
   error.
 */
-ZEXTERN int ZEXPORTVA gzprintf OF((gzFile file, const char *format, ...));
+ZEXTERN int ZEXPORTVA gzprintf Z_ARG((gzFile file, const char *format, ...));
 /*
     Converts, formats, and writes the arguments to the compressed file under
   control of the format string, as in fprintf.  gzprintf returns the number of
@ -1301,7 +1374,10 @@ ZEXTERN int ZEXPORT gzputc OF((gzFile file, int c));
 ZEXTERN int ZEXPORT gzgetc OF((gzFile file));
 /*
     Reads one byte from the compressed file.  gzgetc returns this byte or -1
-   in case of end of file or error.
+   in case of end of file or error.  This is implemented as a macro for speed.
   As such, it does not do all of the checking the other functions do.  I.e.
   it does not check to see if file is NULL, nor whether the structure file
   points to has been clobbered or not.
 */
 ZEXTERN int ZEXPORT gzungetc OF((int c, gzFile file));
@ -1397,9 +1473,7 @@ ZEXTERN int ZEXPORT gzeof OF((gzFile file));
 ZEXTERN int ZEXPORT gzdirect OF((gzFile file));
 /*
     Returns true (1) if file is being copied directly while reading, or false
-   (0) if file is a gzip stream being decompressed.  This state can change from
+   (0) if file is a gzip stream being decompressed.
   false to true while reading the input file if the end of a gzip stream is
   reached, but is followed by data that is not another gzip stream.
     If the input file is empty, gzdirect() will return true, since the input
   does not contain a gzip stream.
@ -1408,6 +1482,13 @@ ZEXTERN int ZEXPORT gzdirect OF((gzFile file));
   cause buffers to be allocated to allow reading the file to determine if it
   is a gzip file.  Therefore if gzbuffer() is used, it should be called before
   gzdirect().
     When writing, gzdirect() returns true (1) if transparent writing was
   requested ("wT" for the gzopen() mode), or false (0) otherwise.  (Note:
   gzdirect() is not needed when writing.  Transparent writing must be
   explicitly requested, so the application already knows the answer.  When
   linking statically, using gzdirect() will include all of the zlib code for
   gzip file reading and decompression, which may not be desired.)
 */
 ZEXTERN int ZEXPORT    gzclose OF((gzFile file));
@ -1419,7 +1500,8 @@ ZEXTERN int ZEXPORT    gzclose OF((gzFile file));
   must not be called more than once on the same allocation.
     gzclose will return Z_STREAM_ERROR if file is not valid, Z_ERRNO on a
-   file operation error, or Z_OK on success.
+   file operation error, Z_MEM_ERROR if out of memory, Z_BUF_ERROR if the
   last read ended in the middle of a gzip stream, or Z_OK on success.
 */
 ZEXTERN int ZEXPORT gzclose_r OF((gzFile file));
@ -1457,6 +1539,7 @@ ZEXTERN void ZEXPORT gzclearerr OF((gzFile file));
   file that is being written concurrently.
 */
 #endif /* !Z_SOLO */
                        /* checksum functions */
@ -1492,16 +1575,17 @@ ZEXTERN uLong ZEXPORT adler32_combine OF((uLong adler1, uLong adler2,
     Combine two Adler-32 checksums into one.  For two sequences of bytes, seq1
   and seq2 with lengths len1 and len2, Adler-32 checksums were calculated for
   each, adler1 and adler2.  adler32_combine() returns the Adler-32 checksum of
-   seq1 and seq2 concatenated, requiring only adler1, adler2, and len2.
+   seq1 and seq2 concatenated, requiring only adler1, adler2, and len2.  Note
   that the z_off_t type (like off_t) is a signed integer.  If len2 is
   negative, the result has no meaning or utility.
 */
 ZEXTERN uLong ZEXPORT crc32   OF((uLong crc, const Bytef *buf, uInt len));
 /*
     Update a running CRC-32 with the bytes buf[0..len-1] and return the
   updated CRC-32.  If buf is Z_NULL, this function returns the required
-   initial value for the for the crc.  Pre- and post-conditioning (one's
+   initial value for the crc.  Pre- and post-conditioning (one's complement) is
-   complement) is performed within this function so it shouldn't be done by the
+   performed within this function so it shouldn't be done by the application.
   application.
   Usage example:
@ -1544,17 +1628,42 @@ ZEXTERN int ZEXPORT inflateBackInit_ OF((z_streamp strm, int windowBits,
                                         const char *version,
                                         int stream_size));
 #define deflateInit(strm, level) \
-        deflateInit_((strm), (level),       ZLIB_VERSION, sizeof(z_stream))
+        deflateInit_((strm), (level), ZLIB_VERSION, (int)sizeof(z_stream))
 #define inflateInit(strm) \
-        inflateInit_((strm),                ZLIB_VERSION, sizeof(z_stream))
+        inflateInit_((strm), ZLIB_VERSION, (int)sizeof(z_stream))
 #define deflateInit2(strm, level, method, windowBits, memLevel, strategy) \
        deflateInit2_((strm),(level),(method),(windowBits),(memLevel),\
-                      (strategy),           ZLIB_VERSION, sizeof(z_stream))
+                      (strategy), ZLIB_VERSION, (int)sizeof(z_stream))
 #define inflateInit2(strm, windowBits) \
-        inflateInit2_((strm), (windowBits), ZLIB_VERSION, sizeof(z_stream))
+        inflateInit2_((strm), (windowBits), ZLIB_VERSION, \
                      (int)sizeof(z_stream))
 #define inflateBackInit(strm, windowBits, window) \
        inflateBackInit_((strm), (windowBits), (window), \
-                                            ZLIB_VERSION, sizeof(z_stream))
+                      ZLIB_VERSION, (int)sizeof(z_stream))
 #ifndef Z_SOLO
 /* gzgetc() macro and its supporting function and exposed data structure.  Note
 * that the real internal state is much larger than the exposed structure.
 * This abbreviated structure exposes just enough for the gzgetc() macro.  The
 * user should not mess with these exposed elements, since their names or
 * behavior could change in the future, perhaps even capriciously.  They can
 * only be used by the gzgetc() macro.  You have been warned.
 */
 struct gzFile_s {
    unsigned have;
    unsigned char *next;
    z_off64_t pos;
 };
 ZEXTERN int ZEXPORT gzgetc_ OF((gzFile file));  /* backward compatibility */
 #ifdef Z_PREFIX_SET
 #  undef z_gzgetc
 #  define z_gzgetc(g) \
          ((g)->have ? ((g)->have--, (g)->pos++, *((g)->next)++) : gzgetc(g))
 #else
 #  define gzgetc(g) \
          ((g)->have ? ((g)->have--, (g)->pos++, *((g)->next)++) : gzgetc(g))
 #endif
 /* provide 64-bit offset functions if _LARGEFILE64_SOURCE defined, and/or
 * change the regular functions to 64 bits if _FILE_OFFSET_BITS is 64 (if
@ -1562,7 +1671,7 @@ ZEXTERN int ZEXPORT inflateBackInit_ OF((z_streamp strm, int windowBits,
 * functions are changed to 64 bits) -- in case these are set on systems
 * without large file support, _LFS64_LARGEFILE must also be true
 */
-#if defined(_LARGEFILE64_SOURCE) && _LFS64_LARGEFILE-0
+#ifdef Z_LARGE64
   ZEXTERN gzFile ZEXPORT gzopen64 OF((const char *, const char *));
   ZEXTERN z_off64_t ZEXPORT gzseek64 OF((gzFile, z_off64_t, int));
   ZEXTERN z_off64_t ZEXPORT gztell64 OF((gzFile));
@ -1571,14 +1680,23 @@ ZEXTERN int ZEXPORT inflateBackInit_ OF((z_streamp strm, int windowBits,
   ZEXTERN uLong ZEXPORT crc32_combine64 OF((uLong, uLong, z_off64_t));
 #endif
-#if !defined(ZLIB_INTERNAL) && _FILE_OFFSET_BITS-0 == 64 && _LFS64_LARGEFILE-0
+#if !defined(ZLIB_INTERNAL) && defined(Z_WANT64)
 #  ifdef Z_PREFIX_SET
 #    define z_gzopen z_gzopen64
 #    define z_gzseek z_gzseek64
 #    define z_gztell z_gztell64
 #    define z_gzoffset z_gzoffset64
 #    define z_adler32_combine z_adler32_combine64
 #    define z_crc32_combine z_crc32_combine64
 #  else
 #    define gzopen gzopen64
 #    define gzseek gzseek64
 #    define gztell gztell64
 #    define gzoffset gzoffset64
 #    define adler32_combine adler32_combine64
 #    define crc32_combine crc32_combine64
-#  ifdef _LARGEFILE64_SOURCE
+#  endif
 #  ifndef Z_LARGE64
     ZEXTERN gzFile ZEXPORT gzopen64 OF((const char *, const char *));
     ZEXTERN z_off_t ZEXPORT gzseek64 OF((gzFile, z_off_t, int));
     ZEXTERN z_off_t ZEXPORT gztell64 OF((gzFile));
@ -1595,6 +1713,13 @@ ZEXTERN int ZEXPORT inflateBackInit_ OF((z_streamp strm, int windowBits,
   ZEXTERN uLong ZEXPORT crc32_combine OF((uLong, uLong, z_off_t));
 #endif
 #else /* Z_SOLO */
   ZEXTERN uLong ZEXPORT adler32_combine OF((uLong, uLong, z_off_t));
   ZEXTERN uLong ZEXPORT crc32_combine OF((uLong, uLong, z_off_t));
 #endif /* !Z_SOLO */
 /* hack for buggy compilers */
 #if !defined(ZUTIL_H) && !defined(NO_DUMMY_DECL)
    struct internal_state {int dummy;};
@ -1603,8 +1728,14 @@ ZEXTERN int ZEXPORT inflateBackInit_ OF((z_streamp strm, int windowBits,
 /* undocumented functions */
 ZEXTERN const char   * ZEXPORT zError           OF((int));
 ZEXTERN int            ZEXPORT inflateSyncPoint OF((z_streamp));
-ZEXTERN const uLongf * ZEXPORT get_crc_table    OF((void));
+ZEXTERN const z_crc_t FAR * ZEXPORT get_crc_table    OF((void));
 ZEXTERN int            ZEXPORT inflateUndermine OF((z_streamp, int));
 ZEXTERN int            ZEXPORT inflateResetKeep OF((z_streamp));
 ZEXTERN int            ZEXPORT deflateResetKeep OF((z_streamp));
 #if defined(_WIN32) && !defined(Z_SOLO)
 ZEXTERN gzFile         ZEXPORT gzopen_w OF((const wchar_t *path,
                                            const char *mode));
 #endif
 #ifdef __cplusplus
 }
--- a/zlib/zlib.vcproj
+++ b/zlib/zlib.vcproj
@ -323,22 +323,17 @@
 				>
 			</File>
 			<File
-				RelativePath=".\gzio.c"
+				RelativePath=".\infback.c"
 				>
 			</File>
 			<File
 				RelativePath=".\inffast.c"
 				>
 				<FileConfiguration
 					Name="Debug|Win32"
 					>
 					<Tool
 						Name="VCCLCompilerTool"
 						DisableSpecificWarnings="4996"
 					/>
 				</FileConfiguration>
 				<FileConfiguration
 					Name="Debug|x64"
 					>
 					<Tool
 						Name="VCCLCompilerTool"
 						DisableSpecificWarnings="4996"
 					/>
 				</FileConfiguration>
 				<FileConfiguration
@ -346,25 +341,8 @@
 					>
 					<Tool
 						Name="VCCLCompilerTool"
 						DisableSpecificWarnings="4996"
 					/>
 				</FileConfiguration>
 				<FileConfiguration
 					Name="Release|x64"
 					>
 					<Tool
 						Name="VCCLCompilerTool"
 						DisableSpecificWarnings="4996"
 					/>
 				</FileConfiguration>
 			</File>
 			<File
 				RelativePath=".\infback.c"
 				>
 			</File>
 			<File
 				RelativePath=".\inffast.c"
 				>
 			</File>
 			<File
 				RelativePath=".\inflate.c"
--- a/zlib/zutil.c
+++ b/zlib/zutil.c
@ -1,11 +1,14 @@
 /* zutil.c -- target dependent utility functions for the compression library
- * Copyright (C) 1995-2005, 2010 Jean-loup Gailly.
+ * Copyright (C) 1995-2005, 2010, 2011, 2012 Jean-loup Gailly.
 * For conditions of distribution and use, see copyright notice in zlib.h
 */
 /* @(#) $Id$ */
 #include "zutil.h"
 #ifndef Z_SOLO
 #  include "gzguts.h"
 #endif
 #ifndef NO_DUMMY_DECL
 struct internal_state      {int dummy;}; /* for buggy compilers */
@ -85,7 +88,7 @@ uLong ZEXPORT zlibCompileFlags()
 #ifdef FASTEST
    flags += 1L << 21;
 #endif
-#ifdef STDC
+#if defined(STDC) || defined(Z_HAVE_STDARG_H)
 #  ifdef NO_vsnprintf
    flags += 1L << 25;
 #    ifdef HAS_vsprintf_void
@ -181,6 +184,7 @@ void ZLIB_INTERNAL zmemzero(dest, len)
 }
 #endif
 #ifndef Z_SOLO
 #ifdef SYS16BIT
@ -316,3 +320,5 @@ void ZLIB_INTERNAL zcfree (opaque, ptr)
 }
 #endif /* MY_ZCALLOC */
 #endif /* !Z_SOLO */
--- a/zlib/zutil.h
+++ b/zlib/zutil.h
@ -1,5 +1,5 @@
 /* zutil.h -- internal interface and configuration of the compression library
- * Copyright (C) 1995-2010 Jean-loup Gailly.
+ * Copyright (C) 1995-2012 Jean-loup Gailly.
 * For conditions of distribution and use, see copyright notice in zlib.h
 */
@ -13,7 +13,7 @@
 #ifndef ZUTIL_H
 #define ZUTIL_H
-#if ((__GNUC__-0) * 10 + __GNUC_MINOR__-0 >= 33) && !defined(NO_VIZ) && !defined(__MINGW32__)
+#ifdef HAVE_HIDDEN
 #  define ZLIB_INTERNAL __attribute__((visibility ("hidden")))
 #else
 #  define ZLIB_INTERNAL
@ -21,7 +21,7 @@
 #include "zlib.h"
-#ifdef STDC
+#if defined(STDC) && !defined(Z_SOLO)
 #  if !(defined(_WIN32_WCE) && defined(_MSC_VER))
 #    include <stddef.h>
 #  endif
@ -29,6 +29,10 @@
 #  include <stdlib.h>
 #endif
 #ifdef Z_SOLO
   typedef long ptrdiff_t;  /* guess -- will be caught if guess is wrong */
 #endif
 #ifndef local
 #  define local static
 #endif
@ -78,6 +82,7 @@ extern const char * const z_errmsg[10]; /* indexed by 2-zlib_error */
 #if defined(MSDOS) || (defined(WINDOWS) && !defined(WIN32))
 #  define OS_CODE  0x00
 #  ifndef Z_SOLO
 #    if defined(__TURBOC__) || defined(__BORLANDC__)
 #      if (__STDC__ == 1) && (defined(__LARGE__) || defined(__COMPACT__))
         /* Allow compilation with ANSI keywords only enabled */
@ -89,6 +94,7 @@ extern const char * const z_errmsg[10]; /* indexed by 2-zlib_error */
 #    else /* MSC or DJGPP */
 #      include <malloc.h>
 #    endif
 #  endif
 #endif
 #ifdef AMIGA
@ -107,13 +113,14 @@ extern const char * const z_errmsg[10]; /* indexed by 2-zlib_error */
 #ifdef OS2
 #  define OS_CODE  0x06
-#  ifdef M_I86
+#  if defined(M_I86) && !defined(Z_SOLO)
 #    include <malloc.h>
 #  endif
 #endif
 #if defined(MACOS) || defined(TARGET_OS_MAC)
 #  define OS_CODE  0x07
 #  ifndef Z_SOLO
 #    if defined(__MWERKS__) && __dest_os != __be_os && __dest_os != __win32_os
 #      include <unix.h> /* for fdopen */
 #    else
@ -121,6 +128,7 @@ extern const char * const z_errmsg[10]; /* indexed by 2-zlib_error */
 #        define fdopen(fd,mode) NULL /* No fdopen() */
 #      endif
 #    endif
 #  endif
 #endif
 #ifdef TOPS20
@ -153,14 +161,14 @@ extern const char * const z_errmsg[10]; /* indexed by 2-zlib_error */
 #  endif
 #endif
-#if defined(__BORLANDC__)
+#if defined(__BORLANDC__) && !defined(MSDOS)
  #pragma warn -8004
  #pragma warn -8008
  #pragma warn -8066
 #endif
 /* provide prototypes for these when building zlib without LFS */
-#if !defined(_LARGEFILE64_SOURCE) || _LFS64_LARGEFILE-0 == 0
+#if !defined(_WIN32) && (!defined(_LARGEFILE64_SOURCE) || _LFS64_LARGEFILE-0 == 0)
    ZEXTERN uLong ZEXPORT adler32_combine64 OF((uLong, uLong, z_off_t));
    ZEXTERN uLong ZEXPORT crc32_combine64 OF((uLong, uLong, z_off_t));
 #endif
@ -177,42 +185,7 @@ extern const char * const z_errmsg[10]; /* indexed by 2-zlib_error */
         /* functions */
-#if defined(STDC99) || (defined(__TURBOC__) && __TURBOC__ >= 0x550)
+#if defined(pyr) || defined(Z_SOLO)
 #  ifndef HAVE_VSNPRINTF
 #    define HAVE_VSNPRINTF
 #  endif
 #endif
 #if defined(__CYGWIN__)
 #  ifndef HAVE_VSNPRINTF
 #    define HAVE_VSNPRINTF
 #  endif
 #endif
 #ifndef HAVE_VSNPRINTF
 #  ifdef MSDOS
     /* vsnprintf may exist on some MS-DOS compilers (DJGPP?),
        but for now we just assume it doesn't. */
 #    define NO_vsnprintf
 #  endif
 #  ifdef __TURBOC__
 #    define NO_vsnprintf
 #  endif
 #  ifdef WIN32
     /* In Win32, vsnprintf is available as the "non-ANSI" _vsnprintf. */
 #    if !defined(vsnprintf) && !defined(NO_vsnprintf)
 #      if !defined(_MSC_VER) || ( defined(_MSC_VER) && _MSC_VER < 1500 )
 #         define vsnprintf _vsnprintf
 #      endif
 #    endif
 #  endif
 #  ifdef __SASC
 #    define NO_vsnprintf
 #  endif
 #endif
 #ifdef VMS
 #  define NO_vsnprintf
 #endif
 #if defined(pyr)
 #  define NO_MEMCPY
 #endif
 #if defined(SMALL_MEDIUM) && !defined(_MSC_VER) && !defined(__SC__)
@ -261,14 +234,19 @@ extern const char * const z_errmsg[10]; /* indexed by 2-zlib_error */
 #  define Tracecv(c,x)
 #endif
-
+#ifndef Z_SOLO
-voidpf ZLIB_INTERNAL zcalloc OF((voidpf opaque, unsigned items,
+   voidpf ZLIB_INTERNAL zcalloc OF((voidpf opaque, unsigned items,
                                    unsigned size));
-void ZLIB_INTERNAL zcfree  OF((voidpf opaque, voidpf ptr));
+   void ZLIB_INTERNAL zcfree  OF((voidpf opaque, voidpf ptr));
 #endif
 #define ZALLOC(strm, items, size) \
           (*((strm)->zalloc))((strm)->opaque, (items), (size))
 #define ZFREE(strm, addr)  (*((strm)->zfree))((strm)->opaque, (voidpf)(addr))
 #define TRY_FREE(s, p) {if (p) ZFREE(s, p);}
 /* Reverse the bytes in a 32-bit value */
 #define ZSWAP32(q) ((((q) >> 24) & 0xff) + (((q) >> 8) & 0xff00) + \
                    (((q) & 0xff00) << 8) + (((q) & 0xff) << 24))
 #endif /* ZUTIL_H */