merge.c 45.1 KB
Newer Older
Miklos Vajna's avatar
Miklos Vajna committed
1 2 3 4 5 6 7 8 9
/*
 * Builtin "git merge"
 *
 * Copyright (c) 2008 Miklos Vajna <[email protected]>
 *
 * Based on git-merge.sh by Junio C Hamano.
 */

#include "cache.h"
10
#include "config.h"
Miklos Vajna's avatar
Miklos Vajna committed
11 12
#include "parse-options.h"
#include "builtin.h"
13
#include "lockfile.h"
Miklos Vajna's avatar
Miklos Vajna committed
14 15 16
#include "run-command.h"
#include "diff.h"
#include "refs.h"
17
#include "refspec.h"
Miklos Vajna's avatar
Miklos Vajna committed
18 19 20 21 22 23 24 25 26
#include "commit.h"
#include "diffcore.h"
#include "revision.h"
#include "unpack-trees.h"
#include "cache-tree.h"
#include "dir.h"
#include "utf8.h"
#include "log-tree.h"
#include "color.h"
27
#include "rerere.h"
28
#include "help.h"
29
#include "merge-recursive.h"
30
#include "resolve-undo.h"
31
#include "remote.h"
32
#include "fmt-merge-msg.h"
33
#include "gpg-interface.h"
34
#include "sequencer.h"
35
#include "string-list.h"
36
#include "packfile.h"
37
#include "tag.h"
38
#include "alias.h"
39
#include "commit-reach.h"
Miklos Vajna's avatar
Miklos Vajna committed
40 41 42 43 44 45 46 47 48 49 50 51

#define DEFAULT_TWOHEAD (1<<0)
#define DEFAULT_OCTOPUS (1<<1)
#define NO_FAST_FORWARD (1<<2)
#define NO_TRIVIAL      (1<<3)

struct strategy {
	const char *name;
	unsigned attr;
};

static const char * const builtin_merge_usage[] = {
52
	N_("git merge [<options>] [<commit>...]"),
53
	N_("git merge --abort"),
54
	N_("git merge --continue"),
Miklos Vajna's avatar
Miklos Vajna committed
55 56 57
	NULL
};

58
static int show_diffstat = 1, shortlog_len = -1, squash;
59 60
static int option_commit = 1;
static int option_edit = -1;
61
static int allow_trivial = 1, have_message, verify_signatures;
62
static int overwrite_ignore = 1;
63
static struct strbuf merge_msg = STRBUF_INIT;
Miklos Vajna's avatar
Miklos Vajna committed
64 65
static struct strategy **use_strategies;
static size_t use_strategies_nr, use_strategies_alloc;
Avery Pennarun's avatar
Avery Pennarun committed
66 67
static const char **xopts;
static size_t xopts_nr, xopts_alloc;
Miklos Vajna's avatar
Miklos Vajna committed
68
static const char *branch;
69
static char *branch_mergeoptions;
70
static int option_renormalize;
tuncer's avatar
tuncer committed
71
static int verbosity;
72
static int allow_rerere_auto;
73
static int abort_current_merge;
74
static int continue_current_merge;
75
static int allow_unrelated_histories;
76
static int show_progress = -1;
77
static int default_to_upstream = 1;
78
static int signoff;
79
static const char *sign_commit;
80
static int verify_msg = 1;
Miklos Vajna's avatar
Miklos Vajna committed
81 82 83 84 85 86 87 88 89 90 91

static struct strategy all_strategy[] = {
	{ "recursive",  DEFAULT_TWOHEAD | NO_TRIVIAL },
	{ "octopus",    DEFAULT_OCTOPUS },
	{ "resolve",    0 },
	{ "ours",       NO_FAST_FORWARD | NO_TRIVIAL },
	{ "subtree",    NO_FAST_FORWARD | NO_TRIVIAL },
};

static const char *pull_twohead, *pull_octopus;

92 93 94 95 96 97 98 99
enum ff_type {
	FF_NO,
	FF_ALLOW,
	FF_ONLY
};

static enum ff_type fast_forward = FF_ALLOW;

Miklos Vajna's avatar
Miklos Vajna committed
100 101 102 103 104 105 106
static int option_parse_message(const struct option *opt,
				const char *arg, int unset)
{
	struct strbuf *buf = opt->value;

	if (unset)
		strbuf_setlen(buf, 0);
107
	else if (arg) {
108
		strbuf_addf(buf, "%s%s", buf->len ? "\n\n" : "", arg);
Miklos Vajna's avatar
Miklos Vajna committed
109
		have_message = 1;
110
	} else
111
		return error(_("switch `m' requires a value"));
Miklos Vajna's avatar
Miklos Vajna committed
112 113 114
	return 0;
}

115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143
static int option_read_message(struct parse_opt_ctx_t *ctx,
			       const struct option *opt, int unset)
{
	struct strbuf *buf = opt->value;
	const char *arg;

	if (unset)
		BUG("-F cannot be negated");

	if (ctx->opt) {
		arg = ctx->opt;
		ctx->opt = NULL;
	} else if (ctx->argc > 1) {
		ctx->argc--;
		arg = *++ctx->argv;
	} else
		return opterror(opt, "requires a value", 0);

	if (buf->len)
		strbuf_addch(buf, '\n');
	if (ctx->prefix && !is_absolute_path(arg))
		arg = prefix_filename(ctx->prefix, arg);
	if (strbuf_read_file(buf, arg, 0) < 0)
		return error(_("could not read file '%s'"), arg);
	have_message = 1;

	return 0;
}

