Convert remaining K&R function declarations to ANSI-C declarations.

12 files changed, 79 insertions, 241 deletions

diff --git a/adler32.c b/adler32.c
index 49b5441..bbd03ef 100644
--- a/adler32.c
+++ b/adler32.c
@@ -60,10 +60,7 @@ static uint32_t adler32_combine_ (uint32_t adler1, uint32_t adler2, z_off64_t le
 #endif
 
 /* ========================================================================= */
-uint32_t ZEXPORT adler32(adler, buf, len)
-    uint32_t adler;
-    const Byte *buf;
-    uInt len;
+uint32_t ZEXPORT adler32(uint32_t adler, const Byte *buf, uInt len)
 {
     uint32_t sum2;
     unsigned n;
@@ -173,18 +170,12 @@ static uint32_t adler32_combine_(uint32_t adler1, uint32_t adler2, z_off64_t len
 }
 
 /* ========================================================================= */
-uint32_t ZEXPORT adler32_combine(adler1, adler2, len2)
-    uint32_t adler1;
-    uint32_t adler2;
-    z_off_t len2;
+uint32_t ZEXPORT adler32_combine(uint32_t adler1, uint32_t adler2, z_off_t len2)
 {
     return adler32_combine_(adler1, adler2, len2);
 }
 
-uint32_t ZEXPORT adler32_combine64(adler1, adler2, len2)
-    uint32_t adler1;
-    uint32_t adler2;
-    z_off64_t len2;
+uint32_t ZEXPORT adler32_combine64(uint32_t adler1, uint32_t adler2, z_off64_t len2)
 {
     return adler32_combine_(adler1, adler2, len2);
 }
diff --git a/compress.c b/compress.c
index ba29677..c703f24 100644
--- a/compress.c
+++ b/compress.c
@@ -19,12 +19,8 @@
    memory, Z_BUF_ERROR if there was not enough room in the output buffer,
    Z_STREAM_ERROR if the level parameter is invalid.
 */
-int ZEXPORT compress2 (dest, destLen, source, sourceLen, level)
-    Byte *dest;
-    uLong *destLen;
-    const Byte *source;
-    uLong sourceLen;
-    int level;
+int ZEXPORT compress2 (Byte *dest, uLong *destLen, const Byte *source,
+                        uLong sourceLen, int level)
 {
     z_stream stream;
     int err;
@@ -55,11 +51,7 @@ int ZEXPORT compress2 (dest, destLen, source, sourceLen, level)
 
 /* ===========================================================================
  */
-int ZEXPORT compress (dest, destLen, source, sourceLen)
-    Byte *dest;
-    uLong *destLen;
-    const Byte *source;
-    uLong sourceLen;
+int ZEXPORT compress (Byte *dest, uLong *destLen, const Byte *source, uLong sourceLen)
 {
     return compress2(dest, destLen, source, sourceLen, Z_DEFAULT_COMPRESSION);
 }
@@ -68,8 +60,7 @@ int ZEXPORT compress (dest, destLen, source, sourceLen)
      If the default memLevel or windowBits for deflateInit() is changed, then
    this function needs to be updated.
  */
-uLong ZEXPORT compressBound (sourceLen)
-    uLong sourceLen;
+uLong ZEXPORT compressBound (uLong sourceLen)
 {
     return sourceLen + (sourceLen >> 12) + (sourceLen >> 14) +
            (sourceLen >> 25) + 13;
diff --git a/crc32.c b/crc32.c
index 03ee157..775442b 100644
--- a/crc32.c
+++ b/crc32.c
@@ -197,10 +197,7 @@ const z_crc_t * ZEXPORT get_crc_table()
 #define DO4 DO1; DO1; DO1; DO1
 
 /* ========================================================================= */
-uint32_t ZEXPORT crc32(crc, buf, len)
-    uint32_t crc;
-    const unsigned char *buf;
-    uInt len;
+uint32_t ZEXPORT crc32(uint32_t crc, const unsigned char *buf, uInt len)
 {
     if (buf == Z_NULL) return 0;
 
@@ -406,18 +403,12 @@ static uint32_t crc32_combine_(uint32_t crc1, uint32_t crc2, z_off64_t len2)
 }
 
 /* ========================================================================= */
-uint32_t ZEXPORT crc32_combine(crc1, crc2, len2)
-    uint32_t crc1;
-    uint32_t crc2;
-    z_off_t len2;
+uint32_t ZEXPORT crc32_combine(uint32_t crc1, uint32_t crc2, z_off_t len2)
 {
     return crc32_combine_(crc1, crc2, len2);
 }
 
-uint32_t ZEXPORT crc32_combine64(crc1, crc2, len2)
-    uint32_t crc1;
-    uint32_t crc2;
-    z_off64_t len2;
+uint32_t ZEXPORT crc32_combine64(uint32_t crc1, uint32_t crc2, z_off64_t len2)
 {
     return crc32_combine_(crc1, crc2, len2);
 }
diff --git a/deflate.c b/deflate.c
index d871cc8..738ff59 100644
--- a/deflate.c
+++ b/deflate.c
@@ -233,11 +233,7 @@ bulk_insert_str(deflate_state *s, Pos startpos, uInt count) {
     memset((Byte *)s->head, 0, (unsigned)(s->hash_size-1)*sizeof(*s->head));
 
 /* ========================================================================= */
-int ZEXPORT deflateInit_(strm, level, version, stream_size)
-    z_stream *strm;
-    int level;
-    const char *version;
-    int stream_size;
+int ZEXPORT deflateInit_(z_stream *strm, int level, const char *version, int stream_size)
 {
     return deflateInit2_(strm, level, Z_DEFLATED, MAX_WBITS, DEF_MEM_LEVEL,
                          Z_DEFAULT_STRATEGY, version, stream_size);
@@ -245,16 +241,8 @@ int ZEXPORT deflateInit_(strm, level, version, stream_size)
 }
 
 /* ========================================================================= */
-int ZEXPORT deflateInit2_(strm, level, method, windowBits, memLevel, strategy,
-                  version, stream_size)
-    z_stream *strm;
-    int  level;
-    int  method;
-    int  windowBits;
-    int  memLevel;
-    int  strategy;
-    const char *version;
-    int stream_size;
+int ZEXPORT deflateInit2_(z_stream *strm, int level, int method, int windowBits,
+                           int memLevel, int strategy, const char *version, int stream_size)
 {
     unsigned window_padding = 0;
     deflate_state *s;
@@ -364,10 +352,7 @@ int ZEXPORT deflateInit2_(strm, level, method, windowBits, memLevel, strategy,
 }
 
 /* ========================================================================= */
-int ZEXPORT deflateSetDictionary (strm, dictionary, dictLength)
-    z_stream *strm;
-    const Byte *dictionary;
-    uInt  dictLength;
+int ZEXPORT deflateSetDictionary (z_stream *strm, const Byte *dictionary, uInt  dictLength)
 {
     deflate_state *s;
     uInt str, n;
@@ -431,8 +416,7 @@ int ZEXPORT deflateSetDictionary (strm, dictionary, dictLength)
 }
 
 /* ========================================================================= */
-int ZEXPORT deflateResetKeep (strm)
-    z_stream *strm;
+int ZEXPORT deflateResetKeep (z_stream *strm)
 {
     deflate_state *s;
 
@@ -466,8 +450,7 @@ int ZEXPORT deflateResetKeep (strm)
 }
 
 /* ========================================================================= */
-int ZEXPORT deflateReset (strm)
-    z_stream *strm;
+int ZEXPORT deflateReset (z_stream *strm)
 {
     int ret;
 
@@ -478,9 +461,7 @@ int ZEXPORT deflateReset (strm)
 }
 
 /* ========================================================================= */
-int ZEXPORT deflateSetHeader (strm, head)
-    z_stream *strm;
-    gz_headerp head;
+int ZEXPORT deflateSetHeader (z_stream *strm, gz_headerp head)
 {
     if (strm == Z_NULL || strm->state == Z_NULL) return Z_STREAM_ERROR;
     if (strm->state->wrap != 2) return Z_STREAM_ERROR;
@@ -489,10 +470,7 @@ int ZEXPORT deflateSetHeader (strm, head)
 }
 
 /* ========================================================================= */
-int ZEXPORT deflatePending (strm, pending, bits)
-    unsigned *pending;
-    int *bits;
-    z_stream *strm;
+int ZEXPORT deflatePending (z_stream *strm, unsigned *pending, int *bits)
 {
     if (strm == Z_NULL || strm->state == Z_NULL) return Z_STREAM_ERROR;
     if (pending != Z_NULL)
@@ -503,10 +481,7 @@ int ZEXPORT deflatePending (strm, pending, bits)
 }
 
 /* ========================================================================= */
-int ZEXPORT deflatePrime (strm, bits, value)
-    z_stream *strm;
-    int bits;
-    int value;
+int ZEXPORT deflatePrime (z_stream *strm, int bits, int value)
 {
     deflate_state *s;
     int put;
@@ -529,10 +504,7 @@ int ZEXPORT deflatePrime (strm, bits, value)
 }
 
 /* ========================================================================= */
-int ZEXPORT deflateParams(strm, level, strategy)
-    z_stream *strm;
-    int level;
-    int strategy;
+int ZEXPORT deflateParams(z_stream *strm, int level, int strategy)
 {
     deflate_state *s;
     compress_func func;
@@ -566,12 +538,8 @@ int ZEXPORT deflateParams(strm, level, strategy)
 }
 
 /* ========================================================================= */
-int ZEXPORT deflateTune(strm, good_length, max_lazy, nice_length, max_chain)
-    z_stream *strm;
-    int good_length;
-    int max_lazy;
-    int nice_length;
-    int max_chain;
+int ZEXPORT deflateTune(z_stream *strm, int good_length, int max_lazy,
+                         int nice_length, int max_chain)
 {
     deflate_state *s;
 
@@ -601,9 +569,7 @@ int ZEXPORT deflateTune(strm, good_length, max_lazy, nice_length, max_chain)
  * upper bound of about 14% expansion does not seem onerous for output buffer
  * allocation.
  */
-uLong ZEXPORT deflateBound(strm, sourceLen)
-    z_stream *strm;
-    uLong sourceLen;
+uLong ZEXPORT deflateBound(z_stream *strm, uLong sourceLen)
 {
     deflate_state *s;
     uLong complen, wraplen;
@@ -698,9 +664,7 @@ ZLIB_INTERNAL void flush_pending(strm)
 }
 
 /* ========================================================================= */
-int ZEXPORT deflate (strm, flush)
-    z_stream *strm;
-    int flush;
+int ZEXPORT deflate (z_stream *strm, int flush)
 {
     int old_flush; /* value of flush param for previous deflate call */
     deflate_state *s;
@@ -1020,8 +984,7 @@ int ZEXPORT deflate (strm, flush)
 }
 
 /* ========================================================================= */
-int ZEXPORT deflateEnd (strm)
-    z_stream *strm;
+int ZEXPORT deflateEnd (z_stream *strm)
 {
     int status;
 
@@ -1053,9 +1016,7 @@ int ZEXPORT deflateEnd (strm)
 /* =========================================================================
  * Copy the source state to the destination state.
  */
-int ZEXPORT deflateCopy (dest, source)
-    z_stream *dest;
-    z_stream *source;
+int ZEXPORT deflateCopy (z_stream *dest, z_stream *source)
 {
     deflate_state *ds;
     deflate_state *ss;
diff --git a/gzclose.c b/gzclose.c
index caeb99a..023d2a6 100644
--- a/gzclose.c
+++ b/gzclose.c
@@ -8,8 +8,7 @@
 /* gzclose() is in a separate file so that it is linked in only if it is used.
    That way the other gzclose functions can be used instead to avoid linking in
    unneeded compression or decompression routines. */
-int ZEXPORT gzclose(file)
-    gzFile file;
+int ZEXPORT gzclose(gzFile file)
 {
 #ifndef NO_GZCOMPRESS
     gz_statep state;
diff --git a/gzlib.c b/gzlib.c
index bef3194..6ad5633 100644
--- a/gzlib.c
+++ b/gzlib.c
@@ -207,25 +207,19 @@ local gzFile gz_open(const void *path, int fd, const char *mode)
 }
 
 /* -- see zlib.h -- */
-gzFile ZEXPORT gzopen(path, mode)
-    const char *path;
-    const char *mode;
+gzFile ZEXPORT gzopen(const char *path, const char *mode)
 {
     return gz_open(path, -1, mode);
 }
 
 /* -- see zlib.h -- */
-gzFile ZEXPORT gzopen64(path, mode)
-    const char *path;
-    const char *mode;
+gzFile ZEXPORT gzopen64(const char *path, const char *mode)
 {
     return gz_open(path, -1, mode);
 }
 
 /* -- see zlib.h -- */
-gzFile ZEXPORT gzdopen(fd, mode)
-    int fd;
-    const char *mode;
+gzFile ZEXPORT gzdopen(int fd, const char *mode)
 {
     char *path;         /* identifier for error messages */
     gzFile gz;
@@ -240,18 +234,14 @@ gzFile ZEXPORT gzdopen(fd, mode)
 
 /* -- see zlib.h -- */
 #if defined(_WIN32) || defined(__CYGWIN__)
-gzFile ZEXPORT gzopen_w(path, mode)
-    const wchar_t *path;
-    const char *mode;
+gzFile ZEXPORT gzopen_w(const wchar_t *path, const char *mode)
 {
     return gz_open(path, -2, mode);
 }
 #endif
 
 /* -- see zlib.h -- */
-int ZEXPORT gzbuffer(file, size)
-    gzFile file;
-    unsigned size;
+int ZEXPORT gzbuffer(gzFile file, unsigned size)
 {
     gz_statep state;
 
@@ -274,8 +264,7 @@ int ZEXPORT gzbuffer(file, size)
 }
 
 /* -- see zlib.h -- */
-int ZEXPORT gzrewind(file)
-    gzFile file;
+int ZEXPORT gzrewind(gzFile file)
 {
     gz_statep state;
 
@@ -297,10 +286,7 @@ int ZEXPORT gzrewind(file)
 }
 
 /* -- see zlib.h -- */
-z_off64_t ZEXPORT gzseek64(file, offset, whence)
-    gzFile file;
-    z_off64_t offset;
-    int whence;
+z_off64_t ZEXPORT gzseek64(gzFile file, z_off64_t offset, int whence)
 {
     unsigned n;
     z_off64_t ret;
@@ -374,10 +360,7 @@ z_off64_t ZEXPORT gzseek64(file, offset, whence)
 }
 
 /* -- see zlib.h -- */
-z_off_t ZEXPORT gzseek(file, offset, whence)
-    gzFile file;
-    z_off_t offset;
-    int whence;
+z_off_t ZEXPORT gzseek(gzFile file, z_off_t offset, int whence)
 {
     z_off64_t ret;
 
@@ -386,8 +369,7 @@ z_off_t ZEXPORT gzseek(file, offset, whence)
 }
 
 /* -- see zlib.h -- */
-z_off64_t ZEXPORT gztell64(file)
-    gzFile file;
+z_off64_t ZEXPORT gztell64(gzFile file)
 {
     gz_statep state;
 
@@ -403,8 +385,7 @@ z_off64_t ZEXPORT gztell64(file)
 }
 
 /* -- see zlib.h -- */
-z_off_t ZEXPORT gztell(file)
-    gzFile file;
+z_off_t ZEXPORT gztell(gzFile file)
 {
     z_off64_t ret;
 
@@ -413,8 +394,7 @@ z_off_t ZEXPORT gztell(file)
 }
 
 /* -- see zlib.h -- */
-z_off64_t ZEXPORT gzoffset64(file)
-    gzFile file;
+z_off64_t ZEXPORT gzoffset64(gzFile file)
 {
     z_off64_t offset;
     gz_statep state;
@@ -436,8 +416,7 @@ z_off64_t ZEXPORT gzoffset64(file)
 }
 
 /* -- see zlib.h -- */
-z_off_t ZEXPORT gzoffset(file)
-    gzFile file;
+z_off_t ZEXPORT gzoffset(gzFile file)
 {
     z_off64_t ret;
 
@@ -446,8 +425,7 @@ z_off_t ZEXPORT gzoffset(file)
 }
 
 /* -- see zlib.h -- */
-int ZEXPORT gzeof(file)
-    gzFile file;
+int ZEXPORT gzeof(gzFile file)
 {
     gz_statep state;
 
@@ -463,9 +441,7 @@ int ZEXPORT gzeof(file)
 }
 
 /* -- see zlib.h -- */
-const char * ZEXPORT gzerror(file, errnum)
-    gzFile file;
-    int *errnum;
+const char * ZEXPORT gzerror(gzFile file, int *errnum)
 {
     gz_statep state;
 
@@ -484,8 +460,7 @@ const char * ZEXPORT gzerror(file, errnum)
 }
 
 /* -- see zlib.h -- */
-void ZEXPORT gzclearerr(file)
-    gzFile file;
+void ZEXPORT gzclearerr(gzFile file)
 {
     gz_statep state;
 
diff --git a/gzread.c b/gzread.c
index 7448b84..f92efdc 100644
--- a/gzread.c
+++ b/gzread.c
@@ -275,10 +275,7 @@ local int gz_skip(gz_statep state, z_off64_t len)
 }
 
 /* -- see zlib.h -- */
-int ZEXPORT gzread(file, buf, len)
-    gzFile file;
-    void *buf;
-    unsigned len;
+int ZEXPORT gzread(gzFile file, void *buf, unsigned len)
 {
     unsigned got, n;
     gz_statep state;
@@ -374,8 +371,7 @@ int ZEXPORT gzread(file, buf, len)
 #else
 #  undef gzgetc
 #endif
-int ZEXPORT gzgetc(file)
-    gzFile file;
+int ZEXPORT gzgetc(gzFile file)
 {
     int ret;
     unsigned char buf[1];
@@ -403,16 +399,13 @@ int ZEXPORT gzgetc(file)
     return ret < 1 ? -1 : buf[0];
 }
 
-int ZEXPORT gzgetc_(file)
-gzFile file;
+int ZEXPORT gzgetc_(gzFile file)
 {
     return gzgetc(file);
 }
 
 /* -- see zlib.h -- */
-int ZEXPORT gzungetc(c, file)
-    int c;
-    gzFile file;
+int ZEXPORT gzungetc(int c, gzFile file)
 {
     gz_statep state;
 
@@ -470,10 +463,7 @@ int ZEXPORT gzungetc(c, file)
 }
 
 /* -- see zlib.h -- */
-char * ZEXPORT gzgets(file, buf, len)
-    gzFile file;
-    char *buf;
-    int len;
+char * ZEXPORT gzgets(gzFile file, char *buf, int len)
 {
     unsigned left, n;
     char *str;
@@ -534,8 +524,7 @@ char * ZEXPORT gzgets(file, buf, len)
 }
 
 /* -- see zlib.h -- */
-int ZEXPORT gzdirect(file)
-    gzFile file;
+int ZEXPORT gzdirect(gzFile file)
 {
     gz_statep state;
 
@@ -554,8 +543,7 @@ int ZEXPORT gzdirect(file)
 }
 
 /* -- see zlib.h -- */
-int ZEXPORT gzclose_r(file)
-    gzFile file;
+int ZEXPORT gzclose_r(gzFile file)
 {
     int ret, err;
     gz_statep state;
diff --git a/gzwrite.c b/gzwrite.c
index 955d5a5..9ee0de8 100644
--- a/gzwrite.c
+++ b/gzwrite.c
@@ -157,10 +157,7 @@ local int gz_zero(gz_statep state, z_off64_t len)
 }
 
 /* -- see zlib.h -- */
-int ZEXPORT gzwrite(file, buf, len)
-    gzFile file;
-    void const *buf;
-    unsigned len;
+int ZEXPORT gzwrite(gzFile file, void const *buf, unsigned len)
 {
     unsigned put = len;
     gz_statep state;
@@ -237,9 +234,7 @@ int ZEXPORT gzwrite(file, buf, len)
 }
 
 /* -- see zlib.h -- */
-int ZEXPORT gzputc(file, c)
-    gzFile file;
-    int c;
+int ZEXPORT gzputc(gzFile file, int c)
 {
     unsigned have;
     unsigned char buf[1];
@@ -285,9 +280,7 @@ int ZEXPORT gzputc(file, c)
 }
 
 /* -- see zlib.h -- */
-int ZEXPORT gzputs(file, str)
-    gzFile file;
-    const char *str;
+int ZEXPORT gzputs(gzFile file, const char *str)
 {
     int ret;
     unsigned len;
@@ -360,9 +353,7 @@ int ZEXPORTVA gzprintf(gzFile file, const char *format, ...)
 }
 
 /* -- see zlib.h -- */
-int ZEXPORT gzflush(file, flush)
-    gzFile file;
-    int flush;
+int ZEXPORT gzflush(gzFile file, int flush)
 {
     gz_statep state;
 
@@ -392,10 +383,7 @@ int ZEXPORT gzflush(file, flush)
 }
 
 /* -- see zlib.h -- */
-int ZEXPORT gzsetparams(file, level, strategy)
-    gzFile file;
-    int level;
-    int strategy;
+int ZEXPORT gzsetparams(gzFile file, int level, int strategy)
 {
     gz_statep state;
     z_stream *strm;
@@ -434,8 +422,7 @@ int ZEXPORT gzsetparams(file, level, strategy)
 }
 
 /* -- see zlib.h -- */
-int ZEXPORT gzclose_w(file)
-    gzFile file;
+int ZEXPORT gzclose_w(gzFile file)
 {
     int ret = Z_OK;
     gz_statep state;
diff --git a/infback.c b/infback.c
index c8eee5e..137c41f 100644
--- a/infback.c
+++ b/infback.c
@@ -25,12 +25,8 @@ local void fixedtables (struct inflate_state *state);
    windowBits is in the range 8..15, and window is a user-supplied
    window and output buffer that is 2**windowBits bytes.
  */
-int ZEXPORT inflateBackInit_(strm, windowBits, window, version, stream_size)
-z_stream *strm;
-int windowBits;
-unsigned char *window;
-const char *version;
-int stream_size;
+int ZEXPORT inflateBackInit_(z_stream *strm, int windowBits, unsigned char *window,
+                              const char *version, int stream_size)
 {
     struct inflate_state *state;
 
@@ -238,12 +234,8 @@ local void fixedtables(struct inflate_state *state)
    inflateBack() can also return Z_STREAM_ERROR if the input parameters
    are not correct, i.e. strm is Z_NULL or the state was not initialized.
  */
-int ZEXPORT inflateBack(strm, in, in_desc, out, out_desc)
-z_stream *strm;
-in_func in;
-void *in_desc;
-out_func out;
-void *out_desc;
+int ZEXPORT inflateBack(z_stream *strm, in_func in, void *in_desc,
+                         out_func out, void *out_desc)
 {
     struct inflate_state *state;
     z_const unsigned char *next;    /* next input */
@@ -619,8 +611,7 @@ void *out_desc;
     return ret;
 }
 
-int ZEXPORT inflateBackEnd(strm)
-z_stream *strm;
+int ZEXPORT inflateBackEnd(z_stream *strm)
 {
     if (strm == Z_NULL || strm->state == Z_NULL || strm->zfree == (free_func)0)
         return Z_STREAM_ERROR;
diff --git a/inflate.c b/inflate.c
index 2cf1d7e..dcb3c97 100644
--- a/inflate.c
+++ b/inflate.c
@@ -99,8 +99,7 @@ local int updatewindow (z_stream *strm, const unsigned char *end, unsigned copy)
 #endif
 local unsigned syncsearch (unsigned *have, const unsigned char *buf, unsigned len);
 
-int ZEXPORT inflateResetKeep(strm)
-z_stream *strm;
+int ZEXPORT inflateResetKeep(z_stream *strm)
 {
     struct inflate_state *state;
 
@@ -124,8 +123,7 @@ z_stream *strm;
     return Z_OK;
 }
 
-int ZEXPORT inflateReset(strm)
-z_stream *strm;
+int ZEXPORT inflateReset(z_stream *strm)
 {
     struct inflate_state *state;
 
@@ -137,9 +135,7 @@ z_stream *strm;
     return inflateResetKeep(strm);
 }
 
-int ZEXPORT inflateReset2(strm, windowBits)
-z_stream *strm;
-int windowBits;
+int ZEXPORT inflateReset2(z_stream *strm, int windowBits)
 {
     int wrap;
     struct inflate_state *state;
@@ -175,11 +171,8 @@ int windowBits;
     return inflateReset(strm);
 }
 
-int ZEXPORT inflateInit2_(strm, windowBits, version, stream_size)
-z_stream *strm;
-int windowBits;
-const char *version;
-int stream_size;
+int ZEXPORT inflateInit2_(z_stream *strm, int windowBits, const char *version,
+                           int stream_size)
 {
     int ret;
     struct inflate_state *state;
@@ -209,18 +202,12 @@ int stream_size;
     return ret;
 }
 
-int ZEXPORT inflateInit_(strm, version, stream_size)
-z_stream *strm;
-const char *version;
-int stream_size;
+int ZEXPORT inflateInit_(z_stream *strm, const char *version, int stream_size)
 {
     return inflateInit2_(strm, DEF_WBITS, version, stream_size);
 }
 
-int ZEXPORT inflatePrime(strm, bits, value)
-z_stream *strm;
-int bits;
-int value;
+int ZEXPORT inflatePrime(z_stream *strm, int bits, int value)
 {
     struct inflate_state *state;
 
@@ -588,9 +575,7 @@ local int updatewindow(z_stream *strm, const Byte *end, unsigned copy)
    will return Z_BUF_ERROR if it has not reached the end of the stream.
  */
 
-int ZEXPORT inflate(strm, flush)
-z_stream *strm;
-int flush;
+int ZEXPORT inflate(z_stream *strm, int flush)
 {
     struct inflate_state *state;
     z_const unsigned char *next;    /* next input */
@@ -1237,8 +1222,7 @@ int flush;
     return ret;
 }
 
-int ZEXPORT inflateEnd(strm)
-z_stream *strm;
+int ZEXPORT inflateEnd(z_stream *strm)
 {
     struct inflate_state *state;
     if (strm == Z_NULL || strm->state == Z_NULL || strm->zfree == (free_func)0)
@@ -1251,10 +1235,7 @@ z_stream *strm;
     return Z_OK;
 }
 
-int ZEXPORT inflateGetDictionary(strm, dictionary, dictLength)
-z_stream *strm;
-Byte *dictionary;
-uInt *dictLength;
+int ZEXPORT inflateGetDictionary(z_stream *strm, Byte *dictionary, uInt *dictLength)
 {
     struct inflate_state *state;
 
@@ -1274,10 +1255,7 @@ uInt *dictLength;
     return Z_OK;
 }
 
-int ZEXPORT inflateSetDictionary(strm, dictionary, dictLength)
-z_stream *strm;
-const Byte *dictionary;
-uInt dictLength;
+int ZEXPORT inflateSetDictionary(z_stream *strm, const Byte *dictionary, uInt dictLength)
 {
     struct inflate_state *state;
     unsigned long dictid;
@@ -1309,9 +1287,7 @@ uInt dictLength;
     return Z_OK;
 }
 
-int ZEXPORT inflateGetHeader(strm, head)
-z_stream *strm;
-gz_headerp head;
+int ZEXPORT inflateGetHeader(z_stream *strm, gz_headerp head)
 {
     struct inflate_state *state;
 
@@ -1357,8 +1333,7 @@ local unsigned syncsearch(unsigned *have, const unsigned char *buf, unsigned len
     return next;
 }
 
-int ZEXPORT inflateSync(strm)
-z_stream *strm;
+int ZEXPORT inflateSync(z_stream *strm)
 {
     unsigned len;               /* number of bytes to look at or looked at */
     unsigned long in, out;      /* temporary to save total_in and total_out */
@@ -1408,8 +1383,7 @@ z_stream *strm;
    block. When decompressing, PPP checks that at the end of input packet,
    inflate is waiting for these length bytes.
  */
-int ZEXPORT inflateSyncPoint(strm)
-z_stream *strm;
+int ZEXPORT inflateSyncPoint(z_stream *strm)
 {
     struct inflate_state *state;
 
@@ -1418,9 +1392,7 @@ z_stream *strm;
     return state->mode == STORED && state->bits == 0;
 }
 
-int ZEXPORT inflateCopy(dest, source)
-z_stream *dest;
-z_stream *source;
+int ZEXPORT inflateCopy(z_stream *dest, z_stream *source)
 {
     struct inflate_state *state;
     struct inflate_state *copy;
@@ -1465,9 +1437,7 @@ z_stream *source;
     return Z_OK;
 }
 
-int ZEXPORT inflateUndermine(strm, subvert)
-z_stream *strm;
-int subvert;
+int ZEXPORT inflateUndermine(z_stream *strm, int subvert)
 {
     struct inflate_state *state;
 
@@ -1482,8 +1452,7 @@ int subvert;
 #endif
 }
 
-long ZEXPORT inflateMark(strm)
-z_stream *strm;
+long ZEXPORT inflateMark(z_stream *strm)
 {
     struct inflate_state *state;
 
diff --git a/uncompr.c b/uncompr.c
index fada0c6..955507c 100644
--- a/uncompr.c
+++ b/uncompr.c
@@ -21,11 +21,7 @@
    enough memory, Z_BUF_ERROR if there was not enough room in the output
    buffer, or Z_DATA_ERROR if the input data was corrupted.
 */
-int ZEXPORT uncompress (dest, destLen, source, sourceLen)
-    Byte *dest;
-    uLong *destLen;
-    const Byte *source;
-    uLong sourceLen;
+int ZEXPORT uncompress (Byte *dest, uLong *destLen, const Byte *source, uLong sourceLen)
 {
     z_stream stream;
     int err;
diff --git a/zutil.c b/zutil.c
index 5c1c754..d38280e 100644
--- a/zutil.c
+++ b/zutil.c
@@ -101,8 +101,7 @@ void ZLIB_INTERNAL z_error (m)
 /* exported to allow conversion of error code to string for compress() and
  * uncompress()
  */
-const char * ZEXPORT zError(err)
-    int err;
+const char * ZEXPORT zError(int err)
 {
     return ERR_MSG(err);
 }