4 * Copyright (c) 2008 Miklos Vajna <vmiklos@frugalware.org>
6 * Based on git-merge.sh by Junio C Hamano.
11 #include "parse-options.h"
14 #include "run-command.h"
21 #include "unpack-trees.h"
22 #include "cache-tree.h"
29 #include "merge-recursive.h"
30 #include "resolve-undo.h"
32 #include "fmt-merge-msg.h"
33 #include "gpg-interface.h"
34 #include "sequencer.h"
35 #include "string-list.h"
39 #include "commit-reach.h"
41 #define DEFAULT_TWOHEAD (1<<0)
42 #define DEFAULT_OCTOPUS (1<<1)
43 #define NO_FAST_FORWARD (1<<2)
44 #define NO_TRIVIAL (1<<3)
51 static const char * const builtin_merge_usage
[] = {
52 N_("git merge [<options>] [<commit>...]"),
53 N_("git merge --abort"),
54 N_("git merge --continue"),
58 static int show_diffstat
= 1, shortlog_len
= -1, squash
;
59 static int option_commit
= 1;
60 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
;
64 static struct strategy
**use_strategies
;
65 static size_t use_strategies_nr
, use_strategies_alloc
;
66 static const char **xopts
;
67 static size_t xopts_nr
, xopts_alloc
;
68 static const char *branch
;
69 static char *branch_mergeoptions
;
70 static int option_renormalize
;
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;
79 static const char *sign_commit
;
80 static int verify_msg
= 1;
82 static struct strategy all_strategy
[] = {
83 { "recursive", DEFAULT_TWOHEAD
| NO_TRIVIAL
},
84 { "octopus", DEFAULT_OCTOPUS
},
86 { "ours", NO_FAST_FORWARD
| NO_TRIVIAL
},
87 { "subtree", NO_FAST_FORWARD
| NO_TRIVIAL
},
90 static const char *pull_twohead
, *pull_octopus
;
98 static enum ff_type fast_forward
= FF_ALLOW
;
100 static int option_parse_message(const struct option
*opt
,
101 const char *arg
, int unset
)
103 struct strbuf
*buf
= opt
->value
;
106 strbuf_setlen(buf
, 0);
108 strbuf_addf(buf
, "%s%s", buf
->len
? "\n\n" : "", arg
);
111 return error(_("switch `m' requires a value"));
115 static int option_read_message(struct parse_opt_ctx_t
*ctx
,
116 const struct option
*opt
, int unset
)
118 struct strbuf
*buf
= opt
->value
;
122 BUG("-F cannot be negated");
127 } else if (ctx
->argc
> 1) {
131 return opterror(opt
, "requires a value", 0);
134 strbuf_addch(buf
, '\n');
135 if (ctx
->prefix
&& !is_absolute_path(arg
))
136 arg
= prefix_filename(ctx
->prefix
, arg
);
137 if (strbuf_read_file(buf
, arg
, 0) < 0)
138 return error(_("could not read file '%s'"), arg
);
144 static struct strategy
*get_strategy(const char *name
)
147 struct strategy
*ret
;
148 static struct cmdnames main_cmds
, other_cmds
;
154 for (i
= 0; i
< ARRAY_SIZE(all_strategy
); i
++)
155 if (!strcmp(name
, all_strategy
[i
].name
))
156 return &all_strategy
[i
];
159 struct cmdnames not_strategies
;
162 memset(¬_strategies
, 0, sizeof(struct cmdnames
));
163 load_command_list("git-merge-", &main_cmds
, &other_cmds
);
164 for (i
= 0; i
< main_cmds
.cnt
; i
++) {
166 struct cmdname
*ent
= main_cmds
.names
[i
];
167 for (j
= 0; j
< ARRAY_SIZE(all_strategy
); j
++)
168 if (!strncmp(ent
->name
, all_strategy
[j
].name
, ent
->len
)
169 && !all_strategy
[j
].name
[ent
->len
])
172 add_cmdname(¬_strategies
, ent
->name
, ent
->len
);
174 exclude_cmds(&main_cmds
, ¬_strategies
);
176 if (!is_in_cmdlist(&main_cmds
, name
) && !is_in_cmdlist(&other_cmds
, name
)) {
177 fprintf(stderr
, _("Could not find merge strategy '%s'.\n"), name
);
178 fprintf(stderr
, _("Available strategies are:"));
179 for (i
= 0; i
< main_cmds
.cnt
; i
++)
180 fprintf(stderr
, " %s", main_cmds
.names
[i
]->name
);
181 fprintf(stderr
, ".\n");
182 if (other_cmds
.cnt
) {
183 fprintf(stderr
, _("Available custom strategies are:"));
184 for (i
= 0; i
< other_cmds
.cnt
; i
++)
185 fprintf(stderr
, " %s", other_cmds
.names
[i
]->name
);
186 fprintf(stderr
, ".\n");
191 ret
= xcalloc(1, sizeof(struct strategy
));
192 ret
->name
= xstrdup(name
);
193 ret
->attr
= NO_TRIVIAL
;
197 static void append_strategy(struct strategy
*s
)
199 ALLOC_GROW(use_strategies
, use_strategies_nr
+ 1, use_strategies_alloc
);
200 use_strategies
[use_strategies_nr
++] = s
;
203 static int option_parse_strategy(const struct option
*opt
,
204 const char *name
, int unset
)
209 append_strategy(get_strategy(name
));
213 static int option_parse_x(const struct option
*opt
,
214 const char *arg
, int unset
)
219 ALLOC_GROW(xopts
, xopts_nr
+ 1, xopts_alloc
);
220 xopts
[xopts_nr
++] = xstrdup(arg
);
224 static int option_parse_n(const struct option
*opt
,
225 const char *arg
, int unset
)
227 show_diffstat
= unset
;
231 static struct option builtin_merge_options
[] = {
232 { OPTION_CALLBACK
, 'n', NULL
, NULL
, NULL
,
233 N_("do not show a diffstat at the end of the merge"),
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 { OPTION_INTEGER
, 0, "log", &shortlog_len
, N_("n"),
239 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 OPT_SET_INT_F(0, "ff-only", &fast_forward
,
249 N_("abort if fast-forward is not possible"),
250 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 OPT_CALLBACK('s', "strategy", &use_strategies
, N_("strategy"),
255 N_("merge strategy to use"), option_parse_strategy
),
256 OPT_CALLBACK('X', "strategy-option", &xopts
, N_("option=value"),
257 N_("option for selected merge strategy"), option_parse_x
),
258 OPT_CALLBACK('m', "message", &merge_msg
, N_("message"),
259 N_("merge commit message (for a non-fast-forward merge)"),
260 option_parse_message
),
261 { OPTION_LOWLEVEL_CALLBACK
, 'F', "file", &merge_msg
, N_("path"),
262 N_("read message from file"), PARSE_OPT_NONEG
,
263 (parse_opt_cb
*) option_read_message
},
264 OPT__VERBOSITY(&verbosity
),
265 OPT_BOOL(0, "abort", &abort_current_merge
,
266 N_("abort the current in-progress merge")),
267 OPT_BOOL(0, "continue", &continue_current_merge
,
268 N_("continue the current in-progress merge")),
269 OPT_BOOL(0, "allow-unrelated-histories", &allow_unrelated_histories
,
270 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")),
280 /* Cleans up metadata that is uninteresting after a succeeded merge. */
281 static void drop_save(void)
283 unlink(git_path_merge_head(the_repository
));
284 unlink(git_path_merge_msg(the_repository
));
285 unlink(git_path_merge_mode(the_repository
));
288 static int save_state(struct object_id
*stash
)
291 struct child_process cp
= CHILD_PROCESS_INIT
;
292 struct strbuf buffer
= STRBUF_INIT
;
293 const char *argv
[] = {"stash", "create", NULL
};
300 if (start_command(&cp
))
301 die(_("could not run stash."));
302 len
= strbuf_read(&buffer
, cp
.out
, 1024);
305 if (finish_command(&cp
) || len
< 0)
306 die(_("stash failed"));
307 else if (!len
) /* no changes */
309 strbuf_setlen(&buffer
, buffer
.len
-1);
310 if (get_oid(buffer
.buf
, stash
))
311 die(_("not a valid object: %s"), buffer
.buf
);
314 strbuf_release(&buffer
);
318 static void read_empty(const struct object_id
*oid
, int verbose
)
323 args
[i
++] = "read-tree";
328 args
[i
++] = empty_tree_oid_hex();
329 args
[i
++] = oid_to_hex(oid
);
332 if (run_command_v_opt(args
, RUN_GIT_CMD
))
333 die(_("read-tree failed"));
336 static void reset_hard(const struct object_id
*oid
, int verbose
)
341 args
[i
++] = "read-tree";
344 args
[i
++] = "--reset";
346 args
[i
++] = oid_to_hex(oid
);
349 if (run_command_v_opt(args
, RUN_GIT_CMD
))
350 die(_("read-tree failed"));
353 static void restore_state(const struct object_id
*head
,
354 const struct object_id
*stash
)
356 struct strbuf sb
= STRBUF_INIT
;
357 const char *args
[] = { "stash", "apply", NULL
, NULL
};
359 if (is_null_oid(stash
))
364 args
[2] = oid_to_hex(stash
);
367 * It is OK to ignore error here, for example when there was
368 * nothing to restore.
370 run_command_v_opt(args
, RUN_GIT_CMD
);
373 refresh_cache(REFRESH_QUIET
);
376 /* This is called when no merge was necessary. */
377 static void finish_up_to_date(const char *msg
)
380 printf("%s%s\n", squash
? _(" (nothing to squash)") : "", msg
);
384 static void squash_message(struct commit
*commit
, struct commit_list
*remoteheads
)
387 struct strbuf out
= STRBUF_INIT
;
388 struct commit_list
*j
;
389 struct pretty_print_context ctx
= {0};
391 printf(_("Squash commit -- not updating HEAD\n"));
393 repo_init_revisions(the_repository
, &rev
, NULL
);
394 rev
.ignore_merges
= 1;
395 rev
.commit_format
= CMIT_FMT_MEDIUM
;
397 commit
->object
.flags
|= UNINTERESTING
;
398 add_pending_object(&rev
, &commit
->object
, NULL
);
400 for (j
= remoteheads
; j
; j
= j
->next
)
401 add_pending_object(&rev
, &j
->item
->object
, NULL
);
403 setup_revisions(0, NULL
, &rev
, NULL
);
404 if (prepare_revision_walk(&rev
))
405 die(_("revision walk setup failed"));
407 ctx
.abbrev
= rev
.abbrev
;
408 ctx
.date_mode
= rev
.date_mode
;
409 ctx
.fmt
= rev
.commit_format
;
411 strbuf_addstr(&out
, "Squashed commit of the following:\n");
412 while ((commit
= get_revision(&rev
)) != NULL
) {
413 strbuf_addch(&out
, '\n');
414 strbuf_addf(&out
, "commit %s\n",
415 oid_to_hex(&commit
->object
.oid
));
416 pretty_print_commit(&ctx
, commit
, &out
);
418 write_file_buf(git_path_squash_msg(the_repository
), out
.buf
, out
.len
);
419 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
)
426 struct strbuf reflog_message
= STRBUF_INIT
;
427 const struct object_id
*head
= &head_commit
->object
.oid
;
430 strbuf_addstr(&reflog_message
, getenv("GIT_REFLOG_ACTION"));
434 strbuf_addf(&reflog_message
, "%s: %s",
435 getenv("GIT_REFLOG_ACTION"), msg
);
438 squash_message(head_commit
, remoteheads
);
440 if (verbosity
>= 0 && !merge_msg
.len
)
441 printf(_("No merge message -- not updating HEAD\n"));
443 const char *argv_gc_auto
[] = { "gc", "--auto", NULL
};
444 update_ref(reflog_message
.buf
, "HEAD", new_head
, head
,
445 0, UPDATE_REFS_DIE_ON_ERR
);
447 * We ignore errors in 'gc --auto', since the
448 * user should see them.
450 close_all_packs(the_repository
->objects
);
451 run_command_v_opt(argv_gc_auto
, RUN_GIT_CMD
);
454 if (new_head
&& show_diffstat
) {
455 struct diff_options opts
;
456 repo_diff_setup(the_repository
, &opts
);
457 opts
.stat_width
= -1; /* use full terminal width */
458 opts
.stat_graph_width
= -1; /* respect statGraphWidth config */
459 opts
.output_format
|=
460 DIFF_FORMAT_SUMMARY
| DIFF_FORMAT_DIFFSTAT
;
461 opts
.detect_rename
= DIFF_DETECT_RENAME
;
462 diff_setup_done(&opts
);
463 diff_tree_oid(head
, new_head
, "", &opts
);
468 /* Run a post-merge hook */
469 run_hook_le(NULL
, "post-merge", squash
? "1" : "0", NULL
);
471 strbuf_release(&reflog_message
);
474 /* Get the name for the merge commit's message. */
475 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
;
480 struct strbuf bname
= STRBUF_INIT
;
481 struct merge_remote_desc
*desc
;
486 strbuf_branchname(&bname
, remote
, 0);
489 oidclr(&branch_head
);
490 remote_head
= get_merge_parent(remote
);
492 die(_("'%s' does not point to a commit"), remote
);
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
);
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
);
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
);
512 /* See if remote matches <name>^^^.. or <name>~<number> */
513 for (len
= 0, ptr
= remote
+ strlen(remote
);
514 remote
< ptr
&& ptr
[-1] == '^';
521 ptr
= strrchr(remote
, '~');
523 int seen_nonzero
= 0;
526 while (*++ptr
&& isdigit(*ptr
)) {
527 seen_nonzero
|= (*ptr
!= '0');
531 len
= 0; /* not ...~<number> */
532 else if (seen_nonzero
)
535 early
= 1; /* "name~" is "name~1"! */
539 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
)) {
544 "%s\t\tbranch '%s'%s of .\n",
545 oid_to_hex(&remote_head
->object
.oid
),
547 (early
? " (early part)" : ""));
548 strbuf_release(&truname
);
551 strbuf_release(&truname
);
554 desc
= merge_remote_util(remote_head
);
555 if (desc
&& desc
->obj
&& desc
->obj
->type
== OBJ_TAG
) {
556 strbuf_addf(msg
, "%s\t\t%s '%s'\n",
557 oid_to_hex(&desc
->obj
->oid
),
558 type_name(desc
->obj
->type
),
563 strbuf_addf(msg
, "%s\t\tcommit '%s'\n",
564 oid_to_hex(&remote_head
->object
.oid
), remote
);
566 strbuf_release(&buf
);
567 strbuf_release(&bname
);
570 static void parse_branch_merge_options(char *bmo
)
577 argc
= split_cmdline(bmo
, &argv
);
579 die(_("Bad branch.%s.mergeoptions string: %s"), branch
,
580 split_cmdline_strerror(argc
));
581 REALLOC_ARRAY(argv
, argc
+ 2);
582 MOVE_ARRAY(argv
+ 1, argv
, argc
+ 1);
584 argv
[0] = "branch.*.mergeoptions";
585 parse_options(argc
, argv
, NULL
, builtin_merge_options
,
586 builtin_merge_usage
, 0);
590 static int git_merge_config(const char *k
, const char *v
, void *cb
)
594 if (branch
&& starts_with(k
, "branch.") &&
595 starts_with(k
+ 7, branch
) &&
596 !strcmp(k
+ 7 + strlen(branch
), ".mergeoptions")) {
597 free(branch_mergeoptions
);
598 branch_mergeoptions
= xstrdup(v
);
602 if (!strcmp(k
, "merge.diffstat") || !strcmp(k
, "merge.stat"))
603 show_diffstat
= git_config_bool(k
, v
);
604 else if (!strcmp(k
, "merge.verifysignatures"))
605 verify_signatures
= git_config_bool(k
, v
);
606 else if (!strcmp(k
, "pull.twohead"))
607 return git_config_string(&pull_twohead
, k
, v
);
608 else if (!strcmp(k
, "pull.octopus"))
609 return git_config_string(&pull_octopus
, k
, v
);
610 else if (!strcmp(k
, "merge.renormalize"))
611 option_renormalize
= git_config_bool(k
, v
);
612 else if (!strcmp(k
, "merge.ff")) {
613 int boolval
= git_parse_maybe_bool(v
);
615 fast_forward
= boolval
? FF_ALLOW
: FF_NO
;
616 } else if (v
&& !strcmp(v
, "only")) {
617 fast_forward
= FF_ONLY
;
618 } /* do not barf on values from future versions of git */
620 } else if (!strcmp(k
, "merge.defaulttoupstream")) {
621 default_to_upstream
= git_config_bool(k
, v
);
623 } else if (!strcmp(k
, "commit.gpgsign")) {
624 sign_commit
= git_config_bool(k
, v
) ? "" : NULL
;
628 status
= fmt_merge_msg_config(k
, v
, cb
);
631 status
= git_gpg_config(k
, v
, NULL
);
634 return git_diff_ui_config(k
, v
, cb
);
637 static int read_tree_trivial(struct object_id
*common
, struct object_id
*head
,
638 struct object_id
*one
)
641 struct tree
*trees
[MAX_UNPACK_TREES
];
642 struct tree_desc t
[MAX_UNPACK_TREES
];
643 struct unpack_trees_options opts
;
645 memset(&opts
, 0, sizeof(opts
));
647 opts
.src_index
= &the_index
;
648 opts
.dst_index
= &the_index
;
650 opts
.verbose_update
= 1;
651 opts
.trivial_merges_only
= 1;
653 trees
[nr_trees
] = parse_tree_indirect(common
);
654 if (!trees
[nr_trees
++])
656 trees
[nr_trees
] = parse_tree_indirect(head
);
657 if (!trees
[nr_trees
++])
659 trees
[nr_trees
] = parse_tree_indirect(one
);
660 if (!trees
[nr_trees
++])
662 opts
.fn
= threeway_merge
;
663 cache_tree_free(&active_cache_tree
);
664 for (i
= 0; i
< nr_trees
; i
++) {
665 parse_tree(trees
[i
]);
666 init_tree_desc(t
+i
, trees
[i
]->buffer
, trees
[i
]->size
);
668 if (unpack_trees(nr_trees
, t
, &opts
))
673 static void write_tree_trivial(struct object_id
*oid
)
675 if (write_cache_as_tree(oid
, 0, NULL
))
676 die(_("git write-tree failed to write a tree"));
679 static int try_merge_strategy(const char *strategy
, struct commit_list
*common
,
680 struct commit_list
*remoteheads
,
683 struct lock_file lock
= LOCK_INIT
;
684 const char *head_arg
= "HEAD";
686 hold_locked_index(&lock
, LOCK_DIE_ON_ERROR
);
687 refresh_cache(REFRESH_QUIET
);
688 if (write_locked_index(&the_index
, &lock
,
689 COMMIT_LOCK
| SKIP_IF_UNCHANGED
))
690 return error(_("Unable to write index."));
692 if (!strcmp(strategy
, "recursive") || !strcmp(strategy
, "subtree")) {
694 struct commit
*result
;
695 struct commit_list
*reversed
= NULL
;
696 struct merge_options o
;
697 struct commit_list
*j
;
699 if (remoteheads
->next
) {
700 error(_("Not handling anything other than two heads merge."));
704 init_merge_options(&o
);
705 if (!strcmp(strategy
, "subtree"))
706 o
.subtree_shift
= "";
708 o
.renormalize
= option_renormalize
;
709 o
.show_rename_progress
=
710 show_progress
== -1 ? isatty(2) : show_progress
;
712 for (x
= 0; x
< xopts_nr
; x
++)
713 if (parse_merge_opt(&o
, xopts
[x
]))
714 die(_("Unknown option for merge-recursive: -X%s"), xopts
[x
]);
716 o
.branch1
= head_arg
;
717 o
.branch2
= merge_remote_util(remoteheads
->item
)->name
;
719 for (j
= common
; j
; j
= j
->next
)
720 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
);
727 if (write_locked_index(&the_index
, &lock
,
728 COMMIT_LOCK
| SKIP_IF_UNCHANGED
))
729 die(_("unable to write %s"), get_index_file());
730 return clean
? 0 : 1;
732 return try_merge_command(the_repository
,
733 strategy
, xopts_nr
, xopts
,
734 common
, head_arg
, remoteheads
);
738 static void count_diff_files(struct diff_queue_struct
*q
,
739 struct diff_options
*opt
, void *data
)
746 static int count_unmerged_entries(void)
750 for (i
= 0; i
< active_nr
; i
++)
751 if (ce_stage(active_cache
[i
]))
757 static void add_strategies(const char *string
, unsigned attr
)
762 struct string_list list
= STRING_LIST_INIT_DUP
;
763 struct string_list_item
*item
;
764 string_list_split(&list
, string
, ' ', -1);
765 for_each_string_list_item(item
, &list
)
766 append_strategy(get_strategy(item
->string
));
767 string_list_clear(&list
, 0);
770 for (i
= 0; i
< ARRAY_SIZE(all_strategy
); i
++)
771 if (all_strategy
[i
].attr
& attr
)
772 append_strategy(&all_strategy
[i
]);
776 static void read_merge_msg(struct strbuf
*msg
)
778 const char *filename
= git_path_merge_msg(the_repository
);
780 if (strbuf_read_file(msg
, filename
, 0) < 0)
781 die_errno(_("Could not read from '%s'"), filename
);
784 static void write_merge_state(struct commit_list
*);
785 static void abort_commit(struct commit_list
*remoteheads
, const char *err_msg
)
788 error("%s", err_msg
);
790 _("Not committing merge; use 'git commit' to complete the merge.\n"));
791 write_merge_state(remoteheads
);
795 static const char merge_editor_comment
[] =
796 N_("Please enter a commit message to explain why this merge is necessary,\n"
797 "especially if it merges an updated upstream into a topic branch.\n"
799 "Lines starting with '%c' will be ignored, and an empty message aborts\n"
802 static void write_merge_heads(struct commit_list
*);
803 static void prepare_to_commit(struct commit_list
*remoteheads
)
805 struct strbuf msg
= STRBUF_INIT
;
806 strbuf_addbuf(&msg
, &merge_msg
);
807 strbuf_addch(&msg
, '\n');
809 BUG("the control must not reach here under --squash");
811 strbuf_commented_addf(&msg
, _(merge_editor_comment
), comment_line_char
);
813 append_signoff(&msg
, ignore_non_trailer(msg
.buf
, msg
.len
), 0);
814 write_merge_heads(remoteheads
);
815 write_file_buf(git_path_merge_msg(the_repository
), msg
.buf
, msg
.len
);
816 if (run_commit_hook(0 < option_edit
, get_index_file(), "prepare-commit-msg",
817 git_path_merge_msg(the_repository
), "merge", NULL
))
818 abort_commit(remoteheads
, NULL
);
819 if (0 < option_edit
) {
820 if (launch_editor(git_path_merge_msg(the_repository
), NULL
, NULL
))
821 abort_commit(remoteheads
, NULL
);
824 if (verify_msg
&& run_commit_hook(0 < option_edit
, get_index_file(),
826 git_path_merge_msg(the_repository
), NULL
))
827 abort_commit(remoteheads
, NULL
);
829 read_merge_msg(&msg
);
830 strbuf_stripspace(&msg
, 0 < option_edit
);
832 abort_commit(remoteheads
, _("Empty commit message."));
833 strbuf_release(&merge_msg
);
834 strbuf_addbuf(&merge_msg
, &msg
);
835 strbuf_release(&msg
);
838 static int merge_trivial(struct commit
*head
, struct commit_list
*remoteheads
)
840 struct object_id result_tree
, result_commit
;
841 struct commit_list
*parents
, **pptr
= &parents
;
842 struct lock_file lock
= LOCK_INIT
;
844 hold_locked_index(&lock
, LOCK_DIE_ON_ERROR
);
845 refresh_cache(REFRESH_QUIET
);
846 if (write_locked_index(&the_index
, &lock
,
847 COMMIT_LOCK
| SKIP_IF_UNCHANGED
))
848 return error(_("Unable to write index."));
850 write_tree_trivial(&result_tree
);
851 printf(_("Wonderful.\n"));
852 pptr
= commit_list_append(head
, pptr
);
853 pptr
= commit_list_append(remoteheads
->item
, pptr
);
854 prepare_to_commit(remoteheads
);
855 if (commit_tree(merge_msg
.buf
, merge_msg
.len
, &result_tree
, parents
,
856 &result_commit
, NULL
, sign_commit
))
857 die(_("failed to write commit object"));
858 finish(head
, remoteheads
, &result_commit
, "In-index merge");
863 static int finish_automerge(struct commit
*head
,
865 struct commit_list
*common
,
866 struct commit_list
*remoteheads
,
867 struct object_id
*result_tree
,
868 const char *wt_strategy
)
870 struct commit_list
*parents
= NULL
;
871 struct strbuf buf
= STRBUF_INIT
;
872 struct object_id result_commit
;
874 free_commit_list(common
);
875 parents
= remoteheads
;
876 if (!head_subsumed
|| fast_forward
== FF_NO
)
877 commit_list_insert(head
, &parents
);
878 strbuf_addch(&merge_msg
, '\n');
879 prepare_to_commit(remoteheads
);
880 if (commit_tree(merge_msg
.buf
, merge_msg
.len
, result_tree
, parents
,
881 &result_commit
, NULL
, sign_commit
))
882 die(_("failed to write commit object"));
883 strbuf_addf(&buf
, "Merge made by the '%s' strategy.", wt_strategy
);
884 finish(head
, remoteheads
, &result_commit
, buf
.buf
);
885 strbuf_release(&buf
);
890 static int suggest_conflicts(void)
892 const char *filename
;
894 struct strbuf msgbuf
= STRBUF_INIT
;
896 filename
= git_path_merge_msg(the_repository
);
897 fp
= xfopen(filename
, "a");
899 append_conflicts_hint(&msgbuf
);
900 fputs(msgbuf
.buf
, fp
);
901 strbuf_release(&msgbuf
);
903 repo_rerere(the_repository
, allow_rerere_auto
);
904 printf(_("Automatic merge failed; "
905 "fix conflicts and then commit the result.\n"));
909 static int evaluate_result(void)
914 /* Check how many files differ. */
915 repo_init_revisions(the_repository
, &rev
, "");
916 setup_revisions(0, NULL
, &rev
, NULL
);
917 rev
.diffopt
.output_format
|=
918 DIFF_FORMAT_CALLBACK
;
919 rev
.diffopt
.format_callback
= count_diff_files
;
920 rev
.diffopt
.format_callback_data
= &cnt
;
921 run_diff_files(&rev
, 0);
924 * Check how many unmerged entries are
927 cnt
+= count_unmerged_entries();
933 * Pretend as if the user told us to merge with the remote-tracking
934 * branch we have for the upstream of the current branch
936 static int setup_with_upstream(const char ***argv
)
938 struct branch
*branch
= branch_get(NULL
);
943 die(_("No current branch."));
944 if (!branch
->remote_name
)
945 die(_("No remote for the current branch."));
946 if (!branch
->merge_nr
)
947 die(_("No default upstream defined for the current branch."));
949 args
= xcalloc(st_add(branch
->merge_nr
, 1), sizeof(char *));
950 for (i
= 0; i
< branch
->merge_nr
; i
++) {
951 if (!branch
->merge
[i
]->dst
)
952 die(_("No remote-tracking branch for %s from %s"),
953 branch
->merge
[i
]->src
, branch
->remote_name
);
954 args
[i
] = branch
->merge
[i
]->dst
;
961 static void write_merge_heads(struct commit_list
*remoteheads
)
963 struct commit_list
*j
;
964 struct strbuf buf
= STRBUF_INIT
;
966 for (j
= remoteheads
; j
; j
= j
->next
) {
967 struct object_id
*oid
;
968 struct commit
*c
= j
->item
;
969 struct merge_remote_desc
*desc
;
971 desc
= merge_remote_util(c
);
972 if (desc
&& desc
->obj
) {
973 oid
= &desc
->obj
->oid
;
975 oid
= &c
->object
.oid
;
977 strbuf_addf(&buf
, "%s\n", oid_to_hex(oid
));
979 write_file_buf(git_path_merge_head(the_repository
), buf
.buf
, buf
.len
);
982 if (fast_forward
== FF_NO
)
983 strbuf_addstr(&buf
, "no-ff");
984 write_file_buf(git_path_merge_mode(the_repository
), buf
.buf
, buf
.len
);
985 strbuf_release(&buf
);
988 static void write_merge_state(struct commit_list
*remoteheads
)
990 write_merge_heads(remoteheads
);
991 strbuf_addch(&merge_msg
, '\n');
992 write_file_buf(git_path_merge_msg(the_repository
), merge_msg
.buf
,
996 static int default_edit_option(void)
998 static const char name
[] = "GIT_MERGE_AUTOEDIT";
999 const char *e
= getenv(name
);
1000 struct stat st_stdin
, st_stdout
;
1003 /* an explicit -m msg without --[no-]edit */
1007 int v
= git_parse_maybe_bool(e
);
1009 die(_("Bad value '%s' in environment '%s'"), e
, name
);
1013 /* Use editor if stdin and stdout are the same and is a tty */
1014 return (!fstat(0, &st_stdin
) &&
1015 !fstat(1, &st_stdout
) &&
1016 isatty(0) && isatty(1) &&
1017 st_stdin
.st_dev
== st_stdout
.st_dev
&&
1018 st_stdin
.st_ino
== st_stdout
.st_ino
&&
1019 st_stdin
.st_mode
== st_stdout
.st_mode
);
1022 static struct commit_list
*reduce_parents(struct commit
*head_commit
,
1024 struct commit_list
*remoteheads
)
1026 struct commit_list
*parents
, **remotes
;
1029 * Is the current HEAD reachable from another commit being
1030 * merged? If so we do not want to record it as a parent of
1031 * the resulting merge, unless --no-ff is given. We will flip
1032 * this variable to 0 when we find HEAD among the independent
1033 * tips being merged.
1037 /* Find what parents to record by checking independent ones. */
1038 parents
= reduce_heads(remoteheads
);
1039 free_commit_list(remoteheads
);
1042 remotes
= &remoteheads
;
1044 struct commit
*commit
= pop_commit(&parents
);
1045 if (commit
== head_commit
)
1048 remotes
= &commit_list_insert(commit
, remotes
)->next
;
1053 static void prepare_merge_message(struct strbuf
*merge_names
, struct strbuf
*merge_msg
)
1055 struct fmt_merge_msg_opts opts
;
1057 memset(&opts
, 0, sizeof(opts
));
1058 opts
.add_title
= !have_message
;
1059 opts
.shortlog_len
= shortlog_len
;
1060 opts
.credit_people
= (0 < option_edit
);
1062 fmt_merge_msg(merge_names
, merge_msg
, &opts
);
1064 strbuf_setlen(merge_msg
, merge_msg
->len
- 1);
1067 static void handle_fetch_head(struct commit_list
**remotes
, struct strbuf
*merge_names
)
1069 const char *filename
;
1071 struct strbuf fetch_head_file
= STRBUF_INIT
;
1072 const unsigned hexsz
= the_hash_algo
->hexsz
;
1075 merge_names
= &fetch_head_file
;
1077 filename
= git_path_fetch_head(the_repository
);
1078 fd
= open(filename
, O_RDONLY
);
1080 die_errno(_("could not open '%s' for reading"), filename
);
1082 if (strbuf_read(merge_names
, fd
, 0) < 0)
1083 die_errno(_("could not read '%s'"), filename
);
1085 die_errno(_("could not close '%s'"), filename
);
1087 for (pos
= 0; pos
< merge_names
->len
; pos
= npos
) {
1088 struct object_id oid
;
1090 struct commit
*commit
;
1092 ptr
= strchr(merge_names
->buf
+ pos
, '\n');
1094 npos
= ptr
- merge_names
->buf
+ 1;
1096 npos
= merge_names
->len
;
1098 if (npos
- pos
< hexsz
+ 2 ||
1099 get_oid_hex(merge_names
->buf
+ pos
, &oid
))
1100 commit
= NULL
; /* bad */
1101 else if (memcmp(merge_names
->buf
+ pos
+ hexsz
, "\t\t", 2))
1102 continue; /* not-for-merge */
1104 char saved
= merge_names
->buf
[pos
+ hexsz
];
1105 merge_names
->buf
[pos
+ hexsz
] = '\0';
1106 commit
= get_merge_parent(merge_names
->buf
+ pos
);
1107 merge_names
->buf
[pos
+ hexsz
] = saved
;
1112 die(_("not something we can merge in %s: %s"),
1113 filename
, merge_names
->buf
+ pos
);
1115 remotes
= &commit_list_insert(commit
, remotes
)->next
;
1118 if (merge_names
== &fetch_head_file
)
1119 strbuf_release(&fetch_head_file
);
1122 static struct commit_list
*collect_parents(struct commit
*head_commit
,
1124 int argc
, const char **argv
,
1125 struct strbuf
*merge_msg
)
1128 struct commit_list
*remoteheads
= NULL
;
1129 struct commit_list
**remotes
= &remoteheads
;
1130 struct strbuf merge_names
= STRBUF_INIT
, *autogen
= NULL
;
1132 if (merge_msg
&& (!have_message
|| shortlog_len
))
1133 autogen
= &merge_names
;
1136 remotes
= &commit_list_insert(head_commit
, remotes
)->next
;
1138 if (argc
== 1 && !strcmp(argv
[0], "FETCH_HEAD")) {
1139 handle_fetch_head(remotes
, autogen
);
1140 remoteheads
= reduce_parents(head_commit
, head_subsumed
, remoteheads
);
1142 for (i
= 0; i
< argc
; i
++) {
1143 struct commit
*commit
= get_merge_parent(argv
[i
]);
1145 help_unknown_ref(argv
[i
], "merge",
1146 _("not something we can merge"));
1147 remotes
= &commit_list_insert(commit
, remotes
)->next
;
1149 remoteheads
= reduce_parents(head_commit
, head_subsumed
, remoteheads
);
1151 struct commit_list
*p
;
1152 for (p
= remoteheads
; p
; p
= p
->next
)
1153 merge_name(merge_remote_util(p
->item
)->name
, autogen
);
1158 prepare_merge_message(autogen
, merge_msg
);
1159 strbuf_release(autogen
);
1165 static int merging_a_throwaway_tag(struct commit
*commit
)
1168 struct object_id oid
;
1169 int is_throwaway_tag
= 0;
1171 /* Are we merging a tag? */
1172 if (!merge_remote_util(commit
) ||
1173 !merge_remote_util(commit
)->obj
||
1174 merge_remote_util(commit
)->obj
->type
!= OBJ_TAG
)
1175 return is_throwaway_tag
;
1178 * Now we know we are merging a tag object. Are we downstream
1179 * and following the tags from upstream? If so, we must have
1180 * the tag object pointed at by "refs/tags/$T" where $T is the
1181 * tagname recorded in the tag object. We want to allow such
1182 * a "just to catch up" merge to fast-forward.
1184 * Otherwise, we are playing an integrator's role, making a
1185 * merge with a throw-away tag from a contributor with
1186 * something like "git pull $contributor $signed_tag".
1187 * We want to forbid such a merge from fast-forwarding
1188 * by default; otherwise we would not keep the signature
1191 tag_ref
= xstrfmt("refs/tags/%s",
1192 ((struct tag
*)merge_remote_util(commit
)->obj
)->tag
);
1193 if (!read_ref(tag_ref
, &oid
) &&
1194 oideq(&oid
, &merge_remote_util(commit
)->obj
->oid
))
1195 is_throwaway_tag
= 0;
1197 is_throwaway_tag
= 1;
1199 return is_throwaway_tag
;
1202 int cmd_merge(int argc
, const char **argv
, const char *prefix
)
1204 struct object_id result_tree
, stash
, head_oid
;
1205 struct commit
*head_commit
;
1206 struct strbuf buf
= STRBUF_INIT
;
1207 int i
, ret
= 0, head_subsumed
;
1208 int best_cnt
= -1, merge_was_ok
= 0, automerge_was_ok
= 0;
1209 struct commit_list
*common
= NULL
;
1210 const char *best_strategy
= NULL
, *wt_strategy
= NULL
;
1211 struct commit_list
*remoteheads
, *p
;
1212 void *branch_to_free
;
1213 int orig_argc
= argc
;
1215 if (argc
== 2 && !strcmp(argv
[1], "-h"))
1216 usage_with_options(builtin_merge_usage
, builtin_merge_options
);
1219 * Check if we are _not_ on a detached HEAD, i.e. if there is a
1222 branch
= branch_to_free
= resolve_refdup("HEAD", 0, &head_oid
, NULL
);
1224 skip_prefix(branch
, "refs/heads/", &branch
);
1226 init_diff_ui_defaults();
1227 git_config(git_merge_config
, NULL
);
1229 if (!branch
|| is_null_oid(&head_oid
))
1232 head_commit
= lookup_commit_or_die(&head_oid
, "HEAD");
1234 if (branch_mergeoptions
)
1235 parse_branch_merge_options(branch_mergeoptions
);
1236 argc
= parse_options(argc
, argv
, prefix
, builtin_merge_options
,
1237 builtin_merge_usage
, 0);
1238 if (shortlog_len
< 0)
1239 shortlog_len
= (merge_log_config
> 0) ? merge_log_config
: 0;
1241 if (verbosity
< 0 && show_progress
== -1)
1244 if (abort_current_merge
) {
1246 const char *nargv
[] = {"reset", "--merge", NULL
};
1249 usage_msg_opt(_("--abort expects no arguments"),
1250 builtin_merge_usage
, builtin_merge_options
);
1252 if (!file_exists(git_path_merge_head(the_repository
)))
1253 die(_("There is no merge to abort (MERGE_HEAD missing)."));
1255 /* Invoke 'git reset --merge' */
1256 ret
= cmd_reset(nargc
, nargv
, prefix
);
1260 if (continue_current_merge
) {
1262 const char *nargv
[] = {"commit", NULL
};
1265 usage_msg_opt(_("--continue expects no arguments"),
1266 builtin_merge_usage
, builtin_merge_options
);
1268 if (!file_exists(git_path_merge_head(the_repository
)))
1269 die(_("There is no merge in progress (MERGE_HEAD missing)."));
1271 /* Invoke 'git commit' */
1272 ret
= cmd_commit(nargc
, nargv
, prefix
);
1276 if (read_cache_unmerged())
1277 die_resolve_conflict("merge");
1279 if (file_exists(git_path_merge_head(the_repository
))) {
1281 * There is no unmerged entry, don't advise 'git
1282 * add/rm <file>', just 'git commit'.
1284 if (advice_resolve_conflict
)
1285 die(_("You have not concluded your merge (MERGE_HEAD exists).\n"
1286 "Please, commit your changes before you merge."));
1288 die(_("You have not concluded your merge (MERGE_HEAD exists)."));
1290 if (file_exists(git_path_cherry_pick_head(the_repository
))) {
1291 if (advice_resolve_conflict
)
1292 die(_("You have not concluded your cherry-pick (CHERRY_PICK_HEAD exists).\n"
1293 "Please, commit your changes before you merge."));
1295 die(_("You have not concluded your cherry-pick (CHERRY_PICK_HEAD exists)."));
1297 resolve_undo_clear();
1303 if (fast_forward
== FF_NO
)
1304 die(_("You cannot combine --squash with --no-ff."));
1309 if (default_to_upstream
)
1310 argc
= setup_with_upstream(&argv
);
1312 die(_("No commit specified and merge.defaultToUpstream not set."));
1313 } else if (argc
== 1 && !strcmp(argv
[0], "-")) {
1318 usage_with_options(builtin_merge_usage
,
1319 builtin_merge_options
);
1323 * If the merged head is a valid one there is no reason
1324 * to forbid "git merge" into a branch yet to be born.
1325 * We do the same for "git pull".
1327 struct object_id
*remote_head_oid
;
1329 die(_("Squash commit into empty head not supported yet"));
1330 if (fast_forward
== FF_NO
)
1331 die(_("Non-fast-forward commit does not make sense into "
1333 remoteheads
= collect_parents(head_commit
, &head_subsumed
,
1336 die(_("%s - not something we can merge"), argv
[0]);
1337 if (remoteheads
->next
)
1338 die(_("Can merge only exactly one commit into empty head"));
1339 remote_head_oid
= &remoteheads
->item
->object
.oid
;
1340 read_empty(remote_head_oid
, 0);
1341 update_ref("initial pull", "HEAD", remote_head_oid
, NULL
, 0,
1342 UPDATE_REFS_DIE_ON_ERR
);
1347 * All the rest are the commits being merged; prepare
1348 * the standard merge summary message to be appended
1349 * to the given message.
1351 remoteheads
= collect_parents(head_commit
, &head_subsumed
,
1352 argc
, argv
, &merge_msg
);
1354 if (!head_commit
|| !argc
)
1355 usage_with_options(builtin_merge_usage
,
1356 builtin_merge_options
);
1358 if (verify_signatures
) {
1359 for (p
= remoteheads
; p
; p
= p
->next
) {
1360 struct commit
*commit
= p
->item
;
1361 char hex
[GIT_MAX_HEXSZ
+ 1];
1362 struct signature_check signature_check
;
1363 memset(&signature_check
, 0, sizeof(signature_check
));
1365 check_commit_signature(commit
, &signature_check
);
1367 find_unique_abbrev_r(hex
, &commit
->object
.oid
, DEFAULT_ABBREV
);
1368 switch (signature_check
.result
) {
1372 die(_("Commit %s has an untrusted GPG signature, "
1373 "allegedly by %s."), hex
, signature_check
.signer
);
1375 die(_("Commit %s has a bad GPG signature "
1376 "allegedly by %s."), hex
, signature_check
.signer
);
1378 die(_("Commit %s does not have a GPG signature."), hex
);
1380 if (verbosity
>= 0 && signature_check
.result
== 'G')
1381 printf(_("Commit %s has a good GPG signature by %s\n"),
1382 hex
, signature_check
.signer
);
1384 signature_check_clear(&signature_check
);
1388 strbuf_addstr(&buf
, "merge");
1389 for (p
= remoteheads
; p
; p
= p
->next
)
1390 strbuf_addf(&buf
, " %s", merge_remote_util(p
->item
)->name
);
1391 setenv("GIT_REFLOG_ACTION", buf
.buf
, 0);
1394 for (p
= remoteheads
; p
; p
= p
->next
) {
1395 struct commit
*commit
= p
->item
;
1396 strbuf_addf(&buf
, "GITHEAD_%s",
1397 oid_to_hex(&commit
->object
.oid
));
1398 setenv(buf
.buf
, merge_remote_util(commit
)->name
, 1);
1400 if (fast_forward
!= FF_ONLY
&& merging_a_throwaway_tag(commit
))
1401 fast_forward
= FF_NO
;
1404 if (option_edit
< 0)
1405 option_edit
= default_edit_option();
1407 if (!use_strategies
) {
1409 ; /* already up-to-date */
1410 else if (!remoteheads
->next
)
1411 add_strategies(pull_twohead
, DEFAULT_TWOHEAD
);
1413 add_strategies(pull_octopus
, DEFAULT_OCTOPUS
);
1416 for (i
= 0; i
< use_strategies_nr
; i
++) {
1417 if (use_strategies
[i
]->attr
& NO_FAST_FORWARD
)
1418 fast_forward
= FF_NO
;
1419 if (use_strategies
[i
]->attr
& NO_TRIVIAL
)
1424 ; /* already up-to-date */
1425 else if (!remoteheads
->next
)
1426 common
= get_merge_bases(head_commit
, remoteheads
->item
);
1428 struct commit_list
*list
= remoteheads
;
1429 commit_list_insert(head_commit
, &list
);
1430 common
= get_octopus_merge_bases(list
);
1434 update_ref("updating ORIG_HEAD", "ORIG_HEAD",
1435 &head_commit
->object
.oid
, NULL
, 0, UPDATE_REFS_DIE_ON_ERR
);
1437 if (remoteheads
&& !common
) {
1438 /* No common ancestors found. */
1439 if (!allow_unrelated_histories
)
1440 die(_("refusing to merge unrelated histories"));
1441 /* otherwise, we need a real merge. */
1442 } else if (!remoteheads
||
1443 (!remoteheads
->next
&& !common
->next
&&
1444 common
->item
== remoteheads
->item
)) {
1446 * If head can reach all the merge then we are up to date.
1447 * but first the most common case of merging one remote.
1449 finish_up_to_date(_("Already up to date."));
1451 } else if (fast_forward
!= FF_NO
&& !remoteheads
->next
&&
1453 oideq(&common
->item
->object
.oid
, &head_commit
->object
.oid
)) {
1454 /* Again the most common case of merging one remote. */
1455 struct strbuf msg
= STRBUF_INIT
;
1456 struct commit
*commit
;
1458 if (verbosity
>= 0) {
1459 printf(_("Updating %s..%s\n"),
1460 find_unique_abbrev(&head_commit
->object
.oid
,
1462 find_unique_abbrev(&remoteheads
->item
->object
.oid
,
1465 strbuf_addstr(&msg
, "Fast-forward");
1468 " (no commit created; -m option ignored)");
1469 commit
= remoteheads
->item
;
1475 if (checkout_fast_forward(the_repository
,
1476 &head_commit
->object
.oid
,
1477 &commit
->object
.oid
,
1478 overwrite_ignore
)) {
1483 finish(head_commit
, remoteheads
, &commit
->object
.oid
, msg
.buf
);
1486 } else if (!remoteheads
->next
&& common
->next
)
1489 * We are not doing octopus and not fast-forward. Need
1492 else if (!remoteheads
->next
&& !common
->next
&& option_commit
) {
1494 * We are not doing octopus, not fast-forward, and have
1497 refresh_cache(REFRESH_QUIET
);
1498 if (allow_trivial
&& fast_forward
!= FF_ONLY
) {
1499 /* See if it is really trivial. */
1500 git_committer_info(IDENT_STRICT
);
1501 printf(_("Trying really trivial in-index merge...\n"));
1502 if (!read_tree_trivial(&common
->item
->object
.oid
,
1503 &head_commit
->object
.oid
,
1504 &remoteheads
->item
->object
.oid
)) {
1505 ret
= merge_trivial(head_commit
, remoteheads
);
1508 printf(_("Nope.\n"));
1512 * An octopus. If we can reach all the remote we are up
1516 struct commit_list
*j
;
1518 for (j
= remoteheads
; j
; j
= j
->next
) {
1519 struct commit_list
*common_one
;
1522 * Here we *have* to calculate the individual
1523 * merge_bases again, otherwise "git merge HEAD^
1524 * HEAD^^" would be missed.
1526 common_one
= get_merge_bases(head_commit
, j
->item
);
1527 if (!oideq(&common_one
->item
->object
.oid
, &j
->item
->object
.oid
)) {
1533 finish_up_to_date(_("Already up to date. Yeeah!"));
1538 if (fast_forward
== FF_ONLY
)
1539 die(_("Not possible to fast-forward, aborting."));
1541 /* We are going to make a new commit. */
1542 git_committer_info(IDENT_STRICT
);
1545 * At this point, we need a real merge. No matter what strategy
1546 * we use, it would operate on the index, possibly affecting the
1547 * working tree, and when resolved cleanly, have the desired
1548 * tree in the index -- this means that the index must be in
1549 * sync with the head commit. The strategies are responsible
1552 if (use_strategies_nr
== 1 ||
1554 * Stash away the local changes so that we can try more than one.
1559 for (i
= 0; i
< use_strategies_nr
; i
++) {
1562 printf(_("Rewinding the tree to pristine...\n"));
1563 restore_state(&head_commit
->object
.oid
, &stash
);
1565 if (use_strategies_nr
!= 1)
1566 printf(_("Trying merge strategy %s...\n"),
1567 use_strategies
[i
]->name
);
1569 * Remember which strategy left the state in the working
1572 wt_strategy
= use_strategies
[i
]->name
;
1574 ret
= try_merge_strategy(use_strategies
[i
]->name
,
1575 common
, remoteheads
,
1577 if (!option_commit
&& !ret
) {
1580 * This is necessary here just to avoid writing
1581 * the tree, but later we will *not* exit with
1582 * status code 1 because merge_was_ok is set.
1589 * The backend exits with 1 when conflicts are
1590 * left to be resolved, with 2 when it does not
1591 * handle the given merge at all.
1594 int cnt
= evaluate_result();
1596 if (best_cnt
<= 0 || cnt
<= best_cnt
) {
1597 best_strategy
= use_strategies
[i
]->name
;
1607 /* Automerge succeeded. */
1608 write_tree_trivial(&result_tree
);
1609 automerge_was_ok
= 1;
1614 * If we have a resulting tree, that means the strategy module
1615 * auto resolved the merge cleanly.
1617 if (automerge_was_ok
) {
1618 ret
= finish_automerge(head_commit
, head_subsumed
,
1619 common
, remoteheads
,
1620 &result_tree
, wt_strategy
);
1625 * Pick the result from the best strategy and have the user fix
1628 if (!best_strategy
) {
1629 restore_state(&head_commit
->object
.oid
, &stash
);
1630 if (use_strategies_nr
> 1)
1632 _("No merge strategy handled the merge.\n"));
1634 fprintf(stderr
, _("Merge with strategy %s failed.\n"),
1635 use_strategies
[0]->name
);
1638 } else if (best_strategy
== wt_strategy
)
1639 ; /* We already have its result in the working tree. */
1641 printf(_("Rewinding the tree to pristine...\n"));
1642 restore_state(&head_commit
->object
.oid
, &stash
);
1643 printf(_("Using the %s to prepare resolving by hand.\n"),
1645 try_merge_strategy(best_strategy
, common
, remoteheads
,
1650 finish(head_commit
, remoteheads
, NULL
, NULL
);
1652 write_merge_state(remoteheads
);
1655 fprintf(stderr
, _("Automatic merge went well; "
1656 "stopped before committing as requested\n"));
1658 ret
= suggest_conflicts();
1661 free(branch_to_free
);