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