static int find_short_packed_object(int len, const unsigned char *match, unsigned char *sha1)
{
struct packed_git *p;
- unsigned char found_sha1[20];
+ const unsigned char *found_sha1 = NULL;
int found = 0;
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, last;
+ uint32_t first = 0;
+ open_pack_index(p);
+ num = p->num_objects;
+ last = num;
while (first < last) {
- unsigned mid = (first + last) / 2;
- unsigned char now[20];
+ uint32_t mid = (first + last) / 2;
+ const unsigned char *now;
int cmp;
- nth_packed_object_sha1(p, mid, now);
+ now = nth_packed_object_sha1(p, mid);
cmp = hashcmp(match, now);
if (!cmp) {
first = mid;
last = mid;
}
if (first < num) {
- unsigned char now[20], next[20];
- nth_packed_object_sha1(p, first, now);
+ const unsigned char *now, *next;
+ now = nth_packed_object_sha1(p, first);
if (match_sha(len, match, now)) {
- if (nth_packed_object_sha1(p, first+1, next) ||
- !match_sha(len, match, next)) {
+ next = nth_packed_object_sha1(p, first+1);
+ if (!next|| !match_sha(len, match, next)) {
/* unique within this pack */
if (!found) {
- hashcpy(found_sha1, now);
+ found_sha1 = now;
found++;
}
else if (hashcmp(found_sha1, now)) {
int has_unpacked, has_packed;
unsigned char unpacked_sha1[20], packed_sha1[20];
+ prepare_alt_odb();
has_unpacked = find_short_object_filename(len, canonical, unpacked_sha1);
has_packed = find_short_packed_object(len, res, packed_sha1);
if (!has_unpacked && !has_packed)
const char *find_unique_abbrev(const unsigned char *sha1, int len)
{
- int status, is_null;
+ int status, exists;
static char hex[41];
- is_null = is_null_sha1(sha1);
+ exists = has_sha1_file(sha1);
memcpy(hex, sha1_to_hex(sha1), 40);
if (len == 40 || !len)
return hex;
while (len < 40) {
unsigned char sha1_ret[20];
status = get_short_sha1(hex, len, sha1_ret, 1);
- if (!status ||
- (is_null && status != SHORT_NAME_AMBIGUOUS)) {
+ if (exists
+ ? !status
+ : status == SHORT_NAME_NOT_FOUND) {
hex[len] = 0;
return hex;
}
- if (status != SHORT_NAME_AMBIGUOUS)
- return NULL;
len++;
}
- return NULL;
+ return hex;
}
static int ambiguous_path(const char *path, int len)
return slash;
}
+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_rev_parse_rules; *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_rev_parse_rules; *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, 1, 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, *ref;
char *real_ref = NULL;
int refs_found = 0;
int at, reflog_len;
- unsigned char *this_result;
- unsigned char sha1_from_ref[20];
if (len == 40 && !get_sha1_hex(str, sha1))
return 0;
/* basic@{time or number} format to query ref-log */
reflog_len = at = 0;
if (str[len-1] == '}') {
- for (at = 1; at < len - 1; at++) {
+ for (at = 0; at < len - 1; at++) {
if (str[at] == '@' && str[at+1] == '{') {
reflog_len = (len-1) - (at+2);
len = at;
}
/* 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;
- ref = resolve_ref(mkpath(*p, len, str), this_result, 1, NULL);
- if (ref) {
- if (!refs_found++)
- real_ref = xstrdup(ref);
- 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;
fprintf(stderr, warning, len, str);
if (reflog_len) {
- /* Is it asking for N-th entry, or approxidate? */
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')
else
nth = -1;
}
- if (0 <= nth)
+ if (100000000 <= nth) {
+ at_time = nth;
+ nth = -1;
+ } else if (0 <= nth)
at_time = 0;
- else
- at_time = approxidate(str + at + 2);
- read_ref_at(real_ref, at_time, nth, sha1);
+ else {
+ char *tmp = xstrndup(str + at + 2, reflog_len);
+ at_time = approxidate(tmp);
+ free(tmp);
+ }
+ 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_date(co_time, co_tz, DATE_RFC2822));
+ else
+ fprintf(stderr,
+ "warning: Log for '%.*s' only has "
+ "%d entries.\n", len, str, co_cnt);
+ }
}
free(real_ref);
unsigned char *result, int generation)
{
unsigned char sha1[20];
- int ret = get_sha1_1(name, len, sha1);
+ struct commit *commit;
+ int ret;
+
+ ret = get_sha1_1(name, len, sha1);
if (ret)
return ret;
+ commit = lookup_commit_reference(sha1);
+ if (!commit)
+ return -1;
while (generation--) {
- struct commit *commit = lookup_commit_reference(sha1);
-
- if (!commit || parse_commit(commit) || !commit->parents)
+ if (parse_commit(commit) || !commit->parents)
return -1;
- hashcpy(sha1, commit->parents->item->object.sha1);
+ commit = commit->parents->item;
}
- hashcpy(result, sha1);
+ hashcpy(result, commit->object.sha1);
return 0;
}
+struct object *peel_to_type(const char *name, int namelen,
+ struct object *o, enum object_type expected_type)
+{
+ if (name && !namelen)
+ namelen = strlen(name);
+ if (!o) {
+ unsigned char sha1[20];
+ if (get_sha1_1(name, namelen, sha1))
+ return NULL;
+ o = parse_object(sha1);
+ }
+ while (1) {
+ if (!o || (!o->parsed && !parse_object(o->sha1)))
+ return NULL;
+ if (o->type == expected_type)
+ return o;
+ if (o->type == OBJ_TAG)
+ o = ((struct tag*) o)->tagged;
+ else if (o->type == OBJ_COMMIT)
+ o = &(((struct commit *) o)->tree->object);
+ else {
+ if (name)
+ error("%.*s: expected %s type, but the object "
+ "dereferences to %s type",
+ namelen, name, typename(expected_type),
+ typename(o->type));
+ return NULL;
+ }
+ }
+}
+
static int peel_onion(const char *name, int len, unsigned char *sha1)
{
unsigned char outer[20];
hashcpy(sha1, o->sha1);
}
else {
- /* At this point, the syntax look correct, so
+ /*
+ * At this point, the syntax look correct, so
* if we do not get the needed object, we should
* barf.
*/
-
- while (1) {
- if (!o || (!o->parsed && !parse_object(o->sha1)))
- return -1;
- if (o->type == expected_type) {
- hashcpy(sha1, o->sha1);
- return 0;
- }
- if (o->type == OBJ_TAG)
- o = ((struct tag*) o)->tagged;
- else if (o->type == OBJ_COMMIT)
- o = &(((struct commit *) o)->tree->object);
- else
- return error("%.*s: expected %s type, but the object dereferences to %s type",
- len, name, typename(expected_type),
- typename(o->type));
- if (!o->parsed)
- parse_object(o->sha1);
+ o = peel_to_type(name, len, o, expected_type);
+ if (o) {
+ hashcpy(sha1, o->sha1);
+ return 0;
}
+ return -1;
}
return 0;
}
int ret, has_suffix;
const char *cp;
- /* "name~3" is "name^^^",
- * "name~" and "name~0" are name -- not "name^0"!
- * "name^" is not "name^0"; it is "name^1".
+ /*
+ * "name~3" is "name^^^", "name~" is "name~1", and "name^" is "name^1".
*/
has_suffix = 0;
for (cp = name + len - 1; name <= cp; cp--) {
cp++;
while (cp < name + len)
num = num * 10 + *cp++ - '0';
- if (has_suffix == '^') {
- if (!num && len1 == len - 1)
- num = 1;
+ if (!num && len1 == len - 1)
+ num = 1;
+ if (has_suffix == '^')
return get_parent(name, len1, sha1, num);
- }
/* else if (has_suffix == '~') -- goes without saying */
return get_nth_ancestor(name, len1, sha1, num);
}
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)
+ return 0;
+ }
+ 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;
+ char *temp_commit_buffer = NULL;
+
+ if (prefix[0] == '!') {
+ if (prefix[1] != '!')
+ die ("Invalid search pattern: %s", prefix);
+ prefix++;
+ }
+ 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;
+ enum object_type type;
+ unsigned long size;
+
+ commit = pop_most_recent_commit(&list, ONELINE_SEEN);
+ if (!parse_object(commit->object.sha1))
+ continue;
+ free(temp_commit_buffer);
+ if (commit->buffer)
+ p = commit->buffer;
+ else {
+ p = read_sha1_file(commit->object.sha1, &type, &size);
+ if (!p)
+ continue;
+ temp_commit_buffer = p;
+ }
+ if (!(p = strstr(p, "\n\n")))
+ continue;
+ if (!prefixcmp(p + 2, prefix)) {
+ hashcpy(sha1, commit->object.sha1);
+ retval = 0;
+ break;
+ }
+ }
+ free(temp_commit_buffer);
+ 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 get_sha1(const char *name, unsigned char *sha1)
{
- int ret, bracket_depth;
unsigned unused;
+ return get_sha1_with_mode(name, sha1, &unused);
+}
+
+int get_sha1_with_mode(const char *name, unsigned char *sha1, unsigned *mode)
+{
+ int ret, bracket_depth;
int namelen = strlen(name);
const char *cp;
- prepare_alt_odb();
+ *mode = S_IFINVALID;
ret = get_sha1_1(name, namelen, sha1);
if (!ret)
return ret;
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])
namelen = namelen - (cp - name);
if (!active_cache)
read_cache();
- if (active_nr < 0)
- return -1;
pos = cache_name_pos(cp, namelen);
if (pos < 0)
pos = -pos - 1;
break;
if (ce_stage(ce) == stage) {
hashcpy(sha1, ce->sha1);
+ *mode = ce->ce_mode;
return 0;
}
pos++;
unsigned char tree_sha1[20];
if (!get_sha1_1(name, cp-name, tree_sha1))
return get_tree_entry(tree_sha1, cp+1, sha1,
- &unused);
+ mode);
}
return ret;
}