revert(3p/git): Revert merge of git upstream at v2.26.2 r/852

This causes cgit to serve error pages, which is undesirable.

This reverts commit 5229c9b232de5bfa959ad6ebbb4c8192ac513352, reversing
changes made to f2b211131f2347342dde63975b09cf603149f1a3.

1 files changed, 36 insertions, 142 deletions

diff --git a/third_party/git/hashmap.h b/third_party/git/hashmap.h
index 79ae9f80de1c..84249115664b 100644
--- a/third_party/git/hashmap.h
+++ b/third_party/git/hashmap.h
@@ -13,7 +13,7 @@
  *
  * struct hashmap map;
  * struct long2string {
- *     struct hashmap_entry ent;
+ *     struct hashmap_entry ent; // must be the first member!
  *     long key;
  *     char value[FLEX_ARRAY];   // be careful with allocating on stack!
  * };
@@ -21,16 +21,12 @@
  * #define COMPARE_VALUE 1
  *
  * static int long2string_cmp(const void *hashmap_cmp_fn_data,
- *                            const struct hashmap_entry *eptr,
- *                            const struct hashmap_entry *entry_or_key,
+ *                            const struct long2string *e1,
+ *                            const struct long2string *e2,
  *                            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 ||
@@ -45,58 +41,54 @@
  *     char value[255], action[32];
  *     unsigned flags = 0;
  *
- *     hashmap_init(&map, long2string_cmp, &flags, 0);
+ *     hashmap_init(&map, (hashmap_cmp_fn) long2string_cmp, &flags, 0);
  *
  *     while (scanf("%s %ld %s", action, &key, value)) {
  *
  *         if (!strcmp("add", action)) {
  *             struct long2string *e;
  *             FLEX_ALLOC_STR(e, value, value);
- *             hashmap_entry_init(&e->ent, memhash(&key, sizeof(long)));
+ *             hashmap_entry_init(e, memhash(&key, sizeof(long)));
  *             e->key = key;
- *             hashmap_add(&map, &e->ent);
+ *             hashmap_add(&map, e);
  *         }
  *
  *         if (!strcmp("print_all_by_key", action)) {
  *             struct long2string k, *e;
- *             hashmap_entry_init(&k.ent, memhash(&key, sizeof(long)));
+ *             hashmap_entry_init(&k, memhash(&key, sizeof(long)));
  *             k.key = key;
  *
  *             flags &= ~COMPARE_VALUE;
- *             e = hashmap_get_entry(&map, &k, ent, NULL);
+ *             e = hashmap_get(&map, &k, NULL);
  *             if (e) {
  *                 printf("first: %ld %s\n", e->key, e->value);
- *                 while ((e = hashmap_get_next_entry(&map, e,
- *                                              struct long2string, ent))) {
+ *                 while ((e = hashmap_get_next(&map, e)))
  *                     printf("found more: %ld %s\n", e->key, e->value);
- *                 }
  *             }
  *         }
  *
  *         if (!strcmp("has_exact_match", action)) {
  *             struct long2string *e;
  *             FLEX_ALLOC_STR(e, value, value);
- *             hashmap_entry_init(&e->ent, memhash(&key, sizeof(long)));
+ *             hashmap_entry_init(e, memhash(&key, sizeof(long)));
  *             e->key = key;
  *
  *             flags |= COMPARE_VALUE;
- *             printf("%sfound\n",
- *                    hashmap_get(&map, &e->ent, NULL) ? "" : "not ");
+ *             printf("%sfound\n", hashmap_get(&map, e, NULL) ? "" : "not ");
  *             free(e);
  *         }
  *
  *         if (!strcmp("has_exact_match_no_heap_alloc", action)) {
  *             struct long2string k;
- *             hashmap_entry_init(&k.ent, memhash(&key, sizeof(long)));
+ *             hashmap_entry_init(&k, memhash(&key, sizeof(long)));
  *             k.key = key;
  *
  *             flags |= COMPARE_VALUE;
- *             printf("%sfound\n",
- *                    hashmap_get(&map, &k.ent, value) ? "" : "not ");
+ *             printf("%sfound\n", hashmap_get(&map, &k, value) ? "" : "not ");
  *         }
  *
  *         if (!strcmp("end", action)) {
- *             hashmap_free_entries(&map, struct long2string, ent);
+ *             hashmap_free(&map, 1);
  *             break;
  *         }
  *     }
@@ -141,7 +133,7 @@ static inline unsigned int oidhash(const struct object_id *oid)
 
 /*
  * struct hashmap_entry is an opaque structure representing an entry in the
- * hash table.
+ * hash table, which must be used as first member of user data structures.
  * Ideally it should be followed by an int-sized member to prevent unused
  * memory on 64-bit systems due to alignment.
  */
@@ -176,8 +168,7 @@ 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 struct hashmap_entry *entry,
-			      const struct hashmap_entry *entry_or_key,
+			      const void *entry, const void *entry_or_key,
 			      const void *keydata);
 
 /*
@@ -232,20 +223,13 @@ void hashmap_init(struct hashmap *map,
 			 const void *equals_function_data,
 			 size_t initial_size);
 
-/* internal function for freeing hashmap */
-void hashmap_free_(struct hashmap *map, ssize_t offset);
-
-/*
- * Frees a hashmap structure and allocated memory, leaves entries undisturbed
- */
-#define hashmap_free(map) hashmap_free_(map, -1)
-
 /*
- * Frees @map and all entries.  @type is the struct type of the entry
- * where @member is the hashmap_entry struct used to associate with @map
+ * Frees a hashmap structure and allocated memory.
+ *
+ * If `free_entries` is true, each hashmap_entry in the map is freed as well
+ * using stdlibs free().
  */
