sha1_name.c 35.6 KB
Newer Older
1
#include "cache.h"
2
#include "tag.h"
3
#include "commit.h"
4 5
#include "tree.h"
#include "blob.h"
6
#include "tree-walk.h"
7
#include "refs.h"
8
#include "remote.h"
9

10 11
static int get_sha1_oneline(const char *, unsigned char *, struct commit_list *);

12 13 14 15 16 17 18 19 20 21 22
typedef int (*disambiguate_hint_fn)(const unsigned char *, void *);

struct disambiguate_state {
	disambiguate_hint_fn fn;
	void *cb_data;
	unsigned char candidate[20];
	unsigned candidate_exists:1;
	unsigned candidate_checked:1;
	unsigned candidate_ok:1;
	unsigned disambiguate_fn_used:1;
	unsigned ambiguous:1;
23
	unsigned always_call_fn:1;
24 25 26 27
};

static void update_candidates(struct disambiguate_state *ds, const unsigned char *current)
{
28 29 30 31
	if (ds->always_call_fn) {
		ds->ambiguous = ds->fn(current, ds->cb_data) ? 1 : 0;
		return;
	}
32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54
	if (!ds->candidate_exists) {
		/* this is the first candidate */
		hashcpy(ds->candidate, current);
		ds->candidate_exists = 1;
		return;
	} else if (!hashcmp(ds->candidate, current)) {
		/* the same as what we already have seen */
		return;
	}

	if (!ds->fn) {
		/* cannot disambiguate between ds->candidate and current */
		ds->ambiguous = 1;
		return;
	}

	if (!ds->candidate_checked) {
		ds->candidate_ok = ds->fn(ds->candidate, ds->cb_data);
		ds->disambiguate_fn_used = 1;
		ds->candidate_checked = 1;
	}

	if (!ds->candidate_ok) {
Ondřej Bílka's avatar
Ondřej Bílka committed
55
		/* discard the candidate; we know it does not satisfy fn */
56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74
		hashcpy(ds->candidate, current);
		ds->candidate_checked = 0;
		return;
	}

	/* if we reach this point, we know ds->candidate satisfies fn */
	if (ds->fn(current, ds->cb_data)) {
		/*
		 * if both current and candidate satisfy fn, we cannot
		 * disambiguate.
		 */
		ds->candidate_ok = 0;
		ds->ambiguous = 1;
	}

	/* otherwise, current can be discarded and candidate is still good */
}

static void find_short_object_filename(int len, const char *hex_pfx, struct disambiguate_state *ds)
75
{
76
	struct alternate_object_database *alt;
77
	char hex[40];
78 79 80
	static struct alternate_object_database *fakeent;

	if (!fakeent) {
81 82 83 84 85 86 87
		/*
		 * Create a "fake" alternate object database that
		 * points to our own object database, to make it
		 * easier to get a temporary working space in
		 * alt->name/alt->base while iterating over the
		 * object databases including our own.
		 */
88 89 90 91 92 93 94 95 96
		const char *objdir = get_object_directory();
		int objdir_len = strlen(objdir);
		int entlen = objdir_len + 43;
		fakeent = xmalloc(sizeof(*fakeent) + entlen);
		memcpy(fakeent->base, objdir, objdir_len);
		fakeent->name = fakeent->base + objdir_len + 1;
		fakeent->name[-1] = '/';
	}
	fakeent->next = alt_odb_list;
97

98
	sprintf(hex, "%.2s", hex_pfx);
99
	for (alt = fakeent; alt && !ds->ambiguous; alt = alt->next) {
100
		struct dirent *de;
101
		DIR *dir;
102
		sprintf(alt->name, "%.2s/", hex_pfx);
103 104 105
		dir = opendir(alt->base);
		if (!dir)
			continue;
106 107 108 109

		while (!ds->ambiguous && (de = readdir(dir)) != NULL) {
			unsigned char sha1[20];

110 111
			if (strlen(de->d_name) != 38)
				continue;
112
			if (memcmp(de->d_name, hex_pfx + 2, len - 2))
113
				continue;
114 115 116
			memcpy(hex + 2, de->d_name, 38);
			if (!get_sha1_hex(hex, sha1))
				update_candidates(ds, sha1);
117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136
		}
		closedir(dir);
	}
}

static int match_sha(unsigned len, const unsigned char *a, const unsigned char *b)
{
	do {
		if (*a != *b)
			return 0;
		a++;
		b++;
		len -= 2;
	} while (len > 1);
	if (len)
		if ((*a ^ *b) & 0xf0)
			return 0;
	return 1;
}

137
static void unique_in_pack(int len,
138
			  const unsigned char *bin_pfx,
139 140
			   struct packed_git *p,
			   struct disambiguate_state *ds)
