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