hashmap_cmp_fn takes hashmap_entry params

Another step in eliminating the requirement of hashmap_entry
being the first member of a struct.

Signed-off-by: Eric Wong <e@80x24.org>
Reviewed-by: Derrick Stolee <stolee@gmail.com>
Signed-off-by: Junio C Hamano <gitster@pobox.com>

diff --git a/attr.c b/attr.c
index 4230bee63de84e60a9f56e991f6e6facf5f3bc06..60534816105f0ad301e7209e8c0d3dec80b729ab 100644 (file)
--- a/attr.c
+++ b/attr.c
@@ -70,12 +70,14 @@ struct attr_hash_entry {
 
 /* attr_hashmap comparison function */
 static int attr_hash_entry_cmp(const void *unused_cmp_data,
-                              const void *entry,
-                              const void *entry_or_key,
+                              const struct hashmap_entry *eptr,
+                              const struct hashmap_entry *entry_or_key,
                               const void *unused_keydata)
 {
-       const struct attr_hash_entry *a = entry;
-       const struct attr_hash_entry *b = entry_or_key;
+       const struct attr_hash_entry *a, *b;
+
+       a = container_of(eptr, const struct attr_hash_entry, ent);
+       b = container_of(entry_or_key, const struct attr_hash_entry, ent);
        return (a->keylen != b->keylen) || strncmp(a->key, b->key, a->keylen);
 }
 

diff --git a/builtin/describe.c b/builtin/describe.c
index c6d2386b64834576eb98b51b0f62041be0bb5db3..e9267b5c9c4cccf174a67bdf186b307fba8cd68e 100644 (file)
--- a/builtin/describe.c
+++ b/builtin/describe.c
@@ -64,12 +64,14 @@ static const char *prio_names[] = {
 };
 
 static int commit_name_neq(const void *unused_cmp_data,
-                          const void *entry,
-                          const void *entry_or_key,
+                          const struct hashmap_entry *eptr,
+                          const struct hashmap_entry *entry_or_key,
                           const void *peeled)
 {
-       const struct commit_name *cn1 = entry;
-       const struct commit_name *cn2 = entry_or_key;
+       const struct commit_name *cn1, *cn2;
+
+       cn1 = container_of(eptr, const struct commit_name, entry);
+       cn2 = container_of(entry_or_key, const struct commit_name, entry);
 
        return !oideq(&cn1->peeled, peeled ? peeled : &cn2->peeled);
 }

diff --git a/builtin/difftool.c b/builtin/difftool.c
index fa9c862e3aaa2c87a39de2254136beb2dcd810c0..4a37b3edee86d5951f01767cb39a04f3bf0b08f2 100644 (file)
--- a/builtin/difftool.c
+++ b/builtin/difftool.c
@@ -125,12 +125,15 @@ struct working_tree_entry {
 };
 
 static int working_tree_entry_cmp(const void *unused_cmp_data,
-                                 const void *entry,
-                                 const void *entry_or_key,
+                                 const struct hashmap_entry *eptr,
+                                 const struct hashmap_entry *entry_or_key,
                                  const void *unused_keydata)
 {
-       const struct working_tree_entry *a = entry;
-       const struct working_tree_entry *b = entry_or_key;
+       const struct working_tree_entry *a, *b;
+
+       a = container_of(eptr, const struct working_tree_entry, entry);
+       b = container_of(entry_or_key, const struct working_tree_entry, entry);
+
        return strcmp(a->path, b->path);
 }
 
@@ -145,12 +148,14 @@ struct pair_entry {
 };
 
 static int pair_cmp(const void *unused_cmp_data,
-                   const void *entry,
-                   const void *entry_or_key,
+                   const struct hashmap_entry *eptr,
+                   const struct hashmap_entry *entry_or_key,
                    const void *unused_keydata)
 {
-       const struct pair_entry *a = entry;
-       const struct pair_entry *b = entry_or_key;
+       const struct pair_entry *a, *b;
+
+       a = container_of(eptr, const struct pair_entry, entry);
+       b = container_of(entry_or_key, const struct pair_entry, entry);
 
        return strcmp(a->path, b->path);
 }
@@ -179,12 +184,14 @@ struct path_entry {
 };
 
 static int path_entry_cmp(const void *unused_cmp_data,
-                         const void *entry,
-                         const void *entry_or_key,
+                         const struct hashmap_entry *eptr,
+                         const struct hashmap_entry *entry_or_key,
                          const void *key)
 {
-       const struct path_entry *a = entry;
-       const struct path_entry *b = entry_or_key;
+       const struct path_entry *a, *b;
+
+       a = container_of(eptr, const struct path_entry, entry);
+       b = container_of(entry_or_key, const struct path_entry, entry);
 
        return strcmp(a->path, key ? key : b->path);
 }

diff --git a/builtin/fast-export.c b/builtin/fast-export.c
index 25195badd4341bfe311c62550c73324e12c21df6..ef0578bf90c4c5ae69ec41fc48f3db514b93014c 100644 (file)
--- a/builtin/fast-export.c
+++ b/builtin/fast-export.c
@@ -126,10 +126,15 @@ struct anonymized_entry {
 };
 
 static int anonymized_entry_cmp(const void *unused_cmp_data,
-                               const void *va, const void *vb,
+                               const struct hashmap_entry *eptr,
+                               const struct hashmap_entry *entry_or_key,
                                const void *unused_keydata)
 {
-       const struct anonymized_entry *a = va, *b = vb;
+       const struct anonymized_entry *a, *b;
+
+       a = container_of(eptr, const struct anonymized_entry, hash);
+       b = container_of(entry_or_key, const struct anonymized_entry, hash);
+
        return a->orig_len != b->orig_len ||
                memcmp(a->orig, b->orig, a->orig_len);
 }

diff --git a/builtin/fetch.c b/builtin/fetch.c
index d06f2b98aae7b1da6d4d2fbb7221b3fc13a69312..476c2416e3b846d0f82b45e9da46c7deb85fe256 100644 (file)
--- a/builtin/fetch.c
+++ b/builtin/fetch.c
@@ -258,13 +258,14 @@ struct refname_hash_entry {
 };
 
 static int refname_hash_entry_cmp(const void *hashmap_cmp_fn_data,
-                                 const void *e1_,
-                                 const void *e2_,
+                                 const struct hashmap_entry *eptr,
+                                 const struct hashmap_entry *entry_or_key,
                                  const void *keydata)
 {
-       const struct refname_hash_entry *e1 = e1_;
-       const struct refname_hash_entry *e2 = e2_;
+       const struct refname_hash_entry *e1, *e2;
 
+       e1 = container_of(eptr, const struct refname_hash_entry, ent);
+       e2 = container_of(entry_or_key, const struct refname_hash_entry, ent);
        return strcmp(e1->refname, keydata ? keydata : e2->refname);
 }
 

diff --git a/config.c b/config.c
index 4952d1cc9ea3a6e7b6168d889ba38a22a6b40506..33043ee73c4128dacc947edfa103ffb76b70b852 100644 (file)
--- a/config.c
+++ b/config.c
@@ -1914,12 +1914,14 @@ static int configset_add_value(struct config_set *cs, const char *key, const cha
 }
 
 static int config_set_element_cmp(const void *unused_cmp_data,
-                                 const void *entry,
-                                 const void *entry_or_key,
+                                 const struct hashmap_entry *eptr,
+                                 const struct hashmap_entry *entry_or_key,
                                  const void *unused_keydata)
 {
-       const struct config_set_element *e1 = entry;
-       const struct config_set_element *e2 = entry_or_key;
+       const struct config_set_element *e1, *e2;
+
+       e1 = container_of(eptr, const struct config_set_element, ent);
+       e2 = container_of(entry_or_key, const struct config_set_element, ent);
 
        return strcmp(e1->key, e2->key);
 }

diff --git a/diff.c b/diff.c
index 66cdf4e9ca4f18530cb529313216d3b709fb0b77..5eaf689fccf39bc6f69de5efc1e09d244860b63f 100644 (file)
--- a/diff.c
+++ b/diff.c
@@ -933,16 +933,18 @@ static int cmp_in_block_with_wsd(const struct diff_options *o,
 }
 
 static int moved_entry_cmp(const void *hashmap_cmp_fn_data,
-                          const void *entry,
-                          const void *entry_or_key,
+                          const struct hashmap_entry *eptr,
+                          const struct hashmap_entry *entry_or_key,
                           const void *keydata)
 {
        const struct diff_options *diffopt = hashmap_cmp_fn_data;
-       const struct moved_entry *a = entry;
-       const struct moved_entry *b = entry_or_key;
+       const struct moved_entry *a, *b;
        unsigned flags = diffopt->color_moved_ws_handling
                         & XDF_WHITESPACE_FLAGS;
 
+       a = container_of(eptr, const struct moved_entry, ent);
+       b = container_of(entry_or_key, const struct moved_entry, ent);
+
        if (diffopt->color_moved_ws_handling &
            COLOR_MOVED_WS_ALLOW_INDENTATION_CHANGE)
                /*
@@ -1019,7 +1021,7 @@ static void pmb_advance_or_null(struct diff_options *o,
                struct moved_entry *prev = pmb[i].match;
                struct moved_entry *cur = (prev && prev->next_line) ?
                                prev->next_line : NULL;
-               if (cur && !hm->cmpfn(o, cur, match, NULL)) {
+               if (cur && !hm->cmpfn(o, &cur->ent, &match->ent, NULL)) {
                        pmb[i].match = cur;
                } else {
                        pmb[i].match = NULL;

diff --git a/hashmap.c b/hashmap.c
index 5662bee10a3189291617cda6d1b3987fe27d4055..64f6accfff924d202d1b71d563ea6becab7935fe 100644 (file)
--- a/hashmap.c
+++ b/hashmap.c
@@ -140,8 +140,8 @@ static inline struct hashmap_entry **find_entry_ptr(const struct hashmap *map,
 }
 
 static int always_equal(const void *unused_cmp_data,
-                       const void *unused1,
-                       const void *unused2,
+                       const struct hashmap_entry *unused1,
+                       const struct hashmap_entry *unused2,
                        const void *unused_keydata)
 {
        return 0;
@@ -279,10 +279,15 @@ struct pool_entry {
 };
 
 static int pool_entry_cmp(const void *unused_cmp_data,
-                         const struct pool_entry *e1,
-                         const struct pool_entry *e2,
-                         const unsigned char *keydata)
+                         const struct hashmap_entry *eptr,
+                         const struct hashmap_entry *entry_or_key,
+                         const void *keydata)
 {
+       const struct pool_entry *e1, *e2;
+
+       e1 = container_of(eptr, const struct pool_entry, ent);
+       e2 = container_of(entry_or_key, const struct pool_entry, ent);
+
        return e1->data != keydata &&
               (e1->len != e2->len || memcmp(e1->data, keydata, e1->len));
 }
@@ -294,7 +299,7 @@ const void *memintern(const void *data, size_t len)
 
        /* initialize string pool hashmap */
        if (!map.tablesize)
-               hashmap_init(&map, (hashmap_cmp_fn) pool_entry_cmp, NULL, 0);
+               hashmap_init(&map, pool_entry_cmp, NULL, 0);
 
        /* lookup interned string in pool */
        hashmap_entry_init(&key.ent, memhash(data, len));

diff --git a/hashmap.h b/hashmap.h
index 82ddb0ef410ffaf4f10230a784ae3ae4def927c1..8f5c163d567d2a915404d00c18edb87842463b52 100644 (file)
--- a/hashmap.h
+++ b/hashmap.h
@@ -21,12 +21,16 @@
  * #define COMPARE_VALUE 1
  *
  * static int long2string_cmp(const void *hashmap_cmp_fn_data,
- *                            const struct long2string *e1,
- *                            const struct long2string *e2,
+ *                            const struct hashmap_entry *eptr,
+ *                            const struct hashmap_entry *entry_or_key,
  *                            const void *keydata)
  * {
  *     const char *string = keydata;
  *     unsigned flags = *(unsigned *)hashmap_cmp_fn_data;
+ *     const struct long2string *e1, *e2;
+ *
+ *     e1 = container_of(eptr, const struct long2string, ent);
+ *     e2 = container_of(entry_or_key, const struct long2string, ent);
  *
  *     if (flags & COMPARE_VALUE)
  *         return e1->key != e2->key ||
@@ -41,7 +45,7 @@
  *     char value[255], action[32];
  *     unsigned flags = 0;
  *
- *     hashmap_init(&map, (hashmap_cmp_fn) long2string_cmp, &flags, 0);
+ *     hashmap_init(&map, long2string_cmp, &flags, 0);
  *
  *     while (scanf("%s %ld %s", action, &key, value)) {
  *
@@ -172,7 +176,8 @@ struct hashmap_entry {
  * The `hashmap_cmp_fn_data` entry is the pointer given in the init function.
  */
 typedef int (*hashmap_cmp_fn)(const void *hashmap_cmp_fn_data,
-                             const void *entry, const void *entry_or_key,
+                             const struct hashmap_entry *entry,
+                             const struct hashmap_entry *entry_or_key,
                              const void *keydata);
 
 /*

diff --git a/merge-recursive.c b/merge-recursive.c
index 8274828c4df6af2bfcaa2048fce58a2770517304..b06e9f7f0b57f4e595905f9ad4f300f0184c3be9 100644 (file)
--- a/merge-recursive.c
+++ b/merge-recursive.c
@@ -35,14 +35,16 @@ struct path_hashmap_entry {
 };
 
 static int path_hashmap_cmp(const void *cmp_data,
-                           const void *entry,
-                           const void *entry_or_key,
+                           const struct hashmap_entry *eptr,
+                           const struct hashmap_entry *entry_or_key,
                            const void *keydata)
 {
-       const struct path_hashmap_entry *a = entry;
-       const struct path_hashmap_entry *b = entry_or_key;
+       const struct path_hashmap_entry *a, *b;
        const char *key = keydata;
 
+       a = container_of(eptr, const struct path_hashmap_entry, e);
+       b = container_of(entry_or_key, const struct path_hashmap_entry, e);
+
        if (ignore_case)
                return strcasecmp(a->path, key ? key : b->path);
        else
@@ -68,12 +70,14 @@ static struct dir_rename_entry *dir_rename_find_entry(struct hashmap *hashmap,
 }
 
 static int dir_rename_cmp(const void *unused_cmp_data,
-                         const void *entry,
-                         const void *entry_or_key,
+                         const struct hashmap_entry *eptr,
+                         const struct hashmap_entry *entry_or_key,
                          const void *unused_keydata)
 {
-       const struct dir_rename_entry *e1 = entry;
-       const struct dir_rename_entry *e2 = entry_or_key;
+       const struct dir_rename_entry *e1, *e2;
+
+       e1 = container_of(eptr, const struct dir_rename_entry, ent);
+       e2 = container_of(entry_or_key, const struct dir_rename_entry, ent);
 
        return strcmp(e1->dir, e2->dir);
 }
@@ -104,17 +108,22 @@ static struct collision_entry *collision_find_entry(struct hashmap *hashmap,
                                struct collision_entry, ent);
 }
 
-static int collision_cmp(void *unused_cmp_data,
-                        const struct collision_entry *e1,
-                        const struct collision_entry *e2,
+static int collision_cmp(const void *unused_cmp_data,
+                        const struct hashmap_entry *eptr,
+                        const struct hashmap_entry *entry_or_key,
                         const void *unused_keydata)
 {
+       const struct collision_entry *e1, *e2;
+
+       e1 = container_of(eptr, const struct collision_entry, ent);
+       e2 = container_of(entry_or_key, const struct collision_entry, ent);
+
        return strcmp(e1->target_file, e2->target_file);
 }
 
 static void collision_init(struct hashmap *map)
 {
-       hashmap_init(map, (hashmap_cmp_fn) collision_cmp, NULL, 0);
+       hashmap_init(map, collision_cmp, NULL, 0);
 }
 
 static void flush_output(struct merge_options *opt)

diff --git a/name-hash.c b/name-hash.c
index aa8253ddd554208c4923c5c83a6330fc5790cbc1..85a1ce982c2f3fd2590ac7ee1c803d8c25a41c67 100644 (file)
--- a/name-hash.c
+++ b/name-hash.c
@@ -17,14 +17,16 @@ struct dir_entry {
 };
 
 static int dir_entry_cmp(const void *unused_cmp_data,
-                        const void *entry,
-                        const void *entry_or_key,
+                        const struct hashmap_entry *eptr,
+                        const struct hashmap_entry *entry_or_key,
                         const void *keydata)
 {
-       const struct dir_entry *e1 = entry;
-       const struct dir_entry *e2 = entry_or_key;
+       const struct dir_entry *e1, *e2;
        const char *name = keydata;
 
+       e1 = container_of(eptr, const struct dir_entry, ent);
+       e2 = container_of(entry_or_key, const struct dir_entry, ent);
+
        return e1->namelen != e2->namelen || strncasecmp(e1->name,
                        name ? name : e2->name, e1->namelen);
 }
@@ -115,12 +117,15 @@ static void hash_index_entry(struct index_state *istate, struct cache_entry *ce)
 }
 
 static int cache_entry_cmp(const void *unused_cmp_data,
-                          const void *entry,
-                          const void *entry_or_key,
+                          const struct hashmap_entry *eptr,
+                          const struct hashmap_entry *entry_or_key,
                           const void *remove)
 {
-       const struct cache_entry *ce1 = entry;
-       const struct cache_entry *ce2 = entry_or_key;
+       const struct cache_entry *ce1, *ce2;
+
+       ce1 = container_of(eptr, const struct cache_entry, ent);
+       ce2 = container_of(entry_or_key, const struct cache_entry, ent);
+
        /*
         * For remove_name_hash, find the exact entry (pointer equality); for
         * index_file_exists, find all entries with matching hash code and

diff --git a/oidmap.c b/oidmap.c
index cd22b3a8bf4b745253c2539867611de3e455acd6..4942599391096d0ac016f49ebb081015440327d1 100644 (file)
--- a/oidmap.c
+++ b/oidmap.c
@@ -2,14 +2,18 @@
 #include "oidmap.h"
 
 static int oidmap_neq(const void *hashmap_cmp_fn_data,
-                     const void *entry, const void *entry_or_key,
+                     const struct hashmap_entry *e1,
+                     const struct hashmap_entry *e2,
                      const void *keydata)
 {
-       const struct oidmap_entry *entry_ = entry;
+       const struct oidmap_entry *a, *b;
+
+       a = container_of(e1, const struct oidmap_entry, internal_entry);
+       b = container_of(e2, const struct oidmap_entry, internal_entry);
+
        if (keydata)
-               return !oideq(&entry_->oid, (const struct object_id *) keydata);
-       return !oideq(&entry_->oid,
-                     &((const struct oidmap_entry *) entry_or_key)->oid);
+               return !oideq(&a->oid, (const struct object_id *) keydata);
+       return !oideq(&a->oid, &b->oid);
 }
 
 void oidmap_init(struct oidmap *map, size_t initial_size)

diff --git a/packfile.c b/packfile.c
index f2aa34bb499297fdeb5fb0ca995a2042fc6d78c3..675d5f22879b39e386299c6b4b93b54b4a64c02d 100644 (file)
--- a/packfile.c
+++ b/packfile.c
@@ -1401,11 +1401,16 @@ static int delta_base_cache_key_eq(const struct delta_base_cache_key *a,
 }
 
 static int delta_base_cache_hash_cmp(const void *unused_cmp_data,
-                                    const void *va, const void *vb,
+                                    const struct hashmap_entry *va,
+                                    const struct hashmap_entry *vb,
                                     const void *vkey)
 {
-       const struct delta_base_cache_entry *a = va, *b = vb;
+       const struct delta_base_cache_entry *a, *b;
        const struct delta_base_cache_key *key = vkey;
+
+       a = container_of(va, const struct delta_base_cache_entry, ent);
+       b = container_of(vb, const struct delta_base_cache_entry, ent);
+
        if (key)
                return !delta_base_cache_key_eq(&a->key, key);
        else

diff --git a/patch-ids.c b/patch-ids.c
index 176c47d9673b07842a2dfe21dbed4d81ebd62a26..75f8c9f1a11e05e8cd6145241178d3b0cae62e40 100644 (file)
--- a/patch-ids.c
+++ b/patch-ids.c
@@ -36,14 +36,16 @@ int commit_patch_id(struct commit *commit, struct diff_options *options,
  * any significance; only that it is non-zero matters.
  */
 static int patch_id_neq(const void *cmpfn_data,
-                       const void *entry,
-                       const void *entry_or_key,
+                       const struct hashmap_entry *eptr,
+                       const struct hashmap_entry *entry_or_key,
                        const void *unused_keydata)
 {
        /* NEEDSWORK: const correctness? */
        struct diff_options *opt = (void *)cmpfn_data;
-       struct patch_id *a = (void *)entry;
-       struct patch_id *b = (void *)entry_or_key;
+       struct patch_id *a, *b;
+
+       a = container_of(eptr, struct patch_id, ent);
+       b = container_of(entry_or_key, struct patch_id, ent);
 
        if (is_null_oid(&a->patch_id) &&
            commit_patch_id(a->commit, opt, &a->patch_id, 0, 0))

diff --git a/ref-filter.c b/ref-filter.c
index 9999426914773af314a0c6c72016a3313ee91ee2..4613df8826818380f2b2554fce7fe409c0de0c56 100644 (file)
--- a/ref-filter.c
+++ b/ref-filter.c
@@ -84,12 +84,15 @@ struct ref_to_worktree_entry {
 };
 
 static int ref_to_worktree_map_cmpfnc(const void *unused_lookupdata,
-                                     const void *existing_hashmap_entry_to_test,
-                                     const void *key,
+                                     const struct hashmap_entry *eptr,
+                                     const struct hashmap_entry *kptr,
                                      const void *keydata_aka_refname)
 {
-       const struct ref_to_worktree_entry *e = existing_hashmap_entry_to_test;
-       const struct ref_to_worktree_entry *k = key;
+       const struct ref_to_worktree_entry *e, *k;
+
+       e = container_of(eptr, const struct ref_to_worktree_entry, ent);
+       k = container_of(kptr, const struct ref_to_worktree_entry, ent);
+
        return strcmp(e->wt->head_ref,
                keydata_aka_refname ? keydata_aka_refname : k->wt->head_ref);
 }

diff --git a/refs.c b/refs.c
index 43a95105f18d4c7ea2f010fd053a3c0243f63adc..2d3eb40f3974aa3eb129f02c8aae3ea49bc2f82c 100644 (file)
--- a/refs.c
+++ b/refs.c
@@ -1781,11 +1781,16 @@ struct ref_store_hash_entry
 };
 
 static int ref_store_hash_cmp(const void *unused_cmp_data,
-                             const void *entry, const void *entry_or_key,
+                             const struct hashmap_entry *eptr,
+                             const struct hashmap_entry *entry_or_key,
                              const void *keydata)
 {
-       const struct ref_store_hash_entry *e1 = entry, *e2 = entry_or_key;
-       const char *name = keydata ? keydata : e2->name;
+       const struct ref_store_hash_entry *e1, *e2;
+       const char *name;
+
+       e1 = container_of(eptr, const struct ref_store_hash_entry, ent);
+       e2 = container_of(entry_or_key, const struct ref_store_hash_entry, ent);
+       name = keydata ? keydata : e2->name;
 
        return strcmp(e1->name, name);
 }

diff --git a/remote.c b/remote.c
index ed95ae6ed6697f64c16c6ca27cf938e9bb943d1b..fa9cadcfbd1844002b4e77af417d61c5844f8a4f 100644 (file)
--- a/remote.c
+++ b/remote.c
@@ -111,14 +111,16 @@ struct remotes_hash_key {
 };
 
 static int remotes_hash_cmp(const void *unused_cmp_data,
-                           const void *entry,
-                           const void *entry_or_key,
+                           const struct hashmap_entry *eptr,
+                           const struct hashmap_entry *entry_or_key,
                            const void *keydata)
 {
-       const struct remote *a = entry;
-       const struct remote *b = entry_or_key;
+       const struct remote *a, *b;
        const struct remotes_hash_key *key = keydata;
 
+       a = container_of(eptr, const struct remote, ent);
+       b = container_of(entry_or_key, const struct remote, ent);
+
        if (key)
                return strncmp(a->name, key->str, key->len) || a->name[key->len];
        else

diff --git a/revision.c b/revision.c
index d5f534209d8ede4c9f4d1fc6edff1e2db26b0b81..f32fbc5e2ebb6b53f7435239faa9d056d213e930 100644 (file)
--- a/revision.c
+++ b/revision.c
@@ -107,16 +107,21 @@ struct path_and_oids_entry {
 };
 
 static int path_and_oids_cmp(const void *hashmap_cmp_fn_data,
-                            const struct path_and_oids_entry *e1,
-                            const struct path_and_oids_entry *e2,
+                            const struct hashmap_entry *eptr,
+                            const struct hashmap_entry *entry_or_key,
                             const void *keydata)
 {
+       const struct path_and_oids_entry *e1, *e2;
+
+       e1 = container_of(eptr, const struct path_and_oids_entry, ent);
+       e2 = container_of(entry_or_key, const struct path_and_oids_entry, ent);
+
        return strcmp(e1->path, e2->path);
 }
 
 static void paths_and_oids_init(struct hashmap *map)
 {
-       hashmap_init(map, (hashmap_cmp_fn) path_and_oids_cmp, NULL, 0);
+       hashmap_init(map, path_and_oids_cmp, NULL, 0);
 }
 
 static void paths_and_oids_clear(struct hashmap *map)

diff --git a/sequencer.c b/sequencer.c
index aea2cb12cc971b892aece12342447b1111674190..b3e7319b5547d7a14089e621f693b6cac2a356a4 100644 (file)
--- a/sequencer.c
+++ b/sequencer.c
@@ -4440,9 +4440,14 @@ struct labels_entry {
        char label[FLEX_ARRAY];
 };
 
-static int labels_cmp(const void *fndata, const struct labels_entry *a,
-                     const struct labels_entry *b, const void *key)
+static int labels_cmp(const void *fndata, const struct hashmap_entry *eptr,
+                     const struct hashmap_entry *entry_or_key, const void *key)
 {
+       const struct labels_entry *a, *b;
+
+       a = container_of(eptr, const struct labels_entry, entry);
+       b = container_of(entry_or_key, const struct labels_entry, entry);
+
        return key ? strcmp(a->label, key) : strcmp(a->label, b->label);
 }
 
@@ -4573,7 +4578,7 @@ static int make_script_with_merges(struct pretty_print_context *pp,
 
        oidmap_init(&commit2todo, 0);
        oidmap_init(&state.commit2label, 0);
-       hashmap_init(&state.labels, (hashmap_cmp_fn) labels_cmp, NULL, 0);
+       hashmap_init(&state.labels, labels_cmp, NULL, 0);
        strbuf_init(&state.buf, 32);
 
        if (revs->cmdline.nr && (revs->cmdline.rev[0].flags & BOTTOM)) {
@@ -5138,9 +5143,15 @@ struct subject2item_entry {
 };
 
 static int subject2item_cmp(const void *fndata,
-                           const struct subject2item_entry *a,
-                           const struct subject2item_entry *b, const void *key)
+                           const struct hashmap_entry *eptr,
+                           const struct hashmap_entry *entry_or_key,
+                           const void *key)
 {
+       const struct subject2item_entry *a, *b;
+
+       a = container_of(eptr, const struct subject2item_entry, entry);
+       b = container_of(entry_or_key, const struct subject2item_entry, entry);
+
        return key ? strcmp(a->subject, key) : strcmp(a->subject, b->subject);
 }
 
@@ -5173,8 +5184,7 @@ int todo_list_rearrange_squash(struct todo_list *todo_list)
         * In that case, last[i] will indicate the index of the latest item to
         * be moved to appear after the i'th.
         */
-       hashmap_init(&subject2item, (hashmap_cmp_fn) subject2item_cmp,
-                    NULL, todo_list->nr);
+       hashmap_init(&subject2item, subject2item_cmp, NULL, todo_list->nr);
        ALLOC_ARRAY(next, todo_list->nr);
        ALLOC_ARRAY(tail, todo_list->nr);
        ALLOC_ARRAY(subjects, todo_list->nr);

diff --git a/sub-process.c b/sub-process.c
index f2fcc16c3ec57dd71eece34af13b597d58a56e90..ad94f7266544a0aab830e352805257025b6af744 100644 (file)
--- a/sub-process.c
+++ b/sub-process.c
@@ -6,12 +6,14 @@
 #include "pkt-line.h"
 
 int cmd2process_cmp(const void *unused_cmp_data,
-                   const void *entry,
-                   const void *entry_or_key,
+                   const struct hashmap_entry *eptr,
+                   const struct hashmap_entry *entry_or_key,
                    const void *unused_keydata)
 {
-       const struct subprocess_entry *e1 = entry;
-       const struct subprocess_entry *e2 = entry_or_key;
+       const struct subprocess_entry *e1, *e2;
+
+       e1 = container_of(eptr, const struct subprocess_entry, ent);
+       e2 = container_of(entry_or_key, const struct subprocess_entry, ent);
 
        return strcmp(e1->cmd, e2->cmd);
 }

diff --git a/sub-process.h b/sub-process.h
index 5c182fad98539eecd1b23edadebf369eb21f353b..0d12708b8cc921a86e83cae6f194dfbaeeea68e4 100644 (file)
--- a/sub-process.h
+++ b/sub-process.h
@@ -43,8 +43,8 @@ struct subprocess_capability {
 
 /* Function to test two subprocess hashmap entries for equality. */
 int cmd2process_cmp(const void *unused_cmp_data,
-                   const void *e1,
-                   const void *e2,
+                   const struct hashmap_entry *e,
+                   const struct hashmap_entry *entry_or_key,
                    const void *unused_keydata);
 
 /*

diff --git a/submodule-config.c b/submodule-config.c
index b03188478991b015f2de028cfaee36c15b5d2a13..5463729ab87b1847f414e90705cc0100b7cd998d 100644 (file)
--- a/submodule-config.c
+++ b/submodule-config.c
@@ -38,24 +38,28 @@ enum lookup_type {
 };
 
 static int config_path_cmp(const void *unused_cmp_data,
-                          const void *entry,
-                          const void *entry_or_key,
+                          const struct hashmap_entry *eptr,
+                          const struct hashmap_entry *entry_or_key,
                           const void *unused_keydata)
 {
-       const struct submodule_entry *a = entry;
-       const struct submodule_entry *b = entry_or_key;
+       const struct submodule_entry *a, *b;
+
+       a = container_of(eptr, const struct submodule_entry, ent);
+       b = container_of(entry_or_key, const struct submodule_entry, ent);
 
        return strcmp(a->config->path, b->config->path) ||
               !oideq(&a->config->gitmodules_oid, &b->config->gitmodules_oid);
 }
 
 static int config_name_cmp(const void *unused_cmp_data,
-                          const void *entry,
-                          const void *entry_or_key,
+                          const struct hashmap_entry *eptr,
+                          const struct hashmap_entry *entry_or_key,
                           const void *unused_keydata)
 {
-       const struct submodule_entry *a = entry;
-       const struct submodule_entry *b = entry_or_key;
+       const struct submodule_entry *a, *b;
+
+       a = container_of(eptr, const struct submodule_entry, ent);
+       b = container_of(entry_or_key, const struct submodule_entry, ent);
 
        return strcmp(a->config->name, b->config->name) ||
               !oideq(&a->config->gitmodules_oid, &b->config->gitmodules_oid);

diff --git a/t/helper/test-hashmap.c b/t/helper/test-hashmap.c
index e82cbfdee272a8573c625cf5417518a7885497f7..56846da64c90fb2080bf7ded13c0f845ed9baa54 100644 (file)
--- a/t/helper/test-hashmap.c
+++ b/t/helper/test-hashmap.c
@@ -16,15 +16,17 @@ static const char *get_value(const struct test_entry *e)
 }
 
 static int test_entry_cmp(const void *cmp_data,
-                         const void *entry,
-                         const void *entry_or_key,
+                         const struct hashmap_entry *eptr,
+                         const struct hashmap_entry *entry_or_key,
                          const void *keydata)
 {
        const int ignore_case = cmp_data ? *((int *)cmp_data) : 0;
-       const struct test_entry *e1 = entry;
-       const struct test_entry *e2 = entry_or_key;
+       const struct test_entry *e1, *e2;
        const char *key = keydata;
 
+       e1 = container_of(eptr, const struct test_entry, ent);
+       e2 = container_of(entry_or_key, const struct test_entry, ent);
+
        if (ignore_case)
                return strcasecmp(e1->key, key ? key : e2->key);
        else