revparse: replace spaces with tabs

2 files changed, 758 insertions, 758 deletions

diff --git a/src/revparse.c b/src/revparse.c
index 3f210d11b..bc750f441 100644
--- a/src/revparse.c
+++ b/src/revparse.c
@@ -14,747 +14,747 @@
 #include "git2.h"
 
 typedef enum {
-   REVPARSE_STATE_INIT,
-   REVPARSE_STATE_CARET,
-   REVPARSE_STATE_LINEAR,
-   REVPARSE_STATE_COLON,
-   REVPARSE_STATE_DONE,
+	REVPARSE_STATE_INIT,
+	REVPARSE_STATE_CARET,
+	REVPARSE_STATE_LINEAR,
+	REVPARSE_STATE_COLON,
+	REVPARSE_STATE_DONE,
 } revparse_state;
 
 static void set_invalid_syntax_err(const char *spec)
 {
-   giterr_set(GITERR_INVALID, "Refspec '%s' is not valid.", spec);
+	giterr_set(GITERR_INVALID, "Refspec '%s' is not valid.", spec);
 }
 
 static int revparse_lookup_fully_qualifed_ref(git_object **out, git_repository *repo, const char*spec)
 {
-   git_oid resolved;
+	git_oid resolved;
 
-   if (git_reference_name_to_oid(&resolved, repo, spec) < 0)
-      return GIT_ERROR;
+	if (git_reference_name_to_oid(&resolved, repo, spec) < 0)
+		return GIT_ERROR;
 
-   return git_object_lookup(out, repo, &resolved, GIT_OBJ_ANY);
+	return git_object_lookup(out, repo, &resolved, GIT_OBJ_ANY);
 }
 
 /* Returns non-zero if yes */
 static int spec_looks_like_describe_output(const char *spec)
 {
-   regex_t regex;
-   int regex_error, retcode;
-
-   regex_error = regcomp(&regex, ".+-[0-9]+-g[0-9a-fA-F]+", REG_EXTENDED);
-   if (regex_error != 0) {
-      giterr_set_regex(&regex, regex_error);
-      return 1; /* To be safe */
-   }
-   retcode = regexec(&regex, spec, 0, NULL, 0);
-   regfree(&regex);
-   return retcode == 0;
+	regex_t regex;
+	int regex_error, retcode;
+
+	regex_error = regcomp(&regex, ".+-[0-9]+-g[0-9a-fA-F]+", REG_EXTENDED);
+	if (regex_error != 0) {
+		giterr_set_regex(&regex, regex_error);
+		return 1; /* To be safe */
+	}
+	retcode = regexec(&regex, spec, 0, NULL, 0);
+	regfree(&regex);
+	return retcode == 0;
 }
 
 static int revparse_lookup_object(git_object **out, git_repository *repo, const char *spec)
 {
-   size_t speclen = strlen(spec);
-   git_object *obj = NULL;
-   git_oid oid;
-   git_buf refnamebuf = GIT_BUF_INIT;
-   static const char* formatters[] = {
-      "refs/%s",
-      "refs/tags/%s",
-      "refs/heads/%s",
-      "refs/remotes/%s",
-      "refs/remotes/%s/HEAD",
-      NULL
-   };
-   unsigned int i;
-   const char *substr;
-
-   /* "git describe" output; snip everything before/including "-g" */
-   substr = strstr(spec, "-g");
-   if (substr &&
-       spec_looks_like_describe_output(spec) &&
-       !revparse_lookup_object(out, repo, substr+2)) {
-      return 0;
-   }
-
-   /* SHA or prefix */
-   if (!git_oid_fromstrn(&oid, spec, speclen)) {
-      if (!git_object_lookup_prefix(&obj, repo, &oid, speclen, GIT_OBJ_ANY)) {
-         *out = obj;
-         return 0;
-      }
-   }
-
-   /* Fully-named ref */
-   if (!revparse_lookup_fully_qualifed_ref(&obj, repo, spec)) {
-      *out = obj;
-      return 0;
-   }
-
-   /* Partially-named ref; match in this order: */
-   for (i=0; formatters[i]; i++) {
-      git_buf_clear(&refnamebuf);
-      if (git_buf_printf(&refnamebuf, formatters[i], spec) < 0) {
-         return GIT_ERROR;
-      }
-
-      if (!revparse_lookup_fully_qualifed_ref(&obj, repo, git_buf_cstr(&refnamebuf))) {
-         git_buf_free(&refnamebuf);
-         *out = obj;
-         return 0;
-      }
-   }
-   git_buf_free(&refnamebuf);
-
-   giterr_set(GITERR_REFERENCE, "Refspec '%s' not found.", spec);
-   return GIT_ERROR;
+	size_t speclen = strlen(spec);
+	git_object *obj = NULL;
+	git_oid oid;
+	git_buf refnamebuf = GIT_BUF_INIT;
+	static const char* formatters[] = {
+		"refs/%s",
+		"refs/tags/%s",
+		"refs/heads/%s",
+		"refs/remotes/%s",
+		"refs/remotes/%s/HEAD",
+		NULL
+	};
+	unsigned int i;
+	const char *substr;
+
+	/* "git describe" output; snip everything before/including "-g" */
+	substr = strstr(spec, "-g");
+	if (substr &&
+		spec_looks_like_describe_output(spec) &&
+		!revparse_lookup_object(out, repo, substr+2)) {
+			return 0;
+	}
+
+	/* SHA or prefix */
+	if (!git_oid_fromstrn(&oid, spec, speclen)) {
+		if (!git_object_lookup_prefix(&obj, repo, &oid, speclen, GIT_OBJ_ANY)) {
+			*out = obj;
+			return 0;
+		}
+	}
+
+	/* Fully-named ref */
+	if (!revparse_lookup_fully_qualifed_ref(&obj, repo, spec)) {
+		*out = obj;
+		return 0;
+	}
+
+	/* Partially-named ref; match in this order: */
+	for (i=0; formatters[i]; i++) {
+		git_buf_clear(&refnamebuf);
+		if (git_buf_printf(&refnamebuf, formatters[i], spec) < 0) {
+			return GIT_ERROR;
+		}
+
+		if (!revparse_lookup_fully_qualifed_ref(&obj, repo, git_buf_cstr(&refnamebuf))) {
+			git_buf_free(&refnamebuf);
+			*out = obj;
+			return 0;
+		}
+	}
+	git_buf_free(&refnamebuf);
+
+	giterr_set(GITERR_REFERENCE, "Refspec '%s' not found.", spec);
+	return GIT_ERROR;
 }
 
 
 static int all_chars_are_digits(const char *str, size_t len)
 {
-   size_t i=0;
-   for (i=0; i<len; i++) {
-      if (str[i] < '0' || str[i] > '9') return 0;
-   }
-   return 1;
+	size_t i=0;
+	for (i=0; i<len; i++) {
+		if (str[i] < '0' || str[i] > '9') return 0;
+	}
+	return 1;
 }
 
 static void normalize_maybe_empty_refname(git_buf *buf, git_repository *repo, const char *refspec, size_t refspeclen)
 {
-   git_reference *ref;
-
-   if (!refspeclen) {
-      /* Empty refspec means current branch (target of HEAD) */
-      git_reference_lookup(&ref, repo, "HEAD");
-      git_buf_puts(buf, git_reference_target(ref));
-      git_reference_free(ref);
-   } else if (strstr(refspec, "HEAD")) {
-      /* Explicit head */
-      git_buf_puts(buf, refspec);
-   }else {
-      if (git__prefixcmp(refspec, "refs/heads/") != 0) {
-         git_buf_printf(buf, "refs/heads/%s", refspec);
-      } else {
-         git_buf_puts(buf, refspec);
-      }
-   }
+	git_reference *ref;
+
+	if (!refspeclen) {
+		/* Empty refspec means current branch (target of HEAD) */
+		git_reference_lookup(&ref, repo, "HEAD");
+		git_buf_puts(buf, git_reference_target(ref));
+		git_reference_free(ref);
+	} else if (strstr(refspec, "HEAD")) {
+		/* Explicit head */
+		git_buf_puts(buf, refspec);
+	}else {
+		if (git__prefixcmp(refspec, "refs/heads/") != 0) {
+			git_buf_printf(buf, "refs/heads/%s", refspec);
+		} else {
+			git_buf_puts(buf, refspec);
+		}
+	}
 }
 
 static int walk_ref_history(git_object **out, git_repository *repo, const char *refspec, const char *reflogspec)
 {
-   git_reference *ref;
-   git_reflog *reflog = NULL;
-   int n, retcode = GIT_ERROR;
-   int i, refloglen;
-   const git_reflog_entry *entry;
-   git_buf buf = GIT_BUF_INIT;
-   size_t refspeclen = strlen(refspec);
-   size_t reflogspeclen = strlen(reflogspec);
-
-   if (git__prefixcmp(reflogspec, "@{") != 0 ||
-       git__suffixcmp(reflogspec, "}") != 0) {
-      giterr_set(GITERR_INVALID, "Bad reflogspec '%s'", reflogspec);
-      return GIT_ERROR;
-   }
-
-   /* "@{-N}" form means walk back N checkouts. That means the HEAD log. */
-   if (refspeclen == 0 && !git__prefixcmp(reflogspec, "@{-")) {
-      regex_t regex;
-      int regex_error;
-
-      if (git__strtol32(&n, reflogspec+3, NULL, 0) < 0 ||
-          n < 1) {
-         giterr_set(GITERR_INVALID, "Invalid reflogspec %s", reflogspec);
-         return GIT_ERROR;
-      }
-
-      if (!git_reference_lookup(&ref, repo, "HEAD")) {
-         if (!git_reflog_read(&reflog, ref)) {
-            regex_error = regcomp(&regex, "checkout: moving from (.*) to .*", REG_EXTENDED);
-            if (regex_error != 0) {
-               giterr_set_regex(&regex, regex_error);
-            } else {
-               regmatch_t regexmatches[2];
-
-               refloglen = git_reflog_entrycount(reflog);
-               for (i=refloglen-1; i >= 0; i--) {
-                  const char *msg;
-                  entry = git_reflog_entry_byindex(reflog, i);
-
-                  msg = git_reflog_entry_msg(entry);
-                  if (!regexec(&regex, msg, 2, regexmatches, 0)) {
-                     n--;
-                     if (!n) {
-                        git_buf_put(&buf, msg+regexmatches[1].rm_so, regexmatches[1].rm_eo - regexmatches[1].rm_so);
-                        retcode = revparse_lookup_object(out, repo, git_buf_cstr(&buf));
-                        break;
-                     }
-                  }
-               }
-               regfree(&regex);
-            }
-         }
-         git_reference_free(ref);
-      }
-   } else {
-      int date_error = 0;
-      git_time_t timestamp;
-      git_buf datebuf = GIT_BUF_INIT;
-
-      git_buf_put(&datebuf, reflogspec+2, reflogspeclen-3);
-      date_error = git__date_parse(&timestamp, git_buf_cstr(&datebuf));
-
-      /* @{u} or @{upstream} -> upstream branch, for a tracking branch. This is stored in the config. */
-      if (!strcmp(reflogspec, "@{u}") || !strcmp(reflogspec, "@{upstream}")) {
-         git_config *cfg;
-         if (!git_repository_config(&cfg, repo)) {
-            /* Is the ref a tracking branch? */
-            const char *remote;
-            git_buf_clear(&buf);
-            git_buf_printf(&buf, "branch.%s.remote", refspec);
-            if (!git_config_get_string(&remote, cfg, git_buf_cstr(&buf))) {
-               /* Yes. Find the first merge target name. */
-               const char *mergetarget;
-               git_buf_clear(&buf);
-               git_buf_printf(&buf, "branch.%s.merge", refspec);
-               if (!git_config_get_string(&mergetarget, cfg, git_buf_cstr(&buf)) &&
-                   !git__prefixcmp(mergetarget, "refs/heads/")) {
-                  /* Success. Look up the target and fetch the object. */
-                  git_buf_clear(&buf);
-                  git_buf_printf(&buf, "refs/remotes/%s/%s", remote, mergetarget+11);
-                  retcode = revparse_lookup_fully_qualifed_ref(out, repo, git_buf_cstr(&buf));
-               }
-            }
-            git_config_free(cfg);
-         }
-      }
-
-      /* @{N} -> Nth prior value for the ref (from reflog) */
-      else if (all_chars_are_digits(reflogspec+2, reflogspeclen-3) &&
-               !git__strtol32(&n, reflogspec+2, NULL, 0) &&
-               n <= 100000000) { /* Allow integer time */
-         normalize_maybe_empty_refname(&buf, repo, refspec, refspeclen);
-
-         if (n == 0) {
-            retcode = revparse_lookup_fully_qualifed_ref(out, repo, git_buf_cstr(&buf));
-         } else if (!git_reference_lookup(&ref, repo, git_buf_cstr(&buf))) {
-            if (!git_reflog_read(&reflog, ref)) {
-               int numentries = git_reflog_entrycount(reflog);
-               if (numentries < n) {
-                  giterr_set(GITERR_REFERENCE, "Reflog for '%s' has only %d entries, asked for %d",
-                             git_buf_cstr(&buf), numentries, n);
-                  retcode = GIT_ERROR;
-               } else {
-                  const git_reflog_entry *entry = git_reflog_entry_byindex(reflog, n);
-                  const git_oid *oid = git_reflog_entry_oidold(entry);
-                  retcode = git_object_lookup(out, repo, oid, GIT_OBJ_ANY);
-               }
-            }
-            git_reference_free(ref);
-         }
-      }
-
-      else if (!date_error) {
-         /* Ref as it was on a certain date */
-         normalize_maybe_empty_refname(&buf, repo, refspec, refspeclen);
-
-         if (!git_reference_lookup(&ref, repo, git_buf_cstr(&buf))) {
-            git_reflog *reflog;
-            if (!git_reflog_read(&reflog, ref)) {
-               /* Keep walking until we find an entry older than the given date */
-               int numentries = git_reflog_entrycount(reflog);
-               int i;
-
-               /* TODO: clunky. Factor "now" into a utility */
-               git_signature *sig;
-               git_time as_of;
-
-               git_signature_now(&sig, "blah", "blah");
-               as_of = sig->when;
-               git_signature_free(sig);
-
-               as_of.time = (timestamp > 0)
-                  ? timestamp
-                  : sig->when.time + timestamp;
-
-               for (i=numentries-1; i>0; i--) {
-                  const git_reflog_entry *entry = git_reflog_entry_byindex(reflog, i);
-                  git_time commit_time = git_reflog_entry_committer(entry)->when;
-                  if (git__time_cmp(&commit_time, &as_of) <= 0 ) {
-                     retcode = git_object_lookup(out, repo, git_reflog_entry_oidnew(entry), GIT_OBJ_ANY);
-                     break;
-                  }
-               }
-
-               if (!i) {
-                  /* Didn't find a match. Use the oldest revision in the reflog. */
-                  const git_reflog_entry *entry = git_reflog_entry_byindex(reflog, 0);
-                  retcode = git_object_lookup(out, repo, git_reflog_entry_oidnew(entry), GIT_OBJ_ANY);
-               }
-
-               git_reflog_free(reflog);
-            }
-
-            git_reference_free(ref);
-         }
-      }
-
-      git_buf_free(&datebuf);
-   }
-
-   if (reflog) git_reflog_free(reflog);
-   git_buf_free(&buf);
-   return retcode;
+	git_reference *ref;
+	git_reflog *reflog = NULL;
+	int n, retcode = GIT_ERROR;
+	int i, refloglen;
+	const git_reflog_entry *entry;
+	git_buf buf = GIT_BUF_INIT;
+	size_t refspeclen = strlen(refspec);
+	size_t reflogspeclen = strlen(reflogspec);
+
+	if (git__prefixcmp(reflogspec, "@{") != 0 ||
+		git__suffixcmp(reflogspec, "}") != 0) {
+			giterr_set(GITERR_INVALID, "Bad reflogspec '%s'", reflogspec);
+			return GIT_ERROR;
+	}
+
+	/* "@{-N}" form means walk back N checkouts. That means the HEAD log. */
+	if (refspeclen == 0 && !git__prefixcmp(reflogspec, "@{-")) {
+		regex_t regex;
+		int regex_error;
+
+		if (git__strtol32(&n, reflogspec+3, NULL, 0) < 0 ||
+			n < 1) {
+				giterr_set(GITERR_INVALID, "Invalid reflogspec %s", reflogspec);
+				return GIT_ERROR;
+		}
+
+		if (!git_reference_lookup(&ref, repo, "HEAD")) {
+			if (!git_reflog_read(&reflog, ref)) {
+				regex_error = regcomp(&regex, "checkout: moving from (.*) to .*", REG_EXTENDED);
+				if (regex_error != 0) {
+					giterr_set_regex(&regex, regex_error);
+				} else {
+					regmatch_t regexmatches[2];
+
+					refloglen = git_reflog_entrycount(reflog);
+					for (i=refloglen-1; i >= 0; i--) {
+						const char *msg;
+						entry = git_reflog_entry_byindex(reflog, i);
+
+						msg = git_reflog_entry_msg(entry);
+						if (!regexec(&regex, msg, 2, regexmatches, 0)) {
+							n--;
+							if (!n) {
+								git_buf_put(&buf, msg+regexmatches[1].rm_so, regexmatches[1].rm_eo - regexmatches[1].rm_so);
+								retcode = revparse_lookup_object(out, repo, git_buf_cstr(&buf));
+								break;
+							}
+						}
+					}
+					regfree(&regex);
+				}
+			}
+			git_reference_free(ref);
+		}
+	} else {
+		int date_error = 0;
+		git_time_t timestamp;
+		git_buf datebuf = GIT_BUF_INIT;
+
+		git_buf_put(&datebuf, reflogspec+2, reflogspeclen-3);
+		date_error = git__date_parse(&timestamp, git_buf_cstr(&datebuf));
+
+		/* @{u} or @{upstream} -> upstream branch, for a tracking branch. This is stored in the config. */
+		if (!strcmp(reflogspec, "@{u}") || !strcmp(reflogspec, "@{upstream}")) {
+			git_config *cfg;
+			if (!git_repository_config(&cfg, repo)) {
+				/* Is the ref a tracking branch? */
+				const char *remote;
+				git_buf_clear(&buf);
+				git_buf_printf(&buf, "branch.%s.remote", refspec);
+				if (!git_config_get_string(&remote, cfg, git_buf_cstr(&buf))) {
+					/* Yes. Find the first merge target name. */
+					const char *mergetarget;
+					git_buf_clear(&buf);
+					git_buf_printf(&buf, "branch.%s.merge", refspec);
+					if (!git_config_get_string(&mergetarget, cfg, git_buf_cstr(&buf)) &&
+						!git__prefixcmp(mergetarget, "refs/heads/")) {
+							/* Success. Look up the target and fetch the object. */
+							git_buf_clear(&buf);
+							git_buf_printf(&buf, "refs/remotes/%s/%s", remote, mergetarget+11);
+							retcode = revparse_lookup_fully_qualifed_ref(out, repo, git_buf_cstr(&buf));
+					}
+				}
+				git_config_free(cfg);
+			}
+		}
+
+		/* @{N} -> Nth prior value for the ref (from reflog) */
+		else if (all_chars_are_digits(reflogspec+2, reflogspeclen-3) &&
+			!git__strtol32(&n, reflogspec+2, NULL, 0) &&
+			n <= 100000000) { /* Allow integer time */
+				normalize_maybe_empty_refname(&buf, repo, refspec, refspeclen);
+
+				if (n == 0) {
+					retcode = revparse_lookup_fully_qualifed_ref(out, repo, git_buf_cstr(&buf));
+				} else if (!git_reference_lookup(&ref, repo, git_buf_cstr(&buf))) {
+					if (!git_reflog_read(&reflog, ref)) {
+						int numentries = git_reflog_entrycount(reflog);
+						if (numentries < n) {
+							giterr_set(GITERR_REFERENCE, "Reflog for '%s' has only %d entries, asked for %d",
+								git_buf_cstr(&buf), numentries, n);
+							retcode = GIT_ERROR;
+						} else {
+							const git_reflog_entry *entry = git_reflog_entry_byindex(reflog, n);
+							const git_oid *oid = git_reflog_entry_oidold(entry);
+							retcode = git_object_lookup(out, repo, oid, GIT_OBJ_ANY);
+						}
+					}
+					git_reference_free(ref);
+				}
+		}
+
+		else if (!date_error) {
+			/* Ref as it was on a certain date */
+			normalize_maybe_empty_refname(&buf, repo, refspec, refspeclen);
+
+			if (!git_reference_lookup(&ref, repo, git_buf_cstr(&buf))) {
+				git_reflog *reflog;
+				if (!git_reflog_read(&reflog, ref)) {
+					/* Keep walking until we find an entry older than the given date */
+					int numentries = git_reflog_entrycount(reflog);
+					int i;
+
+					/* TODO: clunky. Factor "now" into a utility */
+					git_signature *sig;
+					git_time as_of;
+
+					git_signature_now(&sig, "blah", "blah");
+					as_of = sig->when;
+					git_signature_free(sig);
+
+					as_of.time = (timestamp > 0)
+						? timestamp
+						: sig->when.time + timestamp;
+
+					for (i=numentries-1; i>0; i--) {
+						const git_reflog_entry *entry = git_reflog_entry_byindex(reflog, i);
+						git_time commit_time = git_reflog_entry_committer(entry)->when;
+						if (git__time_cmp(&commit_time, &as_of) <= 0 ) {
+							retcode = git_object_lookup(out, repo, git_reflog_entry_oidnew(entry), GIT_OBJ_ANY);
+							break;
+						}
+					}
+
+					if (!i) {
+						/* Didn't find a match. Use the oldest revision in the reflog. */
+						const git_reflog_entry *entry = git_reflog_entry_byindex(reflog, 0);
+						retcode = git_object_lookup(out, repo, git_reflog_entry_oidnew(entry), GIT_OBJ_ANY);
+					}
+
+					git_reflog_free(reflog);
+				}
+
+				git_reference_free(ref);
+			}
+		}
+
+		git_buf_free(&datebuf);
+	}
+
+	if (reflog) git_reflog_free(reflog);
+	git_buf_free(&buf);
+	return retcode;
 }
 
 static git_object* dereference_object(git_object *obj)
 {
-   git_otype type = git_object_type(obj);
-
-   switch (type) {
-   case GIT_OBJ_COMMIT:
-      {
-         git_tree *tree = NULL;
-         if (0 == git_commit_tree(&tree, (git_commit*)obj)) {
-            return (git_object*)tree;
-         }
-      }
-      break;
-   case GIT_OBJ_TAG:
-      {
-         git_object *newobj = NULL;
-         if (0 == git_tag_target(&newobj, (git_tag*)obj)) {
-            return newobj;
-         }
-      }
-      break;
-
-   default:
-   case GIT_OBJ_TREE:
-   case GIT_OBJ_BLOB:
-   case GIT_OBJ_OFS_DELTA:
-   case GIT_OBJ_REF_DELTA:
-      break;
-   }
-
-   /* Can't dereference some types */
-   return NULL;
+	git_otype type = git_object_type(obj);
+
+	switch (type) {
+	case GIT_OBJ_COMMIT:
+		{
+			git_tree *tree = NULL;
+			if (0 == git_commit_tree(&tree, (git_commit*)obj)) {
+				return (git_object*)tree;
+			}
+		}
+		break;
+	case GIT_OBJ_TAG:
+		{
+			git_object *newobj = NULL;
+			if (0 == git_tag_target(&newobj, (git_tag*)obj)) {
+				return newobj;
+			}
+		}
+		break;
+
+	default:
+	case GIT_OBJ_TREE:
+	case GIT_OBJ_BLOB:
+	case GIT_OBJ_OFS_DELTA:
+	case GIT_OBJ_REF_DELTA:
+		break;
+	}
+
+	/* Can't dereference some types */
+	return NULL;
 }
 
 static int dereference_to_type(git_object **out, git_object *obj, git_otype target_type)
 {
-   int retcode = 1;
-   git_object *obj1 = obj, *obj2 = obj;
-
-   while (retcode > 0) {
-      git_otype this_type = git_object_type(obj1);
-
-      if (this_type == target_type) {
-         *out = obj1;
-         retcode = 0;
-      } else {
-         /* Dereference once, if possible. */
-         obj2 = dereference_object(obj1);
-         if (!obj2) {
-            giterr_set(GITERR_REFERENCE, "Can't dereference to type");
-            retcode = GIT_ERROR;
-         }
-      }
-      if (obj1 != obj && obj1 != obj2) {
-         git_object_free(obj1);
-      }
-      obj1 = obj2;
-   }
-   return retcode;
+	int retcode = 1;
+	git_object *obj1 = obj, *obj2 = obj;
+
+	while (retcode > 0) {
+		git_otype this_type = git_object_type(obj1);
+
+		if (this_type == target_type) {
+			*out = obj1;
+			retcode = 0;
+		} else {
+			/* Dereference once, if possible. */
+			obj2 = dereference_object(obj1);
+			if (!obj2) {
+				giterr_set(GITERR_REFERENCE, "Can't dereference to type");
+				retcode = GIT_ERROR;
+			}
+		}
+		if (obj1 != obj && obj1 != obj2) {
+			git_object_free(obj1);
+		}
+		obj1 = obj2;
+	}
+	return retcode;
 }
 
 static git_otype parse_obj_type(const char *str)
 {
-   if (!strcmp(str, "{commit}")) return GIT_OBJ_COMMIT;
-   if (!strcmp(str, "{tree}")) return GIT_OBJ_TREE;
-   if (!strcmp(str, "{blob}")) return GIT_OBJ_BLOB;
-   if (!strcmp(str, "{tag}")) return GIT_OBJ_TAG;
-   return GIT_OBJ_BAD;
+	if (!strcmp(str, "{commit}")) return GIT_OBJ_COMMIT;
+	if (!strcmp(str, "{tree}")) return GIT_OBJ_TREE;
+	if (!strcmp(str, "{blob}")) return GIT_OBJ_BLOB;
+	if (!strcmp(str, "{tag}")) return GIT_OBJ_TAG;
+	return GIT_OBJ_BAD;
 }
 
 static int handle_caret_syntax(git_object **out, git_repository *repo, git_object *obj, const char *movement)
 {
-   git_commit *commit;
-   size_t movementlen = strlen(movement);
-   int n;
-
-   if (*movement == '{') {
-      if (movement[movementlen-1] != '}') {
-         set_invalid_syntax_err(movement);
-         return GIT_ERROR;
-      }
-
-      /* {} -> Dereference until we reach an object that isn't a tag. */
-      if (movementlen == 2) {
-         git_object *newobj = obj;
-         git_object *newobj2 = newobj;
-         while (git_object_type(newobj2) == GIT_OBJ_TAG) {
-            newobj2 = dereference_object(newobj);
-            if (newobj != obj) git_object_free(newobj);
-            if (!newobj2) {
-               giterr_set(GITERR_REFERENCE, "Couldn't find object of target type.");
-               return GIT_ERROR;
-            }
-            newobj = newobj2;
-         }
-         *out = newobj2;
-         return 0;
-      }
-
-      /* {/...} -> Walk all commits until we see a commit msg that matches the phrase. */
-      if (movement[1] == '/') {
-         int retcode = GIT_ERROR;
-         git_revwalk *walk;
-         if (!git_revwalk_new(&walk, repo)) {
-            git_oid oid;
-            regex_t preg;
-            int reg_error;
-            git_buf buf = GIT_BUF_INIT;
-
-            git_revwalk_sorting(walk, GIT_SORT_TIME);
-            git_revwalk_push(walk, git_object_id(obj));
-
-            /* Extract the regex from the movement string */
-            git_buf_put(&buf, movement+2, strlen(movement)-3);
-
-            reg_error = regcomp(&preg, git_buf_cstr(&buf), REG_EXTENDED);
-            if (reg_error != 0) {
-               giterr_set_regex(&preg, reg_error);
-            } else {
-               while(!git_revwalk_next(&oid, walk)) {
-                  git_object *walkobj;
-
-                  /* Fetch the commit object, and check for matches in the message */
-                  if (!git_object_lookup(&walkobj, repo, &oid, GIT_OBJ_COMMIT)) {
-                     if (!regexec(&preg, git_commit_message((git_commit*)walkobj), 0, NULL, 0)) {
-                        /* Found it! */
-                        retcode = 0;
-                        *out = walkobj;
-                        if (obj == walkobj) {
-                           /* Avoid leaking an object */
-                           git_object_free(walkobj);
-                        }
-                        break;
-                     }
-                     git_object_free(walkobj);
-                  }
-               }
-               if (retcode < 0) {
-                  giterr_set(GITERR_REFERENCE, "Couldn't find a match for %s", movement);
-               }
-               regfree(&preg);
-            }
-
-            git_buf_free(&buf);
-            git_revwalk_free(walk);
-         }
-         return retcode;
-      }
-
-      /* {...} -> Dereference until we reach an object of a certain type. */
-      if (dereference_to_type(out, obj, parse_obj_type(movement)) < 0) {
-         return GIT_ERROR;
-      }
-      return 0;
-   }
-
-   /* Dereference until we reach a commit. */
-   if (dereference_to_type(&obj, obj, GIT_OBJ_COMMIT) < 0) {
-      /* Can't dereference to a commit; fail */
-      return GIT_ERROR;
-   }
-
-   /* "^" is the same as "^1" */
-   if (movementlen == 0) {
-      n = 1;
-   } else {
-      git__strtol32(&n, movement, NULL, 0);
-   }
-   commit = (git_commit*)obj;
-
-   /* "^0" just returns the input */
-   if (n == 0) {
-      *out = obj;
-      return 0;
-   }
-
-   if (git_commit_parent(&commit, commit, n-1) < 0) {
-      return GIT_ERROR;
-   }
-
-   *out = (git_object*)commit;
-   return 0;
+	git_commit *commit;
+	size_t movementlen = strlen(movement);
+	int n;
+
+	if (*movement == '{') {
+		if (movement[movementlen-1] != '}') {
+			set_invalid_syntax_err(movement);
+			return GIT_ERROR;
+		}
+
+		/* {} -> Dereference until we reach an object that isn't a tag. */
+		if (movementlen == 2) {
+			git_object *newobj = obj;
+			git_object *newobj2 = newobj;
+			while (git_object_type(newobj2) == GIT_OBJ_TAG) {
+				newobj2 = dereference_object(newobj);
+				if (newobj != obj) git_object_free(newobj);
+				if (!newobj2) {
+					giterr_set(GITERR_REFERENCE, "Couldn't find object of target type.");
+					return GIT_ERROR;
+				}
+				newobj = newobj2;
+			}
+			*out = newobj2;
+			return 0;
+		}
+
+		/* {/...} -> Walk all commits until we see a commit msg that matches the phrase. */
+		if (movement[1] == '/') {
+			int retcode = GIT_ERROR;
+			git_revwalk *walk;
+			if (!git_revwalk_new(&walk, repo)) {
+				git_oid oid;
+				regex_t preg;
+				int reg_error;
+				git_buf buf = GIT_BUF_INIT;
+
+				git_revwalk_sorting(walk, GIT_SORT_TIME);
+				git_revwalk_push(walk, git_object_id(obj));
+
+				/* Extract the regex from the movement string */
+				git_buf_put(&buf, movement+2, strlen(movement)-3);
+
+				reg_error = regcomp(&preg, git_buf_cstr(&buf), REG_EXTENDED);
+				if (reg_error != 0) {
+					giterr_set_regex(&preg, reg_error);
+				} else {
+					while(!git_revwalk_next(&oid, walk)) {
+						git_object *walkobj;
+
+						/* Fetch the commit object, and check for matches in the message */
+						if (!git_object_lookup(&walkobj, repo, &oid, GIT_OBJ_COMMIT)) {
+							if (!regexec(&preg, git_commit_message((git_commit*)walkobj), 0, NULL, 0)) {
+								/* Found it! */
+								retcode = 0;
+								*out = walkobj;
+								if (obj == walkobj) {
+									/* Avoid leaking an object */
+									git_object_free(walkobj);
+								}
+								break;
+							}
+							git_object_free(walkobj);
+						}
+					}
+					if (retcode < 0) {
+						giterr_set(GITERR_REFERENCE, "Couldn't find a match for %s", movement);
+					}
+					regfree(&preg);
+				}
+
+				git_buf_free(&buf);
+				git_revwalk_free(walk);
+			}
+			return retcode;
+		}
+
+		/* {...} -> Dereference until we reach an object of a certain type. */
+		if (dereference_to_type(out, obj, parse_obj_type(movement)) < 0) {
+			return GIT_ERROR;
+		}
+		return 0;
+	}
+
+	/* Dereference until we reach a commit. */
+	if (dereference_to_type(&obj, obj, GIT_OBJ_COMMIT) < 0) {
+		/* Can't dereference to a commit; fail */
+		return GIT_ERROR;
+	}
+
+	/* "^" is the same as "^1" */
+	if (movementlen == 0) {
+		n = 1;
+	} else {
+		git__strtol32(&n, movement, NULL, 0);
+	}
+	commit = (git_commit*)obj;
+
+	/* "^0" just returns the input */
+	if (n == 0) {
+		*out = obj;
+		return 0;
+	}
+
+	if (git_commit_parent(&commit, commit, n-1) < 0) {
+		return GIT_ERROR;
+	}
+
+	*out = (git_object*)commit;
+	return 0;
 }
 
 static int handle_linear_syntax(git_object **out, git_object *obj, const char *movement)
 {
-   git_commit *commit1, *commit2;
-   int i, n;
-
-   /* Dereference until we reach a commit. */
-   if (dereference_to_type(&obj, obj, GIT_OBJ_COMMIT) < 0) {
-      /* Can't dereference to a commit; fail */
-      return GIT_ERROR;
-   }
-
-   /* "~" is the same as "~1" */
-   if (*movement == '\0') {
-      n = 1;
-   } else if (git__strtol32(&n, movement, NULL, 0) < 0) {
-      return GIT_ERROR;
-   }
-   commit1 = (git_commit*)obj;
-
-   /* "~0" just returns the input */
-   if (n == 0) {
-      *out = obj;
-      return 0;
-   }
-
-   for (i=0; i<n; i++) {
-      if (git_commit_parent(&commit2, commit1, 0) < 0) {
-         return GIT_ERROR;
-      }
-      if (commit1 != (git_commit*)obj) {
-         git_commit_free(commit1);
-      }
-      commit1 = commit2;
-   }
-
-   *out = (git_object*)commit1;
-   return 0;
+	git_commit *commit1, *commit2;
+	int i, n;
+
+	/* Dereference until we reach a commit. */
+	if (dereference_to_type(&obj, obj, GIT_OBJ_COMMIT) < 0) {
+		/* Can't dereference to a commit; fail */
+		return GIT_ERROR;
+	}
+
+	/* "~" is the same as "~1" */
+	if (*movement == '\0') {
+		n = 1;
+	} else if (git__strtol32(&n, movement, NULL, 0) < 0) {
+		return GIT_ERROR;
+	}
+	commit1 = (git_commit*)obj;
+
+	/* "~0" just returns the input */
+	if (n == 0) {
+		*out = obj;
+		return 0;
+	}
+
+	for (i=0; i<n; i++) {
+		if (git_commit_parent(&commit2, commit1, 0) < 0) {
+			return GIT_ERROR;
+		}
+		if (commit1 != (git_commit*)obj) {
+			git_commit_free(commit1);
+		}
+		commit1 = commit2;
+	}
+
+	*out = (git_object*)commit1;
+	return 0;
 }
 
 static int oid_for_tree_path(git_oid *out, git_tree *tree, git_repository *repo, const char *path)
 {
-   char *str = git__strdup(path);
-   char *tok;
-   void *alloc = str;
-   git_tree *tree2 = tree;
-   const git_tree_entry *entry = NULL;
-
-   while ((tok = git__strtok(&str, "/\\")) != NULL) {
-      entry = git_tree_entry_byname(tree2, tok);
-      if (tree2 != tree) git_tree_free(tree2);
-      if (git_tree_entry__is_tree(entry)) {
-         if (git_tree_lookup(&tree2, repo, &entry->oid) < 0) {
-            git__free(alloc);
-            return GIT_ERROR;
-         }
-      }
-   }
-
-   if (!entry) {
-      giterr_set(GITERR_INVALID, "Invalid tree path '%s'", path);
-      git__free(alloc);
-      return GIT_ERROR;
-   }
-
-   git_oid_cpy(out, git_tree_entry_id(entry));
-   git__free(alloc);
-   return 0;
+	char *str = git__strdup(path);
+	char *tok;
+	void *alloc = str;
+	git_tree *tree2 = tree;
+	const git_tree_entry *entry = NULL;
+
+	while ((tok = git__strtok(&str, "/\\")) != NULL) {
+		entry = git_tree_entry_byname(tree2, tok);
+		if (tree2 != tree) git_tree_free(tree2);
+		if (git_tree_entry__is_tree(entry)) {
+			if (git_tree_lookup(&tree2, repo, &entry->oid) < 0) {
+				git__free(alloc);
+				return GIT_ERROR;
+			}
+		}
+	}
+
+	if (!entry) {
+		giterr_set(GITERR_INVALID, "Invalid tree path '%s'", path);
+		git__free(alloc);
+		return GIT_ERROR;
+	}
+
+	git_oid_cpy(out, git_tree_entry_id(entry));
+	git__free(alloc);
+	return 0;
 }
 
 static int handle_colon_syntax(git_object **out,
-                               git_repository *repo,
-                               git_object *obj,
-                               const char *path)
+	git_repository *repo,
+	git_object *obj,
+	const char *path)
 {
-   git_tree *tree;
-   git_oid oid;
-   int error;
+	git_tree *tree;
+	git_oid oid;
+	int error;
 
-   /* Dereference until we reach a tree. */
-   if (dereference_to_type(&obj, obj, GIT_OBJ_TREE) < 0) {
-      return GIT_ERROR;
-   }
-   tree = (git_tree*)obj;
+	/* Dereference until we reach a tree. */
+	if (dereference_to_type(&obj, obj, GIT_OBJ_TREE) < 0) {
+		return GIT_ERROR;
+	}
+	tree = (git_tree*)obj;
 
-   /* Find the blob at the given path. */
-   error = oid_for_tree_path(&oid, tree, repo, path);
-   git_tree_free(tree);
+	/* Find the blob at the given path. */
+	error = oid_for_tree_path(&oid, tree, repo, path);
+	git_tree_free(tree);
 
-   if (error < 0)
-      return error;
+	if (error < 0)
+		return error;
 
-   return git_object_lookup(out, repo, &oid, GIT_OBJ_ANY);
+	return git_object_lookup(out, repo, &oid, GIT_OBJ_ANY);
 }
 
 static int revparse_global_grep(git_object **out, git_repository *repo, const char *pattern)
 {
-   git_revwalk *walk;
-   int retcode = GIT_ERROR;
-
-   if (!pattern[0]) {
-      giterr_set(GITERR_REGEX, "Empty pattern");
-      return GIT_ERROR;
-   }
-
-   if (!git_revwalk_new(&walk, repo)) {
-      regex_t preg;
-      int reg_error;
-      git_oid oid;
-
-      git_revwalk_sorting(walk, GIT_SORT_TIME);
-      git_revwalk_push_glob(walk, "refs/heads/*");
-
-      reg_error = regcomp(&preg, pattern, REG_EXTENDED);
-      if (reg_error != 0) {
-         giterr_set_regex(&preg, reg_error);
-      } else {
-         git_object *walkobj = NULL, *resultobj = NULL;
-         while(!git_revwalk_next(&oid, walk)) {
-            /* Fetch the commit object, and check for matches in the message */
-            if (walkobj != resultobj) git_object_free(walkobj);
-            if (!git_object_lookup(&walkobj, repo, &oid, GIT_OBJ_COMMIT)) {
-               if (!regexec(&preg, git_commit_message((git_commit*)walkobj), 0, NULL, 0)) {
-                  /* Match! */
-                  resultobj = walkobj;
-                  retcode = 0;
-                  break;
-               }
-            }
-         }
-         if (!resultobj) {
-            giterr_set(GITERR_REFERENCE, "Couldn't find a match for %s", pattern);
-            git_object_free(walkobj);
-         } else {
-            *out = resultobj;
-         }
-         regfree(&preg);
-         git_revwalk_free(walk);
-      }
-   }
-
-   return retcode;
+	git_revwalk *walk;
+	int retcode = GIT_ERROR;
+
+	if (!pattern[0]) {
+		giterr_set(GITERR_REGEX, "Empty pattern");
+		return GIT_ERROR;
+	}
+
+	if (!git_revwalk_new(&walk, repo)) {
+		regex_t preg;
+		int reg_error;
+		git_oid oid;
+
+		git_revwalk_sorting(walk, GIT_SORT_TIME);
+		git_revwalk_push_glob(walk, "refs/heads/*");
+
+		reg_error = regcomp(&preg, pattern, REG_EXTENDED);
+		if (reg_error != 0) {
+			giterr_set_regex(&preg, reg_error);
+		} else {
+			git_object *walkobj = NULL, *resultobj = NULL;
+			while(!git_revwalk_next(&oid, walk)) {
+				/* Fetch the commit object, and check for matches in the message */
+				if (walkobj != resultobj) git_object_free(walkobj);
+				if (!git_object_lookup(&walkobj, repo, &oid, GIT_OBJ_COMMIT)) {
+					if (!regexec(&preg, git_commit_message((git_commit*)walkobj), 0, NULL, 0)) {
+						/* Match! */
+						resultobj = walkobj;
+						retcode = 0;
+						break;
+					}
+				}
+			}
+			if (!resultobj) {
+				giterr_set(GITERR_REFERENCE, "Couldn't find a match for %s", pattern);
+				git_object_free(walkobj);
+			} else {
+				*out = resultobj;
+			}
+			regfree(&preg);
+			git_revwalk_free(walk);
+		}
+	}
+
+	return retcode;
 }
 
 int git_revparse_single(git_object **out, git_repository *repo, const char *spec)
 {
-   revparse_state current_state = REVPARSE_STATE_INIT,  next_state = REVPARSE_STATE_INIT;
-   const char *spec_cur = spec;
-   git_object *cur_obj = NULL,  *next_obj = NULL;
-   git_buf specbuffer = GIT_BUF_INIT,  stepbuffer = GIT_BUF_INIT;
-   int retcode = 0;
-
-   assert(out && repo && spec);
-
-   if (spec[0] == ':') {
-      if (spec[1] == '/') {
-         return revparse_global_grep(out, repo, spec+2);
-      }
-      /* TODO: support merge-stage path lookup (":2:Makefile"). */
-      giterr_set(GITERR_INVALID, "Unimplemented");
-      return GIT_ERROR;
-   }
-
-   while (current_state != REVPARSE_STATE_DONE) {
-      switch (current_state) {
-      case REVPARSE_STATE_INIT:
-         if (!*spec_cur) {
-            /* No operators, just a name. Find it and return. */
-            retcode = revparse_lookup_object(out, repo, spec);
-            next_state = REVPARSE_STATE_DONE;
-         } else if (*spec_cur == '@') {
-            /* '@' syntax doesn't allow chaining */
-            git_buf_puts(&stepbuffer, spec_cur);
-            retcode = walk_ref_history(out, repo, git_buf_cstr(&specbuffer), git_buf_cstr(&stepbuffer));
-            next_state = REVPARSE_STATE_DONE;
-         } else if (*spec_cur == '^') {
-            next_state = REVPARSE_STATE_CARET;
-         } else if (*spec_cur == '~') {
-            next_state = REVPARSE_STATE_LINEAR;
-         } else if (*spec_cur == ':') {
-            next_state = REVPARSE_STATE_COLON;
-         } else {
-            git_buf_putc(&specbuffer, *spec_cur);
-         }
-         spec_cur++;
-
-         if (current_state != next_state && next_state != REVPARSE_STATE_DONE) {
-            /* Leaving INIT state, find the object specified, in case that state needs it */
-            if (revparse_lookup_object(&next_obj, repo, git_buf_cstr(&specbuffer)) < 0) {
-               retcode = GIT_ERROR;
-               next_state = REVPARSE_STATE_DONE;
-            }
-         }
-         break;
-
-
-      case REVPARSE_STATE_CARET:
-         /* Gather characters until NULL, '~', or '^' */
-         if (!*spec_cur) {
-            retcode = handle_caret_syntax(out, repo, cur_obj, git_buf_cstr(&stepbuffer));
-            next_state = REVPARSE_STATE_DONE;
-         } else if (*spec_cur == '~') {
-            retcode = handle_caret_syntax(&next_obj, repo, cur_obj, git_buf_cstr(&stepbuffer));
-            git_buf_clear(&stepbuffer);
-            next_state = !retcode ? REVPARSE_STATE_LINEAR : REVPARSE_STATE_DONE;
-         } else if (*spec_cur == '^') {
-            retcode = handle_caret_syntax(&next_obj, repo, cur_obj, git_buf_cstr(&stepbuffer));
-            git_buf_clear(&stepbuffer);
-            if (retcode < 0) {
-               next_state = REVPARSE_STATE_DONE;
-            }
-         } else {
-            git_buf_putc(&stepbuffer, *spec_cur);
-         }
-         spec_cur++;
-         break;
-
-      case REVPARSE_STATE_LINEAR:
-         if (!*spec_cur) {
-            retcode = handle_linear_syntax(out, cur_obj, git_buf_cstr(&stepbuffer));
-            next_state = REVPARSE_STATE_DONE;
-         } else if (*spec_cur == '~') {
-            retcode = handle_linear_syntax(&next_obj, cur_obj, git_buf_cstr(&stepbuffer));
-            git_buf_clear(&stepbuffer);
-            if (retcode < 0) {
-               next_state = REVPARSE_STATE_DONE;
-            }
-         } else if (*spec_cur == '^') {
-            retcode = handle_linear_syntax(&next_obj, cur_obj, git_buf_cstr(&stepbuffer));
-            git_buf_clear(&stepbuffer);
-            next_state = !retcode ? REVPARSE_STATE_CARET : REVPARSE_STATE_DONE;
-         } else {
-            git_buf_putc(&stepbuffer, *spec_cur);
-         }
-         spec_cur++;
-         break;
-
-      case REVPARSE_STATE_COLON:
-         if (*spec_cur) {
-            git_buf_putc(&stepbuffer, *spec_cur);
-         } else {
-            retcode = handle_colon_syntax(out, repo, cur_obj, git_buf_cstr(&stepbuffer));
-            next_state = REVPARSE_STATE_DONE;
-         }
-         spec_cur++;
-         break;
-
-      case REVPARSE_STATE_DONE:
-         if (cur_obj && *out != cur_obj) git_object_free(cur_obj);
-         if (next_obj && *out != next_obj) git_object_free(next_obj);
-         break;
-      }
-
-      current_state = next_state;
-      if (cur_obj != next_obj) {
-         if (cur_obj) git_object_free(cur_obj);
-         cur_obj = next_obj;
-      }
-   }
-
-   if (*out != cur_obj) git_object_free(cur_obj);
-   if (*out != next_obj && next_obj != cur_obj) git_object_free(next_obj);
-
-   git_buf_free(&specbuffer);
-   git_buf_free(&stepbuffer);
-   return retcode;
+	revparse_state current_state = REVPARSE_STATE_INIT,  next_state = REVPARSE_STATE_INIT;
+	const char *spec_cur = spec;
+	git_object *cur_obj = NULL,  *next_obj = NULL;
+	git_buf specbuffer = GIT_BUF_INIT,  stepbuffer = GIT_BUF_INIT;
+	int retcode = 0;
+
+	assert(out && repo && spec);
+
+	if (spec[0] == ':') {
+		if (spec[1] == '/') {
+			return revparse_global_grep(out, repo, spec+2);
+		}
+		/* TODO: support merge-stage path lookup (":2:Makefile"). */
+		giterr_set(GITERR_INVALID, "Unimplemented");
+		return GIT_ERROR;
+	}
+
+	while (current_state != REVPARSE_STATE_DONE) {
+		switch (current_state) {
+		case REVPARSE_STATE_INIT:
+			if (!*spec_cur) {
+				/* No operators, just a name. Find it and return. */
+				retcode = revparse_lookup_object(out, repo, spec);
+				next_state = REVPARSE_STATE_DONE;
+			} else if (*spec_cur == '@') {
+				/* '@' syntax doesn't allow chaining */
+				git_buf_puts(&stepbuffer, spec_cur);
+				retcode = walk_ref_history(out, repo, git_buf_cstr(&specbuffer), git_buf_cstr(&stepbuffer));
+				next_state = REVPARSE_STATE_DONE;
+			} else if (*spec_cur == '^') {
+				next_state = REVPARSE_STATE_CARET;
+			} else if (*spec_cur == '~') {
+				next_state = REVPARSE_STATE_LINEAR;
+			} else if (*spec_cur == ':') {
+				next_state = REVPARSE_STATE_COLON;
+			} else {
+				git_buf_putc(&specbuffer, *spec_cur);
+			}
+			spec_cur++;
+
+			if (current_state != next_state && next_state != REVPARSE_STATE_DONE) {
+				/* Leaving INIT state, find the object specified, in case that state needs it */
+				if (revparse_lookup_object(&next_obj, repo, git_buf_cstr(&specbuffer)) < 0) {
+					retcode = GIT_ERROR;
+					next_state = REVPARSE_STATE_DONE;
+				}
+			}
+			break;
+
+
+		case REVPARSE_STATE_CARET:
+			/* Gather characters until NULL, '~', or '^' */
+			if (!*spec_cur) {
+				retcode = handle_caret_syntax(out, repo, cur_obj, git_buf_cstr(&stepbuffer));
+				next_state = REVPARSE_STATE_DONE;
+			} else if (*spec_cur == '~') {
+				retcode = handle_caret_syntax(&next_obj, repo, cur_obj, git_buf_cstr(&stepbuffer));
+				git_buf_clear(&stepbuffer);
+				next_state = !retcode ? REVPARSE_STATE_LINEAR : REVPARSE_STATE_DONE;
+			} else if (*spec_cur == '^') {
+				retcode = handle_caret_syntax(&next_obj, repo, cur_obj, git_buf_cstr(&stepbuffer));
+				git_buf_clear(&stepbuffer);
+				if (retcode < 0) {
+					next_state = REVPARSE_STATE_DONE;
+				}
+			} else {
+				git_buf_putc(&stepbuffer, *spec_cur);
+			}
+			spec_cur++;
+			break;
+
+		case REVPARSE_STATE_LINEAR:
+			if (!*spec_cur) {
+				retcode = handle_linear_syntax(out, cur_obj, git_buf_cstr(&stepbuffer));
+				next_state = REVPARSE_STATE_DONE;
+			} else if (*spec_cur == '~') {
+				retcode = handle_linear_syntax(&next_obj, cur_obj, git_buf_cstr(&stepbuffer));
+				git_buf_clear(&stepbuffer);
+				if (retcode < 0) {
+					next_state = REVPARSE_STATE_DONE;
+				}
+			} else if (*spec_cur == '^') {
+				retcode = handle_linear_syntax(&next_obj, cur_obj, git_buf_cstr(&stepbuffer));
+				git_buf_clear(&stepbuffer);
+				next_state = !retcode ? REVPARSE_STATE_CARET : REVPARSE_STATE_DONE;
+			} else {
+				git_buf_putc(&stepbuffer, *spec_cur);
+			}
+			spec_cur++;
+			break;
+
+		case REVPARSE_STATE_COLON:
+			if (*spec_cur) {
+				git_buf_putc(&stepbuffer, *spec_cur);
+			} else {
+				retcode = handle_colon_syntax(out, repo, cur_obj, git_buf_cstr(&stepbuffer));
+				next_state = REVPARSE_STATE_DONE;
+			}
+			spec_cur++;
+			break;
+
+		case REVPARSE_STATE_DONE:
+			if (cur_obj && *out != cur_obj) git_object_free(cur_obj);
+			if (next_obj && *out != next_obj) git_object_free(next_obj);
+			break;
+		}
+
+		current_state = next_state;
+		if (cur_obj != next_obj) {
+			if (cur_obj) git_object_free(cur_obj);
+			cur_obj = next_obj;
+		}
+	}
+
+	if (*out != cur_obj) git_object_free(cur_obj);
+	if (*out != next_obj && next_obj != cur_obj) git_object_free(next_obj);
+
+	git_buf_free(&specbuffer);
+	git_buf_free(&stepbuffer);
+	return retcode;
 }
