[PATCH] zlib cleanup: OF

Remove the stale support for K&R function declarations through the OF()
macro.

This is the last patch to clean up zconf.h, at least for now.

include/linux/zconf.h

@@ -37,14 +37,9 @@
 
                         /* Type declarations */
 
-#    define OF(args)  args
-
 typedef unsigned char  Byte;  /* 8 bits */
 typedef unsigned int   uInt;  /* 16 bits or more */
 typedef unsigned long  uLong; /* 32 bits or more */
 typedef void     *voidp;
 
-#include <linux/types.h> /* for off_t */
-#include <linux/unistd.h>    /* for SEEK_* and off_t */
-
 #endif /* _ZCONF_H */

include/linux/zlib.h

@@ -161,14 +161,14 @@ typedef z_stream *z_streamp;
 
                         /* basic functions */
 
-extern const char * zlib_zlibVersion OF((void));
+extern const char * zlib_zlibVersion (void);
 /* The application can compare zlibVersion and ZLIB_VERSION for consistency.
    If the first character differs, the library code actually used is
    not compatible with the zlib.h header file used by the application.
    This check is automatically made by deflateInit and inflateInit.
  */
 
-extern int zlib_deflate_workspacesize OF((void));
+extern int zlib_deflate_workspacesize (void);
 /*
    Returns the number of bytes that needs to be allocated for a per-
    stream workspace.  A pointer to this number of bytes should be
@@ -176,7 +176,7 @@ extern int zlib_deflate_workspacesize OF((void));
 */
 
 /* 
-extern int deflateInit OF((z_streamp strm, int level));
+extern int deflateInit (z_streamp strm, int level);
 
      Initializes the internal stream state for compression. The fields
    zalloc, zfree and opaque must be initialized before by the caller.
@@ -198,7 +198,7 @@ extern int deflateInit OF((z_streamp strm, int level));
 */
 
 
-extern int zlib_deflate OF((z_streamp strm, int flush));
+extern int zlib_deflate (z_streamp strm, int flush);
 /*
     deflate compresses as much data as possible, and stops when the input
   buffer becomes empty or the output buffer becomes full. It may introduce some
@@ -276,7 +276,7 @@ extern int zlib_deflate OF((z_streamp strm, int flush));
 */
 
 
-extern int zlib_deflateEnd OF((z_streamp strm));
+extern int zlib_deflateEnd (z_streamp strm);
 /*
      All dynamically allocated data structures for this stream are freed.
    This function discards any unprocessed input and does not flush any
@@ -290,7 +290,7 @@ extern int zlib_deflateEnd OF((z_streamp strm));
 */
 
 
-extern int zlib_inflate_workspacesize OF((void));
+extern int zlib_inflate_workspacesize (void);
 /*
    Returns the number of bytes that needs to be allocated for a per-
    stream workspace.  A pointer to this number of bytes should be
@@ -298,7 +298,7 @@ extern int zlib_inflate_workspacesize OF((void));
 */
 
 /* 
-extern int zlib_inflateInit OF((z_streamp strm));
+extern int zlib_inflateInit (z_streamp strm);
 
      Initializes the internal stream state for decompression. The fields
    next_in, avail_in, and workspace must be initialized before by
@@ -318,7 +318,7 @@ extern int zlib_inflateInit OF((z_streamp strm));
 */
 
 
-extern int zlib_inflate OF((z_streamp strm, int flush));
+extern int zlib_inflate (z_streamp strm, int flush);
 /*
     inflate decompresses as much data as possible, and stops when the input
   buffer becomes empty or the output buffer becomes full. It may some
@@ -387,7 +387,7 @@ extern int zlib_inflate OF((z_streamp strm, int flush));
 */
 
 
-extern int zlib_inflateEnd OF((z_streamp strm));
+extern int zlib_inflateEnd (z_streamp strm);
 /*
      All dynamically allocated data structures for this stream are freed.
    This function discards any unprocessed input and does not flush any
@@ -405,12 +405,12 @@ extern int zlib_inflateEnd OF((z_streamp strm));
 */
 
 /*   
-extern int deflateInit2 OF((z_streamp strm,
+extern int deflateInit2 (z_streamp strm,
                                      int  level,
                                      int  method,
                                      int  windowBits,
                                      int  memLevel,
-                                     int  strategy));
+                                     int  strategy);
 
      This is another version of deflateInit with more compression options. The
    fields next_in, zalloc, zfree and opaque must be initialized before by
@@ -448,9 +448,9 @@ extern int deflateInit2 OF((z_streamp strm,
    not perform any compression: this will be done by deflate().
 */
                             
