Use new HASHMAP_INIT macro to simplify hashmap initialization

Now that hashamp has lazy initialization and a HASHMAP_INIT macro,
hashmaps allocated on the stack can be initialized without a call to
hashmap_init() and in some cases makes the code a bit shorter.  Convert
some callsites over to take advantage of this.

Signed-off-by: Elijah Newren <newren@gmail.com>
Signed-off-by: Junio C Hamano <gitster@pobox.com>

diff --git a/attr.c b/attr.c
index a826b2ef1fabc8d4078d760fe3421d2a9cbbf2b2..4ef85d668b54960d692b6bae127920c10045c4ca 100644 (file)
--- a/attr.c
+++ b/attr.c
@@ -52,13 +52,6 @@ static inline void hashmap_unlock(struct attr_hashmap *map)
        pthread_mutex_unlock(&map->mutex);
 }
 
-/*
- * The global dictionary of all interned attributes.  This
- * is a singleton object which is shared between threads.
- * Access to this dictionary must be surrounded with a mutex.
- */
-static struct attr_hashmap g_attr_hashmap;
-
 /* The container for objects stored in "struct attr_hashmap" */
 struct attr_hash_entry {
        struct hashmap_entry ent;
@@ -80,11 +73,14 @@ static int attr_hash_entry_cmp(const void *unused_cmp_data,
        return (a->keylen != b->keylen) || strncmp(a->key, b->key, a->keylen);
 }
 
-/* Initialize an 'attr_hashmap' object */
-static void attr_hashmap_init(struct attr_hashmap *map)
-{
-       hashmap_init(&map->map, attr_hash_entry_cmp, NULL, 0);
-}
+/*
+ * The global dictionary of all interned attributes.  This
+ * is a singleton object which is shared between threads.
+ * Access to this dictionary must be surrounded with a mutex.
+ */
+static struct attr_hashmap g_attr_hashmap = {
+       HASHMAP_INIT(attr_hash_entry_cmp, NULL)
+};
 
 /*
  * Retrieve the 'value' stored in a hashmap given the provided 'key'.
@@ -96,9 +92,6 @@ static void *attr_hashmap_get(struct attr_hashmap *map,
        struct attr_hash_entry k;
        struct attr_hash_entry *e;
 
-       if (!map->map.tablesize)
-               attr_hashmap_init(map);
-
        hashmap_entry_init(&k.ent, memhash(key, keylen));
        k.key = key;
        k.keylen = keylen;
@@ -114,9 +107,6 @@ static void attr_hashmap_add(struct attr_hashmap *map,
 {
        struct attr_hash_entry *e;
 
-       if (!map->map.tablesize)
-               attr_hashmap_init(map);
-
        e = xmalloc(sizeof(struct attr_hash_entry));
        hashmap_entry_init(&e->ent, memhash(key, keylen));
        e->key = key;

diff --git a/bloom.c b/bloom.c
index 719c313a1c080abdce292dc98ba05ecf11c952f8..b176f28f531eccc412204faa5f4da9fa53164081 100644 (file)
--- a/bloom.c
+++ b/bloom.c
@@ -229,10 +229,9 @@ struct bloom_filter *get_or_compute_bloom_filter(struct repository *r,
        diffcore_std(&diffopt);
 
        if (diff_queued_diff.nr <= settings->max_changed_paths) {
-               struct hashmap pathmap;
+               struct hashmap pathmap = HASHMAP_INIT(pathmap_cmp, NULL);
                struct pathmap_hash_entry *e;
                struct hashmap_iter iter;
-               hashmap_init(&pathmap, pathmap_cmp, NULL, 0);
 
                for (i = 0; i < diff_queued_diff.nr; i++) {
                        const char *path = diff_queued_diff.queue[i]->two->path;

diff --git a/builtin/difftool.c b/builtin/difftool.c
index 7ac432b88193e7468048821a372dae8c2a81919a..6e18e623fddfbfb33a3de9f4df8cabbbc048ed51 100644 (file)
--- a/builtin/difftool.c
+++ b/builtin/difftool.c
@@ -342,7 +342,10 @@ static int run_dir_diff(const char *extcmd, int symlinks, const char *prefix,
        const char *workdir, *tmp;
        int ret = 0, i;
        FILE *fp;
-       struct hashmap working_tree_dups, submodules, symlinks2;
+       struct hashmap working_tree_dups = HASHMAP_INIT(working_tree_entry_cmp,
+                                                       NULL);
+       struct hashmap submodules = HASHMAP_INIT(pair_cmp, NULL);
+       struct hashmap symlinks2 = HASHMAP_INIT(pair_cmp, NULL);
        struct hashmap_iter iter;
        struct pair_entry *entry;
        struct index_state wtindex;
@@ -383,10 +386,6 @@ static int run_dir_diff(const char *extcmd, int symlinks, const char *prefix,
        rdir_len = rdir.len;
        wtdir_len = wtdir.len;
 
-       hashmap_init(&working_tree_dups, working_tree_entry_cmp, NULL, 0);
-       hashmap_init(&submodules, pair_cmp, NULL, 0);
-       hashmap_init(&symlinks2, pair_cmp, NULL, 0);
-
        child.no_stdin = 1;
        child.git_cmd = 1;
        child.use_shell = 0;

diff --git a/range-diff.c b/range-diff.c
index befeecae448844ca086da07dee38e384d509e692..b9950f10c8c486b16a2b916b0898d88c8d82fb59 100644 (file)
--- a/range-diff.c
+++ b/range-diff.c
@@ -232,11 +232,9 @@ static int patch_util_cmp(const void *dummy, const struct patch_util *a,
 
 static void find_exact_matches(struct string_list *a, struct string_list *b)
 {
-       struct hashmap map;
+       struct hashmap map = HASHMAP_INIT((hashmap_cmp_fn)patch_util_cmp, NULL);
        int i;
 
-       hashmap_init(&map, (hashmap_cmp_fn)patch_util_cmp, NULL, 0);
-
        /* First, add the patches of a to a hash map */
        for (i = 0; i < a->nr; i++) {
                struct patch_util *util = a->items[i].util;

diff --git a/revision.c b/revision.c
index f27649d45d1dde74e67d75310affd4d78f504bc5..c6e169e3eb3721b3690a6f822f5978c1718cb673 100644 (file)
--- a/revision.c
+++ b/revision.c
@@ -124,11 +124,6 @@ static int path_and_oids_cmp(const void *hashmap_cmp_fn_data,
        return strcmp(e1->path, e2->path);
 }
 
-static void paths_and_oids_init(struct hashmap *map)
-{
-       hashmap_init(map, path_and_oids_cmp, NULL, 0);
-}
-
 static void paths_and_oids_clear(struct hashmap *map)
 {
        struct hashmap_iter iter;
@@ -213,7 +208,7 @@ void mark_trees_uninteresting_sparse(struct repository *r,
                                     struct oidset *trees)
 {
        unsigned has_interesting = 0, has_uninteresting = 0;
-       struct hashmap map;
+       struct hashmap map = HASHMAP_INIT(path_and_oids_cmp, NULL);
        struct hashmap_iter map_iter;
        struct path_and_oids_entry *entry;
        struct object_id *oid;
@@ -237,8 +232,6 @@ void mark_trees_uninteresting_sparse(struct repository *r,
        if (!has_uninteresting || !has_interesting)
                return;
 
-       paths_and_oids_init(&map);
-
        oidset_iter_init(trees, &iter);
        while ((oid = oidset_iter_next(&iter))) {
                struct tree *tree = lookup_tree(r, oid);

diff --git a/t/helper/test-hashmap.c b/t/helper/test-hashmap.c
index 2475663b49cefc08fe6a9d9d1c1cb3f7a551cc24..36ff07bd4beaefabe5f42d119b0eac26cf3ae8d9 100644 (file)
--- a/t/helper/test-hashmap.c
+++ b/t/helper/test-hashmap.c
@@ -151,12 +151,11 @@ static void perf_hashmap(unsigned int method, unsigned int rounds)
 int cmd__hashmap(int argc, const char **argv)
 {
        struct strbuf line = STRBUF_INIT;
-       struct hashmap map;
        int icase;
+       struct hashmap map = HASHMAP_INIT(test_entry_cmp, &icase);
 
        /* init hash map */
        icase = argc > 1 && !strcmp("ignorecase", argv[1]);
-       hashmap_init(&map, test_entry_cmp, &icase, 0);
 
        /* process commands from stdin */
        while (strbuf_getline(&line, stdin) != EOF) {