[3/4] zlib: Remove files that should certainly not be checked in

diff --git a/zlib/contrib/masmx64/gvmat64.obj b/zlib/contrib/masmx64/gvmat64.obj
deleted file mode 100644
index a49ca029c63e24f907d7cd5d6eaa25f016c9aea5..0000000000000000000000000000000000000000
GIT binary patch
literal 0
HcmV?d00001

literal 4119
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
MTh>}hI=w*t5609pOaK4?

diff --git a/zlib/contrib/masmx64/inffasx64.obj b/zlib/contrib/masmx64/inffasx64.obj
diff --git a/zlib/contrib/masmx86/gvmat32.obj b/zlib/contrib/masmx86/gvmat32.obj
deleted file mode 100644
index ebb326238aed552f381eacbfa69f9ed48d3eb1a3..0000000000000000000000000000000000000000
GIT binary patch
literal 0
HcmV?d00001

literal 10241
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

diff --git a/zlib/contrib/masmx86/inffas32.obj b/zlib/contrib/masmx86/inffas32.obj
diff --git a/zlib/example.c b/zlib/example.c
deleted file mode 100644
index e30389750b2..00000000000
--- a/zlib/example.c
+++ /dev/null
@@ -1,565 +0,0 @@ 
-/* example.c -- usage example of the zlib compression library
- * Copyright (C) 1995-2006 Jean-loup Gailly.
- * For conditions of distribution and use, see copyright notice in zlib.h
- */
-
-/* @(#) $Id: example.c,v 1.1.1.2 2002/03/11 21:53:23 tromey Exp $ */
-
-#include "zlib.h"
-#include <stdio.h>
-
-#ifdef STDC
-#  include <string.h>
-#  include <stdlib.h>
-#endif
-
-#if defined(VMS) || defined(RISCOS)
-#  define TESTFILE "foo-gz"
-#else
-#  define TESTFILE "foo.gz"
-#endif
-
-#define CHECK_ERR(err, msg) { \
-    if (err != Z_OK) { \
-        fprintf(stderr, "%s error: %d\n", msg, err); \
-        exit(1); \
-    } \
-}
-
-const char hello[] = "hello, hello!";
-/* "hello world" would be more standard, but the repeated "hello"
- * stresses the compression code better, sorry...
- */
-
-const char dictionary[] = "hello";
-uLong dictId; /* Adler32 value of the dictionary */
-
-void test_compress      OF((Byte *compr, uLong comprLen,
-                            Byte *uncompr, uLong uncomprLen));
-void test_gzio          OF((const char *fname,
-                            Byte *uncompr, uLong uncomprLen));
-void test_deflate       OF((Byte *compr, uLong comprLen));
-void test_inflate       OF((Byte *compr, uLong comprLen,
-                            Byte *uncompr, uLong uncomprLen));
-void test_large_deflate OF((Byte *compr, uLong comprLen,
-                            Byte *uncompr, uLong uncomprLen));
-void test_large_inflate OF((Byte *compr, uLong comprLen,
-                            Byte *uncompr, uLong uncomprLen));
-void test_flush         OF((Byte *compr, uLong *comprLen));
-void test_sync          OF((Byte *compr, uLong comprLen,
-                            Byte *uncompr, uLong uncomprLen));
-void test_dict_deflate  OF((Byte *compr, uLong comprLen));
-void test_dict_inflate  OF((Byte *compr, uLong comprLen,
-                            Byte *uncompr, uLong uncomprLen));
-int  main               OF((int argc, char *argv[]));
-
-/* ===========================================================================
- * Test compress() and uncompress()
- */
-void test_compress(compr, comprLen, uncompr, uncomprLen)
-    Byte *compr, *uncompr;
-    uLong comprLen, uncomprLen;
-{
-    int err;
-    uLong len = (uLong)strlen(hello)+1;
-
-    err = compress(compr, &comprLen, (const Bytef*)hello, len);
-    CHECK_ERR(err, "compress");
-
-    strcpy((char*)uncompr, "garbage");
-
-    err = uncompress(uncompr, &uncomprLen, compr, comprLen);
-    CHECK_ERR(err, "uncompress");
-
-    if (strcmp((char*)uncompr, hello)) {
-        fprintf(stderr, "bad uncompress\n");
-        exit(1);
-    } else {
-        printf("uncompress(): %s\n", (char *)uncompr);
-    }
-}
-
-/* ===========================================================================
- * Test read/write of .gz files
- */
-void test_gzio(fname, uncompr, uncomprLen)
-    const char *fname; /* compressed file name */
-    Byte *uncompr;
-    uLong uncomprLen;
-{
-#ifdef NO_GZCOMPRESS
-    fprintf(stderr, "NO_GZCOMPRESS -- gz* functions cannot compress\n");
-#else
-    int err;
-    int len = (int)strlen(hello)+1;
-    gzFile file;
-    z_off_t pos;
-
-    file = gzopen(fname, "wb");
-    if (file == NULL) {
-        fprintf(stderr, "gzopen error\n");
-        exit(1);
-    }
-    gzputc(file, 'h');
-    if (gzputs(file, "ello") != 4) {
-        fprintf(stderr, "gzputs err: %s\n", gzerror(file, &err));
-        exit(1);
-    }
-    if (gzprintf(file, ", %s!", "hello") != 8) {
-        fprintf(stderr, "gzprintf err: %s\n", gzerror(file, &err));
-        exit(1);
-    }
-    gzseek(file, 1L, SEEK_CUR); /* add one zero byte */
-    gzclose(file);
-
-    file = gzopen(fname, "rb");
-    if (file == NULL) {
-        fprintf(stderr, "gzopen error\n");
-        exit(1);
-    }
-    strcpy((char*)uncompr, "garbage");
-
-    if (gzread(file, uncompr, (unsigned)uncomprLen) != len) {
-        fprintf(stderr, "gzread err: %s\n", gzerror(file, &err));
-        exit(1);
-    }
-    if (strcmp((char*)uncompr, hello)) {
-        fprintf(stderr, "bad gzread: %s\n", (char*)uncompr);
-        exit(1);
-    } else {
-        printf("gzread(): %s\n", (char*)uncompr);
-    }
-
-    pos = gzseek(file, -8L, SEEK_CUR);
-    if (pos != 6 || gztell(file) != pos) {
-        fprintf(stderr, "gzseek error, pos=%ld, gztell=%ld\n",
-                (long)pos, (long)gztell(file));
-        exit(1);
-    }
-
-    if (gzgetc(file) != ' ') {
-        fprintf(stderr, "gzgetc error\n");
-        exit(1);
-    }
-
-    if (gzungetc(' ', file) != ' ') {
-        fprintf(stderr, "gzungetc error\n");
-        exit(1);
-    }
-
-    gzgets(file, (char*)uncompr, (int)uncomprLen);
-    if (strlen((char*)uncompr) != 7) { /* " hello!" */
-        fprintf(stderr, "gzgets err after gzseek: %s\n", gzerror(file, &err));
-        exit(1);
-    }
-    if (strcmp((char*)uncompr, hello + 6)) {
-        fprintf(stderr, "bad gzgets after gzseek\n");
-        exit(1);
-    } else {
-        printf("gzgets() after gzseek: %s\n", (char*)uncompr);
-    }
-
-    gzclose(file);
-#endif
-}
-
-/* ===========================================================================
- * Test deflate() with small buffers
- */
-void test_deflate(compr, comprLen)
-    Byte *compr;
-    uLong comprLen;
-{
-    z_stream c_stream; /* compression stream */
-    int err;
-    uLong len = (uLong)strlen(hello)+1;
-
-    c_stream.zalloc = (alloc_func)0;
-    c_stream.zfree = (free_func)0;
-    c_stream.opaque = (voidpf)0;
-
-    err = deflateInit(&c_stream, Z_DEFAULT_COMPRESSION);
-    CHECK_ERR(err, "deflateInit");
-
-    c_stream.next_in  = (Bytef*)hello;
-    c_stream.next_out = compr;
-
-    while (c_stream.total_in != len && c_stream.total_out < comprLen) {
-        c_stream.avail_in = c_stream.avail_out = 1; /* force small buffers */
-        err = deflate(&c_stream, Z_NO_FLUSH);
-        CHECK_ERR(err, "deflate");
-    }
-    /* Finish the stream, still forcing small buffers: */
-    for (;;) {
-        c_stream.avail_out = 1;
-        err = deflate(&c_stream, Z_FINISH);
-        if (err == Z_STREAM_END) break;
-        CHECK_ERR(err, "deflate");
-    }
-
-    err = deflateEnd(&c_stream);
-    CHECK_ERR(err, "deflateEnd");
-}
-
-/* ===========================================================================
- * Test inflate() with small buffers
- */
-void test_inflate(compr, comprLen, uncompr, uncomprLen)
-    Byte *compr, *uncompr;
-    uLong comprLen, uncomprLen;
-{
-    int err;
-    z_stream d_stream; /* decompression stream */
-
-    strcpy((char*)uncompr, "garbage");
-
-    d_stream.zalloc = (alloc_func)0;
-    d_stream.zfree = (free_func)0;
-    d_stream.opaque = (voidpf)0;
-
-    d_stream.next_in  = compr;
-    d_stream.avail_in = 0;
-    d_stream.next_out = uncompr;
-
-    err = inflateInit(&d_stream);
-    CHECK_ERR(err, "inflateInit");
-
-    while (d_stream.total_out < uncomprLen && d_stream.total_in < comprLen) {
-        d_stream.avail_in = d_stream.avail_out = 1; /* force small buffers */
-        err = inflate(&d_stream, Z_NO_FLUSH);
-        if (err == Z_STREAM_END) break;
-        CHECK_ERR(err, "inflate");
-    }
-
-    err = inflateEnd(&d_stream);
-    CHECK_ERR(err, "inflateEnd");
-
-    if (strcmp((char*)uncompr, hello)) {
-        fprintf(stderr, "bad inflate\n");
-        exit(1);
-    } else {
-        printf("inflate(): %s\n", (char *)uncompr);
-    }
-}
-
-/* ===========================================================================
- * Test deflate() with large buffers and dynamic change of compression level
- */
-void test_large_deflate(compr, comprLen, uncompr, uncomprLen)
-    Byte *compr, *uncompr;
-    uLong comprLen, uncomprLen;
-{
-    z_stream c_stream; /* compression stream */
-    int err;
-
-    c_stream.zalloc = (alloc_func)0;
-    c_stream.zfree = (free_func)0;
-    c_stream.opaque = (voidpf)0;
-
-    err = deflateInit(&c_stream, Z_BEST_SPEED);
-    CHECK_ERR(err, "deflateInit");
-
-    c_stream.next_out = compr;
-    c_stream.avail_out = (uInt)comprLen;
-
-    /* At this point, uncompr is still mostly zeroes, so it should compress
-     * very well:
-     */
-    c_stream.next_in = uncompr;
-    c_stream.avail_in = (uInt)uncomprLen;
-    err = deflate(&c_stream, Z_NO_FLUSH);
-    CHECK_ERR(err, "deflate");
-    if (c_stream.avail_in != 0) {
-        fprintf(stderr, "deflate not greedy\n");
-        exit(1);
-    }
-
-    /* Feed in already compressed data and switch to no compression: */
-    deflateParams(&c_stream, Z_NO_COMPRESSION, Z_DEFAULT_STRATEGY);
-    c_stream.next_in = compr;
-    c_stream.avail_in = (uInt)comprLen/2;
-    err = deflate(&c_stream, Z_NO_FLUSH);
-    CHECK_ERR(err, "deflate");
-
-    /* Switch back to compressing mode: */
-    deflateParams(&c_stream, Z_BEST_COMPRESSION, Z_FILTERED);
-    c_stream.next_in = uncompr;
-    c_stream.avail_in = (uInt)uncomprLen;
-    err = deflate(&c_stream, Z_NO_FLUSH);
-    CHECK_ERR(err, "deflate");
-
-    err = deflate(&c_stream, Z_FINISH);
-    if (err != Z_STREAM_END) {
-        fprintf(stderr, "deflate should report Z_STREAM_END\n");
-        exit(1);
-    }
-    err = deflateEnd(&c_stream);
-    CHECK_ERR(err, "deflateEnd");
-}
-
-/* ===========================================================================
- * Test inflate() with large buffers
- */
-void test_large_inflate(compr, comprLen, uncompr, uncomprLen)
-    Byte *compr, *uncompr;
-    uLong comprLen, uncomprLen;
-{
-    int err;
-    z_stream d_stream; /* decompression stream */
-
-    strcpy((char*)uncompr, "garbage");
-
-    d_stream.zalloc = (alloc_func)0;
-    d_stream.zfree = (free_func)0;
-    d_stream.opaque = (voidpf)0;
-
-    d_stream.next_in  = compr;
-    d_stream.avail_in = (uInt)comprLen;
-
-    err = inflateInit(&d_stream);
-    CHECK_ERR(err, "inflateInit");
-
-    for (;;) {
-        d_stream.next_out = uncompr;            /* discard the output */
-        d_stream.avail_out = (uInt)uncomprLen;
-        err = inflate(&d_stream, Z_NO_FLUSH);
-        if (err == Z_STREAM_END) break;
-        CHECK_ERR(err, "large inflate");
-    }
-
-    err = inflateEnd(&d_stream);
-    CHECK_ERR(err, "inflateEnd");
-
-    if (d_stream.total_out != 2*uncomprLen + comprLen/2) {
-        fprintf(stderr, "bad large inflate: %ld\n", d_stream.total_out);
-        exit(1);
-    } else {
-        printf("large_inflate(): OK\n");
-    }
-}
-
-/* ===========================================================================
- * Test deflate() with full flush
- */
-void test_flush(compr, comprLen)
-    Byte *compr;
-    uLong *comprLen;
-{
-    z_stream c_stream; /* compression stream */
-    int err;
-    uInt len = (uInt)strlen(hello)+1;
-
-    c_stream.zalloc = (alloc_func)0;
-    c_stream.zfree = (free_func)0;
-    c_stream.opaque = (voidpf)0;
-
-    err = deflateInit(&c_stream, Z_DEFAULT_COMPRESSION);
-    CHECK_ERR(err, "deflateInit");
-
-    c_stream.next_in  = (Bytef*)hello;
-    c_stream.next_out = compr;
-    c_stream.avail_in = 3;
-    c_stream.avail_out = (uInt)*comprLen;
-    err = deflate(&c_stream, Z_FULL_FLUSH);
-    CHECK_ERR(err, "deflate");
-
-    compr[3]++; /* force an error in first compressed block */
-    c_stream.avail_in = len - 3;
-
-    err = deflate(&c_stream, Z_FINISH);
-    if (err != Z_STREAM_END) {
-        CHECK_ERR(err, "deflate");
-    }
-    err = deflateEnd(&c_stream);
-    CHECK_ERR(err, "deflateEnd");
-
-    *comprLen = c_stream.total_out;
-}
-
-/* ===========================================================================
- * Test inflateSync()
- */
-void test_sync(compr, comprLen, uncompr, uncomprLen)
-    Byte *compr, *uncompr;
-    uLong comprLen, uncomprLen;
-{
-    int err;
-    z_stream d_stream; /* decompression stream */
-
-    strcpy((char*)uncompr, "garbage");
-
-    d_stream.zalloc = (alloc_func)0;
-    d_stream.zfree = (free_func)0;
-    d_stream.opaque = (voidpf)0;
-
-    d_stream.next_in  = compr;
-    d_stream.avail_in = 2; /* just read the zlib header */
-
-    err = inflateInit(&d_stream);
-    CHECK_ERR(err, "inflateInit");
-
-    d_stream.next_out = uncompr;
-    d_stream.avail_out = (uInt)uncomprLen;
-
-    inflate(&d_stream, Z_NO_FLUSH);
-    CHECK_ERR(err, "inflate");
-
-    d_stream.avail_in = (uInt)comprLen-2;   /* read all compressed data */
-    err = inflateSync(&d_stream);           /* but skip the damaged part */
-    CHECK_ERR(err, "inflateSync");
-
-    err = inflate(&d_stream, Z_FINISH);
-    if (err != Z_DATA_ERROR) {
-        fprintf(stderr, "inflate should report DATA_ERROR\n");
-        /* Because of incorrect adler32 */
-        exit(1);
-    }
-    err = inflateEnd(&d_stream);
-    CHECK_ERR(err, "inflateEnd");
-
-    printf("after inflateSync(): hel%s\n", (char *)uncompr);
-}
-
-/* ===========================================================================
- * Test deflate() with preset dictionary
- */
-void test_dict_deflate(compr, comprLen)
-    Byte *compr;
-    uLong comprLen;
-{
-    z_stream c_stream; /* compression stream */
-    int err;
-
-    c_stream.zalloc = (alloc_func)0;
-    c_stream.zfree = (free_func)0;
-    c_stream.opaque = (voidpf)0;
-
-    err = deflateInit(&c_stream, Z_BEST_COMPRESSION);
-    CHECK_ERR(err, "deflateInit");
-
-    err = deflateSetDictionary(&c_stream,
-                               (const Bytef*)dictionary, sizeof(dictionary));
-    CHECK_ERR(err, "deflateSetDictionary");
-
-    dictId = c_stream.adler;
-    c_stream.next_out = compr;
-    c_stream.avail_out = (uInt)comprLen;
-
-    c_stream.next_in = (Bytef*)hello;
-    c_stream.avail_in = (uInt)strlen(hello)+1;
-
-    err = deflate(&c_stream, Z_FINISH);
-    if (err != Z_STREAM_END) {
-        fprintf(stderr, "deflate should report Z_STREAM_END\n");
-        exit(1);
-    }
-    err = deflateEnd(&c_stream);
-    CHECK_ERR(err, "deflateEnd");
-}
-
-/* ===========================================================================
- * Test inflate() with a preset dictionary
- */
-void test_dict_inflate(compr, comprLen, uncompr, uncomprLen)
-    Byte *compr, *uncompr;
-    uLong comprLen, uncomprLen;
-{
-    int err;
-    z_stream d_stream; /* decompression stream */
-
-    strcpy((char*)uncompr, "garbage");
-
-    d_stream.zalloc = (alloc_func)0;
-    d_stream.zfree = (free_func)0;
-    d_stream.opaque = (voidpf)0;
-
-    d_stream.next_in  = compr;
-    d_stream.avail_in = (uInt)comprLen;
-
-    err = inflateInit(&d_stream);
-    CHECK_ERR(err, "inflateInit");
-
-    d_stream.next_out = uncompr;
-    d_stream.avail_out = (uInt)uncomprLen;
-
-    for (;;) {
-        err = inflate(&d_stream, Z_NO_FLUSH);
-        if (err == Z_STREAM_END) break;
-        if (err == Z_NEED_DICT) {
-            if (d_stream.adler != dictId) {
-                fprintf(stderr, "unexpected dictionary");
-                exit(1);
-            }
-            err = inflateSetDictionary(&d_stream, (const Bytef*)dictionary,
-                                       sizeof(dictionary));
-        }
-        CHECK_ERR(err, "inflate with dict");
-    }
-
-    err = inflateEnd(&d_stream);
-    CHECK_ERR(err, "inflateEnd");
-
-    if (strcmp((char*)uncompr, hello)) {
-        fprintf(stderr, "bad inflate with dict\n");
-        exit(1);
-    } else {
-        printf("inflate with dictionary: %s\n", (char *)uncompr);
-    }
-}
-
-/* ===========================================================================
- * Usage:  example [output.gz  [input.gz]]
- */
-
-int main(argc, argv)
-    int argc;
-    char *argv[];
-{
-    Byte *compr, *uncompr;
-    uLong comprLen = 10000*sizeof(int); /* don't overflow on MSDOS */
-    uLong uncomprLen = comprLen;
-    static const char* myVersion = ZLIB_VERSION;
-
-    if (zlibVersion()[0] != myVersion[0]) {
-        fprintf(stderr, "incompatible zlib version\n");
-        exit(1);
-
-    } else if (strcmp(zlibVersion(), ZLIB_VERSION) != 0) {
-        fprintf(stderr, "warning: different zlib version\n");
-    }
-
-    printf("zlib version %s = 0x%04x, compile flags = 0x%lx\n",
-            ZLIB_VERSION, ZLIB_VERNUM, zlibCompileFlags());
-
-    compr    = (Byte*)calloc((uInt)comprLen, 1);
-    uncompr  = (Byte*)calloc((uInt)uncomprLen, 1);
-    /* compr and uncompr are cleared to avoid reading uninitialized
-     * data and to ensure that uncompr compresses well.
-     */
-    if (compr == Z_NULL || uncompr == Z_NULL) {
-        printf("out of memory\n");
-        exit(1);
-    }
-    test_compress(compr, comprLen, uncompr, uncomprLen);
-
-    test_gzio((argc > 1 ? argv[1] : TESTFILE),
-              uncompr, uncomprLen);
-
-    test_deflate(compr, comprLen);
-    test_inflate(compr, comprLen, uncompr, uncomprLen);
-
-    test_large_deflate(compr, comprLen, uncompr, uncomprLen);
-    test_large_inflate(compr, comprLen, uncompr, uncomprLen);
-
-    test_flush(compr, &comprLen);
-    test_sync(compr, comprLen, uncompr, uncomprLen);
-    comprLen = uncomprLen;
-
-    test_dict_deflate(compr, comprLen);
-    test_dict_inflate(compr, comprLen, uncompr, uncomprLen);
-
-    free(compr);
-    free(uncompr);
-
-    return 0;
-}
diff --git a/zlib/minigzip.c b/zlib/minigzip.c
deleted file mode 100644
index 7aa1c0f4ddd..00000000000
--- a/zlib/minigzip.c
+++ /dev/null
@@ -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: minigzip.c,v 1.1.1.2 2002/03/11 21:53:26 tromey Exp $ */
-
-#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;
-}