141
{
142 143 144 145 146 147 148 149 150 151 152 153
	uint32_t num, last, i, first = 0;
	const unsigned char *current = NULL;

	open_pack_index(p);
	num = p->num_objects;
	last = num;
	while (first < last) {
		uint32_t mid = (first + last) / 2;
		const unsigned char *current;
		int cmp;

		current = nth_packed_object_sha1(p, mid);
154
		cmp = hashcmp(bin_pfx, current);
155 156 157
		if (!cmp) {
			first = mid;
			break;
158
		}
159 160 161
		if (cmp > 0) {
			first = mid+1;
			continue;
162
		}
163 164 165 166 167
		last = mid;
	}

	/*
	 * At this point, "first" is the location of the lowest object
168
	 * with an object name that could match "bin_pfx".  See if we have
169 170
	 * 0, 1 or more objects that actually match(es).
	 */
171 172
	for (i = first; i < num && !ds->ambiguous; i++) {
		current = nth_packed_object_sha1(p, i);
173
		if (!match_sha(len, bin_pfx, current))
174
			break;
175
		update_candidates(ds, current);
176
	}
177 178
}

179 180
static void find_short_packed_object(int len, const unsigned char *bin_pfx,
				     struct disambiguate_state *ds)
181 182 183 184
{
	struct packed_git *p;

	prepare_packed_git();
185 186
	for (p = packed_git; p && !ds->ambiguous; p = p->next)
		unique_in_pack(len, bin_pfx, p, ds);
187 188
}

189 190 191
#define SHORT_NAME_NOT_FOUND (-1)
#define SHORT_NAME_AMBIGUOUS (-2)

192 193
static int finish_object_disambiguation(struct disambiguate_state *ds,
					unsigned char *sha1)
194
{
195 196
	if (ds->ambiguous)
		return SHORT_NAME_AMBIGUOUS;
197

198
	if (!ds->candidate_exists)
199
		return SHORT_NAME_NOT_FOUND;
200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219

	if (!ds->candidate_checked)
		/*
		 * If this is the only candidate, there is no point
		 * calling the disambiguation hint callback.
		 *
		 * On the other hand, if the current candidate
		 * replaced an earlier candidate that did _not_ pass
		 * the disambiguation hint callback, then we do have
		 * more than one objects that match the short name
		 * given, so we should make sure this one matches;
		 * otherwise, if we discovered this one and the one
		 * that we previously discarded in the reverse order,
		 * we would end up showing different results in the
		 * same repository!
		 */
		ds->candidate_ok = (!ds->disambiguate_fn_used ||
				    ds->fn(ds->candidate, ds->cb_data));

	if (!ds->candidate_ok)
220
		return SHORT_NAME_AMBIGUOUS;
221 222

	hashcpy(sha1, ds->candidate);
223 224 225
	return 0;
}

226 227 228 229 230 231
static int disambiguate_commit_only(const unsigned char *sha1, void *cb_data_unused)
{
	int kind = sha1_object_info(sha1, NULL);
	return kind == OBJ_COMMIT;
}

232 233 234 235 236 237 238 239 240
static int disambiguate_committish_only(const unsigned char *sha1, void *cb_data_unused)
{
	struct object *obj;
	int kind;

	kind = sha1_object_info(sha1, NULL);
	if (kind == OBJ_COMMIT)
		return 1;
	if (kind != OBJ_TAG)
241
		return 0;
242 243

	/* We need to do this the hard way... */
244
	obj = deref_tag(parse_object(sha1), NULL, 0);
245 246
	if (obj && obj->type == OBJ_COMMIT)
		return 1;
247 248 249
	return 0;
}

250
static int disambiguate_tree_only(const unsigned char *sha1, void *cb_data_unused)
251
{
252 253 254
	int kind = sha1_object_info(sha1, NULL);
	return kind == OBJ_TREE;
}
255

256 257 258 259 260 261 262 263 264 265 266 267 268 269 270 271 272 273 274 275 276 277 278 279
static int disambiguate_treeish_only(const unsigned char *sha1, void *cb_data_unused)
{
	struct object *obj;
	int kind;

	kind = sha1_object_info(sha1, NULL);
	if (kind == OBJ_TREE || kind == OBJ_COMMIT)
		return 1;
	if (kind != OBJ_TAG)
		return 0;

	/* We need to do this the hard way... */
	obj = deref_tag(lookup_object(sha1), NULL, 0);
	if (obj && (obj->type == OBJ_TREE || obj->type == OBJ_COMMIT))
		return 1;
	return 0;
}

static int disambiguate_blob_only(const unsigned char *sha1, void *cb_data_unused)
{
	int kind = sha1_object_info(sha1, NULL);
	return kind == OBJ_BLOB;
}

280 281 282
static int prepare_prefixes(const char *name, int len,
			    unsigned char *bin_pfx,
			    char *hex_pfx)
283
{
284
	int i;
285

286 287
	hashclr(bin_pfx);
	memset(hex_pfx, 'x', 40);
288
	for (i = 0; i < len ;i++) {
289 290 291 292 293 294 295 296 297 298 299 300
		unsigned char c = name[i];
		unsigned char val;
		if (c >= '0' && c <= '9')
			val = c - '0';
		else if (c >= 'a' && c <= 'f')
			val = c - 'a' + 10;
		else if (c >= 'A' && c <='F') {
			val = c - 'A' + 10;
			c -= 'A' - 'a';
		}
		else
			return -1;
301
		hex_pfx[i] = c;
302 303
		if (!(i & 1))
			val <<= 4;
304
		bin_pfx[i >> 1] |= val;
305
	}
306 307 308 309 310 311 312 313 314 315 316 317 318 319 320 321
	return 0;
}

