add PARAMS around prototype lists

diff --git a/lib/hash.h b/lib/hash.h
index 344510a..59229bb 100644 (file)
--- a/lib/hash.h
+++ b/lib/hash.h
@@ -5,13 +5,26 @@
 #  include <config.h>
 # endif
 
+# ifndef PARAMS
+#  if defined (__GNUC__) || __STDC__
+#   define PARAMS(args) args
+#  else
+#   define PARAMS(args) ()
+#  endif
+# endif
+
 # include <stdio.h>
 # include <assert.h>
 
 # ifdef STDC_HEADERS
 #  include <stdlib.h>
-# else
+# endif
+
+# ifndef HAVE_DECLARATION_FREE
 void free ();
+# endif
+
+# ifndef HAVE_DECLARATION_MALLOC
 char *malloc ();
 # endif
 
@@ -32,7 +45,7 @@ typedef struct hash_ent HASH_ENT;
 
 /* This is particularly useful to cast uses in hash_initialize of the
    system free function.  */
-typedef void (*Hash_key_freer_type) (void *key);
+typedef void (*Hash_key_freer_type) PARAMS((void *key));
 
 struct HT
   {
@@ -46,14 +59,14 @@ struct HT
 
     /* User-supplied hash function that hashes entry E to an integer
        in the range 0..TABLE_SIZE-1.  */
-    unsigned int (*hash_hash) (const void *e, unsigned int table_size);
+    unsigned int (*hash_hash) PARAMS((const void *e, unsigned int table_size));
 
     /* User-supplied function that determines whether a new entry is
        unique by comparing the new entry to entries that hashed to the
        same bucket index.  It should return zero for a pair of entries
        that compare equal, non-zero otherwise.  */
 
-    int (*hash_key_comparator) (const void *, const void *);
+    int (*hash_key_comparator) PARAMS((const void *, const void *));
 
     HASH_ENT **hash_table;
     unsigned int hash_table_size;
@@ -83,75 +96,87 @@ struct HT
 typedef struct HT HT;
 
 unsigned int
-  hash_get_n_slots_used (const HT *ht);
+  hash_get_n_slots_used PARAMS((const HT *ht));
 
 unsigned int
-  hash_get_max_chain_length (HT *ht);
+  hash_get_max_chain_length PARAMS((HT *ht));
 
 int
-  hash_rehash (HT *ht, unsigned int new_table_size);
+  hash_rehash PARAMS((HT *ht, unsigned int new_table_size));
 
 unsigned int
-  hash_get_table_size (const HT *ht);
+  hash_get_table_size PARAMS((const HT *ht));
 
 HT *
-  hash_initialize (unsigned int table_size,
-                  void (*key_freer) (void *key),
-                  unsigned int (*hash) (const void *, unsigned int),
-                  int (*equality_tester) (const void *, const void *));
+  hash_initialize PARAMS((unsigned int table_size,
+                         void (*key_freer) PARAMS((void *key)),
+                         unsigned int (*hash) PARAMS((const void *,
+                                                      unsigned int)),
+                         int (*equality_tester) PARAMS((const void *,
+                                                        const void *))));
 
 unsigned int
-  hash_get_n_keys (const HT *ht);
+  hash_get_n_keys PARAMS((const HT *ht));
 
 int
-  hash_query_in_table (const HT *ht, const void *e);
+  hash_query_in_table PARAMS((const HT *ht, const void *e));
 
 void *
-  hash_lookup (const HT *ht, const void *e);
+  hash_lookup PARAMS((const HT *ht, const void *e));
 
 void *
-  hash_insert_if_absent (HT *ht, const void *e, int *failed);
+  hash_insert_if_absent PARAMS((HT *ht,
+                               const void *e,
+                               int *failed));
 
 void *
-  hash_delete_if_present (HT *ht, const void *e);
+  hash_delete_if_present PARAMS((HT *ht, const void *e));
 
 void
-  hash_print_statistics (const HT *ht, FILE *stream);
+  hash_print_statistics PARAMS((const HT *ht, FILE *stream));
 
 int
-  hash_get_statistics (const HT *ht, unsigned int *n_slots_used,
-                      unsigned int *n_keys,
-                      unsigned int *max_chain_length);
+  hash_get_statistics PARAMS((const HT *ht, unsigned int *n_slots_used,
+                             unsigned int *n_keys,
+                             unsigned int *max_chain_length));
 
 int
-  hash_table_ok (HT *ht);
+  hash_table_ok PARAMS((HT *ht));
 
 void
-  hash_do_for_each (HT *ht, void (*f) (void *e, void *aux), void *aux);
+  hash_do_for_each PARAMS((HT *ht,
+                          void (*f) PARAMS((void *e, void *aux)),
+                          void *aux));
 
 int
-  hash_do_for_each_2 (HT *ht, int (*f) (void *e, void *aux), void *aux);
+  hash_do_for_each_2 PARAMS((HT *ht,
+                            int (*f) PARAMS((void *e, void *aux)),
+                            void *aux));
 
 int
-  hash_do_for_each_in_selected_bucket (HT *ht, const void *key,
-                                      int (*f) (const void *bucket_key,
-                                                void *e, void *aux),
-                                      void *aux);
+  hash_do_for_each_in_selected_bucket PARAMS((HT *ht,
+                                             const void *key,
+                                     int (*f) PARAMS((const void *bucket_key,
+                                                      void *e,
+                                                      void *aux)),
+                                             void *aux));
 
 void
-  hash_clear (HT *ht);
+  hash_clear PARAMS((HT *ht));
 
 void
-  hash_free (HT *ht);
+  hash_free PARAMS((HT *ht));
 
 void
-  hash_get_key_list (const HT *ht, unsigned int bufsize, void **buf);
+  hash_get_key_list PARAMS((const HT *ht,
+                           unsigned int bufsize,
+                           void **buf));
 
 void *
-  hash_get_first (const HT *ht);
+  hash_get_first PARAMS((const HT *ht));
 
 void *
-  hash_get_next (const HT *ht, const void *e);
+  hash_get_next PARAMS((const HT *ht, const void *e));
 
 /* This interface to hash_insert_if_absent is used frequently enough to
    merit a macro here.  */