7 static int find_short_object_filename(int len
, const char *name
, unsigned char *sha1
)
9 struct alternate_object_database
*alt
;
12 static struct alternate_object_database
*fakeent
;
15 const char *objdir
= get_object_directory();
16 int objdir_len
= strlen(objdir
);
17 int entlen
= objdir_len
+ 43;
18 fakeent
= xmalloc(sizeof(*fakeent
) + entlen
);
19 memcpy(fakeent
->base
, objdir
, objdir_len
);
20 fakeent
->name
= fakeent
->base
+ objdir_len
+ 1;
21 fakeent
->name
[-1] = '/';
23 fakeent
->next
= alt_odb_list
;
25 sprintf(hex
, "%.2s", name
);
26 for (alt
= fakeent
; alt
&& found
< 2; alt
= alt
->next
) {
29 sprintf(alt
->name
, "%.2s/", name
);
30 dir
= opendir(alt
->base
);
33 while ((de
= readdir(dir
)) != NULL
) {
34 if (strlen(de
->d_name
) != 38)
36 if (memcmp(de
->d_name
, name
+ 2, len
- 2))
39 memcpy(hex
+ 2, de
->d_name
, 38);
42 else if (memcmp(hex
+ 2, de
->d_name
, 38)) {
50 return get_sha1_hex(hex
, sha1
) == 0;
54 static int match_sha(unsigned len
, const unsigned char *a
, const unsigned char *b
)
69 static int find_short_packed_object(int len
, const unsigned char *match
, unsigned char *sha1
)
72 unsigned char found_sha1
[20];
76 for (p
= packed_git
; p
&& found
< 2; p
= p
->next
) {
77 unsigned num
= num_packed_objects(p
);
78 unsigned first
= 0, last
= num
;
79 while (first
< last
) {
80 unsigned mid
= (first
+ last
) / 2;
81 unsigned char now
[20];
84 nth_packed_object_sha1(p
, mid
, now
);
85 cmp
= memcmp(match
, now
, 20);
97 unsigned char now
[20], next
[20];
98 nth_packed_object_sha1(p
, first
, now
);
99 if (match_sha(len
, match
, now
)) {
100 if (nth_packed_object_sha1(p
, first
+1, next
) ||
101 !match_sha(len
, match
, next
)) {
102 /* unique within this pack */
104 memcpy(found_sha1
, now
, 20);
107 else if (memcmp(found_sha1
, now
, 20)) {
113 /* not even unique within this pack */
121 memcpy(sha1
, found_sha1
, 20);
125 static int find_unique_short_object(int len
, char *canonical
,
126 unsigned char *res
, unsigned char *sha1
)
128 int has_unpacked
, has_packed
;
129 unsigned char unpacked_sha1
[20], packed_sha1
[20];
131 has_unpacked
= find_short_object_filename(len
, canonical
, unpacked_sha1
);
132 has_packed
= find_short_packed_object(len
, res
, packed_sha1
);
133 if (!has_unpacked
&& !has_packed
)
135 if (1 < has_unpacked
|| 1 < has_packed
)
136 return error("short SHA1 %.*s is ambiguous.", len
, canonical
);
137 if (has_unpacked
!= has_packed
) {
138 memcpy(sha1
, (has_packed
? packed_sha1
: unpacked_sha1
), 20);
141 /* Both have unique ones -- do they match? */
142 if (memcmp(packed_sha1
, unpacked_sha1
, 20))
143 return error("short SHA1 %.*s is ambiguous.", len
, canonical
);
144 memcpy(sha1
, packed_sha1
, 20);
148 static int get_short_sha1(const char *name
, int len
, unsigned char *sha1
)
152 unsigned char res
[20];
157 memset(canonical
, 'x', 40);
158 for (i
= 0; i
< len
;i
++) {
159 unsigned char c
= name
[i
];
161 if (c
>= '0' && c
<= '9')
163 else if (c
>= 'a' && c
<= 'f')
165 else if (c
>= 'A' && c
<='F') {
177 return find_unique_short_object(i
, canonical
, res
, sha1
);
180 static int get_sha1_basic(const char *str
, int len
, unsigned char *sha1
)
182 static const char *prefix
[] = {
191 if (len
== 40 && !get_sha1_hex(str
, sha1
))
194 for (p
= prefix
; *p
; p
++) {
195 char *pathname
= git_path("%s/%.*s", *p
, len
, str
);
196 if (!read_ref(pathname
, sha1
))
203 static int get_sha1_1(const char *name
, int len
, unsigned char *sha1
);
205 static int get_parent(const char *name
, int len
,
206 unsigned char *result
, int idx
)
208 unsigned char sha1
[20];
209 int ret
= get_sha1_1(name
, len
, sha1
);
210 struct commit
*commit
;
211 struct commit_list
*p
;
215 commit
= lookup_commit_reference(sha1
);
218 if (parse_commit(commit
))
221 memcpy(result
, commit
->object
.sha1
, 20);
227 memcpy(result
, p
->item
->object
.sha1
, 20);
235 static int get_nth_ancestor(const char *name
, int len
,
236 unsigned char *result
, int generation
)
238 unsigned char sha1
[20];
239 int ret
= get_sha1_1(name
, len
, sha1
);
243 while (generation
--) {
244 struct commit
*commit
= lookup_commit_reference(sha1
);
246 if (!commit
|| parse_commit(commit
) || !commit
->parents
)
248 memcpy(sha1
, commit
->parents
->item
->object
.sha1
, 20);
250 memcpy(result
, sha1
, 20);
254 static int peel_onion(const char *name
, int len
, unsigned char *sha1
)
256 unsigned char outer
[20];
258 const char *type_string
= NULL
;
262 * "ref^{type}" dereferences ref repeatedly until you cannot
263 * dereference anymore, or you get an object of given type,
264 * whichever comes first. "ref^{}" means just dereference
265 * tags until you get a non-tag. "ref^0" is a shorthand for
266 * "ref^{commit}". "commit^{tree}" could be used to find the
267 * top-level tree of the given commit.
269 if (len
< 4 || name
[len
-1] != '}')
272 for (sp
= name
+ len
- 1; name
<= sp
; sp
--) {
274 if (ch
== '{' && name
< sp
&& sp
[-1] == '^')
280 sp
++; /* beginning of type name, or closing brace for empty */
281 if (!strncmp(commit_type
, sp
, 6) && sp
[6] == '}')
282 type_string
= commit_type
;
283 else if (!strncmp(tree_type
, sp
, 4) && sp
[4] == '}')
284 type_string
= tree_type
;
285 else if (!strncmp(blob_type
, sp
, 4) && sp
[4] == '}')
286 type_string
= blob_type
;
287 else if (sp
[0] == '}')
292 if (get_sha1_1(name
, sp
- name
- 2, outer
))
295 o
= parse_object(outer
);
300 memcpy(sha1
, o
->sha1
, 20);
303 /* At this point, the syntax look correct, so
304 * if we do not get the needed object, we should
311 if (o
->type
== type_string
) {
312 memcpy(sha1
, o
->sha1
, 20);
315 if (o
->type
== tag_type
)
316 o
= ((struct tag
*) o
)->tagged
;
317 else if (o
->type
== commit_type
)
318 o
= &(((struct commit
*) o
)->tree
->object
);
320 return error("%.*s: expected %s type, but the object dereferences to %s type",
321 len
, name
, type_string
,
324 parse_object(o
->sha1
);
330 static int get_sha1_1(const char *name
, int len
, unsigned char *sha1
)
335 /* foo^[0-9] or foo^ (== foo^1); we do not do more than 9 parents. */
336 if (len
> 2 && name
[len
-2] == '^' &&
337 name
[len
-1] >= '0' && name
[len
-1] <= '9') {
338 parent
= name
[len
-1] - '0';
341 else if (len
> 1 && name
[len
-1] == '^') {
348 return get_parent(name
, len
, sha1
, parent
);
350 /* "name~3" is "name^^^",
351 * "name~12" is "name^^^^^^^^^^^^", and
352 * "name~" and "name~0" are name -- not "name^0"!
355 for (cp
= name
+ len
- 1; name
<= cp
; cp
--) {
357 if ('0' <= ch
&& ch
<= '9')
363 if (!parent
&& *cp
== '~') {
364 int len1
= cp
- name
;
366 while (cp
< name
+ len
)
367 parent
= parent
* 10 + *cp
++ - '0';
368 return get_nth_ancestor(name
, len1
, sha1
, parent
);
371 ret
= peel_onion(name
, len
, sha1
);
375 ret
= get_sha1_basic(name
, len
, sha1
);
378 return get_short_sha1(name
, len
, sha1
);
382 * This is like "get_sha1_basic()", except it allows "sha1 expressions",
383 * notably "xyz^" for "parent of xyz"
385 int get_sha1(const char *name
, unsigned char *sha1
)
388 return get_sha1_1(name
, strlen(name
), sha1
);