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