sequencer: refactor how original todo list lines are accessed
[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
004fefa7 2564static int pick_commits(struct todo_list *todo_list, struct replay_opts *opts)
043a4492 2565{
56dc3ab0 2566 int res = 0;
043a4492
RR
2567
2568 setenv(GIT_REFLOG_ACTION, action_name(opts), 0);
2569 if (opts->allow_ff)
2570 assert(!(opts->signoff || opts->no_commit ||
2571 opts->record_origin || opts->edit));
0d9c6dc9
JS
2572 if (read_and_refresh_cache(opts))
2573 return -1;
043a4492 2574
004fefa7
JS
2575 while (todo_list->current < todo_list->nr) {
2576 struct todo_item *item = todo_list->items + todo_list->current;
2577 if (save_todo(todo_list, opts))
221675de 2578 return -1;
6e98de72 2579 if (is_rebase_i(opts)) {
ef80069a
JS
2580 if (item->command != TODO_COMMENT) {
2581 FILE *f = fopen(rebase_path_msgnum(), "w");
2582
2583 todo_list->done_nr++;
2584
2585 if (f) {
2586 fprintf(f, "%d\n", todo_list->done_nr);
2587 fclose(f);
2588 }
968492e4 2589 fprintf(stderr, "Rebasing (%d/%d)%s",
ef80069a 2590 todo_list->done_nr,
968492e4
JS
2591 todo_list->total_nr,
2592 opts->verbose ? "\n" : "\r");
ef80069a 2593 }
6e98de72
JS
2594 unlink(rebase_path_message());
2595 unlink(rebase_path_author_script());
2596 unlink(rebase_path_stopped_sha());
2597 unlink(rebase_path_amend());
fbd7a232 2598 delete_ref(NULL, "REBASE_HEAD", NULL, REF_NO_DEREF);
6e98de72
JS
2599 }
2600 if (item->command <= TODO_SQUASH) {
8ab37ef2
JS
2601 if (is_rebase_i(opts))
2602 setenv("GIT_REFLOG_ACTION", reflog_message(opts,
2603 command_to_string(item->command), NULL),
2604 1);
25c43667 2605 res = do_pick_commit(item->command, item->commit,
6e98de72 2606 opts, is_final_fixup(todo_list));
9d7bf3cf
JS
2607 if (is_rebase_i(opts) && res < 0) {
2608 /* Reschedule */
2609 todo_list->current--;
2610 if (save_todo(todo_list, opts))
2611 return -1;
2612 }
56dc3ab0
JS
2613 if (item->command == TODO_EDIT) {
2614 struct commit *commit = item->commit;
2615 if (!res)
99429213 2616 fprintf(stderr,
a42e1b41 2617 _("Stopped at %s... %.*s\n"),
56dc3ab0
JS
2618 short_commit_name(commit),
2619 item->arg_len, item->arg);
2620 return error_with_patch(commit,
2621 item->arg, item->arg_len, opts, res,
2622 !res);
2623 }
25cb8df9
JS
2624 if (is_rebase_i(opts) && !res)
2625 record_in_rewritten(&item->commit->object.oid,
2626 peek_command(todo_list, 1));
6e98de72
JS
2627 if (res && is_fixup(item->command)) {
2628 if (res == 1)
2629 intend_to_amend();
2630 return error_failed_squash(item->commit, opts,
2631 item->arg_len, item->arg);
4a5146f9
JS
2632 } else if (res && is_rebase_i(opts))
2633 return res | error_with_patch(item->commit,
04efc8b5
JS
2634 item->arg, item->arg_len, opts, res,
2635 item->command == TODO_REWORD);
311af526
JS
2636 } else if (item->command == TODO_EXEC) {
2637 char *end_of_arg = (char *)(item->arg + item->arg_len);
2638 int saved = *end_of_arg;
54fd3243 2639 struct stat st;
311af526
JS
2640
2641 *end_of_arg = '\0';
2642 res = do_exec(item->arg);
2643 *end_of_arg = saved;
54fd3243
SH
2644
2645 /* Reread the todo file if it has changed. */
2646 if (res)
2647 ; /* fall through */
2648 else if (stat(get_todo_path(opts), &st))
2649 res = error_errno(_("could not stat '%s'"),
2650 get_todo_path(opts));
2651 else if (match_stat_data(&todo_list->stat, &st)) {
2652 todo_list_release(todo_list);
2653 if (read_populate_todo(todo_list, opts))
2654 res = -1; /* message was printed */
2655 /* `current` will be incremented below */
2656 todo_list->current = -1;
2657 }
56dc3ab0 2658 } else if (!is_noop(item->command))
25c43667
JS
2659 return error(_("unknown command %d"), item->command);
2660
004fefa7 2661 todo_list->current++;
043a4492
RR
2662 if (res)
2663 return res;
2664 }
2665
56dc3ab0 2666 if (is_rebase_i(opts)) {
4b83ce9f 2667 struct strbuf head_ref = STRBUF_INIT, buf = STRBUF_INIT;
25cb8df9 2668 struct stat st;
556907f1 2669
56dc3ab0
JS
2670 /* Stopped in the middle, as planned? */
2671 if (todo_list->current < todo_list->nr)
2672 return 0;
556907f1 2673
4b83ce9f
JS
2674 if (read_oneliner(&head_ref, rebase_path_head_name(), 0) &&
2675 starts_with(head_ref.buf, "refs/")) {
96e832a5 2676 const char *msg;
092bbcdf 2677 struct object_id head, orig;
4b83ce9f
JS
2678 int res;
2679
092bbcdf 2680 if (get_oid("HEAD", &head)) {
4b83ce9f
JS
2681 res = error(_("cannot read HEAD"));
2682cleanup_head_ref:
2683 strbuf_release(&head_ref);
2684 strbuf_release(&buf);
2685 return res;
2686 }
2687 if (!read_oneliner(&buf, rebase_path_orig_head(), 0) ||
092bbcdf 2688 get_oid_hex(buf.buf, &orig)) {
4b83ce9f
JS
2689 res = error(_("could not read orig-head"));
2690 goto cleanup_head_ref;
2691 }
4ab867b8 2692 strbuf_reset(&buf);
4b83ce9f
JS
2693 if (!read_oneliner(&buf, rebase_path_onto(), 0)) {
2694 res = error(_("could not read 'onto'"));
2695 goto cleanup_head_ref;
2696 }
96e832a5
JS
2697 msg = reflog_message(opts, "finish", "%s onto %s",
2698 head_ref.buf, buf.buf);
ae077771 2699 if (update_ref(msg, head_ref.buf, &head, &orig,
91774afc 2700 REF_NO_DEREF, UPDATE_REFS_MSG_ON_ERR)) {
4b83ce9f
JS
2701 res = error(_("could not update %s"),
2702 head_ref.buf);
2703 goto cleanup_head_ref;
2704 }
96e832a5 2705 msg = reflog_message(opts, "finish", "returning to %s",
4b83ce9f 2706 head_ref.buf);
96e832a5 2707 if (create_symref("HEAD", head_ref.buf, msg)) {
4b83ce9f
JS
2708 res = error(_("could not update HEAD to %s"),
2709 head_ref.buf);
2710 goto cleanup_head_ref;
2711 }
2712 strbuf_reset(&buf);
2713 }
2714
556907f1
JS
2715 if (opts->verbose) {
2716 struct rev_info log_tree_opt;
2717 struct object_id orig, head;
2718
2719 memset(&log_tree_opt, 0, sizeof(log_tree_opt));
2720 init_revisions(&log_tree_opt, NULL);
2721 log_tree_opt.diff = 1;
2722 log_tree_opt.diffopt.output_format =
2723 DIFF_FORMAT_DIFFSTAT;
2724 log_tree_opt.disable_stdin = 1;
2725
2726 if (read_oneliner(&buf, rebase_path_orig_head(), 0) &&
e82caf38 2727 !get_oid(buf.buf, &orig) &&
2728 !get_oid("HEAD", &head)) {
66f414f8
BW
2729 diff_tree_oid(&orig, &head, "",
2730 &log_tree_opt.diffopt);
556907f1
JS
2731 log_tree_diff_flush(&log_tree_opt);
2732 }
2733 }
25cb8df9
JS
2734 flush_rewritten_pending();
2735 if (!stat(rebase_path_rewritten_list(), &st) &&
2736 st.st_size > 0) {
2737 struct child_process child = CHILD_PROCESS_INIT;
79516045
JS
2738 const char *post_rewrite_hook =
2739 find_hook("post-rewrite");
25cb8df9
JS
2740
2741 child.in = open(rebase_path_rewritten_list(), O_RDONLY);
2742 child.git_cmd = 1;
2743 argv_array_push(&child.args, "notes");
2744 argv_array_push(&child.args, "copy");
2745 argv_array_push(&child.args, "--for-rewrite=rebase");
2746 /* we don't care if this copying failed */
2747 run_command(&child);
79516045
JS
2748
2749 if (post_rewrite_hook) {
2750 struct child_process hook = CHILD_PROCESS_INIT;
2751
2752 hook.in = open(rebase_path_rewritten_list(),
2753 O_RDONLY);
2754 hook.stdout_to_stderr = 1;
2755 argv_array_push(&hook.args, post_rewrite_hook);
2756 argv_array_push(&hook.args, "rebase");
2757 /* we don't care if this hook failed */
2758 run_command(&hook);
2759 }
25cb8df9 2760 }
796c7972 2761 apply_autostash(opts);
25cb8df9 2762
5da4966f
JS
2763 fprintf(stderr, "Successfully rebased and updated %s.\n",
2764 head_ref.buf);
2765
556907f1 2766 strbuf_release(&buf);
4b83ce9f 2767 strbuf_release(&head_ref);
56dc3ab0
JS
2768 }
2769
043a4492
RR
2770 /*
2771 * Sequence of picks finished successfully; cleanup by
2772 * removing the .git/sequencer directory
2773 */
2863584f 2774 return sequencer_remove_state(opts);
043a4492
RR
2775}
2776
2777static int continue_single_pick(void)
2778{
2779 const char *argv[] = { "commit", NULL };
2780
f932729c
JK
2781 if (!file_exists(git_path_cherry_pick_head()) &&
2782 !file_exists(git_path_revert_head()))
043a4492
RR
2783 return error(_("no cherry-pick or revert in progress"));
2784 return run_command_v_opt(argv, RUN_GIT_CMD);
2785}
2786
9d93ccd1
JS
2787static int commit_staged_changes(struct replay_opts *opts)
2788{
789b3eff 2789 unsigned int flags = ALLOW_EMPTY | EDIT_MSG;
9d93ccd1
JS
2790
2791 if (has_unstaged_changes(1))
2792 return error(_("cannot rebase: You have unstaged changes."));
52632209 2793 if (!has_uncommitted_changes(0)) {
ca03e067 2794 const char *cherry_pick_head = git_path_cherry_pick_head();
52632209
JS
2795
2796 if (file_exists(cherry_pick_head) && unlink(cherry_pick_head))
2797 return error(_("could not remove CHERRY_PICK_HEAD"));
9d93ccd1 2798 return 0;
52632209 2799 }
9d93ccd1
JS
2800
2801 if (file_exists(rebase_path_amend())) {
2802 struct strbuf rev = STRBUF_INIT;
092bbcdf 2803 struct object_id head, to_amend;
9d93ccd1 2804
092bbcdf 2805 if (get_oid("HEAD", &head))
9d93ccd1
JS
2806 return error(_("cannot amend non-existing commit"));
2807 if (!read_oneliner(&rev, rebase_path_amend(), 0))
2808 return error(_("invalid file: '%s'"), rebase_path_amend());
092bbcdf 2809 if (get_oid_hex(rev.buf, &to_amend))
9d93ccd1
JS
2810 return error(_("invalid contents: '%s'"),
2811 rebase_path_amend());
092bbcdf 2812 if (oidcmp(&head, &to_amend))
9d93ccd1
JS
2813 return error(_("\nYou have uncommitted changes in your "
2814 "working tree. Please, commit them\n"
2815 "first and then run 'git rebase "
2816 "--continue' again."));
2817
2818 strbuf_release(&rev);
789b3eff 2819 flags |= AMEND_MSG;
9d93ccd1
JS
2820 }
2821
789b3eff 2822 if (run_git_commit(rebase_path_message(), opts, flags))
9d93ccd1
JS
2823 return error(_("could not commit staged changes."));
2824 unlink(rebase_path_amend());
2825 return 0;
2826}
2827
2863584f 2828int sequencer_continue(struct replay_opts *opts)
043a4492 2829{
004fefa7
JS
2830 struct todo_list todo_list = TODO_LIST_INIT;
2831 int res;
043a4492 2832
2863584f
JS
2833 if (read_and_refresh_cache(opts))
2834 return -1;
2835
9d93ccd1
JS
2836 if (is_rebase_i(opts)) {
2837 if (commit_staged_changes(opts))
2838 return -1;
4258a6da 2839 } else if (!file_exists(get_todo_path(opts)))
043a4492 2840 return continue_single_pick();
004fefa7 2841 if (read_populate_opts(opts))
0ae42a03 2842 return -1;
004fefa7
JS
2843 if ((res = read_populate_todo(&todo_list, opts)))
2844 goto release_todo_list;
043a4492 2845
4258a6da
JS
2846 if (!is_rebase_i(opts)) {
2847 /* Verify that the conflict has been resolved */
2848 if (file_exists(git_path_cherry_pick_head()) ||
2849 file_exists(git_path_revert_head())) {
2850 res = continue_single_pick();
2851 if (res)
2852 goto release_todo_list;
2853 }
02f2f56b 2854 if (index_differs_from("HEAD", NULL, 0)) {
4258a6da 2855 res = error_dirty_index(opts);
004fefa7 2856 goto release_todo_list;
4258a6da
JS
2857 }
2858 todo_list.current++;
ca98c6d4
JS
2859 } else if (file_exists(rebase_path_stopped_sha())) {
2860 struct strbuf buf = STRBUF_INIT;
2861 struct object_id oid;
2862
2863 if (read_oneliner(&buf, rebase_path_stopped_sha(), 1) &&
e82caf38 2864 !get_oid_committish(buf.buf, &oid))
ca98c6d4
JS
2865 record_in_rewritten(&oid, peek_command(&todo_list, 0));
2866 strbuf_release(&buf);
043a4492 2867 }
4258a6da 2868
004fefa7
JS
2869 res = pick_commits(&todo_list, opts);
2870release_todo_list:
2871 todo_list_release(&todo_list);
2872 return res;
043a4492
RR
2873}
2874
2875static int single_pick(struct commit *cmit, struct replay_opts *opts)
2876{
2877 setenv(GIT_REFLOG_ACTION, action_name(opts), 0);
004fefa7 2878 return do_pick_commit(opts->action == REPLAY_PICK ?
6e98de72 2879 TODO_PICK : TODO_REVERT, cmit, opts, 0);
043a4492
RR
2880}
2881
2882int sequencer_pick_revisions(struct replay_opts *opts)
2883{
004fefa7 2884 struct todo_list todo_list = TODO_LIST_INIT;
1e43ed98 2885 struct object_id oid;
004fefa7 2886 int i, res;
043a4492 2887
2863584f 2888 assert(opts->revs);
0d9c6dc9
JS
2889 if (read_and_refresh_cache(opts))
2890 return -1;
043a4492 2891
21246dbb 2892 for (i = 0; i < opts->revs->pending.nr; i++) {
1e43ed98 2893 struct object_id oid;
21246dbb
MV
2894 const char *name = opts->revs->pending.objects[i].name;
2895
2896 /* This happens when using --stdin. */
2897 if (!strlen(name))
2898 continue;
2899
1e43ed98 2900 if (!get_oid(name, &oid)) {
bc83266a 2901 if (!lookup_commit_reference_gently(&oid, 1)) {
abef9020 2902 enum object_type type = oid_object_info(&oid,
2903 NULL);
b9b946d4 2904 return error(_("%s: can't cherry-pick a %s"),
debca9d2 2905 name, type_name(type));
7c0b0d8d 2906 }
21246dbb 2907 } else
b9b946d4 2908 return error(_("%s: bad revision"), name);
21246dbb
MV
2909 }
2910
043a4492
RR
2911 /*
2912 * If we were called as "git cherry-pick <commit>", just
2913 * cherry-pick/revert it, set CHERRY_PICK_HEAD /
2914 * REVERT_HEAD, and don't touch the sequencer state.
2915 * This means it is possible to cherry-pick in the middle
2916 * of a cherry-pick sequence.
2917 */
2918 if (opts->revs->cmdline.nr == 1 &&
2919 opts->revs->cmdline.rev->whence == REV_CMD_REV &&
2920 opts->revs->no_walk &&
2921 !opts->revs->cmdline.rev->flags) {
2922 struct commit *cmit;
2923 if (prepare_revision_walk(opts->revs))
b9b946d4 2924 return error(_("revision walk setup failed"));
043a4492
RR
2925 cmit = get_revision(opts->revs);
2926 if (!cmit || get_revision(opts->revs))
b9b946d4 2927 return error("BUG: expected exactly one commit from walk");
043a4492
RR
2928 return single_pick(cmit, opts);
2929 }
2930
2931 /*
2932 * Start a new cherry-pick/ revert sequence; but
2933 * first, make sure that an existing one isn't in
2934 * progress
2935 */
2936
34b0528b
JS
2937 if (walk_revs_populate_todo(&todo_list, opts) ||
2938 create_seq_dir() < 0)
043a4492 2939 return -1;
1e43ed98 2940 if (get_oid("HEAD", &oid) && (opts->action == REPLAY_REVERT))
93b3df6f 2941 return error(_("can't revert as initial commit"));
1e43ed98 2942 if (save_head(oid_to_hex(&oid)))
311fd397 2943 return -1;
88d5a271
JS
2944 if (save_opts(opts))
2945 return -1;
1e41229d 2946 update_abort_safety_file();
004fefa7
JS
2947 res = pick_commits(&todo_list, opts);
2948 todo_list_release(&todo_list);
2949 return res;
043a4492 2950}
5ed75e2a 2951
bab4d109 2952void append_signoff(struct strbuf *msgbuf, int ignore_footer, unsigned flag)
5ed75e2a 2953{
bab4d109 2954 unsigned no_dup_sob = flag & APPEND_SIGNOFF_DEDUP;
5ed75e2a 2955 struct strbuf sob = STRBUF_INIT;
bab4d109 2956 int has_footer;
5ed75e2a
MV
2957
2958 strbuf_addstr(&sob, sign_off_header);
2959 strbuf_addstr(&sob, fmt_name(getenv("GIT_COMMITTER_NAME"),
2960 getenv("GIT_COMMITTER_EMAIL")));
2961 strbuf_addch(&sob, '\n');
bab4d109 2962
44dc738a
JT
2963 if (!ignore_footer)
2964 strbuf_complete_line(msgbuf);
2965
bab4d109
BC
2966 /*
2967 * If the whole message buffer is equal to the sob, pretend that we
2968 * found a conforming footer with a matching sob
2969 */
2970 if (msgbuf->len - ignore_footer == sob.len &&
2971 !strncmp(msgbuf->buf, sob.buf, sob.len))
2972 has_footer = 3;
2973 else
2974 has_footer = has_conforming_footer(msgbuf, &sob, ignore_footer);
2975
33f2f9ab
BC
2976 if (!has_footer) {
2977 const char *append_newlines = NULL;
2978 size_t len = msgbuf->len - ignore_footer;
2979
8c613fd5
BC
2980 if (!len) {
2981 /*
2982 * The buffer is completely empty. Leave foom for
2983 * the title and body to be filled in by the user.
2984 */
33f2f9ab 2985 append_newlines = "\n\n";
8c613fd5
BC
2986 } else if (len == 1) {
2987 /*
2988 * Buffer contains a single newline. Add another
2989 * so that we leave room for the title and body.
2990 */
2991 append_newlines = "\n";
2992 } else if (msgbuf->buf[len - 2] != '\n') {
2993 /*
2994 * Buffer ends with a single newline. Add another
2995 * so that there is an empty line between the message
2996 * body and the sob.
2997 */
33f2f9ab 2998 append_newlines = "\n";
8c613fd5 2999 } /* else, the buffer already ends with two newlines. */
33f2f9ab
BC
3000
3001 if (append_newlines)
3002 strbuf_splice(msgbuf, msgbuf->len - ignore_footer, 0,
3003 append_newlines, strlen(append_newlines));
5ed75e2a 3004 }
bab4d109
BC
3005
3006 if (has_footer != 3 && (!no_dup_sob || has_footer != 2))
3007 strbuf_splice(msgbuf, msgbuf->len - ignore_footer, 0,
3008 sob.buf, sob.len);
3009
5ed75e2a
MV
3010 strbuf_release(&sob);
3011}
62db5247 3012
313a48ea
LB
3013int sequencer_make_script(FILE *out, int argc, const char **argv,
3014 unsigned flags)
62db5247
JS
3015{
3016 char *format = NULL;
3017 struct pretty_print_context pp = {0};
3018 struct strbuf buf = STRBUF_INIT;
3019 struct rev_info revs;
3020 struct commit *commit;
313a48ea 3021 int keep_empty = flags & TODO_LIST_KEEP_EMPTY;
d8ae6c84 3022 const char *insn = flags & TODO_LIST_ABBREVIATE_CMDS ? "p" : "pick";
62db5247
JS
3023
3024 init_revisions(&revs, NULL);
3025 revs.verbose_header = 1;
3026 revs.max_parents = 1;
76ea2358 3027 revs.cherry_mark = 1;
62db5247
JS
3028 revs.limited = 1;
3029 revs.reverse = 1;
3030 revs.right_only = 1;
3031 revs.sort_order = REV_SORT_IN_GRAPH_ORDER;
3032 revs.topo_order = 1;
3033
3034 revs.pretty_given = 1;
3035 git_config_get_string("rebase.instructionFormat", &format);
3036 if (!format || !*format) {
3037 free(format);
3038 format = xstrdup("%s");
3039 }
3040 get_commit_format(format, &revs);
3041 free(format);
3042 pp.fmt = revs.commit_format;
3043 pp.output_encoding = get_log_output_encoding();
3044
3045 if (setup_revisions(argc, argv, &revs, NULL) > 1)
3046 return error(_("make_script: unhandled options"));
3047
3048 if (prepare_revision_walk(&revs) < 0)
3049 return error(_("make_script: error preparing revisions"));
3050
3051 while ((commit = get_revision(&revs))) {
76ea2358
PW
3052 int is_empty = is_original_commit_empty(commit);
3053
3054 if (!is_empty && (commit->object.flags & PATCHSAME))
3055 continue;
62db5247 3056 strbuf_reset(&buf);
76ea2358 3057 if (!keep_empty && is_empty)
62db5247 3058 strbuf_addf(&buf, "%c ", comment_line_char);
d8ae6c84
LB
3059 strbuf_addf(&buf, "%s %s ", insn,
3060 oid_to_hex(&commit->object.oid));
62db5247
JS
3061 pretty_print_commit(&pp, commit, &buf);
3062 strbuf_addch(&buf, '\n');
3063 fputs(buf.buf, out);
3064 }
3065 strbuf_release(&buf);
3066 return 0;
3067}
3546c8d9 3068
0cce4a27
LB
3069/*
3070 * Add commands after pick and (series of) squash/fixup commands
3071 * in the todo list.
3072 */
3073int sequencer_add_exec_commands(const char *commands)
3546c8d9
JS
3074{
3075 const char *todo_file = rebase_path_todo();
3076 struct todo_list todo_list = TODO_LIST_INIT;
0cce4a27
LB
3077 struct todo_item *item;
3078 struct strbuf *buf = &todo_list.buf;
3079 size_t offset = 0, commands_len = strlen(commands);
3080 int i, first;
3546c8d9 3081
0cce4a27 3082 if (strbuf_read_file(&todo_list.buf, todo_file, 0) < 0)
3546c8d9 3083 return error(_("could not read '%s'."), todo_file);
3546c8d9 3084
0cce4a27 3085 if (parse_insn_buffer(todo_list.buf.buf, &todo_list)) {
3546c8d9
JS
3086 todo_list_release(&todo_list);
3087 return error(_("unusable todo list: '%s'"), todo_file);
3088 }
3089
0cce4a27
LB
3090 first = 1;
3091 /* insert <commands> before every pick except the first one */
3092 for (item = todo_list.items, i = 0; i < todo_list.nr; i++, item++) {
3093 if (item->command == TODO_PICK && !first) {
3094 strbuf_insert(buf, item->offset_in_buf + offset,
3095 commands, commands_len);
3096 offset += commands_len;
3097 }
3098 first = 0;
3099 }
3100
3101 /* append final <commands> */
3102 strbuf_add(buf, commands, commands_len);
3103
3104 i = write_message(buf->buf, buf->len, todo_file, 0);
3105 todo_list_release(&todo_list);
3106 return i;
3107}
3546c8d9 3108
313a48ea 3109int transform_todos(unsigned flags)
3546c8d9
JS
3110{
3111 const char *todo_file = rebase_path_todo();
3112 struct todo_list todo_list = TODO_LIST_INIT;
8dccc7a6
LB
3113 struct strbuf buf = STRBUF_INIT;
3114 struct todo_item *item;
3115 int i;
3546c8d9 3116
8dccc7a6 3117 if (strbuf_read_file(&todo_list.buf, todo_file, 0) < 0)
3546c8d9 3118 return error(_("could not read '%s'."), todo_file);
3546c8d9 3119
8dccc7a6 3120 if (parse_insn_buffer(todo_list.buf.buf, &todo_list)) {
3546c8d9 3121 todo_list_release(&todo_list);
3546c8d9
JS
3122 return error(_("unusable todo list: '%s'"), todo_file);
3123 }
3124
8dccc7a6
LB
3125 for (item = todo_list.items, i = 0; i < todo_list.nr; i++, item++) {
3126 /* if the item is not a command write it and continue */
3127 if (item->command >= TODO_COMMENT) {
3128 strbuf_addf(&buf, "%.*s\n", item->arg_len, item->arg);
3129 continue;
3546c8d9 3130 }
8dccc7a6
LB
3131
3132 /* add command to the buffer */
d8ae6c84
LB
3133 if (flags & TODO_LIST_ABBREVIATE_CMDS)
3134 strbuf_addch(&buf, command_to_char(item->command));
3135 else
3136 strbuf_addstr(&buf, command_to_string(item->command));
8dccc7a6
LB
3137
3138 /* add commit id */
3139 if (item->commit) {
313a48ea 3140 const char *oid = flags & TODO_LIST_SHORTEN_IDS ?
8dccc7a6
LB
3141 short_commit_name(item->commit) :
3142 oid_to_hex(&item->commit->object.oid);
3143
3144 strbuf_addf(&buf, " %s", oid);
3546c8d9 3145 }
8dccc7a6 3146 /* add all the rest */
c7b4d79c
JS
3147 if (!item->arg_len)
3148 strbuf_addch(&buf, '\n');
3149 else
3150 strbuf_addf(&buf, " %.*s\n", item->arg_len, item->arg);
3546c8d9 3151 }
8dccc7a6
LB
3152
3153 i = write_message(buf.buf, buf.len, todo_file, 0);
3546c8d9 3154 todo_list_release(&todo_list);
8dccc7a6 3155 return i;
3546c8d9 3156}
94399949
JS
3157
3158enum check_level {
3159 CHECK_IGNORE = 0, CHECK_WARN, CHECK_ERROR
3160};
3161
3162static enum check_level get_missing_commit_check_level(void)
3163{
3164 const char *value;
3165
3166 if (git_config_get_value("rebase.missingcommitscheck", &value) ||
3167 !strcasecmp("ignore", value))
3168 return CHECK_IGNORE;
3169 if (!strcasecmp("warn", value))
3170 return CHECK_WARN;
3171 if (!strcasecmp("error", value))
3172 return CHECK_ERROR;
dfab1eac 3173 warning(_("unrecognized setting %s for option "
94399949
JS
3174 "rebase.missingCommitsCheck. Ignoring."), value);
3175 return CHECK_IGNORE;
3176}
3177
3178/*
3179 * Check if the user dropped some commits by mistake
3180 * Behaviour determined by rebase.missingCommitsCheck.
3181 * Check if there is an unrecognized command or a
3182 * bad SHA-1 in a command.
3183 */
3184int check_todo_list(void)
3185{
3186 enum check_level check_level = get_missing_commit_check_level();
3187 struct strbuf todo_file = STRBUF_INIT;
3188 struct todo_list todo_list = TODO_LIST_INIT;
3189 struct strbuf missing = STRBUF_INIT;
87805600 3190 int advise_to_edit_todo = 0, res = 0, i;
94399949
JS
3191
3192 strbuf_addstr(&todo_file, rebase_path_todo());
87805600
RS
3193 if (strbuf_read_file_or_whine(&todo_list.buf, todo_file.buf) < 0) {
3194 res = -1;
94399949
JS
3195 goto leave_check;
3196 }
94399949
JS
3197 advise_to_edit_todo = res =
3198 parse_insn_buffer(todo_list.buf.buf, &todo_list);
3199
3200 if (res || check_level == CHECK_IGNORE)
3201 goto leave_check;
3202
3203 /* Mark the commits in git-rebase-todo as seen */
3204 for (i = 0; i < todo_list.nr; i++) {
3205 struct commit *commit = todo_list.items[i].commit;
3206 if (commit)
3207 commit->util = (void *)1;
3208 }
3209
3210 todo_list_release(&todo_list);
3211 strbuf_addstr(&todo_file, ".backup");
87805600
RS
3212 if (strbuf_read_file_or_whine(&todo_list.buf, todo_file.buf) < 0) {
3213 res = -1;
94399949
JS
3214 goto leave_check;
3215 }
94399949
JS
3216 strbuf_release(&todo_file);
3217 res = !!parse_insn_buffer(todo_list.buf.buf, &todo_list);
3218
3219 /* Find commits in git-rebase-todo.backup yet unseen */
3220 for (i = todo_list.nr - 1; i >= 0; i--) {
3221 struct todo_item *item = todo_list.items + i;
3222 struct commit *commit = item->commit;
3223 if (commit && !commit->util) {
3224 strbuf_addf(&missing, " - %s %.*s\n",
3225 short_commit_name(commit),
3226 item->arg_len, item->arg);
3227 commit->util = (void *)1;
3228 }
3229 }
3230
3231 /* Warn about missing commits */
3232 if (!missing.len)
3233 goto leave_check;
3234
3235 if (check_level == CHECK_ERROR)
3236 advise_to_edit_todo = res = 1;
3237
3238 fprintf(stderr,
3239 _("Warning: some commits may have been dropped accidentally.\n"
3240 "Dropped commits (newer to older):\n"));
3241
3242 /* Make the list user-friendly and display */
3243 fputs(missing.buf, stderr);
3244 strbuf_release(&missing);
3245
3246 fprintf(stderr, _("To avoid this message, use \"drop\" to "
3247 "explicitly remove a commit.\n\n"
3248 "Use 'git config rebase.missingCommitsCheck' to change "
3249 "the level of warnings.\n"
3250 "The possible behaviours are: ignore, warn, error.\n\n"));
3251
3252leave_check:
3253 strbuf_release(&todo_file);
3254 todo_list_release(&todo_list);
3255
3256 if (advise_to_edit_todo)
3257 fprintf(stderr,
3258 _("You can fix this with 'git rebase --edit-todo' "
3259 "and then run 'git rebase --continue'.\n"
3260 "Or you can abort the rebase with 'git rebase"
3261 " --abort'.\n"));
3262
3263 return res;
3264}
cdac2b01 3265
73646bfd
RS
3266static int rewrite_file(const char *path, const char *buf, size_t len)
3267{
3268 int rc = 0;
c8cee96e 3269 int fd = open(path, O_WRONLY | O_TRUNC);
73646bfd
RS
3270 if (fd < 0)
3271 return error_errno(_("could not open '%s' for writing"), path);
3272 if (write_in_full(fd, buf, len) < 0)
3273 rc = error_errno(_("could not write to '%s'"), path);
9360ec00
SR
3274 if (close(fd) && !rc)
3275 rc = error_errno(_("could not close '%s'"), path);
73646bfd
RS
3276 return rc;
3277}
3278
cdac2b01
JS
3279/* skip picking commits whose parents are unchanged */
3280int skip_unnecessary_picks(void)
3281{
3282 const char *todo_file = rebase_path_todo();
3283 struct strbuf buf = STRBUF_INIT;
3284 struct todo_list todo_list = TODO_LIST_INIT;
3285 struct object_id onto_oid, *oid = &onto_oid, *parent_oid;
3286 int fd, i;
3287
3288 if (!read_oneliner(&buf, rebase_path_onto(), 0))
3289 return error(_("could not read 'onto'"));
3290 if (get_oid(buf.buf, &onto_oid)) {
3291 strbuf_release(&buf);
3292 return error(_("need a HEAD to fixup"));
3293 }
3294 strbuf_release(&buf);
3295
87805600
RS
3296 if (strbuf_read_file_or_whine(&todo_list.buf, todo_file) < 0)
3297 return -1;
cdac2b01
JS
3298 if (parse_insn_buffer(todo_list.buf.buf, &todo_list) < 0) {
3299 todo_list_release(&todo_list);
3300 return -1;
3301 }
3302
3303 for (i = 0; i < todo_list.nr; i++) {
3304 struct todo_item *item = todo_list.items + i;
3305
3306 if (item->command >= TODO_NOOP)
3307 continue;
3308 if (item->command != TODO_PICK)
3309 break;
3310 if (parse_commit(item->commit)) {
3311 todo_list_release(&todo_list);
3312 return error(_("could not parse commit '%s'"),
3313 oid_to_hex(&item->commit->object.oid));
3314 }
3315 if (!item->commit->parents)
3316 break; /* root commit */
3317 if (item->commit->parents->next)
3318 break; /* merge commit */
3319 parent_oid = &item->commit->parents->item->object.oid;
3320 if (hashcmp(parent_oid->hash, oid->hash))
3321 break;
3322 oid = &item->commit->object.oid;
3323 }
3324 if (i > 0) {
a01c2a5f 3325 int offset = get_item_line_offset(&todo_list, i);
cdac2b01
JS
3326 const char *done_path = rebase_path_done();
3327
3328 fd = open(done_path, O_CREAT | O_WRONLY | O_APPEND, 0666);
3329 if (fd < 0) {
3330 error_errno(_("could not open '%s' for writing"),
3331 done_path);
3332 todo_list_release(&todo_list);
3333 return -1;
3334 }
3335 if (write_in_full(fd, todo_list.buf.buf, offset) < 0) {
3336 error_errno(_("could not write to '%s'"), done_path);
3337 todo_list_release(&todo_list);
3338 close(fd);
3339 return -1;
3340 }
3341 close(fd);
3342
73646bfd
RS
3343 if (rewrite_file(rebase_path_todo(), todo_list.buf.buf + offset,
3344 todo_list.buf.len - offset) < 0) {
cdac2b01 3345 todo_list_release(&todo_list);
cdac2b01
JS
3346 return -1;
3347 }
cdac2b01
JS
3348
3349 todo_list.current = i;
3350 if (is_fixup(peek_command(&todo_list, 0)))
3351 record_in_rewritten(oid, peek_command(&todo_list, 0));
3352 }
3353
3354 todo_list_release(&todo_list);
3355 printf("%s\n", oid_to_hex(oid));
3356
3357 return 0;
3358}
c44a4c65
JS
3359
3360struct subject2item_entry {
3361 struct hashmap_entry entry;
3362 int i;
3363 char subject[FLEX_ARRAY];
3364};
3365
3366static int subject2item_cmp(const void *fndata,
3367 const struct subject2item_entry *a,
3368 const struct subject2item_entry *b, const void *key)
3369{
3370 return key ? strcmp(a->subject, key) : strcmp(a->subject, b->subject);
3371}
3372
3373/*
3374 * Rearrange the todo list that has both "pick commit-id msg" and "pick
3375 * commit-id fixup!/squash! msg" in it so that the latter is put immediately
3376 * after the former, and change "pick" to "fixup"/"squash".
3377 *
3378 * Note that if the config has specified a custom instruction format, each log
3379 * message will have to be retrieved from the commit (as the oneline in the
3380 * script cannot be trusted) in order to normalize the autosquash arrangement.
3381 */
3382int rearrange_squash(void)
3383{
3384 const char *todo_file = rebase_path_todo();
3385 struct todo_list todo_list = TODO_LIST_INIT;
3386 struct hashmap subject2item;
87805600 3387 int res = 0, rearranged = 0, *next, *tail, i;
c44a4c65
JS
3388 char **subjects;
3389
87805600
RS
3390 if (strbuf_read_file_or_whine(&todo_list.buf, todo_file) < 0)
3391 return -1;
c44a4c65
JS
3392 if (parse_insn_buffer(todo_list.buf.buf, &todo_list) < 0) {
3393 todo_list_release(&todo_list);
3394 return -1;
3395 }
3396
3397 /*
3398 * The hashmap maps onelines to the respective todo list index.
3399 *
3400 * If any items need to be rearranged, the next[i] value will indicate
3401 * which item was moved directly after the i'th.
3402 *
3403 * In that case, last[i] will indicate the index of the latest item to
3404 * be moved to appear after the i'th.
3405 */
3406 hashmap_init(&subject2item, (hashmap_cmp_fn) subject2item_cmp,
3407 NULL, todo_list.nr);
3408 ALLOC_ARRAY(next, todo_list.nr);
3409 ALLOC_ARRAY(tail, todo_list.nr);
3410 ALLOC_ARRAY(subjects, todo_list.nr);
3411 for (i = 0; i < todo_list.nr; i++) {
3412 struct strbuf buf = STRBUF_INIT;
3413 struct todo_item *item = todo_list.items + i;
3414 const char *commit_buffer, *subject, *p;
3415 size_t subject_len;
3416 int i2 = -1;
3417 struct subject2item_entry *entry;
3418
3419 next[i] = tail[i] = -1;
2f6b1d13 3420 if (!item->commit || item->command == TODO_DROP) {
c44a4c65
JS
3421 subjects[i] = NULL;
3422 continue;
3423 }
3424
3425 if (is_fixup(item->command)) {
3426 todo_list_release(&todo_list);
3427 return error(_("the script was already rearranged."));
3428 }
3429
3430 item->commit->util = item;
3431
3432 parse_commit(item->commit);
3433 commit_buffer = get_commit_buffer(item->commit, NULL);
3434 find_commit_subject(commit_buffer, &subject);
3435 format_subject(&buf, subject, " ");
3436 subject = subjects[i] = strbuf_detach(&buf, &subject_len);
3437 unuse_commit_buffer(item->commit, commit_buffer);
3438 if ((skip_prefix(subject, "fixup! ", &p) ||
3439 skip_prefix(subject, "squash! ", &p))) {
3440 struct commit *commit2;
3441
3442 for (;;) {
3443 while (isspace(*p))
3444 p++;
3445 if (!skip_prefix(p, "fixup! ", &p) &&
3446 !skip_prefix(p, "squash! ", &p))
3447 break;
3448 }
3449
3450 if ((entry = hashmap_get_from_hash(&subject2item,
3451 strhash(p), p)))
3452 /* found by title */
3453 i2 = entry->i;
3454 else if (!strchr(p, ' ') &&
3455 (commit2 =
3456 lookup_commit_reference_by_name(p)) &&
3457 commit2->util)
3458 /* found by commit name */
3459 i2 = (struct todo_item *)commit2->util
3460 - todo_list.items;
3461 else {
3462 /* copy can be a prefix of the commit subject */
3463 for (i2 = 0; i2 < i; i2++)
3464 if (subjects[i2] &&
3465 starts_with(subjects[i2], p))
3466 break;
3467 if (i2 == i)
3468 i2 = -1;
3469 }
3470 }
3471 if (i2 >= 0) {
3472 rearranged = 1;
3473 todo_list.items[i].command =
3474 starts_with(subject, "fixup!") ?
3475 TODO_FIXUP : TODO_SQUASH;
3476 if (next[i2] < 0)
3477 next[i2] = i;
3478 else
3479 next[tail[i2]] = i;
3480 tail[i2] = i;
3481 } else if (!hashmap_get_from_hash(&subject2item,
3482 strhash(subject), subject)) {
3483 FLEX_ALLOC_MEM(entry, subject, subject, subject_len);
3484 entry->i = i;
3485 hashmap_entry_init(entry, strhash(entry->subject));
3486 hashmap_put(&subject2item, entry);
3487 }
3488 }
3489
3490 if (rearranged) {
3491 struct strbuf buf = STRBUF_INIT;
3492
3493 for (i = 0; i < todo_list.nr; i++) {
3494 enum todo_command command = todo_list.items[i].command;
3495 int cur = i;
3496
3497 /*
3498 * Initially, all commands are 'pick's. If it is a
3499 * fixup or a squash now, we have rearranged it.
3500 */
3501 if (is_fixup(command))
3502 continue;
3503
3504 while (cur >= 0) {
a01c2a5f
JS
3505 const char *bol =
3506 get_item_line(&todo_list, cur);
3507 const char *eol =
3508 get_item_line(&todo_list, cur + 1);
c44a4c65
JS
3509
3510 /* replace 'pick', by 'fixup' or 'squash' */
3511 command = todo_list.items[cur].command;
3512 if (is_fixup(command)) {
3513 strbuf_addstr(&buf,
3514 todo_command_info[command].str);
3515 bol += strcspn(bol, " \t");
3516 }
3517
3518 strbuf_add(&buf, bol, eol - bol);
3519
3520 cur = next[cur];
3521 }
3522 }
3523
73646bfd 3524 res = rewrite_file(todo_file, buf.buf, buf.len);
c44a4c65
JS
3525 strbuf_release(&buf);
3526 }
3527
3528 free(next);
3529 free(tail);
3530 for (i = 0; i < todo_list.nr; i++)
3531 free(subjects[i]);
3532 free(subjects);
3533 hashmap_free(&subject2item, 1);
3534 todo_list_release(&todo_list);
3535
3536 return res;
3537}