Miklos Vajna's avatar
Miklos Vajna committed
144 145 146
static struct strategy *get_strategy(const char *name)
{
	int i;
147 148
	struct strategy *ret;
	static struct cmdnames main_cmds, other_cmds;
149
	static int loaded;
Miklos Vajna's avatar
Miklos Vajna committed
150 151 152 153 154 155 156

	if (!name)
		return NULL;

	for (i = 0; i < ARRAY_SIZE(all_strategy); i++)
		if (!strcmp(name, all_strategy[i].name))
			return &all_strategy[i];
157

158
	if (!loaded) {
159
		struct cmdnames not_strategies;
160
		loaded = 1;
161 162

		memset(&not_strategies, 0, sizeof(struct cmdnames));
163
		load_command_list("git-merge-", &main_cmds, &other_cmds);
164 165 166 167 168 169 170 171 172 173
		for (i = 0; i < main_cmds.cnt; i++) {
			int j, found = 0;
			struct cmdname *ent = main_cmds.names[i];
			for (j = 0; j < ARRAY_SIZE(all_strategy); j++)
				if (!strncmp(ent->name, all_strategy[j].name, ent->len)
						&& !all_strategy[j].name[ent->len])
					found = 1;
			if (!found)
				add_cmdname(&not_strategies, ent->name, ent->len);
		}
174
		exclude_cmds(&main_cmds, &not_strategies);
175 176
	}
	if (!is_in_cmdlist(&main_cmds, name) && !is_in_cmdlist(&other_cmds, name)) {
177 178
		fprintf(stderr, _("Could not find merge strategy '%s'.\n"), name);
		fprintf(stderr, _("Available strategies are:"));
179 180 181 182
		for (i = 0; i < main_cmds.cnt; i++)
			fprintf(stderr, " %s", main_cmds.names[i]->name);
		fprintf(stderr, ".\n");
		if (other_cmds.cnt) {
183
			fprintf(stderr, _("Available custom strategies are:"));
184 185 186 187
			for (i = 0; i < other_cmds.cnt; i++)
				fprintf(stderr, " %s", other_cmds.names[i]->name);
			fprintf(stderr, ".\n");
		}
188 189 190
		exit(1);
	}

191
	ret = xcalloc(1, sizeof(struct strategy));
192
	ret->name = xstrdup(name);
193
	ret->attr = NO_TRIVIAL;
194
	return ret;
Miklos Vajna's avatar
Miklos Vajna committed
195 196 197 198 199 200 201 202 203 204 205 206 207 208
}

static void append_strategy(struct strategy *s)
{
	ALLOC_GROW(use_strategies, use_strategies_nr + 1, use_strategies_alloc);
	use_strategies[use_strategies_nr++] = s;
}

static int option_parse_strategy(const struct option *opt,
				 const char *name, int unset)
{
	if (unset)
		return 0;

209
	append_strategy(get_strategy(name));
Miklos Vajna's avatar
Miklos Vajna committed
210 211 212
	return 0;
}

Avery Pennarun's avatar
Avery Pennarun committed
213 214 215 216 217 218 219 220 221 222 223
static int option_parse_x(const struct option *opt,
			  const char *arg, int unset)
{
	if (unset)
		return 0;

	ALLOC_GROW(xopts, xopts_nr + 1, xopts_alloc);
	xopts[xopts_nr++] = xstrdup(arg);
	return 0;
}

Miklos Vajna's avatar
Miklos Vajna committed
224 225 226 227 228 229 230 231 232
static int option_parse_n(const struct option *opt,
			  const char *arg, int unset)
{
	show_diffstat = unset;
	return 0;
}

static struct option builtin_merge_options[] = {
	{ OPTION_CALLBACK, 'n', NULL, NULL, NULL,
233
		N_("do not show a diffstat at the end of the merge"),
Miklos Vajna's avatar
Miklos Vajna committed
234
		PARSE_OPT_NOARG, option_parse_n },
235
	OPT_BOOL(0, "stat", &show_diffstat,
236
		N_("show a diffstat at the end of the merge")),
237
	OPT_BOOL(0, "summary", &show_diffstat, N_("(synonym to --stat)")),
238 239
	{ OPTION_INTEGER, 0, "log", &shortlog_len, N_("n"),
	  N_("add (at most <n>) entries from shortlog to merge commit message"),
240
	  PARSE_OPT_OPTARG, NULL, DEFAULT_MERGE_LOG_LEN },
241
	OPT_BOOL(0, "squash", &squash,
242
		N_("create a single commit instead of doing a merge")),
243
	OPT_BOOL(0, "commit", &option_commit,
244
		N_("perform a commit if the merge succeeds (default)")),
245
	OPT_BOOL('e', "edit", &option_edit,
246
		N_("edit message before committing")),
247
	OPT_SET_INT(0, "ff", &fast_forward, N_("allow fast-forward (default)"), FF_ALLOW),
248 249 250
	OPT_SET_INT_F(0, "ff-only", &fast_forward,
		      N_("abort if fast-forward is not possible"),
		      FF_ONLY, PARSE_OPT_NONEG),
251
	OPT_RERERE_AUTOUPDATE(&allow_rerere_auto),
252
	OPT_BOOL(0, "verify-signatures", &verify_signatures,
253
		N_("verify that the named commit has a valid GPG signature")),
254 255 256 257 258 259
	OPT_CALLBACK('s', "strategy", &use_strategies, N_("strategy"),
		N_("merge strategy to use"), option_parse_strategy),
	OPT_CALLBACK('X', "strategy-option", &xopts, N_("option=value"),
		N_("option for selected merge strategy"), option_parse_x),
	OPT_CALLBACK('m', "message", &merge_msg, N_("message"),
		N_("merge commit message (for a non-fast-forward merge)"),
Miklos Vajna's avatar
Miklos Vajna committed
260
		option_parse_message),
261 262 263
	{ OPTION_LOWLEVEL_CALLBACK, 'F', "file", &merge_msg, N_("path"),
		N_("read message from file"), PARSE_OPT_NONEG,
		(parse_opt_cb *) option_read_message },
tuncer's avatar
tuncer committed
264
	OPT__VERBOSITY(&verbosity),
265
	OPT_BOOL(0, "abort", &abort_current_merge,
266
		N_("abort the current in-progress merge")),
267 268
	OPT_BOOL(0, "continue", &continue_current_merge,
		N_("continue the current in-progress merge")),
269 270
	OPT_BOOL(0, "allow-unrelated-histories", &allow_unrelated_histories,
		 N_("allow merging unrelated histories")),
271
	OPT_SET_INT(0, "progress", &show_progress, N_("force progress reporting"), 1),
272
	{ OPTION_STRING, 'S', "gpg-sign", &sign_commit, N_("key-id"),
273
	  N_("GPG sign commit"), PARSE_OPT_OPTARG, NULL, (intptr_t) "" },
274
	OPT_BOOL(0, "overwrite-ignore", &overwrite_ignore, N_("update ignored files (default)")),
275
	OPT_BOOL(0, "signoff", &signoff, N_("add Signed-off-by:")),
276
	OPT_BOOL(0, "verify", &verify_msg, N_("verify commit-msg hook")),
Miklos Vajna's avatar
Miklos Vajna committed
277 278 279 280 281 282
	OPT_END()
};

