rugged 0.27.10 → 0.27.10.1

data/vendor/libgit2/src/blob.h

@@ -12,32 +12,15 @@
 #include "git2/blob.h"
 #include "repository.h"
 #include "odb.h"
-#include "futils.h"
+#include "fileops.h"
 
 struct git_blob {
 	git_object object;
-
-	union {
-		git_odb_object *odb;
-		struct {
-			const char *data;
-			git_object_size_t size;
-		} raw;
-	} data;
-	unsigned int raw:1;
+	git_odb_object *odb_object;
 };
 
-#define GIT_ERROR_CHECK_BLOBSIZE(n) \
-	do { \
-		if (!git__is_sizet(n)) { \
-			git_error_set(GIT_ERROR_NOMEMORY, "blob contents too large to fit in memory"); \
-			return -1; \
-		} \
-	} while(0)
-
 void git_blob__free(void *blob);
 int git_blob__parse(void *blob, git_odb_object *obj);
-int git_blob__parse_raw(void *blob, const char *data, size_t size);
 int git_blob__getbuf(git_buf *buffer, git_blob *blob);
 
 extern int git_blob__create_from_paths(

data/vendor/libgit2/src/branch.c

@@ -22,7 +22,7 @@ static int retrieve_branch_reference(
 	git_reference **branch_reference_out,
 	git_repository *repo,
 	const char *branch_name,
-	bool is_remote)
+	int is_remote)
 {
 	git_reference *branch = NULL;
 	int error = 0;
@@ -34,20 +34,20 @@ static int retrieve_branch_reference(
 	if ((error = git_buf_joinpath(&ref_name, prefix, branch_name)) < 0)
 		/* OOM */;
 	else if ((error = git_reference_lookup(&branch, repo, ref_name.ptr)) < 0)
-		git_error_set(
-			GIT_ERROR_REFERENCE, "cannot locate %s branch '%s'",
+		giterr_set(
+			GITERR_REFERENCE, "cannot locate %s branch '%s'",
 			is_remote ? "remote-tracking" : "local", branch_name);
 
 	*branch_reference_out = branch; /* will be NULL on error */
 
-	git_buf_dispose(&ref_name);
+	git_buf_free(&ref_name);
 	return error;
 }
 
 static int not_a_local_branch(const char *reference_name)
 {
-	git_error_set(
-		GIT_ERROR_INVALID,
+	giterr_set(
+		GITERR_INVALID,
 		"reference '%s' is not a local branch.", reference_name);
 	return -1;
 }
@@ -71,7 +71,7 @@ static int create_branch(
 	assert(git_object_owner((const git_object *)commit) == repository);
 
 	if (!git__strcmp(branch_name, "HEAD")) {
-		git_error_set(GIT_ERROR_REFERENCE, "'HEAD' is not a valid branch name");
+		giterr_set(GITERR_REFERENCE, "'HEAD' is not a valid branch name");
 		error = -1;
 		goto cleanup;
 	}
@@ -88,7 +88,7 @@ static int create_branch(
 	}
 
 	if (is_unmovable_head && force) {
-		git_error_set(GIT_ERROR_REFERENCE, "cannot force update branch '%s' as it is "
+		giterr_set(GITERR_REFERENCE, "cannot force update branch '%s' as it is "
 			"the current HEAD of the repository.", branch_name);
 		error = -1;
 		goto cleanup;
@@ -108,8 +108,8 @@ static int create_branch(
 		*ref_out = branch;
 
 cleanup:
-	git_buf_dispose(&canonical_branch_name);
-	git_buf_dispose(&log_message);
+	git_buf_free(&canonical_branch_name);
+	git_buf_free(&log_message);
 	return error;
 }
 
@@ -141,7 +141,7 @@ static int branch_equals(git_repository *repo, const char *path, void *payload)
 	int equal = 0;
 
 	if (git_reference__read_head(&head, repo, path) < 0 ||
-		git_reference_type(head) != GIT_REFERENCE_SYMBOLIC)
+		git_reference_type(head) != GIT_REF_SYMBOLIC)
 		goto done;
 
 	equal = !git__strcmp(head->target.symbolic, branch->name);
@@ -153,20 +153,10 @@ done:
 
 int git_branch_is_checked_out(const git_reference *branch)
 {
-	git_repository *repo;
-	int flags = 0;
-
-	assert(branch);
+	assert(branch && git_reference_is_branch(branch));
 
-	if (!git_reference_is_branch(branch))
-		return 0;
-
-	repo = git_reference_owner(branch);
-
-	if (git_repository_is_bare(repo))
-		flags |= GIT_REPOSITORY_FOREACH_HEAD_SKIP_REPO;
-
-	return git_repository_foreach_head(repo, branch_equals, flags, (void *) branch) == 1;
+	return git_repository_foreach_head(git_reference_owner(branch),
+		branch_equals, (void *) branch) == 1;
 }
 
 int git_branch_delete(git_reference *branch)
@@ -178,7 +168,7 @@ int git_branch_delete(git_reference *branch)
 	assert(branch);
 
 	if (!git_reference_is_branch(branch) && !git_reference_is_remote(branch)) {
-		git_error_set(GIT_ERROR_INVALID, "reference '%s' is not a valid branch.",
+		giterr_set(GITERR_INVALID, "reference '%s' is not a valid branch.",
 			git_reference_name(branch));
 		return GIT_ENOTFOUND;
 	}
@@ -187,13 +177,13 @@ int git_branch_delete(git_reference *branch)
 		return is_head;
 
 	if (is_head) {
-		git_error_set(GIT_ERROR_REFERENCE, "cannot delete branch '%s' as it is "
+		giterr_set(GITERR_REFERENCE, "cannot delete branch '%s' as it is "
 			"the current HEAD of the repository.", git_reference_name(branch));
 		return -1;
 	}
 
 	if (git_reference_is_branch(branch) && git_branch_is_checked_out(branch)) {
-		git_error_set(GIT_ERROR_REFERENCE, "Cannot delete branch '%s' as it is "
+		giterr_set(GITERR_REFERENCE, "Cannot delete branch '%s' as it is "
 			"the current HEAD of a linked repository.", git_reference_name(branch));
 		return -1;
 	}
@@ -209,7 +199,7 @@ int git_branch_delete(git_reference *branch)
 	error = git_reference_delete(branch);
 
 on_error:
-	git_buf_dispose(&config_section);
+	git_buf_free(&config_section);
 	return error;
 }
 
@@ -253,7 +243,7 @@ int git_branch_iterator_new(
 	branch_iter *iter;
 
 	iter = git__calloc(1, sizeof(branch_iter));
-	GIT_ERROR_CHECK_ALLOC(iter);
+	GITERR_CHECK_ALLOC(iter);
 
 	iter->flags = list_flags;
 
@@ -320,10 +310,10 @@ int git_branch_move(
 		git_buf_cstr(&new_config_section));
 
 done:
-	git_buf_dispose(&new_reference_name);
-	git_buf_dispose(&old_config_section);
-	git_buf_dispose(&new_config_section);
-	git_buf_dispose(&log_message);
+	git_buf_free(&new_reference_name);
+	git_buf_free(&old_config_section);
+	git_buf_free(&new_config_section);
+	git_buf_free(&log_message);
 
 	return error;
 }
@@ -334,23 +324,9 @@ int git_branch_lookup(
 	const char *branch_name,
 	git_branch_t branch_type)
 {
-	int error = -1;
 	assert(ref_out && repo && branch_name);
 
-	switch (branch_type) {
-	case GIT_BRANCH_LOCAL:
-	case GIT_BRANCH_REMOTE:
-		error = retrieve_branch_reference(ref_out, repo, branch_name, branch_type == GIT_BRANCH_REMOTE);
-		break;
-	case GIT_BRANCH_ALL:
-		error = retrieve_branch_reference(ref_out, repo, branch_name, false);
-		if (error == GIT_ENOTFOUND)
-			error = retrieve_branch_reference(ref_out, repo, branch_name, true);
-		break;
-	default:
-		assert(false);
-	}
-	return error;
+	return retrieve_branch_reference(ref_out, repo, branch_name, branch_type == GIT_BRANCH_REMOTE);
 }
 
 int git_branch_name(
@@ -368,7 +344,7 @@ int git_branch_name(
 	} else if (git_reference_is_remote(ref)) {
 		branch_name += strlen(GIT_REFS_REMOTES_DIR);
 	} else {
-		git_error_set(GIT_ERROR_INVALID,
+		giterr_set(GITERR_INVALID,
 				"reference '%s' is neither a local nor a remote branch.", ref->name);
 		return -1;
 	}
@@ -390,7 +366,7 @@ static int retrieve_upstream_configuration(
 			return -1;
 
 	error = git_config_get_string_buf(out, config, git_buf_cstr(&buf));
-	git_buf_dispose(&buf);
+	git_buf_free(&buf);
 	return error;
 }
 
@@ -426,7 +402,7 @@ int git_branch_upstream_name(
 			goto cleanup;
 
 	if (git_buf_len(&remote_name) == 0 || git_buf_len(&merge_name) == 0) {
-		git_error_set(GIT_ERROR_REFERENCE,
+		giterr_set(GITERR_REFERENCE,
 			"branch '%s' does not have an upstream", refname);
 		error = GIT_ENOTFOUND;
 		goto cleanup;
@@ -453,9 +429,9 @@ int git_branch_upstream_name(
 cleanup:
 	git_config_free(config);
 	git_remote_free(remote);
-	git_buf_dispose(&remote_name);
-	git_buf_dispose(&merge_name);
-	git_buf_dispose(&buf);
+	git_buf_free(&remote_name);
+	git_buf_free(&merge_name);
+	git_buf_free(&buf);
 	return error;
 }
 
@@ -476,7 +452,7 @@ int git_branch_upstream_remote(git_buf *buf, git_repository *repo, const char *r
 		return error;
 
 	if (git_buf_len(buf) == 0) {
-		git_error_set(GIT_ERROR_REFERENCE, "branch '%s' does not have an upstream remote", refname);
+		giterr_set(GITERR_REFERENCE, "branch '%s' does not have an upstream remote", refname);
 		error = GIT_ENOTFOUND;
 		git_buf_clear(buf);
 	}
@@ -499,7 +475,7 @@ int git_branch_remote_name(git_buf *buf, git_repository *repo, const char *refna
 
 	/* Verify that this is a remote branch */
 	if (!git_reference__is_remote(refname)) {
-		git_error_set(GIT_ERROR_INVALID, "reference '%s' is not a remote branch.",
+		giterr_set(GITERR_INVALID, "reference '%s' is not a remote branch.",
 			refname);
 		error = GIT_ERROR;
 		goto cleanup;
@@ -525,7 +501,7 @@ int git_branch_remote_name(git_buf *buf, git_repository *repo, const char *refna
 			} else {
 				git_remote_free(remote);
 
-				git_error_set(GIT_ERROR_REFERENCE,
+				giterr_set(GITERR_REFERENCE,
 					"reference '%s' is ambiguous", refname);
 				error = GIT_EAMBIGUOUS;
 				goto cleanup;
@@ -539,14 +515,14 @@ int git_branch_remote_name(git_buf *buf, git_repository *repo, const char *refna
 		git_buf_clear(buf);
 		error = git_buf_puts(buf, remote_name);
 	} else {
-		git_error_set(GIT_ERROR_REFERENCE,
+		giterr_set(GITERR_REFERENCE,
 			"could not determine remote for '%s'", refname);
 		error = GIT_ENOTFOUND;
 	}
 
 cleanup:
 	if (error < 0)
-		git_buf_dispose(buf);
+		git_buf_free(buf);
 
 	git_strarray_free(&remote_list);
 	return error;
@@ -568,7 +544,7 @@ int git_branch_upstream(
 		git_reference_owner(branch),
 		git_buf_cstr(&tracking_name));
 
-	git_buf_dispose(&tracking_name);
+	git_buf_free(&tracking_name);
 	return error;
 }
 
@@ -589,11 +565,11 @@ static int unset_upstream(git_config *config, const char *shortname)
 	if (git_config_delete_entry(config, git_buf_cstr(&buf)) < 0)
 		goto on_error;
 
-	git_buf_dispose(&buf);
+	git_buf_free(&buf);
 	return 0;
 
 on_error:
-	git_buf_dispose(&buf);
+	git_buf_free(&buf);
 	return -1;
 }
 
@@ -628,7 +604,7 @@ int git_branch_set_upstream(git_reference *branch, const char *upstream_name)
 	else if (git_branch_lookup(&upstream, repo, upstream_name, GIT_BRANCH_REMOTE) == 0)
 		local = 0;
 	else {
-		git_error_set(GIT_ERROR_REFERENCE,
+		giterr_set(GITERR_REFERENCE,
 			"cannot set upstream for branch '%s'", shortname);
 		return GIT_ENOTFOUND;
 	}
@@ -679,15 +655,15 @@ int git_branch_set_upstream(git_reference *branch, const char *upstream_name)
 		goto on_error;
 
 	git_reference_free(upstream);
-	git_buf_dispose(&key);
-	git_buf_dispose(&value);
+	git_buf_free(&key);
+	git_buf_free(&value);
 
 	return 0;
 
 on_error:
 	git_reference_free(upstream);
-	git_buf_dispose(&key);
-	git_buf_dispose(&value);
+	git_buf_free(&key);
+	git_buf_free(&value);
 	git_remote_free(remote);
 
 	return -1;

data/vendor/libgit2/src/buf_text.c

@@ -29,7 +29,7 @@ int git_buf_text_puts_escaped(
 		scan += count;
 	}
 
-	GIT_ERROR_CHECK_ALLOC_ADD(&alloclen, total, 1);
+	GITERR_CHECK_ALLOC_ADD(&alloclen, total, 1);
 	if (git_buf_grow_by(buf, alloclen) < 0)
 		return -1;
 
@@ -75,7 +75,7 @@ int git_buf_text_crlf_to_lf(git_buf *tgt, const git_buf *src)
 		return git_buf_set(tgt, src->ptr, src->size);
 
 	/* reduce reallocs while in the loop */
-	GIT_ERROR_CHECK_ALLOC_ADD(&new_size, src->size, 1);
+	GITERR_CHECK_ALLOC_ADD(&new_size, src->size, 1);
 	if (git_buf_grow(tgt, new_size) < 0)
 		return -1;
 
@@ -122,8 +122,8 @@ int git_buf_text_lf_to_crlf(git_buf *tgt, const git_buf *src)
 		return git_buf_set(tgt, src->ptr, src->size);
 
 	/* attempt to reduce reallocs while in the loop */
-	GIT_ERROR_CHECK_ALLOC_ADD(&alloclen, src->size, src->size >> 4);
-	GIT_ERROR_CHECK_ALLOC_ADD(&alloclen, alloclen, 1);
+	GITERR_CHECK_ALLOC_ADD(&alloclen, src->size, src->size >> 4);
+	GITERR_CHECK_ALLOC_ADD(&alloclen, alloclen, 1);
 	if (git_buf_grow(tgt, alloclen) < 0)
 		return -1;
 	tgt->size = 0;
@@ -135,7 +135,7 @@ int git_buf_text_lf_to_crlf(git_buf *tgt, const git_buf *src)
 		if (copylen && next[-1] == '\r')
 			copylen--;
 
-		GIT_ERROR_CHECK_ALLOC_ADD(&alloclen, copylen, 3);
+		GITERR_CHECK_ALLOC_ADD(&alloclen, copylen, 3);
 		if (git_buf_grow_by(tgt, alloclen) < 0)
 			return -1;
 
@@ -310,7 +310,6 @@ bool git_buf_text_gather_stats(
 			}
 	}
 
-	/* Treat files with a bare CR as binary */
-	return (stats->cr != stats->crlf || stats->nul > 0 ||
+	return (stats->nul > 0 ||
 		((stats->printable >> 7) < stats->nonprintable));
 }

data/vendor/libgit2/src/buffer.c

@@ -18,8 +18,7 @@ char git_buf__initbuf[1];
 char git_buf__oom[1];
 
 #define ENSURE_SIZE(b, d) \
-	if ((b)->ptr == git_buf__oom || \
-	    ((d) > (b)->asize && git_buf_grow((b), (d)) < 0))\
+	if ((d) > (b)->asize && git_buf_grow((b), (d)) < 0)\
 		return -1;
 
 
@@ -44,7 +43,7 @@ int git_buf_try_grow(
 		return -1;
 
 	if (buf->asize == 0 && buf->size != 0) {
-		git_error_set(GIT_ERROR_INVALID, "cannot grow a borrowed buffer");
+		giterr_set(GITERR_INVALID, "cannot grow a borrowed buffer");
 		return GIT_EINVALID;
 	}
 
@@ -59,28 +58,22 @@ int git_buf_try_grow(
 		new_ptr = NULL;
 	} else {
 		new_size = buf->asize;
-		/*
-		 * Grow the allocated buffer by 1.5 to allow
-		 * re-use of memory holes resulting from the
-		 * realloc. If this is still too small, then just
-		 * use the target size.
-		 */
-		if ((new_size = (new_size << 1) - (new_size >> 1)) < target_size)
-			new_size = target_size;
 		new_ptr = buf->ptr;
 	}
 
+	/* grow the buffer size by 1.5, until it's big enough
+	 * to fit our target size */
+	while (new_size < target_size)
+		new_size = (new_size << 1) - (new_size >> 1);
+
 	/* round allocation up to multiple of 8 */
 	new_size = (new_size + 7) & ~7;
 
 	if (new_size < buf->size) {
-		if (mark_oom) {
-			if (buf->ptr && buf->ptr != git_buf__initbuf)
-				git__free(buf->ptr);
+		if (mark_oom)
 			buf->ptr = git_buf__oom;
-		}
 
-		git_error_set_oom();
+		giterr_set_oom();
 		return -1;
 	}
 
@@ -123,7 +116,7 @@ int git_buf_grow_by(git_buf *buffer, size_t additional_size)
 	return git_buf_try_grow(buffer, newsize, true);
 }
 
-void git_buf_dispose(git_buf *buf)
+void git_buf_free(git_buf *buf)
 {
 	if (!buf) return;
 
@@ -133,11 +126,6 @@ void git_buf_dispose(git_buf *buf)
 	git_buf_init(buf, 0);
 }
 
-void git_buf_free(git_buf *buf)
-{
-	git_buf_dispose(buf);
-}
-
 void git_buf_sanitize(git_buf *buf)
 {
 	if (buf->ptr == NULL) {
@@ -168,7 +156,7 @@ int git_buf_set(git_buf *buf, const void *data, size_t len)
 		git_buf_clear(buf);
 	} else {
 		if (data != buf->ptr) {
-			GIT_ERROR_CHECK_ALLOC_ADD(&alloclen, len, 1);
+			GITERR_CHECK_ALLOC_ADD(&alloclen, len, 1);
 			ENSURE_SIZE(buf, alloclen);
 			memmove(buf->ptr, data, len);
 		}
@@ -199,7 +187,7 @@ int git_buf_sets(git_buf *buf, const char *string)
 int git_buf_putc(git_buf *buf, char c)
 {
 	size_t new_size;
-	GIT_ERROR_CHECK_ALLOC_ADD(&new_size, buf->size, 2);
+	GITERR_CHECK_ALLOC_ADD(&new_size, buf->size, 2);
 	ENSURE_SIZE(buf, new_size);
 	buf->ptr[buf->size++] = c;
 	buf->ptr[buf->size] = '\0';
@@ -209,8 +197,8 @@ int git_buf_putc(git_buf *buf, char c)
 int git_buf_putcn(git_buf *buf, char c, size_t len)
 {
 	size_t new_size;
-	GIT_ERROR_CHECK_ALLOC_ADD(&new_size, buf->size, len);
-	GIT_ERROR_CHECK_ALLOC_ADD(&new_size, new_size, 1);
+	GITERR_CHECK_ALLOC_ADD(&new_size, buf->size, len);
+	GITERR_CHECK_ALLOC_ADD(&new_size, new_size, 1);
 	ENSURE_SIZE(buf, new_size);
 	memset(buf->ptr + buf->size, c, len);
 	buf->size += len;
@@ -225,8 +213,8 @@ int git_buf_put(git_buf *buf, const char *data, size_t len)
 
 		assert(data);
 
-		GIT_ERROR_CHECK_ALLOC_ADD(&new_size, buf->size, len);
-		GIT_ERROR_CHECK_ALLOC_ADD(&new_size, new_size, 1);
+		GITERR_CHECK_ALLOC_ADD(&new_size, buf->size, len);
+		GITERR_CHECK_ALLOC_ADD(&new_size, new_size, 1);
 		ENSURE_SIZE(buf, new_size);
 		memmove(buf->ptr + buf->size, data, len);
 		buf->size += len;
@@ -251,9 +239,9 @@ int git_buf_encode_base64(git_buf *buf, const char *data, size_t len)
 	const uint8_t *read = (const uint8_t *)data;
 	size_t blocks = (len / 3) + !!extra, alloclen;
 
-	GIT_ERROR_CHECK_ALLOC_ADD(&blocks, blocks, 1);
-	GIT_ERROR_CHECK_ALLOC_MULTIPLY(&alloclen, blocks, 4);
-	GIT_ERROR_CHECK_ALLOC_ADD(&alloclen, alloclen, buf->size);
+	GITERR_CHECK_ALLOC_ADD(&blocks, blocks, 1);
+	GITERR_CHECK_ALLOC_MULTIPLY(&alloclen, blocks, 4);
+	GITERR_CHECK_ALLOC_ADD(&alloclen, alloclen, buf->size);
 
 	ENSURE_SIZE(buf, alloclen);
 	write = (uint8_t *)&buf->ptr[buf->size];
@@ -313,13 +301,13 @@ int git_buf_decode_base64(git_buf *buf, const char *base64, size_t len)
 	size_t orig_size = buf->size, new_size;
 
 	if (len % 4) {
-		git_error_set(GIT_ERROR_INVALID, "invalid base64 input");
+		giterr_set(GITERR_INVALID, "invalid base64 input");
 		return -1;
 	}
 
 	assert(len % 4 == 0);
-	GIT_ERROR_CHECK_ALLOC_ADD(&new_size, (len / 4 * 3), buf->size);
-	GIT_ERROR_CHECK_ALLOC_ADD(&new_size, new_size, 1);
+	GITERR_CHECK_ALLOC_ADD(&new_size, (len / 4 * 3), buf->size);
+	GITERR_CHECK_ALLOC_ADD(&new_size, new_size, 1);
 	ENSURE_SIZE(buf, new_size);
 
 	for (i = 0; i < len; i += 4) {
@@ -330,7 +318,7 @@ int git_buf_decode_base64(git_buf *buf, const char *base64, size_t len)
 			buf->size = orig_size;
 			buf->ptr[buf->size] = '\0';
 
-			git_error_set(GIT_ERROR_INVALID, "invalid base64 input");
+			giterr_set(GITERR_INVALID, "invalid base64 input");
 			return -1;
 		}
 
@@ -350,9 +338,9 @@ int git_buf_encode_base85(git_buf *buf, const char *data, size_t len)
 {
 	size_t blocks = (len / 4) + !!(len % 4), alloclen;
 
-	GIT_ERROR_CHECK_ALLOC_MULTIPLY(&alloclen, blocks, 5);
-	GIT_ERROR_CHECK_ALLOC_ADD(&alloclen, alloclen, buf->size);
-	GIT_ERROR_CHECK_ALLOC_ADD(&alloclen, alloclen, 1);
+	GITERR_CHECK_ALLOC_MULTIPLY(&alloclen, blocks, 5);
+	GITERR_CHECK_ALLOC_ADD(&alloclen, alloclen, buf->size);
+	GITERR_CHECK_ALLOC_ADD(&alloclen, alloclen, 1);
 
 	ENSURE_SIZE(buf, alloclen);
 
@@ -415,12 +403,12 @@ int git_buf_decode_base85(
 
 	if (base85_len % 5 ||
 		output_len > base85_len * 4 / 5) {
-		git_error_set(GIT_ERROR_INVALID, "invalid base85 input");
+		giterr_set(GITERR_INVALID, "invalid base85 input");
 		return -1;
 	}
 
-	GIT_ERROR_CHECK_ALLOC_ADD(&new_size, output_len, buf->size);
-	GIT_ERROR_CHECK_ALLOC_ADD(&new_size, new_size, 1);
+	GITERR_CHECK_ALLOC_ADD(&new_size, output_len, buf->size);
+	GITERR_CHECK_ALLOC_ADD(&new_size, new_size, 1);
 	ENSURE_SIZE(buf, new_size);
 
 	while (output_len) {
@@ -447,7 +435,7 @@ int git_buf_decode_base85(
 
 		acc += de;
 
-		cnt = (output_len < 4) ? (int)output_len : 4;
+		cnt = (output_len < 4) ? output_len : 4;
 		output_len -= cnt;
 		do {
 			acc = (acc << 8) | (acc >> 24);
@@ -463,7 +451,7 @@ on_error:
 	buf->size = orig_size;
 	buf->ptr[buf->size] = '\0';
 
-	git_error_set(GIT_ERROR_INVALID, "invalid base85 input");
+	giterr_set(GITERR_INVALID, "invalid base85 input");
 	return -1;
 }
 
@@ -476,8 +464,8 @@ int git_buf_decode_percent(
 {
 	size_t str_pos, new_size;
 
-	GIT_ERROR_CHECK_ALLOC_ADD(&new_size, buf->size, str_len);
-	GIT_ERROR_CHECK_ALLOC_ADD(&new_size, new_size, 1);
+	GITERR_CHECK_ALLOC_ADD(&new_size, buf->size, str_len);
+	GITERR_CHECK_ALLOC_ADD(&new_size, new_size, 1);
 	ENSURE_SIZE(buf, new_size);
 
 	for (str_pos = 0; str_pos < str_len; buf->size++, str_pos++) {
@@ -502,8 +490,8 @@ int git_buf_vprintf(git_buf *buf, const char *format, va_list ap)
 	size_t expected_size, new_size;
 	int len;
 
-	GIT_ERROR_CHECK_ALLOC_MULTIPLY(&expected_size, strlen(format), 2);
-	GIT_ERROR_CHECK_ALLOC_ADD(&expected_size, expected_size, buf->size);
+	GITERR_CHECK_ALLOC_MULTIPLY(&expected_size, strlen(format), 2);
+	GITERR_CHECK_ALLOC_ADD(&expected_size, expected_size, buf->size);
 	ENSURE_SIZE(buf, expected_size);
 
 	while (1) {
@@ -529,8 +517,8 @@ int git_buf_vprintf(git_buf *buf, const char *format, va_list ap)
 			break;
 		}
 
-		GIT_ERROR_CHECK_ALLOC_ADD(&new_size, buf->size, len);
-		GIT_ERROR_CHECK_ALLOC_ADD(&new_size, new_size, 1);
+		GITERR_CHECK_ALLOC_ADD(&new_size, buf->size, len);
+		GITERR_CHECK_ALLOC_ADD(&new_size, new_size, 1);
 		ENSURE_SIZE(buf, new_size);
 	}
 
@@ -622,7 +610,7 @@ char *git_buf_detach(git_buf *buf)
 
 int git_buf_attach(git_buf *buf, char *ptr, size_t asize)
 {
-	git_buf_dispose(buf);
+	git_buf_free(buf);
 
 	if (ptr) {
 		buf->ptr = ptr;
@@ -640,7 +628,7 @@ int git_buf_attach(git_buf *buf, char *ptr, size_t asize)
 void git_buf_attach_notowned(git_buf *buf, const char *ptr, size_t size)
 {
 	if (git_buf_is_allocated(buf))
-		git_buf_dispose(buf);
+		git_buf_free(buf);
 
 	if (!size) {
 		git_buf_init(buf, 0);
@@ -674,10 +662,10 @@ int git_buf_join_n(git_buf *buf, char separator, int nbuf, ...)
 
 		segment_len = strlen(segment);
 
-		GIT_ERROR_CHECK_ALLOC_ADD(&total_size, total_size, segment_len);
+		GITERR_CHECK_ALLOC_ADD(&total_size, total_size, segment_len);
 
 		if (segment_len == 0 || segment[segment_len - 1] != separator)
-			GIT_ERROR_CHECK_ALLOC_ADD(&total_size, total_size, 1);
+			GITERR_CHECK_ALLOC_ADD(&total_size, total_size, 1);
 	}
 	va_end(ap);
 
@@ -685,7 +673,7 @@ int git_buf_join_n(git_buf *buf, char separator, int nbuf, ...)
 	if (total_size == 0)
 		return 0;
 
-	GIT_ERROR_CHECK_ALLOC_ADD(&total_size, total_size, 1);
+	GITERR_CHECK_ALLOC_ADD(&total_size, total_size, 1);
 	if (git_buf_grow_by(buf, total_size) < 0)
 		return -1;
 
@@ -765,9 +753,9 @@ int git_buf_join(
 	if (str_a >= buf->ptr && str_a < buf->ptr + buf->size)
 		offset_a = str_a - buf->ptr;
 
-	GIT_ERROR_CHECK_ALLOC_ADD(&alloc_len, strlen_a, strlen_b);
-	GIT_ERROR_CHECK_ALLOC_ADD(&alloc_len, alloc_len, need_sep);
-	GIT_ERROR_CHECK_ALLOC_ADD(&alloc_len, alloc_len, 1);
+	GITERR_CHECK_ALLOC_ADD(&alloc_len, strlen_a, strlen_b);
+	GITERR_CHECK_ALLOC_ADD(&alloc_len, alloc_len, need_sep);
+	GITERR_CHECK_ALLOC_ADD(&alloc_len, alloc_len, 1);
 	ENSURE_SIZE(buf, alloc_len);
 
 	/* fix up internal pointers */
@@ -817,11 +805,11 @@ int git_buf_join3(
 			sep_b = (str_b[len_b - 1] != separator);
 	}
 
-	GIT_ERROR_CHECK_ALLOC_ADD(&len_total, len_a, sep_a);
-	GIT_ERROR_CHECK_ALLOC_ADD(&len_total, len_total, len_b);
-	GIT_ERROR_CHECK_ALLOC_ADD(&len_total, len_total, sep_b);
-	GIT_ERROR_CHECK_ALLOC_ADD(&len_total, len_total, len_c);
-	GIT_ERROR_CHECK_ALLOC_ADD(&len_total, len_total, 1);
+	GITERR_CHECK_ALLOC_ADD(&len_total, len_a, sep_a);
+	GITERR_CHECK_ALLOC_ADD(&len_total, len_total, len_b);
+	GITERR_CHECK_ALLOC_ADD(&len_total, len_total, sep_b);
+	GITERR_CHECK_ALLOC_ADD(&len_total, len_total, len_c);
+	GITERR_CHECK_ALLOC_ADD(&len_total, len_total, 1);
 	ENSURE_SIZE(buf, len_total);
 
 	tgt = buf->ptr;
@@ -884,8 +872,8 @@ int git_buf_splice(
 	/* Ported from git.git
 	 * https://github.com/git/git/blob/16eed7c/strbuf.c#L159-176
 	 */
-	GIT_ERROR_CHECK_ALLOC_ADD(&new_size, (buf->size - nb_to_remove), nb_to_insert);
-	GIT_ERROR_CHECK_ALLOC_ADD(&alloc_size, new_size, 1);
+	GITERR_CHECK_ALLOC_ADD(&new_size, (buf->size - nb_to_remove), nb_to_insert);
+	GITERR_CHECK_ALLOC_ADD(&alloc_size, new_size, 1);
 	ENSURE_SIZE(buf, alloc_size);
 
 	memmove(splice_loc + nb_to_insert,
@@ -961,7 +949,7 @@ int git_buf_quote(git_buf *buf)
 	git_buf_swap(&quoted, buf);
 
 done:
-	git_buf_dispose(&quoted);
+	git_buf_free(&quoted);
 	return error;
 }
 
@@ -1002,14 +990,14 @@ int git_buf_unquote(git_buf *buf)
 			/* \xyz digits convert to the char*/
 			case '0': case '1': case '2': case '3':
 				if (j == buf->size-3) {
-					git_error_set(GIT_ERROR_INVALID,
+					giterr_set(GITERR_INVALID,
 						"truncated quoted character \\%c", ch);
 					return -1;
 				}
 
 				if (buf->ptr[j+1] < '0' || buf->ptr[j+1] > '7' ||
 					buf->ptr[j+2] < '0' || buf->ptr[j+2] > '7') {
-					git_error_set(GIT_ERROR_INVALID,
+					giterr_set(GITERR_INVALID,
 						"truncated quoted character \\%c%c%c",
 						buf->ptr[j], buf->ptr[j+1], buf->ptr[j+2]);
 					return -1;
@@ -1022,7 +1010,7 @@ int git_buf_unquote(git_buf *buf)
 				break;
 
 			default:
-				git_error_set(GIT_ERROR_INVALID, "invalid quoted character \\%c", ch);
+				giterr_set(GITERR_INVALID, "invalid quoted character \\%c", ch);
 				return -1;
 			}
 		}
@@ -1036,6 +1024,6 @@ int git_buf_unquote(git_buf *buf)
 	return 0;
 
 invalid:
-	git_error_set(GIT_ERROR_INVALID, "invalid quoted line");
+	giterr_set(GITERR_INVALID, "invalid quoted line");
 	return -1;
 }