Only call GetTextMetrics() in wxDC::GetTextExtent() if necessary.

[wxWidgets.git] / src / zlib / gzio.c

diff --git a/src/zlib/gzio.c b/src/zlib/gzio.c
index 868d218844b2904d6daf3a1d68a9732d4fd357fb..d6b55d5b6c8e07e57cd663f7e90066900206e022 100644 (file)
--- a/src/zlib/gzio.c
+++ b/src/zlib/gzio.c
@@ -1,8 +1,8 @@
 /* gzio.c -- IO on .gz files
 /* gzio.c -- IO on .gz files

- * Copyright (C) 1995-1998 Jean-loup Gailly.
+ * Copyright (C) 1995-2005 Jean-loup Gailly.

  * For conditions of distribution and use, see copyright notice in zlib.h
  *
  * For conditions of distribution and use, see copyright notice in zlib.h
  *

- * Compile this file with -DNO_DEFLATE to avoid the compression code.
+ * Compile this file with -DNO_GZCOMPRESS to avoid the compression code.

  */
 
 /* @(#) $Id$ */
  */
 
 /* @(#) $Id$ */


@@ -11,7 +11,13 @@
 
 #include "zutil.h"
 
 
 #include "zutil.h"
 

+#ifdef NO_DEFLATE       /* for compatibility with old definition */
+#  define NO_GZCOMPRESS
+#endif
+
+#ifndef NO_DUMMY_DECL

 struct internal_state {int dummy;}; /* for buggy compilers */
 struct internal_state {int dummy;}; /* for buggy compilers */

+#endif

 
 #ifndef Z_BUFSIZE
 #  ifdef MAXSEG_64K
 
 #ifndef Z_BUFSIZE
 #  ifdef MAXSEG_64K


@@ -24,10 +30,26 @@ struct internal_state {int dummy;}; /* for buggy compilers */
 #  define Z_PRINTF_BUFSIZE 4096
 #endif
 
 #  define Z_PRINTF_BUFSIZE 4096
 #endif
 

+#ifdef __MVS__
+#  pragma map (fdopen , "\174\174FDOPEN")
+   FILE *fdopen(int, const char *);
+#endif
+
+#ifndef STDC
+extern voidp  malloc OF((uInt size));
+extern void   free   OF((voidpf ptr));
+#endif
+

 #define ALLOC(size) malloc(size)
 #define TRYFREE(p) {if (p) free(p);}
 
 #define ALLOC(size) malloc(size)
 #define TRYFREE(p) {if (p) free(p);}
 

-static int gz_magic[2] = {0x1f, 0x8b}; /* gzip magic header */
+/* there is no errno under Windows CE, provide a dummy one to avoid modifying
+   too much code in this file */
+#ifdef _WIN32_WCE
+static int errno;
+#endif
+
+static int const gz_magic[2] = {0x1f, 0x8b}; /* gzip magic header */

 
 /* gzip flag byte */
 #define ASCII_FLAG   0x01 /* bit 0 set: file probably ascii text */
 
 /* gzip flag byte */
 #define ASCII_FLAG   0x01 /* bit 0 set: file probably ascii text */


@@ -49,7 +71,11 @@ typedef struct gz_stream {
     char     *path;   /* path name for debugging only */
     int      transparent; /* 1 if input file is not a .gz file */
     char     mode;    /* 'w' or 'r' */
     char     *path;   /* path name for debugging only */
     int      transparent; /* 1 if input file is not a .gz file */
     char     mode;    /* 'w' or 'r' */

-    long     startpos; /* start of compressed data in file (header skipped) */
+    z_off_t  start;   /* start of compressed data in file (header skipped) */
+    z_off_t  in;      /* bytes into deflate or inflate */
+    z_off_t  out;     /* bytes out of deflate or inflate */
+    int      back;    /* one character push-back */
+    int      last;    /* true if push-back is last character */

 } gz_stream;
 
 
 } gz_stream;
 
 


@@ -65,19 +91,15 @@ local uLong  getLong      OF((gz_stream *s));
      Opens a gzip (.gz) file for reading or writing. The mode parameter
    is as in fopen ("rb" or "wb"). The file is given either by file descriptor
    or path name (if fd == -1).
      Opens a gzip (.gz) file for reading or writing. The mode parameter
    is as in fopen ("rb" or "wb"). The file is given either by file descriptor
    or path name (if fd == -1).

-     gz_open return NULL if the file could not be opened or if there was
+     gz_open returns NULL if the file could not be opened or if there was

    insufficient memory to allocate the (de)compression state; errno
    can be checked to distinguish the two cases (if errno is zero, the
    zlib error is Z_MEM_ERROR).
 */
    insufficient memory to allocate the (de)compression state; errno
    can be checked to distinguish the two cases (if errno is zero, the
    zlib error is Z_MEM_ERROR).
 */

-#if defined(__VISAGECPP__) // Visual game can't handle this antiquated interface
-local gzFile gz_open (const char* path, const char* mode, int fd)
-#else

 local gzFile gz_open (path, mode, fd)
     const char *path;
     const char *mode;
     int  fd;
 local gzFile gz_open (path, mode, fd)
     const char *path;
     const char *mode;
     int  fd;

