prepare_packed_git();
for (p = packed_git; p && found < 2; p = p->next) {
- unsigned num = num_packed_objects(p);
- unsigned first = 0, last = num;
+ uint32_t num = num_packed_objects(p);
+ uint32_t first = 0, last = num;
while (first < last) {
- unsigned mid = (first + last) / 2;
+ uint32_t mid = (first + last) / 2;
unsigned char now[20];
int cmp;
char canonical[40];
unsigned char res[20];
- if (len < MINIMUM_ABBREV)
+ if (len < MINIMUM_ABBREV || len > 40)
return -1;
hashclr(res);
memset(canonical, 'x', 40);
return slash;
}
+static const char *ref_fmt[] = {
+ "%.*s",
+ "refs/%.*s",
+ "refs/tags/%.*s",
+ "refs/heads/%.*s",
+ "refs/remotes/%.*s",
+ "refs/remotes/%.*s/HEAD",
+ NULL
+};
+
+int dwim_ref(const char *str, int len, unsigned char *sha1, char **ref)
+{
+ const char **p, *r;
+ int refs_found = 0;
+
+ *ref = NULL;
+ for (p = ref_fmt; *p; p++) {
+ unsigned char sha1_from_ref[20];
+ unsigned char *this_result;
+
+ this_result = refs_found ? sha1_from_ref : sha1;
+ r = resolve_ref(mkpath(*p, len, str), this_result, 1, NULL);
+ if (r) {
+ if (!refs_found++)
+ *ref = xstrdup(r);
+ if (!warn_ambiguous_refs)
+ break;
+ }
+ }
+ return refs_found;
+}
+
+int dwim_log(const char *str, int len, unsigned char *sha1, char **log)
+{
+ const char **p;
+ int logs_found = 0;
+
+ *log = NULL;
+ for (p = ref_fmt; *p; p++) {
+ struct stat st;
+ unsigned char hash[20];
+ char path[PATH_MAX];
+ const char *ref, *it;
+
+ strcpy(path, mkpath(*p, len, str));
+ ref = resolve_ref(path, hash, 0, NULL);
+ if (!ref)
+ continue;
+ if (!stat(git_path("logs/%s", path), &st) &&
+ S_ISREG(st.st_mode))
+ it = path;
+ else if (strcmp(ref, path) &&
+ !stat(git_path("logs/%s", ref), &st) &&
+ S_ISREG(st.st_mode))
+ it = ref;
+ else
+ continue;
+ if (!logs_found++) {
+ *log = xstrdup(it);
+ hashcpy(sha1, hash);
+ }
+ if (!warn_ambiguous_refs)
+ break;
+ }
+ return logs_found;
+}
+
static int get_sha1_basic(const char *str, int len, unsigned char *sha1)
{
- static const char *fmt[] = {
- "%.*s",
- "refs/%.*s",
- "refs/tags/%.*s",
- "refs/heads/%.*s",
- "refs/remotes/%.*s",
- "refs/remotes/%.*s/HEAD",
- NULL
- };
static const char *warning = "warning: refname '%.*s' is ambiguous.\n";
- const char **p, *pathname;
- char *real_path = NULL;
- int refs_found = 0, am;
- unsigned long at_time = (unsigned long)-1;
- unsigned char *this_result;
- unsigned char sha1_from_ref[20];
+ char *real_ref = NULL;
+ int refs_found = 0;
+ int at, reflog_len;
if (len == 40 && !get_sha1_hex(str, sha1))
return 0;
- /* At a given period of time? "@{2 hours ago}" */
- for (am = 1; am < len - 1; am++) {
- if (str[am] == '@' && str[am+1] == '{' && str[len-1] == '}') {
- int date_len = len - am - 3;
- char *date_spec = xmalloc(date_len + 1);
- strlcpy(date_spec, str + am + 2, date_len + 1);
- at_time = approxidate(date_spec);
- free(date_spec);
- len = am;
- break;
+ /* basic@{time or number} format to query ref-log */
+ reflog_len = at = 0;
+ if (str[len-1] == '}') {
+ for (at = 0; at < len - 1; at++) {
+ if (str[at] == '@' && str[at+1] == '{') {
+ reflog_len = (len-1) - (at+2);
+ len = at;
+ break;
+ }
}
}
/* Accept only unambiguous ref paths. */
- if (ambiguous_path(str, len))
+ if (len && ambiguous_path(str, len))
return -1;
- for (p = fmt; *p; p++) {
- this_result = refs_found ? sha1_from_ref : sha1;
- pathname = resolve_ref(git_path(*p, len, str), this_result, 1);
- if (pathname) {
- if (!refs_found++)
- real_path = xstrdup(pathname);
- if (!warn_ambiguous_refs)
- break;
- }
- }
+ if (!len && reflog_len) {
+ /* allow "@{...}" to mean the current branch reflog */
+ refs_found = dwim_ref("HEAD", 4, sha1, &real_ref);
+ } else if (reflog_len)
+ refs_found = dwim_log(str, len, sha1, &real_ref);
+ else
+ refs_found = dwim_ref(str, len, sha1, &real_ref);
if (!refs_found)
return -1;
if (warn_ambiguous_refs && refs_found > 1)
fprintf(stderr, warning, len, str);
- if (at_time != (unsigned long)-1) {
- read_ref_at(
- real_path + strlen(git_path(".")) - 1,
- at_time,
- sha1);
+ if (reflog_len) {
+ int nth, i;
+ unsigned long at_time;
+ unsigned long co_time;
+ int co_tz, co_cnt;
+
+ /* Is it asking for N-th entry, or approxidate? */
+ for (i = nth = 0; 0 <= nth && i < reflog_len; i++) {
+ char ch = str[at+2+i];
+ if ('0' <= ch && ch <= '9')
+ nth = nth * 10 + ch - '0';
+ else
+ nth = -1;
+ }
+ if (0 <= nth)
+ at_time = 0;
+ else
+ at_time = approxidate(str + at + 2);
+ if (read_ref_at(real_ref, at_time, nth, sha1, NULL,
+ &co_time, &co_tz, &co_cnt)) {
+ if (at_time)
+ fprintf(stderr,
+ "warning: Log for '%.*s' only goes "
+ "back to %s.\n", len, str,
+ show_rfc2822_date(co_time, co_tz));
+ else
+ fprintf(stderr,
+ "warning: Log for '%.*s' only has "
+ "%d entries.\n", len, str, co_cnt);
+ }
}
- free(real_path);
+ free(real_ref);
return 0;
}
return 0;
}
+static int get_describe_name(const char *name, int len, unsigned char *sha1)
+{
+ const char *cp;
+
+ for (cp = name + len - 1; name + 2 <= cp; cp--) {
+ char ch = *cp;
+ if (hexval(ch) & ~0377) {
+ /* We must be looking at g in "SOMETHING-g"
+ * for it to be describe output.
+ */
+ if (ch == 'g' && cp[-1] == '-') {
+ cp++;
+ len -= cp - name;
+ return get_short_sha1(cp, len, sha1, 1);
+ }
+ }
+ }
+ return -1;
+}
+
static int get_sha1_1(const char *name, int len, unsigned char *sha1)
{
int ret, has_suffix;
ret = get_sha1_basic(name, len, sha1);
if (!ret)
return 0;
+
+ /* It could be describe output that is "SOMETHING-gXXXX" */
+ ret = get_describe_name(name, len, sha1);
+ if (!ret)
+ return 0;
+
return get_short_sha1(name, len, sha1, 0);
}
+static int handle_one_ref(const char *path,
+ const unsigned char *sha1, int flag, void *cb_data)
+{
+ struct commit_list **list = cb_data;
+ struct object *object = parse_object(sha1);
+ if (!object)
+ return 0;
+ if (object->type == OBJ_TAG)
+ object = deref_tag(object, path, strlen(path));
+ if (object->type != OBJ_COMMIT)
+ return 0;
+ insert_by_date((struct commit *)object, list);
+ return 0;
+}
+
+/*
+ * This interprets names like ':/Initial revision of "git"' by searching
+ * through history and returning the first commit whose message starts
+ * with the given string.
+ *
+ * For future extension, ':/!' is reserved. If you want to match a message
+ * beginning with a '!', you have to repeat the exclamation mark.
+ */
+
+#define ONELINE_SEEN (1u<<20)
+static int get_sha1_oneline(const char *prefix, unsigned char *sha1)
+{
+ struct commit_list *list = NULL, *backup = NULL, *l;
+ int retval = -1;
+
+ if (prefix[0] == '!') {
+ if (prefix[1] != '!')
+ die ("Invalid search pattern: %s", prefix);
+ prefix++;
+ }
+ if (!save_commit_buffer)
+ return error("Could not expand oneline-name.");
+ for_each_ref(handle_one_ref, &list);
+ for (l = list; l; l = l->next)
+ commit_list_insert(l->item, &backup);
+ while (list) {
+ char *p;
+ struct commit *commit;
+
+ commit = pop_most_recent_commit(&list, ONELINE_SEEN);
+ parse_object(commit->object.sha1);
+ if (!commit->buffer || !(p = strstr(commit->buffer, "\n\n")))
+ continue;
+ if (!prefixcmp(p + 2, prefix)) {
+ hashcpy(sha1, commit->object.sha1);
+ retval = 0;
+ break;
+ }
+ }
+ free_commit_list(list);
+ for (l = backup; l; l = l->next)
+ clear_commit_marks(l->item, ONELINE_SEEN);
+ return retval;
+}
+
/*
* This is like "get_sha1_basic()", except it allows "sha1 expressions",
* notably "xyz^" for "parent of xyz"
int stage = 0;
struct cache_entry *ce;
int pos;
+ if (namelen > 2 && name[1] == '/')
+ return get_sha1_oneline(name + 2, sha1);
if (namelen < 3 ||
name[2] != ':' ||
name[1] < '0' || '3' < name[1])