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