🌐 AI搜索 & 代理 主页
Google Git
Sign in
chromium / external / github.com / git / git / refs/tags/v2.29.3 / . / sha1-name.c
blob: 0b23b86ceb4433ece828e780be180579a77f3fe8 [file] [log] [blame]
Junio C Hamano9938af62005-08-04 05:15:49[diff] [blame]1#include "cache.h"
Brandon Williamsb2141fc2017-06-14 18:07:36[diff] [blame]2#include "config.h"
Junio C Hamano5385f522005-10-14 01:57:40[diff] [blame]3#include "tag.h"
Junio C Hamano9938af62005-08-04 05:15:49[diff] [blame]4#include "commit.h"
Junio C Hamano5385f522005-10-14 01:57:40[diff] [blame]5#include "tree.h"
6#include "blob.h"
Junio C Hamanof3ab49d2006-04-19 18:56:53[diff] [blame]7#include "tree-walk.h"
Shawn Pearced556fae2006-05-17 09:56:09[diff] [blame]8#include "refs.h"
Johannes Schindelin28fb8432009-09-10 15:25:57[diff] [blame]9#include "remote.h"
René Scharfedbe44fa2015-05-19 21:44:23[diff] [blame]10#include "dir.h"
Jeff Kingfe299ec2020-03-30 14:03:46[diff] [blame]11#include "oid-array.h"
Jonathan Tan0317f452017-08-18 22:20:19[diff] [blame]12#include "packfile.h"
Stefan Beller0d4a1322018-03-23 17:20:56[diff] [blame]13#include "object-store.h"
Stefan Beller031dc922018-03-23 17:20:57[diff] [blame]14#include "repository.h"
Nguyễn Thái Ngọc Duyefe461b2019-04-16 09:33:36[diff] [blame]15#include "submodule.h"
Derrick Stolee8aac67a2018-07-12 19:39:35[diff] [blame]16#include "midx.h"
Derrick Stolee64043552018-07-20 16:33:04[diff] [blame]17#include "commit-reach.h"
Junio C Hamano9938af62005-08-04 05:15:49[diff] [blame]18
Nguyễn Thái Ngọc Duy0bb41a12019-04-16 09:33:29[diff] [blame]19static int get_oid_oneline(struct repository *r, const char *, struct object_id *, struct commit_list *);
Nguyễn Thái Ngọc Duy32574b62010-12-13 03:01:15[diff] [blame]20
Nguyễn Thái Ngọc Duyef9b0372019-04-16 09:33:23[diff] [blame]21typedef int (*disambiguate_hint_fn)(struct repository *, const struct object_id *, void *);
Junio C Hamanoa78fafe2012-06-21 05:07:36[diff] [blame]22
23struct disambiguate_state {
Jeff King00160432016-09-26 12:00:04[diff] [blame]24 int len; /* length of prefix in hex chars */
brian m. carlsondc015052017-03-26 16:01:24[diff] [blame]25 char hex_pfx[GIT_MAX_HEXSZ + 1];
brian m. carlsond2ee1182017-03-26 16:01:33[diff] [blame]26 struct object_id bin_pfx;
Jeff King00160432016-09-26 12:00:04[diff] [blame]27
Nguyễn Thái Ngọc Duyef9b0372019-04-16 09:33:23[diff] [blame]28 struct repository *repo;
Junio C Hamanoa78fafe2012-06-21 05:07:36[diff] [blame]29 disambiguate_hint_fn fn;
30 void *cb_data;
brian m. carlsond2ee1182017-03-26 16:01:33[diff] [blame]31 struct object_id candidate;
Junio C Hamanoa78fafe2012-06-21 05:07:36[diff] [blame]32 unsigned candidate_exists:1;
33 unsigned candidate_checked:1;
34 unsigned candidate_ok:1;
35 unsigned disambiguate_fn_used:1;
36 unsigned ambiguous:1;
Junio C Hamano957d7402012-07-03 21:21:59[diff] [blame]37 unsigned always_call_fn:1;
Junio C Hamanoa78fafe2012-06-21 05:07:36[diff] [blame]38};
39
brian m. carlsond2b7d9c2017-03-26 16:01:34[diff] [blame]40static void update_candidates(struct disambiguate_state *ds, const struct object_id *current)
Junio C Hamanoa78fafe2012-06-21 05:07:36[diff] [blame]41{
Junio C Hamano957d7402012-07-03 21:21:59[diff] [blame]42 if (ds->always_call_fn) {
Nguyễn Thái Ngọc Duyef9b0372019-04-16 09:33:23[diff] [blame]43 ds->ambiguous = ds->fn(ds->repo, current, ds->cb_data) ? 1 : 0;
Junio C Hamano957d7402012-07-03 21:21:59[diff] [blame]44 return;
45 }
Junio C Hamanoa78fafe2012-06-21 05:07:36[diff] [blame]46 if (!ds->candidate_exists) {
47 /* this is the first candidate */
brian m. carlsond2b7d9c2017-03-26 16:01:34[diff] [blame]48 oidcpy(&ds->candidate, current);
Junio C Hamanoa78fafe2012-06-21 05:07:36[diff] [blame]49 ds->candidate_exists = 1;
50 return;
Jeff King4a7e27e2018-08-28 21:22:40[diff] [blame]51 } else if (oideq(&ds->candidate, current)) {
Junio C Hamanoa78fafe2012-06-21 05:07:36[diff] [blame]52 /* the same as what we already have seen */
53 return;
54 }
55
56 if (!ds->fn) {
57 /* cannot disambiguate between ds->candidate and current */
58 ds->ambiguous = 1;
59 return;
60 }
61
62 if (!ds->candidate_checked) {
Nguyễn Thái Ngọc Duyef9b0372019-04-16 09:33:23[diff] [blame]63 ds->candidate_ok = ds->fn(ds->repo, &ds->candidate, ds->cb_data);
Junio C Hamanoa78fafe2012-06-21 05:07:36[diff] [blame]64 ds->disambiguate_fn_used = 1;
65 ds->candidate_checked = 1;
66 }
67
68 if (!ds->candidate_ok) {
Ondřej Bílka749f7632013-07-22 21:02:23[diff] [blame]69 /* discard the candidate; we know it does not satisfy fn */
brian m. carlsond2b7d9c2017-03-26 16:01:34[diff] [blame]70 oidcpy(&ds->candidate, current);
Junio C Hamanoa78fafe2012-06-21 05:07:36[diff] [blame]71 ds->candidate_checked = 0;
72 return;
73 }
74
75 /* if we reach this point, we know ds->candidate satisfies fn */
Nguyễn Thái Ngọc Duyef9b0372019-04-16 09:33:23[diff] [blame]76 if (ds->fn(ds->repo, current, ds->cb_data)) {
Junio C Hamanoa78fafe2012-06-21 05:07:36[diff] [blame]77 /*
78 * if both current and candidate satisfy fn, we cannot
79 * disambiguate.
80 */
81 ds->candidate_ok = 0;
82 ds->ambiguous = 1;
83 }
84
85 /* otherwise, current can be discarded and candidate is still good */
86}
87
René Scharfecc817ca2017-06-22 18:19:48[diff] [blame]88static int match_sha(unsigned, const unsigned char *, const unsigned char *);
89
Jeff King00160432016-09-26 12:00:04[diff] [blame]90static void find_short_object_filename(struct disambiguate_state *ds)
Junio C Hamano9938af62005-08-04 05:15:49[diff] [blame]91{
Jeff King263db402018-11-12 14:48:47[diff] [blame]92 struct object_directory *odb;
Junio C Hamano9938af62005-08-04 05:15:49[diff] [blame]93
Nguyễn Thái Ngọc Duyef9b0372019-04-16 09:33:23[diff] [blame]94 for (odb = ds->repo->objects->odb; odb && !ds->ambiguous; odb = odb->next) {
René Scharfecc817ca2017-06-22 18:19:48[diff] [blame]95 int pos;
René Scharfe0000d652019-01-06 16:45:30[diff] [blame]96 struct oid_array *loose_objects;
Jeff King597f9132016-10-03 20:35:51[diff] [blame]97
René Scharfe0000d652019-01-06 16:45:30[diff] [blame]98 loose_objects = odb_loose_cache(odb, &ds->bin_pfx);
99 pos = oid_array_lookup(loose_objects, &ds->bin_pfx);
René Scharfecc817ca2017-06-22 18:19:48[diff] [blame]100 if (pos < 0)
101 pos = -1 - pos;
René Scharfe0000d652019-01-06 16:45:30[diff] [blame]102 while (!ds->ambiguous && pos < loose_objects->nr) {
René Scharfecc817ca2017-06-22 18:19:48[diff] [blame]103 const struct object_id *oid;
René Scharfe0000d652019-01-06 16:45:30[diff] [blame]104 oid = loose_objects->oid + pos;
René Scharfecc817ca2017-06-22 18:19:48[diff] [blame]105 if (!match_sha(ds->len, ds->bin_pfx.hash, oid->hash))
106 break;
107 update_candidates(ds, oid);
108 pos++;
109 }
Junio C Hamano9938af62005-08-04 05:15:49[diff] [blame]110 }
Junio C Hamano9938af62005-08-04 05:15:49[diff] [blame]111}
112
113static int match_sha(unsigned len, const unsigned char *a, const unsigned char *b)
114{
115 do {
116 if (*a != *b)
117 return 0;
118 a++;
119 b++;
120 len -= 2;
121 } while (len > 1);
122 if (len)
123 if ((*a ^ *b) & 0xf0)
124 return 0;
125 return 1;
126}
127
Derrick Stolee8aac67a2018-07-12 19:39:35[diff] [blame]128static void unique_in_midx(struct multi_pack_index *m,
129 struct disambiguate_state *ds)
130{
131 uint32_t num, i, first = 0;
132 const struct object_id *current = NULL;
133 num = m->num_objects;
134
135 if (!num)
136 return;
137
138 bsearch_midx(&ds->bin_pfx, m, &first);
139
140 /*
141 * At this point, "first" is the location of the lowest object
142 * with an object name that could match "bin_pfx". See if we have
143 * 0, 1 or more objects that actually match(es).
144 */
145 for (i = first; i < num && !ds->ambiguous; i++) {
146 struct object_id oid;
147 current = nth_midxed_object_oid(&oid, m, i);
148 if (!match_sha(ds->len, ds->bin_pfx.hash, current->hash))
149 break;
150 update_candidates(ds, current);
151 }
152}
153
Jeff King00160432016-09-26 12:00:04[diff] [blame]154static void unique_in_pack(struct packed_git *p,
Junio C Hamanoa78fafe2012-06-21 05:07:36[diff] [blame]155 struct disambiguate_state *ds)
Junio C Hamanof703e6e2012-06-18 20:10:38[diff] [blame]156{
René Scharfe902f5a22018-03-24 16:41:08[diff] [blame]157 uint32_t num, i, first = 0;
Junio C Hamanof703e6e2012-06-18 20:10:38[diff] [blame]158
Derrick Stoleeaf96fe32019-04-29 16:18:56[diff] [blame]159 if (p->multi_pack_index)
160 return;
161
Derrick Stolee0e87b852017-10-12 12:02:20[diff] [blame]162 if (open_pack_index(p) || !p->num_objects)
163 return;
164
Junio C Hamanof703e6e2012-06-18 20:10:38[diff] [blame]165 num = p->num_objects;
René Scharfe902f5a22018-03-24 16:41:08[diff] [blame]166 bsearch_pack(&ds->bin_pfx, p, &first);
Junio C Hamanof703e6e2012-06-18 20:10:38[diff] [blame]167
168 /*
169 * At this point, "first" is the location of the lowest object
Junio C Hamano1703f9a2012-06-21 05:35:43[diff] [blame]170 * with an object name that could match "bin_pfx". See if we have
Junio C Hamanof703e6e2012-06-18 20:10:38[diff] [blame]171 * 0, 1 or more objects that actually match(es).
172 */
Junio C Hamanoa78fafe2012-06-21 05:07:36[diff] [blame]173 for (i = first; i < num && !ds->ambiguous; i++) {
brian m. carlsond2b7d9c2017-03-26 16:01:34[diff] [blame]174 struct object_id oid;
Jeff King07636712020-02-24 04:27:36[diff] [blame]175 nth_packed_object_id(&oid, p, i);
176 if (!match_sha(ds->len, ds->bin_pfx.hash, oid.hash))
Junio C Hamanof703e6e2012-06-18 20:10:38[diff] [blame]177 break;
Jeff King07636712020-02-24 04:27:36[diff] [blame]178 update_candidates(ds, &oid);
Junio C Hamanof703e6e2012-06-18 20:10:38[diff] [blame]179 }
Junio C Hamanof703e6e2012-06-18 20:10:38[diff] [blame]180}
181
Jeff King00160432016-09-26 12:00:04[diff] [blame]182static void find_short_packed_object(struct disambiguate_state *ds)
Junio C Hamano9938af62005-08-04 05:15:49[diff] [blame]183{
Derrick Stolee8aac67a2018-07-12 19:39:35[diff] [blame]184 struct multi_pack_index *m;
Junio C Hamano9938af62005-08-04 05:15:49[diff] [blame]185 struct packed_git *p;
Junio C Hamano9938af62005-08-04 05:15:49[diff] [blame]186
Nguyễn Thái Ngọc Duyef9b0372019-04-16 09:33:23[diff] [blame]187 for (m = get_multi_pack_index(ds->repo); m && !ds->ambiguous;
Derrick Stolee8aac67a2018-07-12 19:39:35[diff] [blame]188 m = m->next)
189 unique_in_midx(m, ds);
Nguyễn Thái Ngọc Duyef9b0372019-04-16 09:33:23[diff] [blame]190 for (p = get_packed_git(ds->repo); p && !ds->ambiguous;
Stefan Bellera80d72d2018-03-23 17:20:59[diff] [blame]191 p = p->next)
Jeff King00160432016-09-26 12:00:04[diff] [blame]192 unique_in_pack(p, ds);
Junio C Hamano99a19b42005-10-03 04:40:51[diff] [blame]193}
194
Junio C Hamanoa78fafe2012-06-21 05:07:36[diff] [blame]195static int finish_object_disambiguation(struct disambiguate_state *ds,
brian m. carlsone82caf32017-07-13 23:49:28[diff] [blame]196 struct object_id *oid)
Junio C Hamano99a19b42005-10-03 04:40:51[diff] [blame]197{
Junio C Hamanoa78fafe2012-06-21 05:07:36[diff] [blame]198 if (ds->ambiguous)
199 return SHORT_NAME_AMBIGUOUS;
Junio C Hamano99a19b42005-10-03 04:40:51[diff] [blame]200
Junio C Hamanoa78fafe2012-06-21 05:07:36[diff] [blame]201 if (!ds->candidate_exists)
David Turnerd1dd94b2019-01-18 04:19:43[diff] [blame]202 return MISSING_OBJECT;
Junio C Hamanoa78fafe2012-06-21 05:07:36[diff] [blame]203
204 if (!ds->candidate_checked)
205 /*
206 * If this is the only candidate, there is no point
207 * calling the disambiguation hint callback.
208 *
209 * On the other hand, if the current candidate
210 * replaced an earlier candidate that did _not_ pass
211 * the disambiguation hint callback, then we do have
212 * more than one objects that match the short name
213 * given, so we should make sure this one matches;
214 * otherwise, if we discovered this one and the one
215 * that we previously discarded in the reverse order,
216 * we would end up showing different results in the
217 * same repository!
218 */
219 ds->candidate_ok = (!ds->disambiguate_fn_used ||
Nguyễn Thái Ngọc Duyef9b0372019-04-16 09:33:23[diff] [blame]220 ds->fn(ds->repo, &ds->candidate, ds->cb_data));
Junio C Hamanoa78fafe2012-06-21 05:07:36[diff] [blame]221
222 if (!ds->candidate_ok)
Junio C Hamano013f2762005-10-11 22:22:48[diff] [blame]223 return SHORT_NAME_AMBIGUOUS;
Junio C Hamanoa78fafe2012-06-21 05:07:36[diff] [blame]224
brian m. carlsone82caf32017-07-13 23:49:28[diff] [blame]225 oidcpy(oid, &ds->candidate);
Junio C Hamano9938af62005-08-04 05:15:49[diff] [blame]226 return 0;
227}
228
Nguyễn Thái Ngọc Duyef9b0372019-04-16 09:33:23[diff] [blame]229static int disambiguate_commit_only(struct repository *r,
230 const struct object_id *oid,
231 void *cb_data_unused)
Junio C Hamano9938af62005-08-04 05:15:49[diff] [blame]232{
Nguyễn Thái Ngọc Duyef9b0372019-04-16 09:33:23[diff] [blame]233 int kind = oid_object_info(r, oid, NULL);
Junio C Hamanoaa1dec92012-06-21 06:03:09[diff] [blame]234 return kind == OBJ_COMMIT;
235}
Junio C Hamano9938af62005-08-04 05:15:49[diff] [blame]236
Nguyễn Thái Ngọc Duyef9b0372019-04-16 09:33:23[diff] [blame]237static int disambiguate_committish_only(struct repository *r,
238 const struct object_id *oid,
239 void *cb_data_unused)
Junio C Hamanoe2643612012-07-02 17:00:40[diff] [blame]240{
241 struct object *obj;
242 int kind;
243
Nguyễn Thái Ngọc Duyef9b0372019-04-16 09:33:23[diff] [blame]244 kind = oid_object_info(r, oid, NULL);
Junio C Hamanoe2643612012-07-02 17:00:40[diff] [blame]245 if (kind == OBJ_COMMIT)
246 return 1;
247 if (kind != OBJ_TAG)
248 return 0;
249
250 /* We need to do this the hard way... */
Nguyễn Thái Ngọc Duyef9b0372019-04-16 09:33:23[diff] [blame]251 obj = deref_tag(r, parse_object(r, oid), NULL, 0);
Junio C Hamanoe2643612012-07-02 17:00:40[diff] [blame]252 if (obj && obj->type == OBJ_COMMIT)
253 return 1;
254 return 0;
255}
256
Nguyễn Thái Ngọc Duyef9b0372019-04-16 09:33:23[diff] [blame]257static int disambiguate_tree_only(struct repository *r,
258 const struct object_id *oid,
259 void *cb_data_unused)
Junio C Hamanodaba53a2012-07-03 06:35:05[diff] [blame]260{
Nguyễn Thái Ngọc Duyef9b0372019-04-16 09:33:23[diff] [blame]261 int kind = oid_object_info(r, oid, NULL);
Junio C Hamanodaba53a2012-07-03 06:35:05[diff] [blame]262 return kind == OBJ_TREE;
263}
264
Nguyễn Thái Ngọc Duyef9b0372019-04-16 09:33:23[diff] [blame]265static int disambiguate_treeish_only(struct repository *r,
266 const struct object_id *oid,
267 void *cb_data_unused)
Junio C Hamanodaba53a2012-07-03 06:35:05[diff] [blame]268{
269 struct object *obj;
270 int kind;
271
Nguyễn Thái Ngọc Duyef9b0372019-04-16 09:33:23[diff] [blame]272 kind = oid_object_info(r, oid, NULL);
Junio C Hamanodaba53a2012-07-03 06:35:05[diff] [blame]273 if (kind == OBJ_TREE || kind == OBJ_COMMIT)
274 return 1;
275 if (kind != OBJ_TAG)
276 return 0;
277
278 /* We need to do this the hard way... */
Nguyễn Thái Ngọc Duyef9b0372019-04-16 09:33:23[diff] [blame]279 obj = deref_tag(r, parse_object(r, oid), NULL, 0);
Junio C Hamanodaba53a2012-07-03 06:35:05[diff] [blame]280 if (obj && (obj->type == OBJ_TREE || obj->type == OBJ_COMMIT))
281 return 1;
282 return 0;
283}
284
Nguyễn Thái Ngọc Duyef9b0372019-04-16 09:33:23[diff] [blame]285static int disambiguate_blob_only(struct repository *r,
286 const struct object_id *oid,
287 void *cb_data_unused)
Junio C Hamanodaba53a2012-07-03 06:35:05[diff] [blame]288{
Nguyễn Thái Ngọc Duyef9b0372019-04-16 09:33:23[diff] [blame]289 int kind = oid_object_info(r, oid, NULL);
Junio C Hamanodaba53a2012-07-03 06:35:05[diff] [blame]290 return kind == OBJ_BLOB;
291}
292
Jeff King5b33cb12016-09-27 12:38:01[diff] [blame]293static disambiguate_hint_fn default_disambiguate_hint;
294
295int set_disambiguate_hint_config(const char *var, const char *value)
296{
297 static const struct {
298 const char *name;
299 disambiguate_hint_fn fn;
300 } hints[] = {
301 { "none", NULL },
302 { "commit", disambiguate_commit_only },
303 { "committish", disambiguate_committish_only },
304 { "tree", disambiguate_tree_only },
305 { "treeish", disambiguate_treeish_only },
306 { "blob", disambiguate_blob_only }
307 };
308 int i;
309
310 if (!value)
311 return config_error_nonbool(var);
312
313 for (i = 0; i < ARRAY_SIZE(hints); i++) {
314 if (!strcasecmp(value, hints[i].name)) {
315 default_disambiguate_hint = hints[i].fn;
316 return 0;
317 }
318 }
319
320 return error("unknown hint type for '%s': %s", var, value);
321}
322
Nguyễn Thái Ngọc Duyef9b0372019-04-16 09:33:23[diff] [blame]323static int init_object_disambiguation(struct repository *r,
324 const char *name, int len,
Jeff King00160432016-09-26 12:00:04[diff] [blame]325 struct disambiguate_state *ds)
Junio C Hamano9938af62005-08-04 05:15:49[diff] [blame]326{
Junio C Hamano957d7402012-07-03 21:21:59[diff] [blame]327 int i;
Junio C Hamano9938af62005-08-04 05:15:49[diff] [blame]328
brian m. carlson7b38efa2018-07-16 01:27:58[diff] [blame]329 if (len < MINIMUM_ABBREV || len > the_hash_algo->hexsz)
Jeff King00160432016-09-26 12:00:04[diff] [blame]330 return -1;
331
332 memset(ds, 0, sizeof(*ds));
Jeff King00160432016-09-26 12:00:04[diff] [blame]333
Linus Torvaldsaf61c6e2005-09-19 22:16:03[diff] [blame]334 for (i = 0; i < len ;i++) {
Junio C Hamano9938af62005-08-04 05:15:49[diff] [blame]335 unsigned char c = name[i];
336 unsigned char val;
Junio C Hamano9938af62005-08-04 05:15:49[diff] [blame]337 if (c >= '0' && c <= '9')
338 val = c - '0';
339 else if (c >= 'a' && c <= 'f')
340 val = c - 'a' + 10;
341 else if (c >= 'A' && c <='F') {
342 val = c - 'A' + 10;
343 c -= 'A' - 'a';
344 }
345 else
346 return -1;
Jeff King00160432016-09-26 12:00:04[diff] [blame]347 ds->hex_pfx[i] = c;
Junio C Hamano9938af62005-08-04 05:15:49[diff] [blame]348 if (!(i & 1))
349 val <<= 4;
brian m. carlsond2ee1182017-03-26 16:01:33[diff] [blame]350 ds->bin_pfx.hash[i >> 1] |= val;
Junio C Hamano9938af62005-08-04 05:15:49[diff] [blame]351 }
Jeff King00160432016-09-26 12:00:04[diff] [blame]352
353 ds->len = len;
Jeff King59e4e342016-09-26 12:00:07[diff] [blame]354 ds->hex_pfx[len] = '\0';
Nguyễn Thái Ngọc Duyef9b0372019-04-16 09:33:23[diff] [blame]355 ds->repo = r;
356 prepare_alt_odb(r);
Junio C Hamano957d7402012-07-03 21:21:59[diff] [blame]357 return 0;
358}
Junio C Hamano99a19b42005-10-03 04:40:51[diff] [blame]359
brian m. carlson1b7ba792017-03-31 01:39:59[diff] [blame]360static int show_ambiguous_object(const struct object_id *oid, void *data)
Jeff King1ffa26c2016-09-26 12:00:36[diff] [blame]361{
362 const struct disambiguate_state *ds = data;
363 struct strbuf desc = STRBUF_INIT;
364 int type;
365
Nguyễn Thái Ngọc Duyef9b0372019-04-16 09:33:23[diff] [blame]366 if (ds->fn && !ds->fn(ds->repo, oid, ds->cb_data))
Jeff King1ffa26c2016-09-26 12:00:36[diff] [blame]367 return 0;
368
Nguyễn Thái Ngọc Duyef9b0372019-04-16 09:33:23[diff] [blame]369 type = oid_object_info(ds->repo, oid, NULL);
Jeff King1ffa26c2016-09-26 12:00:36[diff] [blame]370 if (type == OBJ_COMMIT) {
Nguyễn Thái Ngọc Duyef9b0372019-04-16 09:33:23[diff] [blame]371 struct commit *commit = lookup_commit(ds->repo, oid);
Jeff King1ffa26c2016-09-26 12:00:36[diff] [blame]372 if (commit) {
373 struct pretty_print_context pp = {0};
374 pp.date_mode.type = DATE_SHORT;
375 format_commit_message(commit, " %ad - %s", &desc, &pp);
376 }
377 } else if (type == OBJ_TAG) {
Nguyễn Thái Ngọc Duyef9b0372019-04-16 09:33:23[diff] [blame]378 struct tag *tag = lookup_tag(ds->repo, oid);
Jeff King1ffa26c2016-09-26 12:00:36[diff] [blame]379 if (!parse_tag(tag) && tag->tag)
380 strbuf_addf(&desc, " %s", tag->tag);
381 }
382
383 advise(" %s %s%s",
Nguyễn Thái Ngọc Duyef9b0372019-04-16 09:33:23[diff] [blame]384 repo_find_unique_abbrev(ds->repo, oid, DEFAULT_ABBREV),
Brandon Williamsdebca9d2018-02-14 18:59:24[diff] [blame]385 type_name(type) ? type_name(type) : "unknown type",
Jeff King1ffa26c2016-09-26 12:00:36[diff] [blame]386 desc.buf);
387
388 strbuf_release(&desc);
389 return 0;
390}
391
Ævar Arnfjörð Bjarmasona885c932018-05-10 12:43:01[diff] [blame]392static int collect_ambiguous(const struct object_id *oid, void *data)
393{
394 oid_array_append(data, oid);
395 return 0;
396}
397
Nguyễn Thái Ngọc Duyef9b0372019-04-16 09:33:23[diff] [blame]398static int repo_collect_ambiguous(struct repository *r,
399 const struct object_id *oid,
400 void *data)
401{
402 return collect_ambiguous(oid, data);
403}
404
René Scharfe7cfcb162019-08-20 18:49:12[diff] [blame]405static int sort_ambiguous(const void *a, const void *b, void *ctx)
Ævar Arnfjörð Bjarmason5cc044e2018-05-10 12:43:02[diff] [blame]406{
René Scharfe7cfcb162019-08-20 18:49:12[diff] [blame]407 struct repository *sort_ambiguous_repo = ctx;
Nguyễn Thái Ngọc Duyfae2ae42019-04-16 09:33:20[diff] [blame]408 int a_type = oid_object_info(sort_ambiguous_repo, a, NULL);
409 int b_type = oid_object_info(sort_ambiguous_repo, b, NULL);
Ævar Arnfjörð Bjarmason5cc044e2018-05-10 12:43:02[diff] [blame]410 int a_type_sort;
411 int b_type_sort;
412
413 /*
414 * Sorts by hash within the same object type, just as
415 * oid_array_for_each_unique() would do.
416 */
417 if (a_type == b_type)
418 return oidcmp(a, b);
419
420 /*
421 * Between object types show tags, then commits, and finally
422 * trees and blobs.
423 *
424 * The object_type enum is commit, tree, blob, tag, but we
425 * want tag, commit, tree blob. Cleverly (perhaps too
426 * cleverly) do that with modulus, since the enum assigns 1 to
427 * commit, so tag becomes 0.
428 */
429 a_type_sort = a_type % 4;
430 b_type_sort = b_type % 4;
431 return a_type_sort > b_type_sort ? 1 : -1;
432}
433
Nguyễn Thái Ngọc Duyfae2ae42019-04-16 09:33:20[diff] [blame]434static void sort_ambiguous_oid_array(struct repository *r, struct oid_array *a)
435{
René Scharfe7cfcb162019-08-20 18:49:12[diff] [blame]436 QSORT_S(a->oid, a->nr, sort_ambiguous, r);
Nguyễn Thái Ngọc Duyfae2ae42019-04-16 09:33:20[diff] [blame]437}
438
Nguyễn Thái Ngọc Duyc6c02352019-04-16 09:33:25[diff] [blame]439static enum get_oid_result get_short_oid(struct repository *r,
440 const char *name, int len,
David Turnerd1dd94b2019-01-18 04:19:43[diff] [blame]441 struct object_id *oid,
442 unsigned flags)
Junio C Hamano957d7402012-07-03 21:21:59[diff] [blame]443{
444 int status;
Junio C Hamano957d7402012-07-03 21:21:59[diff] [blame]445 struct disambiguate_state ds;
brian m. carlson321c89b2017-07-13 23:49:29[diff] [blame]446 int quietly = !!(flags & GET_OID_QUIETLY);
Junio C Hamano957d7402012-07-03 21:21:59[diff] [blame]447
Nguyễn Thái Ngọc Duyc6c02352019-04-16 09:33:25[diff] [blame]448 if (init_object_disambiguation(r, name, len, &ds) < 0)
Junio C Hamano957d7402012-07-03 21:21:59[diff] [blame]449 return -1;
Jeff King259942f2016-09-26 11:59:01[diff] [blame]450
brian m. carlson321c89b2017-07-13 23:49:29[diff] [blame]451 if (HAS_MULTI_BITS(flags & GET_OID_DISAMBIGUATORS))
Johannes Schindelin033abf92018-05-02 09:38:39[diff] [blame]452 BUG("multiple get_short_oid disambiguator flags");
Jeff King259942f2016-09-26 11:59:01[diff] [blame]453
brian m. carlson321c89b2017-07-13 23:49:29[diff] [blame]454 if (flags & GET_OID_COMMIT)
Junio C Hamanoaa1dec92012-06-21 06:03:09[diff] [blame]455 ds.fn = disambiguate_commit_only;
brian m. carlson321c89b2017-07-13 23:49:29[diff] [blame]456 else if (flags & GET_OID_COMMITTISH)
Junio C Hamanoe2643612012-07-02 17:00:40[diff] [blame]457 ds.fn = disambiguate_committish_only;
brian m. carlson321c89b2017-07-13 23:49:29[diff] [blame]458 else if (flags & GET_OID_TREE)
Junio C Hamanodaba53a2012-07-03 06:35:05[diff] [blame]459 ds.fn = disambiguate_tree_only;
brian m. carlson321c89b2017-07-13 23:49:29[diff] [blame]460 else if (flags & GET_OID_TREEISH)
Junio C Hamanodaba53a2012-07-03 06:35:05[diff] [blame]461 ds.fn = disambiguate_treeish_only;
brian m. carlson321c89b2017-07-13 23:49:29[diff] [blame]462 else if (flags & GET_OID_BLOB)
Junio C Hamanodaba53a2012-07-03 06:35:05[diff] [blame]463 ds.fn = disambiguate_blob_only;
Jeff King5b33cb12016-09-27 12:38:01[diff] [blame]464 else
465 ds.fn = default_disambiguate_hint;
Junio C Hamanoaa1dec92012-06-21 06:03:09[diff] [blame]466
Jeff King00160432016-09-26 12:00:04[diff] [blame]467 find_short_object_filename(&ds);
468 find_short_packed_object(&ds);
brian m. carlsone82caf32017-07-13 23:49:28[diff] [blame]469 status = finish_object_disambiguation(&ds, oid);
Junio C Hamanoa78fafe2012-06-21 05:07:36[diff] [blame]470
Johannes Schindelin6d67a992019-03-13 10:16:34[diff] [blame]471 /*
472 * If we didn't find it, do the usual reprepare() slow-path,
473 * since the object may have recently been added to the repository
474 * or migrated from loose to packed.
475 */
476 if (status == MISSING_OBJECT) {
Nguyễn Thái Ngọc Duy34e77712019-06-27 09:28:52[diff] [blame]477 reprepare_packed_git(r);
Johannes Schindelin6d67a992019-03-13 10:16:34[diff] [blame]478 find_short_object_filename(&ds);
479 find_short_packed_object(&ds);
480 status = finish_object_disambiguation(&ds, oid);
481 }
482
Jeff King1ffa26c2016-09-26 12:00:36[diff] [blame]483 if (!quietly && (status == SHORT_NAME_AMBIGUOUS)) {
Ævar Arnfjörð Bjarmason5cc044e2018-05-10 12:43:02[diff] [blame]484 struct oid_array collect = OID_ARRAY_INIT;
485
Jeff King1ffa26c2016-09-26 12:00:36[diff] [blame]486 error(_("short SHA1 %s is ambiguous"), ds.hex_pfx);
487
488 /*
489 * We may still have ambiguity if we simply saw a series of
490 * candidates that did not satisfy our hint function. In
491 * that case, we still want to show them, so disable the hint
492 * function entirely.
493 */
494 if (!ds.ambiguous)
495 ds.fn = NULL;
496
497 advise(_("The candidates are:"));
Nguyễn Thái Ngọc Duyc6c02352019-04-16 09:33:25[diff] [blame]498 repo_for_each_abbrev(r, ds.hex_pfx, collect_ambiguous, &collect);
499 sort_ambiguous_oid_array(r, &collect);
Ævar Arnfjörð Bjarmason5cc044e2018-05-10 12:43:02[diff] [blame]500
501 if (oid_array_for_each(&collect, show_ambiguous_object, &ds))
502 BUG("show_ambiguous_object shouldn't return non-zero");
503 oid_array_clear(&collect);
Jeff King1ffa26c2016-09-26 12:00:36[diff] [blame]504 }
505
Junio C Hamano013f2762005-10-11 22:22:48[diff] [blame]506 return status;
507}
508
Nguyễn Thái Ngọc Duy4e99f2d2019-04-16 09:33:24[diff] [blame]509int repo_for_each_abbrev(struct repository *r, const char *prefix,
510 each_abbrev_fn fn, void *cb_data)
Junio C Hamano957d7402012-07-03 21:21:59[diff] [blame]511{
brian m. carlson910650d2017-03-31 01:40:00[diff] [blame]512 struct oid_array collect = OID_ARRAY_INIT;
Junio C Hamano957d7402012-07-03 21:21:59[diff] [blame]513 struct disambiguate_state ds;
Jeff Kingfad6b9e2016-09-26 12:00:33[diff] [blame]514 int ret;
Junio C Hamano957d7402012-07-03 21:21:59[diff] [blame]515
Nguyễn Thái Ngọc Duy4e99f2d2019-04-16 09:33:24[diff] [blame]516 if (init_object_disambiguation(r, prefix, strlen(prefix), &ds) < 0)
Junio C Hamano957d7402012-07-03 21:21:59[diff] [blame]517 return -1;
518
Junio C Hamano957d7402012-07-03 21:21:59[diff] [blame]519 ds.always_call_fn = 1;
Nguyễn Thái Ngọc Duyef9b0372019-04-16 09:33:23[diff] [blame]520 ds.fn = repo_collect_ambiguous;
Jeff Kingfad6b9e2016-09-26 12:00:33[diff] [blame]521 ds.cb_data = &collect;
Jeff King00160432016-09-26 12:00:04[diff] [blame]522 find_short_object_filename(&ds);
523 find_short_packed_object(&ds);
Jeff Kingfad6b9e2016-09-26 12:00:33[diff] [blame]524
brian m. carlson910650d2017-03-31 01:40:00[diff] [blame]525 ret = oid_array_for_each_unique(&collect, fn, cb_data);
526 oid_array_clear(&collect);
Jeff Kingfad6b9e2016-09-26 12:00:33[diff] [blame]527 return ret;
Junio C Hamano957d7402012-07-03 21:21:59[diff] [blame]528}
529
Jeff King8e3f52d2016-10-03 23:47:28[diff] [blame]530/*
531 * Return the slot of the most-significant bit set in "val". There are various
532 * ways to do this quickly with fls() or __builtin_clzl(), but speed is
533 * probably not a big deal here.
534 */
535static unsigned msb(unsigned long val)
536{
537 unsigned r = 0;
538 while (val >>= 1)
539 r++;
540 return r;
541}
542
Derrick Stolee5b20ace2017-10-08 18:49:40[diff] [blame]543struct min_abbrev_data {
544 unsigned int init_len;
545 unsigned int cur_len;
546 char *hex;
Nguyễn Thái Ngọc Duy7f07c032019-04-16 09:33:21[diff] [blame]547 struct repository *repo;
brian m. carlson626fd982018-03-22 17:40:08[diff] [blame]548 const struct object_id *oid;
Derrick Stolee5b20ace2017-10-08 18:49:40[diff] [blame]549};
550
Derrick Stoleea42d6fd2017-10-12 12:02:19[diff] [blame]551static inline char get_hex_char_from_oid(const struct object_id *oid,
552 unsigned int pos)
553{
554 static const char hex[] = "0123456789abcdef";
555
556 if ((pos & 1) == 0)
557 return hex[oid->hash[pos >> 1] >> 4];
558 else
559 return hex[oid->hash[pos >> 1] & 0xf];
560}
561
Derrick Stolee5b20ace2017-10-08 18:49:40[diff] [blame]562static int extend_abbrev_len(const struct object_id *oid, void *cb_data)
563{
564 struct min_abbrev_data *mad = cb_data;
565
Derrick Stolee5b20ace2017-10-08 18:49:40[diff] [blame]566 unsigned int i = mad->init_len;
Derrick Stoleea42d6fd2017-10-12 12:02:19[diff] [blame]567 while (mad->hex[i] && mad->hex[i] == get_hex_char_from_oid(oid, i))
Derrick Stolee5b20ace2017-10-08 18:49:40[diff] [blame]568 i++;
569
570 if (i < GIT_MAX_RAWSZ && i >= mad->cur_len)
571 mad->cur_len = i + 1;
572
573 return 0;
574}
575
Nguyễn Thái Ngọc Duyef9b0372019-04-16 09:33:23[diff] [blame]576static int repo_extend_abbrev_len(struct repository *r,
577 const struct object_id *oid,
578 void *cb_data)
579{
580 return extend_abbrev_len(oid, cb_data);
581}
582
Derrick Stolee8aac67a2018-07-12 19:39:35[diff] [blame]583static void find_abbrev_len_for_midx(struct multi_pack_index *m,
584 struct min_abbrev_data *mad)
585{
586 int match = 0;
587 uint32_t num, first = 0;
588 struct object_id oid;
589 const struct object_id *mad_oid;
590
591 if (!m->num_objects)
592 return;
593
594 num = m->num_objects;
595 mad_oid = mad->oid;
596 match = bsearch_midx(mad_oid, m, &first);
597
598 /*
599 * first is now the position in the packfile where we would insert
600 * mad->hash if it does not exist (or the position of mad->hash if
601 * it does exist). Hence, we consider a maximum of two objects
602 * nearby for the abbreviation length.
603 */
604 mad->init_len = 0;
605 if (!match) {
606 if (nth_midxed_object_oid(&oid, m, first))
607 extend_abbrev_len(&oid, mad);
608 } else if (first < num - 1) {
609 if (nth_midxed_object_oid(&oid, m, first + 1))
610 extend_abbrev_len(&oid, mad);
611 }
612 if (first > 0) {
613 if (nth_midxed_object_oid(&oid, m, first - 1))
614 extend_abbrev_len(&oid, mad);
615 }
616 mad->init_len = mad->cur_len;
617}
618
Derrick Stolee0e87b852017-10-12 12:02:20[diff] [blame]619static void find_abbrev_len_for_pack(struct packed_git *p,
620 struct min_abbrev_data *mad)
621{
622 int match = 0;
Derrick Stolee0aaf05b2018-03-22 17:40:10[diff] [blame]623 uint32_t num, first = 0;
Derrick Stolee0e87b852017-10-12 12:02:20[diff] [blame]624 struct object_id oid;
Derrick Stolee0aaf05b2018-03-22 17:40:10[diff] [blame]625 const struct object_id *mad_oid;
Derrick Stolee0e87b852017-10-12 12:02:20[diff] [blame]626
Derrick Stoleeaf96fe32019-04-29 16:18:56[diff] [blame]627 if (p->multi_pack_index)
628 return;
629
Derrick Stolee0e87b852017-10-12 12:02:20[diff] [blame]630 if (open_pack_index(p) || !p->num_objects)
631 return;
632
633 num = p->num_objects;
Derrick Stolee0aaf05b2018-03-22 17:40:10[diff] [blame]634 mad_oid = mad->oid;
635 match = bsearch_pack(mad_oid, p, &first);
Derrick Stolee0e87b852017-10-12 12:02:20[diff] [blame]636
637 /*
638 * first is now the position in the packfile where we would insert
639 * mad->hash if it does not exist (or the position of mad->hash if
Derrick Stolee21abed52018-02-27 11:47:04[diff] [blame]640 * it does exist). Hence, we consider a maximum of two objects
Derrick Stolee0e87b852017-10-12 12:02:20[diff] [blame]641 * nearby for the abbreviation length.
642 */
643 mad->init_len = 0;
644 if (!match) {
Jeff King07636712020-02-24 04:27:36[diff] [blame]645 if (!nth_packed_object_id(&oid, p, first))
Derrick Stolee21abed52018-02-27 11:47:04[diff] [blame]646 extend_abbrev_len(&oid, mad);
Derrick Stolee0e87b852017-10-12 12:02:20[diff] [blame]647 } else if (first < num - 1) {
Jeff King07636712020-02-24 04:27:36[diff] [blame]648 if (!nth_packed_object_id(&oid, p, first + 1))
Derrick Stolee21abed52018-02-27 11:47:04[diff] [blame]649 extend_abbrev_len(&oid, mad);
Derrick Stolee0e87b852017-10-12 12:02:20[diff] [blame]650 }
651 if (first > 0) {
Jeff King07636712020-02-24 04:27:36[diff] [blame]652 if (!nth_packed_object_id(&oid, p, first - 1))
Derrick Stolee21abed52018-02-27 11:47:04[diff] [blame]653 extend_abbrev_len(&oid, mad);
Derrick Stolee0e87b852017-10-12 12:02:20[diff] [blame]654 }
655 mad->init_len = mad->cur_len;
656}
657
658static void find_abbrev_len_packed(struct min_abbrev_data *mad)
659{
Derrick Stolee8aac67a2018-07-12 19:39:35[diff] [blame]660 struct multi_pack_index *m;
Derrick Stolee0e87b852017-10-12 12:02:20[diff] [blame]661 struct packed_git *p;
662
Nguyễn Thái Ngọc Duy7f07c032019-04-16 09:33:21[diff] [blame]663 for (m = get_multi_pack_index(mad->repo); m; m = m->next)
Derrick Stolee8aac67a2018-07-12 19:39:35[diff] [blame]664 find_abbrev_len_for_midx(m, mad);
Nguyễn Thái Ngọc Duy7f07c032019-04-16 09:33:21[diff] [blame]665 for (p = get_packed_git(mad->repo); p; p = p->next)
Derrick Stolee0e87b852017-10-12 12:02:20[diff] [blame]666 find_abbrev_len_for_pack(p, mad);
667}
668
Nguyễn Thái Ngọc Duy8bb95572019-04-16 09:33:22[diff] [blame]669int repo_find_unique_abbrev_r(struct repository *r, char *hex,
670 const struct object_id *oid, int len)
Junio C Hamano013f2762005-10-11 22:22:48[diff] [blame]671{
Derrick Stolee5b20ace2017-10-08 18:49:40[diff] [blame]672 struct disambiguate_state ds;
673 struct min_abbrev_data mad;
674 struct object_id oid_ret;
Nguyễn Thái Ngọc Duy8bb95572019-04-16 09:33:22[diff] [blame]675 const unsigned hexsz = r->hash_algo->hexsz;
brian m. carlson7b38efa2018-07-16 01:27:58[diff] [blame]676
Linus Torvaldse6c587c2016-10-01 00:19:37[diff] [blame]677 if (len < 0) {
Nguyễn Thái Ngọc Duy8bb95572019-04-16 09:33:22[diff] [blame]678 unsigned long count = repo_approximate_object_count(r);
Jeff King8e3f52d2016-10-03 23:47:28[diff] [blame]679 /*
680 * Add one because the MSB only tells us the highest bit set,
681 * not including the value of all the _other_ bits (so "15"
682 * is only one off of 2^4, but the MSB is the 3rd bit.
683 */
684 len = msb(count) + 1;
685 /*
686 * We now know we have on the order of 2^len objects, which
687 * expects a collision at 2^(len/2). But we also care about hex
688 * chars, not bits, and there are 4 bits per hex. So all
René Scharfe42c78a22017-07-08 10:35:35[diff] [blame]689 * together we need to divide by 2 and round up.
Jeff King8e3f52d2016-10-03 23:47:28[diff] [blame]690 */
René Scharfe42c78a22017-07-08 10:35:35[diff] [blame]691 len = DIV_ROUND_UP(len, 2);
Jeff King8e3f52d2016-10-03 23:47:28[diff] [blame]692 /*
693 * For very small repos, we stick with our regular fallback.
694 */
695 if (len < FALLBACK_DEFAULT_ABBREV)
696 len = FALLBACK_DEFAULT_ABBREV;
Linus Torvaldse6c587c2016-10-01 00:19:37[diff] [blame]697 }
Jeff King8e3f52d2016-10-03 23:47:28[diff] [blame]698
brian m. carlsonaab95832018-03-12 02:27:30[diff] [blame]699 oid_to_hex_r(hex, oid);
brian m. carlson7b38efa2018-07-16 01:27:58[diff] [blame]700 if (len == hexsz || !len)
701 return hexsz;
Derrick Stolee5b20ace2017-10-08 18:49:40[diff] [blame]702
Nguyễn Thái Ngọc Duy8bb95572019-04-16 09:33:22[diff] [blame]703 mad.repo = r;
Derrick Stolee5b20ace2017-10-08 18:49:40[diff] [blame]704 mad.init_len = len;
705 mad.cur_len = len;
706 mad.hex = hex;
brian m. carlson626fd982018-03-22 17:40:08[diff] [blame]707 mad.oid = oid;
Derrick Stolee0e87b852017-10-12 12:02:20[diff] [blame]708
709 find_abbrev_len_packed(&mad);
710
Nguyễn Thái Ngọc Duyef9b0372019-04-16 09:33:23[diff] [blame]711 if (init_object_disambiguation(r, hex, mad.cur_len, &ds) < 0)
Derrick Stolee0e87b852017-10-12 12:02:20[diff] [blame]712 return -1;
Derrick Stolee5b20ace2017-10-08 18:49:40[diff] [blame]713
Nguyễn Thái Ngọc Duyef9b0372019-04-16 09:33:23[diff] [blame]714 ds.fn = repo_extend_abbrev_len;
Derrick Stolee5b20ace2017-10-08 18:49:40[diff] [blame]715 ds.always_call_fn = 1;
716 ds.cb_data = (void *)&mad;
717
718 find_short_object_filename(&ds);
Derrick Stolee5b20ace2017-10-08 18:49:40[diff] [blame]719 (void)finish_object_disambiguation(&ds, &oid_ret);
720
721 hex[mad.cur_len] = 0;
722 return mad.cur_len;
Jeff Kingaf49c6d2015-09-24 21:05:45[diff] [blame]723}
724
Nguyễn Thái Ngọc Duy8bb95572019-04-16 09:33:22[diff] [blame]725const char *repo_find_unique_abbrev(struct repository *r,
726 const struct object_id *oid,
727 int len)
Jeff Kingaf49c6d2015-09-24 21:05:45[diff] [blame]728{
Jeff Kingef2ed502016-10-20 06:19:19[diff] [blame]729 static int bufno;
brian m. carlsondc015052017-03-26 16:01:24[diff] [blame]730 static char hexbuffer[4][GIT_MAX_HEXSZ + 1];
René Scharfe3e989192016-11-01 08:49:07[diff] [blame]731 char *hex = hexbuffer[bufno];
732 bufno = (bufno + 1) % ARRAY_SIZE(hexbuffer);
Nguyễn Thái Ngọc Duy8bb95572019-04-16 09:33:22[diff] [blame]733 repo_find_unique_abbrev_r(r, hex, oid, len);
Junio C Hamanob66fde92008-03-02 07:35:32[diff] [blame]734 return hex;
Junio C Hamano9938af62005-08-04 05:15:49[diff] [blame]735}
736
Junio C Hamano6677c462005-12-15 20:54:00[diff] [blame]737static int ambiguous_path(const char *path, int len)
Linus Torvaldsaf13cdf2005-10-28 19:41:49[diff] [blame]738{
739 int slash = 1;
Junio C Hamano6677c462005-12-15 20:54:00[diff] [blame]740 int cnt;
Linus Torvaldsaf13cdf2005-10-28 19:41:49[diff] [blame]741
Junio C Hamano6677c462005-12-15 20:54:00[diff] [blame]742 for (cnt = 0; cnt < len; cnt++) {
Linus Torvaldsaf13cdf2005-10-28 19:41:49[diff] [blame]743 switch (*path++) {
744 case '\0':
745 break;
746 case '/':
747 if (slash)
748 break;
749 slash = 1;
750 continue;
751 case '.':
752 continue;
753 default:
754 slash = 0;
755 continue;
756 }
Junio C Hamanoc054d642005-12-17 08:00:50[diff] [blame]757 break;
Linus Torvaldsaf13cdf2005-10-28 19:41:49[diff] [blame]758 }
Junio C Hamano6677c462005-12-15 20:54:00[diff] [blame]759 return slash;
Linus Torvaldsaf13cdf2005-10-28 19:41:49[diff] [blame]760}
761
Jeff Kinga1ad0eb2015-05-21 04:45:39[diff] [blame]762static inline int at_mark(const char *string, int len,
763 const char **suffix, int nr)
Junio C Hamanoae0ba8e2010-01-20 07:17:11[diff] [blame]764{
Junio C Hamanoae0ba8e2010-01-20 07:17:11[diff] [blame]765 int i;
766
Jeff Kinga1ad0eb2015-05-21 04:45:39[diff] [blame]767 for (i = 0; i < nr; i++) {
Junio C Hamanoae0ba8e2010-01-20 07:17:11[diff] [blame]768 int suffix_len = strlen(suffix[i]);
769 if (suffix_len <= len
Ævar Arnfjörð Bjarmason244ea1b2017-03-27 11:16:55[diff] [blame]770 && !strncasecmp(string, suffix[i], suffix_len))
Junio C Hamanoae0ba8e2010-01-20 07:17:11[diff] [blame]771 return suffix_len;
772 }
773 return 0;
774}
775
Jeff Kinga1ad0eb2015-05-21 04:45:39[diff] [blame]776static inline int upstream_mark(const char *string, int len)
777{
778 const char *suffix[] = { "@{upstream}", "@{u}" };
779 return at_mark(string, len, suffix, ARRAY_SIZE(suffix));
780}
781
Jeff Kingadfe5d02015-05-21 04:45:47[diff] [blame]782static inline int push_mark(const char *string, int len)
783{
784 const char *suffix[] = { "@{push}" };
785 return at_mark(string, len, suffix, ARRAY_SIZE(suffix));
786}
787
Nguyễn Thái Ngọc Duy2b1790f2019-04-16 09:33:32[diff] [blame]788static enum get_oid_result get_oid_1(struct repository *r, const char *name, int len, struct object_id *oid, unsigned lookup_flags);
Nguyễn Thái Ngọc Duy23a57122019-04-16 09:33:26[diff] [blame]789static int interpret_nth_prior_checkout(struct repository *r, const char *name, int namelen, struct strbuf *buf);
Thomas Rastd18ba222009-01-17 16:09:55[diff] [blame]790
Nguyễn Thái Ngọc Duy49281cf2019-04-16 09:33:31[diff] [blame]791static int get_oid_basic(struct repository *r, const char *str, int len,
792 struct object_id *oid, unsigned int flags)
Junio C Hamanoe86eb662007-01-19 09:15:15[diff] [blame]793{
Jon Seymoureedce782010-08-24 04:52:43[diff] [blame]794 static const char *warn_msg = "refname '%.*s' is ambiguous.";
Nguyễn Thái Ngọc Duy798c35f2013-05-29 12:12:42[diff] [blame]795 static const char *object_name_msg = N_(
796 "Git normally never creates a ref that ends with 40 hex characters\n"
797 "because it will be ignored when you just specify 40-hex. These refs\n"
798 "may be created by mistake. For example,\n"
799 "\n"
Nguyễn Thái Ngọc Duy328c6cb2019-03-29 10:39:19[diff] [blame]800 " git switch -c $br $(git rev-parse ...)\n"
Nguyễn Thái Ngọc Duy798c35f2013-05-29 12:12:42[diff] [blame]801 "\n"
802 "where \"$br\" is somehow empty and a 40-hex ref is created. Please\n"
803 "examine these refs and maybe delete them. Turn this message off by\n"
Thomas Rast8dc84fd2013-07-31 20:23:31[diff] [blame]804 "running \"git config advice.objectNameWarning false\"");
brian m. carlsone82caf32017-07-13 23:49:28[diff] [blame]805 struct object_id tmp_oid;
Linus Torvaldsed378ec2006-09-12 03:17:35[diff] [blame]806 char *real_ref = NULL;
Junio C Hamanoab2a1a32006-10-06 06:16:15[diff] [blame]807 int refs_found = 0;
Felipe Contreras128fd542013-05-07 21:55:10[diff] [blame]808 int at, reflog_len, nth_prior = 0;
Junio C Hamano9938af62005-08-04 05:15:49[diff] [blame]809
Nguyễn Thái Ngọc Duy49281cf2019-04-16 09:33:31[diff] [blame]810 if (len == r->hash_algo->hexsz && !get_oid_hex(str, oid)) {
Brodie Rao832cf742014-01-07 03:32:01[diff] [blame]811 if (warn_ambiguous_refs && warn_on_object_refname_ambiguity) {
Jonathan Tanf24c30e2020-09-01 22:28:09[diff] [blame]812 refs_found = repo_dwim_ref(r, str, len, &tmp_oid, &real_ref, 0);
Brodie Rao832cf742014-01-07 03:32:01[diff] [blame]813 if (refs_found > 0) {
Jeff King25fba782013-07-12 06:20:05[diff] [blame]814 warning(warn_msg, len, str);
815 if (advice_object_name_warning)
816 fprintf(stderr, "%s\n", _(object_name_msg));
817 }
818 free(real_ref);
Nguyễn Thái Ngọc Duy798c35f2013-05-29 12:12:42[diff] [blame]819 }
Junio C Hamano9938af62005-08-04 05:15:49[diff] [blame]820 return 0;
Nguyễn Thái Ngọc Duy798c35f2013-05-29 12:12:42[diff] [blame]821 }
Junio C Hamano9938af62005-08-04 05:15:49[diff] [blame]822
Thomas Rastd18ba222009-01-17 16:09:55[diff] [blame]823 /* basic@{time or number or -number} format to query ref-log */
Junio C Hamano694500e2006-10-24 04:15:34[diff] [blame]824 reflog_len = at = 0;
Johannes Schindelinf2654582009-01-27 23:07:46[diff] [blame]825 if (len && str[len-1] == '}') {
Ramkumar Ramachandrae883a052013-05-07 21:55:09[diff] [blame]826 for (at = len-4; at >= 0; at--) {
Junio C Hamanoab2a1a32006-10-06 06:16:15[diff] [blame]827 if (str[at] == '@' && str[at+1] == '{') {
Ramkumar Ramachandra83d16bc2013-05-07 21:55:11[diff] [blame]828 if (str[at+2] == '-') {
829 if (at != 0)
830 /* @{-N} not at start */
831 return -1;
Felipe Contreras128fd542013-05-07 21:55:10[diff] [blame]832 nth_prior = 1;
833 continue;
834 }
Jeff Kingadfe5d02015-05-21 04:45:47[diff] [blame]835 if (!upstream_mark(str + at, len - at) &&
836 !push_mark(str + at, len - at)) {
Johannes Schindelin28fb8432009-09-10 15:25:57[diff] [blame]837 reflog_len = (len-1) - (at+2);
838 len = at;
839 }
Junio C Hamanoab2a1a32006-10-06 06:16:15[diff] [blame]840 break;
841 }
Shawn Pearced556fae2006-05-17 09:56:09[diff] [blame]842 }
843 }
844
Linus Torvaldsaf13cdf2005-10-28 19:41:49[diff] [blame]845 /* Accept only unambiguous ref paths. */
Nicolas Pitre11cf8802007-02-01 22:29:33[diff] [blame]846 if (len && ambiguous_path(str, len))
Linus Torvaldsaf13cdf2005-10-28 19:41:49[diff] [blame]847 return -1;
848
Felipe Contreras128fd542013-05-07 21:55:10[diff] [blame]849 if (nth_prior) {
Thomas Rastd18ba222009-01-17 16:09:55[diff] [blame]850 struct strbuf buf = STRBUF_INIT;
Felipe Contreras128fd542013-05-07 21:55:10[diff] [blame]851 int detached;
852
Nguyễn Thái Ngọc Duy49281cf2019-04-16 09:33:31[diff] [blame]853 if (interpret_nth_prior_checkout(r, str, len, &buf) > 0) {
854 detached = (buf.len == r->hash_algo->hexsz && !get_oid_hex(buf.buf, oid));
Felipe Contreras128fd542013-05-07 21:55:10[diff] [blame]855 strbuf_release(&buf);
856 if (detached)
857 return 0;
Thomas Rastd18ba222009-01-17 16:09:55[diff] [blame]858 }
Felipe Contreras128fd542013-05-07 21:55:10[diff] [blame]859 }
860
861 if (!len && reflog_len)
Nicolas Pitre11cf8802007-02-01 22:29:33[diff] [blame]862 /* allow "@{...}" to mean the current branch reflog */
Jonathan Tanf24c30e2020-09-01 22:28:09[diff] [blame]863 refs_found = repo_dwim_ref(r, "HEAD", 4, oid, &real_ref, 0);
Felipe Contreras128fd542013-05-07 21:55:10[diff] [blame]864 else if (reflog_len)
Nguyễn Thái Ngọc Duy49281cf2019-04-16 09:33:31[diff] [blame]865 refs_found = repo_dwim_log(r, str, len, oid, &real_ref);
Nicolas Pitref2eba662007-02-04 02:49:16[diff] [blame]866 else
Jonathan Tanf24c30e2020-09-01 22:28:09[diff] [blame]867 refs_found = repo_dwim_ref(r, str, len, oid, &real_ref, 0);
Shawn Pearced556fae2006-05-17 09:56:09[diff] [blame]868
869 if (!refs_found)
870 return -1;
871
brian m. carlson321c89b2017-07-13 23:49:29[diff] [blame]872 if (warn_ambiguous_refs && !(flags & GET_OID_QUIETLY) &&
Nguyễn Thái Ngọc Duy798c35f2013-05-29 12:12:42[diff] [blame]873 (refs_found > 1 ||
Nguyễn Thái Ngọc Duy49281cf2019-04-16 09:33:31[diff] [blame]874 !get_short_oid(r, str, len, &tmp_oid, GET_OID_QUIETLY)))
Jon Seymoureedce782010-08-24 04:52:43[diff] [blame]875 warning(warn_msg, len, str);
Shawn Pearced556fae2006-05-17 09:56:09[diff] [blame]876
Junio C Hamanoab2a1a32006-10-06 06:16:15[diff] [blame]877 if (reflog_len) {
Junio C Hamanoab2a1a32006-10-06 06:16:15[diff] [blame]878 int nth, i;
Johannes Schindelindddbad72017-04-26 19:29:31[diff] [blame]879 timestamp_t at_time;
880 timestamp_t co_time;
Junio C Hamano16d7cc92007-01-19 09:19:05[diff] [blame]881 int co_tz, co_cnt;
882
Nicolas Pitrefe558512007-02-01 17:33:23[diff] [blame]883 /* Is it asking for N-th entry, or approxidate? */
Junio C Hamanoab2a1a32006-10-06 06:16:15[diff] [blame]884 for (i = nth = 0; 0 <= nth && i < reflog_len; i++) {
885 char ch = str[at+2+i];
886 if ('0' <= ch && ch <= '9')
887 nth = nth * 10 + ch - '0';
888 else
889 nth = -1;
890 }
Shawn O. Pearceea360dd2008-08-21 15:40:44[diff] [blame]891 if (100000000 <= nth) {
892 at_time = nth;
893 nth = -1;
894 } else if (0 <= nth)
Junio C Hamanoab2a1a32006-10-06 06:16:15[diff] [blame]895 at_time = 0;
Jeff King861f00e2008-04-30 04:13:58[diff] [blame]896 else {
Junio C Hamano93cfa7c2010-01-26 19:58:00[diff] [blame]897 int errors = 0;
Jeff King861f00e2008-04-30 04:13:58[diff] [blame]898 char *tmp = xstrndup(str + at + 2, reflog_len);
Junio C Hamano93cfa7c2010-01-26 19:58:00[diff] [blame]899 at_time = approxidate_careful(tmp, &errors);
Jeff King861f00e2008-04-30 04:13:58[diff] [blame]900 free(tmp);
Jeff King28b35632014-07-24 04:41:11[diff] [blame]901 if (errors) {
902 free(real_ref);
Junio C Hamanoa5e10ac2010-01-27 18:53:09[diff] [blame]903 return -1;
Jeff King28b35632014-07-24 04:41:11[diff] [blame]904 }
Jeff King861f00e2008-04-30 04:13:58[diff] [blame]905 }
Nguyễn Thái Ngọc Duy49281cf2019-04-16 09:33:31[diff] [blame]906 if (read_ref_at(get_main_ref_store(r),
Nguyễn Thái Ngọc Duy7fdff472019-04-06 11:34:30[diff] [blame]907 real_ref, flags, at_time, nth, oid, NULL,
Junio C Hamano16d7cc92007-01-19 09:19:05[diff] [blame]908 &co_time, &co_tz, &co_cnt)) {
Ramkumar Ramachandra305ebea2013-05-22 10:39:55[diff] [blame]909 if (!len) {
Junio C Hamano145136a2020-01-30 19:35:46[diff] [blame]910 if (!skip_prefix(real_ref, "refs/heads/", &str))
Ramkumar Ramachandra305ebea2013-05-22 10:39:55[diff] [blame]911 str = "HEAD";
Junio C Hamano145136a2020-01-30 19:35:46[diff] [blame]912 len = strlen(str);
Ramkumar Ramachandra305ebea2013-05-22 10:39:55[diff] [blame]913 }
David Aguilarc41a87d2014-09-19 03:45:37[diff] [blame]914 if (at_time) {
brian m. carlson321c89b2017-07-13 23:49:29[diff] [blame]915 if (!(flags & GET_OID_QUIETLY)) {
Jeff Kingb0418302020-01-25 00:13:01[diff] [blame]916 warning(_("log for '%.*s' only goes back to %s"),
917 len, str,
Jeff Kinga5481a62015-06-25 16:55:02[diff] [blame]918 show_date(co_time, co_tz, DATE_MODE(RFC2822)));
David Aguilarc41a87d2014-09-19 03:45:37[diff] [blame]919 }
920 } else {
brian m. carlson321c89b2017-07-13 23:49:29[diff] [blame]921 if (flags & GET_OID_QUIETLY) {
David Aguilarc41a87d2014-09-19 03:45:37[diff] [blame]922 exit(128);
923 }
Jeff Kingb0418302020-01-25 00:13:01[diff] [blame]924 die(_("log for '%.*s' only has %d entries"),
Jon Seymoure6eedc32010-08-24 04:52:42[diff] [blame]925 len, str, co_cnt);
926 }
Junio C Hamano16d7cc92007-01-19 09:19:05[diff] [blame]927 }
Shawn Pearced556fae2006-05-17 09:56:09[diff] [blame]928 }
929
Linus Torvaldsed378ec2006-09-12 03:17:35[diff] [blame]930 free(real_ref);
Shawn Pearced556fae2006-05-17 09:56:09[diff] [blame]931 return 0;
Junio C Hamano9938af62005-08-04 05:15:49[diff] [blame]932}
933
Nguyễn Thái Ngọc Duy2b1790f2019-04-16 09:33:32[diff] [blame]934static enum get_oid_result get_parent(struct repository *r,
935 const char *name, int len,
David Turnerd1dd94b2019-01-18 04:19:43[diff] [blame]936 struct object_id *result, int idx)
Junio C Hamano9938af62005-08-04 05:15:49[diff] [blame]937{
brian m. carlson1e43ed92017-05-06 22:10:09[diff] [blame]938 struct object_id oid;
Nguyễn Thái Ngọc Duy2b1790f2019-04-16 09:33:32[diff] [blame]939 enum get_oid_result ret = get_oid_1(r, name, len, &oid,
David Turnerd1dd94b2019-01-18 04:19:43[diff] [blame]940 GET_OID_COMMITTISH);
Junio C Hamano9938af62005-08-04 05:15:49[diff] [blame]941 struct commit *commit;
942 struct commit_list *p;
943
944 if (ret)
945 return ret;
Nguyễn Thái Ngọc Duy2b1790f2019-04-16 09:33:32[diff] [blame]946 commit = lookup_commit_reference(r, &oid);
Junio C Hamano9938af62005-08-04 05:15:49[diff] [blame]947 if (parse_commit(commit))
David Turnerd1dd94b2019-01-18 04:19:43[diff] [blame]948 return MISSING_OBJECT;
Junio C Hamano9938af62005-08-04 05:15:49[diff] [blame]949 if (!idx) {
brian m. carlsone82caf32017-07-13 23:49:28[diff] [blame]950 oidcpy(result, &commit->object.oid);
David Turnerd1dd94b2019-01-18 04:19:43[diff] [blame]951 return FOUND;
Junio C Hamano9938af62005-08-04 05:15:49[diff] [blame]952 }
953 p = commit->parents;
954 while (p) {
955 if (!--idx) {
brian m. carlsone82caf32017-07-13 23:49:28[diff] [blame]956 oidcpy(result, &p->item->object.oid);
David Turnerd1dd94b2019-01-18 04:19:43[diff] [blame]957 return FOUND;
Junio C Hamano9938af62005-08-04 05:15:49[diff] [blame]958 }
959 p = p->next;
960 }
David Turnerd1dd94b2019-01-18 04:19:43[diff] [blame]961 return MISSING_OBJECT;
Junio C Hamano9938af62005-08-04 05:15:49[diff] [blame]962}
963
Nguyễn Thái Ngọc Duy2b1790f2019-04-16 09:33:32[diff] [blame]964static enum get_oid_result get_nth_ancestor(struct repository *r,
965 const char *name, int len,
David Turnerd1dd94b2019-01-18 04:19:43[diff] [blame]966 struct object_id *result,
967 int generation)
Junio C Hamano4f7599a2005-08-21 09:43:54[diff] [blame]968{
brian m. carlson1e43ed92017-05-06 22:10:09[diff] [blame]969 struct object_id oid;
Linus Torvalds621ff672008-03-14 18:49:40[diff] [blame]970 struct commit *commit;
971 int ret;
972
Nguyễn Thái Ngọc Duy2b1790f2019-04-16 09:33:32[diff] [blame]973 ret = get_oid_1(r, name, len, &oid, GET_OID_COMMITTISH);
Junio C Hamano4f7599a2005-08-21 09:43:54[diff] [blame]974 if (ret)
975 return ret;
Nguyễn Thái Ngọc Duy2b1790f2019-04-16 09:33:32[diff] [blame]976 commit = lookup_commit_reference(r, &oid);
Linus Torvalds621ff672008-03-14 18:49:40[diff] [blame]977 if (!commit)
David Turnerd1dd94b2019-01-18 04:19:43[diff] [blame]978 return MISSING_OBJECT;
Junio C Hamano4f7599a2005-08-21 09:43:54[diff] [blame]979
980 while (generation--) {
Linus Torvalds621ff672008-03-14 18:49:40[diff] [blame]981 if (parse_commit(commit) || !commit->parents)
David Turnerd1dd94b2019-01-18 04:19:43[diff] [blame]982 return MISSING_OBJECT;
Linus Torvalds621ff672008-03-14 18:49:40[diff] [blame]983 commit = commit->parents->item;
Junio C Hamano4f7599a2005-08-21 09:43:54[diff] [blame]984 }
brian m. carlsone82caf32017-07-13 23:49:28[diff] [blame]985 oidcpy(result, &commit->object.oid);
David Turnerd1dd94b2019-01-18 04:19:43[diff] [blame]986 return FOUND;
Junio C Hamano4f7599a2005-08-21 09:43:54[diff] [blame]987}
988
Nguyễn Thái Ngọc Duy2b1790f2019-04-16 09:33:32[diff] [blame]989struct object *repo_peel_to_type(struct repository *r, const char *name, int namelen,
990 struct object *o, enum object_type expected_type)
Junio C Hamano81776312007-12-24 08:51:01[diff] [blame]991{
992 if (name && !namelen)
993 namelen = strlen(name);
Junio C Hamano81776312007-12-24 08:51:01[diff] [blame]994 while (1) {
Nguyễn Thái Ngọc Duy2b1790f2019-04-16 09:33:32[diff] [blame]995 if (!o || (!o->parsed && !parse_object(r, &o->oid)))
Junio C Hamano81776312007-12-24 08:51:01[diff] [blame]996 return NULL;
Junio C Hamanoa6a3f2c2013-03-31 22:24:12[diff] [blame]997 if (expected_type == OBJ_ANY || o->type == expected_type)
Junio C Hamano81776312007-12-24 08:51:01[diff] [blame]998 return o;
999 if (o->type == OBJ_TAG)
1000 o = ((struct tag*) o)->tagged;
1001 else if (o->type == OBJ_COMMIT)
Nguyễn Thái Ngọc Duy2b1790f2019-04-16 09:33:32[diff] [blame]1002 o = &(repo_get_commit_tree(r, ((struct commit *)o))->object);
Junio C Hamano81776312007-12-24 08:51:01[diff] [blame]1003 else {
1004 if (name)
1005 error("%.*s: expected %s type, but the object "
1006 "dereferences to %s type",
Brandon Williamsdebca9d2018-02-14 18:59:24[diff] [blame]1007 namelen, name, type_name(expected_type),
1008 type_name(o->type));
Junio C Hamano81776312007-12-24 08:51:01[diff] [blame]1009 return NULL;
1010 }
1011 }
1012}
1013
Nguyễn Thái Ngọc Duy2b1790f2019-04-16 09:33:32[diff] [blame]1014static int peel_onion(struct repository *r, const char *name, int len,
1015 struct object_id *oid, unsigned lookup_flags)
Junio C Hamano5385f522005-10-14 01:57:40[diff] [blame]1016{
brian m. carlsonde37d502017-05-06 22:10:29[diff] [blame]1017 struct object_id outer;
Junio C Hamano5385f522005-10-14 01:57:40[diff] [blame]1018 const char *sp;
Linus Torvalds885a86a2006-06-14 23:45:13[diff] [blame]1019 unsigned int expected_type = 0;
Junio C Hamano5385f522005-10-14 01:57:40[diff] [blame]1020 struct object *o;
1021
1022 /*
1023 * "ref^{type}" dereferences ref repeatedly until you cannot
1024 * dereference anymore, or you get an object of given type,
1025 * whichever comes first. "ref^{}" means just dereference
1026 * tags until you get a non-tag. "ref^0" is a shorthand for
1027 * "ref^{commit}". "commit^{tree}" could be used to find the
1028 * top-level tree of the given commit.
1029 */
1030 if (len < 4 || name[len-1] != '}')
1031 return -1;
1032
1033 for (sp = name + len - 1; name <= sp; sp--) {
1034 int ch = *sp;
1035 if (ch == '{' && name < sp && sp[-1] == '^')
1036 break;
1037 }
1038 if (sp <= name)
1039 return -1;
1040
1041 sp++; /* beginning of type name, or closing brace for empty */
Christian Couder59556542013-11-30 20:55:40[diff] [blame]1042 if (starts_with(sp, "commit}"))
Linus Torvalds19746322006-07-12 03:45:31[diff] [blame]1043 expected_type = OBJ_COMMIT;
Christian Couder59556542013-11-30 20:55:40[diff] [blame]1044 else if (starts_with(sp, "tag}"))
Richard Hansen75aa26d2013-09-03 19:50:16[diff] [blame]1045 expected_type = OBJ_TAG;
Christian Couder59556542013-11-30 20:55:40[diff] [blame]1046 else if (starts_with(sp, "tree}"))
Linus Torvalds19746322006-07-12 03:45:31[diff] [blame]1047 expected_type = OBJ_TREE;
Christian Couder59556542013-11-30 20:55:40[diff] [blame]1048 else if (starts_with(sp, "blob}"))
Linus Torvalds19746322006-07-12 03:45:31[diff] [blame]1049 expected_type = OBJ_BLOB;
Christian Couder59556542013-11-30 20:55:40[diff] [blame]1050 else if (starts_with(sp, "object}"))
Junio C Hamanoa6a3f2c2013-03-31 22:24:12[diff] [blame]1051 expected_type = OBJ_ANY;
Junio C Hamano5385f522005-10-14 01:57:40[diff] [blame]1052 else if (sp[0] == '}')
Linus Torvalds19746322006-07-12 03:45:31[diff] [blame]1053 expected_type = OBJ_NONE;
Nguyễn Thái Ngọc Duy32574b62010-12-13 03:01:15[diff] [blame]1054 else if (sp[0] == '/')
1055 expected_type = OBJ_COMMIT;
Junio C Hamano5385f522005-10-14 01:57:40[diff] [blame]1056 else
1057 return -1;
1058
brian m. carlson321c89b2017-07-13 23:49:29[diff] [blame]1059 lookup_flags &= ~GET_OID_DISAMBIGUATORS;
Junio C Hamanoe2643612012-07-02 17:00:40[diff] [blame]1060 if (expected_type == OBJ_COMMIT)
brian m. carlson321c89b2017-07-13 23:49:29[diff] [blame]1061 lookup_flags |= GET_OID_COMMITTISH;
Junio C Hamanoed1ca602013-03-31 22:19:52[diff] [blame]1062 else if (expected_type == OBJ_TREE)
brian m. carlson321c89b2017-07-13 23:49:29[diff] [blame]1063 lookup_flags |= GET_OID_TREEISH;
Junio C Hamanoe2643612012-07-02 17:00:40[diff] [blame]1064
Nguyễn Thái Ngọc Duy2b1790f2019-04-16 09:33:32[diff] [blame]1065 if (get_oid_1(r, name, sp - name - 2, &outer, lookup_flags))
Junio C Hamano5385f522005-10-14 01:57:40[diff] [blame]1066 return -1;
1067
Nguyễn Thái Ngọc Duy2b1790f2019-04-16 09:33:32[diff] [blame]1068 o = parse_object(r, &outer);
Junio C Hamano5385f522005-10-14 01:57:40[diff] [blame]1069 if (!o)
1070 return -1;
Linus Torvalds885a86a2006-06-14 23:45:13[diff] [blame]1071 if (!expected_type) {
Nguyễn Thái Ngọc Duy2b1790f2019-04-16 09:33:32[diff] [blame]1072 o = deref_tag(r, o, name, sp - name - 2);
1073 if (!o || (!o->parsed && !parse_object(r, &o->oid)))
Junio C Hamano6e1c6c12005-10-20 05:48:16[diff] [blame]1074 return -1;
brian m. carlsone82caf32017-07-13 23:49:28[diff] [blame]1075 oidcpy(oid, &o->oid);
Nguyễn Thái Ngọc Duy32574b62010-12-13 03:01:15[diff] [blame]1076 return 0;
Junio C Hamano5385f522005-10-14 01:57:40[diff] [blame]1077 }
Nguyễn Thái Ngọc Duy32574b62010-12-13 03:01:15[diff] [blame]1078
1079 /*
1080 * At this point, the syntax look correct, so
1081 * if we do not get the needed object, we should
1082 * barf.
1083 */
Nguyễn Thái Ngọc Duy2b1790f2019-04-16 09:33:32[diff] [blame]1084 o = repo_peel_to_type(r, name, len, o, expected_type);
Nguyễn Thái Ngọc Duy32574b62010-12-13 03:01:15[diff] [blame]1085 if (!o)
Junio C Hamano81776312007-12-24 08:51:01[diff] [blame]1086 return -1;
Nguyễn Thái Ngọc Duy32574b62010-12-13 03:01:15[diff] [blame]1087
brian m. carlsone82caf32017-07-13 23:49:28[diff] [blame]1088 oidcpy(oid, &o->oid);
Nguyễn Thái Ngọc Duy32574b62010-12-13 03:01:15[diff] [blame]1089 if (sp[0] == '/') {
1090 /* "$commit^{/foo}" */
1091 char *prefix;
1092 int ret;
1093 struct commit_list *list = NULL;
1094
Nguyễn Thái Ngọc Duy43228422010-12-15 09:02:54[diff] [blame]1095 /*
1096 * $commit^{/}. Some regex implementation may reject.
1097 * We don't need regex anyway. '' pattern always matches.
1098 */
1099 if (sp[1] == '}')
1100 return 0;
1101
Nguyễn Thái Ngọc Duy32574b62010-12-13 03:01:15[diff] [blame]1102 prefix = xstrndup(sp + 1, name + len - 1 - (sp + 1));
1103 commit_list_insert((struct commit *)o, &list);
Nguyễn Thái Ngọc Duy2b1790f2019-04-16 09:33:32[diff] [blame]1104 ret = get_oid_oneline(r, prefix, oid, list);
Nguyễn Thái Ngọc Duy32574b62010-12-13 03:01:15[diff] [blame]1105 free(prefix);
1106 return ret;
Junio C Hamano5385f522005-10-14 01:57:40[diff] [blame]1107 }
1108 return 0;
1109}
1110
Nguyễn Thái Ngọc Duy0c6b5ba2019-04-16 09:33:30[diff] [blame]1111static int get_describe_name(struct repository *r,
1112 const char *name, int len,
1113 struct object_id *oid)
Junio C Hamano7dd45e12006-09-20 23:11:08[diff] [blame]1114{
1115 const char *cp;
brian m. carlson321c89b2017-07-13 23:49:29[diff] [blame]1116 unsigned flags = GET_OID_QUIETLY | GET_OID_COMMIT;
Junio C Hamano7dd45e12006-09-20 23:11:08[diff] [blame]1117
1118 for (cp = name + len - 1; name + 2 <= cp; cp--) {
1119 char ch = *cp;
René Scharfe6f75d452015-03-09 22:46:54[diff] [blame]1120 if (!isxdigit(ch)) {
Junio C Hamano7dd45e12006-09-20 23:11:08[diff] [blame]1121 /* We must be looking at g in "SOMETHING-g"
1122 * for it to be describe output.
1123 */
1124 if (ch == 'g' && cp[-1] == '-') {
1125 cp++;
1126 len -= cp - name;
Nguyễn Thái Ngọc Duy0c6b5ba2019-04-16 09:33:30[diff] [blame]1127 return get_short_oid(r,
Nguyễn Thái Ngọc Duyc6c02352019-04-16 09:33:25[diff] [blame]1128 cp, len, oid, flags);
Junio C Hamano7dd45e12006-09-20 23:11:08[diff] [blame]1129 }
1130 }
1131 }
1132 return -1;
1133}
1134
Nguyễn Thái Ngọc Duy2b1790f2019-04-16 09:33:32[diff] [blame]1135static enum get_oid_result get_oid_1(struct repository *r,
1136 const char *name, int len,
David Turnerd1dd94b2019-01-18 04:19:43[diff] [blame]1137 struct object_id *oid,
1138 unsigned lookup_flags)
Junio C Hamano9938af62005-08-04 05:15:49[diff] [blame]1139{
Junio C Hamano0601dbe2006-02-03 07:48:36[diff] [blame]1140 int ret, has_suffix;
Junio C Hamano4f7599a2005-08-21 09:43:54[diff] [blame]1141 const char *cp;
Junio C Hamano9938af62005-08-04 05:15:49[diff] [blame]1142
Linus Torvalds621ff672008-03-14 18:49:40[diff] [blame]1143 /*
1144 * "name~3" is "name^^^", "name~" is "name~1", and "name^" is "name^1".
Junio C Hamano4f7599a2005-08-21 09:43:54[diff] [blame]1145 */
Junio C Hamano0601dbe2006-02-03 07:48:36[diff] [blame]1146 has_suffix = 0;
Junio C Hamano4f7599a2005-08-21 09:43:54[diff] [blame]1147 for (cp = name + len - 1; name <= cp; cp--) {
1148 int ch = *cp;
1149 if ('0' <= ch && ch <= '9')
1150 continue;
Junio C Hamano0601dbe2006-02-03 07:48:36[diff] [blame]1151 if (ch == '~' || ch == '^')
1152 has_suffix = ch;
Junio C Hamano4f7599a2005-08-21 09:43:54[diff] [blame]1153 break;
1154 }
Junio C Hamano0601dbe2006-02-03 07:48:36[diff] [blame]1155
1156 if (has_suffix) {
René Scharfe59fa5f52019-09-15 12:10:28[diff] [blame]1157 unsigned int num = 0;
Junio C Hamano4f7599a2005-08-21 09:43:54[diff] [blame]1158 int len1 = cp - name;
1159 cp++;
René Scharfe59fa5f52019-09-15 12:10:28[diff] [blame]1160 while (cp < name + len) {
1161 unsigned int digit = *cp++ - '0';
1162 if (unsigned_mult_overflows(num, 10))
1163 return MISSING_OBJECT;
1164 num *= 10;
1165 if (unsigned_add_overflows(num, digit))
1166 return MISSING_OBJECT;
1167 num += digit;
1168 }
Linus Torvalds621ff672008-03-14 18:49:40[diff] [blame]1169 if (!num && len1 == len - 1)
1170 num = 1;
René Scharfe59fa5f52019-09-15 12:10:28[diff] [blame]1171 else if (num > INT_MAX)
1172 return MISSING_OBJECT;
Linus Torvalds621ff672008-03-14 18:49:40[diff] [blame]1173 if (has_suffix == '^')
Nguyễn Thái Ngọc Duy2b1790f2019-04-16 09:33:32[diff] [blame]1174 return get_parent(r, name, len1, oid, num);
Junio C Hamano0601dbe2006-02-03 07:48:36[diff] [blame]1175 /* else if (has_suffix == '~') -- goes without saying */
Nguyễn Thái Ngọc Duy2b1790f2019-04-16 09:33:32[diff] [blame]1176 return get_nth_ancestor(r, name, len1, oid, num);
Junio C Hamano4f7599a2005-08-21 09:43:54[diff] [blame]1177 }
1178
Nguyễn Thái Ngọc Duy2b1790f2019-04-16 09:33:32[diff] [blame]1179 ret = peel_onion(r, name, len, oid, lookup_flags);
Junio C Hamano5385f522005-10-14 01:57:40[diff] [blame]1180 if (!ret)
David Turnerd1dd94b2019-01-18 04:19:43[diff] [blame]1181 return FOUND;
Junio C Hamano5385f522005-10-14 01:57:40[diff] [blame]1182
Nguyễn Thái Ngọc Duy2b1790f2019-04-16 09:33:32[diff] [blame]1183 ret = get_oid_basic(r, name, len, oid, lookup_flags);
Junio C Hamano9938af62005-08-04 05:15:49[diff] [blame]1184 if (!ret)
David Turnerd1dd94b2019-01-18 04:19:43[diff] [blame]1185 return FOUND;
Junio C Hamano7dd45e12006-09-20 23:11:08[diff] [blame]1186
1187 /* It could be describe output that is "SOMETHING-gXXXX" */
Nguyễn Thái Ngọc Duy2b1790f2019-04-16 09:33:32[diff] [blame]1188 ret = get_describe_name(r, name, len, oid);
Junio C Hamano7dd45e12006-09-20 23:11:08[diff] [blame]1189 if (!ret)
David Turnerd1dd94b2019-01-18 04:19:43[diff] [blame]1190 return FOUND;
Junio C Hamano7dd45e12006-09-20 23:11:08[diff] [blame]1191
Nguyễn Thái Ngọc Duy2b1790f2019-04-16 09:33:32[diff] [blame]1192 return get_short_oid(r, name, len, oid, lookup_flags);
Junio C Hamano9938af62005-08-04 05:15:49[diff] [blame]1193}
1194
Junio C Hamanof7bff002010-08-02 21:37:06[diff] [blame]1195/*
1196 * This interprets names like ':/Initial revision of "git"' by searching
1197 * through history and returning the first commit whose message starts
Junio C Hamano3d045892010-08-13 01:32:49[diff] [blame]1198 * the given regular expression.
Junio C Hamanof7bff002010-08-02 21:37:06[diff] [blame]1199 *
Will Palmer07698542016-01-31 00:06:01[diff] [blame]1200 * For negative-matching, prefix the pattern-part with '!-', like: ':/!-WIP'.
1201 *
1202 * For a literal '!' character at the beginning of a pattern, you have to repeat
1203 * that, like: ':/!!foo'
1204 *
1205 * For future extension, all other sequences beginning with ':/!' are reserved.
Junio C Hamanof7bff002010-08-02 21:37:06[diff] [blame]1206 */
Nguyễn Thái Ngọc Duy208acbf2014-03-25 13:23:26[diff] [blame]1207
1208/* Remember to update object flag allocation in object.h */
Junio C Hamanof7bff002010-08-02 21:37:06[diff] [blame]1209#define ONELINE_SEEN (1u<<20)
1210
Nguyễn Thái Ngọc Duyc931ba42019-04-16 09:33:33[diff] [blame]1211struct handle_one_ref_cb {
1212 struct repository *repo;
1213 struct commit_list **list;
1214};
1215
Michael Haggerty9c5fe0b2015-05-25 18:39:05[diff] [blame]1216static int handle_one_ref(const char *path, const struct object_id *oid,
1217 int flag, void *cb_data)
Johannes Schindelin28a4d942007-02-24 02:08:20[diff] [blame]1218{
Nguyễn Thái Ngọc Duyc931ba42019-04-16 09:33:33[diff] [blame]1219 struct handle_one_ref_cb *cb = cb_data;
1220 struct commit_list **list = cb->list;
1221 struct object *object = parse_object(cb->repo, oid);
Johannes Schindelin28a4d942007-02-24 02:08:20[diff] [blame]1222 if (!object)
1223 return 0;
Martin Koegleraffeef12008-02-18 07:31:54[diff] [blame]1224 if (object->type == OBJ_TAG) {
Nguyễn Thái Ngọc Duyc931ba42019-04-16 09:33:33[diff] [blame]1225 object = deref_tag(cb->repo, object, path,
Stefan Bellera74093d2018-06-29 01:22:05[diff] [blame]1226 strlen(path));
Martin Koegleraffeef12008-02-18 07:31:54[diff] [blame]1227 if (!object)
1228 return 0;
1229 }
Johannes Schindelin28a4d942007-02-24 02:08:20[diff] [blame]1230 if (object->type != OBJ_COMMIT)
1231 return 0;
René Scharfee8d1dfe2014-08-21 18:30:29[diff] [blame]1232 commit_list_insert((struct commit *)object, list);
Johannes Schindelin28a4d942007-02-24 02:08:20[diff] [blame]1233 return 0;
1234}
1235
Nguyễn Thái Ngọc Duy0bb41a12019-04-16 09:33:29[diff] [blame]1236static int get_oid_oneline(struct repository *r,
1237 const char *prefix, struct object_id *oid,
1238 struct commit_list *list)
Johannes Schindelin28a4d942007-02-24 02:08:20[diff] [blame]1239{
Nguyễn Thái Ngọc Duy84baa312010-12-13 03:01:14[diff] [blame]1240 struct commit_list *backup = NULL, *l;
Junio C Hamano28042db2010-12-13 06:19:00[diff] [blame]1241 int found = 0;
Will Palmer07698542016-01-31 00:06:01[diff] [blame]1242 int negative = 0;
Linus Torvalds57895102010-04-23 15:20:20[diff] [blame]1243 regex_t regex;
Johannes Schindelin28a4d942007-02-24 02:08:20[diff] [blame]1244
1245 if (prefix[0] == '!') {
Johannes Schindelin28a4d942007-02-24 02:08:20[diff] [blame]1246 prefix++;
Will Palmer07698542016-01-31 00:06:01[diff] [blame]1247
1248 if (prefix[0] == '-') {
1249 prefix++;
1250 negative = 1;
1251 } else if (prefix[0] != '!') {
Junio C Hamanoe6a6a762016-02-24 21:25:52[diff] [blame]1252 return -1;
Will Palmer07698542016-01-31 00:06:01[diff] [blame]1253 }
Johannes Schindelin28a4d942007-02-24 02:08:20[diff] [blame]1254 }
Linus Torvalds57895102010-04-23 15:20:20[diff] [blame]1255
1256 if (regcomp(&regex, prefix, REG_EXTENDED))
Jeff Kingaac4fac2016-02-10 21:19:25[diff] [blame]1257 return -1;
Linus Torvalds57895102010-04-23 15:20:20[diff] [blame]1258
Nguyễn Thái Ngọc Duy84baa312010-12-13 03:01:14[diff] [blame]1259 for (l = list; l; l = l->next) {
1260 l->item->object.flags |= ONELINE_SEEN;
Johannes Schindelin28a4d942007-02-24 02:08:20[diff] [blame]1261 commit_list_insert(l->item, &backup);
Nguyễn Thái Ngọc Duy84baa312010-12-13 03:01:14[diff] [blame]1262 }
Jim Meyeringed8ad7e2007-03-11 18:49:08[diff] [blame]1263 while (list) {
Jeff Kingba41c1c2014-06-10 21:41:02[diff] [blame]1264 const char *p, *buf;
Linus Torvalds1358e7d2007-03-12 18:30:38[diff] [blame]1265 struct commit *commit;
Junio C Hamano28042db2010-12-13 06:19:00[diff] [blame]1266 int matches;
Jim Meyeringed8ad7e2007-03-11 18:49:08[diff] [blame]1267
1268 commit = pop_most_recent_commit(&list, ONELINE_SEEN);
Nguyễn Thái Ngọc Duy0bb41a12019-04-16 09:33:29[diff] [blame]1269 if (!parse_object(r, &commit->object.oid))
Martin Koegler283cdbc2008-02-18 20:47:53[diff] [blame]1270 continue;
Jeff King8597ea32014-06-10 21:44:13[diff] [blame]1271 buf = get_commit_buffer(commit, NULL);
Jeff Kingba41c1c2014-06-10 21:41:02[diff] [blame]1272 p = strstr(buf, "\n\n");
Will Palmer07698542016-01-31 00:06:01[diff] [blame]1273 matches = negative ^ (p && !regexec(&regex, p + 2, 0, NULL, 0));
Jeff Kingba41c1c2014-06-10 21:41:02[diff] [blame]1274 unuse_commit_buffer(commit, buf);
Junio C Hamano28042db2010-12-13 06:19:00[diff] [blame]1275
1276 if (matches) {
brian m. carlsone82caf32017-07-13 23:49:28[diff] [blame]1277 oidcpy(oid, &commit->object.oid);
Junio C Hamano28042db2010-12-13 06:19:00[diff] [blame]1278 found = 1;
Johannes Schindelin28a4d942007-02-24 02:08:20[diff] [blame]1279 break;
1280 }
1281 }
Linus Torvalds57895102010-04-23 15:20:20[diff] [blame]1282 regfree(&regex);
Johannes Schindelin28a4d942007-02-24 02:08:20[diff] [blame]1283 free_commit_list(list);
1284 for (l = backup; l; l = l->next)
1285 clear_commit_marks(l->item, ONELINE_SEEN);
Junio C Hamano28042db2010-12-13 06:19:00[diff] [blame]1286 free_commit_list(backup);
1287 return found ? 0 : -1;
Johannes Schindelin28a4d942007-02-24 02:08:20[diff] [blame]1288}
1289
Junio C Hamanoae5a6c32009-01-17 16:09:53[diff] [blame]1290struct grab_nth_branch_switch_cbdata {
Junio C Hamano98f85ff2013-03-08 21:27:37[diff] [blame]1291 int remaining;
René Scharfe4b3aa172019-09-18 16:35:38[diff] [blame]1292 struct strbuf *sb;
Junio C Hamanoae5a6c32009-01-17 16:09:53[diff] [blame]1293};
1294
brian m. carlson9461d272017-02-21 23:47:32[diff] [blame]1295static int grab_nth_branch_switch(struct object_id *ooid, struct object_id *noid,
Johannes Schindelindddbad72017-04-26 19:29:31[diff] [blame]1296 const char *email, timestamp_t timestamp, int tz,
Junio C Hamanoae5a6c32009-01-17 16:09:53[diff] [blame]1297 const char *message, void *cb_data)
1298{
1299 struct grab_nth_branch_switch_cbdata *cb = cb_data;
Thomas Rasta884d0c2009-01-17 16:09:54[diff] [blame]1300 const char *match = NULL, *target = NULL;
1301 size_t len;
Junio C Hamanoae5a6c32009-01-17 16:09:53[diff] [blame]1302
Jeff King95b567c2014-06-18 19:48:29[diff] [blame]1303 if (skip_prefix(message, "checkout: moving from ", &match))
Junio C Hamanod7c03c12009-01-21 08:37:38[diff] [blame]1304 target = strstr(match, " to ");
Junio C Hamanoae5a6c32009-01-17 16:09:53[diff] [blame]1305
Junio C Hamanoc8297742009-01-20 00:44:08[diff] [blame]1306 if (!match || !target)
Junio C Hamanoae5a6c32009-01-17 16:09:53[diff] [blame]1307 return 0;
Junio C Hamano98f85ff2013-03-08 21:27:37[diff] [blame]1308 if (--(cb->remaining) == 0) {
1309 len = target - match;
René Scharfe4b3aa172019-09-18 16:35:38[diff] [blame]1310 strbuf_reset(cb->sb);
1311 strbuf_add(cb->sb, match, len);
Junio C Hamano98f85ff2013-03-08 21:27:37[diff] [blame]1312 return 1; /* we are done */
1313 }
Junio C Hamanoae5a6c32009-01-17 16:09:53[diff] [blame]1314 return 0;
1315}
1316
1317/*
Junio C Hamanoae0ba8e2010-01-20 07:17:11[diff] [blame]1318 * Parse @{-N} syntax, return the number of characters parsed
1319 * if successful; otherwise signal an error with negative value.
Junio C Hamanoae5a6c32009-01-17 16:09:53[diff] [blame]1320 */
Nguyễn Thái Ngọc Duy23a57122019-04-16 09:33:26[diff] [blame]1321static int interpret_nth_prior_checkout(struct repository *r,
1322 const char *name, int namelen,
Jeff King8cd42492014-01-15 08:31:57[diff] [blame]1323 struct strbuf *buf)
Junio C Hamanoae5a6c32009-01-17 16:09:53[diff] [blame]1324{
Junio C Hamanoc2883e62009-01-19 08:04:25[diff] [blame]1325 long nth;
Junio C Hamano98f85ff2013-03-08 21:27:37[diff] [blame]1326 int retval;
Junio C Hamanoae5a6c32009-01-17 16:09:53[diff] [blame]1327 struct grab_nth_branch_switch_cbdata cb;
Thomas Rasta884d0c2009-01-17 16:09:54[diff] [blame]1328 const char *brace;
1329 char *num_end;
Junio C Hamanoae5a6c32009-01-17 16:09:53[diff] [blame]1330
Jeff King8cd42492014-01-15 08:31:57[diff] [blame]1331 if (namelen < 4)
1332 return -1;
Junio C Hamanoae5a6c32009-01-17 16:09:53[diff] [blame]1333 if (name[0] != '@' || name[1] != '{' || name[2] != '-')
1334 return -1;
Jeff King8cd42492014-01-15 08:31:57[diff] [blame]1335 brace = memchr(name, '}', namelen);
Thomas Rasta884d0c2009-01-17 16:09:54[diff] [blame]1336 if (!brace)
1337 return -1;
Junio C Hamano98f85ff2013-03-08 21:27:37[diff] [blame]1338 nth = strtol(name + 3, &num_end, 10);
Thomas Rasta884d0c2009-01-17 16:09:54[diff] [blame]1339 if (num_end != brace)
Junio C Hamanoae5a6c32009-01-17 16:09:53[diff] [blame]1340 return -1;
Junio C Hamanoc2883e62009-01-19 08:04:25[diff] [blame]1341 if (nth <= 0)
1342 return -1;
Junio C Hamano98f85ff2013-03-08 21:27:37[diff] [blame]1343 cb.remaining = nth;
René Scharfe4b3aa172019-09-18 16:35:38[diff] [blame]1344 cb.sb = buf;
Junio C Hamano98f85ff2013-03-08 21:27:37[diff] [blame]1345
Nguyễn Thái Ngọc Duy23a57122019-04-16 09:33:26[diff] [blame]1346 retval = refs_for_each_reflog_ent_reverse(get_main_ref_store(r),
1347 "HEAD", grab_nth_branch_switch, &cb);
1348 if (0 < retval) {
Junio C Hamano98f85ff2013-03-08 21:27:37[diff] [blame]1349 retval = brace - name + 1;
Nguyễn Thái Ngọc Duy23a57122019-04-16 09:33:26[diff] [blame]1350 } else
1351 retval = 0;
Junio C Hamano39765e52009-01-20 05:58:31[diff] [blame]1352
Junio C Hamano39765e52009-01-20 05:58:31[diff] [blame]1353 return retval;
Junio C Hamanoae5a6c32009-01-17 16:09:53[diff] [blame]1354}
1355
Nguyễn Thái Ngọc Duy0daf7ff2019-04-16 09:33:41[diff] [blame]1356int repo_get_oid_mb(struct repository *r,
1357 const char *name,
1358 struct object_id *oid)
Junio C Hamano619a6442009-10-18 19:34:56[diff] [blame]1359{
1360 struct commit *one, *two;
1361 struct commit_list *mbs;
brian m. carlson151b2912016-09-05 20:08:07[diff] [blame]1362 struct object_id oid_tmp;
Junio C Hamano619a6442009-10-18 19:34:56[diff] [blame]1363 const char *dots;
1364 int st;
1365
1366 dots = strstr(name, "...");
1367 if (!dots)
Nguyễn Thái Ngọc Duy0daf7ff2019-04-16 09:33:41[diff] [blame]1368 return repo_get_oid(r, name, oid);
Junio C Hamano619a6442009-10-18 19:34:56[diff] [blame]1369 if (dots == name)
Nguyễn Thái Ngọc Duy0daf7ff2019-04-16 09:33:41[diff] [blame]1370 st = repo_get_oid(r, "HEAD", &oid_tmp);
Junio C Hamano619a6442009-10-18 19:34:56[diff] [blame]1371 else {
1372 struct strbuf sb;
1373 strbuf_init(&sb, dots - name);
1374 strbuf_add(&sb, name, dots - name);
Nguyễn Thái Ngọc Duy0daf7ff2019-04-16 09:33:41[diff] [blame]1375 st = repo_get_oid_committish(r, sb.buf, &oid_tmp);
Junio C Hamano619a6442009-10-18 19:34:56[diff] [blame]1376 strbuf_release(&sb);
1377 }
1378 if (st)
1379 return st;
Nguyễn Thái Ngọc Duy0daf7ff2019-04-16 09:33:41[diff] [blame]1380 one = lookup_commit_reference_gently(r, &oid_tmp, 0);
Junio C Hamano619a6442009-10-18 19:34:56[diff] [blame]1381 if (!one)
1382 return -1;
1383
Nguyễn Thái Ngọc Duy0daf7ff2019-04-16 09:33:41[diff] [blame]1384 if (repo_get_oid_committish(r, dots[3] ? (dots + 3) : "HEAD", &oid_tmp))
Junio C Hamano619a6442009-10-18 19:34:56[diff] [blame]1385 return -1;
Nguyễn Thái Ngọc Duy0daf7ff2019-04-16 09:33:41[diff] [blame]1386 two = lookup_commit_reference_gently(r, &oid_tmp, 0);
Junio C Hamano619a6442009-10-18 19:34:56[diff] [blame]1387 if (!two)
1388 return -1;
Nguyễn Thái Ngọc Duy34e77712019-06-27 09:28:52[diff] [blame]1389 mbs = repo_get_merge_bases(r, one, two);
Junio C Hamano619a6442009-10-18 19:34:56[diff] [blame]1390 if (!mbs || mbs->next)
1391 st = -1;
1392 else {
1393 st = 0;
brian m. carlson151b2912016-09-05 20:08:07[diff] [blame]1394 oidcpy(oid, &mbs->item->object.oid);
Junio C Hamano619a6442009-10-18 19:34:56[diff] [blame]1395 }
1396 free_commit_list(mbs);
1397 return st;
1398}
1399
Felipe Contreras9ba89f42013-09-02 06:34:30[diff] [blame]1400/* parse @something syntax, when 'something' is not {.*} */
1401static int interpret_empty_at(const char *name, int namelen, int len, struct strbuf *buf)
1402{
1403 const char *next;
1404
1405 if (len || name[1] == '{')
1406 return -1;
1407
1408 /* make sure it's a single @, or @@{.*}, not @foo */
Jeff King8cd42492014-01-15 08:31:57[diff] [blame]1409 next = memchr(name + len + 1, '@', namelen - len - 1);
Felipe Contreras9ba89f42013-09-02 06:34:30[diff] [blame]1410 if (next && next[1] != '{')
1411 return -1;
1412 if (!next)
1413 next = name + namelen;
1414 if (next != name + 1)
1415 return -1;
1416
1417 strbuf_reset(buf);
1418 strbuf_add(buf, "HEAD", 4);
1419 return 1;
1420}
1421
Nguyễn Thái Ngọc Duy71588ed2019-04-16 09:33:28[diff] [blame]1422static int reinterpret(struct repository *r,
1423 const char *name, int namelen, int len,
Jeff King0e9f62d2017-03-02 08:23:01[diff] [blame]1424 struct strbuf *buf, unsigned allowed)
Felipe Contreras7a0a49a2013-05-07 22:04:30[diff] [blame]1425{
1426 /* we have extra data, which might need further processing */
1427 struct strbuf tmp = STRBUF_INIT;
1428 int used = buf->len;
1429 int ret;
Jonathan Tana4f66a72020-09-01 22:28:07[diff] [blame]1430 struct interpret_branch_name_options options = {
1431 .allowed = allowed
1432 };
Felipe Contreras7a0a49a2013-05-07 22:04:30[diff] [blame]1433
1434 strbuf_add(buf, name + len, namelen - len);
Jonathan Tana4f66a72020-09-01 22:28:07[diff] [blame]1435 ret = repo_interpret_branch_name(r, buf->buf, buf->len, &tmp, &options);
Felipe Contreras7a0a49a2013-05-07 22:04:30[diff] [blame]1436 /* that data was not interpreted, remove our cruft */
1437 if (ret < 0) {
1438 strbuf_setlen(buf, used);
1439 return len;
1440 }
1441 strbuf_reset(buf);
1442 strbuf_addbuf(buf, &tmp);
1443 strbuf_release(&tmp);
1444 /* tweak for size of {-N} versus expanded ref name */
1445 return ret - used + len;
1446}
1447
Nguyễn Thái Ngọc Duyea1c8732019-04-16 09:33:27[diff] [blame]1448static void set_shortened_ref(struct repository *r, struct strbuf *buf, const char *ref)
Jeff Kinga39c14a2014-01-15 08:26:33[diff] [blame]1449{
Nguyễn Thái Ngọc Duyea1c8732019-04-16 09:33:27[diff] [blame]1450 char *s = refs_shorten_unambiguous_ref(get_main_ref_store(r), ref, 0);
Jeff Kinga39c14a2014-01-15 08:26:33[diff] [blame]1451 strbuf_reset(buf);
1452 strbuf_addstr(buf, s);
1453 free(s);
1454}
1455
Jeff King0e9f62d2017-03-02 08:23:01[diff] [blame]1456static int branch_interpret_allowed(const char *refname, unsigned allowed)
1457{
1458 if (!allowed)
1459 return 1;
1460
1461 if ((allowed & INTERPRET_BRANCH_LOCAL) &&
1462 starts_with(refname, "refs/heads/"))
1463 return 1;
1464 if ((allowed & INTERPRET_BRANCH_REMOTE) &&
1465 starts_with(refname, "refs/remotes/"))
1466 return 1;
1467
1468 return 0;
1469}
1470
Nguyễn Thái Ngọc Duyea1c8732019-04-16 09:33:27[diff] [blame]1471static int interpret_branch_mark(struct repository *r,
1472 const char *name, int namelen,
Jeff King48c58472015-05-21 04:45:43[diff] [blame]1473 int at, struct strbuf *buf,
1474 int (*get_mark)(const char *, int),
1475 const char *(*get_data)(struct branch *,
Jeff King0e9f62d2017-03-02 08:23:01[diff] [blame]1476 struct strbuf *),
Jonathan Tana4f66a72020-09-01 22:28:07[diff] [blame]1477 const struct interpret_branch_name_options *options)
Jeff Kinga39c14a2014-01-15 08:26:33[diff] [blame]1478{
1479 int len;
Jeff King48c58472015-05-21 04:45:43[diff] [blame]1480 struct branch *branch;
1481 struct strbuf err = STRBUF_INIT;
1482 const char *value;
Jeff Kinga39c14a2014-01-15 08:26:33[diff] [blame]1483
Jeff King48c58472015-05-21 04:45:43[diff] [blame]1484 len = get_mark(name + at, namelen - at);
Jeff Kinga39c14a2014-01-15 08:26:33[diff] [blame]1485 if (!len)
1486 return -1;
1487
Jeff King3f6eb302014-01-15 08:37:23[diff] [blame]1488 if (memchr(name, ':', at))
1489 return -1;
1490
Jeff King48c58472015-05-21 04:45:43[diff] [blame]1491 if (at) {
1492 char *name_str = xmemdupz(name, at);
1493 branch = branch_get(name_str);
1494 free(name_str);
1495 } else
1496 branch = branch_get(NULL);
1497
1498 value = get_data(branch, &err);
Jonathan Tanf24c30e2020-09-01 22:28:09[diff] [blame]1499 if (!value) {
1500 if (options->nonfatal_dangling_mark) {
1501 strbuf_release(&err);
1502 return -1;
1503 } else {
1504 die("%s", err.buf);
1505 }
1506 }
Jeff King48c58472015-05-21 04:45:43[diff] [blame]1507
Jonathan Tana4f66a72020-09-01 22:28:07[diff] [blame]1508 if (!branch_interpret_allowed(value, options->allowed))
Jeff King0e9f62d2017-03-02 08:23:01[diff] [blame]1509 return -1;
1510
Nguyễn Thái Ngọc Duyea1c8732019-04-16 09:33:27[diff] [blame]1511 set_shortened_ref(r, buf, value);
Jeff Kinga39c14a2014-01-15 08:26:33[diff] [blame]1512 return len + at;
1513}
1514
Nguyễn Thái Ngọc Duy8f56e9d2019-04-06 11:34:26[diff] [blame]1515int repo_interpret_branch_name(struct repository *r,
1516 const char *name, int namelen,
1517 struct strbuf *buf,
Jonathan Tana4f66a72020-09-01 22:28:07[diff] [blame]1518 const struct interpret_branch_name_options *options)
Junio C Hamanoae0ba8e2010-01-20 07:17:11[diff] [blame]1519{
Jeff Kingf278f402014-01-15 08:27:32[diff] [blame]1520 char *at;
Jeff King9892d5d2014-01-15 08:40:46[diff] [blame]1521 const char *start;
Jeff King13228c32017-02-27 09:25:40[diff] [blame]1522 int len;
Junio C Hamanoae0ba8e2010-01-20 07:17:11[diff] [blame]1523
Felipe Contrerascf99a762013-09-02 06:34:29[diff] [blame]1524 if (!namelen)
1525 namelen = strlen(name);
1526
Jonathan Tana4f66a72020-09-01 22:28:07[diff] [blame]1527 if (!options->allowed || (options->allowed & INTERPRET_BRANCH_LOCAL)) {
Nguyễn Thái Ngọc Duy71588ed2019-04-16 09:33:28[diff] [blame]1528 len = interpret_nth_prior_checkout(r, name, namelen, buf);
Jeff King0e9f62d2017-03-02 08:23:01[diff] [blame]1529 if (!len) {
1530 return len; /* syntax Ok, not enough switches */
1531 } else if (len > 0) {
1532 if (len == namelen)
1533 return len; /* consumed all */
1534 else
Jonathan Tana4f66a72020-09-01 22:28:07[diff] [blame]1535 return reinterpret(r, name, namelen, len, buf,
1536 options->allowed);
Jeff King0e9f62d2017-03-02 08:23:01[diff] [blame]1537 }
Jeff Kingd46a8302010-01-28 09:52:22[diff] [blame]1538 }
1539
Jeff King9892d5d2014-01-15 08:40:46[diff] [blame]1540 for (start = name;
1541 (at = memchr(start, '@', namelen - (start - name)));
1542 start = at + 1) {
Felipe Contreras9ba89f42013-09-02 06:34:30[diff] [blame]1543
Jonathan Tana4f66a72020-09-01 22:28:07[diff] [blame]1544 if (!options->allowed || (options->allowed & INTERPRET_BRANCH_HEAD)) {
Jeff King0e9f62d2017-03-02 08:23:01[diff] [blame]1545 len = interpret_empty_at(name, namelen, at - name, buf);
1546 if (len > 0)
Nguyễn Thái Ngọc Duy71588ed2019-04-16 09:33:28[diff] [blame]1547 return reinterpret(r, name, namelen, len, buf,
Jonathan Tana4f66a72020-09-01 22:28:07[diff] [blame]1548 options->allowed);
Jeff King0e9f62d2017-03-02 08:23:01[diff] [blame]1549 }
Felipe Contreras9ba89f42013-09-02 06:34:30[diff] [blame]1550
Nguyễn Thái Ngọc Duy71588ed2019-04-16 09:33:28[diff] [blame]1551 len = interpret_branch_mark(r, name, namelen, at - name, buf,
Jeff King0e9f62d2017-03-02 08:23:01[diff] [blame]1552 upstream_mark, branch_get_upstream,
Jonathan Tana4f66a72020-09-01 22:28:07[diff] [blame]1553 options);
Jeff King9892d5d2014-01-15 08:40:46[diff] [blame]1554 if (len > 0)
1555 return len;
Jeff Kingadfe5d02015-05-21 04:45:47[diff] [blame]1556
Nguyễn Thái Ngọc Duy71588ed2019-04-16 09:33:28[diff] [blame]1557 len = interpret_branch_mark(r, name, namelen, at - name, buf,
Jeff King0e9f62d2017-03-02 08:23:01[diff] [blame]1558 push_mark, branch_get_push,
Jonathan Tana4f66a72020-09-01 22:28:07[diff] [blame]1559 options);
Jeff King9892d5d2014-01-15 08:40:46[diff] [blame]1560 if (len > 0)
1561 return len;
Zbigniew Jędrzejewski-Szmekbb0dab52012-04-14 07:54:33[diff] [blame]1562 }
Felipe Contreras9ba89f42013-09-02 06:34:30[diff] [blame]1563
Jeff Kinga39c14a2014-01-15 08:26:33[diff] [blame]1564 return -1;
Junio C Hamanoae0ba8e2010-01-20 07:17:11[diff] [blame]1565}
1566
Jeff King0e9f62d2017-03-02 08:23:01[diff] [blame]1567void strbuf_branchname(struct strbuf *sb, const char *name, unsigned allowed)
Jonathan Nieder6bab74e2010-11-06 11:46:52[diff] [blame]1568{
1569 int len = strlen(name);
Jonathan Tana4f66a72020-09-01 22:28:07[diff] [blame]1570 struct interpret_branch_name_options options = {
1571 .allowed = allowed
1572 };
1573 int used = interpret_branch_name(name, len, sb, &options);
Junio C Hamano84cf2462013-05-15 21:32:30[diff] [blame]1574
Junio C Hamano84cf2462013-05-15 21:32:30[diff] [blame]1575 if (used < 0)
1576 used = 0;
1577 strbuf_add(sb, name + used, len - used);
Jonathan Nieder6bab74e2010-11-06 11:46:52[diff] [blame]1578}
1579
1580int strbuf_check_branch_ref(struct strbuf *sb, const char *name)
1581{
Junio C Hamano7c3f8472017-10-17 07:08:08[diff] [blame]1582 if (startup_info->have_repository)
1583 strbuf_branchname(sb, name, INTERPRET_BRANCH_LOCAL);
1584 else
1585 strbuf_addstr(sb, name);
Junio C Hamanoa625b092017-11-14 11:42:58[diff] [blame]1586
1587 /*
1588 * This splice must be done even if we end up rejecting the
1589 * name; builtin/branch.c::copy_or_rename_branch() still wants
1590 * to see what the name expanded to so that "branch -m" can be
1591 * used as a tool to correct earlier mistakes.
1592 */
Jonathan Nieder6bab74e2010-11-06 11:46:52[diff] [blame]1593 strbuf_splice(sb, 0, 0, "refs/heads/", 11);
Junio C Hamanoa625b092017-11-14 11:42:58[diff] [blame]1594
1595 if (*name == '-' ||
1596 !strcmp(sb->buf, "refs/heads/HEAD"))
1597 return -1;
1598
Michael Haggerty8d9c5012011-09-15 21:10:25[diff] [blame]1599 return check_refname_format(sb->buf, 0);
Jonathan Nieder6bab74e2010-11-06 11:46:52[diff] [blame]1600}
1601
Junio C Hamanoae0ba8e2010-01-20 07:17:11[diff] [blame]1602/*
brian m. carlsone82caf32017-07-13 23:49:28[diff] [blame]1603 * This is like "get_oid_basic()", except it allows "object ID expressions",
Junio C Hamano9938af62005-08-04 05:15:49[diff] [blame]1604 * notably "xyz^" for "parent of xyz"
1605 */
Nguyễn Thái Ngọc Duyec580ea2019-04-16 09:33:37[diff] [blame]1606int repo_get_oid(struct repository *r, const char *name, struct object_id *oid)
brian m. carlson2764fd92016-04-17 23:10:36[diff] [blame]1607{
brian m. carlsone82caf32017-07-13 23:49:28[diff] [blame]1608 struct object_context unused;
Nguyễn Thái Ngọc Duyec580ea2019-04-16 09:33:37[diff] [blame]1609 return get_oid_with_context(r, name, 0, oid, &unused);
brian m. carlson2764fd92016-04-17 23:10:36[diff] [blame]1610}
1611
Paul-Sebastian Ungureanuf5116f42019-02-25 23:16:05[diff] [blame]1612/*
1613 * This returns a non-zero value if the string (built using printf
1614 * format and the given arguments) is not a valid object.
1615 */
1616int get_oidf(struct object_id *oid, const char *fmt, ...)
1617{
1618 va_list ap;
1619 int ret;
1620 struct strbuf sb = STRBUF_INIT;
1621
1622 va_start(ap, fmt);
1623 strbuf_vaddf(&sb, fmt, ap);
1624 va_end(ap);
1625
1626 ret = get_oid(sb.buf, oid);
1627 strbuf_release(&sb);
1628
1629 return ret;
1630}
brian m. carlson2764fd92016-04-17 23:10:36[diff] [blame]1631
1632/*
Richard Hansena8a54062013-09-04 19:04:31[diff] [blame]1633 * Many callers know that the user meant to name a commit-ish by
Junio C Hamanocd74e472012-07-02 19:04:52[diff] [blame]1634 * syntactical positions where the object name appears. Calling this
1635 * function allows the machinery to disambiguate shorter-than-unique
Richard Hansena8a54062013-09-04 19:04:31[diff] [blame]1636 * abbreviated object names between commit-ish and others.
Junio C Hamanocd74e472012-07-02 19:04:52[diff] [blame]1637 *
1638 * Note that this does NOT error out when the named object is not a
Richard Hansena8a54062013-09-04 19:04:31[diff] [blame]1639 * commit-ish. It is merely to give a hint to the disambiguation
Junio C Hamanocd74e472012-07-02 19:04:52[diff] [blame]1640 * machinery.
1641 */
Nguyễn Thái Ngọc Duy65e50462019-04-16 09:33:40[diff] [blame]1642int repo_get_oid_committish(struct repository *r,
1643 const char *name,
1644 struct object_id *oid)
Junio C Hamanocd74e472012-07-02 19:04:52[diff] [blame]1645{
1646 struct object_context unused;
Nguyễn Thái Ngọc Duy65e50462019-04-16 09:33:40[diff] [blame]1647 return get_oid_with_context(r, name, GET_OID_COMMITTISH,
brian m. carlsone82caf32017-07-13 23:49:28[diff] [blame]1648 oid, &unused);
Junio C Hamanocd74e472012-07-02 19:04:52[diff] [blame]1649}
1650
Nguyễn Thái Ngọc Duy65e50462019-04-16 09:33:40[diff] [blame]1651int repo_get_oid_treeish(struct repository *r,
1652 const char *name,
1653 struct object_id *oid)
Junio C Hamanodaba53a2012-07-03 06:35:05[diff] [blame]1654{
1655 struct object_context unused;
Nguyễn Thái Ngọc Duy65e50462019-04-16 09:33:40[diff] [blame]1656 return get_oid_with_context(r, name, GET_OID_TREEISH,
brian m. carlsone82caf32017-07-13 23:49:28[diff] [blame]1657 oid, &unused);
Junio C Hamanodaba53a2012-07-03 06:35:05[diff] [blame]1658}
1659
Nguyễn Thái Ngọc Duy65e50462019-04-16 09:33:40[diff] [blame]1660int repo_get_oid_commit(struct repository *r,
1661 const char *name,
1662 struct object_id *oid)
Junio C Hamanodaba53a2012-07-03 06:35:05[diff] [blame]1663{
1664 struct object_context unused;
Nguyễn Thái Ngọc Duy65e50462019-04-16 09:33:40[diff] [blame]1665 return get_oid_with_context(r, name, GET_OID_COMMIT,
brian m. carlsone82caf32017-07-13 23:49:28[diff] [blame]1666 oid, &unused);
Junio C Hamanodaba53a2012-07-03 06:35:05[diff] [blame]1667}
1668
Nguyễn Thái Ngọc Duy65e50462019-04-16 09:33:40[diff] [blame]1669int repo_get_oid_tree(struct repository *r,
1670 const char *name,
1671 struct object_id *oid)
Junio C Hamanodaba53a2012-07-03 06:35:05[diff] [blame]1672{
1673 struct object_context unused;
Nguyễn Thái Ngọc Duy65e50462019-04-16 09:33:40[diff] [blame]1674 return get_oid_with_context(r, name, GET_OID_TREE,
brian m. carlsone82caf32017-07-13 23:49:28[diff] [blame]1675 oid, &unused);
Junio C Hamanodaba53a2012-07-03 06:35:05[diff] [blame]1676}
1677
Nguyễn Thái Ngọc Duy65e50462019-04-16 09:33:40[diff] [blame]1678int repo_get_oid_blob(struct repository *r,
1679 const char *name,
1680 struct object_id *oid)
Junio C Hamanodaba53a2012-07-03 06:35:05[diff] [blame]1681{
1682 struct object_context unused;
Nguyễn Thái Ngọc Duy65e50462019-04-16 09:33:40[diff] [blame]1683 return get_oid_with_context(r, name, GET_OID_BLOB,
brian m. carlsone82caf32017-07-13 23:49:28[diff] [blame]1684 oid, &unused);
Martin Koeglera0cd87a2007-04-23 20:55:05[diff] [blame]1685}
1686
Matthieu Moy009fee42009-12-07 10:10:50[diff] [blame]1687/* Must be called only when object_name:filename doesn't exist. */
Nguyễn Thái Ngọc Duy50ddb082019-06-27 09:28:49[diff] [blame]1688static void diagnose_invalid_oid_path(struct repository *r,
1689 const char *prefix,
brian m. carlsone82caf32017-07-13 23:49:28[diff] [blame]1690 const char *filename,
1691 const struct object_id *tree_oid,
1692 const char *object_name,
1693 int object_name_len)
Matthieu Moy009fee42009-12-07 10:10:50[diff] [blame]1694{
brian m. carlsone82caf32017-07-13 23:49:28[diff] [blame]1695 struct object_id oid;
Elijah Newren5ec1e722019-04-05 15:00:12[diff] [blame]1696 unsigned short mode;
Matthieu Moy009fee42009-12-07 10:10:50[diff] [blame]1697
1698 if (!prefix)
1699 prefix = "";
1700
René Scharfedbe44fa2015-05-19 21:44:23[diff] [blame]1701 if (file_exists(filename))
Jeff Kingb0418302020-01-25 00:13:01[diff] [blame]1702 die(_("path '%s' exists on disk, but not in '%.*s'"),
René Scharfeb2981d02013-03-16 18:29:31[diff] [blame]1703 filename, object_name_len, object_name);
Junio C Hamanoc7054202017-05-30 00:23:33[diff] [blame]1704 if (is_missing_file_error(errno)) {
Jeff Kingb2724c82014-06-19 21:26:56[diff] [blame]1705 char *fullname = xstrfmt("%s%s", prefix, filename);
Matthieu Moy009fee42009-12-07 10:10:50[diff] [blame]1706
Nguyễn Thái Ngọc Duy50ddb082019-06-27 09:28:49[diff] [blame]1707 if (!get_tree_entry(r, tree_oid, fullname, &oid, &mode)) {
Jeff Kingb0418302020-01-25 00:13:01[diff] [blame]1708 die(_("path '%s' exists, but not '%s'\n"
1709 "hint: Did you mean '%.*s:%s' aka '%.*s:./%s'?"),
Matthieu Moy009fee42009-12-07 10:10:50[diff] [blame]1710 fullname,
1711 filename,
René Scharfeb2981d02013-03-16 18:29:31[diff] [blame]1712 object_name_len, object_name,
Michael J Grubere41d7182011-03-31 09:17:34[diff] [blame]1713 fullname,
René Scharfeb2981d02013-03-16 18:29:31[diff] [blame]1714 object_name_len, object_name,
Michael J Grubere41d7182011-03-31 09:17:34[diff] [blame]1715 filename);
Matthieu Moy009fee42009-12-07 10:10:50[diff] [blame]1716 }
Jeff Kingb0418302020-01-25 00:13:01[diff] [blame]1717 die(_("path '%s' does not exist in '%.*s'"),
René Scharfeb2981d02013-03-16 18:29:31[diff] [blame]1718 filename, object_name_len, object_name);
Matthieu Moy009fee42009-12-07 10:10:50[diff] [blame]1719 }
1720}
1721
1722/* Must be called only when :stage:filename doesn't exist. */
Nguyễn Thái Ngọc Duy04884812019-04-16 09:33:34[diff] [blame]1723static void diagnose_invalid_index_path(struct repository *r,
Nguyễn Thái Ngọc Duy3a7a6982019-01-12 02:13:28[diff] [blame]1724 int stage,
Matthieu Moy009fee42009-12-07 10:10:50[diff] [blame]1725 const char *prefix,
1726 const char *filename)
1727{
Nguyễn Thái Ngọc Duy04884812019-04-16 09:33:34[diff] [blame]1728 struct index_state *istate = r->index;
Nguyễn Thái Ngọc Duy9c5e6c82013-07-09 15:29:00[diff] [blame]1729 const struct cache_entry *ce;
Matthieu Moy009fee42009-12-07 10:10:50[diff] [blame]1730 int pos;
1731 unsigned namelen = strlen(filename);
Jeff King43bb66a2015-09-24 21:07:52[diff] [blame]1732 struct strbuf fullname = STRBUF_INIT;
Matthieu Moy009fee42009-12-07 10:10:50[diff] [blame]1733
1734 if (!prefix)
1735 prefix = "";
1736
1737 /* Wrong stage number? */
Nguyễn Thái Ngọc Duy3a7a6982019-01-12 02:13:28[diff] [blame]1738 pos = index_name_pos(istate, filename, namelen);
Matthieu Moy009fee42009-12-07 10:10:50[diff] [blame]1739 if (pos < 0)
1740 pos = -pos - 1;
Nguyễn Thái Ngọc Duy3a7a6982019-01-12 02:13:28[diff] [blame]1741 if (pos < istate->cache_nr) {
1742 ce = istate->cache[pos];
Markus Heidelberg77e84662010-02-28 15:49:15[diff] [blame]1743 if (ce_namelen(ce) == namelen &&
1744 !memcmp(ce->name, filename, namelen))
Jeff Kingb0418302020-01-25 00:13:01[diff] [blame]1745 die(_("path '%s' is in the index, but not at stage %d\n"
1746 "hint: Did you mean ':%d:%s'?"),
Markus Heidelberg77e84662010-02-28 15:49:15[diff] [blame]1747 filename, stage,
1748 ce_stage(ce), filename);
1749 }
Matthieu Moy009fee42009-12-07 10:10:50[diff] [blame]1750
1751 /* Confusion between relative and absolute filenames? */
Jeff King43bb66a2015-09-24 21:07:52[diff] [blame]1752 strbuf_addstr(&fullname, prefix);
1753 strbuf_addstr(&fullname, filename);
Nguyễn Thái Ngọc Duy3a7a6982019-01-12 02:13:28[diff] [blame]1754 pos = index_name_pos(istate, fullname.buf, fullname.len);
Matthieu Moy009fee42009-12-07 10:10:50[diff] [blame]1755 if (pos < 0)
1756 pos = -pos - 1;
Nguyễn Thái Ngọc Duy3a7a6982019-01-12 02:13:28[diff] [blame]1757 if (pos < istate->cache_nr) {
1758 ce = istate->cache[pos];
Jeff King43bb66a2015-09-24 21:07:52[diff] [blame]1759 if (ce_namelen(ce) == fullname.len &&
1760 !memcmp(ce->name, fullname.buf, fullname.len))
Jeff Kingb0418302020-01-25 00:13:01[diff] [blame]1761 die(_("path '%s' is in the index, but not '%s'\n"
1762 "hint: Did you mean ':%d:%s' aka ':%d:./%s'?"),
Jeff King43bb66a2015-09-24 21:07:52[diff] [blame]1763 fullname.buf, filename,
1764 ce_stage(ce), fullname.buf,
Michael J Grubere41d7182011-03-31 09:17:34[diff] [blame]1765 ce_stage(ce), filename);
Markus Heidelberg77e84662010-02-28 15:49:15[diff] [blame]1766 }
Matthieu Moy009fee42009-12-07 10:10:50[diff] [blame]1767
Nguyễn Thái Ngọc Duy04884812019-04-16 09:33:34[diff] [blame]1768 if (repo_file_exists(r, filename))
Jeff Kingb0418302020-01-25 00:13:01[diff] [blame]1769 die(_("path '%s' exists on disk, but not in the index"), filename);
Junio C Hamanoc7054202017-05-30 00:23:33[diff] [blame]1770 if (is_missing_file_error(errno))
Jeff Kingb0418302020-01-25 00:13:01[diff] [blame]1771 die(_("path '%s' does not exist (neither on disk nor in the index)"),
Matthieu Moy009fee42009-12-07 10:10:50[diff] [blame]1772 filename);
1773
Jeff King43bb66a2015-09-24 21:07:52[diff] [blame]1774 strbuf_release(&fullname);
Matthieu Moy009fee42009-12-07 10:10:50[diff] [blame]1775}
1776
1777
Nguyễn Thái Ngọc Duy0381f7f2019-04-16 09:33:35[diff] [blame]1778static char *resolve_relative_path(struct repository *r, const char *rel)
Nguyễn Thái Ngọc Duy979f79292010-11-28 03:37:32[diff] [blame]1779{
Christian Couder59556542013-11-30 20:55:40[diff] [blame]1780 if (!starts_with(rel, "./") && !starts_with(rel, "../"))
Nguyễn Thái Ngọc Duy979f79292010-11-28 03:37:32[diff] [blame]1781 return NULL;
1782
Nguyễn Thái Ngọc Duy0381f7f2019-04-16 09:33:35[diff] [blame]1783 if (r != the_repository || !is_inside_work_tree())
Jeff Kingb0418302020-01-25 00:13:01[diff] [blame]1784 die(_("relative path syntax can't be used outside working tree"));
Nguyễn Thái Ngọc Duy979f79292010-11-28 03:37:32[diff] [blame]1785
1786 /* die() inside prefix_path() if resolved path is outside worktree */
1787 return prefix_path(startup_info->prefix,
1788 startup_info->prefix ? strlen(startup_info->prefix) : 0,
1789 rel);
1790}
1791
Junio C Hamano7589e632019-02-07 06:05:22[diff] [blame]1792static enum get_oid_result get_oid_with_context_1(struct repository *repo,
Nguyễn Thái Ngọc Duy3a7a6982019-01-12 02:13:28[diff] [blame]1793 const char *name,
brian m. carlsone82caf32017-07-13 23:49:28[diff] [blame]1794 unsigned flags,
1795 const char *prefix,
1796 struct object_id *oid,
1797 struct object_context *oc)
Clément Poulain573285e2010-06-09 17:02:06[diff] [blame]1798{
Martin Koeglera0cd87a2007-04-23 20:55:05[diff] [blame]1799 int ret, bracket_depth;
Junio C Hamano73b0e5a2006-04-22 00:31:04[diff] [blame]1800 int namelen = strlen(name);
1801 const char *cp;
brian m. carlson321c89b2017-07-13 23:49:29[diff] [blame]1802 int only_to_die = flags & GET_OID_ONLY_TO_DIE;
Linus Torvalds51196022006-04-18 23:45:16[diff] [blame]1803
Jeff King7243ffd2016-09-26 11:59:15[diff] [blame]1804 if (only_to_die)
brian m. carlson321c89b2017-07-13 23:49:29[diff] [blame]1805 flags |= GET_OID_QUIETLY;
Jeff King7243ffd2016-09-26 11:59:15[diff] [blame]1806
Clément Poulain573285e2010-06-09 17:02:06[diff] [blame]1807 memset(oc, 0, sizeof(*oc));
1808 oc->mode = S_IFINVALID;
Jeff Kingd72cae12017-05-19 12:52:25[diff] [blame]1809 strbuf_init(&oc->symlink_path, 0);
Nguyễn Thái Ngọc Duy2b1790f2019-04-16 09:33:32[diff] [blame]1810 ret = get_oid_1(repo, name, namelen, oid, flags);
Junio C Hamano73b0e5a2006-04-22 00:31:04[diff] [blame]1811 if (!ret)
1812 return ret;
Junio C Hamano33bd5982012-07-02 17:32:11[diff] [blame]1813 /*
1814 * sha1:path --> object name of path in ent sha1
Nguyễn Thái Ngọc Duy979f79292010-11-28 03:37:32[diff] [blame]1815 * :path -> object name of absolute path in index
1816 * :./path -> object name of path relative to cwd in index
Junio C Hamano73b0e5a2006-04-22 00:31:04[diff] [blame]1817 * :[0-3]:path -> object name of path in index at stage
Matthieu Moy95ad6d22010-09-24 16:43:59[diff] [blame]1818 * :/foo -> recent commit matching foo
Junio C Hamano73b0e5a2006-04-22 00:31:04[diff] [blame]1819 */
1820 if (name[0] == ':') {
1821 int stage = 0;
Nguyễn Thái Ngọc Duy9c5e6c82013-07-09 15:29:00[diff] [blame]1822 const struct cache_entry *ce;
Nguyễn Thái Ngọc Duy979f79292010-11-28 03:37:32[diff] [blame]1823 char *new_path = NULL;
Junio C Hamano73b0e5a2006-04-22 00:31:04[diff] [blame]1824 int pos;
Junio C Hamano2e83b662011-05-10 19:02:54[diff] [blame]1825 if (!only_to_die && namelen > 2 && name[1] == '/') {
Nguyễn Thái Ngọc Duyc931ba42019-04-16 09:33:33[diff] [blame]1826 struct handle_one_ref_cb cb;
Nguyễn Thái Ngọc Duy84baa312010-12-13 03:01:14[diff] [blame]1827 struct commit_list *list = NULL;
Michael Haggerty2b2a5be2015-05-25 18:38:28[diff] [blame]1828
Nguyễn Thái Ngọc Duyc931ba42019-04-16 09:33:33[diff] [blame]1829 cb.repo = repo;
1830 cb.list = &list;
Junio C Hamano5ff4b922020-04-10 00:03:45[diff] [blame]1831 refs_for_each_ref(get_main_ref_store(repo), handle_one_ref, &cb);
Jeff King02204612020-04-10 03:04:11[diff] [blame]1832 refs_head_ref(get_main_ref_store(repo), handle_one_ref, &cb);
René Scharfee8d1dfe2014-08-21 18:30:29[diff] [blame]1833 commit_list_sort_by_date(&list);
Nguyễn Thái Ngọc Duy0bb41a12019-04-16 09:33:29[diff] [blame]1834 return get_oid_oneline(repo, name + 2, oid, list);
Nguyễn Thái Ngọc Duy84baa312010-12-13 03:01:14[diff] [blame]1835 }
Junio C Hamano73b0e5a2006-04-22 00:31:04[diff] [blame]1836 if (namelen < 3 ||
1837 name[2] != ':' ||
1838 name[1] < '0' || '3' < name[1])
1839 cp = name + 1;
1840 else {
1841 stage = name[1] - '0';
1842 cp = name + 3;
Linus Torvalds51196022006-04-18 23:45:16[diff] [blame]1843 }
Nguyễn Thái Ngọc Duy0381f7f2019-04-16 09:33:35[diff] [blame]1844 new_path = resolve_relative_path(repo, cp);
Junio C Hamano3d6e0f72010-12-09 21:38:05[diff] [blame]1845 if (!new_path) {
1846 namelen = namelen - (cp - name);
1847 } else {
1848 cp = new_path;
1849 namelen = strlen(cp);
1850 }
Clément Poulain573285e2010-06-09 17:02:06[diff] [blame]1851
brian m. carlson321c89b2017-07-13 23:49:29[diff] [blame]1852 if (flags & GET_OID_RECORD_PATH)
Jeff Kingdc944b62017-05-19 12:54:43[diff] [blame]1853 oc->path = xstrdup(cp);
Clément Poulain573285e2010-06-09 17:02:06[diff] [blame]1854
Jeff King581d2fd2019-05-14 13:54:55[diff] [blame]1855 if (!repo->index || !repo->index->cache)
Nguyễn Thái Ngọc Duyefe461b2019-04-16 09:33:36[diff] [blame]1856 repo_read_index(repo);
Nguyễn Thái Ngọc Duy3a7a6982019-01-12 02:13:28[diff] [blame]1857 pos = index_name_pos(repo->index, cp, namelen);
Junio C Hamano73b0e5a2006-04-22 00:31:04[diff] [blame]1858 if (pos < 0)
1859 pos = -pos - 1;
Nguyễn Thái Ngọc Duy3a7a6982019-01-12 02:13:28[diff] [blame]1860 while (pos < repo->index->cache_nr) {
1861 ce = repo->index->cache[pos];
Junio C Hamano73b0e5a2006-04-22 00:31:04[diff] [blame]1862 if (ce_namelen(ce) != namelen ||
1863 memcmp(ce->name, cp, namelen))
1864 break;
1865 if (ce_stage(ce) == stage) {
brian m. carlsone82caf32017-07-13 23:49:28[diff] [blame]1866 oidcpy(oid, &ce->oid);
Kirill Smelkov90064712010-09-29 11:35:24[diff] [blame]1867 oc->mode = ce->ce_mode;
Nguyễn Thái Ngọc Duy979f79292010-11-28 03:37:32[diff] [blame]1868 free(new_path);
Junio C Hamano73b0e5a2006-04-22 00:31:04[diff] [blame]1869 return 0;
1870 }
Junio C Hamanoe7cef452006-05-08 22:44:06[diff] [blame]1871 pos++;
Junio C Hamano73b0e5a2006-04-22 00:31:04[diff] [blame]1872 }
Junio C Hamano2e83b662011-05-10 19:02:54[diff] [blame]1873 if (only_to_die && name[1] && name[1] != '/')
Nguyễn Thái Ngọc Duy04884812019-04-16 09:33:34[diff] [blame]1874 diagnose_invalid_index_path(repo, stage, prefix, cp);
Nguyễn Thái Ngọc Duy979f79292010-11-28 03:37:32[diff] [blame]1875 free(new_path);
Junio C Hamano73b0e5a2006-04-22 00:31:04[diff] [blame]1876 return -1;
1877 }
Shawn Pearcecce91a22006-05-19 07:29:43[diff] [blame]1878 for (cp = name, bracket_depth = 0; *cp; cp++) {
1879 if (*cp == '{')
1880 bracket_depth++;
1881 else if (bracket_depth && *cp == '}')
1882 bracket_depth--;
1883 else if (!bracket_depth && *cp == ':')
1884 break;
1885 }
1886 if (*cp == ':') {
brian m. carlsone82caf32017-07-13 23:49:28[diff] [blame]1887 struct object_id tree_oid;
René Scharfeb2981d02013-03-16 18:29:31[diff] [blame]1888 int len = cp - name;
Jeff King8a10fea2016-09-26 11:59:41[diff] [blame]1889 unsigned sub_flags = flags;
1890
brian m. carlson321c89b2017-07-13 23:49:29[diff] [blame]1891 sub_flags &= ~GET_OID_DISAMBIGUATORS;
1892 sub_flags |= GET_OID_TREEISH;
Jeff King8a10fea2016-09-26 11:59:41[diff] [blame]1893
Nguyễn Thái Ngọc Duy2b1790f2019-04-16 09:33:32[diff] [blame]1894 if (!get_oid_1(repo, name, len, &tree_oid, sub_flags)) {
Matthieu Moy009fee42009-12-07 10:10:50[diff] [blame]1895 const char *filename = cp+1;
Nguyễn Thái Ngọc Duy979f79292010-11-28 03:37:32[diff] [blame]1896 char *new_filename = NULL;
1897
Nguyễn Thái Ngọc Duy0381f7f2019-04-16 09:33:35[diff] [blame]1898 new_filename = resolve_relative_path(repo, filename);
Nguyễn Thái Ngọc Duy979f79292010-11-28 03:37:32[diff] [blame]1899 if (new_filename)
1900 filename = new_filename;
brian m. carlson321c89b2017-07-13 23:49:29[diff] [blame]1901 if (flags & GET_OID_FOLLOW_SYMLINKS) {
Nguyễn Thái Ngọc Duy0dd1f0c2019-06-27 09:28:50[diff] [blame]1902 ret = get_tree_entry_follow_symlinks(repo, &tree_oid,
brian m. carlson3b683bc2018-05-02 00:25:40[diff] [blame]1903 filename, oid, &oc->symlink_path,
David Turnerc4ec9672015-05-20 17:03:39[diff] [blame]1904 &oc->mode);
1905 } else {
Nguyễn Thái Ngọc Duy50ddb082019-06-27 09:28:49[diff] [blame]1906 ret = get_tree_entry(repo, &tree_oid, filename, oid,
brian m. carlson916bc352018-03-12 02:27:51[diff] [blame]1907 &oc->mode);
David Turnerc4ec9672015-05-20 17:03:39[diff] [blame]1908 if (ret && only_to_die) {
Nguyễn Thái Ngọc Duy50ddb082019-06-27 09:28:49[diff] [blame]1909 diagnose_invalid_oid_path(repo, prefix,
David Turnerc4ec9672015-05-20 17:03:39[diff] [blame]1910 filename,
brian m. carlsone82caf32017-07-13 23:49:28[diff] [blame]1911 &tree_oid,
David Turnerc4ec9672015-05-20 17:03:39[diff] [blame]1912 name, len);
1913 }
Matthieu Moy009fee42009-12-07 10:10:50[diff] [blame]1914 }
brian m. carlson321c89b2017-07-13 23:49:29[diff] [blame]1915 if (flags & GET_OID_RECORD_PATH)
Jeff Kingdc944b62017-05-19 12:54:43[diff] [blame]1916 oc->path = xstrdup(filename);
Clément Poulain573285e2010-06-09 17:02:06[diff] [blame]1917
Nguyễn Thái Ngọc Duy979f79292010-11-28 03:37:32[diff] [blame]1918 free(new_filename);
Matthieu Moy009fee42009-12-07 10:10:50[diff] [blame]1919 return ret;
1920 } else {
Junio C Hamano2e83b662011-05-10 19:02:54[diff] [blame]1921 if (only_to_die)
Jeff Kingb0418302020-01-25 00:13:01[diff] [blame]1922 die(_("invalid object name '%.*s'."), len, name);
Matthieu Moy009fee42009-12-07 10:10:50[diff] [blame]1923 }
Linus Torvalds51196022006-04-18 23:45:16[diff] [blame]1924 }
1925 return ret;
Junio C Hamano9938af62005-08-04 05:15:49[diff] [blame]1926}
Junio C Hamanof01cc142012-07-02 17:19:35[diff] [blame]1927
Junio C Hamano8c135ea2012-07-02 18:01:25[diff] [blame]1928/*
1929 * Call this function when you know "name" given by the end user must
1930 * name an object but it doesn't; the function _may_ die with a better
1931 * diagnostic message than "no such object 'name'", e.g. "Path 'doc' does not
1932 * exist in 'HEAD'" when given "HEAD:doc", or it may return in which case
1933 * you have a chance to diagnose the error further.
1934 */
Nguyễn Thái Ngọc Duye270f422019-04-16 09:33:39[diff] [blame]1935void maybe_die_on_misspelt_object_name(struct repository *r,
1936 const char *name,
1937 const char *prefix)
Junio C Hamanof01cc142012-07-02 17:19:35[diff] [blame]1938{
1939 struct object_context oc;
brian m. carlsone82caf32017-07-13 23:49:28[diff] [blame]1940 struct object_id oid;
Nguyễn Thái Ngọc Duye270f422019-04-16 09:33:39[diff] [blame]1941 get_oid_with_context_1(r, name, GET_OID_ONLY_TO_DIE,
Nguyễn Thái Ngọc Duy3a7a6982019-01-12 02:13:28[diff] [blame]1942 prefix, &oid, &oc);
Junio C Hamano8c135ea2012-07-02 18:01:25[diff] [blame]1943}
1944
Duy Nguyen127b48f2019-02-12 12:43:23[diff] [blame]1945enum get_oid_result get_oid_with_context(struct repository *repo,
1946 const char *str,
1947 unsigned flags,
1948 struct object_id *oid,
1949 struct object_context *oc)
Junio C Hamanof01cc142012-07-02 17:19:35[diff] [blame]1950{
brian m. carlson321c89b2017-07-13 23:49:29[diff] [blame]1951 if (flags & GET_OID_FOLLOW_SYMLINKS && flags & GET_OID_ONLY_TO_DIE)
Johannes Schindelin033abf92018-05-02 09:38:39[diff] [blame]1952 BUG("incompatible flags for get_sha1_with_context");
Nguyễn Thái Ngọc Duy3a7a6982019-01-12 02:13:28[diff] [blame]1953 return get_oid_with_context_1(repo, str, flags, NULL, oid, oc);
Junio C Hamanof01cc142012-07-02 17:19:35[diff] [blame]1954}