sequencer: refactor transform_todos() to work on a todo_list
[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
1118void commit_post_rewrite(const struct commit *old_head,
1119 const struct object_id *new_head)
1120{
1121 struct notes_rewrite_cfg *cfg;
1122
1123 cfg = init_copy_notes_for_rewrite("amend");
1124 if (cfg) {
1125 /* we are amending, so old_head is not NULL */
1126 copy_note_for_rewrite(cfg, &old_head->object.oid, new_head);
1127 finish_copy_notes_for_rewrite(cfg, "Notes added by 'git commit --amend'");
1128 }
1129 run_rewrite_hook(&old_head->object.oid, new_head);
1130}
1131
f11c9580
NTND
1132static int run_prepare_commit_msg_hook(struct repository *r,
1133 struct strbuf *msg,
1134 const char *commit)
66618a50
PW
1135{
1136 struct argv_array hook_env = ARGV_ARRAY_INIT;
1137 int ret;
1138 const char *name;
1139
1140 name = git_path_commit_editmsg();
1141 if (write_message(msg->buf, msg->len, name, 0))
1142 return -1;
1143
f11c9580 1144 argv_array_pushf(&hook_env, "GIT_INDEX_FILE=%s", r->index_file);
66618a50
PW
1145 argv_array_push(&hook_env, "GIT_EDITOR=:");
1146 if (commit)
1147 ret = run_hook_le(hook_env.argv, "prepare-commit-msg", name,
1148 "commit", commit, NULL);
1149 else
1150 ret = run_hook_le(hook_env.argv, "prepare-commit-msg", name,
1151 "message", NULL);
1152 if (ret)
1153 ret = error(_("'prepare-commit-msg' hook failed"));
1154 argv_array_clear(&hook_env);
1155
1156 return ret;
1157}
1158
e47c6caf
PW
1159static const char implicit_ident_advice_noconfig[] =
1160N_("Your name and email address were configured automatically based\n"
1161"on your username and hostname. Please check that they are accurate.\n"
1162"You can suppress this message by setting them explicitly. Run the\n"
1163"following command and follow the instructions in your editor to edit\n"
1164"your configuration file:\n"
1165"\n"
1166" git config --global --edit\n"
1167"\n"
1168"After doing this, you may fix the identity used for this commit with:\n"
1169"\n"
1170" git commit --amend --reset-author\n");
1171
1172static const char implicit_ident_advice_config[] =
1173N_("Your name and email address were configured automatically based\n"
1174"on your username and hostname. Please check that they are accurate.\n"
1175"You can suppress this message by setting them explicitly:\n"
1176"\n"
1177" git config --global user.name \"Your Name\"\n"
1178" git config --global user.email you@example.com\n"
1179"\n"
1180"After doing this, you may fix the identity used for this commit with:\n"
1181"\n"
1182" git commit --amend --reset-author\n");
1183
1184static const char *implicit_ident_advice(void)
1185{
1186 char *user_config = expand_user_path("~/.gitconfig", 0);
1187 char *xdg_config = xdg_config_home("config");
1188 int config_exists = file_exists(user_config) || file_exists(xdg_config);
1189
1190 free(user_config);
1191 free(xdg_config);
1192
1193 if (config_exists)
1194 return _(implicit_ident_advice_config);
1195 else
1196 return _(implicit_ident_advice_noconfig);
1197
1198}
1199
f11c9580
NTND
1200void print_commit_summary(struct repository *r,
1201 const char *prefix,
1202 const struct object_id *oid,
e47c6caf
PW
1203 unsigned int flags)
1204{
1205 struct rev_info rev;
1206 struct commit *commit;
1207 struct strbuf format = STRBUF_INIT;
1208 const char *head;
1209 struct pretty_print_context pctx = {0};
1210 struct strbuf author_ident = STRBUF_INIT;
1211 struct strbuf committer_ident = STRBUF_INIT;
1212
f11c9580 1213 commit = lookup_commit(r, oid);
e47c6caf
PW
1214 if (!commit)
1215 die(_("couldn't look up newly created commit"));
1216 if (parse_commit(commit))
1217 die(_("could not parse newly created commit"));
1218
1219 strbuf_addstr(&format, "format:%h] %s");
1220
1221 format_commit_message(commit, "%an <%ae>", &author_ident, &pctx);
1222 format_commit_message(commit, "%cn <%ce>", &committer_ident, &pctx);
1223 if (strbuf_cmp(&author_ident, &committer_ident)) {
1224 strbuf_addstr(&format, "\n Author: ");
1225 strbuf_addbuf_percentquote(&format, &author_ident);
1226 }
1227 if (flags & SUMMARY_SHOW_AUTHOR_DATE) {
1228 struct strbuf date = STRBUF_INIT;
1229
1230 format_commit_message(commit, "%ad", &date, &pctx);
1231 strbuf_addstr(&format, "\n Date: ");
1232 strbuf_addbuf_percentquote(&format, &date);
1233 strbuf_release(&date);
1234 }
1235 if (!committer_ident_sufficiently_given()) {
1236 strbuf_addstr(&format, "\n Committer: ");
1237 strbuf_addbuf_percentquote(&format, &committer_ident);
1238 if (advice_implicit_identity) {
1239 strbuf_addch(&format, '\n');
1240 strbuf_addstr(&format, implicit_ident_advice());
1241 }
1242 }
1243 strbuf_release(&author_ident);
1244 strbuf_release(&committer_ident);
1245
f11c9580 1246 repo_init_revisions(r, &rev, prefix);
e47c6caf
PW
1247 setup_revisions(0, NULL, &rev, NULL);
1248
1249 rev.diff = 1;
1250 rev.diffopt.output_format =
1251 DIFF_FORMAT_SHORTSTAT | DIFF_FORMAT_SUMMARY;
1252
1253 rev.verbose_header = 1;
1254 rev.show_root_diff = 1;
1255 get_commit_format(format.buf, &rev);
1256 rev.always_show_header = 0;
0f57f731 1257 rev.diffopt.detect_rename = DIFF_DETECT_RENAME;
e47c6caf
PW
1258 rev.diffopt.break_opt = 0;
1259 diff_setup_done(&rev.diffopt);
1260
1261 head = resolve_ref_unsafe("HEAD", 0, NULL, NULL);
1262 if (!head)
1263 die_errno(_("unable to resolve HEAD after creating commit"));
1264 if (!strcmp(head, "HEAD"))
1265 head = _("detached HEAD");
1266 else
1267 skip_prefix(head, "refs/heads/", &head);
1268 printf("[%s%s ", head, (flags & SUMMARY_INITIAL_COMMIT) ?
1269 _(" (root-commit)") : "");
1270
1271 if (!log_tree_commit(&rev, commit)) {
1272 rev.always_show_header = 1;
1273 rev.use_terminator = 1;
1274 log_tree_commit(&rev, commit);
1275 }
1276
1277 strbuf_release(&format);
1278}
1279
005af339 1280static int parse_head(struct repository *r, struct commit **head)
356ee465
PW
1281{
1282 struct commit *current_head;
1283 struct object_id oid;
1284
1285 if (get_oid("HEAD", &oid)) {
1286 current_head = NULL;
1287 } else {
005af339 1288 current_head = lookup_commit_reference(r, &oid);
356ee465
PW
1289 if (!current_head)
1290 return error(_("could not parse HEAD"));
9001dc2a 1291 if (!oideq(&oid, &current_head->object.oid)) {
356ee465
PW
1292 warning(_("HEAD %s is not a commit!"),
1293 oid_to_hex(&oid));
1294 }
1295 if (parse_commit(current_head))
1296 return error(_("could not parse HEAD commit"));
1297 }
1298 *head = current_head;
1299
1300 return 0;
1301}
1302
1303/*
1304 * Try to commit without forking 'git commit'. In some cases we need
1305 * to run 'git commit' to display an error message
1306 *
1307 * Returns:
1308 * -1 - error unable to commit
1309 * 0 - success
1310 * 1 - run 'git commit'
1311 */
f11c9580
NTND
1312static int try_to_commit(struct repository *r,
1313 struct strbuf *msg, const char *author,
356ee465
PW
1314 struct replay_opts *opts, unsigned int flags,
1315 struct object_id *oid)
1316{
1317 struct object_id tree;
1318 struct commit *current_head;
1319 struct commit_list *parents = NULL;
1320 struct commit_extra_header *extra = NULL;
1321 struct strbuf err = STRBUF_INIT;
66618a50 1322 struct strbuf commit_msg = STRBUF_INIT;
356ee465 1323 char *amend_author = NULL;
66618a50 1324 const char *hook_commit = NULL;
356ee465
PW
1325 enum commit_msg_cleanup_mode cleanup;
1326 int res = 0;
1327
005af339 1328 if (parse_head(r, &current_head))
356ee465
PW
1329 return -1;
1330
1331 if (flags & AMEND_MSG) {
1332 const char *exclude_gpgsig[] = { "gpgsig", NULL };
1333 const char *out_enc = get_commit_output_encoding();
1334 const char *message = logmsg_reencode(current_head, NULL,
1335 out_enc);
1336
1337 if (!msg) {
1338 const char *orig_message = NULL;
1339
1340 find_commit_subject(message, &orig_message);
66618a50 1341 msg = &commit_msg;
356ee465 1342 strbuf_addstr(msg, orig_message);
66618a50 1343 hook_commit = "HEAD";
356ee465
PW
1344 }
1345 author = amend_author = get_author(message);
1346 unuse_commit_buffer(current_head, message);
1347 if (!author) {
1348 res = error(_("unable to parse commit author"));
1349 goto out;
1350 }
1351 parents = copy_commit_list(current_head->parents);
1352 extra = read_commit_extra_headers(current_head, exclude_gpgsig);
1353 } else if (current_head) {
1354 commit_list_insert(current_head, &parents);
1355 }
1356
f11c9580 1357 if (write_index_as_tree(&tree, r->index, r->index_file, 0, NULL)) {
356ee465
PW
1358 res = error(_("git write-tree failed to write a tree"));
1359 goto out;
1360 }
1361
4a7e27e9
JK
1362 if (!(flags & ALLOW_EMPTY) && oideq(current_head ?
1363 get_commit_tree_oid(current_head) :
1364 the_hash_algo->empty_tree, &tree)) {
356ee465
PW
1365 res = 1; /* run 'git commit' to display error message */
1366 goto out;
1367 }
1368
66618a50 1369 if (find_hook("prepare-commit-msg")) {
f11c9580 1370 res = run_prepare_commit_msg_hook(r, msg, hook_commit);
66618a50
PW
1371 if (res)
1372 goto out;
1373 if (strbuf_read_file(&commit_msg, git_path_commit_editmsg(),
1374 2048) < 0) {
1375 res = error_errno(_("unable to read commit message "
1376 "from '%s'"),
1377 git_path_commit_editmsg());
1378 goto out;
1379 }
1380 msg = &commit_msg;
1381 }
1382
1383 cleanup = (flags & CLEANUP_MSG) ? COMMIT_MSG_CLEANUP_ALL :
1384 opts->default_msg_cleanup;
1385
1386 if (cleanup != COMMIT_MSG_CLEANUP_NONE)
1387 strbuf_stripspace(msg, cleanup == COMMIT_MSG_CLEANUP_ALL);
a3ec9eaf 1388 if ((flags & EDIT_MSG) && message_is_empty(msg, cleanup)) {
66618a50
PW
1389 res = 1; /* run 'git commit' to display error message */
1390 goto out;
1391 }
1392
12f7babd
JS
1393 reset_ident_date();
1394
8be8342b
JH
1395 if (commit_tree_extended(msg->buf, msg->len, &tree, parents,
1396 oid, author, opts->gpg_sign, extra)) {
356ee465
PW
1397 res = error(_("failed to write commit object"));
1398 goto out;
1399 }
1400
1401 if (update_head_with_reflog(current_head, oid,
1402 getenv("GIT_REFLOG_ACTION"), msg, &err)) {
1403 res = error("%s", err.buf);
1404 goto out;
1405 }
1406
1407 if (flags & AMEND_MSG)
1408 commit_post_rewrite(current_head, oid);
1409
1410out:
1411 free_commit_extra_headers(extra);
1412 strbuf_release(&err);
66618a50 1413 strbuf_release(&commit_msg);
356ee465
PW
1414 free(amend_author);
1415
1416 return res;
1417}
1418
f11c9580
NTND
1419static int do_commit(struct repository *r,
1420 const char *msg_file, const char *author,
356ee465
PW
1421 struct replay_opts *opts, unsigned int flags)
1422{
1423 int res = 1;
1424
d87d48b2
JS
1425 if (!(flags & EDIT_MSG) && !(flags & VERIFY_MSG) &&
1426 !(flags & CREATE_ROOT_COMMIT)) {
356ee465
PW
1427 struct object_id oid;
1428 struct strbuf sb = STRBUF_INIT;
1429
1430 if (msg_file && strbuf_read_file(&sb, msg_file, 2048) < 0)
1431 return error_errno(_("unable to read commit message "
1432 "from '%s'"),
1433 msg_file);
1434
f11c9580
NTND
1435 res = try_to_commit(r, msg_file ? &sb : NULL,
1436 author, opts, flags, &oid);
356ee465
PW
1437 strbuf_release(&sb);
1438 if (!res) {
f11c9580
NTND
1439 unlink(git_path_cherry_pick_head(r));
1440 unlink(git_path_merge_msg(r));
356ee465 1441 if (!is_rebase_i(opts))
f11c9580 1442 print_commit_summary(r, NULL, &oid,
356ee465
PW
1443 SUMMARY_SHOW_AUTHOR_DATE);
1444 return res;
1445 }
1446 }
1447 if (res == 1)
f11c9580 1448 return run_git_commit(r, msg_file, opts, flags);
356ee465
PW
1449
1450 return res;
1451}
1452
b27cfb0d
NH
1453static int is_original_commit_empty(struct commit *commit)
1454{
092bbcdf 1455 const struct object_id *ptree_oid;
b27cfb0d
NH
1456
1457 if (parse_commit(commit))
aee42e1f 1458 return error(_("could not parse commit %s"),
f2fd0760 1459 oid_to_hex(&commit->object.oid));
b27cfb0d
NH
1460 if (commit->parents) {
1461 struct commit *parent = commit->parents->item;
1462 if (parse_commit(parent))
aee42e1f 1463 return error(_("could not parse parent commit %s"),
f2fd0760 1464 oid_to_hex(&parent->object.oid));
2e27bd77 1465 ptree_oid = get_commit_tree_oid(parent);
b27cfb0d 1466 } else {
eb0ccfd7 1467 ptree_oid = the_hash_algo->empty_tree; /* commit is root */
043a4492 1468 }
043a4492 1469
4a7e27e9 1470 return oideq(ptree_oid, get_commit_tree_oid(commit));
043a4492
RR
1471}
1472
ac2b0e8f
JH
1473/*
1474 * Do we run "git commit" with "--allow-empty"?
1475 */
f11c9580
NTND
1476static int allow_empty(struct repository *r,
1477 struct replay_opts *opts,
1478 struct commit *commit)
ac2b0e8f
JH
1479{
1480 int index_unchanged, empty_commit;
1481
1482 /*
1483 * Three cases:
1484 *
1485 * (1) we do not allow empty at all and error out.
1486 *
1487 * (2) we allow ones that were initially empty, but
1488 * forbid the ones that become empty;
1489 *
1490 * (3) we allow both.
1491 */
1492 if (!opts->allow_empty)
1493 return 0; /* let "git commit" barf as necessary */
1494
005af339 1495 index_unchanged = is_index_unchanged(r);
ac2b0e8f
JH
1496 if (index_unchanged < 0)
1497 return index_unchanged;
1498 if (!index_unchanged)
1499 return 0; /* we do not have to say --allow-empty */
1500
1501 if (opts->keep_redundant_commits)
1502 return 1;
1503
1504 empty_commit = is_original_commit_empty(commit);
1505 if (empty_commit < 0)
1506 return empty_commit;
1507 if (!empty_commit)
1508 return 0;
1509 else
1510 return 1;
1511}
1512
414697a9
JS
1513static struct {
1514 char c;
1515 const char *str;
1516} todo_command_info[] = {
1517 { 'p', "pick" },
1518 { 0, "revert" },
1519 { 'e', "edit" },
04efc8b5 1520 { 'r', "reword" },
414697a9
JS
1521 { 'f', "fixup" },
1522 { 's', "squash" },
1523 { 'x', "exec" },
71f82465 1524 { 'b', "break" },
9055e401
JS
1525 { 'l', "label" },
1526 { 't', "reset" },
4c68e7dd 1527 { 'm', "merge" },
b3fdd581 1528 { 0, "noop" },
ac191470
JS
1529 { 'd', "drop" },
1530 { 0, NULL }
004fefa7
JS
1531};
1532
1533static const char *command_to_string(const enum todo_command command)
1534{
ac191470 1535 if (command < TODO_COMMENT)
414697a9 1536 return todo_command_info[command].str;
02127c63 1537 die(_("unknown command: %d"), command);
004fefa7
JS
1538}
1539
ee5462d6 1540static char command_to_char(const enum todo_command command)
d8ae6c84
LB
1541{
1542 if (command < TODO_COMMENT && todo_command_info[command].c)
1543 return todo_command_info[command].c;
1544 return comment_line_char;
1545}
1546
25c43667
JS
1547static int is_noop(const enum todo_command command)
1548{
b3fdd581 1549 return TODO_NOOP <= command;
25c43667 1550}
004fefa7 1551
6e98de72
JS
1552static int is_fixup(enum todo_command command)
1553{
1554 return command == TODO_FIXUP || command == TODO_SQUASH;
1555}
1556
d87d48b2
JS
1557/* Does this command create a (non-merge) commit? */
1558static int is_pick_or_similar(enum todo_command command)
1559{
1560 switch (command) {
1561 case TODO_PICK:
1562 case TODO_REVERT:
1563 case TODO_EDIT:
1564 case TODO_REWORD:
1565 case TODO_FIXUP:
1566 case TODO_SQUASH:
1567 return 1;
1568 default:
1569 return 0;
1570 }
1571}
1572
005af339
NTND
1573static int update_squash_messages(struct repository *r,
1574 enum todo_command command,
1575 struct commit *commit,
1576 struct replay_opts *opts)
6e98de72
JS
1577{
1578 struct strbuf buf = STRBUF_INIT;
e12a7ef5 1579 int res;
6e98de72
JS
1580 const char *message, *body;
1581
e12a7ef5 1582 if (opts->current_fixup_count > 0) {
6e98de72 1583 struct strbuf header = STRBUF_INIT;
e12a7ef5 1584 char *eol;
6e98de72 1585
e12a7ef5 1586 if (strbuf_read_file(&buf, rebase_path_squash_msg(), 9) <= 0)
6e98de72
JS
1587 return error(_("could not read '%s'"),
1588 rebase_path_squash_msg());
1589
e12a7ef5
JS
1590 eol = buf.buf[0] != comment_line_char ?
1591 buf.buf : strchrnul(buf.buf, '\n');
6e98de72
JS
1592
1593 strbuf_addf(&header, "%c ", comment_line_char);
e12a7ef5
JS
1594 strbuf_addf(&header, _("This is a combination of %d commits."),
1595 opts->current_fixup_count + 2);
6e98de72
JS
1596 strbuf_splice(&buf, 0, eol - buf.buf, header.buf, header.len);
1597 strbuf_release(&header);
1598 } else {
33d66df3 1599 struct object_id head;
6e98de72
JS
1600 struct commit *head_commit;
1601 const char *head_message, *body;
1602
33d66df3 1603 if (get_oid("HEAD", &head))
6e98de72 1604 return error(_("need a HEAD to fixup"));
005af339 1605 if (!(head_commit = lookup_commit_reference(r, &head)))
6e98de72
JS
1606 return error(_("could not read HEAD"));
1607 if (!(head_message = get_commit_buffer(head_commit, NULL)))
1608 return error(_("could not read HEAD's commit message"));
1609
1610 find_commit_subject(head_message, &body);
1611 if (write_message(body, strlen(body),
1612 rebase_path_fixup_msg(), 0)) {
1613 unuse_commit_buffer(head_commit, head_message);
1614 return error(_("cannot write '%s'"),
1615 rebase_path_fixup_msg());
1616 }
1617
6e98de72 1618 strbuf_addf(&buf, "%c ", comment_line_char);
e12a7ef5 1619 strbuf_addf(&buf, _("This is a combination of %d commits."), 2);
6e98de72
JS
1620 strbuf_addf(&buf, "\n%c ", comment_line_char);
1621 strbuf_addstr(&buf, _("This is the 1st commit message:"));
1622 strbuf_addstr(&buf, "\n\n");
1623 strbuf_addstr(&buf, body);
1624
1625 unuse_commit_buffer(head_commit, head_message);
1626 }
1627
1628 if (!(message = get_commit_buffer(commit, NULL)))
1629 return error(_("could not read commit message of %s"),
1630 oid_to_hex(&commit->object.oid));
1631 find_commit_subject(message, &body);
1632
1633 if (command == TODO_SQUASH) {
1634 unlink(rebase_path_fixup_msg());
1635 strbuf_addf(&buf, "\n%c ", comment_line_char);
e12a7ef5 1636 strbuf_addf(&buf, _("This is the commit message #%d:"),
dd2e36eb 1637 ++opts->current_fixup_count + 1);
6e98de72
JS
1638 strbuf_addstr(&buf, "\n\n");
1639 strbuf_addstr(&buf, body);
1640 } else if (command == TODO_FIXUP) {
1641 strbuf_addf(&buf, "\n%c ", comment_line_char);
1642 strbuf_addf(&buf, _("The commit message #%d will be skipped:"),
dd2e36eb 1643 ++opts->current_fixup_count + 1);
6e98de72
JS
1644 strbuf_addstr(&buf, "\n\n");
1645 strbuf_add_commented_lines(&buf, body, strlen(body));
1646 } else
1647 return error(_("unknown command: %d"), command);
1648 unuse_commit_buffer(commit, message);
1649
1650 res = write_message(buf.buf, buf.len, rebase_path_squash_msg(), 0);
1651 strbuf_release(&buf);
e12a7ef5
JS
1652
1653 if (!res) {
1654 strbuf_addf(&opts->current_fixups, "%s%s %s",
1655 opts->current_fixups.len ? "\n" : "",
1656 command_to_string(command),
1657 oid_to_hex(&commit->object.oid));
1658 res = write_message(opts->current_fixups.buf,
1659 opts->current_fixups.len,
1660 rebase_path_current_fixups(), 0);
1661 }
1662
6e98de72
JS
1663 return res;
1664}
1665
25cb8df9
JS
1666static void flush_rewritten_pending(void) {
1667 struct strbuf buf = STRBUF_INIT;
092bbcdf 1668 struct object_id newoid;
25cb8df9
JS
1669 FILE *out;
1670
092bbcdf 1671 if (strbuf_read_file(&buf, rebase_path_rewritten_pending(), (GIT_MAX_HEXSZ + 1) * 2) > 0 &&
1672 !get_oid("HEAD", &newoid) &&
e9d983f1 1673 (out = fopen_or_warn(rebase_path_rewritten_list(), "a"))) {
25cb8df9
JS
1674 char *bol = buf.buf, *eol;
1675
1676 while (*bol) {
1677 eol = strchrnul(bol, '\n');
1678 fprintf(out, "%.*s %s\n", (int)(eol - bol),
092bbcdf 1679 bol, oid_to_hex(&newoid));
25cb8df9
JS
1680 if (!*eol)
1681 break;
1682 bol = eol + 1;
1683 }
1684 fclose(out);
1685 unlink(rebase_path_rewritten_pending());
1686 }
1687 strbuf_release(&buf);
1688}
1689
1690static void record_in_rewritten(struct object_id *oid,
1691 enum todo_command next_command) {
e9d983f1 1692 FILE *out = fopen_or_warn(rebase_path_rewritten_pending(), "a");
25cb8df9
JS
1693
1694 if (!out)
1695 return;
1696
1697 fprintf(out, "%s\n", oid_to_hex(oid));
1698 fclose(out);
1699
1700 if (!is_fixup(next_command))
1701 flush_rewritten_pending();
1702}
1703
f11c9580
NTND
1704static int do_pick_commit(struct repository *r,
1705 enum todo_command command,
1706 struct commit *commit,
1707 struct replay_opts *opts,
1708 int final_fixup)
043a4492 1709{
789b3eff 1710 unsigned int flags = opts->edit ? EDIT_MSG : 0;
f11c9580 1711 const char *msg_file = opts->edit ? NULL : git_path_merge_msg(r);
ace976b2 1712 struct object_id head;
043a4492
RR
1713 struct commit *base, *next, *parent;
1714 const char *base_label, *next_label;
356ee465 1715 char *author = NULL;
d74a4e57 1716 struct commit_message msg = { NULL, NULL, NULL, NULL };
043a4492 1717 struct strbuf msgbuf = STRBUF_INIT;
789b3eff 1718 int res, unborn = 0, allow;
043a4492
RR
1719
1720 if (opts->no_commit) {
1721 /*
1722 * We do not intend to commit immediately. We just want to
1723 * merge the differences in, so let's compute the tree
1724 * that represents the "current" state for merge-recursive
1725 * to work on.
1726 */
f11c9580 1727 if (write_index_as_tree(&head, r->index, r->index_file, 0, NULL))
93b3df6f 1728 return error(_("your index file is unmerged."));
043a4492 1729 } else {
ace976b2 1730 unborn = get_oid("HEAD", &head);
d87d48b2
JS
1731 /* Do we want to generate a root commit? */
1732 if (is_pick_or_similar(command) && opts->have_squash_onto &&
4a7e27e9 1733 oideq(&head, &opts->squash_onto)) {
d87d48b2
JS
1734 if (is_fixup(command))
1735 return error(_("cannot fixup root commit"));
1736 flags |= CREATE_ROOT_COMMIT;
1737 unborn = 1;
1738 } else if (unborn)
eb0ccfd7 1739 oidcpy(&head, the_hash_algo->empty_tree);
ffc00a48 1740 if (index_differs_from(r, unborn ? empty_tree_oid_hex() : "HEAD",
02f2f56b 1741 NULL, 0))
f11c9580 1742 return error_dirty_index(r->index, opts);
043a4492 1743 }
f11c9580 1744 discard_index(r->index);
043a4492 1745
637666c8 1746 if (!commit->parents)
043a4492 1747 parent = NULL;
043a4492
RR
1748 else if (commit->parents->next) {
1749 /* Reverting or cherry-picking a merge commit */
1750 int cnt;
1751 struct commit_list *p;
1752
1753 if (!opts->mainline)
93b3df6f 1754 return error(_("commit %s is a merge but no -m option was given."),
f2fd0760 1755 oid_to_hex(&commit->object.oid));
043a4492
RR
1756
1757 for (cnt = 1, p = commit->parents;
1758 cnt != opts->mainline && p;
1759 cnt++)
1760 p = p->next;
1761 if (cnt != opts->mainline || !p)
93b3df6f 1762 return error(_("commit %s does not have parent %d"),
f2fd0760 1763 oid_to_hex(&commit->object.oid), opts->mainline);
043a4492
RR
1764 parent = p->item;
1765 } else if (0 < opts->mainline)
93b3df6f 1766 return error(_("mainline was specified but commit %s is not a merge."),
f2fd0760 1767 oid_to_hex(&commit->object.oid));
043a4492
RR
1768 else
1769 parent = commit->parents->item;
1770
bcbb68be
JS
1771 if (get_message(commit, &msg) != 0)
1772 return error(_("cannot get commit message for %s"),
1773 oid_to_hex(&commit->object.oid));
1774
6e98de72 1775 if (opts->allow_ff && !is_fixup(command) &&
4a7e27e9 1776 ((parent && oideq(&parent->object.oid, &head)) ||
bcbb68be
JS
1777 (!parent && unborn))) {
1778 if (is_rebase_i(opts))
1779 write_author_script(msg.message);
f11c9580 1780 res = fast_forward_to(r, &commit->object.oid, &head, unborn,
bcbb68be
JS
1781 opts);
1782 if (res || command != TODO_REWORD)
1783 goto leave;
5f8f9277 1784 flags |= EDIT_MSG | AMEND_MSG | VERIFY_MSG;
bcbb68be
JS
1785 msg_file = NULL;
1786 goto fast_forward_edit;
1787 }
043a4492 1788 if (parent && parse_commit(parent) < 0)
004fefa7
JS
1789 /* TRANSLATORS: The first %s will be a "todo" command like
1790 "revert" or "pick", the second %s a SHA1. */
043a4492 1791 return error(_("%s: cannot parse parent commit %s"),
004fefa7
JS
1792 command_to_string(command),
1793 oid_to_hex(&parent->object.oid));
043a4492 1794
043a4492
RR
1795 /*
1796 * "commit" is an existing commit. We would want to apply
1797 * the difference it introduces since its first parent "prev"
1798 * on top of the current HEAD if we are cherry-pick. Or the
1799 * reverse of it if we are revert.
1800 */
1801
004fefa7 1802 if (command == TODO_REVERT) {
043a4492
RR
1803 base = commit;
1804 base_label = msg.label;
1805 next = parent;
1806 next_label = msg.parent_label;
1807 strbuf_addstr(&msgbuf, "Revert \"");
1808 strbuf_addstr(&msgbuf, msg.subject);
1809 strbuf_addstr(&msgbuf, "\"\n\nThis reverts commit ");
f2fd0760 1810 strbuf_addstr(&msgbuf, oid_to_hex(&commit->object.oid));
043a4492
RR
1811
1812 if (commit->parents && commit->parents->next) {
1813 strbuf_addstr(&msgbuf, ", reversing\nchanges made to ");
f2fd0760 1814 strbuf_addstr(&msgbuf, oid_to_hex(&parent->object.oid));
043a4492
RR
1815 }
1816 strbuf_addstr(&msgbuf, ".\n");
1817 } else {
1818 const char *p;
1819
1820 base = parent;
1821 base_label = msg.parent_label;
1822 next = commit;
1823 next_label = msg.label;
1824
23aa5142
JS
1825 /* Append the commit log message to msgbuf. */
1826 if (find_commit_subject(msg.message, &p))
1827 strbuf_addstr(&msgbuf, p);
043a4492
RR
1828
1829 if (opts->record_origin) {
44dc738a 1830 strbuf_complete_line(&msgbuf);
bab4d109 1831 if (!has_conforming_footer(&msgbuf, NULL, 0))
b971e04f 1832 strbuf_addch(&msgbuf, '\n');
cd650a4e 1833 strbuf_addstr(&msgbuf, cherry_picked_prefix);
f2fd0760 1834 strbuf_addstr(&msgbuf, oid_to_hex(&commit->object.oid));
043a4492
RR
1835 strbuf_addstr(&msgbuf, ")\n");
1836 }
356ee465
PW
1837 if (!is_fixup(command))
1838 author = get_author(msg.message);
043a4492
RR
1839 }
1840
04efc8b5 1841 if (command == TODO_REWORD)
b92ff6e8 1842 flags |= EDIT_MSG | VERIFY_MSG;
04efc8b5 1843 else if (is_fixup(command)) {
005af339 1844 if (update_squash_messages(r, command, commit, opts))
6e98de72 1845 return -1;
789b3eff 1846 flags |= AMEND_MSG;
6e98de72
JS
1847 if (!final_fixup)
1848 msg_file = rebase_path_squash_msg();
1849 else if (file_exists(rebase_path_fixup_msg())) {
789b3eff 1850 flags |= CLEANUP_MSG;
6e98de72
JS
1851 msg_file = rebase_path_fixup_msg();
1852 } else {
f11c9580 1853 const char *dest = git_path_squash_msg(r);
6e98de72
JS
1854 unlink(dest);
1855 if (copy_file(dest, rebase_path_squash_msg(), 0666))
1856 return error(_("could not rename '%s' to '%s'"),
1857 rebase_path_squash_msg(), dest);
f11c9580 1858 unlink(git_path_merge_msg(r));
6e98de72 1859 msg_file = dest;
789b3eff 1860 flags |= EDIT_MSG;
6e98de72
JS
1861 }
1862 }
1863
a852ec7f 1864 if (opts->signoff && !is_fixup(command))
b34eeea3
PW
1865 append_signoff(&msgbuf, 0, 0);
1866
0473f28a
JS
1867 if (is_rebase_i(opts) && write_author_script(msg.message) < 0)
1868 res = -1;
1869 else if (!opts->strategy || !strcmp(opts->strategy, "recursive") || command == TODO_REVERT) {
f11c9580 1870 res = do_recursive_merge(r, base, next, base_label, next_label,
48be4c62 1871 &head, &msgbuf, opts);
f241ff0d 1872 if (res < 0)
19517fb9
SB
1873 goto leave;
1874
75871495 1875 res |= write_message(msgbuf.buf, msgbuf.len,
f11c9580 1876 git_path_merge_msg(r), 0);
043a4492
RR
1877 } else {
1878 struct commit_list *common = NULL;
1879 struct commit_list *remotes = NULL;
1880
75871495 1881 res = write_message(msgbuf.buf, msgbuf.len,
f11c9580 1882 git_path_merge_msg(r), 0);
043a4492
RR
1883
1884 commit_list_insert(base, &common);
1885 commit_list_insert(next, &remotes);
f11c9580 1886 res |= try_merge_command(r, opts->strategy,
03a4e260 1887 opts->xopts_nr, (const char **)opts->xopts,
ace976b2 1888 common, oid_to_hex(&head), remotes);
043a4492
RR
1889 free_commit_list(common);
1890 free_commit_list(remotes);
1891 }
452202c7 1892 strbuf_release(&msgbuf);
043a4492
RR
1893
1894 /*
1895 * If the merge was clean or if it failed due to conflict, we write
1896 * CHERRY_PICK_HEAD for the subsequent invocation of commit to use.
1897 * However, if the merge did not even start, then we don't want to
1898 * write it at all.
1899 */
004fefa7 1900 if (command == TODO_PICK && !opts->no_commit && (res == 0 || res == 1) &&
ae077771 1901 update_ref(NULL, "CHERRY_PICK_HEAD", &commit->object.oid, NULL,
91774afc 1902 REF_NO_DEREF, UPDATE_REFS_MSG_ON_ERR))
dbfad033 1903 res = -1;
004fefa7 1904 if (command == TODO_REVERT && ((opts->no_commit && res == 0) || res == 1) &&
ae077771 1905 update_ref(NULL, "REVERT_HEAD", &commit->object.oid, NULL,
91774afc 1906 REF_NO_DEREF, UPDATE_REFS_MSG_ON_ERR))
dbfad033 1907 res = -1;
043a4492
RR
1908
1909 if (res) {
004fefa7 1910 error(command == TODO_REVERT
043a4492
RR
1911 ? _("could not revert %s... %s")
1912 : _("could not apply %s... %s"),
39755964 1913 short_commit_name(commit), msg.subject);
005af339 1914 print_advice(r, res == 1, opts);
f11c9580 1915 repo_rerere(r, opts->allow_rerere_auto);
c8d1351d 1916 goto leave;
043a4492
RR
1917 }
1918
f11c9580 1919 allow = allow_empty(r, opts, commit);
706728a3
FC
1920 if (allow < 0) {
1921 res = allow;
1922 goto leave;
789b3eff
JS
1923 } else if (allow)
1924 flags |= ALLOW_EMPTY;
356ee465 1925 if (!opts->no_commit) {
bcbb68be 1926fast_forward_edit:
356ee465 1927 if (author || command == TODO_REVERT || (flags & AMEND_MSG))
f11c9580 1928 res = do_commit(r, msg_file, author, opts, flags);
356ee465
PW
1929 else
1930 res = error(_("unable to parse commit author"));
1931 }
6e98de72
JS
1932
1933 if (!res && final_fixup) {
1934 unlink(rebase_path_fixup_msg());
1935 unlink(rebase_path_squash_msg());
e12a7ef5
JS
1936 unlink(rebase_path_current_fixups());
1937 strbuf_reset(&opts->current_fixups);
1938 opts->current_fixup_count = 0;
6e98de72 1939 }
c8d1351d
FC
1940
1941leave:
d74a4e57 1942 free_message(commit, &msg);
356ee465 1943 free(author);
1e41229d 1944 update_abort_safety_file();
043a4492
RR
1945
1946 return res;
1947}
1948
c3e8618c 1949static int prepare_revs(struct replay_opts *opts)
043a4492 1950{
a73e22e9
MZ
1951 /*
1952 * picking (but not reverting) ranges (but not individual revisions)
1953 * should be done in reverse
1954 */
1955 if (opts->action == REPLAY_PICK && !opts->revs->no_walk)
043a4492
RR
1956 opts->revs->reverse ^= 1;
1957
1958 if (prepare_revision_walk(opts->revs))
c3e8618c 1959 return error(_("revision walk setup failed"));
043a4492 1960
c3e8618c 1961 return 0;
043a4492
RR
1962}
1963
f11c9580
NTND
1964static int read_and_refresh_cache(struct repository *r,
1965 struct replay_opts *opts)
043a4492 1966{
14bca6c6 1967 struct lock_file index_lock = LOCK_INIT;
043a4492 1968 int index_fd = hold_locked_index(&index_lock, 0);
cde55548 1969 if (read_index(r->index) < 0) {
49fb937e 1970 rollback_lock_file(&index_lock);
0d9c6dc9 1971 return error(_("git %s: failed to read the index"),
c28cbc5e 1972 _(action_name(opts)));
49fb937e 1973 }
f11c9580 1974 refresh_index(r->index, REFRESH_QUIET|REFRESH_UNMERGED, NULL, NULL, NULL);
61000814 1975 if (index_fd >= 0) {
f11c9580 1976 if (write_locked_index(r->index, &index_lock,
61000814 1977 COMMIT_LOCK | SKIP_IF_UNCHANGED)) {
0d9c6dc9 1978 return error(_("git %s: failed to refresh the index"),
c28cbc5e 1979 _(action_name(opts)));
49fb937e 1980 }
043a4492 1981 }
0d9c6dc9 1982 return 0;
043a4492
RR
1983}
1984
4c68e7dd
JS
1985enum todo_item_flags {
1986 TODO_EDIT_MERGE_MSG = 1
1987};
1988
5d94d545 1989void todo_list_release(struct todo_list *todo_list)
043a4492 1990{
004fefa7 1991 strbuf_release(&todo_list->buf);
6a83d902 1992 FREE_AND_NULL(todo_list->items);
004fefa7
JS
1993 todo_list->nr = todo_list->alloc = 0;
1994}
043a4492 1995
004fefa7
JS
1996static struct todo_item *append_new_todo(struct todo_list *todo_list)
1997{
1998 ALLOC_GROW(todo_list->items, todo_list->nr + 1, todo_list->alloc);
1999 return todo_list->items + todo_list->nr++;
043a4492
RR
2000}
2001
6ad656db
AG
2002const char *todo_item_get_arg(struct todo_list *todo_list,
2003 struct todo_item *item)
2004{
2005 return todo_list->buf.buf + item->arg_offset;
2006}
2007
005af339 2008static int parse_insn_line(struct repository *r, struct todo_item *item,
6ad656db 2009 const char *buf, const char *bol, char *eol)
043a4492 2010{
1e43ed98 2011 struct object_id commit_oid;
043a4492 2012 char *end_of_object_name;
004fefa7
JS
2013 int i, saved, status, padding;
2014
4c68e7dd
JS
2015 item->flags = 0;
2016
8f8550b3
JS
2017 /* left-trim */
2018 bol += strspn(bol, " \t");
2019
25c43667 2020 if (bol == eol || *bol == '\r' || *bol == comment_line_char) {
ac191470 2021 item->command = TODO_COMMENT;
25c43667 2022 item->commit = NULL;
6ad656db 2023 item->arg_offset = bol - buf;
25c43667
JS
2024 item->arg_len = eol - bol;
2025 return 0;
2026 }
2027
ac191470 2028 for (i = 0; i < TODO_COMMENT; i++)
414697a9
JS
2029 if (skip_prefix(bol, todo_command_info[i].str, &bol)) {
2030 item->command = i;
2031 break;
3a4a4cab
JS
2032 } else if ((bol + 1 == eol || bol[1] == ' ') &&
2033 *bol == todo_command_info[i].c) {
414697a9 2034 bol++;
004fefa7
JS
2035 item->command = i;
2036 break;
2037 }
ac191470 2038 if (i >= TODO_COMMENT)
004fefa7 2039 return -1;
043a4492 2040
66afa24f
JS
2041 /* Eat up extra spaces/ tabs before object name */
2042 padding = strspn(bol, " \t");
2043 bol += padding;
2044
71f82465 2045 if (item->command == TODO_NOOP || item->command == TODO_BREAK) {
66afa24f
JS
2046 if (bol != eol)
2047 return error(_("%s does not accept arguments: '%s'"),
2048 command_to_string(item->command), bol);
25c43667 2049 item->commit = NULL;
6ad656db 2050 item->arg_offset = bol - buf;
25c43667
JS
2051 item->arg_len = eol - bol;
2052 return 0;
2053 }
2054
043a4492 2055 if (!padding)
66afa24f
JS
2056 return error(_("missing arguments for %s"),
2057 command_to_string(item->command));
043a4492 2058
9055e401
JS
2059 if (item->command == TODO_EXEC || item->command == TODO_LABEL ||
2060 item->command == TODO_RESET) {
7dcbb3cb 2061 item->commit = NULL;
6ad656db 2062 item->arg_offset = bol - buf;
311af526
JS
2063 item->arg_len = (int)(eol - bol);
2064 return 0;
2065 }
2066
4c68e7dd
JS
2067 if (item->command == TODO_MERGE) {
2068 if (skip_prefix(bol, "-C", &bol))
2069 bol += strspn(bol, " \t");
2070 else if (skip_prefix(bol, "-c", &bol)) {
2071 bol += strspn(bol, " \t");
2072 item->flags |= TODO_EDIT_MERGE_MSG;
2073 } else {
2074 item->flags |= TODO_EDIT_MERGE_MSG;
2075 item->commit = NULL;
6ad656db 2076 item->arg_offset = bol - buf;
4c68e7dd
JS
2077 item->arg_len = (int)(eol - bol);
2078 return 0;
2079 }
2080 }
2081
004fefa7 2082 end_of_object_name = (char *) bol + strcspn(bol, " \t\n");
043a4492
RR
2083 saved = *end_of_object_name;
2084 *end_of_object_name = '\0';
1e43ed98 2085 status = get_oid(bol, &commit_oid);
043a4492
RR
2086 *end_of_object_name = saved;
2087
6ad656db
AG
2088 bol = end_of_object_name + strspn(end_of_object_name, " \t");
2089 item->arg_offset = bol - buf;
2090 item->arg_len = (int)(eol - bol);
c22f7dfb 2091
043a4492 2092 if (status < 0)
004fefa7 2093 return -1;
043a4492 2094
005af339 2095 item->commit = lookup_commit_reference(r, &commit_oid);
004fefa7 2096 return !item->commit;
043a4492
RR
2097}
2098
5d94d545
AG
2099int todo_list_parse_insn_buffer(struct repository *r, char *buf,
2100 struct todo_list *todo_list)
043a4492 2101{
004fefa7
JS
2102 struct todo_item *item;
2103 char *p = buf, *next_p;
6e98de72 2104 int i, res = 0, fixup_okay = file_exists(rebase_path_done());
043a4492 2105
2b71595d
AG
2106 todo_list->current = todo_list->nr = 0;
2107
004fefa7 2108 for (i = 1; *p; i++, p = next_p) {
043a4492 2109 char *eol = strchrnul(p, '\n');
004fefa7
JS
2110
2111 next_p = *eol ? eol + 1 /* skip LF */ : eol;
2112
6307041d
JS
2113 if (p != eol && eol[-1] == '\r')
2114 eol--; /* strip Carriage Return */
2115
004fefa7
JS
2116 item = append_new_todo(todo_list);
2117 item->offset_in_buf = p - todo_list->buf.buf;
6ad656db 2118 if (parse_insn_line(r, item, buf, p, eol)) {
93b3df6f 2119 res = error(_("invalid line %d: %.*s"),
004fefa7 2120 i, (int)(eol - p), p);
2b71595d 2121 item->command = TODO_COMMENT + 1;
6ad656db 2122 item->arg_offset = p - buf;
2b71595d
AG
2123 item->arg_len = (int)(eol - p);
2124 item->commit = NULL;
004fefa7 2125 }
6e98de72
JS
2126
2127 if (fixup_okay)
2128 ; /* do nothing */
2129 else if (is_fixup(item->command))
2130 return error(_("cannot '%s' without a previous commit"),
2131 command_to_string(item->command));
2132 else if (!is_noop(item->command))
2133 fixup_okay = 1;
043a4492 2134 }
52865279 2135
004fefa7 2136 return res;
043a4492
RR
2137}
2138
968492e4
JS
2139static int count_commands(struct todo_list *todo_list)
2140{
2141 int count = 0, i;
2142
2143 for (i = 0; i < todo_list->nr; i++)
2144 if (todo_list->items[i].command != TODO_COMMENT)
2145 count++;
2146
2147 return count;
2148}
2149
a01c2a5f
JS
2150static int get_item_line_offset(struct todo_list *todo_list, int index)
2151{
2152 return index < todo_list->nr ?
2153 todo_list->items[index].offset_in_buf : todo_list->buf.len;
2154}
2155
2156static const char *get_item_line(struct todo_list *todo_list, int index)
2157{
2158 return todo_list->buf.buf + get_item_line_offset(todo_list, index);
2159}
2160
2161static int get_item_line_length(struct todo_list *todo_list, int index)
2162{
2163 return get_item_line_offset(todo_list, index + 1)
2164 - get_item_line_offset(todo_list, index);
2165}
2166
87805600
RS
2167static ssize_t strbuf_read_file_or_whine(struct strbuf *sb, const char *path)
2168{
2169 int fd;
2170 ssize_t len;
2171
2172 fd = open(path, O_RDONLY);
2173 if (fd < 0)
2174 return error_errno(_("could not open '%s'"), path);
2175 len = strbuf_read(sb, fd, 0);
2176 close(fd);
2177 if (len < 0)
2178 return error(_("could not read '%s'."), path);
2179 return len;
2180}
2181
005af339
NTND
2182static int read_populate_todo(struct repository *r,
2183 struct todo_list *todo_list,
2184 struct replay_opts *opts)
043a4492 2185{
54fd3243 2186 struct stat st;
c0246501 2187 const char *todo_file = get_todo_path(opts);
87805600 2188 int res;
043a4492 2189
004fefa7 2190 strbuf_reset(&todo_list->buf);
87805600
RS
2191 if (strbuf_read_file_or_whine(&todo_list->buf, todo_file) < 0)
2192 return -1;
043a4492 2193
54fd3243
SH
2194 res = stat(todo_file, &st);
2195 if (res)
2196 return error(_("could not stat '%s'"), todo_file);
2197 fill_stat_data(&todo_list->stat, &st);
2198
5d94d545 2199 res = todo_list_parse_insn_buffer(r, todo_list->buf.buf, todo_list);
27fdbb96
JS
2200 if (res) {
2201 if (is_rebase_i(opts))
2202 return error(_("please fix this using "
2203 "'git rebase --edit-todo'."));
93b3df6f 2204 return error(_("unusable instruction sheet: '%s'"), todo_file);
27fdbb96 2205 }
2eeaf1b3 2206
52865279
JS
2207 if (!todo_list->nr &&
2208 (!is_rebase_i(opts) || !file_exists(rebase_path_done())))
2209 return error(_("no commits parsed."));
2210
2eeaf1b3 2211 if (!is_rebase_i(opts)) {
004fefa7
JS
2212 enum todo_command valid =
2213 opts->action == REPLAY_PICK ? TODO_PICK : TODO_REVERT;
2214 int i;
2215
2216 for (i = 0; i < todo_list->nr; i++)
2217 if (valid == todo_list->items[i].command)
2218 continue;
2219 else if (valid == TODO_PICK)
93b3df6f 2220 return error(_("cannot cherry-pick during a revert."));
004fefa7 2221 else
93b3df6f 2222 return error(_("cannot revert during a cherry-pick."));
004fefa7
JS
2223 }
2224
968492e4
JS
2225 if (is_rebase_i(opts)) {
2226 struct todo_list done = TODO_LIST_INIT;
e9d983f1 2227 FILE *f = fopen_or_warn(rebase_path_msgtotal(), "w");
968492e4
JS
2228
2229 if (strbuf_read_file(&done.buf, rebase_path_done(), 0) > 0 &&
5d94d545 2230 !todo_list_parse_insn_buffer(r, done.buf.buf, &done))
968492e4
JS
2231 todo_list->done_nr = count_commands(&done);
2232 else
2233 todo_list->done_nr = 0;
2234
2235 todo_list->total_nr = todo_list->done_nr
2236 + count_commands(todo_list);
968492e4 2237 todo_list_release(&done);
ef80069a
JS
2238
2239 if (f) {
2240 fprintf(f, "%d\n", todo_list->total_nr);
2241 fclose(f);
2242 }
968492e4
JS
2243 }
2244
0ae42a03 2245 return 0;
043a4492
RR
2246}
2247
03a4e260
JS
2248static int git_config_string_dup(char **dest,
2249 const char *var, const char *value)
2250{
2251 if (!value)
2252 return config_error_nonbool(var);
2253 free(*dest);
2254 *dest = xstrdup(value);
2255 return 0;
2256}
2257
043a4492
RR
2258static int populate_opts_cb(const char *key, const char *value, void *data)
2259{
2260 struct replay_opts *opts = data;
2261 int error_flag = 1;
2262
2263 if (!value)
2264 error_flag = 0;
2265 else if (!strcmp(key, "options.no-commit"))
2266 opts->no_commit = git_config_bool_or_int(key, value, &error_flag);
2267 else if (!strcmp(key, "options.edit"))
2268 opts->edit = git_config_bool_or_int(key, value, &error_flag);
2269 else if (!strcmp(key, "options.signoff"))
2270 opts->signoff = git_config_bool_or_int(key, value, &error_flag);
2271 else if (!strcmp(key, "options.record-origin"))
2272 opts->record_origin = git_config_bool_or_int(key, value, &error_flag);
2273 else if (!strcmp(key, "options.allow-ff"))
2274 opts->allow_ff = git_config_bool_or_int(key, value, &error_flag);
2275 else if (!strcmp(key, "options.mainline"))
2276 opts->mainline = git_config_int(key, value);
2277 else if (!strcmp(key, "options.strategy"))
03a4e260 2278 git_config_string_dup(&opts->strategy, key, value);
3253553e 2279 else if (!strcmp(key, "options.gpg-sign"))
03a4e260 2280 git_config_string_dup(&opts->gpg_sign, key, value);
043a4492
RR
2281 else if (!strcmp(key, "options.strategy-option")) {
2282 ALLOC_GROW(opts->xopts, opts->xopts_nr + 1, opts->xopts_alloc);
2283 opts->xopts[opts->xopts_nr++] = xstrdup(value);
8d8cb4b0
PW
2284 } else if (!strcmp(key, "options.allow-rerere-auto"))
2285 opts->allow_rerere_auto =
2286 git_config_bool_or_int(key, value, &error_flag) ?
2287 RERERE_AUTOUPDATE : RERERE_NOAUTOUPDATE;
2288 else
93b3df6f 2289 return error(_("invalid key: %s"), key);
043a4492
RR
2290
2291 if (!error_flag)
93b3df6f 2292 return error(_("invalid value for %s: %s"), key, value);
043a4492
RR
2293
2294 return 0;
2295}
2296
65850686 2297void parse_strategy_opts(struct replay_opts *opts, char *raw_opts)
ca6c6b45
JS
2298{
2299 int i;
65850686 2300 char *strategy_opts_string = raw_opts;
ca6c6b45 2301
0060041d
EN
2302 if (*strategy_opts_string == ' ')
2303 strategy_opts_string++;
65850686 2304
0060041d
EN
2305 opts->xopts_nr = split_cmdline(strategy_opts_string,
2306 (const char ***)&opts->xopts);
ca6c6b45
JS
2307 for (i = 0; i < opts->xopts_nr; i++) {
2308 const char *arg = opts->xopts[i];
2309
2310 skip_prefix(arg, "--", &arg);
2311 opts->xopts[i] = xstrdup(arg);
2312 }
2313}
2314
65850686
AG
2315static void read_strategy_opts(struct replay_opts *opts, struct strbuf *buf)
2316{
2317 strbuf_reset(buf);
2318 if (!read_oneliner(buf, rebase_path_strategy(), 0))
2319 return;
2320 opts->strategy = strbuf_detach(buf, NULL);
2321 if (!read_oneliner(buf, rebase_path_strategy_opts(), 0))
2322 return;
2323
2324 parse_strategy_opts(opts, buf->buf);
2325}
2326
5adf9bdc 2327static int read_populate_opts(struct replay_opts *opts)
043a4492 2328{
a1c75762
JS
2329 if (is_rebase_i(opts)) {
2330 struct strbuf buf = STRBUF_INIT;
2331
2332 if (read_oneliner(&buf, rebase_path_gpg_sign_opt(), 1)) {
2333 if (!starts_with(buf.buf, "-S"))
2334 strbuf_reset(&buf);
2335 else {
2336 free(opts->gpg_sign);
2337 opts->gpg_sign = xstrdup(buf.buf + 2);
2338 }
9b6d7a62
PW
2339 strbuf_reset(&buf);
2340 }
2341
2342 if (read_oneliner(&buf, rebase_path_allow_rerere_autoupdate(), 1)) {
2343 if (!strcmp(buf.buf, "--rerere-autoupdate"))
2344 opts->allow_rerere_auto = RERERE_AUTOUPDATE;
2345 else if (!strcmp(buf.buf, "--no-rerere-autoupdate"))
2346 opts->allow_rerere_auto = RERERE_NOAUTOUPDATE;
2347 strbuf_reset(&buf);
a1c75762 2348 }
a1c75762 2349
556907f1
JS
2350 if (file_exists(rebase_path_verbose()))
2351 opts->verbose = 1;
2352
a852ec7f
PW
2353 if (file_exists(rebase_path_signoff())) {
2354 opts->allow_ff = 0;
2355 opts->signoff = 1;
2356 }
2357
ca6c6b45
JS
2358 read_strategy_opts(opts, &buf);
2359 strbuf_release(&buf);
2360
e12a7ef5
JS
2361 if (read_oneliner(&opts->current_fixups,
2362 rebase_path_current_fixups(), 1)) {
2363 const char *p = opts->current_fixups.buf;
2364 opts->current_fixup_count = 1;
2365 while ((p = strchr(p, '\n'))) {
2366 opts->current_fixup_count++;
2367 p++;
2368 }
2369 }
2370
d87d48b2
JS
2371 if (read_oneliner(&buf, rebase_path_squash_onto(), 0)) {
2372 if (get_oid_hex(buf.buf, &opts->squash_onto) < 0)
2373 return error(_("unusable squash-onto"));
2374 opts->have_squash_onto = 1;
2375 }
2376
b5a67045 2377 return 0;
a1c75762 2378 }
b5a67045 2379
f932729c 2380 if (!file_exists(git_path_opts_file()))
0d00da7b
JS
2381 return 0;
2382 /*
2383 * The function git_parse_source(), called from git_config_from_file(),
2384 * may die() in case of a syntactically incorrect file. We do not care
2385 * about this case, though, because we wrote that file ourselves, so we
2386 * are pretty certain that it is syntactically correct.
2387 */
5adf9bdc 2388 if (git_config_from_file(populate_opts_cb, git_path_opts_file(), opts) < 0)
93b3df6f 2389 return error(_("malformed options sheet: '%s'"),
0d00da7b
JS
2390 git_path_opts_file());
2391 return 0;
043a4492
RR
2392}
2393
65850686
AG
2394static void write_strategy_opts(struct replay_opts *opts)
2395{
2396 int i;
2397 struct strbuf buf = STRBUF_INIT;
2398
2399 for (i = 0; i < opts->xopts_nr; ++i)
2400 strbuf_addf(&buf, " --%s", opts->xopts[i]);
2401
2402 write_file(rebase_path_strategy_opts(), "%s\n", buf.buf);
2403 strbuf_release(&buf);
2404}
2405
2406int write_basic_state(struct replay_opts *opts, const char *head_name,
2407 const char *onto, const char *orig_head)
2408{
2409 const char *quiet = getenv("GIT_QUIET");
2410
2411 if (head_name)
2412 write_file(rebase_path_head_name(), "%s\n", head_name);
2413 if (onto)
2414 write_file(rebase_path_onto(), "%s\n", onto);
2415 if (orig_head)
2416 write_file(rebase_path_orig_head(), "%s\n", orig_head);
2417
2418 if (quiet)
2419 write_file(rebase_path_quiet(), "%s\n", quiet);
2420 else
2421 write_file(rebase_path_quiet(), "\n");
2422
2423 if (opts->verbose)
4af51741 2424 write_file(rebase_path_verbose(), "%s", "");
65850686
AG
2425 if (opts->strategy)
2426 write_file(rebase_path_strategy(), "%s\n", opts->strategy);
2427 if (opts->xopts_nr > 0)
2428 write_strategy_opts(opts);
2429
2430 if (opts->allow_rerere_auto == RERERE_AUTOUPDATE)
2431 write_file(rebase_path_allow_rerere_autoupdate(), "--rerere-autoupdate\n");
2432 else if (opts->allow_rerere_auto == RERERE_NOAUTOUPDATE)
2433 write_file(rebase_path_allow_rerere_autoupdate(), "--no-rerere-autoupdate\n");
2434
2435 if (opts->gpg_sign)
2436 write_file(rebase_path_gpg_sign_opt(), "-S%s\n", opts->gpg_sign);
2437 if (opts->signoff)
2438 write_file(rebase_path_signoff(), "--signoff\n");
2439
2440 return 0;
2441}
2442
004fefa7 2443static int walk_revs_populate_todo(struct todo_list *todo_list,
043a4492
RR
2444 struct replay_opts *opts)
2445{
004fefa7
JS
2446 enum todo_command command = opts->action == REPLAY_PICK ?
2447 TODO_PICK : TODO_REVERT;
414697a9 2448 const char *command_string = todo_command_info[command].str;
043a4492 2449 struct commit *commit;
043a4492 2450
34b0528b
JS
2451 if (prepare_revs(opts))
2452 return -1;
043a4492 2453
004fefa7
JS
2454 while ((commit = get_revision(opts->revs))) {
2455 struct todo_item *item = append_new_todo(todo_list);
2456 const char *commit_buffer = get_commit_buffer(commit, NULL);
2457 const char *subject;
2458 int subject_len;
2459
2460 item->command = command;
2461 item->commit = commit;
6ad656db 2462 item->arg_offset = 0;
c22f7dfb 2463 item->arg_len = 0;
004fefa7
JS
2464 item->offset_in_buf = todo_list->buf.len;
2465 subject_len = find_commit_subject(commit_buffer, &subject);
2466 strbuf_addf(&todo_list->buf, "%s %s %.*s\n", command_string,
2467 short_commit_name(commit), subject_len, subject);
2468 unuse_commit_buffer(commit, commit_buffer);
2469 }
8530c739
JK
2470
2471 if (!todo_list->nr)
2472 return error(_("empty commit set passed"));
2473
34b0528b 2474 return 0;
043a4492
RR
2475}
2476
2477static int create_seq_dir(void)
2478{
f932729c 2479 if (file_exists(git_path_seq_dir())) {
043a4492
RR
2480 error(_("a cherry-pick or revert is already in progress"));
2481 advise(_("try \"git cherry-pick (--continue | --quit | --abort)\""));
2482 return -1;
a70d8f80 2483 } else if (mkdir(git_path_seq_dir(), 0777) < 0)
93b3df6f 2484 return error_errno(_("could not create sequencer directory '%s'"),
f6e82b0d 2485 git_path_seq_dir());
043a4492
RR
2486 return 0;
2487}
2488
311fd397 2489static int save_head(const char *head)
043a4492 2490{
14bca6c6 2491 struct lock_file head_lock = LOCK_INIT;
043a4492
RR
2492 struct strbuf buf = STRBUF_INIT;
2493 int fd;
ed3f9a12 2494 ssize_t written;
043a4492 2495
311fd397 2496 fd = hold_lock_file_for_update(&head_lock, git_path_head_file(), 0);
350292a1 2497 if (fd < 0)
93b3df6f 2498 return error_errno(_("could not lock HEAD"));
043a4492 2499 strbuf_addf(&buf, "%s\n", head);
ed3f9a12
RS
2500 written = write_in_full(fd, buf.buf, buf.len);
2501 strbuf_release(&buf);
2502 if (written < 0) {
bf5c0571 2503 error_errno(_("could not write to '%s'"), git_path_head_file());
311fd397 2504 rollback_lock_file(&head_lock);
bf5c0571 2505 return -1;
311fd397 2506 }
350292a1
2507 if (commit_lock_file(&head_lock) < 0)
2508 return error(_("failed to finalize '%s'"), git_path_head_file());
311fd397 2509 return 0;
043a4492
RR
2510}
2511
1e41229d
SB
2512static int rollback_is_safe(void)
2513{
2514 struct strbuf sb = STRBUF_INIT;
2515 struct object_id expected_head, actual_head;
2516
2517 if (strbuf_read_file(&sb, git_path_abort_safety_file(), 0) >= 0) {
2518 strbuf_trim(&sb);
2519 if (get_oid_hex(sb.buf, &expected_head)) {
2520 strbuf_release(&sb);
2521 die(_("could not parse %s"), git_path_abort_safety_file());
2522 }
2523 strbuf_release(&sb);
2524 }
2525 else if (errno == ENOENT)
2526 oidclr(&expected_head);
2527 else
2528 die_errno(_("could not read '%s'"), git_path_abort_safety_file());
2529
2530 if (get_oid("HEAD", &actual_head))
2531 oidclr(&actual_head);
2532
4a7e27e9 2533 return oideq(&actual_head, &expected_head);
1e41229d
SB
2534}
2535
092bbcdf 2536static int reset_for_rollback(const struct object_id *oid)
043a4492
RR
2537{
2538 const char *argv[4]; /* reset --merge <arg> + NULL */
1e41229d 2539
043a4492
RR
2540 argv[0] = "reset";
2541 argv[1] = "--merge";
092bbcdf 2542 argv[2] = oid_to_hex(oid);
043a4492
RR
2543 argv[3] = NULL;
2544 return run_command_v_opt(argv, RUN_GIT_CMD);
2545}
2546
005af339 2547static int rollback_single_pick(struct repository *r)
043a4492 2548{
092bbcdf 2549 struct object_id head_oid;
043a4492 2550
005af339
NTND
2551 if (!file_exists(git_path_cherry_pick_head(r)) &&
2552 !file_exists(git_path_revert_head(r)))
043a4492 2553 return error(_("no cherry-pick or revert in progress"));
34c290a6 2554 if (read_ref_full("HEAD", 0, &head_oid, NULL))
043a4492 2555 return error(_("cannot resolve HEAD"));
092bbcdf 2556 if (is_null_oid(&head_oid))
043a4492 2557 return error(_("cannot abort from a branch yet to be born"));
092bbcdf 2558 return reset_for_rollback(&head_oid);
043a4492
RR
2559}
2560
005af339 2561int sequencer_rollback(struct repository *r, struct replay_opts *opts)
043a4492 2562{
043a4492 2563 FILE *f;
092bbcdf 2564 struct object_id oid;
043a4492 2565 struct strbuf buf = STRBUF_INIT;
092bbcdf 2566 const char *p;
043a4492 2567
f932729c 2568 f = fopen(git_path_head_file(), "r");
043a4492
RR
2569 if (!f && errno == ENOENT) {
2570 /*
2571 * There is no multiple-cherry-pick in progress.
2572 * If CHERRY_PICK_HEAD or REVERT_HEAD indicates
2573 * a single-cherry-pick in progress, abort that.
2574 */
005af339 2575 return rollback_single_pick(r);
043a4492
RR
2576 }
2577 if (!f)
f7ed1953 2578 return error_errno(_("cannot open '%s'"), git_path_head_file());
8f309aeb 2579 if (strbuf_getline_lf(&buf, f)) {
f7ed1953 2580 error(_("cannot read '%s': %s"), git_path_head_file(),
f932729c 2581 ferror(f) ? strerror(errno) : _("unexpected end of file"));
043a4492
RR
2582 fclose(f);
2583 goto fail;
2584 }
2585 fclose(f);
092bbcdf 2586 if (parse_oid_hex(buf.buf, &oid, &p) || *p != '\0') {
043a4492 2587 error(_("stored pre-cherry-pick HEAD file '%s' is corrupt"),
f932729c 2588 git_path_head_file());
043a4492
RR
2589 goto fail;
2590 }
092bbcdf 2591 if (is_null_oid(&oid)) {
0f974e21
MG
2592 error(_("cannot abort from a branch yet to be born"));
2593 goto fail;
2594 }
1e41229d
SB
2595
2596 if (!rollback_is_safe()) {
2597 /* Do not error, just do not rollback */
2598 warning(_("You seem to have moved HEAD. "
2599 "Not rewinding, check your HEAD!"));
2600 } else
092bbcdf 2601 if (reset_for_rollback(&oid))
043a4492 2602 goto fail;
043a4492 2603 strbuf_release(&buf);
2863584f 2604 return sequencer_remove_state(opts);
043a4492
RR
2605fail:
2606 strbuf_release(&buf);
2607 return -1;
2608}
2609
004fefa7 2610static int save_todo(struct todo_list *todo_list, struct replay_opts *opts)
043a4492 2611{
14bca6c6 2612 struct lock_file todo_lock = LOCK_INIT;
004fefa7
JS
2613 const char *todo_path = get_todo_path(opts);
2614 int next = todo_list->current, offset, fd;
043a4492 2615
84583957
JS
2616 /*
2617 * rebase -i writes "git-rebase-todo" without the currently executing
2618 * command, appending it to "done" instead.
2619 */
2620 if (is_rebase_i(opts))
2621 next++;
2622
004fefa7 2623 fd = hold_lock_file_for_update(&todo_lock, todo_path, 0);
221675de 2624 if (fd < 0)
93b3df6f 2625 return error_errno(_("could not lock '%s'"), todo_path);
a01c2a5f 2626 offset = get_item_line_offset(todo_list, next);
004fefa7
JS
2627 if (write_in_full(fd, todo_list->buf.buf + offset,
2628 todo_list->buf.len - offset) < 0)
93b3df6f 2629 return error_errno(_("could not write to '%s'"), todo_path);
004fefa7 2630 if (commit_lock_file(&todo_lock) < 0)
350292a1 2631 return error(_("failed to finalize '%s'"), todo_path);
1df6df0c 2632
a01c2a5f
JS
2633 if (is_rebase_i(opts) && next > 0) {
2634 const char *done = rebase_path_done();
2635 int fd = open(done, O_CREAT | O_WRONLY | O_APPEND, 0666);
2636 int ret = 0;
1df6df0c 2637
a01c2a5f
JS
2638 if (fd < 0)
2639 return 0;
2640 if (write_in_full(fd, get_item_line(todo_list, next - 1),
2641 get_item_line_length(todo_list, next - 1))
2642 < 0)
2643 ret = error_errno(_("could not write to '%s'"), done);
2644 if (close(fd) < 0)
2645 ret = error_errno(_("failed to finalize '%s'"), done);
2646 return ret;
1df6df0c 2647 }
221675de 2648 return 0;
043a4492
RR
2649}
2650
88d5a271 2651static int save_opts(struct replay_opts *opts)
043a4492 2652{
f932729c 2653 const char *opts_file = git_path_opts_file();
88d5a271 2654 int res = 0;
043a4492
RR
2655
2656 if (opts->no_commit)
88d5a271 2657 res |= git_config_set_in_file_gently(opts_file, "options.no-commit", "true");
043a4492 2658 if (opts->edit)
88d5a271 2659 res |= git_config_set_in_file_gently(opts_file, "options.edit", "true");
043a4492 2660 if (opts->signoff)
88d5a271 2661 res |= git_config_set_in_file_gently(opts_file, "options.signoff", "true");
043a4492 2662 if (opts->record_origin)
88d5a271 2663 res |= git_config_set_in_file_gently(opts_file, "options.record-origin", "true");
043a4492 2664 if (opts->allow_ff)
88d5a271 2665 res |= git_config_set_in_file_gently(opts_file, "options.allow-ff", "true");
043a4492
RR
2666 if (opts->mainline) {
2667 struct strbuf buf = STRBUF_INIT;
2668 strbuf_addf(&buf, "%d", opts->mainline);
88d5a271 2669 res |= git_config_set_in_file_gently(opts_file, "options.mainline", buf.buf);
043a4492
RR
2670 strbuf_release(&buf);
2671 }
2672 if (opts->strategy)
88d5a271 2673 res |= git_config_set_in_file_gently(opts_file, "options.strategy", opts->strategy);
3253553e 2674 if (opts->gpg_sign)
88d5a271 2675 res |= git_config_set_in_file_gently(opts_file, "options.gpg-sign", opts->gpg_sign);
043a4492
RR
2676 if (opts->xopts) {
2677 int i;
2678 for (i = 0; i < opts->xopts_nr; i++)
88d5a271 2679 res |= git_config_set_multivar_in_file_gently(opts_file,
043a4492
RR
2680 "options.strategy-option",
2681 opts->xopts[i], "^$", 0);
2682 }
8d8cb4b0
PW
2683 if (opts->allow_rerere_auto)
2684 res |= git_config_set_in_file_gently(opts_file, "options.allow-rerere-auto",
2685 opts->allow_rerere_auto == RERERE_AUTOUPDATE ?
2686 "true" : "false");
88d5a271 2687 return res;
043a4492
RR
2688}
2689
f11c9580
NTND
2690static int make_patch(struct repository *r,
2691 struct commit *commit,
2692 struct replay_opts *opts)
56dc3ab0
JS
2693{
2694 struct strbuf buf = STRBUF_INIT;
2695 struct rev_info log_tree_opt;
2696 const char *subject, *p;
2697 int res = 0;
2698
2699 p = short_commit_name(commit);
2700 if (write_message(p, strlen(p), rebase_path_stopped_sha(), 1) < 0)
2701 return -1;
fbd7a232
NTND
2702 if (update_ref("rebase", "REBASE_HEAD", &commit->object.oid,
2703 NULL, REF_NO_DEREF, UPDATE_REFS_MSG_ON_ERR))
2704 res |= error(_("could not update %s"), "REBASE_HEAD");
56dc3ab0
JS
2705
2706 strbuf_addf(&buf, "%s/patch", get_dir(opts));
2707 memset(&log_tree_opt, 0, sizeof(log_tree_opt));
f11c9580 2708 repo_init_revisions(r, &log_tree_opt, NULL);
56dc3ab0
JS
2709 log_tree_opt.abbrev = 0;
2710 log_tree_opt.diff = 1;
2711 log_tree_opt.diffopt.output_format = DIFF_FORMAT_PATCH;
2712 log_tree_opt.disable_stdin = 1;
2713 log_tree_opt.no_commit_id = 1;
2714 log_tree_opt.diffopt.file = fopen(buf.buf, "w");
2715 log_tree_opt.diffopt.use_color = GIT_COLOR_NEVER;
2716 if (!log_tree_opt.diffopt.file)
2717 res |= error_errno(_("could not open '%s'"), buf.buf);
2718 else {
2719 res |= log_tree_commit(&log_tree_opt, commit);
2720 fclose(log_tree_opt.diffopt.file);
2721 }
2722 strbuf_reset(&buf);
2723
2724 strbuf_addf(&buf, "%s/message", get_dir(opts));
2725 if (!file_exists(buf.buf)) {
2726 const char *commit_buffer = get_commit_buffer(commit, NULL);
2727 find_commit_subject(commit_buffer, &subject);
2728 res |= write_message(subject, strlen(subject), buf.buf, 1);
2729 unuse_commit_buffer(commit, commit_buffer);
2730 }
2731 strbuf_release(&buf);
2732
2733 return res;
2734}
2735
2736static int intend_to_amend(void)
2737{
092bbcdf 2738 struct object_id head;
56dc3ab0
JS
2739 char *p;
2740
092bbcdf 2741 if (get_oid("HEAD", &head))
56dc3ab0
JS
2742 return error(_("cannot read HEAD"));
2743
092bbcdf 2744 p = oid_to_hex(&head);
56dc3ab0
JS
2745 return write_message(p, strlen(p), rebase_path_amend(), 1);
2746}
2747
f11c9580
NTND
2748static int error_with_patch(struct repository *r,
2749 struct commit *commit,
2750 const char *subject, int subject_len,
2751 struct replay_opts *opts,
2752 int exit_code, int to_amend)
56dc3ab0 2753{
bc9238bb 2754 if (commit) {
f11c9580 2755 if (make_patch(r, commit, opts))
bc9238bb 2756 return -1;
5a5c5e95 2757 } else if (copy_file(rebase_path_message(),
f11c9580 2758 git_path_merge_msg(r), 0666))
bc9238bb 2759 return error(_("unable to copy '%s' to '%s'"),
f11c9580 2760 git_path_merge_msg(r), rebase_path_message());
56dc3ab0
JS
2761
2762 if (to_amend) {
2763 if (intend_to_amend())
2764 return -1;
2765
02127c63
NTND
2766 fprintf(stderr,
2767 _("You can amend the commit now, with\n"
2768 "\n"
2769 " git commit --amend %s\n"
2770 "\n"
2771 "Once you are satisfied with your changes, run\n"
2772 "\n"
2773 " git rebase --continue\n"),
2774 gpg_sign_opt_quoted(opts));
bc9238bb
PW
2775 } else if (exit_code) {
2776 if (commit)
5a5c5e95
JH
2777 fprintf_ln(stderr, _("Could not apply %s... %.*s"),
2778 short_commit_name(commit), subject_len, subject);
bc9238bb
PW
2779 else
2780 /*
2781 * We don't have the hash of the parent so
2782 * just print the line from the todo file.
2783 */
5a5c5e95
JH
2784 fprintf_ln(stderr, _("Could not merge %.*s"),
2785 subject_len, subject);
bc9238bb 2786 }
56dc3ab0
JS
2787
2788 return exit_code;
2789}
2790
f11c9580
NTND
2791static int error_failed_squash(struct repository *r,
2792 struct commit *commit,
2793 struct replay_opts *opts,
2794 int subject_len,
2795 const char *subject)
6e98de72 2796{
e12a7ef5
JS
2797 if (copy_file(rebase_path_message(), rebase_path_squash_msg(), 0666))
2798 return error(_("could not copy '%s' to '%s'"),
6e98de72 2799 rebase_path_squash_msg(), rebase_path_message());
f11c9580
NTND
2800 unlink(git_path_merge_msg(r));
2801 if (copy_file(git_path_merge_msg(r), rebase_path_message(), 0666))
6e98de72 2802 return error(_("could not copy '%s' to '%s'"),
102de880 2803 rebase_path_message(),
f11c9580
NTND
2804 git_path_merge_msg(r));
2805 return error_with_patch(r, commit, subject, subject_len, opts, 1, 0);
6e98de72
JS
2806}
2807
f11c9580 2808static int do_exec(struct repository *r, const char *command_line)
311af526 2809{
09d7b6c6 2810 struct argv_array child_env = ARGV_ARRAY_INIT;
311af526
JS
2811 const char *child_argv[] = { NULL, NULL };
2812 int dirty, status;
2813
2814 fprintf(stderr, "Executing: %s\n", command_line);
2815 child_argv[0] = command_line;
09d7b6c6 2816 argv_array_pushf(&child_env, "GIT_DIR=%s", absolute_path(get_git_dir()));
ab5e67d7 2817 argv_array_pushf(&child_env, "GIT_WORK_TREE=%s",
2818 absolute_path(get_git_work_tree()));
09d7b6c6
JK
2819 status = run_command_v_opt_cd_env(child_argv, RUN_USING_SHELL, NULL,
2820 child_env.argv);
311af526
JS
2821
2822 /* force re-reading of the cache */
f11c9580 2823 if (discard_index(r->index) < 0 || read_index(r->index) < 0)
311af526
JS
2824 return error(_("could not read index"));
2825
f11c9580 2826 dirty = require_clean_work_tree(r, "rebase", NULL, 1, 1);
311af526
JS
2827
2828 if (status) {
2829 warning(_("execution failed: %s\n%s"
2830 "You can fix the problem, and then run\n"
2831 "\n"
2832 " git rebase --continue\n"
2833 "\n"),
2834 command_line,
2835 dirty ? N_("and made changes to the index and/or the "
2836 "working tree\n") : "");
2837 if (status == 127)
2838 /* command not found */
2839 status = 1;
2840 } else if (dirty) {
2841 warning(_("execution succeeded: %s\nbut "
2842 "left changes to the index and/or the working tree\n"
2843 "Commit or stash your changes, and then run\n"
2844 "\n"
2845 " git rebase --continue\n"
2846 "\n"), command_line);
2847 status = 1;
2848 }
2849
09d7b6c6
JK
2850 argv_array_clear(&child_env);
2851
311af526
JS
2852 return status;
2853}
2854
9055e401
JS
2855static int safe_append(const char *filename, const char *fmt, ...)
2856{
2857 va_list ap;
2858 struct lock_file lock = LOCK_INIT;
2859 int fd = hold_lock_file_for_update(&lock, filename,
2860 LOCK_REPORT_ON_ERROR);
2861 struct strbuf buf = STRBUF_INIT;
2862
2863 if (fd < 0)
2864 return -1;
2865
2866 if (strbuf_read_file(&buf, filename, 0) < 0 && errno != ENOENT) {
2867 error_errno(_("could not read '%s'"), filename);
2868 rollback_lock_file(&lock);
2869 return -1;
2870 }
2871 strbuf_complete(&buf, '\n');
2872 va_start(ap, fmt);
2873 strbuf_vaddf(&buf, fmt, ap);
2874 va_end(ap);
2875
2876 if (write_in_full(fd, buf.buf, buf.len) < 0) {
2877 error_errno(_("could not write to '%s'"), filename);
2878 strbuf_release(&buf);
2879 rollback_lock_file(&lock);
2880 return -1;
2881 }
2882 if (commit_lock_file(&lock) < 0) {
2883 strbuf_release(&buf);
2884 rollback_lock_file(&lock);
2885 return error(_("failed to finalize '%s'"), filename);
2886 }
2887
2888 strbuf_release(&buf);
2889 return 0;
2890}
2891
f11c9580 2892static int do_label(struct repository *r, const char *name, int len)
9055e401 2893{
f11c9580 2894 struct ref_store *refs = get_main_ref_store(r);
9055e401
JS
2895 struct ref_transaction *transaction;
2896 struct strbuf ref_name = STRBUF_INIT, err = STRBUF_INIT;
2897 struct strbuf msg = STRBUF_INIT;
2898 int ret = 0;
2899 struct object_id head_oid;
2900
2901 if (len == 1 && *name == '#')
02127c63 2902 return error(_("illegal label name: '%.*s'"), len, name);
9055e401
JS
2903
2904 strbuf_addf(&ref_name, "refs/rewritten/%.*s", len, name);
2905 strbuf_addf(&msg, "rebase -i (label) '%.*s'", len, name);
2906
2907 transaction = ref_store_transaction_begin(refs, &err);
2908 if (!transaction) {
2909 error("%s", err.buf);
2910 ret = -1;
2911 } else if (get_oid("HEAD", &head_oid)) {
2912 error(_("could not read HEAD"));
2913 ret = -1;
2914 } else if (ref_transaction_update(transaction, ref_name.buf, &head_oid,
2915 NULL, 0, msg.buf, &err) < 0 ||
2916 ref_transaction_commit(transaction, &err)) {
2917 error("%s", err.buf);
2918 ret = -1;
2919 }
2920 ref_transaction_free(transaction);
2921 strbuf_release(&err);
2922 strbuf_release(&msg);
2923
2924 if (!ret)
2925 ret = safe_append(rebase_path_refs_to_delete(),
2926 "%s\n", ref_name.buf);
2927 strbuf_release(&ref_name);
2928
2929 return ret;
2930}
2931
2932static const char *reflog_message(struct replay_opts *opts,
2933 const char *sub_action, const char *fmt, ...);
2934
f11c9580
NTND
2935static int do_reset(struct repository *r,
2936 const char *name, int len,
2937 struct replay_opts *opts)
9055e401
JS
2938{
2939 struct strbuf ref_name = STRBUF_INIT;
2940 struct object_id oid;
2941 struct lock_file lock = LOCK_INIT;
2942 struct tree_desc desc;
2943 struct tree *tree;
2944 struct unpack_trees_options unpack_tree_opts;
71571cd7 2945 int ret = 0;
9055e401
JS
2946
2947 if (hold_locked_index(&lock, LOCK_REPORT_ON_ERROR) < 0)
2948 return -1;
2949
ebddf393
JS
2950 if (len == 10 && !strncmp("[new root]", name, len)) {
2951 if (!opts->have_squash_onto) {
2952 const char *hex;
2953 if (commit_tree("", 0, the_hash_algo->empty_tree,
2954 NULL, &opts->squash_onto,
2955 NULL, NULL))
2956 return error(_("writing fake root commit"));
2957 opts->have_squash_onto = 1;
2958 hex = oid_to_hex(&opts->squash_onto);
2959 if (write_message(hex, strlen(hex),
2960 rebase_path_squash_onto(), 0))
2961 return error(_("writing squash-onto"));
2962 }
2963 oidcpy(&oid, &opts->squash_onto);
2964 } else {
71571cd7
2965 int i;
2966
ebddf393
JS
2967 /* Determine the length of the label */
2968 for (i = 0; i < len; i++)
2969 if (isspace(name[i]))
71571cd7
2970 break;
2971 len = i;
ebddf393
JS
2972
2973 strbuf_addf(&ref_name, "refs/rewritten/%.*s", len, name);
2974 if (get_oid(ref_name.buf, &oid) &&
2975 get_oid(ref_name.buf + strlen("refs/rewritten/"), &oid)) {
2976 error(_("could not read '%s'"), ref_name.buf);
2977 rollback_lock_file(&lock);
2978 strbuf_release(&ref_name);
2979 return -1;
2980 }
9055e401
JS
2981 }
2982
2983 memset(&unpack_tree_opts, 0, sizeof(unpack_tree_opts));
2984 setup_unpack_trees_porcelain(&unpack_tree_opts, "reset");
2985 unpack_tree_opts.head_idx = 1;
f11c9580
NTND
2986 unpack_tree_opts.src_index = r->index;
2987 unpack_tree_opts.dst_index = r->index;
9055e401
JS
2988 unpack_tree_opts.fn = oneway_merge;
2989 unpack_tree_opts.merge = 1;
2990 unpack_tree_opts.update = 1;
2991
f11c9580 2992 if (read_index_unmerged(r->index)) {
9055e401
JS
2993 rollback_lock_file(&lock);
2994 strbuf_release(&ref_name);
2995 return error_resolve_conflict(_(action_name(opts)));
2996 }
2997
2998 if (!fill_tree_descriptor(&desc, &oid)) {
2999 error(_("failed to find tree of %s"), oid_to_hex(&oid));
3000 rollback_lock_file(&lock);
3001 free((void *)desc.buffer);
3002 strbuf_release(&ref_name);
3003 return -1;
3004 }
3005
3006 if (unpack_trees(1, &desc, &unpack_tree_opts)) {
3007 rollback_lock_file(&lock);
3008 free((void *)desc.buffer);
3009 strbuf_release(&ref_name);
3010 return -1;
3011 }
3012
3013 tree = parse_tree_indirect(&oid);
c207e9e1 3014 prime_cache_tree(r, r->index, tree);
9055e401 3015
f11c9580 3016 if (write_locked_index(r->index, &lock, COMMIT_LOCK) < 0)
9055e401
JS
3017 ret = error(_("could not write index"));
3018 free((void *)desc.buffer);
3019
3020 if (!ret)
3021 ret = update_ref(reflog_message(opts, "reset", "'%.*s'",
3022 len, name), "HEAD", &oid,
3023 NULL, 0, UPDATE_REFS_MSG_ON_ERR);
3024
3025 strbuf_release(&ref_name);
3026 return ret;
3027}
3028
2b6ad0f4
JS
3029static struct commit *lookup_label(const char *label, int len,
3030 struct strbuf *buf)
3031{
3032 struct commit *commit;
3033
3034 strbuf_reset(buf);
3035 strbuf_addf(buf, "refs/rewritten/%.*s", len, label);
3036 commit = lookup_commit_reference_by_name(buf->buf);
3037 if (!commit) {
3038 /* fall back to non-rewritten ref or commit */
3039 strbuf_splice(buf, 0, strlen("refs/rewritten/"), "", 0);
3040 commit = lookup_commit_reference_by_name(buf->buf);
3041 }
3042
3043 if (!commit)
3044 error(_("could not resolve '%s'"), buf->buf);
3045
3046 return commit;
3047}
3048
f11c9580
NTND
3049static int do_merge(struct repository *r,
3050 struct commit *commit,
3051 const char *arg, int arg_len,
4c68e7dd
JS
3052 int flags, struct replay_opts *opts)
3053{
3054 int run_commit_flags = (flags & TODO_EDIT_MERGE_MSG) ?
3055 EDIT_MSG | VERIFY_MSG : 0;
3056 struct strbuf ref_name = STRBUF_INIT;
3057 struct commit *head_commit, *merge_commit, *i;
3058 struct commit_list *bases, *j, *reversed = NULL;
2b6ad0f4 3059 struct commit_list *to_merge = NULL, **tail = &to_merge;
4c68e7dd 3060 struct merge_options o;
2b6ad0f4 3061 int merge_arg_len, oneline_offset, can_fast_forward, ret, k;
4c68e7dd
JS
3062 static struct lock_file lock;
3063 const char *p;
3064
3065 if (hold_locked_index(&lock, LOCK_REPORT_ON_ERROR) < 0) {
3066 ret = -1;
3067 goto leave_merge;
3068 }
3069
3070 head_commit = lookup_commit_reference_by_name("HEAD");
3071 if (!head_commit) {
3072 ret = error(_("cannot merge without a current revision"));
3073 goto leave_merge;
3074 }
3075
2b6ad0f4
JS
3076 /*
3077 * For octopus merges, the arg starts with the list of revisions to be
3078 * merged. The list is optionally followed by '#' and the oneline.
3079 */
3080 merge_arg_len = oneline_offset = arg_len;
3081 for (p = arg; p - arg < arg_len; p += strspn(p, " \t\n")) {
3082 if (!*p)
3083 break;
3084 if (*p == '#' && (!p[1] || isspace(p[1]))) {
3085 p += 1 + strspn(p + 1, " \t\n");
3086 oneline_offset = p - arg;
3087 break;
3088 }
3089 k = strcspn(p, " \t\n");
3090 if (!k)
3091 continue;
3092 merge_commit = lookup_label(p, k, &ref_name);
3093 if (!merge_commit) {
3094 ret = error(_("unable to parse '%.*s'"), k, p);
3095 goto leave_merge;
3096 }
3097 tail = &commit_list_insert(merge_commit, tail)->next;
3098 p += k;
3099 merge_arg_len = p - arg;
4c68e7dd
JS
3100 }
3101
2b6ad0f4
JS
3102 if (!to_merge) {
3103 ret = error(_("nothing to merge: '%.*s'"), arg_len, arg);
4c68e7dd
JS
3104 goto leave_merge;
3105 }
3106
9c85a1c2 3107 if (opts->have_squash_onto &&
4a7e27e9 3108 oideq(&head_commit->object.oid, &opts->squash_onto)) {
9c85a1c2
JS
3109 /*
3110 * When the user tells us to "merge" something into a
3111 * "[new root]", let's simply fast-forward to the merge head.
3112 */
3113 rollback_lock_file(&lock);
2b6ad0f4
JS
3114 if (to_merge->next)
3115 ret = error(_("octopus merge cannot be executed on "
3116 "top of a [new root]"));
3117 else
f11c9580 3118 ret = fast_forward_to(r, &to_merge->item->object.oid,
2b6ad0f4
JS
3119 &head_commit->object.oid, 0,
3120 opts);
9c85a1c2
JS
3121 goto leave_merge;
3122 }
3123
4c68e7dd
JS
3124 if (commit) {
3125 const char *message = get_commit_buffer(commit, NULL);
3126 const char *body;
3127 int len;
3128
3129 if (!message) {
3130 ret = error(_("could not get commit message of '%s'"),
3131 oid_to_hex(&commit->object.oid));
3132 goto leave_merge;
3133 }
3134 write_author_script(message);
3135 find_commit_subject(message, &body);
3136 len = strlen(body);
f11c9580 3137 ret = write_message(body, len, git_path_merge_msg(r), 0);
4c68e7dd
JS
3138 unuse_commit_buffer(commit, message);
3139 if (ret) {
3140 error_errno(_("could not write '%s'"),
f11c9580 3141 git_path_merge_msg(r));
4c68e7dd
JS
3142 goto leave_merge;
3143 }
3144 } else {
3145 struct strbuf buf = STRBUF_INIT;
3146 int len;
3147
3148 strbuf_addf(&buf, "author %s", git_author_info(0));
3149 write_author_script(buf.buf);
3150 strbuf_reset(&buf);
3151
3152 if (oneline_offset < arg_len) {
3153 p = arg + oneline_offset;
3154 len = arg_len - oneline_offset;
3155 } else {
2b6ad0f4
JS
3156 strbuf_addf(&buf, "Merge %s '%.*s'",
3157 to_merge->next ? "branches" : "branch",
4c68e7dd
JS
3158 merge_arg_len, arg);
3159 p = buf.buf;
3160 len = buf.len;
3161 }
3162
f11c9580 3163 ret = write_message(p, len, git_path_merge_msg(r), 0);
4c68e7dd
JS
3164 strbuf_release(&buf);
3165 if (ret) {
3166 error_errno(_("could not write '%s'"),
f11c9580 3167 git_path_merge_msg(r));
4c68e7dd
JS
3168 goto leave_merge;
3169 }
3170 }
3171
d1e8b011
JS
3172 /*
3173 * If HEAD is not identical to the first parent of the original merge
3174 * commit, we cannot fast-forward.
3175 */
3176 can_fast_forward = opts->allow_ff && commit && commit->parents &&
4a7e27e9
JK
3177 oideq(&commit->parents->item->object.oid,
3178 &head_commit->object.oid);
d1e8b011
JS
3179
3180 /*
2b6ad0f4 3181 * If any merge head is different from the original one, we cannot
d1e8b011
JS
3182 * fast-forward.
3183 */
3184 if (can_fast_forward) {
2b6ad0f4 3185 struct commit_list *p = commit->parents->next;
d1e8b011 3186
2b6ad0f4 3187 for (j = to_merge; j && p; j = j->next, p = p->next)
9001dc2a 3188 if (!oideq(&j->item->object.oid,
2b6ad0f4
JS
3189 &p->item->object.oid)) {
3190 can_fast_forward = 0;
3191 break;
3192 }
3193 /*
3194 * If the number of merge heads differs from the original merge
3195 * commit, we cannot fast-forward.
3196 */
3197 if (j || p)
d1e8b011
JS
3198 can_fast_forward = 0;
3199 }
3200
2b6ad0f4 3201 if (can_fast_forward) {
d1e8b011 3202 rollback_lock_file(&lock);
f11c9580 3203 ret = fast_forward_to(r, &commit->object.oid,
d1e8b011
JS
3204 &head_commit->object.oid, 0, opts);
3205 goto leave_merge;
3206 }
3207
2b6ad0f4
JS
3208 if (to_merge->next) {
3209 /* Octopus merge */
3210 struct child_process cmd = CHILD_PROCESS_INIT;
3211
3212 if (read_env_script(&cmd.env_array)) {
3213 const char *gpg_opt = gpg_sign_opt_quoted(opts);
3214
3215 ret = error(_(staged_changes_advice), gpg_opt, gpg_opt);
3216 goto leave_merge;
3217 }
3218
3219 cmd.git_cmd = 1;
3220 argv_array_push(&cmd.args, "merge");
3221 argv_array_push(&cmd.args, "-s");
3222 argv_array_push(&cmd.args, "octopus");
3223 argv_array_push(&cmd.args, "--no-edit");
3224 argv_array_push(&cmd.args, "--no-ff");
3225 argv_array_push(&cmd.args, "--no-log");
3226 argv_array_push(&cmd.args, "--no-stat");
3227 argv_array_push(&cmd.args, "-F");
f11c9580 3228 argv_array_push(&cmd.args, git_path_merge_msg(r));
2b6ad0f4
JS
3229 if (opts->gpg_sign)
3230 argv_array_push(&cmd.args, opts->gpg_sign);
3231
3232 /* Add the tips to be merged */
3233 for (j = to_merge; j; j = j->next)
3234 argv_array_push(&cmd.args,
3235 oid_to_hex(&j->item->object.oid));
3236
3237 strbuf_release(&ref_name);
f11c9580 3238 unlink(git_path_cherry_pick_head(r));
2b6ad0f4
JS
3239 rollback_lock_file(&lock);
3240
3241 rollback_lock_file(&lock);
3242 ret = run_command(&cmd);
3243
3244 /* force re-reading of the cache */
f11c9580
NTND
3245 if (!ret && (discard_index(r->index) < 0 ||
3246 read_index(r->index) < 0))
2b6ad0f4
JS
3247 ret = error(_("could not read index"));
3248 goto leave_merge;
3249 }
3250
3251 merge_commit = to_merge->item;
4c68e7dd 3252 bases = get_merge_bases(head_commit, merge_commit);
4a7e27e9
JK
3253 if (bases && oideq(&merge_commit->object.oid,
3254 &bases->item->object.oid)) {
7ccdf65b
JS
3255 ret = 0;
3256 /* skip merging an ancestor of HEAD */
3257 goto leave_merge;
3258 }
3259
85f8d9da 3260 write_message(oid_to_hex(&merge_commit->object.oid), GIT_SHA1_HEXSZ,
cde55548
JH
3261 git_path_merge_head(r), 0);
3262 write_message("no-ff", 5, git_path_merge_mode(r), 0);
85f8d9da 3263
4c68e7dd
JS
3264 for (j = bases; j; j = j->next)
3265 commit_list_insert(j->item, &reversed);
3266 free_commit_list(bases);
3267
f11c9580 3268 read_index(r->index);
4c68e7dd
JS
3269 init_merge_options(&o);
3270 o.branch1 = "HEAD";
3271 o.branch2 = ref_name.buf;
3272 o.buffer_output = 2;
3273
3274 ret = merge_recursive(&o, head_commit, merge_commit, reversed, &i);
3275 if (ret <= 0)
3276 fputs(o.obuf.buf, stdout);
3277 strbuf_release(&o.obuf);
3278 if (ret < 0) {
3279 error(_("could not even attempt to merge '%.*s'"),
3280 merge_arg_len, arg);
3281 goto leave_merge;
3282 }
3283 /*
3284 * The return value of merge_recursive() is 1 on clean, and 0 on
3285 * unclean merge.
3286 *
3287 * Let's reverse that, so that do_merge() returns 0 upon success and
3288 * 1 upon failed merge (keeping the return value -1 for the cases where
3289 * we will want to reschedule the `merge` command).
3290 */
3291 ret = !ret;
3292
f11c9580
NTND
3293 if (r->index->cache_changed &&
3294 write_locked_index(r->index, &lock, COMMIT_LOCK)) {
4c68e7dd
JS
3295 ret = error(_("merge: Unable to write new index file"));
3296 goto leave_merge;
3297 }
3298
3299 rollback_lock_file(&lock);
3300 if (ret)
f11c9580 3301 repo_rerere(r, opts->allow_rerere_auto);
4c68e7dd
JS
3302 else
3303 /*
3304 * In case of problems, we now want to return a positive
3305 * value (a negative one would indicate that the `merge`
3306 * command needs to be rescheduled).
3307 */
f11c9580
NTND
3308 ret = !!run_git_commit(r, git_path_merge_msg(r), opts,
3309 run_commit_flags);
4c68e7dd
JS
3310
3311leave_merge:
3312 strbuf_release(&ref_name);
3313 rollback_lock_file(&lock);
2b6ad0f4 3314 free_commit_list(to_merge);
4c68e7dd
JS
3315 return ret;
3316}
3317
6e98de72
JS
3318static int is_final_fixup(struct todo_list *todo_list)
3319{
3320 int i = todo_list->current;
3321
3322 if (!is_fixup(todo_list->items[i].command))
3323 return 0;
3324
3325 while (++i < todo_list->nr)
3326 if (is_fixup(todo_list->items[i].command))
3327 return 0;
3328 else if (!is_noop(todo_list->items[i].command))
3329 break;
3330 return 1;
3331}
3332
25cb8df9
JS
3333static enum todo_command peek_command(struct todo_list *todo_list, int offset)
3334{
3335 int i;
3336
3337 for (i = todo_list->current + offset; i < todo_list->nr; i++)
3338 if (!is_noop(todo_list->items[i].command))
3339 return todo_list->items[i].command;
3340
3341 return -1;
3342}
3343
796c7972
JS
3344static int apply_autostash(struct replay_opts *opts)
3345{
3346 struct strbuf stash_sha1 = STRBUF_INIT;
3347 struct child_process child = CHILD_PROCESS_INIT;
3348 int ret = 0;
3349
3350 if (!read_oneliner(&stash_sha1, rebase_path_autostash(), 1)) {
3351 strbuf_release(&stash_sha1);
3352 return 0;
3353 }
3354 strbuf_trim(&stash_sha1);
3355
3356 child.git_cmd = 1;
79a62269
PW
3357 child.no_stdout = 1;
3358 child.no_stderr = 1;
796c7972
JS
3359 argv_array_push(&child.args, "stash");
3360 argv_array_push(&child.args, "apply");
3361 argv_array_push(&child.args, stash_sha1.buf);
3362 if (!run_command(&child))
cdb866b3 3363 fprintf(stderr, _("Applied autostash.\n"));
796c7972
JS
3364 else {
3365 struct child_process store = CHILD_PROCESS_INIT;
3366
3367 store.git_cmd = 1;
3368 argv_array_push(&store.args, "stash");
3369 argv_array_push(&store.args, "store");
3370 argv_array_push(&store.args, "-m");
3371 argv_array_push(&store.args, "autostash");
3372 argv_array_push(&store.args, "-q");
3373 argv_array_push(&store.args, stash_sha1.buf);
3374 if (run_command(&store))
3375 ret = error(_("cannot store %s"), stash_sha1.buf);
3376 else
cdb866b3
JS
3377 fprintf(stderr,
3378 _("Applying autostash resulted in conflicts.\n"
3379 "Your changes are safe in the stash.\n"
3380 "You can run \"git stash pop\" or"
3381 " \"git stash drop\" at any time.\n"));
796c7972
JS
3382 }
3383
3384 strbuf_release(&stash_sha1);
3385 return ret;
3386}
3387
96e832a5
JS
3388static const char *reflog_message(struct replay_opts *opts,
3389 const char *sub_action, const char *fmt, ...)
3390{
3391 va_list ap;
3392 static struct strbuf buf = STRBUF_INIT;
3393
3394 va_start(ap, fmt);
3395 strbuf_reset(&buf);
3396 strbuf_addstr(&buf, action_name(opts));
3397 if (sub_action)
3398 strbuf_addf(&buf, " (%s)", sub_action);
3399 if (fmt) {
3400 strbuf_addstr(&buf, ": ");
3401 strbuf_vaddf(&buf, fmt, ap);
3402 }
3403 va_end(ap);
3404
3405 return buf.buf;
3406}
3407
2c58483a
AG
3408static int run_git_checkout(struct replay_opts *opts, const char *commit,
3409 const char *action)
3410{
3411 struct child_process cmd = CHILD_PROCESS_INIT;
3412
3413 cmd.git_cmd = 1;
3414
3415 argv_array_push(&cmd.args, "checkout");
3416 argv_array_push(&cmd.args, commit);
3417 argv_array_pushf(&cmd.env_array, GIT_REFLOG_ACTION "=%s", action);
3418
3419 if (opts->verbose)
3420 return run_command(&cmd);
3421 else
3422 return run_command_silent_on_success(&cmd);
3423}
3424
3425int prepare_branch_to_be_rebased(struct replay_opts *opts, const char *commit)
3426{
3427 const char *action;
3428
3429 if (commit && *commit) {
3430 action = reflog_message(opts, "start", "checkout %s", commit);
3431 if (run_git_checkout(opts, commit, action))
3432 return error(_("could not checkout %s"), commit);
3433 }
3434
3435 return 0;
3436}
3437
91f0d95d
AG
3438static int checkout_onto(struct replay_opts *opts,
3439 const char *onto_name, const char *onto,
3440 const char *orig_head)
4df66c40
AG
3441{
3442 struct object_id oid;
3443 const char *action = reflog_message(opts, "start", "checkout %s", onto_name);
3444
3445 if (get_oid(orig_head, &oid))
3446 return error(_("%s: not a valid OID"), orig_head);
3447
3448 if (run_git_checkout(opts, onto, action)) {
3449 apply_autostash(opts);
3450 sequencer_remove_state(opts);
3451 return error(_("could not detach HEAD"));
3452 }
3453
3454 return update_ref(NULL, "ORIG_HEAD", &oid, NULL, 0, UPDATE_REFS_MSG_ON_ERR);
3455}
3456
005af339 3457static int stopped_at_head(struct repository *r)
71f82465
JS
3458{
3459 struct object_id head;
3460 struct commit *commit;
3461 struct commit_message message;
3462
789b1f70 3463 if (get_oid("HEAD", &head) ||
005af339 3464 !(commit = lookup_commit(r, &head)) ||
71f82465
JS
3465 parse_commit(commit) || get_message(commit, &message))
3466 fprintf(stderr, _("Stopped at HEAD\n"));
3467 else {
3468 fprintf(stderr, _("Stopped at %s\n"), message.label);
3469 free_message(commit, &message);
3470 }
3471 return 0;
3472
3473}
3474
cb5206ea
JS
3475static const char rescheduled_advice[] =
3476N_("Could not execute the todo command\n"
3477"\n"
3478" %.*s"
3479"\n"
3480"It has been rescheduled; To edit the command before continuing, please\n"
3481"edit the todo list first:\n"
3482"\n"
3483" git rebase --edit-todo\n"
3484" git rebase --continue\n");
3485
f11c9580
NTND
3486static int pick_commits(struct repository *r,
3487 struct todo_list *todo_list,
3488 struct replay_opts *opts)
043a4492 3489{
9055e401 3490 int res = 0, reschedule = 0;
043a4492
RR
3491
3492 setenv(GIT_REFLOG_ACTION, action_name(opts), 0);
3493 if (opts->allow_ff)
3494 assert(!(opts->signoff || opts->no_commit ||
3495 opts->record_origin || opts->edit));
f11c9580 3496 if (read_and_refresh_cache(r, opts))
0d9c6dc9 3497 return -1;
043a4492 3498
004fefa7
JS
3499 while (todo_list->current < todo_list->nr) {
3500 struct todo_item *item = todo_list->items + todo_list->current;
6ad656db
AG
3501 const char *arg = todo_item_get_arg(todo_list, item);
3502
004fefa7 3503 if (save_todo(todo_list, opts))
221675de 3504 return -1;
6e98de72 3505 if (is_rebase_i(opts)) {
ef80069a
JS
3506 if (item->command != TODO_COMMENT) {
3507 FILE *f = fopen(rebase_path_msgnum(), "w");
3508
3509 todo_list->done_nr++;
3510
3511 if (f) {
3512 fprintf(f, "%d\n", todo_list->done_nr);
3513 fclose(f);
3514 }
968492e4 3515 fprintf(stderr, "Rebasing (%d/%d)%s",
ef80069a 3516 todo_list->done_nr,
968492e4
JS
3517 todo_list->total_nr,
3518 opts->verbose ? "\n" : "\r");
ef80069a 3519 }
6e98de72
JS
3520 unlink(rebase_path_message());
3521 unlink(rebase_path_author_script());
3522 unlink(rebase_path_stopped_sha());
3523 unlink(rebase_path_amend());
69c92209 3524 unlink(git_path_merge_head(the_repository));
fbd7a232 3525 delete_ref(NULL, "REBASE_HEAD", NULL, REF_NO_DEREF);
71f82465
JS
3526
3527 if (item->command == TODO_BREAK)
005af339 3528 return stopped_at_head(r);
6e98de72
JS
3529 }
3530 if (item->command <= TODO_SQUASH) {
8ab37ef2
JS
3531 if (is_rebase_i(opts))
3532 setenv("GIT_REFLOG_ACTION", reflog_message(opts,
3533 command_to_string(item->command), NULL),
3534 1);
f11c9580 3535 res = do_pick_commit(r, item->command, item->commit,
6e98de72 3536 opts, is_final_fixup(todo_list));
9d7bf3cf
JS
3537 if (is_rebase_i(opts) && res < 0) {
3538 /* Reschedule */
cb5206ea
JS
3539 advise(_(rescheduled_advice),
3540 get_item_line_length(todo_list,
3541 todo_list->current),
3542 get_item_line(todo_list,
3543 todo_list->current));
9d7bf3cf
JS
3544 todo_list->current--;
3545 if (save_todo(todo_list, opts))
3546 return -1;
3547 }
56dc3ab0
JS
3548 if (item->command == TODO_EDIT) {
3549 struct commit *commit = item->commit;
3550 if (!res)
99429213 3551 fprintf(stderr,
a42e1b41 3552 _("Stopped at %s... %.*s\n"),
56dc3ab0 3553 short_commit_name(commit),
6ad656db 3554 item->arg_len, arg);
f11c9580 3555 return error_with_patch(r, commit,
6ad656db 3556 arg, item->arg_len, opts, res, !res);
56dc3ab0 3557 }
25cb8df9
JS
3558 if (is_rebase_i(opts) && !res)
3559 record_in_rewritten(&item->commit->object.oid,
3560 peek_command(todo_list, 1));
6e98de72
JS
3561 if (res && is_fixup(item->command)) {
3562 if (res == 1)
3563 intend_to_amend();
f11c9580 3564 return error_failed_squash(r, item->commit, opts,
6ad656db 3565 item->arg_len, arg);
a9279c67
PW
3566 } else if (res && is_rebase_i(opts) && item->commit) {
3567 int to_amend = 0;
3568 struct object_id oid;
3569
3570 /*
3571 * If we are rewording and have either
3572 * fast-forwarded already, or are about to
3573 * create a new root commit, we want to amend,
3574 * otherwise we do not.
3575 */
3576 if (item->command == TODO_REWORD &&
3577 !get_oid("HEAD", &oid) &&
4a7e27e9 3578 (oideq(&item->commit->object.oid, &oid) ||
a9279c67 3579 (opts->have_squash_onto &&
4a7e27e9 3580 oideq(&opts->squash_onto, &oid))))
a9279c67
PW
3581 to_amend = 1;
3582
f11c9580 3583 return res | error_with_patch(r, item->commit,
6ad656db 3584 arg, item->arg_len, opts,
a9279c67
PW
3585 res, to_amend);
3586 }
311af526 3587 } else if (item->command == TODO_EXEC) {
6ad656db 3588 char *end_of_arg = (char *)(arg + item->arg_len);
311af526 3589 int saved = *end_of_arg;
54fd3243 3590 struct stat st;
311af526
JS
3591
3592 *end_of_arg = '\0';
6ad656db 3593 res = do_exec(r, arg);
311af526 3594 *end_of_arg = saved;
54fd3243
SH
3595
3596 /* Reread the todo file if it has changed. */
3597 if (res)