static int get_short_sha1(const char *name, int len, unsigned char *sha1,
			  unsigned flags)
{
	int status;
	char hex_pfx[40];
	unsigned char bin_pfx[20];
	struct disambiguate_state ds;
	int quietly = !!(flags & GET_SHA1_QUIETLY);

	if (len < MINIMUM_ABBREV || len > 40)
		return -1;
	if (prepare_prefixes(name, len, bin_pfx, hex_pfx) < 0)
		return -1;
322

323 324 325
	prepare_alt_odb();

	memset(&ds, 0, sizeof(ds));
326 327
	if (flags & GET_SHA1_COMMIT)
		ds.fn = disambiguate_commit_only;
328 329
	else if (flags & GET_SHA1_COMMITTISH)
		ds.fn = disambiguate_committish_only;
330 331 332 333 334 335
	else if (flags & GET_SHA1_TREE)
		ds.fn = disambiguate_tree_only;
	else if (flags & GET_SHA1_TREEISH)
		ds.fn = disambiguate_treeish_only;
	else if (flags & GET_SHA1_BLOB)
		ds.fn = disambiguate_blob_only;
336

337 338 339
	find_short_object_filename(len, hex_pfx, &ds);
	find_short_packed_object(len, bin_pfx, &ds);
	status = finish_object_disambiguation(&ds, sha1);
340

341
	if (!quietly && (status == SHORT_NAME_AMBIGUOUS))
342
		return error("short SHA1 %.*s is ambiguous.", len, hex_pfx);
343 344 345
	return status;
}

346 347 348 349 350 351 352 353 354 355 356 357 358 359 360 361 362 363 364 365 366 367 368 369
int for_each_abbrev(const char *prefix, each_abbrev_fn fn, void *cb_data)
{
	char hex_pfx[40];
	unsigned char bin_pfx[20];
	struct disambiguate_state ds;
	int len = strlen(prefix);

	if (len < MINIMUM_ABBREV || len > 40)
		return -1;
	if (prepare_prefixes(prefix, len, bin_pfx, hex_pfx) < 0)
		return -1;

	prepare_alt_odb();

	memset(&ds, 0, sizeof(ds));
	ds.always_call_fn = 1;
	ds.cb_data = cb_data;
	ds.fn = fn;

	find_short_object_filename(len, hex_pfx, &ds);
	find_short_packed_object(len, bin_pfx, &ds);
	return ds.ambiguous;
}

370 371
const char *find_unique_abbrev(const unsigned char *sha1, int len)
{
372
	int status, exists;
373
	static char hex[41];
Junio C Hamano's avatar
Junio C Hamano committed
374

375
	exists = has_sha1_file(sha1);
376
	memcpy(hex, sha1_to_hex(sha1), 40);
377
	if (len == 40 || !len)
Junio C Hamano's avatar
Junio C Hamano committed
378
		return hex;
379 380
	while (len < 40) {
		unsigned char sha1_ret[20];
381
		status = get_short_sha1(hex, len, sha1_ret, GET_SHA1_QUIETLY);
382 383 384
		if (exists
		    ? !status
		    : status == SHORT_NAME_NOT_FOUND) {
385
			hex[len] = 0;
386 387 388 389
			return hex;
		}
		len++;
	}
390
	return hex;
391 392
}

393
static int ambiguous_path(const char *path, int len)
394 395
{
	int slash = 1;
396
	int cnt;
397

398
	for (cnt = 0; cnt < len; cnt++) {
399 400 401 402 403 404 405 406 407 408 409 410 411 412
		switch (*path++) {
		case '\0':
			break;
		case '/':
			if (slash)
				break;
			slash = 1;
			continue;
		case '.':
			continue;
		default:
			slash = 0;
			continue;
		}
413
		break;
414
	}
415
	return slash;
416 417
}

418 419 420 421 422 423 424 425 426 427 428 429 430 431
static inline int upstream_mark(const char *string, int len)
{
	const char *suffix[] = { "@{upstream}", "@{u}" };
	int i;

	for (i = 0; i < ARRAY_SIZE(suffix); i++) {
		int suffix_len = strlen(suffix[i]);
		if (suffix_len <= len
		    && !memcmp(string, suffix[i], suffix_len))
			return suffix_len;
	}
	return 0;
}

432
static int get_sha1_1(const char *name, int len, unsigned char *sha1, unsigned lookup_flags);
433
static int interpret_nth_prior_checkout(const char *name, int namelen, struct strbuf *buf);
434

