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