doc: MyFirstContribution: fix cmd placement instructions
[git/git.git] / sequencer.c
CommitLineData
26ae337b 1#include "cache.h"
b2141fc1 2#include "config.h"
697cc8ef 3#include "lockfile.h"
26ae337b 4#include "dir.h"
cbd53a21 5#include "object-store.h"
043a4492
RR
6#include "object.h"
7#include "commit.h"
0505d604 8#include "sequencer.h"
043a4492
RR
9#include "tag.h"
10#include "run-command.h"
d807c4a0 11#include "exec-cmd.h"
043a4492
RR
12#include "utf8.h"
13#include "cache-tree.h"
14#include "diff.h"
15#include "revision.h"
16#include "rerere.h"
17#include "merge-recursive.h"
18#include "refs.h"
b27cfb0d 19#include "argv-array.h"
a1c75762 20#include "quote.h"
967dfd4d 21#include "trailer.h"
56dc3ab0 22#include "log-tree.h"
311af526 23#include "wt-status.h"
c44a4c65 24#include "hashmap.h"
a87a6f3c
PW
25#include "notes-utils.h"
26#include "sigchain.h"
9055e401
JS
27#include "unpack-trees.h"
28#include "worktree.h"
1644c73c
JS
29#include "oidmap.h"
30#include "oidset.h"
8315bd20 31#include "commit-slab.h"
65b5f948 32#include "alias.h"
64043556 33#include "commit-reach.h"
b97e1873 34#include "rebase-interactive.h"
043a4492
RR
35
36#define GIT_REFLOG_ACTION "GIT_REFLOG_ACTION"
26ae337b 37
5fe81438 38static const char sign_off_header[] = "Signed-off-by: ";
cd650a4e 39static const char cherry_picked_prefix[] = "(cherry picked from commit ";
5ed75e2a 40
66618a50
PW
41GIT_PATH_FUNC(git_path_commit_editmsg, "COMMIT_EDITMSG")
42
8a2a0f53
JS
43GIT_PATH_FUNC(git_path_seq_dir, "sequencer")
44
45static GIT_PATH_FUNC(git_path_todo_file, "sequencer/todo")
46static GIT_PATH_FUNC(git_path_opts_file, "sequencer/opts")
47static GIT_PATH_FUNC(git_path_head_file, "sequencer/head")
1e41229d 48static GIT_PATH_FUNC(git_path_abort_safety_file, "sequencer/abort-safety")
f932729c 49
84583957
JS
50static GIT_PATH_FUNC(rebase_path, "rebase-merge")
51/*
52 * The file containing rebase commands, comments, and empty lines.
53 * This file is created by "git rebase -i" then edited by the user. As
54 * the lines are processed, they are removed from the front of this
55 * file and written to the tail of 'done'.
56 */
44b776c3 57GIT_PATH_FUNC(rebase_path_todo, "rebase-merge/git-rebase-todo")
a930eb03 58GIT_PATH_FUNC(rebase_path_todo_backup, "rebase-merge/git-rebase-todo.backup")
b97e1873 59
1df6df0c
JS
60/*
61 * The rebase command lines that have already been processed. A line
62 * is moved here when it is first handled, before any associated user
63 * actions.
64 */
65static GIT_PATH_FUNC(rebase_path_done, "rebase-merge/done")
ef80069a
JS
66/*
67 * The file to keep track of how many commands were already processed (e.g.
68 * for the prompt).
69 */
9ad36356 70static GIT_PATH_FUNC(rebase_path_msgnum, "rebase-merge/msgnum")
ef80069a
JS
71/*
72 * The file to keep track of how many commands are to be processed in total
73 * (e.g. for the prompt).
74 */
9ad36356 75static GIT_PATH_FUNC(rebase_path_msgtotal, "rebase-merge/end")
6e98de72
JS
76/*
77 * The commit message that is planned to be used for any changes that
78 * need to be committed following a user interaction.
79 */
80static GIT_PATH_FUNC(rebase_path_message, "rebase-merge/message")
81/*
82 * The file into which is accumulated the suggested commit message for
83 * squash/fixup commands. When the first of a series of squash/fixups
84 * is seen, the file is created and the commit message from the
85 * previous commit and from the first squash/fixup commit are written
86 * to it. The commit message for each subsequent squash/fixup commit
87 * is appended to the file as it is processed.
6e98de72
JS
88 */
89static GIT_PATH_FUNC(rebase_path_squash_msg, "rebase-merge/message-squash")
90/*
91 * If the current series of squash/fixups has not yet included a squash
92 * command, then this file exists and holds the commit message of the
93 * original "pick" commit. (If the series ends without a "squash"
94 * command, then this can be used as the commit message of the combined
95 * commit without opening the editor.)
96 */
97static GIT_PATH_FUNC(rebase_path_fixup_msg, "rebase-merge/message-fixup")
e12a7ef5
JS
98/*
99 * This file contains the list fixup/squash commands that have been
100 * accumulated into message-fixup or message-squash so far.
101 */
102static GIT_PATH_FUNC(rebase_path_current_fixups, "rebase-merge/current-fixups")
b5a67045
JS
103/*
104 * A script to set the GIT_AUTHOR_NAME, GIT_AUTHOR_EMAIL, and
105 * GIT_AUTHOR_DATE that will be used for the commit that is currently
106 * being rebased.
107 */
108static GIT_PATH_FUNC(rebase_path_author_script, "rebase-merge/author-script")
56dc3ab0
JS
109/*
110 * When an "edit" rebase command is being processed, the SHA1 of the
111 * commit to be edited is recorded in this file. When "git rebase
112 * --continue" is executed, if there are any staged changes then they
113 * will be amended to the HEAD commit, but only provided the HEAD
114 * commit is still the commit to be edited. When any other rebase
115 * command is processed, this file is deleted.
116 */
117static GIT_PATH_FUNC(rebase_path_amend, "rebase-merge/amend")
118/*
119 * When we stop at a given patch via the "edit" command, this file contains
120 * the abbreviated commit name of the corresponding patch.
121 */
122static GIT_PATH_FUNC(rebase_path_stopped_sha, "rebase-merge/stopped-sha")
25cb8df9
JS
123/*
124 * For the post-rewrite hook, we make a list of rewritten commits and
125 * their new sha1s. The rewritten-pending list keeps the sha1s of
126 * commits that have been processed, but not committed yet,
127 * e.g. because they are waiting for a 'squash' command.
128 */
129static GIT_PATH_FUNC(rebase_path_rewritten_list, "rebase-merge/rewritten-list")
130static GIT_PATH_FUNC(rebase_path_rewritten_pending,
131 "rebase-merge/rewritten-pending")
9055e401 132
d87d48b2
JS
133/*
134 * The path of the file containig the OID of the "squash onto" commit, i.e.
135 * the dummy commit used for `reset [new root]`.
136 */
137static GIT_PATH_FUNC(rebase_path_squash_onto, "rebase-merge/squash-onto")
138
9055e401
JS
139/*
140 * The path of the file listing refs that need to be deleted after the rebase
141 * finishes. This is used by the `label` command to record the need for cleanup.
142 */
143static GIT_PATH_FUNC(rebase_path_refs_to_delete, "rebase-merge/refs-to-delete")
144
a1c75762
JS
145/*
146 * The following files are written by git-rebase just after parsing the
65850686 147 * command-line.
a1c75762
JS
148 */
149static GIT_PATH_FUNC(rebase_path_gpg_sign_opt, "rebase-merge/gpg_sign_opt")
556907f1
JS
150static GIT_PATH_FUNC(rebase_path_orig_head, "rebase-merge/orig-head")
151static GIT_PATH_FUNC(rebase_path_verbose, "rebase-merge/verbose")
899b49c4 152static GIT_PATH_FUNC(rebase_path_quiet, "rebase-merge/quiet")
a852ec7f 153static GIT_PATH_FUNC(rebase_path_signoff, "rebase-merge/signoff")
4b83ce9f
JS
154static GIT_PATH_FUNC(rebase_path_head_name, "rebase-merge/head-name")
155static GIT_PATH_FUNC(rebase_path_onto, "rebase-merge/onto")
796c7972 156static GIT_PATH_FUNC(rebase_path_autostash, "rebase-merge/autostash")
ca6c6b45
JS
157static GIT_PATH_FUNC(rebase_path_strategy, "rebase-merge/strategy")
158static GIT_PATH_FUNC(rebase_path_strategy_opts, "rebase-merge/strategy_opts")
9b6d7a62 159static GIT_PATH_FUNC(rebase_path_allow_rerere_autoupdate, "rebase-merge/allow_rerere_autoupdate")
d421afa0 160static GIT_PATH_FUNC(rebase_path_reschedule_failed_exec, "rebase-merge/reschedule-failed-exec")
b5a67045 161
28d6daed
PW
162static int git_sequencer_config(const char *k, const char *v, void *cb)
163{
164 struct replay_opts *opts = cb;
165 int status;
166
167 if (!strcmp(k, "commit.cleanup")) {
168 const char *s;
169
170 status = git_config_string(&s, k, v);
171 if (status)
172 return status;
173
d74f3e58 174 if (!strcmp(s, "verbatim")) {
28d6daed 175 opts->default_msg_cleanup = COMMIT_MSG_CLEANUP_NONE;
d74f3e58
PW
176 opts->explicit_cleanup = 1;
177 } else if (!strcmp(s, "whitespace")) {
28d6daed 178 opts->default_msg_cleanup = COMMIT_MSG_CLEANUP_SPACE;
d74f3e58
PW
179 opts->explicit_cleanup = 1;
180 } else if (!strcmp(s, "strip")) {
28d6daed 181 opts->default_msg_cleanup = COMMIT_MSG_CLEANUP_ALL;
d74f3e58
PW
182 opts->explicit_cleanup = 1;
183 } else if (!strcmp(s, "scissors")) {
1a2b985f 184 opts->default_msg_cleanup = COMMIT_MSG_CLEANUP_SCISSORS;
d74f3e58
PW
185 opts->explicit_cleanup = 1;
186 } else {
28d6daed
PW
187 warning(_("invalid commit message cleanup mode '%s'"),
188 s);
d74f3e58 189 }
28d6daed 190
f40f3c16 191 free((char *)s);
28d6daed
PW
192 return status;
193 }
194
195 if (!strcmp(k, "commit.gpgsign")) {
ed1e5282 196 opts->gpg_sign = git_config_bool(k, v) ? xstrdup("") : NULL;
28d6daed
PW
197 return 0;
198 }
199
200 status = git_gpg_config(k, v, NULL);
201 if (status)
202 return status;
203
204 return git_diff_basic_config(k, v, NULL);
205}
206
207void sequencer_init_config(struct replay_opts *opts)
208{
209 opts->default_msg_cleanup = COMMIT_MSG_CLEANUP_NONE;
210 git_config(git_sequencer_config, opts);
211}
212
b5a67045
JS
213static inline int is_rebase_i(const struct replay_opts *opts)
214{
84583957 215 return opts->action == REPLAY_INTERACTIVE_REBASE;
b5a67045
JS
216}
217
285abf56
JS
218static const char *get_dir(const struct replay_opts *opts)
219{
84583957
JS
220 if (is_rebase_i(opts))
221 return rebase_path();
285abf56
JS
222 return git_path_seq_dir();
223}
224
c0246501
JS
225static const char *get_todo_path(const struct replay_opts *opts)
226{
84583957
JS
227 if (is_rebase_i(opts))
228 return rebase_path_todo();
c0246501
JS
229 return git_path_todo_file();
230}
231
bab4d109
BC
232/*
233 * Returns 0 for non-conforming footer
234 * Returns 1 for conforming footer
235 * Returns 2 when sob exists within conforming footer
236 * Returns 3 when sob exists within conforming footer as last entry
237 */
238static int has_conforming_footer(struct strbuf *sb, struct strbuf *sob,
66e83d9b 239 size_t ignore_footer)
b971e04f 240{
00a21f5c 241 struct process_trailer_options opts = PROCESS_TRAILER_OPTIONS_INIT;
967dfd4d 242 struct trailer_info info;
a3b636e2 243 size_t i;
967dfd4d 244 int found_sob = 0, found_sob_last = 0;
b971e04f 245
ffce7f59
JK
246 opts.no_divider = 1;
247
00a21f5c 248 trailer_info_get(&info, sb->buf, &opts);
b971e04f 249
967dfd4d 250 if (info.trailer_start == info.trailer_end)
b971e04f
BC
251 return 0;
252
967dfd4d
JT
253 for (i = 0; i < info.trailer_nr; i++)
254 if (sob && !strncmp(info.trailers[i], sob->buf, sob->len)) {
255 found_sob = 1;
256 if (i == info.trailer_nr - 1)
257 found_sob_last = 1;
258 }
b971e04f 259
967dfd4d 260 trailer_info_release(&info);
bab4d109 261
967dfd4d 262 if (found_sob_last)
bab4d109
BC
263 return 3;
264 if (found_sob)
265 return 2;
b971e04f
BC
266 return 1;
267}
5ed75e2a 268
a1c75762
JS
269static const char *gpg_sign_opt_quoted(struct replay_opts *opts)
270{
271 static struct strbuf buf = STRBUF_INIT;
272
273 strbuf_reset(&buf);
274 if (opts->gpg_sign)
275 sq_quotef(&buf, "-S%s", opts->gpg_sign);
276 return buf.buf;
277}
278
2863584f 279int sequencer_remove_state(struct replay_opts *opts)
26ae337b 280{
9055e401 281 struct strbuf buf = STRBUF_INIT;
37e9ee5c 282 int i, ret = 0;
03a4e260 283
9055e401
JS
284 if (is_rebase_i(opts) &&
285 strbuf_read_file(&buf, rebase_path_refs_to_delete(), 0) > 0) {
286 char *p = buf.buf;
287 while (*p) {
288 char *eol = strchr(p, '\n');
289 if (eol)
290 *eol = '\0';
37e9ee5c 291 if (delete_ref("(rebase -i) cleanup", p, NULL, 0) < 0) {
9055e401 292 warning(_("could not delete '%s'"), p);
37e9ee5c
PW
293 ret = -1;
294 }
9055e401
JS
295 if (!eol)
296 break;
297 p = eol + 1;
298 }
299 }
300
03a4e260
JS
301 free(opts->gpg_sign);
302 free(opts->strategy);
303 for (i = 0; i < opts->xopts_nr; i++)
304 free(opts->xopts[i]);
305 free(opts->xopts);
e12a7ef5 306 strbuf_release(&opts->current_fixups);
26ae337b 307
9055e401
JS
308 strbuf_reset(&buf);
309 strbuf_addstr(&buf, get_dir(opts));
37e9ee5c
PW
310 if (remove_dir_recursively(&buf, 0))
311 ret = error(_("could not remove '%s'"), buf.buf);
9055e401 312 strbuf_release(&buf);
2863584f 313
37e9ee5c 314 return ret;
26ae337b 315}
043a4492
RR
316
317static const char *action_name(const struct replay_opts *opts)
318{
84583957
JS
319 switch (opts->action) {
320 case REPLAY_REVERT:
321 return N_("revert");
322 case REPLAY_PICK:
323 return N_("cherry-pick");
324 case REPLAY_INTERACTIVE_REBASE:
325 return N_("rebase -i");
326 }
1a07e59c 327 die(_("unknown action: %d"), opts->action);
043a4492
RR
328}
329
043a4492
RR
330struct commit_message {
331 char *parent_label;
7b35eaf8
JK
332 char *label;
333 char *subject;
043a4492
RR
334 const char *message;
335};
336
39755964
JS
337static const char *short_commit_name(struct commit *commit)
338{
aab9583f 339 return find_unique_abbrev(&commit->object.oid, DEFAULT_ABBREV);
39755964
JS
340}
341
043a4492
RR
342static int get_message(struct commit *commit, struct commit_message *out)
343{
043a4492 344 const char *abbrev, *subject;
7b35eaf8 345 int subject_len;
043a4492 346
7b35eaf8 347 out->message = logmsg_reencode(commit, NULL, get_commit_output_encoding());
39755964 348 abbrev = short_commit_name(commit);
043a4492
RR
349
350 subject_len = find_commit_subject(out->message, &subject);
351
7b35eaf8
JK
352 out->subject = xmemdupz(subject, subject_len);
353 out->label = xstrfmt("%s... %s", abbrev, out->subject);
354 out->parent_label = xstrfmt("parent of %s", out->label);
355
043a4492
RR
356 return 0;
357}
358
d74a4e57 359static void free_message(struct commit *commit, struct commit_message *msg)
043a4492
RR
360{
361 free(msg->parent_label);
7b35eaf8
JK
362 free(msg->label);
363 free(msg->subject);
b66103c3 364 unuse_commit_buffer(commit, msg->message);
043a4492
RR
365}
366
005af339
NTND
367static void print_advice(struct repository *r, int show_hint,
368 struct replay_opts *opts)
043a4492
RR
369{
370 char *msg = getenv("GIT_CHERRY_PICK_HELP");
371
372 if (msg) {
373 fprintf(stderr, "%s\n", msg);
374 /*
41ccfdd9 375 * A conflict has occurred but the porcelain
043a4492
RR
376 * (typically rebase --interactive) wants to take care
377 * of the commit itself so remove CHERRY_PICK_HEAD
378 */
005af339 379 unlink(git_path_cherry_pick_head(r));
043a4492
RR
380 return;
381 }
382
ed727b19
PH
383 if (show_hint) {
384 if (opts->no_commit)
385 advise(_("after resolving the conflicts, mark the corrected paths\n"
386 "with 'git add <paths>' or 'git rm <paths>'"));
387 else
388 advise(_("after resolving the conflicts, mark the corrected paths\n"
389 "with 'git add <paths>' or 'git rm <paths>'\n"
390 "and commit the result with 'git commit'"));
391 }
043a4492
RR
392}
393
ddb81e50
AG
394static int write_message(const void *buf, size_t len, const char *filename,
395 int append_eol)
043a4492 396{
14bca6c6 397 struct lock_file msg_file = LOCK_INIT;
043a4492 398
4ef3d8f0
JS
399 int msg_fd = hold_lock_file_for_update(&msg_file, filename, 0);
400 if (msg_fd < 0)
93b3df6f 401 return error_errno(_("could not lock '%s'"), filename);
75871495 402 if (write_in_full(msg_fd, buf, len) < 0) {
bf5c0571 403 error_errno(_("could not write to '%s'"), filename);
4f66c837 404 rollback_lock_file(&msg_file);
bf5c0571 405 return -1;
4f66c837 406 }
f56fffef 407 if (append_eol && write(msg_fd, "\n", 1) < 0) {
bf5c0571 408 error_errno(_("could not write eol to '%s'"), filename);
f56fffef 409 rollback_lock_file(&msg_file);
bf5c0571 410 return -1;
f56fffef 411 }
350292a1
412 if (commit_lock_file(&msg_file) < 0)
413 return error(_("failed to finalize '%s'"), filename);
4ef3d8f0
JS
414
415 return 0;
043a4492
RR
416}
417
1dfc84e9
JS
418/*
419 * Reads a file that was presumably written by a shell script, i.e. with an
420 * end-of-line marker that needs to be stripped.
421 *
422 * Note that only the last end-of-line marker is stripped, consistent with the
423 * behavior of "$(cat path)" in a shell script.
424 *
425 * Returns 1 if the file was read, 0 if it could not be read or does not exist.
426 */
427static int read_oneliner(struct strbuf *buf,
428 const char *path, int skip_if_empty)
429{
430 int orig_len = buf->len;
431
432 if (!file_exists(path))
433 return 0;
434
435 if (strbuf_read_file(buf, path, 0) < 0) {
436 warning_errno(_("could not read '%s'"), path);
437 return 0;
438 }
439
440 if (buf->len > orig_len && buf->buf[buf->len - 1] == '\n') {
441 if (--buf->len > orig_len && buf->buf[buf->len - 1] == '\r')
442 --buf->len;
443 buf->buf[buf->len] = '\0';
444 }
445
446 if (skip_if_empty && buf->len == orig_len)
447 return 0;
448
449 return 1;
450}
451
005af339 452static struct tree *empty_tree(struct repository *r)
043a4492 453{
005af339 454 return lookup_tree(r, the_hash_algo->empty_tree);
043a4492
RR
455}
456
e1ff0a32 457static int error_dirty_index(struct repository *repo, struct replay_opts *opts)
043a4492 458{
e1ff0a32 459 if (repo_read_index_unmerged(repo))
c28cbc5e 460 return error_resolve_conflict(_(action_name(opts)));
043a4492 461
93b3df6f 462 error(_("your local changes would be overwritten by %s."),
c28cbc5e 463 _(action_name(opts)));
043a4492
RR
464
465 if (advice_commit_before_merge)
93b3df6f 466 advise(_("commit your changes or stash them to proceed."));
043a4492
RR
467 return -1;
468}
469
1e41229d
SB
470static void update_abort_safety_file(void)
471{
472 struct object_id head;
473
474 /* Do nothing on a single-pick */
475 if (!file_exists(git_path_seq_dir()))
476 return;
477
478 if (!get_oid("HEAD", &head))
479 write_file(git_path_abort_safety_file(), "%s", oid_to_hex(&head));
480 else
481 write_file(git_path_abort_safety_file(), "%s", "");
482}
483
f11c9580
NTND
484static int fast_forward_to(struct repository *r,
485 const struct object_id *to,
486 const struct object_id *from,
487 int unborn,
488 struct replay_opts *opts)
043a4492 489{
d668d16c 490 struct ref_transaction *transaction;
eb4be1cb 491 struct strbuf sb = STRBUF_INIT;
d668d16c 492 struct strbuf err = STRBUF_INIT;
043a4492 493
e1ff0a32 494 repo_read_index(r);
f11c9580 495 if (checkout_fast_forward(r, from, to, 1))
0e408fc3 496 return -1; /* the callee should have complained already */
651ab9f5 497
c28cbc5e 498 strbuf_addf(&sb, _("%s: fast-forward"), _(action_name(opts)));
d668d16c
RS
499
500 transaction = ref_transaction_begin(&err);
501 if (!transaction ||
502 ref_transaction_update(transaction, "HEAD",
d87d48b2
JS
503 to, unborn && !is_rebase_i(opts) ?
504 &null_oid : from,
1d147bdf 505 0, sb.buf, &err) ||
db7516ab 506 ref_transaction_commit(transaction, &err)) {
d668d16c
RS
507 ref_transaction_free(transaction);
508 error("%s", err.buf);
509 strbuf_release(&sb);
510 strbuf_release(&err);
511 return -1;
512 }
651ab9f5 513
eb4be1cb 514 strbuf_release(&sb);
d668d16c
RS
515 strbuf_release(&err);
516 ref_transaction_free(transaction);
1e41229d 517 update_abort_safety_file();
d668d16c 518 return 0;
043a4492
RR
519}
520
f29cd862
DL
521enum commit_msg_cleanup_mode get_cleanup_mode(const char *cleanup_arg,
522 int use_editor)
523{
524 if (!cleanup_arg || !strcmp(cleanup_arg, "default"))
525 return use_editor ? COMMIT_MSG_CLEANUP_ALL :
526 COMMIT_MSG_CLEANUP_SPACE;
527 else if (!strcmp(cleanup_arg, "verbatim"))
528 return COMMIT_MSG_CLEANUP_NONE;
529 else if (!strcmp(cleanup_arg, "whitespace"))
530 return COMMIT_MSG_CLEANUP_SPACE;
531 else if (!strcmp(cleanup_arg, "strip"))
532 return COMMIT_MSG_CLEANUP_ALL;
533 else if (!strcmp(cleanup_arg, "scissors"))
534 return use_editor ? COMMIT_MSG_CLEANUP_SCISSORS :
535 COMMIT_MSG_CLEANUP_SPACE;
536 else
537 die(_("Invalid cleanup mode %s"), cleanup_arg);
538}
539
dc42e9a8
PW
540/*
541 * NB using int rather than enum cleanup_mode to stop clang's
542 * -Wtautological-constant-out-of-range-compare complaining that the comparison
543 * is always true.
544 */
545static const char *describe_cleanup_mode(int cleanup_mode)
546{
547 static const char *modes[] = { "whitespace",
548 "verbatim",
549 "scissors",
550 "strip" };
551
552 if (cleanup_mode < ARRAY_SIZE(modes))
553 return modes[cleanup_mode];
554
555 BUG("invalid cleanup_mode provided (%d)", cleanup_mode);
556}
557
f11c9580 558void append_conflicts_hint(struct index_state *istate,
1a2b985f 559 struct strbuf *msgbuf, enum commit_msg_cleanup_mode cleanup_mode)
75c961b7
JH
560{
561 int i;
562
1a2b985f
DL
563 if (cleanup_mode == COMMIT_MSG_CLEANUP_SCISSORS) {
564 strbuf_addch(msgbuf, '\n');
565 wt_status_append_cut_line(msgbuf);
566 strbuf_addch(msgbuf, comment_line_char);
567 }
568
261f315b
JH
569 strbuf_addch(msgbuf, '\n');
570 strbuf_commented_addf(msgbuf, "Conflicts:\n");
f11c9580
NTND
571 for (i = 0; i < istate->cache_nr;) {
572 const struct cache_entry *ce = istate->cache[i++];
75c961b7 573 if (ce_stage(ce)) {
261f315b 574 strbuf_commented_addf(msgbuf, "\t%s\n", ce->name);
f11c9580
NTND
575 while (i < istate->cache_nr &&
576 !strcmp(ce->name, istate->cache[i]->name))
75c961b7
JH
577 i++;
578 }
579 }
580}
581
f11c9580
NTND
582static int do_recursive_merge(struct repository *r,
583 struct commit *base, struct commit *next,
043a4492 584 const char *base_label, const char *next_label,
48be4c62 585 struct object_id *head, struct strbuf *msgbuf,
043a4492
RR
586 struct replay_opts *opts)
587{
588 struct merge_options o;
589 struct tree *result, *next_tree, *base_tree, *head_tree;
03b86647 590 int clean;
03a4e260 591 char **xopt;
14bca6c6 592 struct lock_file index_lock = LOCK_INIT;
043a4492 593
3a95f31d 594 if (repo_hold_locked_index(r, &index_lock, LOCK_REPORT_ON_ERROR) < 0)
bd588867 595 return -1;
043a4492 596
e1ff0a32 597 repo_read_index(r);
043a4492 598
0d6caa2d 599 init_merge_options(&o, r);
043a4492
RR
600 o.ancestor = base ? base_label : "(empty tree)";
601 o.branch1 = "HEAD";
602 o.branch2 = next ? next_label : "(empty tree)";
62fdb652
JS
603 if (is_rebase_i(opts))
604 o.buffer_output = 2;
9268cf4a 605 o.show_rename_progress = 1;
043a4492
RR
606
607 head_tree = parse_tree_indirect(head);
005af339
NTND
608 next_tree = next ? get_commit_tree(next) : empty_tree(r);
609 base_tree = base ? get_commit_tree(base) : empty_tree(r);
043a4492
RR
610
611 for (xopt = opts->xopts; xopt != opts->xopts + opts->xopts_nr; xopt++)
612 parse_merge_opt(&o, *xopt);
613
614 clean = merge_trees(&o,
615 head_tree,
616 next_tree, base_tree, &result);
62fdb652
JS
617 if (is_rebase_i(opts) && clean <= 0)
618 fputs(o.obuf.buf, stdout);
548009c0 619 strbuf_release(&o.obuf);
b520abf1 620 diff_warn_rename_limit("merge.renamelimit", o.needed_rename_limit, 0);
64816524
621 if (clean < 0) {
622 rollback_lock_file(&index_lock);
f241ff0d 623 return clean;
64816524 624 }
043a4492 625
f11c9580 626 if (write_locked_index(r->index, &index_lock,
61000814 627 COMMIT_LOCK | SKIP_IF_UNCHANGED))
66f5f6dc
ÆAB
628 /*
629 * TRANSLATORS: %s will be "revert", "cherry-pick" or
84583957
JS
630 * "rebase -i".
631 */
c527b55e 632 return error(_("%s: Unable to write new index file"),
c28cbc5e 633 _(action_name(opts)));
043a4492 634
75c961b7 635 if (!clean)
1a2b985f
DL
636 append_conflicts_hint(r->index, msgbuf,
637 opts->default_msg_cleanup);
043a4492
RR
638
639 return !clean;
640}
641
f11c9580 642static struct object_id *get_cache_tree_oid(struct index_state *istate)
ba97aea1 643{
f11c9580
NTND
644 if (!istate->cache_tree)
645 istate->cache_tree = cache_tree();
ba97aea1 646
f11c9580
NTND
647 if (!cache_tree_fully_valid(istate->cache_tree))
648 if (cache_tree_update(istate, 0)) {
ba97aea1
JS
649 error(_("unable to update cache tree"));
650 return NULL;
651 }
652
f11c9580 653 return &istate->cache_tree->oid;
ba97aea1
JS
654}
655
005af339 656static int is_index_unchanged(struct repository *r)
b27cfb0d 657{
ba97aea1 658 struct object_id head_oid, *cache_tree_oid;
b27cfb0d 659 struct commit *head_commit;
005af339 660 struct index_state *istate = r->index;
b27cfb0d 661
49e61479 662 if (!resolve_ref_unsafe("HEAD", RESOLVE_REF_READING, &head_oid, NULL))
aee42e1f 663 return error(_("could not resolve HEAD commit"));
b27cfb0d 664
005af339 665 head_commit = lookup_commit(r, &head_oid);
4b580061
NH
666
667 /*
668 * If head_commit is NULL, check_commit, called from
669 * lookup_commit, would have indicated that head_commit is not
670 * a commit object already. parse_commit() will return failure
671 * without further complaints in such a case. Otherwise, if
672 * the commit is invalid, parse_commit() will complain. So
673 * there is nothing for us to say here. Just return failure.
674 */
675 if (parse_commit(head_commit))
676 return -1;
b27cfb0d 677
f11c9580 678 if (!(cache_tree_oid = get_cache_tree_oid(istate)))
ba97aea1 679 return -1;
b27cfb0d 680
4a7e27e9 681 return oideq(cache_tree_oid, get_commit_tree_oid(head_commit));
b27cfb0d
NH
682}
683
0473f28a
JS
684static int write_author_script(const char *message)
685{
686 struct strbuf buf = STRBUF_INIT;
687 const char *eol;
688 int res;
689
690 for (;;)
691 if (!*message || starts_with(message, "\n")) {
692missing_author:
693 /* Missing 'author' line? */
694 unlink(rebase_path_author_script());
695 return 0;
696 } else if (skip_prefix(message, "author ", &message))
697 break;
698 else if ((eol = strchr(message, '\n')))
699 message = eol + 1;
700 else
701 goto missing_author;
702
703 strbuf_addstr(&buf, "GIT_AUTHOR_NAME='");
704 while (*message && *message != '\n' && *message != '\r')
705 if (skip_prefix(message, " <", &message))
706 break;
707 else if (*message != '\'')
708 strbuf_addch(&buf, *(message++));
709 else
4aa5ff94 710 strbuf_addf(&buf, "'\\%c'", *(message++));
0473f28a
JS
711 strbuf_addstr(&buf, "'\nGIT_AUTHOR_EMAIL='");
712 while (*message && *message != '\n' && *message != '\r')
713 if (skip_prefix(message, "> ", &message))
714 break;
715 else if (*message != '\'')
716 strbuf_addch(&buf, *(message++));
717 else
4aa5ff94 718 strbuf_addf(&buf, "'\\%c'", *(message++));
0473f28a
JS
719 strbuf_addstr(&buf, "'\nGIT_AUTHOR_DATE='@");
720 while (*message && *message != '\n' && *message != '\r')
721 if (*message != '\'')
722 strbuf_addch(&buf, *(message++));
723 else
4aa5ff94 724 strbuf_addf(&buf, "'\\%c'", *(message++));
0f16c09a 725 strbuf_addch(&buf, '\'');
0473f28a
JS
726 res = write_message(buf.buf, buf.len, rebase_path_author_script(), 1);
727 strbuf_release(&buf);
728 return res;
729}
730
bcd33ec2
PW
731/**
732 * Take a series of KEY='VALUE' lines where VALUE part is
733 * sq-quoted, and append <KEY, VALUE> at the end of the string list
734 */
735static int parse_key_value_squoted(char *buf, struct string_list *list)
736{
737 while (*buf) {
738 struct string_list_item *item;
739 char *np;
740 char *cp = strchr(buf, '=');
741 if (!cp) {
742 np = strchrnul(buf, '\n');
743 return error(_("no key present in '%.*s'"),
744 (int) (np - buf), buf);
745 }
746 np = strchrnul(cp, '\n');
747 *cp++ = '\0';
748 item = string_list_append(list, buf);
749
750 buf = np + (*np == '\n');
751 *np = '\0';
752 cp = sq_dequote(cp);
753 if (!cp)
754 return error(_("unable to dequote value of '%s'"),
755 item->string);
756 item->util = xstrdup(cp);
757 }
758 return 0;
759}
4aa5ff94 760
bcd33ec2
PW
761/**
762 * Reads and parses the state directory's "author-script" file, and sets name,
763 * email and date accordingly.
764 * Returns 0 on success, -1 if the file could not be parsed.
765 *
766 * The author script is of the format:
767 *
768 * GIT_AUTHOR_NAME='$author_name'
769 * GIT_AUTHOR_EMAIL='$author_email'
770 * GIT_AUTHOR_DATE='$author_date'
771 *
772 * where $author_name, $author_email and $author_date are quoted. We are strict
c3c003e7 773 * with our parsing, as the file was meant to be eval'd in the now-removed
bcd33ec2
PW
774 * git-am.sh/git-rebase--interactive.sh scripts, and thus if the file differs
775 * from what this function expects, it is better to bail out than to do
776 * something that the user does not expect.
4aa5ff94 777 */
bcd33ec2
PW
778int read_author_script(const char *path, char **name, char **email, char **date,
779 int allow_missing)
4aa5ff94 780{
bcd33ec2
PW
781 struct strbuf buf = STRBUF_INIT;
782 struct string_list kv = STRING_LIST_INIT_DUP;
783 int retval = -1; /* assume failure */
784 int i, name_i = -2, email_i = -2, date_i = -2, err = 0;
4aa5ff94 785
bcd33ec2
PW
786 if (strbuf_read_file(&buf, path, 256) <= 0) {
787 strbuf_release(&buf);
788 if (errno == ENOENT && allow_missing)
789 return 0;
790 else
791 return error_errno(_("could not open '%s' for reading"),
792 path);
793 }
794
795 if (parse_key_value_squoted(buf.buf, &kv))
796 goto finish;
797
798 for (i = 0; i < kv.nr; i++) {
799 if (!strcmp(kv.items[i].string, "GIT_AUTHOR_NAME")) {
800 if (name_i != -2)
801 name_i = error(_("'GIT_AUTHOR_NAME' already given"));
802 else
803 name_i = i;
804 } else if (!strcmp(kv.items[i].string, "GIT_AUTHOR_EMAIL")) {
805 if (email_i != -2)
806 email_i = error(_("'GIT_AUTHOR_EMAIL' already given"));
807 else
808 email_i = i;
809 } else if (!strcmp(kv.items[i].string, "GIT_AUTHOR_DATE")) {
810 if (date_i != -2)
811 date_i = error(_("'GIT_AUTHOR_DATE' already given"));
812 else
813 date_i = i;
814 } else {
815 err = error(_("unknown variable '%s'"),
816 kv.items[i].string);
817 }
818 }
819 if (name_i == -2)
820 error(_("missing 'GIT_AUTHOR_NAME'"));
821 if (email_i == -2)
822 error(_("missing 'GIT_AUTHOR_EMAIL'"));
823 if (date_i == -2)
824 error(_("missing 'GIT_AUTHOR_DATE'"));
825 if (date_i < 0 || email_i < 0 || date_i < 0 || err)
826 goto finish;
827 *name = kv.items[name_i].util;
828 *email = kv.items[email_i].util;
829 *date = kv.items[date_i].util;
830 retval = 0;
831finish:
832 string_list_clear(&kv, !!retval);
833 strbuf_release(&buf);
834 return retval;
4aa5ff94
PW
835}
836
b5a67045 837/*
4d010a75
PW
838 * Read a GIT_AUTHOR_NAME, GIT_AUTHOR_EMAIL AND GIT_AUTHOR_DATE from a
839 * file with shell quoting into struct argv_array. Returns -1 on
840 * error, 0 otherwise.
b5a67045 841 */
a2a20b0d 842static int read_env_script(struct argv_array *env)
b5a67045 843{
4d010a75 844 char *name, *email, *date;
b5a67045 845
4d010a75
PW
846 if (read_author_script(rebase_path_author_script(),
847 &name, &email, &date, 0))
a2a20b0d 848 return -1;
b5a67045 849
4d010a75
PW
850 argv_array_pushf(env, "GIT_AUTHOR_NAME=%s", name);
851 argv_array_pushf(env, "GIT_AUTHOR_EMAIL=%s", email);
852 argv_array_pushf(env, "GIT_AUTHOR_DATE=%s", date);
853 free(name);
854 free(email);
855 free(date);
b5a67045 856
a2a20b0d 857 return 0;
b5a67045
JS
858}
859
356ee465
PW
860static char *get_author(const char *message)
861{
862 size_t len;
863 const char *a;
864
865 a = find_commit_header(message, "author", &len);
866 if (a)
867 return xmemdupz(a, len);
868
869 return NULL;
870}
871
d87d48b2
JS
872/* Read author-script and return an ident line (author <email> timestamp) */
873static const char *read_author_ident(struct strbuf *buf)
874{
67f16e3d 875 struct strbuf out = STRBUF_INIT;
4d010a75 876 char *name, *email, *date;
d87d48b2 877
4d010a75
PW
878 if (read_author_script(rebase_path_author_script(),
879 &name, &email, &date, 0))
d87d48b2
JS
880 return NULL;
881
5522bbac 882 /* validate date since fmt_ident() will die() on bad value */
4d010a75 883 if (parse_date(date, &out)){
5522bbac 884 warning(_("invalid date format '%s' in '%s'"),
4d010a75 885 date, rebase_path_author_script());
5522bbac
ES
886 strbuf_release(&out);
887 return NULL;
888 }
889
890 strbuf_reset(&out);
39ab4d09 891 strbuf_addstr(&out, fmt_ident(name, email, WANT_AUTHOR_IDENT, date, 0));
67f16e3d
ES
892 strbuf_swap(buf, &out);
893 strbuf_release(&out);
4d010a75
PW
894 free(name);
895 free(email);
896 free(date);
d87d48b2
JS
897 return buf->buf;
898}
899
791eb870
JS
900static const char staged_changes_advice[] =
901N_("you have staged changes in your working tree\n"
902"If these changes are meant to be squashed into the previous commit, run:\n"
903"\n"
904" git commit --amend %s\n"
905"\n"
906"If they are meant to go into a new commit, run:\n"
907"\n"
908" git commit %s\n"
909"\n"
910"In both cases, once you're done, continue with:\n"
911"\n"
912" git rebase --continue\n");
913
789b3eff
JS
914#define ALLOW_EMPTY (1<<0)
915#define EDIT_MSG (1<<1)
916#define AMEND_MSG (1<<2)
917#define CLEANUP_MSG (1<<3)
b92ff6e8 918#define VERIFY_MSG (1<<4)
d87d48b2 919#define CREATE_ROOT_COMMIT (1<<5)
789b3eff 920
34bec2c4
AG
921static int run_command_silent_on_success(struct child_process *cmd)
922{
923 struct strbuf buf = STRBUF_INIT;
924 int rc;
925
926 cmd->stdout_to_stderr = 1;
927 rc = pipe_command(cmd,
928 NULL, 0,
929 NULL, 0,
930 &buf, 0);
931
932 if (rc)
933 fputs(buf.buf, stderr);
934 strbuf_release(&buf);
935 return rc;
936}
937
043a4492
RR
938/*
939 * If we are cherry-pick, and if the merge did not result in
940 * hand-editing, we will hit this commit and inherit the original
941 * author date and name.
b5a67045 942 *
043a4492
RR
943 * If we are revert, or if our cherry-pick results in a hand merge,
944 * we had better say that the current user is responsible for that.
b5a67045
JS
945 *
946 * An exception is when run_git_commit() is called during an
947 * interactive rebase: in that case, we will want to retain the
948 * author metadata.
043a4492 949 */
f11c9580
NTND
950static int run_git_commit(struct repository *r,
951 const char *defmsg,
952 struct replay_opts *opts,
789b3eff 953 unsigned int flags)
043a4492 954{
07d968ef 955 struct child_process cmd = CHILD_PROCESS_INIT;
b27cfb0d 956
76fda6eb 957 if ((flags & CREATE_ROOT_COMMIT) && !(flags & AMEND_MSG)) {
d87d48b2 958 struct strbuf msg = STRBUF_INIT, script = STRBUF_INIT;
5dfcfe1e 959 const char *author = NULL;
d87d48b2
JS
960 struct object_id root_commit, *cache_tree_oid;
961 int res = 0;
962
5dfcfe1e
PW
963 if (is_rebase_i(opts)) {
964 author = read_author_ident(&script);
965 if (!author) {
966 strbuf_release(&script);
967 return -1;
968 }
969 }
970
d87d48b2
JS
971 if (!defmsg)
972 BUG("root commit without message");
973
f11c9580 974 if (!(cache_tree_oid = get_cache_tree_oid(r->index)))
d87d48b2
JS
975 res = -1;
976
977 if (!res)
978 res = strbuf_read_file(&msg, defmsg, 0);
979
980 if (res <= 0)
981 res = error_errno(_("could not read '%s'"), defmsg);
982 else
983 res = commit_tree(msg.buf, msg.len, cache_tree_oid,
984 NULL, &root_commit, author,
985 opts->gpg_sign);
986
987 strbuf_release(&msg);
988 strbuf_release(&script);
989 if (!res) {
990 update_ref(NULL, "CHERRY_PICK_HEAD", &root_commit, NULL,
991 REF_NO_DEREF, UPDATE_REFS_MSG_ON_ERR);
992 res = update_ref(NULL, "HEAD", &root_commit, NULL, 0,
993 UPDATE_REFS_MSG_ON_ERR);
994 }
995 return res < 0 ? error(_("writing root commit")) : 0;
996 }
997
07d968ef
JS
998 cmd.git_cmd = 1;
999
34bec2c4
AG
1000 if (is_rebase_i(opts) && read_env_script(&cmd.env_array)) {
1001 const char *gpg_opt = gpg_sign_opt_quoted(opts);
a1c75762 1002
34bec2c4
AG
1003 return error(_(staged_changes_advice),
1004 gpg_opt, gpg_opt);
b5a67045
JS
1005 }
1006
07d968ef 1007 argv_array_push(&cmd.args, "commit");
043a4492 1008
b92ff6e8
JS
1009 if (!(flags & VERIFY_MSG))
1010 argv_array_push(&cmd.args, "-n");
789b3eff 1011 if ((flags & AMEND_MSG))
07d968ef 1012 argv_array_push(&cmd.args, "--amend");
3bdd5522 1013 if (opts->gpg_sign)
07d968ef 1014 argv_array_pushf(&cmd.args, "-S%s", opts->gpg_sign);
b5a67045 1015 if (defmsg)
07d968ef 1016 argv_array_pushl(&cmd.args, "-F", defmsg, NULL);
dc4b5bc3
JS
1017 else if (!(flags & EDIT_MSG))
1018 argv_array_pushl(&cmd.args, "-C", "HEAD", NULL);
789b3eff 1019 if ((flags & CLEANUP_MSG))
07d968ef 1020 argv_array_push(&cmd.args, "--cleanup=strip");
789b3eff 1021 if ((flags & EDIT_MSG))
07d968ef 1022 argv_array_push(&cmd.args, "-e");
789b3eff 1023 else if (!(flags & CLEANUP_MSG) &&
0009426d 1024 !opts->signoff && !opts->record_origin &&
1a2b985f 1025 !opts->explicit_cleanup)
07d968ef 1026 argv_array_push(&cmd.args, "--cleanup=verbatim");
b27cfb0d 1027
789b3eff 1028 if ((flags & ALLOW_EMPTY))
07d968ef 1029 argv_array_push(&cmd.args, "--allow-empty");
df478b74 1030
a3ec9eaf 1031 if (!(flags & EDIT_MSG))
07d968ef 1032 argv_array_push(&cmd.args, "--allow-empty-message");
4bee9584 1033
34bec2c4
AG
1034 if (is_rebase_i(opts) && !(flags & EDIT_MSG))
1035 return run_command_silent_on_success(&cmd);
1036 else
1037 return run_command(&cmd);
b27cfb0d
NH
1038}
1039
d0aaa46f
PW
1040static int rest_is_empty(const struct strbuf *sb, int start)
1041{
1042 int i, eol;
1043 const char *nl;
1044
1045 /* Check if the rest is just whitespace and Signed-off-by's. */
1046 for (i = start; i < sb->len; i++) {
1047 nl = memchr(sb->buf + i, '\n', sb->len - i);
1048 if (nl)
1049 eol = nl - sb->buf;
1050 else
1051 eol = sb->len;
1052
1053 if (strlen(sign_off_header) <= eol - i &&
1054 starts_with(sb->buf + i, sign_off_header)) {
1055 i = eol;
1056 continue;
1057 }
1058 while (i < eol)
1059 if (!isspace(sb->buf[i++]))
1060 return 0;
1061 }
1062
1063 return 1;
1064}
1065
f29cd862
DL
1066void cleanup_message(struct strbuf *msgbuf,
1067 enum commit_msg_cleanup_mode cleanup_mode, int verbose)
1068{
1069 if (verbose || /* Truncate the message just before the diff, if any. */
1070 cleanup_mode == COMMIT_MSG_CLEANUP_SCISSORS)
1071 strbuf_setlen(msgbuf, wt_status_locate_end(msgbuf->buf, msgbuf->len));
1072 if (cleanup_mode != COMMIT_MSG_CLEANUP_NONE)
1073 strbuf_stripspace(msgbuf, cleanup_mode == COMMIT_MSG_CLEANUP_ALL);
1074}
1075
d0aaa46f
PW
1076/*
1077 * Find out if the message in the strbuf contains only whitespace and
1078 * Signed-off-by lines.
1079 */
1080int message_is_empty(const struct strbuf *sb,
1081 enum commit_msg_cleanup_mode cleanup_mode)
1082{
1083 if (cleanup_mode == COMMIT_MSG_CLEANUP_NONE && sb->len)
1084 return 0;
1085 return rest_is_empty(sb, 0);
1086}
1087
1088/*
1089 * See if the user edited the message in the editor or left what
1090 * was in the template intact
1091 */
1092int template_untouched(const struct strbuf *sb, const char *template_file,
1093 enum commit_msg_cleanup_mode cleanup_mode)
1094{
1095 struct strbuf tmpl = STRBUF_INIT;
1096 const char *start;
1097
1098 if (cleanup_mode == COMMIT_MSG_CLEANUP_NONE && sb->len)
1099 return 0;
1100
1101 if (!template_file || strbuf_read_file(&tmpl, template_file, 0) <= 0)
1102 return 0;
1103
1104 strbuf_stripspace(&tmpl, cleanup_mode == COMMIT_MSG_CLEANUP_ALL);
1105 if (!skip_prefix(sb->buf, tmpl.buf, &start))
1106 start = sb->buf;
1107 strbuf_release(&tmpl);
1108 return rest_is_empty(sb, start - sb->buf);
1109}
1110
0505d604
PW
1111int update_head_with_reflog(const struct commit *old_head,
1112 const struct object_id *new_head,
1113 const char *action, const struct strbuf *msg,
1114 struct strbuf *err)
1115{
1116 struct ref_transaction *transaction;
1117 struct strbuf sb = STRBUF_INIT;
1118 const char *nl;
1119 int ret = 0;
1120
1121 if (action) {
1122 strbuf_addstr(&sb, action);
1123 strbuf_addstr(&sb, ": ");
1124 }
1125
1126 nl = strchr(msg->buf, '\n');
1127 if (nl) {
1128 strbuf_add(&sb, msg->buf, nl + 1 - msg->buf);
1129 } else {
1130 strbuf_addbuf(&sb, msg);
1131 strbuf_addch(&sb, '\n');
1132 }
1133
1134 transaction = ref_transaction_begin(err);
1135 if (!transaction ||
1136 ref_transaction_update(transaction, "HEAD", new_head,
1137 old_head ? &old_head->object.oid : &null_oid,
1138 0, sb.buf, err) ||
1139 ref_transaction_commit(transaction, err)) {
1140 ret = -1;
1141 }
1142 ref_transaction_free(transaction);
1143 strbuf_release(&sb);
1144
1145 return ret;
1146}
1147
a87a6f3c
PW
1148static int run_rewrite_hook(const struct object_id *oldoid,
1149 const struct object_id *newoid)
1150{
1151 struct child_process proc = CHILD_PROCESS_INIT;
1152 const char *argv[3];
1153 int code;
1154 struct strbuf sb = STRBUF_INIT;
1155
1156 argv[0] = find_hook("post-rewrite");
1157 if (!argv[0])
1158 return 0;
1159
1160 argv[1] = "amend";
1161 argv[2] = NULL;
1162
1163 proc.argv = argv;
1164 proc.in = -1;
1165 proc.stdout_to_stderr = 1;
6206286e 1166 proc.trace2_hook_name = "post-rewrite";
a87a6f3c
PW
1167
1168 code = start_command(&proc);
1169 if (code)
1170 return code;
1171 strbuf_addf(&sb, "%s %s\n", oid_to_hex(oldoid), oid_to_hex(newoid));
1172 sigchain_push(SIGPIPE, SIG_IGN);
1173 write_in_full(proc.in, sb.buf, sb.len);
1174 close(proc.in);
1175 strbuf_release(&sb);
1176 sigchain_pop(SIGPIPE);
1177 return finish_command(&proc);
1178}
1179
1d18d758
NTND
1180void commit_post_rewrite(struct repository *r,
1181 const struct commit *old_head,
a87a6f3c
PW
1182 const struct object_id *new_head)
1183{
1184 struct notes_rewrite_cfg *cfg;
1185
1186 cfg = init_copy_notes_for_rewrite("amend");
1187 if (cfg) {
1188 /* we are amending, so old_head is not NULL */
1189 copy_note_for_rewrite(cfg, &old_head->object.oid, new_head);
1d18d758 1190 finish_copy_notes_for_rewrite(r, cfg, "Notes added by 'git commit --amend'");
a87a6f3c
PW
1191 }
1192 run_rewrite_hook(&old_head->object.oid, new_head);
1193}
1194
f11c9580
NTND
1195static int run_prepare_commit_msg_hook(struct repository *r,
1196 struct strbuf *msg,
1197 const char *commit)
66618a50
PW
1198{
1199 struct argv_array hook_env = ARGV_ARRAY_INIT;
1200 int ret;
1201 const char *name;
1202
1203 name = git_path_commit_editmsg();
1204 if (write_message(msg->buf, msg->len, name, 0))
1205 return -1;
1206
f11c9580 1207 argv_array_pushf(&hook_env, "GIT_INDEX_FILE=%s", r->index_file);
66618a50
PW
1208 argv_array_push(&hook_env, "GIT_EDITOR=:");
1209 if (commit)
1210 ret = run_hook_le(hook_env.argv, "prepare-commit-msg", name,
1211 "commit", commit, NULL);
1212 else
1213 ret = run_hook_le(hook_env.argv, "prepare-commit-msg", name,
1214 "message", NULL);
1215 if (ret)
1216 ret = error(_("'prepare-commit-msg' hook failed"));
1217 argv_array_clear(&hook_env);
1218
1219 return ret;
1220}
1221
e47c6caf
PW
1222static const char implicit_ident_advice_noconfig[] =
1223N_("Your name and email address were configured automatically based\n"
1224"on your username and hostname. Please check that they are accurate.\n"
1225"You can suppress this message by setting them explicitly. Run the\n"
1226"following command and follow the instructions in your editor to edit\n"
1227"your configuration file:\n"
1228"\n"
1229" git config --global --edit\n"
1230"\n"
1231"After doing this, you may fix the identity used for this commit with:\n"
1232"\n"
1233" git commit --amend --reset-author\n");
1234
1235static const char implicit_ident_advice_config[] =
1236N_("Your name and email address were configured automatically based\n"
1237"on your username and hostname. Please check that they are accurate.\n"
1238"You can suppress this message by setting them explicitly:\n"
1239"\n"
1240" git config --global user.name \"Your Name\"\n"
1241" git config --global user.email you@example.com\n"
1242"\n"
1243"After doing this, you may fix the identity used for this commit with:\n"
1244"\n"
1245" git commit --amend --reset-author\n");
1246
1247static const char *implicit_ident_advice(void)
1248{
1249 char *user_config = expand_user_path("~/.gitconfig", 0);
1250 char *xdg_config = xdg_config_home("config");
1251 int config_exists = file_exists(user_config) || file_exists(xdg_config);
1252
1253 free(user_config);
1254 free(xdg_config);
1255
1256 if (config_exists)
1257 return _(implicit_ident_advice_config);
1258 else
1259 return _(implicit_ident_advice_noconfig);
1260
1261}
1262
f11c9580
NTND
1263void print_commit_summary(struct repository *r,
1264 const char *prefix,
1265 const struct object_id *oid,
e47c6caf
PW
1266 unsigned int flags)
1267{
1268 struct rev_info rev;
1269 struct commit *commit;
1270 struct strbuf format = STRBUF_INIT;
1271 const char *head;
1272 struct pretty_print_context pctx = {0};
1273 struct strbuf author_ident = STRBUF_INIT;
1274 struct strbuf committer_ident = STRBUF_INIT;
1275
f11c9580 1276 commit = lookup_commit(r, oid);
e47c6caf
PW
1277 if (!commit)
1278 die(_("couldn't look up newly created commit"));
1279 if (parse_commit(commit))
1280 die(_("could not parse newly created commit"));
1281
1282 strbuf_addstr(&format, "format:%h] %s");
1283
1284 format_commit_message(commit, "%an <%ae>", &author_ident, &pctx);
1285 format_commit_message(commit, "%cn <%ce>", &committer_ident, &pctx);
1286 if (strbuf_cmp(&author_ident, &committer_ident)) {
1287 strbuf_addstr(&format, "\n Author: ");
1288 strbuf_addbuf_percentquote(&format, &author_ident);
1289 }
1290 if (flags & SUMMARY_SHOW_AUTHOR_DATE) {
1291 struct strbuf date = STRBUF_INIT;
1292
1293 format_commit_message(commit, "%ad", &date, &pctx);
1294 strbuf_addstr(&format, "\n Date: ");
1295 strbuf_addbuf_percentquote(&format, &date);
1296 strbuf_release(&date);
1297 }
1298 if (!committer_ident_sufficiently_given()) {
1299 strbuf_addstr(&format, "\n Committer: ");
1300 strbuf_addbuf_percentquote(&format, &committer_ident);
1301 if (advice_implicit_identity) {
1302 strbuf_addch(&format, '\n');
1303 strbuf_addstr(&format, implicit_ident_advice());
1304 }
1305 }
1306 strbuf_release(&author_ident);
1307 strbuf_release(&committer_ident);
1308
f11c9580 1309 repo_init_revisions(r, &rev, prefix);
e47c6caf
PW
1310 setup_revisions(0, NULL, &rev, NULL);
1311
1312 rev.diff = 1;
1313 rev.diffopt.output_format =
1314 DIFF_FORMAT_SHORTSTAT | DIFF_FORMAT_SUMMARY;
1315
1316 rev.verbose_header = 1;
1317 rev.show_root_diff = 1;
1318 get_commit_format(format.buf, &rev);
1319 rev.always_show_header = 0;
0f57f731 1320 rev.diffopt.detect_rename = DIFF_DETECT_RENAME;
e47c6caf
PW
1321 rev.diffopt.break_opt = 0;
1322 diff_setup_done(&rev.diffopt);
1323
1324 head = resolve_ref_unsafe("HEAD", 0, NULL, NULL);
1325 if (!head)
1326 die_errno(_("unable to resolve HEAD after creating commit"));
1327 if (!strcmp(head, "HEAD"))
1328 head = _("detached HEAD");
1329 else
1330 skip_prefix(head, "refs/heads/", &head);
1331 printf("[%s%s ", head, (flags & SUMMARY_INITIAL_COMMIT) ?
1332 _(" (root-commit)") : "");
1333
1334 if (!log_tree_commit(&rev, commit)) {
1335 rev.always_show_header = 1;
1336 rev.use_terminator = 1;
1337 log_tree_commit(&rev, commit);
1338 }
1339
1340 strbuf_release(&format);
1341}
1342
005af339 1343static int parse_head(struct repository *r, struct commit **head)
356ee465
PW
1344{
1345 struct commit *current_head;
1346 struct object_id oid;
1347
1348 if (get_oid("HEAD", &oid)) {
1349 current_head = NULL;
1350 } else {
005af339 1351 current_head = lookup_commit_reference(r, &oid);
356ee465
PW
1352 if (!current_head)
1353 return error(_("could not parse HEAD"));
9001dc2a 1354 if (!oideq(&oid, &current_head->object.oid)) {
356ee465
PW
1355 warning(_("HEAD %s is not a commit!"),
1356 oid_to_hex(&oid));
1357 }
1358 if (parse_commit(current_head))
1359 return error(_("could not parse HEAD commit"));
1360 }
1361 *head = current_head;
1362
1363 return 0;
1364}
1365
1366/*
1367 * Try to commit without forking 'git commit'. In some cases we need
1368 * to run 'git commit' to display an error message
1369 *
1370 * Returns:
1371 * -1 - error unable to commit
1372 * 0 - success
1373 * 1 - run 'git commit'
1374 */
f11c9580
NTND
1375static int try_to_commit(struct repository *r,
1376 struct strbuf *msg, const char *author,
356ee465
PW
1377 struct replay_opts *opts, unsigned int flags,
1378 struct object_id *oid)
1379{
1380 struct object_id tree;
1381 struct commit *current_head;
1382 struct commit_list *parents = NULL;
1383 struct commit_extra_header *extra = NULL;
1384 struct strbuf err = STRBUF_INIT;
66618a50 1385 struct strbuf commit_msg = STRBUF_INIT;
356ee465 1386 char *amend_author = NULL;
66618a50 1387 const char *hook_commit = NULL;
356ee465
PW
1388 enum commit_msg_cleanup_mode cleanup;
1389 int res = 0;
1390
005af339 1391 if (parse_head(r, &current_head))
356ee465
PW
1392 return -1;
1393
1394 if (flags & AMEND_MSG) {
1395 const char *exclude_gpgsig[] = { "gpgsig", NULL };
1396 const char *out_enc = get_commit_output_encoding();
1397 const char *message = logmsg_reencode(current_head, NULL,
1398 out_enc);
1399
1400 if (!msg) {
1401 const char *orig_message = NULL;
1402
1403 find_commit_subject(message, &orig_message);
66618a50 1404 msg = &commit_msg;
356ee465 1405 strbuf_addstr(msg, orig_message);
66618a50 1406 hook_commit = "HEAD";
356ee465
PW
1407 }
1408 author = amend_author = get_author(message);
1409 unuse_commit_buffer(current_head, message);
1410 if (!author) {
1411 res = error(_("unable to parse commit author"));
1412 goto out;
1413 }
1414 parents = copy_commit_list(current_head->parents);
1415 extra = read_commit_extra_headers(current_head, exclude_gpgsig);
1416 } else if (current_head) {
1417 commit_list_insert(current_head, &parents);
1418 }
1419
f11c9580 1420 if (write_index_as_tree(&tree, r->index, r->index_file, 0, NULL)) {
356ee465
PW
1421 res = error(_("git write-tree failed to write a tree"));
1422 goto out;
1423 }
1424
4a7e27e9
JK
1425 if (!(flags & ALLOW_EMPTY) && oideq(current_head ?
1426 get_commit_tree_oid(current_head) :
1427 the_hash_algo->empty_tree, &tree)) {
356ee465
PW
1428 res = 1; /* run 'git commit' to display error message */
1429 goto out;
1430 }
1431
66618a50 1432 if (find_hook("prepare-commit-msg")) {
f11c9580 1433 res = run_prepare_commit_msg_hook(r, msg, hook_commit);
66618a50
PW
1434 if (res)
1435 goto out;
1436 if (strbuf_read_file(&commit_msg, git_path_commit_editmsg(),
1437 2048) < 0) {
1438 res = error_errno(_("unable to read commit message "
1439 "from '%s'"),
1440 git_path_commit_editmsg());
1441 goto out;
1442 }
1443 msg = &commit_msg;
1444 }
1445
d74f3e58
PW
1446 if (flags & CLEANUP_MSG)
1447 cleanup = COMMIT_MSG_CLEANUP_ALL;
1448 else if ((opts->signoff || opts->record_origin) &&
1449 !opts->explicit_cleanup)
1450 cleanup = COMMIT_MSG_CLEANUP_SPACE;
1451 else
1452 cleanup = opts->default_msg_cleanup;
66618a50
PW
1453
1454 if (cleanup != COMMIT_MSG_CLEANUP_NONE)
1455 strbuf_stripspace(msg, cleanup == COMMIT_MSG_CLEANUP_ALL);
a3ec9eaf 1456 if ((flags & EDIT_MSG) && message_is_empty(msg, cleanup)) {
66618a50
PW
1457 res = 1; /* run 'git commit' to display error message */
1458 goto out;
1459 }
1460
12f7babd
JS
1461 reset_ident_date();
1462
8be8342b
JH
1463 if (commit_tree_extended(msg->buf, msg->len, &tree, parents,
1464 oid, author, opts->gpg_sign, extra)) {
356ee465
PW
1465 res = error(_("failed to write commit object"));
1466 goto out;
1467 }
1468
1469 if (update_head_with_reflog(current_head, oid,
1470 getenv("GIT_REFLOG_ACTION"), msg, &err)) {
1471 res = error("%s", err.buf);
1472 goto out;
1473 }
1474
1475 if (flags & AMEND_MSG)
1d18d758 1476 commit_post_rewrite(r, current_head, oid);
356ee465
PW
1477
1478out:
1479 free_commit_extra_headers(extra);
1480 strbuf_release(&err);
66618a50 1481 strbuf_release(&commit_msg);
356ee465
PW
1482 free(amend_author);
1483
1484 return res;
1485}
1486
f11c9580
NTND
1487static int do_commit(struct repository *r,
1488 const char *msg_file, const char *author,
356ee465
PW
1489 struct replay_opts *opts, unsigned int flags)
1490{
1491 int res = 1;
1492
d87d48b2
JS
1493 if (!(flags & EDIT_MSG) && !(flags & VERIFY_MSG) &&
1494 !(flags & CREATE_ROOT_COMMIT)) {
356ee465
PW
1495 struct object_id oid;
1496 struct strbuf sb = STRBUF_INIT;
1497
1498 if (msg_file && strbuf_read_file(&sb, msg_file, 2048) < 0)
1499 return error_errno(_("unable to read commit message "
1500 "from '%s'"),
1501 msg_file);
1502
f11c9580
NTND
1503 res = try_to_commit(r, msg_file ? &sb : NULL,
1504 author, opts, flags, &oid);
356ee465
PW
1505 strbuf_release(&sb);
1506 if (!res) {
f11c9580
NTND
1507 unlink(git_path_cherry_pick_head(r));
1508 unlink(git_path_merge_msg(r));
356ee465 1509 if (!is_rebase_i(opts))
f11c9580 1510 print_commit_summary(r, NULL, &oid,
356ee465
PW
1511 SUMMARY_SHOW_AUTHOR_DATE);
1512 return res;
1513 }
1514 }
1515 if (res == 1)
f11c9580 1516 return run_git_commit(r, msg_file, opts, flags);
356ee465
PW
1517
1518 return res;
1519}
1520
b27cfb0d
NH
1521static int is_original_commit_empty(struct commit *commit)
1522{
092bbcdf 1523 const struct object_id *ptree_oid;
b27cfb0d
NH
1524
1525 if (parse_commit(commit))
aee42e1f 1526 return error(_("could not parse commit %s"),
f2fd0760 1527 oid_to_hex(&commit->object.oid));
b27cfb0d
NH
1528 if (commit->parents) {
1529 struct commit *parent = commit->parents->item;
1530 if (parse_commit(parent))
aee42e1f 1531 return error(_("could not parse parent commit %s"),
f2fd0760 1532 oid_to_hex(&parent->object.oid));
2e27bd77 1533 ptree_oid = get_commit_tree_oid(parent);
b27cfb0d 1534 } else {
eb0ccfd7 1535 ptree_oid = the_hash_algo->empty_tree; /* commit is root */
043a4492 1536 }
043a4492 1537
4a7e27e9 1538 return oideq(ptree_oid, get_commit_tree_oid(commit));
043a4492
RR
1539}
1540
ac2b0e8f
JH
1541/*
1542 * Do we run "git commit" with "--allow-empty"?
1543 */
f11c9580
NTND
1544static int allow_empty(struct repository *r,
1545 struct replay_opts *opts,
1546 struct commit *commit)
ac2b0e8f
JH
1547{
1548 int index_unchanged, empty_commit;
1549
1550 /*
1551 * Three cases:
1552 *
1553 * (1) we do not allow empty at all and error out.
1554 *
1555 * (2) we allow ones that were initially empty, but
1556 * forbid the ones that become empty;
1557 *
1558 * (3) we allow both.
1559 */
1560 if (!opts->allow_empty)
1561 return 0; /* let "git commit" barf as necessary */
1562
005af339 1563 index_unchanged = is_index_unchanged(r);
ac2b0e8f
JH
1564 if (index_unchanged < 0)
1565 return index_unchanged;
1566 if (!index_unchanged)
1567 return 0; /* we do not have to say --allow-empty */
1568
1569 if (opts->keep_redundant_commits)
1570 return 1;
1571
1572 empty_commit = is_original_commit_empty(commit);
1573 if (empty_commit < 0)
1574 return empty_commit;
1575 if (!empty_commit)
1576 return 0;
1577 else
1578 return 1;
1579}
1580
414697a9
JS
1581static struct {
1582 char c;
1583 const char *str;
1584} todo_command_info[] = {
1585 { 'p', "pick" },
1586 { 0, "revert" },
1587 { 'e', "edit" },
04efc8b5 1588 { 'r', "reword" },
414697a9
JS
1589 { 'f', "fixup" },
1590 { 's', "squash" },
1591 { 'x', "exec" },
71f82465 1592 { 'b', "break" },
9055e401
JS
1593 { 'l', "label" },
1594 { 't', "reset" },
4c68e7dd 1595 { 'm', "merge" },
b3fdd581 1596 { 0, "noop" },
ac191470
JS
1597 { 'd', "drop" },
1598 { 0, NULL }
004fefa7
JS
1599};
1600
1601static const char *command_to_string(const enum todo_command command)
1602{
ac191470 1603 if (command < TODO_COMMENT)
414697a9 1604 return todo_command_info[command].str;
02127c63 1605 die(_("unknown command: %d"), command);
004fefa7
JS
1606}
1607
ee5462d6 1608static char command_to_char(const enum todo_command command)
d8ae6c84
LB
1609{
1610 if (command < TODO_COMMENT && todo_command_info[command].c)
1611 return todo_command_info[command].c;
1612 return comment_line_char;
1613}
1614
25c43667
JS
1615static int is_noop(const enum todo_command command)
1616{
b3fdd581 1617 return TODO_NOOP <= command;
25c43667 1618}
004fefa7 1619
6e98de72
JS
1620static int is_fixup(enum todo_command command)
1621{
1622 return command == TODO_FIXUP || command == TODO_SQUASH;
1623}
1624
d87d48b2
JS
1625/* Does this command create a (non-merge) commit? */
1626static int is_pick_or_similar(enum todo_command command)
1627{
1628 switch (command) {
1629 case TODO_PICK:
1630 case TODO_REVERT:
1631 case TODO_EDIT:
1632 case TODO_REWORD:
1633 case TODO_FIXUP:
1634 case TODO_SQUASH:
1635 return 1;
1636 default:
1637 return 0;
1638 }
1639}
1640
005af339
NTND
1641static int update_squash_messages(struct repository *r,
1642 enum todo_command command,
1643 struct commit *commit,
1644 struct replay_opts *opts)
6e98de72
JS
1645{
1646 struct strbuf buf = STRBUF_INIT;
e12a7ef5 1647 int res;
6e98de72
JS
1648 const char *message, *body;
1649
e12a7ef5 1650 if (opts->current_fixup_count > 0) {
6e98de72 1651 struct strbuf header = STRBUF_INIT;
e12a7ef5 1652 char *eol;
6e98de72 1653
e12a7ef5 1654 if (strbuf_read_file(&buf, rebase_path_squash_msg(), 9) <= 0)
6e98de72
JS
1655 return error(_("could not read '%s'"),
1656 rebase_path_squash_msg());
1657
e12a7ef5
JS
1658 eol = buf.buf[0] != comment_line_char ?
1659 buf.buf : strchrnul(buf.buf, '\n');
6e98de72
JS
1660
1661 strbuf_addf(&header, "%c ", comment_line_char);
e12a7ef5
JS
1662 strbuf_addf(&header, _("This is a combination of %d commits."),
1663 opts->current_fixup_count + 2);
6e98de72
JS
1664 strbuf_splice(&buf, 0, eol - buf.buf, header.buf, header.len);
1665 strbuf_release(&header);
1666 } else {
33d66df3 1667 struct object_id head;
6e98de72
JS
1668 struct commit *head_commit;
1669 const char *head_message, *body;
1670
33d66df3 1671 if (get_oid("HEAD", &head))
6e98de72 1672 return error(_("need a HEAD to fixup"));
005af339 1673 if (!(head_commit = lookup_commit_reference(r, &head)))
6e98de72
JS
1674 return error(_("could not read HEAD"));
1675 if (!(head_message = get_commit_buffer(head_commit, NULL)))
1676 return error(_("could not read HEAD's commit message"));
1677
1678 find_commit_subject(head_message, &body);
1679 if (write_message(body, strlen(body),
1680 rebase_path_fixup_msg(), 0)) {
1681 unuse_commit_buffer(head_commit, head_message);
1682 return error(_("cannot write '%s'"),
1683 rebase_path_fixup_msg());
1684 }
1685
6e98de72 1686 strbuf_addf(&buf, "%c ", comment_line_char);
e12a7ef5 1687 strbuf_addf(&buf, _("This is a combination of %d commits."), 2);
6e98de72
JS
1688 strbuf_addf(&buf, "\n%c ", comment_line_char);
1689 strbuf_addstr(&buf, _("This is the 1st commit message:"));
1690 strbuf_addstr(&buf, "\n\n");
1691 strbuf_addstr(&buf, body);
1692
1693 unuse_commit_buffer(head_commit, head_message);
1694 }
1695
1696 if (!(message = get_commit_buffer(commit, NULL)))
1697 return error(_("could not read commit message of %s"),
1698 oid_to_hex(&commit->object.oid));
1699 find_commit_subject(message, &body);
1700
1701 if (command == TODO_SQUASH) {
1702 unlink(rebase_path_fixup_msg());
1703 strbuf_addf(&buf, "\n%c ", comment_line_char);
e12a7ef5 1704 strbuf_addf(&buf, _("This is the commit message #%d:"),
dd2e36eb 1705 ++opts->current_fixup_count + 1);
6e98de72
JS
1706 strbuf_addstr(&buf, "\n\n");
1707 strbuf_addstr(&buf, body);
1708 } else if (command == TODO_FIXUP) {
1709 strbuf_addf(&buf, "\n%c ", comment_line_char);
1710 strbuf_addf(&buf, _("The commit message #%d will be skipped:"),
dd2e36eb 1711 ++opts->current_fixup_count + 1);
6e98de72
JS
1712 strbuf_addstr(&buf, "\n\n");
1713 strbuf_add_commented_lines(&buf, body, strlen(body));
1714 } else
1715 return error(_("unknown command: %d"), command);
1716 unuse_commit_buffer(commit, message);
1717
1718 res = write_message(buf.buf, buf.len, rebase_path_squash_msg(), 0);
1719 strbuf_release(&buf);
e12a7ef5
JS
1720
1721 if (!res) {
1722 strbuf_addf(&opts->current_fixups, "%s%s %s",
1723 opts->current_fixups.len ? "\n" : "",
1724 command_to_string(command),
1725 oid_to_hex(&commit->object.oid));
1726 res = write_message(opts->current_fixups.buf,
1727 opts->current_fixups.len,
1728 rebase_path_current_fixups(), 0);
1729 }
1730
6e98de72
JS
1731 return res;
1732}
1733
3b335762
NTND
1734static void flush_rewritten_pending(void)
1735{
25cb8df9 1736 struct strbuf buf = STRBUF_INIT;
092bbcdf 1737 struct object_id newoid;
25cb8df9
JS
1738 FILE *out;
1739
092bbcdf 1740 if (strbuf_read_file(&buf, rebase_path_rewritten_pending(), (GIT_MAX_HEXSZ + 1) * 2) > 0 &&
1741 !get_oid("HEAD", &newoid) &&
e9d983f1 1742 (out = fopen_or_warn(rebase_path_rewritten_list(), "a"))) {
25cb8df9
JS
1743 char *bol = buf.buf, *eol;
1744
1745 while (*bol) {
1746 eol = strchrnul(bol, '\n');
1747 fprintf(out, "%.*s %s\n", (int)(eol - bol),
092bbcdf 1748 bol, oid_to_hex(&newoid));
25cb8df9
JS
1749 if (!*eol)
1750 break;
1751 bol = eol + 1;
1752 }
1753 fclose(out);
1754 unlink(rebase_path_rewritten_pending());
1755 }
1756 strbuf_release(&buf);
1757}
1758
1759static void record_in_rewritten(struct object_id *oid,
3b335762
NTND
1760 enum todo_command next_command)
1761{
e9d983f1 1762 FILE *out = fopen_or_warn(rebase_path_rewritten_pending(), "a");
25cb8df9
JS
1763
1764 if (!out)
1765 return;
1766
1767 fprintf(out, "%s\n", oid_to_hex(oid));
1768 fclose(out);
1769
1770 if (!is_fixup(next_command))
1771 flush_rewritten_pending();
1772}
1773
f11c9580
NTND
1774static int do_pick_commit(struct repository *r,
1775 enum todo_command command,
1776 struct commit *commit,
1777 struct replay_opts *opts,
1778 int final_fixup)
043a4492 1779{
789b3eff 1780 unsigned int flags = opts->edit ? EDIT_MSG : 0;
f11c9580 1781 const char *msg_file = opts->edit ? NULL : git_path_merge_msg(r);
ace976b2 1782 struct object_id head;
043a4492
RR
1783 struct commit *base, *next, *parent;
1784 const char *base_label, *next_label;
356ee465 1785 char *author = NULL;
d74a4e57 1786 struct commit_message msg = { NULL, NULL, NULL, NULL };
043a4492 1787 struct strbuf msgbuf = STRBUF_INIT;
789b3eff 1788 int res, unborn = 0, allow;
043a4492
RR
1789
1790 if (opts->no_commit) {
1791 /*
1792 * We do not intend to commit immediately. We just want to
1793 * merge the differences in, so let's compute the tree
1794 * that represents the "current" state for merge-recursive
1795 * to work on.
1796 */
f11c9580 1797 if (write_index_as_tree(&head, r->index, r->index_file, 0, NULL))
93b3df6f 1798 return error(_("your index file is unmerged."));
043a4492 1799 } else {
ace976b2 1800 unborn = get_oid("HEAD", &head);
d87d48b2
JS
1801 /* Do we want to generate a root commit? */
1802 if (is_pick_or_similar(command) && opts->have_squash_onto &&
4a7e27e9 1803 oideq(&head, &opts->squash_onto)) {
d87d48b2
JS
1804 if (is_fixup(command))
1805 return error(_("cannot fixup root commit"));
1806 flags |= CREATE_ROOT_COMMIT;
1807 unborn = 1;
1808 } else if (unborn)
eb0ccfd7 1809 oidcpy(&head, the_hash_algo->empty_tree);
ffc00a48 1810 if (index_differs_from(r, unborn ? empty_tree_oid_hex() : "HEAD",
02f2f56b 1811 NULL, 0))
e1ff0a32 1812 return error_dirty_index(r, opts);
043a4492 1813 }
f11c9580 1814 discard_index(r->index);
043a4492 1815
637666c8 1816 if (!commit->parents)
043a4492 1817 parent = NULL;
043a4492
RR
1818 else if (commit->parents->next) {
1819 /* Reverting or cherry-picking a merge commit */
1820 int cnt;
1821 struct commit_list *p;
1822
1823 if (!opts->mainline)
93b3df6f 1824 return error(_("commit %s is a merge but no -m option was given."),
f2fd0760 1825 oid_to_hex(&commit->object.oid));
043a4492
RR
1826
1827 for (cnt = 1, p = commit->parents;
1828 cnt != opts->mainline && p;
1829 cnt++)
1830 p = p->next;
1831 if (cnt != opts->mainline || !p)
93b3df6f 1832 return error(_("commit %s does not have parent %d"),
f2fd0760 1833 oid_to_hex(&commit->object.oid), opts->mainline);
043a4492 1834 parent = p->item;
37897bfc
SO
1835 } else if (1 < opts->mainline)
1836 /*
1837 * Non-first parent explicitly specified as mainline for
1838 * non-merge commit
1839 */
1840 return error(_("commit %s does not have parent %d"),
1841 oid_to_hex(&commit->object.oid), opts->mainline);
043a4492
RR
1842 else
1843 parent = commit->parents->item;
1844
bcbb68be
JS
1845 if (get_message(commit, &msg) != 0)
1846 return error(_("cannot get commit message for %s"),
1847 oid_to_hex(&commit->object.oid));
1848
6e98de72 1849 if (opts->allow_ff && !is_fixup(command) &&
4a7e27e9 1850 ((parent && oideq(&parent->object.oid, &head)) ||
bcbb68be
JS
1851 (!parent && unborn))) {
1852 if (is_rebase_i(opts))
1853 write_author_script(msg.message);
f11c9580 1854 res = fast_forward_to(r, &commit->object.oid, &head, unborn,
bcbb68be
JS
1855 opts);
1856 if (res || command != TODO_REWORD)
1857 goto leave;
5f8f9277 1858 flags |= EDIT_MSG | AMEND_MSG | VERIFY_MSG;
bcbb68be
JS
1859 msg_file = NULL;
1860 goto fast_forward_edit;
1861 }
043a4492 1862 if (parent && parse_commit(parent) < 0)
004fefa7
JS
1863 /* TRANSLATORS: The first %s will be a "todo" command like
1864 "revert" or "pick", the second %s a SHA1. */
043a4492 1865 return error(_("%s: cannot parse parent commit %s"),
004fefa7
JS
1866 command_to_string(command),
1867 oid_to_hex(&parent->object.oid));
043a4492 1868
043a4492
RR
1869 /*
1870 * "commit" is an existing commit. We would want to apply
1871 * the difference it introduces since its first parent "prev"
1872 * on top of the current HEAD if we are cherry-pick. Or the
1873 * reverse of it if we are revert.
1874 */
1875
004fefa7 1876 if (command == TODO_REVERT) {
043a4492
RR
1877 base = commit;
1878 base_label = msg.label;
1879 next = parent;
1880 next_label = msg.parent_label;
1881 strbuf_addstr(&msgbuf, "Revert \"");
1882 strbuf_addstr(&msgbuf, msg.subject);
1883 strbuf_addstr(&msgbuf, "\"\n\nThis reverts commit ");
f2fd0760 1884 strbuf_addstr(&msgbuf, oid_to_hex(&commit->object.oid));
043a4492
RR
1885
1886 if (commit->parents && commit->parents->next) {
1887 strbuf_addstr(&msgbuf, ", reversing\nchanges made to ");
f2fd0760 1888 strbuf_addstr(&msgbuf, oid_to_hex(&parent->object.oid));
043a4492
RR
1889 }
1890 strbuf_addstr(&msgbuf, ".\n");
1891 } else {
1892 const char *p;
1893
1894 base = parent;
1895 base_label = msg.parent_label;
1896 next = commit;
1897 next_label = msg.label;
1898
23aa5142
JS
1899 /* Append the commit log message to msgbuf. */
1900 if (find_commit_subject(msg.message, &p))
1901 strbuf_addstr(&msgbuf, p);
043a4492
RR
1902
1903 if (opts->record_origin) {
44dc738a 1904 strbuf_complete_line(&msgbuf);
bab4d109 1905 if (!has_conforming_footer(&msgbuf, NULL, 0))
b971e04f 1906 strbuf_addch(&msgbuf, '\n');
cd650a4e 1907 strbuf_addstr(&msgbuf, cherry_picked_prefix);
f2fd0760 1908 strbuf_addstr(&msgbuf, oid_to_hex(&commit->object.oid));
043a4492
RR
1909 strbuf_addstr(&msgbuf, ")\n");
1910 }
356ee465
PW
1911 if (!is_fixup(command))
1912 author = get_author(msg.message);
043a4492
RR
1913 }
1914
04efc8b5 1915 if (command == TODO_REWORD)
b92ff6e8 1916 flags |= EDIT_MSG | VERIFY_MSG;
04efc8b5 1917 else if (is_fixup(command)) {
005af339 1918 if (update_squash_messages(r, command, commit, opts))
6e98de72 1919 return -1;
789b3eff 1920 flags |= AMEND_MSG;
6e98de72
JS
1921 if (!final_fixup)
1922 msg_file = rebase_path_squash_msg();
1923 else if (file_exists(rebase_path_fixup_msg())) {
789b3eff 1924 flags |= CLEANUP_MSG;
6e98de72
JS
1925 msg_file = rebase_path_fixup_msg();
1926 } else {
f11c9580 1927 const char *dest = git_path_squash_msg(r);
6e98de72
JS
1928 unlink(dest);
1929 if (copy_file(dest, rebase_path_squash_msg(), 0666))
1930 return error(_("could not rename '%s' to '%s'"),
1931 rebase_path_squash_msg(), dest);
f11c9580 1932 unlink(git_path_merge_msg(r));
6e98de72 1933 msg_file = dest;
789b3eff 1934 flags |= EDIT_MSG;
6e98de72
JS
1935 }
1936 }
1937
a852ec7f 1938 if (opts->signoff && !is_fixup(command))
b34eeea3
PW
1939 append_signoff(&msgbuf, 0, 0);
1940
0473f28a
JS
1941 if (is_rebase_i(opts) && write_author_script(msg.message) < 0)
1942 res = -1;
1943 else if (!opts->strategy || !strcmp(opts->strategy, "recursive") || command == TODO_REVERT) {
f11c9580 1944 res = do_recursive_merge(r, base, next, base_label, next_label,
48be4c62 1945 &head, &msgbuf, opts);
f241ff0d 1946 if (res < 0)
19517fb9
SB
1947 goto leave;
1948
75871495 1949 res |= write_message(msgbuf.buf, msgbuf.len,
f11c9580 1950 git_path_merge_msg(r), 0);
043a4492
RR
1951 } else {
1952 struct commit_list *common = NULL;
1953 struct commit_list *remotes = NULL;
1954
75871495 1955 res = write_message(msgbuf.buf, msgbuf.len,
f11c9580 1956 git_path_merge_msg(r), 0);
043a4492
RR
1957
1958 commit_list_insert(base, &common);
1959 commit_list_insert(next, &remotes);
f11c9580 1960 res |= try_merge_command(r, opts->strategy,
03a4e260 1961 opts->xopts_nr, (const char **)opts->xopts,
ace976b2 1962 common, oid_to_hex(&head), remotes);
043a4492
RR
1963 free_commit_list(common);
1964 free_commit_list(remotes);
1965 }
452202c7 1966 strbuf_release(&msgbuf);
043a4492
RR
1967
1968 /*
1969 * If the merge was clean or if it failed due to conflict, we write
1970 * CHERRY_PICK_HEAD for the subsequent invocation of commit to use.
1971 * However, if the merge did not even start, then we don't want to
1972 * write it at all.
1973 */
004fefa7 1974 if (command == TODO_PICK && !opts->no_commit && (res == 0 || res == 1) &&
ae077771 1975 update_ref(NULL, "CHERRY_PICK_HEAD", &commit->object.oid, NULL,
91774afc 1976 REF_NO_DEREF, UPDATE_REFS_MSG_ON_ERR))
dbfad033 1977 res = -1;
004fefa7 1978 if (command == TODO_REVERT && ((opts->no_commit && res == 0) || res == 1) &&
ae077771 1979 update_ref(NULL, "REVERT_HEAD", &commit->object.oid, NULL,
91774afc 1980 REF_NO_DEREF, UPDATE_REFS_MSG_ON_ERR))
dbfad033 1981 res = -1;
043a4492
RR
1982
1983 if (res) {
004fefa7 1984 error(command == TODO_REVERT
043a4492
RR
1985 ? _("could not revert %s... %s")
1986 : _("could not apply %s... %s"),
39755964 1987 short_commit_name(commit), msg.subject);
005af339 1988 print_advice(r, res == 1, opts);
f11c9580 1989 repo_rerere(r, opts->allow_rerere_auto);
c8d1351d 1990 goto leave;
043a4492
RR
1991 }
1992
f11c9580 1993 allow = allow_empty(r, opts, commit);
706728a3
FC
1994 if (allow < 0) {
1995 res = allow;
1996 goto leave;
789b3eff
JS
1997 } else if (allow)
1998 flags |= ALLOW_EMPTY;
356ee465 1999 if (!opts->no_commit) {
bcbb68be 2000fast_forward_edit:
356ee465 2001 if (author || command == TODO_REVERT || (flags & AMEND_MSG))
f11c9580 2002 res = do_commit(r, msg_file, author, opts, flags);
356ee465
PW
2003 else
2004 res = error(_("unable to parse commit author"));
2005 }
6e98de72
JS
2006
2007 if (!res && final_fixup) {
2008 unlink(rebase_path_fixup_msg());
2009 unlink(rebase_path_squash_msg());
e12a7ef5
JS
2010 unlink(rebase_path_current_fixups());
2011 strbuf_reset(&opts->current_fixups);
2012 opts->current_fixup_count = 0;
6e98de72 2013 }
c8d1351d
FC
2014
2015leave:
d74a4e57 2016 free_message(commit, &msg);
356ee465 2017 free(author);
1e41229d 2018 update_abort_safety_file();
043a4492
RR
2019
2020 return res;
2021}
2022
c3e8618c 2023static int prepare_revs(struct replay_opts *opts)
043a4492 2024{
a73e22e9
MZ
2025 /*
2026 * picking (but not reverting) ranges (but not individual revisions)
2027 * should be done in reverse
2028 */
2029 if (opts->action == REPLAY_PICK && !opts->revs->no_walk)
043a4492
RR
2030 opts->revs->reverse ^= 1;
2031
2032 if (prepare_revision_walk(opts->revs))
c3e8618c 2033 return error(_("revision walk setup failed"));
043a4492 2034
c3e8618c 2035 return 0;
043a4492
RR
2036}
2037
f11c9580
NTND
2038static int read_and_refresh_cache(struct repository *r,
2039 struct replay_opts *opts)
043a4492 2040{
14bca6c6 2041 struct lock_file index_lock = LOCK_INIT;
3a95f31d
NTND
2042 int index_fd = repo_hold_locked_index(r, &index_lock, 0);
2043 if (repo_read_index(r) < 0) {
49fb937e 2044 rollback_lock_file(&index_lock);
0d9c6dc9 2045 return error(_("git %s: failed to read the index"),
c28cbc5e 2046 _(action_name(opts)));
49fb937e 2047 }
f11c9580 2048 refresh_index(r->index, REFRESH_QUIET|REFRESH_UNMERGED, NULL, NULL, NULL);
61000814 2049 if (index_fd >= 0) {
f11c9580 2050 if (write_locked_index(r->index, &index_lock,
61000814 2051 COMMIT_LOCK | SKIP_IF_UNCHANGED)) {
0d9c6dc9 2052 return error(_("git %s: failed to refresh the index"),
c28cbc5e 2053 _(action_name(opts)));
49fb937e 2054 }
043a4492 2055 }
0d9c6dc9 2056 return 0;
043a4492
RR
2057}
2058
4c68e7dd
JS
2059enum todo_item_flags {
2060 TODO_EDIT_MERGE_MSG = 1
2061};
2062
5d94d545 2063void todo_list_release(struct todo_list *todo_list)
043a4492 2064{
004fefa7 2065 strbuf_release(&todo_list->buf);
6a83d902 2066 FREE_AND_NULL(todo_list->items);
004fefa7
JS
2067 todo_list->nr = todo_list->alloc = 0;
2068}
043a4492 2069
004fefa7
JS
2070static struct todo_item *append_new_todo(struct todo_list *todo_list)
2071{
2072 ALLOC_GROW(todo_list->items, todo_list->nr + 1, todo_list->alloc);
2073 return todo_list->items + todo_list->nr++;
043a4492
RR
2074}
2075
6ad656db
AG
2076const char *todo_item_get_arg(struct todo_list *todo_list,
2077 struct todo_item *item)
2078{
2079 return todo_list->buf.buf + item->arg_offset;
2080}
2081
3e81bccd
PW
2082static int is_command(enum todo_command command, const char **bol)
2083{
2084 const char *str = todo_command_info[command].str;
2085 const char nick = todo_command_info[command].c;
2086 const char *p = *bol + 1;
2087
2088 return skip_prefix(*bol, str, bol) ||
2089 ((nick && **bol == nick) &&
2090 (*p == ' ' || *p == '\t' || *p == '\n' || *p == '\r' || !*p) &&
2091 (*bol = p));
2092}
2093
005af339 2094static int parse_insn_line(struct repository *r, struct todo_item *item,
6ad656db 2095 const char *buf, const char *bol, char *eol)
043a4492 2096{
1e43ed98 2097 struct object_id commit_oid;
043a4492 2098 char *end_of_object_name;
004fefa7
JS
2099 int i, saved, status, padding;
2100
4c68e7dd
JS
2101 item->flags = 0;
2102
8f8550b3
JS
2103 /* left-trim */
2104 bol += strspn(bol, " \t");
2105
25c43667 2106 if (bol == eol || *bol == '\r' || *bol == comment_line_char) {
ac191470 2107 item->command = TODO_COMMENT;
25c43667 2108 item->commit = NULL;
6ad656db 2109 item->arg_offset = bol - buf;
25c43667
JS
2110 item->arg_len = eol - bol;
2111 return 0;
2112 }
2113
ac191470 2114 for (i = 0; i < TODO_COMMENT; i++)
3e81bccd 2115 if (is_command(i, &bol)) {
004fefa7
JS
2116 item->command = i;
2117 break;
2118 }
ac191470 2119 if (i >= TODO_COMMENT)
004fefa7 2120 return -1;
043a4492 2121
66afa24f
JS
2122 /* Eat up extra spaces/ tabs before object name */
2123 padding = strspn(bol, " \t");
2124 bol += padding;
2125
71f82465 2126 if (item->command == TODO_NOOP || item->command == TODO_BREAK) {
66afa24f
JS
2127 if (bol != eol)
2128 return error(_("%s does not accept arguments: '%s'"),
2129 command_to_string(item->command), bol);
25c43667 2130 item->commit = NULL;
6ad656db 2131 item->arg_offset = bol - buf;
25c43667
JS
2132 item->arg_len = eol - bol;
2133 return 0;
2134 }
2135
043a4492 2136 if (!padding)
66afa24f
JS
2137 return error(_("missing arguments for %s"),
2138 command_to_string(item->command));
043a4492 2139
9055e401
JS
2140 if (item->command == TODO_EXEC || item->command == TODO_LABEL ||
2141 item->command == TODO_RESET) {
7dcbb3cb 2142 item->commit = NULL;
6ad656db 2143 item->arg_offset = bol - buf;
311af526
JS
2144 item->arg_len = (int)(eol - bol);
2145 return 0;
2146 }
2147
4c68e7dd
JS
2148 if (item->command == TODO_MERGE) {
2149 if (skip_prefix(bol, "-C", &bol))
2150 bol += strspn(bol, " \t");
2151 else if (skip_prefix(bol, "-c", &bol)) {
2152 bol += strspn(bol, " \t");
2153 item->flags |= TODO_EDIT_MERGE_MSG;
2154 } else {
2155 item->flags |= TODO_EDIT_MERGE_MSG;
2156 item->commit = NULL;
6ad656db 2157 item->arg_offset = bol - buf;
4c68e7dd
JS
2158 item->arg_len = (int)(eol - bol);
2159 return 0;
2160 }
2161 }
2162
004fefa7 2163 end_of_object_name = (char *) bol + strcspn(bol, " \t\n");
043a4492
RR
2164 saved = *end_of_object_name;
2165 *end_of_object_name = '\0';
1e43ed98 2166 status = get_oid(bol, &commit_oid);
043a4492
RR
2167 *end_of_object_name = saved;
2168
6ad656db
AG
2169 bol = end_of_object_name + strspn(end_of_object_name, " \t");
2170 item->arg_offset = bol - buf;
2171 item->arg_len = (int)(eol - bol);
c22f7dfb 2172
043a4492 2173 if (status < 0)
8b637cda
JS
2174 return error(_("could not parse '%.*s'"),
2175 (int)(end_of_object_name - bol), bol);
043a4492 2176
005af339 2177 item->commit = lookup_commit_reference(r, &commit_oid);
004fefa7 2178 return !item->commit;
043a4492
RR
2179}
2180
4a72486d
PW
2181int sequencer_get_last_command(struct repository *r, enum replay_action *action)
2182{
ed5b1ca1 2183 const char *todo_file, *bol;
4a72486d 2184 struct strbuf buf = STRBUF_INIT;
ed5b1ca1 2185 int ret = 0;
4a72486d
PW
2186
2187 todo_file = git_path_todo_file();
2188 if (strbuf_read_file(&buf, todo_file, 0) < 0) {
ed5b1ca1 2189 if (errno == ENOENT || errno == ENOTDIR)
4a72486d
PW
2190 return -1;
2191 else
2192 return error_errno("unable to open '%s'", todo_file);
2193 }
ed5b1ca1
PW
2194 bol = buf.buf + strspn(buf.buf, " \t\r\n");
2195 if (is_command(TODO_PICK, &bol) && (*bol == ' ' || *bol == '\t'))
4a72486d 2196 *action = REPLAY_PICK;
ed5b1ca1
PW
2197 else if (is_command(TODO_REVERT, &bol) &&
2198 (*bol == ' ' || *bol == '\t'))
4a72486d
PW
2199 *action = REPLAY_REVERT;
2200 else
ed5b1ca1 2201 ret = -1;
4a72486d 2202
4a72486d
PW
2203 strbuf_release(&buf);
2204
2205 return ret;
2206}
2207
5d94d545
AG
2208int todo_list_parse_insn_buffer(struct repository *r, char *buf,
2209 struct todo_list *todo_list)
043a4492 2210{
004fefa7
JS
2211 struct todo_item *item;
2212 char *p = buf, *next_p;
6e98de72 2213 int i, res = 0, fixup_okay = file_exists(rebase_path_done());
043a4492 2214
2b71595d
AG
2215 todo_list->current = todo_list->nr = 0;
2216
004fefa7 2217 for (i = 1; *p; i++, p = next_p) {
043a4492 2218 char *eol = strchrnul(p, '\n');
004fefa7
JS
2219
2220 next_p = *eol ? eol + 1 /* skip LF */ : eol;
2221
6307041d
JS
2222 if (p != eol && eol[-1] == '\r')
2223 eol--; /* strip Carriage Return */
2224
004fefa7
JS
2225 item = append_new_todo(todo_list);
2226 item->offset_in_buf = p - todo_list->buf.buf;
6ad656db 2227 if (parse_insn_line(r, item, buf, p, eol)) {
93b3df6f 2228 res = error(_("invalid line %d: %.*s"),
004fefa7 2229 i, (int)(eol - p), p);
2b71595d 2230 item->command = TODO_COMMENT + 1;
6ad656db 2231 item->arg_offset = p - buf;
2b71595d
AG
2232 item->arg_len = (int)(eol - p);
2233 item->commit = NULL;
004fefa7 2234 }
6e98de72
JS
2235
2236 if (fixup_okay)
2237 ; /* do nothing */
2238 else if (is_fixup(item->command))
2239 return error(_("cannot '%s' without a previous commit"),
2240 command_to_string(item->command));
2241 else if (!is_noop(item->command))
2242 fixup_okay = 1;
043a4492 2243 }
52865279 2244
004fefa7 2245 return res;
043a4492
RR
2246}
2247
968492e4
JS
2248static int count_commands(struct todo_list *todo_list)
2249{
2250 int count = 0, i;
2251
2252 for (i = 0; i < todo_list->nr; i++)
2253 if (todo_list->items[i].command != TODO_COMMENT)
2254 count++;
2255
2256 return count;
2257}
2258
a01c2a5f
JS
2259static int get_item_line_offset(struct todo_list *todo_list, int index)
2260{
2261 return index < todo_list->nr ?
2262 todo_list->items[index].offset_in_buf : todo_list->buf.len;
2263}
2264
2265static const char *get_item_line(struct todo_list *todo_list, int index)
2266{
2267 return todo_list->buf.buf + get_item_line_offset(todo_list, index);
2268}
2269
2270static int get_item_line_length(struct todo_list *todo_list, int index)
2271{
2272 return get_item_line_offset(todo_list, index + 1)
2273 - get_item_line_offset(todo_list, index);
2274}
2275
87805600
RS
2276static ssize_t strbuf_read_file_or_whine(struct strbuf *sb, const char *path)
2277{
2278 int fd;
2279 ssize_t len;
2280
2281 fd = open(path, O_RDONLY);
2282 if (fd < 0)
2283 return error_errno(_("could not open '%s'"), path);
2284 len = strbuf_read(sb, fd, 0);
2285 close(fd);
2286 if (len < 0)
2287 return error(_("could not read '%s'."), path);
2288 return len;
2289}
2290
b07d9bfd
PW
2291static int have_finished_the_last_pick(void)
2292{
2293 struct strbuf buf = STRBUF_INIT;
2294 const char *eol;
2295 const char *todo_path = git_path_todo_file();
2296 int ret = 0;
2297
2298 if (strbuf_read_file(&buf, todo_path, 0) < 0) {
2299 if (errno == ENOENT) {
2300 return 0;
2301 } else {
2302 error_errno("unable to open '%s'", todo_path);
2303 return 0;
2304 }
2305 }
2306 /* If there is only one line then we are done */
2307 eol = strchr(buf.buf, '\n');
2308 if (!eol || !eol[1])
2309 ret = 1;
2310
2311 strbuf_release(&buf);
2312
2313 return ret;
2314}
2315
f496b064 2316void sequencer_post_commit_cleanup(struct repository *r, int verbose)
b07d9bfd
PW
2317{
2318 struct replay_opts opts = REPLAY_OPTS_INIT;
2319 int need_cleanup = 0;
2320
2321 if (file_exists(git_path_cherry_pick_head(r))) {
f496b064
JH
2322 if (!unlink(git_path_cherry_pick_head(r)) && verbose)
2323 warning(_("cancelling a cherry picking in progress"));
b07d9bfd
PW
2324 opts.action = REPLAY_PICK;
2325 need_cleanup = 1;
2326 }
2327
2328 if (file_exists(git_path_revert_head(r))) {
f496b064
JH
2329 if (!unlink(git_path_revert_head(r)) && verbose)
2330 warning(_("cancelling a revert in progress"));
b07d9bfd
PW
2331 opts.action = REPLAY_REVERT;
2332 need_cleanup = 1;
2333 }
2334
2335 if (!need_cleanup)
2336 return;
2337
2338 if (!have_finished_the_last_pick())
2339 return;
2340
2341 sequencer_remove_state(&opts);
2342}
2343
005af339
NTND
2344static int read_populate_todo(struct repository *r,
2345 struct todo_list *todo_list,
2346 struct replay_opts *opts)
043a4492 2347{
54fd3243 2348 struct stat st;
c0246501 2349 const char *todo_file = get_todo_path(opts);
87805600 2350 int res;
043a4492 2351
004fefa7 2352 strbuf_reset(&todo_list->buf);
87805600
RS
2353 if (strbuf_read_file_or_whine(&todo_list->buf, todo_file) < 0)
2354 return -1;
043a4492 2355
54fd3243
SH
2356 res = stat(todo_file, &st);
2357 if (res)
2358 return error(_("could not stat '%s'"), todo_file);
2359 fill_stat_data(&todo_list->stat, &st);
2360
5d94d545 2361 res = todo_list_parse_insn_buffer(r, todo_list->buf.buf, todo_list);
27fdbb96
JS
2362 if (res) {
2363 if (is_rebase_i(opts))
2364 return error(_("please fix this using "
2365 "'git rebase --edit-todo'."));
93b3df6f 2366 return error(_("unusable instruction sheet: '%s'"), todo_file);
27fdbb96 2367 }
2eeaf1b3 2368
52865279
JS
2369 if (!todo_list->nr &&
2370 (!is_rebase_i(opts) || !file_exists(rebase_path_done())))
2371 return error(_("no commits parsed."));
2372
2eeaf1b3 2373 if (!is_rebase_i(opts)) {
004fefa7
JS
2374 enum todo_command valid =
2375 opts->action == REPLAY_PICK ? TODO_PICK : TODO_REVERT;
2376 int i;
2377
2378 for (i = 0; i < todo_list->nr; i++)
2379 if (valid == todo_list->items[i].command)
2380 continue;
2381 else if (valid == TODO_PICK)
93b3df6f 2382 return error(_("cannot cherry-pick during a revert."));
004fefa7 2383 else
93b3df6f 2384 return error(_("cannot revert during a cherry-pick."));
004fefa7
JS
2385 }
2386
968492e4
JS
2387 if (is_rebase_i(opts)) {
2388 struct todo_list done = TODO_LIST_INIT;
e9d983f1 2389 FILE *f = fopen_or_warn(rebase_path_msgtotal(), "w");
968492e4
JS
2390
2391 if (strbuf_read_file(&done.buf, rebase_path_done(), 0) > 0 &&
5d94d545 2392 !todo_list_parse_insn_buffer(r, done.buf.buf, &done))
968492e4
JS
2393 todo_list->done_nr = count_commands(&done);
2394 else
2395 todo_list->done_nr = 0;
2396
2397 todo_list->total_nr = todo_list->done_nr
2398 + count_commands(todo_list);
968492e4 2399 todo_list_release(&done);
ef80069a
JS
2400
2401 if (f) {
2402 fprintf(f, "%d\n", todo_list->total_nr);
2403 fclose(f);
2404 }
968492e4
JS
2405 }
2406
0ae42a03 2407 return 0;
043a4492
RR
2408}
2409
03a4e260
JS
2410static int git_config_string_dup(char **dest,
2411 const char *var, const char *value)
2412{
2413 if (!value)
2414 return config_error_nonbool(var);
2415 free(*dest);
2416 *dest = xstrdup(value);
2417 return 0;
2418}
2419
043a4492
RR
2420static int populate_opts_cb(const char *key, const char *value, void *data)
2421{
2422 struct replay_opts *opts = data;
2423 int error_flag = 1;
2424
2425 if (!value)
2426 error_flag = 0;
2427 else if (!strcmp(key, "options.no-commit"))
2428 opts->no_commit = git_config_bool_or_int(key, value, &error_flag);
2429 else if (!strcmp(key, "options.edit"))
2430 opts->edit = git_config_bool_or_int(key, value, &error_flag);
6860ce5d
PW
2431 else if (!strcmp(key, "options.allow-empty"))
2432 opts->allow_empty =
2433 git_config_bool_or_int(key, value, &error_flag);
2434 else if (!strcmp(key, "options.allow-empty-message"))
2435 opts->allow_empty_message =
2436 git_config_bool_or_int(key, value, &error_flag);
2437 else if (!strcmp(key, "options.keep-redundant-commits"))
2438 opts->keep_redundant_commits =
2439 git_config_bool_or_int(key, value, &error_flag);
043a4492
RR
2440 else if (!strcmp(key, "options.signoff"))
2441 opts->signoff = git_config_bool_or_int(key, value, &error_flag);
2442 else if (!strcmp(key, "options.record-origin"))
2443 opts->record_origin = git_config_bool_or_int(key, value, &error_flag);
2444 else if (!strcmp(key, "options.allow-ff"))
2445 opts->allow_ff = git_config_bool_or_int(key, value, &error_flag);
2446 else if (!strcmp(key, "options.mainline"))
2447 opts->mainline = git_config_int(key, value);
2448 else if (!strcmp(key, "options.strategy"))
03a4e260 2449 git_config_string_dup(&opts->strategy, key, value);
3253553e 2450 else if (!strcmp(key, "options.gpg-sign"))
03a4e260 2451 git_config_string_dup(&opts->gpg_sign, key, value);
043a4492
RR
2452 else if (!strcmp(key, "options.strategy-option")) {
2453 ALLOC_GROW(opts->xopts, opts->xopts_nr + 1, opts->xopts_alloc);
2454 opts->xopts[opts->xopts_nr++] = xstrdup(value);
8d8cb4b0
PW
2455 } else if (!strcmp(key, "options.allow-rerere-auto"))
2456 opts->allow_rerere_auto =
2457 git_config_bool_or_int(key, value, &error_flag) ?
2458 RERERE_AUTOUPDATE : RERERE_NOAUTOUPDATE;
dc42e9a8
PW
2459 else if (!strcmp(key, "options.default-msg-cleanup")) {
2460 opts->explicit_cleanup = 1;
2461 opts->default_msg_cleanup = get_cleanup_mode(value, 1);
2462 } else
93b3df6f 2463 return error(_("invalid key: %s"), key);
043a4492
RR
2464
2465 if (!error_flag)
93b3df6f 2466 return error(_("invalid value for %s: %s"), key, value);
043a4492
RR
2467
2468 return 0;
2469}
2470
65850686 2471void parse_strategy_opts(struct replay_opts *opts, char *raw_opts)
ca6c6b45
JS
2472{
2473 int i;
65850686 2474 char *strategy_opts_string = raw_opts;
ca6c6b45 2475
0060041d
EN
2476 if (*strategy_opts_string == ' ')
2477 strategy_opts_string++;
65850686 2478
0060041d
EN
2479 opts->xopts_nr = split_cmdline(strategy_opts_string,
2480 (const char ***)&opts->xopts);
ca6c6b45
JS
2481 for (i = 0; i < opts->xopts_nr; i++) {
2482 const char *arg = opts->xopts[i];
2483
2484 skip_prefix(arg, "--", &arg);
2485 opts->xopts[i] = xstrdup(arg);
2486 }
2487}
2488
65850686
AG
2489static void read_strategy_opts(struct replay_opts *opts, struct strbuf *buf)
2490{
2491 strbuf_reset(buf);
2492 if (!read_oneliner(buf, rebase_path_strategy(), 0))
2493 return;
2494 opts->strategy = strbuf_detach(buf, NULL);
2495 if (!read_oneliner(buf, rebase_path_strategy_opts(), 0))
2496 return;
2497
2498 parse_strategy_opts(opts, buf->buf);
2499}
2500
5adf9bdc 2501static int read_populate_opts(struct replay_opts *opts)
043a4492 2502{
a1c75762
JS
2503 if (is_rebase_i(opts)) {
2504 struct strbuf buf = STRBUF_INIT;
2505
2506 if (read_oneliner(&buf, rebase_path_gpg_sign_opt(), 1)) {
2507 if (!starts_with(buf.buf, "-S"))
2508 strbuf_reset(&buf);
2509 else {
2510 free(opts->gpg_sign);
2511 opts->gpg_sign = xstrdup(buf.buf + 2);
2512 }
9b6d7a62
PW
2513 strbuf_reset(&buf);
2514 }
2515
2516 if (read_oneliner(&buf, rebase_path_allow_rerere_autoupdate(), 1)) {
2517 if (!strcmp(buf.buf, "--rerere-autoupdate"))
2518 opts->allow_rerere_auto = RERERE_AUTOUPDATE;
2519 else if (!strcmp(buf.buf, "--no-rerere-autoupdate"))
2520 opts->allow_rerere_auto = RERERE_NOAUTOUPDATE;
2521 strbuf_reset(&buf);
a1c75762 2522 }
a1c75762 2523
556907f1
JS
2524 if (file_exists(rebase_path_verbose()))
2525 opts->verbose = 1;
2526
899b49c4
EN
2527 if (file_exists(rebase_path_quiet()))
2528 opts->quiet = 1;
2529
a852ec7f
PW
2530 if (file_exists(rebase_path_signoff())) {
2531 opts->allow_ff = 0;
2532 opts->signoff = 1;
2533 }
2534
d421afa0
JS
2535 if (file_exists(rebase_path_reschedule_failed_exec()))
2536 opts->reschedule_failed_exec = 1;
2537
ca6c6b45
JS
2538 read_strategy_opts(opts, &buf);
2539 strbuf_release(&buf);
2540
e12a7ef5
JS
2541 if (read_oneliner(&opts->current_fixups,
2542 rebase_path_current_fixups(), 1)) {
2543 const char *p = opts->current_fixups.buf;
2544 opts->current_fixup_count = 1;
2545 while ((p = strchr(p, '\n'))) {
2546 opts->current_fixup_count++;
2547 p++;
2548 }
2549 }
2550
d87d48b2
JS
2551 if (read_oneliner(&buf, rebase_path_squash_onto(), 0)) {
2552 if (get_oid_hex(buf.buf, &opts->squash_onto) < 0)
2553 return error(_("unusable squash-onto"));
2554 opts->have_squash_onto = 1;
2555 }
2556
b5a67045 2557 return 0;
a1c75762 2558 }
b5a67045 2559
f932729c 2560 if (!file_exists(git_path_opts_file()))
0d00da7b
JS
2561 return 0;
2562 /*
2563 * The function git_parse_source(), called from git_config_from_file(),
2564 * may die() in case of a syntactically incorrect file. We do not care
2565 * about this case, though, because we wrote that file ourselves, so we
2566 * are pretty certain that it is syntactically correct.
2567 */
5adf9bdc 2568 if (git_config_from_file(populate_opts_cb, git_path_opts_file(), opts) < 0)
93b3df6f 2569 return error(_("malformed options sheet: '%s'"),
0d00da7b
JS
2570 git_path_opts_file());
2571 return 0;
043a4492
RR
2572}
2573
65850686
AG
2574static void write_strategy_opts(struct replay_opts *opts)
2575{
2576 int i;
2577 struct strbuf buf = STRBUF_INIT;
2578
2579 for (i = 0; i < opts->xopts_nr; ++i)
2580 strbuf_addf(&buf, " --%s", opts->xopts[i]);
2581
2582 write_file(rebase_path_strategy_opts(), "%s\n", buf.buf);
2583 strbuf_release(&buf);
2584}
2585
2586int write_basic_state(struct replay_opts *opts, const char *head_name,
7d3488eb 2587 struct commit *onto, const char *orig_head)
65850686
AG
2588{
2589 const char *quiet = getenv("GIT_QUIET");
2590
2591 if (head_name)
2592 write_file(rebase_path_head_name(), "%s\n", head_name);
2593 if (onto)
7d3488eb
PW
2594 write_file(rebase_path_onto(), "%s\n",
2595 oid_to_hex(&onto->object.oid));
65850686
AG
2596 if (orig_head)
2597 write_file(rebase_path_orig_head(), "%s\n", orig_head);
2598
2599 if (quiet)
2600 write_file(rebase_path_quiet(), "%s\n", quiet);
65850686 2601 if (opts->verbose)
4af51741 2602 write_file(rebase_path_verbose(), "%s", "");
65850686
AG
2603 if (opts->strategy)
2604 write_file(rebase_path_strategy(), "%s\n", opts->strategy);
2605 if (opts->xopts_nr > 0)
2606 write_strategy_opts(opts);
2607
2608 if (opts->allow_rerere_auto == RERERE_AUTOUPDATE)
2609 write_file(rebase_path_allow_rerere_autoupdate(), "--rerere-autoupdate\n");
2610 else if (opts->allow_rerere_auto == RERERE_NOAUTOUPDATE)
2611 write_file(rebase_path_allow_rerere_autoupdate(), "--no-rerere-autoupdate\n");
2612
2613 if (opts->gpg_sign)
2614 write_file(rebase_path_gpg_sign_opt(), "-S%s\n", opts->gpg_sign);
2615 if (opts->signoff)
2616 write_file(rebase_path_signoff(), "--signoff\n");
d421afa0
JS
2617 if (opts->reschedule_failed_exec)
2618 write_file(rebase_path_reschedule_failed_exec(), "%s", "");
65850686
AG
2619
2620 return 0;
2621}
2622
004fefa7 2623static int walk_revs_populate_todo(struct todo_list *todo_list,
043a4492
RR
2624 struct replay_opts *opts)
2625{
004fefa7
JS
2626 enum todo_command command = opts->action == REPLAY_PICK ?
2627 TODO_PICK : TODO_REVERT;
414697a9 2628 const char *command_string = todo_command_info[command].str;
043a4492 2629 struct commit *commit;
043a4492 2630
34b0528b
JS
2631 if (prepare_revs(opts))
2632 return -1;
043a4492 2633
004fefa7
JS
2634 while ((commit = get_revision(opts->revs))) {
2635 struct todo_item *item = append_new_todo(todo_list);
2636 const char *commit_buffer = get_commit_buffer(commit, NULL);
2637 const char *subject;
2638 int subject_len;
2639
2640 item->command = command;
2641 item->commit = commit;
6ad656db 2642 item->arg_offset = 0;
c22f7dfb 2643 item->arg_len = 0;
004fefa7
JS
2644 item->offset_in_buf = todo_list->buf.len;
2645 subject_len = find_commit_subject(commit_buffer, &subject);
2646 strbuf_addf(&todo_list->buf, "%s %s %.*s\n", command_string,
2647 short_commit_name(commit), subject_len, subject);
2648 unuse_commit_buffer(commit, commit_buffer);
2649 }
8530c739
JK
2650
2651 if (!todo_list->nr)
2652 return error(_("empty commit set passed"));
2653
34b0528b 2654 return 0;
043a4492
RR
2655}
2656
6a1f9046 2657static int create_seq_dir(struct repository *r)
043a4492 2658{
6a1f9046
RA
2659 enum replay_action action;
2660 const char *in_progress_error = NULL;
2661 const char *in_progress_advice = NULL;
dcb500dc
RA
2662 unsigned int advise_skip = file_exists(git_path_revert_head(r)) ||
2663 file_exists(git_path_cherry_pick_head(r));
6a1f9046
RA
2664
2665 if (!sequencer_get_last_command(r, &action)) {
2666 switch (action) {
2667 case REPLAY_REVERT:
2668 in_progress_error = _("revert is already in progress");
2669 in_progress_advice =
dcb500dc 2670 _("try \"git revert (--continue | %s--abort | --quit)\"");
6a1f9046
RA
2671 break;
2672 case REPLAY_PICK:
2673 in_progress_error = _("cherry-pick is already in progress");
2674 in_progress_advice =
dcb500dc 2675 _("try \"git cherry-pick (--continue | %s--abort | --quit)\"");
6a1f9046
RA
2676 break;
2677 default:
2678 BUG("unexpected action in create_seq_dir");
2679 }
2680 }
2681 if (in_progress_error) {
2682 error("%s", in_progress_error);
2683 if (advice_sequencer_in_use)
dcb500dc
RA
2684 advise(in_progress_advice,
2685 advise_skip ? "--skip | " : "");
043a4492 2686 return -1;
6a1f9046
RA
2687 }
2688 if (mkdir(git_path_seq_dir(), 0777) < 0)
93b3df6f 2689 return error_errno(_("could not create sequencer directory '%s'"),
f6e82b0d 2690 git_path_seq_dir());
6a1f9046 2691
043a4492
RR
2692 return 0;
2693}
2694
311fd397 2695static int save_head(const char *head)
043a4492 2696{
14bca6c6 2697 struct lock_file head_lock = LOCK_INIT;
043a4492
RR
2698 struct strbuf buf = STRBUF_INIT;
2699 int fd;
ed3f9a12 2700 ssize_t written;
043a4492 2701
311fd397 2702 fd = hold_lock_file_for_update(&head_lock, git_path_head_file(), 0);
350292a1 2703 if (fd < 0)
93b3df6f 2704 return error_errno(_("could not lock HEAD"));
043a4492 2705 strbuf_addf(&buf, "%s\n", head);
ed3f9a12
RS
2706 written = write_in_full(fd, buf.buf, buf.len);
2707 strbuf_release(&buf);
2708 if (written < 0) {
bf5c0571 2709 error_errno(_("could not write to '%s'"), git_path_head_file());
311fd397 2710 rollback_lock_file(&head_lock);
bf5c0571 2711 return -1;
311fd397 2712 }
350292a1
2713 if (commit_lock_file(&head_lock) < 0)
2714 return error(_("failed to finalize '%s'"), git_path_head_file());
311fd397 2715 return 0;
043a4492
RR
2716}
2717
1e41229d
SB
2718static int rollback_is_safe(void)
2719{
2720 struct strbuf sb = STRBUF_INIT;
2721 struct object_id expected_head, actual_head;
2722
2723 if (strbuf_read_file(&sb, git_path_abort_safety_file(), 0) >= 0) {
2724 strbuf_trim(&sb);
2725 if (get_oid_hex(sb.buf, &expected_head)) {
2726 strbuf_release(&sb);
2727 die(_("could not parse %s"), git_path_abort_safety_file());
2728 }
2729 strbuf_release(&sb);
2730 }
2731 else if (errno == ENOENT)
2732 oidclr(&expected_head);
2733 else
2734 die_errno(_("could not read '%s'"), git_path_abort_safety_file());
2735
2736 if (get_oid("HEAD", &actual_head))
2737 oidclr(&actual_head);
2738
4a7e27e9 2739 return oideq(&actual_head, &expected_head);
1e41229d
SB
2740}
2741
918d1e6e 2742static int reset_merge(const struct object_id *oid)
043a4492 2743{
265ab48f
RA
2744 int ret;
2745 struct argv_array argv = ARGV_ARRAY_INIT;
1e41229d 2746
265ab48f
RA
2747 argv_array_pushl(&argv, "reset", "--merge", NULL);
2748
2749 if (!is_null_oid(oid))
2750 argv_array_push(&argv, oid_to_hex(oid));
1e41229d 2751
265ab48f
RA
2752 ret = run_command_v_opt(argv.argv, RUN_GIT_CMD);
2753 argv_array_clear(&argv);
2754
2755 return ret;
043a4492
RR
2756}
2757
005af339 2758static int rollback_single_pick(struct repository *r)
043a4492 2759{
092bbcdf 2760 struct object_id head_oid;
043a4492 2761
005af339
NTND
2762 if (!file_exists(git_path_cherry_pick_head(r)) &&
2763 !file_exists(git_path_revert_head(r)))
043a4492 2764 return error(_("no cherry-pick or revert in progress"));
34c290a6 2765 if (read_ref_full("HEAD", 0, &head_oid, NULL))
043a4492 2766 return error(_("cannot resolve HEAD"));
092bbcdf 2767 if (is_null_oid(&head_oid))
043a4492 2768 return error(_("cannot abort from a branch yet to be born"));
918d1e6e 2769 return reset_merge(&head_oid);
043a4492
RR
2770}
2771
de81ca3f
RA
2772static int skip_single_pick(void)
2773{
2774 struct object_id head;
2775
2776 if (read_ref_full("HEAD", 0, &head, NULL))
2777 return error(_("cannot resolve HEAD"));
2778 return reset_merge(&head);
043a4492
RR
2779}
2780
005af339 2781int sequencer_rollback(struct repository *r, struct replay_opts *opts)
043a4492 2782{
043a4492 2783 FILE *f;
092bbcdf 2784 struct object_id oid;
043a4492 2785 struct strbuf buf = STRBUF_INIT;
092bbcdf 2786 const char *p;
043a4492 2787
f932729c 2788 f = fopen(git_path_head_file(), "r");
043a4492
RR
2789 if (!f && errno == ENOENT) {
2790 /*
2791 * There is no multiple-cherry-pick in progress.
2792 * If CHERRY_PICK_HEAD or REVERT_HEAD indicates
2793 * a single-cherry-pick in progress, abort that.
2794 */
005af339 2795 return rollback_single_pick(r);
043a4492
RR
2796 }
2797 if (!f)
f7ed1953 2798 return error_errno(_("cannot open '%s'"), git_path_head_file());
8f309aeb 2799 if (strbuf_getline_lf(&buf, f)) {
f7ed1953 2800 error(_("cannot read '%s': %s"), git_path_head_file(),
f932729c 2801 ferror(f) ? strerror(errno) : _("unexpected end of file"));
043a4492
RR
2802 fclose(f);
2803 goto fail;
2804 }
2805 fclose(f);
092bbcdf 2806 if (parse_oid_hex(buf.buf, &oid, &p) || *p != '\0') {
043a4492 2807 error(_("stored pre-cherry-pick HEAD file '%s' is corrupt"),
f932729c 2808 git_path_head_file());
043a4492
RR
2809 goto fail;
2810 }
092bbcdf 2811 if (is_null_oid(&oid)) {
0f974e21
MG
2812 error(_("cannot abort from a branch yet to be born"));
2813 goto fail;
2814 }
1e41229d
SB
2815
2816 if (!rollback_is_safe()) {
2817 /* Do not error, just do not rollback */
2818 warning(_("You seem to have moved HEAD. "
2819 "Not rewinding, check your HEAD!"));
2820 } else
918d1e6e 2821 if (reset_merge(&oid))
043a4492 2822 goto fail;
043a4492 2823 strbuf_release(&buf);
2863584f 2824 return sequencer_remove_state(opts);
043a4492
RR
2825fail:
2826 strbuf_release(&buf);
2827 return -1;
2828}
2829
de81ca3f
RA
2830int sequencer_skip(struct repository *r, struct replay_opts *opts)
2831{
2832 enum replay_action action = -1;
2833 sequencer_get_last_command(r, &action);
2834
2835 /*
2836 * Check whether the subcommand requested to skip the commit is actually
2837 * in progress and that it's safe to skip the commit.
2838 *
2839 * opts->action tells us which subcommand requested to skip the commit.
2840 * If the corresponding .git/<ACTION>_HEAD exists, we know that the
2841 * action is in progress and we can skip the commit.
2842 *
2843 * Otherwise we check that the last instruction was related to the
2844 * particular subcommand we're trying to execute and barf if that's not
2845 * the case.
2846 *
2847 * Finally we check that the rollback is "safe", i.e., has the HEAD
2848 * moved? In this case, it doesn't make sense to "reset the merge" and
2849 * "skip the commit" as the user already handled this by committing. But
2850 * we'd not want to barf here, instead give advice on how to proceed. We
2851 * only need to check that when .git/<ACTION>_HEAD doesn't exist because
2852 * it gets removed when the user commits, so if it still exists we're
2853 * sure the user can't have committed before.
2854 */
2855 switch (opts->action) {
2856 case REPLAY_REVERT:
2857 if (!file_exists(git_path_revert_head(r))) {
2858 if (action != REPLAY_REVERT)
2859 return error(_("no revert in progress"));
2860 if (!rollback_is_safe())
2861 goto give_advice;
2862 }
2863 break;
2864 case REPLAY_PICK:
2865 if (!file_exists(git_path_cherry_pick_head(r))) {
2866 if (action != REPLAY_PICK)
2867 return error(_("no cherry-pick in progress"));
2868 if (!rollback_is_safe())
2869 goto give_advice;
2870 }
2871 break;
2872 default:
2873 BUG("unexpected action in sequencer_skip");
2874 }
2875
2876 if (skip_single_pick())
2877 return error(_("failed to skip the commit"));
2878 if (!is_directory(git_path_seq_dir()))
2879 return 0;
2880
2881 return sequencer_continue(r, opts);
2882
2883give_advice:
2884 error(_("there is nothing to skip"));
2885
2886 if (advice_resolve_conflict) {
2887 advise(_("have you committed already?\n"
2888 "try \"git %s --continue\""),
2889 action == REPLAY_REVERT ? "revert" : "cherry-pick");
2890 }
2891 return -1;
2892}
2893
004fefa7 2894static int save_todo(struct todo_list *todo_list, struct replay_opts *opts)
043a4492 2895{
14bca6c6 2896 struct lock_file todo_lock = LOCK_INIT;
004fefa7
JS
2897 const char *todo_path = get_todo_path(opts);
2898 int next = todo_list->current, offset, fd;
043a4492 2899
84583957
JS
2900 /*
2901 * rebase -i writes "git-rebase-todo" without the currently executing
2902 * command, appending it to "done" instead.
2903 */
2904 if (is_rebase_i(opts))
2905 next++;
2906
004fefa7 2907 fd = hold_lock_file_for_update(&todo_lock, todo_path, 0);
221675de 2908 if (fd < 0)
93b3df6f 2909 return error_errno(_("could not lock '%s'"), todo_path);
a01c2a5f 2910 offset = get_item_line_offset(todo_list, next);
004fefa7
JS
2911 if (write_in_full(fd, todo_list->buf.buf + offset,
2912 todo_list->buf.len - offset) < 0)
93b3df6f 2913 return error_errno(_("could not write to '%s'"), todo_path);
004fefa7 2914 if (commit_lock_file(&todo_lock) < 0)
350292a1 2915 return error(_("failed to finalize '%s'"), todo_path);
1df6df0c 2916
a01c2a5f
JS
2917 if (is_rebase_i(opts) && next > 0) {
2918 const char *done = rebase_path_done();
2919 int fd = open(done, O_CREAT | O_WRONLY | O_APPEND, 0666);
2920 int ret = 0;
1df6df0c 2921
a01c2a5f
JS
2922 if (fd < 0)
2923 return 0;
2924 if (write_in_full(fd, get_item_line(todo_list, next - 1),
2925 get_item_line_length(todo_list, next - 1))
2926 < 0)
2927 ret = error_errno(_("could not write to '%s'"), done);
2928 if (close(fd) < 0)
2929 ret = error_errno(_("failed to finalize '%s'"), done);
2930 return ret;
1df6df0c 2931 }
221675de 2932 return 0;
043a4492
RR
2933}
2934
88d5a271 2935static int save_opts(struct replay_opts *opts)
043a4492 2936{
f932729c 2937 const char *opts_file = git_path_opts_file();
88d5a271 2938 int res = 0;
043a4492
RR
2939
2940 if (opts->no_commit)
f59199d5
PW
2941 res |= git_config_set_in_file_gently(opts_file,
2942 "options.no-commit", "true");
043a4492 2943 if (opts->edit)
f59199d5
PW
2944 res |= git_config_set_in_file_gently(opts_file,
2945 "options.edit", "true");
6860ce5d
PW
2946 if (opts->allow_empty)
2947 res |= git_config_set_in_file_gently(opts_file,
2948 "options.allow-empty", "true");
2949 if (opts->allow_empty_message)
2950 res |= git_config_set_in_file_gently(opts_file,
2951 "options.allow-empty-message", "true");
2952 if (opts->keep_redundant_commits)
2953 res |= git_config_set_in_file_gently(opts_file,
2954 "options.keep-redundant-commits", "true");
043a4492 2955 if (opts->signoff)
f59199d5
PW
2956 res |= git_config_set_in_file_gently(opts_file,
2957 "options.signoff", "true");
043a4492 2958 if (opts->record_origin)
f59199d5
PW
2959 res |= git_config_set_in_file_gently(opts_file,
2960 "options.record-origin", "true");
043a4492 2961 if (opts->allow_ff)
f59199d5
PW
2962 res |= git_config_set_in_file_gently(opts_file,
2963 "options.allow-ff", "true");
043a4492
RR
2964 if (opts->mainline) {
2965 struct strbuf buf = STRBUF_INIT;
2966 strbuf_addf(&buf, "%d", opts->mainline);
f59199d5
PW
2967 res |= git_config_set_in_file_gently(opts_file,
2968 "options.mainline", buf.buf);
043a4492
RR
2969 strbuf_release(&buf);
2970 }
2971 if (opts->strategy)
f59199d5
PW
2972 res |= git_config_set_in_file_gently(opts_file,
2973 "options.strategy", opts->strategy);
3253553e 2974 if (opts->gpg_sign)
f59199d5
PW
2975 res |= git_config_set_in_file_gently(opts_file,
2976 "options.gpg-sign", opts->gpg_sign);
043a4492
RR
2977 if (opts->xopts) {
2978 int i;
2979 for (i = 0; i < opts->xopts_nr; i++)
88d5a271 2980 res |= git_config_set_multivar_in_file_gently(opts_file,
f59199d5
PW
2981 "options.strategy-option",
2982 opts->xopts[i], "^$", 0);
043a4492 2983 }
8d8cb4b0 2984 if (opts->allow_rerere_auto)
f59199d5
PW
2985 res |= git_config_set_in_file_gently(opts_file,
2986 "options.allow-rerere-auto",
2987 opts->allow_rerere_auto == RERERE_AUTOUPDATE ?
2988 "true" : "false");
dc42e9a8
PW
2989
2990 if (opts->explicit_cleanup)
2991 res |= git_config_set_in_file_gently(opts_file,
2992 "options.default-msg-cleanup",
2993 describe_cleanup_mode(opts->default_msg_cleanup));
88d5a271 2994 return res;
043a4492
RR
2995}
2996
f11c9580
NTND
2997static int make_patch(struct repository *r,
2998 struct commit *commit,
2999 struct replay_opts *opts)
56dc3ab0
JS
3000{
3001 struct strbuf buf = STRBUF_INIT;
3002 struct rev_info log_tree_opt;
3003 const char *subject, *p;
3004 int res = 0;
3005
3006 p = short_commit_name(commit);
3007 if (write_message(p, strlen(p), rebase_path_stopped_sha(), 1) < 0)
3008 return -1;
fbd7a232
NTND
3009 if (update_ref("rebase", "REBASE_HEAD", &commit->object.oid,
3010 NULL, REF_NO_DEREF, UPDATE_REFS_MSG_ON_ERR))
3011 res |= error(_("could not update %s"), "REBASE_HEAD");
56dc3ab0
JS
3012
3013 strbuf_addf(&buf, "%s/patch", get_dir(opts));
3014 memset(&log_tree_opt, 0, sizeof(log_tree_opt));
f11c9580 3015 repo_init_revisions(r, &log_tree_opt, NULL);
56dc3ab0
JS
3016 log_tree_opt.abbrev = 0;
3017 log_tree_opt.diff = 1;
3018 log_tree_opt.diffopt.output_format = DIFF_FORMAT_PATCH;
3019 log_tree_opt.disable_stdin = 1;
3020 log_tree_opt.no_commit_id = 1;
3021 log_tree_opt.diffopt.file = fopen(buf.buf, "w");
3022 log_tree_opt.diffopt.use_color = GIT_COLOR_NEVER;
3023 if (!log_tree_opt.diffopt.file)
3024 res |= error_errno(_("could not open '%s'"), buf.buf);
3025 else {
3026 res |= log_tree_commit(&log_tree_opt, commit);
3027 fclose(log_tree_opt.diffopt.file);
3028 }
3029 strbuf_reset(&buf);
3030
3031 strbuf_addf(&buf, "%s/message", get_dir(opts));
3032 if (!file_exists(buf.buf)) {
3033 const char *commit_buffer = get_commit_buffer(commit, NULL);
3034 find_commit_subject(commit_buffer, &subject);
3035 res |= write_message(subject, strlen(subject), buf.buf, 1);
3036 unuse_commit_buffer(commit, commit_buffer);
3037 }
3038 strbuf_release(&buf);
3039
3040 return res;
3041}
3042
3043static int intend_to_amend(void)
3044{
092bbcdf 3045 struct object_id head;
56dc3ab0
JS
3046 char *p;
3047
092bbcdf 3048 if (get_oid("HEAD", &head))
56dc3ab0
JS
3049 return error(_("cannot read HEAD"));
3050
092bbcdf 3051 p = oid_to_hex(&head);
56dc3ab0
JS
3052 return write_message(p, strlen(p), rebase_path_amend(), 1);
3053}
3054
f11c9580
NTND
3055static int error_with_patch(struct repository *r,
3056 struct commit *commit,
3057 const char *subject, int subject_len,
3058 struct replay_opts *opts,
3059 int exit_code, int to_amend)
56dc3ab0 3060{
bc9238bb 3061 if (commit) {
f11c9580 3062 if (make_patch(r, commit, opts))
bc9238bb 3063 return -1;
5a5c5e95 3064 } else if (copy_file(rebase_path_message(),
f11c9580 3065 git_path_merge_msg(r), 0666))
bc9238bb 3066 return error(_("unable to copy '%s' to '%s'"),
f11c9580 3067 git_path_merge_msg(r), rebase_path_message());
56dc3ab0
JS
3068
3069 if (to_amend) {
3070 if (intend_to_amend())
3071 return -1;
3072
02127c63
NTND
3073 fprintf(stderr,
3074 _("You can amend the commit now, with\n"
3075 "\n"
3076 " git commit --amend %s\n"
3077 "\n"
3078 "Once you are satisfied with your changes, run\n"
3079 "\n"
3080 " git rebase --continue\n"),
3081 gpg_sign_opt_quoted(opts));
bc9238bb
PW
3082 } else if (exit_code) {
3083 if (commit)
5a5c5e95
JH
3084 fprintf_ln(stderr, _("Could not apply %s... %.*s"),
3085 short_commit_name(commit), subject_len, subject);
bc9238bb
PW
3086 else
3087 /*
3088 * We don't have the hash of the parent so
3089 * just print the line from the todo file.
3090 */
5a5c5e95
JH
3091 fprintf_ln(stderr, _("Could not merge %.*s"),
3092 subject_len, subject);
bc9238bb 3093 }
56dc3ab0
JS
3094
3095 return exit_code;
3096}
3097
f11c9580
NTND
3098static int error_failed_squash(struct repository *r,
3099 struct commit *commit,
3100 struct replay_opts *opts,
3101 int subject_len,
3102 const char *subject)
6e98de72 3103{
e12a7ef5
JS
3104 if (copy_file(rebase_path_message(), rebase_path_squash_msg(), 0666))
3105 return error(_("could not copy '%s' to '%s'"),
6e98de72 3106 rebase_path_squash_msg(), rebase_path_message());
f11c9580
NTND
3107 unlink(git_path_merge_msg(r));
3108 if (copy_file(git_path_merge_msg(r), rebase_path_message(), 0666))
6e98de72 3109 return error(_("could not copy '%s' to '%s'"),
102de880 3110 rebase_path_message(),
f11c9580
NTND
3111 git_path_merge_msg(r));
3112 return error_with_patch(r, commit, subject, subject_len, opts, 1, 0);
6e98de72
JS
3113}
3114
f11c9580 3115static int do_exec(struct repository *r, const char *command_line)
311af526 3116{
09d7b6c6 3117 struct argv_array child_env = ARGV_ARRAY_INIT;
311af526
JS
3118 const char *child_argv[] = { NULL, NULL };
3119 int dirty, status;
3120
3121 fprintf(stderr, "Executing: %s\n", command_line);
3122 child_argv[0] = command_line;
09d7b6c6 3123 argv_array_pushf(&child_env, "GIT_DIR=%s", absolute_path(get_git_dir()));
ab5e67d7 3124 argv_array_pushf(&child_env, "GIT_WORK_TREE=%s",
3125 absolute_path(get_git_work_tree()));
09d7b6c6
JK
3126 status = run_command_v_opt_cd_env(child_argv, RUN_USING_SHELL, NULL,
3127 child_env.argv);
311af526
JS
3128
3129 /* force re-reading of the cache */
e1ff0a32 3130 if (discard_index(r->index) < 0 || repo_read_index(r) < 0)
311af526
JS
3131 return error(_("could not read index"));
3132
f11c9580 3133 dirty = require_clean_work_tree(r, "rebase", NULL, 1, 1);
311af526
JS
3134
3135 if (status) {
3136 warning(_("execution failed: %s\n%s"
3137 "You can fix the problem, and then run\n"
3138 "\n"
3139 " git rebase --continue\n"
3140 "\n"),
3141 command_line,
3142 dirty ? N_("and made changes to the index and/or the "
3143 "working tree\n") : "");
3144 if (status == 127)
3145 /* command not found */
3146 status = 1;
3147 } else if (dirty) {
3148 warning(_("execution succeeded: %s\nbut "
3149 "left changes to the index and/or the working tree\n"
3150 "Commit or stash your changes, and then run\n"
3151 "\n"
3152 " git rebase --continue\n"
3153 "\n"), command_line);
3154 status = 1;
3155 }
3156
09d7b6c6
JK
3157 argv_array_clear(&child_env);
3158
311af526
JS
3159 return status;
3160}
3161
9055e401
JS
3162static int safe_append(const char *filename, const char *fmt, ...)
3163{
3164 va_list ap;
3165 struct lock_file lock = LOCK_INIT;
3166 int fd = hold_lock_file_for_update(&lock, filename,
3167 LOCK_REPORT_ON_ERROR);
3168 struct strbuf buf = STRBUF_INIT;
3169
3170 if (fd < 0)
3171 return -1;
3172
3173 if (strbuf_read_file(&buf, filename, 0) < 0 && errno != ENOENT) {
3174 error_errno(_("could not read '%s'"), filename);
3175 rollback_lock_file(&lock);
3176 return -1;
3177 }
3178 strbuf_complete(&buf, '\n');
3179 va_start(ap, fmt);
3180 strbuf_vaddf(&buf, fmt, ap);
3181 va_end(ap);
3182
3183 if (write_in_full(fd, buf.buf, buf.len) < 0) {
3184 error_errno(_("could not write to '%s'"), filename);
3185 strbuf_release(&buf);
3186 rollback_lock_file(&lock);
3187 return -1;
3188 }
3189 if (commit_lock_file(&lock) < 0) {
3190 strbuf_release(&buf);
3191 rollback_lock_file(&lock);
3192 return error(_("failed to finalize '%s'"), filename);
3193 }
3194
3195 strbuf_release(&buf);
3196 return 0;
3197}
3198
f11c9580 3199static int do_label(struct repository *r, const char *name, int len)
9055e401 3200{
f11c9580 3201 struct ref_store *refs = get_main_ref_store(r);
9055e401
JS
3202 struct ref_transaction *transaction;
3203 struct strbuf ref_name = STRBUF_INIT, err = STRBUF_INIT;
3204 struct strbuf msg = STRBUF_INIT;
3205 int ret = 0;
3206 struct object_id head_oid;
3207
3208 if (len == 1 && *name == '#')
02127c63 3209 return error(_("illegal label name: '%.*s'"), len, name);
9055e401
JS
3210
3211 strbuf_addf(&ref_name, "refs/rewritten/%.*s", len, name);
3212 strbuf_addf(&msg, "rebase -i (label) '%.*s'", len, name);
3213
3214 transaction = ref_store_transaction_begin(refs, &err);
3215 if (!transaction) {
3216 error("%s", err.buf);
3217 ret = -1;
3218 } else if (get_oid("HEAD", &head_oid)) {
3219 error(_("could not read HEAD"));
3220 ret = -1;
3221 } else if (ref_transaction_update(transaction, ref_name.buf, &head_oid,
3222 NULL, 0, msg.buf, &err) < 0 ||
3223 ref_transaction_commit(transaction, &err)) {
3224 error("%s", err.buf);
3225 ret = -1;
3226 }
3227 ref_transaction_free(transaction);
3228 strbuf_release(&err);
3229 strbuf_release(&msg);
3230
3231 if (!ret)
3232 ret = safe_append(rebase_path_refs_to_delete(),
3233 "%s\n", ref_name.buf);
3234 strbuf_release(&ref_name);
3235
3236 return ret;
3237}
3238
3239static const char *reflog_message(struct replay_opts *opts,
3240 const char *sub_action, const char *fmt, ...);
3241
f11c9580
NTND
3242static int do_reset(struct repository *r,
3243 const char *name, int len,
3244 struct replay_opts *opts)
9055e401
JS
3245{
3246 struct strbuf ref_name = STRBUF_INIT;
3247 struct object_id oid;
3248 struct lock_file lock = LOCK_INIT;
3249 struct tree_desc desc;
3250 struct tree *tree;
3251 struct unpack_trees_options unpack_tree_opts;
71571cd7 3252 int ret = 0;
9055e401 3253
3a95f31d 3254 if (repo_hold_locked_index(r, &lock, LOCK_REPORT_ON_ERROR) < 0)
9055e401
JS
3255 return -1;
3256
ebddf393
JS
3257 if (len == 10 && !strncmp("[new root]", name, len)) {
3258 if (!opts->have_squash_onto) {
3259 const char *hex;
3260 if (commit_tree("", 0, the_hash_algo->empty_tree,
3261 NULL, &opts->squash_onto,
3262 NULL, NULL))
3263 return error(_("writing fake root commit"));
3264 opts->have_squash_onto = 1;
3265 hex = oid_to_hex(&opts->squash_onto);
3266 if (write_message(hex, strlen(hex),
3267 rebase_path_squash_onto(), 0))
3268 return error(_("writing squash-onto"));
3269 }
3270 oidcpy(&oid, &opts->squash_onto);
3271 } else {
71571cd7
3272 int i;
3273
ebddf393
JS
3274 /* Determine the length of the label */
3275 for (i = 0; i < len; i++)
3276 if (isspace(name[i]))
71571cd7
3277 break;
3278 len = i;
ebddf393
JS
3279
3280 strbuf_addf(&ref_name, "refs/rewritten/%.*s", len, name);
3281 if (get_oid(ref_name.buf, &oid) &&
3282 get_oid(ref_name.buf + strlen("refs/rewritten/"), &oid)) {
3283 error(_("could not read '%s'"), ref_name.buf);
3284 rollback_lock_file(&lock);
3285 strbuf_release(&ref_name);
3286 return -1;
3287 }
9055e401
JS
3288 }
3289
3290 memset(&unpack_tree_opts, 0, sizeof(unpack_tree_opts));
3291 setup_unpack_trees_porcelain(&unpack_tree_opts, "reset");
3292 unpack_tree_opts.head_idx = 1;
f11c9580
NTND
3293 unpack_tree_opts.src_index = r->index;
3294 unpack_tree_opts.dst_index = r->index;
9055e401
JS
3295 unpack_tree_opts.fn = oneway_merge;
3296 unpack_tree_opts.merge = 1;
3297 unpack_tree_opts.update = 1;
3298
e1ff0a32 3299 if (repo_read_index_unmerged(r)) {
9055e401
JS
3300 rollback_lock_file(&lock);
3301 strbuf_release(&ref_name);
3302 return error_resolve_conflict(_(action_name(opts)));
3303 }
3304
5e575807 3305 if (!fill_tree_descriptor(r, &desc, &oid)) {
9055e401
JS
3306 error(_("failed to find tree of %s"), oid_to_hex(&oid));
3307 rollback_lock_file(&lock);
3308 free((void *)desc.buffer);
3309 strbuf_release(&ref_name);
3310 return -1;
3311 }
3312
3313 if (unpack_trees(1, &desc, &unpack_tree_opts)) {
3314 rollback_lock_file(&lock);
3315 free((void *)desc.buffer);
3316 strbuf_release(&ref_name);
3317 return -1;
3318 }
3319
3320 tree = parse_tree_indirect(&oid);
c207e9e1 3321 prime_cache_tree(r, r->index, tree);
9055e401 3322
f11c9580 3323 if (write_locked_index(r->index, &lock, COMMIT_LOCK) < 0)
9055e401
JS
3324 ret = error(_("could not write index"));
3325 free((void *)desc.buffer);
3326
3327 if (!ret)
3328 ret = update_ref(reflog_message(opts, "reset", "'%.*s'",
3329 len, name), "HEAD", &oid,
3330 NULL, 0, UPDATE_REFS_MSG_ON_ERR);
3331
3332 strbuf_release(&ref_name);
3333 return ret;
3334}
3335
2b6ad0f4
JS
3336static struct commit *lookup_label(const char *label, int len,
3337 struct strbuf *buf)
3338{
3339 struct commit *commit;
3340
3341 strbuf_reset(buf);
3342 strbuf_addf(buf, "refs/rewritten/%.*s", len, label);
3343 commit = lookup_commit_reference_by_name(buf->buf);
3344 if (!commit) {
3345 /* fall back to non-rewritten ref or commit */
3346 strbuf_splice(buf, 0, strlen("refs/rewritten/"), "", 0);
3347 commit = lookup_commit_reference_by_name(buf->buf);
3348 }
3349
3350 if (!commit)
3351 error(_("could not resolve '%s'"), buf->buf);
3352
3353 return commit;
3354}
3355
f11c9580
NTND
3356static int do_merge(struct repository *r,
3357 struct commit *commit,
3358 const char *arg, int arg_len,
4c68e7dd
JS
3359 int flags, struct replay_opts *opts)
3360{
3361 int run_commit_flags = (flags & TODO_EDIT_MERGE_MSG) ?
3362 EDIT_MSG | VERIFY_MSG : 0;
3363 struct strbuf ref_name = STRBUF_INIT;
3364 struct commit *head_commit, *merge_commit, *i;
3365 struct commit_list *bases, *j, *reversed = NULL;
2b6ad0f4 3366 struct commit_list *to_merge = NULL, **tail = &to_merge;
4c68e7dd 3367 struct merge_options o;
2b6ad0f4 3368 int merge_arg_len, oneline_offset, can_fast_forward, ret, k;
4c68e7dd
JS
3369 static struct lock_file lock;
3370 const char *p;
3371
3a95f31d 3372 if (repo_hold_locked_index(r, &lock, LOCK_REPORT_ON_ERROR) < 0) {
4c68e7dd
JS
3373 ret = -1;
3374 goto leave_merge;
3375 }
3376
3377 head_commit = lookup_commit_reference_by_name("HEAD");
3378 if (!head_commit) {
3379 ret = error(_("cannot merge without a current revision"));
3380 goto leave_merge;
3381 }
3382
2b6ad0f4
JS
3383 /*
3384 * For octopus merges, the arg starts with the list of revisions to be
3385 * merged. The list is optionally followed by '#' and the oneline.
3386 */
3387 merge_arg_len = oneline_offset = arg_len;
3388 for (p = arg; p - arg < arg_len; p += strspn(p, " \t\n")) {
3389 if (!*p)
3390 break;
3391 if (*p == '#' && (!p[1] || isspace(p[1]))) {
3392 p += 1 + strspn(p + 1, " \t\n");
3393 oneline_offset = p - arg;
3394 break;
3395 }
3396 k = strcspn(p, " \t\n");
3397 if (!k)
3398 continue;
3399 merge_commit = lookup_label(p, k, &ref_name);
3400 if (!merge_commit) {
3401 ret = error(_("unable to parse '%.*s'"), k, p);
3402 goto leave_merge;
3403 }
3404 tail = &commit_list_insert(merge_commit, tail)->next;
3405 p += k;
3406 merge_arg_len = p - arg;
4c68e7dd
JS
3407 }
3408
2b6ad0f4
JS
3409 if (!to_merge) {
3410 ret = error(_("nothing to merge: '%.*s'"), arg_len, arg);
4c68e7dd
JS
3411 goto leave_merge;
3412 }
3413
9c85a1c2 3414 if (opts->have_squash_onto &&
4a7e27e9 3415 oideq(&head_commit->object.oid, &opts->squash_onto)) {
9c85a1c2
JS
3416 /*
3417 * When the user tells us to "merge" something into a
3418 * "[new root]", let's simply fast-forward to the merge head.
3419 */
3420 rollback_lock_file(&lock);
2b6ad0f4
JS
3421 if (to_merge->next)
3422 ret = error(_("octopus merge cannot be executed on "
3423 "top of a [new root]"));
3424 else
f11c9580 3425 ret = fast_forward_to(r, &to_merge->item->object.oid,
2b6ad0f4
JS
3426 &head_commit->object.oid, 0,
3427 opts);
9c85a1c2
JS
3428 goto leave_merge;
3429 }
3430
4c68e7dd
JS
3431 if (commit) {
3432 const char *message = get_commit_buffer(commit, NULL);
3433 const char *body;
3434 int len;
3435
3436 if (!message) {
3437 ret = error(_("could not get commit message of '%s'"),
3438 oid_to_hex(&commit->object.oid));
3439 goto leave_merge;
3440 }
3441 write_author_script(message);
3442 find_commit_subject(message, &body);
3443 len = strlen(body);
f11c9580 3444 ret = write_message(body, len, git_path_merge_msg(r), 0);
4c68e7dd
JS
3445 unuse_commit_buffer(commit, message);
3446 if (ret) {
3447 error_errno(_("could not write '%s'"),
f11c9580 3448 git_path_merge_msg(r));
4c68e7dd
JS
3449 goto leave_merge;
3450 }
3451 } else {
3452 struct strbuf buf = STRBUF_INIT;
3453 int len;
3454
3455 strbuf_addf(&buf, "author %s", git_author_info(0));
3456 write_author_script(buf.buf);
3457 strbuf_reset(&buf);
3458
3459 if (oneline_offset < arg_len) {
3460 p = arg + oneline_offset;
3461 len = arg_len - oneline_offset;
3462 } else {
2b6ad0f4
JS
3463 strbuf_addf(&buf, "Merge %s '%.*s'",
3464 to_merge->next ? "branches" : "branch",
4c68e7dd
JS
3465 merge_arg_len, arg);
3466 p = buf.buf;
3467 len = buf.len;
3468 }
3469
f11c9580 3470 ret = write_message(p, len, git_path_merge_msg(r), 0);
4c68e7dd
JS
3471 strbuf_release(&buf);
3472 if (ret) {
3473 error_errno(_("could not write '%s'"),
f11c9580 3474 git_path_merge_msg(r));
4c68e7dd
JS
3475 goto leave_merge;
3476 }
3477 }
3478
d1e8b011
JS
3479 /*
3480 * If HEAD is not identical to the first parent of the original merge
3481 * commit, we cannot fast-forward.
3482 */
3483 can_fast_forward = opts->allow_ff && commit && commit->parents &&
4a7e27e9
JK
3484 oideq(&commit->parents->item->object.oid,
3485 &head_commit->object.oid);
d1e8b011
JS
3486
3487 /*
2b6ad0f4 3488 * If any merge head is different from the original one, we cannot
d1e8b011
JS
3489 * fast-forward.
3490 */
3491 if (can_fast_forward) {
2b6ad0f4 3492 struct commit_list *p = commit->parents->next;
d1e8b011 3493
2b6ad0f4 3494 for (j = to_merge; j && p; j = j->next, p = p->next)
9001dc2a 3495 if (!oideq(&j->item->object.oid,
2b6ad0f4
JS
3496 &p->item->object.oid)) {
3497 can_fast_forward = 0;
3498 break;
3499 }
3500 /*
3501 * If the number of merge heads differs from the original merge
3502 * commit, we cannot fast-forward.
3503 */
3504 if (j || p)
d1e8b011
JS
3505 can_fast_forward = 0;
3506 }
3507
2b6ad0f4 3508 if (can_fast_forward) {
d1e8b011 3509 rollback_lock_file(&lock);
f11c9580 3510 ret = fast_forward_to(r, &commit->object.oid,
d1e8b011 3511 &head_commit->object.oid, 0, opts);
6df8df08
PW
3512 if (flags & TODO_EDIT_MERGE_MSG) {
3513 run_commit_flags |= AMEND_MSG;
3514 goto fast_forward_edit;
3515 }
d1e8b011
JS
3516 goto leave_merge;
3517 }
3518
2b6ad0f4
JS
3519 if (to_merge->next) {
3520 /* Octopus merge */
3521 struct child_process cmd = CHILD_PROCESS_INIT;
3522
3523 if (read_env_script(&cmd.env_array)) {
3524 const char *gpg_opt = gpg_sign_opt_quoted(opts);
3525
3526 ret = error(_(staged_changes_advice), gpg_opt, gpg_opt);
3527 goto leave_merge;
3528 }
3529
3530 cmd.git_cmd = 1;
3531 argv_array_push(&cmd.args, "merge");
3532 argv_array_push(&cmd.args, "-s");
3533 argv_array_push(&cmd.args, "octopus");
3534 argv_array_push(&cmd.args, "--no-edit");
3535 argv_array_push(&cmd.args, "--no-ff");
3536 argv_array_push(&cmd.args, "--no-log");
3537 argv_array_push(&cmd.args, "--no-stat");
3538 argv_array_push(&cmd.args, "-F");
f11c9580 3539 argv_array_push(&cmd.args, git_path_merge_msg(r));
2b6ad0f4
JS
3540 if (opts->gpg_sign)
3541 argv_array_push(&cmd.args, opts->gpg_sign);
3542
3543 /* Add the tips to be merged */
3544 for (j = to_merge; j; j = j->next)
3545 argv_array_push(&cmd.args,
3546 oid_to_hex(&j->item->object.oid));
3547
3548 strbuf_release(&ref_name);
f11c9580 3549 unlink(git_path_cherry_pick_head(r));
2b6ad0f4
JS
3550 rollback_lock_file(&lock);
3551
3552 rollback_lock_file(&lock);
3553 ret = run_command(&cmd);
3554
3555 /* force re-reading of the cache */
f11c9580 3556 if (!ret && (discard_index(r->index) < 0 ||
e1ff0a32 3557 repo_read_index(r) < 0))
2b6ad0f4
JS
3558 ret = error(_("could not read index"));
3559 goto leave_merge;
3560 }
3561
3562 merge_commit = to_merge->item;
4c68e7dd 3563 bases = get_merge_bases(head_commit, merge_commit);
4a7e27e9
JK
3564 if (bases && oideq(&merge_commit->object.oid,
3565 &bases->item->object.oid)) {
7ccdf65b
JS
3566 ret = 0;
3567 /* skip merging an ancestor of HEAD */
3568 goto leave_merge;
3569 }
3570
85f8d9da 3571 write_message(oid_to_hex(&merge_commit->object.oid), GIT_SHA1_HEXSZ,
cde55548
JH
3572 git_path_merge_head(r), 0);
3573 write_message("no-ff", 5, git_path_merge_mode(r), 0);
85f8d9da 3574
4c68e7dd
JS
3575 for (j = bases; j; j = j->next)
3576 commit_list_insert(j->item, &reversed);
3577 free_commit_list(bases);
3578
e1ff0a32 3579 repo_read_index(r);
0d6caa2d