/* Cleans up metadata that is uninteresting after a succeeded merge. */
static void drop_save(void)
{
283 284 285
	unlink(git_path_merge_head(the_repository));
	unlink(git_path_merge_msg(the_repository));
	unlink(git_path_merge_mode(the_repository));
Miklos Vajna's avatar
Miklos Vajna committed
286 287
}

288
static int save_state(struct object_id *stash)
Miklos Vajna's avatar
Miklos Vajna committed
289 290
{
	int len;
291
	struct child_process cp = CHILD_PROCESS_INIT;
Miklos Vajna's avatar
Miklos Vajna committed
292 293
	struct strbuf buffer = STRBUF_INIT;
	const char *argv[] = {"stash", "create", NULL};
294
	int rc = -1;
Miklos Vajna's avatar
Miklos Vajna committed
295 296 297 298 299 300

	cp.argv = argv;
	cp.out = -1;
	cp.git_cmd = 1;

	if (start_command(&cp))
301
		die(_("could not run stash."));
Miklos Vajna's avatar
Miklos Vajna committed
302 303 304 305
	len = strbuf_read(&buffer, cp.out, 1024);
	close(cp.out);

	if (finish_command(&cp) || len < 0)
306
		die(_("stash failed"));
307
	else if (!len)		/* no changes */
308
		goto out;
Miklos Vajna's avatar
Miklos Vajna committed
309
	strbuf_setlen(&buffer, buffer.len-1);
310
	if (get_oid(buffer.buf, stash))
311
		die(_("not a valid object: %s"), buffer.buf);
312 313 314 315
	rc = 0;
out:
	strbuf_release(&buffer);
	return rc;
Miklos Vajna's avatar
Miklos Vajna committed
316 317
}

318
static void read_empty(const struct object_id *oid, int verbose)
319 320 321 322 323 324 325 326 327
{
	int i = 0;
	const char *args[7];

	args[i++] = "read-tree";
	if (verbose)
		args[i++] = "-v";
	args[i++] = "-m";
	args[i++] = "-u";
328 329
	args[i++] = empty_tree_oid_hex();
	args[i++] = oid_to_hex(oid);
330 331 332
	args[i] = NULL;

	if (run_command_v_opt(args, RUN_GIT_CMD))
333
		die(_("read-tree failed"));
334 335
}

336
static void reset_hard(const struct object_id *oid, int verbose)
Miklos Vajna's avatar
Miklos Vajna committed
337 338 339 340 341 342 343 344 345
{
	int i = 0;
	const char *args[6];

	args[i++] = "read-tree";
	if (verbose)
		args[i++] = "-v";
	args[i++] = "--reset";
	args[i++] = "-u";
346
	args[i++] = oid_to_hex(oid);
Miklos Vajna's avatar
Miklos Vajna committed
347 348 349
	args[i] = NULL;

	if (run_command_v_opt(args, RUN_GIT_CMD))
350
		die(_("read-tree failed"));
Miklos Vajna's avatar
Miklos Vajna committed
351 352
}

353 354
static void restore_state(const struct object_id *head,
			  const struct object_id *stash)
Miklos Vajna's avatar
Miklos Vajna committed
355
{
356
	struct strbuf sb = STRBUF_INIT;
Miklos Vajna's avatar
Miklos Vajna committed
357 358
	const char *args[] = { "stash", "apply", NULL, NULL };

359
	if (is_null_oid(stash))
Miklos Vajna's avatar
Miklos Vajna committed
360 361
		return;

362
	reset_hard(head, 1);
Miklos Vajna's avatar
Miklos Vajna committed
363

364
	args[2] = oid_to_hex(stash);
Miklos Vajna's avatar
Miklos Vajna committed
365 366 367 368 369 370 371 372 373 374 375 376 377 378

	/*
	 * It is OK to ignore error here, for example when there was
	 * nothing to restore.
	 */
	run_command_v_opt(args, RUN_GIT_CMD);

	strbuf_release(&sb);
	refresh_cache(REFRESH_QUIET);
}

