rugged 0.27.10 → 0.27.10.1

data/vendor/libgit2/src/commit.h

@@ -35,12 +35,5 @@ struct git_commit {
 
 void git_commit__free(void *commit);
 int git_commit__parse(void *commit, git_odb_object *obj);
-int git_commit__parse_raw(void *commit, const char *data, size_t size);
-
-typedef enum {
-	GIT_COMMIT_PARSE_QUICK = (1 << 0), /**< Only parse parents and committer info */
-} git_commit__parse_flags;
-
-int git_commit__parse_ext(git_commit *commit, git_odb_object *odb_obj, unsigned int flags);
 
 #endif

data/vendor/libgit2/src/commit_list.c

@@ -10,7 +10,6 @@
 #include "revwalk.h"
 #include "pool.h"
 #include "odb.h"
-#include "commit.h"
 
 int git_commit_list_time_cmp(const void *a, const void *b)
 {
@@ -56,6 +55,17 @@ git_commit_list_node *git_commit_list_alloc_node(git_revwalk *walk)
 	return (git_commit_list_node *)git_pool_mallocz(&walk->commit_pool, 1);
 }
 
+static int commit_error(git_commit_list_node *commit, const char *msg)
+{
+	char commit_oid[GIT_OID_HEXSZ + 1];
+	git_oid_fmt(commit_oid, &commit->oid);
+	commit_oid[GIT_OID_HEXSZ] = '\0';
+
+	giterr_set(GITERR_ODB, "failed to parse commit %s - %s", commit_oid, msg);
+
+	return -1;
+}
+
 static git_commit_list_node **alloc_parents(
 	git_revwalk *walk, git_commit_list_node *commit, size_t n_parents)
 {
@@ -101,42 +111,77 @@ git_commit_list_node *git_commit_list_pop(git_commit_list **stack)
 
 static int commit_quick_parse(
 	git_revwalk *walk,
-	git_commit_list_node *node,
-	git_odb_object *obj)
+	git_commit_list_node *commit,
+	const uint8_t *buffer,
+	size_t buffer_len)
 {
-	git_oid *parent_oid;
-	git_commit *commit;
-	int error;
-	size_t i;
+	const size_t parent_len = strlen("parent ") + GIT_OID_HEXSZ + 1;
+	const uint8_t *buffer_end = buffer + buffer_len;
+	const uint8_t *parents_start, *committer_start;
+	int i, parents = 0;
+	int64_t commit_time;
+
+	buffer += strlen("tree ") + GIT_OID_HEXSZ + 1;
+
+	parents_start = buffer;
+	while (buffer + parent_len < buffer_end && memcmp(buffer, "parent ", strlen("parent ")) == 0) {
+		parents++;
+		buffer += parent_len;
+	}
 
-	commit = git__calloc(1, sizeof(*commit));
-	GIT_ERROR_CHECK_ALLOC(commit);
-	commit->object.repo = walk->repo;
+	commit->parents = alloc_parents(walk, commit, parents);
+	GITERR_CHECK_ALLOC(commit->parents);
 
-	if ((error = git_commit__parse_ext(commit, obj, GIT_COMMIT_PARSE_QUICK)) < 0) {
-		git__free(commit);
-		return error;
-	}
+	buffer = parents_start;
+	for (i = 0; i < parents; ++i) {
+		git_oid oid;
 
-	if (!git__is_uint16(git_array_size(commit->parent_ids))) {
-		git__free(commit);
-		git_error_set(GIT_ERROR_INVALID, "commit has more than 2^16 parents");
-		return -1;
-	}
+		if (git_oid_fromstr(&oid, (const char *)buffer + strlen("parent ")) < 0)
+			return -1;
 
-	node->time = commit->committer->when.time;
-	node->out_degree = (uint16_t) git_array_size(commit->parent_ids);
-	node->parents = alloc_parents(walk, node, node->out_degree);
-	GIT_ERROR_CHECK_ALLOC(node->parents);
+		commit->parents[i] = git_revwalk__commit_lookup(walk, &oid);
+		if (commit->parents[i] == NULL)
+			return -1;
 
-	git_array_foreach(commit->parent_ids, i, parent_oid) {
-		node->parents[i] = git_revwalk__commit_lookup(walk, parent_oid);
+		buffer += parent_len;
 	}
 
-	git_commit__free(commit);
+	commit->out_degree = (unsigned short)parents;
+
+	if ((committer_start = buffer = memchr(buffer, '\n', buffer_end - buffer)) == NULL)
+		return commit_error(commit, "object is corrupted");
+
+	buffer++;
+
+	if ((buffer = memchr(buffer, '\n', buffer_end - buffer)) == NULL)
+		return commit_error(commit, "object is corrupted");
+
+	/* Skip trailing spaces */
+	while (buffer > committer_start && git__isspace(*buffer))
+		buffer--;
+
+	/* Seek for the beginning of the pack of digits */
+	while (buffer > committer_start && git__isdigit(*buffer))
+		buffer--;
+
+	/* Skip potential timezone offset */
+	if ((buffer > committer_start) && (*buffer == '+' || *buffer == '-')) {
+		buffer--;
+
+		while (buffer > committer_start && git__isspace(*buffer))
+			buffer--;
+
+		while (buffer > committer_start && git__isdigit(*buffer))
+			buffer--;
+	}
 
-	node->parsed = 1;
+	if ((buffer == committer_start) ||
+	    (git__strntol64(&commit_time, (char *)(buffer + 1),
+			    buffer_end - buffer + 1, NULL, 10) < 0))
+		return commit_error(commit, "cannot parse commit time");
 
+	commit->time = commit_time;
+	commit->parsed = 1;
 	return 0;
 }
 
@@ -151,11 +196,14 @@ int git_commit_list_parse(git_revwalk *walk, git_commit_list_node *commit)
 	if ((error = git_odb_read(&obj, walk->odb, &commit->oid)) < 0)
 		return error;
 
-	if (obj->cached.type != GIT_OBJECT_COMMIT) {
-		git_error_set(GIT_ERROR_INVALID, "object is no commit object");
+	if (obj->cached.type != GIT_OBJ_COMMIT) {
+		giterr_set(GITERR_INVALID, "object is no commit object");
 		error = -1;
 	} else
-		error = commit_quick_parse(walk, commit, obj);
+		error = commit_quick_parse(
+			walk, commit,
+			(const uint8_t *)git_odb_object_data(obj),
+			git_odb_object_size(obj));
 
 	git_odb_object_free(obj);
 	return error;

data/vendor/libgit2/src/commit_list.h

@@ -33,8 +33,8 @@ typedef struct git_commit_list_node {
 			 added:1,
 			 flags : FLAG_BITS;
 
-	uint16_t in_degree;
-	uint16_t out_degree;
+	unsigned short in_degree;
+	unsigned short out_degree;
 
 	struct git_commit_list_node **parents;
 } git_commit_list_node;

data/vendor/libgit2/src/common.h

@@ -17,10 +17,8 @@
 /** Declare a function as always inlined. */
 #if defined(_MSC_VER)
 # define GIT_INLINE(type) static __inline type
-#elif defined(__GNUC__)
-# define GIT_INLINE(type) static __inline__ type
 #else
-# define GIT_INLINE(type) static type
+# define GIT_INLINE(type) static inline type
 #endif
 
 /** Support for gcc/clang __has_builtin intrinsic */
@@ -47,7 +45,6 @@
 # include <ws2tcpip.h>
 # include "win32/msvc-compat.h"
 # include "win32/mingw-compat.h"
-# include "win32/w32_common.h"
 # include "win32/win32-compat.h"
 # include "win32/error.h"
 # include "win32/version.h"
@@ -77,17 +74,10 @@
 
 #include "git2/types.h"
 #include "git2/errors.h"
-#include "errors.h"
 #include "thread-utils.h"
 #include "integer.h"
 
-/*
- * Include the declarations for deprecated functions; this ensures
- * that they're decorated with the proper extern/visibility attributes.
- */
-#include "git2/deprecated.h"
-
-#include "posix.h"
+#include <regex.h>
 
 #define DEFAULT_BUFSIZE 65536
 #define FILEIO_BUFSIZE DEFAULT_BUFSIZE
@@ -97,23 +87,97 @@
 /**
  * Check a pointer allocation result, returning -1 if it failed.
  */
-#define GIT_ERROR_CHECK_ALLOC(ptr) if (ptr == NULL) { return -1; }
+#define GITERR_CHECK_ALLOC(ptr) if (ptr == NULL) { return -1; }
 
 /**
  * Check a buffer allocation result, returning -1 if it failed.
  */
-#define GIT_ERROR_CHECK_ALLOC_BUF(buf) if ((void *)(buf) == NULL || git_buf_oom(buf)) { return -1; }
+#define GITERR_CHECK_ALLOC_BUF(buf) if ((void *)(buf) == NULL || git_buf_oom(buf)) { return -1; }
 
 /**
  * Check a return value and propagate result if non-zero.
  */
-#define GIT_ERROR_CHECK_ERROR(code) \
+#define GITERR_CHECK_ERROR(code) \
 	do { int _err = (code); if (_err) return _err; } while (0)
 
+/**
+ * Set the error message for this thread, formatting as needed.
+ */
+
+void giterr_set(int error_class, const char *string, ...) GIT_FORMAT_PRINTF(2, 3);
+
+/**
+ * Set the error message for a regex failure, using the internal regex
+ * error code lookup and return a libgit error code.
+ */
+int giterr_set_regex(const regex_t *regex, int error_code);
+
+/**
+ * Set error message for user callback if needed.
+ *
+ * If the error code in non-zero and no error message is set, this
+ * sets a generic error message.
+ *
+ * @return This always returns the `error_code` parameter.
+ */
+GIT_INLINE(int) giterr_set_after_callback_function(
+	int error_code, const char *action)
+{
+	if (error_code) {
+		const git_error *e = giterr_last();
+		if (!e || !e->message)
+			giterr_set(e ? e->klass : GITERR_CALLBACK,
+				"%s callback returned %d", action, error_code);
+	}
+	return error_code;
+}
+
+#ifdef GIT_WIN32
+#define giterr_set_after_callback(code) \
+	giterr_set_after_callback_function((code), __FUNCTION__)
+#else
+#define giterr_set_after_callback(code) \
+	giterr_set_after_callback_function((code), __func__)
+#endif
+
+/**
+ * Gets the system error code for this thread.
+ */
+int giterr_system_last(void);
+
+/**
+ * Sets the system error code for this thread.
+ */
+void giterr_system_set(int code);
+
+/**
+ * Structure to preserve libgit2 error state
+ */
+typedef struct {
+	int error_code;
+	unsigned int oom : 1;
+	git_error error_msg;
+} git_error_state;
+
+/**
+ * Capture current error state to restore later, returning error code.
+ * If `error_code` is zero, this does not clear the current error state.
+ * You must either restore this error state, or free it.
+ */
+extern int giterr_state_capture(git_error_state *state, int error_code);
+
+/**
+ * Restore error state to a previous value, returning saved error code.
+ */
+extern int giterr_state_restore(git_error_state *state);
+
+/** Free an error state. */
+extern void giterr_state_free(git_error_state *state);
+
 /**
  * Check a versioned structure for validity
  */
-GIT_INLINE(int) git_error__check_version(const void *structure, unsigned int expected_max, const char *name)
+GIT_INLINE(int) giterr__check_version(const void *structure, unsigned int expected_max, const char *name)
 {
 	unsigned int actual;
 
@@ -124,10 +188,10 @@ GIT_INLINE(int) git_error__check_version(const void *structure, unsigned int exp
 	if (actual > 0 && actual <= expected_max)
 		return 0;
 
-	git_error_set(GIT_ERROR_INVALID, "invalid version %d on %s", actual, name);
+	giterr_set(GITERR_INVALID, "invalid version %d on %s", actual, name);
 	return -1;
 }
-#define GIT_ERROR_CHECK_VERSION(S,V,N) if (git_error__check_version(S,V,N) < 0) return -1
+#define GITERR_CHECK_VERSION(S,V,N) if (giterr__check_version(S,V,N) < 0) return -1
 
 /**
  * Initialize a structure with a version.
@@ -141,42 +205,42 @@ GIT_INLINE(void) git__init_structure(void *structure, size_t len, unsigned int v
 
 #define GIT_INIT_STRUCTURE_FROM_TEMPLATE(PTR,VERSION,TYPE,TPL) do { \
 	TYPE _tmpl = TPL; \
-	GIT_ERROR_CHECK_VERSION(&(VERSION), _tmpl.version, #TYPE);	\
+	GITERR_CHECK_VERSION(&(VERSION), _tmpl.version, #TYPE);	\
 	memcpy((PTR), &_tmpl, sizeof(_tmpl)); } while (0)
 
 
 /** Check for additive overflow, setting an error if would occur. */
 #define GIT_ADD_SIZET_OVERFLOW(out, one, two) \
-	(git__add_sizet_overflow(out, one, two) ? (git_error_set_oom(), 1) : 0)
+	(git__add_sizet_overflow(out, one, two) ? (giterr_set_oom(), 1) : 0)
 
 /** Check for additive overflow, setting an error if would occur. */
 #define GIT_MULTIPLY_SIZET_OVERFLOW(out, nelem, elsize) \
-	(git__multiply_sizet_overflow(out, nelem, elsize) ? (git_error_set_oom(), 1) : 0)
+	(git__multiply_sizet_overflow(out, nelem, elsize) ? (giterr_set_oom(), 1) : 0)
 
 /** Check for additive overflow, failing if it would occur. */
-#define GIT_ERROR_CHECK_ALLOC_ADD(out, one, two) \
+#define GITERR_CHECK_ALLOC_ADD(out, one, two) \
 	if (GIT_ADD_SIZET_OVERFLOW(out, one, two)) { return -1; }
 
-#define GIT_ERROR_CHECK_ALLOC_ADD3(out, one, two, three) \
+#define GITERR_CHECK_ALLOC_ADD3(out, one, two, three) \
 	if (GIT_ADD_SIZET_OVERFLOW(out, one, two) || \
 		GIT_ADD_SIZET_OVERFLOW(out, *(out), three)) { return -1; }
 
-#define GIT_ERROR_CHECK_ALLOC_ADD4(out, one, two, three, four) \
+#define GITERR_CHECK_ALLOC_ADD4(out, one, two, three, four) \
 	if (GIT_ADD_SIZET_OVERFLOW(out, one, two) || \
 		GIT_ADD_SIZET_OVERFLOW(out, *(out), three) || \
 		GIT_ADD_SIZET_OVERFLOW(out, *(out), four)) { return -1; }
 
-#define GIT_ERROR_CHECK_ALLOC_ADD5(out, one, two, three, four, five) \
+#define GITERR_CHECK_ALLOC_ADD5(out, one, two, three, four, five) \
 	if (GIT_ADD_SIZET_OVERFLOW(out, one, two) || \
 		GIT_ADD_SIZET_OVERFLOW(out, *(out), three) || \
 		GIT_ADD_SIZET_OVERFLOW(out, *(out), four) || \
 		GIT_ADD_SIZET_OVERFLOW(out, *(out), five)) { return -1; }
 
 /** Check for multiplicative overflow, failing if it would occur. */
-#define GIT_ERROR_CHECK_ALLOC_MULTIPLY(out, nelem, elsize) \
+#define GITERR_CHECK_ALLOC_MULTIPLY(out, nelem, elsize) \
 	if (GIT_MULTIPLY_SIZET_OVERFLOW(out, nelem, elsize)) { return -1; }
 
-/* NOTE: other git_error functions are in the public errors.h header file */
+/* NOTE: other giterr functions are in the public errors.h header file */
 
 #include "util.h"
 

data/vendor/libgit2/src/config.c

@@ -7,15 +7,13 @@
 
 #include "config.h"
 
+#include "sysdir.h"
 #include "git2/config.h"
 #include "git2/sys/config.h"
-
+#include "vector.h"
 #include "buf_text.h"
-#include "config_backend.h"
-#include "regexp.h"
-#include "sysdir.h"
+#include "config_file.h"
 #include "transaction.h"
-#include "vector.h"
 #if GIT_WIN32
 # include <windows.h>
 #endif
@@ -33,30 +31,30 @@ void git_config_entry_free(git_config_entry *entry)
 typedef struct {
 	git_refcount rc;
 
-	git_config_backend *backend;
+	git_config_backend *file;
 	git_config_level_t level;
-} backend_internal;
+} file_internal;
 
-static void backend_internal_free(backend_internal *internal)
+static void file_internal_free(file_internal *internal)
 {
-	git_config_backend *backend;
+	git_config_backend *file;
 
-	backend = internal->backend;
-	backend->free(backend);
+	file = internal->file;
+	file->free(file);
 	git__free(internal);
 }
 
 static void config_free(git_config *cfg)
 {
 	size_t i;
-	backend_internal *internal;
+	file_internal *internal;
 
-	for (i = 0; i < cfg->backends.length; ++i) {
-		internal = git_vector_get(&cfg->backends, i);
-		GIT_REFCOUNT_DEC(internal, backend_internal_free);
+	for (i = 0; i < cfg->files.length; ++i) {
+		internal = git_vector_get(&cfg->files, i);
+		GIT_REFCOUNT_DEC(internal, file_internal_free);
 	}
 
-	git_vector_free(&cfg->backends);
+	git_vector_free(&cfg->files);
 
 	git__memzero(cfg, sizeof(*cfg));
 	git__free(cfg);
@@ -72,8 +70,8 @@ void git_config_free(git_config *cfg)
 
 static int config_backend_cmp(const void *a, const void *b)
 {
-	const backend_internal *bk_a = (const backend_internal *)(a);
-	const backend_internal *bk_b = (const backend_internal *)(b);
+	const file_internal *bk_a = (const file_internal *)(a);
+	const file_internal *bk_b = (const file_internal *)(b);
 
 	return bk_b->level - bk_a->level;
 }
@@ -83,11 +81,11 @@ int git_config_new(git_config **out)
 	git_config *cfg;
 
 	cfg = git__malloc(sizeof(git_config));
-	GIT_ERROR_CHECK_ALLOC(cfg);
+	GITERR_CHECK_ALLOC(cfg);
 
 	memset(cfg, 0x0, sizeof(git_config));
 
-	if (git_vector_init(&cfg->backends, 3, config_backend_cmp) < 0) {
+	if (git_vector_init(&cfg->files, 3, config_backend_cmp) < 0) {
 		git__free(cfg);
 		return -1;
 	}
@@ -112,11 +110,11 @@ int git_config_add_file_ondisk(
 
 	res = p_stat(path, &st);
 	if (res < 0 && errno != ENOENT && errno != ENOTDIR) {
-		git_error_set(GIT_ERROR_CONFIG, "failed to stat '%s'", path);
+		giterr_set(GITERR_CONFIG, "failed to stat '%s'", path);
 		return -1;
 	}
 
-	if (git_config_backend_from_file(&file, path) < 0)
+	if (git_config_file__ondisk(&file, path) < 0)
 		return -1;
 
 	if ((res = git_config_add_backend(cfg, file, level, repo, force)) < 0) {
@@ -153,7 +151,7 @@ int git_config_snapshot(git_config **out, git_config *in)
 {
 	int error = 0;
 	size_t i;
-	backend_internal *internal;
+	file_internal *internal;
 	git_config *config;
 
 	*out = NULL;
@@ -161,10 +159,10 @@ int git_config_snapshot(git_config **out, git_config *in)
 	if (git_config_new(&config) < 0)
 		return -1;
 
-	git_vector_foreach(&in->backends, i, internal) {
+	git_vector_foreach(&in->files, i, internal) {
 		git_config_backend *b;
 
-		if ((error = internal->backend->snapshot(&b, internal->backend)) < 0)
+		if ((error = internal->file->snapshot(&b, internal->file)) < 0)
 			break;
 
 		if ((error = git_config_add_backend(config, b, internal->level, NULL, 0)) < 0) {
@@ -181,59 +179,59 @@ int git_config_snapshot(git_config **out, git_config *in)
 	return error;
 }
 
-static int find_backend_by_level(
-	backend_internal **out,
+static int find_internal_file_by_level(
+	file_internal **internal_out,
 	const git_config *cfg,
 	git_config_level_t level)
 {
 	int pos = -1;
-	backend_internal *internal;
+	file_internal *internal;
 	size_t i;
 
-	/* when passing GIT_CONFIG_HIGHEST_LEVEL, the idea is to get the config backend
-	 * which has the highest level. As config backends are stored in a vector
-	 * sorted by decreasing order of level, getting the backend at position 0
+	/* when passing GIT_CONFIG_HIGHEST_LEVEL, the idea is to get the config file
+	 * which has the highest level. As config files are stored in a vector
+	 * sorted by decreasing order of level, getting the file at position 0
 	 * will do the job.
 	 */
 	if (level == GIT_CONFIG_HIGHEST_LEVEL) {
 		pos = 0;
 	} else {
-		git_vector_foreach(&cfg->backends, i, internal) {
+		git_vector_foreach(&cfg->files, i, internal) {
 			if (internal->level == level)
 				pos = (int)i;
 		}
 	}
 
 	if (pos == -1) {
-		git_error_set(GIT_ERROR_CONFIG,
-			"no configuration exists for the given level '%i'", (int)level);
+		giterr_set(GITERR_CONFIG,
+			"no config file exists for the given level '%i'", (int)level);
 		return GIT_ENOTFOUND;
 	}
 
-	*out = git_vector_get(&cfg->backends, pos);
+	*internal_out = git_vector_get(&cfg->files, pos);
 
 	return 0;
 }
 
 static int duplicate_level(void **old_raw, void *new_raw)
 {
-	backend_internal **old = (backend_internal **)old_raw;
+	file_internal **old = (file_internal **)old_raw;
 
 	GIT_UNUSED(new_raw);
 
-	git_error_set(GIT_ERROR_CONFIG, "there already exists a configuration for the given level (%i)", (int)(*old)->level);
+	giterr_set(GITERR_CONFIG, "a file with the same level (%i) has already been added to the config", (int)(*old)->level);
 	return GIT_EEXISTS;
 }
 
-static void try_remove_existing_backend(
+static void try_remove_existing_file_internal(
 	git_config *cfg,
 	git_config_level_t level)
 {
 	int pos = -1;
-	backend_internal *internal;
+	file_internal *internal;
 	size_t i;
 
-	git_vector_foreach(&cfg->backends, i, internal) {
+	git_vector_foreach(&cfg->files, i, internal) {
 		if (internal->level == level)
 			pos = (int)i;
 	}
@@ -241,32 +239,32 @@ static void try_remove_existing_backend(
 	if (pos == -1)
 		return;
 
-	internal = git_vector_get(&cfg->backends, pos);
+	internal = git_vector_get(&cfg->files, pos);
 
-	if (git_vector_remove(&cfg->backends, pos) < 0)
+	if (git_vector_remove(&cfg->files, pos) < 0)
 		return;
 
-	GIT_REFCOUNT_DEC(internal, backend_internal_free);
+	GIT_REFCOUNT_DEC(internal, file_internal_free);
 }
 
 static int git_config__add_internal(
 	git_config *cfg,
-	backend_internal *internal,
+	file_internal *internal,
 	git_config_level_t level,
 	int force)
 {
 	int result;
 
-	/* delete existing config backend for level if it exists */
+	/* delete existing config file for level if it exists */
 	if (force)
-		try_remove_existing_backend(cfg, level);
+		try_remove_existing_file_internal(cfg, level);
 
-	if ((result = git_vector_insert_sorted(&cfg->backends,
+	if ((result = git_vector_insert_sorted(&cfg->files,
 			internal, &duplicate_level)) < 0)
 		return result;
 
-	git_vector_sort(&cfg->backends);
-	internal->backend->cfg = cfg;
+	git_vector_sort(&cfg->files);
+	internal->file->cfg = cfg;
 
 	GIT_REFCOUNT_INC(internal);
 
@@ -287,10 +285,10 @@ int git_config_open_level(
 	git_config_level_t level)
 {
 	git_config *cfg;
-	backend_internal *internal;
+	file_internal *internal;
 	int res;
 
-	if ((res = find_backend_by_level(&internal, cfg_parent, level)) < 0)
+	if ((res = find_internal_file_by_level(&internal, cfg_parent, level)) < 0)
 		return res;
 
 	if ((res = git_config_new(&cfg)) < 0)
@@ -308,27 +306,27 @@ int git_config_open_level(
 
 int git_config_add_backend(
 	git_config *cfg,
-	git_config_backend *backend,
+	git_config_backend *file,
 	git_config_level_t level,
 	const git_repository *repo,
 	int force)
 {
-	backend_internal *internal;
+	file_internal *internal;
 	int result;
 
-	assert(cfg && backend);
+	assert(cfg && file);
 
-	GIT_ERROR_CHECK_VERSION(backend, GIT_CONFIG_BACKEND_VERSION, "git_config_backend");
+	GITERR_CHECK_VERSION(file, GIT_CONFIG_BACKEND_VERSION, "git_config_backend");
 
-	if ((result = backend->open(backend, level, repo)) < 0)
+	if ((result = file->open(file, level, repo)) < 0)
 		return result;
 
-	internal = git__malloc(sizeof(backend_internal));
-	GIT_ERROR_CHECK_ALLOC(internal);
+	internal = git__malloc(sizeof(file_internal));
+	GITERR_CHECK_ALLOC(internal);
 
-	memset(internal, 0x0, sizeof(backend_internal));
+	memset(internal, 0x0, sizeof(file_internal));
 
-	internal->backend = backend;
+	internal->file = file;
 	internal->level = level;
 
 	if ((result = git_config__add_internal(cfg, internal, level, force)) < 0) {
@@ -347,17 +345,17 @@ typedef struct {
 	git_config_iterator parent;
 	git_config_iterator *current;
 	const git_config *cfg;
-	git_regexp regex;
+	regex_t regex;
 	size_t i;
 } all_iter;
 
 static int find_next_backend(size_t *out, const git_config *cfg, size_t i)
 {
-	backend_internal *internal;
+	file_internal *internal;
 
 	for (; i > 0; --i) {
-		internal = git_vector_get(&cfg->backends, i - 1);
-		if (!internal || !internal->backend)
+		internal = git_vector_get(&cfg->files, i - 1);
+		if (!internal || !internal->file)
 			continue;
 
 		*out = i;
@@ -370,7 +368,7 @@ static int find_next_backend(size_t *out, const git_config *cfg, size_t i)
 static int all_iter_next(git_config_entry **entry, git_config_iterator *_iter)
 {
 	all_iter *iter = (all_iter *) _iter;
-	backend_internal *internal;
+	file_internal *internal;
 	git_config_backend *backend;
 	size_t i;
 	int error = 0;
@@ -387,8 +385,8 @@ static int all_iter_next(git_config_entry **entry, git_config_iterator *_iter)
 		if (find_next_backend(&i, iter->cfg, iter->i) < 0)
 			return GIT_ITEROVER;
 
-		internal = git_vector_get(&iter->cfg->backends, i - 1);
-		backend = internal->backend;
+		internal = git_vector_get(&iter->cfg->files, i - 1);
+		backend = internal->file;
 		iter->i = i - 1;
 
 		if (iter->current)
@@ -425,7 +423,7 @@ static int all_iter_glob_next(git_config_entry **entry, git_config_iterator *_it
 	 */
 	while ((error = all_iter_next(entry, _iter)) == 0) {
 		/* skip non-matching keys if regexp was provided */
-		if (git_regexp_match(&iter->regex, (*entry)->name) != 0)
+		if (regexec(&iter->regex, (*entry)->name, 0, NULL, 0) != 0)
 			continue;
 
 		/* and simply return if we like the entry's name */
@@ -449,7 +447,7 @@ static void all_iter_glob_free(git_config_iterator *_iter)
 {
 	all_iter *iter = (all_iter *) _iter;
 
-	git_regexp_dispose(&iter->regex);
+	regfree(&iter->regex);
 	all_iter_free(_iter);
 }
 
@@ -458,12 +456,12 @@ int git_config_iterator_new(git_config_iterator **out, const git_config *cfg)
 	all_iter *iter;
 
 	iter = git__calloc(1, sizeof(all_iter));
-	GIT_ERROR_CHECK_ALLOC(iter);
+	GITERR_CHECK_ALLOC(iter);
 
 	iter->parent.free = all_iter_free;
 	iter->parent.next = all_iter_next;
 
-	iter->i = cfg->backends.length;
+	iter->i = cfg->files.length;
 	iter->cfg = cfg;
 
 	*out = (git_config_iterator *) iter;
@@ -480,16 +478,17 @@ int git_config_iterator_glob_new(git_config_iterator **out, const git_config *cf
 		return git_config_iterator_new(out, cfg);
 
 	iter = git__calloc(1, sizeof(all_iter));
-	GIT_ERROR_CHECK_ALLOC(iter);
+	GITERR_CHECK_ALLOC(iter);
 
-	if ((result = git_regexp_compile(&iter->regex, regexp, 0)) < 0) {
+	if ((result = p_regcomp(&iter->regex, regexp, REG_EXTENDED)) != 0) {
+		giterr_set_regex(&iter->regex, result);
 		git__free(iter);
 		return -1;
 	}
 
 	iter->parent.next = all_iter_glob_next;
 	iter->parent.free = all_iter_glob_free;
-	iter->i = cfg->backends.length;
+	iter->i = cfg->files.length;
 	iter->cfg = cfg;
 
 	*out = (git_config_iterator *) iter;
@@ -511,13 +510,18 @@ int git_config_backend_foreach_match(
 {
 	git_config_entry *entry;
 	git_config_iterator* iter;
-	git_regexp regex;
+	regex_t regex;
 	int error = 0;
 
 	assert(backend && cb);
 
-	if (regexp && git_regexp_compile(&regex, regexp, 0) < 0)
-		return -1;
+	if (regexp != NULL) {
+		if ((error = p_regcomp(&regex, regexp, REG_EXTENDED)) != 0) {
+			giterr_set_regex(&regex, error);
+			regfree(&regex);
+			return -1;
+		}
+	}
 
 	if ((error = backend->iterator(&iter, backend)) < 0) {
 		iter = NULL;
@@ -526,18 +530,18 @@ int git_config_backend_foreach_match(
 
 	while (!(iter->next(&entry, iter) < 0)) {
 		/* skip non-matching keys if regexp was provided */
-		if (regexp && git_regexp_match(&regex, entry->name) != 0)
+		if (regexp && regexec(&regex, entry->name, 0, NULL, 0) != 0)
 			continue;
 
 		/* abort iterator on non-zero return value */
 		if ((error = cb(entry, payload)) != 0) {
-			git_error_set_after_callback(error);
+			giterr_set_after_callback(error);
 			break;
 		}
 	}
 
 	if (regexp != NULL)
-		git_regexp_dispose(&regex);
+		regfree(&regex);
 
 	iter->free(iter);
 
@@ -559,7 +563,7 @@ int git_config_foreach_match(
 
 	while (!(error = git_config_next(&entry, iter))) {
 		if ((error = cb(entry, payload)) != 0) {
-			git_error_set_after_callback(error);
+			giterr_set_after_callback(error);
 			break;
 		}
 	}
@@ -590,38 +594,38 @@ static int get_backend_for_use(git_config_backend **out,
 	git_config *cfg, const char *name, backend_use use)
 {
 	size_t i;
-	backend_internal *backend;
+	file_internal *f;
 
 	*out = NULL;
 
-	if (git_vector_length(&cfg->backends) == 0) {
-		git_error_set(GIT_ERROR_CONFIG,
-			"cannot %s value for '%s' when no config backends exist",
+	if (git_vector_length(&cfg->files) == 0) {
+		giterr_set(GITERR_CONFIG,
+			"cannot %s value for '%s' when no config files exist",
 			uses[use], name);
 		return GIT_ENOTFOUND;
 	}
 
-	git_vector_foreach(&cfg->backends, i, backend) {
-		if (!backend->backend->readonly) {
-			*out = backend->backend;
+	git_vector_foreach(&cfg->files, i, f) {
+		if (!f->file->readonly) {
+			*out = f->file;
 			return 0;
 		}
 	}
 
-	git_error_set(GIT_ERROR_CONFIG,
-		"cannot %s value for '%s' when all config backends are readonly",
+	giterr_set(GITERR_CONFIG,
+		"cannot %s value for '%s' when all config files are readonly",
 		uses[use], name);
 	return GIT_ENOTFOUND;
 }
 
 int git_config_delete_entry(git_config *cfg, const char *name)
 {
-	git_config_backend *backend;
+	git_config_backend *file;
 
-	if (get_backend_for_use(&backend, cfg, name, BACKEND_USE_DELETE) < 0)
+	if (get_backend_for_use(&file, cfg, name, BACKEND_USE_DELETE) < 0)
 		return GIT_ENOTFOUND;
 
-	return backend->del(backend, name);
+	return file->del(file, name);
 }
 
 int git_config_set_int64(git_config *cfg, const char *name, int64_t value)
@@ -644,20 +648,20 @@ int git_config_set_bool(git_config *cfg, const char *name, int value)
 int git_config_set_string(git_config *cfg, const char *name, const char *value)
 {
 	int error;
-	git_config_backend *backend;
+	git_config_backend *file;
 
 	if (!value) {
-		git_error_set(GIT_ERROR_CONFIG, "the value to set cannot be NULL");
+		giterr_set(GITERR_CONFIG, "the value to set cannot be NULL");
 		return -1;
 	}
 
-	if (get_backend_for_use(&backend, cfg, name, BACKEND_USE_SET) < 0)
+	if (get_backend_for_use(&file, cfg, name, BACKEND_USE_SET) < 0)
 		return GIT_ENOTFOUND;
 
-	error = backend->set(backend, name, value);
+	error = file->set(file, name, value);
 
 	if (!error && GIT_REFCOUNT_OWNER(cfg) != NULL)
-		git_repository__configmap_lookup_cache_clear(GIT_REFCOUNT_OWNER(cfg));
+		git_repository__cvar_cache_clear(GIT_REFCOUNT_OWNER(cfg));
 
 	return error;
 }
@@ -699,7 +703,7 @@ int git_config__update_entry(
 
 static int config_error_notfound(const char *name)
 {
-	git_error_set(GIT_ERROR_CONFIG, "config value '%s' was not found", name);
+	giterr_set(GITERR_CONFIG, "config value '%s' was not found", name);
 	return GIT_ENOTFOUND;
 }
 
@@ -720,7 +724,7 @@ static int get_entry(
 	const char *key = name;
 	char *normalized = NULL;
 	size_t i;
-	backend_internal *internal;
+	file_internal *internal;
 
 	*out = NULL;
 
@@ -731,11 +735,11 @@ static int get_entry(
 	}
 
 	res = GIT_ENOTFOUND;
-	git_vector_foreach(&cfg->backends, i, internal) {
-		if (!internal || !internal->backend)
+	git_vector_foreach(&cfg->files, i, internal) {
+		if (!internal || !internal->file)
 			continue;
 
-		res = internal->backend->get(internal->backend, key, out);
+		res = internal->file->get(internal->file, key, out);
 		if (res != GIT_ENOTFOUND)
 			break;
 	}
@@ -746,7 +750,7 @@ cleanup:
 	if (res == GIT_ENOTFOUND)
 		res = (want_errors > GET_ALL_ERRORS) ? 0 : config_error_notfound(name);
 	else if (res && (want_errors == GET_NO_ERRORS)) {
-		git_error_clear();
+		giterr_clear();
 		res = 0;
 	}
 
@@ -773,7 +777,7 @@ int git_config_get_mapped(
 	int *out,
 	const git_config *cfg,
 	const char *name,
-	const git_configmap *maps,
+	const git_cvar_map *maps,
 	size_t map_n)
 {
 	git_config_entry *entry;
@@ -833,13 +837,13 @@ int git_config_get_bool(int *out, const git_config *cfg, const char *name)
 static int is_readonly(const git_config *cfg)
 {
 	size_t i;
-	backend_internal *internal;
+	file_internal *internal;
 
-	git_vector_foreach(&cfg->backends, i, internal) {
-		if (!internal || !internal->backend)
+	git_vector_foreach(&cfg->files, i, internal) {
+		if (!internal || !internal->file)
 			continue;
 
-		if (!internal->backend->readonly)
+		if (!internal->file->readonly)
 			return 0;
 	}
 
@@ -867,7 +871,7 @@ int git_config_get_string(
 	int ret;
 
 	if (!is_readonly(cfg)) {
-		git_error_set(GIT_ERROR_CONFIG, "get_string called on a live config object");
+		giterr_set(GITERR_CONFIG, "get_string called on a live config object");
 		return -1;
 	}
 
@@ -921,7 +925,7 @@ int git_config__get_bool_force(
 	get_entry(&entry, cfg, key, false, GET_NO_ERRORS);
 
 	if (entry && git_config_parse_bool(&val, entry->value) < 0)
-		git_error_clear();
+		giterr_clear();
 
 	git_config_entry_free(entry);
 	return val;
@@ -936,7 +940,7 @@ int git_config__get_int_force(
 	get_entry(&entry, cfg, key, false, GET_NO_ERRORS);
 
 	if (entry && git_config_parse_int32(&val, entry->value) < 0)
-		git_error_clear();
+		giterr_clear();
 
 	git_config_entry_free(entry);
 	return (int)val;
@@ -958,7 +962,7 @@ int git_config_get_multivar_foreach(
 		found = 1;
 
 		if ((err = cb(entry, payload)) != 0) {
-			git_error_set_after_callback(err);
+			giterr_set_after_callback(err);
 			break;
 		}
 	}
@@ -977,7 +981,7 @@ typedef struct {
 	git_config_iterator parent;
 	git_config_iterator *iter;
 	char *name;
-	git_regexp regex;
+	regex_t regex;
 	int have_regex;
 } multivar_iter;
 
@@ -993,7 +997,7 @@ static int multivar_iter_next(git_config_entry **entry, git_config_iterator *_it
 		if (!iter->have_regex)
 			return 0;
 
-		if (git_regexp_match(&iter->regex, (*entry)->value) == 0)
+		if (regexec(&iter->regex, (*entry)->value, 0, NULL, 0) == 0)
 			return 0;
 	}
 
@@ -1008,7 +1012,7 @@ void multivar_iter_free(git_config_iterator *_iter)
 
 	git__free(iter->name);
 	if (iter->have_regex)
-		git_regexp_dispose(&iter->regex);
+		regfree(&iter->regex);
 	git__free(iter);
 }
 
@@ -1022,14 +1026,19 @@ int git_config_multivar_iterator_new(git_config_iterator **out, const git_config
 		return error;
 
 	iter = git__calloc(1, sizeof(multivar_iter));
-	GIT_ERROR_CHECK_ALLOC(iter);
+	GITERR_CHECK_ALLOC(iter);
 
 	if ((error = git_config__normalize_name(name, &iter->name)) < 0)
 		goto on_error;
 
 	if (regexp != NULL) {
-		if ((error = git_regexp_compile(&iter->regex, regexp, 0)) < 0)
+		error = p_regcomp(&iter->regex, regexp, REG_EXTENDED);
+		if (error != 0) {
+			giterr_set_regex(&iter->regex, error);
+			error = -1;
+			regfree(&iter->regex);
 			goto on_error;
+		}
 
 		iter->have_regex = 1;
 	}
@@ -1051,22 +1060,22 @@ on_error:
 
 int git_config_set_multivar(git_config *cfg, const char *name, const char *regexp, const char *value)
 {
-	git_config_backend *backend;
+	git_config_backend *file;
 
-	if (get_backend_for_use(&backend, cfg, name, BACKEND_USE_DELETE) < 0)
+	if (get_backend_for_use(&file, cfg, name, BACKEND_USE_DELETE) < 0)
 		return GIT_ENOTFOUND;
 
-	return backend->set_multivar(backend, name, regexp, value);
+	return file->set_multivar(file, name, regexp, value);
 }
 
 int git_config_delete_multivar(git_config *cfg, const char *name, const char *regexp)
 {
-	git_config_backend *backend;
+	git_config_backend *file;
 
-	if (get_backend_for_use(&backend, cfg, name, BACKEND_USE_DELETE) < 0)
+	if (get_backend_for_use(&file, cfg, name, BACKEND_USE_DELETE) < 0)
 		return GIT_ENOTFOUND;
 
-	return backend->del_multivar(backend, name, regexp);
+	return file->del_multivar(file, name, regexp);
 }
 
 int git_config_next(git_config_entry **entry, git_config_iterator *iter)
@@ -1164,7 +1173,7 @@ int git_config_open_default(git_config **out)
 		error = git_config_add_file_ondisk(cfg, buf.ptr,
 			GIT_CONFIG_LEVEL_PROGRAMDATA, NULL, 0);
 
-	git_buf_dispose(&buf);
+	git_buf_free(&buf);
 
 	if (error) {
 		git_config_free(cfg);
@@ -1179,19 +1188,17 @@ int git_config_open_default(git_config **out)
 int git_config_lock(git_transaction **out, git_config *cfg)
 {
 	int error;
-	git_config_backend *backend;
-	backend_internal *internal;
+	git_config_backend *file;
+	file_internal *internal;
 
-	assert(cfg);
-
-	internal = git_vector_get(&cfg->backends, 0);
-	if (!internal || !internal->backend) {
-		git_error_set(GIT_ERROR_CONFIG, "cannot lock; the config has no backends");
+	internal = git_vector_get(&cfg->files, 0);
+	if (!internal || !internal->file) {
+		giterr_set(GITERR_CONFIG, "cannot lock; the config has no backends/files");
 		return -1;
 	}
-	backend = internal->backend;
+	file = internal->file;
 
-	if ((error = backend->lock(backend)) < 0)
+	if ((error = file->lock(file)) < 0)
 		return error;
 
 	return git_transaction_config_new(out, cfg);
@@ -1199,20 +1206,18 @@ int git_config_lock(git_transaction **out, git_config *cfg)
 
 int git_config_unlock(git_config *cfg, int commit)
 {
-	git_config_backend *backend;
-	backend_internal *internal;
+	git_config_backend *file;
+	file_internal *internal;
 
-	assert(cfg);
-
-	internal = git_vector_get(&cfg->backends, 0);
-	if (!internal || !internal->backend) {
-		git_error_set(GIT_ERROR_CONFIG, "cannot lock; the config has no backends");
+	internal = git_vector_get(&cfg->files, 0);
+	if (!internal || !internal->file) {
+		giterr_set(GITERR_CONFIG, "cannot lock; the config has no backends/files");
 		return -1;
 	}
 
-	backend = internal->backend;
+	file = internal->file;
 
-	return backend->unlock(backend, commit);
+	return file->unlock(file, commit);
 }
 
 /***********
@@ -1221,7 +1226,7 @@ int git_config_unlock(git_config *cfg, int commit)
 
 int git_config_lookup_map_value(
 	int *out,
-	const git_configmap *maps,
+	const git_cvar_map *maps,
 	size_t map_n,
 	const char *value)
 {
@@ -1231,27 +1236,27 @@ int git_config_lookup_map_value(
 		goto fail_parse;
 
 	for (i = 0; i < map_n; ++i) {
-		const git_configmap *m = maps + i;
+		const git_cvar_map *m = maps + i;
 
-		switch (m->type) {
-		case GIT_CONFIGMAP_FALSE:
-		case GIT_CONFIGMAP_TRUE: {
+		switch (m->cvar_type) {
+		case GIT_CVAR_FALSE:
+		case GIT_CVAR_TRUE: {
 			int bool_val;
 
 			if (git__parse_bool(&bool_val, value) == 0 &&
-				bool_val == (int)m->type) {
+				bool_val == (int)m->cvar_type) {
 				*out = m->map_value;
 				return 0;
 			}
 			break;
 		}
 
-		case GIT_CONFIGMAP_INT32:
+		case GIT_CVAR_INT32:
 			if (git_config_parse_int32(out, value) == 0)
 				return 0;
 			break;
 
-		case GIT_CONFIGMAP_STRING:
+		case GIT_CVAR_STRING:
 			if (strcasecmp(value, m->str_match) == 0) {
 				*out = m->map_value;
 				return 0;
@@ -1261,27 +1266,27 @@ int git_config_lookup_map_value(
 	}
 
 fail_parse:
-	git_error_set(GIT_ERROR_CONFIG, "failed to map '%s'", value);
+	giterr_set(GITERR_CONFIG, "failed to map '%s'", value);
 	return -1;
 }
 
-int git_config_lookup_map_enum(git_configmap_t *type_out, const char **str_out,
-			       const git_configmap *maps, size_t map_n, int enum_val)
+int git_config_lookup_map_enum(git_cvar_t *type_out, const char **str_out,
+			       const git_cvar_map *maps, size_t map_n, int enum_val)
 {
 	size_t i;
 
 	for (i = 0; i < map_n; i++) {
-		const git_configmap *m = &maps[i];
+		const git_cvar_map *m = &maps[i];
 
 		if (m->map_value != enum_val)
 			continue;
 
-		*type_out = m->type;
+		*type_out = m->cvar_type;
 		*str_out = m->str_match;
 		return 0;
 	}
 
-	git_error_set(GIT_ERROR_CONFIG, "invalid enum value");
+	giterr_set(GITERR_CONFIG, "invalid enum value");
 	return GIT_ENOTFOUND;
 }
 
@@ -1295,7 +1300,7 @@ int git_config_parse_bool(int *out, const char *value)
 		return 0;
 	}
 
-	git_error_set(GIT_ERROR_CONFIG, "failed to parse '%s' as a boolean value", value);
+	giterr_set(GITERR_CONFIG, "failed to parse '%s' as a boolean value", value);
 	return -1;
 }
 
@@ -1338,7 +1343,7 @@ int git_config_parse_int64(int64_t *out, const char *value)
 	}
 
 fail_parse:
-	git_error_set(GIT_ERROR_CONFIG, "failed to parse '%s' as an integer", value ? value : "(null)");
+	giterr_set(GITERR_CONFIG, "failed to parse '%s' as an integer", value ? value : "(null)");
 	return -1;
 }
 
@@ -1358,7 +1363,7 @@ int git_config_parse_int32(int32_t *out, const char *value)
 	return 0;
 
 fail_parse:
-	git_error_set(GIT_ERROR_CONFIG, "failed to parse '%s' as a 32-bit integer", value ? value : "(null)");
+	giterr_set(GITERR_CONFIG, "failed to parse '%s' as a 32-bit integer", value ? value : "(null)");
 	return -1;
 }
 
@@ -1370,7 +1375,7 @@ int git_config_parse_path(git_buf *out, const char *value)
 
 	if (value[0] == '~') {
 		if (value[1] != '\0' && value[1] != '/') {
-			git_error_set(GIT_ERROR_CONFIG, "retrieving a homedir by name is not supported");
+			giterr_set(GITERR_CONFIG, "retrieving a homedir by name is not supported");
 			return -1;
 		}
 
@@ -1380,30 +1385,6 @@ int git_config_parse_path(git_buf *out, const char *value)
 	return git_buf_sets(out, value);
 }
 
-static int normalize_section(char *start, char *end)
-{
-	char *scan;
-
-	if (start == end)
-		return GIT_EINVALIDSPEC;
-
-	/* Validate and downcase range */
-	for (scan = start; *scan; ++scan) {
-		if (end && scan >= end)
-			break;
-		if (isalnum(*scan))
-			*scan = (char)git__tolower(*scan);
-		else if (*scan != '-' || scan == start)
-			return GIT_EINVALIDSPEC;
-	}
-
-	if (scan == start)
-		return GIT_EINVALIDSPEC;
-
-	return 0;
-}
-
-
 /* Take something the user gave us and make it nice for our hash function */
 int git_config__normalize_name(const char *in, char **out)
 {
@@ -1412,7 +1393,7 @@ int git_config__normalize_name(const char *in, char **out)
 	assert(in && out);
 
 	name = git__strdup(in);
-	GIT_ERROR_CHECK_ALLOC(name);
+	GITERR_CHECK_ALLOC(name);
 
 	fdot = strchr(name, '.');
 	ldot = strrchr(name, '.');
@@ -1421,8 +1402,8 @@ int git_config__normalize_name(const char *in, char **out)
 		goto invalid;
 
 	/* Validate and downcase up to first dot and after last dot */
-	if (normalize_section(name, fdot) < 0 ||
-	    normalize_section(ldot + 1, NULL) < 0)
+	if (git_config_file_normalize_section(name, fdot) < 0 ||
+		git_config_file_normalize_section(ldot + 1, NULL) < 0)
 		goto invalid;
 
 	/* If there is a middle range, make sure it doesn't have newlines */
@@ -1435,7 +1416,7 @@ int git_config__normalize_name(const char *in, char **out)
 
 invalid:
 	git__free(name);
-	git_error_set(GIT_ERROR_CONFIG, "invalid config item name '%s'", in);
+	giterr_set(GITERR_CONFIG, "invalid config item name '%s'", in);
 	return GIT_EINVALIDSPEC;
 }
 
@@ -1494,10 +1475,11 @@ int git_config_rename_section(
 		goto cleanup;
 
 	if (new_section_name != NULL &&
-	    (error = normalize_section(replace.ptr, strchr(replace.ptr, '.'))) < 0)
+		(error = git_config_file_normalize_section(
+			replace.ptr, strchr(replace.ptr, '.'))) < 0)
 	{
-		git_error_set(
-			GIT_ERROR_CONFIG, "invalid config section '%s'", new_section_name);
+		giterr_set(
+			GITERR_CONFIG, "invalid config section '%s'", new_section_name);
 		goto cleanup;
 	}
 
@@ -1505,8 +1487,8 @@ int git_config_rename_section(
 		config, git_buf_cstr(&pattern), rename_config_entries_cb, &data);
 
 cleanup:
-	git_buf_dispose(&pattern);
-	git_buf_dispose(&replace);
+	git_buf_free(&pattern);
+	git_buf_free(&replace);
 
 	return error;
 }