sequencer: use argv_array in reset_merge
[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
c3c003e7 770 * with our parsing, as the file was meant to be eval'd in the now-removed
bcd33ec2
PW
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
6a1f9046 2653static int create_seq_dir(struct repository *r)
043a4492 2654{
6a1f9046
RA
2655 enum replay_action action;
2656 const char *in_progress_error = NULL;
2657 const char *in_progress_advice = NULL;
2658
2659 if (!sequencer_get_last_command(r, &action)) {
2660 switch (action) {
2661 case REPLAY_REVERT:
2662 in_progress_error = _("revert is already in progress");
2663 in_progress_advice =
2664 _("try \"git revert (--continue | --abort | --quit)\"");
2665 break;
2666 case REPLAY_PICK:
2667 in_progress_error = _("cherry-pick is already in progress");
2668 in_progress_advice =
2669 _("try \"git cherry-pick (--continue | --abort | --quit)\"");
2670 break;
2671 default:
2672 BUG("unexpected action in create_seq_dir");
2673 }
2674 }
2675 if (in_progress_error) {
2676 error("%s", in_progress_error);
2677 if (advice_sequencer_in_use)
2678 advise("%s", in_progress_advice);
043a4492 2679 return -1;
6a1f9046
RA
2680 }
2681 if (mkdir(git_path_seq_dir(), 0777) < 0)
93b3df6f 2682 return error_errno(_("could not create sequencer directory '%s'"),
f6e82b0d 2683 git_path_seq_dir());
6a1f9046 2684
043a4492
RR
2685 return 0;
2686}
2687
311fd397 2688static int save_head(const char *head)
043a4492 2689{
14bca6c6 2690 struct lock_file head_lock = LOCK_INIT;
043a4492
RR
2691 struct strbuf buf = STRBUF_INIT;
2692 int fd;
ed3f9a12 2693 ssize_t written;
043a4492 2694
311fd397 2695 fd = hold_lock_file_for_update(&head_lock, git_path_head_file(), 0);
350292a1 2696 if (fd < 0)
93b3df6f 2697 return error_errno(_("could not lock HEAD"));
043a4492 2698 strbuf_addf(&buf, "%s\n", head);
ed3f9a12
RS
2699 written = write_in_full(fd, buf.buf, buf.len);
2700 strbuf_release(&buf);
2701 if (written < 0) {
bf5c0571 2702 error_errno(_("could not write to '%s'"), git_path_head_file());
311fd397 2703 rollback_lock_file(&head_lock);
bf5c0571 2704 return -1;
311fd397 2705 }
350292a1
2706 if (commit_lock_file(&head_lock) < 0)
2707 return error(_("failed to finalize '%s'"), git_path_head_file());
311fd397 2708 return 0;
043a4492
RR
2709}
2710
1e41229d
SB
2711static int rollback_is_safe(void)
2712{
2713 struct strbuf sb = STRBUF_INIT;
2714 struct object_id expected_head, actual_head;
2715
2716 if (strbuf_read_file(&sb, git_path_abort_safety_file(), 0) >= 0) {
2717 strbuf_trim(&sb);
2718 if (get_oid_hex(sb.buf, &expected_head)) {
2719 strbuf_release(&sb);
2720 die(_("could not parse %s"), git_path_abort_safety_file());
2721 }
2722 strbuf_release(&sb);
2723 }
2724 else if (errno == ENOENT)
2725 oidclr(&expected_head);
2726 else
2727 die_errno(_("could not read '%s'"), git_path_abort_safety_file());
2728
2729 if (get_oid("HEAD", &actual_head))
2730 oidclr(&actual_head);
2731
4a7e27e9 2732 return oideq(&actual_head, &expected_head);
1e41229d
SB
2733}
2734
918d1e6e 2735static int reset_merge(const struct object_id *oid)
043a4492 2736{
265ab48f
RA
2737 int ret;
2738 struct argv_array argv = ARGV_ARRAY_INIT;
2739
2740 argv_array_pushl(&argv, "reset", "--merge", NULL);
2741
2742 if (!is_null_oid(oid))
2743 argv_array_push(&argv, oid_to_hex(oid));
1e41229d 2744
265ab48f
RA
2745 ret = run_command_v_opt(argv.argv, RUN_GIT_CMD);
2746 argv_array_clear(&argv);
2747
2748 return ret;
043a4492
RR
2749}
2750
005af339 2751static int rollback_single_pick(struct repository *r)
043a4492 2752{
092bbcdf 2753 struct object_id head_oid;
043a4492 2754
005af339
NTND
2755 if (!file_exists(git_path_cherry_pick_head(r)) &&
2756 !file_exists(git_path_revert_head(r)))
043a4492 2757 return error(_("no cherry-pick or revert in progress"));
34c290a6 2758 if (read_ref_full("HEAD", 0, &head_oid, NULL))
043a4492 2759 return error(_("cannot resolve HEAD"));
092bbcdf 2760 if (is_null_oid(&head_oid))
043a4492 2761 return error(_("cannot abort from a branch yet to be born"));
918d1e6e 2762 return reset_merge(&head_oid);
043a4492
RR
2763}
2764
005af339 2765int sequencer_rollback(struct repository *r, struct replay_opts *opts)
043a4492 2766{
043a4492 2767 FILE *f;
092bbcdf 2768 struct object_id oid;
043a4492 2769 struct strbuf buf = STRBUF_INIT;
092bbcdf 2770 const char *p;
043a4492 2771
f932729c 2772 f = fopen(git_path_head_file(), "r");
043a4492
RR
2773 if (!f && errno == ENOENT) {
2774 /*
2775 * There is no multiple-cherry-pick in progress.
2776 * If CHERRY_PICK_HEAD or REVERT_HEAD indicates
2777 * a single-cherry-pick in progress, abort that.
2778 */
005af339 2779 return rollback_single_pick(r);
043a4492
RR
2780 }
2781 if (!f)
f7ed1953 2782 return error_errno(_("cannot open '%s'"), git_path_head_file());
8f309aeb 2783 if (strbuf_getline_lf(&buf, f)) {
f7ed1953 2784 error(_("cannot read '%s': %s"), git_path_head_file(),
f932729c 2785 ferror(f) ? strerror(errno) : _("unexpected end of file"));
043a4492
RR
2786 fclose(f);
2787 goto fail;
2788 }
2789 fclose(f);
092bbcdf 2790 if (parse_oid_hex(buf.buf, &oid, &p) || *p != '\0') {
043a4492 2791 error(_("stored pre-cherry-pick HEAD file '%s' is corrupt"),
f932729c 2792 git_path_head_file());
043a4492
RR
2793 goto fail;
2794 }
092bbcdf 2795 if (is_null_oid(&oid)) {
0f974e21
MG
2796 error(_("cannot abort from a branch yet to be born"));
2797 goto fail;
2798 }
1e41229d
SB
2799
2800 if (!rollback_is_safe()) {
2801 /* Do not error, just do not rollback */
2802 warning(_("You seem to have moved HEAD. "
2803 "Not rewinding, check your HEAD!"));
2804 } else
918d1e6e 2805 if (reset_merge(&oid))
043a4492 2806 goto fail;
043a4492 2807 strbuf_release(&buf);
2863584f 2808 return sequencer_remove_state(opts);
043a4492
RR
2809fail:
2810 strbuf_release(&buf);
2811 return -1;
2812}
2813
004fefa7 2814static int save_todo(struct todo_list *todo_list, struct replay_opts *opts)
043a4492 2815{
14bca6c6 2816 struct lock_file todo_lock = LOCK_INIT;
004fefa7
JS
2817 const char *todo_path = get_todo_path(opts);
2818 int next = todo_list->current, offset, fd;
043a4492 2819
84583957
JS
2820 /*
2821 * rebase -i writes "git-rebase-todo" without the currently executing
2822 * command, appending it to "done" instead.
2823 */
2824 if (is_rebase_i(opts))
2825 next++;
2826
004fefa7 2827 fd = hold_lock_file_for_update(&todo_lock, todo_path, 0);
221675de 2828 if (fd < 0)
93b3df6f 2829 return error_errno(_("could not lock '%s'"), todo_path);
a01c2a5f 2830 offset = get_item_line_offset(todo_list, next);
004fefa7
JS
2831 if (write_in_full(fd, todo_list->buf.buf + offset,
2832 todo_list->buf.len - offset) < 0)
93b3df6f 2833 return error_errno(_("could not write to '%s'"), todo_path);
004fefa7 2834 if (commit_lock_file(&todo_lock) < 0)
350292a1 2835 return error(_("failed to finalize '%s'"), todo_path);
1df6df0c 2836
a01c2a5f
JS
2837 if (is_rebase_i(opts) && next > 0) {
2838 const char *done = rebase_path_done();
2839 int fd = open(done, O_CREAT | O_WRONLY | O_APPEND, 0666);
2840 int ret = 0;
1df6df0c 2841
a01c2a5f
JS
2842 if (fd < 0)
2843 return 0;
2844 if (write_in_full(fd, get_item_line(todo_list, next - 1),
2845 get_item_line_length(todo_list, next - 1))
2846 < 0)
2847 ret = error_errno(_("could not write to '%s'"), done);
2848 if (close(fd) < 0)
2849 ret = error_errno(_("failed to finalize '%s'"), done);
2850 return ret;
1df6df0c 2851 }
221675de 2852 return 0;
043a4492
RR
2853}
2854
88d5a271 2855static int save_opts(struct replay_opts *opts)
043a4492 2856{
f932729c 2857 const char *opts_file = git_path_opts_file();
88d5a271 2858 int res = 0;
043a4492
RR
2859
2860 if (opts->no_commit)
f59199d5
PW
2861 res |= git_config_set_in_file_gently(opts_file,
2862 "options.no-commit", "true");
043a4492 2863 if (opts->edit)
f59199d5
PW
2864 res |= git_config_set_in_file_gently(opts_file,
2865 "options.edit", "true");
6860ce5d
PW
2866 if (opts->allow_empty)
2867 res |= git_config_set_in_file_gently(opts_file,
2868 "options.allow-empty", "true");
2869 if (opts->allow_empty_message)
2870 res |= git_config_set_in_file_gently(opts_file,
2871 "options.allow-empty-message", "true");
2872 if (opts->keep_redundant_commits)
2873 res |= git_config_set_in_file_gently(opts_file,
2874 "options.keep-redundant-commits", "true");
043a4492 2875 if (opts->signoff)
f59199d5
PW
2876 res |= git_config_set_in_file_gently(opts_file,
2877 "options.signoff", "true");
043a4492 2878 if (opts->record_origin)
f59199d5
PW
2879 res |= git_config_set_in_file_gently(opts_file,
2880 "options.record-origin", "true");
043a4492 2881 if (opts->allow_ff)
f59199d5
PW
2882 res |= git_config_set_in_file_gently(opts_file,
2883 "options.allow-ff", "true");
043a4492
RR
2884 if (opts->mainline) {
2885 struct strbuf buf = STRBUF_INIT;
2886 strbuf_addf(&buf, "%d", opts->mainline);
f59199d5
PW
2887 res |= git_config_set_in_file_gently(opts_file,
2888 "options.mainline", buf.buf);
043a4492
RR
2889 strbuf_release(&buf);
2890 }
2891 if (opts->strategy)
f59199d5
PW
2892 res |= git_config_set_in_file_gently(opts_file,
2893 "options.strategy", opts->strategy);
3253553e 2894 if (opts->gpg_sign)
f59199d5
PW
2895 res |= git_config_set_in_file_gently(opts_file,
2896 "options.gpg-sign", opts->gpg_sign);
043a4492
RR
2897 if (opts->xopts) {
2898 int i;
2899 for (i = 0; i < opts->xopts_nr; i++)
88d5a271 2900 res |= git_config_set_multivar_in_file_gently(opts_file,
f59199d5
PW
2901 "options.strategy-option",
2902 opts->xopts[i], "^$", 0);
043a4492 2903 }
8d8cb4b0 2904 if (opts->allow_rerere_auto)
f59199d5
PW
2905 res |= git_config_set_in_file_gently(opts_file,
2906 "options.allow-rerere-auto",
2907 opts->allow_rerere_auto == RERERE_AUTOUPDATE ?
2908 "true" : "false");
dc42e9a8
PW
2909
2910 if (opts->explicit_cleanup)
2911 res |= git_config_set_in_file_gently(opts_file,
2912 "options.default-msg-cleanup",
2913 describe_cleanup_mode(opts->default_msg_cleanup));
88d5a271 2914 return res;
043a4492
RR
2915}
2916
f11c9580
NTND
2917static int make_patch(struct repository *r,
2918 struct commit *commit,
2919 struct replay_opts *opts)
56dc3ab0
JS
2920{
2921 struct strbuf buf = STRBUF_INIT;
2922 struct rev_info log_tree_opt;
2923 const char *subject, *p;
2924 int res = 0;
2925
2926 p = short_commit_name(commit);
2927 if (write_message(p, strlen(p), rebase_path_stopped_sha(), 1) < 0)
2928 return -1;
fbd7a232
NTND
2929 if (update_ref("rebase", "REBASE_HEAD", &commit->object.oid,
2930 NULL, REF_NO_DEREF, UPDATE_REFS_MSG_ON_ERR))
2931 res |= error(_("could not update %s"), "REBASE_HEAD");
56dc3ab0
JS
2932
2933 strbuf_addf(&buf, "%s/patch", get_dir(opts));
2934 memset(&log_tree_opt, 0, sizeof(log_tree_opt));
f11c9580 2935 repo_init_revisions(r, &log_tree_opt, NULL);
56dc3ab0
JS
2936 log_tree_opt.abbrev = 0;
2937 log_tree_opt.diff = 1;
2938 log_tree_opt.diffopt.output_format = DIFF_FORMAT_PATCH;
2939 log_tree_opt.disable_stdin = 1;
2940 log_tree_opt.no_commit_id = 1;
2941 log_tree_opt.diffopt.file = fopen(buf.buf, "w");
2942 log_tree_opt.diffopt.use_color = GIT_COLOR_NEVER;
2943 if (!log_tree_opt.diffopt.file)
2944 res |= error_errno(_("could not open '%s'"), buf.buf);
2945 else {
2946 res |= log_tree_commit(&log_tree_opt, commit);
2947 fclose(log_tree_opt.diffopt.file);
2948 }
2949 strbuf_reset(&buf);
2950
2951 strbuf_addf(&buf, "%s/message", get_dir(opts));
2952 if (!file_exists(buf.buf)) {
2953 const char *commit_buffer = get_commit_buffer(commit, NULL);
2954 find_commit_subject(commit_buffer, &subject);
2955 res |= write_message(subject, strlen(subject), buf.buf, 1);
2956 unuse_commit_buffer(commit, commit_buffer);
2957 }
2958 strbuf_release(&buf);
2959
2960 return res;
2961}
2962
2963static int intend_to_amend(void)
2964{
092bbcdf 2965 struct object_id head;
56dc3ab0
JS
2966 char *p;
2967
092bbcdf 2968 if (get_oid("HEAD", &head))
56dc3ab0
JS
2969 return error(_("cannot read HEAD"));
2970
092bbcdf 2971 p = oid_to_hex(&head);
56dc3ab0
JS
2972 return write_message(p, strlen(p), rebase_path_amend(), 1);
2973}
2974
f11c9580
NTND
2975static int error_with_patch(struct repository *r,
2976 struct commit *commit,
2977 const char *subject, int subject_len,
2978 struct replay_opts *opts,
2979 int exit_code, int to_amend)
56dc3ab0 2980{
bc9238bb 2981 if (commit) {
f11c9580 2982 if (make_patch(r, commit, opts))
bc9238bb 2983 return -1;
5a5c5e95 2984 } else if (copy_file(rebase_path_message(),
f11c9580 2985 git_path_merge_msg(r), 0666))
bc9238bb 2986 return error(_("unable to copy '%s' to '%s'"),
f11c9580 2987 git_path_merge_msg(r), rebase_path_message());
56dc3ab0
JS
2988
2989 if (to_amend) {
2990 if (intend_to_amend())
2991 return -1;
2992
02127c63
NTND
2993 fprintf(stderr,
2994 _("You can amend the commit now, with\n"
2995 "\n"
2996 " git commit --amend %s\n"
2997 "\n"
2998 "Once you are satisfied with your changes, run\n"
2999 "\n"
3000 " git rebase --continue\n"),
3001 gpg_sign_opt_quoted(opts));
bc9238bb
PW
3002 } else if (exit_code) {
3003 if (commit)
5a5c5e95
JH
3004 fprintf_ln(stderr, _("Could not apply %s... %.*s"),
3005 short_commit_name(commit), subject_len, subject);
bc9238bb
PW
3006 else
3007 /*
3008 * We don't have the hash of the parent so
3009 * just print the line from the todo file.
3010 */
5a5c5e95
JH
3011 fprintf_ln(stderr, _("Could not merge %.*s"),
3012 subject_len, subject);
bc9238bb 3013 }
56dc3ab0
JS
3014
3015 return exit_code;
3016}
3017
f11c9580
NTND
3018static int error_failed_squash(struct repository *r,
3019 struct commit *commit,
3020 struct replay_opts *opts,
3021 int subject_len,
3022 const char *subject)
6e98de72 3023{
e12a7ef5
JS
3024 if (copy_file(rebase_path_message(), rebase_path_squash_msg(), 0666))
3025 return error(_("could not copy '%s' to '%s'"),
6e98de72 3026 rebase_path_squash_msg(), rebase_path_message());
f11c9580
NTND
3027 unlink(git_path_merge_msg(r));
3028 if (copy_file(git_path_merge_msg(r), rebase_path_message(), 0666))
6e98de72 3029 return error(_("could not copy '%s' to '%s'"),
102de880 3030 rebase_path_message(),
f11c9580
NTND
3031 git_path_merge_msg(r));
3032 return error_with_patch(r, commit, subject, subject_len, opts, 1, 0);
6e98de72
JS
3033}
3034
f11c9580 3035static int do_exec(struct repository *r, const char *command_line)
311af526 3036{
09d7b6c6 3037 struct argv_array child_env = ARGV_ARRAY_INIT;
311af526
JS
3038 const char *child_argv[] = { NULL, NULL };
3039 int dirty, status;
3040
3041 fprintf(stderr, "Executing: %s\n", command_line);
3042 child_argv[0] = command_line;
09d7b6c6 3043 argv_array_pushf(&child_env, "GIT_DIR=%s", absolute_path(get_git_dir()));
ab5e67d7 3044 argv_array_pushf(&child_env, "GIT_WORK_TREE=%s",
3045 absolute_path(get_git_work_tree()));
09d7b6c6
JK
3046 status = run_command_v_opt_cd_env(child_argv, RUN_USING_SHELL, NULL,
3047 child_env.argv);
311af526
JS
3048
3049 /* force re-reading of the cache */
e1ff0a32 3050 if (discard_index(r->index) < 0 || repo_read_index(r) < 0)
311af526
JS
3051 return error(_("could not read index"));
3052
f11c9580 3053 dirty = require_clean_work_tree(r, "rebase", NULL, 1, 1);
311af526
JS
3054
3055 if (status) {
3056 warning(_("execution failed: %s\n%s"
3057 "You can fix the problem, and then run\n"
3058 "\n"
3059 " git rebase --continue\n"
3060 "\n"),
3061 command_line,
3062 dirty ? N_("and made changes to the index and/or the "
3063 "working tree\n") : "");
3064 if (status == 127)
3065 /* command not found */
3066 status = 1;
3067 } else if (dirty) {
3068 warning(_("execution succeeded: %s\nbut "
3069 "left changes to the index and/or the working tree\n"
3070 "Commit or stash your changes, and then run\n"
3071 "\n"
3072 " git rebase --continue\n"
3073 "\n"), command_line);
3074 status = 1;
3075 }
3076
09d7b6c6
JK
3077 argv_array_clear(&child_env);
3078
311af526
JS
3079 return status;
3080}
3081
9055e401
JS
3082static int safe_append(const char *filename, const char *fmt, ...)
3083{
3084 va_list ap;
3085 struct lock_file lock = LOCK_INIT;
3086 int fd = hold_lock_file_for_update(&lock, filename,
3087 LOCK_REPORT_ON_ERROR);
3088 struct strbuf buf = STRBUF_INIT;
3089
3090 if (fd < 0)
3091 return -1;
3092
3093 if (strbuf_read_file(&buf, filename, 0) < 0 && errno != ENOENT) {
3094 error_errno(_("could not read '%s'"), filename);
3095 rollback_lock_file(&lock);
3096 return -1;
3097 }
3098 strbuf_complete(&buf, '\n');
3099 va_start(ap, fmt);
3100 strbuf_vaddf(&buf, fmt, ap);
3101 va_end(ap);
3102
3103 if (write_in_full(fd, buf.buf, buf.len) < 0) {
3104 error_errno(_("could not write to '%s'"), filename);
3105 strbuf_release(&buf);
3106 rollback_lock_file(&lock);
3107 return -1;
3108 }
3109 if (commit_lock_file(&lock) < 0) {
3110 strbuf_release(&buf);
3111 rollback_lock_file(&lock);
3112 return error(_("failed to finalize '%s'"), filename);
3113 }
3114
3115 strbuf_release(&buf);
3116 return 0;
3117}
3118
f11c9580 3119static int do_label(struct repository *r, const char *name, int len)
9055e401 3120{
f11c9580 3121 struct ref_store *refs = get_main_ref_store(r);
9055e401
JS
3122 struct ref_transaction *transaction;
3123 struct strbuf ref_name = STRBUF_INIT, err = STRBUF_INIT;
3124 struct strbuf msg = STRBUF_INIT;
3125 int ret = 0;
3126 struct object_id head_oid;
3127
3128 if (len == 1 && *name == '#')
02127c63 3129 return error(_("illegal label name: '%.*s'"), len, name);
9055e401
JS
3130
3131 strbuf_addf(&ref_name, "refs/rewritten/%.*s", len, name);
3132 strbuf_addf(&msg, "rebase -i (label) '%.*s'", len, name);
3133
3134 transaction = ref_store_transaction_begin(refs, &err);
3135 if (!transaction) {
3136 error("%s", err.buf);
3137 ret = -1;
3138 } else if (get_oid("HEAD", &head_oid)) {
3139 error(_("could not read HEAD"));
3140 ret = -1;
3141 } else if (ref_transaction_update(transaction, ref_name.buf, &head_oid,
3142 NULL, 0, msg.buf, &err) < 0 ||
3143 ref_transaction_commit(transaction, &err)) {
3144 error("%s", err.buf);
3145 ret = -1;
3146 }
3147 ref_transaction_free(transaction);
3148 strbuf_release(&err);
3149 strbuf_release(&msg);
3150
3151 if (!ret)
3152 ret = safe_append(rebase_path_refs_to_delete(),
3153 "%s\n", ref_name.buf);
3154 strbuf_release(&ref_name);
3155
3156 return ret;
3157}
3158
3159static const char *reflog_message(struct replay_opts *opts,
3160 const char *sub_action, const char *fmt, ...);
3161
f11c9580
NTND
3162static int do_reset(struct repository *r,
3163 const char *name, int len,
3164 struct replay_opts *opts)
9055e401
JS
3165{
3166 struct strbuf ref_name = STRBUF_INIT;
3167 struct object_id oid;
3168 struct lock_file lock = LOCK_INIT;
3169 struct tree_desc desc;
3170 struct tree *tree;
3171 struct unpack_trees_options unpack_tree_opts;
71571cd7 3172 int ret = 0;
9055e401 3173
3a95f31d 3174 if (repo_hold_locked_index(r, &lock, LOCK_REPORT_ON_ERROR) < 0)
9055e401
JS
3175 return -1;
3176
ebddf393
JS
3177 if (len == 10 && !strncmp("[new root]", name, len)) {
3178 if (!opts->have_squash_onto) {
3179 const char *hex;
3180 if (commit_tree("", 0, the_hash_algo->empty_tree,
3181 NULL, &opts->squash_onto,
3182 NULL, NULL))
3183 return error(_("writing fake root commit"));
3184 opts->have_squash_onto = 1;
3185 hex = oid_to_hex(&opts->squash_onto);
3186 if (write_message(hex, strlen(hex),
3187 rebase_path_squash_onto(), 0))
3188 return error(_("writing squash-onto"));
3189 }
3190 oidcpy(&oid, &opts->squash_onto);
3191 } else {
71571cd7
3192 int i;
3193
ebddf393
JS
3194 /* Determine the length of the label */
3195 for (i = 0; i < len; i++)
3196 if (isspace(name[i]))
71571cd7
3197 break;
3198 len = i;
ebddf393
JS
3199
3200 strbuf_addf(&ref_name, "refs/rewritten/%.*s", len, name);
3201 if (get_oid(ref_name.buf, &oid) &&
3202 get_oid(ref_name.buf + strlen("refs/rewritten/"), &oid)) {
3203 error(_("could not read '%s'"), ref_name.buf);
3204 rollback_lock_file(&lock);
3205 strbuf_release(&ref_name);
3206 return -1;
3207 }
9055e401
JS
3208 }
3209
3210 memset(&unpack_tree_opts, 0, sizeof(unpack_tree_opts));
3211 setup_unpack_trees_porcelain(&unpack_tree_opts, "reset");
3212 unpack_tree_opts.head_idx = 1;
f11c9580
NTND
3213 unpack_tree_opts.src_index = r->index;
3214 unpack_tree_opts.dst_index = r->index;
9055e401
JS
3215 unpack_tree_opts.fn = oneway_merge;
3216 unpack_tree_opts.merge = 1;
3217 unpack_tree_opts.update = 1;
3218
e1ff0a32 3219 if (repo_read_index_unmerged(r)) {
9055e401
JS
3220 rollback_lock_file(&lock);
3221 strbuf_release(&ref_name);
3222 return error_resolve_conflict(_(action_name(opts)));
3223 }
3224
3225 if (!fill_tree_descriptor(&desc, &oid)) {
3226 error(_("failed to find tree of %s"), oid_to_hex(&oid));
3227 rollback_lock_file(&lock);
3228 free((void *)desc.buffer);
3229 strbuf_release(&ref_name);
3230 return -1;
3231 }
3232
3233 if (unpack_trees(1, &desc, &unpack_tree_opts)) {
3234 rollback_lock_file(&lock);
3235 free((void *)desc.buffer);
3236 strbuf_release(&ref_name);
3237 return -1;
3238 }
3239
3240 tree = parse_tree_indirect(&oid);
c207e9e1 3241 prime_cache_tree(r, r->index, tree);
9055e401 3242
f11c9580 3243 if (write_locked_index(r->index, &lock, COMMIT_LOCK) < 0)
9055e401
JS
3244 ret = error(_("could not write index"));
3245 free((void *)desc.buffer);
3246
3247 if (!ret)
3248 ret = update_ref(reflog_message(opts, "reset", "'%.*s'",
3249 len, name), "HEAD", &oid,
3250 NULL, 0, UPDATE_REFS_MSG_ON_ERR);
3251
3252 strbuf_release(&ref_name);
3253 return ret;
3254}
3255
2b6ad0f4
JS
3256static struct commit *lookup_label(const char *label, int len,
3257 struct strbuf *buf)
3258{
3259 struct commit *commit;
3260
3261 strbuf_reset(buf);
3262 strbuf_addf(buf, "refs/rewritten/%.*s", len, label);
3263 commit = lookup_commit_reference_by_name(buf->buf);
3264 if (!commit) {
3265 /* fall back to non-rewritten ref or commit */
3266 strbuf_splice(buf, 0, strlen("refs/rewritten/"), "", 0);
3267 commit = lookup_commit_reference_by_name(buf->buf);
3268 }
3269
3270 if (!commit)
3271 error(_("could not resolve '%s'"), buf->buf);
3272
3273 return commit;
3274}
3275
f11c9580
NTND
3276static int do_merge(struct repository *r,
3277 struct commit *commit,
3278 const char *arg, int arg_len,
4c68e7dd
JS
3279 int flags, struct replay_opts *opts)
3280{
3281 int run_commit_flags = (flags & TODO_EDIT_MERGE_MSG) ?
3282 EDIT_MSG | VERIFY_MSG : 0;
3283 struct strbuf ref_name = STRBUF_INIT;
3284 struct commit *head_commit, *merge_commit, *i;
3285 struct commit_list *bases, *j, *reversed = NULL;
2b6ad0f4 3286 struct commit_list *to_merge = NULL, **tail = &to_merge;
4c68e7dd 3287 struct merge_options o;
2b6ad0f4 3288 int merge_arg_len, oneline_offset, can_fast_forward, ret, k;
4c68e7dd
JS
3289 static struct lock_file lock;
3290 const char *p;
3291
3a95f31d 3292 if (repo_hold_locked_index(r, &lock, LOCK_REPORT_ON_ERROR) < 0) {
4c68e7dd
JS
3293 ret = -1;
3294 goto leave_merge;
3295 }
3296
3297 head_commit = lookup_commit_reference_by_name("HEAD");
3298 if (!head_commit) {
3299 ret = error(_("cannot merge without a current revision"));
3300 goto leave_merge;
3301 }
3302
2b6ad0f4
JS
3303 /*
3304 * For octopus merges, the arg starts with the list of revisions to be
3305 * merged. The list is optionally followed by '#' and the oneline.
3306 */
3307 merge_arg_len = oneline_offset = arg_len;
3308 for (p = arg; p - arg < arg_len; p += strspn(p, " \t\n")) {
3309 if (!*p)
3310 break;
3311 if (*p == '#' && (!p[1] || isspace(p[1]))) {
3312 p += 1 + strspn(p + 1, " \t\n");
3313 oneline_offset = p - arg;
3314 break;
3315 }
3316 k = strcspn(p, " \t\n");
3317 if (!k)
3318 continue;
3319 merge_commit = lookup_label(p, k, &ref_name);
3320 if (!merge_commit) {
3321 ret = error(_("unable to parse '%.*s'"), k, p);
3322 goto leave_merge;
3323 }
3324 tail = &commit_list_insert(merge_commit, tail)->next;
3325 p += k;
3326 merge_arg_len = p - arg;
4c68e7dd
JS
3327 }
3328
2b6ad0f4
JS
3329 if (!to_merge) {
3330 ret = error(_("nothing to merge: '%.*s'"), arg_len, arg);
4c68e7dd
JS
3331 goto leave_merge;
3332 }
3333
9c85a1c2 3334 if (opts->have_squash_onto &&
4a7e27e9 3335 oideq(&head_commit->object.oid, &opts->squash_onto)) {
9c85a1c2
JS
3336 /*
3337 * When the user tells us to "merge" something into a
3338 * "[new root]", let's simply fast-forward to the merge head.
3339 */
3340 rollback_lock_file(&lock);
2b6ad0f4
JS
3341 if (to_merge->next)
3342 ret = error(_("octopus merge cannot be executed on "
3343 "top of a [new root]"));
3344 else
f11c9580 3345 ret = fast_forward_to(r, &to_merge->item->object.oid,
2b6ad0f4
JS
3346 &head_commit->object.oid, 0,
3347 opts);
9c85a1c2
JS
3348 goto leave_merge;
3349 }
3350
4c68e7dd
JS
3351 if (commit) {
3352 const char *message = get_commit_buffer(commit, NULL);
3353 const char *body;
3354 int len;
3355
3356 if (!message) {
3357 ret = error(_("could not get commit message of '%s'"),
3358 oid_to_hex(&commit->object.oid));
3359 goto leave_merge;
3360 }
3361 write_author_script(message);
3362 find_commit_subject(message, &body);
3363 len = strlen(body);
f11c9580 3364 ret = write_message(body, len, git_path_merge_msg(r), 0);
4c68e7dd
JS
3365 unuse_commit_buffer(commit, message);
3366 if (ret) {
3367 error_errno(_("could not write '%s'"),
f11c9580 3368 git_path_merge_msg(r));
4c68e7dd
JS
3369 goto leave_merge;
3370 }
3371 } else {
3372 struct strbuf buf = STRBUF_INIT;
3373 int len;
3374
3375 strbuf_addf(&buf, "author %s", git_author_info(0));
3376 write_author_script(buf.buf);
3377 strbuf_reset(&buf);
3378
3379 if (oneline_offset < arg_len) {
3380 p = arg + oneline_offset;
3381 len = arg_len - oneline_offset;
3382 } else {
2b6ad0f4
JS
3383 strbuf_addf(&buf, "Merge %s '%.*s'",
3384 to_merge->next ? "branches" : "branch",
4c68e7dd
JS
3385 merge_arg_len, arg);
3386 p = buf.buf;
3387 len = buf.len;
3388 }
3389
f11c9580 3390 ret = write_message(p, len, git_path_merge_msg(r), 0);
4c68e7dd
JS
3391 strbuf_release(&buf);
3392 if (ret) {
3393 error_errno(_("could not write '%s'"),
f11c9580 3394 git_path_merge_msg(r));
4c68e7dd
JS
3395 goto leave_merge;
3396 }
3397 }
3398
d1e8b011
JS
3399 /*
3400 * If HEAD is not identical to the first parent of the original merge
3401 * commit, we cannot fast-forward.
3402 */
3403 can_fast_forward = opts->allow_ff && commit && commit->parents &&
4a7e27e9
JK
3404 oideq(&commit->parents->item->object.oid,
3405 &head_commit->object.oid);
d1e8b011
JS
3406
3407 /*
2b6ad0f4 3408 * If any merge head is different from the original one, we cannot
d1e8b011
JS
3409 * fast-forward.
3410 */
3411 if (can_fast_forward) {
2b6ad0f4 3412 struct commit_list *p = commit->parents->next;
d1e8b011 3413
2b6ad0f4 3414 for (j = to_merge; j && p; j = j->next, p = p->next)
9001dc2a 3415 if (!oideq(&j->item->object.oid,
2b6ad0f4
JS
3416 &p->item->object.oid)) {
3417 can_fast_forward = 0;
3418 break;
3419 }
3420 /*
3421 * If the number of merge heads differs from the original merge
3422 * commit, we cannot fast-forward.
3423 */
3424 if (j || p)
d1e8b011
JS
3425 can_fast_forward = 0;
3426 }
3427
2b6ad0f4 3428 if (can_fast_forward) {
d1e8b011 3429 rollback_lock_file(&lock);
f11c9580 3430 ret = fast_forward_to(r, &commit->object.oid,
d1e8b011 3431 &head_commit->object.oid, 0, opts);
6df8df08
PW
3432 if (flags & TODO_EDIT_MERGE_MSG) {
3433 run_commit_flags |= AMEND_MSG;
3434 goto fast_forward_edit;
3435 }
d1e8b011
JS
3436 goto leave_merge;
3437 }
3438
2b6ad0f4
JS
3439 if (to_merge->next) {
3440 /* Octopus merge */
3441 struct child_process cmd = CHILD_PROCESS_INIT;
3442
3443 if (read_env_script(&cmd.env_array)) {
3444 const char *gpg_opt = gpg_sign_opt_quoted(opts);
3445
3446 ret = error(_(staged_changes_advice), gpg_opt, gpg_opt);
3447 goto leave_merge;
3448 }
3449
3450 cmd.git_cmd = 1;
3451 argv_array_push(&cmd.args, "merge");
3452 argv_array_push(&cmd.args, "-s");
3453 argv_array_push(&cmd.args, "octopus");
3454 argv_array_push(&cmd.args, "--no-edit");
3455 argv_array_push(&cmd.args, "--no-ff");
3456 argv_array_push(&cmd.args, "--no-log");
3457 argv_array_push(&cmd.args, "--no-stat");
3458 argv_array_push(&cmd.args, "-F");
f11c9580 3459 argv_array_push(&cmd.args, git_path_merge_msg(r));
2b6ad0f4
JS
3460 if (opts->gpg_sign)
3461 argv_array_push(&cmd.args, opts->gpg_sign);
3462
3463 /* Add the tips to be merged */
3464 for (j = to_merge; j; j = j->next)
3465 argv_array_push(&cmd.args,
3466 oid_to_hex(&j->item->object.oid));
3467
3468 strbuf_release(&ref_name);
f11c9580 3469 unlink(git_path_cherry_pick_head(r));
2b6ad0f4
JS
3470 rollback_lock_file(&lock);
3471
3472 rollback_lock_file(&lock);
3473 ret = run_command(&cmd);
3474
3475 /* force re-reading of the cache */
f11c9580 3476 if (!ret && (discard_index(r->index) < 0 ||
e1ff0a32 3477 repo_read_index(r) < 0))
2b6ad0f4
JS
3478 ret = error(_("could not read index"));
3479 goto leave_merge;
3480 }
3481
3482 merge_commit = to_merge->item;
4c68e7dd 3483 bases = get_merge_bases(head_commit, merge_commit);
4a7e27e9
JK
3484 if (bases && oideq(&merge_commit->object.oid,
3485 &bases->item->object.oid)) {
7ccdf65b
JS
3486 ret = 0;
3487 /* skip merging an ancestor of HEAD */
3488 goto leave_merge;
3489 }
3490
85f8d9da 3491 write_message(oid_to_hex(&merge_commit->object.oid), GIT_SHA1_HEXSZ,
cde55548
JH
3492 git_path_merge_head(r), 0);
3493 write_message("no-ff", 5, git_path_merge_mode(r), 0);
85f8d9da 3494
4c68e7dd
JS
3495 for (j = bases; j; j = j->next)
3496 commit_list_insert(j->item, &reversed);
3497 free_commit_list(bases);
3498
e1ff0a32 3499 repo_read_index(r);
0d6caa2d 3500 init_merge_options(&o, r);
4c68e7dd
JS
3501 o.branch1 = "HEAD";
3502 o.branch2 = ref_name.buf;
3503 o.buffer_output = 2;
3504
3505 ret = merge_recursive(&o, head_commit, merge_commit, reversed, &i);
3506 if (ret <= 0)
3507 fputs(o.obuf.buf, stdout);
3508 strbuf_release(&o.obuf);
3509 if (ret < 0) {
3510 error(_("could not even attempt to merge '%.*s'"),
3511 merge_arg_len, arg);
3512 goto leave_merge;
3513 }
3514 /*
3515 * The return value of merge_recursive() is 1 on clean, and 0 on
3516 * unclean merge.
3517 *
3518 * Let's reverse that, so that do_merge() returns 0 upon success and
3519 * 1 upon failed merge (keeping the return value -1 for the cases where
3520 * we will want to reschedule the `merge` command).
3521 */
3522 ret = !ret;
3523
f11c9580
NTND
3524 if (r->index->cache_changed &&
3525 write_locked_index(r->index, &lock, COMMIT_LOCK)) {
4c68e7dd
JS
3526 ret = error(_("merge: Unable to write new index file"));
3527 goto leave_merge;
3528 }
3529
3530 rollback_lock_file(&lock);
3531 if (ret)
f11c9580 3532 repo_rerere(r, opts->allow_rerere_auto);
4c68e7dd
JS
3533 else
3534 /*
3535 * In case of problems, we now want to return a positive
3536 * value (a negative one would indicate that the `merge`
3537 * command needs to be rescheduled).
3538 */
6df8df08 3539 fast_forward_edit:
f11c9580
NTND
3540 ret = !!run_git_commit(r, git_path_merge_msg(r), opts,
3541 run_commit_flags);
4c68e7dd
JS
3542
3543leave_merge:
3544 strbuf_release(&ref_name);
3545 rollback_lock_file(&lock);
2b6ad0f4 3546 free_commit_list(to_merge);
4c68e7dd
JS
3547 return ret;
3548}
3549
6e98de72
JS
3550static int is_final_fixup(struct todo_list *todo_list)
3551{
3552 int i = todo_list->current;
3553
3554 if (!is_fixup(todo_list->items[i].command))
3555 return 0;
3556
3557 while (++i < todo_list->nr)
3558 if (is_fixup(todo_list->items[i].command))
3559 return 0;
3560 else if (!is_noop(todo_list->items[i].command))
3561 break;
3562 return 1;
3563}
3564
25cb8df9
JS
3565static enum todo_command peek_command(struct todo_list *todo_list, int offset)
3566{
3567 int i;
3568
3569 for (i = todo_list->current + offset; i < todo_list->nr; i++)
3570 if (!is_noop(todo_list->items[i].command))
3571 return todo_list->items[i].command;
3572
3573 return -1;
3574}
3575
796c7972
JS
3576static int apply_autostash(struct replay_opts *opts)
3577{
3578 struct strbuf stash_sha1 = STRBUF_INIT;
3579 struct child_process child = CHILD_PROCESS_INIT;
3580 int ret = 0;
3581
3582 if (!read_oneliner(&stash_sha1, rebase_path_autostash(), 1)) {
3583 strbuf_release(&stash_sha1);
3584 return 0;
3585 }
3586 strbuf_trim(&stash_sha1);
3587
3588 child.git_cmd = 1;
79a62269
PW
3589 child.no_stdout = 1;
3590 child.no_stderr = 1;
796c7972
JS
3591 argv_array_push(&child.args, "stash");
3592 argv_array_push(&child.args, "apply");
3593 argv_array_push(&child.args, stash_sha1.buf);
3594 if (!run_command(&child))
cdb866b3 3595 fprintf(stderr, _("Applied autostash.\n"));
796c7972
JS
3596 else {
3597 struct child_process store = CHILD_PROCESS_INIT;
3598
3599 store.git_cmd = 1;
3600 argv_array_push(&store.args, "stash");