-#define hashmap_free_entries(map, type, member) \
-	hashmap_free_(map, offsetof(type, member));
+void hashmap_free(struct hashmap *map, int free_entries);
 
 /* hashmap_entry functions */
 
@@ -260,9 +244,9 @@ void hashmap_free_(struct hashmap *map, ssize_t offset);
  * your structure was allocated with xmalloc(), you can just free(3) it,
  * and if it is on stack, you can just let it go out of scope).
  */
-static inline void hashmap_entry_init(struct hashmap_entry *e,
-					unsigned int hash)
+static inline void hashmap_entry_init(void *entry, unsigned int hash)
 {
+	struct hashmap_entry *e = entry;
 	e->hash = hash;
 	e->next = NULL;
 }
@@ -302,9 +286,8 @@ static inline unsigned int hashmap_get_size(struct hashmap *map)
  * If an entry with matching hash code is found, `key` and `keydata` are passed
  * to `hashmap_cmp_fn` to decide whether the entry matches the key.
  */
-struct hashmap_entry *hashmap_get(const struct hashmap *map,
-				const struct hashmap_entry *key,
-				const void *keydata);
+void *hashmap_get(const struct hashmap *map, const void *key,
+			 const void *keydata);
 
 /*
  * Returns the hashmap entry for the specified hash code and key data,
@@ -318,10 +301,9 @@ struct hashmap_entry *hashmap_get(const struct hashmap *map,
  * `entry_or_key` parameter of `hashmap_cmp_fn` points to a hashmap_entry
  * structure that should not be used in the comparison.
  */