/* This is called when no merge was necessary. */
static void finish_up_to_date(const char *msg)
{
tuncer's avatar
tuncer committed
379
	if (verbosity >= 0)
380
		printf("%s%s\n", squash ? _(" (nothing to squash)") : "", msg);
Miklos Vajna's avatar
Miklos Vajna committed
381 382 383
	drop_save();
}

384
static void squash_message(struct commit *commit, struct commit_list *remoteheads)
Miklos Vajna's avatar
Miklos Vajna committed
385 386
{
	struct rev_info rev;
387
	struct strbuf out = STRBUF_INIT;
Miklos Vajna's avatar
Miklos Vajna committed
388
	struct commit_list *j;
389
	struct pretty_print_context ctx = {0};
Miklos Vajna's avatar
Miklos Vajna committed
390

391
	printf(_("Squash commit -- not updating HEAD\n"));
Miklos Vajna's avatar
Miklos Vajna committed
392 393 394 395 396 397 398 399 400 401 402 403 404

	init_revisions(&rev, NULL);
	rev.ignore_merges = 1;
	rev.commit_format = CMIT_FMT_MEDIUM;

	commit->object.flags |= UNINTERESTING;
	add_pending_object(&rev, &commit->object, NULL);

	for (j = remoteheads; j; j = j->next)
		add_pending_object(&rev, &j->item->object, NULL);

	setup_revisions(0, NULL, &rev, NULL);
	if (prepare_revision_walk(&rev))
405
		die(_("revision walk setup failed"));
Miklos Vajna's avatar
Miklos Vajna committed
406

407 408
	ctx.abbrev = rev.abbrev;
	ctx.date_mode = rev.date_mode;
409
	ctx.fmt = rev.commit_format;
410

Miklos Vajna's avatar
Miklos Vajna committed
411 412 413 414
	strbuf_addstr(&out, "Squashed commit of the following:\n");
	while ((commit = get_revision(&rev)) != NULL) {
		strbuf_addch(&out, '\n');
		strbuf_addf(&out, "commit %s\n",
415
			oid_to_hex(&commit->object.oid));
416
		pretty_print_commit(&ctx, commit, &out);
Miklos Vajna's avatar
Miklos Vajna committed
417
	}
418
	write_file_buf(git_path_squash_msg(the_repository), out.buf, out.len);
Miklos Vajna's avatar
Miklos Vajna committed
419 420 421
	strbuf_release(&out);
}

422
static void finish(struct commit *head_commit,
423
		   struct commit_list *remoteheads,
424
		   const struct object_id *new_head, const char *msg)
Miklos Vajna's avatar
Miklos Vajna committed
425
{
426
	struct strbuf reflog_message = STRBUF_INIT;
427
	const struct object_id *head = &head_commit->object.oid;
Miklos Vajna's avatar
Miklos Vajna committed
428 429 430 431

	if (!msg)
		strbuf_addstr(&reflog_message, getenv("GIT_REFLOG_ACTION"));
	else {
tuncer's avatar
tuncer committed
432 433
		if (verbosity >= 0)
			printf("%s\n", msg);
Miklos Vajna's avatar
Miklos Vajna committed
434 435 436 437
		strbuf_addf(&reflog_message, "%s: %s",
			getenv("GIT_REFLOG_ACTION"), msg);
	}
	if (squash) {
438
		squash_message(head_commit, remoteheads);
Miklos Vajna's avatar
Miklos Vajna committed
439
	} else {
tuncer's avatar
tuncer committed
440
		if (verbosity >= 0 && !merge_msg.len)
441
			printf(_("No merge message -- not updating HEAD\n"));
Miklos Vajna's avatar
Miklos Vajna committed
442 443
		else {
			const char *argv_gc_auto[] = { "gc", "--auto", NULL };
444 445
			update_ref(reflog_message.buf, "HEAD", new_head, head,
				   0, UPDATE_REFS_DIE_ON_ERR);
Miklos Vajna's avatar
Miklos Vajna committed
446 447 448 449
			/*
			 * We ignore errors in 'gc --auto', since the
			 * user should see them.
			 */
450
			close_all_packs(the_repository->objects);
Miklos Vajna's avatar
Miklos Vajna committed
451 452 453 454 455 456
			run_command_v_opt(argv_gc_auto, RUN_GIT_CMD);
		}
	}
	if (new_head && show_diffstat) {
		struct diff_options opts;
		diff_setup(&opts);
457
		opts.stat_width = -1; /* use full terminal width */
458
		opts.stat_graph_width = -1; /* respect statGraphWidth config */
Miklos Vajna's avatar
Miklos Vajna committed
459 460 461
		opts.output_format |=
			DIFF_FORMAT_SUMMARY | DIFF_FORMAT_DIFFSTAT;
		opts.detect_rename = DIFF_DETECT_RENAME;
Thomas Rast's avatar
Thomas Rast committed
462
		diff_setup_done(&opts);
463
		diff_tree_oid(head, new_head, "", &opts);
Miklos Vajna's avatar
Miklos Vajna committed
464 465 466 467 468
		diffcore_std(&opts);
		diff_flush(&opts);
	}

	/* Run a post-merge hook */
469
	run_hook_le(NULL, "post-merge", squash ? "1" : "0", NULL);
Miklos Vajna's avatar
Miklos Vajna committed
470 471 472 473 474 475 476

	strbuf_release(&reflog_message);
}

