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

["Luke T. Shumaker" <lukeshu@lukeshu.com>]

The *.obj files are compiled binaries that should have been
.gitignore'd

zlib/example.c and zlib/minigzip.c are outdated duplicates of
zlib/test/example.c and zlib/test/minigzip.c
---
 zlib/contrib/masmx64/gvmat64.obj   | Bin 4119 -> 0 bytes
 zlib/contrib/masmx64/inffasx64.obj | Bin 5913 -> 0 bytes
 zlib/contrib/masmx86/gvmat32.obj   | Bin 10241 -> 0 bytes
 zlib/contrib/masmx86/inffas32.obj  | Bin 14893 -> 0 bytes
 zlib/example.c                     | 565 -----------------------------
 zlib/minigzip.c                    | 440 ----------------------
 6 files changed, 1005 deletions(-)
 delete mode 100644 zlib/contrib/masmx64/gvmat64.obj
 delete mode 100644 zlib/contrib/masmx64/inffasx64.obj
 delete mode 100644 zlib/contrib/masmx86/gvmat32.obj
 delete mode 100644 zlib/contrib/masmx86/inffas32.obj
 delete mode 100644 zlib/example.c
 delete mode 100644 zlib/minigzip.c

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
deleted file mode 100644
index 8df5d82616098e1f791526c3cd9875b24f5ad8c0..0000000000000000000000000000000000000000
GIT binary patch
literal 0
HcmV?d00001

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

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
deleted file mode 100644
index bd6664d111d573b4aa7a4d4a182d33b90d705700..0000000000000000000000000000000000000000
GIT binary patch
literal 0
HcmV?d00001

literal 14893
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
Xj0EA~XIzGb>~U2gmI;e9rc3_^+nh)b

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;
-}
-- 
2.45.1