-extern int zlib_deflateSetDictionary OF((z_streamp strm,
+extern int zlib_deflateSetDictionary (z_streamp strm,
 						     const Byte *dictionary,
-						     uInt  dictLength));
+						     uInt  dictLength);
 /*
      Initializes the compression dictionary from the given byte sequence
    without producing any compressed output. This function must be called
@@ -484,8 +484,7 @@ extern int zlib_deflateSetDictionary OF((z_streamp strm,
    perform any compression: this will be done by deflate().
 */
 
-extern int zlib_deflateCopy OF((z_streamp dest,
-					    z_streamp source));
+extern int zlib_deflateCopy (z_streamp dest, z_streamp source);
 /*
      Sets the destination stream as a complete copy of the source stream.
 
@@ -502,7 +501,7 @@ extern int zlib_deflateCopy OF((z_streamp dest,
    destination.
 */
 
-extern int zlib_deflateReset OF((z_streamp strm));
+extern int zlib_deflateReset (z_streamp strm);
 /*
      This function is equivalent to deflateEnd followed by deflateInit,
    but does not free and reallocate all the internal compression state.
@@ -513,9 +512,7 @@ extern int zlib_deflateReset OF((z_streamp strm));
    stream state was inconsistent (such as zalloc or state being NULL).
 */
 
-extern int zlib_deflateParams OF((z_streamp strm,
-					      int level,
-					      int strategy));
+extern int zlib_deflateParams (z_streamp strm, int level, int strategy);
 /*
      Dynamically update the compression level and compression strategy.  The
    interpretation of level and strategy is as in deflateInit2.  This can be
@@ -535,8 +532,7 @@ extern int zlib_deflateParams OF((z_streamp strm,
 */
 
 /*   
-extern int inflateInit2 OF((z_streamp strm,
-                                     int  windowBits));
+extern int inflateInit2 (z_streamp strm, int  windowBits);
 
      This is another version of inflateInit with an extra parameter. The
    fields next_in, avail_in, zalloc, zfree and opaque must be initialized
@@ -557,9 +553,9 @@ extern int inflateInit2 OF((z_streamp strm,
    modified, but next_out and avail_out are unchanged.)
 */
 
-extern int zlib_inflateSetDictionary OF((z_streamp strm,
+extern int zlib_inflateSetDictionary (z_streamp strm,
 						     const Byte *dictionary,
-						     uInt  dictLength));
+						     uInt  dictLength);
 /*
      Initializes the decompression dictionary from the given uncompressed byte
    sequence. This function must be called immediately after a call of inflate
@@ -576,7 +572,7 @@ extern int zlib_inflateSetDictionary OF((z_streamp strm,
    inflate().
 */
 
-extern int zlib_inflateSync OF((z_streamp strm));
+extern int zlib_inflateSync (z_streamp strm);
 /* 
     Skips invalid compressed data until a full flush point (see above the
   description of deflate with Z_FULL_FLUSH) can be found, or until all
@@ -591,7 +587,7 @@ extern int zlib_inflateSync OF((z_streamp strm));
   until success or end of the input data.
 */
 
-extern int zlib_inflateReset OF((z_streamp strm));
+extern int zlib_inflateReset (z_streamp strm);
 /*
      This function is equivalent to inflateEnd followed by inflateInit,
    but does not free and reallocate all the internal decompression state.
@@ -601,7 +597,7 @@ extern int zlib_inflateReset OF((z_streamp strm));
    stream state was inconsistent (such as zalloc or state being NULL).
 */
 
-extern int zlib_inflateIncomp OF((z_stream *strm));
+extern int zlib_inflateIncomp (z_stream *strm);
 /*
      This function adds the data at next_in (avail_in bytes) to the output
    history without performing any output.  There must be no pending output,
@@ -615,16 +611,16 @@ extern int zlib_inflateIncomp OF((z_stream *strm));
 /* deflateInit and inflateInit are macros to allow checking the zlib version
  * and the compiler's view of z_stream:
  */