/* Get the name for the merge commit's message. */
static void merge_name(const char *remote, struct strbuf *msg)
{
477
	struct commit *remote_head;
478
	struct object_id branch_head;
479
	struct strbuf buf = STRBUF_INIT;
Junio C Hamano's avatar
Junio C Hamano committed
480
	struct strbuf bname = STRBUF_INIT;
481
	struct merge_remote_desc *desc;
Miklos Vajna's avatar
Miklos Vajna committed
482
	const char *ptr;
483
	char *found_ref;
Miklos Vajna's avatar
Miklos Vajna committed
484 485
	int len, early;

486
	strbuf_branchname(&bname, remote, 0);
487
	remote = bname.buf;
Junio C Hamano's avatar
Junio C Hamano committed
488

489
	oidclr(&branch_head);
490
	remote_head = get_merge_parent(remote);
Miklos Vajna's avatar
Miklos Vajna committed
491
	if (!remote_head)
492
		die(_("'%s' does not point to a commit"), remote);
Miklos Vajna's avatar
Miklos Vajna committed
493

494
	if (dwim_ref(remote, strlen(remote), &branch_head, &found_ref) > 0) {
495
		if (starts_with(found_ref, "refs/heads/")) {
496
			strbuf_addf(msg, "%s\t\tbranch '%s' of .\n",
497
				    oid_to_hex(&branch_head), remote);
498 499
			goto cleanup;
		}
500
		if (starts_with(found_ref, "refs/tags/")) {
501
			strbuf_addf(msg, "%s\t\ttag '%s' of .\n",
502
				    oid_to_hex(&branch_head), remote);
503 504
			goto cleanup;
		}
505
		if (starts_with(found_ref, "refs/remotes/")) {
506
			strbuf_addf(msg, "%s\t\tremote-tracking branch '%s' of .\n",
507
				    oid_to_hex(&branch_head), remote);
508 509
			goto cleanup;
		}
Miklos Vajna's avatar
Miklos Vajna committed
510 511 512 513 514 515 516 517 518 519 520 521 522 523 524 525 526 527 528 529 530 531 532 533 534 535 536 537 538 539
	}

	/* See if remote matches <name>^^^.. or <name>~<number> */
	for (len = 0, ptr = remote + strlen(remote);
	     remote < ptr && ptr[-1] == '^';
	     ptr--)
		len++;
	if (len)
		early = 1;
	else {
		early = 0;
		ptr = strrchr(remote, '~');
		if (ptr) {
			int seen_nonzero = 0;

			len++; /* count ~ */
			while (*++ptr && isdigit(*ptr)) {
				seen_nonzero |= (*ptr != '0');
				len++;
			}
			if (*ptr)
				len = 0; /* not ...~<number> */
			else if (seen_nonzero)
				early = 1;
			else if (len == 1)
				early = 1; /* "name~" is "name~1"! */
		}
	}
	if (len) {
		struct strbuf truname = STRBUF_INIT;
540
		strbuf_addf(&truname, "refs/heads/%s", remote);
541
		strbuf_setlen(&truname, truname.len - len);
542
		if (ref_exists(truname.buf)) {
Miklos Vajna's avatar
Miklos Vajna committed
543 544
			strbuf_addf(msg,
				    "%s\t\tbranch '%s'%s of .\n",
545
				    oid_to_hex(&remote_head->object.oid),
546
				    truname.buf + 11,
Miklos Vajna's avatar
Miklos Vajna committed
547
				    (early ? " (early part)" : ""));
Junio C Hamano's avatar
Junio C Hamano committed
548 549
			strbuf_release(&truname);
			goto cleanup;
Miklos Vajna's avatar
Miklos Vajna committed
550
		}
551
		strbuf_release(&truname);
Miklos Vajna's avatar
Miklos Vajna committed
552
	}
553

554 555 556 557 558 559 560
	desc = merge_remote_util(remote_head);
	if (desc && desc->obj && desc->obj->type == OBJ_TAG) {
		strbuf_addf(msg, "%s\t\t%s '%s'\n",
			    oid_to_hex(&desc->obj->oid),
			    type_name(desc->obj->type),
			    remote);
		goto cleanup;
561 562
	}

Miklos Vajna's avatar
Miklos Vajna committed
563
	strbuf_addf(msg, "%s\t\tcommit '%s'\n",
564
		oid_to_hex(&remote_head->object.oid), remote);
Junio C Hamano's avatar
Junio C Hamano committed
565 566 567
cleanup:
	strbuf_release(&buf);
	strbuf_release(&bname);
Miklos Vajna's avatar
Miklos Vajna committed
568 569
}

570 571 572 573 574 575 576 577 578
static void parse_branch_merge_options(char *bmo)
{
	const char **argv;
	int argc;

	if (!bmo)
		return;
	argc = split_cmdline(bmo, &argv);
	if (argc < 0)
579 580
		die(_("Bad branch.%s.mergeoptions string: %s"), branch,
		    split_cmdline_strerror(argc));
581
	REALLOC_ARRAY(argv, argc + 2);
René Scharfe's avatar
René Scharfe committed
582
	MOVE_ARRAY(argv + 1, argv, argc + 1);
583 584 585 586 587 588 589
	argc++;
	argv[0] = "branch.*.mergeoptions";
	parse_options(argc, argv, NULL, builtin_merge_options,
		      builtin_merge_usage, 0);
	free(argv);
}

