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

diff --git a/adler32.c b/adler32.c
index 49b54417a42548b3d37efb142947818334b0f5a8..bbd03efac643787525c6f1af64889ad42c8dbb13 100644 (file)
--- 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 ba296773fc03b86ef18a9683c6566ca91b50cf6b..c703f244b37f5cd9b070fc4918bfc7efa9012cbf 100644 (file)
--- 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 03ee1578bb10102f2347d0ba66db0ff53aeb539b..775442b8f0fbe072f7390a3bc9486fe82c1bf8c5 100644 (file)
--- 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 d871cc81e3fbb71205ee82cef5323478ad24891b..738ff59acd58203f84d5d1a93ba6276d65b0e2c8 100644 (file)
--- 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 caeb99a3177f477d622870255a00ac2b72f10cad..023d2a650135bc4a20c6a57b7044d7b0bff52f8f 100644 (file)
--- 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 bef31943e186607251b9b04a63b5e13fb13131e3..6ad5633e9a2852ef048ea1946ab37b6db6faf2bc 100644 (file)
--- 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 7448b84e920056bbdda02df4ca1ca57cd4683b7c..f92efdc0bf96cb5743c8120f6f575fd1e31ddb90 100644 (file)
--- 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 955d5a50f0373a7b73781c5d5635f7542bd524e4..9ee0de807eedfebd8d5d2b8e970297dafabd42b2 100644 (file)
--- 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 c8eee5e9f119ee4d3f6f22440f404ee7fcff37e8..137c41fe6036633ec3633a744f09ae2412efc9a6 100644 (file)
--- 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 2cf1d7ee23ddc7944007b405ca6a739ebe2b43c8..dcb3c973ae8f6a3ebf8e2c0ca0d9d67bbfdd0009 100644 (file)
--- 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 fada0c68d9d00afb206a23e4c8f355d93de47d5c..955507c6b21ab627f806483355b3da61e85de27c 100644 (file)
--- 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 5c1c7540a978dabe3e6c8519543596d1b9623fdb..d38280e2e8efbaef4d46311608dc63fcdf35485b 100644 (file)
--- 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);
 }