rugged 0.27.10 → 0.27.10.1

data/vendor/libgit2/src/odb_mempack.c

@@ -10,7 +10,7 @@
 #include "git2/object.h"
 #include "git2/sys/odb_backend.h"
 #include "git2/sys/mempack.h"
-#include "futils.h"
+#include "fileops.h"
 #include "hash.h"
 #include "odb.h"
 #include "array.h"
@@ -23,7 +23,7 @@
 struct memobject {
 	git_oid oid;
 	size_t len;
-	git_object_t type;
+	git_otype type;
 	char data[GIT_FLEX_ARRAY];
 };
 
@@ -33,30 +33,36 @@ struct memory_packer_db {
 	git_array_t(struct memobject *) commits;
 };
 
-static int impl__write(git_odb_backend *_backend, const git_oid *oid, const void *data, size_t len, git_object_t type)
+static int impl__write(git_odb_backend *_backend, const git_oid *oid, const void *data, size_t len, git_otype type)
 {
 	struct memory_packer_db *db = (struct memory_packer_db *)_backend;
-	struct memobject *obj = NULL;
+	struct memobject *obj = NULL; 
+	khiter_t pos;
 	size_t alloc_len;
+	int rval;
+
+	pos = git_oidmap_put(db->objects, oid, &rval);
+	if (rval < 0)
+		return -1;
 
-	if (git_oidmap_exists(db->objects, oid))
+	if (rval == 0)
 		return 0;
 
-	GIT_ERROR_CHECK_ALLOC_ADD(&alloc_len, sizeof(struct memobject), len);
+	GITERR_CHECK_ALLOC_ADD(&alloc_len, sizeof(struct memobject), len);
 	obj = git__malloc(alloc_len);
-	GIT_ERROR_CHECK_ALLOC(obj);
+	GITERR_CHECK_ALLOC(obj);
 
 	memcpy(obj->data, data, len);
 	git_oid_cpy(&obj->oid, oid);
 	obj->len = len;
 	obj->type = type;
 
-	if (git_oidmap_set(db->objects, &obj->oid, obj) < 0)
-		return -1;
+	git_oidmap_set_key_at(db->objects, pos, &obj->oid);
+	git_oidmap_set_value_at(db->objects, pos, obj);
 
-	if (type == GIT_OBJECT_COMMIT) {
+	if (type == GIT_OBJ_COMMIT) {
 		struct memobject **store = git_array_alloc(db->commits);
-		GIT_ERROR_CHECK_ALLOC(store);
+		GITERR_CHECK_ALLOC(store);
 		*store = obj;
 	}
 
@@ -70,31 +76,39 @@ static int impl__exists(git_odb_backend *backend, const git_oid *oid)
 	return git_oidmap_exists(db->objects, oid);
 }
 
-static int impl__read(void **buffer_p, size_t *len_p, git_object_t *type_p, git_odb_backend *backend, const git_oid *oid)
+static int impl__read(void **buffer_p, size_t *len_p, git_otype *type_p, git_odb_backend *backend, const git_oid *oid)
 {
 	struct memory_packer_db *db = (struct memory_packer_db *)backend;
-	struct memobject *obj;
+	struct memobject *obj = NULL;
+	khiter_t pos;
 
-	if ((obj = git_oidmap_get(db->objects, oid)) == NULL)
+	pos = git_oidmap_lookup_index(db->objects, oid);
+	if (!git_oidmap_valid_index(db->objects, pos))
 		return GIT_ENOTFOUND;
 
+	obj = git_oidmap_value_at(db->objects, pos);
+
 	*len_p = obj->len;
 	*type_p = obj->type;
 	*buffer_p = git__malloc(obj->len);
-	GIT_ERROR_CHECK_ALLOC(*buffer_p);
+	GITERR_CHECK_ALLOC(*buffer_p);
 
 	memcpy(*buffer_p, obj->data, obj->len);
 	return 0;
 }
 
-static int impl__read_header(size_t *len_p, git_object_t *type_p, git_odb_backend *backend, const git_oid *oid)
+static int impl__read_header(size_t *len_p, git_otype *type_p, git_odb_backend *backend, const git_oid *oid)
 {
 	struct memory_packer_db *db = (struct memory_packer_db *)backend;
-	struct memobject *obj;
+	struct memobject *obj = NULL;
+	khiter_t pos;
 
-	if ((obj = git_oidmap_get(db->objects, oid)) == NULL)
+	pos = git_oidmap_lookup_index(db->objects, oid);
+	if (!git_oidmap_valid_index(db->objects, pos))
 		return GIT_ENOTFOUND;
 
+	obj = git_oidmap_value_at(db->objects, pos);
+
 	*len_p = obj->len;
 	*type_p = obj->type;
 	return 0;
@@ -155,10 +169,9 @@ int git_mempack_new(git_odb_backend **out)
 	assert(out);
 
 	db = git__calloc(1, sizeof(struct memory_packer_db));
-	GIT_ERROR_CHECK_ALLOC(db);
+	GITERR_CHECK_ALLOC(db);
 
-	if (git_oidmap_new(&db->objects) < 0)
-		return -1;
+	db->objects = git_oidmap_alloc();
 
 	db->parent.version = GIT_ODB_BACKEND_VERSION;
 	db->parent.read = &impl__read;

data/vendor/libgit2/src/odb_pack.c

@@ -11,7 +11,7 @@
 #include "git2/repository.h"
 #include "git2/indexer.h"
 #include "git2/sys/odb_backend.h"
-#include "futils.h"
+#include "fileops.h"
 #include "hash.h"
 #include "odb.h"
 #include "delta.h"
@@ -218,7 +218,7 @@ static int packfile_load__cb(void *data, git_buf *path)
 
 	/* ignore missing .pack file as git does */
 	if (error == GIT_ENOTFOUND) {
-		git_error_clear();
+		giterr_clear();
 		return 0;
 	}
 
@@ -346,14 +346,14 @@ static int pack_backend__refresh(git_odb_backend *backend_)
 	/* reload all packs */
 	error = git_path_direach(&path, 0, packfile_load__cb, backend);
 
-	git_buf_dispose(&path);
+	git_buf_free(&path);
 	git_vector_sort(&backend->packs);
 
 	return error;
 }
 
 static int pack_backend__read_header(
-	size_t *len_p, git_object_t *type_p,
+	size_t *len_p, git_otype *type_p,
 	struct git_odb_backend *backend, const git_oid *oid)
 {
 	struct git_pack_entry e;
@@ -390,7 +390,7 @@ static int pack_backend__freshen(
 }
 
 static int pack_backend__read(
-	void **buffer_p, size_t *len_p, git_object_t *type_p,
+	void **buffer_p, size_t *len_p, git_otype *type_p,
 	git_odb_backend *backend, const git_oid *oid)
 {
 	struct git_pack_entry e;
@@ -412,7 +412,7 @@ static int pack_backend__read_prefix(
 	git_oid *out_oid,
 	void **buffer_p,
 	size_t *len_p,
-	git_object_t *type_p,
+	git_otype *type_p,
 	git_odb_backend *backend,
 	const git_oid *short_oid,
 	size_t len)
@@ -478,14 +478,14 @@ static int pack_backend__foreach(git_odb_backend *_backend, git_odb_foreach_cb c
 		return error;
 
 	git_vector_foreach(&backend->packs, i, p) {
-		if ((error = git_pack_foreach_entry(p, cb, data)) != 0)
+		if ((error = git_pack_foreach_entry(p, cb, data)) < 0)
 			return error;
 	}
 
 	return 0;
 }
 
-static int pack_backend__writepack_append(struct git_odb_writepack *_writepack, const void *data, size_t size, git_indexer_progress *stats)
+static int pack_backend__writepack_append(struct git_odb_writepack *_writepack, const void *data, size_t size, git_transfer_progress *stats)
 {
 	struct pack_writepack *writepack = (struct pack_writepack *)_writepack;
 
@@ -494,7 +494,7 @@ static int pack_backend__writepack_append(struct git_odb_writepack *_writepack,
 	return git_indexer_append(writepack->indexer, data, size, stats);
 }
 
-static int pack_backend__writepack_commit(struct git_odb_writepack *_writepack, git_indexer_progress *stats)
+static int pack_backend__writepack_commit(struct git_odb_writepack *_writepack, git_transfer_progress *stats)
 {
 	struct pack_writepack *writepack = (struct pack_writepack *)_writepack;
 
@@ -516,10 +516,9 @@ static void pack_backend__writepack_free(struct git_odb_writepack *_writepack)
 static int pack_backend__writepack(struct git_odb_writepack **out,
 	git_odb_backend *_backend,
         git_odb *odb,
-	git_indexer_progress_cb progress_cb,
+	git_transfer_progress_cb progress_cb,
 	void *progress_payload)
 {
-	git_indexer_options opts = GIT_INDEXER_OPTIONS_INIT;
 	struct pack_backend *backend;
 	struct pack_writepack *writepack;
 
@@ -527,16 +526,13 @@ static int pack_backend__writepack(struct git_odb_writepack **out,
 
 	*out = NULL;
 
-	opts.progress_cb = progress_cb;
-	opts.progress_cb_payload = progress_payload;
-
 	backend = (struct pack_backend *)_backend;
 
 	writepack = git__calloc(1, sizeof(struct pack_writepack));
-	GIT_ERROR_CHECK_ALLOC(writepack);
+	GITERR_CHECK_ALLOC(writepack);
 
 	if (git_indexer_new(&writepack->indexer,
-		backend->pack_folder, 0, odb, &opts) < 0) {
+		backend->pack_folder, 0, odb, progress_cb, progress_payload) < 0) {
 		git__free(writepack);
 		return -1;
 	}
@@ -573,7 +569,7 @@ static void pack_backend__free(git_odb_backend *_backend)
 static int pack_backend__alloc(struct pack_backend **out, size_t initial_size)
 {
 	struct pack_backend *backend = git__calloc(1, sizeof(struct pack_backend));
-	GIT_ERROR_CHECK_ALLOC(backend);
+	GITERR_CHECK_ALLOC(backend);
 
 	if (git_vector_init(&backend->packs, initial_size, packfile_sort__cb) < 0) {
 		git__free(backend);
@@ -639,7 +635,7 @@ int git_odb_backend_pack(git_odb_backend **backend_out, const char *objects_dir)
 
 	*backend_out = (git_odb_backend *)backend;
 
-	git_buf_dispose(&path);
+	git_buf_free(&path);
 
 	return error;
 }

data/vendor/libgit2/src/offmap.c

@@ -7,24 +7,11 @@
 
 #include "offmap.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_IMPL(off, static kh_inline, git_off_t, void *, 1, kh_int64_hash_func, kh_int64_hash_equal)
 
-__KHASH_TYPE(off, off64_t, void *)
-
-__KHASH_IMPL(off, static kh_inline, off64_t, void *, 1, kh_int64_hash_func, kh_int64_hash_equal)
-
-
-int git_offmap_new(git_offmap **out)
+git_offmap *git_offmap_alloc(void)
 {
-	*out = kh_init(off);
-	GIT_ERROR_CHECK_ALLOC(*out);
-
-	return 0;
+	return kh_init(off);
 }
 
 void git_offmap_free(git_offmap *map)
@@ -37,65 +24,60 @@ void git_offmap_clear(git_offmap *map)
 	kh_clear(off, map);
 }
 
-size_t git_offmap_size(git_offmap *map)
+size_t git_offmap_num_entries(git_offmap *map)
 {
 	return kh_size(map);
 }
 
-void *git_offmap_get(git_offmap *map, const off64_t key)
+size_t git_offmap_lookup_index(git_offmap *map, const git_off_t key)
 {
-	size_t idx = kh_get(off, map, key);
-	if (idx == kh_end(map) || !kh_exist(map, idx))
-		return NULL;
-	return kh_val(map, idx);
+	return kh_get(off, map, key);
 }
 
-int git_offmap_set(git_offmap *map, const off64_t key, void *value)
+int git_offmap_valid_index(git_offmap *map, size_t idx)
 {
-	size_t idx;
-	int rval;
+	return idx != kh_end(map);
+}
 
-	idx = kh_put(off, map, key, &rval);
-	if (rval < 0)
-		return -1;
+int git_offmap_exists(git_offmap *map, const git_off_t key)
+{
+	return kh_get(off, map, key) != kh_end(map);
+}
 
-	if (rval == 0)
-		kh_key(map, idx) = key;
+void *git_offmap_value_at(git_offmap *map, size_t idx)
+{
+	return kh_val(map, idx);
+}
 
+void git_offmap_set_value_at(git_offmap *map, size_t idx, void *value)
+{
 	kh_val(map, idx) = value;
-
-	return 0;
 }
 
-int git_offmap_delete(git_offmap *map, const off64_t key)
+void git_offmap_delete_at(git_offmap *map, size_t idx)
 {
-	khiter_t idx = kh_get(off, map, key);
-	if (idx == kh_end(map))
-		return GIT_ENOTFOUND;
 	kh_del(off, map, idx);
-	return 0;
 }
 
-int git_offmap_exists(git_offmap *map, const off64_t key)
+int git_offmap_put(git_offmap *map, const git_off_t key, int *err)
 {
-	return kh_get(off, map, key) != kh_end(map);
+	return kh_put(off, map, key, err);
 }
 
-int git_offmap_iterate(void **value, git_offmap *map, size_t *iter, off64_t *key)
+void git_offmap_insert(git_offmap *map, const git_off_t key, void *value, int *rval)
 {
-	size_t i = *iter;
+	khiter_t idx = kh_put(off, map, key, rval);
 
-	while (i < map->n_buckets && !kh_exist(map, i))
-		i++;
-
-	if (i >= map->n_buckets)
-		return GIT_ITEROVER;
-
-	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_offmap_delete(git_offmap *map, const git_off_t key)
+{
+	khiter_t idx = git_offmap_lookup_index(map, key);
+	if (git_offmap_valid_index(map, idx))
+		git_offmap_delete_at(map, idx);
 }

data/vendor/libgit2/src/offmap.h

@@ -11,123 +11,36 @@
 
 #include "git2/types.h"
 
-/** A map with `off64_t`s as key. */
-typedef struct kh_off_s git_offmap;
+#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 `off64_t` map.
- *
- * @param out Pointer to the map that shall be allocated.
- * @return 0 on success, an error code if allocation has failed.
- */
-int git_offmap_new(git_offmap **out);
+__KHASH_TYPE(off, git_off_t, void *)
+typedef khash_t(off) git_offmap;
 
-/**
- * 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_offmap *git_offmap_alloc(void);
 void git_offmap_free(git_offmap *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_offmap_clear(git_offmap *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_offmap_size(git_offmap *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_offmap_get(git_offmap *map, const off64_t key);
-
-/**
- * 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_offmap_set(git_offmap *map, const off64_t key, void *value);
+size_t git_offmap_num_entries(git_offmap *map);
 
-/**
- * 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_offmap_delete(git_offmap *map, const off64_t key);
+size_t git_offmap_lookup_index(git_offmap *map, const git_off_t key);
+int git_offmap_valid_index(git_offmap *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_offmap_exists(git_offmap *map, const off64_t key);
+int git_offmap_exists(git_offmap *map, const git_off_t 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_offmap_iterate(void **value, git_offmap *map, size_t *iter, off64_t *key);
+void *git_offmap_value_at(git_offmap *map, size_t idx);
+void git_offmap_set_value_at(git_offmap *map, size_t idx, void *value);
+void git_offmap_delete_at(git_offmap *map, size_t idx);
 
-#define git_offmap_foreach(h, kvar, vvar, code) { size_t __i = 0;		\
-	while (git_offmap_iterate((void **) &(vvar), h, &__i, &(kvar)) == 0) {	\
-		code;								\
-	} }
+int git_offmap_put(git_offmap *map, const git_off_t key, int *err);
+void git_offmap_insert(git_offmap *map, const git_off_t key, void *value, int *rval);
+void git_offmap_delete(git_offmap *map, const git_off_t key);
 
-#define git_offmap_foreach_value(h, vvar, code) { size_t __i = 0;		\
-	while (git_offmap_iterate((void **) &(vvar), h, &__i, NULL) == 0) {	\
-		code;								\
-	} }
+#define git_offmap_foreach		kh_foreach
+#define git_offmap_foreach_value	kh_foreach_value
 
 #endif