590
static int git_merge_config(const char *k, const char *v, void *cb)
Miklos Vajna's avatar
Miklos Vajna committed
591
{
592 593
	int status;

594 595
	if (branch && starts_with(k, "branch.") &&
		starts_with(k + 7, branch) &&
Miklos Vajna's avatar
Miklos Vajna committed
596
		!strcmp(k + 7 + strlen(branch), ".mergeoptions")) {
597 598 599
		free(branch_mergeoptions);
		branch_mergeoptions = xstrdup(v);
		return 0;
Miklos Vajna's avatar
Miklos Vajna committed
600 601 602 603
	}

	if (!strcmp(k, "merge.diffstat") || !strcmp(k, "merge.stat"))
		show_diffstat = git_config_bool(k, v);
604 605
	else if (!strcmp(k, "merge.verifysignatures"))
		verify_signatures = git_config_bool(k, v);
Miklos Vajna's avatar
Miklos Vajna committed
606 607 608 609
	else if (!strcmp(k, "pull.twohead"))
		return git_config_string(&pull_twohead, k, v);
	else if (!strcmp(k, "pull.octopus"))
		return git_config_string(&pull_octopus, k, v);
610 611
	else if (!strcmp(k, "merge.renormalize"))
		option_renormalize = git_config_bool(k, v);
612
	else if (!strcmp(k, "merge.ff")) {
613
		int boolval = git_parse_maybe_bool(v);
614
		if (0 <= boolval) {
615
			fast_forward = boolval ? FF_ALLOW : FF_NO;
616
		} else if (v && !strcmp(v, "only")) {
617
			fast_forward = FF_ONLY;
618 619
		} /* do not barf on values from future versions of git */
		return 0;
620 621 622
	} else if (!strcmp(k, "merge.defaulttoupstream")) {
		default_to_upstream = git_config_bool(k, v);
		return 0;
623 624 625
	} else if (!strcmp(k, "commit.gpgsign")) {
		sign_commit = git_config_bool(k, v) ? "" : NULL;
		return 0;
626
	}
627

628
	status = fmt_merge_msg_config(k, v, cb);
Junio C Hamano's avatar
Junio C Hamano committed
629 630
	if (status)
		return status;
631
	status = git_gpg_config(k, v, NULL);
632 633
	if (status)
		return status;
Miklos Vajna's avatar
Miklos Vajna committed
634 635 636
	return git_diff_ui_config(k, v, cb);
}

637 638
static int read_tree_trivial(struct object_id *common, struct object_id *head,
			     struct object_id *one)
Miklos Vajna's avatar
Miklos Vajna committed
639 640 641 642 643 644 645 646 647 648 649 650 651 652
{
	int i, nr_trees = 0;
	struct tree *trees[MAX_UNPACK_TREES];
	struct tree_desc t[MAX_UNPACK_TREES];
	struct unpack_trees_options opts;

	memset(&opts, 0, sizeof(opts));
	opts.head_idx = 2;
	opts.src_index = &the_index;
	opts.dst_index = &the_index;
	opts.update = 1;
	opts.verbose_update = 1;
	opts.trivial_merges_only = 1;
	opts.merge = 1;
653
	trees[nr_trees] = parse_tree_indirect(common);
Miklos Vajna's avatar
Miklos Vajna committed
654 655
	if (!trees[nr_trees++])
		return -1;
656
	trees[nr_trees] = parse_tree_indirect(head);
Miklos Vajna's avatar
Miklos Vajna committed
657 658
	if (!trees[nr_trees++])
		return -1;
659
	trees[nr_trees] = parse_tree_indirect(one);
Miklos Vajna's avatar
Miklos Vajna committed
660 661 662 663 664 665 666 667 668 669 670 671 672
	if (!trees[nr_trees++])
		return -1;
	opts.fn = threeway_merge;
	cache_tree_free(&active_cache_tree);
	for (i = 0; i < nr_trees; i++) {
		parse_tree(trees[i]);
		init_tree_desc(t+i, trees[i]->buffer, trees[i]->size);
	}
	if (unpack_trees(nr_trees, t, &opts))
		return -1;
	return 0;
}

673
static void write_tree_trivial(struct object_id *oid)
Miklos Vajna's avatar
Miklos Vajna committed
674
{
675
	if (write_cache_as_tree(oid, 0, NULL))
676
		die(_("git write-tree failed to write a tree"));
Miklos Vajna's avatar
Miklos Vajna committed
677 678
}

679
static int try_merge_strategy(const char *strategy, struct commit_list *common,
680
			      struct commit_list *remoteheads,
681
			      struct commit *head)
682
{
683
	struct lock_file lock = LOCK_INIT;
684
	const char *head_arg = "HEAD";
685

686
	hold_locked_index(&lock, LOCK_DIE_ON_ERROR);
687
	refresh_cache(REFRESH_QUIET);
688 689
	if (write_locked_index(&the_index, &lock,
			       COMMIT_LOCK | SKIP_IF_UNCHANGED))
690
		return error(_("Unable to write index."));
Miklos Vajna's avatar
Miklos Vajna committed
691

692
	if (!strcmp(strategy, "recursive") || !strcmp(strategy, "subtree")) {
693
		int clean, x;
694 695 696
		struct commit *result;
		struct commit_list *reversed = NULL;
		struct merge_options o;
697
		struct commit_list *j;
698 699

		if (remoteheads->next) {
700
			error(_("Not handling anything other than two heads merge."));
701 702 703 704 705
			return 2;
		}

		init_merge_options(&o);
		if (!strcmp(strategy, "subtree"))
706
			o.subtree_shift = "";
Avery Pennarun's avatar
Avery Pennarun committed
707

708
		o.renormalize = option_renormalize;
709 710
		o.show_rename_progress =
			show_progress == -1 ? isatty(2) : show_progress;
711

712 713
		for (x = 0; x < xopts_nr; x++)
			if (parse_merge_opt(&o, xopts[x]))
714
				die(_("Unknown option for merge-recursive: -X%s"), xopts[x]);
715 716

		o.branch1 = head_arg;
717
		o.branch2 = merge_remote_util(remoteheads->item)->name;
718 719 720 721

		for (j = common; j; j = j->next)
			commit_list_insert(j->item, &reversed);

722
		hold_locked_index(&lock, LOCK_DIE_ON_ERROR);
723
		clean = merge_recursive(&o, head,
724
				remoteheads->item, reversed, &result);
725 726
		if (clean < 0)
			exit(128);
727 728
		if (write_locked_index(&the_index, &lock,
				       COMMIT_LOCK | SKIP_IF_UNCHANGED))
729
			die(_("unable to write %s"), get_index_file());
730 731
		return clean ? 0 : 1;
	} else {
732 733
		return try_merge_command(strategy, xopts_nr, xopts,
						common, head_arg, remoteheads);
734
	}
Miklos Vajna's avatar
Miklos Vajna committed
735 736 737 738 739 740 741 742 743 744 745 746 747 748
}