435 436
static int get_sha1_basic(const char *str, int len, unsigned char *sha1)
{
437
	static const char *warn_msg = "refname '%.*s' is ambiguous.";
438 439 440 441 442 443 444 445 446
	static const char *object_name_msg = N_(
	"Git normally never creates a ref that ends with 40 hex characters\n"
	"because it will be ignored when you just specify 40-hex. These refs\n"
	"may be created by mistake. For example,\n"
	"\n"
	"  git checkout -b $br $(git rev-parse ...)\n"
	"\n"
	"where \"$br\" is somehow empty and a 40-hex ref is created. Please\n"
	"examine these refs and maybe delete them. Turn this message off by\n"
447
	"running \"git config advice.objectNameWarning false\"");
448
	unsigned char tmp_sha1[20];
Linus Torvalds's avatar
Linus Torvalds committed
449
	char *real_ref = NULL;
450
	int refs_found = 0;
451
	int at, reflog_len, nth_prior = 0;
452

453
	if (len == 40 && !get_sha1_hex(str, sha1)) {
454
		if (warn_ambiguous_refs && warn_on_object_refname_ambiguity) {
455
			refs_found = dwim_ref(str, len, tmp_sha1, &real_ref);
456
			if (refs_found > 0) {
457 458 459 460 461
				warning(warn_msg, len, str);
				if (advice_object_name_warning)
					fprintf(stderr, "%s\n", _(object_name_msg));
			}
			free(real_ref);
462
		}
463
		return 0;
464
	}
465

466
	/* basic@{time or number or -number} format to query ref-log */
467
	reflog_len = at = 0;
468
	if (len && str[len-1] == '}') {
469
		for (at = len-4; at >= 0; at--) {
470
			if (str[at] == '@' && str[at+1] == '{') {
471 472 473 474
				if (str[at+2] == '-') {
					if (at != 0)
						/* @{-N} not at start */
						return -1;
475 476 477
					nth_prior = 1;
					continue;
				}
478
				if (!upstream_mark(str + at, len - at)) {
479 480 481
					reflog_len = (len-1) - (at+2);
					len = at;
				}
482 483
				break;
			}
484 485 486
		}
	}

487
	/* Accept only unambiguous ref paths. */
488
	if (len && ambiguous_path(str, len))
489 490
		return -1;

491
	if (nth_prior) {
492
		struct strbuf buf = STRBUF_INIT;
493 494
		int detached;

495
		if (interpret_nth_prior_checkout(str, len, &buf) > 0) {
496 497 498 499
			detached = (buf.len == 40 && !get_sha1_hex(buf.buf, sha1));
			strbuf_release(&buf);
			if (detached)
				return 0;
500
		}
501 502 503
	}

	if (!len && reflog_len)
504 505
		/* allow "@{...}" to mean the current branch reflog */
		refs_found = dwim_ref("HEAD", 4, sha1, &real_ref);
506
	else if (reflog_len)
507 508
		refs_found = dwim_log(str, len, sha1, &real_ref);
	else
509
		refs_found = dwim_ref(str, len, sha1, &real_ref);
510 511 512 513

	if (!refs_found)
		return -1;

514 515 516
	if (warn_ambiguous_refs &&
	    (refs_found > 1 ||
	     !get_short_sha1(str, len, tmp_sha1, GET_SHA1_QUIETLY)))
517
		warning(warn_msg, len, str);
518

519 520 521
	if (reflog_len) {
		int nth, i;
		unsigned long at_time;
522 523 524
		unsigned long co_time;
		int co_tz, co_cnt;

525
		/* Is it asking for N-th entry, or approxidate? */
526 527 528 529 530 531 532
		for (i = nth = 0; 0 <= nth && i < reflog_len; i++) {
			char ch = str[at+2+i];
			if ('0' <= ch && ch <= '9')
				nth = nth * 10 + ch - '0';
			else
				nth = -1;
		}
533 534 535 536
		if (100000000 <= nth) {
			at_time = nth;
			nth = -1;
		} else if (0 <= nth)
537
			at_time = 0;
538
		else {
539
			int errors = 0;
540
			char *tmp = xstrndup(str + at + 2, reflog_len);
541
			at_time = approxidate_careful(tmp, &errors);
542
			free(tmp);
543 544
			if (errors) {
				free(real_ref);
545
				return -1;
546
			}
547
		}
548 549
		if (read_ref_at(real_ref, at_time, nth, sha1, NULL,
				&co_time, &co_tz, &co_cnt)) {
550
			if (!len) {
551
				if (starts_with(real_ref, "refs/heads/")) {
552 553 554 555 556 557 558 559
					str = real_ref + 11;
					len = strlen(real_ref + 11);
				} else {
					/* detached HEAD */
					str = "HEAD";
					len = 4;
				}
			}
560
			if (at_time)
561 562
				warning("Log for '%.*s' only goes "
					"back to %s.", len, str,
563
					show_date(co_time, co_tz, DATE_RFC2822));
564 565 566 567
			else {
				die("Log for '%.*s' only has %d entries.",
				    len, str, co_cnt);
			}
568
		}
569 570
	}

Linus Torvalds's avatar
Linus Torvalds committed
571
	free(real_ref);
572
	return 0;
573 574 575 576 577 578
}

static int get_parent(const char *name, int len,
		      unsigned char *result, int idx)
{
	unsigned char sha1[20];
579
	int ret = get_sha1_1(name, len, sha1, GET_SHA1_COMMITTISH);
580 581 582 583 584 585 586 587 588
	struct commit *commit;
	struct commit_list *p;

	if (ret)
		return ret;
	commit = lookup_commit_reference(sha1);
	if (parse_commit(commit))
		return -1;
	if (!idx) {
589
		hashcpy(result, commit->object.sha1);
590 591 592 593 594
		return 0;
	}
	p = commit->parents;
	while (p) {
		if (!--idx) {
595
			hashcpy(result, p->item->object.sha1);
596 597 598 599 600 601 602
			return 0;
		}
		p = p->next;
	}
	return -1;
}