-extern int zlib_deflateInit_ OF((z_streamp strm, int level,
-                                     const char *version, int stream_size));
-extern int zlib_inflateInit_ OF((z_streamp strm,
-                                     const char *version, int stream_size));
-extern int zlib_deflateInit2_ OF((z_streamp strm, int  level, int  method,
+extern int zlib_deflateInit_ (z_streamp strm, int level,
+                                     const char *version, int stream_size);
+extern int zlib_inflateInit_ (z_streamp strm,
+                                     const char *version, int stream_size);
+extern int zlib_deflateInit2_ (z_streamp strm, int  level, int  method,
                                       int windowBits, int memLevel,
                                       int strategy, const char *version,
-                                      int stream_size));
-extern int zlib_inflateInit2_ OF((z_streamp strm, int  windowBits,
-                                      const char *version, int stream_size));
+                                      int stream_size);
+extern int zlib_inflateInit2_ (z_streamp strm, int  windowBits,
+                                      const char *version, int stream_size);
 #define zlib_deflateInit(strm, level) \
         zlib_deflateInit_((strm), (level), ZLIB_VERSION, sizeof(z_stream))
 #define zlib_inflateInit(strm) \
@@ -640,9 +636,9 @@ extern int zlib_inflateInit2_ OF((z_streamp strm, int  windowBits,
     struct internal_state {int dummy;}; /* hack for buggy compilers */
 #endif
 
-extern const char  * zlib_zError           OF((int err));
-extern int           zlib_inflateSyncPoint OF((z_streamp z));
-extern const uLong * zlib_get_crc_table    OF((void));
+extern const char  * zlib_zError           (int err);
+extern int           zlib_inflateSyncPoint (z_streamp z);
+extern const uLong * zlib_get_crc_table    (void);
 
 #ifdef __cplusplus
 }

include/linux/zutil.h

@@ -62,8 +62,8 @@ typedef unsigned long  ulg;
 
          /* functions */
 
-typedef uLong (*check_func) OF((uLong check, const Byte *buf,
-				       uInt len));
+typedef uLong (*check_func) (uLong check, const Byte *buf,
+				       uInt len);
 
 
                         /* checksum functions */

lib/zlib_deflate/deflate.c

@@ -63,22 +63,22 @@ typedef enum {
     finish_done     /* finish done, accept no more input or output */
 } block_state;
 
-typedef block_state (*compress_func) OF((deflate_state *s, int flush));
+typedef block_state (*compress_func) (deflate_state *s, int flush);
 /* Compression function. Returns the block state after the call. */
 
-local void fill_window    OF((deflate_state *s));
-local block_state deflate_stored OF((deflate_state *s, int flush));
-local block_state deflate_fast   OF((deflate_state *s, int flush));
-local block_state deflate_slow   OF((deflate_state *s, int flush));
-local void lm_init        OF((deflate_state *s));
-local void putShortMSB    OF((deflate_state *s, uInt b));
-local void flush_pending  OF((z_streamp strm));
-local int read_buf        OF((z_streamp strm, Byte *buf, unsigned size));
-local uInt longest_match  OF((deflate_state *s, IPos cur_match));
+local void fill_window    (deflate_state *s);
+local block_state deflate_stored (deflate_state *s, int flush);
+local block_state deflate_fast   (deflate_state *s, int flush);
+local block_state deflate_slow   (deflate_state *s, int flush);
+local void lm_init        (deflate_state *s);
+local void putShortMSB    (deflate_state *s, uInt b);
+local void flush_pending  (z_streamp strm);
+local int read_buf        (z_streamp strm, Byte *buf, unsigned size);
+local uInt longest_match  (deflate_state *s, IPos cur_match);
 
 #ifdef DEBUG_ZLIB
-local  void check_match OF((deflate_state *s, IPos start, IPos match,
-                            int length));
+local  void check_match (deflate_state *s, IPos start, IPos match,
+                         int length);
 #endif
 
 /* ===========================================================================

lib/zlib_deflate/deftree.c

@@ -132,25 +132,25 @@ local static_tree_desc  static_bl_desc =
  * Local (static) routines in this file.
  */
 
-local void tr_static_init OF((void));
-local void init_block     OF((deflate_state *s));
-local void pqdownheap     OF((deflate_state *s, ct_data *tree, int k));
-local void gen_bitlen     OF((deflate_state *s, tree_desc *desc));
-local void gen_codes      OF((ct_data *tree, int max_code, ush *bl_count));
-local void build_tree     OF((deflate_state *s, tree_desc *desc));
-local void scan_tree      OF((deflate_state *s, ct_data *tree, int max_code));
-local void send_tree      OF((deflate_state *s, ct_data *tree, int max_code));
-local int  build_bl_tree  OF((deflate_state *s));
-local void send_all_trees OF((deflate_state *s, int lcodes, int dcodes,
-                              int blcodes));
-local void compress_block OF((deflate_state *s, ct_data *ltree,
-                              ct_data *dtree));
-local void set_data_type  OF((deflate_state *s));
-local unsigned bi_reverse OF((unsigned value, int length));
-local void bi_windup      OF((deflate_state *s));
-local void bi_flush       OF((deflate_state *s));
-local void copy_block     OF((deflate_state *s, char *buf, unsigned len,
-                              int header));
+local void tr_static_init (void);
+local void init_block     (deflate_state *s);
+local void pqdownheap     (deflate_state *s, ct_data *tree, int k);
+local void gen_bitlen     (deflate_state *s, tree_desc *desc);
+local void gen_codes      (ct_data *tree, int max_code, ush *bl_count);
+local void build_tree     (deflate_state *s, tree_desc *desc);
+local void scan_tree      (deflate_state *s, ct_data *tree, int max_code);
+local void send_tree      (deflate_state *s, ct_data *tree, int max_code);
+local int  build_bl_tree  (deflate_state *s);
+local void send_all_trees (deflate_state *s, int lcodes, int dcodes,
+                           int blcodes);
+local void compress_block (deflate_state *s, ct_data *ltree,
+                           ct_data *dtree);
+local void set_data_type  (deflate_state *s);
+local unsigned bi_reverse (unsigned value, int length);
+local void bi_windup      (deflate_state *s);
+local void bi_flush       (deflate_state *s);
+local void copy_block     (deflate_state *s, char *buf, unsigned len,
+                           int header);
 
 #ifndef DEBUG_ZLIB
 #  define send_code(s, c, tree) send_bits(s, tree[c].Code, tree[c].Len)
@@ -174,7 +174,7 @@ local void copy_block     OF((deflate_state *s, char *buf, unsigned len,
  * IN assertion: length <= 16 and value fits in length bits.
  */
 #ifdef DEBUG_ZLIB
-local void send_bits      OF((deflate_state *s, int value, int length));
+local void send_bits      (deflate_state *s, int value, int length);
 
 local void send_bits(
 	deflate_state *s,

lib/zlib_deflate/defutil.h

@@ -264,14 +264,14 @@ typedef struct deflate_workspace {
  */
 
         /* in trees.c */
-void zlib_tr_init         OF((deflate_state *s));
-int  zlib_tr_tally        OF((deflate_state *s, unsigned dist, unsigned lc));
-ulg  zlib_tr_flush_block  OF((deflate_state *s, char *buf, ulg stored_len,
-			      int eof));
-void zlib_tr_align        OF((deflate_state *s));
-void zlib_tr_stored_block OF((deflate_state *s, char *buf, ulg stored_len,
-			      int eof));
-void zlib_tr_stored_type_only OF((deflate_state *));
+void zlib_tr_init         (deflate_state *s);
+int  zlib_tr_tally        (deflate_state *s, unsigned dist, unsigned lc);
+ulg  zlib_tr_flush_block  (deflate_state *s, char *buf, ulg stored_len,
+			   int eof);
+void zlib_tr_align        (deflate_state *s);
+void zlib_tr_stored_block (deflate_state *s, char *buf, ulg stored_len,
+			   int eof);
+void zlib_tr_stored_type_only (deflate_state *);
 
 
 /* ===========================================================================

lib/zlib_inflate/infblock.h

@@ -14,31 +14,31 @@
 struct inflate_blocks_state;
 typedef struct inflate_blocks_state inflate_blocks_statef;
 
-extern inflate_blocks_statef * zlib_inflate_blocks_new OF((
+extern inflate_blocks_statef * zlib_inflate_blocks_new (
     z_streamp z,
-    check_func c,               /* check function */
-    uInt w));                   /* window size */
+    check_func c,              /* check function */
+    uInt w);                   /* window size */
 
-extern int zlib_inflate_blocks OF((
+extern int zlib_inflate_blocks (
     inflate_blocks_statef *,
     z_streamp ,
-    int));                      /* initial return code */
+    int);                      /* initial return code */
 
-extern void zlib_inflate_blocks_reset OF((
+extern void zlib_inflate_blocks_reset (
     inflate_blocks_statef *,
     z_streamp ,
-    uLong *));                  /* check value on output */
+    uLong *);                  /* check value on output */
 
-extern int zlib_inflate_blocks_free OF((
+extern int zlib_inflate_blocks_free (
     inflate_blocks_statef *,
-    z_streamp));
+    z_streamp);
 
-extern void zlib_inflate_set_dictionary OF((
+extern void zlib_inflate_set_dictionary (
     inflate_blocks_statef *s,
-    const Byte *d,   /* dictionary */
-    uInt  n));       /* dictionary length */
+    const Byte *d,  /* dictionary */
+    uInt  n);       /* dictionary length */
 
-extern int zlib_inflate_blocks_sync_point OF((
-    inflate_blocks_statef *s));
+extern int zlib_inflate_blocks_sync_point (
+    inflate_blocks_statef *s);
 
 #endif /* _INFBLOCK_H */

lib/zlib_inflate/infcodes.h

@@ -16,18 +16,18 @@
 struct inflate_codes_state;
 typedef struct inflate_codes_state inflate_codes_statef;
 
-extern inflate_codes_statef *zlib_inflate_codes_new OF((
+extern inflate_codes_statef *zlib_inflate_codes_new (
     uInt, uInt,
     inflate_huft *, inflate_huft *,
-    z_streamp ));
+    z_streamp );
 
-extern int zlib_inflate_codes OF((
+extern int zlib_inflate_codes (
     inflate_blocks_statef *,
     z_streamp ,
-    int));
+    int);
 
-extern void zlib_inflate_codes_free OF((
+extern void zlib_inflate_codes_free (
     inflate_codes_statef *,
-    z_streamp ));
+    z_streamp );
 
 #endif /* _INFCODES_H */

lib/zlib_inflate/inffast.h

@@ -8,10 +8,10 @@
    subject to change. Applications should only use zlib.h.
  */
 
-extern int zlib_inflate_fast OF((
+extern int zlib_inflate_fast (
     uInt,
     uInt,
     inflate_huft *,
     inflate_huft *,
     inflate_blocks_statef *,
-    z_streamp ));
+    z_streamp );

lib/zlib_inflate/inftrees.c

@@ -22,7 +22,7 @@ struct internal_state;
 #define bits word.what.Bits
 
 
-local int huft_build OF((
+local int huft_build (
     uInt *,             /* code lengths in bits */
     uInt,               /* number of codes */
     uInt,               /* number of "simple" codes */
@@ -32,7 +32,7 @@ local int huft_build OF((
     uInt *,             /* maximum lookup bits (returns actual) */
     inflate_huft *,     /* space for trees */
     uInt *,             /* hufts used in space */
-    uInt * ));          /* space for values */
+    uInt * );           /* space for values */
 
 /* Tables for deflate from PKZIP's appnote.txt. */
 local const uInt cplens[31] = { /* Copy lengths for literal codes 257..285 */

lib/zlib_inflate/inftrees.h

@@ -35,14 +35,14 @@ struct inflate_huft_s {
    value below is more than safe. */
 #define MANY 1440
 
-extern int zlib_inflate_trees_bits OF((
+extern int zlib_inflate_trees_bits (
     uInt *,                     /* 19 code lengths */
     uInt *,                     /* bits tree desired/actual depth */
     inflate_huft **,            /* bits tree result */
     inflate_huft *,             /* space for trees */
-    z_streamp));                /* for messages */
+    z_streamp);                 /* for messages */
 
-extern int zlib_inflate_trees_dynamic OF((
+extern int zlib_inflate_trees_dynamic (
     uInt,                       /* number of literal/length codes */
     uInt,                       /* number of distance codes */
     uInt *,                     /* that many (total) code lengths */
@@ -51,13 +51,13 @@ extern int zlib_inflate_trees_dynamic OF((
     inflate_huft **,            /* literal/length tree result */
     inflate_huft **,            /* distance tree result */
     inflate_huft *,             /* space for trees */
-    z_streamp));                /* for messages */
+    z_streamp);                 /* for messages */
 
-extern int zlib_inflate_trees_fixed OF((
+extern int zlib_inflate_trees_fixed (
     uInt *,                     /* literal desired/actual bit depth */
     uInt *,                     /* distance desired/actual bit depth */
     inflate_huft **,            /* literal/length tree result */
     inflate_huft **,            /* distance tree result */
-    z_streamp));                /* for memory allocation */
+    z_streamp);                 /* for memory allocation */
 
 #endif /* _INFTREES_H */

lib/zlib_inflate/infutil.h

@@ -92,10 +92,10 @@ struct inflate_blocks_state {
 extern uInt zlib_inflate_mask[17];
 
 /* copy as much as possible from the sliding window to the output area */
-extern int zlib_inflate_flush OF((
+extern int zlib_inflate_flush (
     inflate_blocks_statef *,
     z_streamp ,
-    int));
+    int);
 
 /* inflate private state */
 typedef enum {