static void count_diff_files(struct diff_queue_struct *q,
			     struct diff_options *opt, void *data)
{
	int *count = data;

	(*count) += q->nr;
}

static int count_unmerged_entries(void)
{
	int i, ret = 0;

749 750
	for (i = 0; i < active_nr; i++)
		if (ce_stage(active_cache[i]))
Miklos Vajna's avatar
Miklos Vajna committed
751 752 753 754 755 756 757
			ret++;

	return ret;
}

static void add_strategies(const char *string, unsigned attr)
{
758 759 760 761 762 763 764 765 766
	int i;

	if (string) {
		struct string_list list = STRING_LIST_INIT_DUP;
		struct string_list_item *item;
		string_list_split(&list, string, ' ', -1);
		for_each_string_list_item(item, &list)
			append_strategy(get_strategy(item->string));
		string_list_clear(&list, 0);
Miklos Vajna's avatar
Miklos Vajna committed
767 768 769 770 771 772 773 774
		return;
	}
	for (i = 0; i < ARRAY_SIZE(all_strategy); i++)
		if (all_strategy[i].attr & attr)
			append_strategy(&all_strategy[i]);

}

775
static void read_merge_msg(struct strbuf *msg)
776
{
777
	const char *filename = git_path_merge_msg(the_repository);
778
	strbuf_reset(msg);
779 780
	if (strbuf_read_file(msg, filename, 0) < 0)
		die_errno(_("Could not read from '%s'"), filename);
781 782
}

783 784
static void write_merge_state(struct commit_list *);
static void abort_commit(struct commit_list *remoteheads, const char *err_msg)
785
{
786 787 788 789
	if (err_msg)
		error("%s", err_msg);
	fprintf(stderr,
		_("Not committing merge; use 'git commit' to complete the merge.\n"));
790
	write_merge_state(remoteheads);
791 792 793
	exit(1);
}

794 795 796 797
static const char merge_editor_comment[] =
N_("Please enter a commit message to explain why this merge is necessary,\n"
   "especially if it merges an updated upstream into a topic branch.\n"
   "\n"
Junio C Hamano's avatar
Junio C Hamano committed
798
   "Lines starting with '%c' will be ignored, and an empty message aborts\n"
799 800
   "the commit.\n");

801
static void write_merge_heads(struct commit_list *);
802
static void prepare_to_commit(struct commit_list *remoteheads)
803 804 805 806
{
	struct strbuf msg = STRBUF_INIT;
	strbuf_addbuf(&msg, &merge_msg);
	strbuf_addch(&msg, '\n');
Michael J Gruber's avatar
Michael J Gruber committed
807 808
	if (squash)
		BUG("the control must not reach here under --squash");
809
	if (0 < option_edit)
Junio C Hamano's avatar
Junio C Hamano committed
810
		strbuf_commented_addf(&msg, _(merge_editor_comment), comment_line_char);
811 812
	if (signoff)
		append_signoff(&msg, ignore_non_trailer(msg.buf, msg.len), 0);
813
	write_merge_heads(remoteheads);
814
	write_file_buf(git_path_merge_msg(the_repository), msg.buf, msg.len);
815
	if (run_commit_hook(0 < option_edit, get_index_file(), "prepare-commit-msg",
816
			    git_path_merge_msg(the_repository), "merge", NULL))
817
		abort_commit(remoteheads, NULL);
818
	if (0 < option_edit) {
819
		if (launch_editor(git_path_merge_msg(the_repository), NULL, NULL))
820
			abort_commit(remoteheads, NULL);
821
	}
822 823 824

	if (verify_msg && run_commit_hook(0 < option_edit, get_index_file(),
					  "commit-msg",
825
					  git_path_merge_msg(the_repository), NULL))
826 827
		abort_commit(remoteheads, NULL);

828
	read_merge_msg(&msg);
829
	strbuf_stripspace(&msg, 0 < option_edit);
830
	if (!msg.len)
831
		abort_commit(remoteheads, _("Empty commit message."));
832 833 834
	strbuf_release(&merge_msg);
	strbuf_addbuf(&merge_msg, &msg);
	strbuf_release(&msg);
835 836
}