diff --git a/tests-clar/refs/revparse.c b/tests-clar/refs/revparse.c
index 2ee72f206..a468a4cac 100644
--- a/tests-clar/refs/revparse.c
+++ b/tests-clar/refs/revparse.c
@@ -11,168 +11,168 @@ static char g_orig_tz[16] = {0};
 /* Helpers */
 static void test_object(const char *spec, const char *expected_oid)
 {
-   char objstr[64] = {0};
+	char objstr[64] = {0};
 
-   cl_git_pass(git_revparse_single(&g_obj, g_repo, spec));
-   git_oid_fmt(objstr, git_object_id(g_obj));
-   cl_assert_equal_s(objstr, expected_oid);
+	cl_git_pass(git_revparse_single(&g_obj, g_repo, spec));
+	git_oid_fmt(objstr, git_object_id(g_obj));
+	cl_assert_equal_s(objstr, expected_oid);
 
-   git_object_free(g_obj);
-   g_obj = NULL;
+	git_object_free(g_obj);
+	g_obj = NULL;
 }
 
 
 void test_refs_revparse__initialize(void)
 {
-   char *tz = cl_getenv("TZ");
-   if (tz)
-      strcpy(g_orig_tz, tz);
-   cl_setenv("TZ", "UTC");
-   g_repo = cl_git_sandbox_init("testrepo.git");
+	char *tz = cl_getenv("TZ");
+	if (tz)
+		strcpy(g_orig_tz, tz);
+	cl_setenv("TZ", "UTC");
+	g_repo = cl_git_sandbox_init("testrepo.git");
 }
 
 void test_refs_revparse__cleanup(void)
 {
-   cl_git_sandbox_cleanup();
-   g_obj = NULL;
-   cl_setenv("TZ", g_orig_tz);
+	cl_git_sandbox_cleanup();
+	g_obj = NULL;
+	cl_setenv("TZ", g_orig_tz);
 }
 
 
 void test_refs_revparse__nonexistant_object(void)
 {
-   cl_git_fail(git_revparse_single(&g_obj, g_repo, "this doesn't exist"));
-   cl_git_fail(git_revparse_single(&g_obj, g_repo, "this doesn't exist^1"));
-   cl_git_fail(git_revparse_single(&g_obj, g_repo, "this doesn't exist~2"));
+	cl_git_fail(git_revparse_single(&g_obj, g_repo, "this doesn't exist"));
+	cl_git_fail(git_revparse_single(&g_obj, g_repo, "this doesn't exist^1"));
+	cl_git_fail(git_revparse_single(&g_obj, g_repo, "this doesn't exist~2"));
 }
 
 void test_refs_revparse__shas(void)
 {
-   test_object("c47800c7266a2be04c571c04d5a6614691ea99bd", "c47800c7266a2be04c571c04d5a6614691ea99bd");
-   test_object("c47800c", "c47800c7266a2be04c571c04d5a6614691ea99bd");
+	test_object("c47800c7266a2be04c571c04d5a6614691ea99bd", "c47800c7266a2be04c571c04d5a6614691ea99bd");
+	test_object("c47800c", "c47800c7266a2be04c571c04d5a6614691ea99bd");
 }
 
 void test_refs_revparse__head(void)
 {
-   test_object("HEAD", "a65fedf39aefe402d3bb6e24df4d4f5fe4547750");
+	test_object("HEAD", "a65fedf39aefe402d3bb6e24df4d4f5fe4547750");
 }
 
 void test_refs_revparse__full_refs(void)
 {
-   test_object("refs/heads/master", "a65fedf39aefe402d3bb6e24df4d4f5fe4547750");
-   test_object("refs/heads/test", "e90810b8df3e80c413d903f631643c716887138d");
-   test_object("refs/tags/test", "b25fa35b38051e4ae45d4222e795f9df2e43f1d1");
+	test_object("refs/heads/master", "a65fedf39aefe402d3bb6e24df4d4f5fe4547750");
+	test_object("refs/heads/test", "e90810b8df3e80c413d903f631643c716887138d");
+	test_object("refs/tags/test", "b25fa35b38051e4ae45d4222e795f9df2e43f1d1");
 }
 
 void test_refs_revparse__partial_refs(void)
 {
-   test_object("point_to_blob", "1385f264afb75a56a5bec74243be9b367ba4ca08");
-   test_object("packed-test", "4a202b346bb0fb0db7eff3cffeb3c70babbd2045");
-   test_object("br2", "a4a7dce85cf63874e984719f4fdd239f5145052f");
+	test_object("point_to_blob", "1385f264afb75a56a5bec74243be9b367ba4ca08");
+	test_object("packed-test", "4a202b346bb0fb0db7eff3cffeb3c70babbd2045");
+	test_object("br2", "a4a7dce85cf63874e984719f4fdd239f5145052f");
 }
 
 void test_refs_revparse__describe_output(void)
 {
-   test_object("blah-7-gc47800c", "c47800c7266a2be04c571c04d5a6614691ea99bd");
-   test_object("not-good", "a65fedf39aefe402d3bb6e24df4d4f5fe4547750");
+	test_object("blah-7-gc47800c", "c47800c7266a2be04c571c04d5a6614691ea99bd");
+	test_object("not-good", "a65fedf39aefe402d3bb6e24df4d4f5fe4547750");
 }
 
 void test_refs_revparse__nth_parent(void)
 {
-   test_object("be3563a^1", "9fd738e8f7967c078dceed8190330fc8648ee56a");
-   test_object("be3563a^", "9fd738e8f7967c078dceed8190330fc8648ee56a");
-   test_object("be3563a^2", "c47800c7266a2be04c571c04d5a6614691ea99bd");
-   test_object("be3563a^1^1", "4a202b346bb0fb0db7eff3cffeb3c70babbd2045");
-   test_object("be3563a^2^1", "5b5b025afb0b4c913b4c338a42934a3863bf3644");
-   test_object("be3563a^0", "be3563ae3f795b2b4353bcce3a527ad0a4f7f644");
+	test_object("be3563a^1", "9fd738e8f7967c078dceed8190330fc8648ee56a");
+	test_object("be3563a^", "9fd738e8f7967c078dceed8190330fc8648ee56a");
+	test_object("be3563a^2", "c47800c7266a2be04c571c04d5a6614691ea99bd");
+	test_object("be3563a^1^1", "4a202b346bb0fb0db7eff3cffeb3c70babbd2045");
+	test_object("be3563a^2^1", "5b5b025afb0b4c913b4c338a42934a3863bf3644");
+	test_object("be3563a^0", "be3563ae3f795b2b4353bcce3a527ad0a4f7f644");
 }
 
 void test_refs_revparse__not_tag(void)
 {
-   test_object("point_to_blob^{}", "1385f264afb75a56a5bec74243be9b367ba4ca08");
-   test_object("wrapped_tag^{}", "a65fedf39aefe402d3bb6e24df4d4f5fe4547750");
+	test_object("point_to_blob^{}", "1385f264afb75a56a5bec74243be9b367ba4ca08");
+	test_object("wrapped_tag^{}", "a65fedf39aefe402d3bb6e24df4d4f5fe4547750");
 }
 
 void test_refs_revparse__to_type(void)
 {
-   test_object("wrapped_tag^{commit}", "a65fedf39aefe402d3bb6e24df4d4f5fe4547750");
-   test_object("wrapped_tag^{tree}", "944c0f6e4dfa41595e6eb3ceecdb14f50fe18162");
-   test_object("point_to_blob^{blob}", "1385f264afb75a56a5bec74243be9b367ba4ca08");
+	test_object("wrapped_tag^{commit}", "a65fedf39aefe402d3bb6e24df4d4f5fe4547750");
+	test_object("wrapped_tag^{tree}", "944c0f6e4dfa41595e6eb3ceecdb14f50fe18162");
+	test_object("point_to_blob^{blob}", "1385f264afb75a56a5bec74243be9b367ba4ca08");
 
-   cl_git_fail(git_revparse_single(&g_obj, g_repo, "wrapped_tag^{blob}"));
+	cl_git_fail(git_revparse_single(&g_obj, g_repo, "wrapped_tag^{blob}"));
 }
 
 void test_refs_revparse__linear_history(void)
 {
-   cl_git_fail(git_revparse_single(&g_obj, g_repo, "foo~bar"));
-   cl_git_fail(git_revparse_single(&g_obj, g_repo, "master~bar"));
+	cl_git_fail(git_revparse_single(&g_obj, g_repo, "foo~bar"));
+	cl_git_fail(git_revparse_single(&g_obj, g_repo, "master~bar"));
 
-   test_object("master~0", "a65fedf39aefe402d3bb6e24df4d4f5fe4547750");
-   test_object("master~1", "be3563ae3f795b2b4353bcce3a527ad0a4f7f644");
-   test_object("master~2", "9fd738e8f7967c078dceed8190330fc8648ee56a");
-   test_object("master~1~1", "9fd738e8f7967c078dceed8190330fc8648ee56a");
+	test_object("master~0", "a65fedf39aefe402d3bb6e24df4d4f5fe4547750");
+	test_object("master~1", "be3563ae3f795b2b4353bcce3a527ad0a4f7f644");
+	test_object("master~2", "9fd738e8f7967c078dceed8190330fc8648ee56a");
+	test_object("master~1~1", "9fd738e8f7967c078dceed8190330fc8648ee56a");
 }
 
 void test_refs_revparse__chaining(void)
 {
-   test_object("master~1^1", "9fd738e8f7967c078dceed8190330fc8648ee56a");
-   test_object("master~1^2", "c47800c7266a2be04c571c04d5a6614691ea99bd");
-   test_object("master^1^2~1", "5b5b025afb0b4c913b4c338a42934a3863bf3644");
-   test_object("master^1^1^1^1^1", "8496071c1b46c854b31185ea97743be6a8774479");
+	test_object("master~1^1", "9fd738e8f7967c078dceed8190330fc8648ee56a");
+	test_object("master~1^2", "c47800c7266a2be04c571c04d5a6614691ea99bd");
+	test_object("master^1^2~1", "5b5b025afb0b4c913b4c338a42934a3863bf3644");
+	test_object("master^1^1^1^1^1", "8496071c1b46c854b31185ea97743be6a8774479");
 }
 
 void test_refs_revparse__reflog(void)
 {
-   cl_git_fail(git_revparse_single(&g_obj, g_repo, "@{-xyz}"));
-   cl_git_fail(git_revparse_single(&g_obj, g_repo, "@{-0}"));
-   cl_git_fail(git_revparse_single(&g_obj, g_repo, "@{1000}"));
+	cl_git_fail(git_revparse_single(&g_obj, g_repo, "@{-xyz}"));
+	cl_git_fail(git_revparse_single(&g_obj, g_repo, "@{-0}"));
+	cl_git_fail(git_revparse_single(&g_obj, g_repo, "@{1000}"));
 
-   test_object("@{-2}", "a65fedf39aefe402d3bb6e24df4d4f5fe4547750");
-   test_object("@{-1}", "a4a7dce85cf63874e984719f4fdd239f5145052f");
-   test_object("master@{0}", "a65fedf39aefe402d3bb6e24df4d4f5fe4547750");
-   test_object("master@{1}", "be3563ae3f795b2b4353bcce3a527ad0a4f7f644");
-   test_object("@{0}", "a65fedf39aefe402d3bb6e24df4d4f5fe4547750");
-   test_object("@{1}", "be3563ae3f795b2b4353bcce3a527ad0a4f7f644");
-   test_object("master@{upstream}", "be3563ae3f795b2b4353bcce3a527ad0a4f7f644");
-   test_object("master@{u}", "be3563ae3f795b2b4353bcce3a527ad0a4f7f644");
+	test_object("@{-2}", "a65fedf39aefe402d3bb6e24df4d4f5fe4547750");
+	test_object("@{-1}", "a4a7dce85cf63874e984719f4fdd239f5145052f");
+	test_object("master@{0}", "a65fedf39aefe402d3bb6e24df4d4f5fe4547750");
+	test_object("master@{1}", "be3563ae3f795b2b4353bcce3a527ad0a4f7f644");
+	test_object("@{0}", "a65fedf39aefe402d3bb6e24df4d4f5fe4547750");
+	test_object("@{1}", "be3563ae3f795b2b4353bcce3a527ad0a4f7f644");
+	test_object("master@{upstream}", "be3563ae3f795b2b4353bcce3a527ad0a4f7f644");
+	test_object("master@{u}", "be3563ae3f795b2b4353bcce3a527ad0a4f7f644");
 }
 
 void test_refs_revparse__revwalk(void)
 {
-   cl_git_fail(git_revparse_single(&g_obj, g_repo, "master^{/not found in any commit}"));
-   cl_git_fail(git_revparse_single(&g_obj, g_repo, "master^{/merge}"));
-   cl_git_fail(git_revparse_single(&g_obj, g_repo, "master^{/((}"));
+	cl_git_fail(git_revparse_single(&g_obj, g_repo, "master^{/not found in any commit}"));
+	cl_git_fail(git_revparse_single(&g_obj, g_repo, "master^{/merge}"));
+	cl_git_fail(git_revparse_single(&g_obj, g_repo, "master^{/((}"));
 
-   test_object("master^{/anoth}", "5b5b025afb0b4c913b4c338a42934a3863bf3644");
-   test_object("master^{/Merge}", "be3563ae3f795b2b4353bcce3a527ad0a4f7f644");
-   test_object("br2^{/Merge}", "a4a7dce85cf63874e984719f4fdd239f5145052f");
-   test_object("master^{/fo.rth}", "9fd738e8f7967c078dceed8190330fc8648ee56a");
+	test_object("master^{/anoth}", "5b5b025afb0b4c913b4c338a42934a3863bf3644");
+	test_object("master^{/Merge}", "be3563ae3f795b2b4353bcce3a527ad0a4f7f644");
+	test_object("br2^{/Merge}", "a4a7dce85cf63874e984719f4fdd239f5145052f");
+	test_object("master^{/fo.rth}", "9fd738e8f7967c078dceed8190330fc8648ee56a");
 }
 
 void test_refs_revparse__date(void)
 {
-   test_object("HEAD@{10 years ago}", "be3563ae3f795b2b4353bcce3a527ad0a4f7f644");
-   test_object("HEAD@{1 second}", "a65fedf39aefe402d3bb6e24df4d4f5fe4547750");
-   test_object("master@{2012-4-30 10:23:20 -0800}", "be3563ae3f795b2b4353bcce3a527ad0a4f7f644");
-   test_object("master@{2012-4-30 18:24 -0800}", "a65fedf39aefe402d3bb6e24df4d4f5fe4547750");
-   test_object("master@{2012-4-30 23:24 -0300}", "a65fedf39aefe402d3bb6e24df4d4f5fe4547750");
+	test_object("HEAD@{10 years ago}", "be3563ae3f795b2b4353bcce3a527ad0a4f7f644");
+	test_object("HEAD@{1 second}", "a65fedf39aefe402d3bb6e24df4d4f5fe4547750");
+	test_object("master@{2012-4-30 10:23:20 -0800}", "be3563ae3f795b2b4353bcce3a527ad0a4f7f644");
+	test_object("master@{2012-4-30 18:24 -0800}", "a65fedf39aefe402d3bb6e24df4d4f5fe4547750");
+	test_object("master@{2012-4-30 23:24 -0300}", "a65fedf39aefe402d3bb6e24df4d4f5fe4547750");
 
-   /* Core git gives a65fedf, because they don't take time zones into account. */
-   test_object("master@{1335806640}", "be3563ae3f795b2b4353bcce3a527ad0a4f7f644");
+	/* Core git gives a65fedf, because they don't take time zones into account. */
+	test_object("master@{1335806640}", "be3563ae3f795b2b4353bcce3a527ad0a4f7f644");
 }
 
 void test_refs_revparse__colon(void)
 {
-   cl_git_fail(git_revparse_single(&g_obj, g_repo, ":/"));
-   cl_git_fail(git_revparse_single(&g_obj, g_repo, ":/not found in any commit"));
-   cl_git_fail(git_revparse_single(&g_obj, g_repo, ":2:README"));
-   cl_git_fail(git_revparse_single(&g_obj, g_repo, "master:"));
-
-   test_object("subtrees:ab/4.txt", "d6c93164c249c8000205dd4ec5cbca1b516d487f");
-   test_object("subtrees:ab/de/fgh/1.txt", "1f67fc4386b2d171e0d21be1c447e12660561f9b");
-   test_object("master:README", "a8233120f6ad708f843d861ce2b7228ec4e3dec6");
-   test_object("master:new.txt", "a71586c1dfe8a71c6cbf6c129f404c5642ff31bd");
-   test_object(":/Merge", "a4a7dce85cf63874e984719f4fdd239f5145052f");
-   test_object(":/one", "c47800c7266a2be04c571c04d5a6614691ea99bd");
-   test_object(":/packed commit t", "41bc8c69075bbdb46c5c6f0566cc8cc5b46e8bd9");
+	cl_git_fail(git_revparse_single(&g_obj, g_repo, ":/"));
+	cl_git_fail(git_revparse_single(&g_obj, g_repo, ":/not found in any commit"));
+	cl_git_fail(git_revparse_single(&g_obj, g_repo, ":2:README"));
+	cl_git_fail(git_revparse_single(&g_obj, g_repo, "master:"));
+
+	test_object("subtrees:ab/4.txt", "d6c93164c249c8000205dd4ec5cbca1b516d487f");
+	test_object("subtrees:ab/de/fgh/1.txt", "1f67fc4386b2d171e0d21be1c447e12660561f9b");
+	test_object("master:README", "a8233120f6ad708f843d861ce2b7228ec4e3dec6");
+	test_object("master:new.txt", "a71586c1dfe8a71c6cbf6c129f404c5642ff31bd");
+	test_object(":/Merge", "a4a7dce85cf63874e984719f4fdd239f5145052f");
+	test_object(":/one", "c47800c7266a2be04c571c04d5a6614691ea99bd");
+	test_object(":/packed commit t", "41bc8c69075bbdb46c5c6f0566cc8cc5b46e8bd9");
 }