-static inline struct hashmap_entry *hashmap_get_from_hash(
-					const struct hashmap *map,
-					unsigned int hash,
-					const void *keydata)
+static inline void *hashmap_get_from_hash(const struct hashmap *map,
+					  unsigned int hash,
+					  const void *keydata)
 {
 	struct hashmap_entry key;
 	hashmap_entry_init(&key, hash);
@@ -336,8 +318,7 @@ static inline struct hashmap_entry *hashmap_get_from_hash(
  * `entry` is the hashmap_entry to start the search from, obtained via a previous
  * call to `hashmap_get` or `hashmap_get_next`.
  */
-struct hashmap_entry *hashmap_get_next(const struct hashmap *map,
-			const struct hashmap_entry *entry);
+void *hashmap_get_next(const struct hashmap *map, const void *entry);
 
 /*
  * Adds a hashmap entry. This allows to add duplicate entries (i.e.
@@ -346,7 +327,7 @@ struct hashmap_entry *hashmap_get_next(const struct hashmap *map,
  * `map` is the hashmap structure.
  * `entry` is the entry to add.
  */
-void hashmap_add(struct hashmap *map, struct hashmap_entry *entry);
+void hashmap_add(struct hashmap *map, void *entry);
 
 /*
  * Adds or replaces a hashmap entry. If the hashmap contains duplicate
@@ -356,20 +337,7 @@ void hashmap_add(struct hashmap *map, struct hashmap_entry *entry);
  * `entry` is the entry to add or replace.
  * Returns the replaced entry, or NULL if not found (i.e. the entry was added).
  */
-struct hashmap_entry *hashmap_put(struct hashmap *map,
-				struct hashmap_entry *entry);
-
-/*
- * Adds or replaces a hashmap entry contained within @keyvar,
- * where @keyvar is a pointer to a struct containing a
- * "struct hashmap_entry" @member.
- *
- * Returns the replaced pointer which is of the same type as @keyvar,
- * or NULL if not found.
- */
-#define hashmap_put_entry(map, keyvar, member) \
-	container_of_or_null_offset(hashmap_put(map, &(keyvar)->member), \
-				OFFSETOF_VAR(keyvar, member))
+void *hashmap_put(struct hashmap *map, void *entry);
 
 /*
  * Removes a hashmap entry matching the specified key. If the hashmap contains
@@ -378,24 +346,8 @@ struct hashmap_entry *hashmap_put(struct hashmap *map,
  *
  * Argument explanation is the same as in `hashmap_get`.
  */
-struct hashmap_entry *hashmap_remove(struct hashmap *map,
-					const struct hashmap_entry *key,
-					const void *keydata);
-
-/*
- * Removes a hashmap entry contained within @keyvar,
- * where @keyvar is a pointer to a struct containing a
- * "struct hashmap_entry" @member.
- *
- * See `hashmap_get` for an explanation of @keydata
- *
- * Returns the replaced pointer which is of the same type as @keyvar,
- * or NULL if not found.
- */
-#define hashmap_remove_entry(map, keyvar, member, keydata) \
-	container_of_or_null_offset( \
-			hashmap_remove(map, &(keyvar)->member, keydata), \
-			OFFSETOF_VAR(keyvar, member))
+void *hashmap_remove(struct hashmap *map, const void *key,
+		const void *keydata);
 
 /*
  * Returns the `bucket` an entry is stored in.
@@ -418,10 +370,10 @@ struct hashmap_iter {
 void hashmap_iter_init(struct hashmap *map, struct hashmap_iter *iter);
 
 /* Returns the next hashmap_entry, or NULL if there are no more entries. */
-struct hashmap_entry *hashmap_iter_next(struct hashmap_iter *iter);
+void *hashmap_iter_next(struct hashmap_iter *iter);
 
 /* Initializes the iterator and returns the first entry, if any. */
-static inline struct hashmap_entry *hashmap_iter_first(struct hashmap *map,
+static inline void *hashmap_iter_first(struct hashmap *map,
 		struct hashmap_iter *iter)
 {
 	hashmap_iter_init(map, iter);
@@ -429,64 +381,6 @@ static inline struct hashmap_entry *hashmap_iter_first(struct hashmap *map,
 }
 
 /*
- * returns the first entry in @map using @iter, where the entry is of
- * @type (e.g. "struct foo") and @member is the name of the
- * "struct hashmap_entry" in @type
- */
-#define hashmap_iter_first_entry(map, iter, type, member) \
-	container_of_or_null(hashmap_iter_first(map, iter), type, member)
-
-/* internal macro for hashmap_for_each_entry */
-#define hashmap_iter_next_entry_offset(iter, offset) \
-	container_of_or_null_offset(hashmap_iter_next(iter), offset)
-
-/* internal macro for hashmap_for_each_entry */
-#define hashmap_iter_first_entry_offset(map, iter, offset) \
-	container_of_or_null_offset(hashmap_iter_first(map, iter), offset)
-
-/*
- * iterate through @map using @iter, @var is a pointer to a type
- * containing a @member which is a "struct hashmap_entry"
- */
-#define hashmap_for_each_entry(map, iter, var, member) \
-	for (var = hashmap_iter_first_entry_offset(map, iter, \
-						OFFSETOF_VAR(var, member)); \
-		var; \
-		var = hashmap_iter_next_entry_offset(iter, \
-						OFFSETOF_VAR(var, member)))
-
-/*
- * returns a pointer of type matching @keyvar, or NULL if nothing found.
- * @keyvar is a pointer to a struct containing a
- * "struct hashmap_entry" @member.
- */
-#define hashmap_get_entry(map, keyvar, member, keydata) \
-	container_of_or_null_offset( \
-				hashmap_get(map, &(keyvar)->member, keydata), \
-				OFFSETOF_VAR(keyvar, member))
-
-#define hashmap_get_entry_from_hash(map, hash, keydata, type, member) \
-	container_of_or_null(hashmap_get_from_hash(map, hash, keydata), \
-				type, member)
-/*
- * returns the next equal pointer to @var, or NULL if not found.
- * @var is a pointer of any type containing "struct hashmap_entry"
- * @member is the name of the "struct hashmap_entry" field
- */
-#define hashmap_get_next_entry(map, var, member) \
-	container_of_or_null_offset(hashmap_get_next(map, &(var)->member), \
-				OFFSETOF_VAR(var, member))
-
-/*
- * iterate @map starting from @var, where @var is a pointer of @type
- * and @member is the name of the "struct hashmap_entry" field in @type
- */
-#define hashmap_for_each_entry_from(map, var, member) \
-	for (; \
-		var; \
-		var = hashmap_get_next_entry(map, var, member))
-
-/*
  * Disable item counting and automatic rehashing when adding/removing items.
  *
  * Normally, the hashmap keeps track of the number of items in the map
@@ -502,7 +396,7 @@ static inline void hashmap_disable_item_counting(struct hashmap *map)
 }
 
 /*
- * Re-enable item counting when adding/removing items.
+ * Re-enable item couting when adding/removing items.
  * If counting is currently disabled, it will force count them.
  * It WILL NOT automatically rehash them.
  */