From 29e948debe603d7dd33a171a0101352e6b133a7a Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Vicent=20Mart=C3=AD?= <tanoku@gmail.com>
Date: Thu, 10 May 2012 10:38:10 +0200
Subject: [PATCH 1/7] global: Change parameter ordering in API

Consistency is good.
---
 include/git2/attr.h   | 32 +++++++++----------
 include/git2/config.h | 24 +++++++--------
 src/attr.c            | 12 ++++----
 src/config.c          | 72 +++++++++++++++++--------------------------
 src/config_cache.c    |  4 +--
 src/crlf.c            |  6 ++--
 src/diff.c            |  4 ++-
 src/diff_output.c     |  2 +-
 src/notes.c           |  2 +-
 src/remote.c          |  4 +--
 src/repository.c      | 15 +++++----
 src/submodule.c       |  5 ++-
 src/util.c            | 24 +++++++++++++++
 src/util.h            |  9 ++++++
 14 files changed, 118 insertions(+), 97 deletions(-)

diff --git a/include/git2/attr.h b/include/git2/attr.h
index 6a05496dc..28ca3bc1c 100644
--- a/include/git2/attr.h
+++ b/include/git2/attr.h
@@ -65,7 +65,7 @@ GIT_BEGIN_DECL
 #define GIT_ATTR_UNSPECIFIED(attr)	(!(attr) || (attr) == git_attr__unset)
 
 /**
- * GIT_ATTR_SET_TO_VALUE checks if an attribute is set to a value (as
+ * GIT_ATTR_HAS_VALUE checks if an attribute is set to a value (as
  * opposied to TRUE, FALSE or UNSPECIFIED).  This would be the case if
  * for a file with something like:
  *
@@ -74,7 +74,7 @@ GIT_BEGIN_DECL
  * Given this, looking up "eol" for `onefile.txt` will give back the
  * string "lf" and `GIT_ATTR_SET_TO_VALUE(attr)` will return true.
  */
-#define GIT_ATTR_SET_TO_VALUE(attr) \
+#define GIT_ATTR_HAS_VALUE(attr) \
 	((attr) && (attr) != git_attr__unset && \
 	 (attr) != git_attr__true && (attr) != git_attr__false)
 
@@ -111,6 +111,10 @@ GIT_EXTERN(const char *) git_attr__unset;
 /**
  * Look up the value of one git attribute for path.
  *
+ * @param value_out Output of the value of the attribute.  Use the GIT_ATTR_...
+ *             macros to test for TRUE, FALSE, UNSPECIFIED, etc. or just
+ *             use the string value for attributes set to a value.  You
+ *             should NOT modify or free this value.
  * @param repo The repository containing the path.
  * @param flags A combination of GIT_ATTR_CHECK... flags.
  * @param path The path to check for attributes.  Relative paths are
@@ -118,17 +122,13 @@ GIT_EXTERN(const char *) git_attr__unset;
  *             not have to exist, but if it does not, then it will be
  *             treated as a plain file (not a directory).
  * @param name The name of the attribute to look up.
- * @param value Output of the value of the attribute.  Use the GIT_ATTR_...
- *             macros to test for TRUE, FALSE, UNSPECIFIED, etc. or just
- *             use the string value for attributes set to a value.  You
- *             should NOT modify or free this value.
  */
 GIT_EXTERN(int) git_attr_get(
+	const char **value_out,
     git_repository *repo,
 	uint32_t flags,
 	const char *path,
-	const char *name,
-	const char **value);
+	const char *name);
 
 /**
  * Look up a list of git attributes for path.
@@ -141,11 +141,16 @@ GIT_EXTERN(int) git_attr_get(
  *
  *     const char *attrs[] = { "crlf", "diff", "foo" };
  *     const char **values[3];
- *     git_attr_get_many(repo, 0, "my/fun/file.c", 3, attrs, values);
+ *     git_attr_get_many(values, repo, 0, "my/fun/file.c", 3, attrs);
  *
  * Then you could loop through the 3 values to get the settings for
  * the three attributes you asked about.
  *
+ * @param values An array of num_attr entries that will have string
+ *             pointers written into it for the values of the attributes.
+ *             You should not modify or free the values that are written
+ *             into this array (although of course, you should free the
+ *             array itself if you allocated it).
  * @param repo The repository containing the path.
  * @param flags A combination of GIT_ATTR_CHECK... flags.
  * @param path The path inside the repo to check attributes.  This
@@ -153,19 +158,14 @@ GIT_EXTERN(int) git_attr_get(
  *             it will be treated as a plain file (i.e. not a directory).
  * @param num_attr The number of attributes being looked up
  * @param names An array of num_attr strings containing attribute names.
- * @param values An array of num_attr entries that will have string
- *             pointers written into it for the values of the attributes.
- *             You should not modify or free the values that are written
- *             into this array (although of course, you should free the
- *             array itself if you allocated it).
  */
 GIT_EXTERN(int) git_attr_get_many(
+	const char **values_out,
 	git_repository *repo,
 	uint32_t flags,
 	const char *path,
 	size_t num_attr,
-	const char **names,
-	const char **values);
+	const char **names);
 
 /**
  * Loop over all the git attributes for a path.
diff --git a/include/git2/config.h b/include/git2/config.h
index acc45b018..983d7fc9a 100644
--- a/include/git2/config.h
+++ b/include/git2/config.h
@@ -65,7 +65,7 @@ typedef struct {
  * @return GIT_SUCCESS if a global configuration file has been
  *	found. Its path will be stored in `buffer`.
  */
-GIT_EXTERN(int) git_config_find_global(char *global_config_path);
+GIT_EXTERN(int) git_config_find_global(char *global_config_path, size_t length);
 
 /**
  * Locate the path to the system configuration file
@@ -77,7 +77,7 @@ GIT_EXTERN(int) git_config_find_global(char *global_config_path);
  * @return GIT_SUCCESS if a system configuration file has been
  *	found. Its path will be stored in `buffer`.
  */
-GIT_EXTERN(int) git_config_find_system(char *system_config_path);
+GIT_EXTERN(int) git_config_find_system(char *system_config_path, size_t length);
 
 /**
  * Open the global configuration file
@@ -177,22 +177,22 @@ GIT_EXTERN(void) git_config_free(git_config *cfg);
 /**
  * Get the value of an integer config variable.
  *
+ * @param out pointer to the variable where the value should be stored
  * @param cfg where to look for the variable
  * @param name the variable's name
- * @param out pointer to the variable where the value should be stored
  * @return GIT_SUCCESS or an error code
  */
-GIT_EXTERN(int) git_config_get_int32(git_config *cfg, const char *name, int32_t *out);
+GIT_EXTERN(int) git_config_get_int32(int32_t *out, git_config *cfg, const char *name);
 
 /**
  * Get the value of a long integer config variable.
  *
+ * @param out pointer to the variable where the value should be stored
  * @param cfg where to look for the variable
  * @param name the variable's name
- * @param out pointer to the variable where the value should be stored
  * @return GIT_SUCCESS or an error code
  */
-GIT_EXTERN(int) git_config_get_int64(git_config *cfg, const char *name, int64_t *out);
+GIT_EXTERN(int) git_config_get_int64(int64_t *out, git_config *cfg, const char *name);
 
 /**
  * Get the value of a boolean config variable.
@@ -200,12 +200,12 @@ GIT_EXTERN(int) git_config_get_int64(git_config *cfg, const char *name, int64_t
  * This function uses the usual C convention of 0 being false and
  * anything else true.
  *
+ * @param out pointer to the variable where the value should be stored
  * @param cfg where to look for the variable
  * @param name the variable's name
- * @param out pointer to the variable where the value should be stored
  * @return GIT_SUCCESS or an error code
  */
-GIT_EXTERN(int) git_config_get_bool(git_config *cfg, const char *name, int *out);
+GIT_EXTERN(int) git_config_get_bool(int *out, git_config *cfg, const char *name);
 
 /**
  * Get the value of a string config variable.
@@ -213,12 +213,12 @@ GIT_EXTERN(int) git_config_get_bool(git_config *cfg, const char *name, int *out)
  * The string is owned by the variable and should not be freed by the
  * user.
  *
+ * @param out pointer to the variable's value
  * @param cfg where to look for the variable
  * @param name the variable's name
- * @param out pointer to the variable's value
  * @return GIT_SUCCESS or an error code
  */
-GIT_EXTERN(int) git_config_get_string(git_config *cfg, const char *name, const char **out);
+GIT_EXTERN(int) git_config_get_string(const char **out, git_config *cfg, const char *name);
 
 /**
  * Get each value of a multivar.
@@ -342,14 +342,14 @@ GIT_EXTERN(int) git_config_foreach(
  * If not a single match can be made to store in `out`, an error code will be
  * returned.
  *
+ * @param out place to store the result of the mapping
  * @param cfg config file to get the variables from
  * @param name name of the config variable to lookup
  * @param maps array of `git_cvar_map` objects specifying the possible mappings
  * @param map_n number of mapping objects in `maps`
- * @param out place to store the result of the mapping
  * @return GIT_SUCCESS on success, error code otherwise
  */
-GIT_EXTERN(int) git_config_get_mapped(git_config *cfg, const char *name, git_cvar_map *maps, size_t map_n, int *out);
+GIT_EXTERN(int) git_config_get_mapped(int *out, git_config *cfg, const char *name, git_cvar_map *maps, size_t map_n);
 
 /** @} */
 GIT_END_DECL
diff --git a/src/attr.c b/src/attr.c
index 1aa965de3..093f64d5c 100644
--- a/src/attr.c
+++ b/src/attr.c
@@ -13,11 +13,11 @@ static int collect_attr_files(
 
 
 int git_attr_get(
+	const char **value,
     git_repository *repo,
 	uint32_t flags,
 	const char *pathname,
-	const char *name,
-	const char **value)
+	const char *name)
 {
 	int error;
 	git_attr_path path;
@@ -64,12 +64,12 @@ typedef struct {
 } attr_get_many_info;
 
 int git_attr_get_many(
+	const char **values,
     git_repository *repo,
 	uint32_t flags,
 	const char *pathname,
     size_t num_attr,
-	const char **names,
-	const char **values)
+	const char **names)
 {
 	int error;
 	git_attr_path path;
@@ -576,11 +576,11 @@ int git_attr_cache__init(git_repository *repo)
 	if (git_repository_config__weakptr(&cfg, repo) < 0)
 		return -1;
 
-	ret = git_config_get_string(cfg, GIT_ATTR_CONFIG, &cache->cfg_attr_file);
+	ret = git_config_get_string(&cache->cfg_attr_file, cfg, GIT_ATTR_CONFIG);
 	if (ret < 0 && ret != GIT_ENOTFOUND)
 		return ret;
 
-	ret = git_config_get_string(cfg, GIT_IGNORE_CONFIG, &cache->cfg_excl_file);
+	ret = git_config_get_string(&cache->cfg_excl_file, cfg, GIT_IGNORE_CONFIG);
 	if (ret < 0 && ret != GIT_ENOTFOUND)
 		return ret;
 
diff --git a/src/config.c b/src/config.c
index 0ab0cd424..618202c34 100644
--- a/src/config.c
+++ b/src/config.c
@@ -199,30 +199,6 @@ int git_config_set_string(git_config *cfg, const char *name, const char *value)
 	return file->set(file, name, value);
 }
 
-int git_config_parse_bool(int *out, const char *value)
-{
-	/* A missing value means true */
-	if (value == NULL) {
-		*out = 1;
-		return 0;
-	}
-
-	if (!strcasecmp(value, "true") ||
-		!strcasecmp(value, "yes") ||
-		!strcasecmp(value, "on")) {
-		*out = 1;
-		return 0;
-	}
-	if (!strcasecmp(value, "false") ||
-		!strcasecmp(value, "no") ||
-		!strcasecmp(value, "off")) {
-		*out = 0;
-		return 0;
-	}
-
-	return -1;
-}
-
 static int parse_int64(int64_t *out, const char *value)
 {
 	const char *num_end;
@@ -297,7 +273,7 @@ int git_config_lookup_map_value(
 		case GIT_CVAR_TRUE: {
 			int bool_val;
 
-			if (git_config_parse_bool(&bool_val, value) == 0 && 
+			if (git__parse_bool(&bool_val, value) == 0 &&
 				bool_val == (int)m->cvar_type) {
 				*out = m->map_value;
 				return 0;
@@ -322,12 +298,17 @@ int git_config_lookup_map_value(
 	return GIT_ENOTFOUND;
 }
 
-int git_config_get_mapped(git_config *cfg, const char *name, git_cvar_map *maps, size_t map_n, int *out)
+int git_config_get_mapped(
+	int *out,
+	git_config *cfg,
+	const char *name,
+	git_cvar_map *maps,
+	size_t map_n)
 {
 	const char *value;
 	int ret;
 
-	ret = git_config_get_string(cfg, name, &value);
+	ret = git_config_get_string(&value, cfg, name);
 	if (ret < 0)
 		return ret;
 
@@ -339,12 +320,12 @@ int git_config_get_mapped(git_config *cfg, const char *name, git_cvar_map *maps,
 	return -1;
 }
 
-int git_config_get_int64(git_config *cfg, const char *name, int64_t *out)
+int git_config_get_int64(int64_t *out, git_config *cfg, const char *name)
 {
 	const char *value;
 	int ret;
 
-	ret = git_config_get_string(cfg, name, &value);
+	ret = git_config_get_string(&value, cfg, name);
 	if (ret < 0)
 		return ret;
 
@@ -356,12 +337,12 @@ int git_config_get_int64(git_config *cfg, const char *name, int64_t *out)
 	return 0;
 }
 
-int git_config_get_int32(git_config *cfg, const char *name, int32_t *out)
+int git_config_get_int32(int32_t *out, git_config *cfg, const char *name)
 {
 	const char *value;
 	int ret;
 
-	ret = git_config_get_string(cfg, name, &value);
+	ret = git_config_get_string(&value, cfg, name);
 	if (ret < 0)
 		return ret;
 
@@ -373,16 +354,16 @@ int git_config_get_int32(git_config *cfg, const char *name, int32_t *out)
 	return 0;
 }
 
-int git_config_get_bool(git_config *cfg, const char *name, int *out)
+int git_config_get_bool(int *out, git_config *cfg, const char *name)
 {
 	const char *value;
 	int ret;
 
-	ret = git_config_get_string(cfg, name, &value);
+	ret = git_config_get_string(&value, cfg, name);
 	if (ret < 0)
 		return ret;
 
-	if (git_config_parse_bool(out, value) == 0)
+	if (git__parse_bool(out, value) == 0)
 		return 0;
 
 	if (parse_int32(out, value) == 0) {
@@ -394,7 +375,7 @@ int git_config_get_bool(git_config *cfg, const char *name, int *out)
 	return -1;
 }
 
-int git_config_get_string(git_config *cfg, const char *name, const char **out)
+int git_config_get_string(const char **out, git_config *cfg, const char *name)
 {
 	file_internal *internal;
 	unsigned int i;
@@ -462,7 +443,7 @@ int git_config_find_global_r(git_buf *path)
 	return git_futils_find_global_file(path, GIT_CONFIG_FILENAME);
 }
 
-int git_config_find_global(char *global_config_path)
+int git_config_find_global(char *global_config_path, size_t length)
 {
 	git_buf path  = GIT_BUF_INIT;
 	int     ret = git_config_find_global_r(&path);
@@ -472,14 +453,14 @@ int git_config_find_global(char *global_config_path)
 		return ret;
 	}
 
-	if (path.size > GIT_PATH_MAX) {
+	if (path.size >= length) {
 		git_buf_free(&path);
 		giterr_set(GITERR_NOMEMORY,
 			"Path is to long to fit on the given buffer");
 		return -1;
 	}
 
-	git_buf_copy_cstr(global_config_path, GIT_PATH_MAX, &path);
+	git_buf_copy_cstr(global_config_path, length, &path);
 	git_buf_free(&path);
 	return 0;
 }
@@ -489,7 +470,7 @@ int git_config_find_system_r(git_buf *path)
 	return git_futils_find_system_file(path, GIT_CONFIG_FILENAME_SYSTEM);
 }
 
-int git_config_find_system(char *system_config_path)
+int git_config_find_system(char *system_config_path, size_t length)
 {
 	git_buf path  = GIT_BUF_INIT;
 	int     ret = git_config_find_system_r(&path);
@@ -499,14 +480,14 @@ int git_config_find_system(char *system_config_path)
 		return ret;
 	}
 
-	if (path.size > GIT_PATH_MAX) {
+	if (path.size >= length) {
 		git_buf_free(&path);
 		giterr_set(GITERR_NOMEMORY,
 			"Path is to long to fit on the given buffer");
 		return -1;
 	}
 
-	git_buf_copy_cstr(system_config_path, GIT_PATH_MAX, &path);
+	git_buf_copy_cstr(system_config_path, length, &path);
 	git_buf_free(&path);
 	return 0;
 }
@@ -514,11 +495,14 @@ int git_config_find_system(char *system_config_path)
 int git_config_open_global(git_config **out)
 {
 	int error;
-	char global_path[GIT_PATH_MAX];
+	git_buf path = GIT_BUF_INIT;
 
-	if ((error = git_config_find_global(global_path)) < 0)
+	if ((error = git_config_find_global_r(&path)) < 0)
 		return error;
 
-	return git_config_open_ondisk(out, global_path);
+	error = git_config_open_ondisk(out, git_buf_cstr(&path));
+	git_buf_free(&path);
+
+	return error;
 }
 
diff --git a/src/config_cache.c b/src/config_cache.c
index 3679a9646..057f21439 100644
--- a/src/config_cache.c
+++ b/src/config_cache.c
@@ -69,8 +69,8 @@ int git_repository__cvar(int *out, git_repository *repo, git_cvar_cached cvar)
 		if (error < GIT_SUCCESS)
 			return error;
 
-		error = git_config_get_mapped(
-			config, data->cvar_name, data->maps, data->map_count, out);
+		error = git_config_get_mapped(out,
+			config, data->cvar_name, data->maps, data->map_count);
 
 		if (error == GIT_ENOTFOUND)
 			*out = data->default_value;
diff --git a/src/crlf.c b/src/crlf.c
index 5d09a1f40..0ee1eef35 100644
--- a/src/crlf.c
+++ b/src/crlf.c
@@ -82,8 +82,8 @@ static int crlf_load_attributes(struct crlf_attrs *ca, git_repository *repo, con
 	const char *attr_vals[NUM_CONV_ATTRS];
 	int error;
 
-	error = git_attr_get_many(
-		repo, 0, path, NUM_CONV_ATTRS, attr_names, attr_vals);
+	error = git_attr_get_many(attr_vals,
+		repo, 0, path, NUM_CONV_ATTRS, attr_names);
 
 	if (error == GIT_ENOTFOUND) {
 		ca->crlf_action = GIT_CRLF_GUESS;
@@ -100,7 +100,7 @@ static int crlf_load_attributes(struct crlf_attrs *ca, git_repository *repo, con
 		return 0;
 	}
 
-	return error;
+	return -1;
 }
 
 static int drop_crlf(git_buf *dest, const git_buf *source)
diff --git a/src/diff.c b/src/diff.c
index d5c0c8ba5..0b2f8fb50 100644
--- a/src/diff.c
+++ b/src/diff.c
@@ -270,8 +270,10 @@ static int diff_delta__cmp(const void *a, const void *b)
 static int config_bool(git_config *cfg, const char *name, int defvalue)
 {
 	int val = defvalue;
-	if (git_config_get_bool(cfg, name, &val) < 0)
+
+	if (git_config_get_bool(&val, cfg, name) < 0)
 		giterr_clear();
+
 	return val;
 }
 
diff --git a/src/diff_output.c b/src/diff_output.c
index 4ad736e26..ba7ef8245 100644
--- a/src/diff_output.c
+++ b/src/diff_output.c
@@ -103,7 +103,7 @@ static int diff_output_cb(void *priv, mmbuffer_t *bufs, int len)
 static int update_file_is_binary_by_attr(git_repository *repo, git_diff_file *file)
 {
 	const char *value;
-	if (git_attr_get(repo, 0, file->path, "diff", &value) < 0)
+	if (git_attr_get(&value, repo, 0, file->path, "diff") < 0)
 		return -1;
 
 	if (GIT_ATTR_FALSE(value))
diff --git a/src/notes.c b/src/notes.c
index a86a75b01..84ad94087 100644
--- a/src/notes.c
+++ b/src/notes.c
@@ -274,7 +274,7 @@ static int note_get_default_ref(const char **out, git_repository *repo)
 	if (git_repository_config__weakptr(&cfg, repo) < 0)
 		return -1;
 
-	ret = git_config_get_string(cfg, "core.notesRef", out);
+	ret = git_config_get_string(out, cfg, "core.notesRef");
 	if (ret == GIT_ENOTFOUND) {
 		*out = GIT_NOTES_DEFAULT_REF;
 		return 0;
diff --git a/src/remote.c b/src/remote.c
index a5cfc822e..dc0ff6a03 100644
--- a/src/remote.c
+++ b/src/remote.c
@@ -48,7 +48,7 @@ static int parse_remote_refspec(git_config *cfg, git_refspec *refspec, const cha
 	int error;
 	const char *val;
 
-	if ((error = git_config_get_string(cfg, var, &val)) < 0)
+	if ((error = git_config_get_string(&val, cfg, var)) < 0)
 		return error;
 
 	return refspec_parse(refspec, val);
@@ -121,7 +121,7 @@ int git_remote_load(git_remote **out, git_repository *repo, const char *name)
 		goto cleanup;
 	}
 
-	if ((error = git_config_get_string(config, git_buf_cstr(&buf), &val)) < 0)
+	if ((error = git_config_get_string(&val, config, git_buf_cstr(&buf))) < 0)
 		goto cleanup;
 
 	remote->repo = repo;
diff --git a/src/repository.c b/src/repository.c
index c5eed531b..6ce3a560f 100644
--- a/src/repository.c
+++ b/src/repository.c
@@ -25,8 +25,7 @@
 
 #define GIT_BRANCH_MASTER "master"
 
-#define GIT_CONFIG_CORE_REPOSITORYFORMATVERSION "core.repositoryformatversion"
-#define GIT_REPOSITORYFORMATVERSION 0
+#define GIT_REPO_VERSION 0
 
 static void drop_odb(git_repository *repo)
 {
@@ -125,7 +124,7 @@ static int load_config_data(git_repository *repo)
 	if (git_repository_config__weakptr(&config, repo) < 0)
 		return -1;
 
-	if (git_config_get_bool(config, "core.bare", &is_bare) < 0)
+	if (git_config_get_bool(&is_bare, config, "core.bare") < 0)
 		return -1; /* FIXME: We assume that a missing core.bare
 					  variable is an error. Is this right? */
 
@@ -146,7 +145,7 @@ static int load_workdir(git_repository *repo, git_buf *parent_path)
 	if (git_repository_config__weakptr(&config, repo) < 0)
 		return -1;
 
-	error = git_config_get_string(config, "core.worktree", &worktree);
+	error = git_config_get_string(&worktree, config, "core.worktree");
 	if (!error && worktree != NULL)
 		repo->workdir = git__strdup(worktree);
 	else if (error != GIT_ENOTFOUND)
@@ -607,13 +606,13 @@ static int check_repositoryformatversion(git_repository *repo)
 	if (git_repository_config__weakptr(&config, repo) < 0)
 		return -1;
 
-	if (git_config_get_int32(config, GIT_CONFIG_CORE_REPOSITORYFORMATVERSION, &version) < 0)
+	if (git_config_get_int32(&version, config, "core.repositoryformatversion") < 0)
 		return -1;
 
-	if (GIT_REPOSITORYFORMATVERSION < version) {
+	if (GIT_REPO_VERSION < version) {
 		giterr_set(GITERR_REPOSITORY,
 			"Unsupported repository version %d. Only versions up to %d are supported.",
-			version, GIT_REPOSITORYFORMATVERSION);
+			version, GIT_REPO_VERSION);
 		return -1;
 	}
 
@@ -676,7 +675,7 @@ static int repo_init_config(const char *git_dir, int is_bare)
 	}
 
 	SET_REPO_CONFIG(bool, "core.bare", is_bare);
-	SET_REPO_CONFIG(int32, GIT_CONFIG_CORE_REPOSITORYFORMATVERSION, GIT_REPOSITORYFORMATVERSION);
+	SET_REPO_CONFIG(int32, "core.repositoryformatversion", GIT_REPO_VERSION);
 	/* TODO: what other defaults? */
 
 	git_buf_free(&cfg_path);
diff --git a/src/submodule.c b/src/submodule.c
index 1b5b59f45..3c07e657d 100644
--- a/src/submodule.c
+++ b/src/submodule.c
@@ -218,8 +218,11 @@ static int submodule_from_config(
 		sm->update = (git_submodule_update_t)val;
 	}
 	else if (strcmp(property, "fetchRecurseSubmodules") == 0) {
-		if (git_config_parse_bool(&sm->fetch_recurse, value) < 0)
+		if (git__parse_bool(&sm->fetch_recurse, value) < 0) {
+			giterr_set(GITERR_INVALID,
+				"Invalid value for submodule 'fetchRecurseSubmodules' property: '%s'", value);
 			goto fail;
+		}
 	}
 	else if (strcmp(property, "ignore") == 0) {
 		int val;
diff --git a/src/util.c b/src/util.c
index 9fd5f286c..ce770203a 100644
--- a/src/util.c
+++ b/src/util.c
@@ -411,3 +411,27 @@ int git__strcmp_cb(const void *a, const void *b)
 
 	return strcmp(stra, strb);
 }
+
+int git__parse_bool(int *out, const char *value)
+{
+	/* A missing value means true */
+	if (value == NULL) {
+		*out = 1;
+		return 0;
+	}
+
+	if (!strcasecmp(value, "true") ||
+		!strcasecmp(value, "yes") ||
+		!strcasecmp(value, "on")) {
+		*out = 1;
+		return 0;
+	}
+	if (!strcasecmp(value, "false") ||
+		!strcasecmp(value, "no") ||
+		!strcasecmp(value, "off")) {
+		*out = 0;
+		return 0;
+	}
+
+	return -1;
+}
diff --git a/src/util.h b/src/util.h
index cb5e83ce9..c6851ac7e 100644
--- a/src/util.h
+++ b/src/util.h
@@ -214,4 +214,13 @@ GIT_INLINE(bool) git__iswildcard(int c)
 	return (c == '*' || c == '?' || c == '[');
 }
 
+/*
+ * Parse a string value as a boolean, just like Core Git
+ * does.
+ *
+ * Valid values for true are: 'true', 'yes', 'on'
+ * Valid values for false are: 'false', 'no', 'off'
+ */
+extern int git__parse_bool(int *out, const char *value);
+
 #endif /* INCLUDE_util_h__ */

From 255c38c500e8fc1d8adcd86e42f8209ef0b84948 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Vicent=20Mart=C3=AD?= <tanoku@gmail.com>
Date: Thu, 10 May 2012 11:50:29 +0200
Subject: [PATCH 2/7] global: Fix unit tests after reordering

---
 tests-clar/attr/flags.c    | 58 +++++++++++++++++++-------------------
 tests-clar/attr/repo.c     | 26 ++++++++---------
 tests-clar/config/add.c    |  4 +--
 tests-clar/config/new.c    |  4 +--
 tests-clar/config/read.c   | 52 +++++++++++++++++-----------------
 tests-clar/config/stress.c | 10 +++----
 tests-clar/config/write.c  | 10 +++----
 7 files changed, 82 insertions(+), 82 deletions(-)

diff --git a/tests-clar/attr/flags.c b/tests-clar/attr/flags.c
index 5081de8b2..80c6e1171 100644
--- a/tests-clar/attr/flags.c
+++ b/tests-clar/attr/flags.c
@@ -14,7 +14,7 @@ void test_attr_flags__bare(void)
 	cl_assert(git_repository_is_bare(repo));
 
 	cl_git_pass(git_attr_get(
-		repo, GIT_ATTR_CHECK_NO_SYSTEM, "README.md", "diff", &value));
+		&value, repo, GIT_ATTR_CHECK_NO_SYSTEM, "README.md", "diff"));
 	cl_assert(GIT_ATTR_UNSPECIFIED(value));
 }
 
@@ -27,34 +27,34 @@ void test_attr_flags__index_vs_workdir(void)
 
 	/* wd then index */
 	cl_git_pass(git_attr_get(
-		repo, GIT_ATTR_CHECK_NO_SYSTEM | GIT_ATTR_CHECK_FILE_THEN_INDEX,
-		"README.md", "bar", &value));
+		&value, repo, GIT_ATTR_CHECK_NO_SYSTEM | GIT_ATTR_CHECK_FILE_THEN_INDEX,
+		"README.md", "bar"));
 	cl_assert(GIT_ATTR_FALSE(value));
 
 	cl_git_pass(git_attr_get(
-		repo, GIT_ATTR_CHECK_NO_SYSTEM | GIT_ATTR_CHECK_FILE_THEN_INDEX,
-		"README.md", "blargh", &value));
+		&value, repo, GIT_ATTR_CHECK_NO_SYSTEM | GIT_ATTR_CHECK_FILE_THEN_INDEX,
+		"README.md", "blargh"));
 	cl_assert_equal_s(value, "goop");
 
 	cl_git_pass(git_attr_get(
-		repo, GIT_ATTR_CHECK_NO_SYSTEM | GIT_ATTR_CHECK_FILE_THEN_INDEX,
-		"README.txt", "foo", &value));
+		&value, repo, GIT_ATTR_CHECK_NO_SYSTEM | GIT_ATTR_CHECK_FILE_THEN_INDEX,
+		"README.txt", "foo"));
 	cl_assert(GIT_ATTR_FALSE(value));
 
 	/* index then wd */
 	cl_git_pass(git_attr_get(
-		repo, GIT_ATTR_CHECK_NO_SYSTEM | GIT_ATTR_CHECK_INDEX_THEN_FILE,
-		"README.md", "bar", &value));
+		&value, repo, GIT_ATTR_CHECK_NO_SYSTEM | GIT_ATTR_CHECK_INDEX_THEN_FILE,
+		"README.md", "bar"));
 	cl_assert(GIT_ATTR_TRUE(value));
 
 	cl_git_pass(git_attr_get(
-		repo, GIT_ATTR_CHECK_NO_SYSTEM | GIT_ATTR_CHECK_INDEX_THEN_FILE,
-		"README.md", "blargh", &value));
+		&value, repo, GIT_ATTR_CHECK_NO_SYSTEM | GIT_ATTR_CHECK_INDEX_THEN_FILE,
+		"README.md", "blargh"));
 	cl_assert_equal_s(value, "garble");
 
 	cl_git_pass(git_attr_get(
-		repo, GIT_ATTR_CHECK_NO_SYSTEM | GIT_ATTR_CHECK_INDEX_THEN_FILE,
-		"README.txt", "foo", &value));
+		&value, repo, GIT_ATTR_CHECK_NO_SYSTEM | GIT_ATTR_CHECK_INDEX_THEN_FILE,
+		"README.txt", "foo"));
 	cl_assert(GIT_ATTR_TRUE(value));
 }
 
@@ -65,44 +65,44 @@ void test_attr_flags__subdir(void)
 
 	/* wd then index */
 	cl_git_pass(git_attr_get(
-		repo, GIT_ATTR_CHECK_NO_SYSTEM | GIT_ATTR_CHECK_FILE_THEN_INDEX,
-		"sub/sub/README.md", "bar", &value));
+		&value, repo, GIT_ATTR_CHECK_NO_SYSTEM | GIT_ATTR_CHECK_FILE_THEN_INDEX,
+		"sub/sub/README.md", "bar"));
 	cl_assert_equal_s(value, "1234");
 
 	cl_git_pass(git_attr_get(
-		repo, GIT_ATTR_CHECK_NO_SYSTEM | GIT_ATTR_CHECK_FILE_THEN_INDEX,
-		"sub/sub/README.txt", "another", &value));
+		&value, repo, GIT_ATTR_CHECK_NO_SYSTEM | GIT_ATTR_CHECK_FILE_THEN_INDEX,
+		"sub/sub/README.txt", "another"));
 	cl_assert_equal_s(value, "one");
 
 	cl_git_pass(git_attr_get(
-		repo, GIT_ATTR_CHECK_NO_SYSTEM | GIT_ATTR_CHECK_FILE_THEN_INDEX,
-		"sub/sub/README.txt", "again", &value));
+		&value, repo, GIT_ATTR_CHECK_NO_SYSTEM | GIT_ATTR_CHECK_FILE_THEN_INDEX,
+		"sub/sub/README.txt", "again"));
 	cl_assert(GIT_ATTR_TRUE(value));
 
 	cl_git_pass(git_attr_get(
-		repo, GIT_ATTR_CHECK_NO_SYSTEM | GIT_ATTR_CHECK_FILE_THEN_INDEX,
-		"sub/sub/README.txt", "beep", &value));
+		&value, repo, GIT_ATTR_CHECK_NO_SYSTEM | GIT_ATTR_CHECK_FILE_THEN_INDEX,
+		"sub/sub/README.txt", "beep"));
 	cl_assert_equal_s(value, "10");
 
 	/* index then wd */
 	cl_git_pass(git_attr_get(
-		repo, GIT_ATTR_CHECK_NO_SYSTEM | GIT_ATTR_CHECK_INDEX_THEN_FILE,
-		"sub/sub/README.md", "bar", &value));
+		&value, repo, GIT_ATTR_CHECK_NO_SYSTEM | GIT_ATTR_CHECK_INDEX_THEN_FILE,
+		"sub/sub/README.md", "bar"));
 	cl_assert_equal_s(value, "1337");
 
 	cl_git_pass(git_attr_get(
-		repo, GIT_ATTR_CHECK_NO_SYSTEM | GIT_ATTR_CHECK_INDEX_THEN_FILE,
-		"sub/sub/README.txt", "another", &value));
+		&value, repo, GIT_ATTR_CHECK_NO_SYSTEM | GIT_ATTR_CHECK_INDEX_THEN_FILE,
+		"sub/sub/README.txt", "another"));
 	cl_assert_equal_s(value, "one");
 
 	cl_git_pass(git_attr_get(
-		repo, GIT_ATTR_CHECK_NO_SYSTEM | GIT_ATTR_CHECK_INDEX_THEN_FILE,
-		"sub/sub/README.txt", "again", &value));
+		&value, repo, GIT_ATTR_CHECK_NO_SYSTEM | GIT_ATTR_CHECK_INDEX_THEN_FILE,
+		"sub/sub/README.txt", "again"));
 	cl_assert(GIT_ATTR_TRUE(value));
 
 	cl_git_pass(git_attr_get(
-		repo, GIT_ATTR_CHECK_NO_SYSTEM | GIT_ATTR_CHECK_INDEX_THEN_FILE,
-		"sub/sub/README.txt", "beep", &value));
+		&value, repo, GIT_ATTR_CHECK_NO_SYSTEM | GIT_ATTR_CHECK_INDEX_THEN_FILE,
+		"sub/sub/README.txt", "beep"));
 	cl_assert_equal_s(value, "5");
 }
 
diff --git a/tests-clar/attr/repo.c b/tests-clar/attr/repo.c
index 006a49081..a88dfb3f9 100644
--- a/tests-clar/attr/repo.c
+++ b/tests-clar/attr/repo.c
@@ -64,7 +64,7 @@ void test_attr_repo__get_one(void)
 
 	for (scan = test_cases; scan->path != NULL; scan++) {
 		const char *value;
-		cl_git_pass(git_attr_get(g_repo, 0, scan->path, scan->attr, &value));
+		cl_git_pass(git_attr_get(&value, g_repo, 0, scan->path, scan->attr));
 		attr_check_expected(scan->expected, scan->expected_str, value);
 	}
 
@@ -78,21 +78,21 @@ void test_attr_repo__get_many(void)
 	const char *names[4] = { "repoattr", "rootattr", "missingattr", "subattr" };
 	const char *values[4];
 
-	cl_git_pass(git_attr_get_many(g_repo, 0, "root_test1", 4, names, values));
+	cl_git_pass(git_attr_get_many(values, g_repo, 0, "root_test1", 4, names));
 
 	cl_assert(GIT_ATTR_TRUE(values[0]));
 	cl_assert(GIT_ATTR_TRUE(values[1]));
 	cl_assert(GIT_ATTR_UNSPECIFIED(values[2]));
 	cl_assert(GIT_ATTR_UNSPECIFIED(values[3]));
 
-	cl_git_pass(git_attr_get_many(g_repo, 0, "root_test2", 4, names, values));
+	cl_git_pass(git_attr_get_many(values, g_repo, 0, "root_test2", 4, names));
 
 	cl_assert(GIT_ATTR_TRUE(values[0]));
 	cl_assert(GIT_ATTR_FALSE(values[1]));
 	cl_assert(GIT_ATTR_UNSPECIFIED(values[2]));
 	cl_assert(GIT_ATTR_UNSPECIFIED(values[3]));
 
-	cl_git_pass(git_attr_get_many(g_repo, 0, "sub/subdir_test1", 4, names, values));
+	cl_git_pass(git_attr_get_many(values, g_repo, 0, "sub/subdir_test1", 4, names));
 
 	cl_assert(GIT_ATTR_TRUE(values[0]));
 	cl_assert(GIT_ATTR_TRUE(values[1]));
@@ -137,19 +137,19 @@ void test_attr_repo__manpage_example(void)
 {
 	const char *value;
 
-	cl_git_pass(git_attr_get(g_repo, 0, "sub/abc", "foo", &value));
+	cl_git_pass(git_attr_get(&value, g_repo, 0, "sub/abc", "foo"));
 	cl_assert(GIT_ATTR_TRUE(value));
 
-	cl_git_pass(git_attr_get(g_repo, 0, "sub/abc", "bar", &value));
+	cl_git_pass(git_attr_get(&value, g_repo, 0, "sub/abc", "bar"));
 	cl_assert(GIT_ATTR_UNSPECIFIED(value));
 
-	cl_git_pass(git_attr_get(g_repo, 0, "sub/abc", "baz", &value));
+	cl_git_pass(git_attr_get(&value, g_repo, 0, "sub/abc", "baz"));
 	cl_assert(GIT_ATTR_FALSE(value));
 
-	cl_git_pass(git_attr_get(g_repo, 0, "sub/abc", "merge", &value));
+	cl_git_pass(git_attr_get(&value, g_repo, 0, "sub/abc", "merge"));
 	cl_assert_equal_s("filfre", value);
 
-	cl_git_pass(git_attr_get(g_repo, 0, "sub/abc", "frotz", &value));
+	cl_git_pass(git_attr_get(&value, g_repo, 0, "sub/abc", "frotz"));
 	cl_assert(GIT_ATTR_UNSPECIFIED(value));
 }
 
