rugged 1.7.2 → 1.9.4

data/vendor/libgit2/src/libgit2/index.c

@@ -17,10 +17,10 @@
 #include "pathspec.h"
 #include "ignore.h"
 #include "blob.h"
-#include "idxmap.h"
 #include "diff.h"
 #include "varint.h"
 #include "path.h"
+#include "index_map.h"
 
 #include "git2/odb.h"
 #include "git2/oid.h"
@@ -133,30 +133,6 @@ static int write_index(unsigned char checksum[GIT_HASH_MAX_SIZE], size_t *checks
 static void index_entry_free(git_index_entry *entry);
 static void index_entry_reuc_free(git_index_reuc_entry *reuc);
 
-GIT_INLINE(int) index_map_set(git_idxmap *map, git_index_entry *e, bool ignore_case)
-{
-	if (ignore_case)
-		return git_idxmap_icase_set((git_idxmap_icase *) map, e, e);
-	else
-		return git_idxmap_set(map, e, e);
-}
-
-GIT_INLINE(int) index_map_delete(git_idxmap *map, git_index_entry *e, bool ignore_case)
-{
-	if (ignore_case)
-		return git_idxmap_icase_delete((git_idxmap_icase *) map, e);
-	else
-		return git_idxmap_delete(map, e);
-}
-
-GIT_INLINE(int) index_map_resize(git_idxmap *map, size_t count, bool ignore_case)
-{
-	if (ignore_case)
-		return git_idxmap_icase_resize((git_idxmap_icase *) map, count);
-	else
-		return git_idxmap_resize(map, count);
-}
-
 int git_index_entry_srch(const void *key, const void *array_member)
 {
 	const struct entry_srch_key *srch_key = key;
@@ -388,6 +364,7 @@ GIT_INLINE(int) index_find(
 void git_index__set_ignore_case(git_index *index, bool ignore_case)
 {
 	index->ignore_case = ignore_case;
+	index->entries_map.ignore_case = ignore_case;
 
 	if (ignore_case) {
 		index->entries_cmp_path    = git__strcasecmp_cb;
@@ -422,6 +399,7 @@ int git_index__open(
 	index = git__calloc(1, sizeof(git_index));
 	GIT_ERROR_CHECK_ALLOC(index);
 
+	GIT_ASSERT_ARG(git_oid_type_is_valid(oid_type));
 	index->oid_type = oid_type;
 
 	if (git_pool_init(&index->tree_pool, 1) < 0)
@@ -438,7 +416,6 @@ int git_index__open(
 	}
 
 	if (git_vector_init(&index->entries, 32, git_index_entry_cmp) < 0 ||
-	    git_idxmap_new(&index->entries_map) < 0 ||
 	    git_vector_init(&index->names, 8, conflict_name_cmp) < 0 ||
 	    git_vector_init(&index->reuc, 8, reuc_cmp) < 0 ||
 	    git_vector_init(&index->deleted, 8, git_index_entry_cmp) < 0)
@@ -465,9 +442,13 @@ fail:
 }
 
 #ifdef GIT_EXPERIMENTAL_SHA256
-int git_index_open(git_index **index_out, const char *index_path, git_oid_t oid_type)
+int git_index_open(
+	git_index **index_out,
+	const char *index_path,
+	const git_index_options *opts)
 {
-	return git_index__open(index_out, index_path, oid_type);
+	return git_index__open(index_out, index_path,
+		opts && opts->oid_type ? opts->oid_type : GIT_OID_DEFAULT);
 }
 #else
 int git_index_open(git_index **index_out, const char *index_path)
@@ -482,9 +463,10 @@ int git_index__new(git_index **out, git_oid_t oid_type)
 }
 
 #ifdef GIT_EXPERIMENTAL_SHA256
-int git_index_new(git_index **out, git_oid_t oid_type)
+int git_index_new(git_index **out, const git_index_options *opts)
 {
-	return git_index__new(out, oid_type);
+	return git_index__new(out,
+		opts && opts->oid_type ? opts->oid_type : GIT_OID_DEFAULT);
 }
 #else
 int git_index_new(git_index **out)
@@ -502,11 +484,11 @@ static void index_free(git_index *index)
 		return;
 
 	git_index_clear(index);
-	git_idxmap_free(index->entries_map);
-	git_vector_free(&index->entries);
-	git_vector_free(&index->names);
-	git_vector_free(&index->reuc);
-	git_vector_free(&index->deleted);
+	git_index_entrymap_dispose(&index->entries_map);
+	git_vector_dispose(&index->entries);
+	git_vector_dispose(&index->names);
+	git_vector_dispose(&index->reuc);
+	git_vector_dispose(&index->deleted);
 
 	git__free(index->index_file_path);
 
@@ -547,7 +529,7 @@ static int index_remove_entry(git_index *index, size_t pos)
 
 	if (entry != NULL) {
 		git_tree_cache_invalidate_path(index->tree, entry->path);
-		index_map_delete(index->entries_map, entry, index->ignore_case);
+		git_index_entrymap_remove(&index->entries_map, entry);
 	}
 
 	error = git_vector_remove(&index->entries, pos);
@@ -575,7 +557,8 @@ int git_index_clear(git_index *index)
 	index->tree = NULL;
 	git_pool_clear(&index->tree_pool);
 
-	git_idxmap_clear(index->entries_map);
+	git_index_entrymap_clear(&index->entries_map);
+
 	while (!error && index->entries.length > 0)
 		error = index_remove_entry(index, index->entries.length - 1);
 
@@ -786,8 +769,10 @@ static int truncate_racily_clean(git_index *index)
 	diff_opts.pathspec.count = paths.length;
 	diff_opts.pathspec.strings = (char **)paths.contents;
 
-	if ((error = git_diff_index_to_workdir(&diff, INDEX_OWNER(index), index, &diff_opts)) < 0)
+	if ((error = git_diff_index_to_workdir(&diff, INDEX_OWNER(index), index, &diff_opts)) < 0) {
+		git_vector_dispose(&paths);
 		return error;
+	}
 
 	git_vector_foreach(&diff->deltas, i, delta) {
 		entry = (git_index_entry *)git_index_get_bypath(index, delta->old_file.path, 0);
@@ -803,7 +788,7 @@ static int truncate_racily_clean(git_index *index)
 
 done:
 	git_diff_free(diff);
-	git_vector_free(&paths);
+	git_vector_dispose(&paths);
 	return 0;
 }
 
@@ -904,14 +889,9 @@ const git_index_entry *git_index_get_bypath(
 	key.path = path;
 	GIT_INDEX_ENTRY_STAGE_SET(&key, stage);
 
-	if (index->ignore_case)
-		value = git_idxmap_icase_get((git_idxmap_icase *) index->entries_map, &key);
-	else
-		value = git_idxmap_get(index->entries_map, &key);
-
-	if (!value) {
-	    git_error_set(GIT_ERROR_INDEX, "index does not contain '%s'", path);
-	    return NULL;
+	if (git_index_entrymap_get(&value, &index->entries_map, &key) != 0) {
+		git_error_set(GIT_ERROR_INDEX, "index does not contain '%s'", path);
+		return NULL;
 	}
 
 	return value;
@@ -1245,7 +1225,7 @@ static int canonicalize_directory_path(
 {
 	const git_index_entry *match, *best = NULL;
 	char *search, *sep;
-	size_t pos, search_len, best_len;
+	size_t pos, search_len, best_len = 0;
 
 	if (!index->ignore_case)
 		return 0;
@@ -1453,7 +1433,7 @@ static int index_insert(
 		 * check for dups, this is actually cheaper in the long run.)
 		 */
 		if ((error = git_vector_insert_sorted(&index->entries, entry, index_no_dups)) < 0 ||
-		    (error = index_map_set(index->entries_map, entry, index->ignore_case)) < 0)
+		    (error = git_index_entrymap_put(&index->entries_map, entry)) < 0)
 			goto out;
 	}
 
@@ -1468,7 +1448,7 @@ out:
 	return error;
 }
 
-static int index_conflict_to_reuc(git_index *index, const char *path)
+int git_index__conflict_to_reuc(git_index *index, const char *path)
 {
 	const git_index_entry *conflict_entries[3];
 	int ancestor_mode, our_mode, their_mode;
@@ -1548,7 +1528,7 @@ int git_index_add_from_buffer(
 		return error;
 
 	/* Adding implies conflict was resolved, move conflict entries to REUC */
-	if ((error = index_conflict_to_reuc(index, entry->path)) < 0 && error != GIT_ENOTFOUND)
+	if ((error = git_index__conflict_to_reuc(index, entry->path)) < 0 && error != GIT_ENOTFOUND)
 		return error;
 
 	git_tree_cache_invalidate_path(index->tree, entry->path);
@@ -1612,15 +1592,17 @@ int git_index_add_bypath(git_index *index, const char *path)
 
 	if (ret == GIT_EDIRECTORY) {
 		git_submodule *sm;
-		git_error_state err;
+		git_error *last_error;
 
-		git_error_state_capture(&err, ret);
+		git_error_save(&last_error);
 
 		ret = git_submodule_lookup(&sm, INDEX_OWNER(index), path);
-		if (ret == GIT_ENOTFOUND)
-			return git_error_state_restore(&err);
+		if (ret == GIT_ENOTFOUND) {
+			git_error_restore(last_error);
+			return GIT_EDIRECTORY;
+		}
 
-		git_error_state_free(&err);
+		git_error_free(last_error);
 
 		/*
 		 * EEXISTS means that there is a repository at that path, but it's not known
@@ -1642,7 +1624,7 @@ int git_index_add_bypath(git_index *index, const char *path)
 	}
 
 	/* Adding implies conflict was resolved, move conflict entries to REUC */
-	if ((ret = index_conflict_to_reuc(index, path)) < 0 && ret != GIT_ENOTFOUND)
+	if ((ret = git_index__conflict_to_reuc(index, path)) < 0 && ret != GIT_ENOTFOUND)
 		return ret;
 
 	git_tree_cache_invalidate_path(index->tree, entry->path);
@@ -1658,7 +1640,7 @@ int git_index_remove_bypath(git_index *index, const char *path)
 
 	if (((ret = git_index_remove(index, path, 0)) < 0 &&
 		ret != GIT_ENOTFOUND) ||
-		((ret = index_conflict_to_reuc(index, path)) < 0 &&
+		((ret = git_index__conflict_to_reuc(index, path)) < 0 &&
 		ret != GIT_ENOTFOUND))
 		return ret;
 
@@ -1680,8 +1662,7 @@ int git_index__fill(git_index *index, const git_vector *source_entries)
 		return 0;
 
 	if (git_vector_size_hint(&index->entries, source_entries->length) < 0 ||
-	    index_map_resize(index->entries_map, (size_t)(source_entries->length * 1.3),
-			     index->ignore_case) < 0)
+	    git_index_entrymap_resize(&index->entries_map, (size_t)(source_entries->length * 1.3)) < 0)
 		return -1;
 
 	git_vector_foreach(source_entries, i, source_entry) {
@@ -1694,10 +1675,8 @@ int git_index__fill(git_index *index, const git_vector *source_entries)
 		entry->flags_extended |= GIT_INDEX_ENTRY_UPTODATE;
 		entry->mode = git_index__create_mode(entry->mode);
 
-		if ((error = git_vector_insert(&index->entries, entry)) < 0)
-			break;
-
-		if ((error = index_map_set(index->entries_map, entry, index->ignore_case)) < 0)
+		if ((error = git_vector_insert(&index->entries, entry)) < 0 ||
+		    (error = git_index_entrymap_put(&index->entries_map, entry)) < 0)
 			break;
 
 		index->dirty = 1;
@@ -1740,7 +1719,7 @@ int git_index_remove(git_index *index, const char *path, int stage)
 	remove_key.path = path;
 	GIT_INDEX_ENTRY_STAGE_SET(&remove_key, stage);
 
-	index_map_delete(index->entries_map, &remove_key, index->ignore_case);
+	git_index_entrymap_remove(&index->entries_map, &remove_key);
 
 	if (index_find(&position, index, path, 0, stage) < 0) {
 		git_error_set(
@@ -2546,7 +2525,7 @@ static int read_entry(
 {
 	size_t path_length, path_offset, entry_size;
 	const char *path_ptr;
-	struct entry_common *source_common;
+	struct entry_common *source_common = NULL;
 	index_entry_short_sha1 source_sha1;
 #ifdef GIT_EXPERIMENTAL_SHA256
 	index_entry_short_sha256 source_sha256;
@@ -2758,6 +2737,7 @@ static int parse_index(git_index *index, const char *buffer, size_t buffer_size)
 	unsigned int i;
 	struct index_header header = { 0 };
 	unsigned char checksum[GIT_HASH_MAX_SIZE];
+	unsigned char zero_checksum[GIT_HASH_MAX_SIZE] = { 0 };
 	size_t checksum_size = git_hash_size(git_oid_algorithm(index->oid_type));
 	const char *last = NULL;
 	const char *empty = "";
@@ -2792,7 +2772,7 @@ static int parse_index(git_index *index, const char *buffer, size_t buffer_size)
 
 	GIT_ASSERT(!index->entries.length);
 
-	if ((error = index_map_resize(index->entries_map, header.entry_count, index->ignore_case)) < 0)
+	if ((error = git_index_entrymap_resize(&index->entries_map, header.entry_count)) < 0)
 		return error;
 
 	/* Parse all the entries */
@@ -2810,7 +2790,7 @@ static int parse_index(git_index *index, const char *buffer, size_t buffer_size)
 			goto done;
 		}
 
-		if ((error = index_map_set(index->entries_map, entry, index->ignore_case)) < 0) {
+		if ((error = git_index_entrymap_put(&index->entries_map, entry)) < 0) {
 			index_entry_free(entry);
 			goto done;
 		}
@@ -2847,8 +2827,11 @@ static int parse_index(git_index *index, const char *buffer, size_t buffer_size)
 	/*
 	 * SHA-1 or SHA-256 (depending on the repository's object format)
 	 * over the content of the index file before this checksum.
+	 * Note: checksum may be 0 if the index was written by a client
+	 * where index.skipHash was set to true.
 	 */
-	if (memcmp(checksum, buffer, checksum_size) != 0) {
+	if (memcmp(zero_checksum, buffer, checksum_size) != 0 &&
+	    memcmp(checksum, buffer, checksum_size) != 0) {
 		error = index_error_invalid(
 			"calculated checksum does not match expected");
 		goto done;
@@ -2894,7 +2877,7 @@ static int write_disk_entry(
 	const char *last)
 {
 	void *mem = NULL;
-	struct entry_common *ondisk_common;
+	struct entry_common *ondisk_common = NULL;
 	size_t path_len, path_offset, disk_size;
 	int varint_len = 0;
 	char *path;
@@ -2983,7 +2966,7 @@ static int write_disk_entry(
 	path_offset = index_entry_path_offset(index->oid_type, entry->flags);
 
 	if (entry->flags & GIT_INDEX_ENTRY_EXTENDED) {
-		struct entry_common *ondisk_ext;
+		struct entry_common *ondisk_ext = NULL;
 		uint16_t flags_extended = htons(entry->flags_extended &
 			GIT_INDEX_ENTRY_EXTENDED_FLAGS);
 
@@ -3083,7 +3066,7 @@ static int write_entries(git_index *index, git_filebuf *file)
 	}
 
 done:
-	git_vector_free(&case_sorted);
+	git_vector_dispose(&case_sorted);
 	return error;
 }
 
@@ -3359,14 +3342,11 @@ int git_index_read_tree(git_index *index, const git_tree *tree)
 {
 	int error = 0;
 	git_vector entries = GIT_VECTOR_INIT;
-	git_idxmap *entries_map;
+	git_index_entrymap entries_map = GIT_INDEX_ENTRYMAP_INIT;
 	read_tree_data data;
 	size_t i;
 	git_index_entry *e;
 
-	if (git_idxmap_new(&entries_map) < 0)
-		return -1;
-
 	git_vector_set_cmp(&entries, index->entries._cmp); /* match sort */
 
 	data.index = index;
@@ -3382,11 +3362,11 @@ int git_index_read_tree(git_index *index, const git_tree *tree)
 	if ((error = git_tree_walk(tree, GIT_TREEWALK_POST, read_tree_cb, &data)) < 0)
 		goto cleanup;
 
-	if ((error = index_map_resize(entries_map, entries.length, index->ignore_case)) < 0)
+	if ((error = git_index_entrymap_resize(&entries_map, entries.length)) < 0)
 		goto cleanup;
 
 	git_vector_foreach(&entries, i, e) {
-		if ((error = index_map_set(entries_map, e, index->ignore_case)) < 0) {
+		if ((error = git_index_entrymap_put(&entries_map, e)) < 0) {
 			git_error_set(GIT_ERROR_INDEX, "failed to insert entry into map");
 			return error;
 		}
@@ -3396,18 +3376,18 @@ int git_index_read_tree(git_index *index, const git_tree *tree)
 
 	git_vector_sort(&entries);
 
-	if ((error = git_index_clear(index)) < 0) {
-		/* well, this isn't good */;
-	} else {
-		git_vector_swap(&entries, &index->entries);
-		entries_map = git_atomic_swap(index->entries_map, entries_map);
-	}
+	if ((error = git_index_clear(index)) < 0)
+		goto cleanup;
+
+	git_vector_swap(&entries, &index->entries);
+	git_index_entrymap_swap(&entries_map, &index->entries_map);
 
 	index->dirty = 1;
 
 cleanup:
-	git_vector_free(&entries);
-	git_idxmap_free(entries_map);
+	git_vector_dispose(&entries);
+	git_index_entrymap_dispose(&entries_map);
+
 	if (error < 0)
 		return error;
 
@@ -3423,7 +3403,7 @@ static int git_index_read_iterator(
 {
 	git_vector new_entries = GIT_VECTOR_INIT,
 		remove_entries = GIT_VECTOR_INIT;
-	git_idxmap *new_entries_map = NULL;
+	git_index_entrymap new_entries_map = GIT_INDEX_ENTRYMAP_INIT;
 	git_iterator *index_iterator = NULL;
 	git_iterator_options opts = GIT_ITERATOR_OPTIONS_INIT;
 	const git_index_entry *old_entry, *new_entry;
@@ -3434,12 +3414,11 @@ static int git_index_read_iterator(
 	GIT_ASSERT((new_iterator->flags & GIT_ITERATOR_DONT_IGNORE_CASE));
 
 	if ((error = git_vector_init(&new_entries, new_length_hint, index->entries._cmp)) < 0 ||
-	    (error = git_vector_init(&remove_entries, index->entries.length, NULL)) < 0 ||
-	    (error = git_idxmap_new(&new_entries_map)) < 0)
+	    (error = git_vector_init(&remove_entries, index->entries.length, NULL)) < 0)
 		goto done;
 
-	if (new_length_hint && (error = index_map_resize(new_entries_map, new_length_hint,
-							 index->ignore_case)) < 0)
+	if (new_length_hint &&
+	    (error = git_index_entrymap_resize(&new_entries_map, new_length_hint)) < 0)
 		goto done;
 
 	opts.flags = GIT_ITERATOR_DONT_IGNORE_CASE |
@@ -3504,8 +3483,7 @@ static int git_index_read_iterator(
 
 		if (add_entry) {
 			if ((error = git_vector_insert(&new_entries, add_entry)) == 0)
-				error = index_map_set(new_entries_map, add_entry,
-						      index->ignore_case);
+				error = git_index_entrymap_put(&new_entries_map, add_entry);
 		}
 
 		if (remove_entry && error >= 0)
@@ -3534,7 +3512,7 @@ static int git_index_read_iterator(
 	    goto done;
 
 	git_vector_swap(&new_entries, &index->entries);
-	new_entries_map = git_atomic_swap(index->entries_map, new_entries_map);
+	git_index_entrymap_swap(&index->entries_map, &new_entries_map);
 
 	git_vector_foreach(&remove_entries, i, entry) {
 		if (index->tree)
@@ -3549,9 +3527,9 @@ static int git_index_read_iterator(
 	error = 0;
 
 done:
-	git_idxmap_free(new_entries_map);
-	git_vector_free(&new_entries);
-	git_vector_free(&remove_entries);
+	git_index_entrymap_dispose(&new_entries_map);
+	git_vector_dispose(&new_entries);
+	git_vector_dispose(&remove_entries);
 	git_iterator_free(index_iterator);
 	return error;
 }
@@ -3852,7 +3830,7 @@ int git_index_snapshot_new(git_vector *snap, git_index *index)
 
 void git_index_snapshot_release(git_vector *snap, git_index *index)
 {
-	git_vector_free(snap);
+	git_vector_dispose(snap);
 
 	git_atomic32_dec(&index->readers);
 

data/vendor/libgit2/src/libgit2/index.h

@@ -12,8 +12,8 @@
 #include "futils.h"
 #include "filebuf.h"
 #include "vector.h"
-#include "idxmap.h"
 #include "tree-cache.h"
+#include "index_map.h"
 #include "git2/odb.h"
 #include "git2/index.h"
 
@@ -30,7 +30,7 @@ struct git_index {
 	unsigned char checksum[GIT_HASH_MAX_SIZE];
 
 	git_vector entries;
-	git_idxmap *entries_map;
+	git_index_entrymap entries_map;
 
 	git_vector deleted; /* deleted entries if readers > 0 */
 	git_atomic32 readers; /* number of active iterators */
@@ -154,6 +154,9 @@ extern int git_index__open(
 	const char *index_path,
 	git_oid_t oid_type);
 
+/* If the path is conflicted, move it from the index to reuc. */
+int git_index__conflict_to_reuc(git_index *index, const char *path);
+
 /* Copy the current entries vector *and* increment the index refcount.
  * Call `git_index__release_snapshot` when done.
  */

data/vendor/libgit2/src/libgit2/index_map.c

@@ -0,0 +1,95 @@
+/*
+ * Copyright (C) the libgit2 contributors. All rights reserved.
+ *
+ * This file is part of libgit2, distributed under the GNU GPL v2 with
+ * a Linking Exception. For full terms see the included COPYING file.
+ */
+
+#include "common.h"
+#include "hashmap.h"
+#include "index_map.h"
+
+typedef git_index_entrymap git_index_entrymap_default;
+typedef git_index_entrymap git_index_entrymap_icase;
+
+/* This is __ac_X31_hash_string but with tolower and it takes the entry's stage into account */
+GIT_INLINE(uint32_t) git_index_entrymap_hash(const git_index_entry *e)
+{
+	const char *s = e->path;
+	uint32_t h = (uint32_t)git__tolower(*s);
+	if (h) {
+		for (++s ; *s; ++s)
+			h = (h << 5) - h + (uint32_t)git__tolower(*s);
+	}
+	return h + GIT_INDEX_ENTRY_STAGE(e);
+}
+
+#define git_index_entrymap_equal_default(a, b) (GIT_INDEX_ENTRY_STAGE(a) == GIT_INDEX_ENTRY_STAGE(b) && strcmp(a->path, b->path) == 0)
+#define git_index_entrymap_equal_icase(a, b) (GIT_INDEX_ENTRY_STAGE(a) == GIT_INDEX_ENTRY_STAGE(b) && strcasecmp(a->path, b->path) == 0)
+
+GIT_HASHMAP_FUNCTIONS(git_index_entrymap_default, GIT_HASHMAP_INLINE, git_index_entry *, git_index_entry *, git_index_entrymap_hash, git_index_entrymap_equal_default)
+GIT_HASHMAP_FUNCTIONS(git_index_entrymap_icase, GIT_HASHMAP_INLINE, git_index_entry *, git_index_entry *, git_index_entrymap_hash, git_index_entrymap_equal_icase)
+
+int git_index_entrymap_put(git_index_entrymap *map, git_index_entry *e)
+{
+	if (map->ignore_case)
+		return git_index_entrymap_icase_put((git_index_entrymap_icase *)map, e, e);
+	else
+		return git_index_entrymap_default_put((git_index_entrymap_default *)map, e, e);
+}
+
+int git_index_entrymap_get(git_index_entry **out, git_index_entrymap *map, git_index_entry *e)
+{
+	if (map->ignore_case)
+		return git_index_entrymap_icase_get(out, (git_index_entrymap_icase *)map, e);
+	else
+		return git_index_entrymap_default_get(out, (git_index_entrymap_default *)map, e);
+}
+
+int git_index_entrymap_remove(git_index_entrymap *map, git_index_entry *e)
+{
+	if (map->ignore_case)
+		return git_index_entrymap_icase_remove((git_index_entrymap_icase *)map, e);
+	else
+		return git_index_entrymap_default_remove((git_index_entrymap_default *)map, e);
+}
+
+int git_index_entrymap_resize(git_index_entrymap *map, size_t count)
+{
+	if (count > UINT32_MAX) {
+		git_error_set(GIT_ERROR_INDEX, "index map is out of bounds");
+		return -1;
+	}
+
+	if (map->ignore_case)
+		return git_index_entrymap_icase__resize((git_index_entrymap_icase *)map, (uint32_t)count);
+	else
+		return git_index_entrymap_default__resize((git_index_entrymap_default *)map, (uint32_t)count);
+}
+
+void git_index_entrymap_swap(git_index_entrymap *a, git_index_entrymap *b)
+{
+	git_index_entrymap t;
+
+	if (a != b) {
+		memcpy(&t, a, sizeof(t));
+		memcpy(a, b, sizeof(t));
+		memcpy(b, &t, sizeof(t));
+	}
+}
+
+void git_index_entrymap_clear(git_index_entrymap *map)
+{
+	if (map->ignore_case)
+		git_index_entrymap_icase_clear((git_index_entrymap_icase *)map);
+	else
+		git_index_entrymap_default_clear((git_index_entrymap_default *)map);
+}
+
+void git_index_entrymap_dispose(git_index_entrymap *map)
+{
+	if (map->ignore_case)
+		git_index_entrymap_icase_dispose((git_index_entrymap_icase *)map);
+	else
+		git_index_entrymap_default_dispose((git_index_entrymap_default *)map);
+}

data/vendor/libgit2/src/libgit2/index_map.h

@@ -0,0 +1,28 @@
+/*
+ * Copyright (C) the libgit2 contributors. All rights reserved.
+ *
+ * This file is part of libgit2, distributed under the GNU GPL v2 with
+ * a Linking Exception. For full terms see the included COPYING file.
+ */
+#ifndef INCLUDE_index_map_h__
+#define INCLUDE_index_map_h__
+
+#include "common.h"
+#include "hashmap.h"
+
+typedef struct {
+	unsigned int ignore_case;
+	GIT_HASHMAP_STRUCT_MEMBERS(git_index_entry *, git_index_entry *)
+} git_index_entrymap;
+
+#define GIT_INDEX_ENTRYMAP_INIT { 0 }
+
+extern int git_index_entrymap_get(git_index_entry **out, git_index_entrymap *map, git_index_entry *e);
+extern int git_index_entrymap_put(git_index_entrymap *map, git_index_entry *e);
+extern int git_index_entrymap_remove(git_index_entrymap *map, git_index_entry *e);
+extern int git_index_entrymap_resize(git_index_entrymap *map, size_t count);
+extern void git_index_entrymap_swap(git_index_entrymap *a, git_index_entrymap *b);
+extern void git_index_entrymap_clear(git_index_entrymap *map);
+extern void git_index_entrymap_dispose(git_index_entrymap *map);
+
+#endif