hashmap_add takes "struct hashmap_entry *"

Eric Wong · gitster · commit b94e5c1df674 · 2019-10-07T10:20:10.000+09:00
This is less error-prone than "void *" as the compiler now
detects invalid types being passed.

Signed-off-by: Eric Wong &lt;e@80x24.org&gt;
Reviewed-by: Derrick Stolee &lt;stolee@gmail.com&gt;
Signed-off-by: Junio C Hamano &lt;gitster@pobox.com&gt;
diff --git a/attr.c b/attr.c
@@ -122,7 +122,7 @@ static void attr_hashmap_add(struct attr_hashmap *map,
 	e->keylen = keylen;
 	e->value = value;
 
-	hashmap_add(&map->map, e);
+	hashmap_add(&map->map, &e->ent);
 }
 
 struct all_attrs_item {
diff --git a/blame.c b/blame.c
@@ -424,7 +424,7 @@ static void get_fingerprint(struct fingerprint *result,
 			found_entry->count += 1;
 		} else {
 			entry->count = 1;
-			hashmap_add(&result->map, entry);
+			hashmap_add(&result->map, &entry->entry);
 			++entry;
 		}
 	}
diff --git a/builtin/describe.c b/builtin/describe.c
@@ -124,7 +124,7 @@ static void add_to_known_names(const char *path,
 			e = xmalloc(sizeof(struct commit_name));
 			oidcpy(&e->peeled, peeled);
 			hashmap_entry_init(&e->entry, oidhash(peeled));
-			hashmap_add(&names, e);
+			hashmap_add(&names, &e->entry);
 			e->path = NULL;
 		}
 		e->tag = tag;
diff --git a/builtin/difftool.c b/builtin/difftool.c
@@ -168,7 +168,7 @@ static void add_left_or_right(struct hashmap *map, const char *path,
 		e = existing;
 	} else {
 		e->left[0] = e->right[0] = '\0';
-		hashmap_add(map, e);
+		hashmap_add(map, &e->entry);
 	}
 	strlcpy(is_right ? e->right : e->left, content, PATH_MAX);
 }
@@ -235,7 +235,7 @@ static void changed_files(struct hashmap *result, const char *index_path,
 		struct path_entry *entry;
 		FLEX_ALLOC_STR(entry, path, buf.buf);
 		hashmap_entry_init(&entry->entry, strhash(buf.buf));
-		hashmap_add(result, entry);
+		hashmap_add(result, &entry->entry);
 	}
 	fclose(fp);
 	if (finish_command(&diff_files))
@@ -466,7 +466,7 @@ static int run_dir_diff(const char *extcmd, int symlinks, const char *prefix,
 				free(entry);
 				continue;
 			}
-			hashmap_add(&working_tree_dups, entry);
+			hashmap_add(&working_tree_dups, &entry->entry);
 
 			if (!use_wt_file(workdir, dst_path, &roid)) {
 				if (checkout_path(rmode, &roid, dst_path,
diff --git a/builtin/fetch.c b/builtin/fetch.c
@@ -278,7 +278,7 @@ static struct refname_hash_entry *refname_hash_add(struct hashmap *map,
 	FLEX_ALLOC_MEM(ent, refname, refname, len);
 	hashmap_entry_init(&ent->ent, strhash(refname));
 	oidcpy(&ent->oid, oid);
-	hashmap_add(map, ent);
+	hashmap_add(map, &ent->ent);
 	return ent;
 }
 
diff --git a/config.c b/config.c
@@ -1885,7 +1885,7 @@ static int configset_add_value(struct config_set *cs, const char *key, const cha
 		hashmap_entry_init(&e->ent, strhash(key));
 		e->key = xstrdup(key);
 		string_list_init(&e->value_list, 1);
-		hashmap_add(&cs->config_hash, e);
+		hashmap_add(&cs->config_hash, &e->ent);
 	}
 	si = string_list_append_nodup(&e->value_list, xstrdup_or_null(value));
 
diff --git a/diff.c b/diff.c
@@ -1003,7 +1003,7 @@ static void add_lines_to_move_detection(struct diff_options *o,
 		if (prev_line && prev_line->es->s == o->emitted_symbols->buf[n].s)
 			prev_line->next_line = key;
 
-		hashmap_add(hm, key);
+		hashmap_add(hm, &key->ent);
 		prev_line = key;
 	}
 }
diff --git a/diffcore-rename.c b/diffcore-rename.c
@@ -330,7 +330,7 @@ static void insert_file_table(struct repository *r,
 	entry->filespec = filespec;
 
 	hashmap_entry_init(&entry->entry, hash_filespec(r, filespec));
-	hashmap_add(table, entry);
+	hashmap_add(table, &entry->entry);
 }
 
 /*
diff --git a/hashmap.c b/hashmap.c
@@ -201,12 +201,12 @@ void *hashmap_get_next(const struct hashmap *map,
 	return NULL;
 }
 
-void hashmap_add(struct hashmap *map, void *entry)
+void hashmap_add(struct hashmap *map, struct hashmap_entry *entry)
 {
 	unsigned int b = bucket(map, entry);
 
 	/* add entry */
-	((struct hashmap_entry *) entry)->next = map->table[b];
+	entry->next = map->table[b];
 	map->table[b] = entry;
 
 	/* fix size and rehash if appropriate */
@@ -302,7 +302,7 @@ const void *memintern(const void *data, size_t len)
 		FLEX_ALLOC_MEM(e, data, data, len);
 		hashmap_entry_init(&e->ent, key.ent.hash);
 		e->len = len;
-		hashmap_add(&map, e);
+		hashmap_add(&map, &e->ent);
 	}
 	return e->data;
 }
