#include "commit.h"
#include "tree.h"
#include "blob.h"
-#include "diff.h"
+#include "tree-walk.h"
+#include "refs.h"
static int find_short_object_filename(int len, const char *name, unsigned char *sha1)
{
"refs/remotes/%.*s/HEAD",
NULL
};
- const char **p;
- const char *warning = "warning: refname '%.*s' is ambiguous.\n";
- char *pathname;
- int already_found = 0;
+ 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];
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);
+ safe_strncpy(date_spec, str + am + 2, date_len + 1);
+ at_time = approxidate(date_spec);
+ free(date_spec);
+ len = am;
+ break;
+ }
+ }
+
/* Accept only unambiguous ref paths. */
if (ambiguous_path(str, len))
return -1;
for (p = fmt; *p; p++) {
- this_result = already_found ? sha1_from_ref : sha1;
- pathname = git_path(*p, len, str);
- if (!read_ref(pathname, this_result)) {
- if (warn_ambiguous_refs) {
- if (already_found)
- fprintf(stderr, warning, len, str);
- already_found++;
- }
- else
- return 0;
+ 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 = strdup(pathname);
+ if (!warn_ambiguous_refs)
+ break;
}
}
- if (already_found)
- return 0;
- return -1;
+
+ 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);
+ }
+
+ free(real_path);
+ return 0;
}
static int get_sha1_1(const char *name, int len, unsigned char *sha1);
{
unsigned char outer[20];
const char *sp;
- const char *type_string = NULL;
+ unsigned int expected_type = 0;
struct object *o;
/*
sp++; /* beginning of type name, or closing brace for empty */
if (!strncmp(commit_type, sp, 6) && sp[6] == '}')
- type_string = commit_type;
+ expected_type = TYPE_COMMIT;
else if (!strncmp(tree_type, sp, 4) && sp[4] == '}')
- type_string = tree_type;
+ expected_type = TYPE_TREE;
else if (!strncmp(blob_type, sp, 4) && sp[4] == '}')
- type_string = blob_type;
+ expected_type = TYPE_BLOB;
else if (sp[0] == '}')
- type_string = NULL;
+ expected_type = TYPE_NONE;
else
return -1;
o = parse_object(outer);
if (!o)
return -1;
- if (!type_string) {
+ if (!expected_type) {
o = deref_tag(o, name, sp - name - 2);
if (!o || (!o->parsed && !parse_object(o->sha1)))
return -1;
while (1) {
if (!o || (!o->parsed && !parse_object(o->sha1)))
return -1;
- if (o->type == type_string) {
+ if (o->type == expected_type) {
memcpy(sha1, o->sha1, 20);
return 0;
}
- if (o->type == tag_type)
+ if (o->type == TYPE_TAG)
o = ((struct tag*) o)->tagged;
- else if (o->type == commit_type)
+ else if (o->type == TYPE_COMMIT)
o = &(((struct commit *) o)->tree->object);
else
return error("%.*s: expected %s type, but the object dereferences to %s type",
- len, name, type_string,
- o->type);
+ len, name, typename(expected_type),
+ typename(o->type));
if (!o->parsed)
parse_object(o->sha1);
}
return get_short_sha1(name, len, sha1, 0);
}
-static int get_tree_entry(const unsigned char *, const char *, unsigned char *, unsigned *);
-
-static int find_tree_entry(struct tree_desc *t, const char *name, unsigned char *result, unsigned *mode)
-{
- int namelen = strlen(name);
- while (t->size) {
- const char *entry;
- const unsigned char *sha1;
- int entrylen, cmp;
-
- sha1 = tree_entry_extract(t, &entry, mode);
- update_tree_entry(t);
- entrylen = strlen(entry);
- if (entrylen > namelen)
- continue;
- cmp = memcmp(name, entry, entrylen);
- if (cmp > 0)
- continue;
- if (cmp < 0)
- break;
- if (entrylen == namelen) {
- memcpy(result, sha1, 20);
- return 0;
- }
- if (name[entrylen] != '/')
- continue;
- if (!S_ISDIR(*mode))
- break;
- if (++entrylen == namelen) {
- memcpy(result, sha1, 20);
- return 0;
- }
- return get_tree_entry(sha1, name + entrylen, result, mode);
- }
- return -1;
-}
-
-static int get_tree_entry(const unsigned char *tree_sha1, const char *name, unsigned char *sha1, unsigned *mode)
-{
- int retval;
- void *tree;
- struct tree_desc t;
-
- tree = read_object_with_reference(tree_sha1, tree_type, &t.size, NULL);
- if (!tree)
- return -1;
- t.buf = tree;
- retval = find_tree_entry(&t, name, sha1, mode);
- free(tree);
- 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;
+ int ret, bracket_depth;
unsigned unused;
+ int namelen = strlen(name);
+ const char *cp;
prepare_alt_odb();
- ret = get_sha1_1(name, strlen(name), sha1);
- if (ret < 0) {
- const char *cp = strchr(name, ':');
- if (cp) {
- unsigned char tree_sha1[20];
- if (!get_sha1_1(name, cp-name, tree_sha1))
- return get_tree_entry(tree_sha1, cp+1, sha1,
- &unused);
+ ret = get_sha1_1(name, namelen, sha1);
+ if (!ret)
+ return ret;
+ /* sha1:path --> object name of path in ent sha1
+ * :path -> object name of path in index
+ * :[0-3]:path -> object name of path in index at stage
+ */
+ if (name[0] == ':') {
+ int stage = 0;
+ struct cache_entry *ce;
+ int pos;
+ if (namelen < 3 ||
+ name[2] != ':' ||
+ name[1] < '0' || '3' < name[1])
+ cp = name + 1;
+ else {
+ stage = name[1] - '0';
+ cp = name + 3;
}
+ 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;
+ while (pos < active_nr) {
+ ce = active_cache[pos];
+ if (ce_namelen(ce) != namelen ||
+ memcmp(ce->name, cp, namelen))
+ break;
+ if (ce_stage(ce) == stage) {
+ memcpy(sha1, ce->sha1, 20);
+ return 0;
+ }
+ pos++;
+ }
+ return -1;
+ }
+ for (cp = name, bracket_depth = 0; *cp; cp++) {
+ if (*cp == '{')
+ bracket_depth++;
+ else if (bracket_depth && *cp == '}')
+ bracket_depth--;
+ else if (!bracket_depth && *cp == ':')
+ break;
+ }
+ if (*cp == ':') {
+ unsigned char tree_sha1[20];
+ if (!get_sha1_1(name, cp-name, tree_sha1))
+ return get_tree_entry(tree_sha1, cp+1, sha1,
+ &unused);
}
return ret;
}