4 static int find_short_object_filename(int len, const char *name, unsigned char *sha1)
6 struct alternate_object_database *alt;
9 static struct alternate_object_database *fakeent;
12 const char *objdir = get_object_directory();
13 int objdir_len = strlen(objdir);
14 int entlen = objdir_len + 43;
15 fakeent = xmalloc(sizeof(*fakeent) + entlen);
16 memcpy(fakeent->base, objdir, objdir_len);
17 fakeent->name = fakeent->base + objdir_len + 1;
18 fakeent->name[-1] = '/';
20 fakeent->next = alt_odb_list;
22 sprintf(hex, "%.2s", name);
23 for (alt = fakeent; alt && found < 2; alt = alt->next) {
26 sprintf(alt->name, "%.2s/", name);
27 dir = opendir(alt->base);
30 while ((de = readdir(dir)) != NULL) {
31 if (strlen(de->d_name) != 38)
33 if (memcmp(de->d_name, name + 2, len - 2))
36 memcpy(hex + 2, de->d_name, 38);
39 else if (memcmp(hex + 2, de->d_name, 38)) {
47 return get_sha1_hex(hex, sha1) == 0;
51 static int match_sha(unsigned len, const unsigned char *a, const unsigned char *b)
66 static int find_short_packed_object(int len, const unsigned char *match, unsigned char *sha1)
69 unsigned char found_sha1[20];
73 for (p = packed_git; p && found < 2; p = p->next) {
74 unsigned num = num_packed_objects(p);
75 unsigned first = 0, last = num;
76 while (first < last) {
77 unsigned mid = (first + last) / 2;
78 unsigned char now[20];
81 nth_packed_object_sha1(p, mid, now);
82 cmp = memcmp(match, now, 20);
94 unsigned char now[20];
95 nth_packed_object_sha1(p, first, now);
96 if (match_sha(len, match, now)) {
98 memcpy(found_sha1, now, 20);
101 else if (memcmp(found_sha1, now, 20)) {
109 memcpy(sha1, found_sha1, 20);
113 static int find_unique_short_object(int len, char *canonical,
114 unsigned char *res, unsigned char *sha1)
116 int has_unpacked, has_packed;
117 unsigned char unpacked_sha1[20], packed_sha1[20];
119 has_unpacked = find_short_object_filename(len, canonical, unpacked_sha1);
120 has_packed = find_short_packed_object(len, res, packed_sha1);
121 if (!has_unpacked && !has_packed)
123 if (1 < has_unpacked || 1 < has_packed)
125 if (has_unpacked != has_packed) {
126 memcpy(sha1, (has_packed ? packed_sha1 : unpacked_sha1), 20);
129 /* Both have unique ones -- do they match? */
130 if (memcmp(packed_sha1, unpacked_sha1, 20))
131 return error("short SHA1 %.*s is ambiguous.", len, canonical);
132 memcpy(sha1, packed_sha1, 20);
136 static int get_short_sha1(const char *name, int len, unsigned char *sha1)
140 unsigned char res[20];
145 memset(canonical, 'x', 40);
146 for (i = 0; i < len ;i++) {
147 unsigned char c = name[i];
149 if (c >= '0' && c <= '9')
151 else if (c >= 'a' && c <= 'f')
153 else if (c >= 'A' && c <='F') {
165 return find_unique_short_object(i, canonical, res, sha1);
168 static int get_sha1_basic(const char *str, int len, unsigned char *sha1)
170 static const char *prefix[] = {
179 if (len == 40 && !get_sha1_hex(str, sha1))
182 for (p = prefix; *p; p++) {
183 char *pathname = git_path("%s/%.*s", *p, len, str);
184 if (!read_ref(pathname, sha1))
191 static int get_sha1_1(const char *name, int len, unsigned char *sha1);
193 static int get_parent(const char *name, int len,
194 unsigned char *result, int idx)
196 unsigned char sha1[20];
197 int ret = get_sha1_1(name, len, sha1);
198 struct commit *commit;
199 struct commit_list *p;
203 commit = lookup_commit_reference(sha1);
206 if (parse_commit(commit))
209 memcpy(result, commit->object.sha1, 20);
215 memcpy(result, p->item->object.sha1, 20);
223 static int get_nth_ancestor(const char *name, int len,
224 unsigned char *result, int generation)
226 unsigned char sha1[20];
227 int ret = get_sha1_1(name, len, sha1);
231 while (generation--) {
232 struct commit *commit = lookup_commit_reference(sha1);
234 if (!commit || parse_commit(commit) || !commit->parents)
236 memcpy(sha1, commit->parents->item->object.sha1, 20);
238 memcpy(result, sha1, 20);
242 static int get_sha1_1(const char *name, int len, unsigned char *sha1)
247 /* foo^[0-9] or foo^ (== foo^1); we do not do more than 9 parents. */
248 if (len > 2 && name[len-2] == '^' &&
249 name[len-1] >= '0' && name[len-1] <= '9') {
250 parent = name[len-1] - '0';
253 else if (len > 1 && name[len-1] == '^') {
260 return get_parent(name, len, sha1, parent);
262 /* "name~3" is "name^^^",
263 * "name~12" is "name^^^^^^^^^^^^", and
264 * "name~" and "name~0" are name -- not "name^0"!
267 for (cp = name + len - 1; name <= cp; cp--) {
269 if ('0' <= ch && ch <= '9')
275 if (!parent && *cp == '~') {
276 int len1 = cp - name;
278 while (cp < name + len)
279 parent = parent * 10 + *cp++ - '0';
280 return get_nth_ancestor(name, len1, sha1, parent);
283 ret = get_sha1_basic(name, len, sha1);
286 return get_short_sha1(name, len, sha1);
290 * This is like "get_sha1_basic()", except it allows "sha1 expressions",
291 * notably "xyz^" for "parent of xyz"
293 int get_sha1(const char *name, unsigned char *sha1)
296 return get_sha1_1(name, strlen(name), sha1);