diff --git a/hashmap.h b/hashmap.h
@@ -50,7 +50,7 @@
  *             FLEX_ALLOC_STR(e, value, value);
  *             hashmap_entry_init(&e->ent, memhash(&key, sizeof(long)));
  *             e->key = key;
- *             hashmap_add(&map, e);
+ *             hashmap_add(&map, &e->ent);
  *         }
  *
  *         if (!strcmp("print_all_by_key", action)) {
@@ -328,7 +328,7 @@ void *hashmap_get_next(const struct hashmap *map,
  * `map` is the hashmap structure.
  * `entry` is the entry to add.
  */
-void hashmap_add(struct hashmap *map, void *entry);
+void hashmap_add(struct hashmap *map, struct hashmap_entry *entry);
 
 /*
  * Adds or replaces a hashmap entry. If the hashmap contains duplicate
diff --git a/merge-recursive.c b/merge-recursive.c
@@ -455,7 +455,7 @@ static int save_files_dirs(const struct object_id *oid,
 
 	FLEX_ALLOC_MEM(entry, path, base->buf, base->len);
 	hashmap_entry_init(&entry->e, path_hash(entry->path));
-	hashmap_add(&opt->current_file_dir_set, entry);
+	hashmap_add(&opt->current_file_dir_set, &entry->e);
 
 	strbuf_setlen(base, baselen);
 	return (S_ISDIR(mode) ? READ_TREE_RECURSIVE : 0);
@@ -732,7 +732,7 @@ static char *unique_path(struct merge_options *opt, const char *path, const char
 
 	FLEX_ALLOC_MEM(entry, path, newpath.buf, newpath.len);
 	hashmap_entry_init(&entry->e, path_hash(entry->path));
-	hashmap_add(&opt->current_file_dir_set, entry);
+	hashmap_add(&opt->current_file_dir_set, &entry->e);
 	return strbuf_detach(&newpath, NULL);
 }
 
diff --git a/name-hash.c b/name-hash.c
@@ -70,7 +70,7 @@ static struct dir_entry *hash_dir_entry(struct index_state *istate,
 		FLEX_ALLOC_MEM(dir, name, ce->name, namelen);
 		hashmap_entry_init(&dir->ent, memihash(ce->name, namelen));
 		dir->namelen = namelen;
-		hashmap_add(&istate->dir_hash, dir);
+		hashmap_add(&istate->dir_hash, &dir->ent);
 
 		/* recursively add missing parent directories */
 		dir->parent = hash_dir_entry(istate, ce, namelen);
@@ -107,7 +107,7 @@ static void hash_index_entry(struct index_state *istate, struct cache_entry *ce)
 		return;
 	ce->ce_flags |= CE_HASHED;
 	hashmap_entry_init(&ce->ent, memihash(ce->name, ce_namelen(ce)));
-	hashmap_add(&istate->name_hash, ce);
+	hashmap_add(&istate->name_hash, &ce->ent);
 
 	if (ignore_case)
 		add_dir_entry(istate, ce);
@@ -283,7 +283,7 @@ static struct dir_entry *hash_dir_entry_with_parent_and_prefix(
 		hashmap_entry_init(&dir->ent, hash);
 		dir->namelen = prefix->len;
 		dir->parent = parent;
-		hashmap_add(&istate->dir_hash, dir);
+		hashmap_add(&istate->dir_hash, &dir->ent);
 
 		if (parent) {
 			unlock_dir_mutex(lock_nr);
@@ -473,7 +473,7 @@ static void *lazy_name_thread_proc(void *_data)
 		struct cache_entry *ce_k = d->istate->cache[k];
 		ce_k->ce_flags |= CE_HASHED;
 		hashmap_entry_init(&ce_k->ent, d->lazy_entries[k].hash_name);
-		hashmap_add(&d->istate->name_hash, ce_k);
+		hashmap_add(&d->istate->name_hash, &ce_k->ent);
 	}
 
 	return NULL;
diff --git a/packfile.c b/packfile.c
@@ -1488,7 +1488,7 @@ static void add_delta_base_cache(struct packed_git *p, off_t base_offset,
 	if (!delta_base_cache.cmpfn)
 		hashmap_init(&delta_base_cache, delta_base_cache_hash_cmp, NULL, 0);
 	hashmap_entry_init(&ent->ent, pack_entry_hash(p, base_offset));
-	hashmap_add(&delta_base_cache, ent);
+	hashmap_add(&delta_base_cache, &ent->ent);
 }
 
 int packed_object_info(struct repository *r, struct packed_git *p,
diff --git a/patch-ids.c b/patch-ids.c
@@ -116,6 +116,6 @@ struct patch_id *add_commit_patch_id(struct commit *commit,
 		return NULL;
 	}
 
-	hashmap_add(&ids->patches, key);
+	hashmap_add(&ids->patches, &key->ent);
 	return key;
 }
diff --git a/range-diff.c b/range-diff.c
@@ -218,7 +218,7 @@ static void find_exact_matches(struct string_list *a, struct string_list *b)
 		util->patch = a->items[i].string;
 		util->diff = util->patch + util->diff_offset;
 		hashmap_entry_init(&util->e, strhash(util->diff));
-		hashmap_add(&map, util);
+		hashmap_add(&map, &util->e);
 	}
 
 	/* Now try to find exact matches in b */
diff --git a/ref-filter.c b/ref-filter.c
@@ -1568,7 +1568,7 @@ static void populate_worktree_map(struct hashmap *map, struct worktree **worktre
 			hashmap_entry_init(&entry->ent,
 					strhash(worktrees[i]->head_ref));
 
-			hashmap_add(map, entry);
+			hashmap_add(map, &entry->ent);
 		}
 	}
 }