603 604 605 606
static int get_nth_ancestor(const char *name, int len,
			    unsigned char *result, int generation)
{
	unsigned char sha1[20];
607 608 609
	struct commit *commit;
	int ret;

610
	ret = get_sha1_1(name, len, sha1, GET_SHA1_COMMITTISH);
611 612
	if (ret)
		return ret;
613 614 615
	commit = lookup_commit_reference(sha1);
	if (!commit)
		return -1;
616 617

	while (generation--) {
618
		if (parse_commit(commit) || !commit->parents)
619
			return -1;
620
		commit = commit->parents->item;
621
	}
622
	hashcpy(result, commit->object.sha1);
623 624 625
	return 0;
}

626 627 628 629 630 631 632 633
struct object *peel_to_type(const char *name, int namelen,
			    struct object *o, enum object_type expected_type)
{
	if (name && !namelen)
		namelen = strlen(name);
	while (1) {
		if (!o || (!o->parsed && !parse_object(o->sha1)))
			return NULL;
634
		if (expected_type == OBJ_ANY || o->type == expected_type)
635 636 637 638 639 640 641 642 643 644 645 646 647 648 649 650
			return o;
		if (o->type == OBJ_TAG)
			o = ((struct tag*) o)->tagged;
		else if (o->type == OBJ_COMMIT)
			o = &(((struct commit *) o)->tree->object);
		else {
			if (name)
				error("%.*s: expected %s type, but the object "
				      "dereferences to %s type",
				      namelen, name, typename(expected_type),
				      typename(o->type));
			return NULL;
		}
	}
}

651 652 653 654
static int peel_onion(const char *name, int len, unsigned char *sha1)
{
	unsigned char outer[20];
	const char *sp;
655
	unsigned int expected_type = 0;
656
	unsigned lookup_flags = 0;
657 658 659 660 661 662 663 664 665 666 667 668 669 670 671 672 673 674 675 676 677 678
	struct object *o;

	/*
	 * "ref^{type}" dereferences ref repeatedly until you cannot
	 * dereference anymore, or you get an object of given type,
	 * whichever comes first.  "ref^{}" means just dereference
	 * tags until you get a non-tag.  "ref^0" is a shorthand for
	 * "ref^{commit}".  "commit^{tree}" could be used to find the
	 * top-level tree of the given commit.
	 */
	if (len < 4 || name[len-1] != '}')
		return -1;

	for (sp = name + len - 1; name <= sp; sp--) {
		int ch = *sp;
		if (ch == '{' && name < sp && sp[-1] == '^')
			break;
	}
	if (sp <= name)
		return -1;

	sp++; /* beginning of type name, or closing brace for empty */
679
	if (starts_with(sp, "commit}"))
680
		expected_type = OBJ_COMMIT;
681
	else if (starts_with(sp, "tag}"))
682
		expected_type = OBJ_TAG;
683
	else if (starts_with(sp, "tree}"))
684
		expected_type = OBJ_TREE;
685
	else if (starts_with(sp, "blob}"))
686
		expected_type = OBJ_BLOB;
687
	else if (starts_with(sp, "object}"))
688
		expected_type = OBJ_ANY;
689
	else if (sp[0] == '}')
690
		expected_type = OBJ_NONE;
691 692
	else if (sp[0] == '/')
		expected_type = OBJ_COMMIT;
693 694 695
	else
		return -1;

696 697
	if (expected_type == OBJ_COMMIT)
		lookup_flags = GET_SHA1_COMMITTISH;
698 699
	else if (expected_type == OBJ_TREE)
		lookup_flags = GET_SHA1_TREEISH;
700 701

	if (get_sha1_1(name, sp - name - 2, outer, lookup_flags))
702 703 704 705 706
		return -1;

	o = parse_object(outer);
	if (!o)
		return -1;
707
	if (!expected_type) {
708
		o = deref_tag(o, name, sp - name - 2);
709 710
		if (!o || (!o->parsed && !parse_object(o->sha1)))
			return -1;
711
		hashcpy(sha1, o->sha1);
712
		return 0;
713
	}
714 715 716 717 718 719 720 721

	/*
	 * At this point, the syntax look correct, so
	 * if we do not get the needed object, we should
	 * barf.
	 */
	o = peel_to_type(name, len, o, expected_type);
	if (!o)
722
		return -1;
723 724 725 726 727 728 729 730

	hashcpy(sha1, o->sha1);
	if (sp[0] == '/') {
		/* "$commit^{/foo}" */
		char *prefix;
		int ret;
		struct commit_list *list = NULL;

731
		/*
732 733
		 * $commit^{/}. Some regex implementation may reject.
		 * We don't need regex anyway. '' pattern always matches.
734
		 */
735
		if (sp[1] == '}')
736
			return 0;
737

738 739 740 741 742
		prefix = xstrndup(sp + 1, name + len - 1 - (sp + 1));
		commit_list_insert((struct commit *)o, &list);
		ret = get_sha1_oneline(prefix, sha1, list);
		free(prefix);
		return ret;
743 744 745 746
	}
	return 0;
}

