Miklos Vajna | 1c7b76b | 2008-07-07 19:24:20 +0200 | [diff] [blame] | 1 | /* |
| 2 | * Builtin "git merge" |
| 3 | * |
| 4 | * Copyright (c) 2008 Miklos Vajna <vmiklos@frugalware.org> |
| 5 | * |
| 6 | * Based on git-merge.sh by Junio C Hamano. |
| 7 | */ |
| 8 | |
Ævar Arnfjörð Bjarmason | dfd0a89 | 2023-02-10 11:28:39 +0100 | [diff] [blame] | 9 | #define USE_THE_INDEX_VARIABLE |
Elijah Newren | bc5c5ec | 2023-05-16 06:33:57 +0000 | [diff] [blame] | 10 | #include "builtin.h" |
Elijah Newren | 0b027f6 | 2023-03-21 06:25:58 +0000 | [diff] [blame] | 11 | #include "abspath.h" |
Elijah Newren | 6c6ddf9 | 2023-04-11 03:00:39 +0000 | [diff] [blame] | 12 | #include "advice.h" |
Brandon Williams | b2141fc | 2017-06-14 11:07:36 -0700 | [diff] [blame] | 13 | #include "config.h" |
Elijah Newren | 4e12082 | 2023-04-11 00:41:57 -0700 | [diff] [blame] | 14 | #include "editor.h" |
Elijah Newren | 7ee24e1 | 2023-03-21 06:25:57 +0000 | [diff] [blame] | 15 | #include "environment.h" |
Elijah Newren | f394e09 | 2023-03-21 06:25:54 +0000 | [diff] [blame] | 16 | #include "gettext.h" |
Elijah Newren | 41771fa | 2023-02-24 00:09:27 +0000 | [diff] [blame] | 17 | #include "hex.h" |
Elijah Newren | dabab1d | 2023-04-11 00:41:49 -0700 | [diff] [blame] | 18 | #include "object-name.h" |
Miklos Vajna | 1c7b76b | 2008-07-07 19:24:20 +0200 | [diff] [blame] | 19 | #include "parse-options.h" |
Michael Haggerty | 697cc8e | 2014-10-01 12:28:42 +0200 | [diff] [blame] | 20 | #include "lockfile.h" |
Miklos Vajna | 1c7b76b | 2008-07-07 19:24:20 +0200 | [diff] [blame] | 21 | #include "run-command.h" |
Ævar Arnfjörð Bjarmason | 5e3aba3 | 2021-09-26 21:03:26 +0200 | [diff] [blame] | 22 | #include "hook.h" |
Miklos Vajna | 1c7b76b | 2008-07-07 19:24:20 +0200 | [diff] [blame] | 23 | #include "diff.h" |
Sergey Organov | 09322b1 | 2020-12-21 18:19:38 +0300 | [diff] [blame] | 24 | #include "diff-merges.h" |
Miklos Vajna | 1c7b76b | 2008-07-07 19:24:20 +0200 | [diff] [blame] | 25 | #include "refs.h" |
Brandon Williams | ec0cb49 | 2018-05-16 15:57:48 -0700 | [diff] [blame] | 26 | #include "refspec.h" |
Miklos Vajna | 1c7b76b | 2008-07-07 19:24:20 +0200 | [diff] [blame] | 27 | #include "commit.h" |
| 28 | #include "diffcore.h" |
Elijah Newren | c339932 | 2023-05-16 06:33:59 +0000 | [diff] [blame] | 29 | #include "path.h" |
Miklos Vajna | 1c7b76b | 2008-07-07 19:24:20 +0200 | [diff] [blame] | 30 | #include "revision.h" |
| 31 | #include "unpack-trees.h" |
| 32 | #include "cache-tree.h" |
| 33 | #include "dir.h" |
| 34 | #include "utf8.h" |
| 35 | #include "log-tree.h" |
| 36 | #include "color.h" |
Junio C Hamano | fcab40a | 2008-07-15 19:09:46 -0700 | [diff] [blame] | 37 | #include "rerere.h" |
Miklos Vajna | 87091b4 | 2008-07-30 01:16:59 +0200 | [diff] [blame] | 38 | #include "help.h" |
Elijah Newren | 750324d | 2023-05-16 06:33:54 +0000 | [diff] [blame] | 39 | #include "merge.h" |
Miklos Vajna | 18668f5 | 2008-08-28 15:43:00 +0200 | [diff] [blame] | 40 | #include "merge-recursive.h" |
Elijah Newren | 14c4586 | 2020-11-02 23:45:34 +0000 | [diff] [blame] | 41 | #include "merge-ort-wrappers.h" |
Junio C Hamano | cfc5789 | 2009-12-25 00:30:51 -0800 | [diff] [blame] | 42 | #include "resolve-undo.h" |
Junio C Hamano | 93e535a | 2011-03-23 23:48:24 -0700 | [diff] [blame] | 43 | #include "remote.h" |
Junio C Hamano | 898eacd | 2011-10-06 23:12:09 -0700 | [diff] [blame] | 44 | #include "fmt-merge-msg.h" |
Junio C Hamano | ba3c69a | 2011-10-05 17:23:20 -0700 | [diff] [blame] | 45 | #include "gpg-interface.h" |
Junio C Hamano | 75c961b | 2014-10-24 11:34:59 -0700 | [diff] [blame] | 46 | #include "sequencer.h" |
René Scharfe | 02a8cfa | 2016-08-05 23:01:35 +0200 | [diff] [blame] | 47 | #include "string-list.h" |
Jonathan Tan | 3836d88 | 2017-08-18 15:20:21 -0700 | [diff] [blame] | 48 | #include "packfile.h" |
Junio C Hamano | adcc94a | 2018-02-14 10:18:55 -0800 | [diff] [blame] | 49 | #include "tag.h" |
Nguyễn Thái Ngọc Duy | 65b5f94 | 2018-05-20 20:40:06 +0200 | [diff] [blame] | 50 | #include "alias.h" |
Nguyễn Thái Ngọc Duy | b643355 | 2019-05-09 17:10:27 +0700 | [diff] [blame] | 51 | #include "branch.h" |
Derrick Stolee | 6404355 | 2018-07-20 16:33:04 +0000 | [diff] [blame] | 52 | #include "commit-reach.h" |
Denton Liu | d540b70 | 2019-04-17 11:23:27 +0100 | [diff] [blame] | 53 | #include "wt-status.h" |
Derrick Stolee | b23ea97 | 2020-04-16 20:14:03 +0000 | [diff] [blame] | 54 | #include "commit-graph.h" |
Miklos Vajna | 1c7b76b | 2008-07-07 19:24:20 +0200 | [diff] [blame] | 55 | |
| 56 | #define DEFAULT_TWOHEAD (1<<0) |
| 57 | #define DEFAULT_OCTOPUS (1<<1) |
| 58 | #define NO_FAST_FORWARD (1<<2) |
| 59 | #define NO_TRIVIAL (1<<3) |
| 60 | |
| 61 | struct strategy { |
| 62 | const char *name; |
| 63 | unsigned attr; |
| 64 | }; |
| 65 | |
| 66 | static const char * const builtin_merge_usage[] = { |
Alex Henrie | 9c9b4f2 | 2015-01-13 00:44:47 -0700 | [diff] [blame] | 67 | N_("git merge [<options>] [<commit>...]"), |
Alex Henrie | a30e43f | 2021-05-15 14:01:11 -0600 | [diff] [blame] | 68 | "git merge --abort", |
| 69 | "git merge --continue", |
Miklos Vajna | 1c7b76b | 2008-07-07 19:24:20 +0200 | [diff] [blame] | 70 | NULL |
| 71 | }; |
| 72 | |
Junio C Hamano | 898eacd | 2011-10-06 23:12:09 -0700 | [diff] [blame] | 73 | static int show_diffstat = 1, shortlog_len = -1, squash; |
Vishal Verma | 1d14d0c | 2019-05-24 12:36:17 -0600 | [diff] [blame] | 74 | static int option_commit = -1; |
Miklos Vajna | a54841e | 2013-07-02 16:47:57 +0200 | [diff] [blame] | 75 | static int option_edit = -1; |
Sebastian Götte | efed002 | 2013-03-31 18:02:24 +0200 | [diff] [blame] | 76 | static int allow_trivial = 1, have_message, verify_signatures; |
Hans Jerry Illikainen | 54887b4 | 2019-12-27 13:55:57 +0000 | [diff] [blame] | 77 | static int check_trust_level = 1; |
Nguyễn Thái Ngọc Duy | c1d7036 | 2011-11-27 17:15:33 +0700 | [diff] [blame] | 78 | static int overwrite_ignore = 1; |
Jeff King | 2c47789 | 2011-12-18 00:03:22 -0500 | [diff] [blame] | 79 | static struct strbuf merge_msg = STRBUF_INIT; |
Miklos Vajna | 1c7b76b | 2008-07-07 19:24:20 +0200 | [diff] [blame] | 80 | static struct strategy **use_strategies; |
| 81 | static size_t use_strategies_nr, use_strategies_alloc; |
Avery Pennarun | 8cc5b29 | 2009-11-25 21:23:55 -0500 | [diff] [blame] | 82 | static const char **xopts; |
| 83 | static size_t xopts_nr, xopts_alloc; |
Miklos Vajna | 1c7b76b | 2008-07-07 19:24:20 +0200 | [diff] [blame] | 84 | static const char *branch; |
Junio C Hamano | 0d8fc3e | 2011-05-04 17:42:51 -0700 | [diff] [blame] | 85 | static char *branch_mergeoptions; |
Tuncer Ayaz | 7f87aff | 2008-11-15 01:14:24 +0100 | [diff] [blame] | 86 | static int verbosity; |
Junio C Hamano | cb6020b | 2009-12-04 00:20:48 -0800 | [diff] [blame] | 87 | static int allow_rerere_auto; |
Johan Herland | 35d2fff | 2010-11-09 22:49:59 +0100 | [diff] [blame] | 88 | static int abort_current_merge; |
Nguyễn Thái Ngọc Duy | f3f8311 | 2019-05-18 18:30:43 +0700 | [diff] [blame] | 89 | static int quit_current_merge; |
Chris Packham | 367ff69 | 2016-12-14 21:37:55 +1300 | [diff] [blame] | 90 | static int continue_current_merge; |
Junio C Hamano | e379fdf | 2016-03-18 13:21:09 -0700 | [diff] [blame] | 91 | static int allow_unrelated_histories; |
Jeff King | 99bfc66 | 2011-02-20 04:53:21 -0500 | [diff] [blame] | 92 | static int show_progress = -1; |
Felipe Contreras | a01f7f2 | 2014-04-20 19:17:33 -0500 | [diff] [blame] | 93 | static int default_to_upstream = 1; |
Łukasz Gryglicki | 14d01b4 | 2017-07-04 09:33:06 +0000 | [diff] [blame] | 94 | static int signoff; |
Junio C Hamano | ba3c69a | 2011-10-05 17:23:20 -0700 | [diff] [blame] | 95 | static const char *sign_commit; |
Denton Liu | a03b555 | 2020-04-07 10:28:07 -0400 | [diff] [blame] | 96 | static int autostash; |
Michael J Gruber | a1f3dd7 | 2019-08-07 11:57:06 -0700 | [diff] [blame] | 97 | static int no_verify; |
Junio C Hamano | bd2bc94 | 2021-12-20 14:53:43 -0800 | [diff] [blame] | 98 | static char *into_name; |
Miklos Vajna | 1c7b76b | 2008-07-07 19:24:20 +0200 | [diff] [blame] | 99 | |
| 100 | static struct strategy all_strategy[] = { |
Elijah Newren | 6a5fb96 | 2021-08-04 05:38:01 +0000 | [diff] [blame] | 101 | { "recursive", NO_TRIVIAL }, |
Miklos Vajna | 1c7b76b | 2008-07-07 19:24:20 +0200 | [diff] [blame] | 102 | { "octopus", DEFAULT_OCTOPUS }, |
Elijah Newren | 6a5fb96 | 2021-08-04 05:38:01 +0000 | [diff] [blame] | 103 | { "ort", DEFAULT_TWOHEAD | NO_TRIVIAL }, |
Miklos Vajna | 1c7b76b | 2008-07-07 19:24:20 +0200 | [diff] [blame] | 104 | { "resolve", 0 }, |
Miklos Vajna | 1c7b76b | 2008-07-07 19:24:20 +0200 | [diff] [blame] | 105 | { "ours", NO_FAST_FORWARD | NO_TRIVIAL }, |
| 106 | { "subtree", NO_FAST_FORWARD | NO_TRIVIAL }, |
| 107 | }; |
| 108 | |
| 109 | static const char *pull_twohead, *pull_octopus; |
| 110 | |
Miklos Vajna | a54841e | 2013-07-02 16:47:57 +0200 | [diff] [blame] | 111 | enum ff_type { |
| 112 | FF_NO, |
| 113 | FF_ALLOW, |
| 114 | FF_ONLY |
| 115 | }; |
| 116 | |
| 117 | static enum ff_type fast_forward = FF_ALLOW; |
| 118 | |
Denton Liu | d540b70 | 2019-04-17 11:23:27 +0100 | [diff] [blame] | 119 | static const char *cleanup_arg; |
| 120 | static enum commit_msg_cleanup_mode cleanup_mode; |
| 121 | |
Miklos Vajna | 1c7b76b | 2008-07-07 19:24:20 +0200 | [diff] [blame] | 122 | static int option_parse_message(const struct option *opt, |
| 123 | const char *arg, int unset) |
| 124 | { |
| 125 | struct strbuf *buf = opt->value; |
| 126 | |
| 127 | if (unset) |
| 128 | strbuf_setlen(buf, 0); |
Michele Ballabio | 74f5b7f | 2008-07-20 14:34:47 +0200 | [diff] [blame] | 129 | else if (arg) { |
Junio C Hamano | ce9d823 | 2009-12-02 10:00:58 -0800 | [diff] [blame] | 130 | strbuf_addf(buf, "%s%s", buf->len ? "\n\n" : "", arg); |
Miklos Vajna | 1c7b76b | 2008-07-07 19:24:20 +0200 | [diff] [blame] | 131 | have_message = 1; |
Michele Ballabio | 74f5b7f | 2008-07-20 14:34:47 +0200 | [diff] [blame] | 132 | } else |
Ævar Arnfjörð Bjarmason | bacec47 | 2011-02-22 23:41:59 +0000 | [diff] [blame] | 133 | return error(_("switch `m' requires a value")); |
Miklos Vajna | 1c7b76b | 2008-07-07 19:24:20 +0200 | [diff] [blame] | 134 | return 0; |
| 135 | } |
| 136 | |
Nguyễn Thái Ngọc Duy | f41179f | 2019-01-27 07:35:27 +0700 | [diff] [blame] | 137 | static enum parse_opt_result option_read_message(struct parse_opt_ctx_t *ctx, |
| 138 | const struct option *opt, |
Nguyễn Thái Ngọc Duy | 3ebbe28 | 2019-01-27 07:35:28 +0700 | [diff] [blame] | 139 | const char *arg_not_used, |
Nguyễn Thái Ngọc Duy | f41179f | 2019-01-27 07:35:27 +0700 | [diff] [blame] | 140 | int unset) |
Johannes Schindelin | 920f22e | 2017-12-22 15:10:02 +0100 | [diff] [blame] | 141 | { |
| 142 | struct strbuf *buf = opt->value; |
| 143 | const char *arg; |
| 144 | |
Nguyễn Thái Ngọc Duy | 3ebbe28 | 2019-01-27 07:35:28 +0700 | [diff] [blame] | 145 | BUG_ON_OPT_ARG(arg_not_used); |
Johannes Schindelin | 920f22e | 2017-12-22 15:10:02 +0100 | [diff] [blame] | 146 | if (unset) |
| 147 | BUG("-F cannot be negated"); |
| 148 | |
| 149 | if (ctx->opt) { |
| 150 | arg = ctx->opt; |
| 151 | ctx->opt = NULL; |
| 152 | } else if (ctx->argc > 1) { |
| 153 | ctx->argc--; |
| 154 | arg = *++ctx->argv; |
| 155 | } else |
Nguyễn Thái Ngọc Duy | 9440b83 | 2018-11-10 06:16:11 +0100 | [diff] [blame] | 156 | return error(_("option `%s' requires a value"), opt->long_name); |
Johannes Schindelin | 920f22e | 2017-12-22 15:10:02 +0100 | [diff] [blame] | 157 | |
| 158 | if (buf->len) |
| 159 | strbuf_addch(buf, '\n'); |
| 160 | if (ctx->prefix && !is_absolute_path(arg)) |
| 161 | arg = prefix_filename(ctx->prefix, arg); |
| 162 | if (strbuf_read_file(buf, arg, 0) < 0) |
| 163 | return error(_("could not read file '%s'"), arg); |
| 164 | have_message = 1; |
| 165 | |
| 166 | return 0; |
| 167 | } |
| 168 | |
Miklos Vajna | 1c7b76b | 2008-07-07 19:24:20 +0200 | [diff] [blame] | 169 | static struct strategy *get_strategy(const char *name) |
| 170 | { |
| 171 | int i; |
Miklos Vajna | 87091b4 | 2008-07-30 01:16:59 +0200 | [diff] [blame] | 172 | struct strategy *ret; |
| 173 | static struct cmdnames main_cmds, other_cmds; |
Alex Riesen | e321180 | 2008-08-28 19:15:33 +0200 | [diff] [blame] | 174 | static int loaded; |
Elijah Newren | 14c4586 | 2020-11-02 23:45:34 +0000 | [diff] [blame] | 175 | char *default_strategy = getenv("GIT_TEST_MERGE_ALGORITHM"); |
Miklos Vajna | 1c7b76b | 2008-07-07 19:24:20 +0200 | [diff] [blame] | 176 | |
| 177 | if (!name) |
| 178 | return NULL; |
| 179 | |
Elijah Newren | 14c4586 | 2020-11-02 23:45:34 +0000 | [diff] [blame] | 180 | if (default_strategy && |
| 181 | !strcmp(default_strategy, "ort") && |
| 182 | !strcmp(name, "recursive")) { |
| 183 | name = "ort"; |
| 184 | } |
| 185 | |
Miklos Vajna | 1c7b76b | 2008-07-07 19:24:20 +0200 | [diff] [blame] | 186 | for (i = 0; i < ARRAY_SIZE(all_strategy); i++) |
| 187 | if (!strcmp(name, all_strategy[i].name)) |
| 188 | return &all_strategy[i]; |
Miklos Vajna | 1719b5e | 2008-07-21 18:10:47 +0200 | [diff] [blame] | 189 | |
Alex Riesen | e321180 | 2008-08-28 19:15:33 +0200 | [diff] [blame] | 190 | if (!loaded) { |
Miklos Vajna | 87091b4 | 2008-07-30 01:16:59 +0200 | [diff] [blame] | 191 | struct cmdnames not_strategies; |
Alex Riesen | e321180 | 2008-08-28 19:15:33 +0200 | [diff] [blame] | 192 | loaded = 1; |
Miklos Vajna | 87091b4 | 2008-07-30 01:16:59 +0200 | [diff] [blame] | 193 | |
Miklos Vajna | 87091b4 | 2008-07-30 01:16:59 +0200 | [diff] [blame] | 194 | memset(¬_strategies, 0, sizeof(struct cmdnames)); |
Alex Riesen | e321180 | 2008-08-28 19:15:33 +0200 | [diff] [blame] | 195 | load_command_list("git-merge-", &main_cmds, &other_cmds); |
Miklos Vajna | 87091b4 | 2008-07-30 01:16:59 +0200 | [diff] [blame] | 196 | for (i = 0; i < main_cmds.cnt; i++) { |
| 197 | int j, found = 0; |
| 198 | struct cmdname *ent = main_cmds.names[i]; |
Seija Kijin | 0c75692 | 2023-01-09 17:34:28 +0000 | [diff] [blame] | 199 | for (j = 0; !found && j < ARRAY_SIZE(all_strategy); j++) |
Miklos Vajna | 87091b4 | 2008-07-30 01:16:59 +0200 | [diff] [blame] | 200 | if (!strncmp(ent->name, all_strategy[j].name, ent->len) |
| 201 | && !all_strategy[j].name[ent->len]) |
| 202 | found = 1; |
| 203 | if (!found) |
| 204 | add_cmdname(¬_strategies, ent->name, ent->len); |
Miklos Vajna | 87091b4 | 2008-07-30 01:16:59 +0200 | [diff] [blame] | 205 | } |
Avery Pennarun | ed87465 | 2009-11-25 21:23:54 -0500 | [diff] [blame] | 206 | exclude_cmds(&main_cmds, ¬_strategies); |
Miklos Vajna | 87091b4 | 2008-07-30 01:16:59 +0200 | [diff] [blame] | 207 | } |
| 208 | if (!is_in_cmdlist(&main_cmds, name) && !is_in_cmdlist(&other_cmds, name)) { |
Ævar Arnfjörð Bjarmason | bacec47 | 2011-02-22 23:41:59 +0000 | [diff] [blame] | 209 | fprintf(stderr, _("Could not find merge strategy '%s'.\n"), name); |
| 210 | fprintf(stderr, _("Available strategies are:")); |
Junio C Hamano | 131f9a1 | 2008-08-20 22:07:55 -0700 | [diff] [blame] | 211 | for (i = 0; i < main_cmds.cnt; i++) |
| 212 | fprintf(stderr, " %s", main_cmds.names[i]->name); |
| 213 | fprintf(stderr, ".\n"); |
| 214 | if (other_cmds.cnt) { |
Ævar Arnfjörð Bjarmason | bacec47 | 2011-02-22 23:41:59 +0000 | [diff] [blame] | 215 | fprintf(stderr, _("Available custom strategies are:")); |
Junio C Hamano | 131f9a1 | 2008-08-20 22:07:55 -0700 | [diff] [blame] | 216 | for (i = 0; i < other_cmds.cnt; i++) |
| 217 | fprintf(stderr, " %s", other_cmds.names[i]->name); |
| 218 | fprintf(stderr, ".\n"); |
| 219 | } |
Miklos Vajna | 87091b4 | 2008-07-30 01:16:59 +0200 | [diff] [blame] | 220 | exit(1); |
| 221 | } |
| 222 | |
René Scharfe | ca56dad | 2021-03-13 17:17:22 +0100 | [diff] [blame] | 223 | CALLOC_ARRAY(ret, 1); |
Miklos Vajna | 87091b4 | 2008-07-30 01:16:59 +0200 | [diff] [blame] | 224 | ret->name = xstrdup(name); |
Jonathan Nieder | 52b48ef | 2010-08-15 20:11:06 -0500 | [diff] [blame] | 225 | ret->attr = NO_TRIVIAL; |
Miklos Vajna | 87091b4 | 2008-07-30 01:16:59 +0200 | [diff] [blame] | 226 | return ret; |
Miklos Vajna | 1c7b76b | 2008-07-07 19:24:20 +0200 | [diff] [blame] | 227 | } |
| 228 | |
| 229 | static void append_strategy(struct strategy *s) |
| 230 | { |
| 231 | ALLOC_GROW(use_strategies, use_strategies_nr + 1, use_strategies_alloc); |
| 232 | use_strategies[use_strategies_nr++] = s; |
| 233 | } |
| 234 | |
| 235 | static int option_parse_strategy(const struct option *opt, |
| 236 | const char *name, int unset) |
| 237 | { |
Miklos Vajna | 1c7b76b | 2008-07-07 19:24:20 +0200 | [diff] [blame] | 238 | if (unset) |
| 239 | return 0; |
| 240 | |
Miklos Vajna | 1719b5e | 2008-07-21 18:10:47 +0200 | [diff] [blame] | 241 | append_strategy(get_strategy(name)); |
Miklos Vajna | 1c7b76b | 2008-07-07 19:24:20 +0200 | [diff] [blame] | 242 | return 0; |
| 243 | } |
| 244 | |
Avery Pennarun | 8cc5b29 | 2009-11-25 21:23:55 -0500 | [diff] [blame] | 245 | static int option_parse_x(const struct option *opt, |
| 246 | const char *arg, int unset) |
| 247 | { |
| 248 | if (unset) |
| 249 | return 0; |
| 250 | |
| 251 | ALLOC_GROW(xopts, xopts_nr + 1, xopts_alloc); |
| 252 | xopts[xopts_nr++] = xstrdup(arg); |
| 253 | return 0; |
| 254 | } |
| 255 | |
Miklos Vajna | 1c7b76b | 2008-07-07 19:24:20 +0200 | [diff] [blame] | 256 | static int option_parse_n(const struct option *opt, |
| 257 | const char *arg, int unset) |
| 258 | { |
Jeff King | 517fe80 | 2018-11-05 01:45:42 -0500 | [diff] [blame] | 259 | BUG_ON_OPT_ARG(arg); |
Miklos Vajna | 1c7b76b | 2008-07-07 19:24:20 +0200 | [diff] [blame] | 260 | show_diffstat = unset; |
| 261 | return 0; |
| 262 | } |
| 263 | |
| 264 | static struct option builtin_merge_options[] = { |
Denton Liu | 203c853 | 2020-04-28 04:36:28 -0400 | [diff] [blame] | 265 | OPT_CALLBACK_F('n', NULL, NULL, NULL, |
Nguyễn Thái Ngọc Duy | 962e629 | 2012-08-20 19:32:24 +0700 | [diff] [blame] | 266 | N_("do not show a diffstat at the end of the merge"), |
Denton Liu | 203c853 | 2020-04-28 04:36:28 -0400 | [diff] [blame] | 267 | PARSE_OPT_NOARG, option_parse_n), |
Stefan Beller | d5d09d4 | 2013-08-03 13:51:19 +0200 | [diff] [blame] | 268 | OPT_BOOL(0, "stat", &show_diffstat, |
Nguyễn Thái Ngọc Duy | 962e629 | 2012-08-20 19:32:24 +0700 | [diff] [blame] | 269 | N_("show a diffstat at the end of the merge")), |
Stefan Beller | d5d09d4 | 2013-08-03 13:51:19 +0200 | [diff] [blame] | 270 | OPT_BOOL(0, "summary", &show_diffstat, N_("(synonym to --stat)")), |
Nguyễn Thái Ngọc Duy | 962e629 | 2012-08-20 19:32:24 +0700 | [diff] [blame] | 271 | { OPTION_INTEGER, 0, "log", &shortlog_len, N_("n"), |
| 272 | N_("add (at most <n>) entries from shortlog to merge commit message"), |
Ramkumar Ramachandra | 96e9420 | 2010-09-08 23:29:54 +0530 | [diff] [blame] | 273 | PARSE_OPT_OPTARG, NULL, DEFAULT_MERGE_LOG_LEN }, |
Stefan Beller | d5d09d4 | 2013-08-03 13:51:19 +0200 | [diff] [blame] | 274 | OPT_BOOL(0, "squash", &squash, |
Nguyễn Thái Ngọc Duy | 962e629 | 2012-08-20 19:32:24 +0700 | [diff] [blame] | 275 | N_("create a single commit instead of doing a merge")), |
Stefan Beller | d5d09d4 | 2013-08-03 13:51:19 +0200 | [diff] [blame] | 276 | OPT_BOOL(0, "commit", &option_commit, |
Nguyễn Thái Ngọc Duy | 962e629 | 2012-08-20 19:32:24 +0700 | [diff] [blame] | 277 | N_("perform a commit if the merge succeeds (default)")), |
Junio C Hamano | f824628 | 2012-01-10 22:44:45 -0800 | [diff] [blame] | 278 | OPT_BOOL('e', "edit", &option_edit, |
Nguyễn Thái Ngọc Duy | 962e629 | 2012-08-20 19:32:24 +0700 | [diff] [blame] | 279 | N_("edit message before committing")), |
Denton Liu | d540b70 | 2019-04-17 11:23:27 +0100 | [diff] [blame] | 280 | OPT_CLEANUP(&cleanup_arg), |
Miklos Vajna | a54841e | 2013-07-02 16:47:57 +0200 | [diff] [blame] | 281 | OPT_SET_INT(0, "ff", &fast_forward, N_("allow fast-forward (default)"), FF_ALLOW), |
Nguyễn Thái Ngọc Duy | 3e4a67b | 2018-05-20 17:42:58 +0200 | [diff] [blame] | 282 | OPT_SET_INT_F(0, "ff-only", &fast_forward, |
| 283 | N_("abort if fast-forward is not possible"), |
| 284 | FF_ONLY, PARSE_OPT_NONEG), |
Junio C Hamano | cb6020b | 2009-12-04 00:20:48 -0800 | [diff] [blame] | 285 | OPT_RERERE_AUTOUPDATE(&allow_rerere_auto), |
Sebastian Götte | efed002 | 2013-03-31 18:02:24 +0200 | [diff] [blame] | 286 | OPT_BOOL(0, "verify-signatures", &verify_signatures, |
Vasco Almeida | c8bb9d2 | 2016-06-17 20:21:18 +0000 | [diff] [blame] | 287 | N_("verify that the named commit has a valid GPG signature")), |
Nguyễn Thái Ngọc Duy | 962e629 | 2012-08-20 19:32:24 +0700 | [diff] [blame] | 288 | OPT_CALLBACK('s', "strategy", &use_strategies, N_("strategy"), |
| 289 | N_("merge strategy to use"), option_parse_strategy), |
| 290 | OPT_CALLBACK('X', "strategy-option", &xopts, N_("option=value"), |
| 291 | N_("option for selected merge strategy"), option_parse_x), |
| 292 | OPT_CALLBACK('m', "message", &merge_msg, N_("message"), |
| 293 | N_("merge commit message (for a non-fast-forward merge)"), |
Miklos Vajna | 1c7b76b | 2008-07-07 19:24:20 +0200 | [diff] [blame] | 294 | option_parse_message), |
Johannes Schindelin | 920f22e | 2017-12-22 15:10:02 +0100 | [diff] [blame] | 295 | { OPTION_LOWLEVEL_CALLBACK, 'F', "file", &merge_msg, N_("path"), |
| 296 | N_("read message from file"), PARSE_OPT_NONEG, |
Nguyễn Thái Ngọc Duy | bf3ff33 | 2019-01-27 07:35:26 +0700 | [diff] [blame] | 297 | NULL, 0, option_read_message }, |
Junio C Hamano | bd2bc94 | 2021-12-20 14:53:43 -0800 | [diff] [blame] | 298 | OPT_STRING(0, "into-name", &into_name, N_("name"), |
| 299 | N_("use <name> instead of the real target")), |
Tuncer Ayaz | 7f87aff | 2008-11-15 01:14:24 +0100 | [diff] [blame] | 300 | OPT__VERBOSITY(&verbosity), |
Stefan Beller | d5d09d4 | 2013-08-03 13:51:19 +0200 | [diff] [blame] | 301 | OPT_BOOL(0, "abort", &abort_current_merge, |
Nguyễn Thái Ngọc Duy | 962e629 | 2012-08-20 19:32:24 +0700 | [diff] [blame] | 302 | N_("abort the current in-progress merge")), |
Nguyễn Thái Ngọc Duy | f3f8311 | 2019-05-18 18:30:43 +0700 | [diff] [blame] | 303 | OPT_BOOL(0, "quit", &quit_current_merge, |
| 304 | N_("--abort but leave index and working tree alone")), |
Chris Packham | 367ff69 | 2016-12-14 21:37:55 +1300 | [diff] [blame] | 305 | OPT_BOOL(0, "continue", &continue_current_merge, |
| 306 | N_("continue the current in-progress merge")), |
Junio C Hamano | e379fdf | 2016-03-18 13:21:09 -0700 | [diff] [blame] | 307 | OPT_BOOL(0, "allow-unrelated-histories", &allow_unrelated_histories, |
| 308 | N_("allow merging unrelated histories")), |
Nguyễn Thái Ngọc Duy | 962e629 | 2012-08-20 19:32:24 +0700 | [diff] [blame] | 309 | OPT_SET_INT(0, "progress", &show_progress, N_("force progress reporting"), 1), |
Junio C Hamano | e703d71 | 2014-03-23 15:58:12 -0700 | [diff] [blame] | 310 | { OPTION_STRING, 'S', "gpg-sign", &sign_commit, N_("key-id"), |
Nguyễn Thái Ngọc Duy | 962e629 | 2012-08-20 19:32:24 +0700 | [diff] [blame] | 311 | N_("GPG sign commit"), PARSE_OPT_OPTARG, NULL, (intptr_t) "" }, |
Denton Liu | a03b555 | 2020-04-07 10:28:07 -0400 | [diff] [blame] | 312 | OPT_AUTOSTASH(&autostash), |
Stefan Beller | d5d09d4 | 2013-08-03 13:51:19 +0200 | [diff] [blame] | 313 | OPT_BOOL(0, "overwrite-ignore", &overwrite_ignore, N_("update ignored files (default)")), |
Bradley M. Kuhn | 3abd4a6 | 2020-10-19 18:03:55 -0700 | [diff] [blame] | 314 | OPT_BOOL(0, "signoff", &signoff, N_("add a Signed-off-by trailer")), |
Michael J Gruber | bc40ce4 | 2019-08-07 11:57:08 -0700 | [diff] [blame] | 315 | OPT_BOOL(0, "no-verify", &no_verify, N_("bypass pre-merge-commit and commit-msg hooks")), |
Miklos Vajna | 1c7b76b | 2008-07-07 19:24:20 +0200 | [diff] [blame] | 316 | OPT_END() |
| 317 | }; |
| 318 | |
brian m. carlson | 5268431 | 2017-02-21 23:47:28 +0000 | [diff] [blame] | 319 | static int save_state(struct object_id *stash) |
Miklos Vajna | 1c7b76b | 2008-07-07 19:24:20 +0200 | [diff] [blame] | 320 | { |
| 321 | int len; |
René Scharfe | d318027 | 2014-08-19 21:09:35 +0200 | [diff] [blame] | 322 | struct child_process cp = CHILD_PROCESS_INIT; |
Miklos Vajna | 1c7b76b | 2008-07-07 19:24:20 +0200 | [diff] [blame] | 323 | struct strbuf buffer = STRBUF_INIT; |
Elijah Newren | 1369f14 | 2022-07-23 01:53:15 +0000 | [diff] [blame] | 324 | struct lock_file lock_file = LOCK_INIT; |
| 325 | int fd; |
Rene Scharfe | 150888e | 2017-08-30 19:49:49 +0200 | [diff] [blame] | 326 | int rc = -1; |
Miklos Vajna | 1c7b76b | 2008-07-07 19:24:20 +0200 | [diff] [blame] | 327 | |
Elijah Newren | 1369f14 | 2022-07-23 01:53:15 +0000 | [diff] [blame] | 328 | fd = repo_hold_locked_index(the_repository, &lock_file, 0); |
Ævar Arnfjörð Bjarmason | 07047d6 | 2022-11-19 14:07:38 +0100 | [diff] [blame] | 329 | refresh_index(&the_index, REFRESH_QUIET, NULL, NULL, NULL); |
Elijah Newren | 1369f14 | 2022-07-23 01:53:15 +0000 | [diff] [blame] | 330 | if (0 <= fd) |
| 331 | repo_update_index_if_able(the_repository, &lock_file); |
| 332 | rollback_lock_file(&lock_file); |
| 333 | |
Ævar Arnfjörð Bjarmason | 2b70989 | 2021-11-25 23:52:20 +0100 | [diff] [blame] | 334 | strvec_pushl(&cp.args, "stash", "create", NULL); |
Miklos Vajna | 1c7b76b | 2008-07-07 19:24:20 +0200 | [diff] [blame] | 335 | cp.out = -1; |
| 336 | cp.git_cmd = 1; |
| 337 | |
| 338 | if (start_command(&cp)) |
Ævar Arnfjörð Bjarmason | bacec47 | 2011-02-22 23:41:59 +0000 | [diff] [blame] | 339 | die(_("could not run stash.")); |
Miklos Vajna | 1c7b76b | 2008-07-07 19:24:20 +0200 | [diff] [blame] | 340 | len = strbuf_read(&buffer, cp.out, 1024); |
| 341 | close(cp.out); |
| 342 | |
| 343 | if (finish_command(&cp) || len < 0) |
Ævar Arnfjörð Bjarmason | bacec47 | 2011-02-22 23:41:59 +0000 | [diff] [blame] | 344 | die(_("stash failed")); |
Nguyễn Thái Ngọc Duy | b4fd940 | 2011-08-19 21:50:05 +0700 | [diff] [blame] | 345 | else if (!len) /* no changes */ |
Rene Scharfe | 150888e | 2017-08-30 19:49:49 +0200 | [diff] [blame] | 346 | goto out; |
Miklos Vajna | 1c7b76b | 2008-07-07 19:24:20 +0200 | [diff] [blame] | 347 | strbuf_setlen(&buffer, buffer.len-1); |
Ævar Arnfjörð Bjarmason | d850b7a | 2023-03-28 15:58:46 +0200 | [diff] [blame] | 348 | if (repo_get_oid(the_repository, buffer.buf, stash)) |
Ævar Arnfjörð Bjarmason | bacec47 | 2011-02-22 23:41:59 +0000 | [diff] [blame] | 349 | die(_("not a valid object: %s"), buffer.buf); |
Rene Scharfe | 150888e | 2017-08-30 19:49:49 +0200 | [diff] [blame] | 350 | rc = 0; |
| 351 | out: |
| 352 | strbuf_release(&buffer); |
| 353 | return rc; |
Miklos Vajna | 1c7b76b | 2008-07-07 19:24:20 +0200 | [diff] [blame] | 354 | } |
| 355 | |
Ævar Arnfjörð Bjarmason | 9397f3c | 2022-10-30 12:42:59 +0100 | [diff] [blame] | 356 | static void read_empty(const struct object_id *oid) |
Clemens Buchacher | 172b642 | 2010-11-14 23:07:49 +0100 | [diff] [blame] | 357 | { |
René Scharfe | 4120294 | 2022-10-30 12:50:27 +0100 | [diff] [blame] | 358 | struct child_process cmd = CHILD_PROCESS_INIT; |
Clemens Buchacher | 172b642 | 2010-11-14 23:07:49 +0100 | [diff] [blame] | 359 | |
René Scharfe | 4120294 | 2022-10-30 12:50:27 +0100 | [diff] [blame] | 360 | strvec_pushl(&cmd.args, "read-tree", "-m", "-u", empty_tree_oid_hex(), |
| 361 | oid_to_hex(oid), NULL); |
| 362 | cmd.git_cmd = 1; |
Clemens Buchacher | 172b642 | 2010-11-14 23:07:49 +0100 | [diff] [blame] | 363 | |
René Scharfe | 4120294 | 2022-10-30 12:50:27 +0100 | [diff] [blame] | 364 | if (run_command(&cmd)) |
Ævar Arnfjörð Bjarmason | bacec47 | 2011-02-22 23:41:59 +0000 | [diff] [blame] | 365 | die(_("read-tree failed")); |
Clemens Buchacher | 172b642 | 2010-11-14 23:07:49 +0100 | [diff] [blame] | 366 | } |
| 367 | |
Ævar Arnfjörð Bjarmason | 9397f3c | 2022-10-30 12:42:59 +0100 | [diff] [blame] | 368 | static void reset_hard(const struct object_id *oid) |
Miklos Vajna | 1c7b76b | 2008-07-07 19:24:20 +0200 | [diff] [blame] | 369 | { |
René Scharfe | 4120294 | 2022-10-30 12:50:27 +0100 | [diff] [blame] | 370 | struct child_process cmd = CHILD_PROCESS_INIT; |
Miklos Vajna | 1c7b76b | 2008-07-07 19:24:20 +0200 | [diff] [blame] | 371 | |
René Scharfe | 4120294 | 2022-10-30 12:50:27 +0100 | [diff] [blame] | 372 | strvec_pushl(&cmd.args, "read-tree", "-v", "--reset", "-u", |
| 373 | oid_to_hex(oid), NULL); |
| 374 | cmd.git_cmd = 1; |
Miklos Vajna | 1c7b76b | 2008-07-07 19:24:20 +0200 | [diff] [blame] | 375 | |
René Scharfe | 4120294 | 2022-10-30 12:50:27 +0100 | [diff] [blame] | 376 | if (run_command(&cmd)) |
Ævar Arnfjörð Bjarmason | bacec47 | 2011-02-22 23:41:59 +0000 | [diff] [blame] | 377 | die(_("read-tree failed")); |
Miklos Vajna | 1c7b76b | 2008-07-07 19:24:20 +0200 | [diff] [blame] | 378 | } |
| 379 | |
brian m. carlson | 5268431 | 2017-02-21 23:47:28 +0000 | [diff] [blame] | 380 | static void restore_state(const struct object_id *head, |
| 381 | const struct object_id *stash) |
Miklos Vajna | 1c7b76b | 2008-07-07 19:24:20 +0200 | [diff] [blame] | 382 | { |
René Scharfe | 0e90673 | 2022-10-30 12:51:14 +0100 | [diff] [blame] | 383 | struct child_process cmd = CHILD_PROCESS_INIT; |
Miklos Vajna | 1c7b76b | 2008-07-07 19:24:20 +0200 | [diff] [blame] | 384 | |
Ævar Arnfjörð Bjarmason | 9397f3c | 2022-10-30 12:42:59 +0100 | [diff] [blame] | 385 | reset_hard(head); |
Miklos Vajna | 1c7b76b | 2008-07-07 19:24:20 +0200 | [diff] [blame] | 386 | |
Elijah Newren | c23fc07 | 2022-07-23 01:53:18 +0000 | [diff] [blame] | 387 | if (is_null_oid(stash)) |
| 388 | goto refresh_cache; |
| 389 | |
René Scharfe | 0e90673 | 2022-10-30 12:51:14 +0100 | [diff] [blame] | 390 | strvec_pushl(&cmd.args, "stash", "apply", "--index", "--quiet", NULL); |
| 391 | strvec_push(&cmd.args, oid_to_hex(stash)); |
Miklos Vajna | 1c7b76b | 2008-07-07 19:24:20 +0200 | [diff] [blame] | 392 | |
| 393 | /* |
| 394 | * It is OK to ignore error here, for example when there was |
| 395 | * nothing to restore. |
| 396 | */ |
René Scharfe | 0e90673 | 2022-10-30 12:51:14 +0100 | [diff] [blame] | 397 | cmd.git_cmd = 1; |
| 398 | run_command(&cmd); |
Miklos Vajna | 1c7b76b | 2008-07-07 19:24:20 +0200 | [diff] [blame] | 399 | |
Elijah Newren | c23fc07 | 2022-07-23 01:53:18 +0000 | [diff] [blame] | 400 | refresh_cache: |
Ævar Arnfjörð Bjarmason | dfd0a89 | 2023-02-10 11:28:39 +0100 | [diff] [blame] | 401 | discard_index(&the_index); |
| 402 | if (repo_read_index(the_repository) < 0) |
Elijah Newren | c23fc07 | 2022-07-23 01:53:18 +0000 | [diff] [blame] | 403 | die(_("could not read index")); |
Miklos Vajna | 1c7b76b | 2008-07-07 19:24:20 +0200 | [diff] [blame] | 404 | } |
| 405 | |
| 406 | /* This is called when no merge was necessary. */ |
Josh Soref | ad9322d | 2021-05-02 01:14:23 -0400 | [diff] [blame] | 407 | static void finish_up_to_date(void) |
Miklos Vajna | 1c7b76b | 2008-07-07 19:24:20 +0200 | [diff] [blame] | 408 | { |
Josh Soref | ad9322d | 2021-05-02 01:14:23 -0400 | [diff] [blame] | 409 | if (verbosity >= 0) { |
| 410 | if (squash) |
| 411 | puts(_("Already up to date. (nothing to squash)")); |
| 412 | else |
| 413 | puts(_("Already up to date.")); |
| 414 | } |
Nguyễn Thái Ngọc Duy | b643355 | 2019-05-09 17:10:27 +0700 | [diff] [blame] | 415 | remove_merge_branch_state(the_repository); |
Miklos Vajna | 1c7b76b | 2008-07-07 19:24:20 +0200 | [diff] [blame] | 416 | } |
| 417 | |
Junio C Hamano | 4c57bd2 | 2012-04-16 16:15:13 -0700 | [diff] [blame] | 418 | static void squash_message(struct commit *commit, struct commit_list *remoteheads) |
Miklos Vajna | 1c7b76b | 2008-07-07 19:24:20 +0200 | [diff] [blame] | 419 | { |
| 420 | struct rev_info rev; |
Brandon Casey | f285a2d | 2008-10-09 14:12:12 -0500 | [diff] [blame] | 421 | struct strbuf out = STRBUF_INIT; |
Miklos Vajna | 1c7b76b | 2008-07-07 19:24:20 +0200 | [diff] [blame] | 422 | struct commit_list *j; |
Thomas Rast | dd2e794 | 2009-10-19 17:48:08 +0200 | [diff] [blame] | 423 | struct pretty_print_context ctx = {0}; |
Miklos Vajna | 1c7b76b | 2008-07-07 19:24:20 +0200 | [diff] [blame] | 424 | |
Ævar Arnfjörð Bjarmason | bacec47 | 2011-02-22 23:41:59 +0000 | [diff] [blame] | 425 | printf(_("Squash commit -- not updating HEAD\n")); |
Miklos Vajna | 1c7b76b | 2008-07-07 19:24:20 +0200 | [diff] [blame] | 426 | |
Nguyễn Thái Ngọc Duy | 2abf350 | 2018-09-21 17:57:38 +0200 | [diff] [blame] | 427 | repo_init_revisions(the_repository, &rev, NULL); |
Sergey Organov | 09322b1 | 2020-12-21 18:19:38 +0300 | [diff] [blame] | 428 | diff_merges_suppress(&rev); |
Miklos Vajna | 1c7b76b | 2008-07-07 19:24:20 +0200 | [diff] [blame] | 429 | rev.commit_format = CMIT_FMT_MEDIUM; |
| 430 | |
Miklos Vajna | 1c7b76b | 2008-07-07 19:24:20 +0200 | [diff] [blame] | 431 | commit->object.flags |= UNINTERESTING; |
| 432 | add_pending_object(&rev, &commit->object, NULL); |
| 433 | |
| 434 | for (j = remoteheads; j; j = j->next) |
| 435 | add_pending_object(&rev, &j->item->object, NULL); |
| 436 | |
| 437 | setup_revisions(0, NULL, &rev, NULL); |
| 438 | if (prepare_revision_walk(&rev)) |
Ævar Arnfjörð Bjarmason | bacec47 | 2011-02-22 23:41:59 +0000 | [diff] [blame] | 439 | die(_("revision walk setup failed")); |
Miklos Vajna | 1c7b76b | 2008-07-07 19:24:20 +0200 | [diff] [blame] | 440 | |
Thomas Rast | dd2e794 | 2009-10-19 17:48:08 +0200 | [diff] [blame] | 441 | ctx.abbrev = rev.abbrev; |
| 442 | ctx.date_mode = rev.date_mode; |
Jeff King | 6bf1394 | 2011-05-26 18:27:49 -0400 | [diff] [blame] | 443 | ctx.fmt = rev.commit_format; |
Thomas Rast | dd2e794 | 2009-10-19 17:48:08 +0200 | [diff] [blame] | 444 | |
Miklos Vajna | 1c7b76b | 2008-07-07 19:24:20 +0200 | [diff] [blame] | 445 | strbuf_addstr(&out, "Squashed commit of the following:\n"); |
| 446 | while ((commit = get_revision(&rev)) != NULL) { |
| 447 | strbuf_addch(&out, '\n'); |
| 448 | strbuf_addf(&out, "commit %s\n", |
brian m. carlson | f2fd076 | 2015-11-10 02:22:28 +0000 | [diff] [blame] | 449 | oid_to_hex(&commit->object.oid)); |
Jeff King | 6bf1394 | 2011-05-26 18:27:49 -0400 | [diff] [blame] | 450 | pretty_print_commit(&ctx, commit, &out); |
Miklos Vajna | 1c7b76b | 2008-07-07 19:24:20 +0200 | [diff] [blame] | 451 | } |
Stefan Beller | 102de88 | 2018-05-17 15:51:51 -0700 | [diff] [blame] | 452 | write_file_buf(git_path_squash_msg(the_repository), out.buf, out.len); |
Miklos Vajna | 1c7b76b | 2008-07-07 19:24:20 +0200 | [diff] [blame] | 453 | strbuf_release(&out); |
Ævar Arnfjörð Bjarmason | 2108fe4 | 2022-04-13 22:01:36 +0200 | [diff] [blame] | 454 | release_revisions(&rev); |
Miklos Vajna | 1c7b76b | 2008-07-07 19:24:20 +0200 | [diff] [blame] | 455 | } |
| 456 | |
Nguyễn Thái Ngọc Duy | 894642f | 2011-09-17 21:57:44 +1000 | [diff] [blame] | 457 | static void finish(struct commit *head_commit, |
Junio C Hamano | 4c57bd2 | 2012-04-16 16:15:13 -0700 | [diff] [blame] | 458 | struct commit_list *remoteheads, |
brian m. carlson | 5268431 | 2017-02-21 23:47:28 +0000 | [diff] [blame] | 459 | const struct object_id *new_head, const char *msg) |
Miklos Vajna | 1c7b76b | 2008-07-07 19:24:20 +0200 | [diff] [blame] | 460 | { |
Brandon Casey | f285a2d | 2008-10-09 14:12:12 -0500 | [diff] [blame] | 461 | struct strbuf reflog_message = STRBUF_INIT; |
brian m. carlson | 5268431 | 2017-02-21 23:47:28 +0000 | [diff] [blame] | 462 | const struct object_id *head = &head_commit->object.oid; |
Miklos Vajna | 1c7b76b | 2008-07-07 19:24:20 +0200 | [diff] [blame] | 463 | |
Miklos Vajna | 1c7b76b | 2008-07-07 19:24:20 +0200 | [diff] [blame] | 464 | if (!msg) |
| 465 | strbuf_addstr(&reflog_message, getenv("GIT_REFLOG_ACTION")); |
| 466 | else { |
Tuncer Ayaz | 7f87aff | 2008-11-15 01:14:24 +0100 | [diff] [blame] | 467 | if (verbosity >= 0) |
| 468 | printf("%s\n", msg); |
Miklos Vajna | 1c7b76b | 2008-07-07 19:24:20 +0200 | [diff] [blame] | 469 | strbuf_addf(&reflog_message, "%s: %s", |
| 470 | getenv("GIT_REFLOG_ACTION"), msg); |
| 471 | } |
| 472 | if (squash) { |
Junio C Hamano | 4c57bd2 | 2012-04-16 16:15:13 -0700 | [diff] [blame] | 473 | squash_message(head_commit, remoteheads); |
Miklos Vajna | 1c7b76b | 2008-07-07 19:24:20 +0200 | [diff] [blame] | 474 | } else { |
Tuncer Ayaz | 7f87aff | 2008-11-15 01:14:24 +0100 | [diff] [blame] | 475 | if (verbosity >= 0 && !merge_msg.len) |
Ævar Arnfjörð Bjarmason | bacec47 | 2011-02-22 23:41:59 +0000 | [diff] [blame] | 476 | printf(_("No merge message -- not updating HEAD\n")); |
Miklos Vajna | 1c7b76b | 2008-07-07 19:24:20 +0200 | [diff] [blame] | 477 | else { |
brian m. carlson | ae07777 | 2017-10-15 22:06:51 +0000 | [diff] [blame] | 478 | update_ref(reflog_message.buf, "HEAD", new_head, head, |
| 479 | 0, UPDATE_REFS_DIE_ON_ERR); |
Miklos Vajna | 1c7b76b | 2008-07-07 19:24:20 +0200 | [diff] [blame] | 480 | /* |
| 481 | * We ignore errors in 'gc --auto', since the |
| 482 | * user should see them. |
| 483 | */ |
Derrick Stolee | a95ce12 | 2020-09-17 18:11:44 +0000 | [diff] [blame] | 484 | run_auto_maintenance(verbosity < 0); |
Miklos Vajna | 1c7b76b | 2008-07-07 19:24:20 +0200 | [diff] [blame] | 485 | } |
| 486 | } |
| 487 | if (new_head && show_diffstat) { |
| 488 | struct diff_options opts; |
Nguyễn Thái Ngọc Duy | e675765 | 2018-09-21 17:57:24 +0200 | [diff] [blame] | 489 | repo_diff_setup(the_repository, &opts); |
Zbigniew Jędrzejewski-Szmek | 7a7159a | 2012-03-01 13:26:42 +0100 | [diff] [blame] | 490 | opts.stat_width = -1; /* use full terminal width */ |
Zbigniew Jędrzejewski-Szmek | df44483 | 2012-03-01 13:26:46 +0100 | [diff] [blame] | 491 | opts.stat_graph_width = -1; /* respect statGraphWidth config */ |
Miklos Vajna | 1c7b76b | 2008-07-07 19:24:20 +0200 | [diff] [blame] | 492 | opts.output_format |= |
| 493 | DIFF_FORMAT_SUMMARY | DIFF_FORMAT_DIFFSTAT; |
| 494 | opts.detect_rename = DIFF_DETECT_RENAME; |
Thomas Rast | 2845265 | 2012-08-03 14:16:24 +0200 | [diff] [blame] | 495 | diff_setup_done(&opts); |
Brandon Williams | 66f414f | 2017-05-30 10:31:03 -0700 | [diff] [blame] | 496 | diff_tree_oid(head, new_head, "", &opts); |
Miklos Vajna | 1c7b76b | 2008-07-07 19:24:20 +0200 | [diff] [blame] | 497 | diffcore_std(&opts); |
| 498 | diff_flush(&opts); |
| 499 | } |
| 500 | |
| 501 | /* Run a post-merge hook */ |
Emily Shaffer | 67ad630 | 2021-12-22 04:59:34 +0100 | [diff] [blame] | 502 | run_hooks_l("post-merge", squash ? "1" : "0", NULL); |
Miklos Vajna | 1c7b76b | 2008-07-07 19:24:20 +0200 | [diff] [blame] | 503 | |
Elijah Newren | d3a9295 | 2022-08-23 02:42:19 +0000 | [diff] [blame] | 504 | if (new_head) |
| 505 | apply_autostash(git_path_merge_autostash(the_repository)); |
Miklos Vajna | 1c7b76b | 2008-07-07 19:24:20 +0200 | [diff] [blame] | 506 | strbuf_release(&reflog_message); |
| 507 | } |
| 508 | |
| 509 | /* Get the name for the merge commit's message. */ |
| 510 | static void merge_name(const char *remote, struct strbuf *msg) |
| 511 | { |
Junio C Hamano | ae8e4c9 | 2011-11-07 13:26:22 -0800 | [diff] [blame] | 512 | struct commit *remote_head; |
brian m. carlson | 5268431 | 2017-02-21 23:47:28 +0000 | [diff] [blame] | 513 | struct object_id branch_head; |
Junio C Hamano | c9717ee | 2009-02-13 23:26:12 -0800 | [diff] [blame] | 514 | struct strbuf bname = STRBUF_INIT; |
Nguyễn Thái Ngọc Duy | e2e5ac2 | 2018-05-19 07:28:30 +0200 | [diff] [blame] | 515 | struct merge_remote_desc *desc; |
Miklos Vajna | 1c7b76b | 2008-07-07 19:24:20 +0200 | [diff] [blame] | 516 | const char *ptr; |
Andrzej Hunt | 8c05e42 | 2021-07-25 15:08:28 +0200 | [diff] [blame] | 517 | char *found_ref = NULL; |
Miklos Vajna | 1c7b76b | 2008-07-07 19:24:20 +0200 | [diff] [blame] | 518 | int len, early; |
| 519 | |
Jeff King | 0e9f62d | 2017-03-02 03:23:01 -0500 | [diff] [blame] | 520 | strbuf_branchname(&bname, remote, 0); |
Junio C Hamano | a552de7 | 2009-03-21 13:17:30 -0700 | [diff] [blame] | 521 | remote = bname.buf; |
Junio C Hamano | c9717ee | 2009-02-13 23:26:12 -0800 | [diff] [blame] | 522 | |
brian m. carlson | 5268431 | 2017-02-21 23:47:28 +0000 | [diff] [blame] | 523 | oidclr(&branch_head); |
Junio C Hamano | ae8e4c9 | 2011-11-07 13:26:22 -0800 | [diff] [blame] | 524 | remote_head = get_merge_parent(remote); |
Miklos Vajna | 1c7b76b | 2008-07-07 19:24:20 +0200 | [diff] [blame] | 525 | if (!remote_head) |
Ævar Arnfjörð Bjarmason | bacec47 | 2011-02-22 23:41:59 +0000 | [diff] [blame] | 526 | die(_("'%s' does not point to a commit"), remote); |
Miklos Vajna | 1c7b76b | 2008-07-07 19:24:20 +0200 | [diff] [blame] | 527 | |
Ævar Arnfjörð Bjarmason | 12cb1c1 | 2023-03-28 15:58:54 +0200 | [diff] [blame] | 528 | if (repo_dwim_ref(the_repository, remote, strlen(remote), &branch_head, |
| 529 | &found_ref, 0) > 0) { |
Christian Couder | 5955654 | 2013-11-30 21:55:40 +0100 | [diff] [blame] | 530 | if (starts_with(found_ref, "refs/heads/")) { |
Jeff King | 751c597 | 2009-08-09 06:02:24 -0400 | [diff] [blame] | 531 | strbuf_addf(msg, "%s\t\tbranch '%s' of .\n", |
brian m. carlson | 5268431 | 2017-02-21 23:47:28 +0000 | [diff] [blame] | 532 | oid_to_hex(&branch_head), remote); |
Jeff King | 751c597 | 2009-08-09 06:02:24 -0400 | [diff] [blame] | 533 | goto cleanup; |
| 534 | } |
Christian Couder | 5955654 | 2013-11-30 21:55:40 +0100 | [diff] [blame] | 535 | if (starts_with(found_ref, "refs/tags/")) { |
Junio C Hamano | 57b58db | 2011-11-04 21:31:28 -0700 | [diff] [blame] | 536 | strbuf_addf(msg, "%s\t\ttag '%s' of .\n", |
brian m. carlson | 5268431 | 2017-02-21 23:47:28 +0000 | [diff] [blame] | 537 | oid_to_hex(&branch_head), remote); |
Junio C Hamano | 57b58db | 2011-11-04 21:31:28 -0700 | [diff] [blame] | 538 | goto cleanup; |
| 539 | } |
Christian Couder | 5955654 | 2013-11-30 21:55:40 +0100 | [diff] [blame] | 540 | if (starts_with(found_ref, "refs/remotes/")) { |
Matthieu Moy | 1393123 | 2010-11-02 16:31:25 +0100 | [diff] [blame] | 541 | strbuf_addf(msg, "%s\t\tremote-tracking branch '%s' of .\n", |
brian m. carlson | 5268431 | 2017-02-21 23:47:28 +0000 | [diff] [blame] | 542 | oid_to_hex(&branch_head), remote); |
Jeff King | 69a8b7c | 2009-08-09 06:02:51 -0400 | [diff] [blame] | 543 | goto cleanup; |
| 544 | } |
Miklos Vajna | 1c7b76b | 2008-07-07 19:24:20 +0200 | [diff] [blame] | 545 | } |
| 546 | |
| 547 | /* See if remote matches <name>^^^.. or <name>~<number> */ |
| 548 | for (len = 0, ptr = remote + strlen(remote); |
| 549 | remote < ptr && ptr[-1] == '^'; |
| 550 | ptr--) |
| 551 | len++; |
| 552 | if (len) |
| 553 | early = 1; |
| 554 | else { |
| 555 | early = 0; |
| 556 | ptr = strrchr(remote, '~'); |
| 557 | if (ptr) { |
| 558 | int seen_nonzero = 0; |
| 559 | |
| 560 | len++; /* count ~ */ |
| 561 | while (*++ptr && isdigit(*ptr)) { |
| 562 | seen_nonzero |= (*ptr != '0'); |
| 563 | len++; |
| 564 | } |
| 565 | if (*ptr) |
| 566 | len = 0; /* not ...~<number> */ |
| 567 | else if (seen_nonzero) |
| 568 | early = 1; |
| 569 | else if (len == 1) |
| 570 | early = 1; /* "name~" is "name~1"! */ |
| 571 | } |
| 572 | } |
| 573 | if (len) { |
| 574 | struct strbuf truname = STRBUF_INIT; |
Junio C Hamano | 1016658 | 2015-04-23 14:37:13 -0700 | [diff] [blame] | 575 | strbuf_addf(&truname, "refs/heads/%s", remote); |
Junio C Hamano | 9b6bf4d | 2008-07-30 01:12:19 -0700 | [diff] [blame] | 576 | strbuf_setlen(&truname, truname.len - len); |
Nguyễn Thái Ngọc Duy | c689332 | 2011-11-13 17:22:14 +0700 | [diff] [blame] | 577 | if (ref_exists(truname.buf)) { |
Miklos Vajna | 1c7b76b | 2008-07-07 19:24:20 +0200 | [diff] [blame] | 578 | strbuf_addf(msg, |
| 579 | "%s\t\tbranch '%s'%s of .\n", |
brian m. carlson | c368dde | 2016-06-24 23:09:22 +0000 | [diff] [blame] | 580 | oid_to_hex(&remote_head->object.oid), |
Junio C Hamano | 9b6bf4d | 2008-07-30 01:12:19 -0700 | [diff] [blame] | 581 | truname.buf + 11, |
Miklos Vajna | 1c7b76b | 2008-07-07 19:24:20 +0200 | [diff] [blame] | 582 | (early ? " (early part)" : "")); |
Junio C Hamano | c9717ee | 2009-02-13 23:26:12 -0800 | [diff] [blame] | 583 | strbuf_release(&truname); |
| 584 | goto cleanup; |
Miklos Vajna | 1c7b76b | 2008-07-07 19:24:20 +0200 | [diff] [blame] | 585 | } |
Junio C Hamano | 1016658 | 2015-04-23 14:37:13 -0700 | [diff] [blame] | 586 | strbuf_release(&truname); |
Miklos Vajna | 1c7b76b | 2008-07-07 19:24:20 +0200 | [diff] [blame] | 587 | } |
Junio C Hamano | 2d1495f | 2013-03-19 09:55:34 -0700 | [diff] [blame] | 588 | |
Nguyễn Thái Ngọc Duy | e2e5ac2 | 2018-05-19 07:28:30 +0200 | [diff] [blame] | 589 | desc = merge_remote_util(remote_head); |
| 590 | if (desc && desc->obj && desc->obj->type == OBJ_TAG) { |
| 591 | strbuf_addf(msg, "%s\t\t%s '%s'\n", |
| 592 | oid_to_hex(&desc->obj->oid), |
| 593 | type_name(desc->obj->type), |
| 594 | remote); |
| 595 | goto cleanup; |
Junio C Hamano | 2d1495f | 2013-03-19 09:55:34 -0700 | [diff] [blame] | 596 | } |
| 597 | |
Miklos Vajna | 1c7b76b | 2008-07-07 19:24:20 +0200 | [diff] [blame] | 598 | strbuf_addf(msg, "%s\t\tcommit '%s'\n", |
brian m. carlson | c368dde | 2016-06-24 23:09:22 +0000 | [diff] [blame] | 599 | oid_to_hex(&remote_head->object.oid), remote); |
Junio C Hamano | c9717ee | 2009-02-13 23:26:12 -0800 | [diff] [blame] | 600 | cleanup: |
Andrzej Hunt | 8c05e42 | 2021-07-25 15:08:28 +0200 | [diff] [blame] | 601 | free(found_ref); |
Junio C Hamano | c9717ee | 2009-02-13 23:26:12 -0800 | [diff] [blame] | 602 | strbuf_release(&bname); |
Miklos Vajna | 1c7b76b | 2008-07-07 19:24:20 +0200 | [diff] [blame] | 603 | } |
| 604 | |
Junio C Hamano | 0d8fc3e | 2011-05-04 17:42:51 -0700 | [diff] [blame] | 605 | static void parse_branch_merge_options(char *bmo) |
| 606 | { |
| 607 | const char **argv; |
| 608 | int argc; |
| 609 | |
| 610 | if (!bmo) |
| 611 | return; |
| 612 | argc = split_cmdline(bmo, &argv); |
| 613 | if (argc < 0) |
Junio C Hamano | c7fe5b6 | 2011-05-11 11:38:36 -0700 | [diff] [blame] | 614 | die(_("Bad branch.%s.mergeoptions string: %s"), branch, |
Nguyễn Thái Ngọc Duy | a7412ae | 2018-11-10 06:16:01 +0100 | [diff] [blame] | 615 | _(split_cmdline_strerror(argc))); |
René Scharfe | 2756ca4 | 2014-09-16 20:56:57 +0200 | [diff] [blame] | 616 | REALLOC_ARRAY(argv, argc + 2); |
René Scharfe | f331ab9 | 2017-07-15 22:00:45 +0200 | [diff] [blame] | 617 | MOVE_ARRAY(argv + 1, argv, argc + 1); |
Junio C Hamano | 0d8fc3e | 2011-05-04 17:42:51 -0700 | [diff] [blame] | 618 | argc++; |
| 619 | argv[0] = "branch.*.mergeoptions"; |
| 620 | parse_options(argc, argv, NULL, builtin_merge_options, |
| 621 | builtin_merge_usage, 0); |
| 622 | free(argv); |
| 623 | } |
| 624 | |
Glen Choo | a4e7e31 | 2023-06-28 19:26:22 +0000 | [diff] [blame] | 625 | static int git_merge_config(const char *k, const char *v, |
| 626 | const struct config_context *ctx, void *cb) |
Miklos Vajna | 1c7b76b | 2008-07-07 19:24:20 +0200 | [diff] [blame] | 627 | { |
Junio C Hamano | 898eacd | 2011-10-06 23:12:09 -0700 | [diff] [blame] | 628 | int status; |
Martin Ågren | 9881b45 | 2020-04-11 09:11:45 +0200 | [diff] [blame] | 629 | const char *str; |
Junio C Hamano | 898eacd | 2011-10-06 23:12:09 -0700 | [diff] [blame] | 630 | |
Martin Ågren | 9881b45 | 2020-04-11 09:11:45 +0200 | [diff] [blame] | 631 | if (branch && |
| 632 | skip_prefix(k, "branch.", &str) && |
| 633 | skip_prefix(str, branch, &str) && |
| 634 | !strcmp(str, ".mergeoptions")) { |
Junio C Hamano | 0d8fc3e | 2011-05-04 17:42:51 -0700 | [diff] [blame] | 635 | free(branch_mergeoptions); |
| 636 | branch_mergeoptions = xstrdup(v); |
| 637 | return 0; |
Miklos Vajna | 1c7b76b | 2008-07-07 19:24:20 +0200 | [diff] [blame] | 638 | } |
| 639 | |
| 640 | if (!strcmp(k, "merge.diffstat") || !strcmp(k, "merge.stat")) |
| 641 | show_diffstat = git_config_bool(k, v); |
Hans Jerry Illikainen | ca779e8 | 2017-12-10 06:53:57 +0000 | [diff] [blame] | 642 | else if (!strcmp(k, "merge.verifysignatures")) |
| 643 | verify_signatures = git_config_bool(k, v); |
Miklos Vajna | 1c7b76b | 2008-07-07 19:24:20 +0200 | [diff] [blame] | 644 | else if (!strcmp(k, "pull.twohead")) |
| 645 | return git_config_string(&pull_twohead, k, v); |
| 646 | else if (!strcmp(k, "pull.octopus")) |
| 647 | return git_config_string(&pull_octopus, k, v); |
Denton Liu | d540b70 | 2019-04-17 11:23:27 +0100 | [diff] [blame] | 648 | else if (!strcmp(k, "commit.cleanup")) |
| 649 | return git_config_string(&cleanup_arg, k, v); |
Junio C Hamano | 898eacd | 2011-10-06 23:12:09 -0700 | [diff] [blame] | 650 | else if (!strcmp(k, "merge.ff")) { |
Martin Ågren | 8957661 | 2017-08-07 20:20:49 +0200 | [diff] [blame] | 651 | int boolval = git_parse_maybe_bool(v); |
Junio C Hamano | f23e8de | 2011-05-06 12:27:05 -0700 | [diff] [blame] | 652 | if (0 <= boolval) { |
Miklos Vajna | a54841e | 2013-07-02 16:47:57 +0200 | [diff] [blame] | 653 | fast_forward = boolval ? FF_ALLOW : FF_NO; |
Junio C Hamano | f23e8de | 2011-05-06 12:27:05 -0700 | [diff] [blame] | 654 | } else if (v && !strcmp(v, "only")) { |
Miklos Vajna | a54841e | 2013-07-02 16:47:57 +0200 | [diff] [blame] | 655 | fast_forward = FF_ONLY; |
Junio C Hamano | f23e8de | 2011-05-06 12:27:05 -0700 | [diff] [blame] | 656 | } /* do not barf on values from future versions of git */ |
| 657 | return 0; |
Junio C Hamano | 93e535a | 2011-03-23 23:48:24 -0700 | [diff] [blame] | 658 | } else if (!strcmp(k, "merge.defaulttoupstream")) { |
| 659 | default_to_upstream = git_config_bool(k, v); |
| 660 | return 0; |
Nicolas Vigier | d95bfb1 | 2013-11-05 00:14:41 +0100 | [diff] [blame] | 661 | } else if (!strcmp(k, "commit.gpgsign")) { |
| 662 | sign_commit = git_config_bool(k, v) ? "" : NULL; |
| 663 | return 0; |
Hans Jerry Illikainen | 54887b4 | 2019-12-27 13:55:57 +0000 | [diff] [blame] | 664 | } else if (!strcmp(k, "gpg.mintrustlevel")) { |
| 665 | check_trust_level = 0; |
Denton Liu | a03b555 | 2020-04-07 10:28:07 -0400 | [diff] [blame] | 666 | } else if (!strcmp(k, "merge.autostash")) { |
| 667 | autostash = git_config_bool(k, v); |
| 668 | return 0; |
Ramkumar Ramachandra | 96e9420 | 2010-09-08 23:29:54 +0530 | [diff] [blame] | 669 | } |
Junio C Hamano | ba3c69a | 2011-10-05 17:23:20 -0700 | [diff] [blame] | 670 | |
Glen Choo | a4e7e31 | 2023-06-28 19:26:22 +0000 | [diff] [blame] | 671 | status = fmt_merge_msg_config(k, v, ctx, cb); |
Junio C Hamano | 898eacd | 2011-10-06 23:12:09 -0700 | [diff] [blame] | 672 | if (status) |
| 673 | return status; |
Glen Choo | a4e7e31 | 2023-06-28 19:26:22 +0000 | [diff] [blame] | 674 | return git_diff_ui_config(k, v, ctx, cb); |
Miklos Vajna | 1c7b76b | 2008-07-07 19:24:20 +0200 | [diff] [blame] | 675 | } |
| 676 | |
brian m. carlson | 5268431 | 2017-02-21 23:47:28 +0000 | [diff] [blame] | 677 | static int read_tree_trivial(struct object_id *common, struct object_id *head, |
| 678 | struct object_id *one) |
Miklos Vajna | 1c7b76b | 2008-07-07 19:24:20 +0200 | [diff] [blame] | 679 | { |
| 680 | int i, nr_trees = 0; |
| 681 | struct tree *trees[MAX_UNPACK_TREES]; |
| 682 | struct tree_desc t[MAX_UNPACK_TREES]; |
| 683 | struct unpack_trees_options opts; |
| 684 | |
| 685 | memset(&opts, 0, sizeof(opts)); |
| 686 | opts.head_idx = 2; |
| 687 | opts.src_index = &the_index; |
| 688 | opts.dst_index = &the_index; |
| 689 | opts.update = 1; |
| 690 | opts.verbose_update = 1; |
| 691 | opts.trivial_merges_only = 1; |
| 692 | opts.merge = 1; |
Elijah Newren | 1b5f373 | 2021-09-27 16:33:43 +0000 | [diff] [blame] | 693 | opts.preserve_ignored = 0; /* FIXME: !overwrite_ignore */ |
brian m. carlson | a9dbc17 | 2017-05-06 22:10:37 +0000 | [diff] [blame] | 694 | trees[nr_trees] = parse_tree_indirect(common); |
Miklos Vajna | 1c7b76b | 2008-07-07 19:24:20 +0200 | [diff] [blame] | 695 | if (!trees[nr_trees++]) |
| 696 | return -1; |
brian m. carlson | a9dbc17 | 2017-05-06 22:10:37 +0000 | [diff] [blame] | 697 | trees[nr_trees] = parse_tree_indirect(head); |
Miklos Vajna | 1c7b76b | 2008-07-07 19:24:20 +0200 | [diff] [blame] | 698 | if (!trees[nr_trees++]) |
| 699 | return -1; |
brian m. carlson | a9dbc17 | 2017-05-06 22:10:37 +0000 | [diff] [blame] | 700 | trees[nr_trees] = parse_tree_indirect(one); |
Miklos Vajna | 1c7b76b | 2008-07-07 19:24:20 +0200 | [diff] [blame] | 701 | if (!trees[nr_trees++]) |
| 702 | return -1; |
| 703 | opts.fn = threeway_merge; |
Ævar Arnfjörð Bjarmason | dc59418 | 2022-11-19 14:07:34 +0100 | [diff] [blame] | 704 | cache_tree_free(&the_index.cache_tree); |
Miklos Vajna | 1c7b76b | 2008-07-07 19:24:20 +0200 | [diff] [blame] | 705 | for (i = 0; i < nr_trees; i++) { |
| 706 | parse_tree(trees[i]); |
| 707 | init_tree_desc(t+i, trees[i]->buffer, trees[i]->size); |
| 708 | } |
| 709 | if (unpack_trees(nr_trees, t, &opts)) |
| 710 | return -1; |
| 711 | return 0; |
| 712 | } |
| 713 | |
brian m. carlson | 5268431 | 2017-02-21 23:47:28 +0000 | [diff] [blame] | 714 | static void write_tree_trivial(struct object_id *oid) |
Miklos Vajna | 1c7b76b | 2008-07-07 19:24:20 +0200 | [diff] [blame] | 715 | { |
Ævar Arnfjörð Bjarmason | 9937086 | 2023-02-10 11:28:37 +0100 | [diff] [blame] | 716 | if (write_index_as_tree(oid, &the_index, get_index_file(), 0, NULL)) |
Ævar Arnfjörð Bjarmason | bacec47 | 2011-02-22 23:41:59 +0000 | [diff] [blame] | 717 | die(_("git write-tree failed to write a tree")); |
Miklos Vajna | 1c7b76b | 2008-07-07 19:24:20 +0200 | [diff] [blame] | 718 | } |
| 719 | |
Christian Couder | 3f9083c | 2010-03-31 21:22:06 +0200 | [diff] [blame] | 720 | static int try_merge_strategy(const char *strategy, struct commit_list *common, |
Junio C Hamano | 4c57bd2 | 2012-04-16 16:15:13 -0700 | [diff] [blame] | 721 | struct commit_list *remoteheads, |
Junio C Hamano | b439165 | 2015-03-25 22:00:48 -0700 | [diff] [blame] | 722 | struct commit *head) |
Christian Couder | 3f9083c | 2010-03-31 21:22:06 +0200 | [diff] [blame] | 723 | { |
Junio C Hamano | b439165 | 2015-03-25 22:00:48 -0700 | [diff] [blame] | 724 | const char *head_arg = "HEAD"; |
Miklos Vajna | 668f26f | 2008-10-03 15:02:31 +0200 | [diff] [blame] | 725 | |
Ævar Arnfjörð Bjarmason | 07047d6 | 2022-11-19 14:07:38 +0100 | [diff] [blame] | 726 | if (repo_refresh_and_write_index(the_repository, REFRESH_QUIET, |
| 727 | SKIP_IF_UNCHANGED, 0, NULL, NULL, |
| 728 | NULL) < 0) |
Ævar Arnfjörð Bjarmason | bacec47 | 2011-02-22 23:41:59 +0000 | [diff] [blame] | 729 | return error(_("Unable to write index.")); |
Miklos Vajna | 1c7b76b | 2008-07-07 19:24:20 +0200 | [diff] [blame] | 730 | |
Elijah Newren | 14c4586 | 2020-11-02 23:45:34 +0000 | [diff] [blame] | 731 | if (!strcmp(strategy, "recursive") || !strcmp(strategy, "subtree") || |
| 732 | !strcmp(strategy, "ort")) { |
Thomas Gummerer | e080b34 | 2019-09-11 19:20:26 +0100 | [diff] [blame] | 733 | struct lock_file lock = LOCK_INIT; |
Christian Couder | 3f9083c | 2010-03-31 21:22:06 +0200 | [diff] [blame] | 734 | int clean, x; |
Miklos Vajna | 18668f5 | 2008-08-28 15:43:00 +0200 | [diff] [blame] | 735 | struct commit *result; |
Miklos Vajna | 18668f5 | 2008-08-28 15:43:00 +0200 | [diff] [blame] | 736 | struct commit_list *reversed = NULL; |
| 737 | struct merge_options o; |
Christian Couder | 3f9083c | 2010-03-31 21:22:06 +0200 | [diff] [blame] | 738 | struct commit_list *j; |
Miklos Vajna | 18668f5 | 2008-08-28 15:43:00 +0200 | [diff] [blame] | 739 | |
| 740 | if (remoteheads->next) { |
Ævar Arnfjörð Bjarmason | bacec47 | 2011-02-22 23:41:59 +0000 | [diff] [blame] | 741 | error(_("Not handling anything other than two heads merge.")); |
Miklos Vajna | 18668f5 | 2008-08-28 15:43:00 +0200 | [diff] [blame] | 742 | return 2; |
| 743 | } |
| 744 | |
Nguyễn Thái Ngọc Duy | 0d6caa2 | 2019-01-12 09:13:29 +0700 | [diff] [blame] | 745 | init_merge_options(&o, the_repository); |
Miklos Vajna | 18668f5 | 2008-08-28 15:43:00 +0200 | [diff] [blame] | 746 | if (!strcmp(strategy, "subtree")) |
Junio C Hamano | 85e51b7 | 2008-06-30 22:18:57 -0700 | [diff] [blame] | 747 | o.subtree_shift = ""; |
Avery Pennarun | 8cc5b29 | 2009-11-25 21:23:55 -0500 | [diff] [blame] | 748 | |
Jeff King | 99bfc66 | 2011-02-20 04:53:21 -0500 | [diff] [blame] | 749 | o.show_rename_progress = |
| 750 | show_progress == -1 ? isatty(2) : show_progress; |
Jonathan Nieder | 7610fa5 | 2010-08-05 06:32:41 -0500 | [diff] [blame] | 751 | |
Jonathan Nieder | 635a7bb | 2010-08-26 00:47:58 -0500 | [diff] [blame] | 752 | for (x = 0; x < xopts_nr; x++) |
| 753 | if (parse_merge_opt(&o, xopts[x])) |
Elijah Newren | 81483fe | 2021-08-04 23:50:54 +0000 | [diff] [blame] | 754 | die(_("unknown strategy option: -X%s"), xopts[x]); |
Miklos Vajna | 18668f5 | 2008-08-28 15:43:00 +0200 | [diff] [blame] | 755 | |
| 756 | o.branch1 = head_arg; |
Junio C Hamano | ae8e4c9 | 2011-11-07 13:26:22 -0800 | [diff] [blame] | 757 | o.branch2 = merge_remote_util(remoteheads->item)->name; |
Miklos Vajna | 18668f5 | 2008-08-28 15:43:00 +0200 | [diff] [blame] | 758 | |
| 759 | for (j = common; j; j = j->next) |
| 760 | commit_list_insert(j->item, &reversed); |
| 761 | |
Ævar Arnfjörð Bjarmason | 07047d6 | 2022-11-19 14:07:38 +0100 | [diff] [blame] | 762 | repo_hold_locked_index(the_repository, &lock, |
| 763 | LOCK_DIE_ON_ERROR); |
Elijah Newren | 14c4586 | 2020-11-02 23:45:34 +0000 | [diff] [blame] | 764 | if (!strcmp(strategy, "ort")) |
| 765 | clean = merge_ort_recursive(&o, head, remoteheads->item, |
| 766 | reversed, &result); |
| 767 | else |
| 768 | clean = merge_recursive(&o, head, remoteheads->item, |
| 769 | reversed, &result); |
Elijah Newren | 8f240b8 | 2022-07-23 01:53:14 +0000 | [diff] [blame] | 770 | if (clean < 0) { |
| 771 | rollback_lock_file(&lock); |
| 772 | return 2; |
| 773 | } |
Martin Ågren | 6100081 | 2018-03-01 21:40:20 +0100 | [diff] [blame] | 774 | if (write_locked_index(&the_index, &lock, |
| 775 | COMMIT_LOCK | SKIP_IF_UNCHANGED)) |
Nguyễn Thái Ngọc Duy | 1a07e59 | 2018-07-21 09:49:19 +0200 | [diff] [blame] | 776 | die(_("unable to write %s"), get_index_file()); |
Miklos Vajna | 18668f5 | 2008-08-28 15:43:00 +0200 | [diff] [blame] | 777 | return clean ? 0 : 1; |
| 778 | } else { |
Nguyễn Thái Ngọc Duy | 7e196c3 | 2018-09-21 17:57:29 +0200 | [diff] [blame] | 779 | return try_merge_command(the_repository, |
| 780 | strategy, xopts_nr, xopts, |
| 781 | common, head_arg, remoteheads); |
Miklos Vajna | 18668f5 | 2008-08-28 15:43:00 +0200 | [diff] [blame] | 782 | } |
Miklos Vajna | 1c7b76b | 2008-07-07 19:24:20 +0200 | [diff] [blame] | 783 | } |
| 784 | |
| 785 | static void count_diff_files(struct diff_queue_struct *q, |
Jeff King | 61bdc7c | 2022-12-13 06:13:48 -0500 | [diff] [blame] | 786 | struct diff_options *opt UNUSED, void *data) |
Miklos Vajna | 1c7b76b | 2008-07-07 19:24:20 +0200 | [diff] [blame] | 787 | { |
| 788 | int *count = data; |
| 789 | |
| 790 | (*count) += q->nr; |
| 791 | } |
| 792 | |
| 793 | static int count_unmerged_entries(void) |
| 794 | { |
Miklos Vajna | 1c7b76b | 2008-07-07 19:24:20 +0200 | [diff] [blame] | 795 | int i, ret = 0; |
| 796 | |
Ævar Arnfjörð Bjarmason | dc59418 | 2022-11-19 14:07:34 +0100 | [diff] [blame] | 797 | for (i = 0; i < the_index.cache_nr; i++) |
| 798 | if (ce_stage(the_index.cache[i])) |
Miklos Vajna | 1c7b76b | 2008-07-07 19:24:20 +0200 | [diff] [blame] | 799 | ret++; |
| 800 | |
| 801 | return ret; |
| 802 | } |
| 803 | |
Miklos Vajna | 1c7b76b | 2008-07-07 19:24:20 +0200 | [diff] [blame] | 804 | static void add_strategies(const char *string, unsigned attr) |
| 805 | { |
René Scharfe | 02a8cfa | 2016-08-05 23:01:35 +0200 | [diff] [blame] | 806 | int i; |
Miklos Vajna | 1c7b76b | 2008-07-07 19:24:20 +0200 | [diff] [blame] | 807 | |
René Scharfe | 02a8cfa | 2016-08-05 23:01:35 +0200 | [diff] [blame] | 808 | if (string) { |
| 809 | struct string_list list = STRING_LIST_INIT_DUP; |
| 810 | struct string_list_item *item; |
| 811 | string_list_split(&list, string, ' ', -1); |
| 812 | for_each_string_list_item(item, &list) |
| 813 | append_strategy(get_strategy(item->string)); |
| 814 | string_list_clear(&list, 0); |
Miklos Vajna | 1c7b76b | 2008-07-07 19:24:20 +0200 | [diff] [blame] | 815 | return; |
| 816 | } |
| 817 | for (i = 0; i < ARRAY_SIZE(all_strategy); i++) |
| 818 | if (all_strategy[i].attr & attr) |
| 819 | append_strategy(&all_strategy[i]); |
| 820 | |
| 821 | } |
| 822 | |
Jay Soffian | 66f4b98 | 2011-10-08 14:39:52 -0400 | [diff] [blame] | 823 | static void read_merge_msg(struct strbuf *msg) |
Jay Soffian | 65969d4 | 2011-02-14 20:07:50 -0500 | [diff] [blame] | 824 | { |
Stefan Beller | 102de88 | 2018-05-17 15:51:51 -0700 | [diff] [blame] | 825 | const char *filename = git_path_merge_msg(the_repository); |
Jay Soffian | 66f4b98 | 2011-10-08 14:39:52 -0400 | [diff] [blame] | 826 | strbuf_reset(msg); |
Jonathan Nieder | 418c9b1 | 2011-11-16 02:03:36 -0600 | [diff] [blame] | 827 | if (strbuf_read_file(msg, filename, 0) < 0) |
| 828 | die_errno(_("Could not read from '%s'"), filename); |
Jay Soffian | 65969d4 | 2011-02-14 20:07:50 -0500 | [diff] [blame] | 829 | } |
| 830 | |
Junio C Hamano | 4c57bd2 | 2012-04-16 16:15:13 -0700 | [diff] [blame] | 831 | static void write_merge_state(struct commit_list *); |
| 832 | static void abort_commit(struct commit_list *remoteheads, const char *err_msg) |
Jay Soffian | 65969d4 | 2011-02-14 20:07:50 -0500 | [diff] [blame] | 833 | { |
Jay Soffian | 66f4b98 | 2011-10-08 14:39:52 -0400 | [diff] [blame] | 834 | if (err_msg) |
| 835 | error("%s", err_msg); |
| 836 | fprintf(stderr, |
| 837 | _("Not committing merge; use 'git commit' to complete the merge.\n")); |
Junio C Hamano | 4c57bd2 | 2012-04-16 16:15:13 -0700 | [diff] [blame] | 838 | write_merge_state(remoteheads); |
Jay Soffian | 66f4b98 | 2011-10-08 14:39:52 -0400 | [diff] [blame] | 839 | exit(1); |
| 840 | } |
| 841 | |
Thomas Rast | f26af3f | 2012-01-30 21:25:30 +0100 | [diff] [blame] | 842 | static const char merge_editor_comment[] = |
| 843 | N_("Please enter a commit message to explain why this merge is necessary,\n" |
| 844 | "especially if it merges an updated upstream into a topic branch.\n" |
Denton Liu | d540b70 | 2019-04-17 11:23:27 +0100 | [diff] [blame] | 845 | "\n"); |
| 846 | |
| 847 | static const char scissors_editor_comment[] = |
| 848 | N_("An empty message aborts the commit.\n"); |
| 849 | |
| 850 | static const char no_scissors_editor_comment[] = |
| 851 | N_("Lines starting with '%c' will be ignored, and an empty message aborts\n" |
Thomas Rast | f26af3f | 2012-01-30 21:25:30 +0100 | [diff] [blame] | 852 | "the commit.\n"); |
| 853 | |
Michael J Gruber | 9d89b35 | 2017-08-23 14:10:45 +0200 | [diff] [blame] | 854 | static void write_merge_heads(struct commit_list *); |
Junio C Hamano | 4c57bd2 | 2012-04-16 16:15:13 -0700 | [diff] [blame] | 855 | static void prepare_to_commit(struct commit_list *remoteheads) |
Jay Soffian | 66f4b98 | 2011-10-08 14:39:52 -0400 | [diff] [blame] | 856 | { |
| 857 | struct strbuf msg = STRBUF_INIT; |
Michael J Gruber | 6098817 | 2019-08-07 11:57:07 -0700 | [diff] [blame] | 858 | const char *index_file = get_index_file(); |
| 859 | |
Ævar Arnfjörð Bjarmason | 9f6e63b | 2022-03-07 13:33:45 +0100 | [diff] [blame] | 860 | if (!no_verify) { |
Ævar Arnfjörð Bjarmason | a8cc594 | 2022-03-07 13:33:46 +0100 | [diff] [blame] | 861 | int invoked_hook; |
| 862 | |
| 863 | if (run_commit_hook(0 < option_edit, index_file, &invoked_hook, |
Ævar Arnfjörð Bjarmason | 9f6e63b | 2022-03-07 13:33:45 +0100 | [diff] [blame] | 864 | "pre-merge-commit", NULL)) |
| 865 | abort_commit(remoteheads, NULL); |
| 866 | /* |
| 867 | * Re-read the index as pre-merge-commit hook could have updated it, |
| 868 | * and write it out as a tree. We must do this before we invoke |
| 869 | * the editor and after we invoke run_status above. |
| 870 | */ |
Ævar Arnfjörð Bjarmason | a8cc594 | 2022-03-07 13:33:46 +0100 | [diff] [blame] | 871 | if (invoked_hook) |
Ævar Arnfjörð Bjarmason | 07047d6 | 2022-11-19 14:07:38 +0100 | [diff] [blame] | 872 | discard_index(&the_index); |
Ævar Arnfjörð Bjarmason | 9f6e63b | 2022-03-07 13:33:45 +0100 | [diff] [blame] | 873 | } |
Ævar Arnfjörð Bjarmason | 07047d6 | 2022-11-19 14:07:38 +0100 | [diff] [blame] | 874 | read_index_from(&the_index, index_file, get_git_dir()); |
Jay Soffian | 66f4b98 | 2011-10-08 14:39:52 -0400 | [diff] [blame] | 875 | strbuf_addbuf(&msg, &merge_msg); |
Michael J Gruber | 62dc42b | 2017-08-23 14:10:43 +0200 | [diff] [blame] | 876 | if (squash) |
| 877 | BUG("the control must not reach here under --squash"); |
Denton Liu | d540b70 | 2019-04-17 11:23:27 +0100 | [diff] [blame] | 878 | if (0 < option_edit) { |
| 879 | strbuf_addch(&msg, '\n'); |
| 880 | if (cleanup_mode == COMMIT_MSG_CLEANUP_SCISSORS) { |
| 881 | wt_status_append_cut_line(&msg); |
Calvin Wan | 787cb8a | 2023-06-06 19:48:43 +0000 | [diff] [blame] | 882 | strbuf_commented_addf(&msg, comment_line_char, "\n"); |
Denton Liu | d540b70 | 2019-04-17 11:23:27 +0100 | [diff] [blame] | 883 | } |
Calvin Wan | 787cb8a | 2023-06-06 19:48:43 +0000 | [diff] [blame] | 884 | strbuf_commented_addf(&msg, comment_line_char, |
| 885 | _(merge_editor_comment)); |
Carlo Marcelo Arenas Belón | 00e302d | 2021-08-07 20:38:34 -0700 | [diff] [blame] | 886 | if (cleanup_mode == COMMIT_MSG_CLEANUP_SCISSORS) |
Calvin Wan | 787cb8a | 2023-06-06 19:48:43 +0000 | [diff] [blame] | 887 | strbuf_commented_addf(&msg, comment_line_char, |
| 888 | _(scissors_editor_comment)); |
Carlo Marcelo Arenas Belón | 00e302d | 2021-08-07 20:38:34 -0700 | [diff] [blame] | 889 | else |
Calvin Wan | 787cb8a | 2023-06-06 19:48:43 +0000 | [diff] [blame] | 890 | strbuf_commented_addf(&msg, comment_line_char, |
Carlo Marcelo Arenas Belón | 00e302d | 2021-08-07 20:38:34 -0700 | [diff] [blame] | 891 | _(no_scissors_editor_comment), comment_line_char); |
Denton Liu | d540b70 | 2019-04-17 11:23:27 +0100 | [diff] [blame] | 892 | } |
Łukasz Gryglicki | 14d01b4 | 2017-07-04 09:33:06 +0000 | [diff] [blame] | 893 | if (signoff) |
| 894 | append_signoff(&msg, ignore_non_trailer(msg.buf, msg.len), 0); |
Michael J Gruber | 9d89b35 | 2017-08-23 14:10:45 +0200 | [diff] [blame] | 895 | write_merge_heads(remoteheads); |
Stefan Beller | 102de88 | 2018-05-17 15:51:51 -0700 | [diff] [blame] | 896 | write_file_buf(git_path_merge_msg(the_repository), msg.buf, msg.len); |
Ævar Arnfjörð Bjarmason | a8cc594 | 2022-03-07 13:33:46 +0100 | [diff] [blame] | 897 | if (run_commit_hook(0 < option_edit, get_index_file(), NULL, |
| 898 | "prepare-commit-msg", |
Stefan Beller | 102de88 | 2018-05-17 15:51:51 -0700 | [diff] [blame] | 899 | git_path_merge_msg(the_repository), "merge", NULL)) |
Antoine Pelisse | 3e4141d | 2013-01-02 19:42:50 +0100 | [diff] [blame] | 900 | abort_commit(remoteheads, NULL); |
Junio C Hamano | f824628 | 2012-01-10 22:44:45 -0800 | [diff] [blame] | 901 | if (0 < option_edit) { |
Stefan Beller | 102de88 | 2018-05-17 15:51:51 -0700 | [diff] [blame] | 902 | if (launch_editor(git_path_merge_msg(the_repository), NULL, NULL)) |
Junio C Hamano | 4c57bd2 | 2012-04-16 16:15:13 -0700 | [diff] [blame] | 903 | abort_commit(remoteheads, NULL); |
Jay Soffian | 66f4b98 | 2011-10-08 14:39:52 -0400 | [diff] [blame] | 904 | } |
Stefan Beller | f8b8635 | 2017-09-07 15:04:29 -0700 | [diff] [blame] | 905 | |
Michael J Gruber | a1f3dd7 | 2019-08-07 11:57:06 -0700 | [diff] [blame] | 906 | if (!no_verify && run_commit_hook(0 < option_edit, get_index_file(), |
Ævar Arnfjörð Bjarmason | a8cc594 | 2022-03-07 13:33:46 +0100 | [diff] [blame] | 907 | NULL, "commit-msg", |
Stefan Beller | 102de88 | 2018-05-17 15:51:51 -0700 | [diff] [blame] | 908 | git_path_merge_msg(the_repository), NULL)) |
Stefan Beller | f8b8635 | 2017-09-07 15:04:29 -0700 | [diff] [blame] | 909 | abort_commit(remoteheads, NULL); |
| 910 | |
Jay Soffian | 66f4b98 | 2011-10-08 14:39:52 -0400 | [diff] [blame] | 911 | read_merge_msg(&msg); |
Denton Liu | d540b70 | 2019-04-17 11:23:27 +0100 | [diff] [blame] | 912 | cleanup_message(&msg, cleanup_mode, 0); |
Jay Soffian | 66f4b98 | 2011-10-08 14:39:52 -0400 | [diff] [blame] | 913 | if (!msg.len) |
Junio C Hamano | 4c57bd2 | 2012-04-16 16:15:13 -0700 | [diff] [blame] | 914 | abort_commit(remoteheads, _("Empty commit message.")); |
Jay Soffian | 66f4b98 | 2011-10-08 14:39:52 -0400 | [diff] [blame] | 915 | strbuf_release(&merge_msg); |
| 916 | strbuf_addbuf(&merge_msg, &msg); |
| 917 | strbuf_release(&msg); |
Jay Soffian | 65969d4 | 2011-02-14 20:07:50 -0500 | [diff] [blame] | 918 | } |
| 919 | |
Junio C Hamano | 4c57bd2 | 2012-04-16 16:15:13 -0700 | [diff] [blame] | 920 | static int merge_trivial(struct commit *head, struct commit_list *remoteheads) |
Miklos Vajna | 1c7b76b | 2008-07-07 19:24:20 +0200 | [diff] [blame] | 921 | { |
brian m. carlson | 5268431 | 2017-02-21 23:47:28 +0000 | [diff] [blame] | 922 | struct object_id result_tree, result_commit; |
René Scharfe | 910a09a | 2014-07-10 11:41:40 +0200 | [diff] [blame] | 923 | struct commit_list *parents, **pptr = &parents; |
Elijah Newren | 40d7194 | 2016-04-09 23:13:40 -0700 | [diff] [blame] | 924 | |
Ævar Arnfjörð Bjarmason | 07047d6 | 2022-11-19 14:07:38 +0100 | [diff] [blame] | 925 | if (repo_refresh_and_write_index(the_repository, REFRESH_QUIET, |
| 926 | SKIP_IF_UNCHANGED, 0, NULL, NULL, |
| 927 | NULL) < 0) |
Elijah Newren | 40d7194 | 2016-04-09 23:13:40 -0700 | [diff] [blame] | 928 | return error(_("Unable to write index.")); |
Miklos Vajna | 1c7b76b | 2008-07-07 19:24:20 +0200 | [diff] [blame] | 929 | |
brian m. carlson | 5268431 | 2017-02-21 23:47:28 +0000 | [diff] [blame] | 930 | write_tree_trivial(&result_tree); |
Ævar Arnfjörð Bjarmason | 157efde | 2011-02-22 23:42:02 +0000 | [diff] [blame] | 931 | printf(_("Wonderful.\n")); |
René Scharfe | 910a09a | 2014-07-10 11:41:40 +0200 | [diff] [blame] | 932 | pptr = commit_list_append(head, pptr); |
| 933 | pptr = commit_list_append(remoteheads->item, pptr); |
Junio C Hamano | 4c57bd2 | 2012-04-16 16:15:13 -0700 | [diff] [blame] | 934 | prepare_to_commit(remoteheads); |
Patryk Obara | 5078f34 | 2018-01-28 01:13:16 +0100 | [diff] [blame] | 935 | if (commit_tree(merge_msg.buf, merge_msg.len, &result_tree, parents, |
| 936 | &result_commit, NULL, sign_commit)) |
Nguyễn Thái Ngọc Duy | 6b3c4c0 | 2011-12-15 20:47:21 +0700 | [diff] [blame] | 937 | die(_("failed to write commit object")); |
brian m. carlson | 5268431 | 2017-02-21 23:47:28 +0000 | [diff] [blame] | 938 | finish(head, remoteheads, &result_commit, "In-index merge"); |
Nguyễn Thái Ngọc Duy | b643355 | 2019-05-09 17:10:27 +0700 | [diff] [blame] | 939 | remove_merge_branch_state(the_repository); |
Miklos Vajna | 1c7b76b | 2008-07-07 19:24:20 +0200 | [diff] [blame] | 940 | return 0; |
| 941 | } |
| 942 | |
Nguyễn Thái Ngọc Duy | 894642f | 2011-09-17 21:57:44 +1000 | [diff] [blame] | 943 | static int finish_automerge(struct commit *head, |
Junio C Hamano | e78cbf8 | 2012-04-17 12:22:26 -0700 | [diff] [blame] | 944 | int head_subsumed, |
Nguyễn Thái Ngọc Duy | 894642f | 2011-09-17 21:57:44 +1000 | [diff] [blame] | 945 | struct commit_list *common, |
Junio C Hamano | 4c57bd2 | 2012-04-16 16:15:13 -0700 | [diff] [blame] | 946 | struct commit_list *remoteheads, |
brian m. carlson | 5268431 | 2017-02-21 23:47:28 +0000 | [diff] [blame] | 947 | struct object_id *result_tree, |
Miklos Vajna | 1c7b76b | 2008-07-07 19:24:20 +0200 | [diff] [blame] | 948 | const char *wt_strategy) |
| 949 | { |
Junio C Hamano | e78cbf8 | 2012-04-17 12:22:26 -0700 | [diff] [blame] | 950 | struct commit_list *parents = NULL; |
Miklos Vajna | 1c7b76b | 2008-07-07 19:24:20 +0200 | [diff] [blame] | 951 | struct strbuf buf = STRBUF_INIT; |
brian m. carlson | 5268431 | 2017-02-21 23:47:28 +0000 | [diff] [blame] | 952 | struct object_id result_commit; |
Miklos Vajna | 1c7b76b | 2008-07-07 19:24:20 +0200 | [diff] [blame] | 953 | |
Edmundo Carmona Antoranz | f00abe6 | 2019-07-08 21:15:59 -0600 | [diff] [blame] | 954 | write_tree_trivial(result_tree); |
Miklos Vajna | 1c7b76b | 2008-07-07 19:24:20 +0200 | [diff] [blame] | 955 | free_commit_list(common); |
Junio C Hamano | e78cbf8 | 2012-04-17 12:22:26 -0700 | [diff] [blame] | 956 | parents = remoteheads; |
Miklos Vajna | a54841e | 2013-07-02 16:47:57 +0200 | [diff] [blame] | 957 | if (!head_subsumed || fast_forward == FF_NO) |
Nguyễn Thái Ngọc Duy | 894642f | 2011-09-17 21:57:44 +1000 | [diff] [blame] | 958 | commit_list_insert(head, &parents); |
Junio C Hamano | 4c57bd2 | 2012-04-16 16:15:13 -0700 | [diff] [blame] | 959 | prepare_to_commit(remoteheads); |
Patryk Obara | 5078f34 | 2018-01-28 01:13:16 +0100 | [diff] [blame] | 960 | if (commit_tree(merge_msg.buf, merge_msg.len, result_tree, parents, |
| 961 | &result_commit, NULL, sign_commit)) |
Nguyễn Thái Ngọc Duy | 6b3c4c0 | 2011-12-15 20:47:21 +0700 | [diff] [blame] | 962 | die(_("failed to write commit object")); |
Junio C Hamano | f23101b | 2011-05-25 12:43:59 -0700 | [diff] [blame] | 963 | strbuf_addf(&buf, "Merge made by the '%s' strategy.", wt_strategy); |
brian m. carlson | 5268431 | 2017-02-21 23:47:28 +0000 | [diff] [blame] | 964 | finish(head, remoteheads, &result_commit, buf.buf); |
Miklos Vajna | 1c7b76b | 2008-07-07 19:24:20 +0200 | [diff] [blame] | 965 | strbuf_release(&buf); |
Nguyễn Thái Ngọc Duy | b643355 | 2019-05-09 17:10:27 +0700 | [diff] [blame] | 966 | remove_merge_branch_state(the_repository); |
Miklos Vajna | 1c7b76b | 2008-07-07 19:24:20 +0200 | [diff] [blame] | 967 | return 0; |
| 968 | } |
| 969 | |
Junio C Hamano | 08e3ce5 | 2014-10-24 11:27:22 -0700 | [diff] [blame] | 970 | static int suggest_conflicts(void) |
Miklos Vajna | 1c7b76b | 2008-07-07 19:24:20 +0200 | [diff] [blame] | 971 | { |
Jonathan Nieder | 418c9b1 | 2011-11-16 02:03:36 -0600 | [diff] [blame] | 972 | const char *filename; |
Miklos Vajna | 1c7b76b | 2008-07-07 19:24:20 +0200 | [diff] [blame] | 973 | FILE *fp; |
Junio C Hamano | 75c961b | 2014-10-24 11:34:59 -0700 | [diff] [blame] | 974 | struct strbuf msgbuf = STRBUF_INIT; |
Miklos Vajna | 1c7b76b | 2008-07-07 19:24:20 +0200 | [diff] [blame] | 975 | |
Stefan Beller | 102de88 | 2018-05-17 15:51:51 -0700 | [diff] [blame] | 976 | filename = git_path_merge_msg(the_repository); |
Nguyễn Thái Ngọc Duy | 23a9e07 | 2017-05-03 17:16:46 +0700 | [diff] [blame] | 977 | fp = xfopen(filename, "a"); |
Miklos Vajna | 1c7b76b | 2008-07-07 19:24:20 +0200 | [diff] [blame] | 978 | |
Denton Liu | 1055997 | 2019-04-17 11:23:28 +0100 | [diff] [blame] | 979 | /* |
| 980 | * We can't use cleanup_mode because if we're not using the editor, |
| 981 | * get_cleanup_mode will return COMMIT_MSG_CLEANUP_SPACE instead, even |
| 982 | * though the message is meant to be processed later by git-commit. |
| 983 | * Thus, we will get the cleanup mode which is returned when we _are_ |
| 984 | * using an editor. |
| 985 | */ |
Denton Liu | 1a2b985 | 2019-04-17 11:23:30 +0100 | [diff] [blame] | 986 | append_conflicts_hint(&the_index, &msgbuf, |
| 987 | get_cleanup_mode(cleanup_arg, 1)); |
Junio C Hamano | 75c961b | 2014-10-24 11:34:59 -0700 | [diff] [blame] | 988 | fputs(msgbuf.buf, fp); |
René Scharfe | 8d025b7 | 2014-12-24 01:18:38 +0100 | [diff] [blame] | 989 | strbuf_release(&msgbuf); |
Miklos Vajna | 1c7b76b | 2008-07-07 19:24:20 +0200 | [diff] [blame] | 990 | fclose(fp); |
Nguyễn Thái Ngọc Duy | 35843b1 | 2018-09-21 17:57:32 +0200 | [diff] [blame] | 991 | repo_rerere(the_repository, allow_rerere_auto); |
Ævar Arnfjörð Bjarmason | bacec47 | 2011-02-22 23:41:59 +0000 | [diff] [blame] | 992 | printf(_("Automatic merge failed; " |
| 993 | "fix conflicts and then commit the result.\n")); |
Miklos Vajna | 1c7b76b | 2008-07-07 19:24:20 +0200 | [diff] [blame] | 994 | return 1; |
| 995 | } |
| 996 | |
Miklos Vajna | 1c7b76b | 2008-07-07 19:24:20 +0200 | [diff] [blame] | 997 | static int evaluate_result(void) |
| 998 | { |
| 999 | int cnt = 0; |
| 1000 | struct rev_info rev; |
| 1001 | |
Miklos Vajna | 1c7b76b | 2008-07-07 19:24:20 +0200 | [diff] [blame] | 1002 | /* Check how many files differ. */ |
Nguyễn Thái Ngọc Duy | 2abf350 | 2018-09-21 17:57:38 +0200 | [diff] [blame] | 1003 | repo_init_revisions(the_repository, &rev, ""); |
Miklos Vajna | 1c7b76b | 2008-07-07 19:24:20 +0200 | [diff] [blame] | 1004 | setup_revisions(0, NULL, &rev, NULL); |
| 1005 | rev.diffopt.output_format |= |
| 1006 | DIFF_FORMAT_CALLBACK; |
| 1007 | rev.diffopt.format_callback = count_diff_files; |
| 1008 | rev.diffopt.format_callback_data = &cnt; |
| 1009 | run_diff_files(&rev, 0); |
| 1010 | |
| 1011 | /* |
| 1012 | * Check how many unmerged entries are |
| 1013 | * there. |
| 1014 | */ |
| 1015 | cnt += count_unmerged_entries(); |
| 1016 | |
Ævar Arnfjörð Bjarmason | 2108fe4 | 2022-04-13 22:01:36 +0200 | [diff] [blame] | 1017 | release_revisions(&rev); |
Miklos Vajna | 1c7b76b | 2008-07-07 19:24:20 +0200 | [diff] [blame] | 1018 | return cnt; |
| 1019 | } |
| 1020 | |
Junio C Hamano | 93e535a | 2011-03-23 23:48:24 -0700 | [diff] [blame] | 1021 | /* |
Michael Schubert | d6ac1d2 | 2013-07-03 11:12:34 +0200 | [diff] [blame] | 1022 | * Pretend as if the user told us to merge with the remote-tracking |
Junio C Hamano | 93e535a | 2011-03-23 23:48:24 -0700 | [diff] [blame] | 1023 | * branch we have for the upstream of the current branch |
| 1024 | */ |
| 1025 | static int setup_with_upstream(const char ***argv) |
| 1026 | { |
| 1027 | struct branch *branch = branch_get(NULL); |
| 1028 | int i; |
| 1029 | const char **args; |
| 1030 | |
| 1031 | if (!branch) |
Ævar Arnfjörð Bjarmason | c7f426d | 2011-04-10 19:34:04 +0000 | [diff] [blame] | 1032 | die(_("No current branch.")); |
Jeff King | 9e3751d | 2015-05-21 00:45:13 -0400 | [diff] [blame] | 1033 | if (!branch->remote_name) |
Ævar Arnfjörð Bjarmason | c7f426d | 2011-04-10 19:34:04 +0000 | [diff] [blame] | 1034 | die(_("No remote for the current branch.")); |
Junio C Hamano | 93e535a | 2011-03-23 23:48:24 -0700 | [diff] [blame] | 1035 | if (!branch->merge_nr) |
Ævar Arnfjörð Bjarmason | c7f426d | 2011-04-10 19:34:04 +0000 | [diff] [blame] | 1036 | die(_("No default upstream defined for the current branch.")); |
Junio C Hamano | 93e535a | 2011-03-23 23:48:24 -0700 | [diff] [blame] | 1037 | |
Jeff King | 50a6c8e | 2016-02-22 17:44:35 -0500 | [diff] [blame] | 1038 | args = xcalloc(st_add(branch->merge_nr, 1), sizeof(char *)); |
Junio C Hamano | 93e535a | 2011-03-23 23:48:24 -0700 | [diff] [blame] | 1039 | for (i = 0; i < branch->merge_nr; i++) { |
| 1040 | if (!branch->merge[i]->dst) |
Michael Schubert | d6ac1d2 | 2013-07-03 11:12:34 +0200 | [diff] [blame] | 1041 | die(_("No remote-tracking branch for %s from %s"), |
Junio C Hamano | 93e535a | 2011-03-23 23:48:24 -0700 | [diff] [blame] | 1042 | branch->merge[i]->src, branch->remote_name); |
| 1043 | args[i] = branch->merge[i]->dst; |
| 1044 | } |
| 1045 | args[i] = NULL; |
| 1046 | *argv = args; |
| 1047 | return i; |
| 1048 | } |
| 1049 | |
Michael J Gruber | 8e6a6bb | 2017-08-23 14:10:44 +0200 | [diff] [blame] | 1050 | static void write_merge_heads(struct commit_list *remoteheads) |
Jay Soffian | 66f4b98 | 2011-10-08 14:39:52 -0400 | [diff] [blame] | 1051 | { |
Jay Soffian | 66f4b98 | 2011-10-08 14:39:52 -0400 | [diff] [blame] | 1052 | struct commit_list *j; |
| 1053 | struct strbuf buf = STRBUF_INIT; |
| 1054 | |
Junio C Hamano | 274a5c0 | 2011-11-07 14:45:10 -0800 | [diff] [blame] | 1055 | for (j = remoteheads; j; j = j->next) { |
brian m. carlson | f2fd076 | 2015-11-10 02:22:28 +0000 | [diff] [blame] | 1056 | struct object_id *oid; |
Junio C Hamano | 274a5c0 | 2011-11-07 14:45:10 -0800 | [diff] [blame] | 1057 | struct commit *c = j->item; |
Nguyễn Thái Ngọc Duy | e2e5ac2 | 2018-05-19 07:28:30 +0200 | [diff] [blame] | 1058 | struct merge_remote_desc *desc; |
| 1059 | |
| 1060 | desc = merge_remote_util(c); |
| 1061 | if (desc && desc->obj) { |
| 1062 | oid = &desc->obj->oid; |
Junio C Hamano | 274a5c0 | 2011-11-07 14:45:10 -0800 | [diff] [blame] | 1063 | } else { |
brian m. carlson | f2fd076 | 2015-11-10 02:22:28 +0000 | [diff] [blame] | 1064 | oid = &c->object.oid; |
Junio C Hamano | 274a5c0 | 2011-11-07 14:45:10 -0800 | [diff] [blame] | 1065 | } |
brian m. carlson | f2fd076 | 2015-11-10 02:22:28 +0000 | [diff] [blame] | 1066 | strbuf_addf(&buf, "%s\n", oid_to_hex(oid)); |
Junio C Hamano | 274a5c0 | 2011-11-07 14:45:10 -0800 | [diff] [blame] | 1067 | } |
Stefan Beller | 102de88 | 2018-05-17 15:51:51 -0700 | [diff] [blame] | 1068 | write_file_buf(git_path_merge_head(the_repository), buf.buf, buf.len); |
Jonathan Nieder | 418c9b1 | 2011-11-16 02:03:36 -0600 | [diff] [blame] | 1069 | |
Jay Soffian | 66f4b98 | 2011-10-08 14:39:52 -0400 | [diff] [blame] | 1070 | strbuf_reset(&buf); |
Miklos Vajna | a54841e | 2013-07-02 16:47:57 +0200 | [diff] [blame] | 1071 | if (fast_forward == FF_NO) |
René Scharfe | a22ae75 | 2016-09-15 20:31:00 +0200 | [diff] [blame] | 1072 | strbuf_addstr(&buf, "no-ff"); |
Stefan Beller | 102de88 | 2018-05-17 15:51:51 -0700 | [diff] [blame] | 1073 | write_file_buf(git_path_merge_mode(the_repository), buf.buf, buf.len); |
Rene Scharfe | 814c4b3 | 2017-08-30 19:49:50 +0200 | [diff] [blame] | 1074 | strbuf_release(&buf); |
Jay Soffian | 66f4b98 | 2011-10-08 14:39:52 -0400 | [diff] [blame] | 1075 | } |
| 1076 | |
Michael J Gruber | 8e6a6bb | 2017-08-23 14:10:44 +0200 | [diff] [blame] | 1077 | static void write_merge_state(struct commit_list *remoteheads) |
| 1078 | { |
| 1079 | write_merge_heads(remoteheads); |
| 1080 | strbuf_addch(&merge_msg, '\n'); |
Stefan Beller | 102de88 | 2018-05-17 15:51:51 -0700 | [diff] [blame] | 1081 | write_file_buf(git_path_merge_msg(the_repository), merge_msg.buf, |
| 1082 | merge_msg.len); |
Michael J Gruber | 8e6a6bb | 2017-08-23 14:10:44 +0200 | [diff] [blame] | 1083 | } |
| 1084 | |
Junio C Hamano | f824628 | 2012-01-10 22:44:45 -0800 | [diff] [blame] | 1085 | static int default_edit_option(void) |
| 1086 | { |
| 1087 | static const char name[] = "GIT_MERGE_AUTOEDIT"; |
| 1088 | const char *e = getenv(name); |
| 1089 | struct stat st_stdin, st_stdout; |
| 1090 | |
| 1091 | if (have_message) |
| 1092 | /* an explicit -m msg without --[no-]edit */ |
| 1093 | return 0; |
| 1094 | |
| 1095 | if (e) { |
Martin Ågren | 8957661 | 2017-08-07 20:20:49 +0200 | [diff] [blame] | 1096 | int v = git_parse_maybe_bool(e); |
Junio C Hamano | f824628 | 2012-01-10 22:44:45 -0800 | [diff] [blame] | 1097 | if (v < 0) |
Vasco Almeida | bef4830 | 2016-06-17 20:21:17 +0000 | [diff] [blame] | 1098 | die(_("Bad value '%s' in environment '%s'"), e, name); |
Junio C Hamano | f824628 | 2012-01-10 22:44:45 -0800 | [diff] [blame] | 1099 | return v; |
| 1100 | } |
| 1101 | |
| 1102 | /* Use editor if stdin and stdout are the same and is a tty */ |
| 1103 | return (!fstat(0, &st_stdin) && |
| 1104 | !fstat(1, &st_stdout) && |
Junio C Hamano | d46f476 | 2012-02-23 11:24:44 -0800 | [diff] [blame] | 1105 | isatty(0) && isatty(1) && |
Junio C Hamano | f824628 | 2012-01-10 22:44:45 -0800 | [diff] [blame] | 1106 | st_stdin.st_dev == st_stdout.st_dev && |
| 1107 | st_stdin.st_ino == st_stdout.st_ino && |
| 1108 | st_stdin.st_mode == st_stdout.st_mode); |
| 1109 | } |
| 1110 | |
Junio C Hamano | 34349db | 2015-04-25 12:00:14 -0700 | [diff] [blame] | 1111 | static struct commit_list *reduce_parents(struct commit *head_commit, |
| 1112 | int *head_subsumed, |
| 1113 | struct commit_list *remoteheads) |
Junio C Hamano | b5d887f | 2012-04-17 11:31:10 -0700 | [diff] [blame] | 1114 | { |
René Scharfe | e510ab8 | 2015-10-24 18:21:31 +0200 | [diff] [blame] | 1115 | struct commit_list *parents, **remotes; |
Junio C Hamano | b5d887f | 2012-04-17 11:31:10 -0700 | [diff] [blame] | 1116 | |
Junio C Hamano | 0b10b8a | 2015-04-25 10:25:43 -0700 | [diff] [blame] | 1117 | /* |
| 1118 | * Is the current HEAD reachable from another commit being |
| 1119 | * merged? If so we do not want to record it as a parent of |
| 1120 | * the resulting merge, unless --no-ff is given. We will flip |
| 1121 | * this variable to 0 when we find HEAD among the independent |
| 1122 | * tips being merged. |
| 1123 | */ |
| 1124 | *head_subsumed = 1; |
Junio C Hamano | e78cbf8 | 2012-04-17 12:22:26 -0700 | [diff] [blame] | 1125 | |
Junio C Hamano | 0b10b8a | 2015-04-25 10:25:43 -0700 | [diff] [blame] | 1126 | /* Find what parents to record by checking independent ones. */ |
Junio C Hamano | e78cbf8 | 2012-04-17 12:22:26 -0700 | [diff] [blame] | 1127 | parents = reduce_heads(remoteheads); |
Martin Ågren | 4da7264 | 2017-11-07 21:39:45 +0100 | [diff] [blame] | 1128 | free_commit_list(remoteheads); |
Junio C Hamano | e78cbf8 | 2012-04-17 12:22:26 -0700 | [diff] [blame] | 1129 | |
René Scharfe | e510ab8 | 2015-10-24 18:21:31 +0200 | [diff] [blame] | 1130 | remoteheads = NULL; |
| 1131 | remotes = &remoteheads; |
| 1132 | while (parents) { |
| 1133 | struct commit *commit = pop_commit(&parents); |
Junio C Hamano | e78cbf8 | 2012-04-17 12:22:26 -0700 | [diff] [blame] | 1134 | if (commit == head_commit) |
| 1135 | *head_subsumed = 0; |
| 1136 | else |
| 1137 | remotes = &commit_list_insert(commit, remotes)->next; |
| 1138 | } |
Junio C Hamano | b5d887f | 2012-04-17 11:31:10 -0700 | [diff] [blame] | 1139 | return remoteheads; |
| 1140 | } |
Junio C Hamano | f824628 | 2012-01-10 22:44:45 -0800 | [diff] [blame] | 1141 | |
Junio C Hamano | 52fecab | 2015-04-25 18:29:44 -0700 | [diff] [blame] | 1142 | static void prepare_merge_message(struct strbuf *merge_names, struct strbuf *merge_msg) |
| 1143 | { |
| 1144 | struct fmt_merge_msg_opts opts; |
| 1145 | |
| 1146 | memset(&opts, 0, sizeof(opts)); |
| 1147 | opts.add_title = !have_message; |
| 1148 | opts.shortlog_len = shortlog_len; |
| 1149 | opts.credit_people = (0 < option_edit); |
Junio C Hamano | bd2bc94 | 2021-12-20 14:53:43 -0800 | [diff] [blame] | 1150 | opts.into_name = into_name; |
Junio C Hamano | 52fecab | 2015-04-25 18:29:44 -0700 | [diff] [blame] | 1151 | |
| 1152 | fmt_merge_msg(merge_names, merge_msg, &opts); |
| 1153 | if (merge_msg->len) |
| 1154 | strbuf_setlen(merge_msg, merge_msg->len - 1); |
| 1155 | } |
| 1156 | |
Junio C Hamano | 74e8bc5 | 2015-04-25 18:47:21 -0700 | [diff] [blame] | 1157 | static void handle_fetch_head(struct commit_list **remotes, struct strbuf *merge_names) |
| 1158 | { |
| 1159 | const char *filename; |
| 1160 | int fd, pos, npos; |
| 1161 | struct strbuf fetch_head_file = STRBUF_INIT; |
brian m. carlson | ab47df2 | 2018-07-16 01:28:03 +0000 | [diff] [blame] | 1162 | const unsigned hexsz = the_hash_algo->hexsz; |
Junio C Hamano | 74e8bc5 | 2015-04-25 18:47:21 -0700 | [diff] [blame] | 1163 | |
| 1164 | if (!merge_names) |
| 1165 | merge_names = &fetch_head_file; |
| 1166 | |
Stefan Beller | 102de88 | 2018-05-17 15:51:51 -0700 | [diff] [blame] | 1167 | filename = git_path_fetch_head(the_repository); |
René Scharfe | 66e905b | 2021-08-25 22:16:46 +0200 | [diff] [blame] | 1168 | fd = xopen(filename, O_RDONLY); |
Junio C Hamano | 74e8bc5 | 2015-04-25 18:47:21 -0700 | [diff] [blame] | 1169 | |
| 1170 | if (strbuf_read(merge_names, fd, 0) < 0) |
| 1171 | die_errno(_("could not read '%s'"), filename); |
| 1172 | if (close(fd) < 0) |
| 1173 | die_errno(_("could not close '%s'"), filename); |
| 1174 | |
| 1175 | for (pos = 0; pos < merge_names->len; pos = npos) { |
brian m. carlson | 5268431 | 2017-02-21 23:47:28 +0000 | [diff] [blame] | 1176 | struct object_id oid; |
Junio C Hamano | 74e8bc5 | 2015-04-25 18:47:21 -0700 | [diff] [blame] | 1177 | char *ptr; |
| 1178 | struct commit *commit; |
| 1179 | |
| 1180 | ptr = strchr(merge_names->buf + pos, '\n'); |
| 1181 | if (ptr) |
| 1182 | npos = ptr - merge_names->buf + 1; |
| 1183 | else |
| 1184 | npos = merge_names->len; |
| 1185 | |
brian m. carlson | ab47df2 | 2018-07-16 01:28:03 +0000 | [diff] [blame] | 1186 | if (npos - pos < hexsz + 2 || |
brian m. carlson | 5268431 | 2017-02-21 23:47:28 +0000 | [diff] [blame] | 1187 | get_oid_hex(merge_names->buf + pos, &oid)) |
Junio C Hamano | 74e8bc5 | 2015-04-25 18:47:21 -0700 | [diff] [blame] | 1188 | commit = NULL; /* bad */ |
brian m. carlson | ab47df2 | 2018-07-16 01:28:03 +0000 | [diff] [blame] | 1189 | else if (memcmp(merge_names->buf + pos + hexsz, "\t\t", 2)) |
Junio C Hamano | 74e8bc5 | 2015-04-25 18:47:21 -0700 | [diff] [blame] | 1190 | continue; /* not-for-merge */ |
| 1191 | else { |
brian m. carlson | ab47df2 | 2018-07-16 01:28:03 +0000 | [diff] [blame] | 1192 | char saved = merge_names->buf[pos + hexsz]; |
| 1193 | merge_names->buf[pos + hexsz] = '\0'; |
Junio C Hamano | 74e8bc5 | 2015-04-25 18:47:21 -0700 | [diff] [blame] | 1194 | commit = get_merge_parent(merge_names->buf + pos); |
brian m. carlson | ab47df2 | 2018-07-16 01:28:03 +0000 | [diff] [blame] | 1195 | merge_names->buf[pos + hexsz] = saved; |
Junio C Hamano | 74e8bc5 | 2015-04-25 18:47:21 -0700 | [diff] [blame] | 1196 | } |
| 1197 | if (!commit) { |
| 1198 | if (ptr) |
| 1199 | *ptr = '\0'; |
Vasco Almeida | bef4830 | 2016-06-17 20:21:17 +0000 | [diff] [blame] | 1200 | die(_("not something we can merge in %s: %s"), |
Junio C Hamano | 74e8bc5 | 2015-04-25 18:47:21 -0700 | [diff] [blame] | 1201 | filename, merge_names->buf + pos); |
| 1202 | } |
| 1203 | remotes = &commit_list_insert(commit, remotes)->next; |
| 1204 | } |
| 1205 | |
| 1206 | if (merge_names == &fetch_head_file) |
| 1207 | strbuf_release(&fetch_head_file); |
| 1208 | } |
| 1209 | |
Junio C Hamano | 34349db | 2015-04-25 12:00:14 -0700 | [diff] [blame] | 1210 | static struct commit_list *collect_parents(struct commit *head_commit, |
| 1211 | int *head_subsumed, |
Junio C Hamano | 1cf32f4 | 2015-04-25 18:34:22 -0700 | [diff] [blame] | 1212 | int argc, const char **argv, |
| 1213 | struct strbuf *merge_msg) |
Junio C Hamano | 34349db | 2015-04-25 12:00:14 -0700 | [diff] [blame] | 1214 | { |
| 1215 | int i; |
| 1216 | struct commit_list *remoteheads = NULL; |
| 1217 | struct commit_list **remotes = &remoteheads; |
Junio C Hamano | 7703801 | 2015-04-25 18:39:43 -0700 | [diff] [blame] | 1218 | struct strbuf merge_names = STRBUF_INIT, *autogen = NULL; |
| 1219 | |
| 1220 | if (merge_msg && (!have_message || shortlog_len)) |
| 1221 | autogen = &merge_names; |
Junio C Hamano | 34349db | 2015-04-25 12:00:14 -0700 | [diff] [blame] | 1222 | |
| 1223 | if (head_commit) |
| 1224 | remotes = &commit_list_insert(head_commit, remotes)->next; |
Junio C Hamano | 74e8bc5 | 2015-04-25 18:47:21 -0700 | [diff] [blame] | 1225 | |
| 1226 | if (argc == 1 && !strcmp(argv[0], "FETCH_HEAD")) { |
| 1227 | handle_fetch_head(remotes, autogen); |
| 1228 | remoteheads = reduce_parents(head_commit, head_subsumed, remoteheads); |
| 1229 | } else { |
| 1230 | for (i = 0; i < argc; i++) { |
| 1231 | struct commit *commit = get_merge_parent(argv[i]); |
| 1232 | if (!commit) |
| 1233 | help_unknown_ref(argv[i], "merge", |
Vasco Almeida | bef4830 | 2016-06-17 20:21:17 +0000 | [diff] [blame] | 1234 | _("not something we can merge")); |
Junio C Hamano | 74e8bc5 | 2015-04-25 18:47:21 -0700 | [diff] [blame] | 1235 | remotes = &commit_list_insert(commit, remotes)->next; |
| 1236 | } |
| 1237 | remoteheads = reduce_parents(head_commit, head_subsumed, remoteheads); |
| 1238 | if (autogen) { |
| 1239 | struct commit_list *p; |
| 1240 | for (p = remoteheads; p; p = p->next) |
| 1241 | merge_name(merge_remote_util(p->item)->name, autogen); |
| 1242 | } |
Junio C Hamano | 34349db | 2015-04-25 12:00:14 -0700 | [diff] [blame] | 1243 | } |
| 1244 | |
Junio C Hamano | 7703801 | 2015-04-25 18:39:43 -0700 | [diff] [blame] | 1245 | if (autogen) { |
Junio C Hamano | 7703801 | 2015-04-25 18:39:43 -0700 | [diff] [blame] | 1246 | prepare_merge_message(autogen, merge_msg); |
| 1247 | strbuf_release(autogen); |
Junio C Hamano | 1cf32f4 | 2015-04-25 18:34:22 -0700 | [diff] [blame] | 1248 | } |
| 1249 | |
| 1250 | return remoteheads; |
Junio C Hamano | 34349db | 2015-04-25 12:00:14 -0700 | [diff] [blame] | 1251 | } |
| 1252 | |
Junio C Hamano | adcc94a | 2018-02-14 10:18:55 -0800 | [diff] [blame] | 1253 | static int merging_a_throwaway_tag(struct commit *commit) |
| 1254 | { |
| 1255 | char *tag_ref; |
| 1256 | struct object_id oid; |
| 1257 | int is_throwaway_tag = 0; |
| 1258 | |
| 1259 | /* Are we merging a tag? */ |
| 1260 | if (!merge_remote_util(commit) || |
| 1261 | !merge_remote_util(commit)->obj || |
| 1262 | merge_remote_util(commit)->obj->type != OBJ_TAG) |
| 1263 | return is_throwaway_tag; |
| 1264 | |
| 1265 | /* |
| 1266 | * Now we know we are merging a tag object. Are we downstream |
| 1267 | * and following the tags from upstream? If so, we must have |
| 1268 | * the tag object pointed at by "refs/tags/$T" where $T is the |
| 1269 | * tagname recorded in the tag object. We want to allow such |
| 1270 | * a "just to catch up" merge to fast-forward. |
| 1271 | * |
| 1272 | * Otherwise, we are playing an integrator's role, making a |
| 1273 | * merge with a throw-away tag from a contributor with |
| 1274 | * something like "git pull $contributor $signed_tag". |
| 1275 | * We want to forbid such a merge from fast-forwarding |
| 1276 | * by default; otherwise we would not keep the signature |
| 1277 | * anywhere. |
| 1278 | */ |
| 1279 | tag_ref = xstrfmt("refs/tags/%s", |
| 1280 | ((struct tag *)merge_remote_util(commit)->obj)->tag); |
| 1281 | if (!read_ref(tag_ref, &oid) && |
Jeff King | 4a7e27e | 2018-08-28 17:22:40 -0400 | [diff] [blame] | 1282 | oideq(&oid, &merge_remote_util(commit)->obj->oid)) |
Junio C Hamano | adcc94a | 2018-02-14 10:18:55 -0800 | [diff] [blame] | 1283 | is_throwaway_tag = 0; |
| 1284 | else |
| 1285 | is_throwaway_tag = 1; |
| 1286 | free(tag_ref); |
| 1287 | return is_throwaway_tag; |
| 1288 | } |
| 1289 | |
Miklos Vajna | 1c7b76b | 2008-07-07 19:24:20 +0200 | [diff] [blame] | 1290 | int cmd_merge(int argc, const char **argv, const char *prefix) |
| 1291 | { |
brian m. carlson | 5268431 | 2017-02-21 23:47:28 +0000 | [diff] [blame] | 1292 | struct object_id result_tree, stash, head_oid; |
Nguyễn Thái Ngọc Duy | 894642f | 2011-09-17 21:57:44 +1000 | [diff] [blame] | 1293 | struct commit *head_commit; |
Brandon Casey | f285a2d | 2008-10-09 14:12:12 -0500 | [diff] [blame] | 1294 | struct strbuf buf = STRBUF_INIT; |
Michael Haggerty | 17377b6 | 2016-04-07 15:03:06 -0400 | [diff] [blame] | 1295 | int i, ret = 0, head_subsumed; |
Miklos Vajna | 1c7b76b | 2008-07-07 19:24:20 +0200 | [diff] [blame] | 1296 | int best_cnt = -1, merge_was_ok = 0, automerge_was_ok = 0; |
| 1297 | struct commit_list *common = NULL; |
| 1298 | const char *best_strategy = NULL, *wt_strategy = NULL; |
Elijah Newren | 6046f7a | 2022-01-20 07:47:15 +0000 | [diff] [blame] | 1299 | struct commit_list *remoteheads = NULL, *p; |
Nguyễn Thái Ngọc Duy | 96ec7b1 | 2011-12-13 21:17:48 +0700 | [diff] [blame] | 1300 | void *branch_to_free; |
Chris Packham | 367ff69 | 2016-12-14 21:37:55 +1300 | [diff] [blame] | 1301 | int orig_argc = argc; |
Miklos Vajna | 1c7b76b | 2008-07-07 19:24:20 +0200 | [diff] [blame] | 1302 | |
Nguyễn Thái Ngọc Duy | da53eec | 2010-10-22 01:49:45 -0500 | [diff] [blame] | 1303 | if (argc == 2 && !strcmp(argv[1], "-h")) |
| 1304 | usage_with_options(builtin_merge_usage, builtin_merge_options); |
Miklos Vajna | 1c7b76b | 2008-07-07 19:24:20 +0200 | [diff] [blame] | 1305 | |
Derrick Stolee | a338063 | 2021-09-08 11:23:57 +0000 | [diff] [blame] | 1306 | prepare_repo_settings(the_repository); |
| 1307 | the_repository->settings.command_requires_full_index = 0; |
| 1308 | |
Miklos Vajna | 1c7b76b | 2008-07-07 19:24:20 +0200 | [diff] [blame] | 1309 | /* |
| 1310 | * Check if we are _not_ on a detached HEAD, i.e. if there is a |
| 1311 | * current branch. |
| 1312 | */ |
brian m. carlson | 0f2dc72 | 2017-10-15 22:06:55 +0000 | [diff] [blame] | 1313 | branch = branch_to_free = resolve_refdup("HEAD", 0, &head_oid, NULL); |
René Scharfe | de3ce21 | 2017-08-10 18:47:55 +0200 | [diff] [blame] | 1314 | if (branch) |
| 1315 | skip_prefix(branch, "refs/heads/", &branch); |
Derrick Stolee | 7adf526 | 2018-05-01 12:47:23 +0000 | [diff] [blame] | 1316 | |
Elijah Newren | 14c4586 | 2020-11-02 23:45:34 +0000 | [diff] [blame] | 1317 | if (!pull_twohead) { |
| 1318 | char *default_strategy = getenv("GIT_TEST_MERGE_ALGORITHM"); |
| 1319 | if (default_strategy && !strcmp(default_strategy, "ort")) |
| 1320 | pull_twohead = "ort"; |
| 1321 | } |
| 1322 | |
Derrick Stolee | 7adf526 | 2018-05-01 12:47:23 +0000 | [diff] [blame] | 1323 | init_diff_ui_defaults(); |
| 1324 | git_config(git_merge_config, NULL); |
| 1325 | |
brian m. carlson | 5268431 | 2017-02-21 23:47:28 +0000 | [diff] [blame] | 1326 | if (!branch || is_null_oid(&head_oid)) |
Nguyễn Thái Ngọc Duy | 894642f | 2011-09-17 21:57:44 +1000 | [diff] [blame] | 1327 | head_commit = NULL; |
Nguyễn Thái Ngọc Duy | baf18fc | 2011-09-17 21:57:45 +1000 | [diff] [blame] | 1328 | else |
brian m. carlson | bc83266 | 2017-05-06 22:10:10 +0000 | [diff] [blame] | 1329 | head_commit = lookup_commit_or_die(&head_oid, "HEAD"); |
Miklos Vajna | 1c7b76b | 2008-07-07 19:24:20 +0200 | [diff] [blame] | 1330 | |
Junio C Hamano | 0d8fc3e | 2011-05-04 17:42:51 -0700 | [diff] [blame] | 1331 | if (branch_mergeoptions) |
| 1332 | parse_branch_merge_options(branch_mergeoptions); |
Stephen Boyd | 3778292 | 2009-05-23 11:53:12 -0700 | [diff] [blame] | 1333 | argc = parse_options(argc, argv, prefix, builtin_merge_options, |
Miklos Vajna | 1c7b76b | 2008-07-07 19:24:20 +0200 | [diff] [blame] | 1334 | builtin_merge_usage, 0); |
Junio C Hamano | 898eacd | 2011-10-06 23:12:09 -0700 | [diff] [blame] | 1335 | if (shortlog_len < 0) |
| 1336 | shortlog_len = (merge_log_config > 0) ? merge_log_config : 0; |
Johan Herland | 2a22c1b | 2010-11-09 22:49:58 +0100 | [diff] [blame] | 1337 | |
Jeff King | 99bfc66 | 2011-02-20 04:53:21 -0500 | [diff] [blame] | 1338 | if (verbosity < 0 && show_progress == -1) |
| 1339 | show_progress = 0; |
| 1340 | |
Johan Herland | 35d2fff | 2010-11-09 22:49:59 +0100 | [diff] [blame] | 1341 | if (abort_current_merge) { |
| 1342 | int nargc = 2; |
| 1343 | const char *nargv[] = {"reset", "--merge", NULL}; |
Denton Liu | a03b555 | 2020-04-07 10:28:07 -0400 | [diff] [blame] | 1344 | struct strbuf stash_oid = STRBUF_INIT; |
Johan Herland | 35d2fff | 2010-11-09 22:49:59 +0100 | [diff] [blame] | 1345 | |
Chris Packham | 042e290 | 2016-12-14 21:37:57 +1300 | [diff] [blame] | 1346 | if (orig_argc != 2) |
Jeff King | c7d227d | 2016-12-15 12:43:46 -0500 | [diff] [blame] | 1347 | usage_msg_opt(_("--abort expects no arguments"), |
Chris Packham | 042e290 | 2016-12-14 21:37:57 +1300 | [diff] [blame] | 1348 | builtin_merge_usage, builtin_merge_options); |
| 1349 | |
Stefan Beller | 102de88 | 2018-05-17 15:51:51 -0700 | [diff] [blame] | 1350 | if (!file_exists(git_path_merge_head(the_repository))) |
Ævar Arnfjörð Bjarmason | bacec47 | 2011-02-22 23:41:59 +0000 | [diff] [blame] | 1351 | die(_("There is no merge to abort (MERGE_HEAD missing).")); |
Johan Herland | 35d2fff | 2010-11-09 22:49:59 +0100 | [diff] [blame] | 1352 | |
Denton Liu | a03b555 | 2020-04-07 10:28:07 -0400 | [diff] [blame] | 1353 | if (read_oneliner(&stash_oid, git_path_merge_autostash(the_repository), |
| 1354 | READ_ONELINER_SKIP_IF_EMPTY)) |
| 1355 | unlink(git_path_merge_autostash(the_repository)); |
| 1356 | |
Johan Herland | 35d2fff | 2010-11-09 22:49:59 +0100 | [diff] [blame] | 1357 | /* Invoke 'git reset --merge' */ |
Nguyễn Thái Ngọc Duy | d5a35c1 | 2011-11-13 17:22:15 +0700 | [diff] [blame] | 1358 | ret = cmd_reset(nargc, nargv, prefix); |
Denton Liu | a03b555 | 2020-04-07 10:28:07 -0400 | [diff] [blame] | 1359 | |
| 1360 | if (stash_oid.len) |
| 1361 | apply_autostash_oid(stash_oid.buf); |
| 1362 | |
| 1363 | strbuf_release(&stash_oid); |
Nguyễn Thái Ngọc Duy | d5a35c1 | 2011-11-13 17:22:15 +0700 | [diff] [blame] | 1364 | goto done; |
Johan Herland | 35d2fff | 2010-11-09 22:49:59 +0100 | [diff] [blame] | 1365 | } |
| 1366 | |
Nguyễn Thái Ngọc Duy | f3f8311 | 2019-05-18 18:30:43 +0700 | [diff] [blame] | 1367 | if (quit_current_merge) { |
| 1368 | if (orig_argc != 2) |
| 1369 | usage_msg_opt(_("--quit expects no arguments"), |
| 1370 | builtin_merge_usage, |
| 1371 | builtin_merge_options); |
| 1372 | |
| 1373 | remove_merge_branch_state(the_repository); |
| 1374 | goto done; |
| 1375 | } |
| 1376 | |
Chris Packham | 367ff69 | 2016-12-14 21:37:55 +1300 | [diff] [blame] | 1377 | if (continue_current_merge) { |
| 1378 | int nargc = 1; |
| 1379 | const char *nargv[] = {"commit", NULL}; |
| 1380 | |
| 1381 | if (orig_argc != 2) |
Jeff King | c7d227d | 2016-12-15 12:43:46 -0500 | [diff] [blame] | 1382 | usage_msg_opt(_("--continue expects no arguments"), |
Chris Packham | 367ff69 | 2016-12-14 21:37:55 +1300 | [diff] [blame] | 1383 | builtin_merge_usage, builtin_merge_options); |
| 1384 | |
Stefan Beller | 102de88 | 2018-05-17 15:51:51 -0700 | [diff] [blame] | 1385 | if (!file_exists(git_path_merge_head(the_repository))) |
Chris Packham | 367ff69 | 2016-12-14 21:37:55 +1300 | [diff] [blame] | 1386 | die(_("There is no merge in progress (MERGE_HEAD missing).")); |
| 1387 | |
| 1388 | /* Invoke 'git commit' */ |
| 1389 | ret = cmd_commit(nargc, nargv, prefix); |
| 1390 | goto done; |
| 1391 | } |
| 1392 | |
Ævar Arnfjörð Bjarmason | fbc1ed6 | 2022-11-19 14:07:30 +0100 | [diff] [blame] | 1393 | if (repo_read_index_unmerged(the_repository)) |
Johan Herland | 2a22c1b | 2010-11-09 22:49:58 +0100 | [diff] [blame] | 1394 | die_resolve_conflict("merge"); |
| 1395 | |
Stefan Beller | 102de88 | 2018-05-17 15:51:51 -0700 | [diff] [blame] | 1396 | if (file_exists(git_path_merge_head(the_repository))) { |
Johan Herland | 2a22c1b | 2010-11-09 22:49:58 +0100 | [diff] [blame] | 1397 | /* |
| 1398 | * There is no unmerged entry, don't advise 'git |
| 1399 | * add/rm <file>', just 'git commit'. |
| 1400 | */ |
Ben Boeckel | ed9bff0 | 2021-08-23 12:44:00 +0200 | [diff] [blame] | 1401 | if (advice_enabled(ADVICE_RESOLVE_CONFLICT)) |
Ævar Arnfjörð Bjarmason | bacec47 | 2011-02-22 23:41:59 +0000 | [diff] [blame] | 1402 | die(_("You have not concluded your merge (MERGE_HEAD exists).\n" |
Alex Henrie | ad5fe37 | 2014-08-30 13:56:01 -0600 | [diff] [blame] | 1403 | "Please, commit your changes before you merge.")); |
Johan Herland | 2a22c1b | 2010-11-09 22:49:58 +0100 | [diff] [blame] | 1404 | else |
Ævar Arnfjörð Bjarmason | bacec47 | 2011-02-22 23:41:59 +0000 | [diff] [blame] | 1405 | die(_("You have not concluded your merge (MERGE_HEAD exists).")); |
Johan Herland | 2a22c1b | 2010-11-09 22:49:58 +0100 | [diff] [blame] | 1406 | } |
Han-Wen Nienhuys | c8e4159 | 2020-08-21 16:59:35 +0000 | [diff] [blame] | 1407 | if (ref_exists("CHERRY_PICK_HEAD")) { |
Ben Boeckel | ed9bff0 | 2021-08-23 12:44:00 +0200 | [diff] [blame] | 1408 | if (advice_enabled(ADVICE_RESOLVE_CONFLICT)) |
Ævar Arnfjörð Bjarmason | f68f180 | 2011-04-10 19:34:05 +0000 | [diff] [blame] | 1409 | die(_("You have not concluded your cherry-pick (CHERRY_PICK_HEAD exists).\n" |
Alex Henrie | ad5fe37 | 2014-08-30 13:56:01 -0600 | [diff] [blame] | 1410 | "Please, commit your changes before you merge.")); |
Jay Soffian | d7e5c0c | 2011-02-19 23:12:27 -0500 | [diff] [blame] | 1411 | else |
Ævar Arnfjörð Bjarmason | f68f180 | 2011-04-10 19:34:05 +0000 | [diff] [blame] | 1412 | die(_("You have not concluded your cherry-pick (CHERRY_PICK_HEAD exists).")); |
Jay Soffian | d7e5c0c | 2011-02-19 23:12:27 -0500 | [diff] [blame] | 1413 | } |
Ævar Arnfjörð Bjarmason | 031b203 | 2022-11-19 14:07:33 +0100 | [diff] [blame] | 1414 | resolve_undo_clear_index(&the_index); |
Johan Herland | 2a22c1b | 2010-11-09 22:49:58 +0100 | [diff] [blame] | 1415 | |
Denton Liu | d540b70 | 2019-04-17 11:23:27 +0100 | [diff] [blame] | 1416 | if (option_edit < 0) |
| 1417 | option_edit = default_edit_option(); |
| 1418 | |
| 1419 | cleanup_mode = get_cleanup_mode(cleanup_arg, 0 < option_edit); |
| 1420 | |
Tuncer Ayaz | 7f87aff | 2008-11-15 01:14:24 +0100 | [diff] [blame] | 1421 | if (verbosity < 0) |
| 1422 | show_diffstat = 0; |
Miklos Vajna | 1c7b76b | 2008-07-07 19:24:20 +0200 | [diff] [blame] | 1423 | |
| 1424 | if (squash) { |
Miklos Vajna | a54841e | 2013-07-02 16:47:57 +0200 | [diff] [blame] | 1425 | if (fast_forward == FF_NO) |
Jean-Noël Avila | 12909b6 | 2022-01-05 20:02:16 +0000 | [diff] [blame] | 1426 | die(_("options '%s' and '%s' cannot be used together"), "--squash", "--no-ff."); |
Vishal Verma | 1d14d0c | 2019-05-24 12:36:17 -0600 | [diff] [blame] | 1427 | if (option_commit > 0) |
Jean-Noël Avila | 12909b6 | 2022-01-05 20:02:16 +0000 | [diff] [blame] | 1428 | die(_("options '%s' and '%s' cannot be used together"), "--squash", "--commit."); |
Vishal Verma | 1d14d0c | 2019-05-24 12:36:17 -0600 | [diff] [blame] | 1429 | /* |
| 1430 | * squash can now silently disable option_commit - this is not |
| 1431 | * a problem as it is only overriding the default, not a user |
| 1432 | * supplied option. |
| 1433 | */ |
Miklos Vajna | 1c7b76b | 2008-07-07 19:24:20 +0200 | [diff] [blame] | 1434 | option_commit = 0; |
| 1435 | } |
| 1436 | |
Vishal Verma | 1d14d0c | 2019-05-24 12:36:17 -0600 | [diff] [blame] | 1437 | if (option_commit < 0) |
| 1438 | option_commit = 1; |
| 1439 | |
Junio C Hamano | 00c7e7e | 2015-04-23 13:01:44 -0700 | [diff] [blame] | 1440 | if (!argc) { |
| 1441 | if (default_to_upstream) |
| 1442 | argc = setup_with_upstream(&argv); |
| 1443 | else |
| 1444 | die(_("No commit specified and merge.defaultToUpstream not set.")); |
| 1445 | } else if (argc == 1 && !strcmp(argv[0], "-")) { |
| 1446 | argv[0] = "@{-1}"; |
Junio C Hamano | 4e8115f | 2011-04-07 15:57:57 -0700 | [diff] [blame] | 1447 | } |
Junio C Hamano | 00c7e7e | 2015-04-23 13:01:44 -0700 | [diff] [blame] | 1448 | |
Miklos Vajna | 1c7b76b | 2008-07-07 19:24:20 +0200 | [diff] [blame] | 1449 | if (!argc) |
| 1450 | usage_with_options(builtin_merge_usage, |
| 1451 | builtin_merge_options); |
| 1452 | |
Junio C Hamano | 1faac1c | 2015-04-23 13:46:44 -0700 | [diff] [blame] | 1453 | if (!head_commit) { |
Miklos Vajna | 1c7b76b | 2008-07-07 19:24:20 +0200 | [diff] [blame] | 1454 | /* |
| 1455 | * If the merged head is a valid one there is no reason |
| 1456 | * to forbid "git merge" into a branch yet to be born. |
| 1457 | * We do the same for "git pull". |
| 1458 | */ |
brian m. carlson | 5268431 | 2017-02-21 23:47:28 +0000 | [diff] [blame] | 1459 | struct object_id *remote_head_oid; |
Paolo Bonzini | 4be636f | 2008-08-21 14:14:18 +0200 | [diff] [blame] | 1460 | if (squash) |
Ævar Arnfjörð Bjarmason | bacec47 | 2011-02-22 23:41:59 +0000 | [diff] [blame] | 1461 | die(_("Squash commit into empty head not supported yet")); |
Miklos Vajna | a54841e | 2013-07-02 16:47:57 +0200 | [diff] [blame] | 1462 | if (fast_forward == FF_NO) |
Ævar Arnfjörð Bjarmason | bacec47 | 2011-02-22 23:41:59 +0000 | [diff] [blame] | 1463 | die(_("Non-fast-forward commit does not make sense into " |
| 1464 | "an empty head")); |
Junio C Hamano | 1cf32f4 | 2015-04-25 18:34:22 -0700 | [diff] [blame] | 1465 | remoteheads = collect_parents(head_commit, &head_subsumed, |
| 1466 | argc, argv, NULL); |
Junio C Hamano | b84e65d | 2016-03-21 12:01:43 -0700 | [diff] [blame] | 1467 | if (!remoteheads) |
Ævar Arnfjörð Bjarmason | bacec47 | 2011-02-22 23:41:59 +0000 | [diff] [blame] | 1468 | die(_("%s - not something we can merge"), argv[0]); |
Junio C Hamano | eaa4e59 | 2015-04-23 13:56:34 -0700 | [diff] [blame] | 1469 | if (remoteheads->next) |
| 1470 | die(_("Can merge only exactly one commit into empty head")); |
Jeff King | 7488ba3 | 2018-11-06 02:51:15 -0500 | [diff] [blame] | 1471 | |
| 1472 | if (verify_signatures) |
Hans Jerry Illikainen | 54887b4 | 2019-12-27 13:55:57 +0000 | [diff] [blame] | 1473 | verify_merge_signature(remoteheads->item, verbosity, |
| 1474 | check_trust_level); |
Jeff King | 7488ba3 | 2018-11-06 02:51:15 -0500 | [diff] [blame] | 1475 | |
brian m. carlson | 5268431 | 2017-02-21 23:47:28 +0000 | [diff] [blame] | 1476 | remote_head_oid = &remoteheads->item->object.oid; |
Ævar Arnfjörð Bjarmason | 9397f3c | 2022-10-30 12:42:59 +0100 | [diff] [blame] | 1477 | read_empty(remote_head_oid); |
brian m. carlson | ae07777 | 2017-10-15 22:06:51 +0000 | [diff] [blame] | 1478 | update_ref("initial pull", "HEAD", remote_head_oid, NULL, 0, |
| 1479 | UPDATE_REFS_DIE_ON_ERR); |
Nguyễn Thái Ngọc Duy | d5a35c1 | 2011-11-13 17:22:15 +0700 | [diff] [blame] | 1480 | goto done; |
Junio C Hamano | 1faac1c | 2015-04-23 13:46:44 -0700 | [diff] [blame] | 1481 | } |
| 1482 | |
Miklos Vajna | 1c7b76b | 2008-07-07 19:24:20 +0200 | [diff] [blame] | 1483 | /* |
Junio C Hamano | b439165 | 2015-03-25 22:00:48 -0700 | [diff] [blame] | 1484 | * All the rest are the commits being merged; prepare |
| 1485 | * the standard merge summary message to be appended |
| 1486 | * to the given message. |
Miklos Vajna | 1c7b76b | 2008-07-07 19:24:20 +0200 | [diff] [blame] | 1487 | */ |
Junio C Hamano | b439165 | 2015-03-25 22:00:48 -0700 | [diff] [blame] | 1488 | remoteheads = collect_parents(head_commit, &head_subsumed, |
| 1489 | argc, argv, &merge_msg); |
Miklos Vajna | 1c7b76b | 2008-07-07 19:24:20 +0200 | [diff] [blame] | 1490 | |
Nguyễn Thái Ngọc Duy | 894642f | 2011-09-17 21:57:44 +1000 | [diff] [blame] | 1491 | if (!head_commit || !argc) |
Miklos Vajna | 1c7b76b | 2008-07-07 19:24:20 +0200 | [diff] [blame] | 1492 | usage_with_options(builtin_merge_usage, |
| 1493 | builtin_merge_options); |
| 1494 | |
Sebastian Götte | efed002 | 2013-03-31 18:02:24 +0200 | [diff] [blame] | 1495 | if (verify_signatures) { |
| 1496 | for (p = remoteheads; p; p = p->next) { |
Hans Jerry Illikainen | 54887b4 | 2019-12-27 13:55:57 +0000 | [diff] [blame] | 1497 | verify_merge_signature(p->item, verbosity, |
| 1498 | check_trust_level); |
Sebastian Götte | efed002 | 2013-03-31 18:02:24 +0200 | [diff] [blame] | 1499 | } |
| 1500 | } |
| 1501 | |
Miklos Vajna | 1c7b76b | 2008-07-07 19:24:20 +0200 | [diff] [blame] | 1502 | strbuf_addstr(&buf, "merge"); |
Junio C Hamano | b5d887f | 2012-04-17 11:31:10 -0700 | [diff] [blame] | 1503 | for (p = remoteheads; p; p = p->next) |
| 1504 | strbuf_addf(&buf, " %s", merge_remote_util(p->item)->name); |
Miklos Vajna | 1c7b76b | 2008-07-07 19:24:20 +0200 | [diff] [blame] | 1505 | setenv("GIT_REFLOG_ACTION", buf.buf, 0); |
| 1506 | strbuf_reset(&buf); |
| 1507 | |
Junio C Hamano | b5d887f | 2012-04-17 11:31:10 -0700 | [diff] [blame] | 1508 | for (p = remoteheads; p; p = p->next) { |
| 1509 | struct commit *commit = p->item; |
Junio C Hamano | ae8e4c9 | 2011-11-07 13:26:22 -0800 | [diff] [blame] | 1510 | strbuf_addf(&buf, "GITHEAD_%s", |
brian m. carlson | c368dde | 2016-06-24 23:09:22 +0000 | [diff] [blame] | 1511 | oid_to_hex(&commit->object.oid)); |
Junio C Hamano | b5d887f | 2012-04-17 11:31:10 -0700 | [diff] [blame] | 1512 | setenv(buf.buf, merge_remote_util(commit)->name, 1); |
Miklos Vajna | 1c7b76b | 2008-07-07 19:24:20 +0200 | [diff] [blame] | 1513 | strbuf_reset(&buf); |
Junio C Hamano | adcc94a | 2018-02-14 10:18:55 -0800 | [diff] [blame] | 1514 | if (fast_forward != FF_ONLY && merging_a_throwaway_tag(commit)) |
Miklos Vajna | a54841e | 2013-07-02 16:47:57 +0200 | [diff] [blame] | 1515 | fast_forward = FF_NO; |
Miklos Vajna | 1c7b76b | 2008-07-07 19:24:20 +0200 | [diff] [blame] | 1516 | } |
| 1517 | |
Elijah Newren | 6a5fb96 | 2021-08-04 05:38:01 +0000 | [diff] [blame] | 1518 | if (!use_strategies && !pull_twohead && |
| 1519 | remoteheads && !remoteheads->next) { |
| 1520 | char *default_strategy = getenv("GIT_TEST_MERGE_ALGORITHM"); |
| 1521 | if (default_strategy) |
| 1522 | append_strategy(get_strategy(default_strategy)); |
| 1523 | } |
Miklos Vajna | 1c7b76b | 2008-07-07 19:24:20 +0200 | [diff] [blame] | 1524 | if (!use_strategies) { |
Junio C Hamano | e78cbf8 | 2012-04-17 12:22:26 -0700 | [diff] [blame] | 1525 | if (!remoteheads) |
| 1526 | ; /* already up-to-date */ |
| 1527 | else if (!remoteheads->next) |
Miklos Vajna | 1c7b76b | 2008-07-07 19:24:20 +0200 | [diff] [blame] | 1528 | add_strategies(pull_twohead, DEFAULT_TWOHEAD); |
| 1529 | else |
| 1530 | add_strategies(pull_octopus, DEFAULT_OCTOPUS); |
| 1531 | } |
| 1532 | |
| 1533 | for (i = 0; i < use_strategies_nr; i++) { |
| 1534 | if (use_strategies[i]->attr & NO_FAST_FORWARD) |
Miklos Vajna | a54841e | 2013-07-02 16:47:57 +0200 | [diff] [blame] | 1535 | fast_forward = FF_NO; |
Miklos Vajna | 1c7b76b | 2008-07-07 19:24:20 +0200 | [diff] [blame] | 1536 | if (use_strategies[i]->attr & NO_TRIVIAL) |
| 1537 | allow_trivial = 0; |
| 1538 | } |
| 1539 | |
Junio C Hamano | e78cbf8 | 2012-04-17 12:22:26 -0700 | [diff] [blame] | 1540 | if (!remoteheads) |
| 1541 | ; /* already up-to-date */ |
| 1542 | else if (!remoteheads->next) |
Ævar Arnfjörð Bjarmason | cb338c2 | 2023-03-28 15:58:47 +0200 | [diff] [blame] | 1543 | common = repo_get_merge_bases(the_repository, head_commit, |
| 1544 | remoteheads->item); |
Miklos Vajna | 1c7b76b | 2008-07-07 19:24:20 +0200 | [diff] [blame] | 1545 | else { |
| 1546 | struct commit_list *list = remoteheads; |
Nguyễn Thái Ngọc Duy | 894642f | 2011-09-17 21:57:44 +1000 | [diff] [blame] | 1547 | commit_list_insert(head_commit, &list); |
Miklos Vajna | 1c7b76b | 2008-07-07 19:24:20 +0200 | [diff] [blame] | 1548 | common = get_octopus_merge_bases(list); |
| 1549 | free(list); |
| 1550 | } |
| 1551 | |
brian m. carlson | ae07777 | 2017-10-15 22:06:51 +0000 | [diff] [blame] | 1552 | update_ref("updating ORIG_HEAD", "ORIG_HEAD", |
| 1553 | &head_commit->object.oid, NULL, 0, UPDATE_REFS_DIE_ON_ERR); |
Miklos Vajna | 1c7b76b | 2008-07-07 19:24:20 +0200 | [diff] [blame] | 1554 | |
Junio C Hamano | e379fdf | 2016-03-18 13:21:09 -0700 | [diff] [blame] | 1555 | if (remoteheads && !common) { |
| 1556 | /* No common ancestors found. */ |
| 1557 | if (!allow_unrelated_histories) |
| 1558 | die(_("refusing to merge unrelated histories")); |
| 1559 | /* otherwise, we need a real merge. */ |
| 1560 | } else if (!remoteheads || |
Junio C Hamano | e78cbf8 | 2012-04-17 12:22:26 -0700 | [diff] [blame] | 1561 | (!remoteheads->next && !common->next && |
| 1562 | common->item == remoteheads->item)) { |
Miklos Vajna | 1c7b76b | 2008-07-07 19:24:20 +0200 | [diff] [blame] | 1563 | /* |
| 1564 | * If head can reach all the merge then we are up to date. |
| 1565 | * but first the most common case of merging one remote. |
| 1566 | */ |
Josh Soref | ad9322d | 2021-05-02 01:14:23 -0400 | [diff] [blame] | 1567 | finish_up_to_date(); |
Nguyễn Thái Ngọc Duy | d5a35c1 | 2011-11-13 17:22:15 +0700 | [diff] [blame] | 1568 | goto done; |
Miklos Vajna | a54841e | 2013-07-02 16:47:57 +0200 | [diff] [blame] | 1569 | } else if (fast_forward != FF_NO && !remoteheads->next && |
Miklos Vajna | 1c7b76b | 2008-07-07 19:24:20 +0200 | [diff] [blame] | 1570 | !common->next && |
Jeff King | 4a7e27e | 2018-08-28 17:22:40 -0400 | [diff] [blame] | 1571 | oideq(&common->item->object.oid, &head_commit->object.oid)) { |
Miklos Vajna | 1c7b76b | 2008-07-07 19:24:20 +0200 | [diff] [blame] | 1572 | /* Again the most common case of merging one remote. */ |
Ævar Arnfjörð Bjarmason | 345e216 | 2023-02-07 00:07:48 +0100 | [diff] [blame] | 1573 | const char *msg = have_message ? |
| 1574 | "Fast-forward (no commit created; -m option ignored)" : |
| 1575 | "Fast-forward"; |
Junio C Hamano | ae8e4c9 | 2011-11-07 13:26:22 -0800 | [diff] [blame] | 1576 | struct commit *commit; |
Miklos Vajna | 1c7b76b | 2008-07-07 19:24:20 +0200 | [diff] [blame] | 1577 | |
Jeff King | d59f765 | 2015-09-24 17:08:03 -0400 | [diff] [blame] | 1578 | if (verbosity >= 0) { |
Jeff King | ef2ed50 | 2016-10-20 02:19:19 -0400 | [diff] [blame] | 1579 | printf(_("Updating %s..%s\n"), |
Ævar Arnfjörð Bjarmason | d850b7a | 2023-03-28 15:58:46 +0200 | [diff] [blame] | 1580 | repo_find_unique_abbrev(the_repository, &head_commit->object.oid, |
| 1581 | DEFAULT_ABBREV), |
| 1582 | repo_find_unique_abbrev(the_repository, &remoteheads->item->object.oid, |
| 1583 | DEFAULT_ABBREV)); |
Jeff King | d59f765 | 2015-09-24 17:08:03 -0400 | [diff] [blame] | 1584 | } |
Junio C Hamano | ae8e4c9 | 2011-11-07 13:26:22 -0800 | [diff] [blame] | 1585 | commit = remoteheads->item; |
Junio C Hamano | b7f7c07 | 2011-12-09 13:37:14 -0800 | [diff] [blame] | 1586 | if (!commit) { |
Nguyễn Thái Ngọc Duy | d5a35c1 | 2011-11-13 17:22:15 +0700 | [diff] [blame] | 1587 | ret = 1; |
| 1588 | goto done; |
| 1589 | } |
Miklos Vajna | 1c7b76b | 2008-07-07 19:24:20 +0200 | [diff] [blame] | 1590 | |
Denton Liu | a03b555 | 2020-04-07 10:28:07 -0400 | [diff] [blame] | 1591 | if (autostash) |
| 1592 | create_autostash(the_repository, |
Phillip Wood | b7de153 | 2022-01-26 13:05:44 +0000 | [diff] [blame] | 1593 | git_path_merge_autostash(the_repository)); |
Nguyễn Thái Ngọc Duy | 7e196c3 | 2018-09-21 17:57:29 +0200 | [diff] [blame] | 1594 | if (checkout_fast_forward(the_repository, |
| 1595 | &head_commit->object.oid, |
brian m. carlson | f06e90d | 2017-05-06 22:10:33 +0000 | [diff] [blame] | 1596 | &commit->object.oid, |
Nguyễn Thái Ngọc Duy | db699a8 | 2012-10-26 22:53:49 +0700 | [diff] [blame] | 1597 | overwrite_ignore)) { |
Philippe Blain | 12510bd | 2021-07-23 12:14:29 +0000 | [diff] [blame] | 1598 | apply_autostash(git_path_merge_autostash(the_repository)); |
Nguyễn Thái Ngọc Duy | d5a35c1 | 2011-11-13 17:22:15 +0700 | [diff] [blame] | 1599 | ret = 1; |
| 1600 | goto done; |
| 1601 | } |
Miklos Vajna | 1c7b76b | 2008-07-07 19:24:20 +0200 | [diff] [blame] | 1602 | |
Ævar Arnfjörð Bjarmason | 345e216 | 2023-02-07 00:07:48 +0100 | [diff] [blame] | 1603 | finish(head_commit, remoteheads, &commit->object.oid, msg); |
Nguyễn Thái Ngọc Duy | b643355 | 2019-05-09 17:10:27 +0700 | [diff] [blame] | 1604 | remove_merge_branch_state(the_repository); |
Nguyễn Thái Ngọc Duy | d5a35c1 | 2011-11-13 17:22:15 +0700 | [diff] [blame] | 1605 | goto done; |
Miklos Vajna | 1c7b76b | 2008-07-07 19:24:20 +0200 | [diff] [blame] | 1606 | } else if (!remoteheads->next && common->next) |
| 1607 | ; |
| 1608 | /* |
Felipe Contreras | a75d7b5 | 2009-10-24 11:31:32 +0300 | [diff] [blame] | 1609 | * We are not doing octopus and not fast-forward. Need |
Miklos Vajna | 1c7b76b | 2008-07-07 19:24:20 +0200 | [diff] [blame] | 1610 | * a real merge. |
| 1611 | */ |
| 1612 | else if (!remoteheads->next && !common->next && option_commit) { |
| 1613 | /* |
Felipe Contreras | a75d7b5 | 2009-10-24 11:31:32 +0300 | [diff] [blame] | 1614 | * We are not doing octopus, not fast-forward, and have |
Miklos Vajna | 1c7b76b | 2008-07-07 19:24:20 +0200 | [diff] [blame] | 1615 | * only one common. |
| 1616 | */ |
Ævar Arnfjörð Bjarmason | 07047d6 | 2022-11-19 14:07:38 +0100 | [diff] [blame] | 1617 | refresh_index(&the_index, REFRESH_QUIET, NULL, NULL, NULL); |
Miklos Vajna | a54841e | 2013-07-02 16:47:57 +0200 | [diff] [blame] | 1618 | if (allow_trivial && fast_forward != FF_ONLY) { |
Elijah Newren | e4cdfe8 | 2022-07-23 01:53:13 +0000 | [diff] [blame] | 1619 | /* |
| 1620 | * Must first ensure that index matches HEAD before |
| 1621 | * attempting a trivial merge. |
| 1622 | */ |
Ævar Arnfjörð Bjarmason | ecb5091 | 2023-03-28 15:58:48 +0200 | [diff] [blame] | 1623 | struct tree *head_tree = repo_get_commit_tree(the_repository, |
| 1624 | head_commit); |
Elijah Newren | e4cdfe8 | 2022-07-23 01:53:13 +0000 | [diff] [blame] | 1625 | struct strbuf sb = STRBUF_INIT; |
| 1626 | |
| 1627 | if (repo_index_has_changes(the_repository, head_tree, |
| 1628 | &sb)) { |
| 1629 | error(_("Your local changes to the following files would be overwritten by merge:\n %s"), |
| 1630 | sb.buf); |
| 1631 | strbuf_release(&sb); |
Ævar Arnfjörð Bjarmason | 41211db | 2023-02-07 00:07:49 +0100 | [diff] [blame] | 1632 | ret = 2; |
| 1633 | goto done; |
Elijah Newren | e4cdfe8 | 2022-07-23 01:53:13 +0000 | [diff] [blame] | 1634 | } |
| 1635 | |
Miklos Vajna | 1c7b76b | 2008-07-07 19:24:20 +0200 | [diff] [blame] | 1636 | /* See if it is really trivial. */ |
Jeff King | f9bc573 | 2012-05-24 19:28:40 -0400 | [diff] [blame] | 1637 | git_committer_info(IDENT_STRICT); |
Ævar Arnfjörð Bjarmason | bacec47 | 2011-02-22 23:41:59 +0000 | [diff] [blame] | 1638 | printf(_("Trying really trivial in-index merge...\n")); |
brian m. carlson | 5268431 | 2017-02-21 23:47:28 +0000 | [diff] [blame] | 1639 | if (!read_tree_trivial(&common->item->object.oid, |
| 1640 | &head_commit->object.oid, |
| 1641 | &remoteheads->item->object.oid)) { |
Junio C Hamano | 4c57bd2 | 2012-04-16 16:15:13 -0700 | [diff] [blame] | 1642 | ret = merge_trivial(head_commit, remoteheads); |
Nguyễn Thái Ngọc Duy | d5a35c1 | 2011-11-13 17:22:15 +0700 | [diff] [blame] | 1643 | goto done; |
| 1644 | } |
Ævar Arnfjörð Bjarmason | bacec47 | 2011-02-22 23:41:59 +0000 | [diff] [blame] | 1645 | printf(_("Nope.\n")); |
Miklos Vajna | 1c7b76b | 2008-07-07 19:24:20 +0200 | [diff] [blame] | 1646 | } |
| 1647 | } else { |
| 1648 | /* |
| 1649 | * An octopus. If we can reach all the remote we are up |
| 1650 | * to date. |
| 1651 | */ |
| 1652 | int up_to_date = 1; |
| 1653 | struct commit_list *j; |
| 1654 | |
| 1655 | for (j = remoteheads; j; j = j->next) { |
| 1656 | struct commit_list *common_one; |
| 1657 | |
| 1658 | /* |
| 1659 | * Here we *have* to calculate the individual |
| 1660 | * merge_bases again, otherwise "git merge HEAD^ |
| 1661 | * HEAD^^" would be missed. |
| 1662 | */ |
Ævar Arnfjörð Bjarmason | cb338c2 | 2023-03-28 15:58:47 +0200 | [diff] [blame] | 1663 | common_one = repo_get_merge_bases(the_repository, |
| 1664 | head_commit, |
| 1665 | j->item); |
Jeff King | 9001dc2 | 2018-08-28 17:22:48 -0400 | [diff] [blame] | 1666 | if (!oideq(&common_one->item->object.oid, &j->item->object.oid)) { |
Miklos Vajna | 1c7b76b | 2008-07-07 19:24:20 +0200 | [diff] [blame] | 1667 | up_to_date = 0; |
| 1668 | break; |
| 1669 | } |
| 1670 | } |
| 1671 | if (up_to_date) { |
Josh Soref | ad9322d | 2021-05-02 01:14:23 -0400 | [diff] [blame] | 1672 | finish_up_to_date(); |
Nguyễn Thái Ngọc Duy | d5a35c1 | 2011-11-13 17:22:15 +0700 | [diff] [blame] | 1673 | goto done; |
Miklos Vajna | 1c7b76b | 2008-07-07 19:24:20 +0200 | [diff] [blame] | 1674 | } |
| 1675 | } |
| 1676 | |
Miklos Vajna | a54841e | 2013-07-02 16:47:57 +0200 | [diff] [blame] | 1677 | if (fast_forward == FF_ONLY) |
Alex Henrie | 3d5fc24 | 2021-07-21 01:42:19 +0000 | [diff] [blame] | 1678 | die_ff_impossible(); |
Björn Gustavsson | 1347483 | 2009-10-29 23:08:31 +0100 | [diff] [blame] | 1679 | |
Denton Liu | a03b555 | 2020-04-07 10:28:07 -0400 | [diff] [blame] | 1680 | if (autostash) |
| 1681 | create_autostash(the_repository, |
Phillip Wood | b7de153 | 2022-01-26 13:05:44 +0000 | [diff] [blame] | 1682 | git_path_merge_autostash(the_repository)); |
Denton Liu | a03b555 | 2020-04-07 10:28:07 -0400 | [diff] [blame] | 1683 | |
Miklos Vajna | 1c7b76b | 2008-07-07 19:24:20 +0200 | [diff] [blame] | 1684 | /* We are going to make a new commit. */ |
Jeff King | f9bc573 | 2012-05-24 19:28:40 -0400 | [diff] [blame] | 1685 | git_committer_info(IDENT_STRICT); |
Miklos Vajna | 1c7b76b | 2008-07-07 19:24:20 +0200 | [diff] [blame] | 1686 | |
| 1687 | /* |
| 1688 | * At this point, we need a real merge. No matter what strategy |
| 1689 | * we use, it would operate on the index, possibly affecting the |
| 1690 | * working tree, and when resolved cleanly, have the desired |
| 1691 | * tree in the index -- this means that the index must be in |
| 1692 | * sync with the head commit. The strategies are responsible |
| 1693 | * to ensure this. |
Elijah Newren | 034195e | 2022-07-23 01:53:17 +0000 | [diff] [blame] | 1694 | * |
| 1695 | * Stash away the local changes so that we can try more than one |
| 1696 | * and/or recover from merge strategies bailing while leaving the |
| 1697 | * index and working tree polluted. |
Miklos Vajna | 1c7b76b | 2008-07-07 19:24:20 +0200 | [diff] [blame] | 1698 | */ |
Elijah Newren | 034195e | 2022-07-23 01:53:17 +0000 | [diff] [blame] | 1699 | if (save_state(&stash)) |
brian m. carlson | 5268431 | 2017-02-21 23:47:28 +0000 | [diff] [blame] | 1700 | oidclr(&stash); |
Miklos Vajna | 1c7b76b | 2008-07-07 19:24:20 +0200 | [diff] [blame] | 1701 | |
Elijah Newren | 5b1d30c | 2022-08-23 02:42:20 +0000 | [diff] [blame] | 1702 | for (i = 0; i < use_strategies_nr; i++) { |
Edmundo Carmona Antoranz | f00abe6 | 2019-07-08 21:15:59 -0600 | [diff] [blame] | 1703 | int ret, cnt; |
Miklos Vajna | 1c7b76b | 2008-07-07 19:24:20 +0200 | [diff] [blame] | 1704 | if (i) { |
Ævar Arnfjörð Bjarmason | bacec47 | 2011-02-22 23:41:59 +0000 | [diff] [blame] | 1705 | printf(_("Rewinding the tree to pristine...\n")); |
brian m. carlson | 5268431 | 2017-02-21 23:47:28 +0000 | [diff] [blame] | 1706 | restore_state(&head_commit->object.oid, &stash); |
Miklos Vajna | 1c7b76b | 2008-07-07 19:24:20 +0200 | [diff] [blame] | 1707 | } |
| 1708 | if (use_strategies_nr != 1) |
Ævar Arnfjörð Bjarmason | bacec47 | 2011-02-22 23:41:59 +0000 | [diff] [blame] | 1709 | printf(_("Trying merge strategy %s...\n"), |
Miklos Vajna | 1c7b76b | 2008-07-07 19:24:20 +0200 | [diff] [blame] | 1710 | use_strategies[i]->name); |
| 1711 | /* |
| 1712 | * Remember which strategy left the state in the working |
| 1713 | * tree. |
| 1714 | */ |
| 1715 | wt_strategy = use_strategies[i]->name; |
| 1716 | |
Elijah Newren | ae15fd4 | 2022-08-23 02:42:21 +0000 | [diff] [blame] | 1717 | ret = try_merge_strategy(wt_strategy, |
Junio C Hamano | 4c57bd2 | 2012-04-16 16:15:13 -0700 | [diff] [blame] | 1718 | common, remoteheads, |
Junio C Hamano | b439165 | 2015-03-25 22:00:48 -0700 | [diff] [blame] | 1719 | head_commit); |
Edmundo Carmona Antoranz | f00abe6 | 2019-07-08 21:15:59 -0600 | [diff] [blame] | 1720 | /* |
| 1721 | * The backend exits with 1 when conflicts are |
| 1722 | * left to be resolved, with 2 when it does not |
| 1723 | * handle the given merge at all. |
| 1724 | */ |
| 1725 | if (ret < 2) { |
| 1726 | if (!ret) { |
Elijah Newren | 5b1d30c | 2022-08-23 02:42:20 +0000 | [diff] [blame] | 1727 | /* |
| 1728 | * This strategy worked; no point in trying |
| 1729 | * another. |
| 1730 | */ |
Edmundo Carmona Antoranz | f00abe6 | 2019-07-08 21:15:59 -0600 | [diff] [blame] | 1731 | merge_was_ok = 1; |
Elijah Newren | ae15fd4 | 2022-08-23 02:42:21 +0000 | [diff] [blame] | 1732 | best_strategy = wt_strategy; |
Elijah Newren | 5b1d30c | 2022-08-23 02:42:20 +0000 | [diff] [blame] | 1733 | break; |
Miklos Vajna | 1c7b76b | 2008-07-07 19:24:20 +0200 | [diff] [blame] | 1734 | } |
Andrew Ng | 8777616 | 2020-05-19 14:05:35 +0100 | [diff] [blame] | 1735 | cnt = (use_strategies_nr > 1) ? evaluate_result() : 0; |
Edmundo Carmona Antoranz | f00abe6 | 2019-07-08 21:15:59 -0600 | [diff] [blame] | 1736 | if (best_cnt <= 0 || cnt <= best_cnt) { |
Elijah Newren | ae15fd4 | 2022-08-23 02:42:21 +0000 | [diff] [blame] | 1737 | best_strategy = wt_strategy; |
Edmundo Carmona Antoranz | f00abe6 | 2019-07-08 21:15:59 -0600 | [diff] [blame] | 1738 | best_cnt = cnt; |
| 1739 | } |
Miklos Vajna | 1c7b76b | 2008-07-07 19:24:20 +0200 | [diff] [blame] | 1740 | } |
Miklos Vajna | 1c7b76b | 2008-07-07 19:24:20 +0200 | [diff] [blame] | 1741 | } |
| 1742 | |
| 1743 | /* |
| 1744 | * If we have a resulting tree, that means the strategy module |
| 1745 | * auto resolved the merge cleanly. |
| 1746 | */ |
Elijah Newren | 5b1d30c | 2022-08-23 02:42:20 +0000 | [diff] [blame] | 1747 | if (merge_was_ok && option_commit) { |
| 1748 | automerge_was_ok = 1; |
Junio C Hamano | e78cbf8 | 2012-04-17 12:22:26 -0700 | [diff] [blame] | 1749 | ret = finish_automerge(head_commit, head_subsumed, |
| 1750 | common, remoteheads, |
brian m. carlson | 5268431 | 2017-02-21 23:47:28 +0000 | [diff] [blame] | 1751 | &result_tree, wt_strategy); |
Nguyễn Thái Ngọc Duy | d5a35c1 | 2011-11-13 17:22:15 +0700 | [diff] [blame] | 1752 | goto done; |
| 1753 | } |
Miklos Vajna | 1c7b76b | 2008-07-07 19:24:20 +0200 | [diff] [blame] | 1754 | |
| 1755 | /* |
| 1756 | * Pick the result from the best strategy and have the user fix |
| 1757 | * it up. |
| 1758 | */ |
| 1759 | if (!best_strategy) { |
brian m. carlson | 5268431 | 2017-02-21 23:47:28 +0000 | [diff] [blame] | 1760 | restore_state(&head_commit->object.oid, &stash); |
Miklos Vajna | 1c7b76b | 2008-07-07 19:24:20 +0200 | [diff] [blame] | 1761 | if (use_strategies_nr > 1) |
| 1762 | fprintf(stderr, |
Ævar Arnfjörð Bjarmason | bacec47 | 2011-02-22 23:41:59 +0000 | [diff] [blame] | 1763 | _("No merge strategy handled the merge.\n")); |
Miklos Vajna | 1c7b76b | 2008-07-07 19:24:20 +0200 | [diff] [blame] | 1764 | else |
Ævar Arnfjörð Bjarmason | bacec47 | 2011-02-22 23:41:59 +0000 | [diff] [blame] | 1765 | fprintf(stderr, _("Merge with strategy %s failed.\n"), |
Miklos Vajna | 1c7b76b | 2008-07-07 19:24:20 +0200 | [diff] [blame] | 1766 | use_strategies[0]->name); |
Philippe Blain | e082631 | 2021-07-23 12:14:30 +0000 | [diff] [blame] | 1767 | apply_autostash(git_path_merge_autostash(the_repository)); |
Nguyễn Thái Ngọc Duy | d5a35c1 | 2011-11-13 17:22:15 +0700 | [diff] [blame] | 1768 | ret = 2; |
| 1769 | goto done; |
Miklos Vajna | 1c7b76b | 2008-07-07 19:24:20 +0200 | [diff] [blame] | 1770 | } else if (best_strategy == wt_strategy) |
| 1771 | ; /* We already have its result in the working tree. */ |
| 1772 | else { |
Ævar Arnfjörð Bjarmason | bacec47 | 2011-02-22 23:41:59 +0000 | [diff] [blame] | 1773 | printf(_("Rewinding the tree to pristine...\n")); |
brian m. carlson | 5268431 | 2017-02-21 23:47:28 +0000 | [diff] [blame] | 1774 | restore_state(&head_commit->object.oid, &stash); |
Philippe Blain | 9938f30 | 2021-07-23 12:14:27 +0000 | [diff] [blame] | 1775 | printf(_("Using the %s strategy to prepare resolving by hand.\n"), |
Miklos Vajna | 1c7b76b | 2008-07-07 19:24:20 +0200 | [diff] [blame] | 1776 | best_strategy); |
Junio C Hamano | 4c57bd2 | 2012-04-16 16:15:13 -0700 | [diff] [blame] | 1777 | try_merge_strategy(best_strategy, common, remoteheads, |
Junio C Hamano | b439165 | 2015-03-25 22:00:48 -0700 | [diff] [blame] | 1778 | head_commit); |
Miklos Vajna | 1c7b76b | 2008-07-07 19:24:20 +0200 | [diff] [blame] | 1779 | } |
| 1780 | |
Derrick Stolee | b23ea97 | 2020-04-16 20:14:03 +0000 | [diff] [blame] | 1781 | if (squash) { |
Junio C Hamano | 4c57bd2 | 2012-04-16 16:15:13 -0700 | [diff] [blame] | 1782 | finish(head_commit, remoteheads, NULL, NULL); |
Derrick Stolee | b23ea97 | 2020-04-16 20:14:03 +0000 | [diff] [blame] | 1783 | |
| 1784 | git_test_write_commit_graph_or_die(); |
| 1785 | } else |
Junio C Hamano | 4c57bd2 | 2012-04-16 16:15:13 -0700 | [diff] [blame] | 1786 | write_merge_state(remoteheads); |
Miklos Vajna | 1c7b76b | 2008-07-07 19:24:20 +0200 | [diff] [blame] | 1787 | |
Nguyễn Thái Ngọc Duy | d5a35c1 | 2011-11-13 17:22:15 +0700 | [diff] [blame] | 1788 | if (merge_was_ok) |
Ævar Arnfjörð Bjarmason | bacec47 | 2011-02-22 23:41:59 +0000 | [diff] [blame] | 1789 | fprintf(stderr, _("Automatic merge went well; " |
| 1790 | "stopped before committing as requested\n")); |
Nguyễn Thái Ngọc Duy | d5a35c1 | 2011-11-13 17:22:15 +0700 | [diff] [blame] | 1791 | else |
Junio C Hamano | 08e3ce5 | 2014-10-24 11:27:22 -0700 | [diff] [blame] | 1792 | ret = suggest_conflicts(); |
Elijah Newren | d3a9295 | 2022-08-23 02:42:19 +0000 | [diff] [blame] | 1793 | if (autostash) |
| 1794 | printf(_("When finished, apply stashed changes with `git stash pop`\n")); |
Nguyễn Thái Ngọc Duy | d5a35c1 | 2011-11-13 17:22:15 +0700 | [diff] [blame] | 1795 | |
| 1796 | done: |
Elijah Newren | 6046f7a | 2022-01-20 07:47:15 +0000 | [diff] [blame] | 1797 | if (!automerge_was_ok) { |
| 1798 | free_commit_list(common); |
| 1799 | free_commit_list(remoteheads); |
| 1800 | } |
Ævar Arnfjörð Bjarmason | 465028e | 2021-10-07 12:01:37 +0200 | [diff] [blame] | 1801 | strbuf_release(&buf); |
Nguyễn Thái Ngọc Duy | 96ec7b1 | 2011-12-13 21:17:48 +0700 | [diff] [blame] | 1802 | free(branch_to_free); |
Ævar Arnfjörð Bjarmason | ab2cf37 | 2022-11-08 19:17:38 +0100 | [diff] [blame] | 1803 | discard_index(&the_index); |
Nguyễn Thái Ngọc Duy | d5a35c1 | 2011-11-13 17:22:15 +0700 | [diff] [blame] | 1804 | return ret; |
Miklos Vajna | 1c7b76b | 2008-07-07 19:24:20 +0200 | [diff] [blame] | 1805 | } |