diff --git a/sequencer.c b/sequencer.c
@@ -4539,7 +4539,7 @@ static const char *label_oid(struct object_id *oid, const char *label,
 
 	FLEX_ALLOC_STR(labels_entry, label, label);
 	hashmap_entry_init(&labels_entry->entry, strihash(label));
-	hashmap_add(&state->labels, labels_entry);
+	hashmap_add(&state->labels, &labels_entry->entry);
 
 	FLEX_ALLOC_STR(string_entry, string, label);
 	oidcpy(&string_entry->entry.oid, oid);
diff --git a/sub-process.c b/sub-process.c
@@ -105,7 +105,7 @@ int subprocess_start(struct hashmap *hashmap, struct subprocess_entry *entry, co
 		return err;
 	}
 
-	hashmap_add(hashmap, entry);
+	hashmap_add(hashmap, &entry->ent);
 	return 0;
 }
 
diff --git a/submodule-config.c b/submodule-config.c
@@ -149,7 +149,7 @@ static void cache_add(struct submodule_cache *cache,
 	struct submodule_entry *e = xmalloc(sizeof(*e));
 	hashmap_entry_init(&e->ent, hash);
 	e->config = submodule;
-	hashmap_add(&cache->for_name, e);
+	hashmap_add(&cache->for_name, &e->ent);
 }
 
 static const struct submodule *cache_lookup_path(struct submodule_cache *cache,
diff --git a/t/helper/test-hashmap.c b/t/helper/test-hashmap.c
@@ -104,7 +104,7 @@ static void perf_hashmap(unsigned int method, unsigned int rounds)
 			/* add entries */
 			for (i = 0; i < TEST_SIZE; i++) {
 				hashmap_entry_init(&entries[i]->ent, hashes[i]);
-				hashmap_add(&map, entries[i]);
+				hashmap_add(&map, &entries[i]->ent);
 			}
 
 			hashmap_free(&map, 0);
@@ -117,7 +117,7 @@ static void perf_hashmap(unsigned int method, unsigned int rounds)
 		j = (method & TEST_SPARSE) ? TEST_SIZE / 10 : TEST_SIZE;
 		for (i = 0; i < j; i++) {
 			hashmap_entry_init(&entries[i]->ent, hashes[i]);
-			hashmap_add(&map, entries[i]);
+			hashmap_add(&map, &entries[i]->ent);
 		}
 
 		for (j = 0; j < rounds; j++) {
@@ -179,7 +179,7 @@ int cmd__hashmap(int argc, const char **argv)
 			entry = alloc_test_entry(hash, p1, p2);
 
 			/* add to hashmap */
-			hashmap_add(&map, entry);
+			hashmap_add(&map, &entry->ent);
 
 		} else if (!strcmp("put", cmd) && p1 && p2) {
 

Original file line number	Diff line number	Diff line change
`@@ -122,7 +122,7 @@ static void attr_hashmap_add(struct attr_hashmap *map,`
`122`	`122`	`e->keylen = keylen;`
`123`	`123`	`e->value = value;`
`124`	`124`
`125`		`- hashmap_add(&map->map, e);`
	`125`	`+ hashmap_add(&map->map, &e->ent);`
`126`	`126`	`}`
`127`	`127`
`128`	`128`	`struct all_attrs_item {`
Original file line number	Diff line number	Diff line change
`@@ -424,7 +424,7 @@ static void get_fingerprint(struct fingerprint *result,`
`424`	`424`	`found_entry->count += 1;`
`425`	`425`	`} else {`
`426`	`426`	`entry->count = 1;`
`427`		`- hashmap_add(&result->map, entry);`
	`427`	`+ hashmap_add(&result->map, &entry->entry);`
`428`	`428`	`++entry;`
`429`	`429`	`}`
`430`	`430`	`}`
Original file line number	Diff line number	Diff line change
`@@ -124,7 +124,7 @@ static void add_to_known_names(const char *path,`
`124`	`124`	`e = xmalloc(sizeof(struct commit_name));`
`125`	`125`	`oidcpy(&e->peeled, peeled);`
`126`	`126`	`hashmap_entry_init(&e->entry, oidhash(peeled));`
`127`		`- hashmap_add(&names, e);`
	`127`	`+ hashmap_add(&names, &e->entry);`
`128`	`128`	`e->path = NULL;`
`129`	`129`	`}`
`130`	`130`	`e->tag = tag;`
Original file line number	Diff line number	Diff line change
`@@ -168,7 +168,7 @@ static void add_left_or_right(struct hashmap map, const char path,`
`168`	`168`	`e = existing;`
`169`	`169`	`} else {`
`170`	`170`	`e->left[0] = e->right[0] = '\0';`
`171`		`- hashmap_add(map, e);`
	`171`	`+ hashmap_add(map, &e->entry);`
`172`	`172`	`}`
`173`	`173`	`strlcpy(is_right ? e->right : e->left, content, PATH_MAX);`
`174`	`174`	`}`
`@@ -235,7 +235,7 @@ static void changed_files(struct hashmap result, const char index_path,`
`235`	`235`	`struct path_entry *entry;`
`236`	`236`	`FLEX_ALLOC_STR(entry, path, buf.buf);`
`237`	`237`	`hashmap_entry_init(&entry->entry, strhash(buf.buf));`
`238`		`- hashmap_add(result, entry);`
	`238`	`+ hashmap_add(result, &entry->entry);`
`239`	`239`	`}`
`240`	`240`	`fclose(fp);`
`241`	`241`	`if (finish_command(&diff_files))`
`@@ -466,7 +466,7 @@ static int run_dir_diff(const char extcmd, int symlinks, const char prefix,`
`466`	`466`	`free(entry);`
`467`	`467`	`continue;`
`468`	`468`	`}`
`469`		`- hashmap_add(&working_tree_dups, entry);`
	`469`	`+ hashmap_add(&working_tree_dups, &entry->entry);`
`470`	`470`
`471`	`471`	`if (!use_wt_file(workdir, dst_path, &roid)) {`
`472`	`472`	`if (checkout_path(rmode, &roid, dst_path,`
Original file line number	Diff line number	Diff line change
`@@ -278,7 +278,7 @@ static struct refname_hash_entry refname_hash_add(struct hashmap map,`
`278`	`278`	`FLEX_ALLOC_MEM(ent, refname, refname, len);`
`279`	`279`	`hashmap_entry_init(&ent->ent, strhash(refname));`
`280`	`280`	`oidcpy(&ent->oid, oid);`
`281`		`- hashmap_add(map, ent);`
	`281`	`+ hashmap_add(map, &ent->ent);`
`282`	`282`	`return ent;`
`283`	`283`	`}`
`284`	`284`
Original file line number	Diff line number	Diff line change
`@@ -1885,7 +1885,7 @@ static int configset_add_value(struct config_set cs, const char key, const cha`
`1885`	`1885`	`hashmap_entry_init(&e->ent, strhash(key));`
`1886`	`1886`	`e->key = xstrdup(key);`
`1887`	`1887`	`string_list_init(&e->value_list, 1);`
`1888`		`- hashmap_add(&cs->config_hash, e);`
	`1888`	`+ hashmap_add(&cs->config_hash, &e->ent);`
`1889`	`1889`	`}`
`1890`	`1890`	`si = string_list_append_nodup(&e->value_list, xstrdup_or_null(value));`
`1891`	`1891`
Original file line number	Diff line number	Diff line change
`@@ -1003,7 +1003,7 @@ static void add_lines_to_move_detection(struct diff_options *o,`
`1003`	`1003`	`if (prev_line && prev_line->es->s == o->emitted_symbols->buf[n].s)`
`1004`	`1004`	`prev_line->next_line = key;`
`1005`	`1005`
`1006`		`- hashmap_add(hm, key);`
	`1006`	`+ hashmap_add(hm, &key->ent);`
`1007`	`1007`	`prev_line = key;`
`1008`	`1008`	`}`
`1009`	`1009`	`}`
Original file line number	Diff line number	Diff line change
`@@ -330,7 +330,7 @@ static void insert_file_table(struct repository *r,`
`330`	`330`	`entry->filespec = filespec;`
`331`	`331`
`332`	`332`	`hashmap_entry_init(&entry->entry, hash_filespec(r, filespec));`
`333`		`- hashmap_add(table, entry);`
	`333`	`+ hashmap_add(table, &entry->entry);`
`334`	`334`	`}`
`335`	`335`
`336`	`336`	`/*`
Original file line number	Diff line number	Diff line change
`@@ -201,12 +201,12 @@ void hashmap_get_next(const struct hashmap map,`
`201`	`201`	`return NULL;`
`202`	`202`	`}`
`203`	`203`
`204`		`-void hashmap_add(struct hashmap map, void entry)`
	`204`	`+void hashmap_add(struct hashmap map, struct hashmap_entry entry)`
`205`	`205`	`{`
`206`	`206`	`unsigned int b = bucket(map, entry);`
`207`	`207`
`208`	`208`	`/* add entry */`
`209`		`- ((struct hashmap_entry *) entry)->next = map->table[b];`
	`209`	`+ entry->next = map->table[b];`
`210`	`210`	`map->table[b] = entry;`
`211`	`211`
`212`	`212`	`/* fix size and rehash if appropriate */`
`@@ -302,7 +302,7 @@ const void memintern(const void data, size_t len)`
`302`	`302`	`FLEX_ALLOC_MEM(e, data, data, len);`
`303`	`303`	`hashmap_entry_init(&e->ent, key.ent.hash);`
`304`	`304`	`e->len = len;`
`305`		`- hashmap_add(&map, e);`
	`305`	`+ hashmap_add(&map, &e->ent);`
`306`	`306`	`}`
`307`	`307`	`return e->data;`
`308`	`308`	`}`