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)
int dwim_ref(const char *str, int len, unsigned char *sha1, char **ref)
{
- static const char *fmt[] = {
- "%.*s",
- "refs/%.*s",
- "refs/tags/%.*s",
- "refs/heads/%.*s",
- "refs/remotes/%.*s",
- "refs/remotes/%.*s/HEAD",
- NULL
- };
const char **p, *r;
int refs_found = 0;
*ref = NULL;
- for (p = fmt; *p; p++) {
+ for (p = ref_rev_parse_rules; *p; p++) {
unsigned char sha1_from_ref[20];
unsigned char *this_result;
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, 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 *warning = "warning: refname '%.*s' is ambiguous.\n";
/* 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;
- refs_found = dwim_ref(str, len, sha1, &real_ref);
+ 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')
fprintf(stderr,
"warning: Log for '%.*s' only goes "
"back to %s.\n", len, str,
- show_rfc2822_date(co_time, co_tz));
+ show_date(co_time, co_tz, DATE_RFC2822));
else
fprintf(stderr,
"warning: Log for '%.*s' only has "
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;
}
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);
+ parse_object(commit->object.sha1);
+ if (temp_commit_buffer)
+ 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;
+ }
+ }
+ if (temp_commit_buffer)
+ 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;
}