@@ -160,7 +160,7 @@ void test_attr_repo__macros(void)
 	const char *names3[3] = { "macro2", "multi2", "multi3" };
 	const char *values[5];
 
-	cl_git_pass(git_attr_get_many(g_repo, 0, "binfile", 5, names, values));
+	cl_git_pass(git_attr_get_many(values, g_repo, 0, "binfile", 5, names));
 
 	cl_assert(GIT_ATTR_TRUE(values[0]));
 	cl_assert(GIT_ATTR_TRUE(values[1]));
@@ -168,7 +168,7 @@ void test_attr_repo__macros(void)
 	cl_assert(GIT_ATTR_FALSE(values[3]));
 	cl_assert(GIT_ATTR_UNSPECIFIED(values[4]));
 
-	cl_git_pass(git_attr_get_many(g_repo, 0, "macro_test", 5, names2, values));
+	cl_git_pass(git_attr_get_many(values, g_repo, 0, "macro_test", 5, names2));
 
 	cl_assert(GIT_ATTR_TRUE(values[0]));
 	cl_assert(GIT_ATTR_TRUE(values[1]));
@@ -176,7 +176,7 @@ void test_attr_repo__macros(void)
 	cl_assert(GIT_ATTR_UNSPECIFIED(values[3]));
 	cl_assert_equal_s("77", values[4]);
 
-	cl_git_pass(git_attr_get_many(g_repo, 0, "macro_test", 3, names3, values));
+	cl_git_pass(git_attr_get_many(values, g_repo, 0, "macro_test", 3, names3));
 
 	cl_assert(GIT_ATTR_TRUE(values[0]));
 	cl_assert(GIT_ATTR_FALSE(values[1]));
@@ -189,7 +189,7 @@ void test_attr_repo__bad_macros(void)
 		"firstmacro", "secondmacro", "thirdmacro" };
 	const char *values[6];
 
-	cl_git_pass(git_attr_get_many(g_repo, 0, "macro_bad", 6, names, values));
+	cl_git_pass(git_attr_get_many(values, g_repo, 0, "macro_bad", 6, names));
 
 	/* these three just confirm that the "mymacro" rule ran */
 	cl_assert(GIT_ATTR_UNSPECIFIED(values[0]));
diff --git a/tests-clar/config/add.c b/tests-clar/config/add.c
index b58029951..9854fbb39 100644
--- a/tests-clar/config/add.c
+++ b/tests-clar/config/add.c
@@ -17,7 +17,7 @@ void test_config_add__to_existing_section(void)
 
 	cl_git_pass(git_config_open_ondisk(&cfg, "config10"));
 	cl_git_pass(git_config_set_int32(cfg, "empty.tmp", 5));
-	cl_git_pass(git_config_get_int32(cfg, "empty.tmp", &i));
+	cl_git_pass(git_config_get_int32(&i, cfg, "empty.tmp"));
 	cl_assert(i == 5);
 	cl_git_pass(git_config_delete(cfg, "empty.tmp"));
 	git_config_free(cfg);
@@ -30,7 +30,7 @@ void test_config_add__to_new_section(void)
 
 	cl_git_pass(git_config_open_ondisk(&cfg, "config10"));
 	cl_git_pass(git_config_set_int32(cfg, "section.tmp", 5));
-	cl_git_pass(git_config_get_int32(cfg, "section.tmp", &i));
+	cl_git_pass(git_config_get_int32(&i, cfg, "section.tmp"));
 	cl_assert(i == 5);
 	cl_git_pass(git_config_delete(cfg, "section.tmp"));
 	git_config_free(cfg);
diff --git a/tests-clar/config/new.c b/tests-clar/config/new.c
index 78e8ec828..fae3ce941 100644
--- a/tests-clar/config/new.c
+++ b/tests-clar/config/new.c
@@ -25,9 +25,9 @@ void test_config_new__write_new_config(void)
 	cl_git_pass(git_config_new(&config));
 	cl_git_pass(git_config_add_file(config, file, 0));
 
-	cl_git_pass(git_config_get_string(config, "color.ui", &out));
+	cl_git_pass(git_config_get_string(&out, config, "color.ui"));
 	cl_assert_equal_s(out, "auto");
-	cl_git_pass(git_config_get_string(config, "core.editor", &out));
+	cl_git_pass(git_config_get_string(&out, config, "core.editor"));
 	cl_assert_equal_s(out, "ed");
 
 	git_config_free(config);
diff --git a/tests-clar/config/read.c b/tests-clar/config/read.c
index 3e9a8d4bf..f33bdd89e 100644
--- a/tests-clar/config/read.c
+++ b/tests-clar/config/read.c
@@ -7,13 +7,13 @@ void test_config_read__simple_read(void)
 
 	cl_git_pass(git_config_open_ondisk(&cfg, cl_fixture("config/config0")));
 
-	cl_git_pass(git_config_get_int32(cfg, "core.repositoryformatversion", &i));
+	cl_git_pass(git_config_get_int32(&i, cfg, "core.repositoryformatversion"));
 	cl_assert(i == 0);
-	cl_git_pass(git_config_get_bool(cfg, "core.filemode", &i));
+	cl_git_pass(git_config_get_bool(&i, cfg, "core.filemode"));
 	cl_assert(i == 1);
-	cl_git_pass(git_config_get_bool(cfg, "core.bare", &i));
+	cl_git_pass(git_config_get_bool(&i, cfg, "core.bare"));
 	cl_assert(i == 0);
-	cl_git_pass(git_config_get_bool(cfg, "core.logallrefupdates", &i));
+	cl_git_pass(git_config_get_bool(&i, cfg, "core.logallrefupdates"));
 	cl_assert(i == 1);
 
 	git_config_free(cfg);
@@ -27,18 +27,18 @@ void test_config_read__case_sensitive(void)
 
 	cl_git_pass(git_config_open_ondisk(&cfg, cl_fixture("config/config1")));
 
-	cl_git_pass(git_config_get_string(cfg, "this.that.other", &str));
+	cl_git_pass(git_config_get_string(&str, cfg, "this.that.other"));
 	cl_assert_equal_s(str, "true");
-	cl_git_pass(git_config_get_string(cfg, "this.That.other", &str));
+	cl_git_pass(git_config_get_string(&str, cfg, "this.That.other"));
 	cl_assert_equal_s(str, "yes");
 
-	cl_git_pass(git_config_get_bool(cfg, "this.that.other", &i));
+	cl_git_pass(git_config_get_bool(&i, cfg, "this.that.other"));
 	cl_assert(i == 1);
-	cl_git_pass(git_config_get_bool(cfg, "this.That.other", &i));
+	cl_git_pass(git_config_get_bool(&i, cfg, "this.That.other"));
 	cl_assert(i == 1);
 
 	/* This one doesn't exist */
-	cl_must_fail(git_config_get_bool(cfg, "this.thaT.other", &i));
+	cl_must_fail(git_config_get_bool(&i, cfg, "this.thaT.other"));
 
 	git_config_free(cfg);
 }
@@ -54,7 +54,7 @@ void test_config_read__multiline_value(void)
 
 	cl_git_pass(git_config_open_ondisk(&cfg, cl_fixture("config/config2")));
 
-	cl_git_pass(git_config_get_string(cfg, "this.That.and", &str));
+	cl_git_pass(git_config_get_string(&str, cfg, "this.That.and"));
 	cl_assert_equal_s(str, "one one one two two three three");
 
 	git_config_free(cfg);
@@ -70,11 +70,11 @@ void test_config_read__subsection_header(void)
 
 	cl_git_pass(git_config_open_ondisk(&cfg, cl_fixture("config/config3")));
 
-	cl_git_pass(git_config_get_string(cfg, "section.subsection.var", &str));
+	cl_git_pass(git_config_get_string(&str, cfg, "section.subsection.var"));
 	cl_assert_equal_s(str, "hello");
 
 	/* The subsection is transformed to lower-case */
-	cl_must_fail(git_config_get_string(cfg, "section.subSectIon.var", &str));
+	cl_must_fail(git_config_get_string(&str, cfg, "section.subSectIon.var"));
 
 	git_config_free(cfg);
 }
@@ -87,10 +87,10 @@ void test_config_read__lone_variable(void)
 
 	cl_git_pass(git_config_open_ondisk(&cfg, cl_fixture("config/config4")));
 
-	cl_git_pass(git_config_get_string(cfg, "some.section.variable", &str));
+	cl_git_pass(git_config_get_string(&str, cfg, "some.section.variable"));
 	cl_assert(str == NULL);
 
-	cl_git_pass(git_config_get_bool(cfg, "some.section.variable", &i));
+	cl_git_pass(git_config_get_bool(&i, cfg, "some.section.variable"));
 	cl_assert(i == 1);
 
 	git_config_free(cfg);
@@ -103,25 +103,25 @@ void test_config_read__number_suffixes(void)
 
 	cl_git_pass(git_config_open_ondisk(&cfg, cl_fixture("config/config5")));
 
-	cl_git_pass(git_config_get_int64(cfg, "number.simple", &i));
+	cl_git_pass(git_config_get_int64(&i, cfg, "number.simple"));
 	cl_assert(i == 1);
 
-	cl_git_pass(git_config_get_int64(cfg, "number.k", &i));
+	cl_git_pass(git_config_get_int64(&i, cfg, "number.k"));
 	cl_assert(i == 1 * 1024);
 
-	cl_git_pass(git_config_get_int64(cfg, "number.kk", &i));
+	cl_git_pass(git_config_get_int64(&i, cfg, "number.kk"));
 	cl_assert(i == 1 * 1024);
 
-	cl_git_pass(git_config_get_int64(cfg, "number.m", &i));
+	cl_git_pass(git_config_get_int64(&i, cfg, "number.m"));
 	cl_assert(i == 1 * 1024 * 1024);
 
-	cl_git_pass(git_config_get_int64(cfg, "number.mm", &i));
+	cl_git_pass(git_config_get_int64(&i, cfg, "number.mm"));
 	cl_assert(i == 1 * 1024 * 1024);
 
-	cl_git_pass(git_config_get_int64(cfg, "number.g", &i));
+	cl_git_pass(git_config_get_int64(&i, cfg, "number.g"));
 	cl_assert(i == 1 * 1024 * 1024 * 1024);
 
-	cl_git_pass(git_config_get_int64(cfg, "number.gg", &i));
+	cl_git_pass(git_config_get_int64(&i, cfg, "number.gg"));
 	cl_assert(i == 1 * 1024 * 1024 * 1024);
 
 	git_config_free(cfg);
@@ -134,10 +134,10 @@ void test_config_read__blank_lines(void)
 
 	cl_git_pass(git_config_open_ondisk(&cfg, cl_fixture("config/config6")));
 
-	cl_git_pass(git_config_get_bool(cfg, "valid.subsection.something", &i));
+	cl_git_pass(git_config_get_bool(&i, cfg, "valid.subsection.something"));
 	cl_assert(i == 1);
 
-	cl_git_pass(git_config_get_bool(cfg, "something.else.something", &i));
+	cl_git_pass(git_config_get_bool(&i, cfg, "something.else.something"));
 	cl_assert(i == 0);
 
 	git_config_free(cfg);
@@ -170,10 +170,10 @@ void test_config_read__prefixes(void)
 	const char *str;
 
 	cl_git_pass(git_config_open_ondisk(&cfg, cl_fixture("config/config9")));
-	cl_git_pass(git_config_get_string(cfg, "remote.ab.url", &str));
+	cl_git_pass(git_config_get_string(&str, cfg, "remote.ab.url"));
 	cl_assert_equal_s(str, "http://example.com/git/ab");
 
-	cl_git_pass(git_config_get_string(cfg, "remote.abba.url", &str));
+	cl_git_pass(git_config_get_string(&str, cfg, "remote.abba.url"));
 	cl_assert_equal_s(str, "http://example.com/git/abba");
 
 	git_config_free(cfg);
@@ -185,7 +185,7 @@ void test_config_read__escaping_quotes(void)
 	const char *str;
 
 	cl_git_pass(git_config_open_ondisk(&cfg, cl_fixture("config/config13")));
-	cl_git_pass(git_config_get_string(cfg, "core.editor", &str));
+	cl_git_pass(git_config_get_string(&str, cfg, "core.editor"));
 	cl_assert(strcmp(str, "\"C:/Program Files/Nonsense/bah.exe\" \"--some option\"") == 0);
 
 	git_config_free(cfg);
diff --git a/tests-clar/config/stress.c b/tests-clar/config/stress.c
index 54a61ad67..3de1f7692 100644
--- a/tests-clar/config/stress.c
+++ b/tests-clar/config/stress.c
@@ -32,8 +32,8 @@ void test_config_stress__dont_break_on_invalid_input(void)
 	cl_git_pass(git_config_new(&config));
 	cl_git_pass(git_config_add_file(config, file, 0));
 
-	cl_git_pass(git_config_get_string(config, "color.ui", &color));
-	cl_git_pass(git_config_get_string(config, "core.editor", &editor));
+	cl_git_pass(git_config_get_string(&color, config, "color.ui"));
+	cl_git_pass(git_config_get_string(&editor, config, "core.editor"));
 
 	git_config_free(config);
 }
@@ -48,13 +48,13 @@ void test_config_stress__comments(void)
 	cl_git_pass(git_config_new(&config));
 	cl_git_pass(git_config_add_file(config, file, 0));
 
-	cl_git_pass(git_config_get_string(config, "some.section.other", &str));
+	cl_git_pass(git_config_get_string(&str, config, "some.section.other"));
 	cl_assert(!strcmp(str, "hello! \" ; ; ; "));
 
-	cl_git_pass(git_config_get_string(config, "some.section.multi", &str));
+	cl_git_pass(git_config_get_string(&str, config, "some.section.multi"));
 	cl_assert(!strcmp(str, "hi, this is a ; multiline comment # with ;\n special chars and other stuff !@#"));
 
-	cl_git_pass(git_config_get_string(config, "some.section.back", &str));
+	cl_git_pass(git_config_get_string(&str, config, "some.section.back"));
 	cl_assert(!strcmp(str, "this is \ba phrase"));
 
 	git_config_free(config);
diff --git a/tests-clar/config/write.c b/tests-clar/config/write.c
index f25bf5a91..f8774473e 100644
--- a/tests-clar/config/write.c
+++ b/tests-clar/config/write.c
@@ -22,7 +22,7 @@ void test_config_write__replace_value(void)
 	git_config_free(cfg);
 
 	cl_git_pass(git_config_open_ondisk(&cfg, "config9"));
-	cl_git_pass(git_config_get_int32(cfg, "core.dummy", &i));
+	cl_git_pass(git_config_get_int32(&i, cfg, "core.dummy"));
 	cl_assert(i == 5);
 	git_config_free(cfg);
 
@@ -35,12 +35,12 @@ void test_config_write__replace_value(void)
 	git_config_free(cfg);
 
 	cl_git_pass(git_config_open_ondisk(&cfg, "config9"));
-	cl_git_pass(git_config_get_int64(cfg, "core.verylong", &l));
+	cl_git_pass(git_config_get_int64(&l, cfg, "core.verylong"));
 	cl_assert(l == expected);
 	git_config_free(cfg);
 
 	cl_git_pass(git_config_open_ondisk(&cfg, "config9"));
-	cl_must_fail(git_config_get_int32(cfg, "core.verylong", &i));
+	cl_must_fail(git_config_get_int32(&i, cfg, "core.verylong"));
 	git_config_free(cfg);
 
 	cl_git_pass(git_config_open_ondisk(&cfg, "config9"));
@@ -62,7 +62,7 @@ void test_config_write__delete_value(void)
 	git_config_free(cfg);
 
 	cl_git_pass(git_config_open_ondisk(&cfg, "config9"));
-	cl_assert(git_config_get_int32(cfg, "core.dummy", &i) == GIT_ENOTFOUND);
+	cl_assert(git_config_get_int32(&i, cfg, "core.dummy") == GIT_ENOTFOUND);
 	cl_git_pass(git_config_set_int32(cfg, "core.dummy", 1));
 	git_config_free(cfg);
 }
@@ -77,7 +77,7 @@ void test_config_write__write_subsection(void)
 	git_config_free(cfg);
 
 	cl_git_pass(git_config_open_ondisk(&cfg, "config9"));
-	cl_git_pass(git_config_get_string(cfg, "my.own.var", &str));
+	cl_git_pass(git_config_get_string(&str, cfg, "my.own.var"));
 	cl_git_pass(strcmp(str, "works"));
 	git_config_free(cfg);
 }

From fe3bcf7d7a1950d430a043a2ae11b81d231d6b1c Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Vicent=20Mart=C3=AD?= <tanoku@gmail.com>
Date: Fri, 11 May 2012 12:20:19 +0200
Subject: [PATCH 3/7] errors: Remove old comments

---
 include/git2/errors.h | 13 -------------
 1 file changed, 13 deletions(-)

diff --git a/include/git2/errors.h b/include/git2/errors.h
index 856343857..fa39a6730 100644
--- a/include/git2/errors.h
+++ b/include/git2/errors.h
@@ -20,25 +20,12 @@ GIT_BEGIN_DECL
 typedef enum {
 	GIT_SUCCESS = 0,
 	GIT_ERROR = -1,
-
-	/** Input does not exist in the scope searched. */
 	GIT_ENOTFOUND = -3,
-
-	/** A reference with this name already exists */
 	GIT_EEXISTS = -23,
-
-	/** The given integer literal is too large to be parsed */
 	GIT_EOVERFLOW = -24,
-
-	/** The given short oid is ambiguous */
 	GIT_EAMBIGUOUS = -29,
-
-	/** Skip and passthrough the given ODB backend */
 	GIT_EPASSTHROUGH = -30,
-
-	/** The buffer is too short to satisfy the request */
 	GIT_ESHORTBUFFER = -32,
-
 	GIT_EREVWALKOVER = -33,
 } git_error_t;
 

From 4fbd1c007e6c72b32c0dd2a29036a5670f85120a Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Vicent=20Mart=C3=AD?= <tanoku@gmail.com>
Date: Thu, 17 May 2012 20:35:48 +0200
Subject: [PATCH 4/7] refs: git_reference_listall -> git_reference_list

---
 include/git2/refs.h       | 2 +-
 src/fetch.c               | 2 +-
 src/refs.c                | 2 +-
 src/transports/local.c    | 2 +-
 tests-clar/refs/list.c    | 4 ++--
 tests-clar/refs/listall.c | 2 +-
 6 files changed, 7 insertions(+), 7 deletions(-)

diff --git a/include/git2/refs.h b/include/git2/refs.h
index 2073aabc5..9abc32369 100644
--- a/include/git2/refs.h
+++ b/include/git2/refs.h
@@ -256,7 +256,7 @@ GIT_EXTERN(int) git_reference_packall(git_repository *repo);
  *		listing.
  * @return GIT_SUCCESS or an error code
  */
-GIT_EXTERN(int) git_reference_listall(git_strarray *array, git_repository *repo, unsigned int list_flags);
+GIT_EXTERN(int) git_reference_list(git_strarray *array, git_repository *repo, unsigned int list_flags);
 
 
 /**
diff --git a/src/fetch.c b/src/fetch.c
index 08c789ddb..c92cf4ef5 100644
--- a/src/fetch.c
+++ b/src/fetch.c
@@ -165,7 +165,7 @@ int git_fetch_setup_walk(git_revwalk **out, git_repository *repo)
 	unsigned int i;
 	git_reference *ref;
 
-	if (git_reference_listall(&refs, repo, GIT_REF_LISTALL) < 0)
+	if (git_reference_list(&refs, repo, GIT_REF_LISTALL) < 0)
 		return -1;
 
 	if (git_revwalk_new(&walk, repo) < 0)
diff --git a/src/refs.c b/src/refs.c
index 28e8f786b..9ba09249c 100644
--- a/src/refs.c
+++ b/src/refs.c
@@ -1518,7 +1518,7 @@ static int cb__reflist_add(const char *ref, void *data)
 	return git_vector_insert((git_vector *)data, git__strdup(ref));
 }
 
-int git_reference_listall(
+int git_reference_list(
 	git_strarray *array,
 	git_repository *repo,
 	unsigned int list_flags)
diff --git a/src/transports/local.c b/src/transports/local.c
index 5dc350103..f074a3478 100644
--- a/src/transports/local.c
+++ b/src/transports/local.c
@@ -91,7 +91,7 @@ static int store_refs(transport_local *t)
 
 	assert(t);
 
-	if (git_reference_listall(&ref_names, t->repo, GIT_REF_LISTALL) < 0 ||
+	if (git_reference_list(&ref_names, t->repo, GIT_REF_LISTALL) < 0 ||
 		git_vector_init(&t->refs, (unsigned int)ref_names.count, NULL) < 0)
 		goto on_error;
 
diff --git a/tests-clar/refs/list.c b/tests-clar/refs/list.c
index f673bd9be..2a7b157ca 100644
--- a/tests-clar/refs/list.c
+++ b/tests-clar/refs/list.c
@@ -25,7 +25,7 @@ void test_refs_list__all(void)
    // try to list all the references in our test repo
 	git_strarray ref_list;
 
-	cl_git_pass(git_reference_listall(&ref_list, g_repo, GIT_REF_LISTALL));
+	cl_git_pass(git_reference_list(&ref_list, g_repo, GIT_REF_LISTALL));
 
 	/*{
 		unsigned short i;
@@ -46,7 +46,7 @@ void test_refs_list__symbolic_only(void)
    // try to list only the symbolic references
 	git_strarray ref_list;
 
-	cl_git_pass(git_reference_listall(&ref_list, g_repo, GIT_REF_SYMBOLIC));
+	cl_git_pass(git_reference_list(&ref_list, g_repo, GIT_REF_SYMBOLIC));
 	cl_assert(ref_list.count == 0); /* no symrefs in the test repo */
 
 	git_strarray_free(&ref_list);
diff --git a/tests-clar/refs/listall.c b/tests-clar/refs/listall.c
index ced40a26e..7f1de74cc 100644
--- a/tests-clar/refs/listall.c
+++ b/tests-clar/refs/listall.c
@@ -9,7 +9,7 @@ static void ensure_no_refname_starts_with_a_forward_slash(const char *path)
 	size_t i;
 
 	cl_git_pass(git_repository_open(&repo, path));
-	cl_git_pass(git_reference_listall(&ref_list, repo, GIT_REF_LISTALL));
+	cl_git_pass(git_reference_list(&ref_list, repo, GIT_REF_LISTALL));
 
 	cl_assert(ref_list.count > 0);
 

From 2e2e97858de18abd43f7e59fcc6151510c6d3272 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Vicent=20Mart=C3=AD?= <tanoku@gmail.com>
Date: Fri, 18 May 2012 00:42:24 +0200
Subject: [PATCH 5/7] Properly tag all `enums` with a `_t`

---
 include/git2/branch.h             |  2 +-
 include/git2/odb_backend.h        | 14 ++++++-------
 include/git2/refs.h               |  2 +-
 include/git2/status.h             | 33 +++++++++++++++++--------------
 include/git2/types.h              |  4 ++--
 src/branch.c                      |  2 +-
 src/refs.c                        |  6 +++---
 tests-clar/refs/branches/delete.c |  2 +-
 8 files changed, 34 insertions(+), 31 deletions(-)

diff --git a/include/git2/branch.h b/include/git2/branch.h
index f4681dc09..69e7d1689 100644
--- a/include/git2/branch.h
+++ b/include/git2/branch.h
@@ -69,7 +69,7 @@ GIT_EXTERN(int) git_branch_create(
 GIT_EXTERN(int) git_branch_delete(
 		git_repository *repo,
 		const char *branch_name,
-		git_branch_type branch_type);
+		git_branch_t branch_type);
 
 /**
  * Fill a list with all the branches in the Repository
diff --git a/include/git2/odb_backend.h b/include/git2/odb_backend.h
index 9a0133f37..f4620f5f4 100644
--- a/include/git2/odb_backend.h
+++ b/include/git2/odb_backend.h
@@ -74,6 +74,13 @@ struct git_odb_backend {
 	void (* free)(struct git_odb_backend *);
 };
 
+/** Streaming mode */
+enum {
+	GIT_STREAM_RDONLY = (1 << 1),
+	GIT_STREAM_WRONLY = (1 << 2),
+	GIT_STREAM_RW = (GIT_STREAM_RDONLY | GIT_STREAM_WRONLY),
+};
+
 /** A stream to read/write from a backend */
 struct git_odb_stream {
 	struct git_odb_backend *backend;
@@ -85,13 +92,6 @@ struct git_odb_stream {
 	void (*free)(struct git_odb_stream *stream);
 };
 
-/** Streaming mode */
-typedef enum {
-	GIT_STREAM_RDONLY = (1 << 1),
-	GIT_STREAM_WRONLY = (1 << 2),
-	GIT_STREAM_RW = (GIT_STREAM_RDONLY | GIT_STREAM_WRONLY),
-} git_odb_streammode;
-
 GIT_EXTERN(int) git_odb_backend_pack(git_odb_backend **backend_out, const char *objects_dir);
 GIT_EXTERN(int) git_odb_backend_loose(git_odb_backend **backend_out, const char *objects_dir, int compression_level, int do_fsync);
 
diff --git a/include/git2/refs.h b/include/git2/refs.h
index 9abc32369..2760f9457 100644
--- a/include/git2/refs.h
+++ b/include/git2/refs.h
@@ -111,7 +111,7 @@ GIT_EXTERN(const char *) git_reference_target(git_reference *ref);
  * @param ref The reference
  * @return the type
  */
-GIT_EXTERN(git_rtype) git_reference_type(git_reference *ref);
+GIT_EXTERN(git_ref_t) git_reference_type(git_reference *ref);
 
 /**
  * Get the full name of a reference
diff --git a/include/git2/status.h b/include/git2/status.h
index 0130b4011..caa350325 100644
--- a/include/git2/status.h
+++ b/include/git2/status.h
@@ -19,19 +19,19 @@
  */
 GIT_BEGIN_DECL
 
-#define GIT_STATUS_CURRENT		0
+enum {
+	GIT_STATUS_CURRENT	= 0,
 
-/** Flags for index status */
-#define GIT_STATUS_INDEX_NEW		(1 << 0)
-#define GIT_STATUS_INDEX_MODIFIED	(1 << 1)
-#define GIT_STATUS_INDEX_DELETED	(1 << 2)
+	GIT_STATUS_INDEX_NEW = (1 << 0),
+	GIT_STATUS_INDEX_MODIFIED = (1 << 1),
+	GIT_STATUS_INDEX_DELETED = (1 << 2),
 
-/** Flags for worktree status */
-#define GIT_STATUS_WT_NEW			(1 << 3)
-#define GIT_STATUS_WT_MODIFIED		(1 << 4)
-#define GIT_STATUS_WT_DELETED		(1 << 5)
+	GIT_STATUS_WT_NEW = (1 << 3),
+	GIT_STATUS_WT_MODIFIED = (1 << 4),
+	GIT_STATUS_WT_DELETED = (1 << 5),
 
-#define GIT_STATUS_IGNORED		(1 << 6)
+	GIT_STATUS_IGNORED = (1 << 6),
+};
 
 /**
  * Gather file statuses and run a callback for each one.
@@ -97,11 +97,14 @@ typedef enum {
  *   slash on the entry name).  Given this flag, the directory
  *   itself will not be included, but all the files in it will.
  */
-#define GIT_STATUS_OPT_INCLUDE_UNTRACKED      (1 << 0)
-#define GIT_STATUS_OPT_INCLUDE_IGNORED        (1 << 1)
-#define GIT_STATUS_OPT_INCLUDE_UNMODIFIED     (1 << 2)
-#define GIT_STATUS_OPT_EXCLUDE_SUBMODULES     (1 << 3)
-#define GIT_STATUS_OPT_RECURSE_UNTRACKED_DIRS (1 << 4)
+
+enum {
+	GIT_STATUS_OPT_INCLUDE_UNTRACKED = (1 << 0),
+	GIT_STATUS_OPT_INCLUDE_IGNORED = (1 << 1),
+	GIT_STATUS_OPT_INCLUDE_UNMODIFIED = (1 << 2),
+	GIT_STATUS_OPT_EXCLUDE_SUBMODULED = (1 << 3),
+	GIT_STATUS_OPT_RECURSE_UNTRACKED_DIRS = (1 << 4),
+};
 
 /**
  * Options to control how callbacks will be made by
diff --git a/include/git2/types.h b/include/git2/types.h
index 98eea5374..cfb0acf33 100644
--- a/include/git2/types.h
+++ b/include/git2/types.h
@@ -158,13 +158,13 @@ typedef enum {
 	GIT_REF_PACKED = 4,
 	GIT_REF_HAS_PEEL = 8,
 	GIT_REF_LISTALL = GIT_REF_OID|GIT_REF_SYMBOLIC|GIT_REF_PACKED,
-} git_rtype;
+} git_ref_t;
 
 /** Basic type of any Git branch. */
 typedef enum {
 	GIT_BRANCH_LOCAL = 1,
 	GIT_BRANCH_REMOTE = 2,
-} git_branch_type;
+} git_branch_t;
 
 typedef struct git_refspec git_refspec;
 typedef struct git_remote git_remote;
diff --git a/src/branch.c b/src/branch.c
index 6d5880cb2..9698bbf56 100644
--- a/src/branch.c
+++ b/src/branch.c
@@ -105,7 +105,7 @@ cleanup:
 	return error;
 }
 
-int git_branch_delete(git_repository *repo, const char *branch_name, git_branch_type branch_type)
+int git_branch_delete(git_repository *repo, const char *branch_name, git_branch_t branch_type)
 {
 	git_reference *branch = NULL;
 	git_reference *head = NULL;
diff --git a/src/refs.c b/src/refs.c
index 9ba09249c..1ef3e13a4 100644
--- a/src/refs.c
+++ b/src/refs.c
@@ -194,10 +194,10 @@ corrupt:
 	return -1;
 }
 