837
static int merge_trivial(struct commit *head, struct commit_list *remoteheads)
Miklos Vajna's avatar
Miklos Vajna committed
838
{
839
	struct object_id result_tree, result_commit;
840
	struct commit_list *parents, **pptr = &parents;
841
	struct lock_file lock = LOCK_INIT;
842

843
	hold_locked_index(&lock, LOCK_DIE_ON_ERROR);
844
	refresh_cache(REFRESH_QUIET);
845 846
	if (write_locked_index(&the_index, &lock,
			       COMMIT_LOCK | SKIP_IF_UNCHANGED))
847
		return error(_("Unable to write index."));
Miklos Vajna's avatar
Miklos Vajna committed
848

849
	write_tree_trivial(&result_tree);
850
	printf(_("Wonderful.\n"));
851 852
	pptr = commit_list_append(head, pptr);
	pptr = commit_list_append(remoteheads->item, pptr);
853
	prepare_to_commit(remoteheads);
854 855
	if (commit_tree(merge_msg.buf, merge_msg.len, &result_tree, parents,
			&result_commit, NULL, sign_commit))
Duy Nguyen's avatar
Duy Nguyen committed
856
		die(_("failed to write commit object"));
857
	finish(head, remoteheads, &result_commit, "In-index merge");
Miklos Vajna's avatar
Miklos Vajna committed
858 859 860 861
	drop_save();
	return 0;
}

862
static int finish_automerge(struct commit *head,
863
			    int head_subsumed,
864
			    struct commit_list *common,
865
			    struct commit_list *remoteheads,
866
			    struct object_id *result_tree,
Miklos Vajna's avatar
Miklos Vajna committed
867 868
			    const char *wt_strategy)
{
869
	struct commit_list *parents = NULL;
Miklos Vajna's avatar
Miklos Vajna committed
870
	struct strbuf buf = STRBUF_INIT;
871
	struct object_id result_commit;
Miklos Vajna's avatar
Miklos Vajna committed
872 873

	free_commit_list(common);
874
	parents = remoteheads;
875
	if (!head_subsumed || fast_forward == FF_NO)
876
		commit_list_insert(head, &parents);
Miklos Vajna's avatar
Miklos Vajna committed
877
	strbuf_addch(&merge_msg, '\n');
878
	prepare_to_commit(remoteheads);
879 880
	if (commit_tree(merge_msg.buf, merge_msg.len, result_tree, parents,
			&result_commit, NULL, sign_commit))
Duy Nguyen's avatar
Duy Nguyen committed
881
		die(_("failed to write commit object"));
882
	strbuf_addf(&buf, "Merge made by the '%s' strategy.", wt_strategy);
883
	finish(head, remoteheads, &result_commit, buf.buf);
Miklos Vajna's avatar
Miklos Vajna committed
884 885 886 887 888
	strbuf_release(&buf);
	drop_save();
	return 0;
}

889
static int suggest_conflicts(void)
Miklos Vajna's avatar
Miklos Vajna committed
890
{
891
	const char *filename;
Miklos Vajna's avatar
Miklos Vajna committed
892
	FILE *fp;
893
	struct strbuf msgbuf = STRBUF_INIT;
Miklos Vajna's avatar
Miklos Vajna committed
894

895
	filename = git_path_merge_msg(the_repository);
Duy Nguyen's avatar
Duy Nguyen committed
896
	fp = xfopen(filename, "a");
897 898 899

	append_conflicts_hint(&msgbuf);
	fputs(msgbuf.buf, fp);
900
	strbuf_release(&msgbuf);
Miklos Vajna's avatar
Miklos Vajna committed
901
	fclose(fp);
902
	rerere(allow_rerere_auto);
903 904
	printf(_("Automatic merge failed; "
			"fix conflicts and then commit the result.\n"));
Miklos Vajna's avatar
Miklos Vajna committed
905 906 907 908 909 910 911 912 913 914 915 916 917 918 919 920 921 922 923 924 925 926 927 928 929 930
	return 1;
}

static int evaluate_result(void)
{
	int cnt = 0;
	struct rev_info rev;

	/* Check how many files differ. */
	init_revisions(&rev, "");
	setup_revisions(0, NULL, &rev, NULL);
	rev.diffopt.output_format |=
		DIFF_FORMAT_CALLBACK;
	rev.diffopt.format_callback = count_diff_files;
	rev.diffopt.format_callback_data = &cnt;
	run_diff_files(&rev, 0);

	/*
	 * Check how many unmerged entries are
	 * there.
	 */
	cnt += count_unmerged_entries();

	return cnt;
}

931
/*
932
 * Pretend as if the user told us to merge with the remote-tracking
933 934 935 936 937 938 939 940 941
 * branch we have for the upstream of the current branch
 */
static int setup_with_upstream(const char ***argv)
{
	struct branch *branch = branch_get(NULL);
	int i;
	const char **args;

	if (!branch)
942
		die(_("No current branch."));
943
	if (!branch->remote_name)
944
		die(_("No remote for the current branch."));
945
	if (!branch->merge_nr)
946
		die(_("No default upstream defined for the current branch."));
947

948
	args = xcalloc(st_add(branch->merge_nr, 1), sizeof(char *));
949 950
	for (i = 0; i < branch->merge_nr; i++) {
		if (!branch->merge[i]->dst)
951
			die(_("No remote-tracking branch for %s from %s"),
952 953 954 955 956 957 958 959
			    branch->merge[i]->src, branch->remote_name);
		args[i] = branch->merge[i]->dst;
	}
	args[i] = NULL;
	*argv = args;
	return i;
}

960
static void write_merge_heads(struct commit_list *remoteheads)
961 962 963 964
{
	struct commit_list *j;
	struct strbuf buf = STRBUF_INIT;

965
	for (j = remoteheads; j; j = j->next) {