-#endif

 {
     int err;
     int level = Z_DEFAULT_COMPRESSION; /* compression level */
 {
     int err;
     int level = Z_DEFAULT_COMPRESSION; /* compression level */


@@ -101,6 +123,9 @@ local gzFile gz_open (path, mode, fd)
     s->file = NULL;
     s->z_err = Z_OK;
     s->z_eof = 0;
     s->file = NULL;
     s->z_err = Z_OK;
     s->z_eof = 0;

+    s->in = 0;
+    s->out = 0;
+    s->back = EOF;

     s->crc = crc32(0L, Z_NULL, 0);
     s->msg = NULL;
     s->transparent = 0;
     s->crc = crc32(0L, Z_NULL, 0);
     s->msg = NULL;
     s->transparent = 0;


@@ -116,19 +141,21 @@ local gzFile gz_open (path, mode, fd)
         if (*p == 'r') s->mode = 'r';
         if (*p == 'w' || *p == 'a') s->mode = 'w';
         if (*p >= '0' && *p <= '9') {
         if (*p == 'r') s->mode = 'r';
         if (*p == 'w' || *p == 'a') s->mode = 'w';
         if (*p >= '0' && *p <= '9') {

-           level = *p - '0';
-       } else if (*p == 'f') {
-         strategy = Z_FILTERED;
-       } else if (*p == 'h') {
-         strategy = Z_HUFFMAN_ONLY;
-       } else {
-           *m++ = *p; /* copy the mode */
-       }
+            level = *p - '0';
+        } else if (*p == 'f') {
+          strategy = Z_FILTERED;
+        } else if (*p == 'h') {
+          strategy = Z_HUFFMAN_ONLY;
+        } else if (*p == 'R') {
+          strategy = Z_RLE;
+        } else {
+            *m++ = *p; /* copy the mode */
+        }

     } while (*p++ && m != fmode + sizeof(fmode));
     if (s->mode == '\0') return destroy(s), (gzFile)Z_NULL;
 
     if (s->mode == 'w') {
     } while (*p++ && m != fmode + sizeof(fmode));
     if (s->mode == '\0') return destroy(s), (gzFile)Z_NULL;
 
     if (s->mode == 'w') {

-#ifdef NO_DEFLATE
+#ifdef NO_GZCOMPRESS

         err = Z_STREAM_ERROR;
 #else
         err = deflateInit2(&(s->stream), level,
         err = Z_STREAM_ERROR;
 #else
         err = deflateInit2(&(s->stream), level,


@@ -167,15 +194,15 @@ local gzFile gz_open (path, mode, fd)
          */
         fprintf(s->file, "%c%c%c%c%c%c%c%c%c%c", gz_magic[0], gz_magic[1],
              Z_DEFLATED, 0 /*flags*/, 0,0,0,0 /*time*/, 0 /*xflags*/, OS_CODE);
          */
         fprintf(s->file, "%c%c%c%c%c%c%c%c%c%c", gz_magic[0], gz_magic[1],
              Z_DEFLATED, 0 /*flags*/, 0,0,0,0 /*time*/, 0 /*xflags*/, OS_CODE);

-       s->startpos = 10L;
-       /* We use 10L instead of ftell(s->file) to because ftell causes an
+        s->start = 10L;
+        /* We use 10L instead of ftell(s->file) to because ftell causes an

          * fflush on some systems. This version of the library doesn't use
          * fflush on some systems. This version of the library doesn't use

-         * startpos anyway in write mode, so this initialization is not
+         * start anyway in write mode, so this initialization is not

          * necessary.
          */
     } else {
          * necessary.
          */
     } else {

-       check_header(s); /* skip the .gz header */
-       s->startpos = (ftell(s->file) - s->stream.avail_in);
+        check_header(s); /* skip the .gz header */
+        s->start = ftell(s->file) - s->stream.avail_in;

     }
 
     return (gzFile)s;
     }
 
     return (gzFile)s;


@@ -184,13 +211,9 @@ local gzFile gz_open (path, mode, fd)
 /* ===========================================================================
      Opens a gzip (.gz) file for reading or writing.
 */
 /* ===========================================================================
      Opens a gzip (.gz) file for reading or writing.
 */

-#if defined(__VISAGECPP__) // Visual game can't handle this antiquated interface
-gzFile ZEXPORT gzopen (const char* path, const char* mode)
-#else

 gzFile ZEXPORT gzopen (path, mode)
     const char *path;
     const char *mode;
 gzFile ZEXPORT gzopen (path, mode)
     const char *path;
     const char *mode;

-#endif

 {
     return gz_open (path, mode, -1);
 }
 {
     return gz_open (path, mode, -1);
 }


@@ -199,15 +222,11 @@ gzFile ZEXPORT gzopen (path, mode)
      Associate a gzFile with the file descriptor fd. fd is not dup'ed here
    to mimic the behavio(u)r of fdopen.
 */
      Associate a gzFile with the file descriptor fd. fd is not dup'ed here
    to mimic the behavio(u)r of fdopen.
 */

-#if defined(__VISAGECPP__) // Visual game can't handle this antiquated interface
-gzFile ZEXPORT gzdopen (int fd, const char* mode)
-#else

 gzFile ZEXPORT gzdopen (fd, mode)
     int fd;
     const char *mode;
 gzFile ZEXPORT gzdopen (fd, mode)
     int fd;
     const char *mode;

-#endif

 {
 {

-    char name[20];
+    char name[46];      /* allow for up to 128-bit integers */

 
     if (fd < 0) return (gzFile)Z_NULL;
     sprintf(name, "<fd:%d>", fd); /* for debugging */
 
     if (fd < 0) return (gzFile)Z_NULL;
     sprintf(name, "<fd:%d>", fd); /* for debugging */


@@ -218,14 +237,10 @@ gzFile ZEXPORT gzdopen (fd, mode)
 /* ===========================================================================
  * Update the compression level and strategy
  */
 /* ===========================================================================
  * Update the compression level and strategy
  */

-#if defined(__VISAGECPP__) // Visual game can't handle this antiquated interface
-int ZEXPORT gzsetparams (gzFile file, int level, int strategy)
-#else

 int ZEXPORT gzsetparams (file, level, strategy)
     gzFile file;
     int level;
     int strategy;
 int ZEXPORT gzsetparams (file, level, strategy)
     gzFile file;
     int level;
     int strategy;

-#endif

 {
     gz_stream *s = (gz_stream*)file;
 
 {
     gz_stream *s = (gz_stream*)file;
 


@@ -234,11 +249,11 @@ int ZEXPORT gzsetparams (file, level, strategy)
     /* Make room to allow flushing */
     if (s->stream.avail_out == 0) {
 
     /* Make room to allow flushing */
     if (s->stream.avail_out == 0) {
 

-       s->stream.next_out = s->outbuf;
-       if (fwrite(s->outbuf, 1, Z_BUFSIZE, s->file) != Z_BUFSIZE) {
-           s->z_err = Z_ERRNO;
-       }
-       s->stream.avail_out = Z_BUFSIZE;
+        s->stream.next_out = s->outbuf;
+        if (fwrite(s->outbuf, 1, Z_BUFSIZE, s->file) != Z_BUFSIZE) {
+            s->z_err = Z_ERRNO;
+        }
+        s->stream.avail_out = Z_BUFSIZE;

     }
 
     return deflateParams (&(s->stream), level, strategy);
     }
 
     return deflateParams (&(s->stream), level, strategy);


@@ -249,23 +264,19 @@ int ZEXPORT gzsetparams (file, level, strategy)
    for end of file.
    IN assertion: the stream s has been sucessfully opened for reading.
 */
    for end of file.
    IN assertion: the stream s has been sucessfully opened for reading.
 */

-#if defined(__VISAGECPP__) // Visual game can't handle this antiquated interface
-local int get_byte(gz_stream* s)
-#else

 local int get_byte(s)
     gz_stream *s;
 local int get_byte(s)
     gz_stream *s;

-#endif

 {
     if (s->z_eof) return EOF;
     if (s->stream.avail_in == 0) {
 {
     if (s->z_eof) return EOF;
     if (s->stream.avail_in == 0) {

-       errno = 0;
-       s->stream.avail_in = fread(s->inbuf, 1, Z_BUFSIZE, s->file);
-       if (s->stream.avail_in == 0) {
-           s->z_eof = 1;
-           if (ferror(s->file)) s->z_err = Z_ERRNO;
-           return EOF;
-       }
-       s->stream.next_in = s->inbuf;
+        errno = 0;
+        s->stream.avail_in = (uInt)fread(s->inbuf, 1, Z_BUFSIZE, s->file);
+        if (s->stream.avail_in == 0) {
+            s->z_eof = 1;
+            if (ferror(s->file)) s->z_err = Z_ERRNO;
+            return EOF;
+        }
+        s->stream.next_in = s->inbuf;

     }
     s->stream.avail_in--;
     return *(s->stream.next_in)++;
     }
     s->stream.avail_in--;
     return *(s->stream.next_in)++;


@@ -280,55 +291,65 @@ local int get_byte(s)
        s->stream.avail_in is zero for the first time, but may be non-zero
        for concatenated .gz files.
 */
        s->stream.avail_in is zero for the first time, but may be non-zero
        for concatenated .gz files.
 */

-#if defined(__VISAGECPP__) // Visual game can't handle this antiquated interface
-local void check_header(gz_stream* s)
-#else

 local void check_header(s)
     gz_stream *s;
 local void check_header(s)
     gz_stream *s;

-#endif

 {
     int method; /* method byte */
     int flags;  /* flags byte */
     uInt len;
     int c;
 
 {
     int method; /* method byte */
     int flags;  /* flags byte */
     uInt len;
     int c;
 

-    /* Check the gzip magic header */
-    for (len = 0; len < 2; len++) {
-       c = get_byte(s);
-       if (c != gz_magic[len]) {
-           if (len != 0) s->stream.avail_in++, s->stream.next_in--;
-           if (c != EOF) {
-               s->stream.avail_in++, s->stream.next_in--;
-               s->transparent = 1;
-           }
-           s->z_err = s->stream.avail_in != 0 ? Z_OK : Z_STREAM_END;
-           return;
-       }
+    /* Assure two bytes in the buffer so we can peek ahead -- handle case
+       where first byte of header is at the end of the buffer after the last
+       gzip segment */
+    len = s->stream.avail_in;
+    if (len < 2) {
+        if (len) s->inbuf[0] = s->stream.next_in[0];
+        errno = 0;
+        len = (uInt)fread(s->inbuf + len, 1, Z_BUFSIZE >> len, s->file);
+        if (len == 0 && ferror(s->file)) s->z_err = Z_ERRNO;
+        s->stream.avail_in += len;
+        s->stream.next_in = s->inbuf;
+        if (s->stream.avail_in < 2) {
+            s->transparent = s->stream.avail_in;
+            return;
+        }
+    }
+
+    /* Peek ahead to check the gzip magic header */
+    if (s->stream.next_in[0] != gz_magic[0] ||
+        s->stream.next_in[1] != gz_magic[1]) {
+        s->transparent = 1;
+        return;

     }
     }

+    s->stream.avail_in -= 2;
+    s->stream.next_in += 2;
+
+    /* Check the rest of the gzip header */

     method = get_byte(s);
     flags = get_byte(s);
     if (method != Z_DEFLATED || (flags & RESERVED) != 0) {
     method = get_byte(s);
     flags = get_byte(s);
     if (method != Z_DEFLATED || (flags & RESERVED) != 0) {

-       s->z_err = Z_DATA_ERROR;
-       return;
+        s->z_err = Z_DATA_ERROR;
+        return;

     }
 
     /* Discard time, xflags and OS code: */
     for (len = 0; len < 6; len++) (void)get_byte(s);
 
     if ((flags & EXTRA_FIELD) != 0) { /* skip the extra field */
     }
 
     /* Discard time, xflags and OS code: */
     for (len = 0; len < 6; len++) (void)get_byte(s);
 
     if ((flags & EXTRA_FIELD) != 0) { /* skip the extra field */

-       len  =  (uInt)get_byte(s);
-       len += ((uInt)get_byte(s))<<8;
-       /* len is garbage if EOF but the loop below will quit anyway */
-       while (len-- != 0 && get_byte(s) != EOF) ;
+        len  =  (uInt)get_byte(s);
+        len += ((uInt)get_byte(s))<<8;
+        /* len is garbage if EOF but the loop below will quit anyway */
+        while (len-- != 0 && get_byte(s) != EOF) ;

     }
     if ((flags & ORIG_NAME) != 0) { /* skip the original file name */
     }
     if ((flags & ORIG_NAME) != 0) { /* skip the original file name */

-       while ((c = get_byte(s)) != 0 && c != EOF) ;
+        while ((c = get_byte(s)) != 0 && c != EOF) ;

     }
     if ((flags & COMMENT) != 0) {   /* skip the .gz file comment */
     }
     if ((flags & COMMENT) != 0) {   /* skip the .gz file comment */

-       while ((c = get_byte(s)) != 0 && c != EOF) ;
+        while ((c = get_byte(s)) != 0 && c != EOF) ;

     }
     if ((flags & HEAD_CRC) != 0) {  /* skip the header crc */
     }
     if ((flags & HEAD_CRC) != 0) {  /* skip the header crc */

-       for (len = 0; len < 2; len++) (void)get_byte(s);
+        for (len = 0; len < 2; len++) (void)get_byte(s);

     }
     s->z_err = s->z_eof ? Z_DATA_ERROR : Z_OK;
 }
     }
     s->z_err = s->z_eof ? Z_DATA_ERROR : Z_OK;
 }


@@ -337,12 +358,8 @@ local void check_header(s)
  * Cleanup then free the given gz_stream. Return a zlib error code.
    Try freeing in the reverse order of allocations.
  */
  * Cleanup then free the given gz_stream. Return a zlib error code.
    Try freeing in the reverse order of allocations.
  */

-#if defined(__VISAGECPP__) // Visual game can't handle this antiquated interface
-local int destroy (gz_stream* s)
-#else

 local int destroy (s)
     gz_stream *s;
 local int destroy (s)
     gz_stream *s;

-#endif

 {
     int err = Z_OK;
 
 {
     int err = Z_OK;
 


@@ -351,21 +368,21 @@ local int destroy (s)
     TRYFREE(s->msg);
 
     if (s->stream.state != NULL) {
     TRYFREE(s->msg);
 
     if (s->stream.state != NULL) {

-       if (s->mode == 'w') {
-#ifdef NO_DEFLATE
-           err = Z_STREAM_ERROR;
+        if (s->mode == 'w') {
+#ifdef NO_GZCOMPRESS
+            err = Z_STREAM_ERROR;

 #else
 #else

-           err = deflateEnd(&(s->stream));
+            err = deflateEnd(&(s->stream));

 #endif
 #endif

-       } else if (s->mode == 'r') {
-           err = inflateEnd(&(s->stream));
-       }
+        } else if (s->mode == 'r') {
+            err = inflateEnd(&(s->stream));
+        }

     }
     if (s->file != NULL && fclose(s->file)) {
 #ifdef ESPIPE
     }
     if (s->file != NULL && fclose(s->file)) {
 #ifdef ESPIPE

-       if (errno != ESPIPE) /* fclose is broken for pipes in HP/UX */
+        if (errno != ESPIPE) /* fclose is broken for pipes in HP/UX */

 #endif
 #endif

-           err = Z_ERRNO;
+            err = Z_ERRNO;

     }
     if (s->z_err < 0) err = s->z_err;
 
     }
     if (s->z_err < 0) err = s->z_err;
 


@@ -380,14 +397,10 @@ local int destroy (s)
      Reads the given number of uncompressed bytes from the compressed file.
    gzread returns the number of bytes actually read (0 for end of file).
 */
      Reads the given number of uncompressed bytes from the compressed file.
    gzread returns the number of bytes actually read (0 for end of file).
 */

-#if defined(__VISAGECPP__) // Visual game can't handle this antiquated interface
-int ZEXPORT gzread (gzFile file, voidp buf, unsigned len)
-#else

 int ZEXPORT gzread (file, buf, len)
     gzFile file;
     voidp buf;
     unsigned len;
 int ZEXPORT gzread (file, buf, len)
     gzFile file;
     voidp buf;
     unsigned len;

-#endif

 {
     gz_stream *s = (gz_stream*)file;
     Bytef *start = (Bytef*)buf; /* starting point for crc computation */
 {
     gz_stream *s = (gz_stream*)file;
     Bytef *start = (Bytef*)buf; /* starting point for crc computation */


@@ -402,70 +415,89 @@ int ZEXPORT gzread (file, buf, len)
     s->stream.next_out = (Bytef*)buf;
     s->stream.avail_out = len;
 
     s->stream.next_out = (Bytef*)buf;
     s->stream.avail_out = len;
 

+    if (s->stream.avail_out && s->back != EOF) {
+        *next_out++ = s->back;
+        s->stream.next_out++;
+        s->stream.avail_out--;
+        s->back = EOF;
+        s->out++;
+        start++;
+        if (s->last) {
+            s->z_err = Z_STREAM_END;
+            return 1;
+        }
+    }
+

     while (s->stream.avail_out != 0) {
 
     while (s->stream.avail_out != 0) {
 

-       if (s->transparent) {
-           /* Copy first the lookahead bytes: */
-           uInt n = s->stream.avail_in;
-           if (n > s->stream.avail_out) n = s->stream.avail_out;
-           if (n > 0) {
-               zmemcpy(s->stream.next_out, s->stream.next_in, n);
-               next_out += n;
-               s->stream.next_out = next_out;
-               s->stream.next_in   += n;
-               s->stream.avail_out -= n;
-               s->stream.avail_in  -= n;
-           }
-           if (s->stream.avail_out > 0) {
-               s->stream.avail_out -= fread(next_out, 1, s->stream.avail_out,
-                                            s->file);
-           }
-           len -= s->stream.avail_out;
-           s->stream.total_in  += (uLong)len;
-           s->stream.total_out += (uLong)len;
+        if (s->transparent) {
+            /* Copy first the lookahead bytes: */
+            uInt n = s->stream.avail_in;
+            if (n > s->stream.avail_out) n = s->stream.avail_out;
+            if (n > 0) {
+                zmemcpy(s->stream.next_out, s->stream.next_in, n);
+                next_out += n;
+                s->stream.next_out = next_out;
+                s->stream.next_in   += n;
+                s->stream.avail_out -= n;
+                s->stream.avail_in  -= n;
+            }
+            if (s->stream.avail_out > 0) {
+                s->stream.avail_out -=
+                    (uInt)fread(next_out, 1, s->stream.avail_out, s->file);
+            }
+            len -= s->stream.avail_out;
+            s->in  += len;
+            s->out += len;

             if (len == 0) s->z_eof = 1;
             if (len == 0) s->z_eof = 1;

-           return (int)len;
-       }
+            return (int)len;
+        }

         if (s->stream.avail_in == 0 && !s->z_eof) {
 
             errno = 0;
         if (s->stream.avail_in == 0 && !s->z_eof) {
 
             errno = 0;

-            s->stream.avail_in = fread(s->inbuf, 1, Z_BUFSIZE, s->file);
+            s->stream.avail_in = (uInt)fread(s->inbuf, 1, Z_BUFSIZE, s->file);

             if (s->stream.avail_in == 0) {
                 s->z_eof = 1;
             if (s->stream.avail_in == 0) {
                 s->z_eof = 1;

-               if (ferror(s->file)) {
-                   s->z_err = Z_ERRNO;
-                   break;
-               }
+                if (ferror(s->file)) {
+                    s->z_err = Z_ERRNO;
+                    break;
+                }

             }
             s->stream.next_in = s->inbuf;
         }
             }
             s->stream.next_in = s->inbuf;
         }

+        s->in += s->stream.avail_in;
+        s->out += s->stream.avail_out;

         s->z_err = inflate(&(s->stream), Z_NO_FLUSH);
         s->z_err = inflate(&(s->stream), Z_NO_FLUSH);

-
-       if (s->z_err == Z_STREAM_END) {
-           /* Check CRC and original size */
-           s->crc = crc32(s->crc, start, (uInt)(s->stream.next_out - start));
-           start = s->stream.next_out;
-
-           if (getLong(s) != s->crc || getLong(s) != s->stream.total_out) {
-               s->z_err = Z_DATA_ERROR;
-           } else {
-               /* Check for concatenated .gz files: */
-               check_header(s);
-               if (s->z_err == Z_OK) {
-                   uLong total_in = s->stream.total_in;
-                   uLong total_out = s->stream.total_out;
-
-                   inflateReset(&(s->stream));
-                   s->stream.total_in = total_in;
-                   s->stream.total_out = total_out;
-                   s->crc = crc32(0L, Z_NULL, 0);
-               }
-           }
-       }
-       if (s->z_err != Z_OK || s->z_eof) break;
+        s->in -= s->stream.avail_in;
+        s->out -= s->stream.avail_out;
+
+        if (s->z_err == Z_STREAM_END) {
+            /* Check CRC and original size */
+            s->crc = crc32(s->crc, start, (uInt)(s->stream.next_out - start));
+            start = s->stream.next_out;
+
+            if (getLong(s) != s->crc) {
+                s->z_err = Z_DATA_ERROR;
+            } else {
+                (void)getLong(s);
+                /* The uncompressed length returned by above getlong() may be
+                 * different from s->out in case of concatenated .gz files.
+                 * Check for such files:
+                 */
+                check_header(s);
+                if (s->z_err == Z_OK) {
+                    inflateReset(&(s->stream));
+                    s->crc = crc32(0L, Z_NULL, 0);
+                }
+            }
+        }
+        if (s->z_err != Z_OK || s->z_eof) break;

     }
     s->crc = crc32(s->crc, start, (uInt)(s->stream.next_out - start));
 
     }
     s->crc = crc32(s->crc, start, (uInt)(s->stream.next_out - start));
 

+    if (len == s->stream.avail_out &&
+        (s->z_err == Z_DATA_ERROR || s->z_err == Z_ERRNO))
+        return -1;

     return (int)(len - s->stream.avail_out);
 }
 
     return (int)(len - s->stream.avail_out);
 }
 


@@ -474,12 +506,8 @@ int ZEXPORT gzread (file, buf, len)
       Reads one byte from the compressed file. gzgetc returns this byte
    or -1 in case of end of file or error.
 */
       Reads one byte from the compressed file. gzgetc returns this byte
    or -1 in case of end of file or error.
 */

-#if defined(__VISAGECPP__) // Visual game can't handle this antiquated interface
-int ZEXPORT gzgetc(gzFile file)
-#else

 int ZEXPORT gzgetc(file)
     gzFile file;
 int ZEXPORT gzgetc(file)
     gzFile file;

-#endif

 {
     unsigned char c;
 
 {
     unsigned char c;
 


@@ -487,6 +515,25 @@ int ZEXPORT gzgetc(file)
 }
 
 
 }
 
 

+/* ===========================================================================
+      Push one byte back onto the stream.
+*/
+int ZEXPORT gzungetc(c, file)
+    int c;
+    gzFile file;
+{
+    gz_stream *s = (gz_stream*)file;
+
+    if (s == NULL || s->mode != 'r' || c == EOF || s->back != EOF) return EOF;
+    s->back = c;
+    s->out--;
+    s->last = (s->z_err == Z_STREAM_END);
+    if (s->last) s->z_err = Z_OK;
+    s->z_eof = 0;
+    return c;
+}
+
+

 /* ===========================================================================
       Reads bytes from the compressed file until len-1 characters are
    read, or a newline character is read and transferred to buf, or an
 /* ===========================================================================
       Reads bytes from the compressed file until len-1 characters are
    read, or a newline character is read and transferred to buf, or an


@@ -496,14 +543,10 @@ int ZEXPORT gzgetc(file)
 
       The current implementation is not optimized at all.
 */
 
       The current implementation is not optimized at all.
 */

-#if defined(__VISAGECPP__) // Visual game can't handle this antiquated interface
-char* ZEXPORT gzgets(gzFile file, char* buf, int len)
-#else

 char * ZEXPORT gzgets(file, buf, len)
     gzFile file;
     char *buf;
     int len;
 char * ZEXPORT gzgets(file, buf, len)
     gzFile file;
     char *buf;
     int len;

-#endif

 {
     char *b = buf;
     if (buf == Z_NULL || len <= 0) return Z_NULL;
 {
     char *b = buf;
     if (buf == Z_NULL || len <= 0) return Z_NULL;


@@ -514,19 +557,15 @@ char * ZEXPORT gzgets(file, buf, len)
 }
 
 
 }
 
 

-#ifndef NO_DEFLATE
+#ifndef NO_GZCOMPRESS

 /* ===========================================================================
      Writes the given number of uncompressed bytes into the compressed file.
    gzwrite returns the number of bytes actually written (0 in case of error).
 */
 /* ===========================================================================
      Writes the given number of uncompressed bytes into the compressed file.
    gzwrite returns the number of bytes actually written (0 in case of error).
 */

-#if defined(__VISAGECPP__) // Visual game can't handle this antiquated interface
-int ZEXPORT gzwrite (gzFile file, const voidp buf, unsigned len)
-#else

 int ZEXPORT gzwrite (file, buf, len)
     gzFile file;
 int ZEXPORT gzwrite (file, buf, len)
     gzFile file;

-    const voidp buf;
+    voidpc buf;

     unsigned len;
     unsigned len;

-#endif

 {
     gz_stream *s = (gz_stream*)file;
 
 {
     gz_stream *s = (gz_stream*)file;
 


@@ -546,7 +585,11 @@ int ZEXPORT gzwrite (file, buf, len)
             }
             s->stream.avail_out = Z_BUFSIZE;
         }
             }
             s->stream.avail_out = Z_BUFSIZE;
         }

+        s->in += s->stream.avail_in;
+        s->out += s->stream.avail_out;

         s->z_err = deflate(&(s->stream), Z_NO_FLUSH);
         s->z_err = deflate(&(s->stream), Z_NO_FLUSH);

+        s->in -= s->stream.avail_in;
+        s->out -= s->stream.avail_out;

         if (s->z_err != Z_OK) break;
     }
     s->crc = crc32(s->crc, (const Bytef *)buf, len);
         if (s->z_err != Z_OK) break;
     }
     s->crc = crc32(s->crc, (const Bytef *)buf, len);


@@ -554,6 +597,7 @@ int ZEXPORT gzwrite (file, buf, len)
     return (int)(len - s->stream.avail_in);
 }
 
     return (int)(len - s->stream.avail_in);
 }
 

+

 /* ===========================================================================
      Converts, formats, and writes the args to the compressed file under
    control of the format string, as in fprintf. gzprintf returns the number of
 /* ===========================================================================
      Converts, formats, and writes the args to the compressed file under
    control of the format string, as in fprintf. gzprintf returns the number of


@@ -568,46 +612,67 @@ int ZEXPORTVA gzprintf (gzFile file, const char *format, /* args */ ...)
     va_list va;
     int len;
 
     va_list va;
     int len;
 

+    buf[sizeof(buf) - 1] = 0;

     va_start(va, format);
     va_start(va, format);

-#ifdef HAS_vsnprintf
-    (void)vsnprintf(buf, sizeof(buf), format, va);
-#else
+#ifdef NO_vsnprintf
+#  ifdef HAS_vsprintf_void

     (void)vsprintf(buf, format, va);
     (void)vsprintf(buf, format, va);

-#endif

     va_end(va);
     va_end(va);

-    len = strlen(buf); /* some *sprintf don't return the nb of bytes written */
-    if (len <= 0) return 0;
-
+    for (len = 0; len < sizeof(buf); len++)
+        if (buf[len] == 0) break;
+#  else
+    len = vsprintf(buf, format, va);
+    va_end(va);
+#  endif
+#else
+#  ifdef HAS_vsnprintf_void
+    (void)vsnprintf(buf, sizeof(buf), format, va);
+    va_end(va);
+    len = strlen(buf);
+#  else
+    len = vsnprintf(buf, sizeof(buf), format, va);
+    va_end(va);
+#  endif
+#endif
+    if (len <= 0 || len >= (int)sizeof(buf) || buf[sizeof(buf) - 1] != 0)
+        return 0;

     return gzwrite(file, buf, (unsigned)len);
 }
 #else /* not ANSI C */
 
     return gzwrite(file, buf, (unsigned)len);
 }
 #else /* not ANSI C */
 

-#if defined(__VISAGECPP__) // Visual game can't handle this antiquated interface
-int ZEXPORTVA gzprintf (gzFile file const char* format, int a1, int a2, int a3, int a4,
-                        int a5, int a6, int a7, int a8, int a9, int a10, int a11, int a12
-                        int a13, int a14, int a15, int a16, int a17, int a18, int a19, int a20)
-#else

 int ZEXPORTVA gzprintf (file, format, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10,
 int ZEXPORTVA gzprintf (file, format, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10,

-                      a11, a12, a13, a14, a15, a16, a17, a18, a19, a20)
+                       a11, a12, a13, a14, a15, a16, a17, a18, a19, a20)

     gzFile file;
     const char *format;
     int a1, a2, a3, a4, a5, a6, a7, a8, a9, a10,
     gzFile file;
     const char *format;
     int a1, a2, a3, a4, a5, a6, a7, a8, a9, a10,

-       a11, a12, a13, a14, a15, a16, a17, a18, a19, a20;
-#endif
+        a11, a12, a13, a14, a15, a16, a17, a18, a19, a20;

 {
     char buf[Z_PRINTF_BUFSIZE];
     int len;
 
 {
     char buf[Z_PRINTF_BUFSIZE];
     int len;
 

-#ifdef HAS_snprintf
-    snprintf(buf, sizeof(buf), format, a1, a2, a3, a4, a5, a6, a7, a8,
-            a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20);
-#else
+    buf[sizeof(buf) - 1] = 0;
+#ifdef NO_snprintf
+#  ifdef HAS_sprintf_void

     sprintf(buf, format, a1, a2, a3, a4, a5, a6, a7, a8,
     sprintf(buf, format, a1, a2, a3, a4, a5, a6, a7, a8,

-           a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20);
+            a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20);
+    for (len = 0; len < sizeof(buf); len++)
+        if (buf[len] == 0) break;
+#  else
+    len = sprintf(buf, format, a1, a2, a3, a4, a5, a6, a7, a8,
+                a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20);
+#  endif
+#else
+#  ifdef HAS_snprintf_void
+    snprintf(buf, sizeof(buf), format, a1, a2, a3, a4, a5, a6, a7, a8,
+             a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20);
+    len = strlen(buf);
+#  else
+    len = snprintf(buf, sizeof(buf), format, a1, a2, a3, a4, a5, a6, a7, a8,
+                 a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20);
+#  endif

 #endif
 #endif

-    len = strlen(buf); /* old sprintf doesn't return the nb of bytes written */
-    if (len <= 0) return 0;
-
+    if (len <= 0 || len >= sizeof(buf) || buf[sizeof(buf) - 1] != 0)
+        return 0;

     return gzwrite(file, buf, len);
 }
 #endif
     return gzwrite(file, buf, len);
 }
 #endif


@@ -616,13 +681,9 @@ int ZEXPORTVA gzprintf (file, format, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10,
       Writes c, converted to an unsigned char, into the compressed file.
    gzputc returns the value that was written, or -1 in case of error.
 */
       Writes c, converted to an unsigned char, into the compressed file.
    gzputc returns the value that was written, or -1 in case of error.
 */

-#if defined(__VISAGECPP__) // Visual game can't handle this antiquated interface
-int ZEXPORT gzputc(gzFile file, int c)
-#else

 int ZEXPORT gzputc(file, c)
     gzFile file;
     int c;
 int ZEXPORT gzputc(file, c)
     gzFile file;
     int c;

-#endif

 {
     unsigned char cc = (unsigned char) c; /* required for big endian systems */
 
 {
     unsigned char cc = (unsigned char) c; /* required for big endian systems */
 


@@ -635,13 +696,9 @@ int ZEXPORT gzputc(file, c)
    the terminating null character.
       gzputs returns the number of characters written, or -1 in case of error.
 */
    the terminating null character.
       gzputs returns the number of characters written, or -1 in case of error.
 */

-#if defined(__VISAGECPP__) // Visual game can't handle this antiquated interface
-int ZEXPORT gzputs(gzFile file, const char* s)
-#else

 int ZEXPORT gzputs(file, s)
     gzFile file;
     const char *s;
 int ZEXPORT gzputs(file, s)
     gzFile file;
     const char *s;

-#endif

 {
     return gzwrite(file, (char*)s, (unsigned)strlen(s));
 }
 {
     return gzwrite(file, (char*)s, (unsigned)strlen(s));
 }


@@ -651,13 +708,9 @@ int ZEXPORT gzputs(file, s)
      Flushes all pending output into the compressed file. The parameter
    flush is as in the deflate() function.
 */
      Flushes all pending output into the compressed file. The parameter
    flush is as in the deflate() function.
 */

-#if defined(__VISAGECPP__) // Visual game can't handle this antiquated interface
-local int do_flush (gzFile file, int flush)
-#else

 local int do_flush (file, flush)
     gzFile file;
     int flush;
 local int do_flush (file, flush)
     gzFile file;
     int flush;

-#endif

 {
     uInt len;
     int done = 0;
 {
     uInt len;
     int done = 0;


@@ -679,10 +732,12 @@ local int do_flush (file, flush)
             s->stream.avail_out = Z_BUFSIZE;
         }
         if (done) break;
             s->stream.avail_out = Z_BUFSIZE;
         }
         if (done) break;

+        s->out += s->stream.avail_out;

         s->z_err = deflate(&(s->stream), flush);
         s->z_err = deflate(&(s->stream), flush);

+        s->out -= s->stream.avail_out;

 
 

-       /* Ignore the second of two consecutive flushes: */
-       if (len == 0 && s->z_err == Z_BUF_ERROR) s->z_err = Z_OK;
+        /* Ignore the second of two consecutive flushes: */
+        if (len == 0 && s->z_err == Z_BUF_ERROR) s->z_err = Z_OK;

 
         /* deflate has finished flushing only when it hasn't used up
          * all the available space in the output buffer:
 
         /* deflate has finished flushing only when it hasn't used up
          * all the available space in the output buffer:


@@ -694,13 +749,9 @@ local int do_flush (file, flush)
     return  s->z_err == Z_STREAM_END ? Z_OK : s->z_err;
 }
 
     return  s->z_err == Z_STREAM_END ? Z_OK : s->z_err;
 }
 

-#if defined(__VISAGECPP__) // Visual game can't handle this antiquated interface
-int ZEXPORT gzflush (gzFile file, int flush)
-#else

 int ZEXPORT gzflush (file, flush)
      gzFile file;
      int flush;
 int ZEXPORT gzflush (file, flush)
      gzFile file;
      int flush;

-#endif

 {
     gz_stream *s = (gz_stream*)file;
     int err = do_flush (file, flush);
 {
     gz_stream *s = (gz_stream*)file;
     int err = do_flush (file, flush);


@@ -709,7 +760,7 @@ int ZEXPORT gzflush (file, flush)
     fflush(s->file);
     return  s->z_err == Z_STREAM_END ? Z_OK : s->z_err;
 }
     fflush(s->file);
     return  s->z_err == Z_STREAM_END ? Z_OK : s->z_err;
 }

-#endif /* NO_DEFLATE */
+#endif /* NO_GZCOMPRESS */

 
 /* ===========================================================================
       Sets the starting position for the next gzread or gzwrite on the given
 
 /* ===========================================================================
       Sets the starting position for the next gzread or gzwrite on the given


@@ -719,97 +770,98 @@ int ZEXPORT gzflush (file, flush)
       SEEK_END is not implemented, returns error.
       In this version of the library, gzseek can be extremely slow.
 */
       SEEK_END is not implemented, returns error.
       In this version of the library, gzseek can be extremely slow.
 */

-#if defined(__VISAGECPP__) // Visual game can't handle this antiquated interface
-z_off_t ZEXPORT gzseek (gzFile file, z_off_t offset, int whence)
-#else

 z_off_t ZEXPORT gzseek (file, offset, whence)
     gzFile file;
     z_off_t offset;
     int whence;
 z_off_t ZEXPORT gzseek (file, offset, whence)
     gzFile file;
     z_off_t offset;
     int whence;

-#endif

 {
     gz_stream *s = (gz_stream*)file;
 
     if (s == NULL || whence == SEEK_END ||
 {
     gz_stream *s = (gz_stream*)file;
 
     if (s == NULL || whence == SEEK_END ||

-       s->z_err == Z_ERRNO || s->z_err == Z_DATA_ERROR) {
-       return -1L;
+        s->z_err == Z_ERRNO || s->z_err == Z_DATA_ERROR) {
+        return -1L;

     }
 
     if (s->mode == 'w') {
     }
 
     if (s->mode == 'w') {

-#ifdef NO_DEFLATE
-       return -1L;
+#ifdef NO_GZCOMPRESS
+        return -1L;

 #else
 #else

-       if (whence == SEEK_SET) {
-           offset -= s->stream.total_out;
-       }
-       if (offset < 0) return -1L;
-
-       /* At this point, offset is the number of zero bytes to write. */
-       if (s->inbuf == Z_NULL) {
-           s->inbuf = (Byte*)ALLOC(Z_BUFSIZE); /* for seeking */
-           zmemzero(s->inbuf, Z_BUFSIZE);
-       }
-       while (offset > 0)  {
-           uInt size = Z_BUFSIZE;
-           if (offset < Z_BUFSIZE) size = (uInt)offset;
-
-           size = gzwrite(file, s->inbuf, size);
-           if (size == 0) return -1L;
-
-           offset -= size;
-       }
-       return (z_off_t)s->stream.total_in;
+        if (whence == SEEK_SET) {
+            offset -= s->in;
+        }
+        if (offset < 0) return -1L;
+
+        /* At this point, offset is the number of zero bytes to write. */
+        if (s->inbuf == Z_NULL) {
+            s->inbuf = (Byte*)ALLOC(Z_BUFSIZE); /* for seeking */
+            if (s->inbuf == Z_NULL) return -1L;
+            zmemzero(s->inbuf, Z_BUFSIZE);
+        }
+        while (offset > 0)  {
+            uInt size = Z_BUFSIZE;
+            if (offset < Z_BUFSIZE) size = (uInt)offset;
+
+            size = gzwrite(file, s->inbuf, size);
+            if (size == 0) return -1L;
+
+            offset -= size;
+        }
+        return s->in;

 #endif
     }
     /* Rest of function is for reading only */
 
     /* compute absolute position */
     if (whence == SEEK_CUR) {
 #endif
     }
     /* Rest of function is for reading only */
 
     /* compute absolute position */
     if (whence == SEEK_CUR) {

-       offset += s->stream.total_out;
+        offset += s->out;

     }
     if (offset < 0) return -1L;
 
     if (s->transparent) {
     }
     if (offset < 0) return -1L;
 
     if (s->transparent) {

-       /* map to fseek */
-       s->stream.avail_in = 0;
-       s->stream.next_in = s->inbuf;
+        /* map to fseek */
+        s->back = EOF;
+        s->stream.avail_in = 0;
+        s->stream.next_in = s->inbuf;

         if (fseek(s->file, offset, SEEK_SET) < 0) return -1L;
 
         if (fseek(s->file, offset, SEEK_SET) < 0) return -1L;
 

-       s->stream.total_in = s->stream.total_out = (uLong)offset;
-       return offset;
+        s->in = s->out = offset;
+        return offset;

     }
 
     /* For a negative seek, rewind and use positive seek */
     }
 
     /* For a negative seek, rewind and use positive seek */

-    if ((uLong)offset >= s->stream.total_out) {
-       offset -= s->stream.total_out;
+    if (offset >= s->out) {
+        offset -= s->out;

     } else if (gzrewind(file) < 0) {
     } else if (gzrewind(file) < 0) {

-       return -1L;
+        return -1L;

     }
     /* offset is now the number of bytes to skip. */
 
     if (offset != 0 && s->outbuf == Z_NULL) {
     }
     /* offset is now the number of bytes to skip. */
 
     if (offset != 0 && s->outbuf == Z_NULL) {

-       s->outbuf = (Byte*)ALLOC(Z_BUFSIZE);
+        s->outbuf = (Byte*)ALLOC(Z_BUFSIZE);
+        if (s->outbuf == Z_NULL) return -1L;
+    }
+    if (offset && s->back != EOF) {
+        s->back = EOF;
+        s->out++;
+        offset--;
+        if (s->last) s->z_err = Z_STREAM_END;

     }
     while (offset > 0)  {
     }
     while (offset > 0)  {

-       int size = Z_BUFSIZE;
-       if (offset < Z_BUFSIZE) size = (int)offset;
+        int size = Z_BUFSIZE;
+        if (offset < Z_BUFSIZE) size = (int)offset;

 
 

-       size = gzread(file, s->outbuf, (uInt)size);
-       if (size <= 0) return -1L;
-       offset -= size;
+        size = gzread(file, s->outbuf, (uInt)size);
+        if (size <= 0) return -1L;
+        offset -= size;

     }
     }

-    return (z_off_t)s->stream.total_out;
+    return s->out;

 }
 
 /* ===========================================================================
      Rewinds input file.
 */
 }
 
 /* ===========================================================================
      Rewinds input file.
 */

-#if defined(__VISAGECPP__) // Visual game can't handle this antiquated interface
-int ZEXPORT gzrewind (gzFile file)
-#else

 int ZEXPORT gzrewind (file)
     gzFile file;
 int ZEXPORT gzrewind (file)
     gzFile file;

-#endif

 {
     gz_stream *s = (gz_stream*)file;
 
 {
     gz_stream *s = (gz_stream*)file;
 


@@ -817,16 +869,14 @@ int ZEXPORT gzrewind (file)
 
     s->z_err = Z_OK;
     s->z_eof = 0;
 
     s->z_err = Z_OK;
     s->z_eof = 0;

+    s->back = EOF;

     s->stream.avail_in = 0;
     s->stream.next_in = s->inbuf;
     s->stream.avail_in = 0;
     s->stream.next_in = s->inbuf;

-       
-    if (s->startpos == 0) { /* not a compressed file */
-       rewind(s->file);
-       return 0;
-    }
-
-    (void) inflateReset(&s->stream);
-    return fseek(s->file, s->startpos, SEEK_SET);
+    s->crc = crc32(0L, Z_NULL, 0);
+    if (!s->transparent) (void)inflateReset(&s->stream);
+    s->in = 0;
+    s->out = 0;
+    return fseek(s->file, s->start, SEEK_SET);

 }
 
 /* ===========================================================================
 }
 
 /* ===========================================================================


@@ -834,12 +884,8 @@ int ZEXPORT gzrewind (file)
    given compressed file. This position represents a number of bytes in the
    uncompressed data stream.
 */
    given compressed file. This position represents a number of bytes in the
    uncompressed data stream.
 */

-#if defined(__VISAGECPP__) // Visual game can't handle this antiquated interface
-z_off_t ZEXPORT gztell (gzFile file)
-#else

 z_off_t ZEXPORT gztell (file)
     gzFile file;
 z_off_t ZEXPORT gztell (file)
     gzFile file;

-#endif

 {
     return gzseek(file, 0L, SEEK_CUR);
 }
 {
     return gzseek(file, 0L, SEEK_CUR);
 }


@@ -848,28 +894,38 @@ z_off_t ZEXPORT gztell (file)
      Returns 1 when EOF has previously been detected reading the given
    input stream, otherwise zero.
 */
      Returns 1 when EOF has previously been detected reading the given
    input stream, otherwise zero.
 */

-#if defined(__VISAGECPP__) // Visual game can't handle this antiquated interface
-int ZEXPORT gzeof (gzFile file)
-#else

 int ZEXPORT gzeof (file)
     gzFile file;
 int ZEXPORT gzeof (file)
     gzFile file;

-#endif

 {
     gz_stream *s = (gz_stream*)file;
 
 {
     gz_stream *s = (gz_stream*)file;
 

-    return (s == NULL || s->mode != 'r') ? 0 : s->z_eof;
+    /* With concatenated compressed files that can have embedded
+     * crc trailers, z_eof is no longer the only/best indicator of EOF
+     * on a gz_stream. Handle end-of-stream error explicitly here.
+     */
+    if (s == NULL || s->mode != 'r') return 0;
+    if (s->z_eof) return 1;
+    return s->z_err == Z_STREAM_END;
+}
+
+/* ===========================================================================
+     Returns 1 if reading and doing so transparently, otherwise zero.
+*/
+int ZEXPORT gzdirect (file)
+    gzFile file;
+{
+    gz_stream *s = (gz_stream*)file;
+
+    if (s == NULL || s->mode != 'r') return 0;
+    return s->transparent;

 }
 
 /* ===========================================================================
    Outputs a long in LSB order to the given file
 */
 }
 
 /* ===========================================================================
    Outputs a long in LSB order to the given file
 */

-#if defined(__VISAGECPP__) // Visual game can't handle this antiquated interface
-local void putLong (FILE* file, uLong x)
-#else

 local void putLong (file, x)
     FILE *file;
     uLong x;
 local void putLong (file, x)
     FILE *file;
     uLong x;

-#endif

 {
     int n;
     for (n = 0; n < 4; n++) {
 {
     int n;
     for (n = 0; n < 4; n++) {


@@ -879,14 +935,11 @@ local void putLong (file, x)
 }
 
 /* ===========================================================================
 }
 
 /* ===========================================================================

-   Reads a long in LSB order from the given gz_stream. Sets
+   Reads a long in LSB order from the given gz_stream. Sets z_err in case
+   of error.

 */
 */

-#if defined(__VISAGECPP__) // Visual game can't handle this antiquated interface
-local uLong getLong (gz_stream* s)
-#else

 local uLong getLong (s)
     gz_stream *s;
 local uLong getLong (s)
     gz_stream *s;

-#endif

 {
     uLong x = (uLong)get_byte(s);
     int c;
 {
     uLong x = (uLong)get_byte(s);
     int c;


@@ -903,46 +956,43 @@ local uLong getLong (s)
      Flushes all pending output if necessary, closes the compressed file
    and deallocates all the (de)compression state.
 */
      Flushes all pending output if necessary, closes the compressed file
    and deallocates all the (de)compression state.
 */

-#if defined(__VISAGECPP__) // Visual game can't handle this antiquated interface
-int ZEXPORT gzclose (gzFile file)
-#else

 int ZEXPORT gzclose (file)
     gzFile file;
 int ZEXPORT gzclose (file)
     gzFile file;

-#endif

 {
 {

-    int err;

     gz_stream *s = (gz_stream*)file;
 
     if (s == NULL) return Z_STREAM_ERROR;
 
     if (s->mode == 'w') {
     gz_stream *s = (gz_stream*)file;
 
     if (s == NULL) return Z_STREAM_ERROR;
 
     if (s->mode == 'w') {

-#ifdef NO_DEFLATE
-       return Z_STREAM_ERROR;
+#ifdef NO_GZCOMPRESS
+        return Z_STREAM_ERROR;

 #else
 #else

-        err = do_flush (file, Z_FINISH);
-        if (err != Z_OK) return destroy((gz_stream*)file);
+        if (do_flush (file, Z_FINISH) != Z_OK)
+            return destroy((gz_stream*)file);

 
         putLong (s->file, s->crc);
 
         putLong (s->file, s->crc);

-        putLong (s->file, s->stream.total_in);
+        putLong (s->file, (uLong)(s->in & 0xffffffff));

 #endif
     }
     return destroy((gz_stream*)file);
 }
 
 #endif
     }
     return destroy((gz_stream*)file);
 }
 

+#ifdef STDC
+#  define zstrerror(errnum) strerror(errnum)
+#else
+#  define zstrerror(errnum) ""
+#endif
+

 /* ===========================================================================
 /* ===========================================================================

-     Returns the error message for the last error which occured on the
+     Returns the error message for the last error which occurred on the

    given compressed file. errnum is set to zlib error number. If an
    given compressed file. errnum is set to zlib error number. If an

-   error occured in the file system and not in the compression library,
+   error occurred in the file system and not in the compression library,

    errnum is set to Z_ERRNO and the application may consult errno
    to get the exact error code.
 */
    errnum is set to Z_ERRNO and the application may consult errno
    to get the exact error code.
 */

-#if defined(__VISAGECPP__) // Visual game can't handle this antiquated interface
-const char* ZEXPORT gzerror (gzFile file, int* errnum)
-#else
-const char*  ZEXPORT gzerror (file, errnum)
+const char * ZEXPORT gzerror (file, errnum)

     gzFile file;
     int *errnum;
     gzFile file;
     int *errnum;

-#endif

 {
     char *m;
     gz_stream *s = (gz_stream*)file;
 {
     char *m;
     gz_stream *s = (gz_stream*)file;


@@ -954,14 +1004,29 @@ const char*  ZEXPORT gzerror (file, errnum)
     *errnum = s->z_err;
     if (*errnum == Z_OK) return (const char*)"";
 
     *errnum = s->z_err;
     if (*errnum == Z_OK) return (const char*)"";
 

-    m =  (char*)(*errnum == Z_ERRNO ? zstrerror(errno) : s->stream.msg);
+    m = (char*)(*errnum == Z_ERRNO ? zstrerror(errno) : s->stream.msg);

 
     if (m == NULL || *m == '\0') m = (char*)ERR_MSG(s->z_err);
 
     TRYFREE(s->msg);
     s->msg = (char*)ALLOC(strlen(s->path) + strlen(m) + 3);
 
     if (m == NULL || *m == '\0') m = (char*)ERR_MSG(s->z_err);
 
     TRYFREE(s->msg);
     s->msg = (char*)ALLOC(strlen(s->path) + strlen(m) + 3);

+    if (s->msg == Z_NULL) return (const char*)ERR_MSG(Z_MEM_ERROR);

     strcpy(s->msg, s->path);
     strcat(s->msg, ": ");
     strcat(s->msg, m);
     return (const char*)s->msg;
 }
     strcpy(s->msg, s->path);
     strcat(s->msg, ": ");
     strcat(s->msg, m);
     return (const char*)s->msg;
 }

+
+/* ===========================================================================
+     Clear the error and end-of-file flags, and do the same for the real file.
+*/
+void ZEXPORT gzclearerr (file)
+    gzFile file;
+{
+    gz_stream *s = (gz_stream*)file;
+
+    if (s == NULL) return;
+    if (s->z_err != Z_STREAM_END) s->z_err = Z_OK;
+    s->z_eof = 0;
+    clearerr(s->file);
+}