remove unnecessary variable

* st.c (do_hash): remove unnecessary variable and cast.

* hash.c, numeric.c, st.c: adjust style and indent.

git-svn-id: svn+ssh://ci.ruby-lang.org/ruby/trunk@56991 b2dd03c8-39d4-4d8f-98ff-823fe69b080e

3 files changed, 101 insertions, 58 deletions

diff --git a/hash.c b/hash.c
index b4c74ed6d3..388446efad 100644
--- a/hash.c
+++ b/hash.c
@@ -217,22 +217,26 @@ obj_any_hash(VALUE obj)
 }
 
 static inline st_index_t
-any_hash_weak(VALUE a, st_index_t (*other_func)(VALUE)) {
+any_hash_weak(VALUE a, st_index_t (*other_func)(VALUE))
+{
     return any_hash_general(a, FALSE, other_func);
 }
 
 static st_index_t
-rb_any_hash_weak(VALUE a) {
+rb_any_hash_weak(VALUE a)
+{
     return any_hash_weak(a, obj_any_hash);
 }
 
 static inline st_index_t
-any_hash(VALUE a, st_index_t (*other_func)(VALUE)) {
+any_hash(VALUE a, st_index_t (*other_func)(VALUE))
+{
     return any_hash_general(a, TRUE, other_func);
 }
 
 static st_index_t
-rb_any_hash(VALUE a) {
+rb_any_hash(VALUE a)
+{
     return any_hash(a, obj_any_hash);
 }
 
@@ -246,7 +250,7 @@ static const uint64_t prime2 = 0xcdb32970830fcaa1ULL;
 
 
 static inline uint64_t
-mult_and_mix (uint64_t m1, uint64_t m2)
+mult_and_mix(uint64_t m1, uint64_t m2)
 {
 #if defined(__GNUC__) && UINT_MAX != ULONG_MAX
     __uint128_t r = (__uint128_t) m1 * (__uint128_t) m2;
@@ -263,7 +267,7 @@ mult_and_mix (uint64_t m1, uint64_t m2)
 }
 
 static inline uint64_t
-key64_hash (uint64_t key, uint32_t seed)
+key64_hash(uint64_t key, uint32_t seed)
 {
     return mult_and_mix(key + seed, prime1);
 }
diff --git a/numeric.c b/numeric.c
index d2c9cf701b..74771cba6f 100644
--- a/numeric.c
+++ b/numeric.c
@@ -1453,7 +1453,7 @@ flo_hash(VALUE num)
 VALUE
 rb_dbl_hash(double d)
 {
-    return LONG2FIX(rb_dbl_long_hash (d));
+    return LONG2FIX(rb_dbl_long_hash(d));
 }
 
 VALUE
diff --git a/st.c b/st.c
index 8cb3f7fef7..89dc248969 100644
--- a/st.c
+++ b/st.c
@@ -303,13 +303,9 @@ struct st_features features[] = {
 
 /* Return hash value of KEY for table TAB.  */
 static inline st_hash_t
-do_hash(st_data_t key, st_table *tab) {
-    st_index_t h = (st_index_t)(tab->curr_hash)(key);
-#if SIZEOF_INT == SIZEOF_VOIDP
-    st_hash_t hash = h;
-#else
-    st_hash_t hash = h;
-#endif
+do_hash(st_data_t key, st_table *tab)
+{
+    st_hash_t hash = (st_hash_t)(tab->type->hash)(key);
 
     /* RESERVED_HASH_VAL is used for a deleted entry.  Map it into
        another value.  Such mapping should be extremely rare.  */
@@ -329,7 +325,8 @@ do_hash(st_data_t key, st_table *tab) {
 
 /* Return smallest n >= MINIMAL_POWER2 such 2^n > SIZE.  */
 static int
-get_power2(st_index_t size) {
+get_power2(st_index_t size)
+{
     unsigned int n;
 
     for (n = 0; size != 0; n++)
@@ -347,7 +344,8 @@ get_power2(st_index_t size) {
 /* Return value of N-th bin in array BINS of table with bins size
    index S.  */
 static inline st_index_t
-get_bin(st_index_t *bins, int s, st_index_t n) {
+get_bin(st_index_t *bins, int s, st_index_t n)
+{
   return (s == 0 ? ((unsigned char *) bins)[n]
 	  : s == 1 ? ((unsigned short *) bins)[n]
 	  : s == 2 ? ((unsigned int *) bins)[n]
@@ -357,7 +355,8 @@ get_bin(st_index_t *bins, int s, st_index_t n) {
 /* Set up N-th bin in array BINS of table with bins size index S to
    value V.  */
 static inline void
-set_bin(st_index_t *bins, int s, st_index_t n, st_index_t v) {
+set_bin(st_index_t *bins, int s, st_index_t n, st_index_t v)
+{
     if (s == 0) ((unsigned char *) bins)[n] = (unsigned char) v;
     else if (s == 1) ((unsigned short *) bins)[n] = (unsigned short) v;
     else if (s == 2) ((unsigned int *) bins)[n] = (unsigned int) v;
@@ -410,44 +409,51 @@ set_bin(st_index_t *bins, int s, st_index_t n, st_index_t v) {
 
 /* Return bin size index of table TAB.  */
 static inline unsigned int
-get_size_ind(const st_table *tab) {
+get_size_ind(const st_table *tab)
+{
     return tab->size_ind;
 }
 
 /* Return the number of allocated bins of table TAB.  */
 static inline st_index_t
-get_bins_num(const st_table *tab) {
+get_bins_num(const st_table *tab)
+{
     return ((st_index_t) 1)<<tab->bin_power;
 }
 
 /* Return mask for a bin index in table TAB.  */
 static inline st_index_t
-bins_mask(const st_table *tab) {
+bins_mask(const st_table *tab)
+{
     return get_bins_num(tab) - 1;
 }
 
 /* Return the index of table TAB bin corresponding to
    HASH_VALUE.  */
 static inline st_index_t
-hash_bin(st_hash_t hash_value, st_table *tab) {
+hash_bin(st_hash_t hash_value, st_table *tab)
+{
     return hash_value & bins_mask(tab);
 }
 
 /* Return the number of allocated entries of table TAB.  */
 static inline st_index_t
-get_allocated_entries(const st_table *tab) {
+get_allocated_entries(const st_table *tab)
+{
     return ((st_index_t) 1)<<tab->entry_power;
 }
 
 /* Return size of the allocated bins of table TAB.  */
 static inline st_index_t
-bins_size(const st_table *tab) {
+bins_size(const st_table *tab)
+{
     return features[tab->entry_power].bins_words * sizeof (st_index_t);
 }
 
 /* Mark all bins of table TAB as empty.  */
 static void
-initialize_bins(st_table *tab) {
+initialize_bins(st_table *tab)
+{
     memset(tab->bins, 0, bins_size(tab));
 }
 
@@ -466,7 +472,8 @@ make_tab_empty(st_table *tab)
 /* Check the table T consistency.  It can be extremely slow.  So use
    it only for debugging.  */
 static void
-st_check(st_table *tab) {
+st_check(st_table *tab)
+{
     st_index_t d, e, i, n, p;
 
     for (p = get_allocated_entries(tab), i = 0; p > 1; i++, p>>=1)
@@ -544,7 +551,8 @@ stat_col(void)
    entries.  The real number of entries which the table can hold is
    the nearest power of two for SIZE.  */
 st_table *
-st_init_table_with_size(const struct st_hash_type *type, st_index_t size) {
+st_init_table_with_size(const struct st_hash_type *type, st_index_t size)
+{
     st_table *tab;
     int n;
 
@@ -591,53 +599,61 @@ st_init_table_with_size(const struct st_hash_type *type, st_index_t size) {
 /* Create and return table with TYPE which can hold a minimal number
    of entries (see comments for get_power2).  */
 st_table *
-st_init_table(const struct st_hash_type *type) {
+st_init_table(const struct st_hash_type *type)
+{
     return st_init_table_with_size(type, 0);
 }
 
 /* Create and return table which can hold a minimal number of
    numbers.  */
 st_table *
-st_init_numtable(void) {
+st_init_numtable(void)
+{
     return st_init_table(&type_numhash);
 }
 
 /* Create and return table which can hold SIZE numbers.  */
 st_table *
-st_init_numtable_with_size(st_index_t size) {
+st_init_numtable_with_size(st_index_t size)
+{
     return st_init_table_with_size(&type_numhash, size);
 }
 
 /* Create and return table which can hold a minimal number of
    strings.  */
 st_table *
-st_init_strtable(void) {
+st_init_strtable(void)
+{
     return st_init_table(&type_strhash);
 }
 
 /* Create and return table which can hold SIZE strings.  */
 st_table *
-st_init_strtable_with_size(st_index_t size) {
+st_init_strtable_with_size(st_index_t size)
+{
     return st_init_table_with_size(&type_strhash, size);
 }
 
 /* Create and return table which can hold a minimal number of strings
    whose character case is ignored.  */
 st_table *
-st_init_strcasetable(void) {
+st_init_strcasetable(void)
+{
     return st_init_table(&type_strcasehash);
 }
 
 /* Create and return table which can hold SIZE strings whose character
    case is ignored.  */
 st_table *
-st_init_strcasetable_with_size(st_index_t size) {
+st_init_strcasetable_with_size(st_index_t size)
+{
     return st_init_table_with_size(&type_strcasehash, size);
 }
 
 /* Make table TAB empty.  */
 void
-st_clear(st_table *tab) {
+st_clear(st_table *tab)
+{
     make_tab_empty(tab);
     tab->rebuilds_num++;
 #ifdef ST_DEBUG
@@ -647,7 +663,8 @@ st_clear(st_table *tab) {
 
 /* Free table TAB space.  */
 void
-st_free_table(st_table *tab) {
+st_free_table(st_table *tab)
+{
     if (tab->bins != NULL)
         free(tab->bins);
     free(tab->entries);
@@ -656,7 +673,8 @@ st_free_table(st_table *tab) {
 
 /* Return byte size of memory allocted for table TAB.  */
 size_t
-st_memsize(const st_table *tab) {
+st_memsize(const st_table *tab)
+{
     return(sizeof(st_table)
            + (tab->bins == NULL ? 0 : bins_size(tab))
            + get_allocated_entries(tab) * sizeof(st_table_entry));
@@ -677,7 +695,8 @@ find_table_bin_ptr_and_reserve(st_table *tab, st_hash_t *hash_value,
 
 #ifdef HASH_LOG
 static void
-count_collision(const struct st_hash_type *type) {
+count_collision(const struct st_hash_type *type)
+{
     collision.all++;
     if (type == &type_numhash) {
         collision.num++;
@@ -712,7 +731,8 @@ count_collision(const struct st_hash_type *type) {
    Rebuilding is implemented by creation of a new table or by
    compaction of the existing one.  */
 static void
-rebuild_table(st_table *tab) {
+rebuild_table(st_table *tab)
+{
     st_index_t i, ni, bound;
     unsigned int size_ind;
     st_table *new_tab;
@@ -797,7 +817,8 @@ rebuild_table(st_table *tab) {
 
    For our case a is 5, c is 1, and m is a power of two.  */
 static inline st_index_t
-secondary_hash(st_index_t ind, st_table *tab, st_index_t *perterb) {
+secondary_hash(st_index_t ind, st_table *tab, st_index_t *perterb)
+{
     *perterb >>= 11;
     ind = (ind << 2) + ind + *perterb + 1;
     return hash_bin(ind, tab);
@@ -807,8 +828,9 @@ secondary_hash(st_index_t ind, st_table *tab, st_index_t *perterb) {
    search.  Return the index of the found entry in array `entries`.
    If it is not found, return UNDEFINED_ENTRY_IND.  */
 static inline st_index_t
-find_entry(st_table *tab, st_hash_t hash_value, st_data_t key) {
-  st_index_t i, bound;
+find_entry(st_table *tab, st_hash_t hash_value, st_data_t key)
+{
+    st_index_t i, bound;
     st_table_entry *entries;
 
     bound = tab->entries_bound;
@@ -828,7 +850,8 @@ find_entry(st_table *tab, st_hash_t hash_value, st_data_t key) {
 /* Return index of entry with HASH_VALUE and KEY in table TAB.  If
    there is no such entry, return UNDEFINED_ENTRY_IND.  */
 static st_index_t
-find_table_entry_ind(st_table *tab, st_hash_t hash_value, st_data_t key) {
+find_table_entry_ind(st_table *tab, st_hash_t hash_value, st_data_t key)
+{
     st_index_t ind;
 #ifdef QUADRATIC_PROBE
     st_index_t d;
@@ -868,7 +891,8 @@ find_table_entry_ind(st_table *tab, st_hash_t hash_value, st_data_t key) {
    with HASH_VALUE and KEY.  If there is no such bin, return
    UNDEFINED_BIN_IND.  */
 static st_index_t
-find_table_bin_ind(st_table *tab, st_hash_t hash_value, st_data_t key) {
+find_table_bin_ind(st_table *tab, st_hash_t hash_value, st_data_t key)
+{
     st_index_t ind;
 #ifdef QUADRATIC_PROBE
     st_index_t d;
@@ -908,7 +932,8 @@ find_table_bin_ind(st_table *tab, st_hash_t hash_value, st_data_t key) {
    with HASH_VALUE and KEY.  The entry should be in the table
    already.  */
 static st_index_t
-find_table_bin_ind_direct(st_table *tab, st_hash_t hash_value, st_data_t key) {
+find_table_bin_ind_direct(st_table *tab, st_hash_t hash_value, st_data_t key)
+{
     st_index_t ind;
 #ifdef QUADRATIC_PROBE
     st_index_t d;
@@ -1044,7 +1069,8 @@ find_table_bin_ptr_and_reserve(st_table *tab, st_hash_t *hash_value,
 /* Find an entry with KEY in table TAB.  Return non-zero if we found
    it.  Set up *RECORD to the found entry record.  */
 int
-st_lookup(st_table *tab, st_data_t key, st_data_t *value) {
+st_lookup(st_table *tab, st_data_t key, st_data_t *value)
+{
     st_index_t bin;
     st_hash_t hash = do_hash(key, tab);
 
@@ -1066,7 +1092,8 @@ st_lookup(st_table *tab, st_data_t key, st_data_t *value) {
 /* Find an entry with KEY in table TAB.  Return non-zero if we found
    it.  Set up *RESULT to the found table entry key.  */
 int
-st_get_key(st_table *tab, st_data_t key, st_data_t *result) {
+st_get_key(st_table *tab, st_data_t key, st_data_t *result)
+{
     st_index_t bin;
     st_hash_t hash = do_hash(key, tab);
 
@@ -1087,7 +1114,8 @@ st_get_key(st_table *tab, st_data_t key, st_data_t *result) {
 
 /* Check the table and rebuild it if it is necessary.  */
 static inline void
-rebuild_table_if_necessary (st_table *tab) {
+rebuild_table_if_necessary (st_table *tab)
+{
     st_index_t bound = tab->entries_bound;
 
     if (bound == get_allocated_entries(tab))
@@ -1099,7 +1127,8 @@ rebuild_table_if_necessary (st_table *tab) {
    already entry with KEY in the table, return nonzero and and update
    the value of the found entry.  */
 int
-st_insert(st_table *tab, st_data_t key, st_data_t value) {
+st_insert(st_table *tab, st_data_t key, st_data_t value)
+{
     st_table_entry *entry;
     st_index_t bin;
     st_index_t ind;
@@ -1171,7 +1200,8 @@ st_add_direct_with_hash(st_table *tab,
 /* Insert (KEY, VALUE) into table TAB.  The table should not have
    entry with KEY before the insertion.  */
 void
-st_add_direct(st_table *tab, st_data_t key, st_data_t value) {
+st_add_direct(st_table *tab, st_data_t key, st_data_t value)
+{
     st_hash_t hash_value;
 
     hash_value = do_hash(key, tab);
@@ -1230,7 +1260,8 @@ st_insert2(st_table *tab, st_data_t key, st_data_t value,
 
 /* Create and return a copy of table OLD_TAB.  */
 st_table *
-st_copy(st_table *old_tab) {
+st_copy(st_table *old_tab)
+{
     st_table *new_tab;
 
     new_tab = (st_table *) malloc(sizeof(st_table));
@@ -1254,7 +1285,8 @@ st_copy(st_table *old_tab) {
 /* Update the entries start of table TAB after removing an entry
    with index N in the array entries.  */
 static inline void
-update_range_for_deleted(st_table *tab, st_index_t n) {
+update_range_for_deleted(st_table *tab, st_index_t n)
+{
     /* Do not update entries_bound here.  Otherwise, we can fill all
        bins by deleted entry value before rebuilding the table.  */
     if (tab->entries_start == n)
@@ -1303,7 +1335,8 @@ st_general_delete(st_table *tab, st_data_t *key, st_data_t *value)
 }
 
 int
-st_delete(st_table *tab, st_data_t *key, st_data_t *value) {
+st_delete(st_table *tab, st_data_t *key, st_data_t *value)
+{
     return st_general_delete(tab, key, value);
 }
 
@@ -1323,7 +1356,8 @@ st_delete_safe(st_table *tab, st_data_t *key, st_data_t *value,
    Return its key through KEY and its record through VALUE (unless
    VALUE is zero).  */
 int
-st_shift(st_table *tab, st_data_t *key, st_data_t *value) {
+st_shift(st_table *tab, st_data_t *key, st_data_t *value)
+{
     st_index_t i, bound;
     st_index_t bin;
     st_table_entry *entries, *curr_entry_ptr;
@@ -1534,7 +1568,8 @@ st_general_foreach(st_table *tab, int (*func)(ANYARGS), st_data_t arg,
 }
 
 int
-st_foreach(st_table *tab, int (*func)(ANYARGS), st_data_t arg) {
+st_foreach(st_table *tab, int (*func)(ANYARGS), st_data_t arg)
+{
   return st_general_foreach(tab, func, arg, FALSE);
 }
 
@@ -1548,7 +1583,8 @@ st_foreach_check(st_table *tab, int (*func)(ANYARGS), st_data_t arg,
 /* Set up array KEYS by at most SIZE keys of head table TAB entries.
    Return the number of keys set up in array KEYS.  */
 static inline st_index_t
-st_general_keys(st_table *tab, st_data_t *keys, st_index_t size) {
+st_general_keys(st_table *tab, st_data_t *keys, st_index_t size)
+{
     st_index_t i, bound;
     st_data_t key, *keys_start, *keys_end;
     st_table_entry *curr_entry_ptr, *entries = tab->entries;
@@ -1569,7 +1605,8 @@ st_general_keys(st_table *tab, st_data_t *keys, st_index_t size) {
 }
 
 st_index_t
-st_keys(st_table *tab, st_data_t *keys, st_index_t size) {
+st_keys(st_table *tab, st_data_t *keys, st_index_t size)
+{
     return st_general_keys(tab, keys, size);
 }
 
@@ -1583,7 +1620,8 @@ st_keys_check(st_table *tab, st_data_t *keys, st_index_t size,
 /* Set up array VALUES by at most SIZE values of head table TAB
    entries.  Return the number of values set up in array VALUES.  */
 static inline st_index_t
-st_general_values(st_table *tab, st_data_t *values, st_index_t size) {
+st_general_values(st_table *tab, st_data_t *values, st_index_t size)
+{
     st_index_t i, bound;
     st_data_t *values_start, *values_end;
     st_table_entry *curr_entry_ptr, *entries = tab->entries;
@@ -1604,7 +1642,8 @@ st_general_values(st_table *tab, st_data_t *values, st_index_t size) {
 }
 
 st_index_t
-st_values(st_table *tab, st_data_t *values, st_index_t size) {
+st_values(st_table *tab, st_data_t *values, st_index_t size)
+{
     return st_general_values(tab, values, size);
 }