-static git_rtype loose_guess_rtype(const git_buf *full_path)
+static git_ref_t loose_guess_rtype(const git_buf *full_path)
 {
 	git_buf ref_file = GIT_BUF_INIT;
-	git_rtype type;
+	git_ref_t type;
 
 	type = GIT_REF_INVALID;
 
@@ -1153,7 +1153,7 @@ int git_reference_lookup_resolved(
 /**
  * Getters
  */
-git_rtype git_reference_type(git_reference *ref)
+git_ref_t git_reference_type(git_reference *ref)
 {
 	assert(ref);
 
diff --git a/tests-clar/refs/branches/delete.c b/tests-clar/refs/branches/delete.c
index 8ccfaf32f..03d3c56d7 100644
--- a/tests-clar/refs/branches/delete.c
+++ b/tests-clar/refs/branches/delete.c
@@ -75,7 +75,7 @@ void test_refs_branches_delete__can_delete_a_remote_branch(void)
 	cl_git_pass(git_branch_delete(repo, "nulltoken/master", GIT_BRANCH_REMOTE));
 }
 
-static void assert_non_exisitng_branch_removal(const char *branch_name, git_branch_type branch_type)
+static void assert_non_exisitng_branch_removal(const char *branch_name, git_branch_t branch_type)
 {
 	int error; 
 	error = git_branch_delete(repo, branch_name, branch_type);

From e172cf082e62aa421703080d0bccb7b8762c8bd4 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Vicent=20Mart=C3=AD?= <tanoku@gmail.com>
Date: Fri, 18 May 2012 01:21:06 +0200
Subject: [PATCH 6/7] errors: Rename the generic return codes

---
 examples/diff.c                   |  4 +--
 examples/general.c                |  2 +-
 examples/network/git2.c           |  4 +--
 examples/network/index-pack.c     |  6 ++--
 examples/network/ls-remote.c      | 10 +++----
 include/git2/blob.h               | 10 +++----
 include/git2/branch.h             |  8 +++---
 include/git2/commit.h             | 10 +++----
 include/git2/config.h             | 34 +++++++++++-----------
 include/git2/errors.h             | 47 +++++++++++++++++++++++++++----
 include/git2/index.h              | 18 ++++++------
 include/git2/notes.h              | 10 +++----
 include/git2/object.h             |  2 +-
 include/git2/odb.h                | 24 ++++++++--------
 include/git2/oid.h                |  6 ++--
 include/git2/reflog.h             |  8 +++---
 include/git2/refs.h               | 26 ++++++++---------
 include/git2/refspec.h            |  2 +-
 include/git2/remote.h             | 18 ++++++------
 include/git2/repository.h         | 14 ++++-----
 include/git2/revwalk.h            | 22 +++++++--------
 include/git2/signature.h          |  4 +--
 include/git2/status.h             |  4 +--
 include/git2/submodule.h          |  4 +--
 include/git2/tag.h                | 22 +++++++--------
 include/git2/tree.h               | 17 ++++++-----
 src/attr.c                        | 14 ++++-----
 src/attr_file.c                   | 14 ++++-----
 src/branch.c                      |  2 +-
 src/commit.c                      |  6 ++--
 src/config.c                      | 16 +++++------
 src/config_cache.c                |  8 +++---
 src/config_file.c                 | 12 ++++----
 src/crlf.c                        |  6 ++--
 src/delta-apply.c                 |  2 +-
 src/delta-apply.h                 |  2 +-
 src/diff.c                        |  2 +-
 src/fileops.c                     | 10 +++----
 src/fileops.h                     |  6 ++--
 src/filter.c                      |  4 +--
 src/filter.h                      |  2 +-
 src/ignore.c                      |  2 +-
 src/index.c                       |  2 +-
 src/indexer.c                     |  8 +++---
 src/iterator.c                    |  6 ++--
 src/notes.c                       | 10 +++----
 src/object.c                      | 12 ++++----
 src/odb.c                         | 24 ++++++++--------
 src/odb.h                         |  4 +--
 src/odb_loose.c                   |  2 +-
 src/odb_pack.c                    | 10 +++----
 src/pack.c                        | 14 ++++-----
 src/path.c                        |  4 +--
 src/pkt.c                         |  4 +--
 src/protocol.c                    |  2 +-
 src/refs.c                        |  8 +++---
 src/refspec.c                     |  4 +--
 src/refspec.h                     |  2 +-
 src/remote.c                      | 10 +++----
 src/repository.c                  | 10 +++----
 src/revwalk.c                     | 22 +++++++--------
 src/signature.c                   |  4 +--
 src/status.c                      |  2 +-
 src/submodule.c                   |  4 +--
 src/tag.c                         | 14 ++++-----
 src/transport.c                   |  6 ++--
 src/transports/git.c              | 10 +++----
 src/transports/http.c             |  6 ++--
 src/tree.c                        | 14 ++++-----
 src/vector.c                      |  6 ++--
 tests-clar/commit/signature.c     |  4 +--
 tests-clar/config/multivar.c      |  4 +--
 tests-clar/config/write.c         |  4 +--
 tests-clar/core/path.c            |  4 +--
 tests-clar/core/vector.c          |  2 +-
 tests-clar/index/tests.c          |  6 ++--
 tests-clar/network/remotelocal.c  |  2 +-
 tests-clar/network/remotes.c      |  2 +-
 tests-clar/notes/notes.c          |  2 +-
 tests-clar/object/lookup.c        |  8 +++---
 tests-clar/object/tag/read.c      |  4 +--
 tests-clar/object/tree/frompath.c | 18 ++++++------
 tests-clar/refs/branches/delete.c |  2 +-
 tests-clar/refs/branches/move.c   |  2 +-
 tests-clar/repo/discover.c        | 10 +++----
 tests-clar/repo/open.c            |  4 +--
 tests-clar/revwalk/basic.c        | 12 ++++----
 tests-clar/revwalk/mergebase.c    |  2 +-
 tests-clar/status/submodules.c    |  4 +--
 tests-clar/status/worktree.c      |  8 +++---
 90 files changed, 404 insertions(+), 368 deletions(-)

diff --git a/examples/diff.c b/examples/diff.c
index 1b4ab549b..3c44695cf 100644
--- a/examples/diff.c
+++ b/examples/diff.c
@@ -36,7 +36,7 @@ int resolve_to_tree(git_repository *repo, const char *identifier, git_tree **tre
 	}
 
 	if (obj == NULL)
-		return GIT_ENOTFOUND;
+		return GIT_NOTFOUND;
 
 	switch (git_object_type(obj)) {
 	case GIT_OBJ_TREE:
@@ -47,7 +47,7 @@ int resolve_to_tree(git_repository *repo, const char *identifier, git_tree **tre
 		git_object_free(obj);
 		break;
 	default:
-		err = GIT_ENOTFOUND;
+		err = GIT_NOTFOUND;
 	}
 
 	return err;
diff --git a/examples/general.c b/examples/general.c
index 46f2009bc..4585a4af5 100644
--- a/examples/general.c
+++ b/examples/general.c
@@ -335,7 +335,7 @@ int main (int argc, char** argv)
   // We can then lookup and parse the commited pointed at by the returned OID;
   // note that this operation is specially fast since the raw contents of the commit object will
   // be cached in memory
-  while ((git_revwalk_next(&oid, walk)) == GIT_SUCCESS) {
+  while ((git_revwalk_next(&oid, walk)) == 0) {
     error = git_commit_lookup(&wcommit, repo, &oid);
     cmsg  = git_commit_message(wcommit);
     cauth = git_commit_author(wcommit);
diff --git a/examples/network/git2.c b/examples/network/git2.c
index d6ea419c4..7c02305c4 100644
--- a/examples/network/git2.c
+++ b/examples/network/git2.c
@@ -25,12 +25,12 @@ int run_command(git_cb fn, int argc, char **argv)
 // repository and pass it to the function.
 
 	error = git_repository_open(&repo, ".git");
-	if (error < GIT_SUCCESS)
+	if (error < 0)
 		repo = NULL;
 
 	// Run the command. If something goes wrong, print the error message to stderr
 	error = fn(repo, argc, argv);
-	if (error < GIT_SUCCESS) {
+	if (error < 0) {
 		if (giterr_last() == NULL)
 			fprintf(stderr, "Error without message");
 		else
diff --git a/examples/network/index-pack.c b/examples/network/index-pack.c
index 881c1493f..03f3ae37e 100644
--- a/examples/network/index-pack.c
+++ b/examples/network/index-pack.c
@@ -80,13 +80,13 @@ int index_pack_old(git_repository *repo, int argc, char **argv)
 
   // Create a new indexer
   error = git_indexer_new(&indexer, argv[1]);
-  if (error < GIT_SUCCESS)
+  if (error < 0)
     return error;
 
   // Index the packfile. This function can take a very long time and
   // should be run in a worker thread.
   error = git_indexer_run(indexer, &stats);
-  if (error < GIT_SUCCESS)
+  if (error < 0)
     return error;
 
   // Write the information out to an index file
@@ -98,5 +98,5 @@ int index_pack_old(git_repository *repo, int argc, char **argv)
 
   git_indexer_free(indexer);
 
-  return GIT_SUCCESS;
+  return 0;
 }
diff --git a/examples/network/ls-remote.c b/examples/network/ls-remote.c
index 958a88651..39cc64725 100644
--- a/examples/network/ls-remote.c
+++ b/examples/network/ls-remote.c
@@ -9,7 +9,7 @@ static int show_ref__cb(git_remote_head *head, void *payload)
 	char oid[GIT_OID_HEXSZ + 1] = {0};
 	git_oid_fmt(oid, &head->oid);
 	printf("%s\t%s\n", oid, head->name);
-	return GIT_SUCCESS;
+	return 0;
 }
 
 int use_unnamed(git_repository *repo, const char *url)
@@ -20,13 +20,13 @@ int use_unnamed(git_repository *repo, const char *url)
 	// Create an instance of a remote from the URL. The transport to use
 	// is detected from the URL
 	error = git_remote_new(&remote, repo, NULL, url, NULL);
-	if (error < GIT_SUCCESS)
+	if (error < 0)
 		goto cleanup;
 
 	// When connecting, the underlying code needs to know wether we
 	// want to push or fetch
 	error = git_remote_connect(remote, GIT_DIR_FETCH);
-	if (error < GIT_SUCCESS)
+	if (error < 0)
 		goto cleanup;
 
 	// With git_remote_ls we can retrieve the advertised heads
@@ -44,11 +44,11 @@ int use_remote(git_repository *repo, char *name)
 
 	// Find the remote by name
 	error = git_remote_load(&remote, repo, name);
-	if (error < GIT_SUCCESS)
+	if (error < 0)
 		goto cleanup;
 
 	error = git_remote_connect(remote, GIT_DIR_FETCH);
-	if (error < GIT_SUCCESS)
+	if (error < 0)
 		goto cleanup;
 
 	error = git_remote_ls(remote, &show_ref__cb, NULL);
diff --git a/include/git2/blob.h b/include/git2/blob.h
index afa350bb1..551770678 100644
--- a/include/git2/blob.h
+++ b/include/git2/blob.h
@@ -27,7 +27,7 @@ GIT_BEGIN_DECL
  * @param blob pointer to the looked up blob
  * @param repo the repo to use when locating the blob.
  * @param id identity of the blob to locate.
- * @return GIT_SUCCESS or an error code
+ * @return 0 or an error code
  */
 GIT_INLINE(int) git_blob_lookup(git_blob **blob, git_repository *repo, const git_oid *id)
 {
@@ -44,7 +44,7 @@ GIT_INLINE(int) git_blob_lookup(git_blob **blob, git_repository *repo, const git
  * @param repo the repo to use when locating the blob.
  * @param id identity of the blob to locate.
  * @param len the length of the short identifier
- * @return GIT_SUCCESS or an error code
+ * @return 0 or an error code
  */
 GIT_INLINE(int) git_blob_lookup_prefix(git_blob **blob, git_repository *repo, const git_oid *id, unsigned int len)
 {
@@ -99,7 +99,7 @@ GIT_EXTERN(size_t) git_blob_rawsize(git_blob *blob);
  *	this repository cannot be bare
  * @param path file from which the blob will be created,
  *	relative to the repository's working dir
- * @return GIT_SUCCESS or an error code
+ * @return 0 or an error code
  */
 GIT_EXTERN(int) git_blob_create_fromfile(git_oid *oid, git_repository *repo, const char *path);
 
@@ -111,7 +111,7 @@ GIT_EXTERN(int) git_blob_create_fromfile(git_oid *oid, git_repository *repo, con
  * @param repo repository where the blob will be written.
  *	this repository can be bare or not
  * @param path file from which the blob will be created
- * @return GIT_SUCCESS or an error code
+ * @return 0 or an error code
  */
 GIT_EXTERN(int) git_blob_create_fromdisk(git_oid *oid, git_repository *repo, const char *path);
 
@@ -123,7 +123,7 @@ GIT_EXTERN(int) git_blob_create_fromdisk(git_oid *oid, git_repository *repo, con
  * @param repo repository where to blob will be written
  * @param buffer data to be written into the blob
  * @param len length of the data
- * @return GIT_SUCCESS or an error code
+ * @return 0 or an error code
  */
 GIT_EXTERN(int) git_blob_create_frombuffer(git_oid *oid, git_repository *repo, const void *buffer, size_t len);
 
diff --git a/include/git2/branch.h b/include/git2/branch.h
index 69e7d1689..5ffc7ddd5 100644
--- a/include/git2/branch.h
+++ b/include/git2/branch.h
@@ -41,7 +41,7 @@ GIT_BEGIN_DECL
  *
  * @param force Overwrite existing branch.
  *
- * @return GIT_SUCCESS or an error code.
+ * @return 0 or an error code.
  * A proper reference is written in the refs/heads namespace
  * pointing to the provided target commit.
  */
@@ -63,7 +63,7 @@ GIT_EXTERN(int) git_branch_create(
  * @param branch_type Type of the considered branch. This should
  * be valued with either GIT_BRANCH_LOCAL or GIT_BRANCH_REMOTE.
  *
- * @return GIT_SUCCESS on success, GIT_ENOTFOUND if the branch
+ * @return 0 on success, GIT_NOTFOUND if the branch
  * doesn't exist or an error code.
  */
 GIT_EXTERN(int) git_branch_delete(
@@ -88,7 +88,7 @@ GIT_EXTERN(int) git_branch_delete(
  * listing. Valid values are GIT_BRANCH_LOCAL, GIT_BRANCH_REMOTE
  * or a combination of the two.
  *
- * @return GIT_SUCCESS or an error code.
+ * @return 0 or an error code.
  */
 GIT_EXTERN(int) git_branch_list(
 		git_strarray *branch_names,
@@ -108,7 +108,7 @@ GIT_EXTERN(int) git_branch_list(
  *
  * @param force Overwrite existing branch.
  *
- * @return GIT_SUCCESS on success, GIT_ENOTFOUND if the branch
+ * @return 0 on success, GIT_NOTFOUND if the branch
  * doesn't exist or an error code.
  */
 GIT_EXTERN(int) git_branch_move(
diff --git a/include/git2/commit.h b/include/git2/commit.h
index e519bc128..a6d9bb0e3 100644
--- a/include/git2/commit.h
+++ b/include/git2/commit.h
@@ -28,7 +28,7 @@ GIT_BEGIN_DECL
  * @param repo the repo to use when locating the commit.
  * @param id identity of the commit to locate. If the object is
  *		an annotated tag it will be peeled back to the commit.
- * @return GIT_SUCCESS or an error code
+ * @return 0 or an error code
  */
 GIT_INLINE(int) git_commit_lookup(git_commit **commit, git_repository *repo, const git_oid *id)
 {
@@ -46,7 +46,7 @@ GIT_INLINE(int) git_commit_lookup(git_commit **commit, git_repository *repo, con
  * @param id identity of the commit to locate. If the object is
  *		an annotated tag it will be peeled back to the commit.
  * @param len the length of the short identifier
- * @return GIT_SUCCESS or an error code
+ * @return 0 or an error code
  */
 GIT_INLINE(int) git_commit_lookup_prefix(git_commit **commit, git_repository *repo, const git_oid *id, unsigned len)
 {
@@ -135,7 +135,7 @@ GIT_EXTERN(const git_signature *) git_commit_author(git_commit *commit);
  *
  * @param tree_out pointer where to store the tree object
  * @param commit a previously loaded commit.
- * @return GIT_SUCCESS or an error code
+ * @return 0 or an error code
  */
 GIT_EXTERN(int) git_commit_tree(git_tree **tree_out, git_commit *commit);
 
@@ -163,7 +163,7 @@ GIT_EXTERN(unsigned int) git_commit_parentcount(git_commit *commit);
  * @param parent Pointer where to store the parent commit
  * @param commit a previously loaded commit.
  * @param n the position of the parent (from 0 to `parentcount`)
- * @return GIT_SUCCESS or an error code
+ * @return 0 or an error code
  */
 GIT_EXTERN(int) git_commit_parent(git_commit **parent, git_commit *commit, unsigned int n);
 
@@ -221,7 +221,7 @@ GIT_EXTERN(const git_oid *) git_commit_parent_oid(git_commit *commit, unsigned i
  * array may be NULL if `parent_count` is 0 (root commit). All the
  * given commits must be owned by the `repo`.
  *
- * @return GIT_SUCCESS or an error code
+ * @return 0 or an error code
  *	The created commit will be written to the Object Database and
  *	the given reference will be updated to point to it
  */
diff --git a/include/git2/config.h b/include/git2/config.h
index 983d7fc9a..36946c4a5 100644
--- a/include/git2/config.h
+++ b/include/git2/config.h
@@ -62,7 +62,7 @@ typedef struct {
  * global configuration file.
  *
  * @param global_config_path Buffer of GIT_PATH_MAX length to store the path
- * @return GIT_SUCCESS if a global configuration file has been
+ * @return 0 if a global configuration file has been
  *	found. Its path will be stored in `buffer`.
  */
 GIT_EXTERN(int) git_config_find_global(char *global_config_path, size_t length);
@@ -74,7 +74,7 @@ GIT_EXTERN(int) git_config_find_global(char *global_config_path, size_t length);
  * %PROGRAMFILES%\Git\etc\gitconfig.
 
  * @param system_config_path Buffer of GIT_PATH_MAX length to store the path
- * @return GIT_SUCCESS if a system configuration file has been
+ * @return 0 if a system configuration file has been
  *	found. Its path will be stored in `buffer`.
  */
 GIT_EXTERN(int) git_config_find_system(char *system_config_path, size_t length);
@@ -86,7 +86,7 @@ GIT_EXTERN(int) git_config_find_system(char *system_config_path, size_t length);
  * and opens the located file, if it exists.
  *
  * @param out Pointer to store the config instance
- * @return GIT_SUCCESS or an error code
+ * @return 0 or an error code
  */
 GIT_EXTERN(int) git_config_open_global(git_config **out);
 
@@ -110,7 +110,7 @@ GIT_EXTERN(int) git_config_file__ondisk(struct git_config_file **out, const char
  * can do anything with it.
  *
  * @param out pointer to the new configuration
- * @return GIT_SUCCESS or an error code
+ * @return 0 or an error code
  */
 GIT_EXTERN(int) git_config_new(git_config **out);
 
@@ -127,7 +127,7 @@ GIT_EXTERN(int) git_config_new(git_config **out);
  * @param cfg the configuration to add the file to
  * @param file the configuration file (backend) to add
  * @param priority the priority the backend should have
- * @return GIT_SUCCESS or an error code
+ * @return 0 or an error code
  */
 GIT_EXTERN(int) git_config_add_file(git_config *cfg, git_config_file *file, int priority);
 
@@ -148,7 +148,7 @@ GIT_EXTERN(int) git_config_add_file(git_config *cfg, git_config_file *file, int
  * @param cfg the configuration to add the file to
  * @param path path to the configuration file (backend) to add
  * @param priority the priority the backend should have
- * @return GIT_SUCCESS or an error code
+ * @return 0 or an error code
  */
 GIT_EXTERN(int) git_config_add_file_ondisk(git_config *cfg, const char *path, int priority);
 
@@ -163,7 +163,7 @@ GIT_EXTERN(int) git_config_add_file_ondisk(git_config *cfg, const char *path, in
  *
  * @param cfg The configuration instance to create
  * @param path Path to the on-disk file to open
- * @return GIT_SUCCESS or an error code
+ * @return 0 or an error code
  */
 GIT_EXTERN(int) git_config_open_ondisk(git_config **cfg, const char *path);
 
@@ -180,7 +180,7 @@ GIT_EXTERN(void) git_config_free(git_config *cfg);
  * @param out pointer to the variable where the value should be stored
  * @param cfg where to look for the variable
  * @param name the variable's name
- * @return GIT_SUCCESS or an error code
+ * @return 0 or an error code
  */
 GIT_EXTERN(int) git_config_get_int32(int32_t *out, git_config *cfg, const char *name);
 
@@ -190,7 +190,7 @@ GIT_EXTERN(int) git_config_get_int32(int32_t *out, git_config *cfg, const char *
  * @param out pointer to the variable where the value should be stored
  * @param cfg where to look for the variable
  * @param name the variable's name
- * @return GIT_SUCCESS or an error code
+ * @return 0 or an error code
  */
 GIT_EXTERN(int) git_config_get_int64(int64_t *out, git_config *cfg, const char *name);
 
@@ -203,7 +203,7 @@ GIT_EXTERN(int) git_config_get_int64(int64_t *out, git_config *cfg, const char *
  * @param out pointer to the variable where the value should be stored
  * @param cfg where to look for the variable
  * @param name the variable's name
- * @return GIT_SUCCESS or an error code
+ * @return 0 or an error code
  */
 GIT_EXTERN(int) git_config_get_bool(int *out, git_config *cfg, const char *name);
 
@@ -216,7 +216,7 @@ GIT_EXTERN(int) git_config_get_bool(int *out, git_config *cfg, const char *name)
  * @param out pointer to the variable's value
  * @param cfg where to look for the variable
  * @param name the variable's name
- * @return GIT_SUCCESS or an error code
+ * @return 0 or an error code
  */
 GIT_EXTERN(int) git_config_get_string(const char **out, git_config *cfg, const char *name);
 
@@ -240,7 +240,7 @@ GIT_EXTERN(int) git_config_get_multivar(git_config *cfg, const char *name, const
  * @param cfg where to look for the variable
  * @param name the variable's name
  * @param value Integer value for the variable
- * @return GIT_SUCCESS or an error code
+ * @return 0 or an error code
  */
 GIT_EXTERN(int) git_config_set_int32(git_config *cfg, const char *name, int32_t value);
 
@@ -250,7 +250,7 @@ GIT_EXTERN(int) git_config_set_int32(git_config *cfg, const char *name, int32_t
  * @param cfg where to look for the variable
  * @param name the variable's name
  * @param value Long integer value for the variable
- * @return GIT_SUCCESS or an error code
+ * @return 0 or an error code
  */
 GIT_EXTERN(int) git_config_set_int64(git_config *cfg, const char *name, int64_t value);
 
@@ -260,7 +260,7 @@ GIT_EXTERN(int) git_config_set_int64(git_config *cfg, const char *name, int64_t
  * @param cfg where to look for the variable
  * @param name the variable's name
  * @param value the value to store
- * @return GIT_SUCCESS or an error code
+ * @return 0 or an error code
  */
 GIT_EXTERN(int) git_config_set_bool(git_config *cfg, const char *name, int value);
 
@@ -273,7 +273,7 @@ GIT_EXTERN(int) git_config_set_bool(git_config *cfg, const char *name, int value
  * @param cfg where to look for the variable
  * @param name the variable's name
  * @param value the string to store.
- * @return GIT_SUCCESS or an error code
+ * @return 0 or an error code
  */
 GIT_EXTERN(int) git_config_set_string(git_config *cfg, const char *name, const char *value);
 
@@ -307,7 +307,7 @@ GIT_EXTERN(int) git_config_delete(git_config *cfg, const char *name);
  * @param cfg where to get the variables from
  * @param callback the function to call on each variable
  * @param payload the data to pass to the callback
- * @return GIT_SUCCESS or the return value of the callback which didn't return 0
+ * @return 0 or the return value of the callback which didn't return 0
  */
 GIT_EXTERN(int) git_config_foreach(
 	git_config *cfg,
@@ -347,7 +347,7 @@ GIT_EXTERN(int) git_config_foreach(
  * @param name name of the config variable to lookup
  * @param maps array of `git_cvar_map` objects specifying the possible mappings
  * @param map_n number of mapping objects in `maps`
- * @return GIT_SUCCESS on success, error code otherwise
+ * @return 0 on success, error code otherwise
  */
 GIT_EXTERN(int) git_config_get_mapped(int *out, git_config *cfg, const char *name, git_cvar_map *maps, size_t map_n);
 
diff --git a/include/git2/errors.h b/include/git2/errors.h
index fa39a6730..361c0aca0 100644
--- a/include/git2/errors.h
+++ b/include/git2/errors.h
@@ -17,17 +17,54 @@
  */
 GIT_BEGIN_DECL
 
-typedef enum {
+#ifdef GIT_OLD_ERRORS
+enum {
 	GIT_SUCCESS = 0,
-	GIT_ERROR = -1,
+	GIT_ENOTOID = -2,
 	GIT_ENOTFOUND = -3,
+	GIT_ENOMEM = -4,
+	GIT_EOSERR = -5,
+	GIT_EOBJTYPE = -6,
+	GIT_ENOTAREPO = -7,
+	GIT_EINVALIDTYPE = -8,
+	GIT_EMISSINGOBJDATA = -9,
+	GIT_EPACKCORRUPTED = -10,
+	GIT_EFLOCKFAIL = -11,
+	GIT_EZLIB = -12,
+	GIT_EBUSY = -13,
+	GIT_EBAREINDEX = -14,
+	GIT_EINVALIDREFNAME = -15,
+	GIT_EREFCORRUPTED = -16,
+	GIT_ETOONESTEDSYMREF = -17,
+	GIT_EPACKEDREFSCORRUPTED = -18,
+	GIT_EINVALIDPATH = -19,
+	GIT_EREVWALKOVER = -20,
+	GIT_EINVALIDREFSTATE = -21,
+	GIT_ENOTIMPLEMENTED = -22,
 	GIT_EEXISTS = -23,
 	GIT_EOVERFLOW = -24,
+	GIT_ENOTNUM = -25,
+	GIT_ESTREAM = -26,
+	GIT_EINVALIDARGS = -27,
+	GIT_EOBJCORRUPTED = -28,
 	GIT_EAMBIGUOUS = -29,
 	GIT_EPASSTHROUGH = -30,
+	GIT_ENOMATCH = -31,
 	GIT_ESHORTBUFFER = -32,
-	GIT_EREVWALKOVER = -33,
-} git_error_t;
+};
+#endif
+
+/** Generic return codes */
+enum {
+	GIT_OK = 0,
+	GIT_ERROR = -1,
+	GIT_NOTFOUND = -3,
+	GIT_EXISTS = -23,
+	GIT_AMBIGUOUS = -29,
+	GIT_PASSTHROUGH = -30,
+	GIT_SHORTBUFFER = -32,
+	GIT_REVWALKOVER = -33,
+};
 
 typedef struct {
 	char *message;
@@ -50,7 +87,7 @@ typedef enum {
 	GITERR_TAG,
 	GITERR_TREE,
 	GITERR_INDEXER,
-} git_error_class;
+} git_error_t;
 
 /**
  * Return the last `git_error` object that was generated for the
diff --git a/include/git2/index.h b/include/git2/index.h
index ae727c59f..6a42c8515 100644
--- a/include/git2/index.h
+++ b/include/git2/index.h
@@ -106,7 +106,7 @@ typedef struct git_index_entry_unmerged {
  *
  * @param index the pointer for the new index
  * @param index_path the path to the index file in disk
- * @return GIT_SUCCESS or an error code
+ * @return 0 or an error code
  */
 GIT_EXTERN(int) git_index_open(git_index **index, const char *index_path);
 
@@ -131,7 +131,7 @@ GIT_EXTERN(void) git_index_free(git_index *index);
  * by reading from the hard disk.
  *
  * @param index an existing index object
- * @return GIT_SUCCESS or an error code
+ * @return 0 or an error code
  */
 GIT_EXTERN(int) git_index_read(git_index *index);
 
@@ -140,7 +140,7 @@ GIT_EXTERN(int) git_index_read(git_index *index);
  * using an atomic file lock.
  *
  * @param index an existing index object
- * @return GIT_SUCCESS or an error code
+ * @return 0 or an error code
  */
 GIT_EXTERN(int) git_index_write(git_index *index);
 
@@ -176,7 +176,7 @@ GIT_EXTERN(void) git_index_uniq(git_index *index);
  * @param index an existing index object
  * @param path filename to add
  * @param stage stage for the entry
- * @return GIT_SUCCESS or an error code
+ * @return 0 or an error code
  */
 GIT_EXTERN(int) git_index_add(git_index *index, const char *path, int stage);
 
@@ -188,7 +188,7 @@ GIT_EXTERN(int) git_index_add(git_index *index, const char *path, int stage);
  *
  * @param index an existing index object
  * @param source_entry new entry object
- * @return GIT_SUCCESS or an error code
+ * @return 0 or an error code
  */
 GIT_EXTERN(int) git_index_add2(git_index *index, const git_index_entry *source_entry);
 
@@ -207,7 +207,7 @@ GIT_EXTERN(int) git_index_add2(git_index *index, const git_index_entry *source_e
  * @param index an existing index object
  * @param path filename to add
  * @param stage stage for the entry
- * @return GIT_SUCCESS or an error code
+ * @return 0 or an error code
  */
 GIT_EXTERN(int) git_index_append(git_index *index, const char *path, int stage);
 
@@ -224,7 +224,7 @@ GIT_EXTERN(int) git_index_append(git_index *index, const char *path, int stage);
  *
  * @param index an existing index object
  * @param source_entry new entry object
- * @return GIT_SUCCESS or an error code
+ * @return 0 or an error code
  */
 GIT_EXTERN(int) git_index_append2(git_index *index, const git_index_entry *source_entry);
 
@@ -233,7 +233,7 @@ GIT_EXTERN(int) git_index_append2(git_index *index, const git_index_entry *sourc
  *
  * @param index an existing index object
  * @param position position of the entry to remove
- * @return GIT_SUCCESS or an error code
+ * @return 0 or an error code
  */
 GIT_EXTERN(int) git_index_remove(git_index *index, int position);
 
@@ -312,7 +312,7 @@ GIT_EXTERN(int) git_index_entry_stage(const git_index_entry *entry);
  *
  * @param index an existing index object
  * @param tree tree to read
- * @return GIT_SUCCESS or an error code
+ * @return 0 or an error code
  */
 GIT_EXTERN(int) git_index_read_tree(git_index *index, git_tree *tree);
 
diff --git a/include/git2/notes.h b/include/git2/notes.h
index ece5b274d..19073abd1 100644
--- a/include/git2/notes.h
+++ b/include/git2/notes.h
@@ -28,7 +28,7 @@ GIT_BEGIN_DECL
  * @param notes_ref OID reference to use (optional); defaults to "refs/notes/commits"
  * @param oid OID of the object
  *
- * @return GIT_SUCCESS or an error code
+ * @return 0 or an error code
  */
 GIT_EXTERN(int) git_note_read(git_note **note, git_repository *repo,
 			      const char *notes_ref, const git_oid *oid);
@@ -62,7 +62,7 @@ GIT_EXTERN(const git_oid *) git_note_oid(git_note *note);
  * @param oid The OID of the object
  * @param oid The note to add for object oid
  *
- * @return GIT_SUCCESS or an error code
+ * @return 0 or an error code
  */
 GIT_EXTERN(int) git_note_create(git_oid *out, git_repository *repo,
 				git_signature *author, git_signature *committer,
@@ -79,7 +79,7 @@ GIT_EXTERN(int) git_note_create(git_oid *out, git_repository *repo,
  * @param committer signature of the notes commit committer
  * @param oid the oid which note's to be removed
  *
- * @return GIT_SUCCESS or an error code
+ * @return 0 or an error code
  */
 GIT_EXTERN(int) git_note_remove(git_repository *repo, const char *notes_ref,
 				git_signature *author, git_signature *committer,
@@ -98,7 +98,7 @@ GIT_EXTERN(void) git_note_free(git_note *note);
  * @param out Pointer to the default notes reference
  * @param repo The Git repository
  *
- * @return GIT_SUCCESS or an error code
+ * @return 0 or an error code
  */
 GIT_EXTERN(int) git_note_default_ref(const char **out, git_repository *repo);
 
@@ -125,7 +125,7 @@ typedef struct {
  *
  * @param payload Extra parameter to callback function.
  *
- * @return GIT_SUCCESS or an error code.
+ * @return 0 or an error code.
  */
 GIT_EXTERN(int) git_note_foreach(
 		git_repository *repo,
diff --git a/include/git2/object.h b/include/git2/object.h
index 859d0c4a4..9e988b7b6 100644
--- a/include/git2/object.h
+++ b/include/git2/object.h
@@ -69,7 +69,7 @@ GIT_EXTERN(int) git_object_lookup(
  * @param id a short identifier for the object
  * @param len the length of the short identifier
  * @param type the type of the object
- * @return GIT_SUCCESS or an error code
+ * @return 0 or an error code
  */
 GIT_EXTERN(int) git_object_lookup_prefix(
 		git_object **object_out,
diff --git a/include/git2/odb.h b/include/git2/odb.h
index 87d70a60b..6f448f657 100644
--- a/include/git2/odb.h
+++ b/include/git2/odb.h
@@ -29,7 +29,7 @@ GIT_BEGIN_DECL
  *
  * @param out location to store the database pointer, if opened.
  *			Set to NULL if the open failed.
- * @return GIT_SUCCESS or an error code
+ * @return 0 or an error code
  */
 GIT_EXTERN(int) git_odb_new(git_odb **out);
 
@@ -47,7 +47,7 @@ GIT_EXTERN(int) git_odb_new(git_odb **out);
  * @param out location to store the database pointer, if opened.
  *			Set to NULL if the open failed.
  * @param objects_dir path of the backends' "objects" directory.
- * @return GIT_SUCCESS or an error code
+ * @return 0 or an error code
  */
 GIT_EXTERN(int) git_odb_open(git_odb **out, const char *objects_dir);
 
@@ -108,8 +108,8 @@ GIT_EXTERN(void) git_odb_free(git_odb *db);
  * @param db database to search for the object in.
  * @param id identity of the object to read.
  * @return
- * - GIT_SUCCESS if the object was read;
- * - GIT_ENOTFOUND if the object is not in the database.
+ * - 0 if the object was read;
+ * - GIT_NOTFOUND if the object is not in the database.
  */
 GIT_EXTERN(int) git_odb_read(git_odb_object **out, git_odb *db, const git_oid *id);
 
@@ -135,9 +135,9 @@ GIT_EXTERN(int) git_odb_read(git_odb_object **out, git_odb *db, const git_oid *i
  * @param db database to search for the object in.
  * @param short_id a prefix of the id of the object to read.
  * @param len the length of the prefix
- * @return GIT_SUCCESS if the object was read;
- *	GIT_ENOTFOUND if the object is not in the database.
- *	GIT_EAMBIGUOUS if the prefix is ambiguous (several objects match the prefix)
+ * @return 0 if the object was read;
+ *	GIT_NOTFOUND if the object is not in the database.
+ *	GIT_AMBIGUOUS if the prefix is ambiguous (several objects match the prefix)
  */
 GIT_EXTERN(int) git_odb_read_prefix(git_odb_object **out, git_odb *db, const git_oid *short_id, unsigned int len);
 
@@ -156,8 +156,8 @@ GIT_EXTERN(int) git_odb_read_prefix(git_odb_object **out, git_odb *db, const git
  * @param db database to search for the object in.
  * @param id identity of the object to read.
  * @return
- * - GIT_SUCCESS if the object was read;
- * - GIT_ENOTFOUND if the object is not in the database.
+ * - 0 if the object was read;
+ * - GIT_NOTFOUND if the object is not in the database.
  */
 GIT_EXTERN(int) git_odb_read_header(size_t *len_p, git_otype *type_p, git_odb *db, const git_oid *id);
 
@@ -188,7 +188,7 @@ GIT_EXTERN(int) git_odb_exists(git_odb *db, const git_oid *id);
  * @param data buffer with the data to storr
  * @param len size of the buffer
  * @param type type of the data to store
- * @return GIT_SUCCESS or an error code
+ * @return 0 or an error code
  */
 GIT_EXTERN(int) git_odb_write(git_oid *oid, git_odb *odb, const void *data, size_t len, git_otype type);
 
@@ -257,7 +257,7 @@ GIT_EXTERN(int) git_odb_open_rstream(git_odb_stream **stream, git_odb *db, const
  * @param data data to hash
  * @param len size of the data
  * @param type of the data to hash
- * @return GIT_SUCCESS or an error code
+ * @return 0 or an error code
  */
 GIT_EXTERN(int) git_odb_hash(git_oid *id, const void *data, size_t len, git_otype type);
 
@@ -270,7 +270,7 @@ GIT_EXTERN(int) git_odb_hash(git_oid *id, const void *data, size_t len, git_otyp
  * @param out oid structure the result is written into.
  * @param path file to read and determine object id for
  * @param type the type of the object that will be hashed
- * @return GIT_SUCCESS or an error code
+ * @return 0 or an error code
  */
 GIT_EXTERN(int) git_odb_hashfile(git_oid *out, const char *path, git_otype type);
 
diff --git a/include/git2/oid.h b/include/git2/oid.h
index 87efbab2f..c06458d24 100644
--- a/include/git2/oid.h
+++ b/include/git2/oid.h
@@ -43,7 +43,7 @@ struct _git_oid {
  * @param str input hex string; must be pointing at the start of
  *		the hex sequence and have at least the number of bytes
  *		needed for an oid encoded in hex (40 bytes).
- * @return GIT_SUCCESS or an error code
+ * @return 0 or an error code
  */
 GIT_EXTERN(int) git_oid_fromstr(git_oid *out, const char *str);
 
@@ -56,7 +56,7 @@ GIT_EXTERN(int) git_oid_fromstr(git_oid *out, const char *str);
  * @param out oid structure the result is written into.
  * @param str input hex string of at least size `length`
  * @param length length of the input string
- * @return GIT_SUCCESS or an error code
+ * @return 0 or an error code
  */
 GIT_EXTERN(int) git_oid_fromstrn(git_oid *out, const char *str, size_t length);
 
@@ -155,7 +155,7 @@ GIT_EXTERN(int) git_oid_ncmp(const git_oid *a, const git_oid *b, unsigned int le
  * @param a oid structure.
  * @param str input hex string of an object id.
  * @return GIT_ENOTOID if str is not a valid hex string,
- * GIT_SUCCESS in case of a match, GIT_ERROR otherwise.
+ * 0 in case of a match, GIT_ERROR otherwise.
  */
 GIT_EXTERN(int) git_oid_streq(const git_oid *a, const char *str);
 
diff --git a/include/git2/reflog.h b/include/git2/reflog.h
index d622abcad..f490e29de 100644
--- a/include/git2/reflog.h
+++ b/include/git2/reflog.h
@@ -28,7 +28,7 @@ GIT_BEGIN_DECL
  *
  * @param reflog pointer to reflog
  * @param ref reference to read the reflog for
- * @return GIT_SUCCESS or an error code
+ * @return 0 or an error code
  */
 GIT_EXTERN(int) git_reflog_read(git_reflog **reflog, git_reference *ref);
 
@@ -46,7 +46,7 @@ GIT_EXTERN(int) git_reflog_read(git_reflog **reflog, git_reference *ref);
  * @param oid_old the OID the reference was pointing to
  * @param committer the signature of the committer
  * @param msg the reflog message
- * @return GIT_SUCCESS or an error code
+ * @return 0 or an error code
  */
 GIT_EXTERN(int) git_reflog_write(git_reference *ref, const git_oid *oid_old, const git_signature *committer, const char *msg);
 
@@ -55,7 +55,7 @@ GIT_EXTERN(int) git_reflog_write(git_reference *ref, const git_oid *oid_old, con
  *
  * @param ref the reference
  * @param new_name the new name of the reference
- * @return GIT_SUCCESS or an error code
+ * @return 0 or an error code
  */
 GIT_EXTERN(int) git_reflog_rename(git_reference *ref, const char *new_name);
 
@@ -63,7 +63,7 @@ GIT_EXTERN(int) git_reflog_rename(git_reference *ref, const char *new_name);
  * Delete the reflog for the given reference
  *
  * @param ref the reference
- * @return GIT_SUCCESS or an error code
+ * @return 0 or an error code
  */
 GIT_EXTERN(int) git_reflog_delete(git_reference *ref);
 
diff --git a/include/git2/refs.h b/include/git2/refs.h
index 2760f9457..882e32769 100644
--- a/include/git2/refs.h
+++ b/include/git2/refs.h
@@ -28,7 +28,7 @@ GIT_BEGIN_DECL
  * @param reference_out pointer to the looked-up reference
  * @param repo the repository to look up the reference
  * @param name the long name for the reference (e.g. HEAD, ref/heads/master, refs/tags/v0.1.0, ...)
- * @return GIT_SUCCESS or an error code
+ * @return 0 or an error code
  */
 GIT_EXTERN(int) git_reference_lookup(git_reference **reference_out, git_repository *repo, const char *name);
 
@@ -59,7 +59,7 @@ GIT_EXTERN(int) git_reference_name_to_oid(
  * @param name The name of the reference
  * @param target The target of the reference
  * @param force Overwrite existing references
- * @return GIT_SUCCESS or an error code
+ * @return 0 or an error code
  */
 GIT_EXTERN(int) git_reference_create_symbolic(git_reference **ref_out, git_repository *repo, const char *name, const char *target, int force);
 
@@ -79,7 +79,7 @@ GIT_EXTERN(int) git_reference_create_symbolic(git_reference **ref_out, git_repos
  * @param name The name of the reference
  * @param id The object id pointed to by the reference.
  * @param force Overwrite existing references
- * @return GIT_SUCCESS or an error code
+ * @return 0 or an error code
  */
 GIT_EXTERN(int) git_reference_create_oid(git_reference **ref_out, git_repository *repo, const char *name, const git_oid *id, int force);
 
@@ -137,7 +137,7 @@ GIT_EXTERN(const char *) git_reference_name(git_reference *ref);
  *
  * @param resolved_ref Pointer to the peeled reference
  * @param ref The reference
- * @return GIT_SUCCESS or an error code
+ * @return 0 or an error code
  */
 GIT_EXTERN(int) git_reference_resolve(git_reference **resolved_ref, git_reference *ref);
 
@@ -160,7 +160,7 @@ GIT_EXTERN(git_repository *) git_reference_owner(git_reference *ref);
  *
  * @param ref The reference
  * @param target The new target for the reference
- * @return GIT_SUCCESS or an error code
+ * @return 0 or an error code
  */
 GIT_EXTERN(int) git_reference_set_target(git_reference *ref, const char *target);
 
@@ -175,7 +175,7 @@ GIT_EXTERN(int) git_reference_set_target(git_reference *ref, const char *target)
  *
  * @param ref The reference
  * @param id The new target OID for the reference
- * @return GIT_SUCCESS or an error code
+ * @return 0 or an error code
  */
 GIT_EXTERN(int) git_reference_set_oid(git_reference *ref, const git_oid *id);
 
@@ -202,7 +202,7 @@ GIT_EXTERN(int) git_reference_set_oid(git_reference *ref, const git_oid *id);
  * @param ref The reference to rename
  * @param new_name The new name for the reference
  * @param force Overwrite an existing reference
- * @return GIT_SUCCESS or an error code
+ * @return 0 or an error code
  *
  */
 GIT_EXTERN(int) git_reference_rename(git_reference *ref, const char *new_name, int force);
@@ -216,7 +216,7 @@ GIT_EXTERN(int) git_reference_rename(git_reference *ref, const char *new_name, i
  * memory. The given reference pointer will no longer be valid.
  *
  * @param ref The reference to remove
- * @return GIT_SUCCESS or an error code
+ * @return 0 or an error code
  */
 GIT_EXTERN(int) git_reference_delete(git_reference *ref);
 
@@ -231,7 +231,7 @@ GIT_EXTERN(int) git_reference_delete(git_reference *ref);
  * the loose references will be removed from disk.
  *
  * @param repo Repository where the loose refs will be packed
- * @return GIT_SUCCESS or an error code
+ * @return 0 or an error code
  */
 GIT_EXTERN(int) git_reference_packall(git_repository *repo);
 
@@ -254,7 +254,7 @@ GIT_EXTERN(int) git_reference_packall(git_repository *repo);
  * @param repo Repository where to find the refs
  * @param list_flags Filtering flags for the reference
  *		listing.
- * @return GIT_SUCCESS or an error code
+ * @return 0 or an error code
  */
 GIT_EXTERN(int) git_reference_list(git_strarray *array, git_repository *repo, unsigned int list_flags);
 
@@ -276,7 +276,7 @@ GIT_EXTERN(int) git_reference_list(git_strarray *array, git_repository *repo, un
  *		listing.
  * @param callback Function which will be called for every listed ref
  * @param payload Additional data to pass to the callback
- * @return GIT_SUCCESS or an error code
+ * @return 0 or an error code
  */
 GIT_EXTERN(int) git_reference_foreach(git_repository *repo, unsigned int list_flags, int (*callback)(const char *, void *), void *payload);
 
@@ -304,7 +304,7 @@ GIT_EXTERN(int) git_reference_is_packed(git_reference *ref);
  * returned and the reference pointer will be invalidated.
  *
  * @param ref The reference to reload
- * @return GIT_SUCCESS on success, or an error code
+ * @return 0 on success, or an error code
  */
 GIT_EXTERN(int) git_reference_reload(git_reference *ref);
 
@@ -320,7 +320,7 @@ GIT_EXTERN(void) git_reference_free(git_reference *ref);
  *
  * @param ref1 The first git_reference
  * @param ref2 The second git_reference
- * @return GIT_SUCCESS if the same, else a stable but meaningless ordering.
+ * @return 0 if the same, else a stable but meaningless ordering.
  */
 GIT_EXTERN(int) git_reference_cmp(git_reference *ref1, git_reference *ref2);
 
diff --git a/include/git2/refspec.h b/include/git2/refspec.h
index 50aa596f9..c46c1876a 100644
--- a/include/git2/refspec.h
+++ b/include/git2/refspec.h
@@ -51,7 +51,7 @@ GIT_EXTERN(int) git_refspec_src_matches(const git_refspec *refspec, const char *
  * @param outlen the size ouf the `out` buffer
  * @param spec the refspec
  * @param name the name of the reference to transform
- * @return GIT_SUCCESS, GIT_ESHORTBUFFER or another error
+ * @return 0, GIT_SHORTBUFFER or another error
  */
 GIT_EXTERN(int) git_refspec_transform(char *out, size_t outlen, const git_refspec *spec, const char *name);
 
diff --git a/include/git2/remote.h b/include/git2/remote.h
index 6550cd20b..865dfef04 100644
--- a/include/git2/remote.h
+++ b/include/git2/remote.h
@@ -41,7 +41,7 @@ GIT_BEGIN_DECL
  * @param name the remote's name
  * @param url the remote repository's URL
  * @param fetch the fetch refspec to use for this remote
- * @return GIT_SUCCESS or an error code
+ * @return 0 or an error code
  */
 GIT_EXTERN(int) git_remote_new(git_remote **out, git_repository *repo, const char *name, const char *url, const char *fetch);
 
@@ -51,7 +51,7 @@ GIT_EXTERN(int) git_remote_new(git_remote **out, git_repository *repo, const cha
  * @param out pointer to the new remote object
  * @param cfg the repository's configuration
  * @param name the remote's name
- * @return GIT_SUCCESS or an error code
+ * @return 0 or an error code
  */
 GIT_EXTERN(int) git_remote_load(git_remote **out, git_repository *repo, const char *name);
 
@@ -59,7 +59,7 @@ GIT_EXTERN(int) git_remote_load(git_remote **out, git_repository *repo, const ch
  * Save a remote to its repository's configuration
  *
  * @param remote the remote to save to config
- * @return GIT_SUCCESS or an error code
+ * @return 0 or an error code
  */
 GIT_EXTERN(int) git_remote_save(const git_remote *remote);
 
@@ -84,7 +84,7 @@ GIT_EXTERN(const char *) git_remote_url(git_remote *remote);
  *
  * @param remote the remote
  * @apram spec the new fetch refspec
- * @return GIT_SUCCESS or an error value
+ * @return 0 or an error value
  */
 GIT_EXTERN(int) git_remote_set_fetchspec(git_remote *remote, const char *spec);
 
@@ -101,7 +101,7 @@ GIT_EXTERN(const git_refspec *) git_remote_fetchspec(git_remote *remote);
  *
  * @param remote the remote
  * @apram spec the new push refspec
- * @return GIT_SUCCESS or an error value
+ * @return 0 or an error value
  */
 GIT_EXTERN(int) git_remote_set_pushspec(git_remote *remote, const char *spec);
 
@@ -123,7 +123,7 @@ GIT_EXTERN(const git_refspec *) git_remote_pushspec(git_remote *remote);
  *
  * @param remote the remote to connect to
  * @param direction whether you want to receive or send data
- * @return GIT_SUCCESS or an error code
+ * @return 0 or an error code
  */
 GIT_EXTERN(int) git_remote_connect(git_remote *remote, int direction);
 
@@ -135,7 +135,7 @@ GIT_EXTERN(int) git_remote_connect(git_remote *remote, int direction);
  *
  * @param refs where to store the refs
  * @param remote the remote
- * @return GIT_SUCCESS or an error code
+ * @return 0 or an error code
  */
 GIT_EXTERN(int) git_remote_ls(git_remote *remote, git_headlist_cb list_cb, void *payload);
 
@@ -150,7 +150,7 @@ GIT_EXTERN(int) git_remote_ls(git_remote *remote, git_headlist_cb list_cb, void
  *
  * @param remote the remote to download from
  * @param filename where to store the temproray filename
- * @return GIT_SUCCESS or an error code
+ * @return 0 or an error code
  */
 GIT_EXTERN(int) git_remote_download(git_remote *remote, git_off_t *bytes, git_indexer_stats *stats);
 
@@ -215,7 +215,7 @@ GIT_EXTERN(int) git_remote_supported_url(const char* url);
  *
  * @param remotes_list a string array with the names of the remotes
  * @param repo the repository to query
- * @return GIT_SUCCESS or an error code
+ * @return 0 or an error code
  */
 GIT_EXTERN(int) git_remote_list(git_strarray *remotes_list, git_repository *repo);
 
diff --git a/include/git2/repository.h b/include/git2/repository.h
index d760c23b7..3949438cf 100644
--- a/include/git2/repository.h
+++ b/include/git2/repository.h
@@ -31,7 +31,7 @@ GIT_BEGIN_DECL
  *
  * @param repository pointer to the repo which will be opened
  * @param path the path to the repository
- * @return GIT_SUCCESS or an error code
+ * @return 0 or an error code
  */
 GIT_EXTERN(int) git_repository_open(git_repository **repository, const char *path);
 
@@ -61,7 +61,7 @@ GIT_EXTERN(int) git_repository_open(git_repository **repository, const char *pat
  * start_path no matter start_path appears in ceiling_dirs ceiling_dirs
  * might be NULL (which is equivalent to an empty string)
  *
- * @return GIT_SUCCESS or an error code
+ * @return 0 or an error code
  */
 GIT_EXTERN(int) git_repository_discover(
 		char *repository_path,
@@ -109,7 +109,7 @@ GIT_EXTERN(void) git_repository_free(git_repository *repo);
  *		at the pointed path. If false, provided path will be considered as the working
  *		directory into which the .git directory will be created.
  *
- * @return GIT_SUCCESS or an error code
+ * @return 0 or an error code
  */
 GIT_EXTERN(int) git_repository_init(git_repository **repo_out, const char *path, unsigned is_bare);
 
@@ -194,7 +194,7 @@ GIT_EXTERN(const char *) git_repository_workdir(git_repository *repo);
  *
  * @param repo A repository object
  * @param workdir The path to a working directory
- * @return GIT_SUCCESS, or an error code
+ * @return 0, or an error code
  */
 GIT_EXTERN(int) git_repository_set_workdir(git_repository *repo, const char *workdir);
 
@@ -218,7 +218,7 @@ GIT_EXTERN(int) git_repository_is_bare(git_repository *repo);
  *
  * @param out Pointer to store the loaded config file
  * @param repo A repository object
- * @return GIT_SUCCESS, or an error code
+ * @return 0, or an error code
  */
 GIT_EXTERN(int) git_repository_config(git_config **out, git_repository *repo);
 
@@ -249,7 +249,7 @@ GIT_EXTERN(void) git_repository_set_config(git_repository *repo, git_config *con
  *
  * @param out Pointer to store the loaded ODB
  * @param repo A repository object
- * @return GIT_SUCCESS, or an error code
+ * @return 0, or an error code
  */
 GIT_EXTERN(int) git_repository_odb(git_odb **out, git_repository *repo);
 
@@ -280,7 +280,7 @@ GIT_EXTERN(void) git_repository_set_odb(git_repository *repo, git_odb *odb);
  *
  * @param out Pointer to store the loaded index
  * @param repo A repository object
- * @return GIT_SUCCESS, or an error code
+ * @return 0, or an error code
  */
 GIT_EXTERN(int) git_repository_index(git_index **out, git_repository *repo);
 
diff --git a/include/git2/revwalk.h b/include/git2/revwalk.h
index 632c67588..aac6fb7c2 100644
--- a/include/git2/revwalk.h
+++ b/include/git2/revwalk.h
@@ -65,7 +65,7 @@ GIT_BEGIN_DECL
  *
  * @param walker pointer to the new revision walker
  * @param repo the repo to walk through
- * @return GIT_SUCCESS or an error code
+ * @return 0 or an error code
  */
 GIT_EXTERN(int) git_revwalk_new(git_revwalk **walker, git_repository *repo);
 
@@ -97,7 +97,7 @@ GIT_EXTERN(void) git_revwalk_reset(git_revwalk *walker);
  *
  * @param walk the walker being used for the traversal.
  * @param oid the oid of the commit to start from.
- * @return GIT_SUCCESS or an error code
+ * @return 0 or an error code
  */
 GIT_EXTERN(int) git_revwalk_push(git_revwalk *walk, const git_oid *oid);
 
@@ -112,7 +112,7 @@ GIT_EXTERN(int) git_revwalk_push(git_revwalk *walk, const git_oid *oid);
  *
  * @param walk the walker being used for the traversal
  * @param glob the glob pattern references should match
- * @return GIT_SUCCESS or an error code
+ * @return 0 or an error code
  */
 GIT_EXTERN(int) git_revwalk_push_glob(git_revwalk *walk, const char *glob);
 
@@ -120,7 +120,7 @@ GIT_EXTERN(int) git_revwalk_push_glob(git_revwalk *walk, const char *glob);
  * Push the repository's HEAD
  *
  * @param walk the walker being used for the traversal
- * @return GIT_SUCCESS or an error code
+ * @return 0 or an error code
  */
 GIT_EXTERN(int) git_revwalk_push_head(git_revwalk *walk);
 
@@ -135,7 +135,7 @@ GIT_EXTERN(int) git_revwalk_push_head(git_revwalk *walk);
  *
  * @param walk the walker being used for the traversal.
  * @param oid the oid of commit that will be ignored during the traversal
- * @return GIT_SUCCESS or an error code
+ * @return 0 or an error code
  */
 GIT_EXTERN(int) git_revwalk_hide(git_revwalk *walk, const git_oid *oid);
 
@@ -151,7 +151,7 @@ GIT_EXTERN(int) git_revwalk_hide(git_revwalk *walk, const git_oid *oid);
  *
  * @param walk the walker being used for the traversal
  * @param glob the glob pattern references should match
- * @return GIT_SUCCESS or an error code
+ * @return 0 or an error code
  */
 GIT_EXTERN(int) git_revwalk_hide_glob(git_revwalk *walk, const char *glob);
 
@@ -159,7 +159,7 @@ GIT_EXTERN(int) git_revwalk_hide_glob(git_revwalk *walk, const char *glob);
  * Hide the repository's HEAD
  *
  * @param walk the walker being used for the traversal
- * @return GIT_SUCCESS or an error code
+ * @return 0 or an error code
  */
 GIT_EXTERN(int) git_revwalk_hide_head(git_revwalk *walk);
 
@@ -170,7 +170,7 @@ GIT_EXTERN(int) git_revwalk_hide_head(git_revwalk *walk);
  *
  * @param walk the walker being used for the traversal
  * @param refname the referece to push
- * @return GIT_SUCCESS or an error code
+ * @return 0 or an error code
  */
 GIT_EXTERN(int) git_revwalk_push_ref(git_revwalk *walk, const char *refname);
 
@@ -181,7 +181,7 @@ GIT_EXTERN(int) git_revwalk_push_ref(git_revwalk *walk, const char *refname);
  *
  * @param walk the walker being used for the traversal
  * @param refname the referece to hide
- * @return GIT_SUCCESS or an error code
+ * @return 0 or an error code
  */
 GIT_EXTERN(int) git_revwalk_hide_ref(git_revwalk *walk, const char *refname);
 
@@ -200,8 +200,8 @@ GIT_EXTERN(int) git_revwalk_hide_ref(git_revwalk *walk, const char *refname);
  *
  * @param oid Pointer where to store the oid of the next commit
  * @param walk the walker to pop the commit from.
- * @return GIT_SUCCESS if the next commit was found;
- *	GIT_EREVWALKOVER if there are no commits left to iterate
+ * @return 0 if the next commit was found;
+ *	GIT_REVWALKOVER if there are no commits left to iterate
  */
 GIT_EXTERN(int) git_revwalk_next(git_oid *oid, git_revwalk *walk);
 
diff --git a/include/git2/signature.h b/include/git2/signature.h
index e26a6c88f..cbf94269f 100644
--- a/include/git2/signature.h
+++ b/include/git2/signature.h
@@ -28,7 +28,7 @@ GIT_BEGIN_DECL
  * @param email email of the person
  * @param time time when the action happened
  * @param offset timezone offset in minutes for the time
- * @return GIT_SUCCESS or an error code
+ * @return 0 or an error code
  */
 GIT_EXTERN(int) git_signature_new(git_signature **sig_out, const char *name, const char *email, git_time_t time, int offset);
 
@@ -39,7 +39,7 @@ GIT_EXTERN(int) git_signature_new(git_signature **sig_out, const char *name, con
  * @param sig_out new signature, in case of error NULL
  * @param name name of the person
  * @param email email of the person
- * @return GIT_SUCCESS or an error code
+ * @return 0 or an error code
  */
 GIT_EXTERN(int) git_signature_now(git_signature **sig_out, const char *name, const char *email);
 
diff --git a/include/git2/status.h b/include/git2/status.h
index caa350325..080db9f3c 100644
--- a/include/git2/status.h
+++ b/include/git2/status.h
@@ -131,9 +131,9 @@ GIT_EXTERN(int) git_status_foreach_ext(
  * @param status_flags the status value
  * @param repo a repository object
  * @param path the file to retrieve status for, rooted at the repo's workdir
- * @return GIT_EINVALIDPATH when `path` points at a folder, GIT_ENOTFOUND when
+ * @return GIT_EINVALIDPATH when `path` points at a folder, GIT_NOTFOUND when
  *		the file doesn't exist in any of HEAD, the index or the worktree,
- *		GIT_SUCCESS otherwise
+ *		0 otherwise
  */
 GIT_EXTERN(int) git_status_file(
 	unsigned int *status_flags,
diff --git a/include/git2/submodule.h b/include/git2/submodule.h
index 930168275..9e6118b98 100644
--- a/include/git2/submodule.h
+++ b/include/git2/submodule.h
@@ -85,13 +85,13 @@ GIT_EXTERN(int) git_submodule_foreach(
  *
  * Given either the submodule name or path (they are ususally the same),
  * this returns a structure describing the submodule.  If the submodule
- * does not exist, this will return GIT_ENOTFOUND and set the submodule
+ * does not exist, this will return GIT_NOTFOUND and set the submodule
  * pointer to NULL.
  *
  * @param submodule Pointer to submodule description object pointer..
  * @param repo The repository.
  * @param name The name of the submodule.  Trailing slashes will be ignored.
- * @return 0 on success, GIT_ENOTFOUND if submodule does not exist, -1 on error
+ * @return 0 on success, GIT_NOTFOUND if submodule does not exist, -1 on error
  */
 GIT_EXTERN(int) git_submodule_lookup(
 	git_submodule **submodule,
diff --git a/include/git2/tag.h b/include/git2/tag.h
index 8224edfea..7f318adf9 100644
--- a/include/git2/tag.h
+++ b/include/git2/tag.h
@@ -27,7 +27,7 @@ GIT_BEGIN_DECL
  * @param tag pointer to the looked up tag
  * @param repo the repo to use when locating the tag.
  * @param id identity of the tag to locate.
- * @return GIT_SUCCESS or an error code
+ * @return 0 or an error code
  */
 GIT_INLINE(int) git_tag_lookup(git_tag **tag, git_repository *repo, const git_oid *id)
 {
@@ -44,7 +44,7 @@ GIT_INLINE(int) git_tag_lookup(git_tag **tag, git_repository *repo, const git_oi
  * @param repo the repo to use when locating the tag.
  * @param id identity of the tag to locate.
  * @param len the length of the short identifier
- * @return GIT_SUCCESS or an error code
+ * @return 0 or an error code
  */
 GIT_INLINE(int) git_tag_lookup_prefix(git_tag **tag, git_repository *repo, const git_oid *id, unsigned int len)
 {
@@ -85,7 +85,7 @@ GIT_EXTERN(const git_oid *) git_tag_id(git_tag *tag);
  *
  * @param target pointer where to store the target
  * @param tag a previously loaded tag.
- * @return GIT_SUCCESS or an error code
+ * @return 0 or an error code
  */
 GIT_EXTERN(int) git_tag_target(git_object **target, git_tag *tag);
 
@@ -143,7 +143,7 @@ GIT_EXTERN(const char *) git_tag_message(git_tag *tag);
  * @param oid Pointer where to store the OID of the
  * newly created tag. If the tag already exists, this parameter
  * will be the oid of the existing tag, and the function will
- * return a GIT_EEXISTS error code.
+ * return a GIT_EXISTS error code.
  *
  * @param repo Repository where to store the tag
  *
@@ -161,7 +161,7 @@ GIT_EXTERN(const char *) git_tag_message(git_tag *tag);
  *
  * @param force Overwrite existing references
  *
- * @return GIT_SUCCESS or an error code
+ * @return 0 or an error code
  *	A tag object is written to the ODB, and a proper reference
  *	is written in the /refs/tags folder, pointing to it
  */
@@ -199,7 +199,7 @@ GIT_EXTERN(int) git_tag_create_frombuffer(
  * @param oid Pointer where to store the OID of the provided
  * target object. If the tag already exists, this parameter
  * will be filled with the oid of the existing pointed object
- * and the function will return a GIT_EEXISTS error code.
+ * and the function will return a GIT_EXISTS error code.
  *
  * @param repo Repository where to store the lightweight tag
  *
@@ -212,7 +212,7 @@ GIT_EXTERN(int) git_tag_create_frombuffer(
  *
  * @param force Overwrite existing references
  *
- * @return GIT_SUCCESS or an error code
+ * @return 0 or an error code
  *	A proper reference is written in the /refs/tags folder,
  * pointing to the provided target object
  */
@@ -231,7 +231,7 @@ GIT_EXTERN(int) git_tag_create_lightweight(
  * @param tag_name Name of the tag to be deleted;
  * this name is validated for consistency.
  *
- * @return GIT_SUCCESS or an error code
+ * @return 0 or an error code
  */
 GIT_EXTERN(int) git_tag_delete(
 		git_repository *repo,
@@ -248,7 +248,7 @@ GIT_EXTERN(int) git_tag_delete(
  * @param tag_names Pointer to a git_strarray structure where
  *		the tag names will be stored
  * @param repo Repository where to find the tags
- * @return GIT_SUCCESS or an error code
+ * @return 0 or an error code
  */
 GIT_EXTERN(int) git_tag_list(
 		git_strarray *tag_names,
@@ -270,7 +270,7 @@ GIT_EXTERN(int) git_tag_list(
  *		the tag names will be stored
  * @param pattern Standard fnmatch pattern
  * @param repo Repository where to find the tags
- * @return GIT_SUCCESS or an error code
+ * @return 0 or an error code
  */
 GIT_EXTERN(int) git_tag_list_match(
 		git_strarray *tag_names,
@@ -286,7 +286,7 @@ GIT_EXTERN(int) git_tag_list_match(
  *
  * @param tag_target Pointer to the peeled git_object
  * @param tag The tag to be processed
- * @return GIT_SUCCESS or an error code
+ * @return 0 or an error code
  */
 GIT_EXTERN(int) git_tag_peel(
 		git_object **tag_target,
diff --git a/include/git2/tree.h b/include/git2/tree.h
index 0d9db430a..3b3b0e2f8 100644
--- a/include/git2/tree.h
+++ b/include/git2/tree.h
@@ -27,7 +27,7 @@ GIT_BEGIN_DECL
  * @param tree pointer to the looked up tree
  * @param repo the repo to use when locating the tree.
  * @param id identity of the tree to locate.
- * @return GIT_SUCCESS or an error code
+ * @return 0 or an error code
  */
 GIT_INLINE(int) git_tree_lookup(git_tree **tree, git_repository *repo, const git_oid *id)
 {
@@ -44,7 +44,7 @@ GIT_INLINE(int) git_tree_lookup(git_tree **tree, git_repository *repo, const git
  * @param repo the repo to use when locating the tree.
  * @param id identity of the tree to locate.
  * @param len the length of the short identifier
- * @return GIT_SUCCESS or an error code
+ * @return 0 or an error code
  */
 GIT_INLINE(int) git_tree_lookup_prefix(git_tree **tree, git_repository *repo, const git_oid *id, unsigned int len)
 {
@@ -141,7 +141,7 @@ GIT_EXTERN(git_otype) git_tree_entry_type(const git_tree_entry *entry);
  * @param object pointer to the converted object
  * @param repo repository where to lookup the pointed object
  * @param entry a tree entry
- * @return GIT_SUCCESS or an error code
+ * @return 0 or an error code
  */
 GIT_EXTERN(int) git_tree_entry_to_object(git_object **object_out, git_repository *repo, const git_tree_entry *entry);
 
@@ -159,7 +159,7 @@ GIT_EXTERN(int) git_tree_entry_to_object(git_object **object_out, git_repository
  *
  * @param oid Pointer where to store the written tree
  * @param index Index to write
- * @return GIT_SUCCESS or an error code
+ * @return 0 or an error code
  */
 GIT_EXTERN(int) git_tree_create_fromindex(git_oid *oid, git_index *index);
 
@@ -229,7 +229,7 @@ GIT_EXTERN(const git_tree_entry *) git_treebuilder_get(git_treebuilder *bld, con
  * @param filename Filename of the entry
  * @param id SHA1 oid of the entry
  * @param attributes Folder attributes of the entry
- * @return GIT_SUCCESS or an error code
+ * @return 0 or an error code
  */
 GIT_EXTERN(int) git_treebuilder_insert(git_tree_entry **entry_out, git_treebuilder *bld, const char *filename, const git_oid *id, unsigned int attributes);
 
@@ -264,7 +264,7 @@ GIT_EXTERN(void) git_treebuilder_filter(git_treebuilder *bld, int (*filter)(cons
  * @param oid Pointer where to store the written OID
  * @param repo Repository where to store the object
  * @param bld Tree builder to write
- * @return GIT_SUCCESS or an error code
+ * @return 0 or an error code
  */
 GIT_EXTERN(int) git_treebuilder_write(git_oid *oid, git_repository *repo, git_treebuilder *bld);
 
@@ -278,8 +278,7 @@ GIT_EXTERN(int) git_treebuilder_write(git_oid *oid, git_repository *repo, git_tr
  * @param subtree Pointer where to store the subtree
  * @param root A previously loaded tree which will be the root of the relative path
  * @param subtree_path Path to the contained subtree
- * @return GIT_SUCCESS on success; GIT_ENOTFOUND if the path does not lead to a
- * subtree, GIT_EINVALIDPATH or an error code
+ * @return 0 on success; GIT_NOTFOUND if the path does not lead to a subtree
  */
 GIT_EXTERN(int) git_tree_get_subtree(git_tree **subtree, git_tree *root, const char *subtree_path);
 
@@ -309,7 +308,7 @@ enum git_treewalk_mode {
  * @param callback Function to call on each tree entry
  * @param mode Traversal mode (pre or post-order)
  * @param payload Opaque pointer to be passed on each callback
- * @return GIT_SUCCESS or an error code
+ * @return 0 or an error code
  */
 GIT_EXTERN(int) git_tree_walk(git_tree *tree, git_treewalk_cb callback, int mode, void *payload);
 
diff --git a/src/attr.c b/src/attr.c
index 093f64d5c..5fef91427 100644
--- a/src/attr.c
+++ b/src/attr.c
@@ -245,13 +245,13 @@ static int load_attr_file(
 	struct stat st;
 
 	if (p_stat(filename, &st) < 0)
-		return GIT_ENOTFOUND;
+		return GIT_NOTFOUND;
 
 	if (sig != NULL &&
 		(git_time_t)st.st_mtime == sig->seconds &&
 		(git_off_t)st.st_size == sig->size &&
 		(unsigned int)st.st_ino == sig->ino)
-		return GIT_ENOTFOUND;
+		return GIT_NOTFOUND;
 
 	error = git_futils_readbuffer_updated(&content, filename, NULL, NULL);
 	if (error < 0)
@@ -286,7 +286,7 @@ static int load_attr_blob_from_index(
 	entry = git_index_get(index, error);
 
 	if (old_oid && git_oid_cmp(old_oid, &entry->oid) == 0)
-		return GIT_ENOTFOUND;
+		return GIT_NOTFOUND;
 
 	if ((error = git_blob_lookup(blob, repo, &entry->oid)) < 0)
 		return error;
@@ -396,7 +396,7 @@ int git_attr_cache__push_file(
 
 	if (error) {
 		/* not finding a file is not an error for this function */
-		if (error == GIT_ENOTFOUND) {
+		if (error == GIT_NOTFOUND) {
 			giterr_clear();
 			error = 0;
 		}
@@ -550,7 +550,7 @@ static int collect_attr_files(
 		error = git_futils_find_system_file(&dir, GIT_ATTR_FILE_SYSTEM);
 		if (!error)
 			error = push_attr_file(repo, files, NULL, dir.ptr);
-		else if (error == GIT_ENOTFOUND)
+		else if (error == GIT_NOTFOUND)
 			error = 0;
 	}
 
@@ -577,11 +577,11 @@ int git_attr_cache__init(git_repository *repo)
 		return -1;
 
 	ret = git_config_get_string(&cache->cfg_attr_file, cfg, GIT_ATTR_CONFIG);
-	if (ret < 0 && ret != GIT_ENOTFOUND)
+	if (ret < 0 && ret != GIT_NOTFOUND)
 		return ret;
 
 	ret = git_config_get_string(&cache->cfg_excl_file, cfg, GIT_IGNORE_CONFIG);
-	if (ret < 0 && ret != GIT_ENOTFOUND)
+	if (ret < 0 && ret != GIT_NOTFOUND)
 		return ret;
 
 	giterr_clear();
diff --git a/src/attr_file.c b/src/attr_file.c
index 5030ad5de..601b286cf 100644
--- a/src/attr_file.c
+++ b/src/attr_file.c
@@ -99,7 +99,7 @@ int git_attr_file__parse_buffer(
 		/* if the rule wasn't a pattern, on to the next */
 		if (error < 0) {
 			git_attr_rule__clear(rule); /* reset rule contents */
-			if (error == GIT_ENOTFOUND)
+			if (error == GIT_NOTFOUND)
 				error = 0;
 		} else {
 			rule = NULL; /* vector now "owns" the rule */
@@ -328,7 +328,7 @@ void git_attr_path__free(git_attr_path *info)
 
 /*
  * This will return 0 if the spec was filled out,
- * GIT_ENOTFOUND if the fnmatch does not require matching, or
+ * GIT_NOTFOUND if the fnmatch does not require matching, or
  * another error code there was an actual problem.
  */
 int git_attr_fnmatch__parse(
@@ -347,7 +347,7 @@ int git_attr_fnmatch__parse(
 	while (git__isspace(*pattern)) pattern++;
 	if (!*pattern || *pattern == '#') {
 		*base = git__next_line(pattern);
-		return GIT_ENOTFOUND;
+		return GIT_NOTFOUND;
 	}
 
 	spec->flags = 0;
@@ -464,7 +464,7 @@ static int merge_assignments(void **old_raw, void *new_raw)
 
 	GIT_REFCOUNT_DEC(*old, git_attr_assignment__free);
 	*old = new;
-	return GIT_EEXISTS;
+	return GIT_EXISTS;
 }
 
 int git_attr_assignment__parse(
@@ -551,7 +551,7 @@ int git_attr_assignment__parse(
 
 					error = git_vector_insert_sorted(
 						assigns, massign, &merge_assignments);
-					if (error < 0 && error != GIT_EEXISTS)
+					if (error < 0 && error != GIT_EXISTS)
 						return error;
 				}
 			}
@@ -559,7 +559,7 @@ int git_attr_assignment__parse(
 
 		/* insert allocated assign into vector */
 		error = git_vector_insert_sorted(assigns, assign, &merge_assignments);
-		if (error < 0 && error != GIT_EEXISTS)
+		if (error < 0 && error != GIT_EXISTS)
 			return error;
 
 		/* clear assign since it is now "owned" by the vector */
@@ -571,7 +571,7 @@ int git_attr_assignment__parse(
 
 	*base = git__next_line(scan);
 
-	return (assigns->length == 0) ? GIT_ENOTFOUND : 0;
+	return (assigns->length == 0) ? GIT_NOTFOUND : 0;
 }
 
 static void git_attr_rule__clear(git_attr_rule *rule)
diff --git a/src/branch.c b/src/branch.c
index 9698bbf56..45f67ffdc 100644
--- a/src/branch.c
+++ b/src/branch.c
@@ -190,7 +190,7 @@ int git_branch_move(git_repository *repo, const char *old_branch_name, const cha
 	if ((error = git_buf_joinpath(&old_reference_name, GIT_REFS_HEADS_DIR, old_branch_name)) < 0)
 		goto cleanup;
 
-	/* We need to be able to return GIT_ENOTFOUND */
+	/* We need to be able to return GIT_NOTFOUND */
 	if ((error = git_reference_lookup(&reference, repo, git_buf_cstr(&old_reference_name))) < 0)
 		goto cleanup;
 
diff --git a/src/commit.c b/src/commit.c
index 2bf12f3a5..1c6bee97a 100644
--- a/src/commit.c
+++ b/src/commit.c
@@ -100,7 +100,7 @@ static int update_reference(git_repository *repo, git_oid *oid, const char *ref_
 
 	/* If we haven't found the reference at all, we assume we need to create
 	 * a new reference and that's it */
-	if (res == GIT_ENOTFOUND) {
+	if (res == GIT_NOTFOUND) {
 		giterr_clear();
 		return git_reference_create_oid(NULL, repo, ref_name, oid, 1);
 	}
@@ -125,7 +125,7 @@ static int update_reference(git_repository *repo, git_oid *oid, const char *ref_
 		 * this is means we're creating a new branch, for example.
 		 * We need to create a new direct reference with that name
 		 */
-		if (res == GIT_ENOTFOUND) {
+		if (res == GIT_NOTFOUND) {
 			giterr_clear();
 			res = git_reference_create_oid(NULL, repo, sym_target, oid, 1);
 			git_reference_free(ref);
@@ -320,7 +320,7 @@ int git_commit_parent(git_commit **parent, git_commit *commit, unsigned int n)
 	parent_oid = git_vector_get(&commit->parent_oids, n);
 	if (parent_oid == NULL) {
 		giterr_set(GITERR_INVALID, "Parent %u does not exist", n);
-		return GIT_ENOTFOUND;
+		return GIT_NOTFOUND;
 	}
 
 	return git_commit_lookup(parent, commit->object.repo, parent_oid);
diff --git a/src/config.c b/src/config.c
index 618202c34..b60faf820 100644
--- a/src/config.c
+++ b/src/config.c
@@ -263,7 +263,7 @@ int git_config_lookup_map_value(
 	size_t i;
 
 	if (!value)
-		return GIT_ENOTFOUND;
+		return GIT_NOTFOUND;
 
 	for (i = 0; i < map_n; ++i) {
 		git_cvar_map *m = maps + i;
@@ -295,7 +295,7 @@ int git_config_lookup_map_value(
 		}
 	}
 
-	return GIT_ENOTFOUND;
+	return GIT_NOTFOUND;
 }
 
 int git_config_get_mapped(
@@ -387,12 +387,12 @@ int git_config_get_string(const char **out, git_config *cfg, const char *name)
 	git_vector_foreach(&cfg->files, i, internal) {
 		git_config_file *file = internal->file;
 		int ret = file->get(file, name, out);
-		if (ret != GIT_ENOTFOUND)
+		if (ret != GIT_NOTFOUND)
 			return ret;
 	}
 
 	giterr_set(GITERR_CONFIG, "Config variable '%s' not found", name);
-	return GIT_ENOTFOUND;
+	return GIT_NOTFOUND;
 }
 
 int git_config_get_multivar(git_config *cfg, const char *name, const char *regexp,
@@ -400,7 +400,7 @@ int git_config_get_multivar(git_config *cfg, const char *name, const char *regex
 {
 	file_internal *internal;
 	git_config_file *file;
-	int ret = GIT_ENOTFOUND;
+	int ret = GIT_NOTFOUND;
 	unsigned int i;
 
 	assert(cfg->files.length);
@@ -413,7 +413,7 @@ int git_config_get_multivar(git_config *cfg, const char *name, const char *regex
 		internal = git_vector_get(&cfg->files, i - 1);
 		file = internal->file;
 		ret = file->get_multivar(file, name, regexp, fn, data);
-		if (ret < 0 && ret != GIT_ENOTFOUND)
+		if (ret < 0 && ret != GIT_NOTFOUND)
 			return ret;
 	}
 
@@ -424,14 +424,14 @@ int git_config_set_multivar(git_config *cfg, const char *name, const char *regex
 {
 	file_internal *internal;
 	git_config_file *file;
-	int ret = GIT_ENOTFOUND;
+	int ret = GIT_NOTFOUND;
 	unsigned int i;
 
 	for (i = cfg->files.length; i > 0; --i) {
 		internal = git_vector_get(&cfg->files, i - 1);
 		file = internal->file;
 		ret = file->set_multivar(file, name, regexp, value);
-		if (ret < 0 && ret != GIT_ENOTFOUND)
+		if (ret < 0 && ret != GIT_NOTFOUND)
 			return ret;
 	}
 
diff --git a/src/config_cache.c b/src/config_cache.c
index 057f21439..b23fd7b31 100644
--- a/src/config_cache.c
+++ b/src/config_cache.c
@@ -66,22 +66,22 @@ int git_repository__cvar(int *out, git_repository *repo, git_cvar_cached cvar)
 		int error;
 
 		error = git_repository_config__weakptr(&config, repo);
-		if (error < GIT_SUCCESS)
+		if (error < 0)
 			return error;
 
 		error = git_config_get_mapped(out,
 			config, data->cvar_name, data->maps, data->map_count);
 
-		if (error == GIT_ENOTFOUND)
+		if (error == GIT_NOTFOUND)
 			*out = data->default_value;
 
-		else if (error < GIT_SUCCESS)
+		else if (error < 0)
 			return error;
 
 		repo->cvar_cache[(int)cvar] = *out;
 	}
 
-	return GIT_SUCCESS;
+	return 0;
 }
 
 void git_repository__cvar_cache_clear(git_repository *repo)
diff --git a/src/config_file.c b/src/config_file.c
index cbc48bcd9..6ecc974ff 100644
--- a/src/config_file.c
+++ b/src/config_file.c
@@ -161,7 +161,7 @@ static int config_open(git_config_file *cfg)
 	res = git_futils_readbuffer(&b->reader.buffer, b->file_path);
 
 	/* It's fine if the file doesn't exist */
-	if (res == GIT_ENOTFOUND)
+	if (res == GIT_NOTFOUND)
 		return 0;
 
 	if (res < 0 || config_parse(b) <  0) {
@@ -289,7 +289,7 @@ static int config_get(git_config_file *cfg, const char *name, const char **out)
 
 	/* no error message; the config system will write one */
 	if (!git_strmap_valid_index(b->values, pos))
-		return GIT_ENOTFOUND;
+		return GIT_NOTFOUND;
 
 	*out = ((cvar_t *)git_strmap_value_at(b->values, pos))->value;
 
@@ -315,7 +315,7 @@ static int config_get_multivar(
 	git__free(key);
 
 	if (!git_strmap_valid_index(b->values, pos))
-		return GIT_ENOTFOUND;
+		return GIT_NOTFOUND;
 
 	var = git_strmap_value_at(b->values, pos);
 
@@ -377,7 +377,7 @@ static int config_set_multivar(
 	pos = git_strmap_lookup_index(b->values, key);
 	if (!git_strmap_valid_index(b->values, pos)) {
 		git__free(key);
-		return GIT_ENOTFOUND;
+		return GIT_NOTFOUND;
 	}
 
 	var = git_strmap_value_at(b->values, pos);
@@ -444,7 +444,7 @@ static int config_delete(git_config_file *cfg, const char *name)
 	git__free(key);
 
 	if (!git_strmap_valid_index(b->values, pos))
-		return GIT_ENOTFOUND;
+		return GIT_NOTFOUND;
 
 	var = git_strmap_value_at(b->values, pos);
 
@@ -978,7 +978,7 @@ static int config_write(diskfile_backend *cfg, const char *key, const regex_t *p
 	result = git_futils_readbuffer(&cfg->reader.buffer, cfg->file_path);
 
 	/* Initialise the reading position */
-	if (result == GIT_ENOTFOUND) {
+	if (result == GIT_NOTFOUND) {
 		cfg->reader.read_ptr = NULL;
 		cfg->reader.eof = 1;
 		data_start = NULL;
diff --git a/src/crlf.c b/src/crlf.c
index 0ee1eef35..5fb1be516 100644
--- a/src/crlf.c
+++ b/src/crlf.c
@@ -85,13 +85,13 @@ static int crlf_load_attributes(struct crlf_attrs *ca, git_repository *repo, con
 	error = git_attr_get_many(attr_vals,
 		repo, 0, path, NUM_CONV_ATTRS, attr_names);
 
-	if (error == GIT_ENOTFOUND) {
+	if (error == GIT_NOTFOUND) {
 		ca->crlf_action = GIT_CRLF_GUESS;
 		ca->eol = GIT_EOL_UNSET;
 		return 0;
 	}
 
-	if (error == GIT_SUCCESS) {
+	if (error == 0) {
 		ca->crlf_action = check_crlf(attr_vals[2]); /* text */
 		if (ca->crlf_action == GIT_CRLF_GUESS)
 			ca->crlf_action = check_crlf(attr_vals[0]); /* clrf */
@@ -207,7 +207,7 @@ int git_filter_add__crlf_to_odb(git_vector *filters, git_repository *repo, const
 		int auto_crlf;
 
 		if ((error = git_repository__cvar(
-			&auto_crlf, repo, GIT_CVAR_AUTO_CRLF)) < GIT_SUCCESS)
+			&auto_crlf, repo, GIT_CVAR_AUTO_CRLF)) < 0)
 			return error;
 
 		if (auto_crlf == GIT_AUTO_CRLF_FALSE)
diff --git a/src/delta-apply.c b/src/delta-apply.c
index d3be084e0..815ca8f16 100644
--- a/src/delta-apply.c
+++ b/src/delta-apply.c
@@ -111,7 +111,7 @@ int git__delta_apply(
 
 	if (delta != delta_end || res_sz)
 		goto fail;
-	return GIT_SUCCESS;
+	return 0;
 
 fail:
 	git__free(out->data);
diff --git a/src/delta-apply.h b/src/delta-apply.h
index e46ef9af4..66fa76d43 100644
--- a/src/delta-apply.h
+++ b/src/delta-apply.h
@@ -20,7 +20,7 @@
  * @param delta the delta to execute copy/insert instructions from.
  * @param delta_len total number of bytes in the delta.
  * @return
- * - GIT_SUCCESS on a successful delta unpack.
+ * - 0 on a successful delta unpack.
  * - GIT_ERROR if the delta is corrupt or doesn't match the base.
  */
 extern int git__delta_apply(
diff --git a/src/diff.c b/src/diff.c
index 0b2f8fb50..882534f72 100644
--- a/src/diff.c
+++ b/src/diff.c
@@ -343,7 +343,7 @@ static git_diff_list *git_diff_list_alloc(
 		if (!match)
 			goto fail;
 		ret = git_attr_fnmatch__parse(match, &diff->pool, NULL, &pattern);
-		if (ret == GIT_ENOTFOUND) {
+		if (ret == GIT_NOTFOUND) {
 			git__free(match);
 			continue;
 		} else if (ret < 0)
diff --git a/src/fileops.c b/src/fileops.c
index ee9d4212d..c467143e4 100644
--- a/src/fileops.c
+++ b/src/fileops.c
@@ -95,7 +95,7 @@ int git_futils_open_ro(const char *path)
 	int fd = p_open(path, O_RDONLY);
 	if (fd < 0) {
 		if (errno == ENOENT)
-			fd = GIT_ENOTFOUND;
+			fd = GIT_NOTFOUND;
 		giterr_set(GITERR_OS, "Failed to open '%s'", path);
 	}
 	return fd;
@@ -365,7 +365,7 @@ int git_futils_find_global_file(git_buf *path, const char *filename)
 
 	if (git_path_exists(path->ptr) == false) {
 		git_buf_clear(path);
-		return GIT_ENOTFOUND;
+		return GIT_NOTFOUND;
 	}
 
 	return 0;
@@ -414,7 +414,7 @@ static int win32_find_system_file(git_buf *path, const char *filename)
 	char *file_utf8 = NULL;
 
 	if (!root || !filename || (len = strlen(filename)) == 0)
-		return GIT_ENOTFOUND;
+		return GIT_NOTFOUND;
 
 	/* allocate space for wchar_t path to file */
 	file_utf16 = git__calloc(root->len + len + 2, sizeof(wchar_t));
@@ -438,7 +438,7 @@ static int win32_find_system_file(git_buf *path, const char *filename)
 
 	/* check access */
 	if (_waccess(file_utf16, F_OK) < 0) {
-		error = GIT_ENOTFOUND;
+		error = GIT_NOTFOUND;
 		goto cleanup;
 	}
 
@@ -470,6 +470,6 @@ int git_futils_find_system_file(git_buf *path, const char *filename)
 #ifdef GIT_WIN32
 	return win32_find_system_file(path, filename);
 #else
-	return GIT_ENOTFOUND;
+	return GIT_NOTFOUND;
 #endif
 }
diff --git a/src/fileops.h b/src/fileops.h
index be619d620..8dd4bb61a 100644
--- a/src/fileops.h
+++ b/src/fileops.h
@@ -139,7 +139,7 @@ extern int git_futils_mmap_ro(
  * @param path path to file to be opened.
  * @return
  * - 0 on success;
- * - GIT_ENOTFOUND if not found;
+ * - GIT_NOTFOUND if not found;
  * - -1 on an unspecified OS related error.
  */
 extern int git_futils_mmap_ro_file(
@@ -159,7 +159,7 @@ extern void git_futils_mmap_free(git_map *map);
  * @param filename name of file to find in the home directory
  * @return
  * - 0 if found;
- * - GIT_ENOTFOUND if not found;
+ * - GIT_NOTFOUND if not found;
  * - -1 on an unspecified OS related error.
  */
 extern int git_futils_find_global_file(git_buf *path, const char *filename);
@@ -171,7 +171,7 @@ extern int git_futils_find_global_file(git_buf *path, const char *filename);
  * @param filename name of file to find in the home directory
  * @return
  * - 0 if found;
- * - GIT_ENOTFOUND if not found;
+ * - GIT_NOTFOUND if not found;
  * - -1 on an unspecified OS related error.
  */
 extern int git_futils_find_system_file(git_buf *path, const char *filename);
diff --git a/src/filter.c b/src/filter.c
index 73fe83e61..8fa3eb684 100644
--- a/src/filter.c
+++ b/src/filter.c
@@ -129,7 +129,7 @@ int git_filters_apply(git_buf *dest, git_buf *source, git_vector *filters)
 
 	if (git_buf_len(source) == 0) {
 		git_buf_clear(dest);
-		return GIT_SUCCESS;
+		return 0;
 	}
 
 	/* Pre-grow the destination buffer to more or less the size
@@ -160,6 +160,6 @@ int git_filters_apply(git_buf *dest, git_buf *source, git_vector *filters)
 	if (src != 1)
 		git_buf_swap(dest, source);
 
-	return GIT_SUCCESS;
+	return 0;
 }
 
diff --git a/src/filter.h b/src/filter.h
index 5a77f25c6..66e370aef 100644
--- a/src/filter.h
+++ b/src/filter.h
@@ -75,7 +75,7 @@ extern int git_filters_load(git_vector *filters, git_repository *repo, const cha
  * @param dest Buffer to store the result of the filtering
  * @param source Buffer containing the document to filter
  * @param filters A non-empty vector of filters as supplied by `git_filters_load`
- * @return GIT_SUCCESS on success, an error code otherwise
+ * @return 0 on success, an error code otherwise
  */
 extern int git_filters_apply(git_buf *dest, git_buf *source, git_vector *filters);
 
diff --git a/src/ignore.c b/src/ignore.c
index fc6194bb5..2a7060501 100644
--- a/src/ignore.c
+++ b/src/ignore.c
@@ -40,7 +40,7 @@ static int parse_ignore_file(
 			git__free(match->pattern);
 			match->pattern = NULL;
 
-			if (error == GIT_ENOTFOUND)
+			if (error == GIT_NOTFOUND)
 				error = 0;
 		} else {
 			match = NULL; /* vector now "owns" the match */
diff --git a/src/index.c b/src/index.c
index f1ae9a710..03b191356 100644
--- a/src/index.c
+++ b/src/index.c
@@ -411,7 +411,7 @@ static int index_insert(git_index *index, git_index_entry *entry, int replace)
 	 * if no entry exists add the entry at the end;
 	 * the index is no longer sorted
 	 */
-	if (position == GIT_ENOTFOUND)
+	if (position == GIT_NOTFOUND)
 		return git_vector_insert(&index->entries, entry);
 
 	/* exists, replace it */
diff --git a/src/indexer.c b/src/indexer.c
index 01bec0877..da6d5d2c8 100644
--- a/src/indexer.c
+++ b/src/indexer.c
@@ -205,9 +205,9 @@ static int store_delta(git_indexer_stream *idx)
 	}
 
 	error = packfile_unpack_compressed(&obj, idx->pack, &w, &idx->off, entry_size, type);
-	if (error == GIT_ESHORTBUFFER) {
+	if (error == GIT_SHORTBUFFER) {
 		idx->off = entry_start;
-		return GIT_ESHORTBUFFER;
+		return GIT_SHORTBUFFER;
 	} else if (error < 0){
 		return -1;
 	}
@@ -355,7 +355,7 @@ int git_indexer_stream_add(git_indexer_stream *idx, const void *data, size_t siz
 			return 0;
 
 		error = git_packfile_unpack(&obj, idx->pack, &idx->off);
-		if (error == GIT_ESHORTBUFFER) {
+		if (error == GIT_SHORTBUFFER) {
 			idx->off = entry_start;
 			return 0;
 		}
@@ -363,7 +363,7 @@ int git_indexer_stream_add(git_indexer_stream *idx, const void *data, size_t siz
 		if (error < 0) {
 			idx->off = entry_start;
 			error = store_delta(idx);
-			if (error == GIT_ESHORTBUFFER)
+			if (error == GIT_SHORTBUFFER)
 				return 0;
 			if (error < 0)
 				return error;
diff --git a/src/iterator.c b/src/iterator.c
index 819b0e22a..cb9838dbc 100644
--- a/src/iterator.c
+++ b/src/iterator.c
@@ -468,7 +468,7 @@ static int workdir_iterator__expand_dir(workdir_iterator *wi)
 	error = git_path_dirload_with_stat(wi->path.ptr, wi->root_len, &wf->entries);
 	if (error < 0 || wf->entries.length == 0) {
 		workdir_iterator__free_frame(wf);
-		return GIT_ENOTFOUND;
+		return GIT_NOTFOUND;
 	}
 
 	git_vector_sort(&wf->entries);
@@ -635,7 +635,7 @@ static int workdir_iterator__update_entry(workdir_iterator *wi)
 		if (!is_submodule) {
 			int res = git_submodule_lookup(NULL, wi->repo, wi->entry.path);
 			is_submodule = (res == 0);
-			if (res == GIT_ENOTFOUND)
+			if (res == GIT_NOTFOUND)
 				giterr_clear();
 		}
 
@@ -683,7 +683,7 @@ int git_iterator_for_workdir_range(
 	wi->root_len = wi->path.size;
 
 	if ((error = workdir_iterator__expand_dir(wi)) < 0) {
-		if (error == GIT_ENOTFOUND)
+		if (error == GIT_NOTFOUND)
 			error = 0;
 		else {
 			git_iterator_free((git_iterator *)wi);
diff --git a/src/notes.c b/src/notes.c
index 84ad94087..afd6fc23d 100644
--- a/src/notes.c
+++ b/src/notes.c
@@ -73,7 +73,7 @@ static int find_blob(git_oid *blob, git_tree *tree, const char *target)
 			return 0;
 		}
 	}
-	return GIT_ENOTFOUND;
+	return GIT_NOTFOUND;
 }
 
 static int note_write(git_oid *out, git_repository *repo,
@@ -96,11 +96,11 @@ static int note_write(git_oid *out, git_repository *repo,
 			return error;
 
 		error = find_blob(&oid, tree, target + fanout);
-		if (error != GIT_ENOTFOUND) {
+		if (error != GIT_NOTFOUND) {
 			git_tree_free(tree);
 			if (!error) {
 				giterr_set(GITERR_REPOSITORY, "Note for '%s' exists already", target);
-				error = GIT_EEXISTS;
+				error = GIT_EXISTS;
 			}
 			return error;
 		}
@@ -275,7 +275,7 @@ static int note_get_default_ref(const char **out, git_repository *repo)
 		return -1;
 
 	ret = git_config_get_string(out, cfg, "core.notesRef");
-	if (ret == GIT_ENOTFOUND) {
+	if (ret == GIT_NOTFOUND) {
 		*out = GIT_NOTES_DEFAULT_REF;
 		return 0;
 	}
@@ -352,7 +352,7 @@ int git_note_create(
 		return -1;
 
 	error = git_reference_lookup(&ref, repo, notes_ref);
-	if (error < 0 && error != GIT_ENOTFOUND)
+	if (error < 0 && error != GIT_NOTFOUND)
 		return error;
 
 	if (!error) {
diff --git a/src/object.c b/src/object.c
index deeacb27c..0c40c05c2 100644
--- a/src/object.c
+++ b/src/object.c
@@ -74,7 +74,7 @@ static int create_object(git_object **object_out, git_otype type)
 	object->type = type;
 
 	*object_out = object;
-	return GIT_SUCCESS;
+	return 0;
 }
 
 int git_object_lookup_prefix(
@@ -87,15 +87,15 @@ int git_object_lookup_prefix(
 	git_object *object = NULL;
 	git_odb *odb = NULL;
 	git_odb_object *odb_obj;
-	int error = GIT_SUCCESS;
+	int error = 0;
 
 	assert(repo && object_out && id);
 
 	if (len < GIT_OID_MINPREFIXLEN)
-		return GIT_EAMBIGUOUS;
+		return GIT_AMBIGUOUS;
 
 	error = git_repository_odb__weakptr(&odb, repo);
-	if (error < GIT_SUCCESS)
+	if (error < 0)
 		return error;
 
 	if (len > GIT_OID_HEXSZ)
@@ -110,7 +110,7 @@ int git_object_lookup_prefix(
 			if (type != GIT_OBJ_ANY && type != object->type) {
 				git_object_free(object);
 				giterr_set(GITERR_ODB, "The given type does not match the type in ODB");
-				return GIT_ENOTFOUND;
+				return GIT_NOTFOUND;
 			}
 
 			*object_out = object;
@@ -151,7 +151,7 @@ int git_object_lookup_prefix(
 	if (type != GIT_OBJ_ANY && type != odb_obj->raw.type) {
 		git_odb_object_free(odb_obj);
 		giterr_set(GITERR_ODB, "The given type does not match the type on the ODB");
-		return GIT_ENOTFOUND;
+		return GIT_NOTFOUND;
 	}
 
 	type = odb_obj->raw.type;
diff --git a/src/odb.c b/src/odb.c
index 03cd912e9..dcb36e296 100644
--- a/src/odb.c
+++ b/src/odb.c
@@ -485,7 +485,7 @@ int git_odb_exists(git_odb *db, const git_oid *id)
 int git_odb_read_header(size_t *len_p, git_otype *type_p, git_odb *db, const git_oid *id)
 {
 	unsigned int i;
-	int error = GIT_ENOTFOUND;
+	int error = GIT_NOTFOUND;
 	git_odb_object *object;
 
 	assert(db && id);
@@ -505,7 +505,7 @@ int git_odb_read_header(size_t *len_p, git_otype *type_p, git_odb *db, const git
 			error = b->read_header(len_p, type_p, b, id);
 	}
 
-	if (!error || error == GIT_EPASSTHROUGH)
+	if (!error || error == GIT_PASSTHROUGH)
 		return 0;
 
 	/*
@@ -524,7 +524,7 @@ int git_odb_read_header(size_t *len_p, git_otype *type_p, git_odb *db, const git
 int git_odb_read(git_odb_object **out, git_odb *db, const git_oid *id)
 {
 	unsigned int i;
-	int error = GIT_ENOTFOUND;
+	int error = GIT_NOTFOUND;
 	git_rawobj raw;
 
 	assert(out && db && id);
@@ -541,11 +541,11 @@ int git_odb_read(git_odb_object **out, git_odb *db, const git_oid *id)
 			error = b->read(&raw.data, &raw.len, &raw.type, b, id);
 	}
 
-	/* TODO: If no backends are configured, this returns GIT_ENOTFOUND but
+	/* TODO: If no backends are configured, this returns GIT_NOTFOUND but
 	 * will never have called giterr_set().
 	 */
 
-	if (error && error != GIT_EPASSTHROUGH)
+	if (error && error != GIT_PASSTHROUGH)
 		return error;
 
 	*out = git_cache_try_store(&db->cache, new_odb_object(id, &raw));
@@ -556,7 +556,7 @@ int git_odb_read_prefix(
 	git_odb_object **out, git_odb *db, const git_oid *short_id, unsigned int len)
 {
 	unsigned int i;
-	int error = GIT_ENOTFOUND;
+	int error = GIT_NOTFOUND;
 	git_oid found_full_oid = {{0}};
 	git_rawobj raw;
 	bool found = false;
@@ -582,7 +582,7 @@ int git_odb_read_prefix(
 		if (b->read != NULL) {
 			git_oid full_oid;
 			error = b->read_prefix(&full_oid, &raw.data, &raw.len, &raw.type, b, short_id, len);
-			if (error == GIT_ENOTFOUND || error == GIT_EPASSTHROUGH)
+			if (error == GIT_NOTFOUND || error == GIT_PASSTHROUGH)
 				continue;
 
 			if (error)
@@ -623,7 +623,7 @@ int git_odb_write(
 			error = b->write(oid, b, data, len, type);
 	}
 
-	if (!error || error == GIT_EPASSTHROUGH)
+	if (!error || error == GIT_PASSTHROUGH)
 		return 0;
 
 	/* if no backends were able to write the object directly, we try a streaming
@@ -662,7 +662,7 @@ int git_odb_open_wstream(
 			error = init_fake_wstream(stream, b, size, type);
 	}
 
-	if (error == GIT_EPASSTHROUGH)
+	if (error == GIT_PASSTHROUGH)
 		error = 0;
 
 	return error;
@@ -683,7 +683,7 @@ int git_odb_open_rstream(git_odb_stream **stream, git_odb *db, const git_oid *oi
 			error = b->readstream(stream, b, oid);
 	}
 
-	if (error == GIT_EPASSTHROUGH)
+	if (error == GIT_PASSTHROUGH)
 		error = 0;
 
 	return error;
@@ -698,12 +698,12 @@ int git_odb__error_notfound(const char *message, const git_oid *oid)
 	} else
 		giterr_set(GITERR_ODB, "Object not found - %s", message);
 
-	return GIT_ENOTFOUND;
+	return GIT_NOTFOUND;
 }
 
 int git_odb__error_ambiguous(const char *message)
 {
 	giterr_set(GITERR_ODB, "Ambiguous SHA1 prefix - %s", message);
-	return GIT_EAMBIGUOUS;
+	return GIT_AMBIGUOUS;
 }
 
diff --git a/src/odb.h b/src/odb.h
index 263e4c30b..2a5c76949 100644
--- a/src/odb.h
+++ b/src/odb.h
@@ -68,12 +68,12 @@ int git_odb__hashfd(git_oid *out, git_file fd, size_t size, git_otype type);
 int git_odb__hashlink(git_oid *out, const char *path);
 
 /*
- * Generate a GIT_ENOTFOUND error for the ODB.
+ * Generate a GIT_NOTFOUND error for the ODB.
  */
 int git_odb__error_notfound(const char *message, const git_oid *oid);
 
 /*
- * Generate a GIT_EAMBIGUOUS error for the ODB.
+ * Generate a GIT_AMBIGUOUS error for the ODB.
  */
 int git_odb__error_ambiguous(const char *message);
 
diff --git a/src/odb_loose.c b/src/odb_loose.c
index 989b03ab2..c229b544e 100644
--- a/src/odb_loose.c
+++ b/src/odb_loose.c
@@ -460,7 +460,7 @@ static int locate_object(
 	int error = object_file_name(object_location, backend->objects_dir, oid);
 
 	if (!error && !git_path_exists(object_location->ptr))
-		return GIT_ENOTFOUND;
+		return GIT_NOTFOUND;
 
 	return error;
 }
diff --git a/src/odb_pack.c b/src/odb_pack.c
index 458f288d9..e03879ee2 100644
--- a/src/odb_pack.c
+++ b/src/odb_pack.c
@@ -141,7 +141,7 @@ static int pack_entry_find(struct git_pack_entry *e,
 
 /* Can find the offset of an object given
  * a prefix of an identifier.
- * Sets GIT_EAMBIGUOUS if short oid is ambiguous.
+ * Sets GIT_AMBIGUOUS if short oid is ambiguous.
  * This method assumes that len is between
  * GIT_OID_MINPREFIXLEN and GIT_OID_HEXSZ.
  */
@@ -224,7 +224,7 @@ static int packfile_load__cb(void *_data, git_buf *path)
 	}
 
 	error = git_packfile_check(&pack, path->ptr);
-	if (error == GIT_ENOTFOUND)
+	if (error == GIT_NOTFOUND)
 		/* ignore missing .pack file as git does */
 		return 0;
 	else if (error < 0)
@@ -306,7 +306,7 @@ static int pack_entry_find_prefix(
 
 	if (backend->last_found) {
 		error = git_pack_entry_find(e, backend->last_found, short_oid, len);
-		if (error == GIT_EAMBIGUOUS)
+		if (error == GIT_AMBIGUOUS)
 			return error;
 		if (!error)
 			found = 1;
@@ -320,7 +320,7 @@ static int pack_entry_find_prefix(
 			continue;
 
 		error = git_pack_entry_find(e, p, short_oid, len);
-		if (error == GIT_EAMBIGUOUS)
+		if (error == GIT_AMBIGUOUS)
 			return error;
 		if (!error) {
 			if (++found > 1)
@@ -354,7 +354,7 @@ int pack_backend__read_header(git_rawobj *obj, git_odb_backend *backend, const g
 	assert(obj && backend && oid);
 
 	if (locate_packfile(&location, (struct pack_backend *)backend, oid) < 0)
-		return GIT_ENOTFOUND;
+		return GIT_NOTFOUND;
 
 	return read_header_packed(obj, &location);
 }
diff --git a/src/pack.c b/src/pack.c
index 4a6bc6ae8..66a23f295 100644
--- a/src/pack.c
+++ b/src/pack.c
@@ -28,7 +28,7 @@ int packfile_unpack_compressed(
 
 /* Can find the offset of an object given
  * a prefix of an identifier.
- * Throws GIT_EAMBIGUOUSOIDPREFIX if short oid
+ * Throws GIT_AMBIGUOUSOIDPREFIX if short oid
  * is ambiguous within the pack.
  * This method assumes that len is between
  * GIT_OID_MINPREFIXLEN and GIT_OID_HEXSZ.
@@ -222,7 +222,7 @@ static int packfile_unpack_header1(
 	shift = 4;
 	while (c & 0x80) {
 		if (len <= used)
-			return GIT_ESHORTBUFFER;
+			return GIT_SHORTBUFFER;
 
 		if (bitsizeof(long) <= shift) {
 			*usedp = 0;
@@ -260,11 +260,11 @@ int git_packfile_unpack_header(
 //	base = pack_window_open(p, w_curs, *curpos, &left);
 	base = git_mwindow_open(mwf, w_curs, *curpos, 20, &left);
 	if (base == NULL)
-		return GIT_ESHORTBUFFER;
+		return GIT_SHORTBUFFER;
 
 	ret = packfile_unpack_header1(&used, size_p, type_p, base, left);
 	git_mwindow_close(w_curs);
-	if (ret == GIT_ESHORTBUFFER)
+	if (ret == GIT_SHORTBUFFER)
 		return ret;
 	else if (ret < 0)
 		return packfile_error("header length is zero");
@@ -428,7 +428,7 @@ int packfile_unpack_compressed(
 		if (st == Z_BUF_ERROR && in == NULL) {
 			inflateEnd(&stream);
 			git__free(buffer);
-			return GIT_ESHORTBUFFER;
+			return GIT_SHORTBUFFER;
 		}
 
 		*curpos += stream.next_in - in;
@@ -467,7 +467,7 @@ git_off_t get_delta_base(
 	base_info = pack_window_open(p, w_curs, *curpos, &left);
 	/* Assumption: the only reason this would fail is because the file is too small */
 	if (base_info == NULL)
-		return GIT_ESHORTBUFFER;
+		return GIT_SHORTBUFFER;
 	/* pack_window_open() assured us we have [base_info, base_info + 20)
 	 * as a range that we can look at without walking off the
 	 * end of the mapped window. Its actually the hash size
@@ -480,7 +480,7 @@ git_off_t get_delta_base(
 		base_offset = c & 127;
 		while (c & 128) {
 			if (left <= used)
-				return GIT_ESHORTBUFFER;
+				return GIT_SHORTBUFFER;
 			base_offset += 1;
 			if (!base_offset || MSB(base_offset, 7))
 				return 0; /* overflow */
diff --git a/src/path.c b/src/path.c
index 84edf6d89..ba67544de 100644
--- a/src/path.c
+++ b/src/path.c
@@ -206,7 +206,7 @@ int git_path_prettify(git_buf *path_out, const char *path, const char *base)
 
 	if (p_realpath(path, buf) == NULL) {
 		/* giterr_set resets the errno when dealing with a GITERR_OS kind of error */
-		int error = (errno == ENOENT || errno == ENOTDIR) ? GIT_ENOTFOUND : -1;
+		int error = (errno == ENOENT || errno == ENOTDIR) ? GIT_NOTFOUND : -1;
 		giterr_set(GITERR_OS, "Failed to resolve path '%s'", path);
 
 		git_buf_clear(path_out);
@@ -390,7 +390,7 @@ int git_path_lstat(const char *path, struct stat *st)
 	int err = 0;
 
 	if (p_lstat(path, st) < 0) {
-		err = (errno == ENOENT) ? GIT_ENOTFOUND : -1;
+		err = (errno == ENOENT) ? GIT_NOTFOUND : -1;
 		giterr_set(GITERR_OS, "Failed to stat file '%s'", path);
 	}
 
diff --git a/src/pkt.c b/src/pkt.c
index b9c87f169..895644638 100644
--- a/src/pkt.c
+++ b/src/pkt.c
@@ -208,7 +208,7 @@ int git_pkt_parse_line(
 
 	/* Not even enough for the length */
 	if (bufflen > 0 && bufflen < PKT_LEN_SIZE)
-		return GIT_ESHORTBUFFER;
+		return GIT_SHORTBUFFER;
 
 	len = parse_len(line);
 	if (len < 0) {
@@ -230,7 +230,7 @@ int git_pkt_parse_line(
 	 * enough in the buffer to satisfy this line
 	 */
 	if (bufflen > 0 && bufflen < (size_t)len)
-		return GIT_ESHORTBUFFER;
+		return GIT_SHORTBUFFER;
 
 	line += PKT_LEN_SIZE;
 	/*
diff --git a/src/protocol.c b/src/protocol.c
index a75354121..184903388 100644
--- a/src/protocol.c
+++ b/src/protocol.c
@@ -34,7 +34,7 @@ int git_protocol_store_refs(git_protocol *p, const char *data, size_t len)
 			return 0;
 
 		error = git_pkt_parse_line(&pkt, ptr, &line_end, git_buf_len(buf));
-		if (error == GIT_ESHORTBUFFER)
+		if (error == GIT_SHORTBUFFER)
 			return 0; /* Ask for more */
 		if (error < 0)
 			return p->error = -1;
diff --git a/src/refs.c b/src/refs.c
index 1ef3e13a4..88e2218d1 100644
--- a/src/refs.c
+++ b/src/refs.c
@@ -437,7 +437,7 @@ static int packed_load(git_repository *repo)
 	 * for us here, so just return. Anything else means we need to
 	 * refresh the packed refs.
 	 */
-	if (result == GIT_ENOTFOUND) {
+	if (result == GIT_NOTFOUND) {
 		git_strmap_clear(ref_cache->packfile);
 		return 0;
 	}
@@ -917,7 +917,7 @@ static int reference_can_write(
 		if (exists) {
 			giterr_set(GITERR_REFERENCE,
 				"A reference with that name (%s) already exists", refname);
-			return GIT_EEXISTS;
+			return GIT_EXISTS;
 		}
 	}
 
@@ -962,7 +962,7 @@ static int packed_lookup(git_reference *ref)
 	pos = git_strmap_lookup_index(packfile_refs, ref->name);
 	if (!git_strmap_valid_index(packfile_refs, pos)) {
 		giterr_set(GITERR_REFERENCE, "Reference '%s' not found", ref->name);
-		return GIT_ENOTFOUND;
+		return GIT_NOTFOUND;
 	}
 
 	pack_ref = git_strmap_value_at(packfile_refs, pos);
@@ -984,7 +984,7 @@ static int reference_lookup(git_reference *ref)
 
 	/* only try to lookup this reference on the packfile if it
 	 * wasn't found on the loose refs; not if there was a critical error */
-	if (result == GIT_ENOTFOUND) {
+	if (result == GIT_NOTFOUND) {
 		giterr_clear();
 		result = packed_lookup(ref);
 		if (result == 0)
diff --git a/src/refspec.c b/src/refspec.c
index ee4d3a158..adb162df9 100644
--- a/src/refspec.c
+++ b/src/refspec.c
@@ -68,7 +68,7 @@ int git_refspec_transform(char *out, size_t outlen, const git_refspec *spec, con
 	baselen = strlen(spec->dst);
 	if (outlen <= baselen) {
 		giterr_set(GITERR_INVALID, "Reference name too long");
-		return GIT_ESHORTBUFFER;
+		return GIT_SHORTBUFFER;
 	}
 
 	/*
@@ -90,7 +90,7 @@ int git_refspec_transform(char *out, size_t outlen, const git_refspec *spec, con
 
 	if (outlen <= baselen + namelen) {
 		giterr_set(GITERR_INVALID, "Reference name too long");
-		return GIT_ESHORTBUFFER;
+		return GIT_SHORTBUFFER;
 	}
 
 	memcpy(out, spec->dst, baselen);
diff --git a/src/refspec.h b/src/refspec.h
index 64c0ded0c..2db504910 100644
--- a/src/refspec.h
+++ b/src/refspec.h
@@ -28,7 +28,7 @@ int git_refspec_parse(struct git_refspec *refspec, const char *str);
  * @param out where to store the target name
  * @param spec the refspec
  * @param name the name of the reference to transform
- * @return GIT_SUCCESS or error if buffer allocation fails
+ * @return 0 or error if buffer allocation fails
  */
 int git_refspec_transform_r(git_buf *out, const git_refspec *spec, const char *name);
 
diff --git a/src/remote.c b/src/remote.c
index dc0ff6a03..db4d0a7fd 100644
--- a/src/remote.c
+++ b/src/remote.c
@@ -135,7 +135,7 @@ int git_remote_load(git_remote **out, git_repository *repo, const char *name)
 	}
 
 	error = parse_remote_refspec(config, &remote->fetch, git_buf_cstr(&buf));
-	if (error == GIT_ENOTFOUND)
+	if (error == GIT_NOTFOUND)
 		error = 0;
 
 	if (error < 0) {
@@ -150,7 +150,7 @@ int git_remote_load(git_remote **out, git_repository *repo, const char *name)
 	}
 
 	error = parse_remote_refspec(config, &remote->push, git_buf_cstr(&buf));
-	if (error == GIT_ENOTFOUND)
+	if (error == GIT_NOTFOUND)
 		error = 0;
 
 	if (error < 0) {
@@ -338,7 +338,7 @@ int git_remote_update_tips(git_remote *remote, int (*cb)(const char *refname, co
 	assert(remote);
 
 	if (refs->length == 0)
-		return GIT_SUCCESS;
+		return 0;
 
 	/* HEAD is only allowed to be the first in the list */
 	head = refs->contents[0];
@@ -357,10 +357,10 @@ int git_remote_update_tips(git_remote *remote, int (*cb)(const char *refname, co
 			goto on_error;
 
 		error = git_reference_name_to_oid(&old, remote->repo, refname.ptr);
-		if (error < 0 && error != GIT_ENOTFOUND)
+		if (error < 0 && error != GIT_NOTFOUND)
 			goto on_error;
 
-		if (error == GIT_ENOTFOUND)
+		if (error == GIT_NOTFOUND)
 			memset(&old, 0, GIT_OID_RAWSZ);
 
 		if (!git_oid_cmp(&old, &head->oid))
diff --git a/src/repository.c b/src/repository.c
index 6ce3a560f..2979b446e 100644
--- a/src/repository.c
+++ b/src/repository.c
@@ -148,7 +148,7 @@ static int load_workdir(git_repository *repo, git_buf *parent_path)
 	error = git_config_get_string(&worktree, config, "core.worktree");
 	if (!error && worktree != NULL)
 		repo->workdir = git__strdup(worktree);
-	else if (error != GIT_ENOTFOUND)
+	else if (error != GIT_NOTFOUND)
 		return error;
 	else {
 		giterr_clear();
@@ -342,7 +342,7 @@ static int find_repo(
 	if (!git_buf_len(repo_path) && !error) {
 		giterr_set(GITERR_REPOSITORY,
 			"Could not find repository from '%s'", start_path);
-		error = GIT_ENOTFOUND;
+		error = GIT_NOTFOUND;
 	}
 
 	return error;
@@ -403,7 +403,7 @@ int git_repository_discover(
 	*repository_path = '\0';
 
 	if ((error = find_repo(&path, NULL, start_path, flags, ceiling_dirs)) < 0)
-		return error != GIT_ENOTFOUND ? -1 : error;
+		return error != GIT_NOTFOUND ? -1 : error;
 
 	if (size < (size_t)(path.size + 1)) {
 		giterr_set(GITERR_REPOSITORY,
@@ -851,7 +851,7 @@ int git_repository_head_orphan(git_repository *repo)
 	error = git_repository_head(&ref, repo);
 	git_reference_free(ref);
 
-	if (error == GIT_ENOTFOUND)
+	if (error == GIT_NOTFOUND)
 		return 1;
 
 	if (error < 0)
@@ -883,7 +883,7 @@ int git_repository_is_empty(git_repository *repo)
 	git_reference_free(head);
 	git_reference_free(branch);
 
-	if (error == GIT_ENOTFOUND)
+	if (error == GIT_NOTFOUND)
 		return 1;
 
 	if (error < 0)
diff --git a/src/revwalk.c b/src/revwalk.c
index d0a5120bd..67695f84b 100644
--- a/src/revwalk.c
+++ b/src/revwalk.c
@@ -316,7 +316,7 @@ static int merge_bases_many(commit_list **out, git_revwalk *walk, commit_object
 			if ((p->flags & flags) == flags)
 				continue;
 
-			if ((error = commit_parse(walk, p)) < GIT_SUCCESS)
+			if ((error = commit_parse(walk, p)) < 0)
 				return error;
 
 			p->flags |= flags;
@@ -375,7 +375,7 @@ int git_merge_base(git_oid *out, git_repository *repo, git_oid *one, git_oid *tw
 
 	if (!result) {
 		git_revwalk_free(walk);
-		return GIT_ENOTFOUND;
+		return GIT_NOTFOUND;
 	}
 
 	git_oid_cpy(out, &result->item->oid);
@@ -600,7 +600,7 @@ static int revwalk_next_timesort(commit_object **object_out, git_revwalk *walk)
 		}
 	}
 
-	return GIT_EREVWALKOVER;
+	return GIT_REVWALKOVER;
 }
 
 static int revwalk_next_unsorted(commit_object **object_out, git_revwalk *walk)
@@ -618,7 +618,7 @@ static int revwalk_next_unsorted(commit_object **object_out, git_revwalk *walk)
 		}
 	}
 
-	return GIT_EREVWALKOVER;
+	return GIT_REVWALKOVER;
 }
 
 static int revwalk_next_toposort(commit_object **object_out, git_revwalk *walk)
@@ -629,7 +629,7 @@ static int revwalk_next_toposort(commit_object **object_out, git_revwalk *walk)
 	for (;;) {
 		next = commit_list_pop(&walk->iterator_topo);
 		if (next == NULL)
-			return GIT_EREVWALKOVER;
+			return GIT_REVWALKOVER;
 
 		if (next->in_degree > 0) {
 			next->topo_delay = 1;
@@ -654,7 +654,7 @@ static int revwalk_next_toposort(commit_object **object_out, git_revwalk *walk)
 static int revwalk_next_reverse(commit_object **object_out, git_revwalk *walk)
 {
 	*object_out = commit_list_pop(&walk->iterator_reverse);
-	return *object_out ? 0 : GIT_EREVWALKOVER;
+	return *object_out ? 0 : GIT_REVWALKOVER;
 }
 
 
@@ -670,7 +670,7 @@ static int prepare_walk(git_revwalk *walk)
 	 * so we know that the walk is already over.
 	 */
 	if (walk->one == NULL)
-		return GIT_EREVWALKOVER;
+		return GIT_REVWALKOVER;
 
 	/* first figure out what the merge bases are */
 	if (merge_bases_many(&bases, walk, walk->one, &walk->twos) < 0)
@@ -698,7 +698,7 @@ static int prepare_walk(git_revwalk *walk)
 				return -1;
 		}
 
-		if (error != GIT_EREVWALKOVER)
+		if (error != GIT_REVWALKOVER)
 			return error;
 
 		walk->get_next = &revwalk_next_toposort;
@@ -710,7 +710,7 @@ static int prepare_walk(git_revwalk *walk)
 			if (commit_list_insert(next, &walk->iterator_reverse) == NULL)
 				return -1;
 
-		if (error != GIT_EREVWALKOVER)
+		if (error != GIT_REVWALKOVER)
 			return error;
 
 		walk->get_next = &revwalk_next_reverse;
@@ -809,9 +809,9 @@ int git_revwalk_next(git_oid *oid, git_revwalk *walk)
 
 	error = walk->get_next(&next, walk);
 
-	if (error == GIT_EREVWALKOVER) {
+	if (error == GIT_REVWALKOVER) {
 		git_revwalk_reset(walk);
-		return GIT_EREVWALKOVER;
+		return GIT_REVWALKOVER;
 	}
 
 	if (!error)
diff --git a/src/signature.c b/src/signature.c
index 4d6d11c70..7d329c4c9 100644
--- a/src/signature.c
+++ b/src/signature.c
@@ -167,7 +167,7 @@ static int parse_timezone_offset(const char *buffer, int *offset_out)
 
 	if (*offset_start == '\n') {
 		*offset_out = 0;
-		return GIT_SUCCESS;
+		return 0;
 	}
 
 	if (offset_start[0] != '-' && offset_start[0] != '+')
@@ -176,7 +176,7 @@ static int parse_timezone_offset(const char *buffer, int *offset_out)
 	if (offset_start[1] < '0' || offset_start[1] > '9')
 		return timezone_error("expected initial digit");
 
-	if (git__strtol32(&dec_offset, offset_start + 1, &offset_end, 10) < GIT_SUCCESS)
+	if (git__strtol32(&dec_offset, offset_start + 1, &offset_end, 10) < 0)
 		return timezone_error("not a valid number");
 
 	if (offset_end - offset_start != 5)
diff --git a/src/status.c b/src/status.c
index e9ad3cfe4..6676cd38f 100644
--- a/src/status.c
+++ b/src/status.c
@@ -214,7 +214,7 @@ int git_status_file(
 	if (!error && !sfi.count) {
 		giterr_set(GITERR_INVALID,
 			"Attempt to get status of nonexistent file '%s'", path);
-		error = GIT_ENOTFOUND;
+		error = GIT_NOTFOUND;
 	}
 
 	*status_flags = sfi.status;
diff --git a/src/submodule.c b/src/submodule.c
index 3c07e657d..a63043fd5 100644
--- a/src/submodule.c
+++ b/src/submodule.c
@@ -351,7 +351,7 @@ int git_submodule_foreach(
 	git_strmap_foreach_value(repo->submodules, sm, {
 		/* usually the following will not come into play */
 		if (sm->refcount > 1) {
-			if (git_vector_bsearch(&seen, sm) != GIT_ENOTFOUND)
+			if (git_vector_bsearch(&seen, sm) != GIT_NOTFOUND)
 				continue;
 			if ((error = git_vector_insert(&seen, sm)) < 0)
 				break;
@@ -378,7 +378,7 @@ int git_submodule_lookup(
 
 	pos = git_strmap_lookup_index(repo->submodules, name);
 	if (!git_strmap_valid_index(repo->submodules, pos))
-		return GIT_ENOTFOUND;
+		return GIT_NOTFOUND;
 
 	if (sm_ptr)
 		*sm_ptr = git_strmap_value_at(repo->submodules, pos);
diff --git a/src/tag.c b/src/tag.c
index 13481c2a6..2a9ffee5b 100644
--- a/src/tag.c
+++ b/src/tag.c
@@ -168,7 +168,7 @@ static int retrieve_tag_reference(
 		return -1;
 
 	error = git_reference_lookup(&tag_ref, repo, ref_name_out->ptr);
-	if (error < GIT_SUCCESS)
+	if (error < 0)
 		return error; /* Be it not foundo or corrupted */
 
 	*tag_reference_out = tag_ref;
@@ -254,7 +254,7 @@ static int git_tag_create__internal(
 	}
 
 	error = retrieve_tag_reference_oid(oid, &ref_name, repo, tag_name);
-	if (error < GIT_SUCCESS && error != GIT_ENOTFOUND)
+	if (error < 0 && error != GIT_NOTFOUND)
 		return -1;
 
 	/** Ensure the tag name doesn't conflict with an already existing
@@ -262,7 +262,7 @@ static int git_tag_create__internal(
 	if (error == 0 && !allow_ref_overwrite) {
 		git_buf_free(&ref_name);
 		giterr_set(GITERR_TAG, "Tag already exists");
-		return GIT_EEXISTS;
+		return GIT_EXISTS;
 	}
 
 	if (create_tag_annotation) {
@@ -332,7 +332,7 @@ int git_tag_create_frombuffer(git_oid *oid, git_repository *repo, const char *bu
 	}
 
 	error = retrieve_tag_reference_oid(oid, &ref_name, repo, tag.tag_name);
-	if (error < GIT_SUCCESS && error != GIT_ENOTFOUND)
+	if (error < 0 && error != GIT_NOTFOUND)
 		goto on_error;
 
 	/* We don't need these objects after this */
@@ -345,7 +345,7 @@ int git_tag_create_frombuffer(git_oid *oid, git_repository *repo, const char *bu
 	 *	reference unless overwriting has explictly been requested **/
 	if (error == 0 && !allow_ref_overwrite) {
 		giterr_set(GITERR_TAG, "Tag already exists");
-		return GIT_EEXISTS;
+		return GIT_EXISTS;
 	}
 
 	/* write the buffer */
@@ -414,7 +414,7 @@ static int tag_list_cb(const char *tag_name, void *payload)
 		return 0;
 
 	filter = (tag_filter_data *)payload;
-	if (!*filter->pattern || p_fnmatch(filter->pattern, tag_name + GIT_REFS_TAGS_DIR_LEN, 0) == GIT_SUCCESS)
+	if (!*filter->pattern || p_fnmatch(filter->pattern, tag_name + GIT_REFS_TAGS_DIR_LEN, 0) == 0)
 		return git_vector_insert(filter->taglist, git__strdup(tag_name));
 
 	return 0;
@@ -428,7 +428,7 @@ int git_tag_list_match(git_strarray *tag_names, const char *pattern, git_reposit
 
 	assert(tag_names && repo && pattern);
 
-	if (git_vector_init(&taglist, 8, NULL) < GIT_SUCCESS)
+	if (git_vector_init(&taglist, 8, NULL) < 0)
 		return -1;
 
 	filter.taglist = &taglist;
diff --git a/src/transport.c b/src/transport.c
index bc4248d5b..5b2cd7ea4 100644
--- a/src/transport.c
+++ b/src/transport.c
@@ -37,7 +37,7 @@ static git_transport_cb transport_find_fn(const char *url)
 	}
 
 	/* still here? Check to see if the path points to a file on the local file system */
-	if ((git_path_exists(url) == GIT_SUCCESS) && git_path_isdir(url))
+	if ((git_path_exists(url) == 0) && git_path_isdir(url))
 		return &git_transport_local;
 
 	/* It could be a SSH remote path. Check to see if there's a : */
@@ -72,7 +72,7 @@ int git_transport_new(git_transport **out, const char *url)
 	}
 
 	error = fn(&transport);
-	if (error < GIT_SUCCESS)
+	if (error < 0)
 		return error;
 
 	transport->url = git__strdup(url);
@@ -80,7 +80,7 @@ int git_transport_new(git_transport **out, const char *url)
 
 	*out = transport;
 
-	return GIT_SUCCESS;
+	return 0;
 }
 
 /* from remote.h */
diff --git a/src/transports/git.c b/src/transports/git.c
index 9a1741941..c8f50800d 100644
--- a/src/transports/git.c
+++ b/src/transports/git.c
@@ -147,7 +147,7 @@ static int store_refs(transport_git *t)
 			return 0;
 
 		ret = git_protocol_store_refs(&t->proto, buf->data, buf->offset);
-		if (ret == GIT_ESHORTBUFFER) {
+		if (ret == GIT_SHORTBUFFER) {
 			gitno_consume_n(buf, buf->len);
 			continue;
 		}
@@ -279,7 +279,7 @@ static int recv_pkt(gitno_buffer *buf)
 			return -1;
 
 		error = git_pkt_parse_line(&pkt, ptr, &line_end, buf->offset);
-		if (error == GIT_ESHORTBUFFER)
+		if (error == GIT_SHORTBUFFER)
 			continue;
 		if (error < 0)
 			return -1;
@@ -344,7 +344,7 @@ static int git_negotiate_fetch(git_transport *transport, git_repository *repo, c
 
 		}
 	}
-	if (error < 0 && error != GIT_EREVWALKOVER)
+	if (error < 0 && error != GIT_REVWALKOVER)
 		goto on_error;
 
 	/* Tell the other end that we're done negotiating */
@@ -384,10 +384,10 @@ static int git_download_pack(git_transport *transport, git_repository *repo, git
 			}
 
 			error = git_pkt_parse_line(&pkt, ptr, &line_end, buf->offset);
-			if (error == GIT_ESHORTBUFFER)
+			if (error == GIT_SHORTBUFFER)
 				break;
 
-			if (error < GIT_SUCCESS)
+			if (error < 0)
 				return error;
 
 			if (pkt->type == GIT_PKT_PACK) {
diff --git a/src/transports/http.c b/src/transports/http.c
index bc4a615f1..b382f7cd7 100644
--- a/src/transports/http.c
+++ b/src/transports/http.c
@@ -354,10 +354,10 @@ static int on_body_parse_response(http_parser *parser, const char *str, size_t l
 			return 0;
 
 		error = git_pkt_parse_line(&pkt, ptr, &line_end, git_buf_len(buf));
-		if (error == GIT_ESHORTBUFFER) {
+		if (error == GIT_SHORTBUFFER) {
 			return 0; /* Ask for more */
 		}
-		if (error < GIT_SUCCESS)
+		if (error < 0)
 			return t->error = -1;
 
 		git_buf_consume(buf, line_end);
@@ -486,7 +486,7 @@ static int http_negotiate_fetch(git_transport *transport, git_repository *repo,
 		git_buf_clear(&request);
 		git_buf_clear(&data);
 
-		if (ret < GIT_SUCCESS || i >= 256)
+		if (ret < 0 || i >= 256)
 			break;
 
 		if ((ret = parse_response(t)) < 0)
diff --git a/src/tree.c b/src/tree.c
index 5acee4a41..a5fe2b63c 100644
--- a/src/tree.c
+++ b/src/tree.c
@@ -117,7 +117,7 @@ static int tree_key_search(git_vector *entries, const char *filename)
 	}
 
 	/* The filename doesn't exist at all */
-	return GIT_ENOTFOUND;
+	return GIT_NOTFOUND;
 }
 
 void git_tree__free(git_tree *tree)
@@ -186,7 +186,7 @@ const git_tree_entry *git_tree_entry_byname(git_tree *tree, const char *filename
 	assert(tree && filename);
 
 	idx = tree_key_search(&tree->entries, filename);
-	if (idx == GIT_ENOTFOUND)
+	if (idx == GIT_NOTFOUND)
 		return NULL;
 
 	return git_vector_get(&tree->entries, idx);
@@ -518,7 +518,7 @@ int git_treebuilder_insert(git_tree_entry **entry_out, git_treebuilder *bld, con
 	git_oid_cpy(&entry->oid, id);
 	entry->attr = attributes;
 
-	if (pos == GIT_ENOTFOUND) {
+	if (pos == GIT_NOTFOUND) {
 		if (git_vector_insert(&bld->entries, entry) < 0)
 			return -1;
 	}
@@ -647,7 +647,7 @@ static int tree_frompath(
 {
 	char *slash_pos = NULL;
 	const git_tree_entry* entry;
-	int error = GIT_SUCCESS;
+	int error = 0;
 	git_tree *subtree;
 
 	if (!*(treeentry_path->ptr + offset)) {
@@ -682,7 +682,7 @@ static int tree_frompath(
 		giterr_set(GITERR_TREE,
 			"No tree entry can be found from "
 			"the given tree and relative path '%s'.", treeentry_path->ptr);
-		return GIT_ENOTFOUND;
+		return GIT_NOTFOUND;
 	}
 
 
@@ -724,7 +724,7 @@ static int tree_walk_post(
 	git_buf *path,
 	void *payload)
 {
-	int error = GIT_SUCCESS;
+	int error = 0;
 	unsigned int i;
 
 	for (i = 0; i < tree->entries.length; ++i) {
@@ -761,7 +761,7 @@ static int tree_walk_post(
 
 int git_tree_walk(git_tree *tree, git_treewalk_cb callback, int mode, void *payload)
 {
-	int error = GIT_SUCCESS;
+	int error = 0;
 	git_buf root_path = GIT_BUF_INIT;
 
 	switch (mode) {
diff --git a/src/vector.c b/src/vector.c
index 6f9aacccf..6bd1e9311 100644
--- a/src/vector.c
+++ b/src/vector.c
@@ -137,7 +137,7 @@ int git_vector_bsearch3(
 	if (at_pos != NULL)
 		*at_pos = (unsigned int)pos;
 
-	return (rval >= 0) ? (int)pos : GIT_ENOTFOUND;
+	return (rval >= 0) ? (int)pos : GIT_NOTFOUND;
 }
 
 int git_vector_search2(
@@ -152,7 +152,7 @@ int git_vector_search2(
 			return i;
 	}
 
-	return GIT_ENOTFOUND;
+	return GIT_NOTFOUND;
 }
 
 static int strict_comparison(const void *a, const void *b)
@@ -172,7 +172,7 @@ int git_vector_remove(git_vector *v, unsigned int idx)
 	assert(v);
 
 	if (idx >= v->length || v->length == 0)
-		return GIT_ENOTFOUND;
+		return GIT_NOTFOUND;
 
 	for (i = idx; i < v->length - 1; ++i)
 		v->contents[i] = v->contents[i + 1];
diff --git a/tests-clar/commit/signature.c b/tests-clar/commit/signature.c
index 605b8330a..290b11fa3 100644
--- a/tests-clar/commit/signature.c
+++ b/tests-clar/commit/signature.c
@@ -3,9 +3,9 @@
 static int try_build_signature(const char *name, const char *email, git_time_t time, int offset)
 {
 	git_signature *sign;
-	int error = GIT_SUCCESS;
+	int error = 0;
 
-	if ((error =  git_signature_new(&sign, name, email, time, offset)) < GIT_SUCCESS)
+	if ((error =  git_signature_new(&sign, name, email, time, offset)) < 0)
 		return error;
 
 	git_signature_free((git_signature *)sign);
diff --git a/tests-clar/config/multivar.c b/tests-clar/config/multivar.c
index d3784c0dd..3b40cd09a 100644
--- a/tests-clar/config/multivar.c
+++ b/tests-clar/config/multivar.c
@@ -21,7 +21,7 @@ static int mv_read_cb(const char *name, const char *value, void *data)
 	if (!strcmp(name, _name))
 		(*n)++;
 
-	return GIT_SUCCESS;
+	return 0;
 }
 
 void test_config_multivar__foreach(void)
@@ -45,7 +45,7 @@ static int cb(const char *val, void *data)
 
 	(*n)++;
 
-	return GIT_SUCCESS;
+	return 0;
 }
 
 void test_config_multivar__get(void)
diff --git a/tests-clar/config/write.c b/tests-clar/config/write.c
index f8774473e..4583a149b 100644
--- a/tests-clar/config/write.c
+++ b/tests-clar/config/write.c
@@ -62,7 +62,7 @@ void test_config_write__delete_value(void)
 	git_config_free(cfg);
 
 	cl_git_pass(git_config_open_ondisk(&cfg, "config9"));
-	cl_assert(git_config_get_int32(&i, cfg, "core.dummy") == GIT_ENOTFOUND);
+	cl_assert(git_config_get_int32(&i, cfg, "core.dummy") == GIT_NOTFOUND);
 	cl_git_pass(git_config_set_int32(cfg, "core.dummy", 1));
 	git_config_free(cfg);
 }
@@ -87,6 +87,6 @@ void test_config_write__delete_inexistent(void)
 	git_config *cfg;
 
 	cl_git_pass(git_config_open_ondisk(&cfg, "config9"));
-	cl_assert(git_config_delete(cfg, "core.imaginary") == GIT_ENOTFOUND);
+	cl_assert(git_config_delete(cfg, "core.imaginary") == GIT_NOTFOUND);
 	git_config_free(cfg);
 }
diff --git a/tests-clar/core/path.c b/tests-clar/core/path.c
index d826612ac..af8bf8127 100644
--- a/tests-clar/core/path.c
+++ b/tests-clar/core/path.c
@@ -413,8 +413,8 @@ void test_core_path__13_cannot_prettify_a_non_existing_file(void)
 	git_buf p = GIT_BUF_INIT;
 
 	cl_must_pass(git_path_exists(NON_EXISTING_FILEPATH) == false);
-	cl_assert_equal_i(GIT_ENOTFOUND, git_path_prettify(&p, NON_EXISTING_FILEPATH, NULL));
-	cl_assert_equal_i(GIT_ENOTFOUND, git_path_prettify(&p, NON_EXISTING_FILEPATH "/so-do-i", NULL));
+	cl_assert_equal_i(GIT_NOTFOUND, git_path_prettify(&p, NON_EXISTING_FILEPATH, NULL));
+	cl_assert_equal_i(GIT_NOTFOUND, git_path_prettify(&p, NON_EXISTING_FILEPATH "/so-do-i", NULL));
 
 	git_buf_free(&p);
 }
diff --git a/tests-clar/core/vector.c b/tests-clar/core/vector.c
index ef3d6c36d..5b47dded2 100644
--- a/tests-clar/core/vector.c
+++ b/tests-clar/core/vector.c
@@ -143,7 +143,7 @@ static int merge_structs(void **old_raw, void *new)
 	((my_struct *)old)->count += 1;
 	git__free(new);
 	_struct_count--;
-	return GIT_EEXISTS;
+	return GIT_EXISTS;
 }
 
 static my_struct *alloc_struct(int value)
diff --git a/tests-clar/index/tests.c b/tests-clar/index/tests.c
index 3d01b7cfb..6420163f5 100644
--- a/tests-clar/index/tests.c
+++ b/tests-clar/index/tests.c
@@ -50,10 +50,10 @@ static void files_are_equal(const char *a, const char *b)
 	git_buf buf_b = GIT_BUF_INIT;
 	int pass;
 
-	if (git_futils_readbuffer(&buf_a, a) < GIT_SUCCESS)
+	if (git_futils_readbuffer(&buf_a, a) < 0)
 		cl_assert(0);
 
-	if (git_futils_readbuffer(&buf_b, b) < GIT_SUCCESS) {
+	if (git_futils_readbuffer(&buf_b, b) < 0) {
 		git_buf_free(&buf_a);
 		cl_assert(0);
 	}
@@ -153,7 +153,7 @@ void test_index_tests__find_in_empty(void)
 
    for (i = 0; i < ARRAY_SIZE(test_entries); ++i) {
       int idx = git_index_find(index, test_entries[i].path);
-      cl_assert(idx == GIT_ENOTFOUND);
+      cl_assert(idx == GIT_NOTFOUND);
    }
 
    git_index_free(index);
diff --git a/tests-clar/network/remotelocal.c b/tests-clar/network/remotelocal.c
index 35fa072ef..98abbbeb9 100644
--- a/tests-clar/network/remotelocal.c
+++ b/tests-clar/network/remotelocal.c
@@ -68,7 +68,7 @@ static int count_ref__cb(git_remote_head *head, void *payload)
 	(void)head;
 	(*count)++;
 
-	return GIT_SUCCESS;
+	return 0;
 }
 
 static int ensure_peeled__cb(git_remote_head *head, void *payload)
diff --git a/tests-clar/network/remotes.c b/tests-clar/network/remotes.c
index 0649c86dd..17cc797d0 100644
--- a/tests-clar/network/remotes.c
+++ b/tests-clar/network/remotes.c
@@ -156,7 +156,7 @@ void test_network_remotes__list(void)
 
 void test_network_remotes__loading_a_missing_remote_returns_ENOTFOUND(void)
 {
-	cl_assert_equal_i(GIT_ENOTFOUND, git_remote_load(&_remote, _repo, "just-left-few-minutes-ago"));
+	cl_assert_equal_i(GIT_NOTFOUND, git_remote_load(&_remote, _repo, "just-left-few-minutes-ago"));
 }
 
 void test_network_remotes__add(void)
diff --git a/tests-clar/notes/notes.c b/tests-clar/notes/notes.c
index 5185f25ea..c23a9f0f9 100644
--- a/tests-clar/notes/notes.c
+++ b/tests-clar/notes/notes.c
@@ -127,7 +127,7 @@ void test_notes_notes__retrieving_a_list_of_notes_for_an_unknown_namespace_retur
 
 	error = git_note_foreach(_repo, "refs/notes/i-am-not", note_list_cb, &retrieved_notes);
 	cl_git_fail(error);
-	cl_assert_equal_i(GIT_ENOTFOUND, error);
+	cl_assert_equal_i(GIT_NOTFOUND, error);
 
 	cl_assert_equal_i(0, retrieved_notes);
 }
diff --git a/tests-clar/object/lookup.c b/tests-clar/object/lookup.c
index 7cbcc6140..f840cb39f 100644
--- a/tests-clar/object/lookup.c
+++ b/tests-clar/object/lookup.c
@@ -22,7 +22,7 @@ void test_object_lookup__lookup_wrong_type_returns_enotfound(void)
 
 	cl_git_pass(git_oid_fromstr(&oid, commit));
 	cl_assert_equal_i(
-		GIT_ENOTFOUND, git_object_lookup(&object, g_repo, &oid, GIT_OBJ_TAG));
+		GIT_NOTFOUND, git_object_lookup(&object, g_repo, &oid, GIT_OBJ_TAG));
 }
 
 void test_object_lookup__lookup_nonexisting_returns_enotfound(void)
@@ -33,7 +33,7 @@ void test_object_lookup__lookup_nonexisting_returns_enotfound(void)
 
 	cl_git_pass(git_oid_fromstr(&oid, unknown));
 	cl_assert_equal_i(
-		GIT_ENOTFOUND, git_object_lookup(&object, g_repo, &oid, GIT_OBJ_ANY));
+		GIT_NOTFOUND, git_object_lookup(&object, g_repo, &oid, GIT_OBJ_ANY));
 }
 
 void test_object_lookup__lookup_wrong_type_by_abbreviated_id_returns_enotfound(void)
@@ -44,7 +44,7 @@ void test_object_lookup__lookup_wrong_type_by_abbreviated_id_returns_enotfound(v
 
 	cl_git_pass(git_oid_fromstrn(&oid, commit, strlen(commit)));
 	cl_assert_equal_i(
-		GIT_ENOTFOUND, git_object_lookup_prefix(&object, g_repo, &oid, strlen(commit), GIT_OBJ_TAG));
+		GIT_NOTFOUND, git_object_lookup_prefix(&object, g_repo, &oid, strlen(commit), GIT_OBJ_TAG));
 }
 
 void test_object_lookup__lookup_wrong_type_eventually_returns_enotfound(void)
@@ -59,5 +59,5 @@ void test_object_lookup__lookup_wrong_type_eventually_returns_enotfound(void)
 	git_object_free(object);
 
 	cl_assert_equal_i(
-		GIT_ENOTFOUND, git_object_lookup(&object, g_repo, &oid, GIT_OBJ_TAG));
+		GIT_NOTFOUND, git_object_lookup(&object, g_repo, &oid, GIT_OBJ_TAG));
 }
diff --git a/tests-clar/object/tag/read.c b/tests-clar/object/tag/read.c
index cfeb3aeee..6a0ad8a23 100644
--- a/tests-clar/object/tag/read.c
+++ b/tests-clar/object/tag/read.c
@@ -17,9 +17,9 @@ static void ensure_tag_pattern_match(git_repository *repo,
                                      const size_t expected_matches)
 {
    git_strarray tag_list;
-   int error = GIT_SUCCESS;
+   int error = 0;
 
-   if ((error = git_tag_list_match(&tag_list, pattern, repo)) < GIT_SUCCESS)
+   if ((error = git_tag_list_match(&tag_list, pattern, repo)) < 0)
       goto exit;
 
    if (tag_list.count != expected_matches)
diff --git a/tests-clar/object/tree/frompath.c b/tests-clar/object/tree/frompath.c
index ea0add37b..7d4adafb2 100644
--- a/tests-clar/object/tree/frompath.c
+++ b/tests-clar/object/tree/frompath.c
@@ -30,10 +30,10 @@ static void assert_tree_from_path(git_tree *root, const char *path, int expected
 
 	cl_assert(git_tree_get_subtree(&containing_tree, root, path) == expected_result);
 	
-	if (containing_tree == NULL && expected_result != GIT_SUCCESS)
+	if (containing_tree == NULL && expected_result != 0)
 		return;
 	
-	cl_assert(containing_tree != NULL && expected_result == GIT_SUCCESS);
+	cl_assert(containing_tree != NULL && expected_result == 0);
 
 	cl_git_pass(git_oid_streq(git_object_id((const git_object *)containing_tree), expected_raw_oid));
 
@@ -49,25 +49,25 @@ static void assert_tree_from_path_klass(git_tree *root, const char *path, int ex
 void test_object_tree_frompath__retrieve_tree_from_path_to_treeentry(void)
 {
 	/* Will return self if given a one path segment... */
-	assert_tree_from_path(tree, "README", GIT_SUCCESS, tree_with_subtrees_oid);
+	assert_tree_from_path(tree, "README", 0, tree_with_subtrees_oid);
 	
 	/* ...even one that lead to a non existent tree entry. */
-	assert_tree_from_path(tree, "i-do-not-exist.txt", GIT_SUCCESS, tree_with_subtrees_oid);
+	assert_tree_from_path(tree, "i-do-not-exist.txt", 0, tree_with_subtrees_oid);
 	
 	/* Will return fgh tree oid given this following path... */
-	assert_tree_from_path(tree, "ab/de/fgh/1.txt", GIT_SUCCESS, "3259a6bd5b57fb9c1281bb7ed3167b50f224cb54");
+	assert_tree_from_path(tree, "ab/de/fgh/1.txt", 0, "3259a6bd5b57fb9c1281bb7ed3167b50f224cb54");
 	
 	/* ... and ab tree oid given this one. */
-	assert_tree_from_path(tree, "ab/de", GIT_SUCCESS, "f1425cef211cc08caa31e7b545ffb232acb098c3");
+	assert_tree_from_path(tree, "ab/de", 0, "f1425cef211cc08caa31e7b545ffb232acb098c3");
 
 	/* Will succeed if given a valid path which leads to a tree entry which doesn't exist */
-	assert_tree_from_path(tree, "ab/de/fgh/i-do-not-exist.txt", GIT_SUCCESS, "3259a6bd5b57fb9c1281bb7ed3167b50f224cb54");
+	assert_tree_from_path(tree, "ab/de/fgh/i-do-not-exist.txt", 0, "3259a6bd5b57fb9c1281bb7ed3167b50f224cb54");
 }
 
 void test_object_tree_frompath__fail_when_processing_an_unknown_tree_segment(void)
 {
-	assert_tree_from_path(tree, "nope/de/fgh/1.txt", GIT_ENOTFOUND, NULL);
-	assert_tree_from_path(tree, "ab/me-neither/fgh/2.txt", GIT_ENOTFOUND, NULL);
+	assert_tree_from_path(tree, "nope/de/fgh/1.txt", GIT_NOTFOUND, NULL);
+	assert_tree_from_path(tree, "ab/me-neither/fgh/2.txt", GIT_NOTFOUND, NULL);
 }
 
 void test_object_tree_frompath__fail_when_processing_an_invalid_path(void)
diff --git a/tests-clar/refs/branches/delete.c b/tests-clar/refs/branches/delete.c
index 03d3c56d7..629c491f3 100644
--- a/tests-clar/refs/branches/delete.c
+++ b/tests-clar/refs/branches/delete.c
@@ -81,7 +81,7 @@ static void assert_non_exisitng_branch_removal(const char *branch_name, git_bran
 	error = git_branch_delete(repo, branch_name, branch_type);
 
 	cl_git_fail(error);
-	cl_assert_equal_i(GIT_ENOTFOUND, error);
+	cl_assert_equal_i(GIT_NOTFOUND, error);
 }
 
 void test_refs_branches_delete__deleting_a_non_existing_branch_returns_ENOTFOUND(void)
diff --git a/tests-clar/refs/branches/move.c b/tests-clar/refs/branches/move.c
index 242e5cd01..8948497e2 100644
--- a/tests-clar/refs/branches/move.c
+++ b/tests-clar/refs/branches/move.c
@@ -68,5 +68,5 @@ void test_refs_branches_move__moving_a_non_exisiting_branch_returns_ENOTFOUND(vo
 	error = git_branch_move(repo, "where/am/I", NEW_BRANCH_NAME, 0);
 	cl_git_fail(error);
 
-	cl_assert_equal_i(GIT_ENOTFOUND, error);
+	cl_assert_equal_i(GIT_NOTFOUND, error);
 }
diff --git a/tests-clar/repo/discover.c b/tests-clar/repo/discover.c
index b3d639bd1..635bf9661 100644
--- a/tests-clar/repo/discover.c
+++ b/tests-clar/repo/discover.c
@@ -82,7 +82,7 @@ void test_repo_discover__0(void)
 	append_ceiling_dir(&ceiling_dirs_buf, TEMP_REPO_FOLDER);
 	ceiling_dirs = git_buf_cstr(&ceiling_dirs_buf);
 
-	cl_assert_equal_i(GIT_ENOTFOUND, git_repository_discover(repository_path, sizeof(repository_path), DISCOVER_FOLDER, 0, ceiling_dirs));
+	cl_assert_equal_i(GIT_NOTFOUND, git_repository_discover(repository_path, sizeof(repository_path), DISCOVER_FOLDER, 0, ceiling_dirs));
 
 	cl_git_pass(git_repository_init(&repo, DISCOVER_FOLDER, 1));
 	cl_git_pass(git_repository_discover(repository_path, sizeof(repository_path), DISCOVER_FOLDER, 0, ceiling_dirs));
@@ -117,7 +117,7 @@ void test_repo_discover__0(void)
 	cl_git_fail(git_repository_discover(found_path, sizeof(found_path), ALTERNATE_MALFORMED_FOLDER1, 0, ceiling_dirs));
 	cl_git_fail(git_repository_discover(found_path, sizeof(found_path), ALTERNATE_MALFORMED_FOLDER2, 0, ceiling_dirs));
 	cl_git_fail(git_repository_discover(found_path, sizeof(found_path), ALTERNATE_MALFORMED_FOLDER3, 0, ceiling_dirs));
-	cl_assert_equal_i(GIT_ENOTFOUND, git_repository_discover(found_path, sizeof(found_path), ALTERNATE_NOT_FOUND_FOLDER, 0, ceiling_dirs));
+	cl_assert_equal_i(GIT_NOTFOUND, git_repository_discover(found_path, sizeof(found_path), ALTERNATE_NOT_FOUND_FOLDER, 0, ceiling_dirs));
 
 	append_ceiling_dir(&ceiling_dirs_buf, SUB_REPOSITORY_FOLDER);
 	ceiling_dirs = git_buf_cstr(&ceiling_dirs_buf);
@@ -125,9 +125,9 @@ void test_repo_discover__0(void)
 	//this must pass as ceiling_directories cannot predent the current
 	//working directory to be checked
 	cl_git_pass(git_repository_discover(found_path, sizeof(found_path), SUB_REPOSITORY_FOLDER, 0, ceiling_dirs));
-	cl_assert_equal_i(GIT_ENOTFOUND, git_repository_discover(found_path, sizeof(found_path), SUB_REPOSITORY_FOLDER_SUB, 0, ceiling_dirs));
-	cl_assert_equal_i(GIT_ENOTFOUND, git_repository_discover(found_path, sizeof(found_path), SUB_REPOSITORY_FOLDER_SUB_SUB, 0, ceiling_dirs));
-	cl_assert_equal_i(GIT_ENOTFOUND, git_repository_discover(found_path, sizeof(found_path), SUB_REPOSITORY_FOLDER_SUB_SUB_SUB, 0, ceiling_dirs));
+	cl_assert_equal_i(GIT_NOTFOUND, git_repository_discover(found_path, sizeof(found_path), SUB_REPOSITORY_FOLDER_SUB, 0, ceiling_dirs));
+	cl_assert_equal_i(GIT_NOTFOUND, git_repository_discover(found_path, sizeof(found_path), SUB_REPOSITORY_FOLDER_SUB_SUB, 0, ceiling_dirs));
+	cl_assert_equal_i(GIT_NOTFOUND, git_repository_discover(found_path, sizeof(found_path), SUB_REPOSITORY_FOLDER_SUB_SUB_SUB, 0, ceiling_dirs));
 
 	//.gitfile redirection should not be affected by ceiling directories
 	ensure_repository_discover(REPOSITORY_ALTERNATE_FOLDER, ceiling_dirs, sub_repository_path);
diff --git a/tests-clar/repo/open.c b/tests-clar/repo/open.c
index 292466390..62578bec3 100644
--- a/tests-clar/repo/open.c
+++ b/tests-clar/repo/open.c
@@ -278,5 +278,5 @@ void test_repo_open__win32_path(void)
 void test_repo_open__opening_a_non_existing_repository_returns_ENOTFOUND(void)
 {
 	git_repository *repo;
-	cl_assert_equal_i(GIT_ENOTFOUND, git_repository_open(&repo, "i-do-not/exist"));
-}
\ No newline at end of file
+	cl_assert_equal_i(GIT_NOTFOUND, git_repository_open(&repo, "i-do-not/exist"));
+}
diff --git a/tests-clar/revwalk/basic.c b/tests-clar/revwalk/basic.c
index 7d54ce990..a5a9b2eda 100644
--- a/tests-clar/revwalk/basic.c
+++ b/tests-clar/revwalk/basic.c
@@ -73,7 +73,7 @@ static int test_walk(git_revwalk *walk, const git_oid *root,
 
 	i = 0;
 
-	while (git_revwalk_next(&oid, walk) == GIT_SUCCESS) {
+	while (git_revwalk_next(&oid, walk) == 0) {
 		result_array[i++] = get_commit_index(&oid);
 		/*{
 			char str[41];
@@ -86,7 +86,7 @@ static int test_walk(git_revwalk *walk, const git_oid *root,
 	for (i = 0; i < results_count; ++i)
 		if (memcmp(possible_results[i],
 				result_array, result_bytes) == 0)
-			return GIT_SUCCESS;
+			return 0;
 
 	return GIT_ERROR;
 }
@@ -125,7 +125,7 @@ void test_revwalk_basic__glob_heads(void)
 
 	cl_git_pass(git_revwalk_push_glob(_walk, "heads"));
 
-	while (git_revwalk_next(&oid, _walk) == GIT_SUCCESS) {
+	while (git_revwalk_next(&oid, _walk) == 0) {
 		i++;
 	}
 
@@ -140,7 +140,7 @@ void test_revwalk_basic__push_head(void)
 
 	cl_git_pass(git_revwalk_push_head(_walk));
 
-	while (git_revwalk_next(&oid, _walk) == GIT_SUCCESS) {
+	while (git_revwalk_next(&oid, _walk) == 0) {
 		i++;
 	}
 
@@ -156,7 +156,7 @@ void test_revwalk_basic__push_head_hide_ref(void)
 	cl_git_pass(git_revwalk_push_head(_walk));
 	cl_git_pass(git_revwalk_hide_ref(_walk, "refs/heads/packed-test"));
 
-	while (git_revwalk_next(&oid, _walk) == GIT_SUCCESS) {
+	while (git_revwalk_next(&oid, _walk) == 0) {
 		i++;
 	}
 
@@ -172,7 +172,7 @@ void test_revwalk_basic__push_head_hide_ref_nobase(void)
 	cl_git_pass(git_revwalk_push_head(_walk));
 	cl_git_pass(git_revwalk_hide_ref(_walk, "refs/heads/packed"));
 
-	while (git_revwalk_next(&oid, _walk) == GIT_SUCCESS) {
+	while (git_revwalk_next(&oid, _walk) == 0) {
 		i++;
 	}
 
diff --git a/tests-clar/revwalk/mergebase.c b/tests-clar/revwalk/mergebase.c
index e807e3ad2..694dffcba 100644
--- a/tests-clar/revwalk/mergebase.c
+++ b/tests-clar/revwalk/mergebase.c
@@ -63,7 +63,7 @@ void test_revwalk_mergebase__no_common_ancestor_returns_ENOTFOUND(void)
 	error = git_merge_base(&result, _repo, &one, &two);
 	cl_git_fail(error);
 
-	cl_assert_equal_i(GIT_ENOTFOUND, error);
+	cl_assert_equal_i(GIT_NOTFOUND, error);
 }
 
 /*
diff --git a/tests-clar/status/submodules.c b/tests-clar/status/submodules.c
index 9423e8490..63a44dc0e 100644
--- a/tests-clar/status/submodules.c
+++ b/tests-clar/status/submodules.c
@@ -34,9 +34,9 @@ void test_status_submodules__api(void)
 {
 	git_submodule *sm;
 
-	cl_assert(git_submodule_lookup(NULL, g_repo, "nonexistent") == GIT_ENOTFOUND);
+	cl_assert(git_submodule_lookup(NULL, g_repo, "nonexistent") == GIT_NOTFOUND);
 
-	cl_assert(git_submodule_lookup(NULL, g_repo, "modified") == GIT_ENOTFOUND);
+	cl_assert(git_submodule_lookup(NULL, g_repo, "modified") == GIT_NOTFOUND);
 
 	cl_git_pass(git_submodule_lookup(&sm, g_repo, "testrepo"));
 	cl_assert(sm != NULL);
diff --git a/tests-clar/status/worktree.c b/tests-clar/status/worktree.c
index 6cc6259b8..d839e8462 100644
--- a/tests-clar/status/worktree.c
+++ b/tests-clar/status/worktree.c
@@ -199,7 +199,7 @@ void test_status_worktree__single_nonexistent_file(void)
 
 	error = git_status_file(&status_flags, repo, "nonexistent");
 	cl_git_fail(error);
-	cl_assert(error == GIT_ENOTFOUND);
+	cl_assert(error == GIT_NOTFOUND);
 }
 
 /* this test is equivalent to t18-status.c:singlestatus2 */
@@ -211,7 +211,7 @@ void test_status_worktree__single_nonexistent_file_empty_repo(void)
 
 	error = git_status_file(&status_flags, repo, "nonexistent");
 	cl_git_fail(error);
-	cl_assert(error == GIT_ENOTFOUND);
+	cl_assert(error == GIT_NOTFOUND);
 }
 
 /* this test is equivalent to t18-status.c:singlestatus3 */
@@ -235,7 +235,7 @@ void test_status_worktree__single_folder(void)
 
 	error = git_status_file(&status_flags, repo, "subdir");
 	cl_git_fail(error);
-	cl_assert(error != GIT_ENOTFOUND);
+	cl_assert(error != GIT_NOTFOUND);
 }
 
 
@@ -416,7 +416,7 @@ void test_status_worktree__cannot_retrieve_the_status_of_a_bare_repository(void)
 	error = git_status_file(&status, repo, "dummy");
 
 	cl_git_fail(error);
-	cl_assert(error != GIT_ENOTFOUND);
+	cl_assert(error != GIT_NOTFOUND);
 
 	git_repository_free(repo);
 }

From 904b67e69fa15b7a3246e43b3d78645ffa2331f6 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Vicent=20Mart=C3=AD?= <tanoku@gmail.com>
Date: Fri, 18 May 2012 01:48:50 +0200
Subject: [PATCH 7/7] errors: Rename error codes

---
 examples/diff.c                   |  4 ++--
 include/git2/branch.h             |  4 ++--
 include/git2/errors.h             | 11 ++++++-----
 include/git2/odb.h                |  8 ++++----
 include/git2/refspec.h            |  2 +-
 include/git2/status.h             |  2 +-
 include/git2/submodule.h          |  4 ++--
 include/git2/tag.h                |  4 ++--
 include/git2/tree.h               |  2 +-
 src/attr.c                        | 14 +++++++-------
 src/attr_file.c                   | 14 +++++++-------
 src/branch.c                      |  2 +-
 src/commit.c                      |  6 +++---
 src/config.c                      | 16 ++++++++--------
 src/config_cache.c                |  2 +-
 src/config_file.c                 | 12 ++++++------
 src/crlf.c                        |  2 +-
 src/diff.c                        |  2 +-
 src/fileops.c                     | 10 +++++-----
 src/fileops.h                     |  6 +++---
 src/ignore.c                      |  2 +-
 src/index.c                       |  2 +-
 src/indexer.c                     |  8 ++++----
 src/iterator.c                    |  6 +++---
 src/notes.c                       | 10 +++++-----
 src/object.c                      |  6 +++---
 src/odb.c                         | 14 +++++++-------
 src/odb.h                         |  4 ++--
 src/odb_loose.c                   |  2 +-
 src/odb_pack.c                    | 10 +++++-----
 src/pack.c                        | 14 +++++++-------
 src/path.c                        |  4 ++--
 src/pkt.c                         |  4 ++--
 src/protocol.c                    |  2 +-
 src/refs.c                        |  8 ++++----
 src/refspec.c                     |  4 ++--
 src/remote.c                      |  8 ++++----
 src/repository.c                  | 10 +++++-----
 src/revwalk.c                     |  2 +-
 src/status.c                      |  2 +-
 src/submodule.c                   |  4 ++--
 src/tag.c                         |  8 ++++----
 src/transports/git.c              |  6 +++---
 src/transports/http.c             |  2 +-
 src/tree.c                        |  8 ++++----
 src/vector.c                      |  6 +++---
 tests-clar/config/write.c         |  4 ++--
 tests-clar/core/path.c            |  4 ++--
 tests-clar/core/vector.c          |  2 +-
 tests-clar/index/tests.c          |  2 +-
 tests-clar/network/remotes.c      |  2 +-
 tests-clar/notes/notes.c          |  2 +-
 tests-clar/object/lookup.c        |  8 ++++----
 tests-clar/object/tree/frompath.c |  4 ++--
 tests-clar/refs/branches/delete.c |  2 +-
 tests-clar/refs/branches/move.c   |  2 +-
 tests-clar/repo/discover.c        | 10 +++++-----
 tests-clar/repo/open.c            |  2 +-
 tests-clar/revwalk/mergebase.c    |  2 +-
 tests-clar/status/submodules.c    |  4 ++--
 tests-clar/status/worktree.c      |  8 ++++----
 61 files changed, 171 insertions(+), 170 deletions(-)

diff --git a/examples/diff.c b/examples/diff.c
index 3c44695cf..1b4ab549b 100644
--- a/examples/diff.c
+++ b/examples/diff.c
@@ -36,7 +36,7 @@ int resolve_to_tree(git_repository *repo, const char *identifier, git_tree **tre
 	}
 
 	if (obj == NULL)
-		return GIT_NOTFOUND;
+		return GIT_ENOTFOUND;
 
 	switch (git_object_type(obj)) {
 	case GIT_OBJ_TREE:
@@ -47,7 +47,7 @@ int resolve_to_tree(git_repository *repo, const char *identifier, git_tree **tre
 		git_object_free(obj);
 		break;
 	default:
-		err = GIT_NOTFOUND;
+		err = GIT_ENOTFOUND;
 	}
 
 	return err;
diff --git a/include/git2/branch.h b/include/git2/branch.h
index 5ffc7ddd5..e2432bcfc 100644
--- a/include/git2/branch.h
+++ b/include/git2/branch.h
@@ -63,7 +63,7 @@ GIT_EXTERN(int) git_branch_create(
  * @param branch_type Type of the considered branch. This should
  * be valued with either GIT_BRANCH_LOCAL or GIT_BRANCH_REMOTE.
  *
- * @return 0 on success, GIT_NOTFOUND if the branch
+ * @return 0 on success, GIT_ENOTFOUND if the branch
  * doesn't exist or an error code.
  */
 GIT_EXTERN(int) git_branch_delete(
@@ -108,7 +108,7 @@ GIT_EXTERN(int) git_branch_list(
  *
  * @param force Overwrite existing branch.
  *
- * @return 0 on success, GIT_NOTFOUND if the branch
+ * @return 0 on success, GIT_ENOTFOUND if the branch
  * doesn't exist or an error code.
  */
 GIT_EXTERN(int) git_branch_move(
diff --git a/include/git2/errors.h b/include/git2/errors.h
index 361c0aca0..fb6670004 100644
--- a/include/git2/errors.h
+++ b/include/git2/errors.h
@@ -58,12 +58,13 @@ enum {
 enum {
 	GIT_OK = 0,
 	GIT_ERROR = -1,
-	GIT_NOTFOUND = -3,
-	GIT_EXISTS = -23,
-	GIT_AMBIGUOUS = -29,
+	GIT_ENOTFOUND = -3,
+	GIT_EEXISTS = -4,
+	GIT_EAMBIGUOUS = -5,
+	GIT_EBUFS = -6,
+
 	GIT_PASSTHROUGH = -30,
-	GIT_SHORTBUFFER = -32,
-	GIT_REVWALKOVER = -33,
+	GIT_REVWALKOVER = -31,
 };
 
 typedef struct {
diff --git a/include/git2/odb.h b/include/git2/odb.h
index 6f448f657..1df193389 100644
--- a/include/git2/odb.h
+++ b/include/git2/odb.h
@@ -109,7 +109,7 @@ GIT_EXTERN(void) git_odb_free(git_odb *db);
  * @param id identity of the object to read.
  * @return
  * - 0 if the object was read;
- * - GIT_NOTFOUND if the object is not in the database.
+ * - GIT_ENOTFOUND if the object is not in the database.
  */
 GIT_EXTERN(int) git_odb_read(git_odb_object **out, git_odb *db, const git_oid *id);
 
@@ -136,8 +136,8 @@ GIT_EXTERN(int) git_odb_read(git_odb_object **out, git_odb *db, const git_oid *i
  * @param short_id a prefix of the id of the object to read.
  * @param len the length of the prefix
  * @return 0 if the object was read;
- *	GIT_NOTFOUND if the object is not in the database.
- *	GIT_AMBIGUOUS if the prefix is ambiguous (several objects match the prefix)
+ *	GIT_ENOTFOUND if the object is not in the database.
+ *	GIT_EAMBIGUOUS if the prefix is ambiguous (several objects match the prefix)
  */
 GIT_EXTERN(int) git_odb_read_prefix(git_odb_object **out, git_odb *db, const git_oid *short_id, unsigned int len);
 
@@ -157,7 +157,7 @@ GIT_EXTERN(int) git_odb_read_prefix(git_odb_object **out, git_odb *db, const git
  * @param id identity of the object to read.
  * @return
  * - 0 if the object was read;
- * - GIT_NOTFOUND if the object is not in the database.
+ * - GIT_ENOTFOUND if the object is not in the database.
  */
 GIT_EXTERN(int) git_odb_read_header(size_t *len_p, git_otype *type_p, git_odb *db, const git_oid *id);
 
diff --git a/include/git2/refspec.h b/include/git2/refspec.h
index c46c1876a..c0a8eabfe 100644
--- a/include/git2/refspec.h
+++ b/include/git2/refspec.h
@@ -51,7 +51,7 @@ GIT_EXTERN(int) git_refspec_src_matches(const git_refspec *refspec, const char *
  * @param outlen the size ouf the `out` buffer
  * @param spec the refspec
  * @param name the name of the reference to transform
- * @return 0, GIT_SHORTBUFFER or another error
+ * @return 0, GIT_EBUFS or another error
  */
 GIT_EXTERN(int) git_refspec_transform(char *out, size_t outlen, const git_refspec *spec, const char *name);
 
diff --git a/include/git2/status.h b/include/git2/status.h
index 080db9f3c..6a424dfd6 100644
--- a/include/git2/status.h
+++ b/include/git2/status.h
@@ -131,7 +131,7 @@ GIT_EXTERN(int) git_status_foreach_ext(
  * @param status_flags the status value
  * @param repo a repository object
  * @param path the file to retrieve status for, rooted at the repo's workdir
- * @return GIT_EINVALIDPATH when `path` points at a folder, GIT_NOTFOUND when
+ * @return GIT_EINVALIDPATH when `path` points at a folder, GIT_ENOTFOUND when
  *		the file doesn't exist in any of HEAD, the index or the worktree,
  *		0 otherwise
  */
diff --git a/include/git2/submodule.h b/include/git2/submodule.h
index 9e6118b98..930168275 100644
--- a/include/git2/submodule.h
+++ b/include/git2/submodule.h
@@ -85,13 +85,13 @@ GIT_EXTERN(int) git_submodule_foreach(
  *
  * Given either the submodule name or path (they are ususally the same),
  * this returns a structure describing the submodule.  If the submodule
- * does not exist, this will return GIT_NOTFOUND and set the submodule
+ * does not exist, this will return GIT_ENOTFOUND and set the submodule
  * pointer to NULL.
  *
  * @param submodule Pointer to submodule description object pointer..
  * @param repo The repository.
  * @param name The name of the submodule.  Trailing slashes will be ignored.
- * @return 0 on success, GIT_NOTFOUND if submodule does not exist, -1 on error
+ * @return 0 on success, GIT_ENOTFOUND if submodule does not exist, -1 on error
  */
 GIT_EXTERN(int) git_submodule_lookup(
 	git_submodule **submodule,
diff --git a/include/git2/tag.h b/include/git2/tag.h
index 7f318adf9..859c28995 100644
--- a/include/git2/tag.h
+++ b/include/git2/tag.h
@@ -143,7 +143,7 @@ GIT_EXTERN(const char *) git_tag_message(git_tag *tag);
  * @param oid Pointer where to store the OID of the
  * newly created tag. If the tag already exists, this parameter
  * will be the oid of the existing tag, and the function will
- * return a GIT_EXISTS error code.
+ * return a GIT_EEXISTS error code.
  *
  * @param repo Repository where to store the tag
  *
@@ -199,7 +199,7 @@ GIT_EXTERN(int) git_tag_create_frombuffer(
  * @param oid Pointer where to store the OID of the provided
  * target object. If the tag already exists, this parameter
  * will be filled with the oid of the existing pointed object
- * and the function will return a GIT_EXISTS error code.
+ * and the function will return a GIT_EEXISTS error code.
  *
  * @param repo Repository where to store the lightweight tag
  *
diff --git a/include/git2/tree.h b/include/git2/tree.h
index 3b3b0e2f8..777f8ff0d 100644
--- a/include/git2/tree.h
+++ b/include/git2/tree.h
@@ -278,7 +278,7 @@ GIT_EXTERN(int) git_treebuilder_write(git_oid *oid, git_repository *repo, git_tr
  * @param subtree Pointer where to store the subtree
  * @param root A previously loaded tree which will be the root of the relative path
  * @param subtree_path Path to the contained subtree
- * @return 0 on success; GIT_NOTFOUND if the path does not lead to a subtree
+ * @return 0 on success; GIT_ENOTFOUND if the path does not lead to a subtree
  */
 GIT_EXTERN(int) git_tree_get_subtree(git_tree **subtree, git_tree *root, const char *subtree_path);
 
diff --git a/src/attr.c b/src/attr.c
index 5fef91427..093f64d5c 100644
--- a/src/attr.c
+++ b/src/attr.c
@@ -245,13 +245,13 @@ static int load_attr_file(
 	struct stat st;
 
 	if (p_stat(filename, &st) < 0)
-		return GIT_NOTFOUND;
+		return GIT_ENOTFOUND;
 
 	if (sig != NULL &&
 		(git_time_t)st.st_mtime == sig->seconds &&
 		(git_off_t)st.st_size == sig->size &&
 		(unsigned int)st.st_ino == sig->ino)
-		return GIT_NOTFOUND;
+		return GIT_ENOTFOUND;
 
 	error = git_futils_readbuffer_updated(&content, filename, NULL, NULL);
 	if (error < 0)
@@ -286,7 +286,7 @@ static int load_attr_blob_from_index(
 	entry = git_index_get(index, error);
 
 	if (old_oid && git_oid_cmp(old_oid, &entry->oid) == 0)
-		return GIT_NOTFOUND;
+		return GIT_ENOTFOUND;
 
 	if ((error = git_blob_lookup(blob, repo, &entry->oid)) < 0)
 		return error;
@@ -396,7 +396,7 @@ int git_attr_cache__push_file(
 
 	if (error) {
 		/* not finding a file is not an error for this function */
-		if (error == GIT_NOTFOUND) {
+		if (error == GIT_ENOTFOUND) {
 			giterr_clear();
 			error = 0;
 		}
@@ -550,7 +550,7 @@ static int collect_attr_files(
 		error = git_futils_find_system_file(&dir, GIT_ATTR_FILE_SYSTEM);
 		if (!error)
 			error = push_attr_file(repo, files, NULL, dir.ptr);
-		else if (error == GIT_NOTFOUND)
+		else if (error == GIT_ENOTFOUND)
 			error = 0;
 	}
 
@@ -577,11 +577,11 @@ int git_attr_cache__init(git_repository *repo)
 		return -1;
 
 	ret = git_config_get_string(&cache->cfg_attr_file, cfg, GIT_ATTR_CONFIG);
-	if (ret < 0 && ret != GIT_NOTFOUND)
+	if (ret < 0 && ret != GIT_ENOTFOUND)
 		return ret;
 
 	ret = git_config_get_string(&cache->cfg_excl_file, cfg, GIT_IGNORE_CONFIG);
-	if (ret < 0 && ret != GIT_NOTFOUND)
+	if (ret < 0 && ret != GIT_ENOTFOUND)
 		return ret;
 
 	giterr_clear();
diff --git a/src/attr_file.c b/src/attr_file.c
index 601b286cf..5030ad5de 100644
--- a/src/attr_file.c
+++ b/src/attr_file.c
@@ -99,7 +99,7 @@ int git_attr_file__parse_buffer(
 		/* if the rule wasn't a pattern, on to the next */
 		if (error < 0) {
 			git_attr_rule__clear(rule); /* reset rule contents */
-			if (error == GIT_NOTFOUND)
+			if (error == GIT_ENOTFOUND)
 				error = 0;
 		} else {
 			rule = NULL; /* vector now "owns" the rule */
@@ -328,7 +328,7 @@ void git_attr_path__free(git_attr_path *info)
 
 /*
  * This will return 0 if the spec was filled out,
- * GIT_NOTFOUND if the fnmatch does not require matching, or
+ * GIT_ENOTFOUND if the fnmatch does not require matching, or
  * another error code there was an actual problem.
  */
 int git_attr_fnmatch__parse(
@@ -347,7 +347,7 @@ int git_attr_fnmatch__parse(
 	while (git__isspace(*pattern)) pattern++;
 	if (!*pattern || *pattern == '#') {
 		*base = git__next_line(pattern);
-		return GIT_NOTFOUND;
+		return GIT_ENOTFOUND;
 	}
 
 	spec->flags = 0;
@@ -464,7 +464,7 @@ static int merge_assignments(void **old_raw, void *new_raw)
 
 	GIT_REFCOUNT_DEC(*old, git_attr_assignment__free);
 	*old = new;
-	return GIT_EXISTS;
+	return GIT_EEXISTS;
 }
 
 int git_attr_assignment__parse(
@@ -551,7 +551,7 @@ int git_attr_assignment__parse(
 
 					error = git_vector_insert_sorted(
 						assigns, massign, &merge_assignments);
-					if (error < 0 && error != GIT_EXISTS)
+					if (error < 0 && error != GIT_EEXISTS)
 						return error;
 				}
 			}
@@ -559,7 +559,7 @@ int git_attr_assignment__parse(
 
 		/* insert allocated assign into vector */
 		error = git_vector_insert_sorted(assigns, assign, &merge_assignments);
-		if (error < 0 && error != GIT_EXISTS)
+		if (error < 0 && error != GIT_EEXISTS)
 			return error;
 
 		/* clear assign since it is now "owned" by the vector */
@@ -571,7 +571,7 @@ int git_attr_assignment__parse(
 
 	*base = git__next_line(scan);
 
-	return (assigns->length == 0) ? GIT_NOTFOUND : 0;
+	return (assigns->length == 0) ? GIT_ENOTFOUND : 0;
 }
 
 static void git_attr_rule__clear(git_attr_rule *rule)
diff --git a/src/branch.c b/src/branch.c
index 45f67ffdc..9698bbf56 100644
--- a/src/branch.c
+++ b/src/branch.c
@@ -190,7 +190,7 @@ int git_branch_move(git_repository *repo, const char *old_branch_name, const cha
 	if ((error = git_buf_joinpath(&old_reference_name, GIT_REFS_HEADS_DIR, old_branch_name)) < 0)
 		goto cleanup;
 
-	/* We need to be able to return GIT_NOTFOUND */
+	/* We need to be able to return GIT_ENOTFOUND */
 	if ((error = git_reference_lookup(&reference, repo, git_buf_cstr(&old_reference_name))) < 0)
 		goto cleanup;
 
diff --git a/src/commit.c b/src/commit.c
index 1c6bee97a..2bf12f3a5 100644
--- a/src/commit.c
+++ b/src/commit.c
@@ -100,7 +100,7 @@ static int update_reference(git_repository *repo, git_oid *oid, const char *ref_
 
 	/* If we haven't found the reference at all, we assume we need to create
 	 * a new reference and that's it */
-	if (res == GIT_NOTFOUND) {
+	if (res == GIT_ENOTFOUND) {
 		giterr_clear();
 		return git_reference_create_oid(NULL, repo, ref_name, oid, 1);
 	}
@@ -125,7 +125,7 @@ static int update_reference(git_repository *repo, git_oid *oid, const char *ref_
 		 * this is means we're creating a new branch, for example.
 		 * We need to create a new direct reference with that name
 		 */
-		if (res == GIT_NOTFOUND) {
+		if (res == GIT_ENOTFOUND) {
 			giterr_clear();
 			res = git_reference_create_oid(NULL, repo, sym_target, oid, 1);
 			git_reference_free(ref);
@@ -320,7 +320,7 @@ int git_commit_parent(git_commit **parent, git_commit *commit, unsigned int n)
 	parent_oid = git_vector_get(&commit->parent_oids, n);
 	if (parent_oid == NULL) {
 		giterr_set(GITERR_INVALID, "Parent %u does not exist", n);
-		return GIT_NOTFOUND;
+		return GIT_ENOTFOUND;
 	}
 
 	return git_commit_lookup(parent, commit->object.repo, parent_oid);
diff --git a/src/config.c b/src/config.c
index b60faf820..618202c34 100644
--- a/src/config.c
+++ b/src/config.c
@@ -263,7 +263,7 @@ int git_config_lookup_map_value(
 	size_t i;
 
 	if (!value)
-		return GIT_NOTFOUND;
+		return GIT_ENOTFOUND;
 
 	for (i = 0; i < map_n; ++i) {
 		git_cvar_map *m = maps + i;
@@ -295,7 +295,7 @@ int git_config_lookup_map_value(
 		}
 	}
 
-	return GIT_NOTFOUND;
+	return GIT_ENOTFOUND;
 }
 
 int git_config_get_mapped(
@@ -387,12 +387,12 @@ int git_config_get_string(const char **out, git_config *cfg, const char *name)
 	git_vector_foreach(&cfg->files, i, internal) {
 		git_config_file *file = internal->file;
 		int ret = file->get(file, name, out);
-		if (ret != GIT_NOTFOUND)
+		if (ret != GIT_ENOTFOUND)
 			return ret;
 	}
 
 	giterr_set(GITERR_CONFIG, "Config variable '%s' not found", name);
-	return GIT_NOTFOUND;
+	return GIT_ENOTFOUND;
 }
 
 int git_config_get_multivar(git_config *cfg, const char *name, const char *regexp,
@@ -400,7 +400,7 @@ int git_config_get_multivar(git_config *cfg, const char *name, const char *regex
 {
 	file_internal *internal;
 	git_config_file *file;
-	int ret = GIT_NOTFOUND;
+	int ret = GIT_ENOTFOUND;
 	unsigned int i;
 
 	assert(cfg->files.length);
@@ -413,7 +413,7 @@ int git_config_get_multivar(git_config *cfg, const char *name, const char *regex
 		internal = git_vector_get(&cfg->files, i - 1);
 		file = internal->file;
 		ret = file->get_multivar(file, name, regexp, fn, data);
-		if (ret < 0 && ret != GIT_NOTFOUND)
+		if (ret < 0 && ret != GIT_ENOTFOUND)
 			return ret;
 	}
 
@@ -424,14 +424,14 @@ int git_config_set_multivar(git_config *cfg, const char *name, const char *regex
 {
 	file_internal *internal;
 	git_config_file *file;
-	int ret = GIT_NOTFOUND;
+	int ret = GIT_ENOTFOUND;
 	unsigned int i;
 
 	for (i = cfg->files.length; i > 0; --i) {
 		internal = git_vector_get(&cfg->files, i - 1);
 		file = internal->file;
 		ret = file->set_multivar(file, name, regexp, value);
-		if (ret < 0 && ret != GIT_NOTFOUND)
+		if (ret < 0 && ret != GIT_ENOTFOUND)
 			return ret;
 	}
 
diff --git a/src/config_cache.c b/src/config_cache.c
index b23fd7b31..ca9602e56 100644
--- a/src/config_cache.c
+++ b/src/config_cache.c
@@ -72,7 +72,7 @@ int git_repository__cvar(int *out, git_repository *repo, git_cvar_cached cvar)
 		error = git_config_get_mapped(out,
 			config, data->cvar_name, data->maps, data->map_count);
 
-		if (error == GIT_NOTFOUND)
+		if (error == GIT_ENOTFOUND)
 			*out = data->default_value;
 
 		else if (error < 0)
diff --git a/src/config_file.c b/src/config_file.c
index 6ecc974ff..cbc48bcd9 100644
--- a/src/config_file.c
+++ b/src/config_file.c
@@ -161,7 +161,7 @@ static int config_open(git_config_file *cfg)
 	res = git_futils_readbuffer(&b->reader.buffer, b->file_path);
 
 	/* It's fine if the file doesn't exist */
-	if (res == GIT_NOTFOUND)
+	if (res == GIT_ENOTFOUND)
 		return 0;
 
 	if (res < 0 || config_parse(b) <  0) {
@@ -289,7 +289,7 @@ static int config_get(git_config_file *cfg, const char *name, const char **out)
 
 	/* no error message; the config system will write one */
 	if (!git_strmap_valid_index(b->values, pos))
-		return GIT_NOTFOUND;
+		return GIT_ENOTFOUND;
 
 	*out = ((cvar_t *)git_strmap_value_at(b->values, pos))->value;
 
@@ -315,7 +315,7 @@ static int config_get_multivar(
 	git__free(key);
 
 	if (!git_strmap_valid_index(b->values, pos))
-		return GIT_NOTFOUND;
+		return GIT_ENOTFOUND;
 
 	var = git_strmap_value_at(b->values, pos);
 
@@ -377,7 +377,7 @@ static int config_set_multivar(
 	pos = git_strmap_lookup_index(b->values, key);
 	if (!git_strmap_valid_index(b->values, pos)) {
 		git__free(key);
-		return GIT_NOTFOUND;
+		return GIT_ENOTFOUND;
 	}
 
 	var = git_strmap_value_at(b->values, pos);
@@ -444,7 +444,7 @@ static int config_delete(git_config_file *cfg, const char *name)
 	git__free(key);
 
 	if (!git_strmap_valid_index(b->values, pos))
-		return GIT_NOTFOUND;
+		return GIT_ENOTFOUND;
 
 	var = git_strmap_value_at(b->values, pos);
 
@@ -978,7 +978,7 @@ static int config_write(diskfile_backend *cfg, const char *key, const regex_t *p
 	result = git_futils_readbuffer(&cfg->reader.buffer, cfg->file_path);
 
 	/* Initialise the reading position */
-	if (result == GIT_NOTFOUND) {
+	if (result == GIT_ENOTFOUND) {
 		cfg->reader.read_ptr = NULL;
 		cfg->reader.eof = 1;
 		data_start = NULL;
diff --git a/src/crlf.c b/src/crlf.c
index 5fb1be516..303a46d3b 100644
--- a/src/crlf.c
+++ b/src/crlf.c
@@ -85,7 +85,7 @@ static int crlf_load_attributes(struct crlf_attrs *ca, git_repository *repo, con
 	error = git_attr_get_many(attr_vals,
 		repo, 0, path, NUM_CONV_ATTRS, attr_names);
 
-	if (error == GIT_NOTFOUND) {
+	if (error == GIT_ENOTFOUND) {
 		ca->crlf_action = GIT_CRLF_GUESS;
 		ca->eol = GIT_EOL_UNSET;
 		return 0;
diff --git a/src/diff.c b/src/diff.c
index 882534f72..0b2f8fb50 100644
--- a/src/diff.c
+++ b/src/diff.c
@@ -343,7 +343,7 @@ static git_diff_list *git_diff_list_alloc(
 		if (!match)
 			goto fail;
 		ret = git_attr_fnmatch__parse(match, &diff->pool, NULL, &pattern);
-		if (ret == GIT_NOTFOUND) {
+		if (ret == GIT_ENOTFOUND) {
 			git__free(match);
 			continue;
 		} else if (ret < 0)
diff --git a/src/fileops.c b/src/fileops.c
index c467143e4..ee9d4212d 100644
--- a/src/fileops.c
+++ b/src/fileops.c
@@ -95,7 +95,7 @@ int git_futils_open_ro(const char *path)
 	int fd = p_open(path, O_RDONLY);
 	if (fd < 0) {
 		if (errno == ENOENT)
-			fd = GIT_NOTFOUND;
+			fd = GIT_ENOTFOUND;
 		giterr_set(GITERR_OS, "Failed to open '%s'", path);
 	}
 	return fd;
@@ -365,7 +365,7 @@ int git_futils_find_global_file(git_buf *path, const char *filename)
 
 	if (git_path_exists(path->ptr) == false) {
 		git_buf_clear(path);
-		return GIT_NOTFOUND;
+		return GIT_ENOTFOUND;
 	}
 
 	return 0;
@@ -414,7 +414,7 @@ static int win32_find_system_file(git_buf *path, const char *filename)
 	char *file_utf8 = NULL;
 
 	if (!root || !filename || (len = strlen(filename)) == 0)
-		return GIT_NOTFOUND;
+		return GIT_ENOTFOUND;
 
 	/* allocate space for wchar_t path to file */
 	file_utf16 = git__calloc(root->len + len + 2, sizeof(wchar_t));
@@ -438,7 +438,7 @@ static int win32_find_system_file(git_buf *path, const char *filename)
 
 	/* check access */
 	if (_waccess(file_utf16, F_OK) < 0) {
-		error = GIT_NOTFOUND;
+		error = GIT_ENOTFOUND;
 		goto cleanup;
 	}
 
@@ -470,6 +470,6 @@ int git_futils_find_system_file(git_buf *path, const char *filename)
 #ifdef GIT_WIN32
 	return win32_find_system_file(path, filename);
 #else
-	return GIT_NOTFOUND;
+	return GIT_ENOTFOUND;
 #endif
 }
diff --git a/src/fileops.h b/src/fileops.h
index 8dd4bb61a..be619d620 100644
--- a/src/fileops.h
+++ b/src/fileops.h
@@ -139,7 +139,7 @@ extern int git_futils_mmap_ro(
  * @param path path to file to be opened.
  * @return
  * - 0 on success;
- * - GIT_NOTFOUND if not found;
+ * - GIT_ENOTFOUND if not found;
  * - -1 on an unspecified OS related error.
  */
 extern int git_futils_mmap_ro_file(
@@ -159,7 +159,7 @@ extern void git_futils_mmap_free(git_map *map);
  * @param filename name of file to find in the home directory
  * @return
  * - 0 if found;
- * - GIT_NOTFOUND if not found;
+ * - GIT_ENOTFOUND if not found;
  * - -1 on an unspecified OS related error.
  */
 extern int git_futils_find_global_file(git_buf *path, const char *filename);
@@ -171,7 +171,7 @@ extern int git_futils_find_global_file(git_buf *path, const char *filename);
  * @param filename name of file to find in the home directory
  * @return
  * - 0 if found;
- * - GIT_NOTFOUND if not found;
+ * - GIT_ENOTFOUND if not found;
  * - -1 on an unspecified OS related error.
  */
 extern int git_futils_find_system_file(git_buf *path, const char *filename);
diff --git a/src/ignore.c b/src/ignore.c
index 2a7060501..fc6194bb5 100644
--- a/src/ignore.c
+++ b/src/ignore.c
@@ -40,7 +40,7 @@ static int parse_ignore_file(
 			git__free(match->pattern);
 			match->pattern = NULL;
 
-			if (error == GIT_NOTFOUND)
+			if (error == GIT_ENOTFOUND)
 				error = 0;
 		} else {
 			match = NULL; /* vector now "owns" the match */
diff --git a/src/index.c b/src/index.c
index 03b191356..f1ae9a710 100644
--- a/src/index.c
+++ b/src/index.c
@@ -411,7 +411,7 @@ static int index_insert(git_index *index, git_index_entry *entry, int replace)
 	 * if no entry exists add the entry at the end;
 	 * the index is no longer sorted
 	 */
-	if (position == GIT_NOTFOUND)
+	if (position == GIT_ENOTFOUND)
 		return git_vector_insert(&index->entries, entry);
 
 	/* exists, replace it */
diff --git a/src/indexer.c b/src/indexer.c
index da6d5d2c8..6f735e651 100644
--- a/src/indexer.c
+++ b/src/indexer.c
@@ -205,9 +205,9 @@ static int store_delta(git_indexer_stream *idx)
 	}
 
 	error = packfile_unpack_compressed(&obj, idx->pack, &w, &idx->off, entry_size, type);
-	if (error == GIT_SHORTBUFFER) {
+	if (error == GIT_EBUFS) {
 		idx->off = entry_start;
-		return GIT_SHORTBUFFER;
+		return GIT_EBUFS;
 	} else if (error < 0){
 		return -1;
 	}
@@ -355,7 +355,7 @@ int git_indexer_stream_add(git_indexer_stream *idx, const void *data, size_t siz
 			return 0;
 
 		error = git_packfile_unpack(&obj, idx->pack, &idx->off);
-		if (error == GIT_SHORTBUFFER) {
+		if (error == GIT_EBUFS) {
 			idx->off = entry_start;
 			return 0;
 		}
@@ -363,7 +363,7 @@ int git_indexer_stream_add(git_indexer_stream *idx, const void *data, size_t siz
 		if (error < 0) {
 			idx->off = entry_start;
 			error = store_delta(idx);
-			if (error == GIT_SHORTBUFFER)
+			if (error == GIT_EBUFS)
 				return 0;
 			if (error < 0)
 				return error;
diff --git a/src/iterator.c b/src/iterator.c
index cb9838dbc..819b0e22a 100644
--- a/src/iterator.c
+++ b/src/iterator.c
@@ -468,7 +468,7 @@ static int workdir_iterator__expand_dir(workdir_iterator *wi)
 	error = git_path_dirload_with_stat(wi->path.ptr, wi->root_len, &wf->entries);
 	if (error < 0 || wf->entries.length == 0) {
 		workdir_iterator__free_frame(wf);
-		return GIT_NOTFOUND;
+		return GIT_ENOTFOUND;
 	}
 
 	git_vector_sort(&wf->entries);
@@ -635,7 +635,7 @@ static int workdir_iterator__update_entry(workdir_iterator *wi)
 		if (!is_submodule) {
 			int res = git_submodule_lookup(NULL, wi->repo, wi->entry.path);
 			is_submodule = (res == 0);
-			if (res == GIT_NOTFOUND)
+			if (res == GIT_ENOTFOUND)
 				giterr_clear();
 		}
 
@@ -683,7 +683,7 @@ int git_iterator_for_workdir_range(
 	wi->root_len = wi->path.size;
 
 	if ((error = workdir_iterator__expand_dir(wi)) < 0) {
-		if (error == GIT_NOTFOUND)
+		if (error == GIT_ENOTFOUND)
 			error = 0;
 		else {
 			git_iterator_free((git_iterator *)wi);
diff --git a/src/notes.c b/src/notes.c
index afd6fc23d..84ad94087 100644
--- a/src/notes.c
+++ b/src/notes.c
@@ -73,7 +73,7 @@ static int find_blob(git_oid *blob, git_tree *tree, const char *target)
 			return 0;
 		}
 	}
-	return GIT_NOTFOUND;
+	return GIT_ENOTFOUND;
 }
 
 static int note_write(git_oid *out, git_repository *repo,
@@ -96,11 +96,11 @@ static int note_write(git_oid *out, git_repository *repo,
 			return error;
 
 		error = find_blob(&oid, tree, target + fanout);
-		if (error != GIT_NOTFOUND) {
+		if (error != GIT_ENOTFOUND) {
 			git_tree_free(tree);
 			if (!error) {
 				giterr_set(GITERR_REPOSITORY, "Note for '%s' exists already", target);
-				error = GIT_EXISTS;
+				error = GIT_EEXISTS;
 			}
 			return error;
 		}
@@ -275,7 +275,7 @@ static int note_get_default_ref(const char **out, git_repository *repo)
 		return -1;
 
 	ret = git_config_get_string(out, cfg, "core.notesRef");
-	if (ret == GIT_NOTFOUND) {
+	if (ret == GIT_ENOTFOUND) {
 		*out = GIT_NOTES_DEFAULT_REF;
 		return 0;
 	}
@@ -352,7 +352,7 @@ int git_note_create(
 		return -1;
 
 	error = git_reference_lookup(&ref, repo, notes_ref);
-	if (error < 0 && error != GIT_NOTFOUND)
+	if (error < 0 && error != GIT_ENOTFOUND)
 		return error;
 
 	if (!error) {
diff --git a/src/object.c b/src/object.c
index 0c40c05c2..d3673eda0 100644
--- a/src/object.c
+++ b/src/object.c
@@ -92,7 +92,7 @@ int git_object_lookup_prefix(
 	assert(repo && object_out && id);
 
 	if (len < GIT_OID_MINPREFIXLEN)
-		return GIT_AMBIGUOUS;
+		return GIT_EAMBIGUOUS;
 
 	error = git_repository_odb__weakptr(&odb, repo);
 	if (error < 0)
@@ -110,7 +110,7 @@ int git_object_lookup_prefix(
 			if (type != GIT_OBJ_ANY && type != object->type) {
 				git_object_free(object);
 				giterr_set(GITERR_ODB, "The given type does not match the type in ODB");
-				return GIT_NOTFOUND;
+				return GIT_ENOTFOUND;
 			}
 
 			*object_out = object;
@@ -151,7 +151,7 @@ int git_object_lookup_prefix(
 	if (type != GIT_OBJ_ANY && type != odb_obj->raw.type) {
 		git_odb_object_free(odb_obj);
 		giterr_set(GITERR_ODB, "The given type does not match the type on the ODB");
-		return GIT_NOTFOUND;
+		return GIT_ENOTFOUND;
 	}
 
 	type = odb_obj->raw.type;
diff --git a/src/odb.c b/src/odb.c
index dcb36e296..a6a18f831 100644
--- a/src/odb.c
+++ b/src/odb.c
@@ -485,7 +485,7 @@ int git_odb_exists(git_odb *db, const git_oid *id)
 int git_odb_read_header(size_t *len_p, git_otype *type_p, git_odb *db, const git_oid *id)
 {
 	unsigned int i;
-	int error = GIT_NOTFOUND;
+	int error = GIT_ENOTFOUND;
 	git_odb_object *object;
 
 	assert(db && id);
@@ -524,7 +524,7 @@ int git_odb_read_header(size_t *len_p, git_otype *type_p, git_odb *db, const git
 int git_odb_read(git_odb_object **out, git_odb *db, const git_oid *id)
 {
 	unsigned int i;
-	int error = GIT_NOTFOUND;
+	int error = GIT_ENOTFOUND;
 	git_rawobj raw;
 
 	assert(out && db && id);
@@ -541,7 +541,7 @@ int git_odb_read(git_odb_object **out, git_odb *db, const git_oid *id)
 			error = b->read(&raw.data, &raw.len, &raw.type, b, id);
 	}
 
-	/* TODO: If no backends are configured, this returns GIT_NOTFOUND but
+	/* TODO: If no backends are configured, this returns GIT_ENOTFOUND but
 	 * will never have called giterr_set().
 	 */
 
@@ -556,7 +556,7 @@ int git_odb_read_prefix(
 	git_odb_object **out, git_odb *db, const git_oid *short_id, unsigned int len)
 {
 	unsigned int i;
-	int error = GIT_NOTFOUND;
+	int error = GIT_ENOTFOUND;
 	git_oid found_full_oid = {{0}};
 	git_rawobj raw;
 	bool found = false;
@@ -582,7 +582,7 @@ int git_odb_read_prefix(
 		if (b->read != NULL) {
 			git_oid full_oid;
 			error = b->read_prefix(&full_oid, &raw.data, &raw.len, &raw.type, b, short_id, len);
-			if (error == GIT_NOTFOUND || error == GIT_PASSTHROUGH)
+			if (error == GIT_ENOTFOUND || error == GIT_PASSTHROUGH)
 				continue;
 
 			if (error)
@@ -698,12 +698,12 @@ int git_odb__error_notfound(const char *message, const git_oid *oid)
 	} else
 		giterr_set(GITERR_ODB, "Object not found - %s", message);
 
-	return GIT_NOTFOUND;
+	return GIT_ENOTFOUND;
 }
 
 int git_odb__error_ambiguous(const char *message)
 {
 	giterr_set(GITERR_ODB, "Ambiguous SHA1 prefix - %s", message);
-	return GIT_AMBIGUOUS;
+	return GIT_EAMBIGUOUS;
 }
 
diff --git a/src/odb.h b/src/odb.h
index 2a5c76949..263e4c30b 100644
--- a/src/odb.h
+++ b/src/odb.h
@@ -68,12 +68,12 @@ int git_odb__hashfd(git_oid *out, git_file fd, size_t size, git_otype type);
 int git_odb__hashlink(git_oid *out, const char *path);
 
 /*
- * Generate a GIT_NOTFOUND error for the ODB.
+ * Generate a GIT_ENOTFOUND error for the ODB.
  */
 int git_odb__error_notfound(const char *message, const git_oid *oid);
 
 /*
- * Generate a GIT_AMBIGUOUS error for the ODB.
+ * Generate a GIT_EAMBIGUOUS error for the ODB.
  */
 int git_odb__error_ambiguous(const char *message);
 
diff --git a/src/odb_loose.c b/src/odb_loose.c
index c229b544e..989b03ab2 100644
--- a/src/odb_loose.c
+++ b/src/odb_loose.c
@@ -460,7 +460,7 @@ static int locate_object(
 	int error = object_file_name(object_location, backend->objects_dir, oid);
 
 	if (!error && !git_path_exists(object_location->ptr))
-		return GIT_NOTFOUND;
+		return GIT_ENOTFOUND;
 
 	return error;
 }
diff --git a/src/odb_pack.c b/src/odb_pack.c
index e03879ee2..458f288d9 100644
--- a/src/odb_pack.c
+++ b/src/odb_pack.c
@@ -141,7 +141,7 @@ static int pack_entry_find(struct git_pack_entry *e,
 
 /* Can find the offset of an object given
  * a prefix of an identifier.
- * Sets GIT_AMBIGUOUS if short oid is ambiguous.
+ * Sets GIT_EAMBIGUOUS if short oid is ambiguous.
  * This method assumes that len is between
  * GIT_OID_MINPREFIXLEN and GIT_OID_HEXSZ.
  */
@@ -224,7 +224,7 @@ static int packfile_load__cb(void *_data, git_buf *path)
 	}
 
 	error = git_packfile_check(&pack, path->ptr);
-	if (error == GIT_NOTFOUND)
+	if (error == GIT_ENOTFOUND)
 		/* ignore missing .pack file as git does */
 		return 0;
 	else if (error < 0)
@@ -306,7 +306,7 @@ static int pack_entry_find_prefix(
 
 	if (backend->last_found) {
 		error = git_pack_entry_find(e, backend->last_found, short_oid, len);
-		if (error == GIT_AMBIGUOUS)
+		if (error == GIT_EAMBIGUOUS)
 			return error;
 		if (!error)
 			found = 1;
@@ -320,7 +320,7 @@ static int pack_entry_find_prefix(
 			continue;
 
 		error = git_pack_entry_find(e, p, short_oid, len);
-		if (error == GIT_AMBIGUOUS)
+		if (error == GIT_EAMBIGUOUS)
 			return error;
 		if (!error) {
 			if (++found > 1)
@@ -354,7 +354,7 @@ int pack_backend__read_header(git_rawobj *obj, git_odb_backend *backend, const g
 	assert(obj && backend && oid);
 
 	if (locate_packfile(&location, (struct pack_backend *)backend, oid) < 0)
-		return GIT_NOTFOUND;
+		return GIT_ENOTFOUND;
 
 	return read_header_packed(obj, &location);
 }
diff --git a/src/pack.c b/src/pack.c
index 66a23f295..0db1069de 100644
--- a/src/pack.c
+++ b/src/pack.c
@@ -28,7 +28,7 @@ int packfile_unpack_compressed(
 
 /* Can find the offset of an object given
  * a prefix of an identifier.
- * Throws GIT_AMBIGUOUSOIDPREFIX if short oid
+ * Throws GIT_EAMBIGUOUSOIDPREFIX if short oid
  * is ambiguous within the pack.
  * This method assumes that len is between
  * GIT_OID_MINPREFIXLEN and GIT_OID_HEXSZ.
@@ -222,7 +222,7 @@ static int packfile_unpack_header1(
 	shift = 4;
 	while (c & 0x80) {
 		if (len <= used)
-			return GIT_SHORTBUFFER;
+			return GIT_EBUFS;
 
 		if (bitsizeof(long) <= shift) {
 			*usedp = 0;
@@ -260,11 +260,11 @@ int git_packfile_unpack_header(
 //	base = pack_window_open(p, w_curs, *curpos, &left);
 	base = git_mwindow_open(mwf, w_curs, *curpos, 20, &left);
 	if (base == NULL)
-		return GIT_SHORTBUFFER;
+		return GIT_EBUFS;
 
 	ret = packfile_unpack_header1(&used, size_p, type_p, base, left);
 	git_mwindow_close(w_curs);
-	if (ret == GIT_SHORTBUFFER)
+	if (ret == GIT_EBUFS)
 		return ret;
 	else if (ret < 0)
 		return packfile_error("header length is zero");
@@ -428,7 +428,7 @@ int packfile_unpack_compressed(
 		if (st == Z_BUF_ERROR && in == NULL) {
 			inflateEnd(&stream);
 			git__free(buffer);
-			return GIT_SHORTBUFFER;
+			return GIT_EBUFS;
 		}
 
 		*curpos += stream.next_in - in;
@@ -467,7 +467,7 @@ git_off_t get_delta_base(
 	base_info = pack_window_open(p, w_curs, *curpos, &left);
 	/* Assumption: the only reason this would fail is because the file is too small */
 	if (base_info == NULL)
-		return GIT_SHORTBUFFER;
+		return GIT_EBUFS;
 	/* pack_window_open() assured us we have [base_info, base_info + 20)
 	 * as a range that we can look at without walking off the
 	 * end of the mapped window. Its actually the hash size
@@ -480,7 +480,7 @@ git_off_t get_delta_base(
 		base_offset = c & 127;
 		while (c & 128) {
 			if (left <= used)
-				return GIT_SHORTBUFFER;
+				return GIT_EBUFS;
 			base_offset += 1;
 			if (!base_offset || MSB(base_offset, 7))
 				return 0; /* overflow */
diff --git a/src/path.c b/src/path.c
index ba67544de..84edf6d89 100644
--- a/src/path.c
+++ b/src/path.c
@@ -206,7 +206,7 @@ int git_path_prettify(git_buf *path_out, const char *path, const char *base)
 
 	if (p_realpath(path, buf) == NULL) {
 		/* giterr_set resets the errno when dealing with a GITERR_OS kind of error */
-		int error = (errno == ENOENT || errno == ENOTDIR) ? GIT_NOTFOUND : -1;
+		int error = (errno == ENOENT || errno == ENOTDIR) ? GIT_ENOTFOUND : -1;
 		giterr_set(GITERR_OS, "Failed to resolve path '%s'", path);
 
 		git_buf_clear(path_out);
@@ -390,7 +390,7 @@ int git_path_lstat(const char *path, struct stat *st)
 	int err = 0;
 
 	if (p_lstat(path, st) < 0) {
-		err = (errno == ENOENT) ? GIT_NOTFOUND : -1;
+		err = (errno == ENOENT) ? GIT_ENOTFOUND : -1;
 		giterr_set(GITERR_OS, "Failed to stat file '%s'", path);
 	}
 
diff --git a/src/pkt.c b/src/pkt.c
index 895644638..95430ddfc 100644
--- a/src/pkt.c
+++ b/src/pkt.c
@@ -208,7 +208,7 @@ int git_pkt_parse_line(
 
 	/* Not even enough for the length */
 	if (bufflen > 0 && bufflen < PKT_LEN_SIZE)
-		return GIT_SHORTBUFFER;
+		return GIT_EBUFS;
 
 	len = parse_len(line);
 	if (len < 0) {
@@ -230,7 +230,7 @@ int git_pkt_parse_line(
 	 * enough in the buffer to satisfy this line
 	 */
 	if (bufflen > 0 && bufflen < (size_t)len)
-		return GIT_SHORTBUFFER;
+		return GIT_EBUFS;
 
 	line += PKT_LEN_SIZE;
 	/*
diff --git a/src/protocol.c b/src/protocol.c
index 184903388..6b3861796 100644
--- a/src/protocol.c
+++ b/src/protocol.c
@@ -34,7 +34,7 @@ int git_protocol_store_refs(git_protocol *p, const char *data, size_t len)
 			return 0;
 
 		error = git_pkt_parse_line(&pkt, ptr, &line_end, git_buf_len(buf));
-		if (error == GIT_SHORTBUFFER)
+		if (error == GIT_EBUFS)
 			return 0; /* Ask for more */
 		if (error < 0)
 			return p->error = -1;
diff --git a/src/refs.c b/src/refs.c
index 88e2218d1..1ef3e13a4 100644
--- a/src/refs.c
+++ b/src/refs.c
@@ -437,7 +437,7 @@ static int packed_load(git_repository *repo)
 	 * for us here, so just return. Anything else means we need to
 	 * refresh the packed refs.
 	 */
-	if (result == GIT_NOTFOUND) {
+	if (result == GIT_ENOTFOUND) {
 		git_strmap_clear(ref_cache->packfile);
 		return 0;
 	}
@@ -917,7 +917,7 @@ static int reference_can_write(
 		if (exists) {
 			giterr_set(GITERR_REFERENCE,
 				"A reference with that name (%s) already exists", refname);
-			return GIT_EXISTS;
+			return GIT_EEXISTS;
 		}
 	}
 
@@ -962,7 +962,7 @@ static int packed_lookup(git_reference *ref)
 	pos = git_strmap_lookup_index(packfile_refs, ref->name);
 	if (!git_strmap_valid_index(packfile_refs, pos)) {
 		giterr_set(GITERR_REFERENCE, "Reference '%s' not found", ref->name);
-		return GIT_NOTFOUND;
+		return GIT_ENOTFOUND;
 	}
 
 	pack_ref = git_strmap_value_at(packfile_refs, pos);
@@ -984,7 +984,7 @@ static int reference_lookup(git_reference *ref)
 
 	/* only try to lookup this reference on the packfile if it
 	 * wasn't found on the loose refs; not if there was a critical error */
-	if (result == GIT_NOTFOUND) {
+	if (result == GIT_ENOTFOUND) {
 		giterr_clear();
 		result = packed_lookup(ref);
 		if (result == 0)
diff --git a/src/refspec.c b/src/refspec.c
index adb162df9..697b1bf87 100644
--- a/src/refspec.c
+++ b/src/refspec.c
@@ -68,7 +68,7 @@ int git_refspec_transform(char *out, size_t outlen, const git_refspec *spec, con
 	baselen = strlen(spec->dst);
 	if (outlen <= baselen) {
 		giterr_set(GITERR_INVALID, "Reference name too long");
-		return GIT_SHORTBUFFER;
+		return GIT_EBUFS;
 	}
 
 	/*
@@ -90,7 +90,7 @@ int git_refspec_transform(char *out, size_t outlen, const git_refspec *spec, con
 
 	if (outlen <= baselen + namelen) {
 		giterr_set(GITERR_INVALID, "Reference name too long");
-		return GIT_SHORTBUFFER;
+		return GIT_EBUFS;
 	}
 
 	memcpy(out, spec->dst, baselen);
diff --git a/src/remote.c b/src/remote.c
index db4d0a7fd..9740344f8 100644
--- a/src/remote.c
+++ b/src/remote.c
@@ -135,7 +135,7 @@ int git_remote_load(git_remote **out, git_repository *repo, const char *name)
 	}
 
 	error = parse_remote_refspec(config, &remote->fetch, git_buf_cstr(&buf));
-	if (error == GIT_NOTFOUND)
+	if (error == GIT_ENOTFOUND)
 		error = 0;
 
 	if (error < 0) {
@@ -150,7 +150,7 @@ int git_remote_load(git_remote **out, git_repository *repo, const char *name)
 	}
 
 	error = parse_remote_refspec(config, &remote->push, git_buf_cstr(&buf));
-	if (error == GIT_NOTFOUND)
+	if (error == GIT_ENOTFOUND)
 		error = 0;
 
 	if (error < 0) {
@@ -357,10 +357,10 @@ int git_remote_update_tips(git_remote *remote, int (*cb)(const char *refname, co
 			goto on_error;
 
 		error = git_reference_name_to_oid(&old, remote->repo, refname.ptr);
-		if (error < 0 && error != GIT_NOTFOUND)
+		if (error < 0 && error != GIT_ENOTFOUND)
 			goto on_error;
 
-		if (error == GIT_NOTFOUND)
+		if (error == GIT_ENOTFOUND)
 			memset(&old, 0, GIT_OID_RAWSZ);
 
 		if (!git_oid_cmp(&old, &head->oid))
diff --git a/src/repository.c b/src/repository.c
index 2979b446e..6ce3a560f 100644
--- a/src/repository.c
+++ b/src/repository.c
@@ -148,7 +148,7 @@ static int load_workdir(git_repository *repo, git_buf *parent_path)
 	error = git_config_get_string(&worktree, config, "core.worktree");
 	if (!error && worktree != NULL)
 		repo->workdir = git__strdup(worktree);
-	else if (error != GIT_NOTFOUND)
+	else if (error != GIT_ENOTFOUND)
 		return error;
 	else {
 		giterr_clear();
@@ -342,7 +342,7 @@ static int find_repo(
 	if (!git_buf_len(repo_path) && !error) {
 		giterr_set(GITERR_REPOSITORY,
 			"Could not find repository from '%s'", start_path);
-		error = GIT_NOTFOUND;
+		error = GIT_ENOTFOUND;
 	}
 
 	return error;
@@ -403,7 +403,7 @@ int git_repository_discover(
 	*repository_path = '\0';
 
 	if ((error = find_repo(&path, NULL, start_path, flags, ceiling_dirs)) < 0)
-		return error != GIT_NOTFOUND ? -1 : error;
+		return error != GIT_ENOTFOUND ? -1 : error;
 
 	if (size < (size_t)(path.size + 1)) {
 		giterr_set(GITERR_REPOSITORY,
@@ -851,7 +851,7 @@ int git_repository_head_orphan(git_repository *repo)
 	error = git_repository_head(&ref, repo);
 	git_reference_free(ref);
 
-	if (error == GIT_NOTFOUND)
+	if (error == GIT_ENOTFOUND)
 		return 1;
 
 	if (error < 0)
@@ -883,7 +883,7 @@ int git_repository_is_empty(git_repository *repo)
 	git_reference_free(head);
 	git_reference_free(branch);
 
-	if (error == GIT_NOTFOUND)
+	if (error == GIT_ENOTFOUND)
 		return 1;
 
 	if (error < 0)
diff --git a/src/revwalk.c b/src/revwalk.c
index 67695f84b..e64d93f20 100644
--- a/src/revwalk.c
+++ b/src/revwalk.c
@@ -375,7 +375,7 @@ int git_merge_base(git_oid *out, git_repository *repo, git_oid *one, git_oid *tw
 
 	if (!result) {
 		git_revwalk_free(walk);
-		return GIT_NOTFOUND;
+		return GIT_ENOTFOUND;
 	}
 
 	git_oid_cpy(out, &result->item->oid);
diff --git a/src/status.c b/src/status.c
index 6676cd38f..e9ad3cfe4 100644
--- a/src/status.c
+++ b/src/status.c
@@ -214,7 +214,7 @@ int git_status_file(
 	if (!error && !sfi.count) {
 		giterr_set(GITERR_INVALID,
 			"Attempt to get status of nonexistent file '%s'", path);
-		error = GIT_NOTFOUND;
+		error = GIT_ENOTFOUND;
 	}
 
 	*status_flags = sfi.status;
diff --git a/src/submodule.c b/src/submodule.c
index a63043fd5..3c07e657d 100644
--- a/src/submodule.c
+++ b/src/submodule.c
@@ -351,7 +351,7 @@ int git_submodule_foreach(
 	git_strmap_foreach_value(repo->submodules, sm, {
 		/* usually the following will not come into play */
 		if (sm->refcount > 1) {
-			if (git_vector_bsearch(&seen, sm) != GIT_NOTFOUND)
+			if (git_vector_bsearch(&seen, sm) != GIT_ENOTFOUND)
 				continue;
 			if ((error = git_vector_insert(&seen, sm)) < 0)
 				break;
@@ -378,7 +378,7 @@ int git_submodule_lookup(
 
 	pos = git_strmap_lookup_index(repo->submodules, name);
 	if (!git_strmap_valid_index(repo->submodules, pos))
-		return GIT_NOTFOUND;
+		return GIT_ENOTFOUND;
 
 	if (sm_ptr)
 		*sm_ptr = git_strmap_value_at(repo->submodules, pos);
diff --git a/src/tag.c b/src/tag.c
index 2a9ffee5b..63424f530 100644
--- a/src/tag.c
+++ b/src/tag.c
@@ -254,7 +254,7 @@ static int git_tag_create__internal(
 	}
 
 	error = retrieve_tag_reference_oid(oid, &ref_name, repo, tag_name);
-	if (error < 0 && error != GIT_NOTFOUND)
+	if (error < 0 && error != GIT_ENOTFOUND)
 		return -1;
 
 	/** Ensure the tag name doesn't conflict with an already existing
@@ -262,7 +262,7 @@ static int git_tag_create__internal(
 	if (error == 0 && !allow_ref_overwrite) {
 		git_buf_free(&ref_name);
 		giterr_set(GITERR_TAG, "Tag already exists");
-		return GIT_EXISTS;
+		return GIT_EEXISTS;
 	}
 
 	if (create_tag_annotation) {
@@ -332,7 +332,7 @@ int git_tag_create_frombuffer(git_oid *oid, git_repository *repo, const char *bu
 	}
 
 	error = retrieve_tag_reference_oid(oid, &ref_name, repo, tag.tag_name);
-	if (error < 0 && error != GIT_NOTFOUND)
+	if (error < 0 && error != GIT_ENOTFOUND)
 		goto on_error;
 
 	/* We don't need these objects after this */
@@ -345,7 +345,7 @@ int git_tag_create_frombuffer(git_oid *oid, git_repository *repo, const char *bu
 	 *	reference unless overwriting has explictly been requested **/
 	if (error == 0 && !allow_ref_overwrite) {
 		giterr_set(GITERR_TAG, "Tag already exists");
-		return GIT_EXISTS;
+		return GIT_EEXISTS;
 	}
 
 	/* write the buffer */
diff --git a/src/transports/git.c b/src/transports/git.c
index c8f50800d..5baa810f0 100644
--- a/src/transports/git.c
+++ b/src/transports/git.c
@@ -147,7 +147,7 @@ static int store_refs(transport_git *t)
 			return 0;
 
 		ret = git_protocol_store_refs(&t->proto, buf->data, buf->offset);
-		if (ret == GIT_SHORTBUFFER) {
+		if (ret == GIT_EBUFS) {
 			gitno_consume_n(buf, buf->len);
 			continue;
 		}
@@ -279,7 +279,7 @@ static int recv_pkt(gitno_buffer *buf)
 			return -1;
 
 		error = git_pkt_parse_line(&pkt, ptr, &line_end, buf->offset);
-		if (error == GIT_SHORTBUFFER)
+		if (error == GIT_EBUFS)
 			continue;
 		if (error < 0)
 			return -1;
@@ -384,7 +384,7 @@ static int git_download_pack(git_transport *transport, git_repository *repo, git
 			}
 
 			error = git_pkt_parse_line(&pkt, ptr, &line_end, buf->offset);
-			if (error == GIT_SHORTBUFFER)
+			if (error == GIT_EBUFS)
 				break;
 
 			if (error < 0)
diff --git a/src/transports/http.c b/src/transports/http.c
index b382f7cd7..2a8ebbb09 100644
--- a/src/transports/http.c
+++ b/src/transports/http.c
@@ -354,7 +354,7 @@ static int on_body_parse_response(http_parser *parser, const char *str, size_t l
 			return 0;
 
 		error = git_pkt_parse_line(&pkt, ptr, &line_end, git_buf_len(buf));
-		if (error == GIT_SHORTBUFFER) {
+		if (error == GIT_EBUFS) {
 			return 0; /* Ask for more */
 		}
 		if (error < 0)
diff --git a/src/tree.c b/src/tree.c
index a5fe2b63c..92b1b1e39 100644
--- a/src/tree.c
+++ b/src/tree.c
@@ -117,7 +117,7 @@ static int tree_key_search(git_vector *entries, const char *filename)
 	}
 
 	/* The filename doesn't exist at all */
-	return GIT_NOTFOUND;
+	return GIT_ENOTFOUND;
 }
 
 void git_tree__free(git_tree *tree)
@@ -186,7 +186,7 @@ const git_tree_entry *git_tree_entry_byname(git_tree *tree, const char *filename
 	assert(tree && filename);
 
 	idx = tree_key_search(&tree->entries, filename);
-	if (idx == GIT_NOTFOUND)
+	if (idx == GIT_ENOTFOUND)
 		return NULL;
 
 	return git_vector_get(&tree->entries, idx);
@@ -518,7 +518,7 @@ int git_treebuilder_insert(git_tree_entry **entry_out, git_treebuilder *bld, con
 	git_oid_cpy(&entry->oid, id);
 	entry->attr = attributes;
 
-	if (pos == GIT_NOTFOUND) {
+	if (pos == GIT_ENOTFOUND) {
 		if (git_vector_insert(&bld->entries, entry) < 0)
 			return -1;
 	}
@@ -682,7 +682,7 @@ static int tree_frompath(
 		giterr_set(GITERR_TREE,
 			"No tree entry can be found from "
 			"the given tree and relative path '%s'.", treeentry_path->ptr);
-		return GIT_NOTFOUND;
+		return GIT_ENOTFOUND;
 	}
 
 
diff --git a/src/vector.c b/src/vector.c
index 6bd1e9311..6f9aacccf 100644
--- a/src/vector.c
+++ b/src/vector.c
@@ -137,7 +137,7 @@ int git_vector_bsearch3(
 	if (at_pos != NULL)
 		*at_pos = (unsigned int)pos;
 
-	return (rval >= 0) ? (int)pos : GIT_NOTFOUND;
+	return (rval >= 0) ? (int)pos : GIT_ENOTFOUND;
 }
 
 int git_vector_search2(
@@ -152,7 +152,7 @@ int git_vector_search2(
 			return i;
 	}
 
-	return GIT_NOTFOUND;
+	return GIT_ENOTFOUND;
 }
 
 static int strict_comparison(const void *a, const void *b)
@@ -172,7 +172,7 @@ int git_vector_remove(git_vector *v, unsigned int idx)
 	assert(v);
 
 	if (idx >= v->length || v->length == 0)
-		return GIT_NOTFOUND;
+		return GIT_ENOTFOUND;
 
 	for (i = idx; i < v->length - 1; ++i)
 		v->contents[i] = v->contents[i + 1];
diff --git a/tests-clar/config/write.c b/tests-clar/config/write.c
index 4583a149b..f8774473e 100644
--- a/tests-clar/config/write.c
+++ b/tests-clar/config/write.c
@@ -62,7 +62,7 @@ void test_config_write__delete_value(void)
 	git_config_free(cfg);
 
 	cl_git_pass(git_config_open_ondisk(&cfg, "config9"));
-	cl_assert(git_config_get_int32(&i, cfg, "core.dummy") == GIT_NOTFOUND);
+	cl_assert(git_config_get_int32(&i, cfg, "core.dummy") == GIT_ENOTFOUND);
 	cl_git_pass(git_config_set_int32(cfg, "core.dummy", 1));
 	git_config_free(cfg);
 }
@@ -87,6 +87,6 @@ void test_config_write__delete_inexistent(void)
 	git_config *cfg;
 
 	cl_git_pass(git_config_open_ondisk(&cfg, "config9"));
-	cl_assert(git_config_delete(cfg, "core.imaginary") == GIT_NOTFOUND);
+	cl_assert(git_config_delete(cfg, "core.imaginary") == GIT_ENOTFOUND);
 	git_config_free(cfg);
 }
diff --git a/tests-clar/core/path.c b/tests-clar/core/path.c
index af8bf8127..d826612ac 100644
--- a/tests-clar/core/path.c
+++ b/tests-clar/core/path.c
@@ -413,8 +413,8 @@ void test_core_path__13_cannot_prettify_a_non_existing_file(void)
 	git_buf p = GIT_BUF_INIT;
 
 	cl_must_pass(git_path_exists(NON_EXISTING_FILEPATH) == false);
-	cl_assert_equal_i(GIT_NOTFOUND, git_path_prettify(&p, NON_EXISTING_FILEPATH, NULL));
-	cl_assert_equal_i(GIT_NOTFOUND, git_path_prettify(&p, NON_EXISTING_FILEPATH "/so-do-i", NULL));
+	cl_assert_equal_i(GIT_ENOTFOUND, git_path_prettify(&p, NON_EXISTING_FILEPATH, NULL));
+	cl_assert_equal_i(GIT_ENOTFOUND, git_path_prettify(&p, NON_EXISTING_FILEPATH "/so-do-i", NULL));
 
 	git_buf_free(&p);
 }
diff --git a/tests-clar/core/vector.c b/tests-clar/core/vector.c
index 5b47dded2..ef3d6c36d 100644
--- a/tests-clar/core/vector.c
+++ b/tests-clar/core/vector.c
@@ -143,7 +143,7 @@ static int merge_structs(void **old_raw, void *new)
 	((my_struct *)old)->count += 1;
 	git__free(new);
 	_struct_count--;
-	return GIT_EXISTS;
+	return GIT_EEXISTS;
 }
 
 static my_struct *alloc_struct(int value)
diff --git a/tests-clar/index/tests.c b/tests-clar/index/tests.c
index 6420163f5..3436f8d1e 100644
--- a/tests-clar/index/tests.c
+++ b/tests-clar/index/tests.c
@@ -153,7 +153,7 @@ void test_index_tests__find_in_empty(void)
 
    for (i = 0; i < ARRAY_SIZE(test_entries); ++i) {
       int idx = git_index_find(index, test_entries[i].path);
-      cl_assert(idx == GIT_NOTFOUND);
+      cl_assert(idx == GIT_ENOTFOUND);
    }
 
    git_index_free(index);
diff --git a/tests-clar/network/remotes.c b/tests-clar/network/remotes.c
index 17cc797d0..0649c86dd 100644
--- a/tests-clar/network/remotes.c
+++ b/tests-clar/network/remotes.c
@@ -156,7 +156,7 @@ void test_network_remotes__list(void)
 
 void test_network_remotes__loading_a_missing_remote_returns_ENOTFOUND(void)
 {
-	cl_assert_equal_i(GIT_NOTFOUND, git_remote_load(&_remote, _repo, "just-left-few-minutes-ago"));
+	cl_assert_equal_i(GIT_ENOTFOUND, git_remote_load(&_remote, _repo, "just-left-few-minutes-ago"));
 }
 
 void test_network_remotes__add(void)
diff --git a/tests-clar/notes/notes.c b/tests-clar/notes/notes.c
index c23a9f0f9..5185f25ea 100644
--- a/tests-clar/notes/notes.c
+++ b/tests-clar/notes/notes.c
@@ -127,7 +127,7 @@ void test_notes_notes__retrieving_a_list_of_notes_for_an_unknown_namespace_retur
 
 	error = git_note_foreach(_repo, "refs/notes/i-am-not", note_list_cb, &retrieved_notes);
 	cl_git_fail(error);
-	cl_assert_equal_i(GIT_NOTFOUND, error);
+	cl_assert_equal_i(GIT_ENOTFOUND, error);
 
 	cl_assert_equal_i(0, retrieved_notes);
 }
diff --git a/tests-clar/object/lookup.c b/tests-clar/object/lookup.c
index f840cb39f..7cbcc6140 100644
--- a/tests-clar/object/lookup.c
+++ b/tests-clar/object/lookup.c
@@ -22,7 +22,7 @@ void test_object_lookup__lookup_wrong_type_returns_enotfound(void)
 
 	cl_git_pass(git_oid_fromstr(&oid, commit));
 	cl_assert_equal_i(
-		GIT_NOTFOUND, git_object_lookup(&object, g_repo, &oid, GIT_OBJ_TAG));
+		GIT_ENOTFOUND, git_object_lookup(&object, g_repo, &oid, GIT_OBJ_TAG));
 }
 
 void test_object_lookup__lookup_nonexisting_returns_enotfound(void)
@@ -33,7 +33,7 @@ void test_object_lookup__lookup_nonexisting_returns_enotfound(void)
 
 	cl_git_pass(git_oid_fromstr(&oid, unknown));
 	cl_assert_equal_i(
-		GIT_NOTFOUND, git_object_lookup(&object, g_repo, &oid, GIT_OBJ_ANY));
+		GIT_ENOTFOUND, git_object_lookup(&object, g_repo, &oid, GIT_OBJ_ANY));
 }
 
 void test_object_lookup__lookup_wrong_type_by_abbreviated_id_returns_enotfound(void)
@@ -44,7 +44,7 @@ void test_object_lookup__lookup_wrong_type_by_abbreviated_id_returns_enotfound(v
 
 	cl_git_pass(git_oid_fromstrn(&oid, commit, strlen(commit)));
 	cl_assert_equal_i(
-		GIT_NOTFOUND, git_object_lookup_prefix(&object, g_repo, &oid, strlen(commit), GIT_OBJ_TAG));
+		GIT_ENOTFOUND, git_object_lookup_prefix(&object, g_repo, &oid, strlen(commit), GIT_OBJ_TAG));
 }
 
 void test_object_lookup__lookup_wrong_type_eventually_returns_enotfound(void)
@@ -59,5 +59,5 @@ void test_object_lookup__lookup_wrong_type_eventually_returns_enotfound(void)
 	git_object_free(object);
 
 	cl_assert_equal_i(
-		GIT_NOTFOUND, git_object_lookup(&object, g_repo, &oid, GIT_OBJ_TAG));
+		GIT_ENOTFOUND, git_object_lookup(&object, g_repo, &oid, GIT_OBJ_TAG));
 }
diff --git a/tests-clar/object/tree/frompath.c b/tests-clar/object/tree/frompath.c
index 7d4adafb2..06c69ac08 100644
--- a/tests-clar/object/tree/frompath.c
+++ b/tests-clar/object/tree/frompath.c
@@ -66,8 +66,8 @@ void test_object_tree_frompath__retrieve_tree_from_path_to_treeentry(void)
 
 void test_object_tree_frompath__fail_when_processing_an_unknown_tree_segment(void)
 {
-	assert_tree_from_path(tree, "nope/de/fgh/1.txt", GIT_NOTFOUND, NULL);
-	assert_tree_from_path(tree, "ab/me-neither/fgh/2.txt", GIT_NOTFOUND, NULL);
+	assert_tree_from_path(tree, "nope/de/fgh/1.txt", GIT_ENOTFOUND, NULL);
+	assert_tree_from_path(tree, "ab/me-neither/fgh/2.txt", GIT_ENOTFOUND, NULL);
 }
 
 void test_object_tree_frompath__fail_when_processing_an_invalid_path(void)
diff --git a/tests-clar/refs/branches/delete.c b/tests-clar/refs/branches/delete.c
index 629c491f3..03d3c56d7 100644
--- a/tests-clar/refs/branches/delete.c
+++ b/tests-clar/refs/branches/delete.c
@@ -81,7 +81,7 @@ static void assert_non_exisitng_branch_removal(const char *branch_name, git_bran
 	error = git_branch_delete(repo, branch_name, branch_type);
 
 	cl_git_fail(error);
-	cl_assert_equal_i(GIT_NOTFOUND, error);
+	cl_assert_equal_i(GIT_ENOTFOUND, error);
 }
 
 void test_refs_branches_delete__deleting_a_non_existing_branch_returns_ENOTFOUND(void)
diff --git a/tests-clar/refs/branches/move.c b/tests-clar/refs/branches/move.c
index 8948497e2..242e5cd01 100644
--- a/tests-clar/refs/branches/move.c
+++ b/tests-clar/refs/branches/move.c
@@ -68,5 +68,5 @@ void test_refs_branches_move__moving_a_non_exisiting_branch_returns_ENOTFOUND(vo
 	error = git_branch_move(repo, "where/am/I", NEW_BRANCH_NAME, 0);
 	cl_git_fail(error);
 
-	cl_assert_equal_i(GIT_NOTFOUND, error);
+	cl_assert_equal_i(GIT_ENOTFOUND, error);
 }
diff --git a/tests-clar/repo/discover.c b/tests-clar/repo/discover.c
index 635bf9661..b3d639bd1 100644
--- a/tests-clar/repo/discover.c
+++ b/tests-clar/repo/discover.c
@@ -82,7 +82,7 @@ void test_repo_discover__0(void)
 	append_ceiling_dir(&ceiling_dirs_buf, TEMP_REPO_FOLDER);
 	ceiling_dirs = git_buf_cstr(&ceiling_dirs_buf);
 
-	cl_assert_equal_i(GIT_NOTFOUND, git_repository_discover(repository_path, sizeof(repository_path), DISCOVER_FOLDER, 0, ceiling_dirs));
+	cl_assert_equal_i(GIT_ENOTFOUND, git_repository_discover(repository_path, sizeof(repository_path), DISCOVER_FOLDER, 0, ceiling_dirs));
 
 	cl_git_pass(git_repository_init(&repo, DISCOVER_FOLDER, 1));
 	cl_git_pass(git_repository_discover(repository_path, sizeof(repository_path), DISCOVER_FOLDER, 0, ceiling_dirs));
@@ -117,7 +117,7 @@ void test_repo_discover__0(void)
 	cl_git_fail(git_repository_discover(found_path, sizeof(found_path), ALTERNATE_MALFORMED_FOLDER1, 0, ceiling_dirs));
 	cl_git_fail(git_repository_discover(found_path, sizeof(found_path), ALTERNATE_MALFORMED_FOLDER2, 0, ceiling_dirs));
 	cl_git_fail(git_repository_discover(found_path, sizeof(found_path), ALTERNATE_MALFORMED_FOLDER3, 0, ceiling_dirs));
-	cl_assert_equal_i(GIT_NOTFOUND, git_repository_discover(found_path, sizeof(found_path), ALTERNATE_NOT_FOUND_FOLDER, 0, ceiling_dirs));
+	cl_assert_equal_i(GIT_ENOTFOUND, git_repository_discover(found_path, sizeof(found_path), ALTERNATE_NOT_FOUND_FOLDER, 0, ceiling_dirs));
 
 	append_ceiling_dir(&ceiling_dirs_buf, SUB_REPOSITORY_FOLDER);
 	ceiling_dirs = git_buf_cstr(&ceiling_dirs_buf);
@@ -125,9 +125,9 @@ void test_repo_discover__0(void)
 	//this must pass as ceiling_directories cannot predent the current
 	//working directory to be checked
 	cl_git_pass(git_repository_discover(found_path, sizeof(found_path), SUB_REPOSITORY_FOLDER, 0, ceiling_dirs));
-	cl_assert_equal_i(GIT_NOTFOUND, git_repository_discover(found_path, sizeof(found_path), SUB_REPOSITORY_FOLDER_SUB, 0, ceiling_dirs));
-	cl_assert_equal_i(GIT_NOTFOUND, git_repository_discover(found_path, sizeof(found_path), SUB_REPOSITORY_FOLDER_SUB_SUB, 0, ceiling_dirs));
-	cl_assert_equal_i(GIT_NOTFOUND, git_repository_discover(found_path, sizeof(found_path), SUB_REPOSITORY_FOLDER_SUB_SUB_SUB, 0, ceiling_dirs));
+	cl_assert_equal_i(GIT_ENOTFOUND, git_repository_discover(found_path, sizeof(found_path), SUB_REPOSITORY_FOLDER_SUB, 0, ceiling_dirs));
+	cl_assert_equal_i(GIT_ENOTFOUND, git_repository_discover(found_path, sizeof(found_path), SUB_REPOSITORY_FOLDER_SUB_SUB, 0, ceiling_dirs));
+	cl_assert_equal_i(GIT_ENOTFOUND, git_repository_discover(found_path, sizeof(found_path), SUB_REPOSITORY_FOLDER_SUB_SUB_SUB, 0, ceiling_dirs));
 
 	//.gitfile redirection should not be affected by ceiling directories
 	ensure_repository_discover(REPOSITORY_ALTERNATE_FOLDER, ceiling_dirs, sub_repository_path);
diff --git a/tests-clar/repo/open.c b/tests-clar/repo/open.c
index 62578bec3..c70ec83a9 100644
--- a/tests-clar/repo/open.c
+++ b/tests-clar/repo/open.c
@@ -278,5 +278,5 @@ void test_repo_open__win32_path(void)
 void test_repo_open__opening_a_non_existing_repository_returns_ENOTFOUND(void)
 {
 	git_repository *repo;
-	cl_assert_equal_i(GIT_NOTFOUND, git_repository_open(&repo, "i-do-not/exist"));
+	cl_assert_equal_i(GIT_ENOTFOUND, git_repository_open(&repo, "i-do-not/exist"));
 }
diff --git a/tests-clar/revwalk/mergebase.c b/tests-clar/revwalk/mergebase.c
index 694dffcba..e807e3ad2 100644
--- a/tests-clar/revwalk/mergebase.c
+++ b/tests-clar/revwalk/mergebase.c
@@ -63,7 +63,7 @@ void test_revwalk_mergebase__no_common_ancestor_returns_ENOTFOUND(void)
 	error = git_merge_base(&result, _repo, &one, &two);
 	cl_git_fail(error);
 
-	cl_assert_equal_i(GIT_NOTFOUND, error);
+	cl_assert_equal_i(GIT_ENOTFOUND, error);
 }
 
 /*
diff --git a/tests-clar/status/submodules.c b/tests-clar/status/submodules.c
index 63a44dc0e..9423e8490 100644
--- a/tests-clar/status/submodules.c
+++ b/tests-clar/status/submodules.c
@@ -34,9 +34,9 @@ void test_status_submodules__api(void)
 {
 	git_submodule *sm;
 
-	cl_assert(git_submodule_lookup(NULL, g_repo, "nonexistent") == GIT_NOTFOUND);
+	cl_assert(git_submodule_lookup(NULL, g_repo, "nonexistent") == GIT_ENOTFOUND);
 
-	cl_assert(git_submodule_lookup(NULL, g_repo, "modified") == GIT_NOTFOUND);
+	cl_assert(git_submodule_lookup(NULL, g_repo, "modified") == GIT_ENOTFOUND);
 
 	cl_git_pass(git_submodule_lookup(&sm, g_repo, "testrepo"));
 	cl_assert(sm != NULL);
diff --git a/tests-clar/status/worktree.c b/tests-clar/status/worktree.c
index d839e8462..6cc6259b8 100644
--- a/tests-clar/status/worktree.c
+++ b/tests-clar/status/worktree.c
@@ -199,7 +199,7 @@ void test_status_worktree__single_nonexistent_file(void)
 
 	error = git_status_file(&status_flags, repo, "nonexistent");
 	cl_git_fail(error);
-	cl_assert(error == GIT_NOTFOUND);
+	cl_assert(error == GIT_ENOTFOUND);
 }
 
 /* this test is equivalent to t18-status.c:singlestatus2 */
@@ -211,7 +211,7 @@ void test_status_worktree__single_nonexistent_file_empty_repo(void)
 
 	error = git_status_file(&status_flags, repo, "nonexistent");
 	cl_git_fail(error);
-	cl_assert(error == GIT_NOTFOUND);
+	cl_assert(error == GIT_ENOTFOUND);
 }
 
 /* this test is equivalent to t18-status.c:singlestatus3 */
@@ -235,7 +235,7 @@ void test_status_worktree__single_folder(void)
 
 	error = git_status_file(&status_flags, repo, "subdir");
 	cl_git_fail(error);
-	cl_assert(error != GIT_NOTFOUND);
+	cl_assert(error != GIT_ENOTFOUND);
 }
 
 
@@ -416,7 +416,7 @@ void test_status_worktree__cannot_retrieve_the_status_of_a_bare_repository(void)
 	error = git_status_file(&status, repo, "dummy");
 
 	cl_git_fail(error);
-	cl_assert(error != GIT_NOTFOUND);
+	cl_assert(error != GIT_ENOTFOUND);
 
 	git_repository_free(repo);
 }