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