747 748 749
static int get_describe_name(const char *name, int len, unsigned char *sha1)
{
	const char *cp;
750
	unsigned flags = GET_SHA1_QUIETLY | GET_SHA1_COMMIT;
751 752 753 754 755 756 757 758 759 760

	for (cp = name + len - 1; name + 2 <= cp; cp--) {
		char ch = *cp;
		if (hexval(ch) & ~0377) {
			/* We must be looking at g in "SOMETHING-g"
			 * for it to be describe output.
			 */
			if (ch == 'g' && cp[-1] == '-') {
				cp++;
				len -= cp - name;
761
				return get_short_sha1(cp, len, sha1, flags);
762 763 764 765 766 767
			}
		}
	}
	return -1;
}

768
static int get_sha1_1(const char *name, int len, unsigned char *sha1, unsigned lookup_flags)
769
{
770
	int ret, has_suffix;
771
	const char *cp;
772

773 774
	/*
	 * "name~3" is "name^^^", "name~" is "name~1", and "name^" is "name^1".
775
	 */
776
	has_suffix = 0;
777 778 779 780
	for (cp = name + len - 1; name <= cp; cp--) {
		int ch = *cp;
		if ('0' <= ch && ch <= '9')
			continue;
781 782
		if (ch == '~' || ch == '^')
			has_suffix = ch;
783 784
		break;
	}
785 786 787

	if (has_suffix) {
		int num = 0;
788 789 790
		int len1 = cp - name;
		cp++;
		while (cp < name + len)
791
			num = num * 10 + *cp++ - '0';
792 793 794
		if (!num && len1 == len - 1)
			num = 1;
		if (has_suffix == '^')
795 796 797
			return get_parent(name, len1, sha1, num);
		/* else if (has_suffix == '~') -- goes without saying */
		return get_nth_ancestor(name, len1, sha1, num);
798 799
	}

800 801 802 803
	ret = peel_onion(name, len, sha1);
	if (!ret)
		return 0;

804 805 806
	ret = get_sha1_basic(name, len, sha1);
	if (!ret)
		return 0;
807 808 809 810 811 812

	/* It could be describe output that is "SOMETHING-gXXXX" */
	ret = get_describe_name(name, len, sha1);
	if (!ret)
		return 0;

813
	return get_short_sha1(name, len, sha1, lookup_flags);
814 815
}

816 817 818
/*
 * This interprets names like ':/Initial revision of "git"' by searching
 * through history and returning the first commit whose message starts
819
 * the given regular expression.
820 821 822 823
 *
 * For future extension, ':/!' is reserved. If you want to match a message
 * beginning with a '!', you have to repeat the exclamation mark.
 */
824 825

/* Remember to update object flag allocation in object.h */
826 827
#define ONELINE_SEEN (1u<<20)

828 829 830 831 832 833 834
static int handle_one_ref(const char *path,
		const unsigned char *sha1, int flag, void *cb_data)
{
	struct commit_list **list = cb_data;
	struct object *object = parse_object(sha1);
	if (!object)
		return 0;
835
	if (object->type == OBJ_TAG) {
836
		object = deref_tag(object, path, strlen(path));
837 838 839
		if (!object)
			return 0;
	}
840 841
	if (object->type != OBJ_COMMIT)
		return 0;
842
	commit_list_insert_by_date((struct commit *)object, list);
843 844 845
	return 0;
}

846 847
static int get_sha1_oneline(const char *prefix, unsigned char *sha1,
			    struct commit_list *list)
848
{
849
	struct commit_list *backup = NULL, *l;
850
	int found = 0;
851
	regex_t regex;
852 853 854 855 856 857

	if (prefix[0] == '!') {
		if (prefix[1] != '!')
			die ("Invalid search pattern: %s", prefix);
		prefix++;
	}
858 859 860 861

	if (regcomp(&regex, prefix, REG_EXTENDED))
		die("Invalid search pattern: %s", prefix);

862 863
	for (l = list; l; l = l->next) {
		l->item->object.flags |= ONELINE_SEEN;
864
		commit_list_insert(l->item, &backup);
865
	}
866
	while (list) {
867
		const char *p, *buf;
Linus Torvalds's avatar
Linus Torvalds committed
868
		struct commit *commit;
869
		int matches;
870 871

		commit = pop_most_recent_commit(&list, ONELINE_SEEN);
872 873
		if (!parse_object(commit->object.sha1))
			continue;
874
		buf = get_commit_buffer(commit, NULL);
875
		p = strstr(buf, "\n\n");
876
		matches = p && !regexec(&regex, p + 2, 0, NULL, 0);
877
		unuse_commit_buffer(commit, buf);
878 879

		if (matches) {
880
			hashcpy(sha1, commit->object.sha1);
881
			found = 1;
882 883 884
			break;
		}
	}
885
	regfree(&regex);
886 887 888
	free_commit_list(list);
	for (l = backup; l; l = l->next)
		clear_commit_marks(l->item, ONELINE_SEEN);
889 890
	free_commit_list(backup);
	return found ? 0 : -1;
891 892
}

893
struct grab_nth_branch_switch_cbdata {
894 895
	int remaining;
	struct strbuf buf;
896 897 898 899 900 901 902
};

