X-Git-Url: https://git.octo.it/?a=blobdiff_plain;f=sha1_name.c;h=4f92e12a8dfce29b5bb50108468259d9f04653f3;hb=7b0c996679e975b666fd27c922e1e0837b611c98;hp=4e9a052333dcbb538866766f68b4fe18f615fe4d;hpb=013f276eb78967f9742654ebde303c2fbe7a6cd6;p=git.git diff --git a/sha1_name.c b/sha1_name.c index 4e9a0523..4f92e12a 100644 --- a/sha1_name.c +++ b/sha1_name.c @@ -1,5 +1,8 @@ #include "cache.h" +#include "tag.h" #include "commit.h" +#include "tree.h" +#include "blob.h" static int find_short_object_filename(int len, const char *name, unsigned char *sha1) { @@ -140,7 +143,7 @@ static int find_unique_short_object(int len, char *canonical, } /* Both have unique ones -- do they match? */ if (memcmp(packed_sha1, unpacked_sha1, 20)) - return -2; + return SHORT_NAME_AMBIGUOUS; memcpy(sha1, packed_sha1, 20); return 0; } @@ -152,7 +155,7 @@ static int get_short_sha1(const char *name, int len, unsigned char *sha1, char canonical[40]; unsigned char res[20]; - if (len < 4) + if (len < MINIMUM_ABBREV) return -1; memset(res, 0, 20); memset(canonical, 'x', 40); @@ -183,13 +186,18 @@ static int get_short_sha1(const char *name, int len, unsigned char *sha1, const char *find_unique_abbrev(const unsigned char *sha1, int len) { - int status; + int status, is_null; static char hex[41]; + + is_null = !memcmp(sha1, null_sha1, 20); memcpy(hex, sha1_to_hex(sha1), 40); + if (len == 40) + return hex; while (len < 40) { unsigned char sha1_ret[20]; status = get_short_sha1(hex, len, sha1_ret, 1); - if (!status) { + if (!status || + (is_null && status != SHORT_NAME_AMBIGUOUS)) { hex[len] = 0; return hex; } @@ -200,26 +208,71 @@ const char *find_unique_abbrev(const unsigned char *sha1, int len) return NULL; } +static int ambiguous_path(const char *path, int len) +{ + int slash = 1; + int cnt; + + for (cnt = 0; cnt < len; cnt++) { + switch (*path++) { + case '\0': + break; + case '/': + if (slash) + break; + slash = 1; + continue; + case '.': + continue; + default: + slash = 0; + continue; + } + break; + } + return slash; +} + static int get_sha1_basic(const char *str, int len, unsigned char *sha1) { - static const char *prefix[] = { - "", - "refs", - "refs/tags", - "refs/heads", + static const char *fmt[] = { + "%.*s", + "refs/%.*s", + "refs/tags/%.*s", + "refs/heads/%.*s", + "refs/remotes/%.*s", + "refs/remotes/%.*s/HEAD", NULL }; const char **p; + const char *warning = "warning: refname '%.*s' is ambiguous.\n"; + char *pathname; + int already_found = 0; + unsigned char *this_result; + unsigned char sha1_from_ref[20]; if (len == 40 && !get_sha1_hex(str, sha1)) return 0; - for (p = prefix; *p; p++) { - char *pathname = git_path("%s/%.*s", *p, len, str); - if (!read_ref(pathname, sha1)) - return 0; - } + /* 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; + } + } + if (already_found) + return 0; return -1; } @@ -274,47 +327,122 @@ static int get_nth_ancestor(const char *name, int len, return 0; } -static int get_sha1_1(const char *name, int len, unsigned char *sha1) +static int peel_onion(const char *name, int len, unsigned char *sha1) { - int parent, ret; - const char *cp; + unsigned char outer[20]; + const char *sp; + const char *type_string = NULL; + struct object *o; - /* foo^[0-9] or foo^ (== foo^1); we do not do more than 9 parents. */ - if (len > 2 && name[len-2] == '^' && - name[len-1] >= '0' && name[len-1] <= '9') { - parent = name[len-1] - '0'; - len -= 2; + /* + * "ref^{type}" dereferences ref repeatedly until you cannot + * dereference anymore, or you get an object of given type, + * whichever comes first. "ref^{}" means just dereference + * tags until you get a non-tag. "ref^0" is a shorthand for + * "ref^{commit}". "commit^{tree}" could be used to find the + * top-level tree of the given commit. + */ + if (len < 4 || name[len-1] != '}') + return -1; + + for (sp = name + len - 1; name <= sp; sp--) { + int ch = *sp; + if (ch == '{' && name < sp && sp[-1] == '^') + break; + } + if (sp <= name) + return -1; + + sp++; /* beginning of type name, or closing brace for empty */ + if (!strncmp(commit_type, sp, 6) && sp[6] == '}') + type_string = commit_type; + else if (!strncmp(tree_type, sp, 4) && sp[4] == '}') + type_string = tree_type; + else if (!strncmp(blob_type, sp, 4) && sp[4] == '}') + type_string = blob_type; + else if (sp[0] == '}') + type_string = NULL; + else + return -1; + + if (get_sha1_1(name, sp - name - 2, outer)) + return -1; + + o = parse_object(outer); + if (!o) + return -1; + if (!type_string) { + o = deref_tag(o, name, sp - name - 2); + if (!o || (!o->parsed && !parse_object(o->sha1))) + return -1; + memcpy(sha1, o->sha1, 20); + } + else { + /* 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 == type_string) { + memcpy(sha1, o->sha1, 20); + return 0; + } + if (o->type == tag_type) + o = ((struct tag*) o)->tagged; + else if (o->type == commit_type) + 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); + if (!o->parsed) + parse_object(o->sha1); + } } - else if (len > 1 && name[len-1] == '^') { - parent = 1; - len--; - } else - parent = -1; + return 0; +} - if (parent >= 0) - return get_parent(name, len, sha1, parent); +static int get_sha1_1(const char *name, int len, unsigned char *sha1) +{ + int ret, has_suffix; + const char *cp; /* "name~3" is "name^^^", - * "name~12" is "name^^^^^^^^^^^^", and * "name~" and "name~0" are name -- not "name^0"! + * "name^" is not "name^0"; it is "name^1". */ - parent = 0; + has_suffix = 0; for (cp = name + len - 1; name <= cp; cp--) { int ch = *cp; if ('0' <= ch && ch <= '9') continue; - if (ch != '~') - parent = -1; + if (ch == '~' || ch == '^') + has_suffix = ch; break; } - if (!parent && *cp == '~') { + + if (has_suffix) { + int num = 0; int len1 = cp - name; cp++; while (cp < name + len) - parent = parent * 10 + *cp++ - '0'; - return get_nth_ancestor(name, len1, sha1, parent); + num = num * 10 + *cp++ - '0'; + if (has_suffix == '^') { + if (!num && len1 == len - 1) + num = 1; + return get_parent(name, len1, sha1, num); + } + /* else if (has_suffix == '~') -- goes without saying */ + return get_nth_ancestor(name, len1, sha1, num); } + ret = peel_onion(name, len, sha1); + if (!ret) + return 0; + ret = get_sha1_basic(name, len, sha1); if (!ret) return 0;