rugged 0.27.10 → 0.27.10.1

data/vendor/libgit2/src/oid.c

@@ -17,7 +17,7 @@ static char to_hex[] = "0123456789abcdef";
 
 static int oid_error_invalid(const char *msg)
 {
-	git_error_set(GIT_ERROR_INVALID, "unable to parse OID - %s", msg);
+	giterr_set(GITERR_INVALID, "unable to parse OID - %s", msg);
 	return -1;
 }
 
@@ -237,7 +237,7 @@ int git_oid_streq(const git_oid *oid_a, const char *str)
 	return git_oid_strcmp(oid_a, str) == 0 ? 0 : -1;
 }
 
-int git_oid_is_zero(const git_oid *oid_a)
+int git_oid_iszero(const git_oid *oid_a)
 {
 	const unsigned char *a = oid_a->id;
 	unsigned int i;
@@ -247,11 +247,6 @@ int git_oid_is_zero(const git_oid *oid_a)
 	return 1;
 }
 
-int git_oid_iszero(const git_oid *oid_a)
-{
-	return git_oid_is_zero(oid_a);
-}
-
 typedef short node_index;
 
 typedef union {
@@ -268,7 +263,7 @@ struct git_oid_shorten {
 static int resize_trie(git_oid_shorten *self, size_t new_size)
 {
 	self->nodes = git__reallocarray(self->nodes, new_size, sizeof(trie_node));
-	GIT_ERROR_CHECK_ALLOC(self->nodes);
+	GITERR_CHECK_ALLOC(self->nodes);
 
 	if (new_size > self->size) {
 		memset(&self->nodes[self->size], 0x0, (new_size - self->size) * sizeof(trie_node));
@@ -386,7 +381,7 @@ int git_oid_shorten_add(git_oid_shorten *os, const char *text_oid)
 	node_index idx;
 
 	if (os->full) {
-		git_error_set(GIT_ERROR_INVALID, "unable to shorten OID - OID set full");
+		giterr_set(GITERR_INVALID, "unable to shorten OID - OID set full");
 		return -1;
 	}
 
@@ -401,7 +396,7 @@ int git_oid_shorten_add(git_oid_shorten *os, const char *text_oid)
 		trie_node *node;
 
 		if (c == -1) {
-			git_error_set(GIT_ERROR_INVALID, "unable to shorten OID - invalid hex value");
+			giterr_set(GITERR_INVALID, "unable to shorten OID - invalid hex value");
 			return -1;
 		}
 
@@ -416,7 +411,7 @@ int git_oid_shorten_add(git_oid_shorten *os, const char *text_oid)
 			node = push_leaf(os, idx, git__fromhex(tail[0]), &tail[1]);
 			if (node == NULL) {
 				if (os->full)
-					git_error_set(GIT_ERROR_INVALID, "unable to shorten OID - OID set full");
+					giterr_set(GITERR_INVALID, "unable to shorten OID - OID set full");
 				return -1;
 			}
 		}
@@ -424,7 +419,7 @@ int git_oid_shorten_add(git_oid_shorten *os, const char *text_oid)
 		if (node->children[c] == 0) {
 			if (push_leaf(os, idx, c, &text_oid[i + 1]) == NULL) {
 				if (os->full)
-					git_error_set(GIT_ERROR_INVALID, "unable to shorten OID - OID set full");
+					giterr_set(GITERR_INVALID, "unable to shorten OID - OID set full");
 				return -1;
 			}
 			break;

data/vendor/libgit2/src/oidmap.c

@@ -7,15 +7,6 @@
 
 #include "oidmap.h"
 
-#define kmalloc git__malloc
-#define kcalloc git__calloc
-#define krealloc git__realloc
-#define kreallocarray git__reallocarray
-#define kfree git__free
-#include "khash.h"
-
-__KHASH_TYPE(oid, const git_oid *, void *)
-
 GIT_INLINE(khint_t) git_oidmap_hash(const git_oid *oid)
 {
 	khint_t h;
@@ -25,12 +16,9 @@ GIT_INLINE(khint_t) git_oidmap_hash(const git_oid *oid)
 
 __KHASH_IMPL(oid, static kh_inline, const git_oid *, void *, 1, git_oidmap_hash, git_oid_equal)
 
-int git_oidmap_new(git_oidmap **out)
+git_oidmap *git_oidmap_alloc()
 {
-	*out = kh_init(oid);
-	GIT_ERROR_CHECK_ALLOC(*out);
-
-	return 0;
+	return kh_init(oid);
 }
 
 void git_oidmap_free(git_oidmap *map)
@@ -48,60 +36,70 @@ size_t git_oidmap_size(git_oidmap *map)
 	return kh_size(map);
 }
 
-void *git_oidmap_get(git_oidmap *map, const git_oid *key)
+size_t git_oidmap_lookup_index(git_oidmap *map, const git_oid *key)
 {
-	size_t idx = kh_get(oid, map, key);
-	if (idx == kh_end(map) || !kh_exist(map, idx))
-		return NULL;
-	return kh_val(map, idx);
+	return kh_get(oid, map, key);
 }
 
-int git_oidmap_set(git_oidmap *map, const git_oid *key, void *value)
+int git_oidmap_valid_index(git_oidmap *map, size_t idx)
 {
-	size_t idx;
-	int rval;
+	return idx != kh_end(map);
+}
 
-	idx = kh_put(oid, map, key, &rval);
-	if (rval < 0)
-		return -1;
+int git_oidmap_exists(git_oidmap *map, const git_oid *key)
+{
+	return kh_get(oid, map, key) != kh_end(map);
+}
 
-	if (rval == 0)
-		kh_key(map, idx) = key;
+int git_oidmap_has_data(git_oidmap *map, size_t idx)
+{
+	return kh_exist(map, idx);
+}
 
-	kh_val(map, idx) = value;
+const git_oid *git_oidmap_key(git_oidmap *map, size_t idx)
+{
+	return kh_key(map, idx);
+}
 
-	return 0;
+void git_oidmap_set_key_at(git_oidmap *map, size_t idx, git_oid *key)
+{
+	kh_key(map, idx) = key;
 }
 
-int git_oidmap_delete(git_oidmap *map, const git_oid *key)
+void *git_oidmap_value_at(git_oidmap *map, size_t idx)
 {
-	khiter_t idx = kh_get(oid, map, key);
-	if (idx == kh_end(map))
-		return GIT_ENOTFOUND;
-	kh_del(oid, map, idx);
-	return 0;
+	return kh_val(map, idx);
 }
 
-int git_oidmap_exists(git_oidmap *map, const git_oid *key)
+void git_oidmap_set_value_at(git_oidmap *map, size_t idx, void *value)
 {
-	return kh_get(oid, map, key) != kh_end(map);
+	kh_val(map, idx) = value;
 }
 
-int git_oidmap_iterate(void **value, git_oidmap *map, size_t *iter, const git_oid **key)
+void git_oidmap_delete_at(git_oidmap *map, size_t idx)
 {
-	size_t i = *iter;
+	kh_del(oid, map, idx);
+}
 
-	while (i < map->n_buckets && !kh_exist(map, i))
-		i++;
+int git_oidmap_put(git_oidmap *map, const git_oid *key, int *err)
+{
+	return kh_put(oid, map, key, err);
+}
 
-	if (i >= map->n_buckets)
-		return GIT_ITEROVER;
+void git_oidmap_insert(git_oidmap *map, const git_oid *key, void *value, int *rval)
+{
+	khiter_t idx = kh_put(oid, map, key, rval);
 
-	if (key)
-		*key = kh_key(map, i);
-	if (value)
-		*value = kh_value(map, i);
-	*iter = ++i;
+	if ((*rval) >= 0) {
+		if ((*rval) == 0)
+			kh_key(map, idx) = key;
+		kh_val(map, idx) = value;
+	}
+}
 
-	return 0;
+void git_oidmap_delete(git_oidmap *map, const git_oid *key)
+{
+	khiter_t idx = git_oidmap_lookup_index(map, key);
+	if (git_oidmap_valid_index(map, idx))
+		git_oidmap_delete_at(map, idx);
 }

data/vendor/libgit2/src/oidmap.h

@@ -11,118 +11,41 @@
 
 #include "git2/oid.h"
 
-/** A map with `git_oid`s as key. */
-typedef struct kh_oid_s git_oidmap;
+#define kmalloc git__malloc
+#define kcalloc git__calloc
+#define krealloc git__realloc
+#define kreallocarray git__reallocarray
+#define kfree git__free
+#include "khash.h"
 
-/**
- * Allocate a new OID map.
- *
- * @param out Pointer to the map that shall be allocated.
- * @return 0 on success, an error code if allocation has failed.
- */
-int git_oidmap_new(git_oidmap **out);
+__KHASH_TYPE(oid, const git_oid *, void *)
+typedef khash_t(oid) git_oidmap;
 
-/**
- * Free memory associated with the map.
- *
- * Note that this function will _not_ free values added to this
- * map.
- *
- * @param map Pointer to the map that is to be free'd. May be
- *            `NULL`.
- */
+git_oidmap *git_oidmap_alloc(void);
 void git_oidmap_free(git_oidmap *map);
-
-/**
- * Clear all entries from the map.
- *
- * This function will remove all entries from the associated map.
- * Memory associated with it will not be released, though.
- *
- * @param map Pointer to the map that shall be cleared. May be
- *            `NULL`.
- */
 void git_oidmap_clear(git_oidmap *map);
 
-/**
- * Return the number of elements in the map.
- *
- * @parameter map map containing the elements
- * @return number of elements in the map
- */
 size_t git_oidmap_size(git_oidmap *map);
 
-/**
- * Return value associated with the given key.
- *
- * @param map map to search key in
- * @param key key to search for
- * @return value associated with the given key or NULL if the key was not found
- */
-void *git_oidmap_get(git_oidmap *map, const git_oid *key);
+size_t git_oidmap_lookup_index(git_oidmap *map, const git_oid *key);
+int git_oidmap_valid_index(git_oidmap *map, size_t idx);
 
-/**
- * Set the entry for key to value.
- *
- * If the map has no corresponding entry for the given key, a new
- * entry will be created with the given value. If an entry exists
- * already, its value will be updated to match the given value.
- *
- * @param map map to create new entry in
- * @param key key to set
- * @param value value to associate the key with; may be NULL
- * @return zero if the key was successfully set, a negative error
- *         code otherwise
- */
-int git_oidmap_set(git_oidmap *map, const git_oid *key, void *value);
+int git_oidmap_exists(git_oidmap *map, const git_oid *key);
+int git_oidmap_has_data(git_oidmap *map, size_t idx);
 
-/**
- * Delete an entry from the map.
- *
- * Delete the given key and its value from the map. If no such
- * key exists, this will do nothing.
- *
- * @param map map to delete key in
- * @param key key to delete
- * @return `0` if the key has been deleted, GIT_ENOTFOUND if no
- *         such key was found, a negative code in case of an
- *         error
- */
-int git_oidmap_delete(git_oidmap *map, const git_oid *key);
+const git_oid *git_oidmap_key(git_oidmap *map, size_t idx);
+void git_oidmap_set_key_at(git_oidmap *map, size_t idx, git_oid *key);
+void *git_oidmap_value_at(git_oidmap *map, size_t idx);
+void git_oidmap_set_value_at(git_oidmap *map, size_t idx, void *value);
+void git_oidmap_delete_at(git_oidmap *map, size_t idx);
 
-/**
- * Check whether a key exists in the given map.
- *
- * @param map map to query for the key
- * @param key key to search for
- * @return 0 if the key has not been found, 1 otherwise
- */
-int git_oidmap_exists(git_oidmap *map, const git_oid *key);
+int git_oidmap_put(git_oidmap *map, const git_oid *key, int *err);
+void git_oidmap_insert(git_oidmap *map, const git_oid *key, void *value, int *rval);
+void git_oidmap_delete(git_oidmap *map, const git_oid *key);
 
-/**
- * Iterate over entries of the map.
- *
- * This functions allows to iterate over all key-value entries of
- * the map. The current position is stored in the `iter` variable
- * and should be initialized to `0` before the first call to this
- * function.
- *
- * @param map map to iterate over
- * @param value pointer to the variable where to store the current
- *            value. May be NULL.
- * @param iter iterator storing the current position. Initialize
- *             with zero previous to the first call.
- * @param key pointer to the variable where to store the current
- *            key. May be NULL.
- * @return `0` if the next entry was correctly retrieved.
- *        GIT_ITEROVER if no entries are left. A negative error
- *        code otherwise.
- */
-int git_oidmap_iterate(void **value, git_oidmap *map, size_t *iter, const git_oid **key);
+#define git_oidmap_foreach_value kh_foreach_value
 
-#define git_oidmap_foreach_value(h, vvar, code) { size_t __i = 0;		\
-	while (git_oidmap_iterate((void **) &(vvar), h, &__i, NULL) == 0) {	\
-		code;								\
-	} }
+#define git_oidmap_begin	kh_begin
+#define git_oidmap_end		kh_end
 
 #endif

data/vendor/libgit2/src/pack-objects.c

@@ -38,13 +38,7 @@ struct tree_walk_context {
 
 struct pack_write_context {
 	git_indexer *indexer;
-	git_indexer_progress *stats;
-};
-
-struct walk_object {
-	git_oid id;
-	unsigned int uninteresting:1,
-		seen:1;
+	git_transfer_progress *stats;
 };
 
 #ifdef GIT_THREADS
@@ -105,7 +99,7 @@ static int packbuilder_config(git_packbuilder *pb)
 	ret = git_config_get_int64(&val, config, KEY); \
 	if (!ret) { \
 		if (!git__is_sizet(val)) { \
-			git_error_set(GIT_ERROR_CONFIG, \
+			giterr_set(GITERR_CONFIG, \
 				"configuration value '%s' is too large", KEY); \
 			ret = -1; \
 			goto out; \
@@ -139,15 +133,17 @@ int git_packbuilder_new(git_packbuilder **out, git_repository *repo)
 	*out = NULL;
 
 	pb = git__calloc(1, sizeof(*pb));
-	GIT_ERROR_CHECK_ALLOC(pb);
+	GITERR_CHECK_ALLOC(pb);
 
-	if (git_oidmap_new(&pb->object_ix) < 0)
+	pb->object_ix = git_oidmap_alloc();
+	if (!pb->object_ix)
 		goto on_error;
 
-	if (git_oidmap_new(&pb->walk_objects) < 0)
+	pb->walk_objects = git_oidmap_alloc();
+	if (!pb->walk_objects)
 		goto on_error;
 
-	git_pool_init(&pb->object_pool, sizeof(struct walk_object));
+	git_pool_init(&pb->object_pool, sizeof(git_walk_object));
 
 	pb->repo = repo;
 	pb->nr_threads = 1; /* do not spawn any thread by default */
@@ -164,7 +160,7 @@ int git_packbuilder_new(git_packbuilder **out, git_repository *repo)
 		git_mutex_init(&pb->progress_mutex) ||
 		git_cond_init(&pb->progress_cond))
 	{
-		git_error_set(GIT_ERROR_OS, "failed to initialize packbuilder mutex");
+		giterr_set(GITERR_OS, "failed to initialize packbuilder mutex");
 		goto on_error;
 	}
 
@@ -192,25 +188,25 @@ unsigned int git_packbuilder_set_threads(git_packbuilder *pb, unsigned int n)
 	return pb->nr_threads;
 }
 
-static int rehash(git_packbuilder *pb)
+static void rehash(git_packbuilder *pb)
 {
 	git_pobject *po;
+	khiter_t pos;
 	size_t i;
+	int ret;
 
 	git_oidmap_clear(pb->object_ix);
-
 	for (i = 0, po = pb->object_list; i < pb->nr_objects; i++, po++) {
-		if (git_oidmap_set(pb->object_ix, &po->id, po) < 0)
-			return -1;
+		pos = git_oidmap_put(pb->object_ix, &po->id, &ret);
+		git_oidmap_set_value_at(pb->object_ix, pos, po);
 	}
-
-	return 0;
 }
 
 int git_packbuilder_insert(git_packbuilder *pb, const git_oid *oid,
 			   const char *name)
 {
 	git_pobject *po;
+	khiter_t pos;
 	size_t newsize;
 	int ret;
 
@@ -222,11 +218,11 @@ int git_packbuilder_insert(git_packbuilder *pb, const git_oid *oid,
 		return 0;
 
 	if (pb->nr_objects >= pb->nr_alloc) {
-		GIT_ERROR_CHECK_ALLOC_ADD(&newsize, pb->nr_alloc, 1024);
-		GIT_ERROR_CHECK_ALLOC_MULTIPLY(&newsize, newsize / 2, 3);
+		GITERR_CHECK_ALLOC_ADD(&newsize, pb->nr_alloc, 1024);
+		GITERR_CHECK_ALLOC_MULTIPLY(&newsize, newsize, 3 / 2);
 
 		if (!git__is_uint32(newsize)) {
-			git_error_set(GIT_ERROR_NOMEMORY, "packfile too large to fit in memory.");
+			giterr_set(GITERR_NOMEMORY, "packfile too large to fit in memory.");
 			return -1;
 		}
 
@@ -234,10 +230,8 @@ int git_packbuilder_insert(git_packbuilder *pb, const git_oid *oid,
 
 		pb->object_list = git__reallocarray(pb->object_list,
 			pb->nr_alloc, sizeof(*po));
-		GIT_ERROR_CHECK_ALLOC(pb->object_list);
-
-		if (rehash(pb) < 0)
-			return -1;
+		GITERR_CHECK_ALLOC(pb->object_list);
+		rehash(pb);
 	}
 
 	po = pb->object_list + pb->nr_objects;
@@ -250,10 +244,13 @@ int git_packbuilder_insert(git_packbuilder *pb, const git_oid *oid,
 	git_oid_cpy(&po->id, oid);
 	po->hash = name_hash(name);
 
-	if (git_oidmap_set(pb->object_ix, &po->id, po) < 0) {
-		git_error_set_oom();
-		return -1;
+	pos = git_oidmap_put(pb->object_ix, &po->id, &ret);
+	if (ret < 0) {
+		giterr_set_oom();
+		return ret;
 	}
+	assert(ret != 0);
+	git_oidmap_set_value_at(pb->object_ix, pos, po);
 
 	pb->done = false;
 
@@ -269,7 +266,7 @@ int git_packbuilder_insert(git_packbuilder *pb, const git_oid *oid,
 				pb->nr_objects, 0, pb->progress_cb_payload);
 
 			if (ret)
-				return git_error_set_after_callback(ret);
+				return giterr_set_after_callback(ret);
 		}
 	}
 
@@ -298,7 +295,7 @@ static int get_delta(void **out, git_odb *odb, git_pobject *po)
 		goto on_error;
 
 	if (error == GIT_EBUFS || delta_size != po->delta_size) {
-		git_error_set(GIT_ERROR_INVALID, "delta size changed");
+		giterr_set(GITERR_INVALID, "delta size changed");
 		goto on_error;
 	}
 
@@ -321,7 +318,7 @@ static int write_object(
 	void *cb_data)
 {
 	git_odb_object *obj = NULL;
-	git_object_t type;
+	git_otype type;
 	unsigned char hdr[10], *zbuf = NULL;
 	void *data = NULL;
 	size_t hdr_len, zbuf_len = COMPRESS_BUFLEN, data_len;
@@ -339,7 +336,7 @@ static int write_object(
 				goto done;
 
 		data_len = po->delta_size;
-		type = GIT_OBJECT_REF_DELTA;
+		type = GIT_OBJ_REF_DELTA;
 	} else {
 		if ((error = git_odb_read(&obj, pb->odb, &po->id)) < 0)
 			goto done;
@@ -356,7 +353,7 @@ static int write_object(
 		(error = git_hash_update(&pb->ctx, hdr, hdr_len)) < 0)
 		goto done;
 
-	if (type == GIT_OBJECT_REF_DELTA) {
+	if (type == GIT_OBJ_REF_DELTA) {
 		if ((error = write_cb(po->delta->id.id, GIT_OID_RAWSZ, cb_data)) < 0 ||
 			(error = git_hash_update(&pb->ctx, po->delta->id.id, GIT_OID_RAWSZ)) < 0)
 			goto done;
@@ -371,7 +368,7 @@ static int write_object(
 			goto done;
 	} else {
 		zbuf = git__malloc(zbuf_len);
-		GIT_ERROR_CHECK_ALLOC(zbuf);
+		GITERR_CHECK_ALLOC(zbuf);
 
 		git_zstream_reset(&pb->zstream);
 		git_zstream_set_input(&pb->zstream, data, data_len);
@@ -513,12 +510,15 @@ static int cb_tag_foreach(const char *name, git_oid *oid, void *data)
 {
 	git_packbuilder *pb = data;
 	git_pobject *po;
+	khiter_t pos;
 
 	GIT_UNUSED(name);
 
-	if ((po = git_oidmap_get(pb->object_ix, oid)) == NULL)
+	pos = git_oidmap_lookup_index(pb->object_ix, oid);
+	if (!git_oidmap_valid_index(pb->object_ix, pos))
 		return 0;
 
+	po = git_oidmap_value_at(pb->object_ix, pos);
 	po->tagged = 1;
 
 	/* TODO: peel objects */
@@ -590,8 +590,8 @@ static git_pobject **compute_write_order(git_packbuilder *pb)
 	 */
 	for (i = last_untagged; i < pb->nr_objects; i++) {
 		git_pobject *po = pb->object_list + i;
-		if (po->type != GIT_OBJECT_COMMIT &&
-		    po->type != GIT_OBJECT_TAG)
+		if (po->type != GIT_OBJ_COMMIT &&
+		    po->type != GIT_OBJ_TAG)
 			continue;
 		add_to_write_order(wo, &wo_end, po);
 	}
@@ -601,7 +601,7 @@ static git_pobject **compute_write_order(git_packbuilder *pb)
 	 */
 	for (i = last_untagged; i < pb->nr_objects; i++) {
 		git_pobject *po = pb->object_list + i;
-		if (po->type != GIT_OBJECT_TREE)
+		if (po->type != GIT_OBJ_TREE)
 			continue;
 		add_to_write_order(wo, &wo_end, po);
 	}
@@ -617,7 +617,7 @@ static git_pobject **compute_write_order(git_packbuilder *pb)
 
 	if (wo_end != pb->nr_objects) {
 		git__free(wo);
-		git_error_set(GIT_ERROR_INVALID, "invalid write order");
+		giterr_set(GITERR_INVALID, "invalid write order");
 		return NULL;
 	}
 
@@ -641,7 +641,7 @@ static int write_pack(git_packbuilder *pb,
 		return -1;
 
 	if (!git__is_uint32(pb->nr_objects)) {
-		git_error_set(GIT_ERROR_INVALID, "too many objects");
+		giterr_set(GITERR_INVALID, "too many objects");
 		return -1;
 	}
 
@@ -798,13 +798,13 @@ static int try_delta(git_packbuilder *pb, struct unpacked *trg,
 
 		sz = git_odb_object_size(obj);
 		trg->data = git__malloc(sz);
-		GIT_ERROR_CHECK_ALLOC(trg->data);
+		GITERR_CHECK_ALLOC(trg->data);
 		memcpy(trg->data, git_odb_object_data(obj), sz);
 
 		git_odb_object_free(obj);
 
 		if (sz != trg_size) {
-			git_error_set(GIT_ERROR_INVALID,
+			giterr_set(GITERR_INVALID,
 				   "inconsistent target object length");
 			return -1;
 		}
@@ -820,13 +820,13 @@ static int try_delta(git_packbuilder *pb, struct unpacked *trg,
 
 		sz = obj_sz;
 		src->data = git__malloc(sz);
-		GIT_ERROR_CHECK_ALLOC(src->data);
+		GITERR_CHECK_ALLOC(src->data);
 		memcpy(src->data, git_odb_object_data(obj), sz);
 
 		git_odb_object_free(obj);
 
 		if (sz != src_size) {
-			git_error_set(GIT_ERROR_INVALID,
+			giterr_set(GITERR_INVALID,
 				   "inconsistent source object length");
 			return -1;
 		}
@@ -872,7 +872,7 @@ static int try_delta(git_packbuilder *pb, struct unpacked *trg,
 		}
 
 		trg_object->delta_data = git__realloc(delta_buf, delta_size);
-		GIT_ERROR_CHECK_ALLOC(trg_object->delta_data);
+		GITERR_CHECK_ALLOC(trg_object->delta_data);
 	} else {
 		/* create delta when writing the pack */
 		git_packbuilder__cache_unlock(pb);
@@ -938,7 +938,7 @@ static int report_delta_progress(
 				count, pb->nr_objects, pb->progress_cb_payload);
 
 			if (ret)
-				return git_error_set_after_callback(ret);
+				return giterr_set_after_callback(ret);
 		}
 	}
 
@@ -957,7 +957,7 @@ static int find_deltas(git_packbuilder *pb, git_pobject **list,
 	int error = -1;
 
 	array = git__calloc(window, sizeof(struct unpacked));
-	GIT_ERROR_CHECK_ALLOC(array);
+	GITERR_CHECK_ALLOC(array);
 
 	for (;;) {
 		struct unpacked *n = array + idx;
@@ -1043,7 +1043,7 @@ static int find_deltas(git_packbuilder *pb, git_pobject **list,
 
 			git__free(po->delta_data);
 			po->delta_data = git__malloc(zbuf.size);
-			GIT_ERROR_CHECK_ALLOC(po->delta_data);
+			GITERR_CHECK_ALLOC(po->delta_data);
 
 			memcpy(po->delta_data, zbuf.ptr, zbuf.size);
 			po->z_delta_size = zbuf.size;
@@ -1095,7 +1095,7 @@ on_error:
 		git__free(array[i].data);
 	}
 	git__free(array);
-	git_buf_dispose(&zbuf);
+	git_buf_free(&zbuf);
 
 	return error;
 }
@@ -1136,7 +1136,7 @@ static void *threaded_find_deltas(void *arg)
 		git_packbuilder__progress_unlock(me->pb);
 
 		if (git_mutex_lock(&me->mutex)) {
-			git_error_set(GIT_ERROR_THREAD, "unable to lock packfile condition mutex");
+			giterr_set(GITERR_THREAD, "unable to lock packfile condition mutex");
 			return NULL;
 		}
 
@@ -1174,7 +1174,7 @@ static int ll_find_deltas(git_packbuilder *pb, git_pobject **list,
 	}
 
 	p = git__mallocarray(pb->nr_threads, sizeof(*p));
-	GIT_ERROR_CHECK_ALLOC(p);
+	GITERR_CHECK_ALLOC(p);
 
 	/* Partition the work among the threads */
 	for (i = 0; i < pb->nr_threads; ++i) {
@@ -1215,7 +1215,7 @@ static int ll_find_deltas(git_packbuilder *pb, git_pobject **list,
 		ret = git_thread_create(&p[i].thread,
 					threaded_find_deltas, &p[i]);
 		if (ret) {
-			git_error_set(GIT_ERROR_THREAD, "unable to create thread");
+			giterr_set(GITERR_THREAD, "unable to create thread");
 			return -1;
 		}
 		active_threads++;
@@ -1284,7 +1284,7 @@ static int ll_find_deltas(git_packbuilder *pb, git_pobject **list,
 		git_packbuilder__progress_unlock(pb);
 
 		if (git_mutex_lock(&target->mutex)) {
-			git_error_set(GIT_ERROR_THREAD, "unable to lock packfile condition mutex");
+			giterr_set(GITERR_THREAD, "unable to lock packfile condition mutex");
 			git__free(p);
 			return -1;
 		}
@@ -1325,7 +1325,7 @@ static int prepare_pack(git_packbuilder *pb)
 			pb->progress_cb(GIT_PACKBUILDER_DELTAFICATION, 0, pb->nr_objects, pb->progress_cb_payload);
 
 	delta_list = git__mallocarray(pb->nr_objects, sizeof(*delta_list));
-	GIT_ERROR_CHECK_ALLOC(delta_list);
+	GITERR_CHECK_ALLOC(delta_list);
 
 	for (i = 0; i < pb->nr_objects; ++i) {
 		git_pobject *po = pb->object_list + i;
@@ -1379,25 +1379,21 @@ int git_packbuilder_write(
 	git_packbuilder *pb,
 	const char *path,
 	unsigned int mode,
-	git_indexer_progress_cb progress_cb,
+	git_transfer_progress_cb progress_cb,
 	void *progress_cb_payload)
 {
-	git_indexer_options opts = GIT_INDEXER_OPTIONS_INIT;
 	git_indexer *indexer;
-	git_indexer_progress stats;
+	git_transfer_progress stats;
 	struct pack_write_context ctx;
 	int t;
 
 	PREPARE_PACK;
 
-	opts.progress_cb = progress_cb;
-	opts.progress_cb_payload = progress_cb_payload;
-
 	if (git_indexer_new(
-		&indexer, path, mode, pb->odb, &opts) < 0)
+		&indexer, path, mode, pb->odb, progress_cb, progress_cb_payload) < 0)
 		return -1;
 
-	if (!git_repository__configmap_lookup(&t, pb->repo, GIT_CONFIGMAP_FSYNCOBJECTFILES) && t)
+	if (!git_repository__cvar(&t, pb->repo, GIT_CVAR_FSYNCOBJECTFILES) && t)
 		git_indexer__set_fsync(indexer, 1);
 
 	ctx.indexer = indexer;
@@ -1430,7 +1426,7 @@ static int cb_tree_walk(
 	struct tree_walk_context *ctx = payload;
 
 	/* A commit inside a tree represents a submodule commit and should be skipped. */
-	if (git_tree_entry_type(entry) == GIT_OBJECT_COMMIT)
+	if (git_tree_entry_type(entry) == GIT_OBJ_COMMIT)
 		return 0;
 
 	if (!(error = git_buf_sets(&ctx->buf, root)) &&
@@ -1467,7 +1463,7 @@ int git_packbuilder_insert_tree(git_packbuilder *pb, const git_oid *oid)
 		error = git_tree_walk(tree, GIT_TREEWALK_PRE, cb_tree_walk, &context);
 
 	git_tree_free(tree);
-	git_buf_dispose(&context.buf);
+	git_buf_free(&context.buf);
 	return error;
 }
 
@@ -1478,27 +1474,27 @@ int git_packbuilder_insert_recur(git_packbuilder *pb, const git_oid *id, const c
 
 	assert(pb && id);
 
-	if ((error = git_object_lookup(&obj, pb->repo, id, GIT_OBJECT_ANY)) < 0)
+	if ((error = git_object_lookup(&obj, pb->repo, id, GIT_OBJ_ANY)) < 0)
 		return error;
 
 	switch (git_object_type(obj)) {
-	case GIT_OBJECT_BLOB:
+	case GIT_OBJ_BLOB:
 		error = git_packbuilder_insert(pb, id, name);
 		break;
-	case GIT_OBJECT_TREE:
+	case GIT_OBJ_TREE:
 		error = git_packbuilder_insert_tree(pb, id);
 		break;
-	case GIT_OBJECT_COMMIT:
+	case GIT_OBJ_COMMIT:
 		error = git_packbuilder_insert_commit(pb, id);
 		break;
-	case GIT_OBJECT_TAG:
+	case GIT_OBJ_TAG:
 		if ((error = git_packbuilder_insert(pb, id, name)) < 0)
 			goto cleanup;
 		error = git_packbuilder_insert_recur(pb, git_tag_target_id((git_tag *) obj), NULL);
 		break;
 
 	default:
-		git_error_set(GIT_ERROR_INVALID, "unknown object type");
+		giterr_set(GITERR_INVALID, "unknown object type");
 		error = -1;
 	}
 
@@ -1517,13 +1513,13 @@ size_t git_packbuilder_written(git_packbuilder *pb)
 	return pb->nr_written;
 }
 
-static int lookup_walk_object(struct walk_object **out, git_packbuilder *pb, const git_oid *id)
+int lookup_walk_object(git_walk_object **out, git_packbuilder *pb, const git_oid *id)
 {
-	struct walk_object *obj;
+	git_walk_object *obj;
 
 	obj = git_pool_mallocz(&pb->object_pool, 1);
 	if (!obj) {
-		git_error_set_oom();
+		giterr_set_oom();
 		return -1;
 	}
 
@@ -1533,17 +1529,20 @@ static int lookup_walk_object(struct walk_object **out, git_packbuilder *pb, con
 	return 0;
 }
 
-static int retrieve_object(struct walk_object **out, git_packbuilder *pb, const git_oid *id)
+static int retrieve_object(git_walk_object **out, git_packbuilder *pb, const git_oid *id)
 {
-	struct walk_object *obj;
 	int error;
+	khiter_t pos;
+	git_walk_object *obj;
 
-	if ((obj = git_oidmap_get(pb->walk_objects, id)) == NULL) {
+	pos = git_oidmap_lookup_index(pb->walk_objects, id);
+	if (git_oidmap_valid_index(pb->walk_objects, pos)) {
+		obj = git_oidmap_value_at(pb->walk_objects, pos);
+	} else {
 		if ((error = lookup_walk_object(&obj, pb, id)) < 0)
 			return error;
 
-		if ((error = git_oidmap_set(pb->walk_objects, &obj->id, obj)) < 0)
-			return error;
+		git_oidmap_insert(pb->walk_objects, &obj->id, obj, &error);
 	}
 
 	*out = obj;
@@ -1553,7 +1552,7 @@ static int retrieve_object(struct walk_object **out, git_packbuilder *pb, const
 static int mark_blob_uninteresting(git_packbuilder *pb, const git_oid *id)
 {
 	int error;
-	struct walk_object *obj;
+	git_walk_object *obj;
 
 	if ((error = retrieve_object(&obj, pb, id)) < 0)
 		return error;
@@ -1565,7 +1564,7 @@ static int mark_blob_uninteresting(git_packbuilder *pb, const git_oid *id)
 
 static int mark_tree_uninteresting(git_packbuilder *pb, const git_oid *id)
 {
-	struct walk_object *obj;
+	git_walk_object *obj;
 	git_tree *tree;
 	int error;
 	size_t i;
@@ -1585,11 +1584,11 @@ static int mark_tree_uninteresting(git_packbuilder *pb, const git_oid *id)
 		const git_tree_entry *entry = git_tree_entry_byindex(tree, i);
 		const git_oid *entry_id = git_tree_entry_id(entry);
 		switch (git_tree_entry_type(entry)) {
-		case GIT_OBJECT_TREE:
+		case GIT_OBJ_TREE:
 			if ((error = mark_tree_uninteresting(pb, entry_id)) < 0)
 				goto cleanup;
 			break;
-		case GIT_OBJECT_BLOB:
+		case GIT_OBJ_BLOB:
 			if ((error = mark_blob_uninteresting(pb, entry_id)) < 0)
 				goto cleanup;
 			break;
@@ -1637,7 +1636,7 @@ int insert_tree(git_packbuilder *pb, git_tree *tree)
 	size_t i;
 	int error;
 	git_tree *subtree;
-	struct walk_object *obj;
+	git_walk_object *obj;
 	const char *name;
 
 	if ((error = retrieve_object(&obj, pb, git_tree_id(tree))) < 0)
@@ -1655,7 +1654,7 @@ int insert_tree(git_packbuilder *pb, git_tree *tree)
 		const git_tree_entry *entry = git_tree_entry_byindex(tree, i);
 		const git_oid *entry_id = git_tree_entry_id(entry);
 		switch (git_tree_entry_type(entry)) {
-		case GIT_OBJECT_TREE:
+		case GIT_OBJ_TREE:
 			if ((error = git_tree_lookup(&subtree, pb->repo, entry_id)) < 0)
 				return error;
 
@@ -1666,7 +1665,7 @@ int insert_tree(git_packbuilder *pb, git_tree *tree)
 				return error;
 
 			break;
-		case GIT_OBJECT_BLOB:
+		case GIT_OBJ_BLOB:
 			if ((error = retrieve_object(&obj, pb, entry_id)) < 0)
 				return error;
 			if (obj->uninteresting)
@@ -1685,7 +1684,7 @@ int insert_tree(git_packbuilder *pb, git_tree *tree)
 	return error;
 }
 
-int insert_commit(git_packbuilder *pb, struct walk_object *obj)
+int insert_commit(git_packbuilder *pb, git_walk_object *obj)
 {
 	int error;
 	git_commit *commit = NULL;
@@ -1715,7 +1714,7 @@ int git_packbuilder_insert_walk(git_packbuilder *pb, git_revwalk *walk)
 {
 	int error;
 	git_oid id;
-	struct walk_object *obj;
+	git_walk_object *obj;
 
 	assert(pb && walk);