static int grab_nth_branch_switch(unsigned char *osha1, unsigned char *nsha1,
				  const char *email, unsigned long timestamp, int tz,
				  const char *message, void *cb_data)
{
	struct grab_nth_branch_switch_cbdata *cb = cb_data;
Thomas Rast's avatar
Thomas Rast committed
903 904 905
	const char *match = NULL, *target = NULL;
	size_t len;

906
	if (skip_prefix(message, "checkout: moving from ", &match))
907
		target = strstr(match, " to ");
908

909
	if (!match || !target)
910
		return 0;
911 912 913 914 915 916
	if (--(cb->remaining) == 0) {
		len = target - match;
		strbuf_reset(&cb->buf);
		strbuf_add(&cb->buf, match, len);
		return 1; /* we are done */
	}
917 918 919 920
	return 0;
}

/*
921 922
 * Parse @{-N} syntax, return the number of characters parsed
 * if successful; otherwise signal an error with negative value.
923
 */
924 925
static int interpret_nth_prior_checkout(const char *name, int namelen,
					struct strbuf *buf)
926
{
927
	long nth;
928
	int retval;
929
	struct grab_nth_branch_switch_cbdata cb;
Thomas Rast's avatar
Thomas Rast committed
930 931
	const char *brace;
	char *num_end;
932

933 934
	if (namelen < 4)
		return -1;
935 936
	if (name[0] != '@' || name[1] != '{' || name[2] != '-')
		return -1;
937
	brace = memchr(name, '}', namelen);
Thomas Rast's avatar
Thomas Rast committed
938 939
	if (!brace)
		return -1;
940
	nth = strtol(name + 3, &num_end, 10);
Thomas Rast's avatar
Thomas Rast committed
941
	if (num_end != brace)
942
		return -1;
943 944
	if (nth <= 0)
		return -1;
945 946 947
	cb.remaining = nth;
	strbuf_init(&cb.buf, 20);

948
	retval = 0;
949 950
	if (0 < for_each_reflog_ent_reverse("HEAD", grab_nth_branch_switch, &cb)) {
		strbuf_reset(buf);
951
		strbuf_addbuf(buf, &cb.buf);
952 953
		retval = brace - name + 1;
	}
Thomas Rast's avatar
Thomas Rast committed
954

955
	strbuf_release(&cb.buf);
956
	return retval;
957 958
}

959 960 961 962 963 964 965 966 967 968 969 970 971 972 973 974 975
int get_sha1_mb(const char *name, unsigned char *sha1)
{
	struct commit *one, *two;
	struct commit_list *mbs;
	unsigned char sha1_tmp[20];
	const char *dots;
	int st;

	dots = strstr(name, "...");
	if (!dots)
		return get_sha1(name, sha1);
	if (dots == name)
		st = get_sha1("HEAD", sha1_tmp);
	else {
		struct strbuf sb;
		strbuf_init(&sb, dots - name);
		strbuf_add(&sb, name, dots - name);
976
		st = get_sha1_committish(sb.buf, sha1_tmp);
977 978 979 980 981 982 983 984
		strbuf_release(&sb);
	}
	if (st)
		return st;
	one = lookup_commit_reference_gently(sha1_tmp, 0);
	if (!one)
		return -1;

985
	if (get_sha1_committish(dots[3] ? (dots + 3) : "HEAD", sha1_tmp))
986 987 988 989 990 991 992 993 994 995 996 997 998 999 1000
		return -1;
	two = lookup_commit_reference_gently(sha1_tmp, 0);
	if (!two)
		return -1;
	mbs = get_merge_bases(one, two, 1);
	if (!mbs || mbs->next)
		st = -1;
	else {
		st = 0;
		hashcpy(sha1, mbs->item->object.sha1);
	}
	free_commit_list(mbs);
	return st;
}

1001 1002 1003 1004 1005 1006 1007 1008 1009
/* parse @something syntax, when 'something' is not {.*} */
static int interpret_empty_at(const char *name, int namelen, int len, struct strbuf *buf)
{
	const char *next;

	if (len || name[1] == '{')
		return -1;

	/* make sure it's a single @, or @@{.*}, not @foo */
1010
	next = memchr(name + len + 1, '@', namelen - len - 1);
1011 1012 1013 1014 1015 1016 1017 1018 1019 1020 1021 1022
	if (next && next[1] != '{')
		return -1;
	if (!next)
		next = name + namelen;
	if (next != name + 1)
		return -1;

	strbuf_reset(buf);
	strbuf_add(buf, "HEAD", 4);
	return 1;
}

1023 1024 1025 1026 1027 1028 1029 1030
static int reinterpret(const char *name, int namelen, int len, struct strbuf *buf)
{
	/* we have extra data, which might need further processing */
	struct strbuf tmp = STRBUF_INIT;
	int used = buf->len;
	int ret;

	strbuf_add(buf, name + len, namelen - len);
1031
	ret = interpret_branch_name(buf->buf, buf->len, &tmp);
1032 1033 1034 1035 1036 1037 1038 1039 1040 1041 1042 1043
	/* that data was not interpreted, remove our cruft */
	if (ret < 0) {
		strbuf_setlen(buf, used);
		return len;
	}
	strbuf_reset(buf);
	strbuf_addbuf(buf, &tmp);
	strbuf_release(&tmp);
	/* tweak for size of {-N} versus expanded ref name */
	return ret - used + len;
}

1044 1045 1046 1047 1048 1049 1050 1051 1052 1053 1054 1055 1056 1057 1058 1059 1060 1061 1062 1063 1064 1065 1066 1067 1068 1069 1070 1071 1072 1073 1074 1075 1076 1077 1078 1079 1080 1081 1082 1083 1084 1085 1086 1087
static void set_shortened_ref(struct strbuf *buf, const char *ref)
{
	char *s = shorten_unambiguous_ref(ref, 0);
	strbuf_reset(buf);
	strbuf_addstr(buf, s);
	free(s);
}

static const char *get_upstream_branch(const char *branch_buf, int len)
{
	char *branch = xstrndup(branch_buf, len);
	struct branch *upstream = branch_get(*branch ? branch : NULL);

	/*
	 * Upstream can be NULL only if branch refers to HEAD and HEAD
	 * points to something different than a branch.
	 */
	if (!upstream)
		die(_("HEAD does not point to a branch"));
	if (!upstream->merge || !upstream->merge[0]->dst) {
		if (!ref_exists(upstream->refname))
			die(_("No such branch: '%s'"), branch);
		if (!upstream->merge) {
			die(_("No upstream configured for branch '%s'"),
				upstream->name);
		}
		die(
			_("Upstream branch '%s' not stored as a remote-tracking branch"),
			upstream->merge[0]->src);
	}
	free(branch);

	return upstream->merge[0]->dst;
}

static int interpret_upstream_mark(const char *name, int namelen,
				   int at, struct strbuf *buf)
{
	int len;

	len = upstream_mark(name + at, namelen - at);
	if (!len)
		return -1;

1088 1089 1090
	if (memchr(name, ':', at))
		return -1;

1091 1092 1093 1094
	set_shortened_ref(buf, get_upstream_branch(name, at));
	return len + at;
}

1095 1096 1097 1098 1099 1100 1101 1102 1103 1104 1105 1106 1107 1108 1109 1110 1111 1112 1113 1114 1115
/*
 * This reads short-hand syntax that not only evaluates to a commit
 * object name, but also can act as if the end user spelled the name
 * of the branch from the command line.
 *
 * - "@{-N}" finds the name of the Nth previous branch we were on, and
 *   places the name of the branch in the given buf and returns the
 *   number of characters parsed if successful.
 *
 * - "<branch>@{upstream}" finds the name of the other ref that
 *   <branch> is configured to merge with (missing <branch> defaults
 *   to the current branch), and places the name of the branch in the
 *   given buf and returns the number of characters parsed if
 *   successful.
 *
 * If the input is not of the accepted format, it returns a negative
 * number to signal an error.
 *
 * If the input was ok but there are not N branch switches in the
 * reflog, it returns 0.
 */
1116
int interpret_branch_name(const char *name, int namelen, struct strbuf *buf)
1117
{
1118
	char *at;
1119
	const char *start;
1120
	int len = interpret_nth_prior_checkout(name, namelen, buf);
1121

1122 1123 1124
	if (!namelen)
		namelen = strlen(name);

1125
	if (!len) {
1126
		return len; /* syntax Ok, not enough switches */
1127 1128 1129 1130 1131
	} else if (len > 0) {
		if (len == namelen)
			return len; /* consumed all */
		else
			return reinterpret(name, namelen, len, buf);
1132 1133
	}

1134 1135 1136
	for (start = name;
	     (at = memchr(start, '@', namelen - (start - name)));
	     start = at + 1) {
1137

1138 1139 1140
		len = interpret_empty_at(name, namelen, at - name, buf);
		if (len > 0)
			return reinterpret(name, namelen, len, buf);
1141

1142 1143 1144
		len = interpret_upstream_mark(name, namelen, at - name, buf);
		if (len > 0)
			return len;
1145
	}
1146

1147
	return -1;
1148 1149
}

1150 1151 1152
int strbuf_branchname(struct strbuf *sb, const char *name)
{
	int len = strlen(name);
1153
	int used = interpret_branch_name(name, len, sb);
1154 1155

	if (used == len)
1156
		return 0;
1157 1158 1159
	if (used < 0)
		used = 0;
	strbuf_add(sb, name + used, len - used);
1160 1161 1162 1163 1164 1165 1166
	return len;
}

int strbuf_check_branch_ref(struct strbuf *sb, const char *name)
{
	strbuf_branchname(sb, name);
	if (name[0] == '-')
1167
		return -1;
1168
	strbuf_splice(sb, 0, 0, "refs/heads/", 11);
1169
	return check_refname_format(sb->buf, 0);
1170 1171
}

1172 1173 1174 1175 1176 1177
/*
 * This is like "get_sha1_basic()", except it allows "sha1 expressions",
 * notably "xyz^" for "parent of xyz"
 */
int get_sha1(const char *name, unsigned char *sha1)
{
1178
	struct object_context unused;
1179
	return get_sha1_with_context(name, 0, sha1, &unused);
Martin Koegler's avatar
Martin Koegler committed
1180 1181
}

1182
/*
1183
 * Many callers know that the user meant to name a commit-ish by
1184 1185
 * syntactical positions where the object name appears.  Calling this
 * function allows the machinery to disambiguate shorter-than-unique